<!-- canonical: https://docs.melee.markets/resolver-api/api/actions | markdown: https://docs.melee.markets/resolver-api/api/actions.md | index: https://docs.melee.markets/llms.txt -->
# Resolution actions

## Transaction envelope

Every action returns an unsigned-by-you transaction wrapped like this:

```json
{
  "transactionId": "5c0e…",
  "transaction": "<base64 VersionedTransaction, version 0>",
  "message": "Resolve market 9xQe… to outcome 1 (Yes)",
  "expiresAt": 1789000025,
  "estimatedLamports": 16400,
  "programId": "…",
  "signers": [
    { "pubkey": "<resolverAuthority>", "role": "resolver", "signed": false },
    { "pubkey": "<payer>", "role": "payer", "signed": false }
  ],
  "payer": "<payer>"
}
```

- `transaction` is a Solana v0 `VersionedTransaction`. Any signatures Melee must provide (for example on the
  registration transaction) are **already present**; sign with your keys without rebuilding the message. See
  [Signing transactions](/resolver-api/reference#signing-transactions).
- `signers[].role` is one of `resolver`, `proposer`, `payer`, `feeRecipient`, `melee`. Entries with
  `signed: true` are Melee's and need nothing from you.
- `expiresAt` is about 25 seconds after issue, inside the recent blockhash's real lifetime. Sign and submit
  promptly; request a new envelope if it passes.
- `estimatedLamports` is what the payer will spend on fees and rent. It includes a priority fee (by default
  1,000 and at most 50,000 micro-lamports per compute unit). At the default it adds about 1,400 lamports to
  a resolve and about 206 to a one-instruction action.

Sign every unsigned signer you control, then submit with
[`POST /transactions/{transactionId}`](/resolver-api/api/transactions).

## Endpoints

| Method & path | Body | Behaviour |
|---|---|---|
| `POST /markets/{market}/propose` | `{ outcome, definitionHash, payer? }` or `{ "void": true, definitionHash, payer? }` | **Disputable resolvers only.** Records a proposal. If a proposal already stands, returns a transaction that clears it and records the new one (see [Changing a standing proposal](/resolver-api/lifecycles#changing-a-standing-proposal)). |
| `POST /markets/{market}/resolve` | `{ outcome, definitionHash, payer? }` | Commits the outcome. Non-disputable: one transaction that proposes and resolves. Disputable: requires a standing proposal with the same outcome; otherwise `409 proposal_required` or `409 proposal_mismatch`. A standing **void** proposal also returns `proposal_mismatch`; use `void`. |
| `POST /markets/{market}/void` | `{ definitionHash, payer? }` | Voids the market. Always composable: with no proposal it proposes and resolves void; with a standing void proposal it resolves it; with a standing outcome proposal it clears, proposes void and resolves (two transactions if your proposer key differs). |
| `POST /markets/{market}/reject` | `{ payer? }` | **Disputable resolvers only.** Clears the standing proposal without resolving; the market continues trading. |
| `POST /markets/{market}/claim-fees` | `{ payer? }` | Fee claim for `feeRecipient` after resolution and settlement. Signer role `feeRecipient`. |
| `PUT /markets/{market}/fee-recipient` | `{ feeRecipient, payer? }` | Changes this market's fee recipient wallet. Signer role `resolver`. |

`outcome` is an [outcome reference](/resolver-api/api#conventions): `{ "outcomeIndex": 1 }`,
`{ "outcomePubkey": "…" }` or `{ "outcomeLabel": "Yes" }`.

Any standing proposal Melee observes on-chain counts, however it was submitted; a proposal you broadcast
yourself is recognized within about a minute of confirmation.

Actions are available from the market's `earliestProposalTs`, which every payload carries (10 minutes after the
market's planned trading start, or later on the current program). Before it, `propose` and `resolve` return
`409 not_yet_open` with `opensAt` (Unix seconds); nothing is issued. On the current program `void` and a void
proposal also wait for `earliestProposalTs`; on a program with an early void lane, `void` is available from
launch. See [Contract versions](/resolver-api/reference#contract-versions).

## The `definitionHash` check

`propose`, `resolve` and `void` require `definitionHash`. It must equal the hash of the market's **current**
definition version; otherwise you receive `409 definition_mismatch` with the current version and hash in the
problem body. This stops you from resolving against rules that changed under you. Fetch
[`GET /markets/{market}/definition`](/resolver-api/api/markets), review the change, and retry.

## Payer

`payer` is any Solana public key you control and defaults to `resolverAuthority`. It funds the transaction
fee and any rent the transaction creates, and must sign alongside your authority key. It is never read for
authorization, so a dedicated gas wallet is fine.

## Example: resolve

```http
POST /api/resolver/v1/markets/9xQe…/resolve
Idempotency-Key: 0f4c7b1e-…
Content-Type: application/json

{ "outcome": { "outcomeLabel": "Yes" }, "definitionHash": "9f2a…" }
```

```json
{
  "transactionId": "5c0e…",
  "transaction": "AQAAAA…",
  "message": "Propose and resolve market 9xQe… to outcome 1 (Yes)",
  "expiresAt": 1789000025,
  "estimatedLamports": 11400,
  "programId": "…",
  "signers": [{ "pubkey": "<resolverAuthority>", "role": "resolver", "signed": false }],
  "payer": "<resolverAuthority>"
}
```

Only one signer is listed because the payer defaults to the resolver key.
