@whetstone-research/doppler-sdk 0.0.24 → 1.0.0

package/dist/solana/index.d.ts

@@ -0,0 +1,2495 @@
+import { Address, ReadonlyUint8Array, ProgramDerivedAddress, Instruction, TransactionSigner, Rpc, GetAccountInfoApi, FixedSizeDecoder, FixedSizeEncoder, FixedSizeCodec, Encoder, Decoder, Codec, OptionOrNullable, Option } from '@solana/kit';
+import { A as AmmConfig, P as Pool, a as Position, O as OracleState, S as SwapDirection, b as SwapQuote, c as AddLiquidityQuote, R as RemoveLiquidityQuote, M as MarketCapValidationResult, d as MarketCapToCurveParamsInput, C as CurveParams, e as CurveParamsToMarketCapInput, I as InitializeConfigArgs$1, f as InitializePoolArgs, g as InitializeOracleArgs, h as SetFeesArgs, i as SetSentinelArgs, j as SetRouteArgs, T as TransferAdminArgs, k as SwapExactInArgs, l as CreatePositionArgs, m as AddLiquidityArgs, n as RemoveLiquidityArgs, o as CollectFeesArgs, p as CollectProtocolFeesArgs, q as OracleConsultArgs, Q as QuoteToNumeraireArgs, G as GetProgramAccountsRpc } from '../oracle-BSvZ6pxp.js';
+export { u as AddLiquidityEvent, N as AdminTransferredEvent, w as CollectFeesEvent, x as CollectProtocolFeesEvent, H as FeesUpdatedEvent, ab as FetchOracleConfig, a9 as FetchPositionsConfig, r as Observation, J as OracleInitializedEvent, K as OracleUpdatedEvent, ac as OracleWithAddress, U as PausedEvent, y as PoolInitializedEvent, B as PositionClosedEvent, z as PositionCreatedEvent, a8 as PositionValue, aa as PositionWithAddress, v as RemoveLiquidityEvent, L as RouteUpdatedEvent, E as SentinelErrorEvent, D as SentinelInvokedEvent, F as SentinelUpdatedEvent, W as SkimmedEvent, t as SwapEvent, s as TwapResult, V as UnpausedEvent, aj as comparePoolAndOraclePrices, a3 as consultTwap, a1 as fetchOracle, ai as fetchOraclesBatch, _ as fetchPoolPositions, X as fetchPosition, $ as fetchPositionByParams, a0 as fetchPositionsBatch, Y as fetchUserPositions, ae as filterActivePositions, ag as getOracleAddressFromPool, ah as getOracleAge, a7 as getOracleBufferStats, a5 as getOracleDeviation, a2 as getOracleForPool, a4 as getOracleSpotPrices, ad as getPositionAddressFromParams, Z as getPositionValue, a6 as isOracleStale, af as sortPositionsByShares } from '../oracle-BSvZ6pxp.js';
+
+/**
+ * Program ID for the CPMM AMM (deployed to devnet)
+ */
+declare const PROGRAM_ID: Address;
+/**
+ * Program ID for the Sentinel program (deployed to devnet)
+ */
+declare const SENTINEL_PROGRAM_ID: Address;
+/**
+ * SPL Token Program ID
+ */
+declare const TOKEN_PROGRAM_ID: Address;
+/**
+ * Metaplex Token Metadata Program ID
+ */
+declare const TOKEN_METADATA_PROGRAM_ID: Address;
+/**
+ * System Program ID
+ */
+declare const SYSTEM_PROGRAM_ID: Address;
+/** Basis points denominator (10,000 = 100%) */
+declare const BPS_DENOM = 10000n;
+/** Q64.64 fixed-point representation of 1.0 (2^64) */
+declare const Q64_ONE: bigint;
+/** Current account version */
+declare const ACCOUNT_VERSION = 1;
+/** Maximum number of programs in sentinel allowlist */
+declare const MAX_SENTINEL_ALLOWLIST$1 = 32;
+/** Maximum number of oracle observations (TWAP buffer size) */
+declare const MAX_ORACLE_OBSERVATIONS = 64;
+/** Seed for AmmConfig PDA: ['config'] */
+declare const SEED_CONFIG$1 = "config";
+/** Seed prefix for Pool PDA: ['pool', token0_mint, token1_mint] */
+declare const SEED_POOL = "pool";
+/** Seed prefix for pool authority PDA: ['authority', pool] */
+declare const SEED_AUTHORITY = "authority";
+/** Seed prefix for Position PDA: ['position', pool, owner, position_id] */
+declare const SEED_POSITION = "position";
+/** Seed prefix for OracleState PDA: ['oracle', pool] */
+declare const SEED_ORACLE = "oracle";
+/** Seed prefix for protocol position PDA: ['protocol_position', pool] */
+declare const SEED_PROTOCOL_POSITION = "protocol_position";
+/** Sentinel hook: called before swap */
+declare const SF_BEFORE_SWAP$1: number;
+/** Sentinel hook: called after swap */
+declare const SF_AFTER_SWAP$1: number;
+/** Sentinel hook: called before add liquidity */
+declare const SF_BEFORE_ADD_LIQ: number;
+/** Sentinel hook: called after add liquidity */
+declare const SF_AFTER_ADD_LIQ: number;
+/** Sentinel hook: called before remove liquidity */
+declare const SF_BEFORE_REMOVE_LIQ: number;
+/** Sentinel hook: called after remove liquidity */
+declare const SF_AFTER_REMOVE_LIQ: number;
+/** Sentinel return value indicating "no change" to fee parameter */
+declare const SENTINEL_NO_CHANGE$1 = 65535;
+/** Account is read-only (not writable, not signer) */
+declare const ACCOUNT_ROLE_READONLY = 0;
+/** Account is writable (not signer) */
+declare const ACCOUNT_ROLE_WRITABLE = 1;
+/** Account is a signer (not writable) */
+declare const ACCOUNT_ROLE_SIGNER = 2;
+/** Account is both writable and a signer */
+declare const ACCOUNT_ROLE_WRITABLE_SIGNER = 3;
+/**
+ * Anchor instruction discriminator (first 8 bytes of SHA256("global:<instruction_name>"))
+ * These are computed at build time from the instruction names.
+ */
+declare const INSTRUCTION_DISCRIMINATORS: {
+    readonly initializeConfig: Uint8Array<ArrayBuffer>;
+    readonly initializePool: Uint8Array<ArrayBuffer>;
+    readonly initializeOracle: Uint8Array<ArrayBuffer>;
+    readonly createPosition: Uint8Array<ArrayBuffer>;
+    readonly addLiquidity: Uint8Array<ArrayBuffer>;
+    readonly removeLiquidity: Uint8Array<ArrayBuffer>;
+    readonly swapExactIn: Uint8Array<ArrayBuffer>;
+    readonly collectFees: Uint8Array<ArrayBuffer>;
+    readonly collectProtocolFees: Uint8Array<ArrayBuffer>;
+    readonly closePosition: Uint8Array<ArrayBuffer>;
+    readonly oracleUpdate: Uint8Array<ArrayBuffer>;
+    readonly oracleConsult: Uint8Array<ArrayBuffer>;
+    readonly quoteToNumeraire: Uint8Array<ArrayBuffer>;
+    readonly setSentinel: Uint8Array<ArrayBuffer>;
+    readonly setFees: Uint8Array<ArrayBuffer>;
+    readonly setRoute: Uint8Array<ArrayBuffer>;
+    readonly transferAdmin: Uint8Array<ArrayBuffer>;
+    readonly pause: Uint8Array<ArrayBuffer>;
+    readonly unpause: Uint8Array<ArrayBuffer>;
+    readonly skim: Uint8Array<ArrayBuffer>;
+};
+/**
+ * Anchor account discriminator (first 8 bytes of SHA256("account:<AccountName>"))
+ */
+declare const ACCOUNT_DISCRIMINATORS: {
+    readonly AmmConfig: Uint8Array<ArrayBuffer>;
+    readonly Pool: Uint8Array<ArrayBuffer>;
+    readonly Position: Uint8Array<ArrayBuffer>;
+    readonly OracleState: Uint8Array<ArrayBuffer>;
+};
+
+/**
+ * Borsh serialization/deserialization for CPMM accounts and instructions
+ *
+ * This module provides encoding/decoding utilities for program accounts
+ * and instruction data using Borsh-compatible binary formats.
+ */
+
+/**
+ * Decode AmmConfig from raw account data (including discriminator)
+ */
+declare function decodeAmmConfig(data: ReadonlyUint8Array): AmmConfig;
+/**
+ * Decode Pool from raw account data (including discriminator)
+ */
+declare function decodePool(data: ReadonlyUint8Array): Pool;
+/**
+ * Decode Position from raw account data (including discriminator)
+ */
+declare function decodePosition(data: ReadonlyUint8Array): Position;
+/**
+ * Decode OracleState from raw account data (including discriminator)
+ */
+declare function decodeOracleState(data: ReadonlyUint8Array): OracleState;
+
+/**
+ * Sort two mints into canonical order (token0 < token1 by bytes)
+ * This is required for Pool PDA derivation and instruction ordering.
+ *
+ * @param mintA - First mint address
+ * @param mintB - Second mint address
+ * @returns Tuple of [token0, token1] in canonical order
+ * @throws Error if mints are equal
+ */
+declare function sortMints(mintA: Address, mintB: Address): [Address, Address];
+/**
+ * Check if mints are in canonical order
+ */
+declare function areMintsOrdered(mint0: Address, mint1: Address): boolean;
+/**
+ * Derive the AmmConfig PDA address
+ * Seeds: ['config']
+ */
+declare function getConfigAddress$1(programId?: Address): Promise<ProgramDerivedAddress>;
+/**
+ * Derive the Pool PDA address for a token pair
+ * Seeds: ['pool', token0_mint, token1_mint]
+ *
+ * Note: Mints will be automatically sorted if not in canonical order.
+ */
+declare function getPoolAddress(mintA: Address, mintB: Address, programId?: Address): Promise<ProgramDerivedAddress>;
+/**
+ * Derive the Pool authority PDA (vault owner)
+ * Seeds: ['authority', pool]
+ */
+declare function getPoolAuthorityAddress(pool: Address, programId?: Address): Promise<ProgramDerivedAddress>;
+/**
+ * Derive the Position PDA address
+ * Seeds: ['position', pool, owner, position_id_le_bytes]
+ */
+declare function getPositionAddress(pool: Address, owner: Address, positionId: bigint, programId?: Address): Promise<ProgramDerivedAddress>;
+/**
+ * Derive the OracleState PDA address
+ * Seeds: ['oracle', pool]
+ */
+declare function getOracleAddress(pool: Address, programId?: Address): Promise<ProgramDerivedAddress>;
+/**
+ * Derive the Protocol Position PDA address
+ * Seeds: ['protocol_position', pool]
+ */
+declare function getProtocolPositionAddress(pool: Address, programId?: Address): Promise<ProgramDerivedAddress>;
+/**
+ * Derive all PDAs needed for pool initialization
+ */
+declare function getPoolInitAddresses(mintA: Address, mintB: Address, programId?: Address): Promise<{
+    token0: Address;
+    token1: Address;
+    pool: ProgramDerivedAddress;
+    authority: ProgramDerivedAddress;
+    config: ProgramDerivedAddress;
+    protocolPosition: ProgramDerivedAddress;
+}>;
+/**
+ * Derive all PDAs needed for swap operation
+ */
+declare function getSwapAddresses(pool: Address, programId?: Address): Promise<{
+    config: ProgramDerivedAddress;
+    authority: ProgramDerivedAddress;
+    oracle: ProgramDerivedAddress;
+}>;
+/**
+ * Derive all PDAs needed for liquidity operations
+ */
+declare function getLiquidityAddresses(pool: Address, owner: Address, positionId: bigint, programId?: Address): Promise<{
+    config: ProgramDerivedAddress;
+    authority: ProgramDerivedAddress;
+    position: ProgramDerivedAddress;
+    protocolPosition: ProgramDerivedAddress;
+    oracle: ProgramDerivedAddress;
+}>;
+
+/**
+ * Derive Metaplex Token Metadata PDA for a given mint.
+ *
+ * Seeds: ['metadata', token_metadata_program_id, mint]
+ */
+declare function getMetadataAddress(mint: Address): Promise<ProgramDerivedAddress>;
+
+/**
+ * Convert a Q64.64 fixed-point number to a decimal number
+ */
+declare function q64ToNumber(q64: bigint): number;
+/**
+ * Convert a decimal number to Q64.64 fixed-point
+ */
+declare function numberToQ64(n: number): bigint;
+/**
+ * Multiply two Q64.64 numbers, returning Q64.64 result
+ */
+declare function q64Mul(a: bigint, b: bigint): bigint;
+/**
+ * Divide two Q64.64 numbers, returning Q64.64 result
+ */
+declare function q64Div(a: bigint, b: bigint): bigint;
+/**
+ * Compute spot price (reserve1/reserve0) as Q64.64
+ * Price of token0 denominated in token1
+ */
+declare function computePrice0Q64(reserve0: bigint, reserve1: bigint): bigint;
+/**
+ * Compute spot price (reserve0/reserve1) as Q64.64
+ * Price of token1 denominated in token0
+ */
+declare function computePrice1Q64(reserve0: bigint, reserve1: bigint): bigint;
+/**
+ * Integer square root (floor)
+ */
+declare function isqrt(n: bigint): bigint;
+/**
+ * Ceiling division: ceil(a / b)
+ */
+declare function ceilDiv(a: bigint, b: bigint): bigint;
+/**
+ * Minimum of two bigints
+ */
+declare function minBigInt(a: bigint, b: bigint): bigint;
+/**
+ * Maximum of two bigints
+ */
+declare function maxBigInt(a: bigint, b: bigint): bigint;
+/**
+ * Convert a ratio of two bigints to a decimal number using Q64.64 precision
+ */
+declare function ratioToNumber(numerator: bigint, denominator: bigint): number;
+/**
+ * Calculate swap output and fees for exact input amount
+ *
+ * Fee calculation (from spec):
+ * - fee_total = floor(amount_in * fee_bps / 10_000)
+ * - fee_dist = floor(fee_total * split_bps / 10_000)
+ * - fee_comp = fee_total - fee_dist
+ * - amount_in_eff = amount_in - fee_total
+ *
+ * CPMM output:
+ * - amount_out = floor(amount_in_eff * reserve_out / (reserve_in + amount_in_eff))
+ */
+declare function getSwapQuote(pool: Pool, amountIn: bigint, direction: SwapDirection): SwapQuote;
+/**
+ * Calculate input amount needed for exact output (reverse quote)
+ */
+declare function getSwapQuoteExactOut(pool: Pool, amountOut: bigint, direction: SwapDirection): {
+    amountIn: bigint;
+    feeTotal: bigint;
+};
+/**
+ * Calculate shares and actual amounts for adding liquidity
+ *
+ * From spec:
+ * - If initial: shares = floor_sqrt(amount0 * amount1)
+ * - Else: shares = min(amount0 * totalShares / reserve0, amount1 * totalShares / reserve1)
+ */
+declare function getAddLiquidityQuote(pool: Pool, amount0Max: bigint, amount1Max: bigint): AddLiquidityQuote;
+/**
+ * Calculate token amounts for removing liquidity
+ *
+ * From spec:
+ * - amount0 = shares * reserve0 / totalShares
+ * - amount1 = shares * reserve1 / totalShares
+ */
+declare function getRemoveLiquidityQuote(pool: Pool, sharesIn: bigint): RemoveLiquidityQuote;
+/**
+ * Calculate accrued fees for a position
+ *
+ * From spec:
+ * - delta = pool.fee_growth_global - position.fee_growth_last
+ * - owed_inc = floor(position.shares * delta / 2^64)
+ */
+declare function calculateAccruedFees(shares: bigint, feeGrowthLastQ64: bigint, feeGrowthGlobalQ64: bigint): bigint;
+/**
+ * Calculate pending fees for a position (both tokens)
+ */
+declare function getPendingFees(pool: Pool, position: {
+    shares: bigint;
+    feeGrowthLast0Q64: bigint;
+    feeGrowthLast1Q64: bigint;
+    feeOwed0: bigint;
+    feeOwed1: bigint;
+}): {
+    pending0: bigint;
+    pending1: bigint;
+};
+/**
+ * Calculate spot price of token0 in terms of token1
+ */
+declare function getSpotPrice0(pool: Pool): number;
+/**
+ * Calculate spot price of token1 in terms of token0
+ */
+declare function getSpotPrice1(pool: Pool): number;
+/**
+ * Calculate k (constant product invariant)
+ */
+declare function getK(pool: Pool): bigint;
+/**
+ * Calculate pool TVL in terms of one token
+ * @param pool Pool data
+ * @param side 0 = denominate in token0, 1 = denominate in token1
+ */
+declare function getTvl(pool: Pool, side?: 0 | 1): bigint;
+/**
+ * Calculate TWAP price from oracle observations
+ *
+ * TWAP = (cumulative_end - cumulative_start) / (timestamp_end - timestamp_start)
+ */
+declare function calculateTwap(cumulativeStart: bigint, cumulativeEnd: bigint, timestampStart: number, timestampEnd: number): bigint;
+/**
+ * Calculate TWAP as a decimal number
+ */
+declare function calculateTwapNumber(cumulativeStart: bigint, cumulativeEnd: bigint, timestampStart: number, timestampEnd: number): number;
+
+/**
+ * Market cap conversion utilities for Solana token launches.
+ *
+ * Converts between human-readable market cap values (USD) and the raw
+ * curve parameters used by the initializer program.
+ *
+ * For an XYK bonding curve the marginal spot price at any point is:
+ *
+ *   spotPrice (quote/base, raw units) = (quoteReserve + curveVirtualQuote)
+ *                                     / (baseReserve  + curveVirtualBase)
+ *
+ * At launch open (quoteReserve = 0, baseReserve = baseForCurve):
+ *
+ *   spotPrice = curveVirtualQuote / (baseForCurve + curveVirtualBase)
+ *
+ * Adjusted for decimals and numeraire price:
+ *
+ *   spotPriceUSD = spotPrice * 10^(baseDecimals - quoteDecimals) * numerairePriceUSD
+ *
+ * Market cap (FDV) is then:
+ *
+ *   marketCap = spotPriceUSD * (baseTotalSupply / 10^baseDecimals)
+ */
+
+/**
+ * Convert a market cap (USD) and total supply to a per-token price (USD).
+ *
+ * @example
+ * // $1M market cap, 1B tokens with 6 decimals
+ * marketCapToTokenPrice(1_000_000, 1_000_000_000n * 10n**6n, 6)
+ * // => 0.001
+ */
+declare function marketCapToTokenPrice(marketCapUSD: number, baseTotalSupply: bigint, baseDecimals: number): number;
+/**
+ * Validate market cap parameters and return warnings for unusual values.
+ * Does not throw — callers can decide whether to surface warnings to users.
+ *
+ * @example
+ * const { valid, warnings } = validateMarketCapParameters(500, supply, 6);
+ * if (!valid) console.warn(warnings);
+ */
+declare function validateMarketCapParameters(marketCapUSD: number, baseTotalSupply: bigint, baseDecimals: number): MarketCapValidationResult;
+/**
+ * Convert a market cap range (USD) to XYK curve virtual reserve parameters.
+ *
+ * Returns `{ curveVirtualBase, curveVirtualQuote }` for both the start (open)
+ * and end (graduation) prices, ready to pass into `InitializeLaunchArgs`.
+ *
+ * `baseForCurve` is the number of base tokens allocated to the curve vault
+ * (baseTotalSupply - baseForDistribution - baseForLiquidity). It determines
+ * the correct initial spot price alongside the virtual reserves.
+ *
+ * `virtualBase` defaults to `baseForCurve`. A larger value gives finer price
+ * granularity at the cost of a proportionally larger `curveVirtualQuote`.
+ *
+ * @example
+ * const totalSupply = 1_000_000_000n * 10n ** 6n;
+ * const { start, end } = marketCapToCurveParams({
+ *   startMarketCapUSD: 100_000,
+ *   endMarketCapUSD:   5_000_000,
+ *   baseTotalSupply:   totalSupply,
+ *   baseForCurve:      totalSupply,   // no distribution or liquidity allocation
+ *   baseDecimals:      6,
+ *   quoteDecimals:     9,             // SOL
+ *   numerairePriceUSD: 150,
+ * });
+ * // Use start.curveVirtualBase / start.curveVirtualQuote in InitializeLaunchArgs
+ */
+declare function marketCapToCurveParams(input: MarketCapToCurveParamsInput): {
+    start: CurveParams;
+    end: CurveParams;
+};
+/**
+ * Convert a single market cap (USD) to XYK curve virtual reserve parameters.
+ * Use `marketCapToCurveParams` for a full start/end range.
+ */
+declare function marketCapToSingleCurveParams(marketCapUSD: number, baseTotalSupply: bigint, baseForCurve: bigint, baseDecimals: number, quoteDecimals: number, numerairePriceUSD: number, virtualBase?: bigint): CurveParams;
+/**
+ * Derive the current market cap (USD) from live XYK curve state.
+ *
+ * Pass the virtual reserves from the `Launch` account and the current token
+ * vault balances (`baseReserve`, `quoteReserve`) to get the live spot price.
+ *
+ * @example
+ * const launch = await fetchLaunch(connection, launchAddress);
+ * const [baseVaultBalance, quoteVaultBalance] = await Promise.all([
+ *   getTokenAccountBalance(connection, launch.baseVault),
+ *   getTokenAccountBalance(connection, launch.quoteVault),
+ * ]);
+ * // baseReserve is the curve-available portion, excluding reserved allocations
+ * const baseReserve = baseVaultBalance - launch.baseForDistribution - launch.baseForLiquidity;
+ * const mcap = curveParamsToMarketCap({
+ *   curveVirtualBase:  launch.curveVirtualBase,
+ *   curveVirtualQuote: launch.curveVirtualQuote,
+ *   baseReserve,
+ *   quoteReserve:      quoteVaultBalance,
+ *   baseTotalSupply:   launch.baseTotalSupply,
+ *   baseDecimals:      6,
+ *   quoteDecimals:     9,
+ *   numerairePriceUSD: 150,
+ * });
+ */
+declare function curveParamsToMarketCap(input: CurveParamsToMarketCapInput): number;
+
+/**
+ * CPMM program error codes
+ *
+ * These correspond to the CpmmError enum in the on-chain program.
+ * Anchor errors start at 6000 (0x1770).
+ */
+declare enum CpmmErrorCode {
+    /** Unauthorized - caller lacks required authority */
+    Unauthorized = 6000,
+    /** Pool is currently locked (reentrancy protection) */
+    PoolLocked = 6001,
+    /** Invalid fee value (exceeds max or invalid range) */
+    InvalidFee = 6002,
+    /** Invalid fee split value (exceeds max or invalid range) */
+    InvalidFeeSplit = 6003,
+    /** Invalid swap direction (must be 0 or 1) */
+    InvalidDirection = 6004,
+    /** Insufficient liquidity for operation */
+    InsufficientLiquidity = 6005,
+    /** Output amount less than minimum (slippage exceeded) */
+    SlippageExceeded = 6006,
+    /** Math operation overflowed */
+    MathOverflow = 6007,
+    /** Mints not in canonical order */
+    InvalidMintOrder = 6008,
+    /** Cannot create pool with identical tokens */
+    SameMintPair = 6009,
+    /** Vault account invalid or mismatch */
+    InvalidVault = 6010,
+    /** Position account invalid or mismatch */
+    InvalidPosition = 6011,
+    /** Cannot close position with non-zero shares or fees */
+    PositionNotEmpty = 6012,
+    /** Invalid route configuration */
+    InvalidRoute = 6013,
+    /** Not supported in v0.1 */
+    NotSupportedInV0_1 = 6014,
+    /** Oracle not initialized for this pool */
+    OracleNotInitialized = 6015,
+    /** Zero shares out */
+    ZeroSharesOut = 6016,
+    /** Sentinel program rejected the operation */
+    SentinelRejected = 6017,
+    /** Sentinel CPI call failed */
+    SentinelCpiFailed = 6018,
+    /** Sentinel program account not provided */
+    SentinelProgramNotProvided = 6019,
+    /** Sentinel program account is not executable */
+    SentinelProgramNotExecutable = 6020,
+    /** Sentinel return data missing or wrong program id */
+    SentinelReturnDataMissing = 6021,
+    /** Sentinel return data invalid length or could not deserialize */
+    SentinelReturnDataInvalid = 6022,
+    /** Sentinel program not in allowlist */
+    SentinelNotAllowlisted = 6023,
+    /** Pool has zero shares (no liquidity) */
+    TotalSharesZero = 6024,
+    /** Amount cannot be zero */
+    AmountZero = 6025,
+    /** Pool is paused by admin */
+    Paused = 6026,
+    /** Internal invariant violation */
+    InvariantViolation = 6027,
+    /** Invalid mint address */
+    InvalidMint = 6028,
+    /** Invalid input parameter */
+    InvalidInput = 6029,
+    /** Reentrancy detected */
+    Reentrancy = 6030
+}
+/**
+ * Human-readable error messages
+ */
+declare const CPMM_ERROR_MESSAGES: Record<CpmmErrorCode, string>;
+/**
+ * Custom error class for CPMM program errors
+ */
+declare class CpmmError extends Error {
+    readonly code: CpmmErrorCode;
+    readonly logs?: string[] | undefined;
+    constructor(code: CpmmErrorCode, logs?: string[] | undefined);
+    /**
+     * Get the error code name
+     */
+    get codeName(): string;
+}
+/**
+ * Parse error code from transaction logs
+ */
+declare function parseErrorFromLogs(logs: string[]): CpmmError | null;
+/**
+ * Check if an error code is a CPMM error
+ */
+declare function isCpmmError(code: number): code is CpmmErrorCode;
+/**
+ * Get error message from code
+ */
+declare function getErrorMessage(code: number): string;
+
+/**
+ * Accounts required for initialize_config instruction
+ */
+interface InitializeConfigAccounts$1 {
+    /** AmmConfig account to initialize (writable, PDA: ['config']) */
+    config: Address;
+    /** Payer for account creation (writable, signer) */
+    payer: Address;
+    /** System program */
+    systemProgram?: Address;
+}
+/**
+ * Create an initialize_config instruction
+ *
+ * Initializes the global AMM configuration singleton. This should only be called once
+ * per deployment to set up the admin, fees, and allowlist.
+ *
+ * @param accounts - Required accounts for initialization
+ * @param args - Instruction arguments (admin, numeraireMint, fees, allowlist)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to initialize the config
+ *
+ * @example
+ * ```ts
+ * const [configAddress] = await getConfigAddress();
+ * const ix = createInitializeConfigInstruction(
+ *   {
+ *     config: configAddress,
+ *     payer: payerPublicKey,
+ *   },
+ *   {
+ *     admin: adminPublicKey,
+ *     numeraireMint: usdcMint,
+ *     maxSwapFeeBps: 100,
+ *     maxFeeSplitBps: 5000,
+ *     maxRouteHops: 3,
+ *     protocolFeeEnabled: true,
+ *     protocolFeeBps: 500,
+ *     sentinelAllowlist: [],
+ *   }
+ * );
+ * ```
+ */
+declare function createInitializeConfigInstruction$1(accounts: InitializeConfigAccounts$1, args: InitializeConfigArgs$1, programId?: Address): Instruction;
+
+/**
+ * Accounts required for initialize_pool instruction
+ */
+interface InitializePoolAccounts {
+    /** AmmConfig account (read-only) */
+    config: Address;
+    /** Pool account to initialize (writable, PDA: ['pool', token0_mint, token1_mint]) */
+    pool: Address;
+    /** Protocol position account (writable, PDA: ['protocol_position', pool]) */
+    protocolPosition: Address;
+    /** Pool authority PDA (read-only, PDA: ['authority', pool]) */
+    authority: Address;
+    /** Vault for token0 (writable signer - pass TransactionSigner to include signer in instruction) */
+    vault0: Address | TransactionSigner;
+    /** Vault for token1 (writable signer - pass TransactionSigner to include signer in instruction) */
+    vault1: Address | TransactionSigner;
+    /** Token0 mint (read-only, must be lexicographically smaller) */
+    token0Mint: Address;
+    /** Token1 mint (read-only, must be lexicographically larger) */
+    token1Mint: Address;
+    /** Payer for account creation (writable signer - pass TransactionSigner to include signer in instruction) */
+    payer: Address | TransactionSigner;
+    /** SPL Token program */
+    tokenProgram?: Address;
+    /** System program */
+    systemProgram?: Address;
+    /** Rent sysvar */
+    rent: Address;
+}
+/**
+ * Create an initialize_pool instruction
+ *
+ * Initializes a new trading pool for a token pair. The mints must be in canonical order
+ * (token0 < token1 by bytes). Use sortMints() to ensure proper ordering.
+ *
+ * @param accounts - Required accounts for pool initialization
+ * @param args - Instruction arguments (mintA, mintB, fees, liquidityMeasureSide, numeraire override)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to initialize the pool
+ *
+ * @example
+ * ```ts
+ * const addresses = await getPoolInitAddresses(mintA, mintB);
+ * const ix = createInitializePoolInstruction(
+ *   {
+ *     config: addresses.config[0],
+ *     pool: addresses.pool[0],
+ *     protocolPosition: addresses.protocolPosition[0],
+ *     authority: addresses.authority[0],
+ *     vault0: vault0Keypair.publicKey,
+ *     vault1: vault1Keypair.publicKey,
+ *     token0Mint: addresses.token0,
+ *     token1Mint: addresses.token1,
+ *     payer: payerPublicKey,
+ *     rent: SYSVAR_RENT_PUBKEY,
+ *   },
+ *   {
+ *     mintA: mintA,
+ *     mintB: mintB,
+ *     initialSwapFeeBps: 30,
+ *     initialFeeSplitBps: 5000,
+ *     liquidityMeasureSide: 0,
+ *     numeraireMintOverride: null,
+ *   }
+ * );
+ * ```
+ */
+declare function createInitializePoolInstruction(accounts: InitializePoolAccounts, args: InitializePoolArgs, programId?: Address): Instruction;
+
+/**
+ * Accounts required for initialize_oracle instruction
+ */
+interface InitializeOracleAccounts {
+    /** AmmConfig account (read-only) */
+    config: Address;
+    /** Pool account (read-only) */
+    pool: Address;
+    /** Oracle PDA to initialize (writable, will be created) */
+    oracle: Address;
+    /** Admin authority (signer, must match config.admin) */
+    admin: Address;
+    /** Payer for account creation (signer, writable) */
+    payer: Address;
+    /** System program */
+    systemProgram?: Address;
+}
+/**
+ * Create an initialize_oracle instruction
+ *
+ * Initializes a TWAP oracle for a pool. The oracle tracks price movements
+ * and stores observations for time-weighted average price calculations.
+ *
+ * @param accounts - Required accounts for the instruction
+ * @param args - Instruction arguments (maxPriceChangeRatioQ64, observationIntervalSec, numObservations)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to initialize the oracle
+ *
+ * @example
+ * ```ts
+ * const ix = createInitializeOracleInstruction(
+ *   {
+ *     config: configAddress,
+ *     pool: poolAddress,
+ *     oracle: oracleAddress,
+ *     admin: adminPublicKey,
+ *     payer: payerPublicKey,
+ *   },
+ *   {
+ *     maxPriceChangeRatioQ64: 1n << 64n, // 100% max change per slot
+ *     observationIntervalSec: 60, // 1 minute between observations
+ *     numObservations: 64, // Must be MAX_ORACLE_OBSERVATIONS
+ *   }
+ * );
+ * ```
+ */
+declare function createInitializeOracleInstruction(accounts: InitializeOracleAccounts, args: InitializeOracleArgs, programId?: Address): Instruction;
+
+/**
+ * Accounts required for set_fees instruction
+ */
+interface SetFeesAccounts {
+    /** AmmConfig account (read-only) */
+    config: Address;
+    /** Pool account (writable) */
+    pool: Address;
+    /** Admin authority (signer, must match config.admin) */
+    admin: Address;
+}
+/**
+ * Create a set_fees instruction
+ *
+ * Admin instruction to update the swap fee and fee split on a pool.
+ * Fees will be clamped to the config's max values.
+ *
+ * @param accounts - Required accounts for setting fees
+ * @param args - Instruction arguments (swapFeeBps, feeSplitBps)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to set fees
+ *
+ * @example
+ * ```ts
+ * const ix = createSetFeesInstruction(
+ *   {
+ *     config: configAddress,
+ *     pool: poolAddress,
+ *     admin: adminPublicKey,
+ *   },
+ *   {
+ *     swapFeeBps: 30,    // 0.30% swap fee
+ *     feeSplitBps: 5000, // 50% of fees go to LPs (distributable)
+ *   }
+ * );
+ * ```
+ */
+declare function createSetFeesInstruction(accounts: SetFeesAccounts, args: SetFeesArgs, programId?: Address): Instruction;
+
+/**
+ * Accounts required for set_sentinel instruction
+ */
+interface SetSentinelAccounts {
+    /** AmmConfig account (read-only) */
+    config: Address;
+    /** Pool account (writable) */
+    pool: Address;
+    /** Admin authority (signer, must match config.admin) */
+    admin: Address;
+}
+/**
+ * Create a set_sentinel instruction
+ *
+ * Admin instruction to configure a sentinel (hook) program on a pool.
+ * The sentinel program must be in the config's allowlist (if the allowlist is non-empty).
+ * Use Pubkey::default() to disable the sentinel.
+ *
+ * @param accounts - Required accounts for setting sentinel
+ * @param args - Instruction arguments (sentinelProgram, sentinelFlags)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to set sentinel
+ *
+ * @example
+ * ```ts
+ * import { SF_BEFORE_SWAP, SF_AFTER_SWAP } from '@cpmm/sdk';
+ *
+ * const ix = createSetSentinelInstruction(
+ *   {
+ *     config: configAddress,
+ *     pool: poolAddress,
+ *     admin: adminPublicKey,
+ *   },
+ *   {
+ *     sentinelProgram: sentinelProgramId,
+ *     sentinelFlags: SF_BEFORE_SWAP | SF_AFTER_SWAP, // Enable both hooks
+ *   }
+ * );
+ * ```
+ */
+declare function createSetSentinelInstruction(accounts: SetSentinelAccounts, args: SetSentinelArgs, programId?: Address): Instruction;
+
+/**
+ * Accounts required for set_route instruction
+ */
+interface SetRouteAccounts {
+    /** AmmConfig account (read-only) */
+    config: Address;
+    /** Pool account (writable) */
+    pool: Address;
+    /** Next pool in routing chain (optional, required if setting a route) */
+    nextPool?: Address;
+    /** Admin authority (signer, must match config.admin) */
+    admin: Address;
+}
+/**
+ * Create a set_route instruction
+ *
+ * Admin instruction to configure routing for a pool. This allows multi-hop swaps
+ * through a chain of pools. The bridge mint must exist in both the current pool
+ * and the next pool.
+ *
+ * To clear routing, pass Pubkey::default() for both routeNextPool and routeBridgeMint.
+ *
+ * @param accounts - Required accounts for setting route
+ * @param args - Instruction arguments (routeNextPool, routeBridgeMint)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to set route
+ *
+ * @example
+ * ```ts
+ * // Set up routing: Pool A -> Pool B via USDC
+ * const ix = createSetRouteInstruction(
+ *   {
+ *     config: configAddress,
+ *     pool: poolAAddress,
+ *     nextPool: poolBAddress,
+ *     admin: adminPublicKey,
+ *   },
+ *   {
+ *     routeNextPool: poolBAddress,
+ *     routeBridgeMint: usdcMint, // Must be in both pools
+ *   }
+ * );
+ *
+ * // Clear routing
+ * const clearIx = createSetRouteInstruction(
+ *   {
+ *     config: configAddress,
+ *     pool: poolAddress,
+ *     admin: adminPublicKey,
+ *   },
+ *   {
+ *     routeNextPool: address('11111111111111111111111111111111'),
+ *     routeBridgeMint: address('11111111111111111111111111111111'),
+ *   }
+ * );
+ * ```
+ */
+declare function createSetRouteInstruction(accounts: SetRouteAccounts, args: SetRouteArgs, programId?: Address): Instruction;
+
+/**
+ * Accounts required for pause instruction
+ */
+interface PauseAccounts {
+    /** AmmConfig account (writable) */
+    config: Address;
+    /** Admin authority (signer, must match config.admin) */
+    admin: Address;
+}
+/**
+ * Create a pause instruction
+ *
+ * Admin instruction to pause all pool operations globally. When paused,
+ * swaps, liquidity additions, and liquidity removals will fail.
+ *
+ * @param accounts - Required accounts for pausing
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to pause the AMM
+ *
+ * @example
+ * ```ts
+ * const ix = createPauseInstruction({
+ *   config: configAddress,
+ *   admin: adminPublicKey,
+ * });
+ * ```
+ */
+declare function createPauseInstruction(accounts: PauseAccounts, programId?: Address): Instruction;
+
+/**
+ * Accounts required for unpause instruction
+ */
+interface UnpauseAccounts {
+    /** AmmConfig account (writable) */
+    config: Address;
+    /** Admin authority (signer, must match config.admin) */
+    admin: Address;
+}
+/**
+ * Create an unpause instruction
+ *
+ * Admin instruction to unpause all pool operations. This re-enables
+ * swaps, liquidity additions, and liquidity removals after a pause.
+ *
+ * @param accounts - Required accounts for unpausing
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to unpause the AMM
+ *
+ * @example
+ * ```ts
+ * const ix = createUnpauseInstruction({
+ *   config: configAddress,
+ *   admin: adminPublicKey,
+ * });
+ * ```
+ */
+declare function createUnpauseInstruction(accounts: UnpauseAccounts, programId?: Address): Instruction;
+
+/**
+ * Accounts required for transfer_admin instruction
+ */
+interface TransferAdminAccounts {
+    /** AmmConfig account (writable) */
+    config: Address;
+    /** Current admin authority (signer, must match config.admin) */
+    admin: Address;
+}
+/**
+ * Create a transfer_admin instruction
+ *
+ * Admin instruction to transfer administrative authority to a new address.
+ * The new admin will have full control over the AMM configuration and all pools.
+ *
+ * CAUTION: This action is irreversible. Ensure the new admin address is correct
+ * and that you have access to it before executing.
+ *
+ * @param accounts - Required accounts for transferring admin
+ * @param args - Instruction arguments (newAdmin)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to transfer admin
+ *
+ * @example
+ * ```ts
+ * const ix = createTransferAdminInstruction(
+ *   {
+ *     config: configAddress,
+ *     admin: currentAdminPublicKey,
+ *   },
+ *   {
+ *     newAdmin: newAdminPublicKey,
+ *   }
+ * );
+ * ```
+ */
+declare function createTransferAdminInstruction(accounts: TransferAdminAccounts, args: TransferAdminArgs, programId?: Address): Instruction;
+
+/**
+ * Accounts required for skim instruction
+ */
+interface SkimAccounts {
+    /** AmmConfig account (read-only) */
+    config: Address;
+    /** Pool account (read-only) */
+    pool: Address;
+    /** Admin authority (signer, must match config.admin) */
+    admin: Address;
+    /** Pool authority PDA (read-only, PDA: ['authority', pool]) */
+    authority: Address;
+    /** Token0 vault (writable) */
+    vault0: Address;
+    /** Token1 vault (writable) */
+    vault1: Address;
+    /** Token0 mint (read-only) */
+    token0Mint: Address;
+    /** Token1 mint (read-only) */
+    token1Mint: Address;
+    /** Admin's token0 ATA to receive excess (writable) */
+    adminAta0: Address;
+    /** Admin's token1 ATA to receive excess (writable) */
+    adminAta1: Address;
+    /** SPL Token program */
+    tokenProgram?: Address;
+}
+/**
+ * Create a skim instruction
+ *
+ * Admin instruction to withdraw excess tokens from pool vaults. This recovers any
+ * tokens that were accidentally sent directly to the vault accounts (outside of
+ * normal pool operations).
+ *
+ * Only withdraws tokens in excess of (reserve + unclaimed_fees). Normal pool
+ * reserves and LP fees are not affected.
+ *
+ * @param accounts - Required accounts for skimming
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to skim excess tokens
+ *
+ * @example
+ * ```ts
+ * const ix = createSkimInstruction({
+ *   config: configAddress,
+ *   pool: poolAddress,
+ *   admin: adminPublicKey,
+ *   authority: authorityAddress,
+ *   vault0: vault0Address,
+ *   vault1: vault1Address,
+ *   token0Mint: mint0,
+ *   token1Mint: mint1,
+ *   adminAta0: adminToken0Account,
+ *   adminAta1: adminToken1Account,
+ * });
+ * ```
+ */
+declare function createSkimInstruction(accounts: SkimAccounts, programId?: Address): Instruction;
+
+/**
+ * Accounts required for swap_exact_in instruction
+ */
+interface SwapExactInAccounts {
+    /** AmmConfig account (read-only) */
+    config: Address;
+    /** Pool account (writable) */
+    pool: Address;
+    /** Pool authority PDA (read-only) */
+    authority: Address;
+    /** Input token vault (writable) */
+    vaultIn: Address;
+    /** Output token vault (writable) */
+    vaultOut: Address;
+    /** Token0 mint (read-only, for transfer_checked) */
+    token0Mint: Address;
+    /** Token1 mint (read-only, for transfer_checked) */
+    token1Mint: Address;
+    /** User's input token account (writable) */
+    userIn: Address;
+    /** User's output token account (writable) */
+    userOut: Address;
+    /** User authority (signer) */
+    user: Address;
+    /** SPL Token program */
+    tokenProgram?: Address;
+    /** Oracle account (optional, required if updateOracle is true) */
+    oracle?: Address;
+    /** Optional remaining accounts (sentinel program/state, route/oracle data) */
+    remainingAccounts?: Address[];
+}
+/**
+ * Create a swap_exact_in instruction
+ *
+ * Swaps an exact input amount for a minimum output amount using the CPMM formula.
+ *
+ * @param accounts - Required accounts for the swap
+ * @param args - Instruction arguments (amountIn, minAmountOut, direction, updateOracle)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to execute the swap
+ *
+ * @example
+ * ```ts
+ * const ix = createSwapExactInInstruction(
+ *   {
+ *     config: configAddress,
+ *     pool: poolAddress,
+ *     authority: authorityAddress,
+ *     vaultIn: vault0Address,
+ *     vaultOut: vault1Address,
+ *     token0Mint: mint0,
+ *     token1Mint: mint1,
+ *     userIn: userToken0Account,
+ *     userOut: userToken1Account,
+ *     user: userPublicKey,
+ *   },
+ *   {
+ *     amountIn: 1000000n,
+ *     minAmountOut: 990000n,
+ *     direction: 0, // token0 -> token1
+ *     updateOracle: false,
+ *   }
+ * );
+ * ```
+ */
+declare function createSwapExactInInstruction(accounts: SwapExactInAccounts, args: SwapExactInArgs, programId?: Address): Instruction;
+/**
+ * Helper to create swap instruction with simplified parameters
+ */
+declare function createSwapInstruction(params: {
+    config: Address;
+    pool: Address;
+    authority: Address;
+    vault0: Address;
+    vault1: Address;
+    token0Mint: Address;
+    token1Mint: Address;
+    userToken0: Address;
+    userToken1: Address;
+    user: Address;
+    amountIn: bigint;
+    minAmountOut: bigint;
+    direction: SwapDirection;
+    oracle?: Address;
+    remainingAccounts?: Address[];
+    updateOracle?: boolean;
+    programId?: Address;
+}): Instruction;
+
+/**
+ * Accounts required for create_position instruction
+ */
+interface CreatePositionAccounts {
+    /** Pool account (read-only) */
+    pool: Address;
+    /** Position PDA to be created (writable, derived from ['position', pool, owner, position_id]) */
+    position: Address;
+    /** Owner of the position (signer) */
+    owner: Address;
+    /** Payer for rent (signer, writable) */
+    payer: Address;
+    /** System program */
+    systemProgram?: Address;
+}
+/**
+ * Create a create_position instruction
+ *
+ * Creates a new liquidity position for a pool. The position is a PDA derived from
+ * the pool, owner, and position ID. Users can have multiple positions per pool
+ * by using different position IDs.
+ *
+ * @param accounts - Required accounts for creating the position
+ * @param args - Instruction arguments (positionId)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to create a new position
+ *
+ * @example
+ * ```ts
+ * const ix = createCreatePositionInstruction(
+ *   {
+ *     pool: poolAddress,
+ *     position: positionPda,
+ *     owner: userPublicKey,
+ *     payer: userPublicKey,
+ *   },
+ *   {
+ *     positionId: 0n,
+ *   }
+ * );
+ * ```
+ */
+declare function createCreatePositionInstruction(accounts: CreatePositionAccounts, args: CreatePositionArgs, programId?: Address): Instruction;
+
+/**
+ * Accounts required for close_position instruction
+ */
+interface ClosePositionAccounts {
+    /** Pool account (read-only) */
+    pool: Address;
+    /** Position account to close (writable) */
+    position: Address;
+    /** Position owner (signer) */
+    owner: Address;
+    /** Recipient for rent lamports (writable) */
+    rentRecipient: Address;
+}
+/**
+ * Create a close_position instruction
+ *
+ * Closes an empty position account, returning the rent lamports to the recipient.
+ * The position must have zero shares and zero accrued fees to be closed.
+ *
+ * @param accounts - Required accounts for closing the position
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to close a position
+ *
+ * @example
+ * ```ts
+ * const ix = createClosePositionInstruction({
+ *   pool: poolAddress,
+ *   position: positionAddress,
+ *   owner: userPublicKey,
+ *   rentRecipient: userPublicKey,
+ * });
+ * ```
+ */
+declare function createClosePositionInstruction(accounts: ClosePositionAccounts, programId?: Address): Instruction;
+
+/**
+ * Extended AddLiquidity args that include updateOracle flag
+ * (matches the on-chain program's actual args)
+ */
+interface AddLiquidityArgsWithOracle extends AddLiquidityArgs {
+    /** Whether to update the oracle (requires oracle account) */
+    updateOracle: boolean;
+}
+/**
+ * Accounts required for add_liquidity instruction
+ */
+interface AddLiquidityAccounts {
+    /** AmmConfig account (read-only) */
+    config: Address;
+    /** Pool account (writable) */
+    pool: Address;
+    /** User's position account (writable) */
+    position: Address;
+    /** Protocol position for protocol fees (writable) */
+    protocolPosition: Address;
+    /** Position owner (signer) */
+    owner: Address;
+    /** Pool authority PDA (read-only) */
+    authority: Address;
+    /** Pool vault for token0 (writable) */
+    vault0: Address;
+    /** Pool vault for token1 (writable) */
+    vault1: Address;
+    /** Token0 mint (read-only) */
+    token0Mint: Address;
+    /** Token1 mint (read-only) */
+    token1Mint: Address;
+    /** User's token0 account (writable) */
+    user0: Address;
+    /** User's token1 account (writable) */
+    user1: Address;
+    /** SPL Token program */
+    tokenProgram?: Address;
+    /** Oracle account (optional, required if updateOracle is true) */
+    oracle?: Address;
+    /** Optional remaining accounts (sentinel program/state, route/oracle data) */
+    remainingAccounts?: Address[];
+}
+/**
+ * Create an add_liquidity instruction
+ *
+ * Adds liquidity to a pool by depositing tokens and receiving LP shares.
+ * For an empty pool (first deposit), the amount of shares is sqrt(amount0 * amount1).
+ * For subsequent deposits, shares are proportional to the smaller ratio of deposit to reserves.
+ *
+ * @param accounts - Required accounts for adding liquidity
+ * @param args - Instruction arguments (amount0Max, amount1Max, minSharesOut, updateOracle)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to add liquidity
+ *
+ * @example
+ * ```ts
+ * const ix = createAddLiquidityInstruction(
+ *   {
+ *     config: configAddress,
+ *     pool: poolAddress,
+ *     position: positionAddress,
+ *     protocolPosition: protocolPositionAddress,
+ *     owner: userPublicKey,
+ *     authority: authorityPda,
+ *     vault0: vault0Address,
+ *     vault1: vault1Address,
+ *     token0Mint: mint0,
+ *     token1Mint: mint1,
+ *     user0: userToken0Account,
+ *     user1: userToken1Account,
+ *   },
+ *   {
+ *     amount0Max: 1000000n,
+ *     amount1Max: 1000000n,
+ *     minSharesOut: 0n,
+ *     updateOracle: false,
+ *   }
+ * );
+ * ```
+ */
+declare function createAddLiquidityInstruction(accounts: AddLiquidityAccounts, args: AddLiquidityArgsWithOracle, programId?: Address): Instruction;
+
+/**
+ * Accounts required for remove_liquidity instruction
+ */
+interface RemoveLiquidityAccounts {
+    /** AmmConfig account (read-only) */
+    config: Address;
+    /** Pool account (writable) */
+    pool: Address;
+    /** User's position account (writable) */
+    position: Address;
+    /** Protocol position for protocol fees (writable) */
+    protocolPosition: Address;
+    /** Position owner (signer) */
+    owner: Address;
+    /** Pool authority PDA (read-only) */
+    authority: Address;
+    /** Pool vault for token0 (writable) */
+    vault0: Address;
+    /** Pool vault for token1 (writable) */
+    vault1: Address;
+    /** Token0 mint (read-only) */
+    token0Mint: Address;
+    /** Token1 mint (read-only) */
+    token1Mint: Address;
+    /** User's token0 account (writable) */
+    user0: Address;
+    /** User's token1 account (writable) */
+    user1: Address;
+    /** SPL Token program */
+    tokenProgram?: Address;
+    /** Oracle account (optional, required if updateOracle is true) */
+    oracle?: Address;
+    /** Optional remaining accounts (sentinel program/state, route/oracle data) */
+    remainingAccounts?: Address[];
+}
+/**
+ * Create a remove_liquidity instruction
+ *
+ * Removes liquidity from a pool by burning LP shares and receiving tokens back.
+ * The amount of tokens received is proportional to the share of the pool being withdrawn.
+ * Also accrues any pending fees to the position before withdrawal.
+ *
+ * @param accounts - Required accounts for removing liquidity
+ * @param args - Instruction arguments (sharesIn, minAmount0Out, minAmount1Out, updateOracle)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to remove liquidity
+ *
+ * @example
+ * ```ts
+ * const ix = createRemoveLiquidityInstruction(
+ *   {
+ *     config: configAddress,
+ *     pool: poolAddress,
+ *     position: positionAddress,
+ *     protocolPosition: protocolPositionAddress,
+ *     owner: userPublicKey,
+ *     authority: authorityPda,
+ *     vault0: vault0Address,
+ *     vault1: vault1Address,
+ *     token0Mint: mint0,
+ *     token1Mint: mint1,
+ *     user0: userToken0Account,
+ *     user1: userToken1Account,
+ *   },
+ *   {
+ *     sharesIn: 500000n,
+ *     minAmount0Out: 450000n,
+ *     minAmount1Out: 450000n,
+ *     updateOracle: false,
+ *   }
+ * );
+ * ```
+ */
+declare function createRemoveLiquidityInstruction(accounts: RemoveLiquidityAccounts, args: RemoveLiquidityArgs, programId?: Address): Instruction;
+
+/**
+ * Accounts required for collect_fees instruction
+ */
+interface CollectFeesAccounts {
+    /** Pool account (writable) */
+    pool: Address;
+    /** User's position account (writable) */
+    position: Address;
+    /** Position owner (signer) */
+    owner: Address;
+    /** Pool authority PDA (read-only) */
+    authority: Address;
+    /** Pool vault for token0 (writable) */
+    vault0: Address;
+    /** Pool vault for token1 (writable) */
+    vault1: Address;
+    /** Token0 mint (read-only) */
+    token0Mint: Address;
+    /** Token1 mint (read-only) */
+    token1Mint: Address;
+    /** User's token0 account (writable) */
+    user0: Address;
+    /** User's token1 account (writable) */
+    user1: Address;
+    /** SPL Token program */
+    tokenProgram?: Address;
+}
+/**
+ * Create a collect_fees instruction
+ *
+ * Collects accrued LP fees from a position. Fees are first accrued from the global
+ * fee growth, then transferred from the pool vaults to the user's token accounts.
+ * You can specify max amounts to partially collect fees.
+ *
+ * @param accounts - Required accounts for collecting fees
+ * @param args - Instruction arguments (max0, max1)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to collect fees
+ *
+ * @example
+ * ```ts
+ * // Collect all accrued fees
+ * const ix = createCollectFeesInstruction(
+ *   {
+ *     pool: poolAddress,
+ *     position: positionAddress,
+ *     owner: userPublicKey,
+ *     authority: authorityPda,
+ *     vault0: vault0Address,
+ *     vault1: vault1Address,
+ *     token0Mint: mint0,
+ *     token1Mint: mint1,
+ *     user0: userToken0Account,
+ *     user1: userToken1Account,
+ *   },
+ *   {
+ *     max0: BigInt('18446744073709551615'), // u64::MAX to collect all
+ *     max1: BigInt('18446744073709551615'),
+ *   }
+ * );
+ * ```
+ */
+declare function createCollectFeesInstruction(accounts: CollectFeesAccounts, args: CollectFeesArgs, programId?: Address): Instruction;
+/**
+ * Convenience constant for collecting all fees (u64::MAX)
+ */
+declare const MAX_FEE_AMOUNT: bigint;
+
+/**
+ * Accounts required for collect_protocol_fees instruction
+ */
+interface CollectProtocolFeesAccounts {
+    /** AmmConfig account (read-only) */
+    config: Address;
+    /** Pool account (writable) */
+    pool: Address;
+    /** Protocol position account (writable) */
+    protocolPosition: Address;
+    /** Admin authority (signer) */
+    admin: Address;
+    /** Pool authority PDA (read-only) */
+    authority: Address;
+    /** Pool vault for token0 (writable) */
+    vault0: Address;
+    /** Pool vault for token1 (writable) */
+    vault1: Address;
+    /** Token0 mint (read-only) */
+    token0Mint: Address;
+    /** Token1 mint (read-only) */
+    token1Mint: Address;
+    /** Recipient token0 account (writable) */
+    recipient0: Address;
+    /** Recipient token1 account (writable) */
+    recipient1: Address;
+    /** SPL Token program */
+    tokenProgram?: Address;
+}
+/**
+ * Create a collect_protocol_fees instruction
+ *
+ * Collects accrued protocol fees from the protocol position and transfers them
+ * to the configured recipients.
+ *
+ * @param accounts - Required accounts for collecting protocol fees
+ * @param args - Instruction arguments (max0, max1)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to collect protocol fees
+ *
+ * @example
+ * ```ts
+ * const ix = createCollectProtocolFeesInstruction(
+ *   {
+ *     config: configAddress,
+ *     pool: poolAddress,
+ *     protocolPosition: protocolPositionAddress,
+ *     admin: adminPublicKey,
+ *     authority: authorityPda,
+ *     vault0: vault0Address,
+ *     vault1: vault1Address,
+ *     token0Mint: mint0,
+ *     token1Mint: mint1,
+ *     recipient0: adminToken0Account,
+ *     recipient1: adminToken1Account,
+ *   },
+ *   {
+ *     max0: BigInt('18446744073709551615'),
+ *     max1: BigInt('18446744073709551615'),
+ *   }
+ * );
+ * ```
+ */
+declare function createCollectProtocolFeesInstruction(accounts: CollectProtocolFeesAccounts, args: CollectProtocolFeesArgs, programId?: Address): Instruction;
+
+/**
+ * Accounts required for oracle_update instruction
+ */
+interface OracleUpdateAccounts {
+    /** Pool account (read-only) */
+    pool: Address;
+    /** Oracle PDA to update (writable) */
+    oracle: Address;
+}
+/**
+ * Create an oracle_update instruction
+ *
+ * Updates the oracle with the current pool prices. This samples the current
+ * spot price, clamps it according to maxPriceChangeRatioQ64, and records
+ * a new observation if the observation interval has elapsed.
+ *
+ * This instruction is permissionless - anyone can call it to update the oracle.
+ *
+ * @param accounts - Required accounts for the instruction
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to update the oracle
+ *
+ * @example
+ * ```ts
+ * const ix = createOracleUpdateInstruction({
+ *   pool: poolAddress,
+ *   oracle: oracleAddress,
+ * });
+ * ```
+ */
+declare function createOracleUpdateInstruction(accounts: OracleUpdateAccounts, programId?: Address): Instruction;
+
+/**
+ * Accounts required for oracle_consult instruction
+ */
+interface OracleConsultAccounts {
+    /** Pool account (read-only) */
+    pool: Address;
+    /** Oracle PDA to query (read-only) */
+    oracle: Address;
+}
+/**
+ * Result returned from oracle_consult via return data
+ */
+interface OracleConsultResult {
+    /** TWAP price of token0 in token1 (Q64.64 fixed-point) */
+    price0Q64: bigint;
+    /** TWAP price of token1 in token0 (Q64.64 fixed-point) */
+    price1Q64: bigint;
+}
+/**
+ * Decode oracle_consult return data
+ */
+declare function decodeOracleConsultResult(data: ReadonlyUint8Array): OracleConsultResult;
+/**
+ * Create an oracle_consult instruction
+ *
+ * Queries the TWAP price from the oracle over the specified time window.
+ * The result is returned via Solana's return data mechanism.
+ *
+ * Note: To read the result, you must invoke this instruction via CPI or
+ * simulate the transaction and parse the return data.
+ *
+ * @param accounts - Required accounts for the instruction
+ * @param args - Instruction arguments (windowSeconds)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to consult the oracle
+ *
+ * @example
+ * ```ts
+ * const ix = createOracleConsultInstruction(
+ *   {
+ *     pool: poolAddress,
+ *     oracle: oracleAddress,
+ *   },
+ *   {
+ *     windowSeconds: 300, // 5-minute TWAP
+ *   }
+ * );
+ * ```
+ */
+declare function createOracleConsultInstruction(accounts: OracleConsultAccounts, args: OracleConsultArgs, programId?: Address): Instruction;
+
+/**
+ * Accounts required for quote_to_numeraire instruction
+ */
+interface QuoteToNumeraireAccounts {
+    /** AmmConfig account (read-only) */
+    config: Address;
+    /** Starting pool for the route (read-only) */
+    startPool: Address;
+    /**
+     * Remaining accounts for routing:
+     * - [pool1?, pool2?, ...]
+     *
+     * Each hop requires the next pool in the route chain.
+     */
+    remainingAccounts?: Address[];
+}
+/**
+ * Result returned from quote_to_numeraire via return data
+ */
+interface QuoteToNumeraireResult {
+    /** Amount converted to numeraire (u128) */
+    amountInNumeraire: bigint;
+    /** Final mint reached (should be numeraire) */
+    endMint: Address;
+    /** Number of hops used in the route */
+    hopsUsed: number;
+}
+/**
+ * Decode quote_to_numeraire return data
+ */
+declare function decodeQuoteToNumeraireResult(data: ReadonlyUint8Array): QuoteToNumeraireResult;
+/**
+ * Create a quote_to_numeraire instruction
+ *
+ * Converts an amount of one token to its value in the pool's numeraire
+ * via the routing chain using spot pricing. (TWAP is not supported in v0.1.)
+ *
+ * The result is returned via Solana's return data mechanism.
+ *
+ * @param accounts - Required accounts for the instruction
+ * @param args - Instruction arguments (amount, side, maxHops, useTwap, windowSeconds)
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Instruction to quote amount in numeraire
+ *
+ * @example
+ * ```ts
+ * // Quote using spot prices (no TWAP)
+ * const ix = createQuoteToNumeraireInstruction(
+ *   {
+ *     config: configAddress,
+ *     startPool: poolAddress,
+ *   },
+ *   {
+ *     amount: 1000000n,
+ *     side: 0, // token0
+ *     maxHops: 3,
+ *     useTwap: false,
+ *     windowSeconds: 0,
+ *   }
+ * );
+ * ```
+ */
+declare function createQuoteToNumeraireInstruction(accounts: QuoteToNumeraireAccounts, args: QuoteToNumeraireArgs, programId?: Address): Instruction;
+
+/**
+ * Pool fetching and utility functions for the CPMM SDK
+ */
+
+/**
+ * Configuration for fetching pools
+ */
+interface FetchPoolsConfig {
+    /** Program ID (defaults to CPMM program) */
+    programId?: Address;
+    /** Commitment level */
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+}
+/**
+ * Pool with its address
+ */
+interface PoolWithAddress {
+    address: Address;
+    account: Pool;
+}
+/**
+ * Fetch and decode a single pool account
+ *
+ * @param rpc - Solana RPC client
+ * @param address - Pool account address
+ * @param config - Optional configuration
+ * @returns Decoded pool data or null if not found
+ *
+ * @example
+ * ```ts
+ * const pool = await fetchPool(rpc, poolAddress);
+ * if (pool) {
+ *   console.log(`Pool reserves: ${pool.reserve0} / ${pool.reserve1}`);
+ * }
+ * ```
+ */
+declare function fetchPool(rpc: Rpc<GetAccountInfoApi>, address: Address, config?: FetchPoolsConfig): Promise<Pool | null>;
+/**
+ * Fetch all pool accounts for the CPMM program
+ *
+ * Uses getProgramAccounts with a discriminator filter for efficiency.
+ *
+ * @param rpc - Solana RPC client
+ * @param config - Optional configuration
+ * @returns Array of pools with their addresses
+ *
+ * @example
+ * ```ts
+ * const pools = await fetchAllPools(rpc);
+ * console.log(`Found ${pools.length} pools`);
+ * for (const { address, account } of pools) {
+ *   console.log(`Pool ${address}: ${account.token0Mint} / ${account.token1Mint}`);
+ * }
+ * ```
+ */
+declare function fetchAllPools(rpc: GetProgramAccountsRpc, config?: FetchPoolsConfig): Promise<PoolWithAddress[]>;
+/**
+ * Find a pool by its token pair mints
+ *
+ * Derives the pool PDA from the mints (automatically sorted) and fetches it.
+ *
+ * @param rpc - Solana RPC client
+ * @param mintA - First token mint
+ * @param mintB - Second token mint
+ * @param config - Optional configuration
+ * @returns Pool data with address, or null if not found
+ *
+ * @example
+ * ```ts
+ * const result = await getPoolByMints(rpc, usdcMint, solMint);
+ * if (result) {
+ *   console.log(`Found pool at ${result.address}`);
+ *   console.log(`Swap fee: ${result.account.swapFeeBps} bps`);
+ * }
+ * ```
+ */
+declare function getPoolByMints(rpc: Rpc<GetAccountInfoApi>, mintA: Address, mintB: Address, config?: FetchPoolsConfig): Promise<PoolWithAddress | null>;
+/**
+ * Get multiple pools by their addresses in a single batch request
+ *
+ * @param rpc - Solana RPC client
+ * @param addresses - Array of pool addresses to fetch
+ * @param config - Optional configuration
+ * @returns Map of address to pool (missing pools are not included)
+ *
+ * @example
+ * ```ts
+ * const poolMap = await fetchPoolsBatch(rpc, [pool1, pool2, pool3]);
+ * for (const [addr, pool] of poolMap) {
+ *   console.log(`Pool ${addr}: TVL = ${pool.reserve0 + pool.reserve1}`);
+ * }
+ * ```
+ */
+declare function fetchPoolsBatch(rpc: Rpc<GetAccountInfoApi>, addresses: Address[], config?: FetchPoolsConfig): Promise<Map<Address, Pool>>;
+/**
+ * Check if a pool exists for a token pair
+ *
+ * @param rpc - Solana RPC client
+ * @param mintA - First token mint
+ * @param mintB - Second token mint
+ * @param config - Optional configuration
+ * @returns true if pool exists, false otherwise
+ */
+declare function poolExists(rpc: Rpc<GetAccountInfoApi>, mintA: Address, mintB: Address, config?: FetchPoolsConfig): Promise<boolean>;
+/**
+ * Get the pool address for a token pair without fetching
+ *
+ * @param mintA - First token mint
+ * @param mintB - Second token mint
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Pool address and sorted mints
+ */
+declare function getPoolAddressFromMints(mintA: Address, mintB: Address, programId?: Address): Promise<{
+    poolAddress: Address;
+    token0: Address;
+    token1: Address;
+}>;
+/**
+ * Filter pools by a specific token mint
+ *
+ * @param pools - Array of pools to filter
+ * @param mint - Token mint to filter by
+ * @returns Pools that contain the specified mint
+ */
+declare function filterPoolsByMint(pools: PoolWithAddress[], mint: Address): PoolWithAddress[];
+/**
+ * Sort pools by total reserves (proxy for TVL)
+ *
+ * @param pools - Array of pools to sort
+ * @param descending - Sort descending (highest first) if true
+ * @returns Sorted array (does not mutate input)
+ */
+declare function sortPoolsByReserves(pools: PoolWithAddress[], descending?: boolean): PoolWithAddress[];
+
+/**
+ * Config fetching and utilities for the CPMM SDK
+ */
+
+/**
+ * Fetch and decode the AmmConfig account
+ *
+ * @param rpc - Solana RPC client
+ * @param programId - Program ID (defaults to CPMM program)
+ * @param commitment - Optional commitment level
+ * @returns Decoded config data or null if not found
+ */
+declare function fetchConfig(rpc: Rpc<GetAccountInfoApi>, programId?: Address, commitment?: 'processed' | 'confirmed' | 'finalized'): Promise<AmmConfig | null>;
+/**
+ * Fetch config with its PDA address
+ */
+declare function fetchConfigWithAddress(rpc: Rpc<GetAccountInfoApi>, programId?: Address, commitment?: 'processed' | 'confirmed' | 'finalized'): Promise<{
+    address: Address;
+    account: AmmConfig;
+} | null>;
+
+/**
+ * Program ID for the Initializer program (devnet in this repo).
+ *
+ * Source of truth: programs/initializer/src/lib.rs
+ */
+declare const INITIALIZER_PROGRAM_ID: Address;
+declare const BPF_LOADER_UPGRADEABLE_PROGRAM_ID: Address;
+declare const SEED_CONFIG = "config_v3";
+declare const SEED_LAUNCH = "launch_v3";
+declare const SEED_LAUNCH_AUTHORITY = "launch_authority_v3";
+declare const MAX_MIGRATOR_ALLOWLIST = 32;
+declare const MAX_SENTINEL_ALLOWLIST = 32;
+declare const MAX_CALLDATA = 256;
+declare const PHASE_TRADING = 0;
+declare const PHASE_MIGRATED = 1;
+declare const PHASE_ABORTED = 2;
+declare const DIRECTION_BUY = 0;
+declare const DIRECTION_SELL = 1;
+declare const CURVE_KIND_XYK = 0;
+declare const CURVE_PARAMS_FORMAT_XYK_V0 = 0;
+declare const SF_BEFORE_SWAP: number;
+declare const SF_AFTER_SWAP: number;
+declare const SENTINEL_NO_CHANGE = 65535;
+declare const INITIALIZER_INSTRUCTION_DISCRIMINATORS: {
+    readonly initializeConfig: Uint8Array<ArrayBuffer>;
+    readonly setMigratorAllowlist: Uint8Array<ArrayBuffer>;
+    readonly setSentinelAllowlist: Uint8Array<ArrayBuffer>;
+    readonly initializeLaunch: Uint8Array<ArrayBuffer>;
+    readonly curveSwapExactIn: Uint8Array<ArrayBuffer>;
+    readonly migrateLaunch: Uint8Array<ArrayBuffer>;
+    readonly abortLaunch: Uint8Array<ArrayBuffer>;
+    readonly previewSwapExactIn: Uint8Array<ArrayBuffer>;
+    readonly previewMigration: Uint8Array<ArrayBuffer>;
+};
+declare const INITIALIZER_ACCOUNT_DISCRIMINATORS: {
+    readonly InitConfig: Uint8Array<ArrayBuffer>;
+    readonly Launch: Uint8Array<ArrayBuffer>;
+};
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type InitConfig = {
+    discriminator: ReadonlyUint8Array;
+    admin: Address;
+    migratorAllowlistLen: number;
+    migratorAllowlist: Array<Address>;
+    sentinelAllowlistLen: number;
+    sentinelAllowlist: Array<Address>;
+    bump: number;
+    version: number;
+    reserved: ReadonlyUint8Array;
+};
+type InitConfigArgs = {
+    admin: Address;
+    migratorAllowlistLen: number;
+    migratorAllowlist: Array<Address>;
+    sentinelAllowlistLen: number;
+    sentinelAllowlist: Array<Address>;
+    bump: number;
+    version: number;
+    reserved: ReadonlyUint8Array;
+};
+/** Gets the encoder for {@link InitConfigArgs} account data. */
+declare function getInitConfigEncoder(): FixedSizeEncoder<InitConfigArgs>;
+/** Gets the decoder for {@link InitConfig} account data. */
+declare function getInitConfigDecoder(): FixedSizeDecoder<InitConfig>;
+/** Gets the codec for {@link InitConfig} account data. */
+declare function getInitConfigCodec(): FixedSizeCodec<InitConfigArgs, InitConfig>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type CalldataBuf = {
+    len: number;
+    bytes: ReadonlyUint8Array;
+};
+type CalldataBufArgs = CalldataBuf;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type InitializeConfigArgs = {
+    migratorAllowlist: Array<Address>;
+    sentinelAllowlist: Array<Address>;
+};
+type InitializeConfigArgsArgs = InitializeConfigArgs;
+declare function getInitializeConfigArgsEncoder(): Encoder<InitializeConfigArgsArgs>;
+declare function getInitializeConfigArgsDecoder(): Decoder<InitializeConfigArgs>;
+declare function getInitializeConfigArgsCodec(): Codec<InitializeConfigArgsArgs, InitializeConfigArgs>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type InitializeLaunchArgs = {
+    namespace: Address;
+    launchId: ReadonlyUint8Array;
+    baseDecimals: number;
+    baseTotalSupply: bigint;
+    baseForDistribution: bigint;
+    baseForLiquidity: bigint;
+    curveVirtualBase: bigint;
+    curveVirtualQuote: bigint;
+    curveFeeBps: number;
+    curveKind: number;
+    curveParams: ReadonlyUint8Array;
+    allowBuy: number;
+    allowSell: number;
+    sentinelProgram: Address;
+    sentinelFlags: number;
+    sentinelCalldata: ReadonlyUint8Array;
+    migratorProgram: Address;
+    migratorInitCalldata: ReadonlyUint8Array;
+    migratorMigrateCalldata: ReadonlyUint8Array;
+    /**
+     * Commitment hash for swap/preview sentinel remaining accounts.
+     * Computed as hash(u32_len || pubkey_0 || ... || pubkey_n).
+     */
+    sentinelRemainingAccountsHash: ReadonlyUint8Array;
+    /**
+     * Commitment hash for migrate remaining accounts.
+     * Computed as hash(u32_len || pubkey_0 || ... || pubkey_n).
+     */
+    migratorRemainingAccountsHash: ReadonlyUint8Array;
+    /** Token name for on-chain metadata. If empty, metadata creation is skipped. */
+    metadataName: string;
+    /** Token symbol for on-chain metadata. */
+    metadataSymbol: string;
+    /** Metadata JSON URI for on-chain metadata. */
+    metadataUri: string;
+};
+type InitializeLaunchArgsArgs = {
+    namespace: Address;
+    launchId: ReadonlyUint8Array;
+    baseDecimals: number;
+    baseTotalSupply: number | bigint;
+    baseForDistribution: number | bigint;
+    baseForLiquidity: number | bigint;
+    curveVirtualBase: number | bigint;
+    curveVirtualQuote: number | bigint;
+    curveFeeBps: number;
+    curveKind: number;
+    curveParams: ReadonlyUint8Array;
+    allowBuy: number;
+    allowSell: number;
+    sentinelProgram: Address;
+    sentinelFlags: number;
+    sentinelCalldata: ReadonlyUint8Array;
+    migratorProgram: Address;
+    migratorInitCalldata: ReadonlyUint8Array;
+    migratorMigrateCalldata: ReadonlyUint8Array;
+    /**
+     * Commitment hash for swap/preview sentinel remaining accounts.
+     * Computed as hash(u32_len || pubkey_0 || ... || pubkey_n).
+     */
+    sentinelRemainingAccountsHash: ReadonlyUint8Array;
+    /**
+     * Commitment hash for migrate remaining accounts.
+     * Computed as hash(u32_len || pubkey_0 || ... || pubkey_n).
+     */
+    migratorRemainingAccountsHash: ReadonlyUint8Array;
+    /** Token name for on-chain metadata. If empty, metadata creation is skipped. */
+    metadataName: string;
+    /** Token symbol for on-chain metadata. */
+    metadataSymbol: string;
+    /** Metadata JSON URI for on-chain metadata. */
+    metadataUri: string;
+};
+declare function getInitializeLaunchArgsEncoder(): Encoder<InitializeLaunchArgsArgs>;
+declare function getInitializeLaunchArgsDecoder(): Decoder<InitializeLaunchArgs>;
+declare function getInitializeLaunchArgsCodec(): Codec<InitializeLaunchArgsArgs, InitializeLaunchArgs>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type Launch = {
+    discriminator: ReadonlyUint8Array;
+    authority: Address;
+    namespace: Address;
+    launchId: ReadonlyUint8Array;
+    phase: number;
+    bump: number;
+    launchAuthorityBump: number;
+    pad0: ReadonlyUint8Array;
+    baseMint: Address;
+    quoteMint: Address;
+    baseVault: Address;
+    quoteVault: Address;
+    baseTotalSupply: bigint;
+    baseForDistribution: bigint;
+    baseForLiquidity: bigint;
+    baseForCurve: bigint;
+    curveVirtualBase: bigint;
+    curveVirtualQuote: bigint;
+    curveFeeBps: number;
+    pad1: ReadonlyUint8Array;
+    allowBuy: number;
+    allowSell: number;
+    pad2: ReadonlyUint8Array;
+    sentinelProgram: Address;
+    sentinelFlags: number;
+    pad3: ReadonlyUint8Array;
+    sentinelCalldata: CalldataBuf;
+    migratorProgram: Address;
+    migratorInitCalldata: CalldataBuf;
+    migratorMigrateCalldata: CalldataBuf;
+    curveKind: number;
+    swapLock: number;
+    pad4: ReadonlyUint8Array;
+    curveParams: CalldataBuf;
+    quoteDeposited: bigint;
+    reserved: ReadonlyUint8Array;
+};
+type LaunchArgs = {
+    authority: Address;
+    namespace: Address;
+    launchId: ReadonlyUint8Array;
+    phase: number;
+    bump: number;
+    launchAuthorityBump: number;
+    pad0: ReadonlyUint8Array;
+    baseMint: Address;
+    quoteMint: Address;
+    baseVault: Address;
+    quoteVault: Address;
+    baseTotalSupply: number | bigint;
+    baseForDistribution: number | bigint;
+    baseForLiquidity: number | bigint;
+    baseForCurve: number | bigint;
+    curveVirtualBase: number | bigint;
+    curveVirtualQuote: number | bigint;
+    curveFeeBps: number;
+    pad1: ReadonlyUint8Array;
+    allowBuy: number;
+    allowSell: number;
+    pad2: ReadonlyUint8Array;
+    sentinelProgram: Address;
+    sentinelFlags: number;
+    pad3: ReadonlyUint8Array;
+    sentinelCalldata: CalldataBufArgs;
+    migratorProgram: Address;
+    migratorInitCalldata: CalldataBufArgs;
+    migratorMigrateCalldata: CalldataBufArgs;
+    curveKind: number;
+    swapLock: number;
+    pad4: ReadonlyUint8Array;
+    curveParams: CalldataBufArgs;
+    quoteDeposited: number | bigint;
+    reserved: ReadonlyUint8Array;
+};
+/** Gets the encoder for {@link LaunchArgs} account data. */
+declare function getLaunchEncoder(): FixedSizeEncoder<LaunchArgs>;
+/** Gets the decoder for {@link Launch} account data. */
+declare function getLaunchDecoder(): FixedSizeDecoder<Launch>;
+/** Gets the codec for {@link Launch} account data. */
+declare function getLaunchCodec(): FixedSizeCodec<LaunchArgs, Launch>;
+
+declare function encodeU64LE(value: bigint): Uint8Array;
+/**
+ * Derive the InitConfig PDA address.
+ * Seeds: ['config_v3']
+ */
+declare function getConfigAddress(programId?: Address): Promise<ProgramDerivedAddress>;
+/**
+ * Derive the ProgramData PDA for an upgradeable program.
+ * Seeds: [initializer_program_id] with program = BPFLoaderUpgradeable.
+ */
+declare function getProgramDataAddress(programId?: Address): Promise<ProgramDerivedAddress>;
+/**
+ * Derive the Launch PDA address.
+ * Seeds: ['launch_v3', namespace, launch_id_bytes_32]
+ */
+declare function getLaunchAddress(namespace: Address, launchId: Uint8Array, programId?: Address): Promise<ProgramDerivedAddress>;
+/**
+ * Derive the Launch authority PDA address.
+ * Seeds: ['launch_authority_v3', launch]
+ */
+declare function getLaunchAuthorityAddress(launch: Address, programId?: Address): Promise<ProgramDerivedAddress>;
+/**
+ * Convenience helper for the common pattern: embed a u64 into a 32-byte launch_id.
+ */
+declare function launchIdFromU64(launchId: bigint): Uint8Array;
+
+type AddressOrSigner$6 = Address | TransactionSigner;
+interface InitializeConfigAccounts {
+    admin: AddressOrSigner$6;
+    config: Address;
+    programData: Address;
+    systemProgram?: Address;
+}
+declare function createInitializeConfigInstruction(accounts: InitializeConfigAccounts, args: InitializeConfigArgsArgs, programId?: Address): Instruction;
+
+type AddressOrSigner$5 = Address | TransactionSigner;
+interface SetMigratorAllowlistAccounts {
+    admin: AddressOrSigner$5;
+    config: Address;
+}
+declare function createSetMigratorAllowlistInstruction(accounts: SetMigratorAllowlistAccounts, allowlist: Address[], programId?: Address): Instruction;
+
+type AddressOrSigner$4 = Address | TransactionSigner;
+interface SetSentinelAllowlistAccounts {
+    admin: AddressOrSigner$4;
+    config: Address;
+}
+declare function createSetSentinelAllowlistInstruction(accounts: SetSentinelAllowlistAccounts, allowlist: Address[], programId?: Address): Instruction;
+
+type AddressOrSigner$3 = Address | TransactionSigner;
+interface InitializeLaunchAccounts {
+    config: Address;
+    launch: Address;
+    launchAuthority: Address;
+    baseMint: AddressOrSigner$3;
+    quoteMint: Address;
+    baseVault: AddressOrSigner$3;
+    quoteVault: AddressOrSigner$3;
+    payer: AddressOrSigner$3;
+    authority?: AddressOrSigner$3;
+    migratorProgram?: Address;
+    tokenProgram?: Address;
+    systemProgram?: Address;
+    rent: Address;
+}
+declare function createInitializeLaunchInstruction(accounts: InitializeLaunchAccounts, args: InitializeLaunchArgsArgs, programId?: Address): Instruction;
+
+type AddressOrSigner$2 = Address | TransactionSigner;
+interface CurveSwapExactInAccounts {
+    config: Address;
+    launch: Address;
+    launchAuthority: Address;
+    baseVault: Address;
+    quoteVault: Address;
+    userBaseAccount: Address;
+    userQuoteAccount: Address;
+    baseMint: Address;
+    quoteMint: Address;
+    user: AddressOrSigner$2;
+    sentinelProgram?: Address;
+    tokenProgram?: Address;
+}
+declare function createCurveSwapExactInInstruction(accounts: CurveSwapExactInAccounts, args: {
+    amountIn: bigint;
+    minAmountOut: bigint;
+    direction: number;
+}, programId?: Address): Instruction;
+
+type AddressOrSigner$1 = Address | TransactionSigner;
+interface MigrateLaunchAccounts {
+    config: Address;
+    launch: Address;
+    launchAuthority: Address;
+    baseMint: Address;
+    quoteMint: Address;
+    baseVault: Address;
+    quoteVault: Address;
+    migratorProgram: Address;
+    payer: AddressOrSigner$1;
+    tokenProgram?: Address;
+    systemProgram?: Address;
+    rent: Address;
+}
+declare function createMigrateLaunchInstruction(accounts: MigrateLaunchAccounts, programId?: Address): Instruction;
+
+type AddressOrSigner = Address | TransactionSigner;
+interface AbortLaunchAccounts {
+    config: Address;
+    launch: Address;
+    launchAuthority: Address;
+    baseVault: Address;
+    quoteVault: Address;
+    authority: AddressOrSigner;
+    authorityBaseAccount: Address;
+    baseMint: Address;
+    tokenProgram?: Address;
+}
+declare function createAbortLaunchInstruction(accounts: AbortLaunchAccounts, programId?: Address): Instruction;
+
+interface PreviewSwapExactInResult {
+    amountOut: bigint;
+    feePaid: bigint;
+}
+interface PreviewSwapExactInAccounts {
+    launch: Address;
+    baseVault: Address;
+    quoteVault: Address;
+    sentinelProgram?: Address;
+}
+declare function createPreviewSwapExactInInstruction(accounts: PreviewSwapExactInAccounts, args: {
+    amountIn: bigint;
+    direction: number;
+}, programId?: Address): Instruction;
+declare function decodePreviewSwapExactInResult(data: Uint8Array): PreviewSwapExactInResult;
+
+interface PreviewMigrationResult {
+    baseVaultAmount: bigint;
+    quoteVaultAmount: bigint;
+    baseMintSupply: bigint;
+}
+interface PreviewMigrationAccounts {
+    launch: Address;
+    baseMint: Address;
+    baseVault: Address;
+    quoteVault: Address;
+}
+declare function createPreviewMigrationInstruction(accounts: PreviewMigrationAccounts, programId?: Address): Instruction;
+declare function decodePreviewMigrationResult(data: Uint8Array): PreviewMigrationResult;
+
+/**
+ * Launch fetching functions for the Initializer SDK
+ */
+
+interface FetchLaunchesConfig {
+    programId?: Address;
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+}
+interface LaunchWithAddress {
+    address: Address;
+    account: Launch;
+}
+declare function fetchLaunch(rpc: Rpc<GetAccountInfoApi>, address: Address, config?: FetchLaunchesConfig): Promise<Launch | null>;
+declare function fetchAllLaunches(rpc: GetProgramAccountsRpc, config?: FetchLaunchesConfig): Promise<LaunchWithAddress[]>;
+/**
+ * Fetch launches filtered by Launch.authority (offset 8).
+ * Note: Permissionless launches have authority == Pubkey::default().
+ */
+declare function fetchLaunchesByAuthority(rpc: GetProgramAccountsRpc, authority: Address, config?: FetchLaunchesConfig): Promise<LaunchWithAddress[]>;
+declare function launchExists(rpc: Rpc<GetAccountInfoApi>, namespace: Address, launchId: Uint8Array, config?: FetchLaunchesConfig): Promise<boolean>;
+
+type index$1_AbortLaunchAccounts = AbortLaunchAccounts;
+declare const index$1_BPF_LOADER_UPGRADEABLE_PROGRAM_ID: typeof BPF_LOADER_UPGRADEABLE_PROGRAM_ID;
+declare const index$1_CURVE_KIND_XYK: typeof CURVE_KIND_XYK;
+declare const index$1_CURVE_PARAMS_FORMAT_XYK_V0: typeof CURVE_PARAMS_FORMAT_XYK_V0;
+type index$1_CalldataBuf = CalldataBuf;
+type index$1_CurveSwapExactInAccounts = CurveSwapExactInAccounts;
+declare const index$1_DIRECTION_BUY: typeof DIRECTION_BUY;
+declare const index$1_DIRECTION_SELL: typeof DIRECTION_SELL;
+type index$1_FetchLaunchesConfig = FetchLaunchesConfig;
+declare const index$1_INITIALIZER_ACCOUNT_DISCRIMINATORS: typeof INITIALIZER_ACCOUNT_DISCRIMINATORS;
+declare const index$1_INITIALIZER_INSTRUCTION_DISCRIMINATORS: typeof INITIALIZER_INSTRUCTION_DISCRIMINATORS;
+declare const index$1_INITIALIZER_PROGRAM_ID: typeof INITIALIZER_PROGRAM_ID;
+type index$1_InitConfig = InitConfig;
+type index$1_InitConfigArgs = InitConfigArgs;
+type index$1_InitializeConfigAccounts = InitializeConfigAccounts;
+type index$1_InitializeConfigArgs = InitializeConfigArgs;
+type index$1_InitializeConfigArgsArgs = InitializeConfigArgsArgs;
+type index$1_InitializeLaunchAccounts = InitializeLaunchAccounts;
+type index$1_InitializeLaunchArgs = InitializeLaunchArgs;
+type index$1_InitializeLaunchArgsArgs = InitializeLaunchArgsArgs;
+type index$1_Launch = Launch;
+type index$1_LaunchArgs = LaunchArgs;
+type index$1_LaunchWithAddress = LaunchWithAddress;
+declare const index$1_MAX_CALLDATA: typeof MAX_CALLDATA;
+declare const index$1_MAX_MIGRATOR_ALLOWLIST: typeof MAX_MIGRATOR_ALLOWLIST;
+declare const index$1_MAX_SENTINEL_ALLOWLIST: typeof MAX_SENTINEL_ALLOWLIST;
+type index$1_MigrateLaunchAccounts = MigrateLaunchAccounts;
+declare const index$1_PHASE_ABORTED: typeof PHASE_ABORTED;
+declare const index$1_PHASE_MIGRATED: typeof PHASE_MIGRATED;
+declare const index$1_PHASE_TRADING: typeof PHASE_TRADING;
+type index$1_PreviewMigrationAccounts = PreviewMigrationAccounts;
+type index$1_PreviewMigrationResult = PreviewMigrationResult;
+type index$1_PreviewSwapExactInAccounts = PreviewSwapExactInAccounts;
+type index$1_PreviewSwapExactInResult = PreviewSwapExactInResult;
+declare const index$1_SEED_CONFIG: typeof SEED_CONFIG;
+declare const index$1_SEED_LAUNCH: typeof SEED_LAUNCH;
+declare const index$1_SEED_LAUNCH_AUTHORITY: typeof SEED_LAUNCH_AUTHORITY;
+declare const index$1_SENTINEL_NO_CHANGE: typeof SENTINEL_NO_CHANGE;
+declare const index$1_SF_AFTER_SWAP: typeof SF_AFTER_SWAP;
+declare const index$1_SF_BEFORE_SWAP: typeof SF_BEFORE_SWAP;
+type index$1_SetMigratorAllowlistAccounts = SetMigratorAllowlistAccounts;
+type index$1_SetSentinelAllowlistAccounts = SetSentinelAllowlistAccounts;
+declare const index$1_createAbortLaunchInstruction: typeof createAbortLaunchInstruction;
+declare const index$1_createCurveSwapExactInInstruction: typeof createCurveSwapExactInInstruction;
+declare const index$1_createInitializeConfigInstruction: typeof createInitializeConfigInstruction;
+declare const index$1_createInitializeLaunchInstruction: typeof createInitializeLaunchInstruction;
+declare const index$1_createMigrateLaunchInstruction: typeof createMigrateLaunchInstruction;
+declare const index$1_createPreviewMigrationInstruction: typeof createPreviewMigrationInstruction;
+declare const index$1_createPreviewSwapExactInInstruction: typeof createPreviewSwapExactInInstruction;
+declare const index$1_createSetMigratorAllowlistInstruction: typeof createSetMigratorAllowlistInstruction;
+declare const index$1_createSetSentinelAllowlistInstruction: typeof createSetSentinelAllowlistInstruction;
+declare const index$1_decodePreviewMigrationResult: typeof decodePreviewMigrationResult;
+declare const index$1_decodePreviewSwapExactInResult: typeof decodePreviewSwapExactInResult;
+declare const index$1_encodeU64LE: typeof encodeU64LE;
+declare const index$1_fetchAllLaunches: typeof fetchAllLaunches;
+declare const index$1_fetchLaunch: typeof fetchLaunch;
+declare const index$1_fetchLaunchesByAuthority: typeof fetchLaunchesByAuthority;
+declare const index$1_getConfigAddress: typeof getConfigAddress;
+declare const index$1_getInitConfigCodec: typeof getInitConfigCodec;
+declare const index$1_getInitConfigDecoder: typeof getInitConfigDecoder;
+declare const index$1_getInitConfigEncoder: typeof getInitConfigEncoder;
+declare const index$1_getInitializeConfigArgsCodec: typeof getInitializeConfigArgsCodec;
+declare const index$1_getInitializeConfigArgsDecoder: typeof getInitializeConfigArgsDecoder;
+declare const index$1_getInitializeConfigArgsEncoder: typeof getInitializeConfigArgsEncoder;
+declare const index$1_getInitializeLaunchArgsCodec: typeof getInitializeLaunchArgsCodec;
+declare const index$1_getInitializeLaunchArgsDecoder: typeof getInitializeLaunchArgsDecoder;
+declare const index$1_getInitializeLaunchArgsEncoder: typeof getInitializeLaunchArgsEncoder;
+declare const index$1_getLaunchAddress: typeof getLaunchAddress;
+declare const index$1_getLaunchAuthorityAddress: typeof getLaunchAuthorityAddress;
+declare const index$1_getLaunchCodec: typeof getLaunchCodec;
+declare const index$1_getLaunchDecoder: typeof getLaunchDecoder;
+declare const index$1_getLaunchEncoder: typeof getLaunchEncoder;
+declare const index$1_getProgramDataAddress: typeof getProgramDataAddress;
+declare const index$1_launchExists: typeof launchExists;
+declare const index$1_launchIdFromU64: typeof launchIdFromU64;
+declare namespace index$1 {
+  export { type index$1_AbortLaunchAccounts as AbortLaunchAccounts, index$1_BPF_LOADER_UPGRADEABLE_PROGRAM_ID as BPF_LOADER_UPGRADEABLE_PROGRAM_ID, index$1_CURVE_KIND_XYK as CURVE_KIND_XYK, index$1_CURVE_PARAMS_FORMAT_XYK_V0 as CURVE_PARAMS_FORMAT_XYK_V0, type index$1_CalldataBuf as CalldataBuf, type index$1_CurveSwapExactInAccounts as CurveSwapExactInAccounts, index$1_DIRECTION_BUY as DIRECTION_BUY, index$1_DIRECTION_SELL as DIRECTION_SELL, type index$1_FetchLaunchesConfig as FetchLaunchesConfig, index$1_INITIALIZER_ACCOUNT_DISCRIMINATORS as INITIALIZER_ACCOUNT_DISCRIMINATORS, index$1_INITIALIZER_INSTRUCTION_DISCRIMINATORS as INITIALIZER_INSTRUCTION_DISCRIMINATORS, index$1_INITIALIZER_PROGRAM_ID as INITIALIZER_PROGRAM_ID, type index$1_InitConfig as InitConfig, type index$1_InitConfigArgs as InitConfigArgs, type index$1_InitializeConfigAccounts as InitializeConfigAccounts, type index$1_InitializeConfigArgs as InitializeConfigArgs, type index$1_InitializeConfigArgsArgs as InitializeConfigArgsArgs, type index$1_InitializeLaunchAccounts as InitializeLaunchAccounts, type index$1_InitializeLaunchArgs as InitializeLaunchArgs, type index$1_InitializeLaunchArgsArgs as InitializeLaunchArgsArgs, type index$1_Launch as Launch, type index$1_LaunchArgs as LaunchArgs, type index$1_LaunchWithAddress as LaunchWithAddress, index$1_MAX_CALLDATA as MAX_CALLDATA, index$1_MAX_MIGRATOR_ALLOWLIST as MAX_MIGRATOR_ALLOWLIST, index$1_MAX_SENTINEL_ALLOWLIST as MAX_SENTINEL_ALLOWLIST, type index$1_MigrateLaunchAccounts as MigrateLaunchAccounts, index$1_PHASE_ABORTED as PHASE_ABORTED, index$1_PHASE_MIGRATED as PHASE_MIGRATED, index$1_PHASE_TRADING as PHASE_TRADING, type index$1_PreviewMigrationAccounts as PreviewMigrationAccounts, type index$1_PreviewMigrationResult as PreviewMigrationResult, type index$1_PreviewSwapExactInAccounts as PreviewSwapExactInAccounts, type index$1_PreviewSwapExactInResult as PreviewSwapExactInResult, index$1_SEED_CONFIG as SEED_CONFIG, index$1_SEED_LAUNCH as SEED_LAUNCH, index$1_SEED_LAUNCH_AUTHORITY as SEED_LAUNCH_AUTHORITY, index$1_SENTINEL_NO_CHANGE as SENTINEL_NO_CHANGE, index$1_SF_AFTER_SWAP as SF_AFTER_SWAP, index$1_SF_BEFORE_SWAP as SF_BEFORE_SWAP, type index$1_SetMigratorAllowlistAccounts as SetMigratorAllowlistAccounts, type index$1_SetSentinelAllowlistAccounts as SetSentinelAllowlistAccounts, index$1_createAbortLaunchInstruction as createAbortLaunchInstruction, index$1_createCurveSwapExactInInstruction as createCurveSwapExactInInstruction, index$1_createInitializeConfigInstruction as createInitializeConfigInstruction, index$1_createInitializeLaunchInstruction as createInitializeLaunchInstruction, index$1_createMigrateLaunchInstruction as createMigrateLaunchInstruction, index$1_createPreviewMigrationInstruction as createPreviewMigrationInstruction, index$1_createPreviewSwapExactInInstruction as createPreviewSwapExactInInstruction, index$1_createSetMigratorAllowlistInstruction as createSetMigratorAllowlistInstruction, index$1_createSetSentinelAllowlistInstruction as createSetSentinelAllowlistInstruction, index$1_decodePreviewMigrationResult as decodePreviewMigrationResult, index$1_decodePreviewSwapExactInResult as decodePreviewSwapExactInResult, index$1_encodeU64LE as encodeU64LE, index$1_fetchAllLaunches as fetchAllLaunches, index$1_fetchLaunch as fetchLaunch, index$1_fetchLaunchesByAuthority as fetchLaunchesByAuthority, index$1_getConfigAddress as getConfigAddress, index$1_getInitConfigCodec as getInitConfigCodec, index$1_getInitConfigDecoder as getInitConfigDecoder, index$1_getInitConfigEncoder as getInitConfigEncoder, index$1_getInitializeConfigArgsCodec as getInitializeConfigArgsCodec, index$1_getInitializeConfigArgsDecoder as getInitializeConfigArgsDecoder, index$1_getInitializeConfigArgsEncoder as getInitializeConfigArgsEncoder, index$1_getInitializeLaunchArgsCodec as getInitializeLaunchArgsCodec, index$1_getInitializeLaunchArgsDecoder as getInitializeLaunchArgsDecoder, index$1_getInitializeLaunchArgsEncoder as getInitializeLaunchArgsEncoder, index$1_getLaunchAddress as getLaunchAddress, index$1_getLaunchAuthorityAddress as getLaunchAuthorityAddress, index$1_getLaunchCodec as getLaunchCodec, index$1_getLaunchDecoder as getLaunchDecoder, index$1_getLaunchEncoder as getLaunchEncoder, index$1_getProgramDataAddress as getProgramDataAddress, index$1_launchExists as launchExists, index$1_launchIdFromU64 as launchIdFromU64 };
+}
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+/**
+ * Arguments for migrate instruction.
+ * These are deserialized from the migrator_migrate_calldata passed by initializer.
+ */
+type MigrateArgs = {
+    /** Base tokens reserved for distribution to recipients */
+    baseForDistribution: bigint;
+    /** Base tokens reserved for CPMM liquidity */
+    baseForLiquidity: bigint;
+};
+type MigrateArgsArgs = {
+    /** Base tokens reserved for distribution to recipients */
+    baseForDistribution: number | bigint;
+    /** Base tokens reserved for CPMM liquidity */
+    baseForLiquidity: number | bigint;
+};
+declare function getMigrateArgsEncoder(): FixedSizeEncoder<MigrateArgsArgs>;
+declare function getMigrateArgsDecoder(): FixedSizeDecoder<MigrateArgs>;
+declare function getMigrateArgsCodec(): FixedSizeCodec<MigrateArgsArgs, MigrateArgs>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type Recipient = {
+    wallet: Address;
+    amount: bigint;
+};
+type RecipientArgs = {
+    wallet: Address;
+    amount: number | bigint;
+};
+declare function getRecipientEncoder(): FixedSizeEncoder<RecipientArgs>;
+declare function getRecipientDecoder(): FixedSizeDecoder<Recipient>;
+declare function getRecipientCodec(): FixedSizeCodec<RecipientArgs, Recipient>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+/**
+ * Arguments for register_launch instruction.
+ * These are deserialized from the migrator_init_calldata passed by initializer.
+ */
+type RegisterLaunchArgs = {
+    cpmmConfig: Address;
+    initialSwapFeeBps: number;
+    initialFeeSplitBps: number;
+    recipients: Array<Recipient>;
+    minRaiseQuote: bigint;
+    minMigrationPriceQ64Opt: Option<bigint>;
+};
+type RegisterLaunchArgsArgs = {
+    cpmmConfig: Address;
+    initialSwapFeeBps: number;
+    initialFeeSplitBps: number;
+    recipients: Array<RecipientArgs>;
+    minRaiseQuote: number | bigint;
+    minMigrationPriceQ64Opt: OptionOrNullable<number | bigint>;
+};
+declare function getRegisterLaunchArgsEncoder(): Encoder<RegisterLaunchArgsArgs>;
+declare function getRegisterLaunchArgsDecoder(): Decoder<RegisterLaunchArgs>;
+declare function getRegisterLaunchArgsCodec(): Codec<RegisterLaunchArgsArgs, RegisterLaunchArgs>;
+
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+type CpmmMigratorState = {
+    discriminator: ReadonlyUint8Array;
+    /** The launch this state is associated with */
+    launch: Address;
+    /** Admin who registered this launch (receives unsold curve base tokens) */
+    admin: Address;
+    /** CPMM config to use for pool initialization */
+    cpmmConfig: Address;
+    /** Initial swap fee for the CPMM pool (basis points) */
+    initialSwapFeeBps: number;
+    /** Initial fee split for the CPMM pool (basis points) */
+    initialFeeSplitBps: number;
+    /** Padding for alignment */
+    pad0: ReadonlyUint8Array;
+    /** Recipients for base token distribution at migration */
+    recipients: Array<Recipient>;
+    /** Minimum quote tokens required to migrate */
+    minRaiseQuote: bigint;
+    /** Optional minimum price floor (Q64 fixed point) */
+    minMigrationPriceQ64Opt: Option<bigint>;
+    /** Whether this launch has been migrated */
+    isMigrated: boolean;
+    /** Bump seed for this PDA */
+    bump: number;
+    /** Reserved for future use */
+    reserved: ReadonlyUint8Array;
+};
+type CpmmMigratorStateArgs = {
+    /** The launch this state is associated with */
+    launch: Address;
+    /** Admin who registered this launch (receives unsold curve base tokens) */
+    admin: Address;
+    /** CPMM config to use for pool initialization */
+    cpmmConfig: Address;
+    /** Initial swap fee for the CPMM pool (basis points) */
+    initialSwapFeeBps: number;
+    /** Initial fee split for the CPMM pool (basis points) */
+    initialFeeSplitBps: number;
+    /** Padding for alignment */
+    pad0: ReadonlyUint8Array;
+    /** Recipients for base token distribution at migration */
+    recipients: Array<RecipientArgs>;
+    /** Minimum quote tokens required to migrate */
+    minRaiseQuote: number | bigint;
+    /** Optional minimum price floor (Q64 fixed point) */
+    minMigrationPriceQ64Opt: OptionOrNullable<number | bigint>;
+    /** Whether this launch has been migrated */
+    isMigrated: boolean;
+    /** Bump seed for this PDA */
+    bump: number;
+    /** Reserved for future use */
+    reserved: ReadonlyUint8Array;
+};
+/** Gets the encoder for {@link CpmmMigratorStateArgs} account data. */
+declare function getCpmmMigratorStateEncoder(): Encoder<CpmmMigratorStateArgs>;
+/** Gets the decoder for {@link CpmmMigratorState} account data. */
+declare function getCpmmMigratorStateDecoder(): Decoder<CpmmMigratorState>;
+/** Gets the codec for {@link CpmmMigratorState} account data. */
+declare function getCpmmMigratorStateCodec(): Codec<CpmmMigratorStateArgs, CpmmMigratorState>;
+
+declare const CPMM_MIGRATOR_PROGRAM_ID: Address;
+declare const SEED_STATE = "state";
+declare const MAX_RECIPIENTS = 2;
+declare const CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS: {
+    readonly registerLaunch: Uint8Array<ArrayBuffer>;
+    readonly migrate: Uint8Array<ArrayBuffer>;
+};
+declare const CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS: {
+    readonly CpmmMigratorState: Uint8Array<ArrayBuffer>;
+};
+
+declare function getCpmmMigratorStateAddress(launch: Address, programId?: Address): Promise<ProgramDerivedAddress>;
+
+declare function fetchCpmmMigratorState(rpc: Rpc<GetAccountInfoApi>, address: Address): Promise<CpmmMigratorState | null>;
+
+declare function encodeRegisterLaunchCalldata(args: RegisterLaunchArgsArgs): Uint8Array;
+declare function encodeMigrateCalldata(args: MigrateArgsArgs): Uint8Array;
+
+declare const index_CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS: typeof CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS;
+declare const index_CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS: typeof CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS;
+declare const index_CPMM_MIGRATOR_PROGRAM_ID: typeof CPMM_MIGRATOR_PROGRAM_ID;
+type index_CpmmMigratorState = CpmmMigratorState;
+type index_CpmmMigratorStateArgs = CpmmMigratorStateArgs;
+declare const index_MAX_RECIPIENTS: typeof MAX_RECIPIENTS;
+type index_MigrateArgs = MigrateArgs;
+type index_MigrateArgsArgs = MigrateArgsArgs;
+type index_Recipient = Recipient;
+type index_RecipientArgs = RecipientArgs;
+type index_RegisterLaunchArgs = RegisterLaunchArgs;
+type index_RegisterLaunchArgsArgs = RegisterLaunchArgsArgs;
+declare const index_SEED_STATE: typeof SEED_STATE;
+declare const index_encodeMigrateCalldata: typeof encodeMigrateCalldata;
+declare const index_encodeRegisterLaunchCalldata: typeof encodeRegisterLaunchCalldata;
+declare const index_fetchCpmmMigratorState: typeof fetchCpmmMigratorState;
+declare const index_getCpmmMigratorStateAddress: typeof getCpmmMigratorStateAddress;
+declare const index_getCpmmMigratorStateCodec: typeof getCpmmMigratorStateCodec;
+declare const index_getCpmmMigratorStateDecoder: typeof getCpmmMigratorStateDecoder;
+declare const index_getCpmmMigratorStateEncoder: typeof getCpmmMigratorStateEncoder;
+declare const index_getMigrateArgsCodec: typeof getMigrateArgsCodec;
+declare const index_getMigrateArgsDecoder: typeof getMigrateArgsDecoder;
+declare const index_getMigrateArgsEncoder: typeof getMigrateArgsEncoder;
+declare const index_getRecipientCodec: typeof getRecipientCodec;
+declare const index_getRecipientDecoder: typeof getRecipientDecoder;
+declare const index_getRecipientEncoder: typeof getRecipientEncoder;
+declare const index_getRegisterLaunchArgsCodec: typeof getRegisterLaunchArgsCodec;
+declare const index_getRegisterLaunchArgsDecoder: typeof getRegisterLaunchArgsDecoder;
+declare const index_getRegisterLaunchArgsEncoder: typeof getRegisterLaunchArgsEncoder;
+declare namespace index {
+  export { index_CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS as CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS, index_CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS as CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS, index_CPMM_MIGRATOR_PROGRAM_ID as CPMM_MIGRATOR_PROGRAM_ID, type index_CpmmMigratorState as CpmmMigratorState, type index_CpmmMigratorStateArgs as CpmmMigratorStateArgs, index_MAX_RECIPIENTS as MAX_RECIPIENTS, type index_MigrateArgs as MigrateArgs, type index_MigrateArgsArgs as MigrateArgsArgs, type index_Recipient as Recipient, type index_RecipientArgs as RecipientArgs, type index_RegisterLaunchArgs as RegisterLaunchArgs, type index_RegisterLaunchArgsArgs as RegisterLaunchArgsArgs, index_SEED_STATE as SEED_STATE, index_encodeMigrateCalldata as encodeMigrateCalldata, index_encodeRegisterLaunchCalldata as encodeRegisterLaunchCalldata, index_fetchCpmmMigratorState as fetchCpmmMigratorState, index_getCpmmMigratorStateAddress as getCpmmMigratorStateAddress, index_getCpmmMigratorStateCodec as getCpmmMigratorStateCodec, index_getCpmmMigratorStateDecoder as getCpmmMigratorStateDecoder, index_getCpmmMigratorStateEncoder as getCpmmMigratorStateEncoder, index_getMigrateArgsCodec as getMigrateArgsCodec, index_getMigrateArgsDecoder as getMigrateArgsDecoder, index_getMigrateArgsEncoder as getMigrateArgsEncoder, index_getRecipientCodec as getRecipientCodec, index_getRecipientDecoder as getRecipientDecoder, index_getRecipientEncoder as getRecipientEncoder, index_getRegisterLaunchArgsCodec as getRegisterLaunchArgsCodec, index_getRegisterLaunchArgsDecoder as getRegisterLaunchArgsDecoder, index_getRegisterLaunchArgsEncoder as getRegisterLaunchArgsEncoder };
+}
+
+export { ACCOUNT_DISCRIMINATORS, ACCOUNT_ROLE_READONLY, ACCOUNT_ROLE_SIGNER, ACCOUNT_ROLE_WRITABLE, ACCOUNT_ROLE_WRITABLE_SIGNER, ACCOUNT_VERSION, type AddLiquidityAccounts, AddLiquidityArgs, type AddLiquidityArgsWithOracle, AddLiquidityQuote, AmmConfig, BPS_DENOM, CPMM_ERROR_MESSAGES, type ClosePositionAccounts, type CollectFeesAccounts, CollectFeesArgs, type CollectProtocolFeesAccounts, CollectProtocolFeesArgs, CpmmError, CpmmErrorCode, type CreatePositionAccounts, CreatePositionArgs, CurveParams, CurveParamsToMarketCapInput, type FetchPoolsConfig, INSTRUCTION_DISCRIMINATORS, type InitializeConfigAccounts$1 as InitializeConfigAccounts, InitializeConfigArgs$1 as InitializeConfigArgs, type InitializeOracleAccounts, InitializeOracleArgs, type InitializePoolAccounts, InitializePoolArgs, MAX_FEE_AMOUNT, MAX_ORACLE_OBSERVATIONS, MAX_SENTINEL_ALLOWLIST$1 as MAX_SENTINEL_ALLOWLIST, MarketCapToCurveParamsInput, MarketCapValidationResult, type OracleConsultAccounts, OracleConsultArgs, type OracleConsultResult, OracleState, type OracleUpdateAccounts, PROGRAM_ID, type PauseAccounts, Pool, type PoolWithAddress, Position, Q64_ONE, type QuoteToNumeraireAccounts, QuoteToNumeraireArgs, type QuoteToNumeraireResult, type RemoveLiquidityAccounts, RemoveLiquidityArgs, RemoveLiquidityQuote, SEED_AUTHORITY, SEED_CONFIG$1 as SEED_CONFIG, SEED_ORACLE, SEED_POOL, SEED_POSITION, SEED_PROTOCOL_POSITION, SENTINEL_NO_CHANGE$1 as SENTINEL_NO_CHANGE, SENTINEL_PROGRAM_ID, SF_AFTER_ADD_LIQ, SF_AFTER_REMOVE_LIQ, SF_AFTER_SWAP$1 as SF_AFTER_SWAP, SF_BEFORE_ADD_LIQ, SF_BEFORE_REMOVE_LIQ, SF_BEFORE_SWAP$1 as SF_BEFORE_SWAP, SYSTEM_PROGRAM_ID, type SetFeesAccounts, SetFeesArgs, type SetRouteAccounts, SetRouteArgs, type SetSentinelAccounts, SetSentinelArgs, type SkimAccounts, SwapDirection, type SwapExactInAccounts, SwapExactInArgs, SwapQuote, TOKEN_METADATA_PROGRAM_ID, TOKEN_PROGRAM_ID, type TransferAdminAccounts, TransferAdminArgs, type UnpauseAccounts, areMintsOrdered, calculateAccruedFees, calculateTwap, calculateTwapNumber, ceilDiv, computePrice0Q64, computePrice1Q64, index as cpmmMigrator, createAddLiquidityInstruction, createClosePositionInstruction, createCollectFeesInstruction, createCollectProtocolFeesInstruction, createCreatePositionInstruction, createInitializeConfigInstruction$1 as createInitializeConfigInstruction, createInitializeOracleInstruction, createInitializePoolInstruction, createOracleConsultInstruction, createOracleUpdateInstruction, createPauseInstruction, createQuoteToNumeraireInstruction, createRemoveLiquidityInstruction, createSetFeesInstruction, createSetRouteInstruction, createSetSentinelInstruction, createSkimInstruction, createSwapExactInInstruction, createSwapInstruction, createTransferAdminInstruction, createUnpauseInstruction, curveParamsToMarketCap, decodeAmmConfig, decodeOracleConsultResult, decodeOracleState, decodePool, decodePosition, decodeQuoteToNumeraireResult, fetchAllPools, fetchConfig, fetchConfigWithAddress, fetchPool, fetchPoolsBatch, filterPoolsByMint, getAddLiquidityQuote, getConfigAddress$1 as getConfigAddress, getErrorMessage, getK, getLiquidityAddresses, getMetadataAddress, getOracleAddress, getPendingFees, getPoolAddress, getPoolAddressFromMints, getPoolAuthorityAddress, getPoolByMints, getPoolInitAddresses, getPositionAddress, getProtocolPositionAddress, getRemoveLiquidityQuote, getSpotPrice0, getSpotPrice1, getSwapAddresses, getSwapQuote, getSwapQuoteExactOut, getTvl, index$1 as initializer, isCpmmError, isqrt, marketCapToCurveParams, marketCapToSingleCurveParams, marketCapToTokenPrice, maxBigInt, minBigInt, numberToQ64, parseErrorFromLogs, poolExists, q64Div, q64Mul, q64ToNumber, ratioToNumber, sortMints, sortPoolsByReserves, validateMarketCapParameters };