Capital Stack and Fee Waterfall

Signals v1 uses a capital stack and a fixed fee waterfall to preserve solvency and keep incentives aligned. The stack is not just a funding structure; it is the mechanism that turns daily trading results into a clear allocation of gains and losses.

Figure: Fee and loss flow across maker capital, buffer capital, and protocol reserves.

Capital stack

Role ordering for gains and losses.

The capital stack is a priority order. Maker capital absorbs routine trading variation first. A buffer layer exists to smooth extreme days. A protocol reserve sits behind those layers as a last-resort backstop. The exact implementation is on-chain, but the public idea is simple: losses and fees move through a fixed ordering.

The ordering is the contract: it defines who absorbs losses first and how buffers are restored. The sequence dominates any single numerical choice because it defines the long-run shape of liquidity depth.

The layers exist for different reasons:

• Maker capital is the first-loss layer that underwrites depth.
• Buffers exist to avoid forcing depth to collapse after a single bad day.
• Reserves exist to provide last-resort coverage in rare tail regimes.

The stack can be read as a solvency geometry. Depth is an economic promise: the curve can quote prices for any range, but the cost of moving the curve is backed by maker-side capital. The stack defines which capital absorbs negative outcomes and which capital accumulates positive outcomes.

Because the stack is ordered, a market day produces a unique attribution. The same day inputs cannot be allocated in multiple inconsistent ways. That uniqueness is part of what makes the protocol analyzable over time.

Waterfall purpose

The waterfall enforces a clear priority of losses and fee allocation. It keeps risk and reward well-defined and prevents ambiguous “who pays” outcomes on bad days.

Without a fixed ordering, daily losses could be negotiated after the fact. The waterfall removes that ambiguity by hard‑coding the sequence.

High-level flow

At a high level, the flow looks like this:

1. Trading produces gains or losses, plus fees.
2. Losses are absorbed in priority order, starting with maker capital.
3. Fees are allocated by a fixed rule to restore buffers and fund the system.

The exact weights are policy choices, but the ordering is fixed.

The ordering also stabilizes incentives. Makers know where losses land, and the protocol can rebuild buffers over time without hidden transfers.

The separation between ordering and weights is deliberate:

• Ordering defines fairness and determinism at the mechanism surface.
• Weights define policy inside that ordering and can adapt across regimes.

This keeps the system coherent even when allocation weights are updated. A weight change is a regime boundary. The ordering remains the same grammar for daily accounting.

Waterfall steps in one place

The concrete algorithm used at the daily boundary can be summarized as four ordered steps. The notation on this page matches the implementation-level objects:

• $L_t$ is the net maker-side trading result recorded at settlement (signed).
• $F_\text{tot}$ is the gross fee total for the batch day.
• $N_{t-1}$, $B_{t-1}$, $T_{t-1}$ are the pre-batch NAV values of maker, backstop, and treasury.
• $\Delta E^\text{sum}$ is the batch tail budget sum.

1. Loss compensation from fees. Let $L_t^- = \max(0, -L_t)$. Use fees to compensate losses first:

$$F_\text{loss} = \min(F_\text{tot}, L_t^-),\qquad F_\text{pool} = F_\text{tot} - F_\text{loss}$$

and compute:

$$N_\text{raw} = N_{t-1} + L_t + F_\text{loss}$$

1. NAV floor and grant. Define a NAV floor by a fixed fraction parameter $p_\text{dd}<0$:

$$N_\text{floor} = N_{t-1}\,(1+p_\text{dd})$$

The grant need is:

$$G^\text{need} = \max(0, N_\text{floor} - N_\text{raw})$$

Two admissibility checks apply:

$$G^\text{need} \le \Delta E^\text{sum} \qquad\text{and}\qquad G^\text{need} \le B_{t-1}$$

If either fails, batch processing reverts. If both hold, the grant is executed: $G_t = G^\text{need}$ and $N_\text{grant} = N_\text{raw} + G_t$.

1. Backstop coverage target. The backstop has a target coverage ratio $\rho_\text{BS}$ applied to maker NAV:

