Pools & Discovery

Pool identity

A pool is (token0, token1, poolType) — nothing else. There are no fee tiers: exactly one canonical pool per combination. Lookup is getPool(tokenA, tokenB, poolType), which answers with the tokens in either order.

Listing a pool

The factory creates pools only for accounts holding its creator role:

function canCreatePool(address account) external view returns (bool);   // POOL_CREATOR_ROLE, or the owner
function createPool(address tokenA, address tokenB, PoolType poolType) external returns (address pool);
function createPoolWithTerms(address tokenA, address tokenB, PoolType poolType, PoolTerms calldata terms)
    external returns (address pool);

struct PoolTerms {
    uint24 fee;
    ILunyaPool.FeeToken feeToken;
    uint16 pluginConfig;
    address pluginFactory;
    bytes pluginSettings;
}

An ordinary address calling either reverts NotAPoolCreator() — and so does initialize on an unpriced pool. What holds the role are listers: contracts that apply a listing policy and create and price a pool in a single call.

interface ILunyaLister {
    function listPool(address tokenA, address tokenB, bytes calldata data) external returns (address pool);
}

Listing is idempotent: whoever lands second is handed the existing pool, and an existing price is never touched — so a lister cannot be used to move a market.

Lister	Who may call	`data`	Lists
Public lister	anyone	`abi.encode(PoolType poolType, uint160 sqrtPriceX96)`	CL only — any other type reverts `CurveNotOpen(poolType)`
Terms lister	callers governance has registered a listing for	`abi.encode(uint160 sqrtPriceX96)` — exactly 32 bytes, else `PriceRequired()`	the pool type and terms registered for that caller; `NoTermsRegistered(caller)` otherwise

Contracts that hold the role directly — such as the launchpad — call createPoolWithTerms themselves. The role holders are enumerable on-chain (getRoleMemberCount / getRoleMember for POOL_CREATOR_ROLE()), and role changes emit OpenZeppelin’s RoleGranted / RoleRevoked. The position manager offers the same flow to LP frontends, forwarding data to the lister unread:

function createAndInitializePoolIfNecessary(address lister, address token0, address token1, bytes calldata data)
    external payable returns (address pool);   // tokens must be sorted, else TokensOutOfOrder()

Before offering pool creation in a UI

Check the lister, not the user: factory.canCreatePool(publicLister). A user’s own address is not a creator.
Offer CL only through the public lister.
Check the type has defaults — defaultsOf(CL) with a non-zero tick spacing — or creation reverts DefaultsNotSet().
Check getPool(a, b, CL) first: an existing, priced pool is simply handed back, so show it as already listed.
Collect an opening price and encode it: abi.encode(PoolType.CL, sqrtPriceX96).
On a chain with no native wrapper, send no msg.value.

Pool types are an open set

PoolType is a user-defined uint8, not an enum — deliberately, so the ABI never rejects a value newer than your build:

CL = 0       // concentrated liquidity, the Uniswap V3 model
CP = 1       // constant product — CL constrained to full range
STABLE = 2   // amplified stableswap

Numbers are forever and new types go at the end (the value is part of the CREATE2 salt). Write integrations that pass unknown types through rather than reject them.

Address derivation

The deployer, not the factory. Pools are CREATE2-deployed by a separate deployer contract — read its address from factory.poolDeployer(). Derivation:

salt         = keccak256(abi.encode(token0, token1, poolType))   // abi.encode, NOT encodePacked
initCodeHash = deployer.initCodeHashOf(poolType)                  // ONE HASH PER TYPE
pool         = keccak256(0xff ++ deployer ++ salt ++ initCodeHash)[12:]

Or simply call deployer.computePoolAddress(token0, token1, poolType).

Two classic V3 habits break here: hardcoding one init code hash, and deriving from the factory address (it is the deployer). There is one hash per pool type and per deployment — a pool is an EIP-1167 minimal proxy, so the hash is of the proxy’s creation code, which embeds the address of its type’s implementation (deployer.implementationOf(poolType)), and that address belongs to the deployment. Read and cache initCodeHashOf per deployment; implementation registration is append-only, so each type’s hash never changes once set.

Reading a pool

Uniform across every pool type:

function slot0() external view
    returns (uint160 sqrtPriceX96, int24 tick, uint24 fee, uint16 feeProtocol0, uint16 feeProtocol1);
function sqrtPriceX96() external view returns (uint160);   // one SLOAD — prefer it when the price is all you want
function feeInfo() external view returns (uint24 fee, bool isDynamic);
function feeToken() external view returns (FeeToken);           // Paid | Token0 | Token1
function liquidity() external view returns (uint128);
function tickSpacing() external view returns (int24);      // 0 on tickless pools — a capability, not a name
function poolType() external view returns (PoolType);

The caveats that matter:

Uninitialized pools return zeros, never revert — a pool created directly through the factory exists unpriced until a creator initializes it; listers create and price in one call.
tick on a tickless (STABLE) pool is a measurement of where the price sits, nothing more — the pool holds nothing at it. Never mint against a tick read from a STABLE pool.
feeInfo() is backward-looking on dynamic pools: it is the fee the last swap charged. For real quotes, use the Quoter. Fees are in hundredths of a bip and can range up to 999,999 — the units, the splits, and how to work out what a trade actually paid are on Fees.
feeToken() names the fee coin: Paid means each trade pays its fee in the token it sells; Token0 / Token1 mean every fee is taken in that slot’s token — from the output side when trading the other way. Fee growth and protocol fees then accrue on that side only.
tickSpacing is mutable on CL pools (governance), fixed on CP, 0 on STABLE.
liquidity() is in-range liquidity on CL — unrelated to the total across all ticks.

Positions and `resolveTicks`

Pool-level positions are keyed keccak256(owner, tickLower, tickUpper). But some pool types override the range: CP pins every position to the spacing-aligned full range; STABLE has exactly one range and ignores the arguments. Before computing a key, ask the pool:

function resolveTicks(int24 tickLower, int24 tickUpper) external view returns (int24, int24);

Compute the key from what the pool settled on, or you will read an empty position and conclude — wrongly — that nothing is owed. The emitted Mint/Burn/Collect events always carry the resolved range.

Tick data for routing engines

The tick tree indexes by the tick itself, not tick / tickSpacing — that is what lets governance retune spacing on a live pool without moving a stored bit:

word = tick >> 8        // arithmetic shift: floors correctly for negative ticks

tickBitmap(int16 word) returns the leaf word; tickTreeRoot() the top. The TickLens walks it for you: getPopulatedTicksInWord(pool, word) returns exact-sized (tick, liquidityNet, liquidityGross) arrays, and wordOf(tick) computes the word — no spacing argument. CL and CP only; a STABLE pool’s whole depth sits at one price and is liquidity(). STABLE-only reads: curveReserve0() / curveReserve1() — the curve’s pricing reserves, deliberately not the pool’s balances (uncollected fees sit alongside), plus amplificationX100() and amplificationRamping().

Get Started

Exchange

Earn

Bridge

Launchpad

Raise

Points

Developers

Pool identity

Listing a pool

Before offering pool creation in a UI

Pool types are an open set

Address derivation

Reading a pool

Positions and `resolveTicks`

Tick data for routing engines

​Pool identity

​Listing a pool

​Before offering pool creation in a UI

​Pool types are an open set

​Address derivation

​Reading a pool

​Positions and resolveTicks

​Tick data for routing engines

Pool identity

Listing a pool

Before offering pool creation in a UI

Pool types are an open set

Address derivation

Reading a pool

Positions and `resolveTicks`

Tick data for routing engines