@whetstone-research/doppler-sdk 1.0.2 → 1.0.4

package/dist/solana/index.d.cts

@@ -0,0 +1,4584 @@
+import { Address, ReadonlyUint8Array, Codec, ProgramDerivedAddress, Instruction, TransactionSigner, Rpc, GetAccountInfoApi, FixedSizeDecoder, FixedSizeEncoder, FixedSizeCodec, Encoder, Decoder, OptionOrNullable, Option, EncodedAccount, Account, MaybeEncodedAccount, MaybeAccount, fetchEncodedAccount, FetchAccountConfig, fetchEncodedAccounts, FetchAccountsConfig, SolanaError, SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM, InstructionWithData, ClientWithRpc, GetMultipleAccountsApi, ClientWithPayer, ClientWithTransactionPlanning, ClientWithTransactionSending, AccountMeta, InstructionWithAccounts, WritableAccount, ReadonlyAccount, ReadonlySignerAccount, AccountSignerMeta, WritableSignerAccount } from '@solana/kit';
+import { A as AmmConfig, P as Pool, a as Position, O as OracleState$2, S as SwapExactInArgs, b as AddLiquidityArgs, R as RemoveLiquidityArgs, C as CollectFeesArgs, c as CollectProtocolFeesArgs, d as CreatePositionArgs, I as InitializeConfigArgs$1, e as InitializePoolArgs, f as InitializeOracleArgs$1, g as SetSentinelArgs, h as SetFeesArgs, i as SetRouteArgs, T as TransferAdminArgs, j as OracleConsultArgs, Q as QuoteToNumeraireArgs, k as Observation, l as SwapDirection, m as SwapQuote, n as SwapQuoteExactOut, o as AddLiquidityQuote, p as RemoveLiquidityQuote, M as MarketCapValidationResult, q as MarketCapToCurveParamsInput, r as CurveParams, s as CurveParamsToMarketCapInput, G as GetProgramAccountsRpc, t as AddLiquidityEvent, u as AdminTransferredEvent, v as CollectFeesEvent, w as CollectProtocolFeesEvent, F as FeesUpdatedEvent, x as FetchOracleConfig, y as FetchPositionsConfig, z as OracleInitializedEvent, B as OracleUpdatedEvent, D as OracleWithAddress, E as PausedEvent, H as PoolInitializedEvent, J as PositionClosedEvent, K as PositionCreatedEvent, L as PositionValue, N as PositionWithAddress, U as RemoveLiquidityEvent, V as RouteUpdatedEvent, W as SentinelErrorEvent, X as SentinelInvokedEvent, Y as SentinelUpdatedEvent, Z as SkimmedEvent, _ as SwapEvent, $ as TwapResult, a0 as UnpausedEvent, a1 as comparePoolAndOraclePrices, a2 as consultTwap, a3 as fetchOracle, a4 as fetchOraclesBatch, a5 as fetchPoolPositions, a6 as fetchPosition, a7 as fetchPositionByParams, a8 as fetchPositionsBatch, a9 as fetchUserPositions, aa as filterActivePositions, ab as getOracleAddressFromPool, ac as getOracleAge, ad as getOracleBufferStats, ae as getOracleDeviation, af as getOracleForPool, ag as getOracleSpotPrices, ah as getPositionAddressFromParams, ai as getPositionValue, aj as isOracleStale, ak as sortPositionsByShares } from '../oracle-CU-nZnja.cjs';
+import { SelfFetchFunctions, SelfPlanAndSendFunctions } from '@solana/program-client-core';
+
+/**
+ * CPMM AMM program ID (devnet)
+ */
+declare const CPMM_PROGRAM_ID: Address;
+/**
+ * Metaplex Token Metadata Program ID
+ */
+declare const TOKEN_METADATA_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;
+/**
+ * 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.
+ */
+
+declare const observationCodec: Codec<Observation>;
+declare const ammConfigDataCodec: Codec<AmmConfig>;
+declare const poolDataCodec: Codec<Pool>;
+declare const positionDataCodec: Codec<Position>;
+declare const oracleStateDataCodec: Codec<OracleState$2>;
+/**
+ * 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$2(data: ReadonlyUint8Array): OracleState$2;
+/**
+ * Encode instruction data with discriminator prefix
+ */
+declare function encodeInstructionData<T>(discriminator: Uint8Array, codec?: {
+    encode: (args: T) => ReadonlyUint8Array | Uint8Array;
+}, args?: T): Uint8Array;
+type AddLiquidityArgsWithOracle$1 = AddLiquidityArgs & {
+    updateOracle?: boolean;
+};
+declare const swapExactInArgsCodec: Codec<SwapExactInArgs>;
+declare const addLiquidityArgsCodec: Codec<AddLiquidityArgsWithOracle$1>;
+declare const removeLiquidityArgsCodec: Codec<RemoveLiquidityArgs>;
+declare const collectFeesArgsCodec: Codec<CollectFeesArgs>;
+declare const collectProtocolFeesArgsCodec: Codec<CollectProtocolFeesArgs>;
+declare const createPositionArgsCodec: Codec<CreatePositionArgs>;
+declare const initializeConfigArgsCodec: Codec<InitializeConfigArgs$1>;
+declare const initializePoolArgsCodec: Codec<InitializePoolArgs>;
+declare const initializeOracleArgsCodec: Codec<InitializeOracleArgs$1>;
+declare const setSentinelArgsCodec: Codec<SetSentinelArgs>;
+declare const setFeesArgsCodec: Codec<SetFeesArgs>;
+declare const setRouteArgsCodec: Codec<SetRouteArgs>;
+declare const transferAdminArgsCodec: Codec<TransferAdminArgs>;
+declare const oracleConsultArgsCodec: Codec<OracleConsultArgs>;
+declare const quoteToNumeraireArgsCodec: Codec<QuoteToNumeraireArgs>;
+/** Encode SwapExactIn args */
+declare function encodeSwapExactInArgs(args: SwapExactInArgs): Uint8Array;
+/** Encode AddLiquidity args */
+declare function encodeAddLiquidityArgs(args: AddLiquidityArgsWithOracle$1): Uint8Array;
+/** Encode RemoveLiquidity args */
+declare function encodeRemoveLiquidityArgs(args: RemoveLiquidityArgs): Uint8Array;
+/** Encode CollectFees args */
+declare function encodeCollectFeesArgs(args: CollectFeesArgs): Uint8Array;
+/** Encode CollectProtocolFees args */
+declare function encodeCollectProtocolFeesArgs(args: CollectProtocolFeesArgs): Uint8Array;
+/** Encode CreatePosition args */
+declare function encodeCreatePositionArgs(args: CreatePositionArgs): Uint8Array;
+/** Encode InitializeConfig args */
+declare function encodeInitializeConfigArgs(args: InitializeConfigArgs$1): Uint8Array;
+/** Encode InitializePool args */
+declare function encodeInitializePoolArgs(args: InitializePoolArgs): Uint8Array;
+/** Encode InitializeOracle args */
+declare function encodeInitializeOracleArgs(args: InitializeOracleArgs$1): Uint8Array;
+/** Encode SetSentinel args */
+declare function encodeSetSentinelArgs(args: SetSentinelArgs): Uint8Array;
+/** Encode SetFees args */
+declare function encodeSetFeesArgs(args: SetFeesArgs): Uint8Array;
+/** Encode SetRoute args */
+declare function encodeSetRouteArgs(args: SetRouteArgs): Uint8Array;
+/** Encode TransferAdmin args */
+declare function encodeTransferAdminArgs(args: TransferAdminArgs): Uint8Array;
+/** Encode OracleConsult args */
+declare function encodeOracleConsultArgs(args: OracleConsultArgs): Uint8Array;
+/** Encode QuoteToNumeraire args */
+declare function encodeQuoteToNumeraireArgs(args: QuoteToNumeraireArgs): Uint8Array;
+
+/**
+ * Sort two mints into canonical order (token0 < token1 by bytes)
+ * This is required for Pool PDA derivation and instruction ordering.
+ *
+ * @param mint0 - First mint address
+ * @param mint1 - Second mint address
+ * @returns Tuple of [token0, token1] in canonical order
+ * @throws Error if mints are equal
+ */
+declare function sortMints(mint0: Address, mint1: 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(mint0: Address, mint1: 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(mint0: Address, mint1: 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): SwapQuoteExactOut;
+/**
+ * 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?: SwapDirection): 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$1, 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 mint0 - First token mint
+ * @param mint1 - 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, wsolMint);
+ * if (result) {
+ *   console.log(`Found pool at ${result.address}`);
+ *   console.log(`Swap fee: ${result.account.swapFeeBps} bps`);
+ * }
+ * ```
+ */
+declare function getPoolByMints(rpc: Rpc<GetAccountInfoApi>, mint0: Address, mint1: 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 mint0 - First token mint
+ * @param mint1 - Second token mint
+ * @param config - Optional configuration
+ * @returns true if pool exists, false otherwise
+ */
+declare function poolExists(rpc: Rpc<GetAccountInfoApi>, mint0: Address, mint1: Address, config?: FetchPoolsConfig): Promise<boolean>;
+/**
+ * Get the pool address for a token pair without fetching
+ *
+ * @param mint0 - First token mint
+ * @param mint1 - Second token mint
+ * @param programId - Program ID (defaults to CPMM program)
+ * @returns Pool address and sorted mints
+ */
+declare function getPoolAddressFromMints(mint0: Address, mint1: 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>;
+
+declare const index$4_ACCOUNT_DISCRIMINATORS: typeof ACCOUNT_DISCRIMINATORS;
+declare const index$4_ACCOUNT_VERSION: typeof ACCOUNT_VERSION;
+type index$4_AddLiquidityAccounts = AddLiquidityAccounts;
+declare const index$4_AddLiquidityArgs: typeof AddLiquidityArgs;
+type index$4_AddLiquidityArgsWithOracle = AddLiquidityArgsWithOracle;
+declare const index$4_AddLiquidityEvent: typeof AddLiquidityEvent;
+declare const index$4_AddLiquidityQuote: typeof AddLiquidityQuote;
+declare const index$4_AdminTransferredEvent: typeof AdminTransferredEvent;
+declare const index$4_AmmConfig: typeof AmmConfig;
+declare const index$4_BPS_DENOM: typeof BPS_DENOM;
+declare const index$4_CPMM_ERROR_MESSAGES: typeof CPMM_ERROR_MESSAGES;
+declare const index$4_CPMM_PROGRAM_ID: typeof CPMM_PROGRAM_ID;
+type index$4_ClosePositionAccounts = ClosePositionAccounts;
+type index$4_CollectFeesAccounts = CollectFeesAccounts;
+declare const index$4_CollectFeesArgs: typeof CollectFeesArgs;
+declare const index$4_CollectFeesEvent: typeof CollectFeesEvent;
+type index$4_CollectProtocolFeesAccounts = CollectProtocolFeesAccounts;
+declare const index$4_CollectProtocolFeesArgs: typeof CollectProtocolFeesArgs;
+declare const index$4_CollectProtocolFeesEvent: typeof CollectProtocolFeesEvent;
+type index$4_CpmmError = CpmmError;
+declare const index$4_CpmmError: typeof CpmmError;
+type index$4_CpmmErrorCode = CpmmErrorCode;
+declare const index$4_CpmmErrorCode: typeof CpmmErrorCode;
+type index$4_CreatePositionAccounts = CreatePositionAccounts;
+declare const index$4_CreatePositionArgs: typeof CreatePositionArgs;
+declare const index$4_CurveParams: typeof CurveParams;
+declare const index$4_CurveParamsToMarketCapInput: typeof CurveParamsToMarketCapInput;
+declare const index$4_FeesUpdatedEvent: typeof FeesUpdatedEvent;
+declare const index$4_FetchOracleConfig: typeof FetchOracleConfig;
+type index$4_FetchPoolsConfig = FetchPoolsConfig;
+declare const index$4_FetchPositionsConfig: typeof FetchPositionsConfig;
+declare const index$4_INSTRUCTION_DISCRIMINATORS: typeof INSTRUCTION_DISCRIMINATORS;
+type index$4_InitializeOracleAccounts = InitializeOracleAccounts;
+type index$4_InitializePoolAccounts = InitializePoolAccounts;
+declare const index$4_InitializePoolArgs: typeof InitializePoolArgs;
+declare const index$4_MAX_FEE_AMOUNT: typeof MAX_FEE_AMOUNT;
+declare const index$4_MAX_ORACLE_OBSERVATIONS: typeof MAX_ORACLE_OBSERVATIONS;
+declare const index$4_MarketCapToCurveParamsInput: typeof MarketCapToCurveParamsInput;
+declare const index$4_MarketCapValidationResult: typeof MarketCapValidationResult;
+declare const index$4_Observation: typeof Observation;
+type index$4_OracleConsultAccounts = OracleConsultAccounts;
+declare const index$4_OracleConsultArgs: typeof OracleConsultArgs;
+type index$4_OracleConsultResult = OracleConsultResult;
+declare const index$4_OracleInitializedEvent: typeof OracleInitializedEvent;
+type index$4_OracleUpdateAccounts = OracleUpdateAccounts;
+declare const index$4_OracleUpdatedEvent: typeof OracleUpdatedEvent;
+declare const index$4_OracleWithAddress: typeof OracleWithAddress;
+type index$4_PauseAccounts = PauseAccounts;
+declare const index$4_PausedEvent: typeof PausedEvent;
+declare const index$4_Pool: typeof Pool;
+declare const index$4_PoolInitializedEvent: typeof PoolInitializedEvent;
+type index$4_PoolWithAddress = PoolWithAddress;
+declare const index$4_Position: typeof Position;
+declare const index$4_PositionClosedEvent: typeof PositionClosedEvent;
+declare const index$4_PositionCreatedEvent: typeof PositionCreatedEvent;
+declare const index$4_PositionValue: typeof PositionValue;
+declare const index$4_PositionWithAddress: typeof PositionWithAddress;
+declare const index$4_Q64_ONE: typeof Q64_ONE;
+type index$4_QuoteToNumeraireAccounts = QuoteToNumeraireAccounts;
+declare const index$4_QuoteToNumeraireArgs: typeof QuoteToNumeraireArgs;
+type index$4_QuoteToNumeraireResult = QuoteToNumeraireResult;
+type index$4_RemoveLiquidityAccounts = RemoveLiquidityAccounts;
+declare const index$4_RemoveLiquidityArgs: typeof RemoveLiquidityArgs;
+declare const index$4_RemoveLiquidityEvent: typeof RemoveLiquidityEvent;
+declare const index$4_RemoveLiquidityQuote: typeof RemoveLiquidityQuote;
+declare const index$4_RouteUpdatedEvent: typeof RouteUpdatedEvent;
+declare const index$4_SEED_AUTHORITY: typeof SEED_AUTHORITY;
+declare const index$4_SEED_ORACLE: typeof SEED_ORACLE;
+declare const index$4_SEED_POOL: typeof SEED_POOL;
+declare const index$4_SEED_POSITION: typeof SEED_POSITION;
+declare const index$4_SEED_PROTOCOL_POSITION: typeof SEED_PROTOCOL_POSITION;
+declare const index$4_SF_AFTER_ADD_LIQ: typeof SF_AFTER_ADD_LIQ;
+declare const index$4_SF_AFTER_REMOVE_LIQ: typeof SF_AFTER_REMOVE_LIQ;
+declare const index$4_SF_BEFORE_ADD_LIQ: typeof SF_BEFORE_ADD_LIQ;
+declare const index$4_SF_BEFORE_REMOVE_LIQ: typeof SF_BEFORE_REMOVE_LIQ;
+declare const index$4_SentinelErrorEvent: typeof SentinelErrorEvent;
+declare const index$4_SentinelInvokedEvent: typeof SentinelInvokedEvent;
+declare const index$4_SentinelUpdatedEvent: typeof SentinelUpdatedEvent;
+type index$4_SetFeesAccounts = SetFeesAccounts;
+declare const index$4_SetFeesArgs: typeof SetFeesArgs;
+type index$4_SetRouteAccounts = SetRouteAccounts;
+declare const index$4_SetRouteArgs: typeof SetRouteArgs;
+type index$4_SetSentinelAccounts = SetSentinelAccounts;
+declare const index$4_SetSentinelArgs: typeof SetSentinelArgs;
+type index$4_SkimAccounts = SkimAccounts;
+declare const index$4_SkimmedEvent: typeof SkimmedEvent;
+declare const index$4_SwapDirection: typeof SwapDirection;
+declare const index$4_SwapEvent: typeof SwapEvent;
+type index$4_SwapExactInAccounts = SwapExactInAccounts;
+declare const index$4_SwapExactInArgs: typeof SwapExactInArgs;
+declare const index$4_SwapQuote: typeof SwapQuote;
+declare const index$4_SwapQuoteExactOut: typeof SwapQuoteExactOut;
+declare const index$4_TOKEN_METADATA_PROGRAM_ID: typeof TOKEN_METADATA_PROGRAM_ID;
+type index$4_TransferAdminAccounts = TransferAdminAccounts;
+declare const index$4_TransferAdminArgs: typeof TransferAdminArgs;
+declare const index$4_TwapResult: typeof TwapResult;
+type index$4_UnpauseAccounts = UnpauseAccounts;
+declare const index$4_UnpausedEvent: typeof UnpausedEvent;
+declare const index$4_addLiquidityArgsCodec: typeof addLiquidityArgsCodec;
+declare const index$4_ammConfigDataCodec: typeof ammConfigDataCodec;
+declare const index$4_areMintsOrdered: typeof areMintsOrdered;
+declare const index$4_calculateAccruedFees: typeof calculateAccruedFees;
+declare const index$4_calculateTwap: typeof calculateTwap;
+declare const index$4_calculateTwapNumber: typeof calculateTwapNumber;
+declare const index$4_ceilDiv: typeof ceilDiv;
+declare const index$4_collectFeesArgsCodec: typeof collectFeesArgsCodec;
+declare const index$4_collectProtocolFeesArgsCodec: typeof collectProtocolFeesArgsCodec;
+declare const index$4_comparePoolAndOraclePrices: typeof comparePoolAndOraclePrices;
+declare const index$4_computePrice0Q64: typeof computePrice0Q64;
+declare const index$4_computePrice1Q64: typeof computePrice1Q64;
+declare const index$4_consultTwap: typeof consultTwap;
+declare const index$4_createAddLiquidityInstruction: typeof createAddLiquidityInstruction;
+declare const index$4_createClosePositionInstruction: typeof createClosePositionInstruction;
+declare const index$4_createCollectFeesInstruction: typeof createCollectFeesInstruction;
+declare const index$4_createCollectProtocolFeesInstruction: typeof createCollectProtocolFeesInstruction;
+declare const index$4_createCreatePositionInstruction: typeof createCreatePositionInstruction;
+declare const index$4_createInitializeOracleInstruction: typeof createInitializeOracleInstruction;
+declare const index$4_createInitializePoolInstruction: typeof createInitializePoolInstruction;
+declare const index$4_createOracleConsultInstruction: typeof createOracleConsultInstruction;
+declare const index$4_createOracleUpdateInstruction: typeof createOracleUpdateInstruction;
+declare const index$4_createPauseInstruction: typeof createPauseInstruction;
+declare const index$4_createPositionArgsCodec: typeof createPositionArgsCodec;
+declare const index$4_createQuoteToNumeraireInstruction: typeof createQuoteToNumeraireInstruction;
+declare const index$4_createRemoveLiquidityInstruction: typeof createRemoveLiquidityInstruction;
+declare const index$4_createSetFeesInstruction: typeof createSetFeesInstruction;
+declare const index$4_createSetRouteInstruction: typeof createSetRouteInstruction;
+declare const index$4_createSetSentinelInstruction: typeof createSetSentinelInstruction;
+declare const index$4_createSkimInstruction: typeof createSkimInstruction;
+declare const index$4_createSwapExactInInstruction: typeof createSwapExactInInstruction;
+declare const index$4_createSwapInstruction: typeof createSwapInstruction;
+declare const index$4_createTransferAdminInstruction: typeof createTransferAdminInstruction;
+declare const index$4_createUnpauseInstruction: typeof createUnpauseInstruction;
+declare const index$4_curveParamsToMarketCap: typeof curveParamsToMarketCap;
+declare const index$4_decodeAmmConfig: typeof decodeAmmConfig;
+declare const index$4_decodeOracleConsultResult: typeof decodeOracleConsultResult;
+declare const index$4_decodePool: typeof decodePool;
+declare const index$4_decodePosition: typeof decodePosition;
+declare const index$4_decodeQuoteToNumeraireResult: typeof decodeQuoteToNumeraireResult;
+declare const index$4_encodeAddLiquidityArgs: typeof encodeAddLiquidityArgs;
+declare const index$4_encodeCollectFeesArgs: typeof encodeCollectFeesArgs;
+declare const index$4_encodeCollectProtocolFeesArgs: typeof encodeCollectProtocolFeesArgs;
+declare const index$4_encodeCreatePositionArgs: typeof encodeCreatePositionArgs;
+declare const index$4_encodeInitializeConfigArgs: typeof encodeInitializeConfigArgs;
+declare const index$4_encodeInitializeOracleArgs: typeof encodeInitializeOracleArgs;
+declare const index$4_encodeInitializePoolArgs: typeof encodeInitializePoolArgs;
+declare const index$4_encodeInstructionData: typeof encodeInstructionData;
+declare const index$4_encodeOracleConsultArgs: typeof encodeOracleConsultArgs;
+declare const index$4_encodeQuoteToNumeraireArgs: typeof encodeQuoteToNumeraireArgs;
+declare const index$4_encodeRemoveLiquidityArgs: typeof encodeRemoveLiquidityArgs;
+declare const index$4_encodeSetFeesArgs: typeof encodeSetFeesArgs;
+declare const index$4_encodeSetRouteArgs: typeof encodeSetRouteArgs;
+declare const index$4_encodeSetSentinelArgs: typeof encodeSetSentinelArgs;
+declare const index$4_encodeSwapExactInArgs: typeof encodeSwapExactInArgs;
+declare const index$4_encodeTransferAdminArgs: typeof encodeTransferAdminArgs;
+declare const index$4_fetchAllPools: typeof fetchAllPools;
+declare const index$4_fetchConfig: typeof fetchConfig;
+declare const index$4_fetchConfigWithAddress: typeof fetchConfigWithAddress;
+declare const index$4_fetchOracle: typeof fetchOracle;
+declare const index$4_fetchOraclesBatch: typeof fetchOraclesBatch;
+declare const index$4_fetchPool: typeof fetchPool;
+declare const index$4_fetchPoolPositions: typeof fetchPoolPositions;
+declare const index$4_fetchPoolsBatch: typeof fetchPoolsBatch;
+declare const index$4_fetchPosition: typeof fetchPosition;
+declare const index$4_fetchPositionByParams: typeof fetchPositionByParams;
+declare const index$4_fetchPositionsBatch: typeof fetchPositionsBatch;
+declare const index$4_fetchUserPositions: typeof fetchUserPositions;
+declare const index$4_filterActivePositions: typeof filterActivePositions;
+declare const index$4_filterPoolsByMint: typeof filterPoolsByMint;
+declare const index$4_getAddLiquidityQuote: typeof getAddLiquidityQuote;
+declare const index$4_getErrorMessage: typeof getErrorMessage;
+declare const index$4_getK: typeof getK;
+declare const index$4_getLiquidityAddresses: typeof getLiquidityAddresses;
+declare const index$4_getMetadataAddress: typeof getMetadataAddress;
+declare const index$4_getOracleAddress: typeof getOracleAddress;
+declare const index$4_getOracleAddressFromPool: typeof getOracleAddressFromPool;
+declare const index$4_getOracleAge: typeof getOracleAge;
+declare const index$4_getOracleBufferStats: typeof getOracleBufferStats;
+declare const index$4_getOracleDeviation: typeof getOracleDeviation;
+declare const index$4_getOracleForPool: typeof getOracleForPool;
+declare const index$4_getOracleSpotPrices: typeof getOracleSpotPrices;
+declare const index$4_getPendingFees: typeof getPendingFees;
+declare const index$4_getPoolAddress: typeof getPoolAddress;
+declare const index$4_getPoolAddressFromMints: typeof getPoolAddressFromMints;
+declare const index$4_getPoolAuthorityAddress: typeof getPoolAuthorityAddress;
+declare const index$4_getPoolByMints: typeof getPoolByMints;
+declare const index$4_getPoolInitAddresses: typeof getPoolInitAddresses;
+declare const index$4_getPositionAddress: typeof getPositionAddress;
+declare const index$4_getPositionAddressFromParams: typeof getPositionAddressFromParams;
+declare const index$4_getPositionValue: typeof getPositionValue;
+declare const index$4_getProtocolPositionAddress: typeof getProtocolPositionAddress;
+declare const index$4_getRemoveLiquidityQuote: typeof getRemoveLiquidityQuote;
+declare const index$4_getSpotPrice0: typeof getSpotPrice0;
+declare const index$4_getSpotPrice1: typeof getSpotPrice1;
+declare const index$4_getSwapAddresses: typeof getSwapAddresses;
+declare const index$4_getSwapQuote: typeof getSwapQuote;
+declare const index$4_getSwapQuoteExactOut: typeof getSwapQuoteExactOut;
+declare const index$4_getTvl: typeof getTvl;
+declare const index$4_initializeConfigArgsCodec: typeof initializeConfigArgsCodec;
+declare const index$4_initializeOracleArgsCodec: typeof initializeOracleArgsCodec;
+declare const index$4_initializePoolArgsCodec: typeof initializePoolArgsCodec;
+declare const index$4_isCpmmError: typeof isCpmmError;
+declare const index$4_isOracleStale: typeof isOracleStale;
+declare const index$4_isqrt: typeof isqrt;
+declare const index$4_marketCapToCurveParams: typeof marketCapToCurveParams;
+declare const index$4_marketCapToSingleCurveParams: typeof marketCapToSingleCurveParams;
+declare const index$4_marketCapToTokenPrice: typeof marketCapToTokenPrice;
+declare const index$4_maxBigInt: typeof maxBigInt;
+declare const index$4_minBigInt: typeof minBigInt;
+declare const index$4_numberToQ64: typeof numberToQ64;
+declare const index$4_observationCodec: typeof observationCodec;
+declare const index$4_oracleConsultArgsCodec: typeof oracleConsultArgsCodec;
+declare const index$4_oracleStateDataCodec: typeof oracleStateDataCodec;
+declare const index$4_parseErrorFromLogs: typeof parseErrorFromLogs;
+declare const index$4_poolDataCodec: typeof poolDataCodec;
+declare const index$4_poolExists: typeof poolExists;
+declare const index$4_positionDataCodec: typeof positionDataCodec;
+declare const index$4_q64Div: typeof q64Div;
+declare const index$4_q64Mul: typeof q64Mul;
+declare const index$4_q64ToNumber: typeof q64ToNumber;
+declare const index$4_quoteToNumeraireArgsCodec: typeof quoteToNumeraireArgsCodec;
+declare const index$4_ratioToNumber: typeof ratioToNumber;
+declare const index$4_removeLiquidityArgsCodec: typeof removeLiquidityArgsCodec;
+declare const index$4_setFeesArgsCodec: typeof setFeesArgsCodec;
+declare const index$4_setRouteArgsCodec: typeof setRouteArgsCodec;
+declare const index$4_setSentinelArgsCodec: typeof setSentinelArgsCodec;
+declare const index$4_sortMints: typeof sortMints;
+declare const index$4_sortPoolsByReserves: typeof sortPoolsByReserves;
+declare const index$4_sortPositionsByShares: typeof sortPositionsByShares;
+declare const index$4_swapExactInArgsCodec: typeof swapExactInArgsCodec;
+declare const index$4_transferAdminArgsCodec: typeof transferAdminArgsCodec;
+declare const index$4_validateMarketCapParameters: typeof validateMarketCapParameters;
+declare namespace index$4 {
+  export { index$4_ACCOUNT_DISCRIMINATORS as ACCOUNT_DISCRIMINATORS, index$4_ACCOUNT_VERSION as ACCOUNT_VERSION, type index$4_AddLiquidityAccounts as AddLiquidityAccounts, index$4_AddLiquidityArgs as AddLiquidityArgs, type index$4_AddLiquidityArgsWithOracle as AddLiquidityArgsWithOracle, index$4_AddLiquidityEvent as AddLiquidityEvent, index$4_AddLiquidityQuote as AddLiquidityQuote, index$4_AdminTransferredEvent as AdminTransferredEvent, index$4_AmmConfig as AmmConfig, index$4_BPS_DENOM as BPS_DENOM, index$4_CPMM_ERROR_MESSAGES as CPMM_ERROR_MESSAGES, index$4_CPMM_PROGRAM_ID as CPMM_PROGRAM_ID, type index$4_ClosePositionAccounts as ClosePositionAccounts, type index$4_CollectFeesAccounts as CollectFeesAccounts, index$4_CollectFeesArgs as CollectFeesArgs, index$4_CollectFeesEvent as CollectFeesEvent, type index$4_CollectProtocolFeesAccounts as CollectProtocolFeesAccounts, index$4_CollectProtocolFeesArgs as CollectProtocolFeesArgs, index$4_CollectProtocolFeesEvent as CollectProtocolFeesEvent, index$4_CpmmError as CpmmError, index$4_CpmmErrorCode as CpmmErrorCode, type index$4_CreatePositionAccounts as CreatePositionAccounts, index$4_CreatePositionArgs as CreatePositionArgs, index$4_CurveParams as CurveParams, index$4_CurveParamsToMarketCapInput as CurveParamsToMarketCapInput, index$4_FeesUpdatedEvent as FeesUpdatedEvent, index$4_FetchOracleConfig as FetchOracleConfig, type index$4_FetchPoolsConfig as FetchPoolsConfig, index$4_FetchPositionsConfig as FetchPositionsConfig, index$4_INSTRUCTION_DISCRIMINATORS as INSTRUCTION_DISCRIMINATORS, type InitializeConfigAccounts$1 as InitializeConfigAccounts, InitializeConfigArgs$1 as InitializeConfigArgs, type index$4_InitializeOracleAccounts as InitializeOracleAccounts, InitializeOracleArgs$1 as InitializeOracleArgs, type index$4_InitializePoolAccounts as InitializePoolAccounts, index$4_InitializePoolArgs as InitializePoolArgs, index$4_MAX_FEE_AMOUNT as MAX_FEE_AMOUNT, index$4_MAX_ORACLE_OBSERVATIONS as MAX_ORACLE_OBSERVATIONS, MAX_SENTINEL_ALLOWLIST$1 as MAX_SENTINEL_ALLOWLIST, index$4_MarketCapToCurveParamsInput as MarketCapToCurveParamsInput, index$4_MarketCapValidationResult as MarketCapValidationResult, index$4_Observation as Observation, type index$4_OracleConsultAccounts as OracleConsultAccounts, index$4_OracleConsultArgs as OracleConsultArgs, type index$4_OracleConsultResult as OracleConsultResult, index$4_OracleInitializedEvent as OracleInitializedEvent, OracleState$2 as OracleState, type index$4_OracleUpdateAccounts as OracleUpdateAccounts, index$4_OracleUpdatedEvent as OracleUpdatedEvent, index$4_OracleWithAddress as OracleWithAddress, type index$4_PauseAccounts as PauseAccounts, index$4_PausedEvent as PausedEvent, index$4_Pool as Pool, index$4_PoolInitializedEvent as PoolInitializedEvent, type index$4_PoolWithAddress as PoolWithAddress, index$4_Position as Position, index$4_PositionClosedEvent as PositionClosedEvent, index$4_PositionCreatedEvent as PositionCreatedEvent, index$4_PositionValue as PositionValue, index$4_PositionWithAddress as PositionWithAddress, index$4_Q64_ONE as Q64_ONE, type index$4_QuoteToNumeraireAccounts as QuoteToNumeraireAccounts, index$4_QuoteToNumeraireArgs as QuoteToNumeraireArgs, type index$4_QuoteToNumeraireResult as QuoteToNumeraireResult, type index$4_RemoveLiquidityAccounts as RemoveLiquidityAccounts, index$4_RemoveLiquidityArgs as RemoveLiquidityArgs, index$4_RemoveLiquidityEvent as RemoveLiquidityEvent, index$4_RemoveLiquidityQuote as RemoveLiquidityQuote, index$4_RouteUpdatedEvent as RouteUpdatedEvent, index$4_SEED_AUTHORITY as SEED_AUTHORITY, SEED_CONFIG$1 as SEED_CONFIG, index$4_SEED_ORACLE as SEED_ORACLE, index$4_SEED_POOL as SEED_POOL, index$4_SEED_POSITION as SEED_POSITION, index$4_SEED_PROTOCOL_POSITION as SEED_PROTOCOL_POSITION, SENTINEL_NO_CHANGE$1 as SENTINEL_NO_CHANGE, index$4_SF_AFTER_ADD_LIQ as SF_AFTER_ADD_LIQ, index$4_SF_AFTER_REMOVE_LIQ as SF_AFTER_REMOVE_LIQ, SF_AFTER_SWAP$1 as SF_AFTER_SWAP, index$4_SF_BEFORE_ADD_LIQ as SF_BEFORE_ADD_LIQ, index$4_SF_BEFORE_REMOVE_LIQ as SF_BEFORE_REMOVE_LIQ, SF_BEFORE_SWAP$1 as SF_BEFORE_SWAP, index$4_SentinelErrorEvent as SentinelErrorEvent, index$4_SentinelInvokedEvent as SentinelInvokedEvent, index$4_SentinelUpdatedEvent as SentinelUpdatedEvent, type index$4_SetFeesAccounts as SetFeesAccounts, index$4_SetFeesArgs as SetFeesArgs, type index$4_SetRouteAccounts as SetRouteAccounts, index$4_SetRouteArgs as SetRouteArgs, type index$4_SetSentinelAccounts as SetSentinelAccounts, index$4_SetSentinelArgs as SetSentinelArgs, type index$4_SkimAccounts as SkimAccounts, index$4_SkimmedEvent as SkimmedEvent, index$4_SwapDirection as SwapDirection, index$4_SwapEvent as SwapEvent, type index$4_SwapExactInAccounts as SwapExactInAccounts, index$4_SwapExactInArgs as SwapExactInArgs, index$4_SwapQuote as SwapQuote, index$4_SwapQuoteExactOut as SwapQuoteExactOut, index$4_TOKEN_METADATA_PROGRAM_ID as TOKEN_METADATA_PROGRAM_ID, type index$4_TransferAdminAccounts as TransferAdminAccounts, index$4_TransferAdminArgs as TransferAdminArgs, index$4_TwapResult as TwapResult, type index$4_UnpauseAccounts as UnpauseAccounts, index$4_UnpausedEvent as UnpausedEvent, index$4_addLiquidityArgsCodec as addLiquidityArgsCodec, index$4_ammConfigDataCodec as ammConfigDataCodec, index$4_areMintsOrdered as areMintsOrdered, index$4_calculateAccruedFees as calculateAccruedFees, index$4_calculateTwap as calculateTwap, index$4_calculateTwapNumber as calculateTwapNumber, index$4_ceilDiv as ceilDiv, index$4_collectFeesArgsCodec as collectFeesArgsCodec, index$4_collectProtocolFeesArgsCodec as collectProtocolFeesArgsCodec, index$4_comparePoolAndOraclePrices as comparePoolAndOraclePrices, index$4_computePrice0Q64 as computePrice0Q64, index$4_computePrice1Q64 as computePrice1Q64, index$4_consultTwap as consultTwap, index$4_createAddLiquidityInstruction as createAddLiquidityInstruction, index$4_createClosePositionInstruction as createClosePositionInstruction, index$4_createCollectFeesInstruction as createCollectFeesInstruction, index$4_createCollectProtocolFeesInstruction as createCollectProtocolFeesInstruction, index$4_createCreatePositionInstruction as createCreatePositionInstruction, createInitializeConfigInstruction$1 as createInitializeConfigInstruction, index$4_createInitializeOracleInstruction as createInitializeOracleInstruction, index$4_createInitializePoolInstruction as createInitializePoolInstruction, index$4_createOracleConsultInstruction as createOracleConsultInstruction, index$4_createOracleUpdateInstruction as createOracleUpdateInstruction, index$4_createPauseInstruction as createPauseInstruction, index$4_createPositionArgsCodec as createPositionArgsCodec, index$4_createQuoteToNumeraireInstruction as createQuoteToNumeraireInstruction, index$4_createRemoveLiquidityInstruction as createRemoveLiquidityInstruction, index$4_createSetFeesInstruction as createSetFeesInstruction, index$4_createSetRouteInstruction as createSetRouteInstruction, index$4_createSetSentinelInstruction as createSetSentinelInstruction, index$4_createSkimInstruction as createSkimInstruction, index$4_createSwapExactInInstruction as createSwapExactInInstruction, index$4_createSwapInstruction as createSwapInstruction, index$4_createTransferAdminInstruction as createTransferAdminInstruction, index$4_createUnpauseInstruction as createUnpauseInstruction, index$4_curveParamsToMarketCap as curveParamsToMarketCap, index$4_decodeAmmConfig as decodeAmmConfig, index$4_decodeOracleConsultResult as decodeOracleConsultResult, decodeOracleState$2 as decodeOracleState, index$4_decodePool as decodePool, index$4_decodePosition as decodePosition, index$4_decodeQuoteToNumeraireResult as decodeQuoteToNumeraireResult, index$4_encodeAddLiquidityArgs as encodeAddLiquidityArgs, index$4_encodeCollectFeesArgs as encodeCollectFeesArgs, index$4_encodeCollectProtocolFeesArgs as encodeCollectProtocolFeesArgs, index$4_encodeCreatePositionArgs as encodeCreatePositionArgs, index$4_encodeInitializeConfigArgs as encodeInitializeConfigArgs, index$4_encodeInitializeOracleArgs as encodeInitializeOracleArgs, index$4_encodeInitializePoolArgs as encodeInitializePoolArgs, index$4_encodeInstructionData as encodeInstructionData, index$4_encodeOracleConsultArgs as encodeOracleConsultArgs, index$4_encodeQuoteToNumeraireArgs as encodeQuoteToNumeraireArgs, index$4_encodeRemoveLiquidityArgs as encodeRemoveLiquidityArgs, index$4_encodeSetFeesArgs as encodeSetFeesArgs, index$4_encodeSetRouteArgs as encodeSetRouteArgs, index$4_encodeSetSentinelArgs as encodeSetSentinelArgs, index$4_encodeSwapExactInArgs as encodeSwapExactInArgs, index$4_encodeTransferAdminArgs as encodeTransferAdminArgs, index$4_fetchAllPools as fetchAllPools, index$4_fetchConfig as fetchConfig, index$4_fetchConfigWithAddress as fetchConfigWithAddress, index$4_fetchOracle as fetchOracle, index$4_fetchOraclesBatch as fetchOraclesBatch, index$4_fetchPool as fetchPool, index$4_fetchPoolPositions as fetchPoolPositions, index$4_fetchPoolsBatch as fetchPoolsBatch, index$4_fetchPosition as fetchPosition, index$4_fetchPositionByParams as fetchPositionByParams, index$4_fetchPositionsBatch as fetchPositionsBatch, index$4_fetchUserPositions as fetchUserPositions, index$4_filterActivePositions as filterActivePositions, index$4_filterPoolsByMint as filterPoolsByMint, index$4_getAddLiquidityQuote as getAddLiquidityQuote, getConfigAddress$1 as getConfigAddress, index$4_getErrorMessage as getErrorMessage, index$4_getK as getK, index$4_getLiquidityAddresses as getLiquidityAddresses, index$4_getMetadataAddress as getMetadataAddress, index$4_getOracleAddress as getOracleAddress, index$4_getOracleAddressFromPool as getOracleAddressFromPool, index$4_getOracleAge as getOracleAge, index$4_getOracleBufferStats as getOracleBufferStats, index$4_getOracleDeviation as getOracleDeviation, index$4_getOracleForPool as getOracleForPool, index$4_getOracleSpotPrices as getOracleSpotPrices, index$4_getPendingFees as getPendingFees, index$4_getPoolAddress as getPoolAddress, index$4_getPoolAddressFromMints as getPoolAddressFromMints, index$4_getPoolAuthorityAddress as getPoolAuthorityAddress, index$4_getPoolByMints as getPoolByMints, index$4_getPoolInitAddresses as getPoolInitAddresses, index$4_getPositionAddress as getPositionAddress, index$4_getPositionAddressFromParams as getPositionAddressFromParams, index$4_getPositionValue as getPositionValue, index$4_getProtocolPositionAddress as getProtocolPositionAddress, index$4_getRemoveLiquidityQuote as getRemoveLiquidityQuote, index$4_getSpotPrice0 as getSpotPrice0, index$4_getSpotPrice1 as getSpotPrice1, index$4_getSwapAddresses as getSwapAddresses, index$4_getSwapQuote as getSwapQuote, index$4_getSwapQuoteExactOut as getSwapQuoteExactOut, index$4_getTvl as getTvl, index$4_initializeConfigArgsCodec as initializeConfigArgsCodec, index$4_initializeOracleArgsCodec as initializeOracleArgsCodec, index$4_initializePoolArgsCodec as initializePoolArgsCodec, index$4_isCpmmError as isCpmmError, index$4_isOracleStale as isOracleStale, index$4_isqrt as isqrt, index$4_marketCapToCurveParams as marketCapToCurveParams, index$4_marketCapToSingleCurveParams as marketCapToSingleCurveParams, index$4_marketCapToTokenPrice as marketCapToTokenPrice, index$4_maxBigInt as maxBigInt, index$4_minBigInt as minBigInt, index$4_numberToQ64 as numberToQ64, index$4_observationCodec as observationCodec, index$4_oracleConsultArgsCodec as oracleConsultArgsCodec, index$4_oracleStateDataCodec as oracleStateDataCodec, index$4_parseErrorFromLogs as parseErrorFromLogs, index$4_poolDataCodec as poolDataCodec, index$4_poolExists as poolExists, index$4_positionDataCodec as positionDataCodec, index$4_q64Div as q64Div, index$4_q64Mul as q64Mul, index$4_q64ToNumber as q64ToNumber, index$4_quoteToNumeraireArgsCodec as quoteToNumeraireArgsCodec, index$4_ratioToNumber as ratioToNumber, index$4_removeLiquidityArgsCodec as removeLiquidityArgsCodec, index$4_setFeesArgsCodec as setFeesArgsCodec, index$4_setRouteArgsCodec as setRouteArgsCodec, index$4_setSentinelArgsCodec as setSentinelArgsCodec, index$4_sortMints as sortMints, index$4_sortPoolsByReserves as sortPoolsByReserves, index$4_sortPositionsByShares as sortPositionsByShares, index$4_swapExactInArgsCodec as swapExactInArgsCodec, index$4_transferAdminArgsCodec as transferAdminArgsCodec, index$4_validateMarketCapParameters as validateMarketCapParameters };
+}
+
+/**
+ * Program ID for the Initializer program.
+ *
+ * Source of truth: programs/initializer/src/lib.rs
+ */
+declare const INITIALIZER_PROGRAM_ID: Address;
+declare const BPF_LOADER_UPGRADEABLE_PROGRAM_ID: Address;
+/**
+ * Sentinel program for CPMM-migrated launches.
+ * Invoked during bonding curve swaps and previews as a pre/post-swap hook.
+ *
+ * Source of truth: programs/cpmm_sentinel/src/lib.rs
+ */
+declare const CPMM_SENTINEL_PROGRAM_ID: Address;
+/**
+ * Sentinel program for prediction market launches.
+ * Invoked during bonding curve swaps and previews as a pre/post-swap hook.
+ *
+ * Source of truth: programs/prediction_sentinel/src/lib.rs
+ */
+declare const PREDICTION_SENTINEL_PROGRAM_ID: Address;
+declare const SEED_CONFIG = "config_v3";
+declare const SEED_LAUNCH = "launch_v3";
+declare const SEED_LAUNCH_AUTHORITY = "launch_authority_v3";
+/**
+ * Commitment hash for an empty remaining-accounts list — keccak256 of [0,0,0,0].
+ * Pass this for sentinelRemainingAccountsHash and migratorRemainingAccountsHash
+ * when no extra accounts are needed at that hook's invocation time.
+ */
+declare const EMPTY_REMAINING_ACCOUNTS_HASH: Uint8Array<ArrayBuffer>;
+/**
+ * Devnet ALT containing static accounts shared by every initializeLaunch tx.
+ * Indices: 0=TOKEN_PROGRAM, 1=SYSTEM_PROGRAM, 2=SYSVAR_RENT,
+ *          3=INITIALIZER_PROGRAM, 4=TOKEN_METADATA_PROGRAM,
+ *          5=CPMM_MIGRATOR_PROGRAM, 6=WSOL_MINT, 7=config PDA
+ */
+declare const DOPPLER_DEVNET_ALT: Address;
+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$1 = {
+    len: number;
+    bytes: ReadonlyUint8Array;
+};
+type CalldataBufArgs$1 = CalldataBuf$1;
+
+/**
+ * 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$1 = {
+    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$1;
+    migratorProgram: Address;
+    migratorInitCalldata: CalldataBuf$1;
+    migratorMigrateCalldata: CalldataBuf$1;
+    curveKind: number;
+    swapLock: number;
+    pad4: ReadonlyUint8Array;
+    curveParams: CalldataBuf$1;
+    quoteDeposited: bigint;
+    reserved: ReadonlyUint8Array;
+};
+type LaunchArgs$1 = {
+    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$1;
+    migratorProgram: Address;
+    migratorInitCalldata: CalldataBufArgs$1;
+    migratorMigrateCalldata: CalldataBufArgs$1;
+    curveKind: number;
+    swapLock: number;
+    pad4: ReadonlyUint8Array;
+    curveParams: CalldataBufArgs$1;
+    quoteDeposited: number | bigint;
+    reserved: ReadonlyUint8Array;
+};
+/** Gets the encoder for {@link LaunchArgs} account data. */
+declare function getLaunchEncoder$1(): FixedSizeEncoder<LaunchArgs$1>;
+/** Gets the decoder for {@link Launch} account data. */
+declare function getLaunchDecoder$1(): FixedSizeDecoder<Launch$1>;
+/** Gets the codec for {@link Launch} account data. */
+declare function getLaunchCodec$1(): FixedSizeCodec<LaunchArgs$1, Launch$1>;
+
+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;
+
+/**
+ * Public params for createInitializeLaunchInstruction.
+ * - allowBuy / allowSell are boolean; converted to u8 wire format (1/0).
+ * - migratorProgram is omitted — it is derived from accounts.migratorProgram
+ *   so callers do not need to repeat it in both the accounts object and args.
+ */
+type InitializeLaunchParams = Omit<InitializeLaunchArgsArgs, 'allowBuy' | 'allowSell' | 'migratorProgram'> & {
+    allowBuy: boolean;
+    allowSell: boolean;
+};
+type AddressOrSigner$3 = Address | TransactionSigner;
+/**
+ * Derive the Metaplex token metadata PDA for a given mint.
+ * Seeds: ["metadata", TOKEN_METADATA_PROGRAM_ID, mint]
+ *
+ * Pass the result as `metadataAccount` in InitializeLaunchAccounts
+ * whenever `metadataName` is non-empty.
+ */
+declare function getTokenMetadataAddress(mint: Address): Promise<Address>;
+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;
+    /** Required when args.metadataName is non-empty. Derive with getTokenMetadataAddress(baseMint). */
+    metadataAccount?: Address;
+    /**
+     * Optional Address Lookup Table to reference for static accounts.
+     * When provided, constant non-signer accounts (tokenProgram, systemProgram,
+     * rent, migratorProgram, quoteMint when WSOL, metadataProgram, config) are
+     * encoded as ALT lookup metas instead of 32-byte static keys, reducing
+     * transaction size by ~200+ bytes and enabling V4 metadata within the
+     * 1232-byte Solana transaction limit.
+     *
+     * Use DOPPLER_DEVNET_ALT for devnet.
+     */
+    addressLookupTable?: Address;
+}
+declare function createInitializeLaunchInstruction(accounts: InitializeLaunchAccounts, args: InitializeLaunchParams, programId?: Address): Promise<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;
+    /** Pass the actual sentinel program address, or omit to use System Program as a no-op placeholder. */
+    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;
+
+/**
+ * Compute the remaining-accounts commitment hash used by the Initializer program.
+ *
+ * Algorithm: keccak256(u32_len_le || pubkey_0 || ... || pubkey_n)
+ *
+ * This matches compute_remaining_accounts_hash in
+ * programs/initializer/src/instructions/launch_common.rs.
+ *
+ * Commit the result as sentinelRemainingAccountsHash or migratorRemainingAccountsHash
+ * when calling initializeLaunch. At migrate_launch (or sentinel invoke) time, pass the
+ * same accounts in the same order as remaining accounts — the program verifies they match.
+ *
+ * For an empty account list use EMPTY_REMAINING_ACCOUNTS_HASH instead.
+ */
+declare function computeRemainingAccountsHash(addresses: Address[]): Uint8Array;
+/**
+ * Returns a human-readable label for a launch phase value.
+ * Falls back to the numeric string for any unrecognised phase.
+ */
+declare function phaseLabel(phase: number): string;
+
+/**
+ * Launch fetching functions for the Initializer SDK
+ */
+
+interface FetchLaunchesConfig {
+    programId?: Address;
+    commitment?: 'processed' | 'confirmed' | 'finalized';
+}
+interface LaunchWithAddress {
+    address: Address;
+    account: Launch$1;
+}
+declare function fetchLaunch$1(rpc: Rpc<GetAccountInfoApi>, address: Address, config?: FetchLaunchesConfig): Promise<Launch$1 | 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$3_AbortLaunchAccounts = AbortLaunchAccounts;
+declare const index$3_BPF_LOADER_UPGRADEABLE_PROGRAM_ID: typeof BPF_LOADER_UPGRADEABLE_PROGRAM_ID;
+declare const index$3_CPMM_SENTINEL_PROGRAM_ID: typeof CPMM_SENTINEL_PROGRAM_ID;
+declare const index$3_CURVE_KIND_XYK: typeof CURVE_KIND_XYK;
+declare const index$3_CURVE_PARAMS_FORMAT_XYK_V0: typeof CURVE_PARAMS_FORMAT_XYK_V0;
+type index$3_CurveSwapExactInAccounts = CurveSwapExactInAccounts;
+declare const index$3_DIRECTION_BUY: typeof DIRECTION_BUY;
+declare const index$3_DIRECTION_SELL: typeof DIRECTION_SELL;
+declare const index$3_DOPPLER_DEVNET_ALT: typeof DOPPLER_DEVNET_ALT;
+declare const index$3_EMPTY_REMAINING_ACCOUNTS_HASH: typeof EMPTY_REMAINING_ACCOUNTS_HASH;
+type index$3_FetchLaunchesConfig = FetchLaunchesConfig;
+declare const index$3_INITIALIZER_ACCOUNT_DISCRIMINATORS: typeof INITIALIZER_ACCOUNT_DISCRIMINATORS;
+declare const index$3_INITIALIZER_INSTRUCTION_DISCRIMINATORS: typeof INITIALIZER_INSTRUCTION_DISCRIMINATORS;
+declare const index$3_INITIALIZER_PROGRAM_ID: typeof INITIALIZER_PROGRAM_ID;
+type index$3_InitConfig = InitConfig;
+type index$3_InitConfigArgs = InitConfigArgs;
+type index$3_InitializeConfigAccounts = InitializeConfigAccounts;
+type index$3_InitializeConfigArgs = InitializeConfigArgs;
+type index$3_InitializeConfigArgsArgs = InitializeConfigArgsArgs;
+type index$3_InitializeLaunchAccounts = InitializeLaunchAccounts;
+type index$3_InitializeLaunchArgs = InitializeLaunchArgs;
+type index$3_InitializeLaunchArgsArgs = InitializeLaunchArgsArgs;
+type index$3_LaunchWithAddress = LaunchWithAddress;
+declare const index$3_MAX_CALLDATA: typeof MAX_CALLDATA;
+declare const index$3_MAX_MIGRATOR_ALLOWLIST: typeof MAX_MIGRATOR_ALLOWLIST;
+declare const index$3_MAX_SENTINEL_ALLOWLIST: typeof MAX_SENTINEL_ALLOWLIST;
+type index$3_MigrateLaunchAccounts = MigrateLaunchAccounts;
+declare const index$3_PHASE_ABORTED: typeof PHASE_ABORTED;
+declare const index$3_PHASE_MIGRATED: typeof PHASE_MIGRATED;
+declare const index$3_PHASE_TRADING: typeof PHASE_TRADING;
+declare const index$3_PREDICTION_SENTINEL_PROGRAM_ID: typeof PREDICTION_SENTINEL_PROGRAM_ID;
+type index$3_PreviewMigrationAccounts = PreviewMigrationAccounts;
+type index$3_PreviewMigrationResult = PreviewMigrationResult;
+type index$3_PreviewSwapExactInAccounts = PreviewSwapExactInAccounts;
+type index$3_PreviewSwapExactInResult = PreviewSwapExactInResult;
+declare const index$3_SEED_CONFIG: typeof SEED_CONFIG;
+declare const index$3_SEED_LAUNCH: typeof SEED_LAUNCH;
+declare const index$3_SEED_LAUNCH_AUTHORITY: typeof SEED_LAUNCH_AUTHORITY;
+declare const index$3_SENTINEL_NO_CHANGE: typeof SENTINEL_NO_CHANGE;
+declare const index$3_SF_AFTER_SWAP: typeof SF_AFTER_SWAP;
+declare const index$3_SF_BEFORE_SWAP: typeof SF_BEFORE_SWAP;
+type index$3_SetMigratorAllowlistAccounts = SetMigratorAllowlistAccounts;
+type index$3_SetSentinelAllowlistAccounts = SetSentinelAllowlistAccounts;
+declare const index$3_computeRemainingAccountsHash: typeof computeRemainingAccountsHash;
+declare const index$3_createAbortLaunchInstruction: typeof createAbortLaunchInstruction;
+declare const index$3_createCurveSwapExactInInstruction: typeof createCurveSwapExactInInstruction;
+declare const index$3_createInitializeConfigInstruction: typeof createInitializeConfigInstruction;
+declare const index$3_createInitializeLaunchInstruction: typeof createInitializeLaunchInstruction;
+declare const index$3_createMigrateLaunchInstruction: typeof createMigrateLaunchInstruction;
+declare const index$3_createPreviewMigrationInstruction: typeof createPreviewMigrationInstruction;
+declare const index$3_createPreviewSwapExactInInstruction: typeof createPreviewSwapExactInInstruction;
+declare const index$3_createSetMigratorAllowlistInstruction: typeof createSetMigratorAllowlistInstruction;
+declare const index$3_createSetSentinelAllowlistInstruction: typeof createSetSentinelAllowlistInstruction;
+declare const index$3_decodePreviewMigrationResult: typeof decodePreviewMigrationResult;
+declare const index$3_decodePreviewSwapExactInResult: typeof decodePreviewSwapExactInResult;
+declare const index$3_encodeU64LE: typeof encodeU64LE;
+declare const index$3_fetchAllLaunches: typeof fetchAllLaunches;
+declare const index$3_fetchLaunchesByAuthority: typeof fetchLaunchesByAuthority;
+declare const index$3_getConfigAddress: typeof getConfigAddress;
+declare const index$3_getInitConfigCodec: typeof getInitConfigCodec;
+declare const index$3_getInitConfigDecoder: typeof getInitConfigDecoder;
+declare const index$3_getInitConfigEncoder: typeof getInitConfigEncoder;
+declare const index$3_getInitializeConfigArgsCodec: typeof getInitializeConfigArgsCodec;
+declare const index$3_getInitializeConfigArgsDecoder: typeof getInitializeConfigArgsDecoder;
+declare const index$3_getInitializeConfigArgsEncoder: typeof getInitializeConfigArgsEncoder;
+declare const index$3_getInitializeLaunchArgsCodec: typeof getInitializeLaunchArgsCodec;
+declare const index$3_getInitializeLaunchArgsDecoder: typeof getInitializeLaunchArgsDecoder;
+declare const index$3_getInitializeLaunchArgsEncoder: typeof getInitializeLaunchArgsEncoder;
+declare const index$3_getLaunchAddress: typeof getLaunchAddress;
+declare const index$3_getLaunchAuthorityAddress: typeof getLaunchAuthorityAddress;
+declare const index$3_getProgramDataAddress: typeof getProgramDataAddress;
+declare const index$3_getTokenMetadataAddress: typeof getTokenMetadataAddress;
+declare const index$3_launchExists: typeof launchExists;
+declare const index$3_launchIdFromU64: typeof launchIdFromU64;
+declare const index$3_phaseLabel: typeof phaseLabel;
+declare namespace index$3 {
+  export { type index$3_AbortLaunchAccounts as AbortLaunchAccounts, index$3_BPF_LOADER_UPGRADEABLE_PROGRAM_ID as BPF_LOADER_UPGRADEABLE_PROGRAM_ID, index$3_CPMM_SENTINEL_PROGRAM_ID as CPMM_SENTINEL_PROGRAM_ID, index$3_CURVE_KIND_XYK as CURVE_KIND_XYK, index$3_CURVE_PARAMS_FORMAT_XYK_V0 as CURVE_PARAMS_FORMAT_XYK_V0, type CalldataBuf$1 as CalldataBuf, type index$3_CurveSwapExactInAccounts as CurveSwapExactInAccounts, index$3_DIRECTION_BUY as DIRECTION_BUY, index$3_DIRECTION_SELL as DIRECTION_SELL, index$3_DOPPLER_DEVNET_ALT as DOPPLER_DEVNET_ALT, index$3_EMPTY_REMAINING_ACCOUNTS_HASH as EMPTY_REMAINING_ACCOUNTS_HASH, type index$3_FetchLaunchesConfig as FetchLaunchesConfig, index$3_INITIALIZER_ACCOUNT_DISCRIMINATORS as INITIALIZER_ACCOUNT_DISCRIMINATORS, index$3_INITIALIZER_INSTRUCTION_DISCRIMINATORS as INITIALIZER_INSTRUCTION_DISCRIMINATORS, index$3_INITIALIZER_PROGRAM_ID as INITIALIZER_PROGRAM_ID, type index$3_InitConfig as InitConfig, type index$3_InitConfigArgs as InitConfigArgs, type index$3_InitializeConfigAccounts as InitializeConfigAccounts, type index$3_InitializeConfigArgs as InitializeConfigArgs, type index$3_InitializeConfigArgsArgs as InitializeConfigArgsArgs, type index$3_InitializeLaunchAccounts as InitializeLaunchAccounts, type index$3_InitializeLaunchArgs as InitializeLaunchArgs, type index$3_InitializeLaunchArgsArgs as InitializeLaunchArgsArgs, type Launch$1 as Launch, type LaunchArgs$1 as LaunchArgs, type index$3_LaunchWithAddress as LaunchWithAddress, index$3_MAX_CALLDATA as MAX_CALLDATA, index$3_MAX_MIGRATOR_ALLOWLIST as MAX_MIGRATOR_ALLOWLIST, index$3_MAX_SENTINEL_ALLOWLIST as MAX_SENTINEL_ALLOWLIST, type index$3_MigrateLaunchAccounts as MigrateLaunchAccounts, index$3_PHASE_ABORTED as PHASE_ABORTED, index$3_PHASE_MIGRATED as PHASE_MIGRATED, index$3_PHASE_TRADING as PHASE_TRADING, index$3_PREDICTION_SENTINEL_PROGRAM_ID as PREDICTION_SENTINEL_PROGRAM_ID, type index$3_PreviewMigrationAccounts as PreviewMigrationAccounts, type index$3_PreviewMigrationResult as PreviewMigrationResult, type index$3_PreviewSwapExactInAccounts as PreviewSwapExactInAccounts, type index$3_PreviewSwapExactInResult as PreviewSwapExactInResult, index$3_SEED_CONFIG as SEED_CONFIG, index$3_SEED_LAUNCH as SEED_LAUNCH, index$3_SEED_LAUNCH_AUTHORITY as SEED_LAUNCH_AUTHORITY, index$3_SENTINEL_NO_CHANGE as SENTINEL_NO_CHANGE, index$3_SF_AFTER_SWAP as SF_AFTER_SWAP, index$3_SF_BEFORE_SWAP as SF_BEFORE_SWAP, type index$3_SetMigratorAllowlistAccounts as SetMigratorAllowlistAccounts, type index$3_SetSentinelAllowlistAccounts as SetSentinelAllowlistAccounts, index$3_computeRemainingAccountsHash as computeRemainingAccountsHash, index$3_createAbortLaunchInstruction as createAbortLaunchInstruction, index$3_createCurveSwapExactInInstruction as createCurveSwapExactInInstruction, index$3_createInitializeConfigInstruction as createInitializeConfigInstruction, index$3_createInitializeLaunchInstruction as createInitializeLaunchInstruction, index$3_createMigrateLaunchInstruction as createMigrateLaunchInstruction, index$3_createPreviewMigrationInstruction as createPreviewMigrationInstruction, index$3_createPreviewSwapExactInInstruction as createPreviewSwapExactInInstruction, index$3_createSetMigratorAllowlistInstruction as createSetMigratorAllowlistInstruction, index$3_createSetSentinelAllowlistInstruction as createSetSentinelAllowlistInstruction, index$3_decodePreviewMigrationResult as decodePreviewMigrationResult, index$3_decodePreviewSwapExactInResult as decodePreviewSwapExactInResult, index$3_encodeU64LE as encodeU64LE, index$3_fetchAllLaunches as fetchAllLaunches, fetchLaunch$1 as fetchLaunch, index$3_fetchLaunchesByAuthority as fetchLaunchesByAuthority, index$3_getConfigAddress as getConfigAddress, index$3_getInitConfigCodec as getInitConfigCodec, index$3_getInitConfigDecoder as getInitConfigDecoder, index$3_getInitConfigEncoder as getInitConfigEncoder, index$3_getInitializeConfigArgsCodec as getInitializeConfigArgsCodec, index$3_getInitializeConfigArgsDecoder as getInitializeConfigArgsDecoder, index$3_getInitializeConfigArgsEncoder as getInitializeConfigArgsEncoder, index$3_getInitializeLaunchArgsCodec as getInitializeLaunchArgsCodec, index$3_getInitializeLaunchArgsDecoder as getInitializeLaunchArgsDecoder, index$3_getInitializeLaunchArgsEncoder as getInitializeLaunchArgsEncoder, index$3_getLaunchAddress as getLaunchAddress, index$3_getLaunchAuthorityAddress as getLaunchAuthorityAddress, getLaunchCodec$1 as getLaunchCodec, getLaunchDecoder$1 as getLaunchDecoder, getLaunchEncoder$1 as getLaunchEncoder, index$3_getProgramDataAddress as getProgramDataAddress, index$3_getTokenMetadataAddress as getTokenMetadataAddress, index$3_launchExists as launchExists, index$3_launchIdFromU64 as launchIdFromU64, index$3_phaseLabel as phaseLabel };
+}
+
+/**
+ * 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$2_CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS: typeof CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS;
+declare const index$2_CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS: typeof CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS;
+declare const index$2_CPMM_MIGRATOR_PROGRAM_ID: typeof CPMM_MIGRATOR_PROGRAM_ID;
+type index$2_CpmmMigratorState = CpmmMigratorState;
+type index$2_CpmmMigratorStateArgs = CpmmMigratorStateArgs;
+declare const index$2_MAX_RECIPIENTS: typeof MAX_RECIPIENTS;
+type index$2_MigrateArgs = MigrateArgs;
+type index$2_MigrateArgsArgs = MigrateArgsArgs;
+type index$2_Recipient = Recipient;
+type index$2_RecipientArgs = RecipientArgs;
+type index$2_RegisterLaunchArgs = RegisterLaunchArgs;
+type index$2_RegisterLaunchArgsArgs = RegisterLaunchArgsArgs;
+declare const index$2_SEED_STATE: typeof SEED_STATE;
+declare const index$2_encodeMigrateCalldata: typeof encodeMigrateCalldata;
+declare const index$2_encodeRegisterLaunchCalldata: typeof encodeRegisterLaunchCalldata;
+declare const index$2_fetchCpmmMigratorState: typeof fetchCpmmMigratorState;
+declare const index$2_getCpmmMigratorStateAddress: typeof getCpmmMigratorStateAddress;
+declare const index$2_getCpmmMigratorStateCodec: typeof getCpmmMigratorStateCodec;
+declare const index$2_getCpmmMigratorStateDecoder: typeof getCpmmMigratorStateDecoder;
+declare const index$2_getCpmmMigratorStateEncoder: typeof getCpmmMigratorStateEncoder;
+declare const index$2_getMigrateArgsCodec: typeof getMigrateArgsCodec;
+declare const index$2_getMigrateArgsDecoder: typeof getMigrateArgsDecoder;
+declare const index$2_getMigrateArgsEncoder: typeof getMigrateArgsEncoder;
+declare const index$2_getRecipientCodec: typeof getRecipientCodec;
+declare const index$2_getRecipientDecoder: typeof getRecipientDecoder;
+declare const index$2_getRecipientEncoder: typeof getRecipientEncoder;
+declare const index$2_getRegisterLaunchArgsCodec: typeof getRegisterLaunchArgsCodec;
+declare const index$2_getRegisterLaunchArgsDecoder: typeof getRegisterLaunchArgsDecoder;
+declare const index$2_getRegisterLaunchArgsEncoder: typeof getRegisterLaunchArgsEncoder;
+declare namespace index$2 {
+  export { index$2_CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS as CPMM_MIGRATOR_ACCOUNT_DISCRIMINATORS, index$2_CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS as CPMM_MIGRATOR_INSTRUCTION_DISCRIMINATORS, index$2_CPMM_MIGRATOR_PROGRAM_ID as CPMM_MIGRATOR_PROGRAM_ID, type index$2_CpmmMigratorState as CpmmMigratorState, type index$2_CpmmMigratorStateArgs as CpmmMigratorStateArgs, index$2_MAX_RECIPIENTS as MAX_RECIPIENTS, type index$2_MigrateArgs as MigrateArgs, type index$2_MigrateArgsArgs as MigrateArgsArgs, type index$2_Recipient as Recipient, type index$2_RecipientArgs as RecipientArgs, type index$2_RegisterLaunchArgs as RegisterLaunchArgs, type index$2_RegisterLaunchArgsArgs as RegisterLaunchArgsArgs, index$2_SEED_STATE as SEED_STATE, index$2_encodeMigrateCalldata as encodeMigrateCalldata, index$2_encodeRegisterLaunchCalldata as encodeRegisterLaunchCalldata, index$2_fetchCpmmMigratorState as fetchCpmmMigratorState, index$2_getCpmmMigratorStateAddress as getCpmmMigratorStateAddress, index$2_getCpmmMigratorStateCodec as getCpmmMigratorStateCodec, index$2_getCpmmMigratorStateDecoder as getCpmmMigratorStateDecoder, index$2_getCpmmMigratorStateEncoder as getCpmmMigratorStateEncoder, index$2_getMigrateArgsCodec as getMigrateArgsCodec, index$2_getMigrateArgsDecoder as getMigrateArgsDecoder, index$2_getMigrateArgsEncoder as getMigrateArgsEncoder, index$2_getRecipientCodec as getRecipientCodec, index$2_getRecipientDecoder as getRecipientDecoder, index$2_getRecipientEncoder as getRecipientEncoder, index$2_getRegisterLaunchArgsCodec as getRegisterLaunchArgsCodec, index$2_getRegisterLaunchArgsDecoder as getRegisterLaunchArgsDecoder, index$2_getRegisterLaunchArgsEncoder as getRegisterLaunchArgsEncoder };
+}
+
+/**
+ * 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
+ */
+
+declare const CLAIM_RECEIPT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getClaimReceiptDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type ClaimReceipt = {
+    discriminator: ReadonlyUint8Array;
+    /** The market this receipt belongs to */
+    market: Address;
+    /** The claimer's wallet */
+    claimer: Address;
+    /** Total winner tokens burned by this user */
+    burnedAmount: bigint;
+    /** Reward debt for accumulator accounting (scaled by ACC_SCALE) */
+    rewardDebt: bigint;
+    /** Bump seed for this PDA */
+    bump: number;
+    /** Reserved for future use */
+    reserved: ReadonlyUint8Array;
+};
+type ClaimReceiptArgs = {
+    /** The market this receipt belongs to */
+    market: Address;
+    /** The claimer's wallet */
+    claimer: Address;
+    /** Total winner tokens burned by this user */
+    burnedAmount: number | bigint;
+    /** Reward debt for accumulator accounting (scaled by ACC_SCALE) */
+    rewardDebt: number | bigint;
+    /** Bump seed for this PDA */
+    bump: number;
+    /** Reserved for future use */
+    reserved: ReadonlyUint8Array;
+};
+/** Gets the encoder for {@link ClaimReceiptArgs} account data. */
+declare function getClaimReceiptEncoder(): FixedSizeEncoder<ClaimReceiptArgs>;
+/** Gets the decoder for {@link ClaimReceipt} account data. */
+declare function getClaimReceiptDecoder(): FixedSizeDecoder<ClaimReceipt>;
+/** Gets the codec for {@link ClaimReceipt} account data. */
+declare function getClaimReceiptCodec(): FixedSizeCodec<ClaimReceiptArgs, ClaimReceipt>;
+declare function decodeClaimReceipt<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<ClaimReceipt, TAddress>;
+declare function decodeClaimReceipt<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<ClaimReceipt, TAddress>;
+declare function fetchClaimReceipt<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<ClaimReceipt, TAddress>>;
+declare function fetchMaybeClaimReceipt<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<ClaimReceipt, TAddress>>;
+declare function fetchAllClaimReceipt(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<ClaimReceipt>[]>;
+declare function fetchAllMaybeClaimReceipt(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<ClaimReceipt>[]>;
+declare function getClaimReceiptSize(): number;
+
+/**
+ * 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
+ */
+
+declare const ENTRY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getEntryDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type Entry = {
+    discriminator: ReadonlyUint8Array;
+    /** The oracle this entry belongs to */
+    oracle: Address;
+    /** Unique identifier for this entry within the market */
+    entryId: ReadonlyUint8Array;
+    /** The token mint for this entry */
+    baseMint: Address;
+    /** Quote contributed when this entry was migrated */
+    contribution: bigint;
+    /** Whether this entry has been migrated */
+    isMigrated: boolean;
+    /** Bump seed for this PDA */
+    bump: number;
+    /** Reserved for future use */
+    reserved: ReadonlyUint8Array;
+};
+type EntryArgs = {
+    /** The oracle this entry belongs to */
+    oracle: Address;
+    /** Unique identifier for this entry within the market */
+    entryId: ReadonlyUint8Array;
+    /** The token mint for this entry */
+    baseMint: Address;
+    /** Quote contributed when this entry was migrated */
+    contribution: number | bigint;
+    /** Whether this entry has been migrated */
+    isMigrated: boolean;
+    /** Bump seed for this PDA */
+    bump: number;
+    /** Reserved for future use */
+    reserved: ReadonlyUint8Array;
+};
+/** Gets the encoder for {@link EntryArgs} account data. */
+declare function getEntryEncoder(): FixedSizeEncoder<EntryArgs>;
+/** Gets the decoder for {@link Entry} account data. */
+declare function getEntryDecoder(): FixedSizeDecoder<Entry>;
+/** Gets the codec for {@link Entry} account data. */
+declare function getEntryCodec(): FixedSizeCodec<EntryArgs, Entry>;
+declare function decodeEntry<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<Entry, TAddress>;
+declare function decodeEntry<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<Entry, TAddress>;
+declare function fetchEntry<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<Entry, TAddress>>;
+declare function fetchMaybeEntry<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<Entry, TAddress>>;
+declare function fetchAllEntry(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<Entry>[]>;
+declare function fetchAllMaybeEntry(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<Entry>[]>;
+declare function getEntrySize(): number;
+
+/**
+ * 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
+ */
+
+declare const ENTRY_BY_MINT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getEntryByMintDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type EntryByMint = {
+    discriminator: ReadonlyUint8Array;
+    /** The oracle this entry belongs to */
+    oracle: Address;
+    /** The base mint */
+    baseMint: Address;
+    /** The entry_id for reverse lookup */
+    entryId: ReadonlyUint8Array;
+    /** Bump seed for this PDA */
+    bump: number;
+    /** Reserved for future use */
+    reserved: ReadonlyUint8Array;
+};
+type EntryByMintArgs = {
+    /** The oracle this entry belongs to */
+    oracle: Address;
+    /** The base mint */
+    baseMint: Address;
+    /** The entry_id for reverse lookup */
+    entryId: ReadonlyUint8Array;
+    /** Bump seed for this PDA */
+    bump: number;
+    /** Reserved for future use */
+    reserved: ReadonlyUint8Array;
+};
+/** Gets the encoder for {@link EntryByMintArgs} account data. */
+declare function getEntryByMintEncoder(): FixedSizeEncoder<EntryByMintArgs>;
+/** Gets the decoder for {@link EntryByMint} account data. */
+declare function getEntryByMintDecoder(): FixedSizeDecoder<EntryByMint>;
+/** Gets the codec for {@link EntryByMint} account data. */
+declare function getEntryByMintCodec(): FixedSizeCodec<EntryByMintArgs, EntryByMint>;
+declare function decodeEntryByMint<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<EntryByMint, TAddress>;
+declare function decodeEntryByMint<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<EntryByMint, TAddress>;
+declare function fetchEntryByMint<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<EntryByMint, TAddress>>;
+declare function fetchMaybeEntryByMint<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<EntryByMint, TAddress>>;
+declare function fetchAllEntryByMint(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<EntryByMint>[]>;
+declare function fetchAllMaybeEntryByMint(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<EntryByMint>[]>;
+declare function getEntryByMintSize(): number;
+
+/**
+ * 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 AccumulatorUpdated = {
+    market: Address;
+    newTotalPot: bigint;
+    newAccQuotePerToken: bigint;
+};
+type AccumulatorUpdatedArgs = {
+    market: Address;
+    newTotalPot: number | bigint;
+    newAccQuotePerToken: number | bigint;
+};
+declare function getAccumulatorUpdatedEncoder(): FixedSizeEncoder<AccumulatorUpdatedArgs>;
+declare function getAccumulatorUpdatedDecoder(): FixedSizeDecoder<AccumulatorUpdated>;
+declare function getAccumulatorUpdatedCodec(): FixedSizeCodec<AccumulatorUpdatedArgs, AccumulatorUpdated>;
+
+/**
+ * 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
+ */
+
+/** Variable-length calldata buffer. */
+type CalldataBuf = {
+    len: number;
+    bytes: ReadonlyUint8Array;
+};
+type CalldataBufArgs = CalldataBuf;
+declare function getCalldataBufEncoder(): FixedSizeEncoder<CalldataBufArgs>;
+declare function getCalldataBufDecoder(): FixedSizeDecoder<CalldataBuf>;
+declare function getCalldataBufCodec(): FixedSizeCodec<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 EntryMigrated = {
+    market: Address;
+    oracle: Address;
+    entryId: ReadonlyUint8Array;
+    baseMint: Address;
+    contribution: bigint;
+    isWinner: boolean;
+};
+type EntryMigratedArgs = {
+    market: Address;
+    oracle: Address;
+    entryId: ReadonlyUint8Array;
+    baseMint: Address;
+    contribution: number | bigint;
+    isWinner: boolean;
+};
+declare function getEntryMigratedEncoder(): FixedSizeEncoder<EntryMigratedArgs>;
+declare function getEntryMigratedDecoder(): FixedSizeDecoder<EntryMigrated>;
+declare function getEntryMigratedCodec(): FixedSizeCodec<EntryMigratedArgs, EntryMigrated>;
+
+/**
+ * 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 EntryRegistered = {
+    market: Address;
+    oracle: Address;
+    entryId: ReadonlyUint8Array;
+    baseMint: Address;
+};
+type EntryRegisteredArgs = EntryRegistered;
+declare function getEntryRegisteredEncoder(): FixedSizeEncoder<EntryRegisteredArgs>;
+declare function getEntryRegisteredDecoder(): FixedSizeDecoder<EntryRegistered>;
+declare function getEntryRegisteredCodec(): FixedSizeCodec<EntryRegisteredArgs, EntryRegistered>;
+
+/**
+ * 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 MarketCreated = {
+    market: Address;
+    oracle: Address;
+    quoteMint: Address;
+};
+type MarketCreatedArgs = MarketCreated;
+declare function getMarketCreatedEncoder(): FixedSizeEncoder<MarketCreatedArgs>;
+declare function getMarketCreatedDecoder(): FixedSizeDecoder<MarketCreated>;
+declare function getMarketCreatedCodec(): FixedSizeCodec<MarketCreatedArgs, MarketCreated>;
+
+/**
+ * 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 MarketResolved = {
+    market: Address;
+    oracle: Address;
+    winnerMint: Address;
+    claimableSupply: bigint;
+    totalPot: bigint;
+};
+type MarketResolvedArgs = {
+    market: Address;
+    oracle: Address;
+    winnerMint: Address;
+    claimableSupply: number | bigint;
+    totalPot: number | bigint;
+};
+declare function getMarketResolvedEncoder(): FixedSizeEncoder<MarketResolvedArgs>;
+declare function getMarketResolvedDecoder(): FixedSizeDecoder<MarketResolved>;
+declare function getMarketResolvedCodec(): FixedSizeCodec<MarketResolvedArgs, MarketResolved>;
+
+/**
+ * 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_entry instruction.
+ * This is decoded from migrator_migrate_calldata passed by initializer.
+ */
+type MigrateEntryArgs = {
+    entryId: ReadonlyUint8Array;
+};
+type MigrateEntryArgsArgs = MigrateEntryArgs;
+declare function getMigrateEntryArgsEncoder(): FixedSizeEncoder<MigrateEntryArgsArgs>;
+declare function getMigrateEntryArgsDecoder(): FixedSizeDecoder<MigrateEntryArgs>;
+declare function getMigrateEntryArgsCodec(): FixedSizeCodec<MigrateEntryArgsArgs, MigrateEntryArgs>;
+
+/**
+ * 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 PreviewPayoutIfWinnerArgs = {
+    candidateWinnerMint: Address;
+    tokenAmount: bigint;
+};
+type PreviewPayoutIfWinnerArgsArgs = {
+    candidateWinnerMint: Address;
+    tokenAmount: number | bigint;
+};
+declare function getPreviewPayoutIfWinnerArgsEncoder(): FixedSizeEncoder<PreviewPayoutIfWinnerArgsArgs>;
+declare function getPreviewPayoutIfWinnerArgsDecoder(): FixedSizeDecoder<PreviewPayoutIfWinnerArgs>;
+declare function getPreviewPayoutIfWinnerArgsCodec(): FixedSizeCodec<PreviewPayoutIfWinnerArgsArgs, PreviewPayoutIfWinnerArgs>;
+
+/**
+ * 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_entry instruction.
+ * This is decoded from migrator_init_calldata passed by initializer.
+ */
+type RegisterEntryArgs = {
+    entryId: ReadonlyUint8Array;
+};
+type RegisterEntryArgsArgs = RegisterEntryArgs;
+declare function getRegisterEntryArgsEncoder(): FixedSizeEncoder<RegisterEntryArgsArgs>;
+declare function getRegisterEntryArgsDecoder(): FixedSizeDecoder<RegisterEntryArgs>;
+declare function getRegisterEntryArgsCodec(): FixedSizeCodec<RegisterEntryArgsArgs, RegisterEntryArgs>;
+
+/**
+ * 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 RewardsClaimed = {
+    market: Address;
+    claimer: Address;
+    burnedAmount: bigint;
+    rewardAmount: bigint;
+    totalBurned: bigint;
+};
+type RewardsClaimedArgs = {
+    market: Address;
+    claimer: Address;
+    burnedAmount: number | bigint;
+    rewardAmount: number | bigint;
+    totalBurned: number | bigint;
+};
+declare function getRewardsClaimedEncoder(): FixedSizeEncoder<RewardsClaimedArgs>;
+declare function getRewardsClaimedDecoder(): FixedSizeDecoder<RewardsClaimed>;
+declare function getRewardsClaimedCodec(): FixedSizeCodec<RewardsClaimedArgs, RewardsClaimed>;
+
+/**
+ * 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
+ */
+
+declare const LAUNCH_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getLaunchDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+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;
+    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;
+    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 decodeLaunch<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<Launch, TAddress>;
+declare function decodeLaunch<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<Launch, TAddress>;
+declare function fetchLaunch<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<Launch, TAddress>>;
+declare function fetchMaybeLaunch<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<Launch, TAddress>>;
+declare function fetchAllLaunch(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<Launch>[]>;
+declare function fetchAllMaybeLaunch(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<Launch>[]>;
+declare function getLaunchSize(): number;
+
+/**
+ * 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
+ */
+
+declare const MARKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getMarketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type Market = {
+    discriminator: ReadonlyUint8Array;
+    /** The oracle that determines the winner */
+    oracle: Address;
+    /** Quote mint for this market (e.g., USDC) */
+    quoteMint: Address;
+    /** The pot vault holding quote tokens */
+    potVault: Address;
+    /** Total quote migrated into pot (cumulative) */
+    totalPot: bigint;
+    /** Total quote claimed/paid out (cumulative) */
+    totalClaimed: bigint;
+    /** Winner mint (set when market resolves) */
+    winnerMint: Address;
+    /** Claimable supply of winner token (fixed after winning entry migrates) */
+    claimableSupply: bigint;
+    /**
+     * Scaled accumulator: total_pot * ACC_SCALE / claimable_supply
+     * This tracks quote per token and increases as losing entries migrate
+     */
+    accQuotePerToken: bigint;
+    /** Whether the market has been resolved (winner determined) */
+    isResolved: boolean;
+    /** Bump seed for this PDA */
+    bump: number;
+    /** Bump seed for market authority PDA */
+    marketAuthorityBump: number;
+    /** Reserved for future use */
+    reserved: ReadonlyUint8Array;
+};
+type MarketArgs = {
+    /** The oracle that determines the winner */
+    oracle: Address;
+    /** Quote mint for this market (e.g., USDC) */
+    quoteMint: Address;
+    /** The pot vault holding quote tokens */
+    potVault: Address;
+    /** Total quote migrated into pot (cumulative) */
+    totalPot: number | bigint;
+    /** Total quote claimed/paid out (cumulative) */
+    totalClaimed: number | bigint;
+    /** Winner mint (set when market resolves) */
+    winnerMint: Address;
+    /** Claimable supply of winner token (fixed after winning entry migrates) */
+    claimableSupply: number | bigint;
+    /**
+     * Scaled accumulator: total_pot * ACC_SCALE / claimable_supply
+     * This tracks quote per token and increases as losing entries migrate
+     */
+    accQuotePerToken: number | bigint;
+    /** Whether the market has been resolved (winner determined) */
+    isResolved: boolean;
+    /** Bump seed for this PDA */
+    bump: number;
+    /** Bump seed for market authority PDA */
+    marketAuthorityBump: number;
+    /** Reserved for future use */
+    reserved: ReadonlyUint8Array;
+};
+/** Gets the encoder for {@link MarketArgs} account data. */
+declare function getMarketEncoder(): FixedSizeEncoder<MarketArgs>;
+/** Gets the decoder for {@link Market} account data. */
+declare function getMarketDecoder(): FixedSizeDecoder<Market>;
+/** Gets the codec for {@link Market} account data. */
+declare function getMarketCodec(): FixedSizeCodec<MarketArgs, Market>;
+declare function decodeMarket<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<Market, TAddress>;
+declare function decodeMarket<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<Market, TAddress>;
+declare function fetchMarket<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<Market, TAddress>>;
+declare function fetchMaybeMarket<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<Market, TAddress>>;
+declare function fetchAllMarket(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<Market>[]>;
+declare function fetchAllMaybeMarket(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<Market>[]>;
+declare function getMarketSize(): number;
+
+/**
+ * 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
+ */
+
+declare const ORACLE_STATE_DISCRIMINATOR$1: Uint8Array<ArrayBuffer>;
+declare function getOracleStateDiscriminatorBytes$1(): ReadonlyUint8Array<ArrayBuffer>;
+type OracleState$1 = {
+    discriminator: ReadonlyUint8Array;
+    /** The authority that can finalize this oracle. */
+    oracleAuthority: Address;
+    /** Optional quote mint for validation (Pubkey::default() if not used). */
+    quoteMint: Address;
+    /** Whether the oracle has been finalized with a winner. */
+    isFinalized: boolean;
+    /** The winning mint (only valid if is_finalized == true). */
+    winningMint: Address;
+    /** Nonce used in PDA derivation. */
+    nonce: bigint;
+    /** PDA bump seed. */
+    bump: number;
+    /** Reserved for future use. */
+    reserved: ReadonlyUint8Array;
+};
+type OracleStateArgs$1 = {
+    /** The authority that can finalize this oracle. */
+    oracleAuthority: Address;
+    /** Optional quote mint for validation (Pubkey::default() if not used). */
+    quoteMint: Address;
+    /** Whether the oracle has been finalized with a winner. */
+    isFinalized: boolean;
+    /** The winning mint (only valid if is_finalized == true). */
+    winningMint: Address;
+    /** Nonce used in PDA derivation. */
+    nonce: number | bigint;
+    /** PDA bump seed. */
+    bump: number;
+    /** Reserved for future use. */
+    reserved: ReadonlyUint8Array;
+};
+/** Gets the encoder for {@link OracleStateArgs} account data. */
+declare function getOracleStateEncoder$1(): FixedSizeEncoder<OracleStateArgs$1>;
+/** Gets the decoder for {@link OracleState} account data. */
+declare function getOracleStateDecoder$1(): FixedSizeDecoder<OracleState$1>;
+/** Gets the codec for {@link OracleState} account data. */
+declare function getOracleStateCodec$1(): FixedSizeCodec<OracleStateArgs$1, OracleState$1>;
+declare function decodeOracleState$1<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<OracleState$1, TAddress>;
+declare function decodeOracleState$1<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<OracleState$1, TAddress>;
+declare function fetchOracleState$1<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<OracleState$1, TAddress>>;
+declare function fetchMaybeOracleState$1<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<OracleState$1, TAddress>>;
+declare function fetchAllOracleState$1(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<OracleState$1>[]>;
+declare function fetchAllMaybeOracleState$1(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<OracleState$1>[]>;
+declare function getOracleStateSize$1(): number;
+
+/**
+ * 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
+ */
+
+/** Unauthorized: Unauthorized */
+declare const PREDICTION_MIGRATOR_ERROR__UNAUTHORIZED = 6000;
+/** QuoteMintMismatch: Quote mint mismatch */
+declare const PREDICTION_MIGRATOR_ERROR__QUOTE_MINT_MISMATCH = 6001;
+/** EntryAlreadyRegistered: Entry already registered */
+declare const PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_REGISTERED = 6002;
+/** EntryNotRegistered: Entry not registered */
+declare const PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_REGISTERED = 6003;
+/** EntryAlreadyMigrated: Entry already migrated */
+declare const PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_MIGRATED = 6004;
+/** EntryNotMigrated: Entry not migrated */
+declare const PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_MIGRATED = 6005;
+/** OracleNotFinalized: Oracle not finalized */
+declare const PREDICTION_MIGRATOR_ERROR__ORACLE_NOT_FINALIZED = 6006;
+/** MarketNotResolved: Market not resolved */
+declare const PREDICTION_MIGRATOR_ERROR__MARKET_NOT_RESOLVED = 6007;
+/** InvalidWinnerMint: Invalid winner mint */
+declare const PREDICTION_MIGRATOR_ERROR__INVALID_WINNER_MINT = 6008;
+/** InsufficientBalance: Insufficient balance */
+declare const PREDICTION_MIGRATOR_ERROR__INSUFFICIENT_BALANCE = 6009;
+/** MathOverflow: Math overflow */
+declare const PREDICTION_MIGRATOR_ERROR__MATH_OVERFLOW = 6010;
+/** InvalidEntryId: Invalid entry ID */
+declare const PREDICTION_MIGRATOR_ERROR__INVALID_ENTRY_ID = 6011;
+/** InvalidMarket: Invalid market */
+declare const PREDICTION_MIGRATOR_ERROR__INVALID_MARKET = 6012;
+/** InvalidVault: Invalid vault */
+declare const PREDICTION_MIGRATOR_ERROR__INVALID_VAULT = 6013;
+/** InvalidMint: Invalid mint */
+declare const PREDICTION_MIGRATOR_ERROR__INVALID_MINT = 6014;
+/** WinningEntryNotMigrated: Winning entry not migrated */
+declare const PREDICTION_MIGRATOR_ERROR__WINNING_ENTRY_NOT_MIGRATED = 6015;
+/** NoPendingRewards: No pending rewards */
+declare const PREDICTION_MIGRATOR_ERROR__NO_PENDING_REWARDS = 6016;
+/** InvalidOracle: Invalid oracle */
+declare const PREDICTION_MIGRATOR_ERROR__INVALID_ORACLE = 6017;
+/** ZeroClaimableSupply: Zero claimable supply */
+declare const PREDICTION_MIGRATOR_ERROR__ZERO_CLAIMABLE_SUPPLY = 6018;
+/** InvalidInput: Invalid input */
+declare const PREDICTION_MIGRATOR_ERROR__INVALID_INPUT = 6019;
+type PredictionMigratorError = typeof PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_MIGRATED | typeof PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_REGISTERED | typeof PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_MIGRATED | typeof PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_REGISTERED | typeof PREDICTION_MIGRATOR_ERROR__INSUFFICIENT_BALANCE | typeof PREDICTION_MIGRATOR_ERROR__INVALID_ENTRY_ID | typeof PREDICTION_MIGRATOR_ERROR__INVALID_INPUT | typeof PREDICTION_MIGRATOR_ERROR__INVALID_MARKET | typeof PREDICTION_MIGRATOR_ERROR__INVALID_MINT | typeof PREDICTION_MIGRATOR_ERROR__INVALID_ORACLE | typeof PREDICTION_MIGRATOR_ERROR__INVALID_VAULT | typeof PREDICTION_MIGRATOR_ERROR__INVALID_WINNER_MINT | typeof PREDICTION_MIGRATOR_ERROR__MARKET_NOT_RESOLVED | typeof PREDICTION_MIGRATOR_ERROR__MATH_OVERFLOW | typeof PREDICTION_MIGRATOR_ERROR__NO_PENDING_REWARDS | typeof PREDICTION_MIGRATOR_ERROR__ORACLE_NOT_FINALIZED | typeof PREDICTION_MIGRATOR_ERROR__QUOTE_MINT_MISMATCH | typeof PREDICTION_MIGRATOR_ERROR__UNAUTHORIZED | typeof PREDICTION_MIGRATOR_ERROR__WINNING_ENTRY_NOT_MIGRATED | typeof PREDICTION_MIGRATOR_ERROR__ZERO_CLAIMABLE_SUPPLY;
+declare function getPredictionMigratorErrorMessage(code: PredictionMigratorError): string;
+declare function isPredictionMigratorError<TProgramErrorCode extends PredictionMigratorError>(error: unknown, transactionMessage: {
+    instructions: Record<number, {
+        programAddress: Address;
+    }>;
+}, code?: TProgramErrorCode): error is SolanaError<typeof SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM> & Readonly<{
+    context: Readonly<{
+        code: TProgramErrorCode;
+    }>;
+}>;
+
+/**
+ * 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
+ */
+
+declare const PREDICTION_MIGRATOR_PROGRAM_ADDRESS: Address<"HYHdyy7QZg8Ucky9Z97xNtSCvrZxVNkeoney8xEPXjiZ">;
+declare enum PredictionMigratorAccount {
+    ClaimReceipt = 0,
+    Entry = 1,
+    EntryByMint = 2,
+    Launch = 3,
+    Market = 4,
+    OracleState = 5
+}
+declare function identifyPredictionMigratorAccount(account: {
+    data: ReadonlyUint8Array;
+} | ReadonlyUint8Array): PredictionMigratorAccount;
+declare enum PredictionMigratorInstruction {
+    Claim = 0,
+    MigrateEntry = 1,
+    PreviewPayoutIfWinner = 2,
+    RegisterEntry = 3
+}
+declare function identifyPredictionMigratorInstruction(instruction: {
+    data: ReadonlyUint8Array;
+} | ReadonlyUint8Array): PredictionMigratorInstruction;
+type ParsedPredictionMigratorInstruction<TProgram extends string = 'HYHdyy7QZg8Ucky9Z97xNtSCvrZxVNkeoney8xEPXjiZ'> = ({
+    instructionType: PredictionMigratorInstruction.Claim;
+} & ParsedClaimInstruction<TProgram>) | ({
+    instructionType: PredictionMigratorInstruction.MigrateEntry;
+} & ParsedMigrateEntryInstruction<TProgram>) | ({
+    instructionType: PredictionMigratorInstruction.PreviewPayoutIfWinner;
+} & ParsedPreviewPayoutIfWinnerInstruction<TProgram>) | ({
+    instructionType: PredictionMigratorInstruction.RegisterEntry;
+} & ParsedRegisterEntryInstruction<TProgram>);
+declare function parsePredictionMigratorInstruction<TProgram extends string>(instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>): ParsedPredictionMigratorInstruction<TProgram>;
+type PredictionMigratorPlugin = {
+    accounts: PredictionMigratorPluginAccounts;
+    instructions: PredictionMigratorPluginInstructions;
+};
+type PredictionMigratorPluginAccounts = {
+    claimReceipt: ReturnType<typeof getClaimReceiptCodec> & SelfFetchFunctions<ClaimReceiptArgs, ClaimReceipt>;
+    entry: ReturnType<typeof getEntryCodec> & SelfFetchFunctions<EntryArgs, Entry>;
+    entryByMint: ReturnType<typeof getEntryByMintCodec> & SelfFetchFunctions<EntryByMintArgs, EntryByMint>;
+    launch: ReturnType<typeof getLaunchCodec> & SelfFetchFunctions<LaunchArgs, Launch>;
+    market: ReturnType<typeof getMarketCodec> & SelfFetchFunctions<MarketArgs, Market>;
+    oracleState: ReturnType<typeof getOracleStateCodec$1> & SelfFetchFunctions<OracleStateArgs$1, OracleState$1>;
+};
+type PredictionMigratorPluginInstructions = {
+    claim: (input: MakeOptional<ClaimAsyncInput, 'payer'>) => ReturnType<typeof getClaimInstructionAsync> & SelfPlanAndSendFunctions;
+    migrateEntry: (input: MakeOptional<MigrateEntryAsyncInput, 'payer'>) => ReturnType<typeof getMigrateEntryInstructionAsync> & SelfPlanAndSendFunctions;
+    previewPayoutIfWinner: (input: PreviewPayoutIfWinnerInput) => ReturnType<typeof getPreviewPayoutIfWinnerInstruction> & SelfPlanAndSendFunctions;
+    registerEntry: (input: MakeOptional<RegisterEntryAsyncInput, 'payer'>) => ReturnType<typeof getRegisterEntryInstructionAsync> & SelfPlanAndSendFunctions;
+};
+type PredictionMigratorPluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi> & ClientWithPayer & ClientWithTransactionPlanning & ClientWithTransactionSending;
+declare function predictionMigratorProgram(): <T extends PredictionMigratorPluginRequirements>(client: T) => T & {
+    predictionMigrator: PredictionMigratorPlugin;
+};
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+/**
+ * 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
+ */
+
+declare const CLAIM_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getClaimDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type ClaimInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountMarket extends string | AccountMeta<string> = string, TAccountMarketAuthority extends string | AccountMeta<string> = string, TAccountPotVault extends string | AccountMeta<string> = string, TAccountWinnerMint extends string | AccountMeta<string> = string, TAccountEntryByMint extends string | AccountMeta<string> = string, TAccountClaimerWinnerAta extends string | AccountMeta<string> = string, TAccountClaimerQuoteAta extends string | AccountMeta<string> = string, TAccountClaimer extends string | AccountMeta<string> = string, TAccountReceipt extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA', TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
+    TAccountMarketAuthority extends string ? ReadonlyAccount<TAccountMarketAuthority> : TAccountMarketAuthority,
+    TAccountPotVault extends string ? WritableAccount<TAccountPotVault> : TAccountPotVault,
+    TAccountWinnerMint extends string ? WritableAccount<TAccountWinnerMint> : TAccountWinnerMint,
+    TAccountEntryByMint extends string ? ReadonlyAccount<TAccountEntryByMint> : TAccountEntryByMint,
+    TAccountClaimerWinnerAta extends string ? WritableAccount<TAccountClaimerWinnerAta> : TAccountClaimerWinnerAta,
+    TAccountClaimerQuoteAta extends string ? WritableAccount<TAccountClaimerQuoteAta> : TAccountClaimerQuoteAta,
+    TAccountClaimer extends string ? ReadonlySignerAccount<TAccountClaimer> & AccountSignerMeta<TAccountClaimer> : TAccountClaimer,
+    TAccountReceipt extends string ? WritableAccount<TAccountReceipt> : TAccountReceipt,
+    TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
+    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
+    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
+    ...TRemainingAccounts
+]>;
+type ClaimInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    burnAmount: bigint;
+};
+type ClaimInstructionDataArgs = {
+    burnAmount: number | bigint;
+};
+declare function getClaimInstructionDataEncoder(): FixedSizeEncoder<ClaimInstructionDataArgs>;
+declare function getClaimInstructionDataDecoder(): FixedSizeDecoder<ClaimInstructionData>;
+declare function getClaimInstructionDataCodec(): FixedSizeCodec<ClaimInstructionDataArgs, ClaimInstructionData>;
+type ClaimAsyncInput<TAccountMarket extends string = string, TAccountMarketAuthority extends string = string, TAccountPotVault extends string = string, TAccountWinnerMint extends string = string, TAccountEntryByMint extends string = string, TAccountClaimerWinnerAta extends string = string, TAccountClaimerQuoteAta extends string = string, TAccountClaimer extends string = string, TAccountReceipt extends string = string, TAccountPayer extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
+    /** Market PDA */
+    market: Address<TAccountMarket>;
+    marketAuthority?: Address<TAccountMarketAuthority>;
+    /** Pot vault holding quote tokens */
+    potVault: Address<TAccountPotVault>;
+    /** Winner mint (must match market.winner_mint) */
+    winnerMint: Address<TAccountWinnerMint>;
+    /** EntryByMint for validation that this mint belongs to this market */
+    entryByMint: Address<TAccountEntryByMint>;
+    /** Claimer's winner token account (source for burn) */
+    claimerWinnerAta: Address<TAccountClaimerWinnerAta>;
+    /** Claimer's quote token account (destination for rewards) */
+    claimerQuoteAta: Address<TAccountClaimerQuoteAta>;
+    /** Claimer wallet (signer) */
+    claimer: TransactionSigner<TAccountClaimer>;
+    /** Claim receipt PDA (created if first claim) */
+    receipt?: Address<TAccountReceipt>;
+    /** Payer for receipt creation (can be same as claimer) */
+    payer: TransactionSigner<TAccountPayer>;
+    tokenProgram?: Address<TAccountTokenProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    burnAmount: ClaimInstructionDataArgs['burnAmount'];
+};
+declare function getClaimInstructionAsync<TAccountMarket extends string, TAccountMarketAuthority extends string, TAccountPotVault extends string, TAccountWinnerMint extends string, TAccountEntryByMint extends string, TAccountClaimerWinnerAta extends string, TAccountClaimerQuoteAta extends string, TAccountClaimer extends string, TAccountReceipt extends string, TAccountPayer extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS>(input: ClaimAsyncInput<TAccountMarket, TAccountMarketAuthority, TAccountPotVault, TAccountWinnerMint, TAccountEntryByMint, TAccountClaimerWinnerAta, TAccountClaimerQuoteAta, TAccountClaimer, TAccountReceipt, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<ClaimInstruction<TProgramAddress, TAccountMarket, TAccountMarketAuthority, TAccountPotVault, TAccountWinnerMint, TAccountEntryByMint, TAccountClaimerWinnerAta, TAccountClaimerQuoteAta, TAccountClaimer, TAccountReceipt, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram>>;
+type ClaimInput<TAccountMarket extends string = string, TAccountMarketAuthority extends string = string, TAccountPotVault extends string = string, TAccountWinnerMint extends string = string, TAccountEntryByMint extends string = string, TAccountClaimerWinnerAta extends string = string, TAccountClaimerQuoteAta extends string = string, TAccountClaimer extends string = string, TAccountReceipt extends string = string, TAccountPayer extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = {
+    /** Market PDA */
+    market: Address<TAccountMarket>;
+    marketAuthority: Address<TAccountMarketAuthority>;
+    /** Pot vault holding quote tokens */
+    potVault: Address<TAccountPotVault>;
+    /** Winner mint (must match market.winner_mint) */
+    winnerMint: Address<TAccountWinnerMint>;
+    /** EntryByMint for validation that this mint belongs to this market */
+    entryByMint: Address<TAccountEntryByMint>;
+    /** Claimer's winner token account (source for burn) */
+    claimerWinnerAta: Address<TAccountClaimerWinnerAta>;
+    /** Claimer's quote token account (destination for rewards) */
+    claimerQuoteAta: Address<TAccountClaimerQuoteAta>;
+    /** Claimer wallet (signer) */
+    claimer: TransactionSigner<TAccountClaimer>;
+    /** Claim receipt PDA (created if first claim) */
+    receipt: Address<TAccountReceipt>;
+    /** Payer for receipt creation (can be same as claimer) */
+    payer: TransactionSigner<TAccountPayer>;
+    tokenProgram?: Address<TAccountTokenProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    burnAmount: ClaimInstructionDataArgs['burnAmount'];
+};
+declare function getClaimInstruction<TAccountMarket extends string, TAccountMarketAuthority extends string, TAccountPotVault extends string, TAccountWinnerMint extends string, TAccountEntryByMint extends string, TAccountClaimerWinnerAta extends string, TAccountClaimerQuoteAta extends string, TAccountClaimer extends string, TAccountReceipt extends string, TAccountPayer extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS>(input: ClaimInput<TAccountMarket, TAccountMarketAuthority, TAccountPotVault, TAccountWinnerMint, TAccountEntryByMint, TAccountClaimerWinnerAta, TAccountClaimerQuoteAta, TAccountClaimer, TAccountReceipt, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): ClaimInstruction<TProgramAddress, TAccountMarket, TAccountMarketAuthority, TAccountPotVault, TAccountWinnerMint, TAccountEntryByMint, TAccountClaimerWinnerAta, TAccountClaimerQuoteAta, TAccountClaimer, TAccountReceipt, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram>;
+type ParsedClaimInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        /** Market PDA */
+        market: TAccountMetas[0];
+        marketAuthority: TAccountMetas[1];
+        /** Pot vault holding quote tokens */
+        potVault: TAccountMetas[2];
+        /** Winner mint (must match market.winner_mint) */
+        winnerMint: TAccountMetas[3];
+        /** EntryByMint for validation that this mint belongs to this market */
+        entryByMint: TAccountMetas[4];
+        /** Claimer's winner token account (source for burn) */
+        claimerWinnerAta: TAccountMetas[5];
+        /** Claimer's quote token account (destination for rewards) */
+        claimerQuoteAta: TAccountMetas[6];
+        /** Claimer wallet (signer) */
+        claimer: TAccountMetas[7];
+        /** Claim receipt PDA (created if first claim) */
+        receipt: TAccountMetas[8];
+        /** Payer for receipt creation (can be same as claimer) */
+        payer: TAccountMetas[9];
+        tokenProgram: TAccountMetas[10];
+        systemProgram: TAccountMetas[11];
+    };
+    data: ClaimInstructionData;
+};
+declare function parseClaimInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedClaimInstruction<TProgram, TAccountMetas>;
+
+/**
+ * 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
+ */
+
+declare const MIGRATE_ENTRY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getMigrateEntryDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type MigrateEntryInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountInitializerConfig extends string | AccountMeta<string> = string, TAccountLaunch extends string | AccountMeta<string> = string, TAccountLaunchAuthority extends string | AccountMeta<string> = string, TAccountBaseMint extends string | AccountMeta<string> = string, TAccountQuoteMint extends string | AccountMeta<string> = string, TAccountBaseVault extends string | AccountMeta<string> = string, TAccountQuoteVault extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA', TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TAccountRent extends string | AccountMeta<string> = 'SysvarRent111111111111111111111111111111111', TAccountOracle extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountPotVault extends string | AccountMeta<string> = string, TAccountMarketAuthority extends string | AccountMeta<string> = string, TAccountEntry extends string | AccountMeta<string> = string, TAccountEntryByMint extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountInitializerConfig extends string ? ReadonlyAccount<TAccountInitializerConfig> : TAccountInitializerConfig,
+    TAccountLaunch extends string ? ReadonlyAccount<TAccountLaunch> : TAccountLaunch,
+    TAccountLaunchAuthority extends string ? ReadonlySignerAccount<TAccountLaunchAuthority> & AccountSignerMeta<TAccountLaunchAuthority> : TAccountLaunchAuthority,
+    TAccountBaseMint extends string ? WritableAccount<TAccountBaseMint> : TAccountBaseMint,
+    TAccountQuoteMint extends string ? ReadonlyAccount<TAccountQuoteMint> : TAccountQuoteMint,
+    TAccountBaseVault extends string ? WritableAccount<TAccountBaseVault> : TAccountBaseVault,
+    TAccountQuoteVault extends string ? WritableAccount<TAccountQuoteVault> : TAccountQuoteVault,
+    TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
+    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
+    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
+    TAccountRent extends string ? ReadonlyAccount<TAccountRent> : TAccountRent,
+    TAccountOracle extends string ? ReadonlyAccount<TAccountOracle> : TAccountOracle,
+    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
+    TAccountPotVault extends string ? WritableAccount<TAccountPotVault> : TAccountPotVault,
+    TAccountMarketAuthority extends string ? ReadonlyAccount<TAccountMarketAuthority> : TAccountMarketAuthority,
+    TAccountEntry extends string ? WritableAccount<TAccountEntry> : TAccountEntry,
+    TAccountEntryByMint extends string ? ReadonlyAccount<TAccountEntryByMint> : TAccountEntryByMint,
+    ...TRemainingAccounts
+]>;
+type MigrateEntryInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    entryId: ReadonlyUint8Array;
+};
+type MigrateEntryInstructionDataArgs = {
+    entryId: ReadonlyUint8Array;
+};
+declare function getMigrateEntryInstructionDataEncoder(): FixedSizeEncoder<MigrateEntryInstructionDataArgs>;
+declare function getMigrateEntryInstructionDataDecoder(): FixedSizeDecoder<MigrateEntryInstructionData>;
+declare function getMigrateEntryInstructionDataCodec(): FixedSizeCodec<MigrateEntryInstructionDataArgs, MigrateEntryInstructionData>;
+type MigrateEntryAsyncInput<TAccountInitializerConfig extends string = string, TAccountLaunch extends string = string, TAccountLaunchAuthority extends string = string, TAccountBaseMint extends string = string, TAccountQuoteMint extends string = string, TAccountBaseVault extends string = string, TAccountQuoteVault extends string = string, TAccountPayer extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string, TAccountRent extends string = string, TAccountOracle extends string = string, TAccountMarket extends string = string, TAccountPotVault extends string = string, TAccountMarketAuthority extends string = string, TAccountEntry extends string = string, TAccountEntryByMint extends string = string> = {
+    initializerConfig: Address<TAccountInitializerConfig>;
+    /** Launch account from initializer */
+    launch: Address<TAccountLaunch>;
+    /** Launch authority PDA - signed by initializer */
+    launchAuthority: TransactionSigner<TAccountLaunchAuthority>;
+    /** Base mint for this entry (will burn unsold) */
+    baseMint: Address<TAccountBaseMint>;
+    /** Quote mint for this market */
+    quoteMint: Address<TAccountQuoteMint>;
+    /** Base vault from launch (source for burn) */
+    baseVault: Address<TAccountBaseVault>;
+    /** Quote vault from launch (source for transfer) */
+    quoteVault: Address<TAccountQuoteVault>;
+    payer: TransactionSigner<TAccountPayer>;
+    tokenProgram?: Address<TAccountTokenProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    rent?: Address<TAccountRent>;
+    /**
+     * The oracle that determines the winner.
+     * Anchor enforces owner + discriminator (trusted_oracle_interface).
+     */
+    oracle: Address<TAccountOracle>;
+    /** Market PDA */
+    market?: Address<TAccountMarket>;
+    /** Pot vault for holding quote tokens */
+    potVault: Address<TAccountPotVault>;
+    marketAuthority?: Address<TAccountMarketAuthority>;
+    /** Entry PDA */
+    entry: Address<TAccountEntry>;
+    /** EntryByMint PDA (for validation) */
+    entryByMint?: Address<TAccountEntryByMint>;
+    entryId: MigrateEntryInstructionDataArgs['entryId'];
+};
+declare function getMigrateEntryInstructionAsync<TAccountInitializerConfig extends string, TAccountLaunch extends string, TAccountLaunchAuthority extends string, TAccountBaseMint extends string, TAccountQuoteMint extends string, TAccountBaseVault extends string, TAccountQuoteVault extends string, TAccountPayer extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TAccountRent extends string, TAccountOracle extends string, TAccountMarket extends string, TAccountPotVault extends string, TAccountMarketAuthority extends string, TAccountEntry extends string, TAccountEntryByMint extends string, TProgramAddress extends Address = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS>(input: MigrateEntryAsyncInput<TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<MigrateEntryInstruction<TProgramAddress, TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint>>;
+type MigrateEntryInput<TAccountInitializerConfig extends string = string, TAccountLaunch extends string = string, TAccountLaunchAuthority extends string = string, TAccountBaseMint extends string = string, TAccountQuoteMint extends string = string, TAccountBaseVault extends string = string, TAccountQuoteVault extends string = string, TAccountPayer extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string, TAccountRent extends string = string, TAccountOracle extends string = string, TAccountMarket extends string = string, TAccountPotVault extends string = string, TAccountMarketAuthority extends string = string, TAccountEntry extends string = string, TAccountEntryByMint extends string = string> = {
+    initializerConfig: Address<TAccountInitializerConfig>;
+    /** Launch account from initializer */
+    launch: Address<TAccountLaunch>;
+    /** Launch authority PDA - signed by initializer */
+    launchAuthority: TransactionSigner<TAccountLaunchAuthority>;
+    /** Base mint for this entry (will burn unsold) */
+    baseMint: Address<TAccountBaseMint>;
+    /** Quote mint for this market */
+    quoteMint: Address<TAccountQuoteMint>;
+    /** Base vault from launch (source for burn) */
+    baseVault: Address<TAccountBaseVault>;
+    /** Quote vault from launch (source for transfer) */
+    quoteVault: Address<TAccountQuoteVault>;
+    payer: TransactionSigner<TAccountPayer>;
+    tokenProgram?: Address<TAccountTokenProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    rent?: Address<TAccountRent>;
+    /**
+     * The oracle that determines the winner.
+     * Anchor enforces owner + discriminator (trusted_oracle_interface).
+     */
+    oracle: Address<TAccountOracle>;
+    /** Market PDA */
+    market: Address<TAccountMarket>;
+    /** Pot vault for holding quote tokens */
+    potVault: Address<TAccountPotVault>;
+    marketAuthority: Address<TAccountMarketAuthority>;
+    /** Entry PDA */
+    entry: Address<TAccountEntry>;
+    /** EntryByMint PDA (for validation) */
+    entryByMint: Address<TAccountEntryByMint>;
+    entryId: MigrateEntryInstructionDataArgs['entryId'];
+};
+declare function getMigrateEntryInstruction<TAccountInitializerConfig extends string, TAccountLaunch extends string, TAccountLaunchAuthority extends string, TAccountBaseMint extends string, TAccountQuoteMint extends string, TAccountBaseVault extends string, TAccountQuoteVault extends string, TAccountPayer extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TAccountRent extends string, TAccountOracle extends string, TAccountMarket extends string, TAccountPotVault extends string, TAccountMarketAuthority extends string, TAccountEntry extends string, TAccountEntryByMint extends string, TProgramAddress extends Address = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS>(input: MigrateEntryInput<TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint>, config?: {
+    programAddress?: TProgramAddress;
+}): MigrateEntryInstruction<TProgramAddress, TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint>;
+type ParsedMigrateEntryInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        initializerConfig: TAccountMetas[0];
+        /** Launch account from initializer */
+        launch: TAccountMetas[1];
+        /** Launch authority PDA - signed by initializer */
+        launchAuthority: TAccountMetas[2];
+        /** Base mint for this entry (will burn unsold) */
+        baseMint: TAccountMetas[3];
+        /** Quote mint for this market */
+        quoteMint: TAccountMetas[4];
+        /** Base vault from launch (source for burn) */
+        baseVault: TAccountMetas[5];
+        /** Quote vault from launch (source for transfer) */
+        quoteVault: TAccountMetas[6];
+        payer: TAccountMetas[7];
+        tokenProgram: TAccountMetas[8];
+        systemProgram: TAccountMetas[9];
+        rent: TAccountMetas[10];
+        /**
+         * The oracle that determines the winner.
+         * Anchor enforces owner + discriminator (trusted_oracle_interface).
+         */
+        oracle: TAccountMetas[11];
+        /** Market PDA */
+        market: TAccountMetas[12];
+        /** Pot vault for holding quote tokens */
+        potVault: TAccountMetas[13];
+        marketAuthority: TAccountMetas[14];
+        /** Entry PDA */
+        entry: TAccountMetas[15];
+        /** EntryByMint PDA (for validation) */
+        entryByMint: TAccountMetas[16];
+    };
+    data: MigrateEntryInstructionData;
+};
+declare function parseMigrateEntryInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedMigrateEntryInstruction<TProgram, TAccountMetas>;
+
+/**
+ * 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
+ */
+
+declare const PREVIEW_PAYOUT_IF_WINNER_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getPreviewPayoutIfWinnerDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type PreviewPayoutIfWinnerInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountMarket extends string | AccountMeta<string> = string, TAccountCandidateMint extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountMarket extends string ? ReadonlyAccount<TAccountMarket> : TAccountMarket,
+    TAccountCandidateMint extends string ? ReadonlyAccount<TAccountCandidateMint> : TAccountCandidateMint,
+    ...TRemainingAccounts
+]>;
+type PreviewPayoutIfWinnerInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    candidateWinnerMint: Address;
+    tokenAmount: bigint;
+};
+type PreviewPayoutIfWinnerInstructionDataArgs = {
+    candidateWinnerMint: Address;
+    tokenAmount: number | bigint;
+};
+declare function getPreviewPayoutIfWinnerInstructionDataEncoder(): FixedSizeEncoder<PreviewPayoutIfWinnerInstructionDataArgs>;
+declare function getPreviewPayoutIfWinnerInstructionDataDecoder(): FixedSizeDecoder<PreviewPayoutIfWinnerInstructionData>;
+declare function getPreviewPayoutIfWinnerInstructionDataCodec(): FixedSizeCodec<PreviewPayoutIfWinnerInstructionDataArgs, PreviewPayoutIfWinnerInstructionData>;
+type PreviewPayoutIfWinnerInput<TAccountMarket extends string = string, TAccountCandidateMint extends string = string> = {
+    /** Market PDA */
+    market: Address<TAccountMarket>;
+    /** Candidate winner mint (may or may not match oracle winner) */
+    candidateMint: Address<TAccountCandidateMint>;
+    candidateWinnerMint: PreviewPayoutIfWinnerInstructionDataArgs['candidateWinnerMint'];
+    tokenAmount: PreviewPayoutIfWinnerInstructionDataArgs['tokenAmount'];
+};
+declare function getPreviewPayoutIfWinnerInstruction<TAccountMarket extends string, TAccountCandidateMint extends string, TProgramAddress extends Address = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS>(input: PreviewPayoutIfWinnerInput<TAccountMarket, TAccountCandidateMint>, config?: {
+    programAddress?: TProgramAddress;
+}): PreviewPayoutIfWinnerInstruction<TProgramAddress, TAccountMarket, TAccountCandidateMint>;
+type ParsedPreviewPayoutIfWinnerInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        /** Market PDA */
+        market: TAccountMetas[0];
+        /** Candidate winner mint (may or may not match oracle winner) */
+        candidateMint: TAccountMetas[1];
+    };
+    data: PreviewPayoutIfWinnerInstructionData;
+};
+declare function parsePreviewPayoutIfWinnerInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedPreviewPayoutIfWinnerInstruction<TProgram, TAccountMetas>;
+
+/**
+ * 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
+ */
+
+declare const REGISTER_ENTRY_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getRegisterEntryDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type RegisterEntryInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountInitializerConfig extends string | AccountMeta<string> = string, TAccountLaunch extends string | AccountMeta<string> = string, TAccountLaunchAuthority extends string | AccountMeta<string> = string, TAccountBaseMint extends string | AccountMeta<string> = string, TAccountQuoteMint extends string | AccountMeta<string> = string, TAccountBaseVault extends string | AccountMeta<string> = string, TAccountQuoteVault extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA', TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TAccountRent extends string | AccountMeta<string> = 'SysvarRent111111111111111111111111111111111', TAccountOracle extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountPotVault extends string | AccountMeta<string> = string, TAccountMarketAuthority extends string | AccountMeta<string> = string, TAccountEntry extends string | AccountMeta<string> = string, TAccountEntryByMint extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountInitializerConfig extends string ? ReadonlyAccount<TAccountInitializerConfig> : TAccountInitializerConfig,
+    TAccountLaunch extends string ? ReadonlyAccount<TAccountLaunch> : TAccountLaunch,
+    TAccountLaunchAuthority extends string ? ReadonlySignerAccount<TAccountLaunchAuthority> & AccountSignerMeta<TAccountLaunchAuthority> : TAccountLaunchAuthority,
+    TAccountBaseMint extends string ? ReadonlyAccount<TAccountBaseMint> : TAccountBaseMint,
+    TAccountQuoteMint extends string ? ReadonlyAccount<TAccountQuoteMint> : TAccountQuoteMint,
+    TAccountBaseVault extends string ? ReadonlyAccount<TAccountBaseVault> : TAccountBaseVault,
+    TAccountQuoteVault extends string ? ReadonlyAccount<TAccountQuoteVault> : TAccountQuoteVault,
+    TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer,
+    TAccountTokenProgram extends string ? ReadonlyAccount<TAccountTokenProgram> : TAccountTokenProgram,
+    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
+    TAccountRent extends string ? ReadonlyAccount<TAccountRent> : TAccountRent,
+    TAccountOracle extends string ? ReadonlyAccount<TAccountOracle> : TAccountOracle,
+    TAccountMarket extends string ? WritableAccount<TAccountMarket> : TAccountMarket,
+    TAccountPotVault extends string ? WritableAccount<TAccountPotVault> : TAccountPotVault,
+    TAccountMarketAuthority extends string ? ReadonlyAccount<TAccountMarketAuthority> : TAccountMarketAuthority,
+    TAccountEntry extends string ? WritableAccount<TAccountEntry> : TAccountEntry,
+    TAccountEntryByMint extends string ? WritableAccount<TAccountEntryByMint> : TAccountEntryByMint,
+    ...TRemainingAccounts
+]>;
+type RegisterEntryInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    entryId: ReadonlyUint8Array;
+};
+type RegisterEntryInstructionDataArgs = {
+    entryId: ReadonlyUint8Array;
+};
+declare function getRegisterEntryInstructionDataEncoder(): FixedSizeEncoder<RegisterEntryInstructionDataArgs>;
+declare function getRegisterEntryInstructionDataDecoder(): FixedSizeDecoder<RegisterEntryInstructionData>;
+declare function getRegisterEntryInstructionDataCodec(): FixedSizeCodec<RegisterEntryInstructionDataArgs, RegisterEntryInstructionData>;
+type RegisterEntryAsyncInput<TAccountInitializerConfig extends string = string, TAccountLaunch extends string = string, TAccountLaunchAuthority extends string = string, TAccountBaseMint extends string = string, TAccountQuoteMint extends string = string, TAccountBaseVault extends string = string, TAccountQuoteVault extends string = string, TAccountPayer extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string, TAccountRent extends string = string, TAccountOracle extends string = string, TAccountMarket extends string = string, TAccountPotVault extends string = string, TAccountMarketAuthority extends string = string, TAccountEntry extends string = string, TAccountEntryByMint extends string = string> = {
+    initializerConfig: Address<TAccountInitializerConfig>;
+    /** Launch account from initializer */
+    launch: Address<TAccountLaunch>;
+    /** Launch authority PDA - signed by initializer */
+    launchAuthority: TransactionSigner<TAccountLaunchAuthority>;
+    /** Base mint for this entry */
+    baseMint: Address<TAccountBaseMint>;
+    /** Quote mint for this market */
+    quoteMint: Address<TAccountQuoteMint>;
+    baseVault: Address<TAccountBaseVault>;
+    quoteVault: Address<TAccountQuoteVault>;
+    payer: TransactionSigner<TAccountPayer>;
+    tokenProgram?: Address<TAccountTokenProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    rent?: Address<TAccountRent>;
+    /** The oracle that this market is tied to */
+    oracle: Address<TAccountOracle>;
+    /** Market PDA - created if first entry */
+    market?: Address<TAccountMarket>;
+    /** Pot vault for holding quote tokens */
+    potVault?: Address<TAccountPotVault>;
+    marketAuthority?: Address<TAccountMarketAuthority>;
+    /** Entry PDA for this entry */
+    entry: Address<TAccountEntry>;
+    /** EntryByMint PDA for reverse lookup */
+    entryByMint?: Address<TAccountEntryByMint>;
+    entryId: RegisterEntryInstructionDataArgs['entryId'];
+};
+declare function getRegisterEntryInstructionAsync<TAccountInitializerConfig extends string, TAccountLaunch extends string, TAccountLaunchAuthority extends string, TAccountBaseMint extends string, TAccountQuoteMint extends string, TAccountBaseVault extends string, TAccountQuoteVault extends string, TAccountPayer extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TAccountRent extends string, TAccountOracle extends string, TAccountMarket extends string, TAccountPotVault extends string, TAccountMarketAuthority extends string, TAccountEntry extends string, TAccountEntryByMint extends string, TProgramAddress extends Address = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS>(input: RegisterEntryAsyncInput<TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<RegisterEntryInstruction<TProgramAddress, TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint>>;
+type RegisterEntryInput<TAccountInitializerConfig extends string = string, TAccountLaunch extends string = string, TAccountLaunchAuthority extends string = string, TAccountBaseMint extends string = string, TAccountQuoteMint extends string = string, TAccountBaseVault extends string = string, TAccountQuoteVault extends string = string, TAccountPayer extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string, TAccountRent extends string = string, TAccountOracle extends string = string, TAccountMarket extends string = string, TAccountPotVault extends string = string, TAccountMarketAuthority extends string = string, TAccountEntry extends string = string, TAccountEntryByMint extends string = string> = {
+    initializerConfig: Address<TAccountInitializerConfig>;
+    /** Launch account from initializer */
+    launch: Address<TAccountLaunch>;
+    /** Launch authority PDA - signed by initializer */
+    launchAuthority: TransactionSigner<TAccountLaunchAuthority>;
+    /** Base mint for this entry */
+    baseMint: Address<TAccountBaseMint>;
+    /** Quote mint for this market */
+    quoteMint: Address<TAccountQuoteMint>;
+    baseVault: Address<TAccountBaseVault>;
+    quoteVault: Address<TAccountQuoteVault>;
+    payer: TransactionSigner<TAccountPayer>;
+    tokenProgram?: Address<TAccountTokenProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    rent?: Address<TAccountRent>;
+    /** The oracle that this market is tied to */
+    oracle: Address<TAccountOracle>;
+    /** Market PDA - created if first entry */
+    market: Address<TAccountMarket>;
+    /** Pot vault for holding quote tokens */
+    potVault: Address<TAccountPotVault>;
+    marketAuthority: Address<TAccountMarketAuthority>;
+    /** Entry PDA for this entry */
+    entry: Address<TAccountEntry>;
+    /** EntryByMint PDA for reverse lookup */
+    entryByMint: Address<TAccountEntryByMint>;
+    entryId: RegisterEntryInstructionDataArgs['entryId'];
+};
+declare function getRegisterEntryInstruction<TAccountInitializerConfig extends string, TAccountLaunch extends string, TAccountLaunchAuthority extends string, TAccountBaseMint extends string, TAccountQuoteMint extends string, TAccountBaseVault extends string, TAccountQuoteVault extends string, TAccountPayer extends string, TAccountTokenProgram extends string, TAccountSystemProgram extends string, TAccountRent extends string, TAccountOracle extends string, TAccountMarket extends string, TAccountPotVault extends string, TAccountMarketAuthority extends string, TAccountEntry extends string, TAccountEntryByMint extends string, TProgramAddress extends Address = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS>(input: RegisterEntryInput<TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint>, config?: {
+    programAddress?: TProgramAddress;
+}): RegisterEntryInstruction<TProgramAddress, TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint>;
+type ParsedRegisterEntryInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        initializerConfig: TAccountMetas[0];
+        /** Launch account from initializer */
+        launch: TAccountMetas[1];
+        /** Launch authority PDA - signed by initializer */
+        launchAuthority: TAccountMetas[2];
+        /** Base mint for this entry */
+        baseMint: TAccountMetas[3];
+        /** Quote mint for this market */
+        quoteMint: TAccountMetas[4];
+        baseVault: TAccountMetas[5];
+        quoteVault: TAccountMetas[6];
+        payer: TAccountMetas[7];
+        tokenProgram: TAccountMetas[8];
+        systemProgram: TAccountMetas[9];
+        rent: TAccountMetas[10];
+        /** The oracle that this market is tied to */
+        oracle: TAccountMetas[11];
+        /** Market PDA - created if first entry */
+        market: TAccountMetas[12];
+        /** Pot vault for holding quote tokens */
+        potVault: TAccountMetas[13];
+        marketAuthority: TAccountMetas[14];
+        /** Entry PDA for this entry */
+        entry: TAccountMetas[15];
+        /** EntryByMint PDA for reverse lookup */
+        entryByMint: TAccountMetas[16];
+    };
+    data: RegisterEntryInstructionData;
+};
+declare function parseRegisterEntryInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedRegisterEntryInstruction<TProgram, TAccountMetas>;
+
+declare function getPredictionMarketAddress(oracleState: Address, programId?: Address): Promise<ProgramDerivedAddress>;
+declare function getPredictionMarketAuthorityAddress(market: Address, programId?: Address): Promise<ProgramDerivedAddress>;
+declare function getPredictionPotVaultAddress(market: Address, programId?: Address): Promise<ProgramDerivedAddress>;
+declare function getPredictionEntryAddress(oracleState: Address, entryId: ReadonlyUint8Array | Uint8Array, programId?: Address): Promise<ProgramDerivedAddress>;
+declare function getPredictionEntryByMintAddress(oracleState: Address, mint: Address, programId?: Address): Promise<ProgramDerivedAddress>;
+
+type index$1_AccumulatorUpdated = AccumulatorUpdated;
+type index$1_AccumulatorUpdatedArgs = AccumulatorUpdatedArgs;
+declare const index$1_CLAIM_DISCRIMINATOR: typeof CLAIM_DISCRIMINATOR;
+declare const index$1_CLAIM_RECEIPT_DISCRIMINATOR: typeof CLAIM_RECEIPT_DISCRIMINATOR;
+type index$1_CalldataBuf = CalldataBuf;
+type index$1_CalldataBufArgs = CalldataBufArgs;
+type index$1_ClaimAsyncInput<TAccountMarket extends string = string, TAccountMarketAuthority extends string = string, TAccountPotVault extends string = string, TAccountWinnerMint extends string = string, TAccountEntryByMint extends string = string, TAccountClaimerWinnerAta extends string = string, TAccountClaimerQuoteAta extends string = string, TAccountClaimer extends string = string, TAccountReceipt extends string = string, TAccountPayer extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = ClaimAsyncInput<TAccountMarket, TAccountMarketAuthority, TAccountPotVault, TAccountWinnerMint, TAccountEntryByMint, TAccountClaimerWinnerAta, TAccountClaimerQuoteAta, TAccountClaimer, TAccountReceipt, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram>;
+type index$1_ClaimInput<TAccountMarket extends string = string, TAccountMarketAuthority extends string = string, TAccountPotVault extends string = string, TAccountWinnerMint extends string = string, TAccountEntryByMint extends string = string, TAccountClaimerWinnerAta extends string = string, TAccountClaimerQuoteAta extends string = string, TAccountClaimer extends string = string, TAccountReceipt extends string = string, TAccountPayer extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string> = ClaimInput<TAccountMarket, TAccountMarketAuthority, TAccountPotVault, TAccountWinnerMint, TAccountEntryByMint, TAccountClaimerWinnerAta, TAccountClaimerQuoteAta, TAccountClaimer, TAccountReceipt, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram>;
+type index$1_ClaimInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountMarket extends string | AccountMeta<string> = string, TAccountMarketAuthority extends string | AccountMeta<string> = string, TAccountPotVault extends string | AccountMeta<string> = string, TAccountWinnerMint extends string | AccountMeta<string> = string, TAccountEntryByMint extends string | AccountMeta<string> = string, TAccountClaimerWinnerAta extends string | AccountMeta<string> = string, TAccountClaimerQuoteAta extends string | AccountMeta<string> = string, TAccountClaimer extends string | AccountMeta<string> = string, TAccountReceipt extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA', TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = ClaimInstruction<TProgram, TAccountMarket, TAccountMarketAuthority, TAccountPotVault, TAccountWinnerMint, TAccountEntryByMint, TAccountClaimerWinnerAta, TAccountClaimerQuoteAta, TAccountClaimer, TAccountReceipt, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TRemainingAccounts>;
+type index$1_ClaimInstructionData = ClaimInstructionData;
+type index$1_ClaimInstructionDataArgs = ClaimInstructionDataArgs;
+type index$1_ClaimReceipt = ClaimReceipt;
+type index$1_ClaimReceiptArgs = ClaimReceiptArgs;
+declare const index$1_ENTRY_BY_MINT_DISCRIMINATOR: typeof ENTRY_BY_MINT_DISCRIMINATOR;
+declare const index$1_ENTRY_DISCRIMINATOR: typeof ENTRY_DISCRIMINATOR;
+type index$1_Entry = Entry;
+type index$1_EntryArgs = EntryArgs;
+type index$1_EntryByMint = EntryByMint;
+type index$1_EntryByMintArgs = EntryByMintArgs;
+type index$1_EntryMigrated = EntryMigrated;
+type index$1_EntryMigratedArgs = EntryMigratedArgs;
+type index$1_EntryRegistered = EntryRegistered;
+type index$1_EntryRegisteredArgs = EntryRegisteredArgs;
+declare const index$1_LAUNCH_DISCRIMINATOR: typeof LAUNCH_DISCRIMINATOR;
+type index$1_Launch = Launch;
+type index$1_LaunchArgs = LaunchArgs;
+declare const index$1_MARKET_DISCRIMINATOR: typeof MARKET_DISCRIMINATOR;
+declare const index$1_MIGRATE_ENTRY_DISCRIMINATOR: typeof MIGRATE_ENTRY_DISCRIMINATOR;
+type index$1_Market = Market;
+type index$1_MarketArgs = MarketArgs;
+type index$1_MarketCreated = MarketCreated;
+type index$1_MarketCreatedArgs = MarketCreatedArgs;
+type index$1_MarketResolved = MarketResolved;
+type index$1_MarketResolvedArgs = MarketResolvedArgs;
+type index$1_MigrateEntryArgs = MigrateEntryArgs;
+type index$1_MigrateEntryArgsArgs = MigrateEntryArgsArgs;
+type index$1_MigrateEntryAsyncInput<TAccountInitializerConfig extends string = string, TAccountLaunch extends string = string, TAccountLaunchAuthority extends string = string, TAccountBaseMint extends string = string, TAccountQuoteMint extends string = string, TAccountBaseVault extends string = string, TAccountQuoteVault extends string = string, TAccountPayer extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string, TAccountRent extends string = string, TAccountOracle extends string = string, TAccountMarket extends string = string, TAccountPotVault extends string = string, TAccountMarketAuthority extends string = string, TAccountEntry extends string = string, TAccountEntryByMint extends string = string> = MigrateEntryAsyncInput<TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint>;
+type index$1_MigrateEntryInput<TAccountInitializerConfig extends string = string, TAccountLaunch extends string = string, TAccountLaunchAuthority extends string = string, TAccountBaseMint extends string = string, TAccountQuoteMint extends string = string, TAccountBaseVault extends string = string, TAccountQuoteVault extends string = string, TAccountPayer extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string, TAccountRent extends string = string, TAccountOracle extends string = string, TAccountMarket extends string = string, TAccountPotVault extends string = string, TAccountMarketAuthority extends string = string, TAccountEntry extends string = string, TAccountEntryByMint extends string = string> = MigrateEntryInput<TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint>;
+type index$1_MigrateEntryInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountInitializerConfig extends string | AccountMeta<string> = string, TAccountLaunch extends string | AccountMeta<string> = string, TAccountLaunchAuthority extends string | AccountMeta<string> = string, TAccountBaseMint extends string | AccountMeta<string> = string, TAccountQuoteMint extends string | AccountMeta<string> = string, TAccountBaseVault extends string | AccountMeta<string> = string, TAccountQuoteVault extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA', TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TAccountRent extends string | AccountMeta<string> = 'SysvarRent111111111111111111111111111111111', TAccountOracle extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountPotVault extends string | AccountMeta<string> = string, TAccountMarketAuthority extends string | AccountMeta<string> = string, TAccountEntry extends string | AccountMeta<string> = string, TAccountEntryByMint extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = MigrateEntryInstruction<TProgram, TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint, TRemainingAccounts>;
+type index$1_MigrateEntryInstructionData = MigrateEntryInstructionData;
+type index$1_MigrateEntryInstructionDataArgs = MigrateEntryInstructionDataArgs;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_MIGRATED: typeof PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_MIGRATED;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_REGISTERED: typeof PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_REGISTERED;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_MIGRATED: typeof PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_MIGRATED;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_REGISTERED: typeof PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_REGISTERED;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__INSUFFICIENT_BALANCE: typeof PREDICTION_MIGRATOR_ERROR__INSUFFICIENT_BALANCE;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__INVALID_ENTRY_ID: typeof PREDICTION_MIGRATOR_ERROR__INVALID_ENTRY_ID;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__INVALID_INPUT: typeof PREDICTION_MIGRATOR_ERROR__INVALID_INPUT;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__INVALID_MARKET: typeof PREDICTION_MIGRATOR_ERROR__INVALID_MARKET;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__INVALID_MINT: typeof PREDICTION_MIGRATOR_ERROR__INVALID_MINT;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__INVALID_ORACLE: typeof PREDICTION_MIGRATOR_ERROR__INVALID_ORACLE;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__INVALID_VAULT: typeof PREDICTION_MIGRATOR_ERROR__INVALID_VAULT;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__INVALID_WINNER_MINT: typeof PREDICTION_MIGRATOR_ERROR__INVALID_WINNER_MINT;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__MARKET_NOT_RESOLVED: typeof PREDICTION_MIGRATOR_ERROR__MARKET_NOT_RESOLVED;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__MATH_OVERFLOW: typeof PREDICTION_MIGRATOR_ERROR__MATH_OVERFLOW;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__NO_PENDING_REWARDS: typeof PREDICTION_MIGRATOR_ERROR__NO_PENDING_REWARDS;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__ORACLE_NOT_FINALIZED: typeof PREDICTION_MIGRATOR_ERROR__ORACLE_NOT_FINALIZED;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__QUOTE_MINT_MISMATCH: typeof PREDICTION_MIGRATOR_ERROR__QUOTE_MINT_MISMATCH;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__UNAUTHORIZED: typeof PREDICTION_MIGRATOR_ERROR__UNAUTHORIZED;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__WINNING_ENTRY_NOT_MIGRATED: typeof PREDICTION_MIGRATOR_ERROR__WINNING_ENTRY_NOT_MIGRATED;
+declare const index$1_PREDICTION_MIGRATOR_ERROR__ZERO_CLAIMABLE_SUPPLY: typeof PREDICTION_MIGRATOR_ERROR__ZERO_CLAIMABLE_SUPPLY;
+declare const index$1_PREDICTION_MIGRATOR_PROGRAM_ADDRESS: typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS;
+declare const index$1_PREVIEW_PAYOUT_IF_WINNER_DISCRIMINATOR: typeof PREVIEW_PAYOUT_IF_WINNER_DISCRIMINATOR;
+type index$1_ParsedClaimInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = ParsedClaimInstruction<TProgram, TAccountMetas>;
+type index$1_ParsedMigrateEntryInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = ParsedMigrateEntryInstruction<TProgram, TAccountMetas>;
+type index$1_ParsedPredictionMigratorInstruction<TProgram extends string = 'HYHdyy7QZg8Ucky9Z97xNtSCvrZxVNkeoney8xEPXjiZ'> = ParsedPredictionMigratorInstruction<TProgram>;
+type index$1_ParsedPreviewPayoutIfWinnerInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = ParsedPreviewPayoutIfWinnerInstruction<TProgram, TAccountMetas>;
+type index$1_ParsedRegisterEntryInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = ParsedRegisterEntryInstruction<TProgram, TAccountMetas>;
+type index$1_PredictionMigratorAccount = PredictionMigratorAccount;
+declare const index$1_PredictionMigratorAccount: typeof PredictionMigratorAccount;
+type index$1_PredictionMigratorError = PredictionMigratorError;
+type index$1_PredictionMigratorInstruction = PredictionMigratorInstruction;
+declare const index$1_PredictionMigratorInstruction: typeof PredictionMigratorInstruction;
+type index$1_PredictionMigratorPlugin = PredictionMigratorPlugin;
+type index$1_PredictionMigratorPluginAccounts = PredictionMigratorPluginAccounts;
+type index$1_PredictionMigratorPluginInstructions = PredictionMigratorPluginInstructions;
+type index$1_PredictionMigratorPluginRequirements = PredictionMigratorPluginRequirements;
+type index$1_PreviewPayoutIfWinnerArgs = PreviewPayoutIfWinnerArgs;
+type index$1_PreviewPayoutIfWinnerArgsArgs = PreviewPayoutIfWinnerArgsArgs;
+type index$1_PreviewPayoutIfWinnerInput<TAccountMarket extends string = string, TAccountCandidateMint extends string = string> = PreviewPayoutIfWinnerInput<TAccountMarket, TAccountCandidateMint>;
+type index$1_PreviewPayoutIfWinnerInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountMarket extends string | AccountMeta<string> = string, TAccountCandidateMint extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = PreviewPayoutIfWinnerInstruction<TProgram, TAccountMarket, TAccountCandidateMint, TRemainingAccounts>;
+type index$1_PreviewPayoutIfWinnerInstructionData = PreviewPayoutIfWinnerInstructionData;
+type index$1_PreviewPayoutIfWinnerInstructionDataArgs = PreviewPayoutIfWinnerInstructionDataArgs;
+declare const index$1_REGISTER_ENTRY_DISCRIMINATOR: typeof REGISTER_ENTRY_DISCRIMINATOR;
+type index$1_RegisterEntryArgs = RegisterEntryArgs;
+type index$1_RegisterEntryArgsArgs = RegisterEntryArgsArgs;
+type index$1_RegisterEntryAsyncInput<TAccountInitializerConfig extends string = string, TAccountLaunch extends string = string, TAccountLaunchAuthority extends string = string, TAccountBaseMint extends string = string, TAccountQuoteMint extends string = string, TAccountBaseVault extends string = string, TAccountQuoteVault extends string = string, TAccountPayer extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string, TAccountRent extends string = string, TAccountOracle extends string = string, TAccountMarket extends string = string, TAccountPotVault extends string = string, TAccountMarketAuthority extends string = string, TAccountEntry extends string = string, TAccountEntryByMint extends string = string> = RegisterEntryAsyncInput<TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint>;
+type index$1_RegisterEntryInput<TAccountInitializerConfig extends string = string, TAccountLaunch extends string = string, TAccountLaunchAuthority extends string = string, TAccountBaseMint extends string = string, TAccountQuoteMint extends string = string, TAccountBaseVault extends string = string, TAccountQuoteVault extends string = string, TAccountPayer extends string = string, TAccountTokenProgram extends string = string, TAccountSystemProgram extends string = string, TAccountRent extends string = string, TAccountOracle extends string = string, TAccountMarket extends string = string, TAccountPotVault extends string = string, TAccountMarketAuthority extends string = string, TAccountEntry extends string = string, TAccountEntryByMint extends string = string> = RegisterEntryInput<TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint>;
+type index$1_RegisterEntryInstruction<TProgram extends string = typeof PREDICTION_MIGRATOR_PROGRAM_ADDRESS, TAccountInitializerConfig extends string | AccountMeta<string> = string, TAccountLaunch extends string | AccountMeta<string> = string, TAccountLaunchAuthority extends string | AccountMeta<string> = string, TAccountBaseMint extends string | AccountMeta<string> = string, TAccountQuoteMint extends string | AccountMeta<string> = string, TAccountBaseVault extends string | AccountMeta<string> = string, TAccountQuoteVault extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountTokenProgram extends string | AccountMeta<string> = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA', TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TAccountRent extends string | AccountMeta<string> = 'SysvarRent111111111111111111111111111111111', TAccountOracle extends string | AccountMeta<string> = string, TAccountMarket extends string | AccountMeta<string> = string, TAccountPotVault extends string | AccountMeta<string> = string, TAccountMarketAuthority extends string | AccountMeta<string> = string, TAccountEntry extends string | AccountMeta<string> = string, TAccountEntryByMint extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = RegisterEntryInstruction<TProgram, TAccountInitializerConfig, TAccountLaunch, TAccountLaunchAuthority, TAccountBaseMint, TAccountQuoteMint, TAccountBaseVault, TAccountQuoteVault, TAccountPayer, TAccountTokenProgram, TAccountSystemProgram, TAccountRent, TAccountOracle, TAccountMarket, TAccountPotVault, TAccountMarketAuthority, TAccountEntry, TAccountEntryByMint, TRemainingAccounts>;
+type index$1_RegisterEntryInstructionData = RegisterEntryInstructionData;
+type index$1_RegisterEntryInstructionDataArgs = RegisterEntryInstructionDataArgs;
+type index$1_RewardsClaimed = RewardsClaimed;
+type index$1_RewardsClaimedArgs = RewardsClaimedArgs;
+declare const index$1_decodeClaimReceipt: typeof decodeClaimReceipt;
+declare const index$1_decodeEntry: typeof decodeEntry;
+declare const index$1_decodeEntryByMint: typeof decodeEntryByMint;
+declare const index$1_decodeLaunch: typeof decodeLaunch;
+declare const index$1_decodeMarket: typeof decodeMarket;
+declare const index$1_fetchAllClaimReceipt: typeof fetchAllClaimReceipt;
+declare const index$1_fetchAllEntry: typeof fetchAllEntry;
+declare const index$1_fetchAllEntryByMint: typeof fetchAllEntryByMint;
+declare const index$1_fetchAllLaunch: typeof fetchAllLaunch;
+declare const index$1_fetchAllMarket: typeof fetchAllMarket;
+declare const index$1_fetchAllMaybeClaimReceipt: typeof fetchAllMaybeClaimReceipt;
+declare const index$1_fetchAllMaybeEntry: typeof fetchAllMaybeEntry;
+declare const index$1_fetchAllMaybeEntryByMint: typeof fetchAllMaybeEntryByMint;
+declare const index$1_fetchAllMaybeLaunch: typeof fetchAllMaybeLaunch;
+declare const index$1_fetchAllMaybeMarket: typeof fetchAllMaybeMarket;
+declare const index$1_fetchClaimReceipt: typeof fetchClaimReceipt;
+declare const index$1_fetchEntry: typeof fetchEntry;
+declare const index$1_fetchEntryByMint: typeof fetchEntryByMint;
+declare const index$1_fetchLaunch: typeof fetchLaunch;
+declare const index$1_fetchMarket: typeof fetchMarket;
+declare const index$1_fetchMaybeClaimReceipt: typeof fetchMaybeClaimReceipt;
+declare const index$1_fetchMaybeEntry: typeof fetchMaybeEntry;
+declare const index$1_fetchMaybeEntryByMint: typeof fetchMaybeEntryByMint;
+declare const index$1_fetchMaybeLaunch: typeof fetchMaybeLaunch;
+declare const index$1_fetchMaybeMarket: typeof fetchMaybeMarket;
+declare const index$1_getAccumulatorUpdatedCodec: typeof getAccumulatorUpdatedCodec;
+declare const index$1_getAccumulatorUpdatedDecoder: typeof getAccumulatorUpdatedDecoder;
+declare const index$1_getAccumulatorUpdatedEncoder: typeof getAccumulatorUpdatedEncoder;
+declare const index$1_getCalldataBufCodec: typeof getCalldataBufCodec;
+declare const index$1_getCalldataBufDecoder: typeof getCalldataBufDecoder;
+declare const index$1_getCalldataBufEncoder: typeof getCalldataBufEncoder;
+declare const index$1_getClaimDiscriminatorBytes: typeof getClaimDiscriminatorBytes;
+declare const index$1_getClaimInstruction: typeof getClaimInstruction;
+declare const index$1_getClaimInstructionAsync: typeof getClaimInstructionAsync;
+declare const index$1_getClaimInstructionDataCodec: typeof getClaimInstructionDataCodec;
+declare const index$1_getClaimInstructionDataDecoder: typeof getClaimInstructionDataDecoder;
+declare const index$1_getClaimInstructionDataEncoder: typeof getClaimInstructionDataEncoder;
+declare const index$1_getClaimReceiptCodec: typeof getClaimReceiptCodec;
+declare const index$1_getClaimReceiptDecoder: typeof getClaimReceiptDecoder;
+declare const index$1_getClaimReceiptDiscriminatorBytes: typeof getClaimReceiptDiscriminatorBytes;
+declare const index$1_getClaimReceiptEncoder: typeof getClaimReceiptEncoder;
+declare const index$1_getClaimReceiptSize: typeof getClaimReceiptSize;
+declare const index$1_getEntryByMintCodec: typeof getEntryByMintCodec;
+declare const index$1_getEntryByMintDecoder: typeof getEntryByMintDecoder;
+declare const index$1_getEntryByMintDiscriminatorBytes: typeof getEntryByMintDiscriminatorBytes;
+declare const index$1_getEntryByMintEncoder: typeof getEntryByMintEncoder;
+declare const index$1_getEntryByMintSize: typeof getEntryByMintSize;
+declare const index$1_getEntryCodec: typeof getEntryCodec;
+declare const index$1_getEntryDecoder: typeof getEntryDecoder;
+declare const index$1_getEntryDiscriminatorBytes: typeof getEntryDiscriminatorBytes;
+declare const index$1_getEntryEncoder: typeof getEntryEncoder;
+declare const index$1_getEntryMigratedCodec: typeof getEntryMigratedCodec;
+declare const index$1_getEntryMigratedDecoder: typeof getEntryMigratedDecoder;
+declare const index$1_getEntryMigratedEncoder: typeof getEntryMigratedEncoder;
+declare const index$1_getEntryRegisteredCodec: typeof getEntryRegisteredCodec;
+declare const index$1_getEntryRegisteredDecoder: typeof getEntryRegisteredDecoder;
+declare const index$1_getEntryRegisteredEncoder: typeof getEntryRegisteredEncoder;
+declare const index$1_getEntrySize: typeof getEntrySize;
+declare const index$1_getLaunchCodec: typeof getLaunchCodec;
+declare const index$1_getLaunchDecoder: typeof getLaunchDecoder;
+declare const index$1_getLaunchDiscriminatorBytes: typeof getLaunchDiscriminatorBytes;
+declare const index$1_getLaunchEncoder: typeof getLaunchEncoder;
+declare const index$1_getLaunchSize: typeof getLaunchSize;
+declare const index$1_getMarketCodec: typeof getMarketCodec;
+declare const index$1_getMarketCreatedCodec: typeof getMarketCreatedCodec;
+declare const index$1_getMarketCreatedDecoder: typeof getMarketCreatedDecoder;
+declare const index$1_getMarketCreatedEncoder: typeof getMarketCreatedEncoder;
+declare const index$1_getMarketDecoder: typeof getMarketDecoder;
+declare const index$1_getMarketDiscriminatorBytes: typeof getMarketDiscriminatorBytes;
+declare const index$1_getMarketEncoder: typeof getMarketEncoder;
+declare const index$1_getMarketResolvedCodec: typeof getMarketResolvedCodec;
+declare const index$1_getMarketResolvedDecoder: typeof getMarketResolvedDecoder;
+declare const index$1_getMarketResolvedEncoder: typeof getMarketResolvedEncoder;
+declare const index$1_getMarketSize: typeof getMarketSize;
+declare const index$1_getMigrateEntryArgsCodec: typeof getMigrateEntryArgsCodec;
+declare const index$1_getMigrateEntryArgsDecoder: typeof getMigrateEntryArgsDecoder;
+declare const index$1_getMigrateEntryArgsEncoder: typeof getMigrateEntryArgsEncoder;
+declare const index$1_getMigrateEntryDiscriminatorBytes: typeof getMigrateEntryDiscriminatorBytes;
+declare const index$1_getMigrateEntryInstruction: typeof getMigrateEntryInstruction;
+declare const index$1_getMigrateEntryInstructionAsync: typeof getMigrateEntryInstructionAsync;
+declare const index$1_getMigrateEntryInstructionDataCodec: typeof getMigrateEntryInstructionDataCodec;
+declare const index$1_getMigrateEntryInstructionDataDecoder: typeof getMigrateEntryInstructionDataDecoder;
+declare const index$1_getMigrateEntryInstructionDataEncoder: typeof getMigrateEntryInstructionDataEncoder;
+declare const index$1_getPredictionEntryAddress: typeof getPredictionEntryAddress;
+declare const index$1_getPredictionEntryByMintAddress: typeof getPredictionEntryByMintAddress;
+declare const index$1_getPredictionMarketAddress: typeof getPredictionMarketAddress;
+declare const index$1_getPredictionMarketAuthorityAddress: typeof getPredictionMarketAuthorityAddress;
+declare const index$1_getPredictionMigratorErrorMessage: typeof getPredictionMigratorErrorMessage;
+declare const index$1_getPredictionPotVaultAddress: typeof getPredictionPotVaultAddress;
+declare const index$1_getPreviewPayoutIfWinnerArgsCodec: typeof getPreviewPayoutIfWinnerArgsCodec;
+declare const index$1_getPreviewPayoutIfWinnerArgsDecoder: typeof getPreviewPayoutIfWinnerArgsDecoder;
+declare const index$1_getPreviewPayoutIfWinnerArgsEncoder: typeof getPreviewPayoutIfWinnerArgsEncoder;
+declare const index$1_getPreviewPayoutIfWinnerDiscriminatorBytes: typeof getPreviewPayoutIfWinnerDiscriminatorBytes;
+declare const index$1_getPreviewPayoutIfWinnerInstruction: typeof getPreviewPayoutIfWinnerInstruction;
+declare const index$1_getPreviewPayoutIfWinnerInstructionDataCodec: typeof getPreviewPayoutIfWinnerInstructionDataCodec;
+declare const index$1_getPreviewPayoutIfWinnerInstructionDataDecoder: typeof getPreviewPayoutIfWinnerInstructionDataDecoder;
+declare const index$1_getPreviewPayoutIfWinnerInstructionDataEncoder: typeof getPreviewPayoutIfWinnerInstructionDataEncoder;
+declare const index$1_getRegisterEntryArgsCodec: typeof getRegisterEntryArgsCodec;
+declare const index$1_getRegisterEntryArgsDecoder: typeof getRegisterEntryArgsDecoder;
+declare const index$1_getRegisterEntryArgsEncoder: typeof getRegisterEntryArgsEncoder;
+declare const index$1_getRegisterEntryDiscriminatorBytes: typeof getRegisterEntryDiscriminatorBytes;
+declare const index$1_getRegisterEntryInstruction: typeof getRegisterEntryInstruction;
+declare const index$1_getRegisterEntryInstructionAsync: typeof getRegisterEntryInstructionAsync;
+declare const index$1_getRegisterEntryInstructionDataCodec: typeof getRegisterEntryInstructionDataCodec;
+declare const index$1_getRegisterEntryInstructionDataDecoder: typeof getRegisterEntryInstructionDataDecoder;
+declare const index$1_getRegisterEntryInstructionDataEncoder: typeof getRegisterEntryInstructionDataEncoder;
+declare const index$1_getRewardsClaimedCodec: typeof getRewardsClaimedCodec;
+declare const index$1_getRewardsClaimedDecoder: typeof getRewardsClaimedDecoder;
+declare const index$1_getRewardsClaimedEncoder: typeof getRewardsClaimedEncoder;
+declare const index$1_identifyPredictionMigratorAccount: typeof identifyPredictionMigratorAccount;
+declare const index$1_identifyPredictionMigratorInstruction: typeof identifyPredictionMigratorInstruction;
+declare const index$1_isPredictionMigratorError: typeof isPredictionMigratorError;
+declare const index$1_parseClaimInstruction: typeof parseClaimInstruction;
+declare const index$1_parseMigrateEntryInstruction: typeof parseMigrateEntryInstruction;
+declare const index$1_parsePredictionMigratorInstruction: typeof parsePredictionMigratorInstruction;
+declare const index$1_parsePreviewPayoutIfWinnerInstruction: typeof parsePreviewPayoutIfWinnerInstruction;
+declare const index$1_parseRegisterEntryInstruction: typeof parseRegisterEntryInstruction;
+declare const index$1_predictionMigratorProgram: typeof predictionMigratorProgram;
+declare namespace index$1 {
+  export { type index$1_AccumulatorUpdated as AccumulatorUpdated, type index$1_AccumulatorUpdatedArgs as AccumulatorUpdatedArgs, index$1_CLAIM_DISCRIMINATOR as CLAIM_DISCRIMINATOR, index$1_CLAIM_RECEIPT_DISCRIMINATOR as CLAIM_RECEIPT_DISCRIMINATOR, type index$1_CalldataBuf as CalldataBuf, type index$1_CalldataBufArgs as CalldataBufArgs, type index$1_ClaimAsyncInput as ClaimAsyncInput, type index$1_ClaimInput as ClaimInput, type index$1_ClaimInstruction as ClaimInstruction, type index$1_ClaimInstructionData as ClaimInstructionData, type index$1_ClaimInstructionDataArgs as ClaimInstructionDataArgs, type index$1_ClaimReceipt as ClaimReceipt, type index$1_ClaimReceiptArgs as ClaimReceiptArgs, index$1_ENTRY_BY_MINT_DISCRIMINATOR as ENTRY_BY_MINT_DISCRIMINATOR, index$1_ENTRY_DISCRIMINATOR as ENTRY_DISCRIMINATOR, type index$1_Entry as Entry, type index$1_EntryArgs as EntryArgs, type index$1_EntryByMint as EntryByMint, type index$1_EntryByMintArgs as EntryByMintArgs, type index$1_EntryMigrated as EntryMigrated, type index$1_EntryMigratedArgs as EntryMigratedArgs, type index$1_EntryRegistered as EntryRegistered, type index$1_EntryRegisteredArgs as EntryRegisteredArgs, index$1_LAUNCH_DISCRIMINATOR as LAUNCH_DISCRIMINATOR, type index$1_Launch as Launch, type index$1_LaunchArgs as LaunchArgs, index$1_MARKET_DISCRIMINATOR as MARKET_DISCRIMINATOR, index$1_MIGRATE_ENTRY_DISCRIMINATOR as MIGRATE_ENTRY_DISCRIMINATOR, type index$1_Market as Market, type index$1_MarketArgs as MarketArgs, type index$1_MarketCreated as MarketCreated, type index$1_MarketCreatedArgs as MarketCreatedArgs, type index$1_MarketResolved as MarketResolved, type index$1_MarketResolvedArgs as MarketResolvedArgs, type index$1_MigrateEntryArgs as MigrateEntryArgs, type index$1_MigrateEntryArgsArgs as MigrateEntryArgsArgs, type index$1_MigrateEntryAsyncInput as MigrateEntryAsyncInput, type index$1_MigrateEntryInput as MigrateEntryInput, type index$1_MigrateEntryInstruction as MigrateEntryInstruction, type index$1_MigrateEntryInstructionData as MigrateEntryInstructionData, type index$1_MigrateEntryInstructionDataArgs as MigrateEntryInstructionDataArgs, ORACLE_STATE_DISCRIMINATOR$1 as ORACLE_STATE_DISCRIMINATOR, type OracleState$1 as OracleState, type OracleStateArgs$1 as OracleStateArgs, index$1_PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_MIGRATED as PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_MIGRATED, index$1_PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_REGISTERED as PREDICTION_MIGRATOR_ERROR__ENTRY_ALREADY_REGISTERED, index$1_PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_MIGRATED as PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_MIGRATED, index$1_PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_REGISTERED as PREDICTION_MIGRATOR_ERROR__ENTRY_NOT_REGISTERED, index$1_PREDICTION_MIGRATOR_ERROR__INSUFFICIENT_BALANCE as PREDICTION_MIGRATOR_ERROR__INSUFFICIENT_BALANCE, index$1_PREDICTION_MIGRATOR_ERROR__INVALID_ENTRY_ID as PREDICTION_MIGRATOR_ERROR__INVALID_ENTRY_ID, index$1_PREDICTION_MIGRATOR_ERROR__INVALID_INPUT as PREDICTION_MIGRATOR_ERROR__INVALID_INPUT, index$1_PREDICTION_MIGRATOR_ERROR__INVALID_MARKET as PREDICTION_MIGRATOR_ERROR__INVALID_MARKET, index$1_PREDICTION_MIGRATOR_ERROR__INVALID_MINT as PREDICTION_MIGRATOR_ERROR__INVALID_MINT, index$1_PREDICTION_MIGRATOR_ERROR__INVALID_ORACLE as PREDICTION_MIGRATOR_ERROR__INVALID_ORACLE, index$1_PREDICTION_MIGRATOR_ERROR__INVALID_VAULT as PREDICTION_MIGRATOR_ERROR__INVALID_VAULT, index$1_PREDICTION_MIGRATOR_ERROR__INVALID_WINNER_MINT as PREDICTION_MIGRATOR_ERROR__INVALID_WINNER_MINT, index$1_PREDICTION_MIGRATOR_ERROR__MARKET_NOT_RESOLVED as PREDICTION_MIGRATOR_ERROR__MARKET_NOT_RESOLVED, index$1_PREDICTION_MIGRATOR_ERROR__MATH_OVERFLOW as PREDICTION_MIGRATOR_ERROR__MATH_OVERFLOW, index$1_PREDICTION_MIGRATOR_ERROR__NO_PENDING_REWARDS as PREDICTION_MIGRATOR_ERROR__NO_PENDING_REWARDS, index$1_PREDICTION_MIGRATOR_ERROR__ORACLE_NOT_FINALIZED as PREDICTION_MIGRATOR_ERROR__ORACLE_NOT_FINALIZED, index$1_PREDICTION_MIGRATOR_ERROR__QUOTE_MINT_MISMATCH as PREDICTION_MIGRATOR_ERROR__QUOTE_MINT_MISMATCH, index$1_PREDICTION_MIGRATOR_ERROR__UNAUTHORIZED as PREDICTION_MIGRATOR_ERROR__UNAUTHORIZED, index$1_PREDICTION_MIGRATOR_ERROR__WINNING_ENTRY_NOT_MIGRATED as PREDICTION_MIGRATOR_ERROR__WINNING_ENTRY_NOT_MIGRATED, index$1_PREDICTION_MIGRATOR_ERROR__ZERO_CLAIMABLE_SUPPLY as PREDICTION_MIGRATOR_ERROR__ZERO_CLAIMABLE_SUPPLY, index$1_PREDICTION_MIGRATOR_PROGRAM_ADDRESS as PREDICTION_MIGRATOR_PROGRAM_ADDRESS, index$1_PREVIEW_PAYOUT_IF_WINNER_DISCRIMINATOR as PREVIEW_PAYOUT_IF_WINNER_DISCRIMINATOR, type index$1_ParsedClaimInstruction as ParsedClaimInstruction, type index$1_ParsedMigrateEntryInstruction as ParsedMigrateEntryInstruction, type index$1_ParsedPredictionMigratorInstruction as ParsedPredictionMigratorInstruction, type index$1_ParsedPreviewPayoutIfWinnerInstruction as ParsedPreviewPayoutIfWinnerInstruction, type index$1_ParsedRegisterEntryInstruction as ParsedRegisterEntryInstruction, index$1_PredictionMigratorAccount as PredictionMigratorAccount, type index$1_PredictionMigratorError as PredictionMigratorError, index$1_PredictionMigratorInstruction as PredictionMigratorInstruction, type index$1_PredictionMigratorPlugin as PredictionMigratorPlugin, type index$1_PredictionMigratorPluginAccounts as PredictionMigratorPluginAccounts, type index$1_PredictionMigratorPluginInstructions as PredictionMigratorPluginInstructions, type index$1_PredictionMigratorPluginRequirements as PredictionMigratorPluginRequirements, type index$1_PreviewPayoutIfWinnerArgs as PreviewPayoutIfWinnerArgs, type index$1_PreviewPayoutIfWinnerArgsArgs as PreviewPayoutIfWinnerArgsArgs, type index$1_PreviewPayoutIfWinnerInput as PreviewPayoutIfWinnerInput, type index$1_PreviewPayoutIfWinnerInstruction as PreviewPayoutIfWinnerInstruction, type index$1_PreviewPayoutIfWinnerInstructionData as PreviewPayoutIfWinnerInstructionData, type index$1_PreviewPayoutIfWinnerInstructionDataArgs as PreviewPayoutIfWinnerInstructionDataArgs, index$1_REGISTER_ENTRY_DISCRIMINATOR as REGISTER_ENTRY_DISCRIMINATOR, type index$1_RegisterEntryArgs as RegisterEntryArgs, type index$1_RegisterEntryArgsArgs as RegisterEntryArgsArgs, type index$1_RegisterEntryAsyncInput as RegisterEntryAsyncInput, type index$1_RegisterEntryInput as RegisterEntryInput, type index$1_RegisterEntryInstruction as RegisterEntryInstruction, type index$1_RegisterEntryInstructionData as RegisterEntryInstructionData, type index$1_RegisterEntryInstructionDataArgs as RegisterEntryInstructionDataArgs, type index$1_RewardsClaimed as RewardsClaimed, type index$1_RewardsClaimedArgs as RewardsClaimedArgs, index$1_decodeClaimReceipt as decodeClaimReceipt, index$1_decodeEntry as decodeEntry, index$1_decodeEntryByMint as decodeEntryByMint, index$1_decodeLaunch as decodeLaunch, index$1_decodeMarket as decodeMarket, decodeOracleState$1 as decodeOracleState, index$1_fetchAllClaimReceipt as fetchAllClaimReceipt, index$1_fetchAllEntry as fetchAllEntry, index$1_fetchAllEntryByMint as fetchAllEntryByMint, index$1_fetchAllLaunch as fetchAllLaunch, index$1_fetchAllMarket as fetchAllMarket, index$1_fetchAllMaybeClaimReceipt as fetchAllMaybeClaimReceipt, index$1_fetchAllMaybeEntry as fetchAllMaybeEntry, index$1_fetchAllMaybeEntryByMint as fetchAllMaybeEntryByMint, index$1_fetchAllMaybeLaunch as fetchAllMaybeLaunch, index$1_fetchAllMaybeMarket as fetchAllMaybeMarket, fetchAllMaybeOracleState$1 as fetchAllMaybeOracleState, fetchAllOracleState$1 as fetchAllOracleState, index$1_fetchClaimReceipt as fetchClaimReceipt, index$1_fetchEntry as fetchEntry, index$1_fetchEntryByMint as fetchEntryByMint, index$1_fetchLaunch as fetchLaunch, index$1_fetchMarket as fetchMarket, index$1_fetchMaybeClaimReceipt as fetchMaybeClaimReceipt, index$1_fetchMaybeEntry as fetchMaybeEntry, index$1_fetchMaybeEntryByMint as fetchMaybeEntryByMint, index$1_fetchMaybeLaunch as fetchMaybeLaunch, index$1_fetchMaybeMarket as fetchMaybeMarket, fetchMaybeOracleState$1 as fetchMaybeOracleState, fetchOracleState$1 as fetchOracleState, index$1_getAccumulatorUpdatedCodec as getAccumulatorUpdatedCodec, index$1_getAccumulatorUpdatedDecoder as getAccumulatorUpdatedDecoder, index$1_getAccumulatorUpdatedEncoder as getAccumulatorUpdatedEncoder, index$1_getCalldataBufCodec as getCalldataBufCodec, index$1_getCalldataBufDecoder as getCalldataBufDecoder, index$1_getCalldataBufEncoder as getCalldataBufEncoder, index$1_getClaimDiscriminatorBytes as getClaimDiscriminatorBytes, index$1_getClaimInstruction as getClaimInstruction, index$1_getClaimInstructionAsync as getClaimInstructionAsync, index$1_getClaimInstructionDataCodec as getClaimInstructionDataCodec, index$1_getClaimInstructionDataDecoder as getClaimInstructionDataDecoder, index$1_getClaimInstructionDataEncoder as getClaimInstructionDataEncoder, index$1_getClaimReceiptCodec as getClaimReceiptCodec, index$1_getClaimReceiptDecoder as getClaimReceiptDecoder, index$1_getClaimReceiptDiscriminatorBytes as getClaimReceiptDiscriminatorBytes, index$1_getClaimReceiptEncoder as getClaimReceiptEncoder, index$1_getClaimReceiptSize as getClaimReceiptSize, index$1_getEntryByMintCodec as getEntryByMintCodec, index$1_getEntryByMintDecoder as getEntryByMintDecoder, index$1_getEntryByMintDiscriminatorBytes as getEntryByMintDiscriminatorBytes, index$1_getEntryByMintEncoder as getEntryByMintEncoder, index$1_getEntryByMintSize as getEntryByMintSize, index$1_getEntryCodec as getEntryCodec, index$1_getEntryDecoder as getEntryDecoder, index$1_getEntryDiscriminatorBytes as getEntryDiscriminatorBytes, index$1_getEntryEncoder as getEntryEncoder, index$1_getEntryMigratedCodec as getEntryMigratedCodec, index$1_getEntryMigratedDecoder as getEntryMigratedDecoder, index$1_getEntryMigratedEncoder as getEntryMigratedEncoder, index$1_getEntryRegisteredCodec as getEntryRegisteredCodec, index$1_getEntryRegisteredDecoder as getEntryRegisteredDecoder, index$1_getEntryRegisteredEncoder as getEntryRegisteredEncoder, index$1_getEntrySize as getEntrySize, index$1_getLaunchCodec as getLaunchCodec, index$1_getLaunchDecoder as getLaunchDecoder, index$1_getLaunchDiscriminatorBytes as getLaunchDiscriminatorBytes, index$1_getLaunchEncoder as getLaunchEncoder, index$1_getLaunchSize as getLaunchSize, index$1_getMarketCodec as getMarketCodec, index$1_getMarketCreatedCodec as getMarketCreatedCodec, index$1_getMarketCreatedDecoder as getMarketCreatedDecoder, index$1_getMarketCreatedEncoder as getMarketCreatedEncoder, index$1_getMarketDecoder as getMarketDecoder, index$1_getMarketDiscriminatorBytes as getMarketDiscriminatorBytes, index$1_getMarketEncoder as getMarketEncoder, index$1_getMarketResolvedCodec as getMarketResolvedCodec, index$1_getMarketResolvedDecoder as getMarketResolvedDecoder, index$1_getMarketResolvedEncoder as getMarketResolvedEncoder, index$1_getMarketSize as getMarketSize, index$1_getMigrateEntryArgsCodec as getMigrateEntryArgsCodec, index$1_getMigrateEntryArgsDecoder as getMigrateEntryArgsDecoder, index$1_getMigrateEntryArgsEncoder as getMigrateEntryArgsEncoder, index$1_getMigrateEntryDiscriminatorBytes as getMigrateEntryDiscriminatorBytes, index$1_getMigrateEntryInstruction as getMigrateEntryInstruction, index$1_getMigrateEntryInstructionAsync as getMigrateEntryInstructionAsync, index$1_getMigrateEntryInstructionDataCodec as getMigrateEntryInstructionDataCodec, index$1_getMigrateEntryInstructionDataDecoder as getMigrateEntryInstructionDataDecoder, index$1_getMigrateEntryInstructionDataEncoder as getMigrateEntryInstructionDataEncoder, getOracleStateCodec$1 as getOracleStateCodec, getOracleStateDecoder$1 as getOracleStateDecoder, getOracleStateDiscriminatorBytes$1 as getOracleStateDiscriminatorBytes, getOracleStateEncoder$1 as getOracleStateEncoder, getOracleStateSize$1 as getOracleStateSize, index$1_getPredictionEntryAddress as getPredictionEntryAddress, index$1_getPredictionEntryByMintAddress as getPredictionEntryByMintAddress, index$1_getPredictionMarketAddress as getPredictionMarketAddress, index$1_getPredictionMarketAuthorityAddress as getPredictionMarketAuthorityAddress, index$1_getPredictionMigratorErrorMessage as getPredictionMigratorErrorMessage, index$1_getPredictionPotVaultAddress as getPredictionPotVaultAddress, index$1_getPreviewPayoutIfWinnerArgsCodec as getPreviewPayoutIfWinnerArgsCodec, index$1_getPreviewPayoutIfWinnerArgsDecoder as getPreviewPayoutIfWinnerArgsDecoder, index$1_getPreviewPayoutIfWinnerArgsEncoder as getPreviewPayoutIfWinnerArgsEncoder, index$1_getPreviewPayoutIfWinnerDiscriminatorBytes as getPreviewPayoutIfWinnerDiscriminatorBytes, index$1_getPreviewPayoutIfWinnerInstruction as getPreviewPayoutIfWinnerInstruction, index$1_getPreviewPayoutIfWinnerInstructionDataCodec as getPreviewPayoutIfWinnerInstructionDataCodec, index$1_getPreviewPayoutIfWinnerInstructionDataDecoder as getPreviewPayoutIfWinnerInstructionDataDecoder, index$1_getPreviewPayoutIfWinnerInstructionDataEncoder as getPreviewPayoutIfWinnerInstructionDataEncoder, index$1_getRegisterEntryArgsCodec as getRegisterEntryArgsCodec, index$1_getRegisterEntryArgsDecoder as getRegisterEntryArgsDecoder, index$1_getRegisterEntryArgsEncoder as getRegisterEntryArgsEncoder, index$1_getRegisterEntryDiscriminatorBytes as getRegisterEntryDiscriminatorBytes, index$1_getRegisterEntryInstruction as getRegisterEntryInstruction, index$1_getRegisterEntryInstructionAsync as getRegisterEntryInstructionAsync, index$1_getRegisterEntryInstructionDataCodec as getRegisterEntryInstructionDataCodec, index$1_getRegisterEntryInstructionDataDecoder as getRegisterEntryInstructionDataDecoder, index$1_getRegisterEntryInstructionDataEncoder as getRegisterEntryInstructionDataEncoder, index$1_getRewardsClaimedCodec as getRewardsClaimedCodec, index$1_getRewardsClaimedDecoder as getRewardsClaimedDecoder, index$1_getRewardsClaimedEncoder as getRewardsClaimedEncoder, index$1_identifyPredictionMigratorAccount as identifyPredictionMigratorAccount, index$1_identifyPredictionMigratorInstruction as identifyPredictionMigratorInstruction, index$1_isPredictionMigratorError as isPredictionMigratorError, index$1_parseClaimInstruction as parseClaimInstruction, index$1_parseMigrateEntryInstruction as parseMigrateEntryInstruction, index$1_parsePredictionMigratorInstruction as parsePredictionMigratorInstruction, index$1_parsePreviewPayoutIfWinnerInstruction as parsePreviewPayoutIfWinnerInstruction, index$1_parseRegisterEntryInstruction as parseRegisterEntryInstruction, index$1_predictionMigratorProgram as predictionMigratorProgram };
+}
+
+/**
+ * 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
+ */
+
+declare const ORACLE_STATE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getOracleStateDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type OracleState = {
+    discriminator: ReadonlyUint8Array;
+    /** The authority that can finalize this oracle */
+    oracleAuthority: Address;
+    /** Optional quote mint for validation (Pubkey::default() if not used) */
+    quoteMint: Address;
+    /** Whether the oracle has been finalized with a winner */
+    isFinalized: boolean;
+    /** The winning mint (only valid if is_finalized == true) */
+    winningMint: Address;
+    /** Nonce used in PDA derivation */
+    nonce: bigint;
+    /** PDA bump seed */
+    bump: number;
+    /** Reserved for future use */
+    reserved: ReadonlyUint8Array;
+};
+type OracleStateArgs = {
+    /** The authority that can finalize this oracle */
+    oracleAuthority: Address;
+    /** Optional quote mint for validation (Pubkey::default() if not used) */
+    quoteMint: Address;
+    /** Whether the oracle has been finalized with a winner */
+    isFinalized: boolean;
+    /** The winning mint (only valid if is_finalized == true) */
+    winningMint: Address;
+    /** Nonce used in PDA derivation */
+    nonce: number | bigint;
+    /** PDA bump seed */
+    bump: number;
+    /** Reserved for future use */
+    reserved: ReadonlyUint8Array;
+};
+/** Gets the encoder for {@link OracleStateArgs} account data. */
+declare function getOracleStateEncoder(): FixedSizeEncoder<OracleStateArgs>;
+/** Gets the decoder for {@link OracleState} account data. */
+declare function getOracleStateDecoder(): FixedSizeDecoder<OracleState>;
+/** Gets the codec for {@link OracleState} account data. */
+declare function getOracleStateCodec(): FixedSizeCodec<OracleStateArgs, OracleState>;
+declare function decodeOracleState<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<OracleState, TAddress>;
+declare function decodeOracleState<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<OracleState, TAddress>;
+declare function fetchOracleState<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<OracleState, TAddress>>;
+declare function fetchMaybeOracleState<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<OracleState, TAddress>>;
+declare function fetchAllOracleState(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<OracleState>[]>;
+declare function fetchAllMaybeOracleState(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<OracleState>[]>;
+declare function getOracleStateSize(): number;
+
+/**
+ * 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
+ */
+
+/** Unauthorized: Unauthorized: only oracle authority can perform this action */
+declare const TRUSTED_ORACLE_ERROR__UNAUTHORIZED = 6000;
+/** AlreadyFinalized: Oracle already finalized */
+declare const TRUSTED_ORACLE_ERROR__ALREADY_FINALIZED = 6001;
+/** NotFinalized: Oracle not finalized */
+declare const TRUSTED_ORACLE_ERROR__NOT_FINALIZED = 6002;
+/** InvalidWinningMint: Invalid winning mint */
+declare const TRUSTED_ORACLE_ERROR__INVALID_WINNING_MINT = 6003;
+type TrustedOracleError = typeof TRUSTED_ORACLE_ERROR__ALREADY_FINALIZED | typeof TRUSTED_ORACLE_ERROR__INVALID_WINNING_MINT | typeof TRUSTED_ORACLE_ERROR__NOT_FINALIZED | typeof TRUSTED_ORACLE_ERROR__UNAUTHORIZED;
+declare function getTrustedOracleErrorMessage(code: TrustedOracleError): string;
+declare function isTrustedOracleError<TProgramErrorCode extends TrustedOracleError>(error: unknown, transactionMessage: {
+    instructions: Record<number, {
+        programAddress: Address;
+    }>;
+}, code?: TProgramErrorCode): error is SolanaError<typeof SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM> & Readonly<{
+    context: Readonly<{
+        code: TProgramErrorCode;
+    }>;
+}>;
+
+/**
+ * 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
+ */
+
+declare const TRUSTED_ORACLE_PROGRAM_ADDRESS: Address<"HhUzN7VvonNUevATyugZUepzxpeEZMXQbV92X2xvsp5m">;
+declare enum TrustedOracleAccount {
+    OracleState = 0
+}
+declare function identifyTrustedOracleAccount(account: {
+    data: ReadonlyUint8Array;
+} | ReadonlyUint8Array): TrustedOracleAccount;
+declare enum TrustedOracleInstruction {
+    Finalize = 0,
+    InitializeOracle = 1
+}
+declare function identifyTrustedOracleInstruction(instruction: {
+    data: ReadonlyUint8Array;
+} | ReadonlyUint8Array): TrustedOracleInstruction;
+type ParsedTrustedOracleInstruction<TProgram extends string = 'HhUzN7VvonNUevATyugZUepzxpeEZMXQbV92X2xvsp5m'> = ({
+    instructionType: TrustedOracleInstruction.Finalize;
+} & ParsedFinalizeInstruction<TProgram>) | ({
+    instructionType: TrustedOracleInstruction.InitializeOracle;
+} & ParsedInitializeOracleInstruction<TProgram>);
+declare function parseTrustedOracleInstruction<TProgram extends string>(instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>): ParsedTrustedOracleInstruction<TProgram>;
+type TrustedOraclePlugin = {
+    accounts: TrustedOraclePluginAccounts;
+    instructions: TrustedOraclePluginInstructions;
+};
+type TrustedOraclePluginAccounts = {
+    oracleState: ReturnType<typeof getOracleStateCodec> & SelfFetchFunctions<OracleStateArgs, OracleState>;
+};
+type TrustedOraclePluginInstructions = {
+    finalize: (input: FinalizeInput) => ReturnType<typeof getFinalizeInstruction> & SelfPlanAndSendFunctions;
+    initializeOracle: (input: InitializeOracleInput) => ReturnType<typeof getInitializeOracleInstruction> & SelfPlanAndSendFunctions;
+};
+type TrustedOraclePluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi> & ClientWithTransactionPlanning & ClientWithTransactionSending;
+declare function trustedOracleProgram(): <T extends TrustedOraclePluginRequirements>(client: T) => T & {
+    trustedOracle: TrustedOraclePlugin;
+};
+
+/**
+ * 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
+ */
+
+declare const FINALIZE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getFinalizeDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type FinalizeInstruction<TProgram extends string = typeof TRUSTED_ORACLE_PROGRAM_ADDRESS, TAccountOracleAuthority extends string | AccountMeta<string> = string, TAccountOracleState extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountOracleAuthority extends string ? ReadonlySignerAccount<TAccountOracleAuthority> & AccountSignerMeta<TAccountOracleAuthority> : TAccountOracleAuthority,
+    TAccountOracleState extends string ? WritableAccount<TAccountOracleState> : TAccountOracleState,
+    ...TRemainingAccounts
+]>;
+type FinalizeInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    winningMint: Address;
+};
+type FinalizeInstructionDataArgs = {
+    winningMint: Address;
+};
+declare function getFinalizeInstructionDataEncoder(): FixedSizeEncoder<FinalizeInstructionDataArgs>;
+declare function getFinalizeInstructionDataDecoder(): FixedSizeDecoder<FinalizeInstructionData>;
+declare function getFinalizeInstructionDataCodec(): FixedSizeCodec<FinalizeInstructionDataArgs, FinalizeInstructionData>;
+type FinalizeInput<TAccountOracleAuthority extends string = string, TAccountOracleState extends string = string> = {
+    /** The oracle authority - must sign to finalize */
+    oracleAuthority: TransactionSigner<TAccountOracleAuthority>;
+    oracleState: Address<TAccountOracleState>;
+    winningMint: FinalizeInstructionDataArgs['winningMint'];
+};
+declare function getFinalizeInstruction<TAccountOracleAuthority extends string, TAccountOracleState extends string, TProgramAddress extends Address = typeof TRUSTED_ORACLE_PROGRAM_ADDRESS>(input: FinalizeInput<TAccountOracleAuthority, TAccountOracleState>, config?: {
+    programAddress?: TProgramAddress;
+}): FinalizeInstruction<TProgramAddress, TAccountOracleAuthority, TAccountOracleState>;
+type ParsedFinalizeInstruction<TProgram extends string = typeof TRUSTED_ORACLE_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        /** The oracle authority - must sign to finalize */
+        oracleAuthority: TAccountMetas[0];
+        oracleState: TAccountMetas[1];
+    };
+    data: FinalizeInstructionData;
+};
+declare function parseFinalizeInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedFinalizeInstruction<TProgram, TAccountMetas>;
+
+/**
+ * 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
+ */
+
+declare const INITIALIZE_ORACLE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare function getInitializeOracleDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+type InitializeOracleInstruction<TProgram extends string = typeof TRUSTED_ORACLE_PROGRAM_ADDRESS, TAccountOracleAuthority extends string | AccountMeta<string> = string, TAccountOracleState extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[
+    TAccountOracleAuthority extends string ? WritableSignerAccount<TAccountOracleAuthority> & AccountSignerMeta<TAccountOracleAuthority> : TAccountOracleAuthority,
+    TAccountOracleState extends string ? WritableAccount<TAccountOracleState> : TAccountOracleState,
+    TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram,
+    ...TRemainingAccounts
+]>;
+type InitializeOracleInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    /** Nonce for PDA derivation (allows multiple oracles per authority) */
+    nonce: bigint;
+    /** Optional quote mint for validation (use Pubkey::default() if not needed) */
+    quoteMint: Address;
+};
+type InitializeOracleInstructionDataArgs = {
+    /** Nonce for PDA derivation (allows multiple oracles per authority) */
+    nonce: number | bigint;
+    /** Optional quote mint for validation (use Pubkey::default() if not needed) */
+    quoteMint: Address;
+};
+declare function getInitializeOracleInstructionDataEncoder(): FixedSizeEncoder<InitializeOracleInstructionDataArgs>;
+declare function getInitializeOracleInstructionDataDecoder(): FixedSizeDecoder<InitializeOracleInstructionData>;
+declare function getInitializeOracleInstructionDataCodec(): FixedSizeCodec<InitializeOracleInstructionDataArgs, InitializeOracleInstructionData>;
+type InitializeOracleInput<TAccountOracleAuthority extends string = string, TAccountOracleState extends string = string, TAccountSystemProgram extends string = string> = {
+    /** The authority that will be able to finalize this oracle */
+    oracleAuthority: TransactionSigner<TAccountOracleAuthority>;
+    oracleState: Address<TAccountOracleState>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    nonce: InitializeOracleInstructionDataArgs['nonce'];
+    quoteMint: InitializeOracleInstructionDataArgs['quoteMint'];
+};
+declare function getInitializeOracleInstruction<TAccountOracleAuthority extends string, TAccountOracleState extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof TRUSTED_ORACLE_PROGRAM_ADDRESS>(input: InitializeOracleInput<TAccountOracleAuthority, TAccountOracleState, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): InitializeOracleInstruction<TProgramAddress, TAccountOracleAuthority, TAccountOracleState, TAccountSystemProgram>;
+type ParsedInitializeOracleInstruction<TProgram extends string = typeof TRUSTED_ORACLE_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        /** The authority that will be able to finalize this oracle */
+        oracleAuthority: TAccountMetas[0];
+        oracleState: TAccountMetas[1];
+        systemProgram: TAccountMetas[2];
+    };
+    data: InitializeOracleInstructionData;
+};
+declare function parseInitializeOracleInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitializeOracleInstruction<TProgram, TAccountMetas>;
+
+/**
+ * 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 InitializeOracleArgs = {
+    /** Nonce for PDA derivation (allows multiple oracles per authority) */
+    nonce: bigint;
+    /** Optional quote mint for validation (use Pubkey::default() if not needed) */
+    quoteMint: Address;
+};
+type InitializeOracleArgsArgs = {
+    /** Nonce for PDA derivation (allows multiple oracles per authority) */
+    nonce: number | bigint;
+    /** Optional quote mint for validation (use Pubkey::default() if not needed) */
+    quoteMint: Address;
+};
+declare function getInitializeOracleArgsEncoder(): FixedSizeEncoder<InitializeOracleArgsArgs>;
+declare function getInitializeOracleArgsDecoder(): FixedSizeDecoder<InitializeOracleArgs>;
+declare function getInitializeOracleArgsCodec(): FixedSizeCodec<InitializeOracleArgsArgs, InitializeOracleArgs>;
+
+/**
+ * Derive the OracleState PDA address.
+ * Seeds: ["oracle", oracleAuthority, nonce_le_u64]
+ *
+ * The nonce allows a single authority to create multiple independent oracles.
+ * Use Date.now() or any unique u64 value.
+ */
+declare function getOracleStateAddress(oracleAuthority: Address, nonce: bigint): Promise<ProgramDerivedAddress>;
+
+declare const index_FINALIZE_DISCRIMINATOR: typeof FINALIZE_DISCRIMINATOR;
+type index_FinalizeInput<TAccountOracleAuthority extends string = string, TAccountOracleState extends string = string> = FinalizeInput<TAccountOracleAuthority, TAccountOracleState>;
+type index_FinalizeInstruction<TProgram extends string = typeof TRUSTED_ORACLE_PROGRAM_ADDRESS, TAccountOracleAuthority extends string | AccountMeta<string> = string, TAccountOracleState extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = FinalizeInstruction<TProgram, TAccountOracleAuthority, TAccountOracleState, TRemainingAccounts>;
+type index_FinalizeInstructionData = FinalizeInstructionData;
+type index_FinalizeInstructionDataArgs = FinalizeInstructionDataArgs;
+declare const index_INITIALIZE_ORACLE_DISCRIMINATOR: typeof INITIALIZE_ORACLE_DISCRIMINATOR;
+type index_InitializeOracleArgs = InitializeOracleArgs;
+type index_InitializeOracleArgsArgs = InitializeOracleArgsArgs;
+type index_InitializeOracleInput<TAccountOracleAuthority extends string = string, TAccountOracleState extends string = string, TAccountSystemProgram extends string = string> = InitializeOracleInput<TAccountOracleAuthority, TAccountOracleState, TAccountSystemProgram>;
+type index_InitializeOracleInstruction<TProgram extends string = typeof TRUSTED_ORACLE_PROGRAM_ADDRESS, TAccountOracleAuthority extends string | AccountMeta<string> = string, TAccountOracleState extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = '11111111111111111111111111111111', TRemainingAccounts extends readonly AccountMeta<string>[] = []> = InitializeOracleInstruction<TProgram, TAccountOracleAuthority, TAccountOracleState, TAccountSystemProgram, TRemainingAccounts>;
+type index_InitializeOracleInstructionData = InitializeOracleInstructionData;
+type index_InitializeOracleInstructionDataArgs = InitializeOracleInstructionDataArgs;
+declare const index_ORACLE_STATE_DISCRIMINATOR: typeof ORACLE_STATE_DISCRIMINATOR;
+type index_OracleState = OracleState;
+type index_OracleStateArgs = OracleStateArgs;
+type index_ParsedFinalizeInstruction<TProgram extends string = typeof TRUSTED_ORACLE_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = ParsedFinalizeInstruction<TProgram, TAccountMetas>;
+type index_ParsedInitializeOracleInstruction<TProgram extends string = typeof TRUSTED_ORACLE_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = ParsedInitializeOracleInstruction<TProgram, TAccountMetas>;
+type index_ParsedTrustedOracleInstruction<TProgram extends string = 'HhUzN7VvonNUevATyugZUepzxpeEZMXQbV92X2xvsp5m'> = ParsedTrustedOracleInstruction<TProgram>;
+declare const index_TRUSTED_ORACLE_ERROR__ALREADY_FINALIZED: typeof TRUSTED_ORACLE_ERROR__ALREADY_FINALIZED;
+declare const index_TRUSTED_ORACLE_ERROR__INVALID_WINNING_MINT: typeof TRUSTED_ORACLE_ERROR__INVALID_WINNING_MINT;
+declare const index_TRUSTED_ORACLE_ERROR__NOT_FINALIZED: typeof TRUSTED_ORACLE_ERROR__NOT_FINALIZED;
+declare const index_TRUSTED_ORACLE_ERROR__UNAUTHORIZED: typeof TRUSTED_ORACLE_ERROR__UNAUTHORIZED;
+declare const index_TRUSTED_ORACLE_PROGRAM_ADDRESS: typeof TRUSTED_ORACLE_PROGRAM_ADDRESS;
+type index_TrustedOracleAccount = TrustedOracleAccount;
+declare const index_TrustedOracleAccount: typeof TrustedOracleAccount;
+type index_TrustedOracleError = TrustedOracleError;
+type index_TrustedOracleInstruction = TrustedOracleInstruction;
+declare const index_TrustedOracleInstruction: typeof TrustedOracleInstruction;
+type index_TrustedOraclePlugin = TrustedOraclePlugin;
+type index_TrustedOraclePluginAccounts = TrustedOraclePluginAccounts;
+type index_TrustedOraclePluginInstructions = TrustedOraclePluginInstructions;
+type index_TrustedOraclePluginRequirements = TrustedOraclePluginRequirements;
+declare const index_decodeOracleState: typeof decodeOracleState;
+declare const index_fetchAllMaybeOracleState: typeof fetchAllMaybeOracleState;
+declare const index_fetchAllOracleState: typeof fetchAllOracleState;
+declare const index_fetchMaybeOracleState: typeof fetchMaybeOracleState;
+declare const index_fetchOracleState: typeof fetchOracleState;
+declare const index_getFinalizeDiscriminatorBytes: typeof getFinalizeDiscriminatorBytes;
+declare const index_getFinalizeInstruction: typeof getFinalizeInstruction;
+declare const index_getFinalizeInstructionDataCodec: typeof getFinalizeInstructionDataCodec;
+declare const index_getFinalizeInstructionDataDecoder: typeof getFinalizeInstructionDataDecoder;
+declare const index_getFinalizeInstructionDataEncoder: typeof getFinalizeInstructionDataEncoder;
+declare const index_getInitializeOracleArgsCodec: typeof getInitializeOracleArgsCodec;
+declare const index_getInitializeOracleArgsDecoder: typeof getInitializeOracleArgsDecoder;
+declare const index_getInitializeOracleArgsEncoder: typeof getInitializeOracleArgsEncoder;
+declare const index_getInitializeOracleDiscriminatorBytes: typeof getInitializeOracleDiscriminatorBytes;
+declare const index_getInitializeOracleInstruction: typeof getInitializeOracleInstruction;
+declare const index_getInitializeOracleInstructionDataCodec: typeof getInitializeOracleInstructionDataCodec;
+declare const index_getInitializeOracleInstructionDataDecoder: typeof getInitializeOracleInstructionDataDecoder;
+declare const index_getInitializeOracleInstructionDataEncoder: typeof getInitializeOracleInstructionDataEncoder;
+declare const index_getOracleStateAddress: typeof getOracleStateAddress;
+declare const index_getOracleStateCodec: typeof getOracleStateCodec;
+declare const index_getOracleStateDecoder: typeof getOracleStateDecoder;
+declare const index_getOracleStateDiscriminatorBytes: typeof getOracleStateDiscriminatorBytes;
+declare const index_getOracleStateEncoder: typeof getOracleStateEncoder;
+declare const index_getOracleStateSize: typeof getOracleStateSize;
+declare const index_getTrustedOracleErrorMessage: typeof getTrustedOracleErrorMessage;
+declare const index_identifyTrustedOracleAccount: typeof identifyTrustedOracleAccount;
+declare const index_identifyTrustedOracleInstruction: typeof identifyTrustedOracleInstruction;
+declare const index_isTrustedOracleError: typeof isTrustedOracleError;
+declare const index_parseFinalizeInstruction: typeof parseFinalizeInstruction;
+declare const index_parseInitializeOracleInstruction: typeof parseInitializeOracleInstruction;
+declare const index_parseTrustedOracleInstruction: typeof parseTrustedOracleInstruction;
+declare const index_trustedOracleProgram: typeof trustedOracleProgram;
+declare namespace index {
+  export { index_FINALIZE_DISCRIMINATOR as FINALIZE_DISCRIMINATOR, type index_FinalizeInput as FinalizeInput, type index_FinalizeInstruction as FinalizeInstruction, type index_FinalizeInstructionData as FinalizeInstructionData, type index_FinalizeInstructionDataArgs as FinalizeInstructionDataArgs, index_INITIALIZE_ORACLE_DISCRIMINATOR as INITIALIZE_ORACLE_DISCRIMINATOR, type index_InitializeOracleArgs as InitializeOracleArgs, type index_InitializeOracleArgsArgs as InitializeOracleArgsArgs, type index_InitializeOracleInput as InitializeOracleInput, type index_InitializeOracleInstruction as InitializeOracleInstruction, type index_InitializeOracleInstructionData as InitializeOracleInstructionData, type index_InitializeOracleInstructionDataArgs as InitializeOracleInstructionDataArgs, index_ORACLE_STATE_DISCRIMINATOR as ORACLE_STATE_DISCRIMINATOR, type index_OracleState as OracleState, type index_OracleStateArgs as OracleStateArgs, type index_ParsedFinalizeInstruction as ParsedFinalizeInstruction, type index_ParsedInitializeOracleInstruction as ParsedInitializeOracleInstruction, type index_ParsedTrustedOracleInstruction as ParsedTrustedOracleInstruction, index_TRUSTED_ORACLE_ERROR__ALREADY_FINALIZED as TRUSTED_ORACLE_ERROR__ALREADY_FINALIZED, index_TRUSTED_ORACLE_ERROR__INVALID_WINNING_MINT as TRUSTED_ORACLE_ERROR__INVALID_WINNING_MINT, index_TRUSTED_ORACLE_ERROR__NOT_FINALIZED as TRUSTED_ORACLE_ERROR__NOT_FINALIZED, index_TRUSTED_ORACLE_ERROR__UNAUTHORIZED as TRUSTED_ORACLE_ERROR__UNAUTHORIZED, index_TRUSTED_ORACLE_PROGRAM_ADDRESS as TRUSTED_ORACLE_PROGRAM_ADDRESS, index_TrustedOracleAccount as TrustedOracleAccount, type index_TrustedOracleError as TrustedOracleError, index_TrustedOracleInstruction as TrustedOracleInstruction, type index_TrustedOraclePlugin as TrustedOraclePlugin, type index_TrustedOraclePluginAccounts as TrustedOraclePluginAccounts, type index_TrustedOraclePluginInstructions as TrustedOraclePluginInstructions, type index_TrustedOraclePluginRequirements as TrustedOraclePluginRequirements, index_decodeOracleState as decodeOracleState, index_fetchAllMaybeOracleState as fetchAllMaybeOracleState, index_fetchAllOracleState as fetchAllOracleState, index_fetchMaybeOracleState as fetchMaybeOracleState, index_fetchOracleState as fetchOracleState, index_getFinalizeDiscriminatorBytes as getFinalizeDiscriminatorBytes, index_getFinalizeInstruction as getFinalizeInstruction, index_getFinalizeInstructionDataCodec as getFinalizeInstructionDataCodec, index_getFinalizeInstructionDataDecoder as getFinalizeInstructionDataDecoder, index_getFinalizeInstructionDataEncoder as getFinalizeInstructionDataEncoder, index_getInitializeOracleArgsCodec as getInitializeOracleArgsCodec, index_getInitializeOracleArgsDecoder as getInitializeOracleArgsDecoder, index_getInitializeOracleArgsEncoder as getInitializeOracleArgsEncoder, index_getInitializeOracleDiscriminatorBytes as getInitializeOracleDiscriminatorBytes, index_getInitializeOracleInstruction as getInitializeOracleInstruction, index_getInitializeOracleInstructionDataCodec as getInitializeOracleInstructionDataCodec, index_getInitializeOracleInstructionDataDecoder as getInitializeOracleInstructionDataDecoder, index_getInitializeOracleInstructionDataEncoder as getInitializeOracleInstructionDataEncoder, index_getOracleStateAddress as getOracleStateAddress, index_getOracleStateCodec as getOracleStateCodec, index_getOracleStateDecoder as getOracleStateDecoder, index_getOracleStateDiscriminatorBytes as getOracleStateDiscriminatorBytes, index_getOracleStateEncoder as getOracleStateEncoder, index_getOracleStateSize as getOracleStateSize, index_getTrustedOracleErrorMessage as getTrustedOracleErrorMessage, index_identifyTrustedOracleAccount as identifyTrustedOracleAccount, index_identifyTrustedOracleInstruction as identifyTrustedOracleInstruction, index_isTrustedOracleError as isTrustedOracleError, index_parseFinalizeInstruction as parseFinalizeInstruction, index_parseInitializeOracleInstruction as parseInitializeOracleInstruction, index_parseTrustedOracleInstruction as parseTrustedOracleInstruction, index_trustedOracleProgram as trustedOracleProgram };
+}
+
+export { index$4 as cpmm, index$2 as cpmmMigrator, index$3 as initializer, index$1 as predictionMigrator, index as trustedOracle };