Whitepaper

The Signals v1 whitepaper is the formal specification of the mechanism. It defines the primitives, the equations, and the invariants that make the system well-defined as an on-chain market.

Signals v1 is also upgradeable. The deployed contracts define the live behavior. When bytecode or configuration changes, that on-chain change is the regime boundary for interpretation of historical behavior.

This page is a guided extraction of the core definitions used across the whitepaper. The complete PDF is linked at the end.

Primitive objects

Signals v1 is built from a small set of primitives.

A market day fixes:

• an outcome grid expressed as ticks,
• a shared pricing state $q$ that prices every tick and every contiguous range,
• a settlement timestamp $T_\text{set}$ and its time-gated windows,
• a single finalized settlement tick $\tau$ written on-chain at finality,
• and a daily accounting boundary that realizes maker PnL and fees.

A position is a range claim:

• lower tick $\ell$ is inclusive,
• upper tick $u$ is exclusive,
• quantity $x$ is the payout amount if the finalized tick lands inside the range.

Because exactly one tick is finalized per market day, a range position behaves like a bundle of tick claims. It adds the same quantity to every tick inside its range, but it only ever pays once, at the single finalized tick.

This is the reason ranges are composable. A portfolio of ranges is still a claim on the same one-tick finality rule. The pricing engine can therefore keep one global state for all ranges without introducing conflicting payout semantics.

Outcome grid and tick mapping

A market defines a discrete tick grid. The grid is specified by:

• $\text{minTick}$
• $\text{maxTick}$ as an exclusive upper bound
• tick spacing $s > 0$

Ticks are aligned to spacing. A tick is valid if it is at least $\text{minTick}$ and $(\text{tick} - \text{minTick})$ is a multiple of $s$.

Oracle settlement produces a settlement value in a fixed unit and then converts that value into a tick by integer division. Let $\text{settlementValue}$ be the scaled settlement value. The raw tick is:

$$\text{tick}_0 = \left\lfloor \frac{\text{settlementValue}}{10^6} \right\rfloor$$

The raw tick is clamped into the valid tick range and aligned down to spacing:

$$\text{tick}_1 = \mathrm{clamp}\!\left(\text{tick}_0,\ \text{minTick},\ \text{maxTick} - s\right)$$ $$\tau = \text{minTick} + \left\lfloor \frac{\text{tick}_1 - \text{minTick}}{s} \right\rfloor s$$

This rule removes ambiguity at settlement time. A continuous external value is reduced to one discrete tick by a deterministic, public function.

Two boundary conventions are worth stating explicitly:

• $\text{maxTick}$ is exclusive. If the raw tick lands at or above $\text{maxTick}$, it clamps into the last valid tick $\text{maxTick} - s$.
• Alignment rounds down. If spacing is 10 and the raw tick is 20057, the aligned tick becomes 20050.

These are not cosmetic conventions. They decide which range receives payout at exact boundary outcomes.

Range positions and payout semantics

A position is defined by ticks and quantity: $(\ell, u, x)$ with $\ell < u$. The range is half-open, so adjacent ranges do not overlap at boundaries.

The claim rule is:

$$\text{payout}(x, \ell, u, \tau) = \begin{cases} x, & \tau \in [\ell, u) \\ 0, & \text{otherwise} \end{cases}$$

The semantics are intentionally discrete. Settlement pays a single tick, and positions read that tick. Claims do not depend on off-chain interpretation.

Half-open ranges avoid double counting at boundaries. Consider two adjacent ranges $[20000, 20010)$ and $[20010, 20020)$. If $\tau = 20010$, only the second range pays. The boundary tick is not shared.

Position bounds must align to tick spacing and must be strictly ordered. A range with $\ell \ge u$ is invalid, and a range that is not aligned to spacing does not have a clear meaning as a tick set.

CLMSR pricing core

Signals v1 prices a full tick grid with a shared CLMSR state $q$ and depth $\alpha > 0$.

Define:

$$w_i(q) = \exp(q_i / \alpha),\quad Z(q) = \sum_j w_j(q)$$ $$C(q) = \alpha \ln Z(q),\quad p_i(q) = \frac{w_i(q)}{Z(q)}$$

$C(q)$ is the potential. $p_i(q)$ is the tick price distribution induced by the state.

Two identities define the pricing contract:

Normalization:

$$\sum_i p_i(q) = 1$$

Gradient identity:

$$\frac{\partial C}{\partial q_i} = p_i(q)$$

