Trader FAQ and First Scenarios

This page collects concrete scenarios and boundary cases that show how range trading behaves in Signals v1. It stays at the trader surface: positions, costs, slippage, fees, settlement, and claims.

The instrument

The traded instrument is a range position defined on the tick grid. A position specifies a half-open interval $[\text{lowerTick}, \text{upperTick})$ and a quantity $x$.

At finality, the market writes a single settlement tick $\tau$. The payout rule is binary over the interval:

$$\text{Payout} = \begin{cases} x, & \tau \in [\text{lowerTick}, \text{upperTick}) \\ 0, & \text{otherwise} \end{cases}$$

Half-open intervals remove boundary ambiguity. If settlement lands exactly on an upper bound, the position is treated as out-of-range for that interval and in-range for the adjacent interval starting at that tick.

Range positions are composable. A broad belief can be represented as a union of wide ranges. A sharper belief can be represented as one or more narrow ranges. The shared curve prices these shapes coherently because every range price is a sum of tick prices from the same curve state.

Execution amounts

Execution is decomposed into two layers:

• base pricing from the curve, and
• a fee overlay applied after base pricing.

For a range buy of quantity $x$ on $R$, base cost is:

$$\text{baseCost}(x; q, R) = C(q + x\mathbf{1}_R) - C(q)$$

This expression has a useful closed form that makes the role of depth explicit. Let $p = p(R;q)$ be the range price mass at the current state and let $\alpha$ be the market depth. Then:

$$\text{baseCost}(x; q, R) = \alpha \ln\!\left(1 - p + p\,\exp(x/\alpha)\right)$$

The dimensionless size $x/\alpha$ controls how quickly the exponential term grows. For small $x/\alpha$, a second-order approximation is:

$$\text{baseCost}(x; q, R) \approx x p + \frac{x^2}{2\alpha}p(1-p)$$

The first term is the "quote times size" term and the second term is the leading slippage term.

Fees are applied on top of the base amount to produce the debited ctUSD amount. For sells, fees reduce proceeds.

Effective execution amounts can be written directly:

$$\text{paid}_6 = \text{baseCost}_6 + \text{fee}_6$$

and

$$\text{received}_6 = \text{baseProceeds}_6 - \text{fee}_6$$

where the subscript 6 denotes ctUSD base units. Internally, base amounts are computed in WAD and then converted at the unit boundary. Costs round up and proceeds round down.

Execution bounds are explicit:

• buys supply maxCost and revert if baseCost + fee > maxCost
• sells supply minProceeds and revert if baseProceeds - fee < minProceeds

These bounds make slippage tolerance part of transaction calldata rather than a UI-only setting.

Two interpretations are useful when setting bounds.

First, bounds control worst-case execution under state movement between submission and inclusion. If the state moves against the trade, the effective amount can worsen until the bound triggers a revert. Second, bounds do not change the pricing rule. They only decide whether the state-defined execution is accepted.

Scenario set

Narrow range

Consider a BTC market with spacing $100$. The range $[60{,}000, 62{,}000)$ spans 20 ticks. Buying that range is a concentrated update to the shared curve: the trade increases weights on a small subset of ticks relative to the rest of the grid.

Two mechanical consequences follow:

• the range price mass increases along the buy path, so marginal cost rises as the position grows
• the executed average price (baseCost divided by quantity) is higher than the starting quote, with the gap determined by depth and size

This is the mechanism meaning of precision: concentration is paid for in slippage on the shared curve.

Wide range

A wide range such as $[55{,}000, 65{,}000)$ spreads the state update across more ticks. Holding size fixed, the update is less concentrated and tends to move range price mass more slowly along the trade path.

This is not a claim that wide ranges are always cheap. Cost still depends on the current state and on depth. The structural point is that width changes how the trade concentrates the update on the grid.

Setting maxCost on a buy

For a buy, the protocol computes an effective ctUSD amount from base cost plus fees. maxCost is the maximum acceptable effective amount.

