@gabox-labs/sdk 0.1.1 → 0.6.0

package/dist/raydium-B-l9V3O-.js

@@ -0,0 +1,2604 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { AccountRole, Endian, addEncoderSizePrefix, appendTransactionMessageInstructions, compileTransaction, compressTransactionMessageUsingAddressLookupTables, createTransactionMessage, fixDecoderSize, getAddressDecoder, getAddressEncoder, getBase64Encoder, getBooleanDecoder, getBytesDecoder, 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",
+	solGlobalConfig: "6s1xP3hpbAfFoNtUNF8mfHsjr2Bd97JxFJRWLbL6aHuX",
+	gaboxPlatform: "8tXUG97CEpSKTNXdGtanYyC33RWmTTuSin4VdaWwNj8q",
+	cpmm: "CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C",
+	cpmmAuthority: "GpMZbSM2GgvTKHJirzeGfMFoaZ8UR2X7F4v8vHTvxFbL",
+	launchQuoteRaise: 85000000000n
+};
+const RAYDIUM_DEVNET_IDS = {
+	launchlab: "DRay6fNdQ5J82H7xV6uq2aV3mNrUZ1J4PgSKsWgptcm6",
+	launchlabAuthority: "5xqNaZXX5eUi4p5HU4oz9i5QnwRNT2y6oN7yyn4qENeq",
+	launchlabEventAuthority: "4uAB7seenFJKPUXqYewAdfra2u6baBgjiXU8x1SC7Ycz",
+	solGlobalConfig: "7ZR4zD7PYfY2XxoG1Gxcy2EgEeGYrpxrwzPuwdUBssEt",
+	gaboxPlatform: "DdEeCPXbCAzHE2PZSoR3RZng4WA4bSztrezQznrJ4ooB",
+	cpmm: "DRaycpLY18LhpbydsBWbVJtxpNv9oXPgjRSfpF2bWpYb",
+	cpmmAuthority: "CXniRufdq5xL8t8jZAPxsPZDpuudwuJSPWnbcD5Y5Nxq",
+	launchQuoteRaise: 3000000000n
+};
+/** Wrapped SOL. The only quote Gabox accepts today, on both venues. */
+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. LaunchLab pins it on both sides of every Gabox launch and trade. */
+const TOKEN_PROGRAM_ADDRESS = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+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 quote the curve must raise before a coin graduates. 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 WSOL. */
+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/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/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 = 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)
+	};
+}
+/** 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);
+	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);
+	return {
+		curveType: head.curveType,
+		index: head.index,
+		migrateFee: head.migrateFee,
+		tradeFeeRate: head.tradeFeeRate,
+		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);
+	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);
+	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);
+	return {
+		index: head.index,
+		disableCreatePool: head.disableCreatePool,
+		tradeFeeRate: head.tradeFeeRate,
+		protocolFeeRate: head.protocolFeeRate,
+		fundFeeRate: head.fundFeeRate,
+		creatorFeeRate: head.creatorFeeRate
+	};
+}
+//#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.
+*
+* 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 `293,004`, `264,249` and `268,749`. The first run is the
+* worst case: that creator had no LaunchLab fee vault yet, so the transaction created one.
+*/
+const CREATE_MACHINE_COMPUTE_UNITS = 385e3;
+/**
+* A WSOL wrap, a venue buy, an escrow transfer, a draw init, a VRF request and the WSOL close.
+* Measured at `164,717`, `167,723` and `181,225` on the curve, and `116,332`, `113,342` and
+* `119,334` 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 = 24e4;
+/**
+* A WSOL wrap, a venue sale, and the WSOL close. Measured at `93,827`, `93,827` and `101,327` on
+* the curve, and `61,041`, `64,041` and `67,041` on CPMM.
+*/
+const REDEEM_COMPUTE_UNITS = 135e3;
+/**
+* A creator fee claim: create the WSOL account, claim or collect, close it again. Measured at
+* `31,319` every run for the LaunchLab claim, and `40,959` every run for the CPMM collect.
+*/
+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/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. LaunchLab names its accounts by role instead, and uses one list for both sides.
+*/
+/**
+* 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: TOKEN_PROGRAM_ADDRESS,
+		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: TOKEN_PROGRAM_ADDRESS,
+		output_token_program: TOKEN_PROGRAM_ADDRESS,
+		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
+/**
+* Reading the venue: which one a coin trades on right now, what a pack costs there, and the account
+* list for the trade.
+*
+* `resolveVenue` reads every account the answer depends on, decodes them, and hands back a plain
+* object whose methods are pure. A caller that wants to re-price a different token count calls
+* `quoteBuy` again with no further reads.
+*
+* # Choosing the venue
+*
+* The LaunchLab pool's `status` is the whole rule:
+*
+*   - `0`: the curve is still selling, so trade LaunchLab.
+*   - `1`: the raise is finished and Raydium's own bot is moving the coin into a CPMM pool. Nothing
+*     trades. This throws, and the message says to retry in a moment. On devnet the move usually
+*     finishes within a minute.
+*   - `2`: the coin graduated, so trade its CPMM pool.
+*
+* A coin can graduate between the read and the send. A pack buy then fails and no draw is created,
+* which is the intended outcome: refresh and retry.
+*
+* # Finding the migrated CPMM pool
+*
+* The pool is normally at `["pool", cpswap_config, token_0, token_1]` under CPMM, where
+* `cpswap_config` is the fee tier the Gabox platform config names. It is not always: when that
+* address is already taken, Raydium migrates into a random account instead. So this module tries
+* the derived address first and falls back to a filtered `getProgramAccounts` scan.
+*
+* Either way the pool has to prove itself from its own data, which is what `venue/trade.rs` checks
+* on chain as well: CPMM owns it, it carries the `PoolState` discriminator, its `pool_creator` is
+* the coin creator, its two mints are the sorted pair, and `enable_creator_fee` is true. That last
+* flag is the one that cannot be forged. A plain CPMM `initialize` always leaves it false; only a
+* creator Raydium has permissioned, such as LaunchLab's migration, can set it.
+*/
+const base64$1 = getBase64Encoder();
+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$1.encode(encoded)),
+			owner: account.owner
+		};
+	});
+}
+/**
+* The user's WSOL associated token account.
+*
+* Both venues settle in WSOL, never in native SOL. This account must exist and hold enough before a
+* pack is bought, and sale proceeds land in it. Every builder in `tx/` wraps the SOL it needs into
+* this account and closes it again in the same transaction.
+*/
+async function wsolAccountFor(user) {
+	return await ata(user, WSOL_MINT);
+}
+/** Read the two pinned config accounts and take the four numbers a quote needs out of them. */
+async function fetchCurveSettings(client, ids = raydiumIds(client.cluster)) {
+	const [globalAccount, platformAccount] = await readAccounts(client.rpc, [ids.solGlobalConfig, ids.gaboxPlatform]);
+	if (!globalAccount) throw new Error(`LaunchLab's WSOL global config is missing at ${ids.solGlobalConfig}`);
+	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 quoteMint = WSOL_MINT;
+	const curvePool = await launchlabPoolAddress(ids.launchlab, mint, quoteMint);
+	const [poolAccount, globalAccount, platformAccount] = await readAccounts(client.rpc, [
+		curvePool,
+		ids.solGlobalConfig,
+		ids.gaboxPlatform
+	]);
+	if (!poolAccount) throw new Error(`no LaunchLab pool at ${curvePool}. The coin was not launched on LaunchLab with WSOL as its quote, so it has no Gabox venue.`);
+	if (!globalAccount) throw new Error(`LaunchLab's WSOL global config is missing at ${ids.solGlobalConfig}`);
+	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 !== quoteMint) 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,
+			quoteMint,
+			user,
+			poolState: curvePool
+		});
+	}
+	return await cpmmVenue(client, ids, pool, settings.cpswapConfig, {
+		mint,
+		quoteMint,
+		user
+	});
+}
+async function launchlabVenue(ids, pool, rates, where) {
+	const { mint, quoteMint, user, poolState } = where;
+	const shared = {
+		launchlab: ids.launchlab,
+		launchlabAuthority: ids.launchlabAuthority,
+		launchlabEventAuthority: ids.launchlabEventAuthority,
+		globalConfig: ids.solGlobalConfig,
+		platformConfig: ids.gaboxPlatform,
+		poolState,
+		mint,
+		quoteMint,
+		baseVault: await launchlabVaultAddress(ids.launchlab, poolState, mint),
+		quoteVault: await launchlabVaultAddress(ids.launchlab, poolState, quoteMint),
+		user,
+		userBaseToken: await ata(user, mint),
+		userQuoteToken: await ata(user, quoteMint),
+		platformFeeVault: await platformFeeVaultAddress(ids.launchlab, ids.gaboxPlatform, quoteMint),
+		creatorFeeVault: await creatorFeeVaultAddress(ids.launchlab, pool.creator, quoteMint)
+	};
+	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,
+		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(new Uint8Array(base64$1.encode(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, quoteMint, user } = where;
+	const { address: poolState, pool } = await findCpmmPool(client, {
+		mint,
+		quoteMint,
+		creator: curve.creator,
+		cpswapConfig
+	});
+	const baseIsToken0 = pool.token0Mint === mint;
+	const baseVault = baseIsToken0 ? pool.token0Vault : pool.token1Vault;
+	const quoteVault = baseIsToken0 ? pool.token1Vault : pool.token0Vault;
+	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 shared = {
+		cpmmAuthority: ids.cpmmAuthority,
+		ammConfig: pool.ammConfig,
+		poolState,
+		mint,
+		quoteMint,
+		baseVault,
+		quoteVault,
+		observationState: pool.observationKey,
+		user,
+		userBaseToken: await ata(user, mint),
+		userQuoteToken: await ata(user, quoteMint)
+	};
+	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, quoteMint)
+	};
+	const sellRates = {
+		tradeFeeRate: config.tradeFeeRate,
+		creatorFeeRate,
+		creatorFeeOnInput: creatorFeeOnInput(pool, mint)
+	};
+	return {
+		kind: "cpmm",
+		program: ids.cpmm,
+		mint,
+		quoteMint,
+		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 WSOL 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;
+}
+/**
+* WSOL an exact-coins-out buy of `tokens` costs right now, on whichever venue the coin trades.
+* Pass `pool.packTokens` for the pack price.
+*
+* Use `resolveVenue` when you also need the account list, which every transaction builder does.
+* This is for a price display.
+*/
+async function curveQuote(client, mint, tokens, options = {}) {
+	return (await resolveVenue(client, {
+		mint,
+		user: options.user ?? mint,
+		...options.venue ? { venue: options.venue } : {}
+	})).quoteBuy(tokens);
+}
+/** WSOL 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 } : {}
+	})).quoteSell(tokens);
+}
+/**
+* WSOL an exact-coins-out buy of `tokens` would cost on a curve that does not exist yet, fees
+* included.
+*
+* This is what the seed costs. `initialize_pool` buys it in the same transaction that creates the
+* coin, so the curve is a brand-new LaunchLab curve with the pinned Gabox launch shape at that
+* moment. Exact, unless Raydium changes a fee rate between this read and the send.
+*/
+async function newCurveBuyCost(client, tokens) {
+	if (tokens <= 0n) return 0n;
+	const ids = raydiumIds(client.cluster);
+	const settings = await fetchCurveSettings(client, ids);
+	return curveBuyExactOut(newCurveReserves(ids, settings.migrateFee), settings.rates, tokens);
+}
+/** The starting reserves of a brand-new Gabox curve on this cluster. */
+function newCurveReserves(ids, migrateFee) {
+	return initialCurve({
+		supply: LAUNCH_SUPPLY,
+		totalBaseSell: LAUNCH_TOTAL_BASE_SELL,
+		quoteRaise: ids.launchQuoteRaise,
+		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 |
+* | curve | `Constant` |
+* | `supply` | 1,000,000,000 coins |
+* | `total_base_sell` | 793,100,000 coins |
+* | `total_quote_fund_raising` | 85 SOL on mainnet, 3 SOL on devnet |
+* | `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 = WSOL_MINT;
+	const poolState = await launchlabPoolAddress(ids.launchlab, mint.address, quoteMint);
+	const metas = order(LAUNCHLAB_INITIALIZE, {
+		payer: creator.address,
+		creator: creator.address,
+		global_config: ids.solGlobalConfig,
+		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: TOKEN_PROGRAM_ADDRESS,
+		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: ids.launchQuoteRaise,
+		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, WSOL]` under LaunchLab.
+*     One vault per wallet, not one per coin, so a single `claim_creator_fee` sweeps every coin
+*     that creator launched.
+*   - **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 WSOL associated token account. Every builder here closes
+* that account afterwards, so the creator ends up with plain SOL in their wallet.
+*
+* **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.
+*/
+const base64 = getBase64Encoder();
+/**
+* Create the creator's WSOL account, if it is missing, and close it again at the end.
+*
+* 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 the
+* WSOL into SOL.
+*/
+async function wrapAround(creator, middle) {
+	const account = await ata(creator.address, WSOL_MINT);
+	return [
+		getCreateAssociatedTokenIdempotentInstruction({
+			payer: creator,
+			ata: account,
+			owner: creator.address,
+			mint: WSOL_MINT,
+			tokenProgram: TOKEN_PROGRAM_ADDRESS
+		}),
+		...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: create the WSOL account, claim, close it.
+*
+* This sweeps **every** coin this wallet launched, because LaunchLab keeps one vault per wallet per
+* quote asset. There is no per-coin version.
+*/
+async function getClaimCreatorFeeInstructions(creator, ids) {
+	const quoteMint = WSOL_MINT;
+	return await wrapAround(creator, [{
+		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, quoteMint),
+			recipient_token_account: await ata(creator.address, quoteMint),
+			quote_mint: quoteMint,
+			token_program: TOKEN_PROGRAM_ADDRESS,
+			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 and receive it as SOL.
+*
+* One transaction, three instructions. It sweeps every coin this wallet launched on LaunchLab.
+*/
+async function claimCreatorFee(client, input) {
+	const ids = raydiumIds(client.cluster);
+	const instructions = await getClaimCreatorFeeInstructions(input.creator, ids);
+	return await buildMessage(client, input.creator, instructions, {
+		addressLookupTables: input.addressLookupTables,
+		computeUnitLimit: input.computeUnitLimit ?? 55e3,
+		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+	});
+}
+/**
+* The instructions of a graduated coin's fee collection: create the WSOL account, collect, close.
+*
+* This is per coin. `collect_creator_fee` pays out both sides of the pair, so anything owed in the
+* coin itself lands in the creator's coin account and stays there.
+*/
+async function getCollectCreatorFeeInstructions(client, input, ids = raydiumIds(client.cluster)) {
+	const { mint, creator } = input;
+	const quoteMint = WSOL_MINT;
+	const settings = await fetchCurveSettings(client, ids);
+	const { address: poolState, pool } = await findCpmmPool(client, {
+		mint,
+		quoteMint,
+		creator: creator.address,
+		cpswapConfig: settings.cpswapConfig
+	});
+	return await wrapAround(creator, [{
+		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)
+	}]);
+}
+/** Collect one graduated coin's CPMM creator fee and receive the WSOL side as SOL. */
+async function collectCreatorFee(client, input) {
+	const instructions = await getCollectCreatorFeeInstructions(client, {
+		mint: input.mint,
+		creator: input.creator
+	});
+	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.
+*
+* `mint` is optional. Without it only the curve vault is read, which is the one number that covers
+* every coin at once. With it the coin's CPMM pool is read too, and a coin that has not graduated
+* reports zeros rather than failing.
+*/
+async function fetchCreatorFees(client, input) {
+	const ids = raydiumIds(client.cluster);
+	const quoteMint = WSOL_MINT;
+	const vault = await creatorFeeVaultAddress(ids.launchlab, input.creator, quoteMint);
+	const { value } = await client.rpc.getAccountInfo(vault, {
+		encoding: "base64",
+		commitment: "confirmed"
+	}).send();
+	const curveLamports = value ? tokenAccountAmount(new Uint8Array(base64.encode(value.data[0]))) : 0n;
+	if (!input.mint) return {
+		curveLamports,
+		cpmmLamports: 0n,
+		cpmmTokens: 0n
+	};
+	const settings = await fetchCurveSettings(client, 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 {
+			curveLamports,
+			cpmmLamports: baseIsToken0 ? pool.creatorFeesToken1 : pool.creatorFeesToken0,
+			cpmmTokens: baseIsToken0 ? pool.creatorFeesToken0 : pool.creatorFeesToken1
+		};
+	} catch {
+		return {
+			curveLamports,
+			cpmmLamports: 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` WSOL and take whatever coins it buys.
+*
+* LaunchLab caps the trade at what the curve has left to sell, so a spend larger than the rest of
+* the raise still succeeds and graduates the coin. Wrap the SOL into the user's WSOL ATA first and
+* close it afterwards, the same way the Gabox builders do.
+*/
+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 = WSOL_MINT;
+	const poolState = await launchlabPoolAddress(ids.launchlab, input.mint, quoteMint);
+	const accounts = launchlabBuyExactInAccounts({
+		launchlab: ids.launchlab,
+		launchlabAuthority: ids.launchlabAuthority,
+		launchlabEventAuthority: ids.launchlabEventAuthority,
+		globalConfig: ids.solGlobalConfig,
+		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),
+		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_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,
+	decodeCpmmAmmConfig: () => decodeCpmmAmmConfig,
+	decodeCpmmPool: () => decodeCpmmPool,
+	decodeLaunchlabGlobalConfig: () => decodeLaunchlabGlobalConfig,
+	decodeLaunchlabPlatformConfig: () => decodeLaunchlabPlatformConfig,
+	decodeLaunchlabPool: () => decodeLaunchlabPool,
+	fetchCreatorFees: () => fetchCreatorFees,
+	fetchCurveSettings: () => fetchCurveSettings,
+	findCpmmPool: () => findCpmmPool,
+	getClaimCreatorFeeInstructions: () => getClaimCreatorFeeInstructions,
+	getCollectCreatorFeeInstructions: () => getCollectCreatorFeeInstructions,
+	getCurveBuyExactInInstruction: () => getCurveBuyExactInInstruction,
+	getLaunchInstruction: () => getLaunchInstruction,
+	initialCurve: () => initialCurve,
+	launchlabAuthority: () => launchlabAuthority,
+	launchlabBuyAccounts: () => launchlabBuyAccounts,
+	launchlabBuyExactInAccounts: () => launchlabBuyExactInAccounts,
+	launchlabEventAuthority: () => launchlabEventAuthority,
+	launchlabGlobalConfig: () => launchlabGlobalConfig,
+	launchlabPlatformConfig: () => launchlabPlatformConfig,
+	launchlabPoolAddress: () => launchlabPoolAddress,
+	launchlabSellAccounts: () => launchlabSellAccounts,
+	launchlabVaultAddress: () => launchlabVaultAddress,
+	metadataAddress: () => metadataAddress,
+	newCurveBuyCost: () => newCurveBuyCost,
+	newCurveReserves: () => newCurveReserves,
+	order: () => order,
+	platformFeeVaultAddress: () => platformFeeVaultAddress,
+	preFeeAmount: () => preFeeAmount,
+	raydiumIds: () => raydiumIds,
+	remainingBase: () => remainingBase,
+	resolveVenue: () => resolveVenue,
+	sellQuote: () => sellQuote,
+	sortedMints: () => sortedMints,
+	tokenAccountAmount: () => tokenAccountAmount,
+	tokenAccountOwnerAndMint: () => tokenAccountOwnerAndMint,
+	totalCurveFeeRate: () => totalCurveFeeRate,
+	wsolAccountFor: () => wsolAccountFor
+});
+//#endregion
+export { LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE as $, LAUNCH_SUPPLY as $t, remainingBase as A, METADATA_LIMITS as At, COMPUTE_BUDGET_PROGRAM_ADDRESS as B, CPMM_AMM_CONFIG_DISCRIMINATOR as Bt, cpmmSwapBaseInput as C, CPMM_SEEDS as Ct, curveSellExactIn as D, LAUNCHLAB_STATUS_MIGRATE as Dt, curveBuyExactOut as E, LAUNCHLAB_STATUS_FUND as Et, launchlabBuyExactInAccounts as F, SHARE_FEE_RATE as Ft, computeBudgetInstructions as G, LAUNCHLAB_BUY_EXACT_IN as Gt, DEFAULT_COMPUTE_UNIT_LIMIT as H, CPMM_POOL_STATE_DISCRIMINATOR as Ht, launchlabSellAccounts as I, compareAddresses as It, CPMM_AMM_CONFIG_HEAD_SIZE as J, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR as Jt, getSetComputeUnitLimitInstruction as K, LAUNCHLAB_BUY_EXACT_OUT as Kt, order as L, raydiumIds as Lt, cpmmBuyAccounts as M, MIGRATE_TO_CPMM as Mt, cpmmSellAccounts as N, RATE_DENOMINATOR as Nt, initialCurve as O, LAUNCHLAB_STATUS_TRADE as Ot, launchlabBuyAccounts as P, RAYDIUM_IDS as Pt, LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE as Q, LAUNCHLAB_SELL_EXACT_IN as Qt, BUY_PACK_COMPUTE_UNITS as R, sortedMints as Rt, ceilDivRate as S, CONSTANT_CURVE_TAG as St, curveBuyExactIn as T, LAUNCHLAB_SEEDS as Tt, MAX_COMPUTE_UNIT_LIMIT as U, CPMM_SWAP_BASE_INPUT as Ut, CREATE_MACHINE_COMPUTE_UNITS as V, CPMM_COLLECT_CREATOR_FEE as Vt, REDEEM_COMPUTE_UNITS as W, CPMM_SWAP_BASE_OUTPUT as Wt, CPMM_POOL_STATE_HEAD_SIZE as X, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR as Xt, CPMM_POOL_OFFSETS as Y, LAUNCHLAB_INITIALIZE as Yt, CPMM_POOL_STATE_SIZE as Z, LAUNCHLAB_POOL_STATE_DISCRIMINATOR as Zt, newCurveReserves as _, launchlabPlatformConfig as _t, fetchCreatorFees as a, RENT_SYSVAR_ADDRESS as an, decodeLaunchlabPool as at, wsolAccountFor as b, metadataAddress as bt, getLaunchInstruction as c, WSOL_MINT as cn, ata as ct, cpmmPoolMatches as d, cpmmPoolAddress as dt, LAUNCH_TOTAL_BASE_SELL as en, LAUNCHLAB_POOL_STATE_HEAD_SIZE as et, creatorFeeOnInput as f, creatorFeeVaultAddress as ft, newCurveBuyCost as g, launchlabGlobalConfig as gt, findCpmmPool as h, launchlabEventAuthority as ht, collectCreatorFee as i, RAYDIUM_MAINNET_IDS as in, decodeLaunchlabPlatformConfig as it, totalCurveFeeRate as j, METADATA_SEED as jt, preFeeAmount as k, LAUNCH_DECIMALS as kt, buildMessage as l, cpmmAuthority as lt, fetchCurveSettings as m, launchlabAuthority as mt, getCurveBuyExactInInstruction as n, PLATFORM_ADMIN as nn, decodeCpmmPool as nt, getClaimCreatorFeeInstructions as o, SYSTEM_PROGRAM_ADDRESS as on, tokenAccountAmount as ot, curveQuote as p, creatorFeeVaultAuthority as pt, getSetComputeUnitPriceInstruction as q, LAUNCHLAB_CLAIM_CREATOR_FEE as qt, claimCreatorFee as r, RAYDIUM_DEVNET_IDS as rn, decodeLaunchlabGlobalConfig as rt, getCollectCreatorFeeInstructions as s, TOKEN_PROGRAM_ADDRESS as sn, tokenAccountOwnerAndMint as st, raydium_exports as t, METAPLEX_PROGRAM_ADDRESS as tn, decodeCpmmAmmConfig as tt, withRemainingAccounts as u, cpmmCreatorFeeShare as ut, resolveVenue as v, launchlabPoolAddress as vt, cpmmSwapBaseOutput as w, CREATOR_FEE_ON_QUOTE as wt, ceilDiv as x, platformFeeVaultAddress as xt, sellQuote as y, launchlabVaultAddress as yt, CLAIM_COMPUTE_UNITS as z, ASSOCIATED_TOKEN_PROGRAM_ADDRESS as zt };
+
+//# sourceMappingURL=raydium-B-l9V3O-.js.map