A contiguous range $R$ is priced as a sum of its ticks:

$$p(R; q) = \sum_{i \in R} p_i(q)$$

A range trade is a structured state update. Let $\mathbf{1}_R$ be the indicator vector for range ticks. Buying quantity $x$ on $R$ updates state by:

$$q' = q + x\mathbf{1}_R$$

The fee-free base cost is pinned down by the potential difference:

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

The same identity can be written as an integral. The marginal price of a range buy at size $x$ is the range price after applying the update:

$$\frac{d}{dx} C(q + x\mathbf{1}_R) = p(R; q + x\mathbf{1}_R)$$

Integrating from 0 to $x$ yields:

$$\text{baseCost}(x; q, R) = \int_{0}^{x} p(R; q + t\mathbf{1}_R)\, dt$$

This makes two facts explicit:

• slippage is the change in $p(R; q + t\mathbf{1}_R)$ as size increases, and
• depth $\alpha$ is the scale that controls how quickly the price mass moves.

In the small-trade limit, the integral reduces to a linear approximation:

$$\text{baseCost}(x; q, R) \approx x \cdot p(R; q)$$

The deviation from linearity is the slippage term. It is driven by curvature of the log-sum-exp potential and grows as $x$ becomes large relative to $\alpha$.

The path independence identity follows immediately from telescoping sums:

$$\sum_{t=0}^{k-1} \left(C(q_{t+1}) - C(q_t)\right) = C(q_k) - C(q_0)$$

Path independence is a statement about the fee-free mechanism. Fees are an explicit overlay applied after base pricing.

Classical LMSR loss bounds also carry into this formulation. The potential form implies a bounded market-maker subsidy for an $n$-tick market, controlled by $\alpha$. This is one reason depth is treated as a mechanism-level parameter rather than a UI knob.

Daily lifecycle and finality

Each market day is time-gated around $T_\text{set}$:

$$\text{settleEnd} = T_\text{set} + \Delta_\text{settle}$$ $$\text{opsEnd} = T_\text{set} + \Delta_\text{settle} + \Delta_\text{ops}$$

Finality writes one tick $\tau$ on-chain. Claims remain closed until both:

• the market is finalized, and
• the claim gate has opened:

$$\text{claimOpen} = T_\text{set} + \Delta_\text{claim},\quad \Delta_\text{claim} = \Delta_\text{settle} + \Delta_\text{ops}$$

Oracle candidate selection is deterministic. A set of signed samples submitted during the submission window induces one selected candidate by closest timestamp to $T_\text{set}$, with a tie-breaker to the past.

Two failure paths exist when oracle settlement does not produce a usable candidate:

• If no admissible candidate exists, primary finalization is unavailable and the day remains non-final.
• A failure flag can route the day to the secondary finalization path, which writes a settlement value supplied by the permissioned finalizer and converts it into a tick using the same tick mapping rule.

Both paths preserve the same claim semantics. They differ only in how the settlement value is sourced.

Accounting boundary and maker-side allocation

Finality is also the accounting boundary. When a market day finalizes, the protocol:

• computes the day PnL and gross fees for the market,
• escrows a payout reserve for open positions at the finalized tick,
• records the day input into the daily batch keyed by the market day.

Maker-side allocation then applies a deterministic fee waterfall to produce the next-day maker state.

The waterfall is an algorithm over a small input vector. A convenient notation is:

• $L_t$ as signed maker PnL for the day
• $F^{\text{tot}}_t$ as gross fees for the day

The waterfall then produces the daily LP credit, the new backstop balance, and the new treasury balance under fixed ordering and fixed rounding semantics. Those semantics are part of the specification because they affect long-run depth and realized maker returns.

Safety envelope

Signals v1 enforces a safety envelope at market creation. Two quantities are checked mechanically:

• an admissible depth limit $\alpha \le \alpha_{\text{limit}}$
• a tail budget bound $\Delta E_t \le \text{backstopNav}$

The enforcement surface is market creation. Trade-level exposure cap hooks exist in v1, but exposure cap enforcement is not active in the current release.

The safety envelope connects to the accounting boundary. Finality records the market day PnL and fees, and the batch processes the day under a tail budget constraint. A day that would require a grant beyond $\Delta E_t$ is rejected by reverting the batch.

This coupling is intentional. It makes "loss beyond capacity" an explicit failure mode, not an implicit drift.

Whitepaper PDF

Whitepaper PDF:

• Whitepaper PDF