SDK reference

CalamariClient#

new CalamariClient({ publicClient, walletClient? })

Generic over the chain, inferred from publicClient. Addresses resolve from its chain id. Throws ChainMismatchError when the two clients disagree.

readonly publicClient;
readonly walletClient;
readonly addresses;   // CalamariAddresses for this chain

Reads#

Method	Returns
`getPoolState(poolId, blockNumber?)`	`PoolState`
`isPoolInitialized(poolId)`	`boolean`

Quotes#

Method	Returns
`quoteExactInputSingle(pool, zeroForOne, amountIn)`	`SwapQuote`
`quoteExactOutputSingle(pool, zeroForOne, amountOut)`	`SwapQuote`
`quoteExactInput(route, amountIn)`	`SwapQuote`
`quoteExactOutput(route, amountOut)`	`SwapQuote`

All four static-call the Quoter, which simulates rather than computing — so they include hook effects, cost more than a plain read, and can revert for real reasons.

Swaps#

Method
`prepareSwapExactInSingle(pool, zeroForOne, amountIn, options?)`
`prepareSwapExactOutSingle(pool, zeroForOne, amountOut, options?)`
`prepareSwapExactIn(route, amountIn, options?)`
`prepareSwapExactOut(route, amountOut, options?)`

All return PreparedTransaction[].

Liquidity#

Method
`prepareCreatePool(pool, sqrtPriceX96)`
`prepareCreatePoolUnchecked(pool, sqrtPriceX96)`
`prepareMintPosition(pool, options)`
`prepareIncreaseLiquidity(pool, tokenId, options)`
`prepareDecreaseLiquidity(pool, tokenId, options)`
`prepareBurnPosition(pool, tokenId, options)`

Approvals#

Method
`spenderFor(flow)` — `"swap"` or `"liquidity"`
`prepareApprovals({ token, flow, amount, owner })`
`prepareErc20Approve(token, amount?)`
`preparePermit2Approve(token, flow, amount, expiration?)`

Pool keys#

createPoolKey({ currencyA, currencyB, fee, tickSpacing, hooks? }): PoolKey
poolId(key): Hex
createRoute(currencyIn, pools): Route
encodeRouteToPath(route): PathKey[]
sortsBefore(a, b): boolean
isNative(currency): boolean
opposite(key, currencyIn): Address

Types#

interface PoolKey {
  currency0: Address; currency1: Address;
  fee: number; tickSpacing: number; hooks: Address;
}

interface PoolState {
  poolId: Hex; sqrtPriceX96: bigint; tick: number;
  protocolFee: number; lpFee: number; liquidity: bigint;
}

interface SwapQuote { amountIn: bigint; amountOut: bigint; gasEstimate: bigint }

interface SwapOptions { slippageBps?: number; deadline?: bigint; hookData?: Hex }

interface LiquidityOptions { deadline?: bigint; hookData?: Hex }

interface MintOptions extends LiquidityOptions {
  tickLower: number; tickUpper: number; liquidity: bigint;
  amount0Max: bigint; amount1Max: bigint; recipient: Address;
}

interface PreparedTransaction {
  to: Address; data: Hex; value: bigint; description: string;
}

Constants#

Export	Value
`NATIVE`	Zero address — the native currency
`DYNAMIC_FEE_FLAG`	`0x800000`
`MAX_UINT160`	Default ERC-20 approval ceiling
`MAX_UINT48`	A Permit2 expiry that never lapses
`MSG_SENDER`, `ADDRESS_THIS`	Recipient sentinels in encoded actions
`NO_HOP_PRICE`	No per-hop price bound

Lower-level exports#

For encoding the SDK does not wrap:

import { Planner, Actions, Commands, V4_SWAP, encodeCommands } from "@calamari-dex/sdk";

Actions is generated from Actions.sol and Commands covers the router's command bytes. Planner builds an action list the way the client's own prepare methods do.

ABIs#

import {
  poolManagerAbi, positionManagerAbi, universalRouterAbi,
  quoterAbi, stateViewAbi, permit2Abi, erc20Abi, weth9Abi,
} from "@calamari-dex/sdk";

Generated from the deployed artifacts, so they cannot drift from what is on chain.

Addresses#

import { inkMainnet, inkSepolia, anvil } from "@calamari-dex/sdk";

Frozen CalamariAddresses objects, generated from deployments/*.json. positionDescriptor and router are optional — not every chain has them.