The C-pool
Concentrated. A floor and a cap per LP, one base against one quote.
Give each LP its own boundaries and claims become heterogeneous — which costs the shared-floor accounting and buys everything concentration is for.
What is gained
One curve, many floors. By aggregation the sum of the active positions is itself a log position, so a swap prices against a single between crossings. Crossing a floor adds or removes that floor's , and becomes a step function of price. Liquidity concentrates where LPs put it, without the pool ever having to price against more than one curve at a time.
Resting orders, both directions. By the cap a capped position reaches all quote at and goes dormant above. A resting buy is a capped position minted above spot — quote-only on entry, converting to base as price falls to the floor. A resting sell is a dormant mint below completion. Both earn fees while resting, and both are edited in place.
There is no passive-order mechanism in the protocol. A partially filled order is a position mid-band. See Resting orders.
A coarse ladder suffices. A blend of two adjacent floors is one position at the weighted mean, so a discrete ladder spans a continuum of floors. Ladder density is an interface parameter, not a precision parameter.
What is lost
The floor can no longer absorb a fee, so becomes an explicit accumulator with per-class attribution. See Fee machinery.
Multi-asset goes. Per-asset attribution across bases would need accumulators with -valued snapshots at every boundary — buildable, but against the posture. A C-pool is one base against one quote, and a concentrated basket is assembled from one C-pool per constituent.
Positions stay fungible
Aggregation carries no per-holder path dependence, so per-holder state collapses to the class: a position is a share balance in a (floor, cap) class. Claims are heterogeneous across classes and homogeneous within one — which is exactly enough for the shared-floor accrual argument to run one class at a time.
This is why positions are fungible ERC-6909 tokens rather than NFTs. Uniswap v3 needs a
feeGrowthInside snapshot per NFT because ranges are individually addressed and do not compose.
What the cap forbids
A capped position is a difference containing a short leg, so it is held as one indivisible claim. Splitting it would let a holder sell the long leg and keep the short. Because the primitive carries one — shed at the cap as it was taken on at the floor — the representation has no way to express a net short at all.
The surface
Everything goes through the router; the manager holds the state.
// create a market and add its first liquidity, in one transaction
createMarket(key, x0, targetFloor, L, maxBaseIn, maxQuoteIn, recipient, deadline)
// enter and exit
mintBlended(key, targetFloor, cap, L, maxBaseIn, maxQuoteIn, recipient, deadline)
burn(key, ids[], shares[], minBaseOut, minQuoteOut, recipient, deadline)
zapIn(key, fundWithBase, amountIn, targetFloor, cap, L, maxIn, recipient, deadline)
// trade
swapExactIn(key, baseIn, amountIn, minOut, recipient, deadline)
swapExactOut(key, baseOut, amountOut, maxIn, recipient, deadline)
swapExactInPath(hops[], amountIn, minOut, recipient, deadline)
// live position management
claim(key, ids[], recipient, deadline)
update(key, fromId, shares, toFloor, toCap, newL, maxBaseIn, maxQuoteIn, recipient, deadline)
move(key, fromId, shares, toFloor, toCap, deadline)mintBlended takes an arbitrary target floor and splits it across the two adjacent ladder rungs;
previewBlend returns the split. update sets to any valid triple in
one call and returns signed flows — every LP operation named in
Liquidity provider is a wrapper over it that pins one or two degrees of
freedom. move is update with pinned; newL = 0 is a full exit and settles identically to
burn.
Market identity
A market is a PoolKey — the full economic tuple, and nothing else:
struct PoolKeyC {
address base;
address quote;
int256 tickSpacing; // δ_ξ — the coarse LP-boundary ladder
address policy; // admission and action policy
uint256 swapFee; // fixed swap fee, WAD; 0 requires policy admission
uint256 mintFee; // fixed mint fee, WAD; twice swapFee to 2%
}
poolId = keccak256(abi.encode(key))The key's swapFee is the fee: there is no default and nothing is resolved at read time. A fee of
0 means no fee. The manager accepts 0 or anything from FEE_MIN (1 bp) to FEE_MAX (1%); which of
those a market may use is the gate's list (below). The initial price is deliberately excluded: it seeds
state, it does not identify the market — so an x0-only duplicate is refused, which is the squatting
defence.
Creating a market
initialize(key, x0) validates the key and asks its policy to admit the market. The current local
contracts use a policy address in PoolKeyC; the creator selects mintFee in that key, subject to
2 * swapFee <= mintFee <= 2%. A policy can restrict creators, pairs, fee tiers and tick spacings.
Read the deployed policy's terms rather than assuming a universal list.
The router's createMarket initializes a market and adds its first, uncapped liquidity atomically.
The policy sees the router as the initializer. If admission requires the user to initialize directly,
call the manager first, then mint through the router. First liquidity locks a small permanent
backstop in the manager ledger.
Policies can also gate later actions when their configured permissions require it. Check the market's policy before providing liquidity. See Contracts.