$$B_\text{target} = \rho_\text{BS}\,N_\text{grant}$$

If the backstop is below target after the grant, fees fill the deficit before residual splitting:

$$F_\text{fill} = \min(\max(0, B_\text{target} - (B_{t-1} - G_t)),\ F_\text{pool})$$

1. Residual split. The remaining fee pool is split into LP, backstop, and treasury shares with weights that sum to 1. Any rounding dust is routed deterministically.

The conceptual point is ordering, not the choice of weights: loss compensation happens before buffer fill, which happens before residual distribution.

A worked numeric sketch

This sketch uses simple numbers to show the ordering and the hard reverts. The numbers are illustrative only.

Assume pre-batch maker NAV $N_{t-1}=1000$, backstop NAV $B_{t-1}=300$, daily PnL $L_t=-120$, and gross fees $F_\text{tot}=20$.

Loss compensation uses fees first:

$$L^-_t = 120,\quad F_\text{loss}=\min(20,120)=20,\quad F_\text{pool}=0$$

so:

$$N_\text{raw}=1000 + (-120) + 20 = 900$$

Now assume the floor parameter implies $N_\text{floor}=950$. The grant need is $G^\text{need}=50$. If the tail budget sum is $\Delta E^\text{sum}=40$, then the inequality $G^\text{need}\le \Delta E^\text{sum}$ fails and the batch reverts.

If instead $\Delta E^\text{sum}=80$ and $B_{t-1}=300$, then the grant is admissible, $G_t=50$, and the post-grant NAV becomes $N_\text{grant}=950$.

The important behavior is not the specific numbers. It is the invariant that infeasible days do not partially execute. They revert at the daily boundary.

Example day

Consider a day with 12 ctUSD of fees and -8 ctUSD of net maker-side trading PnL. At the daily batch boundary, the protocol applies the ordering:

1. Trading PnL is applied to maker-side accounting.
2. Fees are allocated through the waterfall to refill buffers and route residuals.

If instead the day is -50 ctUSD net and the buffer is thin, the ordering determines which layer absorbs the deficit first. The system does not negotiate losses after the fact. It applies the same priority order, making outcomes comparable across days.

Two sketch scenarios

Scenario A: mild loss day.

• Day inputs: fees 12, maker-side PnL -8.
• Maker capital absorbs the loss.
• Fees are routed according to the policy split, typically prioritizing buffer restoration before residual routing.

Scenario B: large loss day with thin buffers.

• Day inputs: fees 12, maker-side PnL -50.
• Maker capital absorbs as much as it can according to the stack rules.
• Remaining deficit propagates to buffer layers according to the fixed ordering.
• Fee routing still follows the same sequence; it does not become discretionary.

The mechanism-level content is the stability of this accounting grammar. The same ordering is applied to different magnitudes.

Cadence and accounting boundary

Allocation happens on the daily batch boundary. Trades during the day affect positions, but the accounting update that realizes gains and losses into capital occurs at a single checkpoint. That checkpoint is observable in settlement and accounting events.

This cadence makes outcomes comparable across time because attribution happens once, at a single daily boundary.

The waterfall does not change the pricing curve. It defines how maker capital absorbs gains and losses and how buffers rebuild, which in turn influences future depth. Maker returns are realized on the daily cadence, not per trade.

Over time, the waterfall determines whether depth can recover after loss days. If buffers refill predictably, the curve can remain resilient. If they do not, depth can thin and slippage rises.

LP access is private in v1, but the capital-stack model still describes how maker-side buffers and fee allocation behave.

Boundary behavior

Some days stress the accounting boundary more than others. Days with little fee revenue but negative trading results emphasize loss absorption. Large loss days test how quickly buffers can rebuild. These are not special "modes" of the mechanism; they are the same ordering applied to more extreme inputs.

Boundary behavior also includes timing. Allocation happens after settlement finality. If finality is delayed, allocation waits. This keeps maker accounting aligned to explicit finality in the lifecycle state machine.

Related reading

• Vault Fee Waterfall
• Risk Invariants