Skip to main content

Trader Journey

Signals v1 trading is interaction with a shared pricing curve rather than peer-to-peer matching. A trade is defined by a range on the tick grid, a trade quantity, and the current curve state. Execution cost follows from how much the trade moves that shared state.

Two pieces of geometry are explicit in v1:

  • Range width is precision. Narrow ranges encode a sharper view.
  • Trade size is price impact. Larger size pushes the curve further.

Time affects execution because other trades move the state, and global configuration or implementations can change across governance actions. In the current release, depth and fee policy are fixed per market at creation. Path independence is a statement about the curve, not a promise that costs are constant over time.

This guide describes the trade lifecycle the way the contracts do: as a sequence of time-gated state transitions. The goal is to make the surface legible without turning it into a UI walkthrough.

Market frame​

Every market defines the outcome domain [L,U)[L, U) and a tick spacing ss. Those two values define the grid and the meaning of "a range" in that market.

Markets also define timing windows: trading closes before the oracle and finality steps, and claims open after finality plus a delay. Depth and fee policy are on-chain configuration that shape execution cost.

Markets also carry two pieces of structure that shape every trade:

  • Resolution: tick spacing sets how fine the settlement surface is. A range that is "narrow" depends on spacing, not only on raw units.
  • Cost geometry: depth and the current curve state define how quickly the marginal price rises as size increases.

At a minimum, a market can be understood by reading its bounds, spacing, timing, depth, and fee policy. These values do not change mid-trade; they shape the state transition that the curve applies when a trade is executed.

Trading also has a simple operational boundary: trades are admitted only during the trading window. Transactions submitted near the boundary can revert if the block timestamp at inclusion falls outside the admitted interval. This is a mechanism property, not a UI choice.

Range geometry​

A position is a contiguous interval [lowerTick,upperTick)[\text{lowerTick}, \text{upperTick}) on the grid. After finality, it pays a fixed quantity if the finalized settlement tick lies inside the interval, and pays zero otherwise.

Ranges are expressed in ticks, but trades are usually expressed in observed units. Converting an observed interval into ticks is part of specifying a trade: the same numeric interval can map to different tick spans across markets if spacing differs.

Narrow ranges concentrate price mass into fewer ticks. That concentration is what makes a narrow range more "precise", and it is also what tends to make the marginal cost of adding more quantity rise faster as the curve moves.

Wide ranges spread quantity across more ticks. The exposure is less specific, but the curve is being pushed over a broader interval, so marginal price impact per unit often behaves differently than in a narrow interval.

It can be helpful to read a range as a bundle of ticks. A range that spans mm ticks is a claim that pays on any of those mm tick outcomes. The shared curve prices that bundle by assigning a price mass to each tick and summing over the range.

Because range positions are standardized and composable, a belief shape can be constructed as a combination of intervals. A single view can be represented as a bundle of adjacent or overlapping ranges, and the shared curve prices the bundle coherently because it prices all ranges from the same global state.

One concrete edge case is tick alignment. Ranges are expressed in ticks, and ticks are aligned to spacing. If a market has spacing ss, then only tick indices aligned to ss are meaningful as boundaries. A well-formed range boundary is therefore not an arbitrary integer. It is an integer multiple of the spacing inside the market's tick domain. This is one reason spacing is part of the market definition, not a UI detail.

Size, depth, and slippage​

The curve is shared across all ranges. Buying quantity on a range adds mass to ticks inside that range. Selling removes it. Execution cost is the cost of moving the state.

Fee-free cost is path-independent: it depends only on the pre-trade and post-trade state. Slippage is the price impact implied by that state change. It is not a separate fee; it is the consequence of pushing new information into the shared price distribution.

Mechanically, the fee-free base cost of a range buy of size xx on range RR is the CLMSR cost-function difference:

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

The executed average base price is baseCost/x\text{baseCost}/x. The gap between the starting range price and the executed average is slippage from moving the curve.

Depth scales how sensitive prices are to trades. Higher depth means the same trade size moves prices less. Lower depth means the same size produces larger state movement, so effective price changes more with size.

Fees are applied after base pricing as an overlay. The effective price is the base price plus fees, and effective price is what enters realized PnL.

A worked sketch​

Consider a market whose domain is [50,000,70,000)[50{,}000, 70{,}000) with spacing 100100. Suppose the range [60,000,62,000)[60{,}000, 62{,}000) is bought with quantity xx.

  • A smaller xx produces a smaller state update and a smaller slippage gap.
  • A larger xx moves the curve further, so the average execution price drifts away from the starting quote.
  • A narrower range concentrates the update on fewer ticks, which typically makes marginal price rise faster with size than a wider range under the same depth.

The fee overlay then adjusts the base cost into the effective cost. Two trades can have similar slippage but different effective results if fee rates differ.

The execution bounds should be interpreted in the same language. For a buy, maxCost is an on-chain statement of "do not pay more than this ctUSD amount." The bound does not tell the curve what to do. It tells the transaction when to revert. A bound that is too tight will revert often during volatile periods. A bound that is too loose will execute, but the trader has accepted the full slippage implied by state movement at inclusion time.

Time and state dependence​

Path independence does not mean time-independence. The same range and quantity can have different base cost at different times because the starting state and depth can differ.

The stable comparison unit is the state transition: two trades that start from the same state and end at the same state have the same fee-free cost, even if they occur in different sequences of intermediate trades.

Positions can be increased, reduced, or closed before settlement by trading in the opposite direction. Mechanically, that is simply moving the shared state in the other direction at the current state.

The open execution environment also affects realized execution. A submitted transaction can be included after the state has moved due to other trades. The mechanism remains state-defined, but the realized execution depends on the state at inclusion.

This is the concrete meaning of state dependence. If the state changes between submission and inclusion, the same calldata can imply a different effective price. Execution bounds exist precisely to make this risk explicit and controllable at the transaction level.

Finality and claims​

Trading closes before settlement finality. Finality selects a single settlement tick. After the claim delay, a position is claimable and the payout rule is purely "tick in interval".

Ranges are half-open: [lowerTick,upperTick)[\text{lowerTick}, \text{upperTick}). The lower bound is included and the upper bound is excluded. This convention removes boundary overlap between adjacent ranges and makes settlement edge cases unambiguous.

Claims are mechanically simpler than trading. A claim does not move the curve. It reads the finalized tick and applies the payout rule. The protocol escrows a payout reserve as part of finality, so claims are deterministic transfers after the time gate opens.

Related sections: