Liquidity Depth and Slippage

Signals v1 uses a shared pricing curve across all ranges. The curve has a notion of depth: deeper liquidity means prices move less for the same trade size, while shallower liquidity means prices move more. Depth is what turns trade size into price impact.

Depth is not an extra feature bolted on later. It is the core knob that makes a market feel either smooth or jumpy. When depth is high, moderate trade sizes shift prices modestly. When depth is low, the same trade pushes the curve noticeably, and the average execution price drifts away from the initial quote.

Depth is a state, not a promise. It describes how elastic the price is at the current state of the curve, not how much volume will trade in the future. Volume is flow over time; depth is instantaneous price elasticity.

From quote to executed price

The shared curve defines an instantaneous quote and an executed average.

For a contiguous range $R$, the instantaneous range price is the sum of tick prices:

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

That number is the starting point. A trade is a state update, so execution follows a path on the curve. For a range buy of quantity $x$, the base pricing cost is the cost-function difference:

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

where $\mathbf{1}_R$ is the indicator vector for the range (1 inside $R$, 0 outside).

The average base price paid is $\text{baseCost}(x; q, R)/x$. Slippage is the gap between the starting quote and that average. Fees apply afterward as an explicit overlay, so the effective average price is $(\text{baseCost} + \text{fee})/x$.

Definitions for $C(q)$, $q$, and $p_i(q)$ live in CLMSR Pricing Curve.

One useful identity makes the depth role explicit. Define:

$$Z_\text{in}(q;R) = \sum_{i\in R} \exp(q_i/\alpha), \qquad Z_\text{out}(q;R) = \sum_{i\notin R} \exp(q_i/\alpha), \qquad Z = Z_\text{in} + Z_\text{out}$$

Buying quantity $x$ on $R$ adds $x$ to every $q_i$ inside $R$, so the weights inside the range are multiplied by $\exp(x/\alpha)$. The post-trade partition sum is therefore:

$$Z' = Z_\text{out} + \exp(x/\alpha)\,Z_\text{in}$$

and base cost has a closed form:

$$\text{baseCost}(x; q, R) = \alpha \ln\!\left(\frac{Z_\text{out} + \exp(x/\alpha)\,Z_\text{in}}{Z}\right)$$

Since $p(R;q)=Z_\text{in}/Z$, this can be written directly in terms of the range price mass:

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

This identity shows what depth controls: $x/\alpha$ is the dimensionless trade size that governs how quickly the exponential term grows.

Depth as liquidity

Depth is the scale of the shared curve. When depth is higher, a given trade shifts prices less; when depth is lower, the same trade shifts prices more. This is the core link between liquidity and slippage.

In CLMSR terms, depth is the parameter that spreads weight across ticks. A larger depth makes each unit of quantity move the state less, so prices adjust more gently. A smaller depth concentrates weight, so each trade has a larger effect. Depth therefore behaves like the market's stiffness.

An intuitive way to think about it: the curve is a spring. A stiffer spring means more force is required to move it. A softer spring moves a lot with the same push. Depth is that stiffness.

Depth is global. It applies to every range because the market shares a single curve. This is a key distinction from per-range pools: there is one depth, not one depth per range.

A simple numeric sketch

Imagine two markets with the same starting price but different depth. A trader places the same buy size in both.

• Shallow depth: price might move from ~0.40 to ~0.55 after the trade.
• Deep depth: price might move from ~0.40 to ~0.44 after the trade.

These numbers are illustrative only, but the direction is the point: deeper liquidity compresses price impact for the same trade size.

The effective price paid is the average price along the trade path, not the initial quote. In a shallow market, that average can be meaningfully higher (or lower) than the starting price. That gap is the slippage cost.

Slippage as information cost

Slippage is not just a fee. It is the cost of pushing new information into the market price. Larger or more aggressive trades move the curve further, so the marginal cost rises as the position grows.

Slippage therefore differs from a fixed fee. A fee is a flat markup. Slippage is a curve: as a trade pushes the price further, each additional unit becomes more expensive.

Slippage is also convex. Doubling trade size more than doubles the marginal cost because the trade pushes the curve into a steeper region. Sizing and timing change slippage, and the curve punishes brute force.

If the curve state changes between trades, identical sizes can have different slippage. Depth is fixed per market at creation in the current release, but it can differ across markets.

The closed form above also yields a small-trade approximation. For small $x/\alpha$, expand $\exp(x/\alpha)$ and $\ln(\cdot)$ to second order to obtain:

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

The first term is the "quote times size" term. The second term is the leading slippage term and makes two dependencies explicit:

• slippage grows with $x^2$ for fixed $\alpha$, and
• slippage shrinks as $\alpha$ increases.

The factor $p(R;q)(1-p(R;q))$ also makes range context explicit: for very small or very large $p(R;q)$, the local curvature contribution is smaller than around mid-mass ranges.

One curve, many ranges

Because all ranges are priced by a single curve, liquidity is not fragmented. Trading a narrow range still benefits from the total liquidity embedded in the curve. Depth is therefore a protocol-level property, not a per-range pool.

That shared curve is what keeps the market coherent. A narrow range is still expensive to move because it sits on top of the same global pricing state as every other range. This avoids the common failure mode where liquidity gets trapped in isolated bins.

It also means price impact is a global effect. Trading one range moves the same curve that prices adjacent ranges. The state change propagates across the grid through that shared curve.

Range width and price impact

Range width changes how much value is concentrated in a position. Narrow ranges concentrate value and tend to be more sensitive to price impact; wide ranges spread value out and tend to move the curve less per unit of quantity. This precision is not free: it is paid for in slippage.

Range width interacts with tick spacing. A range that is narrow in tick terms behaves like a very concentrated bet even if its real-world width looks large. Tick spacing and range width should be thought about together.

Execution in Signals is shaped by state-based price impact. Larger positions face rising marginal cost as the curve moves. Quotes are starting points; the effective price is the path average. Narrower ranges concentrate value and often amplify price impact. Depth is fixed per market at creation in the current release, but it can differ across markets.

Because base cost depends only on state, the cost of a hypothetical trade is defined by the current curve without relying on a counterparty quote.

Connection to maker capital

Depth is underwritten by maker capital that absorbs trading risk. LP access is private in v1, but this is the structural reason liquidity depth exists in the system.

The key point is that depth is real economic capacity, not just a cosmetic number. If maker capital is thin, the curve becomes sensitive. If capital is deep, the curve becomes resilient, and slippage compresses.

Related sections:

• CLMSR Pricing Curve
• Trader Journey
• Trader FAQ and Scenarios