> ## Documentation Index
> Fetch the complete documentation index at: https://docs.radion.app/llms.txt
> Use this file to discover all available pages before exploring further.

# resolution

> Settlement outcomes from the Polymarket module and CTF contracts — condition resolutions, reported results, and resolution pauses.

The `resolution` channel sends every settlement event: when a condition resolves, a result is reported, or resolution is paused. They come from the CTF base layer, the NegRisk adapter, and the BinaryModule and NegRiskModule contracts. We decode each one and send it after the transaction is confirmed on-chain.

<Note>
  These events used to be split across the old `lifecycle` and `combos`
  channels. They now stream here as one settlement feed. Market **setup** events
  (not settlement) stay on [`lifecycle`](/websockets/channels/lifecycle).
</Note>

## Subscribe

```json theme={null}
{
  "action": "subscribe",
  "id": "s1",
  "channel": "resolution"
}
```

With no filters, you get every confirmed resolution event from all markets.

## Filters

| Filter       | Type       | Required | Description                                                             |
| ------------ | ---------- | -------- | ----------------------------------------------------------------------- |
| `market_ids` | `string[]` | No       | Condition IDs as `bytes32` hex strings. Keeps events for those markets. |

This channel accepts only `market_ids`. `wallets`, `token_ids`, and `min_usd` are ignored here. See [Filters](/websockets/filters) for the combination rule.

## Events

This channel sends all eight settlement events. See [Onchain Data](/concepts/onchain-data) for the part each event plays in the resolution lifecycle.

| Event                 | `data.type`            | Description                                                                                             |
| --------------------- | ---------------------- | ------------------------------------------------------------------------------------------------------- |
| `ConditionResolution` | `condition_resolution` | The final payout numerators saved for a CTF condition. Sets how a resolved condition splits collateral. |
| `ConditionResolved`   | `condition_resolved`   | A condition resolved inside the module system. Carries the condition id and result numerators.          |
| `OutcomeReported`     | `outcome_reported`     | A reported neg-risk outcome. Gives resolution context for a question in a neg-risk market.              |
| `ResultReported`      | `result_reported`      | A result reported to a module. Carries the resolver address, condition id, and result numerators.       |
| `ResolutionPaused`    | `resolution_paused`    | Resolution paused for a module id. Means market resolution is blocked for now.                          |
| `ResolutionUnpaused`  | `resolution_unpaused`  | Resolution unpaused for a module id. Means market resolution can run again.                             |
| `ResolverPaused`      | `resolver_paused`      | A resolver paused at the module level. Carries the resolver address and timestamp.                      |
| `ResolverUnpaused`    | `resolver_unpaused`    | A resolver unpaused at the module level. Carries the resolver address.                                  |

## Payloads

Every frame wraps the event in the standard envelope (`type`, `id`, `channel`, `confirmed`, `data`) shown on [Frames](/websockets/frames). Below, each block is the `data` object for one event — its `type` discriminator plus every field the ABI decodes. A full frame looks like:

```json theme={null}
{
  "type": "event",
  "id": "s1",
  "channel": "resolution",
  "confirmed": true,
  "data": {
    "type": "condition_resolution",
    "conditionId": "0x…",
    "oracle": "0x…",
    "…": "…"
  }
}
```

<Note>
  `conditionId` is `bytes32` on the CTF base-layer events
  (`condition_resolution`) but the compact `bytes31` module id on the module
  events (`condition_resolved`, `result_reported`). Both serialize as `0x…` hex;
  the byte length differs.
</Note>

### `condition_resolution`

`ConditionResolution` on ConditionalTokens. The final payout numerators saved for a resolved CTF condition.

```json theme={null}
{
  "type": "condition_resolution",
  "conditionId": "0x…",
  "oracle": "0x…",
  "questionId": "0x…",
  "outcomeSlotCount": "0x2",
  "payoutNumerators": ["0x1", "0x0"]
}
```

| Field              | Solidity type     | Description                                                    |
| ------------------ | ----------------- | -------------------------------------------------------------- |
| `type`             | string            | `condition_resolution`.                                        |
| `conditionId`      | `bytes32` (hex)   | Condition being resolved.                                      |
| `oracle`           | `address` (hex)   | Oracle that reported the outcome.                              |
| `questionId`       | `bytes32` (hex)   | Question id linked to this condition.                          |
| `outcomeSlotCount` | `uint256` (hex)   | Number of outcome slots for this condition.                    |
| `payoutNumerators` | `uint256[]` (hex) | Payout numerator per outcome slot. Sets how collateral splits. |

