The Solver flow

The Solver flow end to end — what you check before you start, what the client does for you, and what you own afterwards.

You are a Solver if you are doing the work. You own your artifacts and the wallet that submits them. Your submission is encrypted before it leaves your machine, and it stays encrypted until the deadline passes — not by policy, but because the keys are time-locked.

You encrypt it for the bounty's Guardian roster: the committee of independent Guardians — several, never one — that the bounty pinned on-chain when it was created. Your client resolves that committee, checks it against the contract's own record, and encrypts to exactly those members. Two thirds of them must agree before any result settles, and you can query who they are and what each of them decided. See The Guardian roster.

One active Submission per Solver, per bounty

Submitting again before the deadline replaces your previous Submission. It does not create a second entry, and the replaced one stops being eligible.

What you need

You need	Why
An EVM wallet you control	It owns your Submission slot and is the only address that can claim the award
A little native gas on that chain	One transaction records your Submission commitment
Node.js 24 and `@elgora/cli`	The client encrypts your artifacts and prepares the exact transaction
A sandbox for untrusted inputs	Challenges may reference outside files; open them in isolation, never on your key-holding host

You do not need USDC to submit, and you do not stake anything. No account, no signup, no API key — your wallet is your identity.

Do the math before you build

Only one Submission wins. Weigh the time and compute a serious attempt will cost you against the prize before you start.

The whole flow

Verify what you are solving

Fetch the bounty, verify the challenge bytes against the on-chain spec_commitment, and check the status and deadline yourself. Treat every outside file the challenge references as untrusted.

→ Verify the challenge

Build the package

One flat directory of regular files, exactly what the challenge asks for, at most 500 files, sealing to under 50 MiB and extracting to under 250 MB. Every required deliverable is submitted as bytes; a link never stands in for one.

→ Build the package

Submit

One command encrypts for the bounty's pinned Guardian roster, time-locks the keys to the deadline, uploads only ciphertext, and records a commitment on-chain from your wallet.

→ Submitting, step by step

Wait, then claim if you win

Guardians judge after the deadline. If the contract finalizes awarded with your address, you pull the reward yourself.

→ After you submit

The one command

elgora-cli help solver:submit

# recommended: your key never enters the CLI process
elgora-cli solver:submit --solver-address 0xYourWallet <bounty_id> ./artifacts

# local signing, for controlled testing
ELGORA_SOLVER_PRIVATE_KEY=… elgora-cli solver:submit <bounty_id> ./artifacts

With --solver-address, the CLI prints each request for your wallet to sign and prints the final transaction for your wallet to send. Nothing secret enters the process.

What you are trusting, and what you are not

You trust	Because
The contract's record of the bounty	Status, deadline, and pinned roster hash are read directly from `ElgoraHub` immediately before you sign
Your own client	It re-derives every commitment locally and refuses to sign anything it did not compute itself

You do not have to trust	Why not
Elgora's API	It cannot produce a commitment or a transaction your client will accept if it disagrees with the bytes you sent
Elgora's storage	Ciphertext is verified against a hash inside your own envelope
The listed Guardian roster	It is only accepted after it re-hashes to the value the contract pinned
Any other Solver	Nobody, including the Poster and Elgora, can read your Submission before the deadline

What it costs you

Gas for one transaction. No stake, no deposit, no fee, no USDC. If you lose, you lose the time you spent — nothing else, and your work is never published.

On this page