Skip to main content
Public pool mappings let wallets, routers, market makers, and LP tools reconstruct state and verify finalization. Trade size, route, price movement, position range, and timing remain observable.

​
Public mappings

The program exposes the following public mappings.

​
Market state

pools stores:
  • Sorted token program identifiers
  • Fee tier
  • Enabled state
  • Wrapper and underlying token relationships
slots stores:
  • Current tick
  • Tick spacing
  • Current square-root price
  • Protocol-fee setting
  • Active liquidity
  • Global fee growth for both tokens
  • Maximum liquidity per tick
  • Accrued protocol fees
  • Nearest initialized ticks above and below
ticks stores, for each initialized boundary:
  • Pool identifier
  • Net and gross liquidity
  • Tick index
  • Fee growth outside the tick
  • Previous and next initialized ticks
initialized_pools, tick_spacings, fee_tiers, and fee_to_tick_spacing expose pool and configuration availability.

​
Position state

positions stores a public row keyed by token_id. The row contains:
  • Pool
  • Lower and upper ticks
  • Liquidity
  • Last fee-growth checkpoints
  • Owed amounts for both tokens
The mapping does not contain the LP wallet address. Ownership is carried by the encrypted PositionNFT. The token ID still gives observers a stable pseudonymous handle for the position. Mint, increase, and decrease return the token ID as a public output. Burn also returns the token ID and removes the position row. A public observer can therefore follow a position’s economic lifecycle without learning the record owner directly from this program.

​
Pending swap state

swap_outputs stores a public SwapOutput until claim. It includes:
  • Public confidential recipient address
  • Public confidential caller address
  • Input and output token identifiers
  • Exact output amount
  • Exact unspent input amount
  • Up to two additional input-token and remainder slots for multi-hop execution
The claim transition repeats these values as public inputs and removes the mapping entry after successful validation. Removal changes current state, but it does not erase the transaction from chain history.

​
Control state

The public control mappings expose:
  • Current and pending admin
  • Used confidential addresses through used_blinded_addresses
  • Registered token decimals
  • Whether pool creation is open
  • Global pause state
  • Token eligibility for pool creation
  • Token pause state
  • Pair pause state
  • Position freeze state and its current stored block height
An operator that needs a durable administrative history should archive state changes. pending_admin, swap_outputs, positions, and frozen_position entries can be removed.

​
Public inputs by operation

​
Pool creation

create_pool takes public token IDs, fee, initial square-root price, tick spacing, and initial tick. It returns the pool key and self.signer as public outputs. Pool creation is not a confidential participant path. The return value explicitly exposes the creator’s signer address.

​
Mint

The full MintPositionRequest is public:
  • Pool
  • Tick range
  • Desired token amounts
  • Minimum token amounts
  • Tick insertion hints
The token program identifiers and resulting token ID are also public. The nonce and recipient are private inputs, and the PositionNFT is encrypted. Finalization publishes the resulting liquidity and owed balances through the position and pool mappings.

​
Increase liquidity

The following are public:
  • Desired token amounts
  • Minimum token amounts
  • Token program identifiers
  • Tick insertion hints
  • Returned token ID
The replacement PositionNFT and token change records are encrypted to their owners. Public position, tick, and slot state changes reveal the economic effect.

​
Decrease liquidity

The token ID, liquidity removed, and minimum amounts are public. Principal and accrued fees are credited into the public tokens_owed fields. No token transfer occurs until collect.

​
Collect

Requested amounts and token identifiers are public. The recipient is a private input, and payout records are encrypted. The position mapping shows the reduction in owed amounts.

​
Burn

The token ID is public. The signer address is not returned in the public outputs. The removal of the position mapping entry is public.

​
Single-hop swap

The public inputs include:
  • Confidential address
  • Pool
  • Direction
  • Input amount
  • Minimum output
  • Square-root price limit
  • Nonce
  • Deadline
  • Both pool token identifiers
The swap ID is a public output. Finalization exposes the exact output and remainder in swap_outputs and updates public pool and tick state.

​
Multi-hop swap

The public inputs include:
  • Confidential address
  • Endpoint token identifiers
  • Input amount and minimum output
  • Two or three pool identifiers
  • Direction and square-root price limit for every hop
  • Hop count
  • Nonce and deadline
The route is public. Each hop’s pool-state effect is public. The final output and per-hop remainders are public in the pending output mapping.

​
Claims

Claims keep the blinding factor private but take the following values publicly:
  • Confidential address
  • Swap ID
  • Output and refund token identifiers
  • Exact output and refund amounts
The resulting token records are encrypted to the signer. The public claim still reveals timing and confirms that a particular pending output was consumed.

​
Market-data consequences

Public state supports:
  • Deterministic quote simulation
  • Independent fee and liquidity accounting
  • Route validation
  • Market surveillance based on amounts and price movement
  • Public verification of pause and freeze controls
  • Reconciliation of protocol fees
It also creates correlation surfaces. A distinctive amount, narrow tick range, unusual route, or closely timed claim may be recognizable even when the wallet address remains confidential. Market makers should assume competitors can observe executed size and route. Institutions should assume transaction economics are public. Compliance reviewers should treat the encrypted compliance record as an attribution layer over data that is already largely public.

​
Current state is not complete history

Mappings are mutable state, not immutable event tables.
  • swap_outputs is removed after claim.
  • positions is removed after burn.
  • pending_admin is removed after acceptance.
  • frozen_position is removed on unfreeze.
Historical reconstruction requires transaction and state-diff indexing. A live mapping read alone cannot prove when prior values were set or removed. The freeze block height illustrates the distinction. While a freeze is active, the mapping records the height at which it was set. Unfreeze removes that entry. The chain transaction remains available to an indexer, but the current mapping does not retain a permanent freeze stamp.