# The Poster flow

> The Poster flow end to end — what you decide, what Elgora checks, what goes on-chain, and what you can do afterwards.

You are a Poster if you are paying for an answer. You own two things nobody
can take from you: the exact wording of the challenge, and the wallet that
funds it. You do **not** pick the winner — the pinned Guardian roster judges,
and the contract settles.

That roster is a committee, not a person: the several independent Guardians the
protocol had in place when you created the bounty, recorded on-chain against it
so nobody can substitute them later and anyone can check who they were and what
each decided. Two thirds of them have to agree before anything settles. See
[The Guardian roster](/docs/how-it-works/guardian-roster).

## What you need

| You need                                         | Why                                                                                           |
| ------------------------------------------------ | --------------------------------------------------------------------------------------------- |
| An EVM wallet you control                        | It owns the bounty, funds escrow, and later claims a refund or retrieves the winning work     |
| USDC on the deployment's chain                   | The reward is escrowed in USDC (6 decimals) at publication                                    |
| A little native gas on that chain                | One funding transaction with authorization; approval plus creation for the allowance fallback |
| Node.js 24 and `@elgora/cli`, **or** the web app | The CLI publishes and funds from your own machine; the app does the same in a browser         |
| A written challenge                              | One `bounty_challenge.md` file — see [Write the challenge](/docs/poster/challenge)            |

No account, no signup, no API key. Your wallet is your identity.

<Callout title="Submissions are only as good as the bounty">
  Solvers and Guardians follow the rules you set, so the challenge decides the
  outcome before anyone starts. Price it below what solving it yourself would
  cost you, and high enough to draw Solvers.
</Callout>

## The whole flow

<Steps>
  <Step>
    ### Decide and draft

    Write one `bounty_challenge.md`: the task, the deliverables, finite acceptance
    criteria, a deterministic winner and tie-break rule, the reward in USDC base
    units, and an absolute submission deadline.

    → [Write the challenge](/docs/poster/challenge)
  </Step>

  <Step>
    ### Publish

    `poster:publish-fund` sends the exact bytes to Elgora. The API validates the
    frontmatter, runs an automated readiness review, stores the bytes, and returns
    the `spec_commitment` plus prepared transaction arguments. A challenge that is
    not practically judgeable is returned to you with a list of issues, and nothing
    is stored or spent.

    → [The readiness review](/docs/poster/readiness-review)
  </Step>

  <Step>
    ### Fund

    The same command signs a USDC authorization and calls
    `createBountyWithAuthorization` from your wallet,
    carrying `spec_commitment`, the escrow amount, and the deadline. The contract
    assigns a `bounty_id`, pins the current Guardian roster to it, snapshots the
    fee policy, and computes the judging and timeout deadlines.

    → [Publish and fund](/docs/poster/publish-and-fund)
  </Step>

  <Step>
    ### Wait out the window

    Solvers submit until the deadline. Guardians judge after it. You do nothing in
    this phase — there is no Poster action that influences the result, by design.

    → [Lifecycle and deadlines](/docs/how-it-works/lifecycle)
  </Step>

  <Step>
    ### Handle the outcome

    `awarded`, `no_valid_submission`, or `timed_out`. Each has exactly one thing
    for you to do, and an awarded bounty additionally lets you retrieve the winning
    Submission's content.

    → [Outcomes, refunds, and getting the work](/docs/poster/outcomes)
  </Step>
</Steps>

## The one command

```sh
elgora-cli help poster:publish-fund
elgora-cli poster:publish-fund ./bounty_challenge.md
```

It needs `ELGORA_POSTER_PRIVATE_KEY` in the process environment; publishing and
funding are not available in external-wallet mode from the CLI. If you cannot
inject a process-local secret safely, use the web app instead — it does exactly
the same thing with a browser wallet.

<Callout type="warn" title="Read the emitted bounty_id">
  The command prints one JSON line per step. The last one carries the
  `bounty_id`. That number is how everything else — Solvers, Guardians, the
  subgraph, your refund, your delivery — refers to your bounty. Record it, along
  with `spec_commitment` and the transaction hash.
</Callout>

## What this costs you

The reward you set in frontmatter, gas for funding (plus approval when using
the allowance fallback), and a protocol fee
taken out of the escrow at settlement — never charged separately, and capped in
the contract. A `timed_out` bounty refunds the **full** escrow with no fee at
all.

The rate in force is public state on the Hub, and publishing quotes you the
policy that would apply before you sign anything. Your bounty snapshots that
rate at creation, so a later change does not touch it.

## What a Poster can never do

* Change the challenge after publication. Publish a new bounty instead.
* Cancel a funded bounty, or withdraw escrow before an outcome.
* Overrule, appeal, or veto a Verdict.
* Read a Submission before finality. The funding Poster is authorized to fetch
  a Submission's stored envelope, but the artifact keys are time-locked, and
  the content key for the *winning* Submission is released only after the
  contract has finalized `awarded`.