### `condition_resolved`

`ConditionResolved` on the BinaryModule / NegRiskModule. A condition resolved inside the module system.

```json theme={null}
{
  "type": "condition_resolved",
  "conditionId": "0x…",
  "result": ["0x1", "0x0"]
}
```

| Field         | Solidity type     | Description                        |
| ------------- | ----------------- | ---------------------------------- |
| `type`        | string            | `condition_resolved`.              |
| `conditionId` | `bytes31` (hex)   | Module condition id that resolved. |
| `result`      | `uint256[]` (hex) | Result numerator per outcome slot. |

### `outcome_reported`

`OutcomeReported` on the NegRiskAdapter. A single neg-risk question's outcome reported.

```json theme={null}
{
  "type": "outcome_reported",
  "marketId": "0x…",
  "questionId": "0x…",
  "outcome": true
}
```

| Field        | Solidity type   | Description                                    |
| ------------ | --------------- | ---------------------------------------------- |
| `type`       | string          | `outcome_reported`.                            |
| `marketId`   | `bytes32` (hex) | Neg-risk market the question belongs to.       |
| `questionId` | `bytes32` (hex) | Question that was reported.                    |
| `outcome`    | `bool`          | Reported outcome (`true` = yes, `false` = no). |

### `result_reported`

`ResultReported` on a module. A resolver pushed a result into a module condition.

```json theme={null}
{
  "type": "result_reported",
  "resolver": "0x…",
  "conditionId": "0x…",
  "result": ["0x1", "0x0"]
}
```

| Field         | Solidity type     | Description                        |
| ------------- | ----------------- | ---------------------------------- |
| `type`        | string            | `result_reported`.                 |
| `resolver`    | `address` (hex)   | Resolver that reported the result. |
| `conditionId` | `bytes31` (hex)   | Module condition id.               |
| `result`      | `uint256[]` (hex) | Result numerator per outcome slot. |

### `resolution_paused`

`ResolutionPaused` on a module. Resolution blocked for a module id, with the pause timestamp.

```json theme={null}
{
  "type": "resolution_paused",
  "id": "0x…",
  "timestamp": "0x…"
}
```

| Field       | Solidity type   | Description                                |
| ----------- | --------------- | ------------------------------------------ |
| `type`      | string          | `resolution_paused`.                       |
| `id`        | `bytes31` (hex) | Module id whose resolution was paused.     |
| `timestamp` | `uint256` (hex) | Unix time (seconds) the pause took effect. |

### `resolution_unpaused`

`ResolutionUnpaused` on a module. Resolution allowed again for a module id.

```json theme={null}
{
  "type": "resolution_unpaused",
  "id": "0x…"
}
```

| Field  | Solidity type   | Description                         |
| ------ | --------------- | ----------------------------------- |
| `type` | string          | `resolution_unpaused`.              |
| `id`   | `bytes31` (hex) | Module id whose resolution resumed. |

### `resolver_paused`

`ResolverPaused` on a module. A resolver paused at the module level, with the pause timestamp.

```json theme={null}
{
  "type": "resolver_paused",
  "resolver": "0x…",
  "timestamp": "0x…"
}
```

| Field       | Solidity type   | Description                                |
| ----------- | --------------- | ------------------------------------------ |
| `type`      | string          | `resolver_paused`.                         |
| `resolver`  | `address` (hex) | Resolver that was paused.                  |
| `timestamp` | `uint256` (hex) | Unix time (seconds) the pause took effect. |

### `resolver_unpaused`

`ResolverUnpaused` on a module. A resolver resumed at the module level.

```json theme={null}
{
  "type": "resolver_unpaused",
  "resolver": "0x…"
}
```

| Field      | Solidity type   | Description            |
| ---------- | --------------- | ---------------------- |
| `type`     | string          | `resolver_unpaused`.   |
| `resolver` | `address` (hex) | Resolver that resumed. |

## Pending feed

Set `confirmed: false` on your subscribe to get the pending feed of this channel — the same payload shape for pending transactions sent to the CTF, NegRisk adapter, and module contracts, before they are in a block. Pending events are guesses. A transaction can be dropped, replaced, or reverted. See [Mempool](/websockets/mempool) for the full frame shape and how to handle it.

```json theme={null}
{
  "action": "subscribe",
  "id": "pending",
  "channel": "resolution",
  "confirmed": false
}
```