@gabox-labs/sdk 0.2.0 → 0.6.0

package/dist/index-BDfGvmgF.d.ts

@@ -0,0 +1,934 @@
+import { AccountMeta, Address, AddressesByLookupTableAddress, Instruction, Rpc, RpcSubscriptions, SolanaRpcApi, SolanaRpcSubscriptionsApi, TransactionMessage, TransactionMessageWithBlockhashLifetime, TransactionMessageWithFeePayerSigner, TransactionSigner } from "@solana/kit";
+//#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;
+};
+/**
+ * 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 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;
+//#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, and so does the quote the curve must raise.
+ */
+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(["global_config", WSOL, u8 0, u16 big-endian 0], launchlab). Holds the curve settings. */
+  readonly solGlobalConfig: 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 quote the curve must raise before the coin graduates, in lamports.
+   *
+   * There is no fee tier here on purpose. The Gabox platform config names the CPMM fee tier a coin
+   * graduates into, and a migrated pool records it again in its own data. Both are read from the
+   * chain, never compiled in.
+   */
+  readonly launchQuoteRaise: bigint;
+};
+declare const RAYDIUM_MAINNET_IDS: RaydiumClusterIds;
+declare const RAYDIUM_DEVNET_IDS: RaydiumClusterIds;
+/** Wrapped SOL. The only quote Gabox accepts today, on both venues. */
+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. LaunchLab pins it on both sides of every Gabox launch and trade. */
+declare const TOKEN_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 WSOL. */
+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 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. Gabox reads the trade fee and the migrate fee. */
+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;
+  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';
+/** 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 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[];
+  /** WSOL an exact-coins-out buy of `tokens` costs right now, the venue's fees included. */
+  quoteBuy(tokens: bigint): bigint;
+  /** WSOL 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 user's WSOL associated token account.
+ *
+ * Both venues settle in WSOL, never in native SOL. This account must exist and hold enough before a
+ * pack is bought, and sale proceeds land in it. Every builder in `tx/` wraps the SOL it needs into
+ * this account and closes it again in the same transaction.
+ */
+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 two pinned config accounts and take the four numbers a quote needs out of them. */
+declare function fetchCurveSettings(client: GaboxClient, 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;
+  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 WSOL only: on the input of a buy, on the output of a sale.
+ */
+declare function creatorFeeOnInput(pool: CpmmPoolState, inputMint: Address): boolean;
+/**
+ * WSOL 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;
+}): Promise<bigint>;
+/** WSOL 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;
+}): Promise<bigint>;
+/**
+ * WSOL 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): Promise<bigint>;
+/** The starting reserves of a brand-new Gabox curve on this cluster. */
+declare function newCurveReserves(ids: RaydiumIds, 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 WSOL ATA. Both venues settle here. */
+  userQuoteToken: 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;
+};
+/** `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: create the WSOL account, claim, close it.
+ *
+ * This sweeps **every** coin this wallet launched, because LaunchLab keeps one vault per wallet per
+ * quote asset. There is no per-coin version.
+ */
+declare function getClaimCreatorFeeInstructions(creator: TransactionSigner, ids: RaydiumIds): Promise<Instruction[]>;
+type ClaimCreatorFeeInput = {
+  creator: TransactionSigner;
+} & Partial<BuildOptions>;
+/**
+ * Claim the curve creator fee and receive it as SOL.
+ *
+ * One transaction, three instructions. It sweeps every coin this wallet launched on LaunchLab.
+ */
+declare function claimCreatorFee(client: GaboxClient, input: ClaimCreatorFeeInput): Promise<GaboxTransactionMessage>;
+/**
+ * The instructions of a graduated coin's fee collection: create the WSOL account, collect, close.
+ *
+ * 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.
+ */
+declare function getCollectCreatorFeeInstructions(client: GaboxClient, input: {
+  mint: Address;
+  creator: TransactionSigner;
+}, ids?: RaydiumIds): Promise<Instruction[]>;
+type CollectCreatorFeeInput = {
+  mint: Address;
+  creator: TransactionSigner;
+} & Partial<BuildOptions>;
+/** Collect one graduated coin's CPMM creator fee and receive the WSOL side as SOL. */
+declare function collectCreatorFee(client: GaboxClient, input: CollectCreatorFeeInput): Promise<GaboxTransactionMessage>;
+/** What a creator can collect right now. Every amount is in base units. */
+type CreatorFees = {
+  /** WSOL waiting in the LaunchLab creator fee vault, across every coin this wallet launched. */
+  curveLamports: bigint;
+  /**
+   * WSOL the migrated CPMM pool of `mint` owes this creator. `0n` when the coin has not graduated,
+   * and `0n` when no `mint` was passed.
+   */
+  cpmmLamports: 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.
+ *
+ * `mint` is optional. Without it only the curve vault is read, which is the one number that covers
+ * every coin 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;
+}): 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;
+};
+/**
+ * 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/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 WSOL ATA must already hold `quoteIn`. */
+  user: TransactionSigner;
+  /** WSOL to spend, fees included. */
+  quoteIn: bigint;
+  /** The floor on the coins received. Use `curveBuyExactIn` from `curve.ts` to compute it. */
+  minTokensOut: bigint;
+};
+/**
+ * `buy_exact_in` on the curve: spend exactly `quoteIn` WSOL 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. Wrap the SOL into the user's WSOL ATA first and
+ * close it 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, MigratedCpmmPool, PLATFORM_ADMIN, RATE_DENOMINATOR, RAYDIUM_DEVNET_IDS, RAYDIUM_IDS, RAYDIUM_MAINNET_IDS, RENT_SYSVAR_ADDRESS, RaydiumClusterIds, RaydiumIds, ResolveVenueOptions, ResolvedVenue, SHARE_FEE_RATE, SYSTEM_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, decodeCpmmAmmConfig, decodeCpmmPool, decodeLaunchlabGlobalConfig, decodeLaunchlabPlatformConfig, decodeLaunchlabPool, fetchCreatorFees, fetchCurveSettings, findCpmmPool, getClaimCreatorFeeInstructions, getCollectCreatorFeeInstructions, getCurveBuyExactInInstruction, getLaunchInstruction, initialCurve, launchlabAuthority, launchlabBuyAccounts, launchlabBuyExactInAccounts, launchlabEventAuthority, launchlabGlobalConfig, launchlabPlatformConfig, launchlabPoolAddress, launchlabSellAccounts, launchlabVaultAddress, metadataAddress, newCurveBuyCost, newCurveReserves, order, platformFeeVaultAddress, preFeeAmount, raydiumIds, remainingBase, resolveVenue, sellQuote, sortedMints, tokenAccountAmount, tokenAccountOwnerAndMint, totalCurveFeeRate, wsolAccountFor };
+}
+//#endregion
+export { resolveVenue as $, raydiumIds as $t, cpmmBuyAccounts as A, Cluster as An, decodeCpmmAmmConfig as At, CurveSettings as B, LAUNCHLAB_SEEDS as Bt, claimCreatorFee as C, SYSTEM_PROGRAM_ADDRESS as Cn, CpmmPoolState as Ct, getCollectCreatorFeeInstructions as D, WSOL_MINT as Dn, LaunchlabGlobalConfig as Dt, getClaimCreatorFeeInstructions as E, VenueInstructionAbi as En, LAUNCHLAB_POOL_STATE_HEAD_SIZE as Et, order as F, GaboxRpcSubscriptions as Fn, tokenAccountAmount as Ft, VenueKind as G, METADATA_LIMITS as Gt, MigratedCpmmPool as H, LAUNCHLAB_STATUS_MIGRATE as Ht, BuildOptions as I, assertClusterUrl as In, tokenAccountOwnerAndMint as It, curveQuote as J, RATE_DENOMINATOR as Jt, cpmmPoolMatches as K, METADATA_SEED as Kt, GaboxTransactionMessage as L, clusterNamedBy as Ln, CONSTANT_CURVE_TAG as Lt, launchlabBuyAccounts as M, DEVNET_WS as Mn, decodeLaunchlabGlobalConfig as Mt, launchlabBuyExactInAccounts as N, GaboxClient as Nn, decodeLaunchlabPlatformConfig as Nt, CpmmTradeAccountsInput as O, CLUSTER_ENDPOINTS as On, LaunchlabPlatformConfig as Ot, launchlabSellAccounts as P, GaboxRpc as Pn, decodeLaunchlabPool as Pt, newCurveReserves as Q, compareAddresses as Qt, buildMessage as R, createClient as Rn, CPMM_SEEDS as Rt, CreatorFees as S, RaydiumClusterIds as Sn, CpmmAmmConfig as St, fetchCreatorFees as T, VenueAccountSpec as Tn, LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE as Tt, ResolveVenueOptions as U, LAUNCHLAB_STATUS_TRADE as Ut, FindCpmmPoolOptions as V, LAUNCHLAB_STATUS_FUND as Vt, ResolvedVenue as W, LAUNCH_DECIMALS as Wt, findCpmmPool as X, RaydiumIds as Xt, fetchCurveSettings as Y, RAYDIUM_IDS as Yt, newCurveBuyCost as Z, SHARE_FEE_RATE as Zt, platformFeeVaultAddress as _, METAPLEX_PROGRAM_ADDRESS as _n, totalCurveFeeRate as _t, cpmmAuthority as a, CPMM_SWAP_BASE_INPUT as an, CurveReserves as at, ClaimCreatorFeeInput as b, RAYDIUM_MAINNET_IDS as bn, CPMM_POOL_STATE_HEAD_SIZE as bt, creatorFeeVaultAddress as c, LAUNCHLAB_BUY_EXACT_OUT as cn, ceilDivRate as ct, launchlabEventAuthority as d, LAUNCHLAB_INITIALIZE as dn, curveBuyExactIn as dt, sortedMints as en, sellQuote as et, launchlabGlobalConfig as f, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR as fn, curveBuyExactOut as ft, metadataAddress as g, LAUNCH_TOTAL_BASE_SELL as gn, remainingBase as gt, launchlabVaultAddress as h, LAUNCH_SUPPLY as hn, preFeeAmount as ht, ata as i, CPMM_POOL_STATE_DISCRIMINATOR as in, CurveFeeRates as it, cpmmSellAccounts as j, DEVNET_HTTP as jn, decodeCpmmPool as jt, LaunchlabTradeAccountsInput as k, ClientConfig as kn, LaunchlabPoolState as kt, creatorFeeVaultAuthority as l, LAUNCHLAB_CLAIM_CREATOR_FEE as ln, cpmmSwapBaseInput as lt, launchlabPoolAddress as m, LAUNCHLAB_SELL_EXACT_IN as mn, initialCurve as mt, CurveBuyExactInInput as n, CPMM_AMM_CONFIG_DISCRIMINATOR as nn, CpmmFeeRates as nt, cpmmCreatorFeeShare as o, CPMM_SWAP_BASE_OUTPUT as on, LaunchParams as ot, launchlabPlatformConfig as p, LAUNCHLAB_POOL_STATE_DISCRIMINATOR as pn, curveSellExactIn as pt, creatorFeeOnInput as q, MIGRATE_TO_CPMM as qt, getCurveBuyExactInInstruction as r, CPMM_COLLECT_CREATOR_FEE as rn, CpmmSwapSides as rt, cpmmPoolAddress as s, LAUNCHLAB_BUY_EXACT_IN as sn, ceilDiv as st, index_d_exports as t, ASSOCIATED_TOKEN_PROGRAM_ADDRESS as tn, wsolAccountFor as tt, launchlabAuthority as u, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR as un, cpmmSwapBaseOutput as ut, LaunchInput as v, PLATFORM_ADMIN as vn, CPMM_AMM_CONFIG_HEAD_SIZE as vt, collectCreatorFee as w, TOKEN_PROGRAM_ADDRESS as wn, LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE as wt, CollectCreatorFeeInput as x, RENT_SYSVAR_ADDRESS as xn, CPMM_POOL_STATE_SIZE as xt, getLaunchInstruction as y, RAYDIUM_DEVNET_IDS as yn, CPMM_POOL_OFFSETS as yt, withRemainingAccounts as z, websocketUrlFor as zn, CREATOR_FEE_ON_QUOTE as zt };
+//# sourceMappingURL=index-BDfGvmgF.d.ts.map