# Conditional market variants

{% hint style="info" %}
Event conditionals define branches by event outcomes, while price conditionals define branches by terminal price bins at a fixed expiry.
{% endhint %}

Conditionals have two variants:

* **Event conditionals**: branches are real-world outcomes (Cut / Hold / Hike, Approve / Reject, Beat / Miss).
* **Price conditionals**: branches are terminal price ranges (bins) at a fixed expiry.

Both variants use the same underlying mechanics:

* **Shared collateral**: One USDC deposit supports all branches simultaneously.
* **Deterministic resolution**: Non-realized branches are canceled, and the realized branch settles to the observed settlement value.
* **Scalar exposure**: Inside a branch, scalar long and short tokens give bounded linear exposure to the settlement price.

If you want the full token lifecycle, start with:

* [Conditional tokens](https://docs.butter.markets/core-concepts/conditional-tokens)
* [Scalar tokens](https://docs.butter.markets/core-concepts/scalar-tokens)

***

## Event conditionals

Event conditionals are the first type of conditional on Butter. They can be considered an extension of event / prediction markets.

### Definition

An event conditional market is defined by:

* an **event** (e.g., FOMC decision, earnings release, election outcome),
* an **asset/datapoint** (e.g., BTCUSD, SPX, CPI, a KPI),
* and one branch per **mutually exclusive event outcome**.

Example branches for a Fed decision:

* **BTCUSD | Cut**
* **BTCUSD | Hold**
* **BTCUSD | Hike**

### What is being priced

Each branch price is the market’s forecast of the asset’s value **if that outcome occurs**.

This differs from other venues:

Prediction markets price probabilities.

Options markets price volatility over time.

Conditionals price each branch of the future as if it happens.

### Settlement

Settlement occurs after the event resolves **or** when the market’s expiry date is reached (whichever happens first).

At settlement:

Positions in unrealized branches are set to zero.

Only positions in the realized branch can be redeemed according to the payout rule.

### Use cases

Event-aware hedging lets you hedge spot exposure only in the outcomes you care about (e.g., hedge BTC downside specifically in the “Hike” branch).

Event-driven dispersion lets you take a view on pre-event and post-event dispersion and magnitude by trading multiple branches without complex derivatives.

Tail risk insurance selectively shorts the asset in low-probability “bad” branches while leaving collateral in other branches, which acts as an event-specific put analogue.

Concentrated tail exposure concentrates exposure in a low-probability “good” branch by trading away conditional USDC in other branches so that only exposure in that target outcome remains, which acts as an event-specific call analogue.

Event-impact isolation trades the asset inside an outcome branch so the event result is held constant. Branch prices are insulated from shifts in event probabilities.

For an intuition-first explanation of trading branch prices, see: [How to trade](https://github.com/butterygg/docs/blob/conditionals/user-guide/how-to-trade/README.md)

***

## Price conditionals

Price conditionals use the same conditional-token and scalar-token machinery, but change what “the outcomes” are.

Instead of outcomes like “Cut / Hold / Hike”, outcomes are **terminal price ranges (bins)** at a fixed expiry.

### Definition

A price conditional market is defined by:

* an **asset/datapoint** (e.g., BTCUSD),
* an **expiry**,
* and a set of **non-overlapping bins** that partition terminal price.

Example bins:

* BTC < $60k.
* $60k–$70k.
* …
* BTC > $130k.

Each bin is a branch. “BTC | $95k–$100k” is the branch where the expiry price lands in $95k–$100k.

### What is being priced

Price conditionals are a way to trade the **terminal distribution** of an asset at expiry, at the resolution defined by your bins.

They do this by giving you two useful building blocks per bin:

1. **Bin membership (digital) exposure**\
   You can hold exposure that only pays out if the terminal price ends in that bin.
2. **Within-bin (scalar) exposure**\
   Inside the realized bin, scalar long/short payoffs vary linearly between the bin endpoints (and clamp outside them).

Together, these let a single market support a wide family of terminal payoff curves without listing a full strike grid.

### Use cases

* **Terminal risk hedging (range and threshold)**\
  Hedge “ends in this range” or “ends above/below this level” directly.
* **One-market option synthesis**\
  Compose calls/puts/spreads/ranges from bin building blocks. Basis risk becomes primarily a function of bin resolution.
* **Trading the distribution itself**\
  Trading the distribution lets you express views like “$95k–$100k is overpriced, $105k–$110k is underpriced” by rotating exposure between bins.
* **Structured overlays at expiry**\
  Build bounded payoff profiles (caps/floors) using bin and scalar components.

Price conditionals are terminal-only. If you need path-dependent payoffs (barriers, Asians), you need additional state variables beyond where the asset ends at expiry.

***

## Event vs price conditionals

Use **event conditionals** when the risk you care about is scenario/event-driven:

* “What is BTC worth if the Fed hikes?”
* “What is SPX worth if Candidate A wins?”

Use **price conditionals** when the risk you care about is terminal-distribution-driven:

* “Where will BTC finish at expiry?”
* “Give me a $90k call-like payoff at expiry.”

### Summary

|                         | Event conditionals                          | Price conditionals                                   |
| ----------------------- | ------------------------------------------- | ---------------------------------------------------- |
| Branches are defined by | event outcomes (Cut/Hold/Hike)              | terminal price bins ($95k–$100k, $100k–$105k, …)     |
| What you trade          | conditional price “as if outcome happens”   | terminal distribution + within-bin exposure          |
| Best for                | event risk, event hedging, impact isolation | strike/range payoffs at expiry, distribution trading |
| Settlement timing       | after event or at expiry                    | at expiry                                            |

***

## Payoff cookbook

This section shows how to recreate common payoff structures using either variant.

The recipes below describe how to express common terminal payoff structures using branch exposure, bin exposure, and scalar long and short tokens.

### Binary contract on an event outcome (YES/NO)

The closest analogue is a prediction market YES share.

Recipe (event conditional): Hold exposure to the outcome branch you want:

* “USDC | Outcome A” pays if outcome A is realized.
* All other outcomes expire worthless.

Use this when you want pure outcome exposure (probability-like), not price exposure.

### Range digital on terminal price

The closest analogue is a range option, or an “in-range” event contract.

Recipe (price conditional): Buy exposure to a single bin \[L, U), or to a union of adjacent bins for a wider range:

* “USDC | $95k–$100k” pays if expiry price lands in $95k–$100k.

To hedge **outside** the range, hold the complement basket (all other bins).

### Digital above a strike (terminal threshold)

The closest analogue is a cash-or-nothing digital call.

Recipe (price conditional): Construct a terminal-threshold claim (terminal price at least a strike price) as the union of all bins whose lower bound is at least the strike price.

* If the strike price is exactly a bin boundary, this is exact.
* If the strike price is not a bin boundary, either accept small approximation error or split or refine the bin at the strike price.

### Scenario forward or scenario future

The closest analogue is a forward conditional on a scenario.

Recipe (event conditional): Go long or short the asset inside a specific outcome branch.

Examples:

* Go long “BTC | Cut” if you want BTC exposure only if Cut happens.
* Go short “BTC | Hike” to hedge BTC downside only if Hike happens.

### Call spread or put spread (bounded payoff)

The closest analogue is a vertical spread.

Recipe (either variant): A scalar long token has a bounded linear payoff between its lower and upper bound and clamps outside those bounds.

A long scalar token has a call-spread-like bounded payoff profile.

A short scalar token has the complementary put-spread-like bounded payoff profile.

This is the simplest way to get “option-like” bounded convexity.

### Vanilla call or put (European, terminal)

The closest analogue is a standard call or put payoff: $0 below a strike price, then linear above it.

Recipe (price conditional): Recreate calls/puts as **piecewise-linear payoffs** using bin membership + within-bin scalars:

Bin membership provides the stepwise offsets between bins above and below a strike price.

Within-bin scalars provide the linear movement inside the realized bin.

Practical guidance:

Align the strike price to a bin boundary for exact replication.

If you need a strike price inside a bin, split or refine the bin at the strike price.

Tail note: To replicate an unbounded call, your bin set must extend far enough into the tail, or you accept a capped call.

### Straddle, strangle, or condor at expiry

The closest analogue is a standard option combination.

Recipe (price conditional): Build these as linear combinations of the call/put recipes above, or directly as “in-range” / “out-of-range” baskets of bins.

### Event-specific far out-of-the-money call or put analogues

The closest analogue is “BTC call if the Fed cuts” or “BTC put if the Fed hikes”.

Recipe (event conditional):

Tail risk insurance (put analogue) shorts the asset in low-probability “bad” outcome branches while keeping collateral in other branches.

Concentrated tail exposure (call analogue) trades away conditional USDC in non-target branches so only exposure in a low-probability “good” branch remains.

These structures are useful when the scenario itself is the hedge, and you want to avoid basis to proxy instruments.
