@gabox-labs/sdk 0.2.0 → 0.7.0

package/dist/raydium-CU-tZzIk.js

@@ -0,0 +1,3282 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { Dt as POOL_DISCRIMINATOR, Et as getWalletActivitySize, Jt as getDrawSize, Lt as getPoolSize, Ot as decodePool, Rt as DRAW_DISCRIMINATOR, _t as decodeWalletActivity, ft as findPoolPda, ht as findActivityPda, mt as findDrawPda, pt as findIdentityPda, t as GABOX_PROGRAM_ADDRESS, zt as decodeDraw } from "./gabox-DGTCh34U.js";
+import { AccountRole, Endian, addEncoderSizePrefix, appendTransactionMessageInstructions, compileTransaction, compressTransactionMessageUsingAddressLookupTables, createTransactionMessage, fetchEncodedAccount, fixDecoderSize, getAddressDecoder, getAddressEncoder, getBase58Decoder, getBase64Encoder, getBooleanDecoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, getTransactionEncoder, getU16Decoder, getU16Encoder, getU32Encoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, getUtf8Encoder, pipe, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash } from "@solana/kit";
+import { getCloseAccountInstruction, getCreateAssociatedTokenIdempotentInstruction } from "@solana-program/token";
+//#region src/raydium/abi.ts
+const RAYDIUM_MAINNET_IDS = {
+	launchlab: "LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj",
+	launchlabAuthority: "WLHv2UAZm6z4KyaaELi5pjdbJh6RESMva1Rnn8pJVVh",
+	launchlabEventAuthority: "2DPAtwB8L12vrMRExbLuyGnC7n2J5LNoZQSejeQGpwkr",
+	gaboxPlatform: "8tXUG97CEpSKTNXdGtanYyC33RWmTTuSin4VdaWwNj8q",
+	cpmm: "CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C",
+	cpmmAuthority: "GpMZbSM2GgvTKHJirzeGfMFoaZ8UR2X7F4v8vHTvxFbL",
+	launchQuoteRaise: 85000000000n
+};
+const RAYDIUM_DEVNET_IDS = {
+	launchlab: "DRay6fNdQ5J82H7xV6uq2aV3mNrUZ1J4PgSKsWgptcm6",
+	launchlabAuthority: "5xqNaZXX5eUi4p5HU4oz9i5QnwRNT2y6oN7yyn4qENeq",
+	launchlabEventAuthority: "4uAB7seenFJKPUXqYewAdfra2u6baBgjiXU8x1SC7Ycz",
+	gaboxPlatform: "DdEeCPXbCAzHE2PZSoR3RZng4WA4bSztrezQznrJ4ooB",
+	cpmm: "DRaycpLY18LhpbydsBWbVJtxpNv9oXPgjRSfpF2bWpYb",
+	cpmmAuthority: "CXniRufdq5xL8t8jZAPxsPZDpuudwuJSPWnbcD5Y5Nxq",
+	launchQuoteRaise: 3000000000n
+};
+/**
+* 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.
+*/
+const WSOL_MINT = "So11111111111111111111111111111111111111112";
+/** Metaplex Token Metadata, which LaunchLab's create instruction writes to. */
+const METAPLEX_PROGRAM_ADDRESS = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
+/**
+* `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.
+*/
+const PLATFORM_ADMIN = "5WcPTEQ59UqpQzjZUPbU8QRGCbj7NeQNLDa7DbsLkLKT";
+/** The coin supply every Gabox launch mints: 1,000,000,000 coins at 6 decimals. */
+const LAUNCH_SUPPLY = 1000000000000000n;
+/** The part of the supply the LaunchLab curve sells: 793,100,000 coins. */
+const LAUNCH_TOTAL_BASE_SELL = 793100000000000n;
+/** Classic SPL Token. The base coin is always under it, on both venues. */
+const TOKEN_PROGRAM_ADDRESS = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+/**
+* 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.
+*/
+const TOKEN_2022_PROGRAM_ADDRESS = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+const ASSOCIATED_TOKEN_PROGRAM_ADDRESS = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+const SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
+/** The rent sysvar. LaunchLab's create instruction still takes it. */
+const RENT_SYSVAR_ADDRESS = "SysvarRent111111111111111111111111111111111";
+/**
+* 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.
+*/
+const LAUNCHLAB_POOL_STATE_DISCRIMINATOR = new Uint8Array([
+	247,
+	237,
+	227,
+	245,
+	215,
+	195,
+	222,
+	70
+]);
+const LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR = new Uint8Array([
+	149,
+	8,
+	156,
+	202,
+	160,
+	252,
+	176,
+	217
+]);
+const LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR = new Uint8Array([
+	160,
+	78,
+	128,
+	0,
+	248,
+	83,
+	230,
+	160
+]);
+const CPMM_POOL_STATE_DISCRIMINATOR = new Uint8Array([
+	247,
+	237,
+	227,
+	245,
+	215,
+	195,
+	222,
+	70
+]);
+const CPMM_AMM_CONFIG_DISCRIMINATOR = new Uint8Array([
+	218,
+	244,
+	33,
+	104,
+	203,
+	203,
+	43,
+	111
+]);
+/**
+* `initialize_v2` on `LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj` — cross-checked against interfaces.json.
+*/
+const LAUNCHLAB_INITIALIZE = {
+	name: "initialize_v2",
+	discriminator: new Uint8Array([
+		67,
+		153,
+		175,
+		39,
+		218,
+		16,
+		38,
+		32
+	]),
+	accounts: [
+		{
+			name: "payer",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "creator",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "global_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "platform_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "pool_state",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "base_mint",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "quote_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "base_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "quote_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "metadata_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "base_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "metadata_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "system_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "rent_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "event_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "program",
+			writable: false,
+			signer: false
+		}
+	]
+};
+/**
+* `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.
+*/
+const LAUNCHLAB_BUY_EXACT_IN = {
+	name: "buy_exact_in",
+	discriminator: new Uint8Array([
+		250,
+		234,
+		13,
+		123,
+		213,
+		156,
+		19,
+		236
+	]),
+	accounts: [
+		{
+			name: "payer",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "global_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "platform_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "pool_state",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "user_base_token",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "user_quote_token",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "base_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "quote_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "base_token_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_token_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "base_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "event_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "system_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "platform_fee_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "creator_fee_vault",
+			writable: true,
+			signer: false
+		}
+	]
+};
+/**
+* `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.
+*/
+const LAUNCHLAB_BUY_EXACT_OUT = {
+	name: "buy_exact_out",
+	discriminator: new Uint8Array([
+		24,
+		211,
+		116,
+		40,
+		105,
+		3,
+		153,
+		56
+	]),
+	accounts: [
+		{
+			name: "payer",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "global_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "platform_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "pool_state",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "user_base_token",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "user_quote_token",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "base_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "quote_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "base_token_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_token_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "base_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "event_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "system_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "platform_fee_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "creator_fee_vault",
+			writable: true,
+			signer: false
+		}
+	]
+};
+/**
+* `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.
+*/
+const LAUNCHLAB_SELL_EXACT_IN = {
+	name: "sell_exact_in",
+	discriminator: new Uint8Array([
+		149,
+		39,
+		222,
+		155,
+		211,
+		124,
+		152,
+		26
+	]),
+	accounts: [
+		{
+			name: "payer",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "global_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "platform_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "pool_state",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "user_base_token",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "user_quote_token",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "base_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "quote_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "base_token_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_token_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "base_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "quote_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "event_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "system_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "platform_fee_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "creator_fee_vault",
+			writable: true,
+			signer: false
+		}
+	]
+};
+/**
+* `claim_creator_fee` on `LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj` — not in interfaces.json (the program never builds it).
+*/
+const LAUNCHLAB_CLAIM_CREATOR_FEE = {
+	name: "claim_creator_fee",
+	discriminator: new Uint8Array([
+		26,
+		97,
+		138,
+		203,
+		132,
+		171,
+		141,
+		252
+	]),
+	accounts: [
+		{
+			name: "creator",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "fee_vault_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "creator_fee_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "recipient_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "quote_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "system_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "associated_token_program",
+			writable: false,
+			signer: false
+		}
+	]
+};
+/**
+* `swap_base_output` on `CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C` — cross-checked against interfaces.json.
+*/
+const CPMM_SWAP_BASE_OUTPUT = {
+	name: "swap_base_output",
+	discriminator: new Uint8Array([
+		55,
+		217,
+		98,
+		86,
+		163,
+		74,
+		180,
+		173
+	]),
+	accounts: [
+		{
+			name: "payer",
+			writable: false,
+			signer: true
+		},
+		{
+			name: "authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "amm_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "pool_state",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "input_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "output_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "input_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "output_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "input_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "output_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "input_token_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "output_token_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "observation_state",
+			writable: true,
+			signer: false
+		}
+	]
+};
+/**
+* `swap_base_input` on `CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C` — cross-checked against interfaces.json.
+*/
+const CPMM_SWAP_BASE_INPUT = {
+	name: "swap_base_input",
+	discriminator: new Uint8Array([
+		143,
+		190,
+		90,
+		218,
+		196,
+		30,
+		51,
+		222
+	]),
+	accounts: [
+		{
+			name: "payer",
+			writable: false,
+			signer: true
+		},
+		{
+			name: "authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "amm_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "pool_state",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "input_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "output_token_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "input_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "output_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "input_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "output_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "input_token_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "output_token_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "observation_state",
+			writable: true,
+			signer: false
+		}
+	]
+};
+/**
+* `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]).
+*/
+const CPMM_COLLECT_CREATOR_FEE = {
+	name: "collect_creator_fee",
+	discriminator: new Uint8Array([
+		20,
+		22,
+		86,
+		123,
+		198,
+		28,
+		219,
+		132
+	]),
+	accounts: [
+		{
+			name: "creator",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "pool_state",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "amm_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "token_0_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "token_1_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "vault_0_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "vault_1_mint",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "creator_token_0",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "creator_token_1",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "token_0_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "token_1_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "associated_token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "system_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "creator_fee_share",
+			writable: false,
+			signer: false
+		}
+	]
+};
+//#endregion
+//#region src/raydium/ids.ts
+/**
+* The Raydium addresses and launch numbers Gabox pins, per cluster.
+*
+* Mainnet and devnet run different Raydium deployments. Every program id and every PDA differs, and
+* so does the raise a WSOL-quoted curve must reach. So nothing here is a global: a caller passes the
+* cluster, which comes from `createClient({ cluster })`.
+*
+* None of these strings is typed in this file. `scripts/codegen.mjs` reads them out of the Rust
+* program's `programs/gabox/src/venue/ids.rs` and writes `abi.ts`. The Rust file is the source of
+* truth, because the program checks every one of these addresses on chain.
+* `test/raydium-pdas.test.ts` derives each PDA again and compares.
+*/
+const ADDRESS_ENCODER = getAddressEncoder();
+/**
+* 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.
+*/
+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.
+*/
+const RAYDIUM_IDS = {
+	"mainnet-beta": RAYDIUM_MAINNET_IDS,
+	devnet: RAYDIUM_DEVNET_IDS,
+	localnet: RAYDIUM_MAINNET_IDS
+};
+/** The Raydium deployment one cluster trades on. Throws for a cluster this SDK does not know. */
+function raydiumIds(cluster) {
+	const ids = RAYDIUM_IDS[cluster];
+	if (!ids) throw new Error(`unknown cluster ${JSON.stringify(cluster)}; expected 'devnet', 'mainnet-beta' or 'localnet'`);
+	return ids;
+}
+/** LaunchLab's PDA seeds, and the two Gabox coins are always sorted against. */
+const LAUNCHLAB_SEEDS = {
+	/** `["vault_auth_seed"]`. */
+	authority: "vault_auth_seed",
+	/** `["__event_authority"]`. */
+	eventAuthority: "__event_authority",
+	/** `["global_config", quote_mint, u8 curve_type, u16 big-endian index]`. */
+	globalConfig: "global_config",
+	/** `["platform_config", platform_admin]`. */
+	platformConfig: "platform_config",
+	/** `["pool", base_mint, quote_mint]`. */
+	pool: "pool",
+	/** `["pool_vault", pool_state, mint]`. */
+	vault: "pool_vault",
+	/** `["creator_fee_vault_auth_seed"]`, the authority over every creator fee vault. */
+	creatorFeeVaultAuthority: "creator_fee_vault_auth_seed"
+};
+/** CPMM's PDA seeds. */
+const CPMM_SEEDS = {
+	/** `["vault_and_lp_mint_auth_seed"]`. */
+	authority: "vault_and_lp_mint_auth_seed",
+	/** `["pool", amm_config, token_0_mint, token_1_mint]`, the mints sorted by byte order. */
+	pool: "pool",
+	/** `["pool_vault", pool_state, mint]`. */
+	vault: "pool_vault",
+	/** `["observation", pool_state]`. */
+	observation: "observation",
+	/** `["creator_fee_share", creator, amm_config]`. */
+	creatorFeeShare: "creator_fee_share"
+};
+/** Metaplex's metadata PDA seed: `["metadata", metaplex, mint]`. */
+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%.
+*/
+const RATE_DENOMINATOR = 1000000n;
+/** The share-fee receiver Gabox never passes, so its rate is always zero on every trade. */
+const SHARE_FEE_RATE = 0n;
+/** `CurveParams::Constant`, the only curve shape Gabox launches. */
+const CONSTANT_CURVE_TAG = 0;
+/** `migrate_type` 1: the coin graduates into a CPMM pool, not into an AMM pool. */
+const MIGRATE_TO_CPMM = 1;
+/** `AmmCreatorFeeOn::QuoteToken`, so the CPMM creator fee is paid in the pool's quote asset. */
+const CREATOR_FEE_ON_QUOTE = 0;
+/** LaunchLab pool `status`: still selling on the curve. */
+const LAUNCHLAB_STATUS_FUND = 0;
+/** LaunchLab pool `status`: the raise is complete and Raydium's bot is migrating the coin. */
+const LAUNCHLAB_STATUS_MIGRATE = 1;
+/** LaunchLab pool `status`: the coin has graduated and trades on its CPMM pool. */
+const LAUNCHLAB_STATUS_TRADE = 2;
+/** Metaplex's own limits on the three strings a creator picks, in UTF-8 bytes. */
+const METADATA_LIMITS = {
+	name: 32,
+	symbol: 10,
+	uri: 200
+};
+/** Raydium sorts a CPMM pair by raw address byte order. */
+function sortedMints(a, b) {
+	return compareAddresses(a, b) <= 0 ? [a, b] : [b, a];
+}
+/** Compare two addresses the way the runtime does: by their 32 raw bytes, not by base58 text. */
+function compareAddresses(a, b) {
+	const left = ADDRESS_ENCODER.encode(a);
+	const right = ADDRESS_ENCODER.encode(b);
+	for (let i = 0; i < 32; i++) {
+		const difference = (left[i] ?? 0) - (right[i] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
+//#endregion
+//#region src/ids.ts
+/** `declare_id!` in `programs/gabox/src/lib.rs`. */
+const GABOX_PROGRAM_ID = GABOX_PROGRAM_ADDRESS;
+/** MagicBlock's ephemeral VRF program. `vrf.rs` pins it and refuses any other. */
+const VRF_PROGRAM_ADDRESS = "Vrf1RNUjXmQGjmQrQLvJHs9SNkvDJEsRVFPkfSQUwGz";
+/**
+* MagicBlock's default oracle queue. The program pins this one address, so a pool creator cannot
+* point a draw at an oracle they control.
+*/
+const VRF_DEFAULT_QUEUE = "Cuj97ggrhhidhbu39TijNVqE74xvKJ69gDervRUXAxGh";
+/** The seed of both identity PDAs. See `pdas.ts` — there are two, under different programs. */
+const IDENTITY_SEED = new Uint8Array([
+	105,
+	100,
+	101,
+	110,
+	116,
+	105,
+	116,
+	121
+]);
+const SLOT_HASHES_SYSVAR = "SysvarS1otHashes111111111111111111111111111";
+const INSTRUCTIONS_SYSVAR = "Sysvar1nstructions1111111111111111111111111";
+/** `constants.rs`. A retry may not run sooner than this after the last attempt. */
+const RETRY_SLOTS = 300n;
+/** `constants.rs`. After this many slots from the purchase, anyone may expire the draw. */
+const TIMEOUT_SLOTS = 216000n;
+/** `constants.rs`. Three requests in total, counting the one `buy_pack` makes. */
+const MAX_ATTEMPTS = 3;
+/**
+* `constants.rs`. Tokens in one pack, in base units: 1,000,000 tokens at the fixed 6 decimals, or
+* 0.1% of the 1,000,000,000 supply. Every pool sells packs of this size. The venue decides what a
+* pack costs, so the pack price follows the coin. Read `pool.packTokens` rather than this when a
+* pool is at hand: a later program version may change the constant.
+*/
+const PACK_TOKENS = 1000000n * 1000000n;
+//#endregion
+//#region src/math.ts
+/**
+* A bigint port of `programs/gabox/src/math.rs`.
+*
+* The point is that a client can show a buyer the exact prize table the program will freeze into
+* their `Draw`, before they pay. Every rounding step here matches the Rust, including the direction
+* of each division. `test/math.test.ts` runs the same vectors as `programs/gabox/tests/math.rs`.
+*
+* All amounts are `bigint`, in the mint's smallest unit. `multiplierBps` and `tickets` are numbers
+* because both are `u32` in the program and both stay small.
+*/
+/** Basis points. A multiplier of 10_000 pays back exactly one pack. */
+const BPS = 10000n;
+/**
+* `constants::MIN_SEED_MULTIPLIER_BPS`. The mandatory seed makes a 3x top prize payable on the
+* first pack, or the full top prize when the table's top tier is below 3x. A creator can add more
+* seed on top through `extraSeedTokens`.
+*/
+const MIN_SEED_MULTIPLIER_BPS = 3e4;
+/**
+* `constants::MAX_MULTIPLIER_BPS`. A table's top tier can be at most 20x. Seed beyond what a 20x
+* prize needs stays in the vault as backup for the draws after a top-tier hit.
+*/
+const MAX_MULTIPLIER_BPS = 2e5;
+/** Ticket counts must sum to this. A uniform 16-bit word then maps with no modulo bias. */
+const TICKETS = 65536;
+/** The prize table has exactly this many slots. Unused slots are all-zero. */
+const TIERS = 8;
+/** Thrown by every function here. `code` matches a `GaboxError` variant name. */
+var GaboxMathError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(`${code}: ${message}`);
+		this.name = "GaboxMathError";
+		this.code = code;
+	}
+};
+const U64_MAX = (1n << 64n) - 1n;
+const U32_MAX = 4294967295;
+/**
+* The default prize table. The program does not enforce this table: it accepts any table that
+* passes `validateTiers`. This is only the table the Gabox app creates its pools with, and the
+* starting point for a client that has no reason to pick another one.
+*
+* Common 75% at 0.52x, Rare 20% at 1.2x, Epic 4% at 3x, Mythic 1% at 20x. Expected payout is
+* 0.9499x of a pack, so the seed is 19 packs.
+*/
+const DEFAULT_TIERS = Object.freeze([
+	Object.freeze({
+		multiplierBps: 5201,
+		tickets: 49153
+	}),
+	Object.freeze({
+		multiplierBps: 12e3,
+		tickets: 13107
+	}),
+	Object.freeze({
+		multiplierBps: 3e4,
+		tickets: 2621
+	}),
+	Object.freeze({
+		multiplierBps: 2e5,
+		tickets: 655
+	}),
+	Object.freeze({
+		multiplierBps: 0,
+		tickets: 0
+	}),
+	Object.freeze({
+		multiplierBps: 0,
+		tickets: 0
+	}),
+	Object.freeze({
+		multiplierBps: 0,
+		tickets: 0
+	}),
+	Object.freeze({
+		multiplierBps: 0,
+		tickets: 0
+	})
+]);
+function checkedU64(value, what) {
+	if (value < 0n || value > U64_MAX) throw new GaboxMathError("Arithmetic", `${what} does not fit in u64`);
+	return value;
+}
+/** Tier fields encode as program `u32`s. Reject JavaScript-only values before `BigInt` or codecs. */
+function checkedU32(value, what) {
+	if (!Number.isInteger(value) || value < 0 || value > U32_MAX) throw new GaboxMathError("InvalidDistribution", `${what} must be an integer from 0 to ${U32_MAX}`);
+	return value;
+}
+/** `math::tokens`. Floor division, and an overflow past u64 is an error, not a wrap. */
+function tierAmount(base, multiplierBps) {
+	return checkedU64(base * BigInt(checkedU32(multiplierBps, "multiplierBps")) / BPS, "tier amount");
+}
+/**
+* `math::validate`. Checks the table alone, with no base.
+*
+* Four rules, and each one closes a way to sell a bad ticket:
+*   - ticket counts sum to exactly 65,536, so the 16-bit draw is uniform;
+*   - an unused row is all-zero, so a hidden multiplier cannot ride along;
+*   - a ticketed tier's multiplier is from 1 to `MAX_MULTIPLIER_BPS` (20x);
+*   - the expected multiplier over all tickets is at most 1x, so the table cannot promise more
+*     tokens than a pack buys. This bounds tokens, not cash value.
+*/
+function validateTiers(tiers) {
+	if (tiers.length !== 8) throw new GaboxMathError("InvalidDistribution", `expected 8 tiers, got ${tiers.length}`);
+	let count = 0n;
+	let expected = 0n;
+	for (const [index, tier] of tiers.entries()) {
+		checkedU32(tier.tickets, `tier ${index} tickets`);
+		checkedU32(tier.multiplierBps, `tier ${index} multiplierBps`);
+		if (tier.tickets === 0) {
+			if (tier.multiplierBps !== 0) throw new GaboxMathError("InvalidDistribution", "a tier with no tickets must have no multiplier");
+			continue;
+		}
+		if (tier.multiplierBps <= 0) throw new GaboxMathError("InvalidDistribution", "a ticketed tier must pay something; it would sell a ticket that can only win zero");
+		if (tier.multiplierBps > 2e5) throw new GaboxMathError("InvalidDistribution", `tier ${index} multiplierBps exceeds the ${MAX_MULTIPLIER_BPS} maximum (20x)`);
+		count += BigInt(tier.tickets);
+		expected += BigInt(tier.multiplierBps) * BigInt(tier.tickets);
+	}
+	if (count !== BigInt(65536)) throw new GaboxMathError("InvalidDistribution", `tickets must sum to ${TICKETS}, they sum to ${count}`);
+	if (expected > 10000n * BigInt(65536)) throw new GaboxMathError("UnfundedExpectation", "the expected token award exceeds the tokens a pack buys");
+}
+/**
+* `math::validate_pack`. Every ticketed tier must pay at least one token for a pack of this size.
+*
+* The program checks this once at creation. At `PACK_TOKENS` no sane table fails it; it exists so
+* a table cannot sell a ticket that can only win zero.
+*/
+function validatePack(packTokens, tiers) {
+	if (packTokens <= 0n) throw new GaboxMathError("ZeroAmount", "packTokens must be positive");
+	checkedU64(packTokens, "pack tokens");
+	validateTiers(tiers);
+	for (const [i, tier] of tiers.entries()) {
+		if (tier.tickets === 0) continue;
+		if (tierAmount(packTokens, tier.multiplierBps) === 0n) throw new GaboxMathError("PackTooSmall", `tier ${i} rounds to zero tokens at this pack size`);
+	}
+}
+/**
+* `math::seed_tokens`. The mandatory seed a table needs, in tokens.
+*
+* The mandatory seed makes a 3x top prize payable on the first pack, or the full top prize when
+* the table's top tier is below 3x. A jackpot above 3x still shows the full table once later
+* packs grow the free vault; the mandatory seed alone does not have to fund it. The pack itself
+* brings `packTokens` into the vault, so the vault has to hold the rest beforehand:
+*
+*     seedTokens = min(uncappedMaximum(packTokens, tiers), tierAmount(packTokens, MIN_SEED_MULTIPLIER_BPS)) - packTokens
+*
+* A 20x or a 3x top tier on a 1M-token pack both need a 2M-token seed, since the mandatory seed
+* stops at the 3x minimum. A 2x top tier needs a 1M-token seed, already below the minimum. A
+* table whose top tier pays exactly one pack needs no seed. A top tier below one pack is refused:
+* every ticket would lose. `createMachine` lets a creator add more seed on top of this mandatory
+* amount through `extraSeedTokens`, for example to fund a top tier above 3x from the first pack.
+*
+* Pool initialization computes this number itself and buys exactly that many tokens on the curve.
+* The creator only signs a maximum SOL cost.
+*/
+function seedTokens(packTokens, tiers) {
+	validateTiers(tiers);
+	const largest = uncappedMaximum(packTokens, tiers);
+	if (largest < packTokens) throw new GaboxMathError("JackpotBelowOnePack", "the largest tier must pay at least one pack");
+	const minimum = tierAmount(packTokens, MIN_SEED_MULTIPLIER_BPS);
+	return (largest < minimum ? largest : minimum) - packTokens;
+}
+/**
+* `math::uncapped_maximum`. The largest tier's award for this base, before any inventory cap.
+*
+* At `packTokens` this is the jackpot in tokens. `seedTokens` is this minus one pack.
+*/
+function uncappedMaximum(base, tiers) {
+	validateTiers(tiers);
+	let largest = 0n;
+	for (const tier of tiers) {
+		if (tier.tickets === 0) continue;
+		const amount = tierAmount(base, tier.multiplierBps);
+		if (amount > largest) largest = amount;
+	}
+	return largest;
+}
+/**
+* `math::quote`. The offer a pack of `base` tokens would freeze right now. `base` is always
+* `pool.packTokens`; the parameter stays general so the vectors can use small numbers.
+*
+* `inventory` is the vault's token balance and `reserved` is `pool.reserved`. The difference is
+* free inventory. This pack's own `base` is added to it, because the purchase and the offer are
+* one transaction — the tokens are in the vault before the draw is written.
+*
+* Every amount is capped at what is actually available. A tier that rounds to zero tokens is an
+* error: the pool must not sell a ticket that can only win nothing.
+*/
+function quote(base, tiers, inventory, reserved) {
+	validateTiers(tiers);
+	if (inventory < reserved) throw new GaboxMathError("InsolventInventory", "the vault holds less than the pool has already reserved");
+	const available = checkedU64(inventory - reserved + base, "available inventory");
+	const prizes = Array.from({ length: 8 }, () => ({
+		amount: 0n,
+		tickets: 0
+	}));
+	let maximum = 0n;
+	let minimum = U64_MAX;
+	for (const [i, tier] of tiers.entries()) {
+		if (tier.tickets === 0) continue;
+		const uncapped = tierAmount(base, tier.multiplierBps);
+		if (uncapped === 0n) throw new GaboxMathError("PackTooSmall", `tier ${i} rounds to zero tokens at this pack size`);
+		const amount = uncapped < available ? uncapped : available;
+		prizes[i] = {
+			amount,
+			tickets: tier.tickets
+		};
+		if (amount > maximum) maximum = amount;
+		if (amount < minimum) minimum = amount;
+	}
+	return {
+		prizes,
+		maximum,
+		minimum
+	};
+}
+/**
+* `math::choose`. Which prize a 16-bit ticket wins.
+*
+* The rows are consecutive ranges in table order, so this is a running total and a comparison.
+* A ticket past the last row returns `0`, which cannot happen for a validated table.
+*/
+function choose(prizes, ticket) {
+	let end = 0;
+	for (const prize of prizes) {
+		end += prize.tickets;
+		if (ticket < end) return prize.amount;
+	}
+	return 0n;
+}
+/** `math::resolve_reservation`. Release the unwon part of a maximum, keep the award reserved. */
+function resolveReservation(reserved, maximum, award) {
+	if (award > maximum) throw new GaboxMathError("InsolventInventory", "the award exceeds the reserved maximum");
+	if (reserved < maximum) throw new GaboxMathError("Arithmetic", "the pool has reserved less than this draw holds");
+	return checkedU64(reserved - maximum + award, "reserved");
+}
+/** The largest `multiplierBps` on any ticketed row. `0` for a table with no rows. */
+function maxMultiplierBps(tiers) {
+	validateTiers(tiers);
+	let largest = 0;
+	for (const tier of tiers) {
+		if (tier.tickets === 0) continue;
+		if (tier.multiplierBps > largest) largest = tier.multiplierBps;
+	}
+	return largest;
+}
+/**
+* The expected multiplier over all 65,536 tickets, in basis points. Rounded down.
+*
+* `validateTiers` caps this at 10,000. A table at 9,800 keeps 2% of every pack's tokens in the
+* vault on average, which is what lets a pool survive a run of top-tier wins.
+*/
+function averageMultiplierBps(tiers) {
+	validateTiers(tiers);
+	let weighted = 0n;
+	for (const tier of tiers) {
+		if (tier.tickets === 0) continue;
+		weighted += BigInt(tier.multiplierBps) * BigInt(tier.tickets);
+	}
+	return Number(weighted / BigInt(TICKETS));
+}
+//#endregion
+//#region src/raydium/pdas.ts
+/**
+* Every Raydium address a Gabox transaction derives.
+*
+* All of them are program-derived, so each one takes the program it lives under. Mainnet and devnet
+* run different Raydium programs, so the same seeds give different addresses on the two clusters.
+* Pass `raydiumIds(client.cluster)` and read the program out of it.
+*
+* `venue/trade.rs` and `venue/launch.rs` derive the same addresses on chain and refuse any account
+* that does not match. `test/raydium-pdas.test.ts` checks every one of these against the pinned
+* table in `abi.ts`, for both clusters.
+*/
+const address$1 = getAddressEncoder();
+const utf8 = getUtf8Encoder();
+const u8$1 = getU8Encoder();
+const u16be = getU16Encoder({ endian: Endian.Big });
+const derive = async (programAddress, seeds) => (await getProgramDerivedAddress({
+	programAddress,
+	seeds
+}))[0];
+/** `["vault_auth_seed"]`. LaunchLab signs its own vault transfers with this PDA. */
+const launchlabAuthority = async (launchlab) => await derive(launchlab, [utf8.encode(LAUNCHLAB_SEEDS.authority)]);
+/** `["__event_authority"]`. */
+const launchlabEventAuthority = async (launchlab) => await derive(launchlab, [utf8.encode(LAUNCHLAB_SEEDS.eventAuthority)]);
+/**
+* `["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.
+*/
+const launchlabGlobalConfig = async (launchlab, quoteMint, curveType = 0, index = 0) => await derive(launchlab, [
+	utf8.encode(LAUNCHLAB_SEEDS.globalConfig),
+	address$1.encode(quoteMint),
+	u8$1.encode(curveType),
+	u16be.encode(index)
+]);
+/** `["platform_config", platform_admin]`. The Gabox platform on LaunchLab. */
+const launchlabPlatformConfig = async (launchlab, platformAdmin) => await derive(launchlab, [utf8.encode(LAUNCHLAB_SEEDS.platformConfig), address$1.encode(platformAdmin)]);
+/** `["pool", base_mint, quote_mint]`. The curve pool of one coin. */
+const launchlabPoolAddress = async (launchlab, baseMint, quoteMint) => await derive(launchlab, [
+	utf8.encode(LAUNCHLAB_SEEDS.pool),
+	address$1.encode(baseMint),
+	address$1.encode(quoteMint)
+]);
+/** `["pool_vault", pool_state, mint]`. One side of a curve pool's reserves. */
+const launchlabVaultAddress = async (launchlab, poolState, mint) => await derive(launchlab, [
+	utf8.encode(LAUNCHLAB_SEEDS.vault),
+	address$1.encode(poolState),
+	address$1.encode(mint)
+]);
+/**
+* `[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.
+*/
+const platformFeeVaultAddress = async (launchlab, platformConfig, quoteMint) => await derive(launchlab, [address$1.encode(platformConfig), address$1.encode(quoteMint)]);
+/**
+* `[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`.
+*/
+const creatorFeeVaultAddress = async (launchlab, creator, quoteMint) => await derive(launchlab, [address$1.encode(creator), address$1.encode(quoteMint)]);
+/** `["creator_fee_vault_auth_seed"]`. The authority `claim_creator_fee` signs the payout with. */
+const creatorFeeVaultAuthority = async (launchlab) => await derive(launchlab, [utf8.encode(LAUNCHLAB_SEEDS.creatorFeeVaultAuthority)]);
+/** `["metadata", metaplex, mint]` under Metaplex. LaunchLab's create instruction writes it. */
+const metadataAddress = async (mint) => await derive(METAPLEX_PROGRAM_ADDRESS, [
+	utf8.encode(METADATA_SEED),
+	address$1.encode(METAPLEX_PROGRAM_ADDRESS),
+	address$1.encode(mint)
+]);
+/** `["vault_and_lp_mint_auth_seed"]`. */
+const cpmmAuthority = async (cpmm) => await derive(cpmm, [utf8.encode(CPMM_SEEDS.authority)]);
+/**
+* `["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.
+*/
+const cpmmPoolAddress = async (cpmm, ammConfig, mintA, mintB) => {
+	const [token0, token1] = sortedMints(mintA, mintB);
+	return await derive(cpmm, [
+		utf8.encode(CPMM_SEEDS.pool),
+		address$1.encode(ammConfig),
+		address$1.encode(token0),
+		address$1.encode(token1)
+	]);
+};
+/**
+* `["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.
+*/
+const cpmmCreatorFeeShare = async (cpmm, creator, ammConfig) => await derive(cpmm, [
+	utf8.encode(CPMM_SEEDS.creatorFeeShare),
+	address$1.encode(creator),
+	address$1.encode(ammConfig)
+]);
+/** An associated token account. Off-curve owners are allowed: pool PDAs are all off-curve. */
+const ata = async (owner, mint, tokenProgram = TOKEN_PROGRAM_ADDRESS) => await derive(ASSOCIATED_TOKEN_PROGRAM_ADDRESS, [
+	address$1.encode(owner),
+	address$1.encode(tokenProgram),
+	address$1.encode(mint)
+]);
+//#endregion
+//#region src/pdas.ts
+/**
+* Gabox's own program-derived addresses.
+*
+* Raydium's live in `src/raydium/pdas.ts`, because they depend on the cluster. These do not: the
+* Gabox program id is the same everywhere.
+*
+* Classic SPL Token only. Both venues use it, and the accepted LaunchLab create instruction mints
+* the coin with it, so no derivation here takes a token program any more.
+*/
+/** `["pool", mint]`. One pool per coin. */
+const poolAddress = async (mint) => (await findPoolPda({ mint }))[0];
+/** `["draw", pool, seq]`, with the sequence as eight little-endian bytes. */
+const drawAddress = async (pool, seq) => (await findDrawPda({
+	pool,
+	seq
+}))[0];
+/** The per-wallet `WalletActivity` PDA. `buy_pack` derives it from the purchaser automatically. */
+const activityAddress = async (wallet) => (await findActivityPda({ purchaser: wallet }))[0];
+/** `["identity"]` under Gabox. The PDA the program signs its randomness request with. */
+const vrfIdentityAddress = async () => (await findIdentityPda())[0];
+/** `["identity", gabox_program_id]` under the VRF program. MagicBlock signs the callback with it. */
+async function scopedVrfIdentityAddress() {
+	return await getProgramDerivedAddress({
+		programAddress: VRF_PROGRAM_ADDRESS,
+		seeds: [getBytesEncoder().encode(IDENTITY_SEED), getAddressEncoder().encode(GABOX_PROGRAM_ID)]
+	});
+}
+/** An associated token account under classic SPL Token. */
+const associatedTokenAddress = async (owner, mint, tokenProgram = TOKEN_PROGRAM_ADDRESS) => await ata(owner, mint, tokenProgram);
+/** The prize vault: the pool PDA's own associated token account for the coin. */
+const vaultAddress = async (mint) => await associatedTokenAddress(await poolAddress(mint), mint);
+//#endregion
+//#region src/raydium/adapter.ts
+/**
+* Reading Raydium's accounts.
+*
+* Every decoder here is written from the field list in the two IDL snapshots under `idl/`. Nothing
+* is guessed: each struct is laid out in Borsh order with no padding between fields, so the offsets
+* follow from the field sizes alone. Each decoder checks the account's eight-byte discriminator
+* first, so a wrong account fails loudly instead of decoding as plausible rubbish.
+*
+* `test/raydium-decode.test.ts` builds one byte array per decoder by hand and reads it back.
+*
+* Only the fields Gabox needs are decoded. The trailing padding of each account is skipped, which
+* is also why a longer account than the one recorded here still decodes: Raydium only ever appends
+* into its own padding.
+*
+* Kit's codecs, never `Buffer`. This module is vendored into a Next.js app, and `Buffer` does not
+* exist in a browser.
+*/
+const DISCRIMINATOR$1 = 8;
+const u8 = getU8Decoder();
+const u16 = getU16Decoder();
+const u64$1 = getU64Decoder();
+const addressAt = getAddressDecoder();
+const bool = getBooleanDecoder();
+/** Refuse an account that is too short or carries another type's discriminator. */
+function checked(data, discriminator, what) {
+	if (data.length < discriminator.length) throw new Error(`not a ${what}: ${data.length} bytes is shorter than a discriminator`);
+	for (const [i, byte] of discriminator.entries()) if (data[i] !== byte) throw new Error(`not a ${what}: the discriminator does not match`);
+	return data;
+}
+/** Refuse a truncated account before a decoder reads past its end. */
+function atLeast(data, size, what) {
+	if (data.length < size) throw new Error(`not a ${what}: ${data.length} bytes, expected at least ${size}`);
+	return data;
+}
+/**
+* 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.
+*/
+function tokenAccountAmount(data) {
+	if (data.length < 72) throw new Error("not a token account: fewer than 72 bytes");
+	return u64$1.decode(data, 64);
+}
+/** The `mint` and `owner` of an SPL token account: bytes 0 to 32 and 32 to 64. */
+function tokenAccountOwnerAndMint(data) {
+	if (data.length < 64) throw new Error("not a token account: fewer than 64 bytes");
+	return {
+		mint: addressAt.decode(data, 0),
+		owner: addressAt.decode(data, 32)
+	};
+}
+/** The base SPL mint is 82 bytes. Token-2022 repeats those 82 and appends its extensions. */
+const MINT_BASE_SIZE = 82;
+/** `decimals` sits after `mint_authority` (4 + 32) and `supply` (8). */
+const MINT_DECIMALS_AT = 44;
+/**
+* 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.
+*/
+function mintDecimals(data) {
+	if (data.length < MINT_BASE_SIZE) throw new Error(`not a mint: ${data.length} bytes, expected at least ${MINT_BASE_SIZE}`);
+	return u8.decode(data, MINT_DECIMALS_AT);
+}
+/** A Borsh string: a u32 little-endian length, then that many UTF-8 bytes. */
+function borshString$1(data, at) {
+	if (at + 4 > data.length) return null;
+	const length = new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(at, true);
+	const end = at + 4 + length;
+	if (end > data.length) return null;
+	return {
+		text: new TextDecoder().decode(data.subarray(at + 4, end)),
+		next: end
+	};
+}
+/** Metaplex pads its three strings with NUL bytes up to their maximum length. */
+const trimmed = (text) => {
+	const clean = text.replace(/\0+$/, "").trim();
+	return clean.length > 0 ? clean : null;
+};
+/**
+* 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.
+*/
+function metaplexSymbol(data) {
+	const name = borshString$1(data, 65);
+	if (!name) return null;
+	const symbol = borshString$1(data, name.next);
+	return symbol ? trimmed(symbol.text) : null;
+}
+/** The Token-2022 extension type of `TokenMetadata`, from the SPL token metadata interface. */
+const TOKEN_METADATA_EXTENSION = 19;
+/** Token-2022 writes one account-type byte after the 82-byte mint, then its TLV extensions. */
+const EXTENSION_START = 166;
+/**
+* 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`.
+*/
+function token2022Symbol(data) {
+	let at = EXTENSION_START;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	while (at + 4 <= data.length) {
+		const type = view.getUint16(at, true);
+		const length = view.getUint16(at + 2, true);
+		const value = at + 4;
+		if (value + length > data.length) return null;
+		if (type === TOKEN_METADATA_EXTENSION) {
+			const name = borshString$1(data.subarray(value, value + length), 64);
+			if (!name) return null;
+			const symbol = borshString$1(data.subarray(value, value + length), name.next);
+			return symbol ? trimmed(symbol.text) : null;
+		}
+		at = value + length;
+	}
+	return null;
+}
+/** Offsets follow the `PoolState` field list in `idl/raydium_launchpad.json`. */
+const LAUNCHLAB_POOL_HEAD = getStructDecoder([
+	["epoch", u64$1],
+	["authBump", u8],
+	["status", u8],
+	["baseDecimals", u8],
+	["quoteDecimals", u8],
+	["migrateType", u8],
+	["supply", u64$1],
+	["totalBaseSell", u64$1],
+	["virtualBase", u64$1],
+	["virtualQuote", u64$1],
+	["realBase", u64$1],
+	["realQuote", u64$1],
+	["totalQuoteFundRaising", u64$1],
+	["quoteProtocolFee", u64$1],
+	["platformFee", u64$1],
+	["migrateFee", u64$1],
+	["vestingTotalLockedAmount", u64$1],
+	["vestingCliffPeriod", u64$1],
+	["vestingUnlockPeriod", u64$1],
+	["vestingStartTime", u64$1],
+	["vestingAllocatedShareAmount", u64$1],
+	["globalConfig", addressAt],
+	["platformConfig", addressAt],
+	["baseMint", addressAt],
+	["quoteMint", addressAt],
+	["baseVault", addressAt],
+	["quoteVault", addressAt],
+	["creator", addressAt],
+	["tokenProgramFlag", u8],
+	["ammCreatorFeeOn", u8]
+]);
+/** The bytes the decoder above reads, discriminator included. The account itself is longer. */
+const LAUNCHLAB_POOL_STATE_HEAD_SIZE = 367;
+function decodeLaunchlabPool(data) {
+	checked(data, LAUNCHLAB_POOL_STATE_DISCRIMINATOR, "LaunchLab pool");
+	atLeast(data, 367, "LaunchLab pool");
+	const head = LAUNCHLAB_POOL_HEAD.decode(data, DISCRIMINATOR$1);
+	return {
+		status: head.status,
+		baseDecimals: head.baseDecimals,
+		quoteDecimals: head.quoteDecimals,
+		migrateType: head.migrateType,
+		supply: head.supply,
+		totalBaseSell: head.totalBaseSell,
+		virtualBase: head.virtualBase,
+		virtualQuote: head.virtualQuote,
+		realBase: head.realBase,
+		realQuote: head.realQuote,
+		totalQuoteFundRaising: head.totalQuoteFundRaising,
+		migrateFee: head.migrateFee,
+		globalConfig: head.globalConfig,
+		platformConfig: head.platformConfig,
+		baseMint: head.baseMint,
+		quoteMint: head.quoteMint,
+		baseVault: head.baseVault,
+		quoteVault: head.quoteVault,
+		creator: head.creator,
+		ammCreatorFeeOn: head.ammCreatorFeeOn
+	};
+}
+const LAUNCHLAB_GLOBAL_CONFIG_HEAD = getStructDecoder([
+	["epoch", u64$1],
+	["curveType", u8],
+	["index", u16],
+	["migrateFee", u64$1],
+	["tradeFeeRate", u64$1],
+	["maxShareFeeRate", u64$1],
+	["minBaseSupply", u64$1],
+	["maxLockRate", u64$1],
+	["minBaseSellRate", u64$1],
+	["minBaseMigrateRate", u64$1],
+	["minQuoteFundRaising", u64$1],
+	["quoteMint", addressAt]
+]);
+const LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE = 115;
+function decodeLaunchlabGlobalConfig(data) {
+	checked(data, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR, "LaunchLab global config");
+	atLeast(data, 115, "LaunchLab global config");
+	const head = LAUNCHLAB_GLOBAL_CONFIG_HEAD.decode(data, DISCRIMINATOR$1);
+	return {
+		curveType: head.curveType,
+		index: head.index,
+		migrateFee: head.migrateFee,
+		tradeFeeRate: head.tradeFeeRate,
+		minQuoteFundRaising: head.minQuoteFundRaising,
+		quoteMint: head.quoteMint
+	};
+}
+/**
+* The fixed-size head of `PlatformConfig`, before its `curve_params` vector. The three text fields
+* are fixed byte arrays, so this is the same length for every platform.
+*/
+const LAUNCHLAB_PLATFORM_CONFIG_HEAD = getStructDecoder([
+	["epoch", u64$1],
+	["platformFeeWallet", addressAt],
+	["platformNftWallet", addressAt],
+	["platformScale", u64$1],
+	["creatorScale", u64$1],
+	["burnScale", u64$1],
+	["feeRate", u64$1]
+]);
+const PLATFORM_CPSWAP_CONFIG_OFFSET = 688;
+const PLATFORM_CREATOR_FEE_RATE_OFFSET = 720;
+const PLATFORM_CP_CREATOR_OFFSET = 800;
+/** Everything before `curve_params`, discriminator included. */
+const LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE = 940;
+function decodeLaunchlabPlatformConfig(data) {
+	checked(data, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR, "LaunchLab platform config");
+	atLeast(data, 940, "LaunchLab platform config");
+	const head = LAUNCHLAB_PLATFORM_CONFIG_HEAD.decode(data, DISCRIMINATOR$1);
+	return {
+		platformFeeWallet: head.platformFeeWallet,
+		feeRate: head.feeRate,
+		creatorFeeRate: u64$1.decode(data, PLATFORM_CREATOR_FEE_RATE_OFFSET),
+		cpswapConfig: addressAt.decode(data, PLATFORM_CPSWAP_CONFIG_OFFSET),
+		platformCpCreator: addressAt.decode(data, PLATFORM_CP_CREATOR_OFFSET)
+	};
+}
+const CPMM_POOL_HEAD = getStructDecoder([
+	["ammConfig", addressAt],
+	["poolCreator", addressAt],
+	["token0Vault", addressAt],
+	["token1Vault", addressAt],
+	["lpMint", addressAt],
+	["token0Mint", addressAt],
+	["token1Mint", addressAt],
+	["token0Program", addressAt],
+	["token1Program", addressAt],
+	["observationKey", addressAt],
+	["authBump", u8],
+	["status", u8],
+	["lpMintDecimals", u8],
+	["mint0Decimals", u8],
+	["mint1Decimals", u8],
+	["lpSupply", u64$1],
+	["protocolFeesToken0", u64$1],
+	["protocolFeesToken1", u64$1],
+	["fundFeesToken0", u64$1],
+	["fundFeesToken1", u64$1],
+	["openTime", u64$1],
+	["recentEpoch", u64$1],
+	["creatorFeeOn", u8],
+	["enableCreatorFee", bool],
+	["padding1", fixDecoderSize(getBytesDecoder(), 6)],
+	["creatorFeesToken0", u64$1],
+	["creatorFeesToken1", u64$1]
+]);
+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.
+*/
+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.
+*/
+const CPMM_POOL_OFFSETS = {
+	ammConfig: 8,
+	poolCreator: 40,
+	token0Mint: 168,
+	token1Mint: 200,
+	enableCreatorFee: 390
+};
+function decodeCpmmPool(data) {
+	checked(data, CPMM_POOL_STATE_DISCRIMINATOR, "CPMM pool");
+	atLeast(data, 413, "CPMM pool");
+	const head = CPMM_POOL_HEAD.decode(data, DISCRIMINATOR$1);
+	return {
+		ammConfig: head.ammConfig,
+		poolCreator: head.poolCreator,
+		token0Vault: head.token0Vault,
+		token1Vault: head.token1Vault,
+		token0Mint: head.token0Mint,
+		token1Mint: head.token1Mint,
+		token0Program: head.token0Program,
+		token1Program: head.token1Program,
+		observationKey: head.observationKey,
+		status: head.status,
+		mint0Decimals: head.mint0Decimals,
+		mint1Decimals: head.mint1Decimals,
+		protocolFeesToken0: head.protocolFeesToken0,
+		protocolFeesToken1: head.protocolFeesToken1,
+		fundFeesToken0: head.fundFeesToken0,
+		fundFeesToken1: head.fundFeesToken1,
+		creatorFeesToken0: head.creatorFeesToken0,
+		creatorFeesToken1: head.creatorFeesToken1,
+		openTime: head.openTime,
+		creatorFeeOn: head.creatorFeeOn,
+		enableCreatorFee: head.enableCreatorFee
+	};
+}
+const CPMM_AMM_CONFIG_HEAD = getStructDecoder([
+	["bump", u8],
+	["disableCreatePool", bool],
+	["index", u16],
+	["tradeFeeRate", u64$1],
+	["protocolFeeRate", u64$1],
+	["fundFeeRate", u64$1],
+	["createPoolFee", u64$1],
+	["protocolOwner", addressAt],
+	["fundOwner", addressAt],
+	["creatorFeeRate", u64$1]
+]);
+const CPMM_AMM_CONFIG_HEAD_SIZE = 116;
+function decodeCpmmAmmConfig(data) {
+	checked(data, CPMM_AMM_CONFIG_DISCRIMINATOR, "CPMM amm config");
+	atLeast(data, 116, "CPMM amm config");
+	const head = CPMM_AMM_CONFIG_HEAD.decode(data, DISCRIMINATOR$1);
+	return {
+		index: head.index,
+		disableCreatePool: head.disableCreatePool,
+		tradeFeeRate: head.tradeFeeRate,
+		protocolFeeRate: head.protocolFeeRate,
+		fundFeeRate: head.fundFeeRate,
+		creatorFeeRate: head.creatorFeeRate
+	};
+}
+//#endregion
+//#region src/accounts.ts
+/** Account readers and bounded discovery scans. Old pool layouts are intentionally unsupported. */
+const DISCRIMINATOR = 8;
+const DRAW_POOL_OFFSET = DISCRIMINATOR;
+const DRAW_PURCHASER_OFFSET = 40;
+const POOL_CREATOR_OFFSET = DISCRIMINATOR;
+const POOL_MINT_OFFSET = 40;
+const base58 = getBase58Decoder();
+const base64$1 = getBase64Encoder();
+const asBase58 = (bytes) => base58.decode(bytes);
+const memcmp$1 = (offset, bytes) => ({ memcmp: {
+	offset: BigInt(offset),
+	bytes,
+	encoding: "base58"
+} });
+const encoded = (address, data) => ({
+	address,
+	data,
+	exists: true,
+	executable: false,
+	lamports: 0n,
+	programAddress: GABOX_PROGRAM_ID,
+	space: BigInt(data.length)
+});
+async function fetchPoolByMint(client, mint) {
+	return await fetchPoolAt(client, await poolAddress(mint));
+}
+async function fetchPoolAt(client, address) {
+	return decodeCurrentPool(await fetchEncodedAccount(client.rpc, address, { commitment: "confirmed" }));
+}
+function decodeCurrentPool(account) {
+	if (!account.exists) return null;
+	if (account.data.length !== getPoolSize()) throw new Error(`pool ${account.address} is not a Gabox pool and is intentionally unsupported`);
+	return decodePool(account).data;
+}
+function decodeCurrentDraw(account) {
+	if (!account.exists) return null;
+	if (account.data.length !== getDrawSize()) throw new Error(`draw ${account.address} is not a Gabox draw and is intentionally unsupported`);
+	return decodeDraw(account).data;
+}
+async function fetchDraw(client, address) {
+	return decodeCurrentDraw(await fetchEncodedAccount(client.rpc, address, { commitment: "confirmed" }));
+}
+function decodeCurrentWalletActivity(account) {
+	if (!account.exists) return null;
+	if (account.data.length !== getWalletActivitySize()) throw new Error(`activity account ${account.address} is not a Gabox WalletActivity and is intentionally unsupported`);
+	return decodeWalletActivity(account).data;
+}
+/**
+* A wallet's lifetime pack-buying activity, or `null` before it has bought its first pack.
+* `buy_pack` creates this account `init_if_needed`, so a fresh wallet has none yet.
+*/
+async function fetchWalletActivity(client, wallet) {
+	return decodeCurrentWalletActivity(await fetchEncodedAccount(client.rpc, await activityAddress(wallet), { commitment: "confirmed" }));
+}
+async function scan(rpc, filters, decode) {
+	return (await rpc.getProgramAccounts(GABOX_PROGRAM_ID, {
+		encoding: "base64",
+		commitment: "confirmed",
+		filters
+	}).send()).map(({ pubkey, account }) => decode(pubkey, new Uint8Array(base64$1.encode(account.data[0]))));
+}
+async function listPools(client) {
+	return await scan(client.rpc, [memcmp$1(0, asBase58(POOL_DISCRIMINATOR)), { dataSize: BigInt(getPoolSize()) }], (address, data) => ({
+		address,
+		data: decodePool(encoded(address, data)).data
+	}));
+}
+async function listDraws(client, query = {}) {
+	const filters = [memcmp$1(0, asBase58(DRAW_DISCRIMINATOR)), { dataSize: BigInt(getDrawSize()) }];
+	if (query.pool) filters.push(memcmp$1(8, query.pool));
+	if (query.purchaser) filters.push(memcmp$1(40, query.purchaser));
+	return await scan(client.rpc, filters, (address, data) => ({
+		address,
+		data: decodeDraw(encoded(address, data)).data
+	}));
+}
+const listDrawsByPool = async (client, pool) => await listDraws(client, { pool });
+const listDrawsByPurchaser = async (client, purchaser) => await listDraws(client, { purchaser });
+async function fetchVaultBalance(client, mint) {
+	const vault = await vaultAddress(mint);
+	const { value } = await client.rpc.getAccountInfo(vault, {
+		encoding: "base64",
+		commitment: "confirmed"
+	}).send();
+	return value ? tokenAccountAmount(new Uint8Array(base64$1.encode(value.data[0]))) : 0n;
+}
+async function fetchPoolInventory(client, mint) {
+	const poolPda = await poolAddress(mint);
+	const vaultPda = await vaultAddress(mint);
+	const { value } = await client.rpc.getMultipleAccounts([poolPda, vaultPda], {
+		encoding: "base64",
+		commitment: "confirmed"
+	}).send();
+	const poolAccount = value[0];
+	if (!poolAccount) return null;
+	const pool = decodeCurrentPool(encoded(poolPda, new Uint8Array(base64$1.encode(poolAccount.data[0]))));
+	if (!pool) return null;
+	if (pool.vault !== vaultPda) throw new Error(`pool ${poolPda} has an unexpected vault; it is not a supported Gabox pool`);
+	const vaultAccount = value[1];
+	const inventory = vaultAccount ? tokenAccountAmount(new Uint8Array(base64$1.encode(vaultAccount.data[0]))) : 0n;
+	return {
+		poolAddress: poolPda,
+		pool,
+		inventory,
+		reserved: pool.reserved,
+		free: inventory > pool.reserved ? inventory - pool.reserved : 0n
+	};
+}
+const tiersOf = (pool) => pool.tiers.map(({ multiplierBps, tickets }) => ({
+	multiplierBps,
+	tickets
+}));
+const quotePool = (inventory) => quote(inventory.pool.packTokens, tiersOf(inventory.pool), inventory.inventory, inventory.reserved);
+//#endregion
+//#region src/compute.ts
+/**
+* The two `ComputeBudget` instructions the transaction builders prepend.
+*
+* # Why every gabox transaction needs one
+*
+* The default budget is 200,000 compute units for the whole transaction. `buy_pack` alone does a
+* CPI into Raydium (which does its own CPIs into the token program and may create two fee vaults),
+* a `transfer_checked`, an account init, and a CPI into MagicBlock's VRF program that allocates a
+* request account. `createMachine` adds LaunchLab's `initialize_v2` to that, which mints the coin
+* and writes its Metaplex metadata. Neither fits in the default, and nothing on chain can raise its
+* own budget.
+*
+* # The numbers are measured
+*
+* Each figure below is about 1.3x the largest `computeUnitsConsumed` the devnet end-to-end test saw
+* over three runs on 2026-09-18, across both venues. That matters because the prioritisation fee is
+* `price x requested limit`: a request three times too large costs three times too much on every
+* pack. A caller may still override any of them.
+*
+* The three runs did not agree. A curve pack cost 164,717, then 167,723, then 181,225 units for the
+* same work, so the venue's own cost moves with state this SDK does not control. The 1.3x margin is
+* there to absorb that, and the largest of the three is always the basis.
+*
+* None of them covers a swap. When a builder puts a route in the same transaction, the route states
+* its own cost as `Route.computeUnits` and the builder adds it, capped at `MAX_COMPUTE_UNIT_LIMIT`.
+*
+* Re-measure after a change to a builder or to a Raydium program. `test/devnet.e2e.test.ts` prints
+* `CU <label>: <units> | <signature>` for every transaction it sends, which is where these came
+* from.
+*/
+const COMPUTE_BUDGET_PROGRAM_ADDRESS = "ComputeBudget111111111111111111111111111111";
+/** The runtime's per-transaction ceiling. A larger request is rejected outright. */
+const MAX_COMPUTE_UNIT_LIMIT = 14e5;
+/** What an instruction gets when no `SetComputeUnitLimit` is present. */
+const DEFAULT_COMPUTE_UNIT_LIMIT = 2e5;
+/**
+* LaunchLab `initialize_v2`, the WSOL wrap, pool initialization with a seed buy, and the WSOL
+* close, in one transaction. Measured at `266,488`, `258,988` and `267,988` over three devnet runs
+* against the slot-500297753 build.
+*/
+const CREATE_MACHINE_COMPUTE_UNITS = 35e4;
+/**
+* A WSOL wrap, a venue buy, an escrow transfer, a draw init, a VRF request and the WSOL close.
+* Measured at `178,690`, `163,686` and `157,692` on the curve, and `113,891`, `110,922` and
+* `106,387` on CPMM. The curve buy is dearer because a coin's first trade also creates the platform
+* and creator fee vaults.
+*/
+const BUY_PACK_COMPUTE_UNITS = 235e3;
+/**
+* A WSOL wrap, a venue sale, and the WSOL close. Measured at `94,246`, `86,745` and `88,246` on the
+* curve, and `61,545`, `55,576` and `57,046` on CPMM.
+*/
+const REDEEM_COMPUTE_UNITS = 125e3;
+/**
+* A creator fee claim: create the quote account, claim or collect, and close it when it is WSOL.
+* Measured at `31,319` every run for the LaunchLab claim and `40,959` for the CPMM collect. A claim
+* on a pool quoted in another token is cheaper, `17,635`, because nothing has to be unwrapped.
+*/
+const CLAIM_COMPUTE_UNITS = 55e3;
+/** `ComputeBudgetInstruction`'s discriminants. Positional and append-only upstream. */
+const SET_COMPUTE_UNIT_LIMIT = 2;
+const SET_COMPUTE_UNIT_PRICE = 3;
+/** `[u8 discriminant, u32 units]` — five bytes. */
+const LIMIT_ENCODER = getStructEncoder([["discriminant", getU8Encoder()], ["units", getU32Encoder()]]);
+/** `[u8 discriminant, u64 microLamports]` — nine bytes. */
+const PRICE_ENCODER = getStructEncoder([["discriminant", getU8Encoder()], ["microLamports", getU64Encoder()]]);
+function getSetComputeUnitLimitInstruction(units) {
+	if (!Number.isInteger(units) || units < 0 || units > 14e5) throw new Error(`compute unit limit must be an integer in 0..=${MAX_COMPUTE_UNIT_LIMIT}, got ${units}`);
+	return {
+		programAddress: COMPUTE_BUDGET_PROGRAM_ADDRESS,
+		accounts: [],
+		data: LIMIT_ENCODER.encode({
+			discriminant: SET_COMPUTE_UNIT_LIMIT,
+			units
+		})
+	};
+}
+/**
+* `SetComputeUnitPrice(microLamports)` — the priority fee, per compute unit.
+*
+* No default, deliberately. The fee that lands a transaction is a property of the network at the
+* moment you send it. A hardcoded price is either money burnt on an idle chain or a transaction
+* that quietly stops landing under load. Sample `getRecentPrioritizationFees`, or take it from
+* config.
+*/
+function getSetComputeUnitPriceInstruction(microLamports) {
+	const price = BigInt(microLamports);
+	if (price < 0n) throw new Error(`compute unit price must not be negative, got ${price}`);
+	return {
+		programAddress: COMPUTE_BUDGET_PROGRAM_ADDRESS,
+		accounts: [],
+		data: PRICE_ENCODER.encode({
+			discriminant: SET_COMPUTE_UNIT_PRICE,
+			microLamports: price
+		})
+	};
+}
+/** The compute budget prefix a builder prepends: a limit, and a price only when one is asked for. */
+function computeBudgetInstructions(units, microLamports) {
+	const instructions = [getSetComputeUnitLimitInstruction(units)];
+	if (microLamports !== void 0) instructions.push(getSetComputeUnitPriceInstruction(microLamports));
+	return instructions;
+}
+//#endregion
+//#region src/raydium/read.ts
+/**
+* One account reader, shared by every module that decodes a Raydium account.
+*
+* Kit's codecs, not `Buffer`. This SDK is vendored into a Next.js app and `Buffer` is not defined
+* in the browser.
+*/
+const base64 = getBase64Encoder();
+/** Read several accounts in one call. A missing account comes back as `null`, not as an error. */
+async function readAccounts(rpc, addresses) {
+	const { value } = await rpc.getMultipleAccounts(addresses, {
+		encoding: "base64",
+		commitment: "confirmed"
+	}).send();
+	return value.map((account) => {
+		if (!account) return null;
+		const [encoded] = account.data;
+		return {
+			data: new Uint8Array(base64.encode(encoded)),
+			owner: account.owner
+		};
+	});
+}
+/** Decode one base64 account payload the RPC returned inside another shape. */
+const decodeBase64 = (encoded) => new Uint8Array(base64.encode(encoded));
+//#endregion
+//#region src/raydium/quote.ts
+/**
+* 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.
+*/
+async function fetchQuoteConfig(client, mint, ids = raydiumIds(client.cluster)) {
+	const address = await launchlabGlobalConfig(ids.launchlab, mint, 0, 0);
+	const [account] = await readAccounts(client.rpc, [address]);
+	if (!account || account.owner !== ids.launchlab) return null;
+	let config;
+	try {
+		config = decodeLaunchlabGlobalConfig(account.data);
+	} catch {
+		return null;
+	}
+	if (config.curveType !== 0 || config.quoteMint !== mint) return null;
+	return {
+		...config,
+		address
+	};
+}
+/** Can a Gabox machine be quoted in this mint? One account read. */
+async function isQuoteSupported(client, mint) {
+	return await fetchQuoteConfig(client, mint) !== null;
+}
+/**
+* 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.
+*/
+async function fetchQuoteAsset(client, mint, ids = raydiumIds(client.cluster)) {
+	const config = await fetchQuoteConfig(client, mint, ids);
+	if (!config) throw new Error(`Raydium has no LaunchLab global config for ${mint}, so it is not a quote asset Gabox can use. Pick a quote Raydium enabled, such as wrapped SOL or USDC.`);
+	const display = await fetchQuoteDisplay(client, mint);
+	return {
+		mint,
+		config: config.address,
+		tokenProgram: display.tokenProgram,
+		decimals: display.decimals,
+		symbol: display.symbol,
+		tradeFeeRate: config.tradeFeeRate,
+		migrateFee: config.migrateFee,
+		minQuoteFundRaising: config.minQuoteFundRaising
+	};
+}
+/**
+* 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`.
+*/
+async function fetchQuoteDisplay(client, mint) {
+	const [mintAccount, metadata] = await readAccounts(client.rpc, [mint, await metadataAddress(mint)]);
+	if (!mintAccount) throw new Error(`the quote mint ${mint} is not on chain`);
+	const tokenProgram = mintAccount.owner;
+	if (tokenProgram !== "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" && tokenProgram !== "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb") throw new Error(`the quote mint ${mint} is owned by ${tokenProgram}, which is neither classic SPL Token nor Token-2022`);
+	const own = tokenProgram === "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb" ? token2022Symbol(mintAccount.data) : null;
+	return {
+		tokenProgram,
+		decimals: mintDecimals(mintAccount.data),
+		symbol: own ?? (metadata ? metaplexSymbol(metadata.data) : null)
+	};
+}
+//#endregion
+//#region src/raydium/accounts.ts
+/**
+* The ordered account list of every Raydium trade Gabox forwards.
+*
+* # Why these are built here
+*
+* `venue/trade.rs` accepts four trade instructions and no others: LaunchLab's `buy_exact_out` and
+* `sell_exact_in`, CPMM's `swap_base_output` and `swap_base_input`. It takes the venue's own
+* account list as `remaining_accounts` and walks it position by position. So the lists are
+* assembled here, from `abi.ts`, which codegen generated from the same Raydium IDLs the program's
+* `venue/abi.rs` came from.
+*
+* # How to read the output
+*
+* Each function returns `AccountMeta[]` in ABI order, with the role each slot's own ABI gives it.
+* That list goes into `initialize_pool`, `buy_pack` or `sell_tokens` as `remainingAccounts`,
+* unchanged. The program then requires every writable slot to be writable in the outer transaction,
+* requires the one signer slot to be the purchaser, and checks every address by name.
+*
+* # CPMM names its accounts by direction
+*
+* CPMM calls its four pairs `input_*` and `output_*`. A buy sends quote and receives the coin; a
+* sell is the other way round. So the two builders below fill the same four names with opposite
+* addresses, the token programs included. LaunchLab names its accounts by role instead, and uses
+* one list for both sides.
+*
+* # The token programs are inputs, not constants
+*
+* The base coin is always classic SPL Token. The quote may be Token-2022, so its program travels
+* with the pool: `pool.quoteTokenProgram` on the curve, and the two programs a migrated CPMM pool
+* records in its own data. `venue/trade.rs` checks both slots against the same values.
+*/
+/**
+* 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`.
+*/
+function order(abi, byName) {
+	return abi.accounts.map((spec) => {
+		const address = byName[spec.name];
+		if (address === void 0) throw new Error(`${abi.name}: no address given for the "${spec.name}" account`);
+		return {
+			address,
+			role: spec.signer ? spec.writable ? AccountRole.WRITABLE_SIGNER : AccountRole.READONLY_SIGNER : spec.writable ? AccountRole.WRITABLE : AccountRole.READONLY
+		};
+	});
+}
+function launchlabTradeAccounts(abi, input) {
+	return order(abi, {
+		payer: input.user,
+		authority: input.launchlabAuthority,
+		global_config: input.globalConfig,
+		platform_config: input.platformConfig,
+		pool_state: input.poolState,
+		user_base_token: input.userBaseToken,
+		user_quote_token: input.userQuoteToken,
+		base_vault: input.baseVault,
+		quote_vault: input.quoteVault,
+		base_token_mint: input.mint,
+		quote_token_mint: input.quoteMint,
+		base_token_program: TOKEN_PROGRAM_ADDRESS,
+		quote_token_program: input.quoteTokenProgram,
+		event_authority: input.launchlabEventAuthority,
+		program: input.launchlab,
+		system_program: SYSTEM_PROGRAM_ADDRESS,
+		platform_fee_vault: input.platformFeeVault,
+		creator_fee_vault: input.creatorFeeVault
+	});
+}
+/** `buy_exact_out`: 18 accounts. The first argument is the coins wanted, the second the cost cap. */
+const launchlabBuyAccounts = (input) => launchlabTradeAccounts(LAUNCHLAB_BUY_EXACT_OUT, input);
+/** `sell_exact_in`: the same 18 accounts. `venue/trade.rs` uses one table for both sides. */
+const launchlabSellAccounts = (input) => launchlabTradeAccounts(LAUNCHLAB_SELL_EXACT_IN, input);
+/**
+* `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.
+*/
+const launchlabBuyExactInAccounts = (input) => launchlabTradeAccounts(LAUNCHLAB_BUY_EXACT_IN, input);
+/** A buy sends the quote and receives the coin. A sell is the other way round. */
+function cpmmTradeAccounts(abi, input, side) {
+	const buying = side === "buy";
+	return order(abi, {
+		payer: input.user,
+		authority: input.cpmmAuthority,
+		amm_config: input.ammConfig,
+		pool_state: input.poolState,
+		input_token_account: buying ? input.userQuoteToken : input.userBaseToken,
+		output_token_account: buying ? input.userBaseToken : input.userQuoteToken,
+		input_vault: buying ? input.quoteVault : input.baseVault,
+		output_vault: buying ? input.baseVault : input.quoteVault,
+		input_token_program: buying ? input.quoteTokenProgram : input.baseTokenProgram,
+		output_token_program: buying ? input.baseTokenProgram : input.quoteTokenProgram,
+		input_token_mint: buying ? input.quoteMint : input.mint,
+		output_token_mint: buying ? input.mint : input.quoteMint,
+		observation_state: input.observationState
+	});
+}
+/** `swap_base_output`: 13 accounts. Note the argument order is `(max_amount_in, amount_out)`. */
+const cpmmBuyAccounts = (input) => cpmmTradeAccounts(CPMM_SWAP_BASE_OUTPUT, input, "buy");
+/** `swap_base_input`: 13 accounts, with the four pairs swapped. */
+const cpmmSellAccounts = (input) => cpmmTradeAccounts(CPMM_SWAP_BASE_INPUT, input, "sell");
+//#endregion
+//#region src/raydium/curve.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)`. */
+function ceilDivRate(amount, rate, denominator = RATE_DENOMINATOR) {
+	if (rate === 0n) return 0n;
+	return ceilDiv(amount * rate, denominator);
+}
+/** `ceil(numerator / denominator)` for non-negative values. */
+function ceilDiv(numerator, denominator) {
+	if (denominator === 0n) throw new Error("divide by zero");
+	return (numerator + denominator - 1n) / denominator;
+}
+/**
+* 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.
+*/
+function preFeeAmount(postFeeAmount, rate) {
+	if (rate === 0n) return postFeeAmount;
+	if (rate >= 1000000n) throw new Error("a fee rate of 100% or more has no pre-fee amount");
+	return ceilDiv(postFeeAmount * RATE_DENOMINATOR, RATE_DENOMINATOR - rate);
+}
+/**
+* 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.
+*/
+function totalCurveFeeRate(rates) {
+	const total = rates.tradeFeeRate + rates.platformFeeRate + rates.creatorFeeRate;
+	if (total > 1000000n) throw new Error("the total curve fee rate exceeds 1,000,000");
+	return total;
+}
+/** Coins the curve still has to sell. A buy cannot take more than this. */
+function remainingBase(pool) {
+	return pool.totalBaseSell > pool.realBase ? pool.totalBaseSell - pool.realBase : 0n;
+}
+/** The two sides of the constant product, as the curve sees them right now. */
+const quoteSide = (pool) => pool.virtualQuote + pool.realQuote;
+const baseSide = (pool) => pool.virtualBase - pool.realBase;
+/**
+* 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.
+*/
+function curveBuyExactOut(pool, rates, tokens) {
+	if (tokens <= 0n) throw new Error("tokens must be positive");
+	const remaining = remainingBase(pool);
+	const amount = tokens > remaining ? remaining : tokens;
+	if (amount === 0n) throw new Error("the curve has no coins left to sell");
+	return preFeeAmount(curveQuoteInForBaseOut(pool, amount), totalCurveFeeRate(rates));
+}
+/**
+* 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.
+*/
+function curveBuyExactIn(pool, rates, quote) {
+	if (quote <= 0n) throw new Error("quote must be positive");
+	const spend = quote - ceilDivRate(quote, totalCurveFeeRate(rates));
+	if (spend <= 0n) throw new Error("the whole spend would go to fees");
+	const tokens = curveBaseOutForQuoteIn(pool, spend);
+	const remaining = remainingBase(pool);
+	return tokens > remaining ? remaining : tokens;
+}
+/**
+* Quote a sale of exactly `tokens` coins returns, net of fees. This is `Curve.sellExactIn`.
+*/
+function curveSellExactIn(pool, rates, tokens) {
+	if (tokens <= 0n) throw new Error("tokens must be positive");
+	const gross = curveQuoteOutForBaseIn(pool, tokens);
+	const fee = ceilDivRate(gross, totalCurveFeeRate(rates));
+	return gross > fee ? gross - fee : 0n;
+}
+/** `getAmountIn` on the buy side: `ceil(quoteSide * out / (baseSide - out))`. */
+function curveQuoteInForBaseOut(pool, tokens) {
+	const output = baseSide(pool);
+	if (tokens >= output) throw new Error("the curve does not hold that many coins");
+	return ceilDiv(quoteSide(pool) * tokens, output - tokens);
+}
+/** `getAmountOut` on the buy side: `floor(in * baseSide / (quoteSide + in))`. */
+function curveBaseOutForQuoteIn(pool, quote) {
+	return quote * baseSide(pool) / (quoteSide(pool) + quote);
+}
+/** `getAmountOut` on the sell side: `floor(in * quoteSide / (baseSide + in))`. */
+function curveQuoteOutForBaseIn(pool, tokens) {
+	return tokens * quoteSide(pool) / (baseSide(pool) + tokens);
+}
+/**
+* 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.
+*/
+function initialCurve(params) {
+	const { supply, totalBaseSell, quoteRaise } = params;
+	const locked = params.totalLockedAmount ?? 0n;
+	const migrateFee = params.migrateFee ?? 0n;
+	if (supply <= totalBaseSell) throw new Error("the supply must be larger than the curve sells");
+	const migrateBase = supply - totalBaseSell - locked;
+	if (migrateBase <= 0n) throw new Error("nothing would be left to seed the pool at graduation");
+	const raiseLessMigrateFee = quoteRaise - migrateFee;
+	if (raiseLessMigrateFee <= 0n) throw new Error("the migrate fee eats the whole raise");
+	const numerator = raiseLessMigrateFee * totalBaseSell * totalBaseSell / migrateBase;
+	const denominator = raiseLessMigrateFee * totalBaseSell / migrateBase - quoteRaise;
+	if (denominator <= 0n) throw new Error("these launch parameters have no valid starting price");
+	return {
+		virtualBase: numerator / denominator,
+		virtualQuote: quoteRaise * quoteRaise / denominator,
+		realBase: 0n,
+		realQuote: 0n,
+		totalBaseSell
+	};
+}
+/**
+* Quote a CPMM buy of exactly `tokens` coins costs, both fees included.
+*
+* This is `CurveCalculator.swapBaseOutput`, which is what `swap_base_output` charges.
+*/
+function cpmmSwapBaseOutput(sides, rates, amountOut) {
+	if (amountOut <= 0n) throw new Error("amountOut must be positive");
+	const actualOut = rates.creatorFeeOnInput ? amountOut : preFeeAmount(amountOut, rates.creatorFeeRate);
+	if (actualOut >= sides.outputReserve) throw new Error("the pool does not hold that much of the output token");
+	return preFeeAmount(ceilDiv(sides.inputReserve * actualOut, sides.outputReserve - actualOut), rates.creatorFeeOnInput ? rates.tradeFeeRate + rates.creatorFeeRate : rates.tradeFeeRate);
+}
+/**
+* What a CPMM swap of exactly `amountIn` returns, net of both fees.
+*
+* This is `CurveCalculator.swapBaseInput`, which is what `swap_base_input` pays out.
+*/
+function cpmmSwapBaseInput(sides, rates, amountIn) {
+	if (amountIn <= 0n) throw new Error("amountIn must be positive");
+	const tradeFee = ceilDivRate(amountIn, rates.tradeFeeRate);
+	const creatorFeeIn = rates.creatorFeeOnInput ? ceilDivRate(amountIn, rates.creatorFeeRate) : 0n;
+	const lessFees = amountIn - tradeFee - creatorFeeIn;
+	if (lessFees <= 0n) throw new Error("the whole input would go to fees");
+	const swapped = lessFees * sides.outputReserve / (sides.inputReserve + lessFees);
+	if (rates.creatorFeeOnInput) return swapped;
+	const creatorFeeOut = ceilDivRate(swapped, rates.creatorFeeRate);
+	return swapped > creatorFeeOut ? swapped - creatorFeeOut : 0n;
+}
+//#endregion
+//#region src/raydium/venue.ts
+/** The quote binding a Gabox pool records. One account read. */
+async function fetchQuoteBinding(client, mint) {
+	const pool = await fetchPoolByMint(client, mint);
+	if (!pool) throw new Error(`no Gabox pool for mint ${mint}, so its quote asset is unknown. Pass \`quote\` to price a coin that has no pool.`);
+	return {
+		mint: pool.quoteMint,
+		config: pool.quoteConfig,
+		tokenProgram: pool.quoteTokenProgram
+	};
+}
+/**
+* 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.
+*/
+async function quoteAccountFor(user, quoteMint, quoteTokenProgram = TOKEN_PROGRAM_ADDRESS) {
+	return await ata(user, quoteMint, quoteTokenProgram);
+}
+/** The user's WSOL associated token account. WSOL is always classic SPL Token. */
+async function wsolAccountFor(user) {
+	return await ata(user, WSOL_MINT, TOKEN_PROGRAM_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.
+*/
+async function fetchCurveSettings(client, quoteConfig, ids = raydiumIds(client.cluster)) {
+	const [globalAccount, platformAccount] = await readAccounts(client.rpc, [quoteConfig, ids.gaboxPlatform]);
+	if (!globalAccount) throw new Error(`LaunchLab has no global config at ${quoteConfig}`);
+	if (!platformAccount) throw new Error(`the Gabox platform config is missing at ${ids.gaboxPlatform}`);
+	return settingsFrom(globalAccount.data, platformAccount.data);
+}
+function settingsFrom(globalData, platformData) {
+	const global = decodeLaunchlabGlobalConfig(globalData);
+	const platform = decodeLaunchlabPlatformConfig(platformData);
+	return {
+		rates: {
+			tradeFeeRate: global.tradeFeeRate,
+			platformFeeRate: platform.feeRate,
+			creatorFeeRate: platform.creatorFeeRate
+		},
+		migrateFee: global.migrateFee,
+		cpswapConfig: platform.cpswapConfig
+	};
+}
+async function resolveVenue(client, options) {
+	const ids = raydiumIds(client.cluster);
+	const { mint, user } = options;
+	const quote = options.quote ?? await fetchQuoteBinding(client, mint);
+	const curvePool = await launchlabPoolAddress(ids.launchlab, mint, quote.mint);
+	const [poolAccount, globalAccount, platformAccount] = await readAccounts(client.rpc, [
+		curvePool,
+		quote.config,
+		ids.gaboxPlatform
+	]);
+	if (!poolAccount) throw new Error(`no LaunchLab pool at ${curvePool}. The coin was not launched on LaunchLab with ${quote.mint} as its quote, so it has no Gabox venue.`);
+	if (!globalAccount) throw new Error(`LaunchLab has no global config at ${quote.config}`);
+	if (!platformAccount) throw new Error(`the Gabox platform config is missing at ${ids.gaboxPlatform}`);
+	const pool = decodeLaunchlabPool(poolAccount.data);
+	if (pool.baseMint !== mint || pool.quoteMint !== quote.mint) throw new Error(`the LaunchLab pool at ${curvePool} is not the pool of ${mint}`);
+	const settings = settingsFrom(globalAccount.data, platformAccount.data);
+	const kind = options.venue ?? (pool.status === 2 ? "cpmm" : "launchlab");
+	if (options.venue === void 0 && pool.status === 1) throw new Error(`${mint} is graduating: its LaunchLab curve is sold out and Raydium is moving it into a CPMM pool. Retry in a moment; the move usually finishes within a minute.`);
+	if (kind === "launchlab") {
+		if (pool.status !== 0) throw new Error(`${mint} no longer trades on its LaunchLab curve (status ${pool.status}). Use the CPMM venue.`);
+		return await launchlabVenue(ids, pool, settings.rates, {
+			mint,
+			quote,
+			user,
+			poolState: curvePool
+		});
+	}
+	return await cpmmVenue(client, ids, pool, settings.cpswapConfig, {
+		mint,
+		quote,
+		user
+	});
+}
+async function launchlabVenue(ids, pool, rates, where) {
+	const { mint, quote, user, poolState } = where;
+	const userQuoteToken = await quoteAccountFor(user, quote.mint, quote.tokenProgram);
+	const shared = {
+		launchlab: ids.launchlab,
+		launchlabAuthority: ids.launchlabAuthority,
+		launchlabEventAuthority: ids.launchlabEventAuthority,
+		globalConfig: quote.config,
+		platformConfig: ids.gaboxPlatform,
+		poolState,
+		mint,
+		quoteMint: quote.mint,
+		baseVault: await launchlabVaultAddress(ids.launchlab, poolState, mint),
+		quoteVault: await launchlabVaultAddress(ids.launchlab, poolState, quote.mint),
+		user,
+		userBaseToken: await ata(user, mint),
+		userQuoteToken,
+		quoteTokenProgram: quote.tokenProgram,
+		platformFeeVault: await platformFeeVaultAddress(ids.launchlab, ids.gaboxPlatform, quote.mint),
+		creatorFeeVault: await creatorFeeVaultAddress(ids.launchlab, pool.creator, quote.mint)
+	};
+	const reserves = {
+		virtualBase: pool.virtualBase,
+		virtualQuote: pool.virtualQuote,
+		realBase: pool.realBase,
+		realQuote: pool.realQuote,
+		totalBaseSell: pool.totalBaseSell
+	};
+	const remaining = remainingBase(reserves);
+	return {
+		kind: "launchlab",
+		program: ids.launchlab,
+		mint,
+		quoteMint: quote.mint,
+		quoteTokenProgram: quote.tokenProgram,
+		userQuoteToken,
+		poolState,
+		status: pool.status,
+		creator: pool.creator,
+		ammConfig: null,
+		remainingCurveBase: remaining,
+		buyAccounts: launchlabBuyAccounts(shared),
+		sellAccounts: launchlabSellAccounts(shared),
+		quoteBuy: (tokens) => {
+			if (tokens > remaining) throw new Error(`the curve has ${remaining} base units left and cannot sell ${tokens}. Wait for the coin to graduate, then buy on its CPMM pool.`);
+			return curveBuyExactOut(reserves, rates, tokens);
+		},
+		quoteSell: (tokens) => curveSellExactIn(reserves, rates, tokens)
+	};
+}
+/**
+* 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.
+*/
+function cpmmPoolMatches(pool, expect) {
+	return pool.enableCreatorFee && pool.poolCreator === expect.creator && pool.token0Mint === expect.token0 && pool.token1Mint === expect.token1;
+}
+/**
+* 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.
+*/
+async function findCpmmPool(client, options) {
+	const ids = raydiumIds(client.cluster);
+	const { mint, creator, cpswapConfig } = options;
+	const quoteMint = options.quoteMint ?? "So11111111111111111111111111111111111111112";
+	const [token0, token1] = sortedMints(mint, quoteMint);
+	const expect = {
+		creator,
+		token0,
+		token1
+	};
+	const derived = await cpmmPoolAddress(ids.cpmm, cpswapConfig, mint, quoteMint);
+	const [account] = await readAccounts(client.rpc, [derived]);
+	if (account && account.owner === ids.cpmm) {
+		const pool = decodeCpmmPoolOrNull(account.data);
+		if (pool && cpmmPoolMatches(pool, expect)) return {
+			address: derived,
+			pool
+		};
+	}
+	const rows = await client.rpc.getProgramAccounts(ids.cpmm, {
+		encoding: "base64",
+		commitment: "confirmed",
+		filters: [
+			{ dataSize: BigInt(637) },
+			memcmp(CPMM_POOL_OFFSETS.poolCreator, creator),
+			memcmp(CPMM_POOL_OFFSETS.token0Mint, token0),
+			memcmp(CPMM_POOL_OFFSETS.token1Mint, token1)
+		]
+	}).send();
+	const matches = [];
+	for (const { pubkey, account: row } of rows) {
+		const pool = decodeCpmmPoolOrNull(decodeBase64(row.data[0]));
+		if (pool && cpmmPoolMatches(pool, expect)) matches.push({
+			address: pubkey,
+			pool
+		});
+	}
+	const [only] = matches;
+	if (!only) throw new Error(`no migrated CPMM pool for ${mint}. The derived address ${derived} holds no matching pool, and no other CPMM pool has this coin, this creator and a creator fee enabled.`);
+	if (matches.length > 1) throw new Error(`${matches.length} CPMM pools match ${mint}: ${matches.map((m) => m.address).join(", ")}. Pass the one you mean rather than letting this choose.`);
+	return only;
+}
+/** A `getProgramAccounts` byte filter. The bytes of an address are its own base58 text. */
+function memcmp(offset, value) {
+	return { memcmp: {
+		offset: BigInt(offset),
+		bytes: value,
+		encoding: "base58"
+	} };
+}
+/** Decode a candidate account, or give up quietly. A scan row that is not a pool is not an error. */
+function decodeCpmmPoolOrNull(data) {
+	try {
+		return decodeCpmmPool(data);
+	} catch {
+		return null;
+	}
+}
+async function cpmmVenue(client, ids, curve, cpswapConfig, where) {
+	const { mint, quote, user } = where;
+	const { address: poolState, pool } = await findCpmmPool(client, {
+		mint,
+		quoteMint: quote.mint,
+		creator: curve.creator,
+		cpswapConfig
+	});
+	const baseIsToken0 = pool.token0Mint === mint;
+	const baseVault = baseIsToken0 ? pool.token0Vault : pool.token1Vault;
+	const quoteVault = baseIsToken0 ? pool.token1Vault : pool.token0Vault;
+	const baseTokenProgram = baseIsToken0 ? pool.token0Program : pool.token1Program;
+	const quoteTokenProgram = baseIsToken0 ? pool.token1Program : pool.token0Program;
+	if (baseTokenProgram !== "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" || quoteTokenProgram !== quote.tokenProgram) throw new Error(`the CPMM pool at ${poolState} records token programs ${baseTokenProgram} and ${quoteTokenProgram}, which are not the ones this coin trades under`);
+	const [configAccount, baseVaultAccount, quoteVaultAccount] = await readAccounts(client.rpc, [
+		pool.ammConfig,
+		baseVault,
+		quoteVault
+	]);
+	if (!configAccount) throw new Error(`the CPMM pool at ${poolState} names a fee tier that is not on chain`);
+	if (!baseVaultAccount || !quoteVaultAccount) throw new Error(`the CPMM pool at ${poolState} has no reserve accounts`);
+	const config = decodeCpmmAmmConfig(configAccount.data);
+	const owedBase = baseIsToken0 ? pool.protocolFeesToken0 + pool.fundFeesToken0 + pool.creatorFeesToken0 : pool.protocolFeesToken1 + pool.fundFeesToken1 + pool.creatorFeesToken1;
+	const owedQuote = baseIsToken0 ? pool.protocolFeesToken1 + pool.fundFeesToken1 + pool.creatorFeesToken1 : pool.protocolFeesToken0 + pool.fundFeesToken0 + pool.creatorFeesToken0;
+	const baseReserve = tokenAccountAmount(baseVaultAccount.data) - owedBase;
+	const quoteReserve = tokenAccountAmount(quoteVaultAccount.data) - owedQuote;
+	if (baseReserve <= 0n || quoteReserve <= 0n) throw new Error(`the CPMM pool at ${poolState} has no tradable reserves`);
+	const userQuoteToken = await quoteAccountFor(user, quote.mint, quoteTokenProgram);
+	const shared = {
+		cpmmAuthority: ids.cpmmAuthority,
+		ammConfig: pool.ammConfig,
+		poolState,
+		mint,
+		quoteMint: quote.mint,
+		baseVault,
+		quoteVault,
+		observationState: pool.observationKey,
+		user,
+		userBaseToken: await ata(user, mint),
+		userQuoteToken,
+		baseTokenProgram,
+		quoteTokenProgram
+	};
+	const creatorFeeRate = pool.enableCreatorFee ? config.creatorFeeRate : 0n;
+	const buySides = {
+		inputReserve: quoteReserve,
+		outputReserve: baseReserve
+	};
+	const sellSides = {
+		inputReserve: baseReserve,
+		outputReserve: quoteReserve
+	};
+	const buyRates = {
+		tradeFeeRate: config.tradeFeeRate,
+		creatorFeeRate,
+		creatorFeeOnInput: creatorFeeOnInput(pool, quote.mint)
+	};
+	const sellRates = {
+		tradeFeeRate: config.tradeFeeRate,
+		creatorFeeRate,
+		creatorFeeOnInput: creatorFeeOnInput(pool, mint)
+	};
+	return {
+		kind: "cpmm",
+		program: ids.cpmm,
+		mint,
+		quoteMint: quote.mint,
+		quoteTokenProgram,
+		userQuoteToken,
+		poolState,
+		status: curve.status,
+		creator: pool.poolCreator,
+		ammConfig: pool.ammConfig,
+		remainingCurveBase: 0n,
+		buyAccounts: cpmmBuyAccounts(shared),
+		sellAccounts: cpmmSellAccounts(shared),
+		quoteBuy: (tokens) => cpmmSwapBaseOutput(buySides, buyRates, tokens),
+		quoteSell: (tokens) => cpmmSwapBaseInput(sellSides, sellRates, tokens)
+	};
+}
+/**
+* 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.
+*/
+function creatorFeeOnInput(pool, inputMint) {
+	if (pool.creatorFeeOn === 0) return true;
+	const inputIsToken0 = pool.token0Mint === inputMint;
+	return pool.creatorFeeOn === 1 ? inputIsToken0 : !inputIsToken0;
+}
+/**
+* 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.
+*/
+async function curveQuote(client, mint, tokens, options = {}) {
+	return (await resolveVenue(client, {
+		mint,
+		user: options.user ?? mint,
+		...options.venue ? { venue: options.venue } : {},
+		...options.quote ? { quote: options.quote } : {}
+	})).quoteBuy(tokens);
+}
+/** Quote token a sale of `tokens` returns right now, net of the venue's fees. */
+async function sellQuote(client, mint, tokens, options = {}) {
+	return (await resolveVenue(client, {
+		mint,
+		user: options.user ?? mint,
+		...options.venue ? { venue: options.venue } : {},
+		...options.quote ? { quote: options.quote } : {}
+	})).quoteSell(tokens);
+}
+/**
+* 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.
+*/
+async function newCurveBuyCost(client, tokens, launch) {
+	if (tokens <= 0n) return 0n;
+	const ids = raydiumIds(client.cluster);
+	const settings = await fetchCurveSettings(client, launch.quoteConfig, ids);
+	return curveBuyExactOut(newCurveReserves(launch.raise, settings.migrateFee), settings.rates, tokens);
+}
+/**
+* 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.
+*/
+function newCurveReserves(raise, migrateFee) {
+	return initialCurve({
+		supply: LAUNCH_SUPPLY,
+		totalBaseSell: LAUNCH_TOTAL_BASE_SELL,
+		quoteRaise: raise,
+		migrateFee
+	});
+}
+//#endregion
+//#region src/tx/message.ts
+/**
+* Assembling a transaction message.
+*
+* Every builder in this directory ends here: compute budget first, then the program instructions,
+* with a fee payer and a blockhash lifetime. The result is a message a wallet can sign and send —
+* nothing in this SDK signs or sends anything itself.
+*/
+/**
+* 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.
+*/
+async function buildMessage(client, feePayer, instructions, options) {
+	const { value: latestBlockhash } = await client.rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
+	const budget = computeBudgetInstructions(options.computeUnitLimit, options.computeUnitPrice);
+	const message = pipe(createTransactionMessage({ version: 0 }), (m) => setTransactionMessageFeePayerSigner(feePayer, m), (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m), (m) => appendTransactionMessageInstructions([...budget, ...instructions], m), (m) => compressTransactionMessageUsingAddressLookupTables(m, options.addressLookupTables ?? client.addressLookupTables));
+	const size = getTransactionEncoder().encode(compileTransaction(message)).length;
+	if (size > 1232) throw new Error(`Transaction is ${size} bytes; Solana allows 1232. Shorten metadata or supply additional address lookup tables.`);
+	return message;
+}
+/** Append `remainingAccounts` to a generated instruction, which is how a venue's list is passed. */
+function withRemainingAccounts(instruction, remaining) {
+	return {
+		...instruction,
+		accounts: [...instruction.accounts ?? [], ...remaining]
+	};
+}
+//#endregion
+//#region src/raydium/launch.ts
+/**
+* LaunchLab's `initialize_v2`, built by hand.
+*
+* Put it **before** `initialize_pool` in the transaction. `venue/launch.rs` reads the Instructions
+* sysvar and looks for this instruction by discriminator, then checks all 18 of its accounts and
+* every one of its arguments. The order matters for a second reason too: the mint account has to
+* exist and deserialize before Anchor validates the Gabox accounts.
+*
+* # The launch shape is pinned
+*
+* A creator picks the name, the symbol and the metadata URI. Nothing else. Every other argument is
+* fixed, and the program refuses any other value:
+*
+* | Argument | Value |
+* | --- | --- |
+* | `decimals` | 6 (the coin; the quote keeps its own) |
+* | curve | `Constant` |
+* | `supply` | 1,000,000,000 coins |
+* | `total_base_sell` | 793,100,000 coins |
+* | `total_quote_fund_raising` | the caller's `raise`, pinned to 85 SOL on mainnet and 3 SOL on devnet for a WSOL pool |
+* | `migrate_type` | 1, which means graduate into a CPMM pool |
+* | `VestingParams` | all three fields 0 |
+* | `AmmCreatorFeeOn` | `QuoteToken` |
+*
+* The instruction data must end exactly after the last argument. Trailing bytes are refused.
+*
+* # The argument layout
+*
+* Borsh, in IDL order: `MintParams { decimals, name, symbol, uri }`, then the `CurveParams` enum
+* tag and its `ConstantCurve` fields, then `VestingParams`, then the `AmmCreatorFeeOn` enum tag.
+* An Anchor enum tag is one byte.
+*/
+const borshString = () => addEncoderSizePrefix(getUtf8Encoder(), getU32Encoder());
+const ARGS_ENCODER = getStructEncoder([
+	["decimals", getU8Encoder()],
+	["name", borshString()],
+	["symbol", borshString()],
+	["uri", borshString()],
+	["curveTag", getU8Encoder()],
+	["supply", getU64Encoder()],
+	["totalBaseSell", getU64Encoder()],
+	["totalQuoteFundRaising", getU64Encoder()],
+	["migrateType", getU8Encoder()],
+	["totalLockedAmount", getU64Encoder()],
+	["cliffPeriod", getU64Encoder()],
+	["unlockPeriod", getU64Encoder()],
+	["ammFeeOn", getU8Encoder()]
+]);
+/** Metaplex refuses a longer string, so refuse it here rather than on chain. */
+function bounded(value, limit, what) {
+	const bytes = new TextEncoder().encode(value).length;
+	if (bytes === 0) throw new Error(`${what} must not be empty`);
+	if (bytes > limit) throw new Error(`${what} is ${bytes} UTF-8 bytes; Metaplex allows at most ${limit}`);
+	return value;
+}
+/**
+* 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.
+*/
+async function getLaunchInstruction(input, ids) {
+	const { mint, creator } = input;
+	const name = bounded(input.name, METADATA_LIMITS.name, "name");
+	const symbol = bounded(input.symbol, METADATA_LIMITS.symbol, "symbol");
+	const uri = bounded(input.uri, METADATA_LIMITS.uri, "uri");
+	const { quoteMint, quoteTokenProgram } = input;
+	const poolState = await launchlabPoolAddress(ids.launchlab, mint.address, quoteMint);
+	const metas = order(LAUNCHLAB_INITIALIZE, {
+		payer: creator.address,
+		creator: creator.address,
+		global_config: input.quoteConfig,
+		platform_config: ids.gaboxPlatform,
+		authority: ids.launchlabAuthority,
+		pool_state: poolState,
+		base_mint: mint.address,
+		quote_mint: quoteMint,
+		base_vault: await launchlabVaultAddress(ids.launchlab, poolState, mint.address),
+		quote_vault: await launchlabVaultAddress(ids.launchlab, poolState, quoteMint),
+		metadata_account: await metadataAddress(mint.address),
+		base_token_program: TOKEN_PROGRAM_ADDRESS,
+		quote_token_program: quoteTokenProgram,
+		metadata_program: METAPLEX_PROGRAM_ADDRESS,
+		system_program: SYSTEM_PROGRAM_ADDRESS,
+		rent_program: RENT_SYSVAR_ADDRESS,
+		event_authority: ids.launchlabEventAuthority,
+		program: ids.launchlab
+	});
+	const signerFor = /* @__PURE__ */ new Map([[mint.address, mint], [creator.address, creator]]);
+	const accounts = metas.map((meta) => {
+		const signs = meta.role === 2 || meta.role === 3;
+		const signer = signerFor.get(meta.address);
+		return signs && signer ? {
+			...meta,
+			signer
+		} : meta;
+	});
+	const data = new Uint8Array([...LAUNCHLAB_INITIALIZE.discriminator, ...ARGS_ENCODER.encode({
+		decimals: 6,
+		name,
+		symbol,
+		uri,
+		curveTag: 0,
+		supply: LAUNCH_SUPPLY,
+		totalBaseSell: LAUNCH_TOTAL_BASE_SELL,
+		totalQuoteFundRaising: input.raise,
+		migrateType: 1,
+		totalLockedAmount: 0n,
+		cliffPeriod: 0n,
+		unlockPeriod: 0n,
+		ammFeeOn: 0
+	})]);
+	return {
+		programAddress: ids.launchlab,
+		accounts,
+		data
+	};
+}
+//#endregion
+//#region src/raydium/claim.ts
+/**
+* Collecting the creator's share of trading.
+*
+* Gabox charges no fee at all. The creator's income is the share Raydium pays out of its own
+* revenue, and it sits in two different places depending on where the coin trades:
+*
+*   - **On the curve.** LaunchLab pays 0.5% of every trade into `[creator, quote_mint]` under
+*     LaunchLab. One vault per wallet **per quote asset**, not one per coin, so a single
+*     `claim_creator_fee` sweeps every coin that creator launched against that quote. A creator
+*     with a SOL machine and a USDC machine claims twice, once per quote.
+*   - **After graduation.** The CPMM pool keeps the creator's fee inside the pool account, and
+*     `collect_creator_fee` pays it out. That is per pool, so it takes one call per coin.
+*
+* Both instructions pay into the creator's associated token account for the quote mint, under that
+* mint's own token program. When the quote is WSOL, every builder here closes that account
+* afterwards, so the creator ends up with plain SOL. For any other quote the account is created if
+* missing and left alone: closing it would throw away a real balance.
+*
+* **Closing unwraps everything.** If the creator already held WSOL in that account before the
+* claim, closing turns that into SOL too. Nothing is lost, but the balance moves.
+*/
+/**
+* Create the creator's quote account, if it is missing, and close it again when it is WSOL.
+*
+* Raydium's own instructions create the account when they need to, but an idempotent create here
+* costs nothing and makes the flow the same whichever instruction runs. The close is what turns
+* WSOL into SOL, so it only belongs on a WSOL claim: closing a USDC account would throw the payout
+* away.
+*/
+async function wrapAround(creator, quote, middle) {
+	const account = await ata(creator.address, quote.mint, quote.tokenProgram);
+	const create = getCreateAssociatedTokenIdempotentInstruction({
+		payer: creator,
+		ata: account,
+		owner: creator.address,
+		mint: quote.mint,
+		tokenProgram: quote.tokenProgram
+	});
+	if (quote.mint !== "So11111111111111111111111111111111111111112") return [create, ...middle];
+	return [
+		create,
+		...middle,
+		getCloseAccountInstruction({
+			account,
+			destination: creator.address,
+			owner: creator
+		})
+	];
+}
+/** Attach a signer to the one slot the ABI marks as signing. Roles never change here. */
+function withSigner(accounts, signer) {
+	return accounts.map((meta) => (meta.role === AccountRole.READONLY_SIGNER || meta.role === AccountRole.WRITABLE_SIGNER) && meta.address === signer.address ? {
+		...meta,
+		signer
+	} : meta);
+}
+/**
+* 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.
+*/
+async function getClaimCreatorFeeInstructions(creator, ids, quote) {
+	return await wrapAround(creator, quote, [{
+		programAddress: ids.launchlab,
+		accounts: withSigner(order(LAUNCHLAB_CLAIM_CREATOR_FEE, {
+			creator: creator.address,
+			fee_vault_authority: await creatorFeeVaultAuthority(ids.launchlab),
+			creator_fee_vault: await creatorFeeVaultAddress(ids.launchlab, creator.address, quote.mint),
+			recipient_token_account: await ata(creator.address, quote.mint, quote.tokenProgram),
+			quote_mint: quote.mint,
+			token_program: quote.tokenProgram,
+			system_program: SYSTEM_PROGRAM_ADDRESS,
+			associated_token_program: ASSOCIATED_TOKEN_PROGRAM_ADDRESS
+		}), creator),
+		data: new Uint8Array(LAUNCHLAB_CLAIM_CREATOR_FEE.discriminator)
+	}]);
+}
+/**
+* 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.
+*/
+async function claimCreatorFee(client, input) {
+	const ids = raydiumIds(client.cluster);
+	const quote = await quoteOf(client, input.quoteMint ?? "So11111111111111111111111111111111111111112");
+	const instructions = await getClaimCreatorFeeInstructions(input.creator, ids, quote);
+	return await buildMessage(client, input.creator, instructions, {
+		addressLookupTables: input.addressLookupTables,
+		computeUnitLimit: input.computeUnitLimit ?? 55e3,
+		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+	});
+}
+/**
+* The token program a quote mint lives under. WSOL is always classic SPL Token, so that one needs
+* no read at all.
+*/
+async function quoteOf(client, mint) {
+	if (mint === "So11111111111111111111111111111111111111112") return {
+		mint,
+		tokenProgram: TOKEN_PROGRAM_ADDRESS
+	};
+	return {
+		mint,
+		tokenProgram: (await fetchQuoteDisplay(client, mint)).tokenProgram
+	};
+}
+/**
+* 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.
+*/
+async function getCollectCreatorFeeInstructions(client, input, ids = raydiumIds(client.cluster)) {
+	const { mint, creator } = input;
+	const quote = input.quote ?? await fetchQuoteBinding(client, mint);
+	const settings = await fetchCurveSettings(client, quote.config, ids);
+	const { address: poolState, pool } = await findCpmmPool(client, {
+		mint,
+		quoteMint: quote.mint,
+		creator: creator.address,
+		cpswapConfig: settings.cpswapConfig
+	});
+	const collect = {
+		programAddress: ids.cpmm,
+		accounts: withSigner(order(CPMM_COLLECT_CREATOR_FEE, {
+			creator: creator.address,
+			authority: ids.cpmmAuthority,
+			pool_state: poolState,
+			amm_config: pool.ammConfig,
+			token_0_vault: pool.token0Vault,
+			token_1_vault: pool.token1Vault,
+			vault_0_mint: pool.token0Mint,
+			vault_1_mint: pool.token1Mint,
+			creator_token_0: await ata(creator.address, pool.token0Mint, pool.token0Program),
+			creator_token_1: await ata(creator.address, pool.token1Mint, pool.token1Program),
+			token_0_program: pool.token0Program,
+			token_1_program: pool.token1Program,
+			associated_token_program: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+			system_program: SYSTEM_PROGRAM_ADDRESS,
+			creator_fee_share: await cpmmCreatorFeeShare(ids.cpmm, creator.address, pool.ammConfig)
+		}), creator),
+		data: new Uint8Array(CPMM_COLLECT_CREATOR_FEE.discriminator)
+	};
+	return await wrapAround(creator, {
+		mint: quote.mint,
+		tokenProgram: quote.tokenProgram
+	}, [collect]);
+}
+/**
+* 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.
+*/
+async function collectCreatorFee(client, input) {
+	const instructions = await getCollectCreatorFeeInstructions(client, {
+		mint: input.mint,
+		creator: input.creator,
+		...input.quote ? { quote: input.quote } : {}
+	});
+	return await buildMessage(client, input.creator, instructions, {
+		addressLookupTables: input.addressLookupTables,
+		computeUnitLimit: input.computeUnitLimit ?? 55e3,
+		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+	});
+}
+/**
+* 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.
+*/
+async function fetchCreatorFees(client, input) {
+	const ids = raydiumIds(client.cluster);
+	const quoteMint = input.quoteMint ?? "So11111111111111111111111111111111111111112";
+	const vault = await creatorFeeVaultAddress(ids.launchlab, input.creator, quoteMint);
+	const [vaultAccount] = await readAccounts(client.rpc, [vault]);
+	const curveQuote = vaultAccount ? tokenAccountAmount(vaultAccount.data) : 0n;
+	if (!input.mint) return {
+		quoteMint,
+		curveQuote,
+		cpmmQuote: 0n,
+		cpmmTokens: 0n
+	};
+	const settings = await fetchCurveSettings(client, await launchlabGlobalConfig(ids.launchlab, quoteMint), ids);
+	try {
+		const { pool } = await findCpmmPool(client, {
+			mint: input.mint,
+			quoteMint,
+			creator: input.creator,
+			cpswapConfig: settings.cpswapConfig
+		});
+		const [token0] = sortedMints(input.mint, quoteMint);
+		const baseIsToken0 = token0 === input.mint;
+		return {
+			quoteMint,
+			curveQuote,
+			cpmmQuote: baseIsToken0 ? pool.creatorFeesToken1 : pool.creatorFeesToken0,
+			cpmmTokens: baseIsToken0 ? pool.creatorFeesToken0 : pool.creatorFeesToken1
+		};
+	} catch {
+		return {
+			quoteMint,
+			curveQuote,
+			cpmmQuote: 0n,
+			cpmmTokens: 0n
+		};
+	}
+}
+//#endregion
+//#region src/raydium/trade.ts
+/**
+* A venue trade a wallet sends on its own, outside any Gabox instruction.
+*
+* Pack buys and token sales go through `buy_pack` and `sell_tokens`: they take the venue's account
+* list as `remainingAccounts` and the Gabox program does the call. This file is for the one trade
+* Gabox never makes, a plain `buy_exact_in` on the curve. Anyone may trade a Gabox coin directly,
+* and the devnet end-to-end test uses this to buy the rest of the curve and force graduation.
+*
+* The account list and the discriminator both come from `abi.ts`, which codegen took from
+* Raydium's IDL. Nothing here retypes either.
+*/
+const u64 = getU64Encoder();
+/**
+* `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.
+*/
+async function getCurveBuyExactInInstruction(client, input, ids = raydiumIds(client.cluster)) {
+	if (input.quoteIn <= 0n) throw new Error("quoteIn must be positive");
+	if (input.minTokensOut < 0n) throw new Error("minTokensOut must not be negative");
+	const quoteMint = input.quoteMint ?? "So11111111111111111111111111111111111111112";
+	const quoteTokenProgram = input.quoteTokenProgram ?? "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+	const poolState = await launchlabPoolAddress(ids.launchlab, input.mint, quoteMint);
+	const accounts = launchlabBuyExactInAccounts({
+		launchlab: ids.launchlab,
+		launchlabAuthority: ids.launchlabAuthority,
+		launchlabEventAuthority: ids.launchlabEventAuthority,
+		globalConfig: await launchlabGlobalConfig(ids.launchlab, quoteMint),
+		platformConfig: ids.gaboxPlatform,
+		poolState,
+		mint: input.mint,
+		quoteMint,
+		baseVault: await launchlabVaultAddress(ids.launchlab, poolState, input.mint),
+		quoteVault: await launchlabVaultAddress(ids.launchlab, poolState, quoteMint),
+		user: input.user.address,
+		userBaseToken: await ata(input.user.address, input.mint),
+		userQuoteToken: await ata(input.user.address, quoteMint, quoteTokenProgram),
+		quoteTokenProgram,
+		platformFeeVault: await platformFeeVaultAddress(ids.launchlab, ids.gaboxPlatform, quoteMint),
+		creatorFeeVault: await creatorFeeVaultAddress(ids.launchlab, input.creator, quoteMint)
+	});
+	return {
+		programAddress: ids.launchlab,
+		accounts: attachSigner(accounts, input.user),
+		data: new Uint8Array([
+			...LAUNCHLAB_BUY_EXACT_IN.discriminator,
+			...u64.encode(input.quoteIn),
+			...u64.encode(input.minTokensOut),
+			...u64.encode(SHARE_FEE_RATE)
+		])
+	};
+}
+/** Give the signer to the slot the ABI already marks as signing. Roles never change here. */
+function attachSigner(accounts, signer) {
+	let matched = false;
+	const withSigner = accounts.map((meta) => {
+		if (!(meta.role === 2 || meta.role === 3) || meta.address !== signer.address) return meta;
+		matched = true;
+		return {
+			...meta,
+			signer
+		};
+	});
+	if (!matched) throw new Error(`${signer.address} is not the signing account of this trade. Build the account list with the same wallet you are going to sign with.`);
+	return withSigner;
+}
+//#endregion
+//#region src/raydium/index.ts
+var raydium_exports = /* @__PURE__ */ __exportAll({
+	ASSOCIATED_TOKEN_PROGRAM_ADDRESS: () => ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+	CONSTANT_CURVE_TAG: () => 0,
+	CPMM_AMM_CONFIG_DISCRIMINATOR: () => CPMM_AMM_CONFIG_DISCRIMINATOR,
+	CPMM_AMM_CONFIG_HEAD_SIZE: () => 116,
+	CPMM_COLLECT_CREATOR_FEE: () => CPMM_COLLECT_CREATOR_FEE,
+	CPMM_POOL_OFFSETS: () => CPMM_POOL_OFFSETS,
+	CPMM_POOL_STATE_DISCRIMINATOR: () => CPMM_POOL_STATE_DISCRIMINATOR,
+	CPMM_POOL_STATE_HEAD_SIZE: () => 413,
+	CPMM_POOL_STATE_SIZE: () => 637,
+	CPMM_SEEDS: () => CPMM_SEEDS,
+	CPMM_SWAP_BASE_INPUT: () => CPMM_SWAP_BASE_INPUT,
+	CPMM_SWAP_BASE_OUTPUT: () => CPMM_SWAP_BASE_OUTPUT,
+	CREATOR_FEE_ON_QUOTE: () => 0,
+	LAUNCHLAB_BUY_EXACT_IN: () => LAUNCHLAB_BUY_EXACT_IN,
+	LAUNCHLAB_BUY_EXACT_OUT: () => LAUNCHLAB_BUY_EXACT_OUT,
+	LAUNCHLAB_CLAIM_CREATOR_FEE: () => LAUNCHLAB_CLAIM_CREATOR_FEE,
+	LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR: () => LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR,
+	LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE: () => 115,
+	LAUNCHLAB_INITIALIZE: () => LAUNCHLAB_INITIALIZE,
+	LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR: () => LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR,
+	LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE: () => 940,
+	LAUNCHLAB_POOL_STATE_DISCRIMINATOR: () => LAUNCHLAB_POOL_STATE_DISCRIMINATOR,
+	LAUNCHLAB_POOL_STATE_HEAD_SIZE: () => 367,
+	LAUNCHLAB_SEEDS: () => LAUNCHLAB_SEEDS,
+	LAUNCHLAB_SELL_EXACT_IN: () => LAUNCHLAB_SELL_EXACT_IN,
+	LAUNCHLAB_STATUS_FUND: () => 0,
+	LAUNCHLAB_STATUS_MIGRATE: () => 1,
+	LAUNCHLAB_STATUS_TRADE: () => 2,
+	LAUNCH_DECIMALS: () => 6,
+	LAUNCH_SUPPLY: () => LAUNCH_SUPPLY,
+	LAUNCH_TOTAL_BASE_SELL: () => LAUNCH_TOTAL_BASE_SELL,
+	METADATA_LIMITS: () => METADATA_LIMITS,
+	METADATA_SEED: () => METADATA_SEED,
+	METAPLEX_PROGRAM_ADDRESS: () => METAPLEX_PROGRAM_ADDRESS,
+	MIGRATE_TO_CPMM: () => 1,
+	PLATFORM_ADMIN: () => PLATFORM_ADMIN,
+	RATE_DENOMINATOR: () => RATE_DENOMINATOR,
+	RAYDIUM_DEVNET_IDS: () => RAYDIUM_DEVNET_IDS,
+	RAYDIUM_IDS: () => RAYDIUM_IDS,
+	RAYDIUM_MAINNET_IDS: () => RAYDIUM_MAINNET_IDS,
+	RENT_SYSVAR_ADDRESS: () => RENT_SYSVAR_ADDRESS,
+	SHARE_FEE_RATE: () => SHARE_FEE_RATE,
+	SYSTEM_PROGRAM_ADDRESS: () => SYSTEM_PROGRAM_ADDRESS,
+	TOKEN_2022_PROGRAM_ADDRESS: () => TOKEN_2022_PROGRAM_ADDRESS,
+	TOKEN_PROGRAM_ADDRESS: () => TOKEN_PROGRAM_ADDRESS,
+	WSOL_MINT: () => WSOL_MINT,
+	ata: () => ata,
+	ceilDiv: () => ceilDiv,
+	ceilDivRate: () => ceilDivRate,
+	claimCreatorFee: () => claimCreatorFee,
+	collectCreatorFee: () => collectCreatorFee,
+	compareAddresses: () => compareAddresses,
+	cpmmAuthority: () => cpmmAuthority,
+	cpmmBuyAccounts: () => cpmmBuyAccounts,
+	cpmmCreatorFeeShare: () => cpmmCreatorFeeShare,
+	cpmmPoolAddress: () => cpmmPoolAddress,
+	cpmmPoolMatches: () => cpmmPoolMatches,
+	cpmmSellAccounts: () => cpmmSellAccounts,
+	cpmmSwapBaseInput: () => cpmmSwapBaseInput,
+	cpmmSwapBaseOutput: () => cpmmSwapBaseOutput,
+	creatorFeeOnInput: () => creatorFeeOnInput,
+	creatorFeeVaultAddress: () => creatorFeeVaultAddress,
+	creatorFeeVaultAuthority: () => creatorFeeVaultAuthority,
+	curveBuyExactIn: () => curveBuyExactIn,
+	curveBuyExactOut: () => curveBuyExactOut,
+	curveQuote: () => curveQuote,
+	curveSellExactIn: () => curveSellExactIn,
+	decodeBase64: () => decodeBase64,
+	decodeCpmmAmmConfig: () => decodeCpmmAmmConfig,
+	decodeCpmmPool: () => decodeCpmmPool,
+	decodeLaunchlabGlobalConfig: () => decodeLaunchlabGlobalConfig,
+	decodeLaunchlabPlatformConfig: () => decodeLaunchlabPlatformConfig,
+	decodeLaunchlabPool: () => decodeLaunchlabPool,
+	fetchCreatorFees: () => fetchCreatorFees,
+	fetchCurveSettings: () => fetchCurveSettings,
+	fetchQuoteAsset: () => fetchQuoteAsset,
+	fetchQuoteBinding: () => fetchQuoteBinding,
+	fetchQuoteConfig: () => fetchQuoteConfig,
+	fetchQuoteDisplay: () => fetchQuoteDisplay,
+	findCpmmPool: () => findCpmmPool,
+	getClaimCreatorFeeInstructions: () => getClaimCreatorFeeInstructions,
+	getCollectCreatorFeeInstructions: () => getCollectCreatorFeeInstructions,
+	getCurveBuyExactInInstruction: () => getCurveBuyExactInInstruction,
+	getLaunchInstruction: () => getLaunchInstruction,
+	initialCurve: () => initialCurve,
+	isQuoteSupported: () => isQuoteSupported,
+	launchlabAuthority: () => launchlabAuthority,
+	launchlabBuyAccounts: () => launchlabBuyAccounts,
+	launchlabBuyExactInAccounts: () => launchlabBuyExactInAccounts,
+	launchlabEventAuthority: () => launchlabEventAuthority,
+	launchlabGlobalConfig: () => launchlabGlobalConfig,
+	launchlabPlatformConfig: () => launchlabPlatformConfig,
+	launchlabPoolAddress: () => launchlabPoolAddress,
+	launchlabSellAccounts: () => launchlabSellAccounts,
+	launchlabVaultAddress: () => launchlabVaultAddress,
+	metadataAddress: () => metadataAddress,
+	metaplexSymbol: () => metaplexSymbol,
+	mintDecimals: () => mintDecimals,
+	newCurveBuyCost: () => newCurveBuyCost,
+	newCurveReserves: () => newCurveReserves,
+	order: () => order,
+	platformFeeVaultAddress: () => platformFeeVaultAddress,
+	preFeeAmount: () => preFeeAmount,
+	quoteAccountFor: () => quoteAccountFor,
+	raydiumIds: () => raydiumIds,
+	readAccounts: () => readAccounts,
+	remainingBase: () => remainingBase,
+	resolveVenue: () => resolveVenue,
+	sellQuote: () => sellQuote,
+	sortedMints: () => sortedMints,
+	token2022Symbol: () => token2022Symbol,
+	tokenAccountAmount: () => tokenAccountAmount,
+	tokenAccountOwnerAndMint: () => tokenAccountOwnerAndMint,
+	totalCurveFeeRate: () => totalCurveFeeRate,
+	wsolAccountFor: () => wsolAccountFor
+});
+//#endregion
+export { computeBudgetInstructions as $, LAUNCHLAB_BUY_EXACT_OUT as $n, launchlabVaultAddress as $t, initialCurve as A, CPMM_SEEDS as An, metaplexSymbol as At, fetchQuoteAsset as B, RATE_DENOMINATOR as Bn, vaultAddress as Bt, ceilDiv as C, PACK_TOKENS as Cn, LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE as Ct, curveBuyExactIn as D, VRF_DEFAULT_QUEUE as Dn, decodeLaunchlabGlobalConfig as Dt, cpmmSwapBaseOutput as E, TIMEOUT_SLOTS as En, decodeCpmmPool as Et, cpmmSellAccounts as F, LAUNCHLAB_STATUS_TRADE as Fn, activityAddress as Ft, readAccounts as G, sortedMints as Gn, cpmmPoolAddress as Gt, fetchQuoteDisplay as H, SHARE_FEE_RATE as Hn, ata as Ht, launchlabBuyAccounts as I, LAUNCH_DECIMALS as In, associatedTokenAddress as It, COMPUTE_BUDGET_PROGRAM_ADDRESS as J, CPMM_COLLECT_CREATOR_FEE as Jn, launchlabAuthority as Jt, BUY_PACK_COMPUTE_UNITS as K, ASSOCIATED_TOKEN_PROGRAM_ADDRESS as Kn, creatorFeeVaultAddress as Kt, launchlabBuyExactInAccounts as L, METADATA_LIMITS as Ln, drawAddress as Lt, remainingBase as M, LAUNCHLAB_SEEDS as Mn, token2022Symbol as Mt, totalCurveFeeRate as N, LAUNCHLAB_STATUS_FUND as Nn, tokenAccountAmount as Nt, curveBuyExactOut as O, VRF_PROGRAM_ADDRESS as On, decodeLaunchlabPlatformConfig as Ot, cpmmBuyAccounts as P, LAUNCHLAB_STATUS_MIGRATE as Pn, tokenAccountOwnerAndMint as Pt, REDEEM_COMPUTE_UNITS as Q, LAUNCHLAB_BUY_EXACT_IN as Qn, launchlabPoolAddress as Qt, launchlabSellAccounts as R, METADATA_SEED as Rn, poolAddress as Rt, wsolAccountFor as S, MAX_ATTEMPTS as Sn, LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE as St, cpmmSwapBaseInput as T, SLOT_HASHES_SYSVAR as Tn, decodeCpmmAmmConfig as Tt, isQuoteSupported as U, compareAddresses as Un, cpmmAuthority as Ut, fetchQuoteConfig as V, RAYDIUM_IDS as Vn, vrfIdentityAddress as Vt, decodeBase64 as W, raydiumIds as Wn, cpmmCreatorFeeShare as Wt, DEFAULT_COMPUTE_UNIT_LIMIT as X, CPMM_SWAP_BASE_INPUT as Xn, launchlabGlobalConfig as Xt, CREATE_MACHINE_COMPUTE_UNITS as Y, CPMM_POOL_STATE_DISCRIMINATOR as Yn, launchlabEventAuthority as Yt, MAX_COMPUTE_UNIT_LIMIT as Z, CPMM_SWAP_BASE_OUTPUT as Zn, launchlabPlatformConfig as Zt, newCurveBuyCost as _, validatePack as _n, tiersOf as _t, fetchCreatorFees as a, MAX_MULTIPLIER_BPS as an, LAUNCHLAB_SELL_EXACT_IN as ar, POOL_MINT_OFFSET as at, resolveVenue as b, IDENTITY_SEED as bn, CPMM_POOL_STATE_HEAD_SIZE as bt, getLaunchInstruction as c, TIERS as cn, METAPLEX_PROGRAM_ADDRESS as cr, fetchPoolByMint as ct, cpmmPoolMatches as d, maxMultiplierBps as dn, RAYDIUM_MAINNET_IDS as dr, fetchWalletActivity as dt, metadataAddress as en, LAUNCHLAB_CLAIM_CREATOR_FEE as er, getSetComputeUnitLimitInstruction as et, creatorFeeOnInput as f, quote as fn, RENT_SYSVAR_ADDRESS as fr, listDraws as ft, findCpmmPool as g, uncappedMaximum as gn, WSOL_MINT as gr, quotePool as gt, fetchQuoteBinding as h, tierAmount as hn, TOKEN_PROGRAM_ADDRESS as hr, listPools as ht, collectCreatorFee as i, GaboxMathError as in, LAUNCHLAB_POOL_STATE_DISCRIMINATOR as ir, POOL_CREATOR_OFFSET as it, preFeeAmount as j, CREATOR_FEE_ON_QUOTE as jn, mintDecimals as jt, curveSellExactIn as k, CONSTANT_CURVE_TAG as kn, decodeLaunchlabPool as kt, buildMessage as l, averageMultiplierBps as ln, PLATFORM_ADMIN as lr, fetchPoolInventory as lt, fetchCurveSettings as m, seedTokens as mn, TOKEN_2022_PROGRAM_ADDRESS as mr, listDrawsByPurchaser as mt, getCurveBuyExactInInstruction as n, BPS as nn, LAUNCHLAB_INITIALIZE as nr, DRAW_POOL_OFFSET as nt, getClaimCreatorFeeInstructions as o, MIN_SEED_MULTIPLIER_BPS as on, LAUNCH_SUPPLY as or, fetchDraw as ot, curveQuote as p, resolveReservation as pn, SYSTEM_PROGRAM_ADDRESS as pr, listDrawsByPool as pt, CLAIM_COMPUTE_UNITS as q, CPMM_AMM_CONFIG_DISCRIMINATOR as qn, creatorFeeVaultAuthority as qt, claimCreatorFee as r, DEFAULT_TIERS as rn, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR as rr, DRAW_PURCHASER_OFFSET as rt, getCollectCreatorFeeInstructions as s, TICKETS as sn, LAUNCH_TOTAL_BASE_SELL as sr, fetchPoolAt as st, raydium_exports as t, platformFeeVaultAddress as tn, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR as tr, getSetComputeUnitPriceInstruction as tt, withRemainingAccounts as u, choose as un, RAYDIUM_DEVNET_IDS as ur, fetchVaultBalance as ut, newCurveReserves as v, validateTiers as vn, CPMM_AMM_CONFIG_HEAD_SIZE as vt, ceilDivRate as w, RETRY_SLOTS as wn, LAUNCHLAB_POOL_STATE_HEAD_SIZE as wt, sellQuote as x, INSTRUCTIONS_SYSVAR as xn, CPMM_POOL_STATE_SIZE as xt, quoteAccountFor as y, GABOX_PROGRAM_ID as yn, CPMM_POOL_OFFSETS as yt, order as z, MIGRATE_TO_CPMM as zn, scopedVrfIdentityAddress as zt };
+
+//# sourceMappingURL=raydium-CU-tZzIk.js.map