@gabox-labs/sdk 0.2.0 → 0.7.0

package/dist/index-C4at2cZ_.d.ts

@@ -0,0 +1,1184 @@
+import { AccountMeta, Address, AddressesByLookupTableAddress, Instruction, Rpc, RpcSubscriptions, SolanaRpcApi, SolanaRpcSubscriptionsApi, TransactionMessage, TransactionMessageWithBlockhashLifetime, TransactionMessageWithFeePayerSigner, TransactionSigner } from "@solana/kit";
+//#region src/route/types.d.ts
+/** Which of the two swap modes produced a route. */
+type RouteMode = 'exactOut' | 'exactIn';
+/** One priced swap, ready to put in a transaction message. */
+type Route = {
+  /** The swap's own instructions, in order. No compute budget instruction is included. */
+  instructions: Instruction[];
+  /** The lookup tables the instructions above were compressed against. */
+  lookupTables: AddressesByLookupTableAddress;
+  /** The input amount. Exact for an exact-in route, a maximum for an exact-out one. */
+  inAmount: bigint;
+  /** The output amount. Exact for an exact-out route, a minimum for an exact-in one. */
+  outAmount: bigint;
+  mode: RouteMode;
+  /**
+   * The compute units this route needs, on top of what the Gabox instruction uses.
+   *
+   * The swap shares one transaction with the Gabox instruction, so it shares the budget too. Each
+   * provider states its own figure: Jupiter returns one with the route, and the CPMM provider uses
+   * a measured number, because it is always one pool. A builder adds this to its own limit and caps
+   * the total at the runtime's ceiling.
+   */
+  computeUnits: number;
+};
+/**
+ * Something that can price and build a swap between two mints for one wallet.
+ *
+ * `client` comes first, the way every chain-touching function in this SDK takes it. `user` is the
+ * wallet that will sign: its token accounts are the swap's own source and destination, and the
+ * provider creates whichever of them is missing.
+ */
+type RouteProvider = {
+  /** Buy exactly `amount` of `output`, spending as much `input` as the route needs. */
+  exactOut(client: GaboxClient, input: Address, output: Address, amount: bigint, user: Address): Promise<Route>;
+  /** Spend exactly `amount` of `input` and take whatever `output` it buys. */
+  exactIn(client: GaboxClient, input: Address, output: Address, amount: bigint, user: Address): Promise<Route>;
+};
+//#endregion
+//#region src/rpc.d.ts
+type Cluster = 'devnet' | 'mainnet-beta' | 'localnet';
+/** Solana's public endpoints, and the test validator's default ports. */
+declare const CLUSTER_ENDPOINTS: Readonly<Record<Cluster, {
+  url: string;
+  wsUrl: string;
+}>>;
+declare const DEVNET_HTTP: string;
+declare const DEVNET_WS: string;
+type GaboxRpc = Rpc<SolanaRpcApi>;
+type GaboxRpcSubscriptions = RpcSubscriptions<SolanaRpcSubscriptionsApi>;
+type ClientConfig = {
+  /** The cluster this client talks to. Required: see the file comment. */
+  cluster: Cluster;
+  /** HTTP endpoint. Defaults to the cluster's entry in `CLUSTER_ENDPOINTS`. */
+  url?: string;
+  /**
+   * WebSocket endpoint. Left out, it follows `url`: `https` becomes `wss`, `http` becomes `ws`.
+   * When `url` is left out too, it is the cluster's default.
+   */
+  wsUrl?: string;
+  /**
+   * Address lookup tables every builder compresses with. Defaults to the cluster's shared table,
+   * which only devnet has today; other clusters default to none. Pass `{}` to disable compression.
+   */
+  addressLookupTables?: AddressesByLookupTableAddress;
+  /**
+   * How a buyer pays in SOL for a machine priced in another token.
+   *
+   * Mainnet defaults to Jupiter, which is where the liquidity is. Devnet and localnet default to
+   * none, because Jupiter does not serve them: pass `raydiumCpmmRoute(pool)` with a CPMM pool that
+   * holds the SOL/quote pair. `null` disables the swap leg, and `payWith: 'sol'` then fails on a
+   * pool quoted in anything but WSOL.
+   */
+  route?: RouteProvider | null;
+};
+/**
+ * Everything the SDK needs to talk to one cluster. Pass it to every chain-touching function.
+ *
+ * A plain object, so a caller who needs a custom transport can spread it:
+ * `{ ...createClient({ cluster }), rpc: createSolanaRpcFromTransport(transport) }`.
+ */
+type GaboxClient = Readonly<{
+  cluster: Cluster;
+  url: string;
+  wsUrl: string;
+  rpc: GaboxRpc;
+  rpcSubscriptions: GaboxRpcSubscriptions;
+  addressLookupTables: AddressesByLookupTableAddress;
+  /** The swap provider a SOL payment routes through, or `null` when this cluster has none. */
+  route: RouteProvider | null;
+}>;
+/**
+ * The cluster a URL names, from its text alone. A substring check, deliberately: providers spell
+ * it many ways. `null` when the URL names none, which is a local validator or a private endpoint.
+ */
+declare function clusterNamedBy(url: string): Cluster | 'testnet' | null;
+/**
+ * Refuse a URL that contradicts the declared cluster. Exported so a script can check a URL before
+ * it does anything else with it. The rules are in the file comment.
+ */
+declare function assertClusterUrl(cluster: Cluster, url: string): void;
+/** `https://x` becomes `wss://x`, `http://x` becomes `ws://x`. Anything else is returned as is. */
+declare function websocketUrlFor(url: string): string;
+/**
+ * The SDK's init step. Call it once and pass the result everywhere.
+ *
+ * Both RPC clients are created together because everything in this SDK that watches a draw needs
+ * the pair: the subscription reports the change, and the RPC reads the account that changed.
+ */
+declare function createClient(config: ClientConfig): GaboxClient;
+/**
+ * The swap provider a cluster gets when the caller names none.
+ *
+ * Jupiter on mainnet, nothing anywhere else. Jupiter's API only prices mainnet liquidity, and a
+ * devnet caller has to say which pool to route through, so there is nothing to guess.
+ */
+declare function defaultRoute(cluster: Cluster): RouteProvider | null;
+//#endregion
+//#region src/raydium/abi.d.ts
+/** One account slot: its IDL name and the privileges the venue's own ABI gives it. */
+type VenueAccountSpec = {
+  readonly name: string;
+  readonly writable: boolean;
+  readonly signer: boolean;
+};
+type VenueInstructionAbi = {
+  readonly name: string;
+  readonly discriminator: Uint8Array;
+  readonly accounts: readonly VenueAccountSpec[];
+};
+/**
+ * The Raydium deployment of one cluster. Mainnet and devnet run different programs, so every
+ * address here differs between the two.
+ *
+ * Two things are deliberately absent, and both for the same reason: the program reads them from
+ * the chain instead of pinning them. The CPMM fee tier comes from the Gabox platform config and
+ * from the migrated pool's own data. The quote assets come from Raydium's own LaunchLab
+ * `GlobalConfig` accounts, one per quote mint, so there is no list of quotes here.
+ */
+type RaydiumClusterIds = {
+  /** Raydium LaunchLab, the bonding curve a Gabox coin launches and trades on first. */
+  readonly launchlab: Address;
+  /** PDA(["vault_auth_seed"], launchlab). Signs LaunchLab's own vault transfers. */
+  readonly launchlabAuthority: Address;
+  /** PDA(["__event_authority"], launchlab). */
+  readonly launchlabEventAuthority: Address;
+  /** PDA(["platform_config", PLATFORM_ADMIN], launchlab). The Gabox platform on LaunchLab. */
+  readonly gaboxPlatform: Address;
+  /** Raydium CPMM, the pool a Gabox coin graduates into. */
+  readonly cpmm: Address;
+  /** PDA(["vault_and_lp_mint_auth_seed"], cpmm). */
+  readonly cpmmAuthority: Address;
+  /**
+   * The raise a WSOL-quoted curve must reach before the coin graduates, in lamports.
+   *
+   * The program pins this one value, and only for a WSOL pool: it knows what SOL is worth to its
+   * own product and cannot say the same about USDC or a stock token. A pool quoted in any other
+   * asset picks its own raise, and LaunchLab checks it against `min_quote_fund_raising` in that
+   * quote's own global config.
+   */
+  readonly launchQuoteRaise: bigint;
+};
+declare const RAYDIUM_MAINNET_IDS: RaydiumClusterIds;
+declare const RAYDIUM_DEVNET_IDS: RaydiumClusterIds;
+/**
+ * Wrapped SOL: the default quote, and the one every price in SOL is measured in. Gabox accepts any
+ * quote Raydium enabled on LaunchLab, so this is not the only one.
+ */
+declare const WSOL_MINT: Address;
+/** Metaplex Token Metadata, which LaunchLab's create instruction writes to. */
+declare const METAPLEX_PROGRAM_ADDRESS: Address;
+/**
+ * `PLATFORM_ADMIN` in the program's constants.rs. The Gabox platform config PDA derives from this
+ * wallet, and LaunchLab pays the platform share of every curve trade to it.
+ */
+declare const PLATFORM_ADMIN: Address;
+/** The coin supply every Gabox launch mints: 1,000,000,000 coins at 6 decimals. */
+declare const LAUNCH_SUPPLY = 1000000000000000n;
+/** The part of the supply the LaunchLab curve sells: 793,100,000 coins. */
+declare const LAUNCH_TOTAL_BASE_SELL = 793100000000000n;
+/** Classic SPL Token. The base coin is always under it, on both venues. */
+declare const TOKEN_PROGRAM_ADDRESS: Address;
+/**
+ * Token-2022. A quote mint may be under it, inside the bounded profile the program's
+ * `tokens::validate_quote_mint` accepts. The base coin never is.
+ */
+declare const TOKEN_2022_PROGRAM_ADDRESS: Address;
+declare const ASSOCIATED_TOKEN_PROGRAM_ADDRESS: Address;
+declare const SYSTEM_PROGRAM_ADDRESS: Address;
+/** The rent sysvar. LaunchLab's create instruction still takes it. */
+declare const RENT_SYSVAR_ADDRESS: Address;
+/**
+ * The first eight bytes of each Raydium account this SDK decodes. `adapter.ts` checks them before
+ * it reads a field, so an account of the wrong type fails loudly instead of decoding as rubbish.
+ *
+ * LaunchLab and CPMM give their pool account the same eight bytes, because Anchor derives a
+ * discriminator from the struct name alone and both are called `PoolState`. The two programs own
+ * different accounts, so the pair never collides in practice.
+ */
+declare const LAUNCHLAB_POOL_STATE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare const LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare const LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare const CPMM_POOL_STATE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+declare const CPMM_AMM_CONFIG_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+/**
+ * `initialize_v2` on `LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj` — cross-checked against interfaces.json.
+ */
+declare const LAUNCHLAB_INITIALIZE: VenueInstructionAbi;
+/**
+ * `buy_exact_in` on `LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj` — not in interfaces.json (the program never builds it).
+ * The last three accounts are not in the IDL. LaunchLab reads them from the remaining
+ * accounts, in this order.
+ */
+declare const LAUNCHLAB_BUY_EXACT_IN: VenueInstructionAbi;
+/**
+ * `buy_exact_out` on `LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj` — cross-checked against interfaces.json.
+ * The last three accounts are not in the IDL. LaunchLab reads them from the remaining
+ * accounts, in this order.
+ */
+declare const LAUNCHLAB_BUY_EXACT_OUT: VenueInstructionAbi;
+/**
+ * `sell_exact_in` on `LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj` — cross-checked against interfaces.json.
+ * The last three accounts are not in the IDL. LaunchLab reads them from the remaining
+ * accounts, in this order.
+ */
+declare const LAUNCHLAB_SELL_EXACT_IN: VenueInstructionAbi;
+/**
+ * `claim_creator_fee` on `LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj` — not in interfaces.json (the program never builds it).
+ */
+declare const LAUNCHLAB_CLAIM_CREATOR_FEE: VenueInstructionAbi;
+/**
+ * `swap_base_output` on `CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C` — cross-checked against interfaces.json.
+ */
+declare const CPMM_SWAP_BASE_OUTPUT: VenueInstructionAbi;
+/**
+ * `swap_base_input` on `CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C` — cross-checked against interfaces.json.
+ */
+declare const CPMM_SWAP_BASE_INPUT: VenueInstructionAbi;
+/**
+ * `collect_creator_fee` on `CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C` — not in interfaces.json (the program never builds it).
+ * The last account is not in the IDL snapshot; see `CPMM_CREATOR_FEE_SHARE_ACCOUNT` in
+ * scripts/codegen.mjs. Derive it as PDA(["creator_fee_share", creator, amm_config]).
+ */
+declare const CPMM_COLLECT_CREATOR_FEE: VenueInstructionAbi;
+//#endregion
+//#region src/raydium/ids.d.ts
+/** The name the rest of the SDK uses for one cluster's Raydium deployment. */
+type RaydiumIds = RaydiumClusterIds;
+/**
+ * The decimals every Gabox coin is launched with. `venue/launch.rs` refuses any other value, and
+ * `tokens.rs` refuses a pool mint that does not have exactly this many.
+ */
+declare const LAUNCH_DECIMALS = 6;
+/**
+ * The Raydium deployment of each cluster.
+ *
+ * `localnet` uses the mainnet set. A local validator normally clones the mainnet Raydium programs,
+ * and the program's own default `anchor build` pins the mainnet addresses too; the `devnet` cargo
+ * feature is what swaps them. Pass your own ids to a builder if your validator clones devnet.
+ */
+declare const RAYDIUM_IDS: Readonly<Record<Cluster, RaydiumIds>>;
+/** The Raydium deployment one cluster trades on. Throws for a cluster this SDK does not know. */
+declare function raydiumIds(cluster: Cluster): RaydiumIds;
+/** LaunchLab's PDA seeds, and the two Gabox coins are always sorted against. */
+declare const LAUNCHLAB_SEEDS: {
+  /** `["vault_auth_seed"]`. */
+  readonly authority: "vault_auth_seed";
+  /** `["__event_authority"]`. */
+  readonly eventAuthority: "__event_authority";
+  /** `["global_config", quote_mint, u8 curve_type, u16 big-endian index]`. */
+  readonly globalConfig: "global_config";
+  /** `["platform_config", platform_admin]`. */
+  readonly platformConfig: "platform_config";
+  /** `["pool", base_mint, quote_mint]`. */
+  readonly pool: "pool";
+  /** `["pool_vault", pool_state, mint]`. */
+  readonly vault: "pool_vault";
+  /** `["creator_fee_vault_auth_seed"]`, the authority over every creator fee vault. */
+  readonly creatorFeeVaultAuthority: "creator_fee_vault_auth_seed";
+};
+/** CPMM's PDA seeds. */
+declare const CPMM_SEEDS: {
+  /** `["vault_and_lp_mint_auth_seed"]`. */
+  readonly authority: "vault_and_lp_mint_auth_seed";
+  /** `["pool", amm_config, token_0_mint, token_1_mint]`, the mints sorted by byte order. */
+  readonly pool: "pool";
+  /** `["pool_vault", pool_state, mint]`. */
+  readonly vault: "pool_vault";
+  /** `["observation", pool_state]`. */
+  readonly observation: "observation";
+  /** `["creator_fee_share", creator, amm_config]`. */
+  readonly creatorFeeShare: "creator_fee_share";
+};
+/** Metaplex's metadata PDA seed: `["metadata", metaplex, mint]`. */
+declare const METADATA_SEED = "metadata";
+/**
+ * Every rate LaunchLab and CPMM state is out of 1,000,000, not out of 10,000. A `trade_fee_rate`
+ * of 5,000 is 0.5%.
+ */
+declare const RATE_DENOMINATOR = 1000000n;
+/** The share-fee receiver Gabox never passes, so its rate is always zero on every trade. */
+declare const SHARE_FEE_RATE = 0n;
+/** `CurveParams::Constant`, the only curve shape Gabox launches. */
+declare const CONSTANT_CURVE_TAG = 0;
+/** `migrate_type` 1: the coin graduates into a CPMM pool, not into an AMM pool. */
+declare const MIGRATE_TO_CPMM = 1;
+/** `AmmCreatorFeeOn::QuoteToken`, so the CPMM creator fee is paid in the pool's quote asset. */
+declare const CREATOR_FEE_ON_QUOTE = 0;
+/** LaunchLab pool `status`: still selling on the curve. */
+declare const LAUNCHLAB_STATUS_FUND = 0;
+/** LaunchLab pool `status`: the raise is complete and Raydium's bot is migrating the coin. */
+declare const LAUNCHLAB_STATUS_MIGRATE = 1;
+/** LaunchLab pool `status`: the coin has graduated and trades on its CPMM pool. */
+declare const LAUNCHLAB_STATUS_TRADE = 2;
+/** Metaplex's own limits on the three strings a creator picks, in UTF-8 bytes. */
+declare const METADATA_LIMITS: {
+  readonly name: 32;
+  readonly symbol: 10;
+  readonly uri: 200;
+};
+/** Raydium sorts a CPMM pair by raw address byte order. */
+declare function sortedMints(a: Address, b: Address): [Address, Address];
+/** Compare two addresses the way the runtime does: by their 32 raw bytes, not by base58 text. */
+declare function compareAddresses(a: Address, b: Address): number;
+//#endregion
+//#region src/raydium/adapter.d.ts
+/**
+ * The `amount` field of an SPL token account: bytes 64 to 72, little-endian.
+ *
+ * Both venues and every Gabox account use classic SPL Token, whose account is 165 bytes. The
+ * Token-2022 layout shares those first 165 bytes, so this reader covers a Token-2022 account too.
+ */
+declare function tokenAccountAmount(data: Uint8Array): bigint;
+/** The `mint` and `owner` of an SPL token account: bytes 0 to 32 and 32 to 64. */
+declare function tokenAccountOwnerAndMint(data: Uint8Array): {
+  mint: Address;
+  owner: Address;
+};
+/**
+ * The `decimals` of a mint. Both token programs share the first 82 bytes, so one reader covers a
+ * classic SPL mint and a Token-2022 one.
+ */
+declare function mintDecimals(data: Uint8Array): number;
+/**
+ * The `symbol` of a Metaplex token metadata account, or `null` when it carries none.
+ *
+ * Layout: a one-byte key, `update_authority` and `mint`, then the three Borsh strings `name`,
+ * `symbol` and `uri`. Metaplex stores them at their maximum length, NUL padded.
+ */
+declare function metaplexSymbol(data: Uint8Array): string | null;
+/**
+ * The `symbol` a Token-2022 mint stores in its own `TokenMetadata` extension, or `null`.
+ *
+ * The extensions are a TLV list: a u16 type, a u16 length, then the value. The metadata value is
+ * `update_authority`, `mint`, then the Borsh strings `name`, `symbol` and `uri`.
+ */
+declare function token2022Symbol(data: Uint8Array): string | null;
+/** The curve pool of one coin, as far as pricing and routing need it. */
+type LaunchlabPoolState = {
+  /** 0 while the curve still sells, 1 while Raydium migrates the coin, 2 once it has graduated. */
+  status: number;
+  baseDecimals: number;
+  quoteDecimals: number;
+  /** 1 means the coin graduates into a CPMM pool. Every Gabox launch pins this. */
+  migrateType: number;
+  supply: bigint;
+  /** The part of the supply the curve sells. The curve cannot sell more than this. */
+  totalBaseSell: bigint;
+  /** The curve's virtual reserves. `virtualQuote / virtualBase` is the starting price. */
+  virtualBase: bigint;
+  virtualQuote: bigint;
+  /** Coins the curve has already sold, and quote it has already raised. */
+  realBase: bigint;
+  realQuote: bigint;
+  totalQuoteFundRaising: bigint;
+  migrateFee: bigint;
+  globalConfig: Address;
+  platformConfig: Address;
+  baseMint: Address;
+  quoteMint: Address;
+  baseVault: Address;
+  quoteVault: Address;
+  /** The coin creator. LaunchLab pays the creator share of every trade to this wallet's vault. */
+  creator: Address;
+  /** 0 means the CPMM creator fee is paid in the quote token only. Every Gabox launch pins it. */
+  ammCreatorFeeOn: number;
+};
+/** The bytes the decoder above reads, discriminator included. The account itself is longer. */
+declare const LAUNCHLAB_POOL_STATE_HEAD_SIZE = 367;
+declare function decodeLaunchlabPool(data: Uint8Array): LaunchlabPoolState;
+/**
+ * LaunchLab's settings for one quote asset.
+ *
+ * One of these exists for every quote Raydium enabled, and only Raydium's admin can create one. So
+ * the account itself is what proves a quote is allowed: the program checks the same four things in
+ * `venue/launch.rs` before it opens a pool.
+ */
+type LaunchlabGlobalConfig = {
+  /** 0 is the constant product curve, the only shape Gabox launches. */
+  curveType: number;
+  index: number;
+  /** The quote LaunchLab keeps at graduation. It lowers the curve's own starting reserves. */
+  migrateFee: bigint;
+  /** Raydium's own share of every curve trade, out of 1,000,000. */
+  tradeFeeRate: bigint;
+  /** The smallest raise LaunchLab accepts for this quote, in its own base units. */
+  minQuoteFundRaising: bigint;
+  quoteMint: Address;
+};
+declare const LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE = 115;
+declare function decodeLaunchlabGlobalConfig(data: Uint8Array): LaunchlabGlobalConfig;
+/** The Gabox platform on LaunchLab. Its two rates are the platform and creator shares. */
+type LaunchlabPlatformConfig = {
+  /** Receives the platform share of every curve trade. */
+  platformFeeWallet: Address;
+  /** The platform share of every curve trade, out of 1,000,000. 5,000 is 0.5%. */
+  feeRate: bigint;
+  /** The coin creator's share of every curve trade, out of 1,000,000. 5,000 is 0.5%. */
+  creatorFeeRate: bigint;
+  /** The CPMM fee tier a coin of this platform graduates into. */
+  cpswapConfig: Address;
+  /**
+   * When this is a real wallet, it becomes the CPMM pool creator at graduation instead of the coin
+   * creator. Gabox leaves it empty, so its coin creators keep the CPMM creator fee.
+   */
+  platformCpCreator: Address;
+};
+/** Everything before `curve_params`, discriminator included. */
+declare const LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE: number;
+declare function decodeLaunchlabPlatformConfig(data: Uint8Array): LaunchlabPlatformConfig;
+/** The pool a graduated Gabox coin trades in. */
+type CpmmPoolState = {
+  ammConfig: Address;
+  /** LaunchLab sets this to the coin creator at migration. It earns the CPMM creator fee. */
+  poolCreator: Address;
+  token0Vault: Address;
+  token1Vault: Address;
+  token0Mint: Address;
+  token1Mint: Address;
+  token0Program: Address;
+  token1Program: Address;
+  observationKey: Address;
+  /** Bit flags. Bit 2 set (value 4) means swaps are switched off. */
+  status: number;
+  mint0Decimals: number;
+  mint1Decimals: number;
+  /** Fees the pool owes and a swap must not spend. Subtract them from the vault balances. */
+  protocolFeesToken0: bigint;
+  protocolFeesToken1: bigint;
+  fundFeesToken0: bigint;
+  fundFeesToken1: bigint;
+  creatorFeesToken0: bigint;
+  creatorFeesToken1: bigint;
+  /** Unix seconds. Swaps fail before it. */
+  openTime: bigint;
+  /** 0 charges the creator fee on whichever token comes in, 1 only token 0, 2 only token 1. */
+  creatorFeeOn: number;
+  /** `false` switches the creator fee off entirely. */
+  enableCreatorFee: boolean;
+};
+declare const CPMM_POOL_STATE_HEAD_SIZE = 413;
+/**
+ * The full byte length of a CPMM `PoolState`, trailing padding included. A `getProgramAccounts`
+ * scan filters on it, so it has to be the whole account and not only the part decoded above.
+ */
+declare const CPMM_POOL_STATE_SIZE = 637;
+/**
+ * Byte offsets a `getProgramAccounts` scan matches on. They are the same offsets `venue/trade.rs`
+ * reads the fields at, so a pool that passes the scan passes the program's own check.
+ */
+declare const CPMM_POOL_OFFSETS: {
+  readonly ammConfig: 8;
+  readonly poolCreator: 40;
+  readonly token0Mint: 168;
+  readonly token1Mint: 200;
+  readonly enableCreatorFee: 390;
+};
+declare function decodeCpmmPool(data: Uint8Array): CpmmPoolState;
+/** One CPMM fee tier. Every rate is out of 1,000,000. */
+type CpmmAmmConfig = {
+  index: number;
+  disableCreatePool: boolean;
+  /** The pool's own fee on every swap. Devnet tier 5 is 5,000, which is 0.50%. */
+  tradeFeeRate: bigint;
+  /** Raydium's share of the trade fee, not an extra charge on the swap. */
+  protocolFeeRate: bigint;
+  fundFeeRate: bigint;
+  /** The pool creator's fee on every swap. Devnet tier 5 is 4,000, which is 0.40%. */
+  creatorFeeRate: bigint;
+};
+declare const CPMM_AMM_CONFIG_HEAD_SIZE = 116;
+declare function decodeCpmmAmmConfig(data: Uint8Array): CpmmAmmConfig;
+//#endregion
+//#region src/raydium/curve.d.ts
+/**
+ * Raydium's own price math, ported to bigint.
+ *
+ * Every function here is a line-by-line port of Raydium's TypeScript, which is itself the same math
+ * their on-chain programs run. The point is that a buyer sees the exact number the venue will
+ * charge, not an estimate: `buy_pack` passes the pack size as an exact-tokens-out amount, and the
+ * program then requires the token delta to equal one pack.
+ *
+ * Sources, read on 2026-09-18:
+ *
+ *   - `raydium/launchpad/curve/constantProductCurve.ts` and `curve.ts` (LaunchLab)
+ *   - `raydium/cpmm/curve/calculator.ts`, `constantProduct.ts` and `fee.ts` (CPMM)
+ *
+ * Raydium uses `BN`, which truncates toward zero on division. Every value here is a non-negative
+ * bigint, where `/` truncates the same way, so a plain `/` is the faithful port of their `.div()`.
+ * Where they round up they call a ceiling helper, and so does this file. Nothing is approximated
+ * and no step is reordered: a division that happens before a subtraction there happens before it
+ * here, because the two orders give different answers.
+ *
+ * Every rate is out of 1,000,000, not out of 10,000.
+ */
+/** `ceilDiv(a, b, denominator)` in Raydium's code: `ceil(a * b / denominator)`. */
+declare function ceilDivRate(amount: bigint, rate: bigint, denominator?: bigint): bigint;
+/** `ceil(numerator / denominator)` for non-negative values. */
+declare function ceilDiv(numerator: bigint, denominator: bigint): bigint;
+/**
+ * The amount before a fee was taken, given the amount after it: `ceil(post * 1e6 / (1e6 - rate))`.
+ *
+ * Raydium calls this `calculatePreFee` on the curve and `calculatePreFeeAmount` on CPMM. Both are
+ * the same expression.
+ */
+declare function preFeeAmount(postFeeAmount: bigint, rate: bigint): bigint;
+/** The four reserve numbers a curve price depends on. Read them off the pool account. */
+type CurveReserves = {
+  virtualBase: bigint;
+  virtualQuote: bigint;
+  realBase: bigint;
+  realQuote: bigint;
+  /** The most the curve will ever sell. A buy larger than what is left is capped at it. */
+  totalBaseSell: bigint;
+};
+/** The three fee rates a curve trade pays, each out of 1,000,000. */
+type CurveFeeRates = {
+  /** `trade_fee_rate` on LaunchLab's global config: Raydium's own share. */
+  tradeFeeRate: bigint;
+  /** `fee_rate` on the platform config: the Gabox platform's share. */
+  platformFeeRate: bigint;
+  /** `creator_fee_rate` on the platform config: the coin creator's share. */
+  creatorFeeRate: bigint;
+};
+/**
+ * The whole fee a curve trade pays. Gabox never passes a share-fee receiver, so the fourth rate
+ * Raydium supports is always zero and is left out here.
+ */
+declare function totalCurveFeeRate(rates: CurveFeeRates): bigint;
+/** Coins the curve still has to sell. A buy cannot take more than this. */
+declare function remainingBase(pool: CurveReserves): bigint;
+/**
+ * Quote needed to buy exactly `tokens` coins on the curve, fees included.
+ *
+ * This is `Curve.buyExactOut` with no token transfer fee, which is always the case for Gabox: both
+ * mints are classic SPL Token and carry no transfer-fee extension.
+ *
+ * Raydium caps the amount at what the curve has left to sell and still returns a price, so this
+ * does the same. A caller that needs the whole `tokens` must check `remainingBase` first;
+ * `resolveVenue` does.
+ */
+declare function curveBuyExactOut(pool: CurveReserves, rates: CurveFeeRates, tokens: bigint): bigint;
+/**
+ * Coins `quote` buys on the curve right now, fees already taken off the spend.
+ *
+ * This is `Curve.buyExactIn`. It is what a raw `buy_exact_in` pays out, which the devnet end-to-end
+ * test uses to push a curve to graduation.
+ */
+declare function curveBuyExactIn(pool: CurveReserves, rates: CurveFeeRates, quote: bigint): bigint;
+/**
+ * Quote a sale of exactly `tokens` coins returns, net of fees. This is `Curve.sellExactIn`.
+ */
+declare function curveSellExactIn(pool: CurveReserves, rates: CurveFeeRates, tokens: bigint): bigint;
+/** What a launch pins, and what the starting reserves follow from. */
+type LaunchParams = {
+  /** The whole supply the coin is minted with. */
+  supply: bigint;
+  /** The part of it the curve sells. */
+  totalBaseSell: bigint;
+  /** The quote the curve must raise before the coin graduates. */
+  quoteRaise: bigint;
+  /** Coins locked in a vesting schedule. Always zero for a Gabox launch. */
+  totalLockedAmount?: bigint;
+  /** The quote LaunchLab keeps at graduation, from its global config. */
+  migrateFee?: bigint;
+};
+/**
+ * The virtual reserves LaunchLab gives a coin that does not exist yet.
+ *
+ * This is `LaunchConstantProductCurve.getInitParam`. `createMachine` needs it because the seed buy
+ * runs in the same transaction that creates the coin: there is no pool account to read yet, and the
+ * reserves follow from the pinned launch shape alone.
+ *
+ * Checked against Raydium's own published numbers for the mainnet Gabox launch shape (supply
+ * 1,000,000,000 coins, 793,100,000 sold on the curve, 85 SOL raised, no migrate fee):
+ * `virtualBase` 1,073,025,605,596,382 and `virtualQuote` 30,000,852,951.
+ */
+declare function initialCurve(params: LaunchParams): CurveReserves;
+/** One side of a CPMM swap, after the pool's own unspendable fee balances are taken off. */
+type CpmmSwapSides = {
+  /** Token going in: the quote on a buy, the coin on a sell. */
+  inputReserve: bigint;
+  /** Token coming out: the coin on a buy, the quote on a sell. */
+  outputReserve: bigint;
+};
+/** The two CPMM rates, each out of 1,000,000, plus where the creator fee is charged. */
+type CpmmFeeRates = {
+  /** `trade_fee_rate` on the `amm_config`. */
+  tradeFeeRate: bigint;
+  /** `creator_fee_rate` on the `amm_config`, or zero when the pool switched the fee off. */
+  creatorFeeRate: bigint;
+  /**
+   * `true` when this side's creator fee comes off the input token, `false` when it comes off the
+   * output. It follows from the pool's `creator_fee_on` and which token is going in.
+   */
+  creatorFeeOnInput: boolean;
+};
+/**
+ * Quote a CPMM buy of exactly `tokens` coins costs, both fees included.
+ *
+ * This is `CurveCalculator.swapBaseOutput`, which is what `swap_base_output` charges.
+ */
+declare function cpmmSwapBaseOutput(sides: CpmmSwapSides, rates: CpmmFeeRates, amountOut: bigint): bigint;
+/**
+ * What a CPMM swap of exactly `amountIn` returns, net of both fees.
+ *
+ * This is `CurveCalculator.swapBaseInput`, which is what `swap_base_input` pays out.
+ */
+declare function cpmmSwapBaseInput(sides: CpmmSwapSides, rates: CpmmFeeRates, amountIn: bigint): bigint;
+//#endregion
+//#region src/raydium/venue.d.ts
+type VenueKind = 'launchlab' | 'cpmm';
+/**
+ * The quote asset one pool is bound to, as the pool records it.
+ *
+ * `config` is LaunchLab's global config for the mint: the account that proves Raydium enabled the
+ * quote, and the account both venues check the trade against. `tokenProgram` owns the mint, and the
+ * user's quote ATA lives under it.
+ */
+type QuoteBinding = {
+  mint: Address;
+  config: Address;
+  tokenProgram: Address;
+};
+/** Everything `resolveVenue` learned, plus the pure functions that follow from it. */
+type ResolvedVenue = {
+  kind: VenueKind;
+  /** The program to pass as the `venue` account. */
+  program: Address;
+  mint: Address;
+  quoteMint: Address;
+  /** The token program the quote mint lives under: classic SPL Token, or Token-2022. */
+  quoteTokenProgram: Address;
+  /** The trader's quote ATA. Both venues settle here, and the program pins this address. */
+  userQuoteToken: Address;
+  /** The venue's own pool: the LaunchLab curve pool, or the migrated CPMM pool. */
+  poolState: Address;
+  /** The LaunchLab pool's `status`: 0 funding, 1 migrating, 2 graduated. */
+  status: number;
+  /** The coin creator. LaunchLab and CPMM both pay their creator fee to this wallet. */
+  creator: Address;
+  /** The CPMM fee tier the pool names. Equal to the LaunchLab program on the curve venue. */
+  ammConfig: Address | null;
+  /** Coins the curve still has to sell. `0n` once the coin has graduated. */
+  remainingCurveBase: bigint;
+  /** The ordered account list for an exact-coins-out buy, in `remainingAccounts` order. */
+  buyAccounts: AccountMeta[];
+  /** The ordered account list for a sale. */
+  sellAccounts: AccountMeta[];
+  /** Quote token an exact-coins-out buy of `tokens` costs right now, the venue's fees included. */
+  quoteBuy(tokens: bigint): bigint;
+  /** Quote token a sale of `tokens` returns right now, net of the venue's fees. */
+  quoteSell(tokens: bigint): bigint;
+};
+type ResolveVenueOptions = {
+  mint: Address;
+  /** The wallet that will sign the trade. Its token accounts appear in the account list. */
+  user: Address;
+  /** Force a venue instead of reading the pool's `status`. A wrong choice fails on chain. */
+  venue?: VenueKind;
+  /** The pool's quote binding. Read from the Gabox pool when it is left out. */
+  quote?: QuoteBinding;
+};
+/** The quote binding a Gabox pool records. One account read. */
+declare function fetchQuoteBinding(client: GaboxClient, mint: Address): Promise<QuoteBinding>;
+/**
+ * The user's quote associated token account, under the quote's own token program.
+ *
+ * Both venues settle in this account, never in native SOL. It must exist and hold enough before a
+ * pack is bought, and sale proceeds land in it. For a WSOL-quoted pool every builder in `tx/` wraps
+ * the SOL it needs into this account and closes it again in the same transaction.
+ */
+declare function quoteAccountFor(user: Address, quoteMint: Address, quoteTokenProgram?: Address): Promise<Address>;
+/** The user's WSOL associated token account. WSOL is always classic SPL Token. */
+declare function wsolAccountFor(user: Address): Promise<Address>;
+/** What LaunchLab's global config and the Gabox platform config say about a curve trade. */
+type CurveSettings = {
+  rates: CurveFeeRates;
+  /** `migrate_fee` on the global config. The starting reserves depend on it. */
+  migrateFee: bigint;
+  /** `cpswap_config` on the platform config: the CPMM fee tier a Gabox coin graduates into. */
+  cpswapConfig: Address;
+};
+/**
+ * Read the quote's global config and the Gabox platform config, and take the four numbers a quote
+ * needs out of them.
+ *
+ * `quoteConfig` is the LaunchLab global config of the pool's quote asset: `pool.quoteConfig`, or
+ * the address `raydium.fetchQuoteConfig` derives for a coin that has no pool yet.
+ */
+declare function fetchCurveSettings(client: GaboxClient, quoteConfig: Address, ids?: RaydiumIds): Promise<CurveSettings>;
+declare function resolveVenue(client: GaboxClient, options: ResolveVenueOptions): Promise<ResolvedVenue>;
+/** A CPMM pool that has proved, from its own data, that it is a coin's migrated pool. */
+type MigratedCpmmPool = {
+  address: Address;
+  pool: CpmmPoolState;
+};
+type FindCpmmPoolOptions = {
+  mint: Address;
+  /** The coin creator, from the Gabox pool or the LaunchLab pool. */
+  creator: Address;
+  /** The fee tier the Gabox platform config names. Read it with `fetchCurveSettings`. */
+  cpswapConfig: Address;
+  /** The pool's quote mint. Defaults to WSOL, which is the default quote. */
+  quoteMint?: Address;
+};
+/**
+ * Every check the program makes on a CPMM pool account, in one place.
+ *
+ * `enable_creator_fee` is the one that identifies the migrated pool. Anyone can call CPMM's own
+ * `initialize` and open a pool for the same pair with the same creator, but that pool always has
+ * the flag false. Only a creator Raydium has permissioned can set it, and LaunchLab's migration is
+ * one of those.
+ */
+declare function cpmmPoolMatches(pool: CpmmPoolState, expect: {
+  creator: Address;
+  token0: Address;
+  token1: Address;
+}): boolean;
+/**
+ * The CPMM pool LaunchLab migrated a coin into.
+ *
+ * Two steps, because the pool is not always at a derived address. Raydium migrates into
+ * `["pool", cpswap_config, token_0, token_1]` when that account is free, and into a random account
+ * when it is not. So: try the derived address, and scan for the pool when it does not hold one.
+ *
+ * The scan filters on the account length and on the three fields at their fixed offsets, so the
+ * RPC does the work and returns at most a handful of accounts. Every candidate still has to pass
+ * `cpmmPoolMatches`, and more than one match is an error rather than a guess.
+ */
+declare function findCpmmPool(client: GaboxClient, options: FindCpmmPoolOptions): Promise<MigratedCpmmPool>;
+/**
+ * Does this side's creator fee come off the token going in?
+ *
+ * `creator_fee_on` is 0 when the fee follows the input token, 1 when it is always token 0, and 2
+ * when it is always token 1. LaunchLab migrates a Gabox coin with `AmmCreatorFeeOn::QuoteToken`, so
+ * the pool charges the creator fee in the quote token only: on the input of a buy, on the output of
+ * a sale.
+ */
+declare function creatorFeeOnInput(pool: CpmmPoolState, inputMint: Address): boolean;
+/**
+ * Quote token an exact-coins-out buy of `tokens` costs right now, on whichever venue the coin
+ * trades. Pass `pool.packTokens` for the pack price.
+ *
+ * Use `resolveVenue` when you also need the account list, which every transaction builder does.
+ * This is for a price display.
+ */
+declare function curveQuote(client: GaboxClient, mint: Address, tokens: bigint, options?: {
+  user?: Address;
+  venue?: VenueKind;
+  quote?: QuoteBinding;
+}): Promise<bigint>;
+/** Quote token a sale of `tokens` returns right now, net of the venue's fees. */
+declare function sellQuote(client: GaboxClient, mint: Address, tokens: bigint, options?: {
+  user?: Address;
+  venue?: VenueKind;
+  quote?: QuoteBinding;
+}): Promise<bigint>;
+/**
+ * Quote token an exact-coins-out buy of `tokens` would cost on a curve that does not exist yet,
+ * fees included.
+ *
+ * This is what the seed costs. `initialize_pool` buys it in the same transaction that creates the
+ * coin, so the curve is a brand-new LaunchLab curve with the pinned Gabox launch shape at that
+ * moment. Exact, unless Raydium changes a fee rate between this read and the send.
+ */
+declare function newCurveBuyCost(client: GaboxClient, tokens: bigint, launch: {
+  quoteConfig: Address;
+  raise: bigint;
+}): Promise<bigint>;
+/**
+ * The starting reserves of a brand-new Gabox curve.
+ *
+ * `raise` is `total_quote_fund_raising`, in the quote's own base units. It is the one launch number
+ * the client picks, so the reserves follow it.
+ */
+declare function newCurveReserves(raise: bigint, migrateFee: bigint): CurveReserves;
+//#endregion
+//#region src/tx/message.d.ts
+/**
+ * What every builder returns: a version 0 message with a fee-payer signer and a blockhash
+ * lifetime, ready for `signTransactionMessageWithSigners`.
+ *
+ * Named, and built only from types `@solana/kit` exports, so the published declaration file
+ * refers to kit's types instead of copying them. `pipe`'s inferred type is a long intersection
+ * of kit-internal brands, and a copy of a branded type is not assignable to the original.
+ */
+type GaboxTransactionMessage = Extract<TransactionMessage, {
+  version: 0;
+}> & TransactionMessageWithFeePayerSigner & TransactionMessageWithBlockhashLifetime;
+type BuildOptions = {
+  /** Compute units to request. Each builder passes its own default. */
+  computeUnitLimit: number;
+  /** Priority fee in micro-lamports per compute unit. Left out, no price instruction is added. */
+  computeUnitPrice?: number | bigint;
+  /** Defaults to the client's tables, which the cluster chose. Pass `{}` to disable compression. */
+  addressLookupTables?: AddressesByLookupTableAddress;
+};
+/**
+ * Build the message. One RPC read, for the blockhash.
+ *
+ * The blockhash expires in about a minute, so build the message when the user is ready to sign
+ * rather than when the page loads.
+ */
+declare function buildMessage(client: GaboxClient, feePayer: TransactionSigner, instructions: Instruction[], options: BuildOptions): Promise<GaboxTransactionMessage>;
+/** Append `remainingAccounts` to a generated instruction, which is how a venue's list is passed. */
+declare function withRemainingAccounts<T extends Instruction>(instruction: T, remaining: readonly NonNullable<T['accounts']>[number][]): T;
+//#endregion
+//#region src/raydium/accounts.d.ts
+/**
+ * Turn `{name -> address}` into the ABI's ordered `AccountMeta[]`.
+ *
+ * The map is keyed by the IDL's own account names, so a missing entry names the slot it belongs to
+ * rather than failing as an off-by-one further down. The role comes from the ABI table alone, never
+ * from the caller, which is what keeps this list in step with `venue/abi.rs`.
+ */
+declare function order(abi: VenueInstructionAbi, byName: Record<string, Address>): AccountMeta[];
+/** Everything a LaunchLab trade list needs. Every address is derived, never read off the chain. */
+type LaunchlabTradeAccountsInput = {
+  /** Raydium LaunchLab on this cluster. */
+  launchlab: Address;
+  /** `["vault_auth_seed"]` under LaunchLab. */
+  launchlabAuthority: Address;
+  /** `["__event_authority"]` under LaunchLab. */
+  launchlabEventAuthority: Address;
+  /** The global config of the quote asset. */
+  globalConfig: Address;
+  /** The Gabox platform config. */
+  platformConfig: Address;
+  /** `["pool", mint, quote_mint]` under LaunchLab. */
+  poolState: Address;
+  mint: Address;
+  quoteMint: Address;
+  /** `["pool_vault", pool_state, mint]` under LaunchLab. */
+  baseVault: Address;
+  /** `["pool_vault", pool_state, quote_mint]` under LaunchLab. */
+  quoteVault: Address;
+  /** The trader. The one signing slot in the list. */
+  user: Address;
+  /** The trader's coin ATA. `buy_pack` passes the same address as its own `user_tokens`. */
+  userBaseToken: Address;
+  /** The trader's quote ATA, under the quote's own token program. Both venues settle here. */
+  userQuoteToken: Address;
+  /** The quote mint's token program: classic SPL Token, or Token-2022. */
+  quoteTokenProgram: Address;
+  /** `[platform_config, quote_mint]` under LaunchLab. */
+  platformFeeVault: Address;
+  /** `[creator, quote_mint]` under LaunchLab, where `creator` is the coin creator. */
+  creatorFeeVault: Address;
+};
+/** `buy_exact_out`: 18 accounts. The first argument is the coins wanted, the second the cost cap. */
+declare const launchlabBuyAccounts: (input: LaunchlabTradeAccountsInput) => AccountMeta[];
+/** `sell_exact_in`: the same 18 accounts. `venue/trade.rs` uses one table for both sides. */
+declare const launchlabSellAccounts: (input: LaunchlabTradeAccountsInput) => AccountMeta[];
+/**
+ * `buy_exact_in`: the same 18 accounts again. Gabox never forwards this instruction; a wallet sends
+ * it on its own, to buy the curve out with a fixed spend.
+ */
+declare const launchlabBuyExactInAccounts: (input: LaunchlabTradeAccountsInput) => AccountMeta[];
+/** Everything a CPMM trade list needs. */
+type CpmmTradeAccountsInput = {
+  /** `["vault_and_lp_mint_auth_seed"]` under CPMM. */
+  cpmmAuthority: Address;
+  /** The fee tier the pool belongs to. Gabox pins the one LaunchLab migrates into. */
+  ammConfig: Address;
+  /** The migrated pool. */
+  poolState: Address;
+  mint: Address;
+  quoteMint: Address;
+  /** `["pool_vault", pool_state, mint]` under CPMM. */
+  baseVault: Address;
+  /** `["pool_vault", pool_state, quote_mint]` under CPMM. */
+  quoteVault: Address;
+  /** `["observation", pool_state]` under CPMM. */
+  observationState: Address;
+  /** The trader. The one signing slot, and read-only here: CPMM does not take its lamports. */
+  user: Address;
+  userBaseToken: Address;
+  userQuoteToken: Address;
+  /** The two token programs the pool records. Read them from the pool account, never derive them. */
+  baseTokenProgram: Address;
+  quoteTokenProgram: Address;
+};
+/** `swap_base_output`: 13 accounts. Note the argument order is `(max_amount_in, amount_out)`. */
+declare const cpmmBuyAccounts: (input: CpmmTradeAccountsInput) => AccountMeta[];
+/** `swap_base_input`: 13 accounts, with the four pairs swapped. */
+declare const cpmmSellAccounts: (input: CpmmTradeAccountsInput) => AccountMeta[];
+//#endregion
+//#region src/raydium/claim.d.ts
+/**
+ * The instructions of a curve fee claim, for one quote asset: create the quote account, claim, and
+ * close it again when the quote is WSOL.
+ *
+ * This sweeps **every** coin this wallet launched against that quote, because LaunchLab keeps one
+ * vault per wallet per quote asset. There is no per-coin version, and a creator with machines in
+ * two quote assets claims once per asset.
+ */
+declare function getClaimCreatorFeeInstructions(creator: TransactionSigner, ids: RaydiumIds, quote: {
+  mint: Address;
+  tokenProgram: Address;
+}): Promise<Instruction[]>;
+type ClaimCreatorFeeInput = {
+  creator: TransactionSigner;
+  /** The quote asset to claim. Defaults to wrapped SOL. One claim per quote asset. */
+  quoteMint?: Address;
+} & Partial<BuildOptions>;
+/**
+ * Claim the curve creator fee for one quote asset.
+ *
+ * A WSOL claim arrives as SOL, because the builder closes the WSOL account. Any other quote arrives
+ * as that token, in the creator's own account.
+ */
+declare function claimCreatorFee(client: GaboxClient, input: ClaimCreatorFeeInput): Promise<GaboxTransactionMessage>;
+/**
+ * The instructions of a graduated coin's fee collection: create the quote account, collect, and
+ * close it again when the quote is WSOL.
+ *
+ * This is per coin. `collect_creator_fee` pays out both sides of the pair, so anything owed in the
+ * coin itself lands in the creator's coin account and stays there.
+ *
+ * The coin's quote asset comes from its Gabox pool, so a caller never has to name it.
+ */
+declare function getCollectCreatorFeeInstructions(client: GaboxClient, input: {
+  mint: Address;
+  creator: TransactionSigner;
+  quote?: QuoteBinding;
+}, ids?: RaydiumIds): Promise<Instruction[]>;
+type CollectCreatorFeeInput = {
+  mint: Address;
+  creator: TransactionSigner;
+  /** The coin's quote binding, when it is already at hand. Read from the Gabox pool otherwise. */
+  quote?: QuoteBinding;
+} & Partial<BuildOptions>;
+/**
+ * Collect one graduated coin's CPMM creator fee.
+ *
+ * A WSOL-quoted coin pays the quote side out as SOL, because the builder closes the WSOL account.
+ * Any other quote arrives as that token.
+ */
+declare function collectCreatorFee(client: GaboxClient, input: CollectCreatorFeeInput): Promise<GaboxTransactionMessage>;
+/** What a creator can collect right now, for one quote asset. Every amount is in base units. */
+type CreatorFees = {
+  /** The quote asset these three amounts are measured against. */
+  quoteMint: Address;
+  /**
+   * Quote token waiting in the LaunchLab creator fee vault, across every coin this wallet launched
+   * against that quote.
+   */
+  curveQuote: bigint;
+  /**
+   * Quote token the migrated CPMM pool of `mint` owes this creator. `0n` when the coin has not
+   * graduated, and `0n` when no `mint` was passed.
+   */
+  cpmmQuote: bigint;
+  /** Coins the same pool owes this creator. CPMM can charge the fee on either side. */
+  cpmmTokens: bigint;
+};
+/**
+ * Read both places a creator's fees can sit, for one quote asset.
+ *
+ * `quoteMint` defaults to wrapped SOL. LaunchLab keeps one vault per wallet per quote, so a creator
+ * with machines in two quote assets reads this twice.
+ *
+ * `mint` is optional. Without it only the curve vault is read, which is the one number that covers
+ * every coin of that quote at once. With it the coin's CPMM pool is read too, and a coin that has
+ * not graduated reports zeros rather than failing.
+ */
+declare function fetchCreatorFees(client: GaboxClient, input: {
+  creator: Address;
+  mint?: Address;
+  quoteMint?: Address;
+}): Promise<CreatorFees>;
+//#endregion
+//#region src/raydium/launch.d.ts
+type LaunchInput = {
+  /** The coin's mint. A fresh keypair, and it signs. */
+  mint: TransactionSigner;
+  /**
+   * The wallet paying. LaunchLab takes it as both `payer` and `creator`, so this wallet receives
+   * LaunchLab's creator fee and owns the CPMM creator fee after graduation. It must be the same
+   * wallet that signs `initialize_pool`.
+   */
+  creator: TransactionSigner;
+  name: string;
+  symbol: string;
+  /** The metadata URI. Metaplex stores it on the mint's metadata account. */
+  uri: string;
+  /** The quote asset the coin is priced in. */
+  quoteMint: Address;
+  /** LaunchLab's global config for that quote: `["global_config", quote_mint, 0u8, 0u16]`. */
+  quoteConfig: Address;
+  /** The token program that owns the quote mint: classic SPL Token, or Token-2022. */
+  quoteTokenProgram: Address;
+  /** `total_quote_fund_raising`, in the quote's own base units. */
+  raise: bigint;
+};
+/**
+ * Build `initialize_v2` for one cluster's LaunchLab. `ids` is `raydiumIds(client.cluster)`.
+ *
+ * Two slots sign: the mint keypair, which LaunchLab takes as a signer rather than deriving, and the
+ * creator, who pays for everything.
+ */
+declare function getLaunchInstruction(input: LaunchInput, ids: RaydiumIds): Promise<Instruction>;
+//#endregion
+//#region src/raydium/pdas.d.ts
+/** `["vault_auth_seed"]`. LaunchLab signs its own vault transfers with this PDA. */
+declare const launchlabAuthority: (launchlab: Address) => Promise<Address>;
+/** `["__event_authority"]`. */
+declare const launchlabEventAuthority: (launchlab: Address) => Promise<Address>;
+/**
+ * `["global_config", quote_mint, u8 curve_type, u16 big-endian index]`. The curve settings for one
+ * quote asset. Gabox uses curve type 0 (constant product) and index 0.
+ */
+declare const launchlabGlobalConfig: (launchlab: Address, quoteMint: Address, curveType?: number, index?: number) => Promise<Address>;
+/** `["platform_config", platform_admin]`. The Gabox platform on LaunchLab. */
+declare const launchlabPlatformConfig: (launchlab: Address, platformAdmin: Address) => Promise<Address>;
+/** `["pool", base_mint, quote_mint]`. The curve pool of one coin. */
+declare const launchlabPoolAddress: (launchlab: Address, baseMint: Address, quoteMint: Address) => Promise<Address>;
+/** `["pool_vault", pool_state, mint]`. One side of a curve pool's reserves. */
+declare const launchlabVaultAddress: (launchlab: Address, poolState: Address, mint: Address) => Promise<Address>;
+/**
+ * `[platform_config, quote_mint]`. LaunchLab pays the platform share of every curve trade here.
+ *
+ * The seeds carry no text prefix. That is Raydium's own derivation, not a mistake.
+ */
+declare const platformFeeVaultAddress: (launchlab: Address, platformConfig: Address, quoteMint: Address) => Promise<Address>;
+/**
+ * `[creator, quote_mint]`. LaunchLab pays the creator share of every curve trade here.
+ *
+ * One vault per wallet per quote asset, not one per coin. A creator with several coins collects
+ * all of them with a single `claim_creator_fee`.
+ */
+declare const creatorFeeVaultAddress: (launchlab: Address, creator: Address, quoteMint: Address) => Promise<Address>;
+/** `["creator_fee_vault_auth_seed"]`. The authority `claim_creator_fee` signs the payout with. */
+declare const creatorFeeVaultAuthority: (launchlab: Address) => Promise<Address>;
+/** `["metadata", metaplex, mint]` under Metaplex. LaunchLab's create instruction writes it. */
+declare const metadataAddress: (mint: Address) => Promise<Address>;
+/** `["vault_and_lp_mint_auth_seed"]`. */
+declare const cpmmAuthority: (cpmm: Address) => Promise<Address>;
+/**
+ * `["pool", amm_config, token_0, token_1]`, with the two mints sorted by raw byte order.
+ *
+ * This is where Raydium migrates a coin when the address is free. It is only a first guess: when the
+ * account is taken, the migration lands somewhere else entirely. And the address alone proves
+ * nothing, because anyone can open a CPMM pool for any pair under any config. `findCpmmPool` tries
+ * this address, checks the account data, and scans for the real pool when it does not match.
+ *
+ * There are no vault or observation derivations here on purpose. `venue/trade.rs` reads those three
+ * addresses out of the pool account, and so does this SDK: a migrated pool names its own vaults and
+ * its own oracle, wherever it sits.
+ */
+declare const cpmmPoolAddress: (cpmm: Address, ammConfig: Address, mintA: Address, mintB: Address) => Promise<Address>;
+/**
+ * `["creator_fee_share", creator, amm_config]`. Where CPMM tracks what one creator is owed under
+ * one fee tier.
+ *
+ * `collect_creator_fee` takes this account after the fourteen the mainnet IDL lists. That snapshot
+ * predates the account; Raydium's devnet build declares it and stops with `AccountNotEnoughKeys`
+ * (3005) when it is missing. One account per creator per fee tier, not one per pool.
+ */
+declare const cpmmCreatorFeeShare: (cpmm: Address, creator: Address, ammConfig: Address) => Promise<Address>;
+/** An associated token account. Off-curve owners are allowed: pool PDAs are all off-curve. */
+declare const ata: (owner: Address, mint: Address, tokenProgram?: Address) => Promise<Address>;
+//#endregion
+//#region src/raydium/quote.d.ts
+/** LaunchLab's settings for one quote, and the address they were read from. */
+type QuoteConfig = LaunchlabGlobalConfig & {
+  /** `["global_config", quote_mint, u8 0, u16 big-endian 0]` under LaunchLab. */
+  address: Address;
+};
+/** Everything a pool, a price and an account list need to know about a quote asset. */
+type QuoteAsset = {
+  mint: Address;
+  /** The LaunchLab global config `initialize_pool` proves the quote with. */
+  config: Address;
+  /** Classic SPL Token, or Token-2022. The user's quote ATA lives under it. */
+  tokenProgram: Address;
+  decimals: number;
+  /** From Metaplex, or from the Token-2022 metadata extension. `null` when the mint has none. */
+  symbol: string | null;
+  /** Raydium's own share of every curve trade, out of 1,000,000. */
+  tradeFeeRate: bigint;
+  /** The quote LaunchLab keeps at graduation. The starting reserves depend on it. */
+  migrateFee: bigint;
+  /** The smallest `raise` LaunchLab accepts for this quote, in the quote's base units. */
+  minQuoteFundRaising: bigint;
+};
+/**
+ * LaunchLab's global config for one quote mint, or `null` when Raydium enabled no such quote.
+ *
+ * Index 0 is the usual config, and the constant-product curve is the only shape Gabox launches, so
+ * those two are fixed here. The decoded `quoteMint` has to be the mint asked for: a config for a
+ * different quote would price the wrong asset.
+ */
+declare function fetchQuoteConfig(client: GaboxClient, mint: Address, ids?: RaydiumIds): Promise<QuoteConfig | null>;
+/** Can a Gabox machine be quoted in this mint? One account read. */
+declare function isQuoteSupported(client: GaboxClient, mint: Address): Promise<boolean>;
+/**
+ * The full quote asset: its LaunchLab config, its token program, its decimals and its symbol.
+ *
+ * Two round trips. The first reads the global config, because the config address is derived from
+ * the mint. The second reads the mint and its Metaplex metadata account together.
+ *
+ * Throws when Raydium has no config for the mint, because no pool can be created or traded then.
+ */
+declare function fetchQuoteAsset(client: GaboxClient, mint: Address, ids?: RaydiumIds): Promise<QuoteAsset>;
+/** What a price display needs about a quote mint: its program, its decimals and its symbol. */
+type QuoteDisplay = {
+  tokenProgram: Address;
+  decimals: number;
+  symbol: string | null;
+};
+/**
+ * Read a quote mint and its Metaplex metadata in one call.
+ *
+ * A Token-2022 mint may carry its own `TokenMetadata` extension, and that one wins: it is the
+ * issuer's own record. A classic SPL mint keeps its symbol in a Metaplex account, and a mint with
+ * neither reports `null`.
+ */
+declare function fetchQuoteDisplay(client: GaboxClient, mint: Address): Promise<QuoteDisplay>;
+//#endregion
+//#region src/raydium/read.d.ts
+/** An account that may not exist, with its raw bytes and its owning program. */
+type MaybeAccount$1 = {
+  data: Uint8Array;
+  owner: Address;
+} | null;
+/** Read several accounts in one call. A missing account comes back as `null`, not as an error. */
+declare function readAccounts(rpc: GaboxRpc, addresses: Address[]): Promise<MaybeAccount$1[]>;
+/** Decode one base64 account payload the RPC returned inside another shape. */
+declare const decodeBase64: (encoded: string) => Uint8Array;
+//#endregion
+//#region src/raydium/trade.d.ts
+type CurveBuyExactInInput = {
+  mint: Address;
+  /** The coin creator, so the creator fee vault can be derived. Read it off the pool. */
+  creator: Address;
+  /** The wallet spending. It signs, and its quote ATA must already hold `quoteIn`. */
+  user: TransactionSigner;
+  /** Quote token to spend, fees included. */
+  quoteIn: bigint;
+  /** The floor on the coins received. Use `curveBuyExactIn` from `curve.ts` to compute it. */
+  minTokensOut: bigint;
+  /** The pool's quote mint. Defaults to wrapped SOL. */
+  quoteMint?: Address;
+  /** The quote mint's token program. Defaults to classic SPL Token, which is what WSOL uses. */
+  quoteTokenProgram?: Address;
+};
+/**
+ * `buy_exact_in` on the curve: spend exactly `quoteIn` of the quote token and take whatever coins
+ * it buys.
+ *
+ * LaunchLab caps the trade at what the curve has left to sell, so a spend larger than the rest of
+ * the raise still succeeds and graduates the coin. Fund the user's quote ATA first. On a WSOL pool
+ * that means wrapping the SOL and closing the account afterwards, the same way the Gabox builders
+ * do.
+ */
+declare function getCurveBuyExactInInstruction(client: GaboxClient, input: CurveBuyExactInInput, ids?: RaydiumIds): Promise<Instruction>;
+declare namespace index_d_exports {
+  export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, CONSTANT_CURVE_TAG, CPMM_AMM_CONFIG_DISCRIMINATOR, CPMM_AMM_CONFIG_HEAD_SIZE, CPMM_COLLECT_CREATOR_FEE, CPMM_POOL_OFFSETS, CPMM_POOL_STATE_DISCRIMINATOR, CPMM_POOL_STATE_HEAD_SIZE, CPMM_POOL_STATE_SIZE, CPMM_SEEDS, CPMM_SWAP_BASE_INPUT, CPMM_SWAP_BASE_OUTPUT, CREATOR_FEE_ON_QUOTE, ClaimCreatorFeeInput, CollectCreatorFeeInput, CpmmAmmConfig, CpmmFeeRates, CpmmPoolState, CpmmSwapSides, CpmmTradeAccountsInput, CreatorFees, CurveBuyExactInInput, CurveFeeRates, CurveReserves, CurveSettings, FindCpmmPoolOptions, LAUNCHLAB_BUY_EXACT_IN, LAUNCHLAB_BUY_EXACT_OUT, LAUNCHLAB_CLAIM_CREATOR_FEE, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR, LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE, LAUNCHLAB_INITIALIZE, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR, LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE, LAUNCHLAB_POOL_STATE_DISCRIMINATOR, LAUNCHLAB_POOL_STATE_HEAD_SIZE, LAUNCHLAB_SEEDS, LAUNCHLAB_SELL_EXACT_IN, LAUNCHLAB_STATUS_FUND, LAUNCHLAB_STATUS_MIGRATE, LAUNCHLAB_STATUS_TRADE, LAUNCH_DECIMALS, LAUNCH_SUPPLY, LAUNCH_TOTAL_BASE_SELL, LaunchInput, LaunchParams, LaunchlabGlobalConfig, LaunchlabPlatformConfig, LaunchlabPoolState, LaunchlabTradeAccountsInput, METADATA_LIMITS, METADATA_SEED, METAPLEX_PROGRAM_ADDRESS, MIGRATE_TO_CPMM, MaybeAccount$1 as MaybeAccount, MigratedCpmmPool, PLATFORM_ADMIN, QuoteAsset, QuoteBinding, QuoteConfig, QuoteDisplay, RATE_DENOMINATOR, RAYDIUM_DEVNET_IDS, RAYDIUM_IDS, RAYDIUM_MAINNET_IDS, RENT_SYSVAR_ADDRESS, RaydiumClusterIds, RaydiumIds, ResolveVenueOptions, ResolvedVenue, SHARE_FEE_RATE, SYSTEM_PROGRAM_ADDRESS, TOKEN_2022_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, VenueAccountSpec, VenueInstructionAbi, VenueKind, WSOL_MINT, ata, ceilDiv, ceilDivRate, claimCreatorFee, collectCreatorFee, compareAddresses, cpmmAuthority, cpmmBuyAccounts, cpmmCreatorFeeShare, cpmmPoolAddress, cpmmPoolMatches, cpmmSellAccounts, cpmmSwapBaseInput, cpmmSwapBaseOutput, creatorFeeOnInput, creatorFeeVaultAddress, creatorFeeVaultAuthority, curveBuyExactIn, curveBuyExactOut, curveQuote, curveSellExactIn, decodeBase64, decodeCpmmAmmConfig, decodeCpmmPool, decodeLaunchlabGlobalConfig, decodeLaunchlabPlatformConfig, decodeLaunchlabPool, fetchCreatorFees, fetchCurveSettings, fetchQuoteAsset, fetchQuoteBinding, fetchQuoteConfig, fetchQuoteDisplay, findCpmmPool, getClaimCreatorFeeInstructions, getCollectCreatorFeeInstructions, getCurveBuyExactInInstruction, getLaunchInstruction, initialCurve, isQuoteSupported, launchlabAuthority, launchlabBuyAccounts, launchlabBuyExactInAccounts, launchlabEventAuthority, launchlabGlobalConfig, launchlabPlatformConfig, launchlabPoolAddress, launchlabSellAccounts, launchlabVaultAddress, metadataAddress, metaplexSymbol, mintDecimals, newCurveBuyCost, newCurveReserves, order, platformFeeVaultAddress, preFeeAmount, quoteAccountFor, raydiumIds, readAccounts, remainingBase, resolveVenue, sellQuote, sortedMints, token2022Symbol, tokenAccountAmount, tokenAccountOwnerAndMint, totalCurveFeeRate, wsolAccountFor };
+}
+//#endregion
+export { QuoteBinding as $, assertClusterUrl as $n, CONSTANT_CURVE_TAG as $t, ClaimCreatorFeeInput as A, LAUNCHLAB_SELL_EXACT_IN as An, totalCurveFeeRate as At, cpmmBuyAccounts as B, TOKEN_2022_PROGRAM_ADDRESS as Bn, LaunchlabGlobalConfig as Bt, launchlabPlatformConfig as C, LAUNCHLAB_BUY_EXACT_IN as Cn, cpmmSwapBaseOutput as Ct, platformFeeVaultAddress as D, LAUNCHLAB_INITIALIZE as Dn, initialCurve as Dt, metadataAddress as E, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR as En, curveSellExactIn as Et, fetchCreatorFees as F, RAYDIUM_DEVNET_IDS as Fn, CpmmAmmConfig as Ft, order as G, CLUSTER_ENDPOINTS as Gn, decodeLaunchlabGlobalConfig as Gt, launchlabBuyAccounts as H, VenueAccountSpec as Hn, LaunchlabPoolState as Ht, getClaimCreatorFeeInstructions as I, RAYDIUM_MAINNET_IDS as In, CpmmPoolState as It, buildMessage as J, DEVNET_HTTP as Jn, metaplexSymbol as Jt, BuildOptions as K, ClientConfig as Kn, decodeLaunchlabPlatformConfig as Kt, getCollectCreatorFeeInstructions as L, RENT_SYSVAR_ADDRESS as Ln, LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE as Lt, CreatorFees as M, LAUNCH_TOTAL_BASE_SELL as Mn, CPMM_POOL_OFFSETS as Mt, claimCreatorFee as N, METAPLEX_PROGRAM_ADDRESS as Nn, CPMM_POOL_STATE_HEAD_SIZE as Nt, LaunchInput as O, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR as On, preFeeAmount as Ot, collectCreatorFee as P, PLATFORM_ADMIN as Pn, CPMM_POOL_STATE_SIZE as Pt, MigratedCpmmPool as Q, GaboxRpcSubscriptions as Qn, tokenAccountOwnerAndMint as Qt, CpmmTradeAccountsInput as R, RaydiumClusterIds as Rn, LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE as Rt, launchlabGlobalConfig as S, CPMM_SWAP_BASE_OUTPUT as Sn, cpmmSwapBaseInput as St, launchlabVaultAddress as T, LAUNCHLAB_CLAIM_CREATOR_FEE as Tn, curveBuyExactOut as Tt, launchlabBuyExactInAccounts as U, VenueInstructionAbi as Un, decodeCpmmAmmConfig as Ut, cpmmSellAccounts as V, TOKEN_PROGRAM_ADDRESS as Vn, LaunchlabPlatformConfig as Vt, launchlabSellAccounts as W, WSOL_MINT as Wn, decodeCpmmPool as Wt, CurveSettings as X, GaboxClient as Xn, token2022Symbol as Xt, withRemainingAccounts as Y, DEVNET_WS as Yn, mintDecimals as Yt, FindCpmmPoolOptions as Z, GaboxRpc as Zn, tokenAccountAmount as Zt, cpmmPoolAddress as _, ASSOCIATED_TOKEN_PROGRAM_ADDRESS as _n, CurveFeeRates as _t, decodeBase64 as a, LAUNCHLAB_STATUS_TRADE as an, RouteMode as ar, curveQuote as at, launchlabAuthority as b, CPMM_POOL_STATE_DISCRIMINATOR as bn, ceilDiv as bt, QuoteConfig as c, METADATA_SEED as cn, findCpmmPool as ct, fetchQuoteConfig as d, RAYDIUM_IDS as dn, quoteAccountFor as dt, CPMM_SEEDS as en, clusterNamedBy as er, ResolveVenueOptions as et, fetchQuoteDisplay as f, RaydiumIds as fn, resolveVenue as ft, cpmmCreatorFeeShare as g, sortedMints as gn, CpmmSwapSides as gt, cpmmAuthority as h, raydiumIds as hn, CpmmFeeRates as ht, MaybeAccount$1 as i, LAUNCHLAB_STATUS_MIGRATE as in, Route as ir, creatorFeeOnInput as it, CollectCreatorFeeInput as j, LAUNCH_SUPPLY as jn, CPMM_AMM_CONFIG_HEAD_SIZE as jt, getLaunchInstruction as k, LAUNCHLAB_POOL_STATE_DISCRIMINATOR as kn, remainingBase as kt, QuoteDisplay as l, MIGRATE_TO_CPMM as ln, newCurveBuyCost as lt, ata as m, compareAddresses as mn, wsolAccountFor as mt, CurveBuyExactInInput as n, LAUNCHLAB_SEEDS as nn, defaultRoute as nr, VenueKind as nt, readAccounts as o, LAUNCH_DECIMALS as on, RouteProvider as or, fetchCurveSettings as ot, isQuoteSupported as p, SHARE_FEE_RATE as pn, sellQuote as pt, GaboxTransactionMessage as q, Cluster as qn, decodeLaunchlabPool as qt, getCurveBuyExactInInstruction as r, LAUNCHLAB_STATUS_FUND as rn, websocketUrlFor as rr, cpmmPoolMatches as rt, QuoteAsset as s, METADATA_LIMITS as sn, fetchQuoteBinding as st, index_d_exports as t, CREATOR_FEE_ON_QUOTE as tn, createClient as tr, ResolvedVenue as tt, fetchQuoteAsset as u, RATE_DENOMINATOR as un, newCurveReserves as ut, creatorFeeVaultAddress as v, CPMM_AMM_CONFIG_DISCRIMINATOR as vn, CurveReserves as vt, launchlabPoolAddress as w, LAUNCHLAB_BUY_EXACT_OUT as wn, curveBuyExactIn as wt, launchlabEventAuthority as x, CPMM_SWAP_BASE_INPUT as xn, ceilDivRate as xt, creatorFeeVaultAuthority as y, CPMM_COLLECT_CREATOR_FEE as yn, LaunchParams as yt, LaunchlabTradeAccountsInput as z, SYSTEM_PROGRAM_ADDRESS as zn, LAUNCHLAB_POOL_STATE_HEAD_SIZE as zt };
+//# sourceMappingURL=index-C4at2cZ_.d.ts.map