Types

Every type is exported from the package root.

State#

`BondingCurveState`#

interface BondingCurveState {
  realBaseReserves: bigint;     // tokens still for sale
  realQuoteReserves: bigint;    // quote actually collected
  virtualBaseReserves: bigint;  // sets the price curve's shape
  virtualQuoteReserves: bigint;
}

`CurveInfo`#

interface CurveInfo {
  address: Address;
  token: Address;
  quoteToken: Address;
  isNativeQuote: boolean;   // quoteToken === zeroAddress
  factory: Address;
  hook: Address;
  raiseAmount: bigint;
  migrated: boolean;
  poolSeeded: boolean;
  state: BondingCurveState;
  progressBps: number;      // 0–10000; reaches 10000 only once migrated
}

`FactoryConfig`#

interface FactoryConfig {
  address: Address;
  owner: Address;
  platformFeeWallet: Address;
  platformFeeBps: bigint;
  feeSharePercent: bigint;   // creator's cut of platformFeeBps, 0–100
  feeShareImpl: Address;
  hookAddress: Address;
  poolManager: Address;
  curveBeacon: Address;
  paused: boolean;           // blocks new launches; curves keep trading
  totalTokensLaunched: bigint;
}

`PoolKey`#

interface PoolKey {
  currency0: Address;   // Calamari orders by address — either side may be the base
  currency1: Address;
  fee: number;          // DYNAMIC_FEE_FLAG, not a rate
  tickSpacing: number;  // 1
  hooks: Address;
}

`QuoteCurrency`#

interface QuoteCurrency {
  address: Address;   // zeroAddress means native ETH
  maxRaise: bigint;   // largest targetRaise permitted, in this asset's units
}

Launching#

`LaunchTokenArgs`#

interface LaunchTokenArgs {
  name: string;
  symbol: string;
  uri: string;                              // ipfs://…
  targetRaise: bigint;
  quoteToken: Address;                      // zeroAddress = native ETH
  salt?: Hex;                               // random if omitted
  feeShareConfig?: readonly FeeShareEntry[];
}

`FeeShareEntry`#

interface FeeShareEntry {
  destination: Address;   // must not be zero
  shareBps: number;       // entries must total 10000
}

`LaunchResult` and `LaunchedToken`#

interface LaunchedToken { token: Address; curve: Address }
interface TxResult      { hash: Hash }
interface LaunchResult extends TxResult, LaunchedToken {}

Trading#

`BuyQuote`#

interface BuyQuote {
  baseAmountOut: bigint;    // tokens received
  quoteAmountIn: bigint;    // gross spent, fee included
  feeAmount: bigint;        // platform fee inside quoteAmountIn
  refund: bigint;           // returned when the reserve cannot absorb it all
  completesRaise: boolean;  // this buy migrates the curve
}

`SellQuote`#

interface SellQuote {
  quoteAmountOut: bigint;   // after the fee
  feeAmount: bigint;
}

`SlippageOptions`#

interface SlippageOptions {
  slippageBps?: number;  // default 100 (1%); 0 requires the exact quote
}

`VerifyOptions`#

interface VerifyOptions {
  verify?: boolean;  // default true — check the curve against the registry
}

Fees#

`ClaimableFees`#

interface ClaimableFees {
  claimable: bigint;         // credited to this account, withdrawable now
  hookAccruedGross: bigint;  // the curve's un-swept accrual, gross
  needsSweep: boolean;       // hookAccruedGross > 0
}

Unsigned transactions#

`PreparedTransaction`#

interface PreparedTransaction {
  to: Address;
  data: Hex;
  value: bigint;        // 0n for calls that send none
  description: string;  // for a confirmation UI
}

`PreparedLaunch`#

interface PreparedLaunch {
  transactions: PreparedTransaction[];
  salt: Hex;
}

`AccountOption` and `LaunchBuyOptions`#

interface AccountOption    { account?: Address }
interface LaunchBuyOptions { minAmountOut?: bigint }