If maxCost is set equal to the quoted cost without slack, the transaction can revert whenever other trades move the state before inclusion. If maxCost is set with slack, the trade can execute under adverse state movement, and the slack is the maximum tolerated extra cost.

Because slippage is convex in size, slack requirements typically grow with position size. Small trades can often use tight bounds. Large trades either need looser bounds or need to be broken into smaller trades spaced over time.

Adjusting exposure before finality

Positions are dynamic during the trading window. A position can be reduced or closed by executing the opposite direction (selling the same range). The base proceeds depend on the curve state at the time of the adjustment, not on the original entry quote.

Closing is the reverse state update. If the current state is $q$, then selling quantity $x$ on $R$ has fee-free proceeds:

$$\text{baseProceeds}(x; q, R) = C(q) - C(q - x\mathbf{1}_R)$$

Fees are then applied to produce net proceeds in ctUSD.

Splitting entry and timing

At the mechanism layer, fee-free cashflow depends only on the start and end state. A buy split into multiple buys that lands at the same final state has the same fee-free total cashflow as the unsplit buy.

Across time, the state is not fixed. If the market moves between the split trades, the final state differs and the executed amounts differ. Splitting is therefore not a generic discount; it is a way to manage the state dependence of slippage by choosing when to accept state movement.

Trading near the close

Trading is time gated. If a transaction is submitted near the end of the trading window, it can be mined after the window has closed and revert. This is a phase rule, not a special case for large trades.

The practical implication is that a trade has two distinct sources of uncertainty:

• the state can move before inclusion, which affects execution and can trigger bounds, and
• inclusion time can cross a phase boundary, which triggers an unconditional revert regardless of bounds.

Tick spacing and range geometry

Tick spacing sets resolution. A smaller spacing increases the number of ticks in a fixed real-world domain, which makes narrow ranges narrower in tick terms and increases concentration for a fixed real-world width.

Range width and tick spacing therefore interact:

• width measured in ticks determines how concentrated the update is
• width measured in real-world units determines the settlement precision of the claim

This is a structural coupling. It does not depend on UI conventions.

Settlement and claims

Trading is admitted only inside the market's trading window. Settlement is anchored at a settlement timestamp $T_\text{set}$ and proceeds in time-gated stages.

Oracle samples are admissible only inside the submission window. A deterministic closest-to-$T_\text{set}$ rule selects a single candidate, and settlement finalization records a single settlement tick.

Claims are admitted only after two conditions hold:

• settlement has been finalized on-chain, and
• $t \ge T_\text{set} + \Delta_\text{claim}$

Claims burn the position token and transfer ctUSD from the payout reserve escrow reserved at settlement finalization.

Edge cases

• Adjacent ranges at a boundary: consider $R_1=[60{,}000,62{,}000)$ and $R_2=[62{,}000,64{,}000)$. A settlement tick at exactly $62{,}000$ is out-of-range for $R_1$ and in-range for $R_2$. Holding both positions yields a constant payoff across $[60{,}000,64{,}000)$ without double counting at the boundary.
• Upper bound boundary: $[\text{lowerTick}, \text{upperTick})$ excludes the upper tick. Settlement equal to the upper bound is out-of-range for that interval.
• Out-of-domain settlement values: tick mapping clamps settlement into the first or last tick of the domain.
• Delayed finalization: even after the claim-open timestamp, claims remain closed until finality has been written on-chain.

Common misreads

• Interpreting a range as a point: a range is a bundle of ticks. It is priced and settled as an interval, not as a single strike.
• Ignoring the fee overlay: base pricing is the curve. Effective execution is curve plus fees. Realized PnL depends on the effective amount.
• Missing half-open semantics: the upper bound is excluded. Adjacent ranges do not overlap at their boundary tick.

Related sections:

• Positions and Payouts
• CLMSR Pricing Curve
• Liquidity Depth and Slippage
• Fees and Effective Price
• Market Lifecycle
• Oracle and Settlement