@gabox-labs/sdk 0.6.0 → 0.7.0

package/dist/{raydium-B-l9V3O-.js → raydium-CU-tZzIk.js}

@@ -1,12 +1,12 @@
 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 { Dt as POOL_DISCRIMINATOR, Et as getWalletActivitySize, Jt as getDrawSize, Lt as getPoolSize, Ot as decodePool, Rt as DRAW_DISCRIMINATOR, _t as decodeWalletActivity, ft as findPoolPda, ht as findActivityPda, mt as findDrawPda, pt as findIdentityPda, t as GABOX_PROGRAM_ADDRESS, zt as decodeDraw } from "./gabox-DGTCh34U.js";
+import { AccountRole, Endian, addEncoderSizePrefix, appendTransactionMessageInstructions, compileTransaction, compressTransactionMessageUsingAddressLookupTables, createTransactionMessage, fetchEncodedAccount, fixDecoderSize, getAddressDecoder, getAddressEncoder, getBase58Decoder, getBase64Encoder, getBooleanDecoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, getTransactionEncoder, getU16Decoder, getU16Encoder, getU32Encoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, getUtf8Encoder, pipe, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash } from "@solana/kit";
 import { getCloseAccountInstruction, getCreateAssociatedTokenIdempotentInstruction } from "@solana-program/token";
 //#region src/raydium/abi.ts
 const RAYDIUM_MAINNET_IDS = {
 	launchlab: "LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj",
 	launchlabAuthority: "WLHv2UAZm6z4KyaaELi5pjdbJh6RESMva1Rnn8pJVVh",
 	launchlabEventAuthority: "2DPAtwB8L12vrMRExbLuyGnC7n2J5LNoZQSejeQGpwkr",
-	solGlobalConfig: "6s1xP3hpbAfFoNtUNF8mfHsjr2Bd97JxFJRWLbL6aHuX",
 	gaboxPlatform: "8tXUG97CEpSKTNXdGtanYyC33RWmTTuSin4VdaWwNj8q",
 	cpmm: "CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C",
 	cpmmAuthority: "GpMZbSM2GgvTKHJirzeGfMFoaZ8UR2X7F4v8vHTvxFbL",
@@ -16,13 +16,15 @@ 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. */
+/**
+* Wrapped SOL: the default quote, and the one every price in SOL is measured in. Gabox accepts any
+* quote Raydium enabled on LaunchLab, so this is not the only one.
+*/
 const WSOL_MINT = "So11111111111111111111111111111111111111112";
 /** Metaplex Token Metadata, which LaunchLab's create instruction writes to. */
 const METAPLEX_PROGRAM_ADDRESS = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
@@ -35,8 +37,13 @@ const PLATFORM_ADMIN = "5WcPTEQ59UqpQzjZUPbU8QRGCbj7NeQNLDa7DbsLkLKT";
 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. */
+/** Classic SPL Token. The base coin is always under it, on both venues. */
 const TOKEN_PROGRAM_ADDRESS = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+/**
+* Token-2022. A quote mint may be under it, inside the bounded profile the program's
+* `tokens::validate_quote_mint` accepts. The base coin never is.
+*/
+const TOKEN_2022_PROGRAM_ADDRESS = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
 const ASSOCIATED_TOKEN_PROGRAM_ADDRESS = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
 const SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
 /** The rent sysvar. LaunchLab's create instruction still takes it. */
@@ -862,8 +869,8 @@ const CPMM_COLLECT_CREATOR_FEE = {
 * 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 })`.
+* so does the raise a WSOL-quoted curve must reach. So nothing here is a global: a caller passes the
+* cluster, which comes from `createClient({ cluster })`.
 *
 * None of these strings is typed in this file. `scripts/codegen.mjs` reads them out of the Rust
 * program's `programs/gabox/src/venue/ids.rs` and writes `abi.ts`. The Rust file is the source of
@@ -937,7 +944,7 @@ const SHARE_FEE_RATE = 0n;
 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. */
+/** `AmmCreatorFeeOn::QuoteToken`, so the CPMM creator fee is paid in the pool's quote asset. */
 const CREATOR_FEE_ON_QUOTE = 0;
 /** LaunchLab pool `status`: still selling on the curve. */
 const LAUNCHLAB_STATUS_FUND = 0;
@@ -966,6 +973,307 @@ function compareAddresses(a, b) {
 	return 0;
 }
 //#endregion
+//#region src/ids.ts
+/** `declare_id!` in `programs/gabox/src/lib.rs`. */
+const GABOX_PROGRAM_ID = GABOX_PROGRAM_ADDRESS;
+/** MagicBlock's ephemeral VRF program. `vrf.rs` pins it and refuses any other. */
+const VRF_PROGRAM_ADDRESS = "Vrf1RNUjXmQGjmQrQLvJHs9SNkvDJEsRVFPkfSQUwGz";
+/**
+* MagicBlock's default oracle queue. The program pins this one address, so a pool creator cannot
+* point a draw at an oracle they control.
+*/
+const VRF_DEFAULT_QUEUE = "Cuj97ggrhhidhbu39TijNVqE74xvKJ69gDervRUXAxGh";
+/** The seed of both identity PDAs. See `pdas.ts` — there are two, under different programs. */
+const IDENTITY_SEED = new Uint8Array([
+	105,
+	100,
+	101,
+	110,
+	116,
+	105,
+	116,
+	121
+]);
+const SLOT_HASHES_SYSVAR = "SysvarS1otHashes111111111111111111111111111";
+const INSTRUCTIONS_SYSVAR = "Sysvar1nstructions1111111111111111111111111";
+/** `constants.rs`. A retry may not run sooner than this after the last attempt. */
+const RETRY_SLOTS = 300n;
+/** `constants.rs`. After this many slots from the purchase, anyone may expire the draw. */
+const TIMEOUT_SLOTS = 216000n;
+/** `constants.rs`. Three requests in total, counting the one `buy_pack` makes. */
+const MAX_ATTEMPTS = 3;
+/**
+* `constants.rs`. Tokens in one pack, in base units: 1,000,000 tokens at the fixed 6 decimals, or
+* 0.1% of the 1,000,000,000 supply. Every pool sells packs of this size. The venue decides what a
+* pack costs, so the pack price follows the coin. Read `pool.packTokens` rather than this when a
+* pool is at hand: a later program version may change the constant.
+*/
+const PACK_TOKENS = 1000000n * 1000000n;
+//#endregion
+//#region src/math.ts
+/**
+* A bigint port of `programs/gabox/src/math.rs`.
+*
+* The point is that a client can show a buyer the exact prize table the program will freeze into
+* their `Draw`, before they pay. Every rounding step here matches the Rust, including the direction
+* of each division. `test/math.test.ts` runs the same vectors as `programs/gabox/tests/math.rs`.
+*
+* All amounts are `bigint`, in the mint's smallest unit. `multiplierBps` and `tickets` are numbers
+* because both are `u32` in the program and both stay small.
+*/
+/** Basis points. A multiplier of 10_000 pays back exactly one pack. */
+const BPS = 10000n;
+/**
+* `constants::MIN_SEED_MULTIPLIER_BPS`. The mandatory seed makes a 3x top prize payable on the
+* first pack, or the full top prize when the table's top tier is below 3x. A creator can add more
+* seed on top through `extraSeedTokens`.
+*/
+const MIN_SEED_MULTIPLIER_BPS = 3e4;
+/**
+* `constants::MAX_MULTIPLIER_BPS`. A table's top tier can be at most 20x. Seed beyond what a 20x
+* prize needs stays in the vault as backup for the draws after a top-tier hit.
+*/
+const MAX_MULTIPLIER_BPS = 2e5;
+/** Ticket counts must sum to this. A uniform 16-bit word then maps with no modulo bias. */
+const TICKETS = 65536;
+/** The prize table has exactly this many slots. Unused slots are all-zero. */
+const TIERS = 8;
+/** Thrown by every function here. `code` matches a `GaboxError` variant name. */
+var GaboxMathError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(`${code}: ${message}`);
+		this.name = "GaboxMathError";
+		this.code = code;
+	}
+};
+const U64_MAX = (1n << 64n) - 1n;
+const U32_MAX = 4294967295;
+/**
+* The default prize table. The program does not enforce this table: it accepts any table that
+* passes `validateTiers`. This is only the table the Gabox app creates its pools with, and the
+* starting point for a client that has no reason to pick another one.
+*
+* Common 75% at 0.52x, Rare 20% at 1.2x, Epic 4% at 3x, Mythic 1% at 20x. Expected payout is
+* 0.9499x of a pack, so the seed is 19 packs.
+*/
+const DEFAULT_TIERS = Object.freeze([
+	Object.freeze({
+		multiplierBps: 5201,
+		tickets: 49153
+	}),
+	Object.freeze({
+		multiplierBps: 12e3,
+		tickets: 13107
+	}),
+	Object.freeze({
+		multiplierBps: 3e4,
+		tickets: 2621
+	}),
+	Object.freeze({
+		multiplierBps: 2e5,
+		tickets: 655
+	}),
+	Object.freeze({
+		multiplierBps: 0,
+		tickets: 0
+	}),
+	Object.freeze({
+		multiplierBps: 0,
+		tickets: 0
+	}),
+	Object.freeze({
+		multiplierBps: 0,
+		tickets: 0
+	}),
+	Object.freeze({
+		multiplierBps: 0,
+		tickets: 0
+	})
+]);
+function checkedU64(value, what) {
+	if (value < 0n || value > U64_MAX) throw new GaboxMathError("Arithmetic", `${what} does not fit in u64`);
+	return value;
+}
+/** Tier fields encode as program `u32`s. Reject JavaScript-only values before `BigInt` or codecs. */
+function checkedU32(value, what) {
+	if (!Number.isInteger(value) || value < 0 || value > U32_MAX) throw new GaboxMathError("InvalidDistribution", `${what} must be an integer from 0 to ${U32_MAX}`);
+	return value;
+}
+/** `math::tokens`. Floor division, and an overflow past u64 is an error, not a wrap. */
+function tierAmount(base, multiplierBps) {
+	return checkedU64(base * BigInt(checkedU32(multiplierBps, "multiplierBps")) / BPS, "tier amount");
+}
+/**
+* `math::validate`. Checks the table alone, with no base.
+*
+* Four rules, and each one closes a way to sell a bad ticket:
+*   - ticket counts sum to exactly 65,536, so the 16-bit draw is uniform;
+*   - an unused row is all-zero, so a hidden multiplier cannot ride along;
+*   - a ticketed tier's multiplier is from 1 to `MAX_MULTIPLIER_BPS` (20x);
+*   - the expected multiplier over all tickets is at most 1x, so the table cannot promise more
+*     tokens than a pack buys. This bounds tokens, not cash value.
+*/
+function validateTiers(tiers) {
+	if (tiers.length !== 8) throw new GaboxMathError("InvalidDistribution", `expected 8 tiers, got ${tiers.length}`);
+	let count = 0n;
+	let expected = 0n;
+	for (const [index, tier] of tiers.entries()) {
+		checkedU32(tier.tickets, `tier ${index} tickets`);
+		checkedU32(tier.multiplierBps, `tier ${index} multiplierBps`);
+		if (tier.tickets === 0) {
+			if (tier.multiplierBps !== 0) throw new GaboxMathError("InvalidDistribution", "a tier with no tickets must have no multiplier");
+			continue;
+		}
+		if (tier.multiplierBps <= 0) throw new GaboxMathError("InvalidDistribution", "a ticketed tier must pay something; it would sell a ticket that can only win zero");
+		if (tier.multiplierBps > 2e5) throw new GaboxMathError("InvalidDistribution", `tier ${index} multiplierBps exceeds the ${MAX_MULTIPLIER_BPS} maximum (20x)`);
+		count += BigInt(tier.tickets);
+		expected += BigInt(tier.multiplierBps) * BigInt(tier.tickets);
+	}
+	if (count !== BigInt(65536)) throw new GaboxMathError("InvalidDistribution", `tickets must sum to ${TICKETS}, they sum to ${count}`);
+	if (expected > 10000n * BigInt(65536)) throw new GaboxMathError("UnfundedExpectation", "the expected token award exceeds the tokens a pack buys");
+}
+/**
+* `math::validate_pack`. Every ticketed tier must pay at least one token for a pack of this size.
+*
+* The program checks this once at creation. At `PACK_TOKENS` no sane table fails it; it exists so
+* a table cannot sell a ticket that can only win zero.
+*/
+function validatePack(packTokens, tiers) {
+	if (packTokens <= 0n) throw new GaboxMathError("ZeroAmount", "packTokens must be positive");
+	checkedU64(packTokens, "pack tokens");
+	validateTiers(tiers);
+	for (const [i, tier] of tiers.entries()) {
+		if (tier.tickets === 0) continue;
+		if (tierAmount(packTokens, tier.multiplierBps) === 0n) throw new GaboxMathError("PackTooSmall", `tier ${i} rounds to zero tokens at this pack size`);
+	}
+}
+/**
+* `math::seed_tokens`. The mandatory seed a table needs, in tokens.
+*
+* The mandatory seed makes a 3x top prize payable on the first pack, or the full top prize when
+* the table's top tier is below 3x. A jackpot above 3x still shows the full table once later
+* packs grow the free vault; the mandatory seed alone does not have to fund it. The pack itself
+* brings `packTokens` into the vault, so the vault has to hold the rest beforehand:
+*
+*     seedTokens = min(uncappedMaximum(packTokens, tiers), tierAmount(packTokens, MIN_SEED_MULTIPLIER_BPS)) - packTokens
+*
+* A 20x or a 3x top tier on a 1M-token pack both need a 2M-token seed, since the mandatory seed
+* stops at the 3x minimum. A 2x top tier needs a 1M-token seed, already below the minimum. A
+* table whose top tier pays exactly one pack needs no seed. A top tier below one pack is refused:
+* every ticket would lose. `createMachine` lets a creator add more seed on top of this mandatory
+* amount through `extraSeedTokens`, for example to fund a top tier above 3x from the first pack.
+*
+* Pool initialization computes this number itself and buys exactly that many tokens on the curve.
+* The creator only signs a maximum SOL cost.
+*/
+function seedTokens(packTokens, tiers) {
+	validateTiers(tiers);
+	const largest = uncappedMaximum(packTokens, tiers);
+	if (largest < packTokens) throw new GaboxMathError("JackpotBelowOnePack", "the largest tier must pay at least one pack");
+	const minimum = tierAmount(packTokens, MIN_SEED_MULTIPLIER_BPS);
+	return (largest < minimum ? largest : minimum) - packTokens;
+}
+/**
+* `math::uncapped_maximum`. The largest tier's award for this base, before any inventory cap.
+*
+* At `packTokens` this is the jackpot in tokens. `seedTokens` is this minus one pack.
+*/
+function uncappedMaximum(base, tiers) {
+	validateTiers(tiers);
+	let largest = 0n;
+	for (const tier of tiers) {
+		if (tier.tickets === 0) continue;
+		const amount = tierAmount(base, tier.multiplierBps);
+		if (amount > largest) largest = amount;
+	}
+	return largest;
+}
+/**
+* `math::quote`. The offer a pack of `base` tokens would freeze right now. `base` is always
+* `pool.packTokens`; the parameter stays general so the vectors can use small numbers.
+*
+* `inventory` is the vault's token balance and `reserved` is `pool.reserved`. The difference is
+* free inventory. This pack's own `base` is added to it, because the purchase and the offer are
+* one transaction — the tokens are in the vault before the draw is written.
+*
+* Every amount is capped at what is actually available. A tier that rounds to zero tokens is an
+* error: the pool must not sell a ticket that can only win nothing.
+*/
+function quote(base, tiers, inventory, reserved) {
+	validateTiers(tiers);
+	if (inventory < reserved) throw new GaboxMathError("InsolventInventory", "the vault holds less than the pool has already reserved");
+	const available = checkedU64(inventory - reserved + base, "available inventory");
+	const prizes = Array.from({ length: 8 }, () => ({
+		amount: 0n,
+		tickets: 0
+	}));
+	let maximum = 0n;
+	let minimum = U64_MAX;
+	for (const [i, tier] of tiers.entries()) {
+		if (tier.tickets === 0) continue;
+		const uncapped = tierAmount(base, tier.multiplierBps);
+		if (uncapped === 0n) throw new GaboxMathError("PackTooSmall", `tier ${i} rounds to zero tokens at this pack size`);
+		const amount = uncapped < available ? uncapped : available;
+		prizes[i] = {
+			amount,
+			tickets: tier.tickets
+		};
+		if (amount > maximum) maximum = amount;
+		if (amount < minimum) minimum = amount;
+	}
+	return {
+		prizes,
+		maximum,
+		minimum
+	};
+}
+/**
+* `math::choose`. Which prize a 16-bit ticket wins.
+*
+* The rows are consecutive ranges in table order, so this is a running total and a comparison.
+* A ticket past the last row returns `0`, which cannot happen for a validated table.
+*/
+function choose(prizes, ticket) {
+	let end = 0;
+	for (const prize of prizes) {
+		end += prize.tickets;
+		if (ticket < end) return prize.amount;
+	}
+	return 0n;
+}
+/** `math::resolve_reservation`. Release the unwon part of a maximum, keep the award reserved. */
+function resolveReservation(reserved, maximum, award) {
+	if (award > maximum) throw new GaboxMathError("InsolventInventory", "the award exceeds the reserved maximum");
+	if (reserved < maximum) throw new GaboxMathError("Arithmetic", "the pool has reserved less than this draw holds");
+	return checkedU64(reserved - maximum + award, "reserved");
+}
+/** The largest `multiplierBps` on any ticketed row. `0` for a table with no rows. */
+function maxMultiplierBps(tiers) {
+	validateTiers(tiers);
+	let largest = 0;
+	for (const tier of tiers) {
+		if (tier.tickets === 0) continue;
+		if (tier.multiplierBps > largest) largest = tier.multiplierBps;
+	}
+	return largest;
+}
+/**
+* The expected multiplier over all 65,536 tickets, in basis points. Rounded down.
+*
+* `validateTiers` caps this at 10,000. A table at 9,800 keeps 2% of every pack's tokens in the
+* vault on average, which is what lets a pool survive a run of top-tier wins.
+*/
+function averageMultiplierBps(tiers) {
+	validateTiers(tiers);
+	let weighted = 0n;
+	for (const tier of tiers) {
+		if (tier.tickets === 0) continue;
+		weighted += BigInt(tier.multiplierBps) * BigInt(tier.tickets);
+	}
+	return Number(weighted / BigInt(TICKETS));
+}
+//#endregion
 //#region src/raydium/pdas.ts
 /**
 * Every Raydium address a Gabox transaction derives.
@@ -1078,6 +1386,39 @@ const ata = async (owner, mint, tokenProgram = TOKEN_PROGRAM_ADDRESS) => await d
 	address$1.encode(mint)
 ]);
 //#endregion
+//#region src/pdas.ts
+/**
+* Gabox's own program-derived addresses.
+*
+* Raydium's live in `src/raydium/pdas.ts`, because they depend on the cluster. These do not: the
+* Gabox program id is the same everywhere.
+*
+* Classic SPL Token only. Both venues use it, and the accepted LaunchLab create instruction mints
+* the coin with it, so no derivation here takes a token program any more.
+*/
+/** `["pool", mint]`. One pool per coin. */
+const poolAddress = async (mint) => (await findPoolPda({ mint }))[0];
+/** `["draw", pool, seq]`, with the sequence as eight little-endian bytes. */
+const drawAddress = async (pool, seq) => (await findDrawPda({
+	pool,
+	seq
+}))[0];
+/** The per-wallet `WalletActivity` PDA. `buy_pack` derives it from the purchaser automatically. */
+const activityAddress = async (wallet) => (await findActivityPda({ purchaser: wallet }))[0];
+/** `["identity"]` under Gabox. The PDA the program signs its randomness request with. */
+const vrfIdentityAddress = async () => (await findIdentityPda())[0];
+/** `["identity", gabox_program_id]` under the VRF program. MagicBlock signs the callback with it. */
+async function scopedVrfIdentityAddress() {
+	return await getProgramDerivedAddress({
+		programAddress: VRF_PROGRAM_ADDRESS,
+		seeds: [getBytesEncoder().encode(IDENTITY_SEED), getAddressEncoder().encode(GABOX_PROGRAM_ID)]
+	});
+}
+/** An associated token account under classic SPL Token. */
+const associatedTokenAddress = async (owner, mint, tokenProgram = TOKEN_PROGRAM_ADDRESS) => await ata(owner, mint, tokenProgram);
+/** The prize vault: the pool PDA's own associated token account for the coin. */
+const vaultAddress = async (mint) => await associatedTokenAddress(await poolAddress(mint), mint);
+//#endregion
 //#region src/raydium/adapter.ts
 /**
 * Reading Raydium's accounts.
@@ -1096,7 +1437,7 @@ const ata = async (owner, mint, tokenProgram = TOKEN_PROGRAM_ADDRESS) => await d
 * 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 DISCRIMINATOR$1 = 8;
 const u8 = getU8Decoder();
 const u16 = getU16Decoder();
 const u64$1 = getU64Decoder();
@@ -1131,6 +1472,74 @@ function tokenAccountOwnerAndMint(data) {
 		owner: addressAt.decode(data, 32)
 	};
 }
+/** The base SPL mint is 82 bytes. Token-2022 repeats those 82 and appends its extensions. */
+const MINT_BASE_SIZE = 82;
+/** `decimals` sits after `mint_authority` (4 + 32) and `supply` (8). */
+const MINT_DECIMALS_AT = 44;
+/**
+* The `decimals` of a mint. Both token programs share the first 82 bytes, so one reader covers a
+* classic SPL mint and a Token-2022 one.
+*/
+function mintDecimals(data) {
+	if (data.length < MINT_BASE_SIZE) throw new Error(`not a mint: ${data.length} bytes, expected at least ${MINT_BASE_SIZE}`);
+	return u8.decode(data, MINT_DECIMALS_AT);
+}
+/** A Borsh string: a u32 little-endian length, then that many UTF-8 bytes. */
+function borshString$1(data, at) {
+	if (at + 4 > data.length) return null;
+	const length = new DataView(data.buffer, data.byteOffset, data.byteLength).getUint32(at, true);
+	const end = at + 4 + length;
+	if (end > data.length) return null;
+	return {
+		text: new TextDecoder().decode(data.subarray(at + 4, end)),
+		next: end
+	};
+}
+/** Metaplex pads its three strings with NUL bytes up to their maximum length. */
+const trimmed = (text) => {
+	const clean = text.replace(/\0+$/, "").trim();
+	return clean.length > 0 ? clean : null;
+};
+/**
+* The `symbol` of a Metaplex token metadata account, or `null` when it carries none.
+*
+* Layout: a one-byte key, `update_authority` and `mint`, then the three Borsh strings `name`,
+* `symbol` and `uri`. Metaplex stores them at their maximum length, NUL padded.
+*/
+function metaplexSymbol(data) {
+	const name = borshString$1(data, 65);
+	if (!name) return null;
+	const symbol = borshString$1(data, name.next);
+	return symbol ? trimmed(symbol.text) : null;
+}
+/** The Token-2022 extension type of `TokenMetadata`, from the SPL token metadata interface. */
+const TOKEN_METADATA_EXTENSION = 19;
+/** Token-2022 writes one account-type byte after the 82-byte mint, then its TLV extensions. */
+const EXTENSION_START = 166;
+/**
+* The `symbol` a Token-2022 mint stores in its own `TokenMetadata` extension, or `null`.
+*
+* The extensions are a TLV list: a u16 type, a u16 length, then the value. The metadata value is
+* `update_authority`, `mint`, then the Borsh strings `name`, `symbol` and `uri`.
+*/
+function token2022Symbol(data) {
+	let at = EXTENSION_START;
+	const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+	while (at + 4 <= data.length) {
+		const type = view.getUint16(at, true);
+		const length = view.getUint16(at + 2, true);
+		const value = at + 4;
+		if (value + length > data.length) return null;
+		if (type === TOKEN_METADATA_EXTENSION) {
+			const name = borshString$1(data.subarray(value, value + length), 64);
+			if (!name) return null;
+			const symbol = borshString$1(data.subarray(value, value + length), name.next);
+			return symbol ? trimmed(symbol.text) : null;
+		}
+		at = value + length;
+	}
+	return null;
+}
 /** Offsets follow the `PoolState` field list in `idl/raydium_launchpad.json`. */
 const LAUNCHLAB_POOL_HEAD = getStructDecoder([
 	["epoch", u64$1],
@@ -1169,7 +1578,7 @@ 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);
+	const head = LAUNCHLAB_POOL_HEAD.decode(data, DISCRIMINATOR$1);
 	return {
 		status: head.status,
 		baseDecimals: head.baseDecimals,
@@ -1211,12 +1620,13 @@ 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);
+	const head = LAUNCHLAB_GLOBAL_CONFIG_HEAD.decode(data, DISCRIMINATOR$1);
 	return {
 		curveType: head.curveType,
 		index: head.index,
 		migrateFee: head.migrateFee,
 		tradeFeeRate: head.tradeFeeRate,
+		minQuoteFundRaising: head.minQuoteFundRaising,
 		quoteMint: head.quoteMint
 	};
 }
@@ -1241,7 +1651,7 @@ 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);
+	const head = LAUNCHLAB_PLATFORM_CONFIG_HEAD.decode(data, DISCRIMINATOR$1);
 	return {
 		platformFeeWallet: head.platformFeeWallet,
 		feeRate: head.feeRate,
@@ -1299,7 +1709,7 @@ const CPMM_POOL_OFFSETS = {
 function decodeCpmmPool(data) {
 	checked(data, CPMM_POOL_STATE_DISCRIMINATOR, "CPMM pool");
 	atLeast(data, 413, "CPMM pool");
-	const head = CPMM_POOL_HEAD.decode(data, DISCRIMINATOR);
+	const head = CPMM_POOL_HEAD.decode(data, DISCRIMINATOR$1);
 	return {
 		ammConfig: head.ammConfig,
 		poolCreator: head.poolCreator,
@@ -1340,7 +1750,7 @@ 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);
+	const head = CPMM_AMM_CONFIG_HEAD.decode(data, DISCRIMINATOR$1);
 	return {
 		index: head.index,
 		disableCreatePool: head.disableCreatePool,
@@ -1351,6 +1761,121 @@ function decodeCpmmAmmConfig(data) {
 	};
 }
 //#endregion
+//#region src/accounts.ts
+/** Account readers and bounded discovery scans. Old pool layouts are intentionally unsupported. */
+const DISCRIMINATOR = 8;
+const DRAW_POOL_OFFSET = DISCRIMINATOR;
+const DRAW_PURCHASER_OFFSET = 40;
+const POOL_CREATOR_OFFSET = DISCRIMINATOR;
+const POOL_MINT_OFFSET = 40;
+const base58 = getBase58Decoder();
+const base64$1 = getBase64Encoder();
+const asBase58 = (bytes) => base58.decode(bytes);
+const memcmp$1 = (offset, bytes) => ({ memcmp: {
+	offset: BigInt(offset),
+	bytes,
+	encoding: "base58"
+} });
+const encoded = (address, data) => ({
+	address,
+	data,
+	exists: true,
+	executable: false,
+	lamports: 0n,
+	programAddress: GABOX_PROGRAM_ID,
+	space: BigInt(data.length)
+});
+async function fetchPoolByMint(client, mint) {
+	return await fetchPoolAt(client, await poolAddress(mint));
+}
+async function fetchPoolAt(client, address) {
+	return decodeCurrentPool(await fetchEncodedAccount(client.rpc, address, { commitment: "confirmed" }));
+}
+function decodeCurrentPool(account) {
+	if (!account.exists) return null;
+	if (account.data.length !== getPoolSize()) throw new Error(`pool ${account.address} is not a Gabox pool and is intentionally unsupported`);
+	return decodePool(account).data;
+}
+function decodeCurrentDraw(account) {
+	if (!account.exists) return null;
+	if (account.data.length !== getDrawSize()) throw new Error(`draw ${account.address} is not a Gabox draw and is intentionally unsupported`);
+	return decodeDraw(account).data;
+}
+async function fetchDraw(client, address) {
+	return decodeCurrentDraw(await fetchEncodedAccount(client.rpc, address, { commitment: "confirmed" }));
+}
+function decodeCurrentWalletActivity(account) {
+	if (!account.exists) return null;
+	if (account.data.length !== getWalletActivitySize()) throw new Error(`activity account ${account.address} is not a Gabox WalletActivity and is intentionally unsupported`);
+	return decodeWalletActivity(account).data;
+}
+/**
+* A wallet's lifetime pack-buying activity, or `null` before it has bought its first pack.
+* `buy_pack` creates this account `init_if_needed`, so a fresh wallet has none yet.
+*/
+async function fetchWalletActivity(client, wallet) {
+	return decodeCurrentWalletActivity(await fetchEncodedAccount(client.rpc, await activityAddress(wallet), { commitment: "confirmed" }));
+}
+async function scan(rpc, filters, decode) {
+	return (await rpc.getProgramAccounts(GABOX_PROGRAM_ID, {
+		encoding: "base64",
+		commitment: "confirmed",
+		filters
+	}).send()).map(({ pubkey, account }) => decode(pubkey, new Uint8Array(base64$1.encode(account.data[0]))));
+}
+async function listPools(client) {
+	return await scan(client.rpc, [memcmp$1(0, asBase58(POOL_DISCRIMINATOR)), { dataSize: BigInt(getPoolSize()) }], (address, data) => ({
+		address,
+		data: decodePool(encoded(address, data)).data
+	}));
+}
+async function listDraws(client, query = {}) {
+	const filters = [memcmp$1(0, asBase58(DRAW_DISCRIMINATOR)), { dataSize: BigInt(getDrawSize()) }];
+	if (query.pool) filters.push(memcmp$1(8, query.pool));
+	if (query.purchaser) filters.push(memcmp$1(40, query.purchaser));
+	return await scan(client.rpc, filters, (address, data) => ({
+		address,
+		data: decodeDraw(encoded(address, data)).data
+	}));
+}
+const listDrawsByPool = async (client, pool) => await listDraws(client, { pool });
+const listDrawsByPurchaser = async (client, purchaser) => await listDraws(client, { purchaser });
+async function fetchVaultBalance(client, mint) {
+	const vault = await vaultAddress(mint);
+	const { value } = await client.rpc.getAccountInfo(vault, {
+		encoding: "base64",
+		commitment: "confirmed"
+	}).send();
+	return value ? tokenAccountAmount(new Uint8Array(base64$1.encode(value.data[0]))) : 0n;
+}
+async function fetchPoolInventory(client, mint) {
+	const poolPda = await poolAddress(mint);
+	const vaultPda = await vaultAddress(mint);
+	const { value } = await client.rpc.getMultipleAccounts([poolPda, vaultPda], {
+		encoding: "base64",
+		commitment: "confirmed"
+	}).send();
+	const poolAccount = value[0];
+	if (!poolAccount) return null;
+	const pool = decodeCurrentPool(encoded(poolPda, new Uint8Array(base64$1.encode(poolAccount.data[0]))));
+	if (!pool) return null;
+	if (pool.vault !== vaultPda) throw new Error(`pool ${poolPda} has an unexpected vault; it is not a supported Gabox pool`);
+	const vaultAccount = value[1];
+	const inventory = vaultAccount ? tokenAccountAmount(new Uint8Array(base64$1.encode(vaultAccount.data[0]))) : 0n;
+	return {
+		poolAddress: poolPda,
+		pool,
+		inventory,
+		reserved: pool.reserved,
+		free: inventory > pool.reserved ? inventory - pool.reserved : 0n
+	};
+}
+const tiersOf = (pool) => pool.tiers.map(({ multiplierBps, tickets }) => ({
+	multiplierBps,
+	tickets
+}));
+const quotePool = (inventory) => quote(inventory.pool.packTokens, tiersOf(inventory.pool), inventory.inventory, inventory.reserved);
+//#endregion
 //#region src/compute.ts
 /**
 * The two `ComputeBudget` instructions the transaction builders prepend.
@@ -1375,6 +1900,9 @@ function decodeCpmmAmmConfig(data) {
 * same work, so the venue's own cost moves with state this SDK does not control. The 1.3x margin is
 * there to absorb that, and the largest of the three is always the basis.
 *
+* None of them covers a swap. When a builder puts a route in the same transaction, the route states
+* its own cost as `Route.computeUnits` and the builder adds it, capped at `MAX_COMPUTE_UNIT_LIMIT`.
+*
 * Re-measure after a change to a builder or to a Raydium program. `test/devnet.e2e.test.ts` prints
 * `CU <label>: <units> | <signature>` for every transaction it sends, which is where these came
 * from.
@@ -1386,25 +1914,26 @@ const MAX_COMPUTE_UNIT_LIMIT = 14e5;
 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.
+* close, in one transaction. Measured at `266,488`, `258,988` and `267,988` over three devnet runs
+* against the slot-500297753 build.
 */
-const CREATE_MACHINE_COMPUTE_UNITS = 385e3;
+const CREATE_MACHINE_COMPUTE_UNITS = 35e4;
 /**
 * A WSOL wrap, a venue buy, an escrow transfer, a draw init, a VRF request and the WSOL close.
-* Measured at `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
+* Measured at `178,690`, `163,686` and `157,692` on the curve, and `113,891`, `110,922` and
+* `106,387` on CPMM. The curve buy is dearer because a coin's first trade also creates the platform
 * and creator fee vaults.
 */
-const BUY_PACK_COMPUTE_UNITS = 24e4;
+const BUY_PACK_COMPUTE_UNITS = 235e3;
 /**
-* 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.
+* A WSOL wrap, a venue sale, and the WSOL close. Measured at `94,246`, `86,745` and `88,246` on the
+* curve, and `61,545`, `55,576` and `57,046` on CPMM.
 */
-const REDEEM_COMPUTE_UNITS = 135e3;
+const REDEEM_COMPUTE_UNITS = 125e3;
 /**
-* 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.
+* A creator fee claim: create the quote account, claim or collect, and close it when it is WSOL.
+* Measured at `31,319` every run for the LaunchLab claim and `40,959` for the CPMM collect. A claim
+* on a pool quoted in another token is cheaper, `17,635`, because nothing has to be unwrapped.
 */
 const CLAIM_COMPUTE_UNITS = 55e3;
 /** `ComputeBudgetInstruction`'s discriminants. Positional and append-only upstream. */
@@ -1452,6 +1981,103 @@ function computeBudgetInstructions(units, microLamports) {
 	return instructions;
 }
 //#endregion
+//#region src/raydium/read.ts
+/**
+* One account reader, shared by every module that decodes a Raydium account.
+*
+* Kit's codecs, not `Buffer`. This SDK is vendored into a Next.js app and `Buffer` is not defined
+* in the browser.
+*/
+const base64 = getBase64Encoder();
+/** Read several accounts in one call. A missing account comes back as `null`, not as an error. */
+async function readAccounts(rpc, addresses) {
+	const { value } = await rpc.getMultipleAccounts(addresses, {
+		encoding: "base64",
+		commitment: "confirmed"
+	}).send();
+	return value.map((account) => {
+		if (!account) return null;
+		const [encoded] = account.data;
+		return {
+			data: new Uint8Array(base64.encode(encoded)),
+			owner: account.owner
+		};
+	});
+}
+/** Decode one base64 account payload the RPC returned inside another shape. */
+const decodeBase64 = (encoded) => new Uint8Array(base64.encode(encoded));
+//#endregion
+//#region src/raydium/quote.ts
+/**
+* LaunchLab's global config for one quote mint, or `null` when Raydium enabled no such quote.
+*
+* Index 0 is the usual config, and the constant-product curve is the only shape Gabox launches, so
+* those two are fixed here. The decoded `quoteMint` has to be the mint asked for: a config for a
+* different quote would price the wrong asset.
+*/
+async function fetchQuoteConfig(client, mint, ids = raydiumIds(client.cluster)) {
+	const address = await launchlabGlobalConfig(ids.launchlab, mint, 0, 0);
+	const [account] = await readAccounts(client.rpc, [address]);
+	if (!account || account.owner !== ids.launchlab) return null;
+	let config;
+	try {
+		config = decodeLaunchlabGlobalConfig(account.data);
+	} catch {
+		return null;
+	}
+	if (config.curveType !== 0 || config.quoteMint !== mint) return null;
+	return {
+		...config,
+		address
+	};
+}
+/** Can a Gabox machine be quoted in this mint? One account read. */
+async function isQuoteSupported(client, mint) {
+	return await fetchQuoteConfig(client, mint) !== null;
+}
+/**
+* The full quote asset: its LaunchLab config, its token program, its decimals and its symbol.
+*
+* Two round trips. The first reads the global config, because the config address is derived from
+* the mint. The second reads the mint and its Metaplex metadata account together.
+*
+* Throws when Raydium has no config for the mint, because no pool can be created or traded then.
+*/
+async function fetchQuoteAsset(client, mint, ids = raydiumIds(client.cluster)) {
+	const config = await fetchQuoteConfig(client, mint, ids);
+	if (!config) throw new Error(`Raydium has no LaunchLab global config for ${mint}, so it is not a quote asset Gabox can use. Pick a quote Raydium enabled, such as wrapped SOL or USDC.`);
+	const display = await fetchQuoteDisplay(client, mint);
+	return {
+		mint,
+		config: config.address,
+		tokenProgram: display.tokenProgram,
+		decimals: display.decimals,
+		symbol: display.symbol,
+		tradeFeeRate: config.tradeFeeRate,
+		migrateFee: config.migrateFee,
+		minQuoteFundRaising: config.minQuoteFundRaising
+	};
+}
+/**
+* Read a quote mint and its Metaplex metadata in one call.
+*
+* A Token-2022 mint may carry its own `TokenMetadata` extension, and that one wins: it is the
+* issuer's own record. A classic SPL mint keeps its symbol in a Metaplex account, and a mint with
+* neither reports `null`.
+*/
+async function fetchQuoteDisplay(client, mint) {
+	const [mintAccount, metadata] = await readAccounts(client.rpc, [mint, await metadataAddress(mint)]);
+	if (!mintAccount) throw new Error(`the quote mint ${mint} is not on chain`);
+	const tokenProgram = mintAccount.owner;
+	if (tokenProgram !== "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" && tokenProgram !== "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb") throw new Error(`the quote mint ${mint} is owned by ${tokenProgram}, which is neither classic SPL Token nor Token-2022`);
+	const own = tokenProgram === "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb" ? token2022Symbol(mintAccount.data) : null;
+	return {
+		tokenProgram,
+		decimals: mintDecimals(mintAccount.data),
+		symbol: own ?? (metadata ? metaplexSymbol(metadata.data) : null)
+	};
+}
+//#endregion
 //#region src/raydium/accounts.ts
 /**
 * The ordered account list of every Raydium trade Gabox forwards.
@@ -1475,7 +2101,14 @@ function computeBudgetInstructions(units, microLamports) {
 *
 * 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.
+* addresses, the token programs included. LaunchLab names its accounts by role instead, and uses
+* one list for both sides.
+*
+* # The token programs are inputs, not constants
+*
+* The base coin is always classic SPL Token. The quote may be Token-2022, so its program travels
+* with the pool: `pool.quoteTokenProgram` on the curve, and the two programs a migrated CPMM pool
+* records in its own data. `venue/trade.rs` checks both slots against the same values.
 */
 /**
 * Turn `{name -> address}` into the ABI's ordered `AccountMeta[]`.
@@ -1508,7 +2141,7 @@ function launchlabTradeAccounts(abi, input) {
 		base_token_mint: input.mint,
 		quote_token_mint: input.quoteMint,
 		base_token_program: TOKEN_PROGRAM_ADDRESS,
-		quote_token_program: TOKEN_PROGRAM_ADDRESS,
+		quote_token_program: input.quoteTokenProgram,
 		event_authority: input.launchlabEventAuthority,
 		program: input.launchlab,
 		system_program: SYSTEM_PROGRAM_ADDRESS,
@@ -1537,8 +2170,8 @@ function cpmmTradeAccounts(abi, input, side) {
 		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_program: buying ? input.quoteTokenProgram : input.baseTokenProgram,
+		output_token_program: buying ? input.baseTokenProgram : input.quoteTokenProgram,
 		input_token_mint: buying ? input.quoteMint : input.mint,
 		output_token_mint: buying ? input.mint : input.quoteMint,
 		observation_state: input.observationState
@@ -1722,69 +2355,40 @@ function cpmmSwapBaseInput(sides, rates, amountIn) {
 }
 //#endregion
 //#region src/raydium/venue.ts
+/** The quote binding a Gabox pool records. One account read. */
+async function fetchQuoteBinding(client, mint) {
+	const pool = await fetchPoolByMint(client, mint);
+	if (!pool) throw new Error(`no Gabox pool for mint ${mint}, so its quote asset is unknown. Pass \`quote\` to price a coin that has no pool.`);
+	return {
+		mint: pool.quoteMint,
+		config: pool.quoteConfig,
+		tokenProgram: pool.quoteTokenProgram
+	};
+}
 /**
-* 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.
+* The user's quote associated token account, under the quote's own token program.
 *
-* # 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.
+* Both venues settle in this account, never in native SOL. It must exist and hold enough before a
+* pack is bought, and sale proceeds land in it. For a WSOL-quoted pool every builder in `tx/` wraps
+* the SOL it needs into this account and closes it again in the same transaction.
 */
-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
-		};
-	});
+async function quoteAccountFor(user, quoteMint, quoteTokenProgram = TOKEN_PROGRAM_ADDRESS) {
+	return await ata(user, quoteMint, quoteTokenProgram);
+}
+/** The user's WSOL associated token account. WSOL is always classic SPL Token. */
+async function wsolAccountFor(user) {
+	return await ata(user, WSOL_MINT, TOKEN_PROGRAM_ADDRESS);
 }
 /**
-* The user's WSOL associated token account.
+* Read the quote's global config and the Gabox platform config, and take the four numbers a quote
+* needs out of them.
 *
-* 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.
+* `quoteConfig` is the LaunchLab global config of the pool's quote asset: `pool.quoteConfig`, or
+* the address `raydium.fetchQuoteConfig` derives for a coin that has no pool yet.
 */
-async function 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}`);
+async function fetchCurveSettings(client, quoteConfig, ids = raydiumIds(client.cluster)) {
+	const [globalAccount, platformAccount] = await readAccounts(client.rpc, [quoteConfig, ids.gaboxPlatform]);
+	if (!globalAccount) throw new Error(`LaunchLab has no global config at ${quoteConfig}`);
 	if (!platformAccount) throw new Error(`the Gabox platform config is missing at ${ids.gaboxPlatform}`);
 	return settingsFrom(globalAccount.data, platformAccount.data);
 }
@@ -1804,18 +2408,18 @@ function settingsFrom(globalData, platformData) {
 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 quote = options.quote ?? await fetchQuoteBinding(client, mint);
+	const curvePool = await launchlabPoolAddress(ids.launchlab, mint, quote.mint);
 	const [poolAccount, globalAccount, platformAccount] = await readAccounts(client.rpc, [
 		curvePool,
-		ids.solGlobalConfig,
+		quote.config,
 		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 (!poolAccount) throw new Error(`no LaunchLab pool at ${curvePool}. The coin was not launched on LaunchLab with ${quote.mint} as its quote, so it has no Gabox venue.`);
+	if (!globalAccount) throw new Error(`LaunchLab has no global config at ${quote.config}`);
 	if (!platformAccount) throw new Error(`the Gabox platform config is missing at ${ids.gaboxPlatform}`);
 	const pool = decodeLaunchlabPool(poolAccount.data);
-	if (pool.baseMint !== mint || pool.quoteMint !== quoteMint) throw new Error(`the LaunchLab pool at ${curvePool} is not the pool of ${mint}`);
+	if (pool.baseMint !== mint || pool.quoteMint !== quote.mint) throw new Error(`the LaunchLab pool at ${curvePool} is not the pool of ${mint}`);
 	const settings = settingsFrom(globalAccount.data, platformAccount.data);
 	const kind = options.venue ?? (pool.status === 2 ? "cpmm" : "launchlab");
 	if (options.venue === void 0 && pool.status === 1) throw new Error(`${mint} is graduating: its LaunchLab curve is sold out and Raydium is moving it into a CPMM pool. Retry in a moment; the move usually finishes within a minute.`);
@@ -1823,35 +2427,37 @@ async function resolveVenue(client, options) {
 		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,
+			quote,
 			user,
 			poolState: curvePool
 		});
 	}
 	return await cpmmVenue(client, ids, pool, settings.cpswapConfig, {
 		mint,
-		quoteMint,
+		quote,
 		user
 	});
 }
 async function launchlabVenue(ids, pool, rates, where) {
-	const { mint, quoteMint, user, poolState } = where;
+	const { mint, quote, user, poolState } = where;
+	const userQuoteToken = await quoteAccountFor(user, quote.mint, quote.tokenProgram);
 	const shared = {
 		launchlab: ids.launchlab,
 		launchlabAuthority: ids.launchlabAuthority,
 		launchlabEventAuthority: ids.launchlabEventAuthority,
-		globalConfig: ids.solGlobalConfig,
+		globalConfig: quote.config,
 		platformConfig: ids.gaboxPlatform,
 		poolState,
 		mint,
-		quoteMint,
+		quoteMint: quote.mint,
 		baseVault: await launchlabVaultAddress(ids.launchlab, poolState, mint),
-		quoteVault: await launchlabVaultAddress(ids.launchlab, poolState, quoteMint),
+		quoteVault: await launchlabVaultAddress(ids.launchlab, poolState, quote.mint),
 		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)
+		userQuoteToken,
+		quoteTokenProgram: quote.tokenProgram,
+		platformFeeVault: await platformFeeVaultAddress(ids.launchlab, ids.gaboxPlatform, quote.mint),
+		creatorFeeVault: await creatorFeeVaultAddress(ids.launchlab, pool.creator, quote.mint)
 	};
 	const reserves = {
 		virtualBase: pool.virtualBase,
@@ -1865,7 +2471,9 @@ async function launchlabVenue(ids, pool, rates, where) {
 		kind: "launchlab",
 		program: ids.launchlab,
 		mint,
-		quoteMint,
+		quoteMint: quote.mint,
+		quoteTokenProgram: quote.tokenProgram,
+		userQuoteToken,
 		poolState,
 		status: pool.status,
 		creator: pool.creator,
@@ -1933,7 +2541,7 @@ async function findCpmmPool(client, options) {
 	}).send();
 	const matches = [];
 	for (const { pubkey, account: row } of rows) {
-		const pool = decodeCpmmPoolOrNull(new Uint8Array(base64$1.encode(row.data[0])));
+		const pool = decodeCpmmPoolOrNull(decodeBase64(row.data[0]));
 		if (pool && cpmmPoolMatches(pool, expect)) matches.push({
 			address: pubkey,
 			pool
@@ -1961,16 +2569,19 @@ function decodeCpmmPoolOrNull(data) {
 	}
 }
 async function cpmmVenue(client, ids, curve, cpswapConfig, where) {
-	const { mint, quoteMint, user } = where;
+	const { mint, quote, user } = where;
 	const { address: poolState, pool } = await findCpmmPool(client, {
 		mint,
-		quoteMint,
+		quoteMint: quote.mint,
 		creator: curve.creator,
 		cpswapConfig
 	});
 	const baseIsToken0 = pool.token0Mint === mint;
 	const baseVault = baseIsToken0 ? pool.token0Vault : pool.token1Vault;
 	const quoteVault = baseIsToken0 ? pool.token1Vault : pool.token0Vault;
+	const baseTokenProgram = baseIsToken0 ? pool.token0Program : pool.token1Program;
+	const quoteTokenProgram = baseIsToken0 ? pool.token1Program : pool.token0Program;
+	if (baseTokenProgram !== "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" || quoteTokenProgram !== quote.tokenProgram) throw new Error(`the CPMM pool at ${poolState} records token programs ${baseTokenProgram} and ${quoteTokenProgram}, which are not the ones this coin trades under`);
 	const [configAccount, baseVaultAccount, quoteVaultAccount] = await readAccounts(client.rpc, [
 		pool.ammConfig,
 		baseVault,
@@ -1984,18 +2595,21 @@ async function cpmmVenue(client, ids, curve, cpswapConfig, where) {
 	const baseReserve = tokenAccountAmount(baseVaultAccount.data) - owedBase;
 	const quoteReserve = tokenAccountAmount(quoteVaultAccount.data) - owedQuote;
 	if (baseReserve <= 0n || quoteReserve <= 0n) throw new Error(`the CPMM pool at ${poolState} has no tradable reserves`);
+	const userQuoteToken = await quoteAccountFor(user, quote.mint, quoteTokenProgram);
 	const shared = {
 		cpmmAuthority: ids.cpmmAuthority,
 		ammConfig: pool.ammConfig,
 		poolState,
 		mint,
-		quoteMint,
+		quoteMint: quote.mint,
 		baseVault,
 		quoteVault,
 		observationState: pool.observationKey,
 		user,
 		userBaseToken: await ata(user, mint),
-		userQuoteToken: await ata(user, quoteMint)
+		userQuoteToken,
+		baseTokenProgram,
+		quoteTokenProgram
 	};
 	const creatorFeeRate = pool.enableCreatorFee ? config.creatorFeeRate : 0n;
 	const buySides = {
@@ -2009,7 +2623,7 @@ async function cpmmVenue(client, ids, curve, cpswapConfig, where) {
 	const buyRates = {
 		tradeFeeRate: config.tradeFeeRate,
 		creatorFeeRate,
-		creatorFeeOnInput: creatorFeeOnInput(pool, quoteMint)
+		creatorFeeOnInput: creatorFeeOnInput(pool, quote.mint)
 	};
 	const sellRates = {
 		tradeFeeRate: config.tradeFeeRate,
@@ -2020,7 +2634,9 @@ async function cpmmVenue(client, ids, curve, cpswapConfig, where) {
 		kind: "cpmm",
 		program: ids.cpmm,
 		mint,
-		quoteMint,
+		quoteMint: quote.mint,
+		quoteTokenProgram,
+		userQuoteToken,
 		poolState,
 		status: curve.status,
 		creator: pool.poolCreator,
@@ -2037,7 +2653,8 @@ async function cpmmVenue(client, ids, curve, cpswapConfig, where) {
 *
 * `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.
+* the pool charges the creator fee in the quote token only: on the input of a buy, on the output of
+* a sale.
 */
 function creatorFeeOnInput(pool, inputMint) {
 	if (pool.creatorFeeOn === 0) return true;
@@ -2045,8 +2662,8 @@ function creatorFeeOnInput(pool, 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.
+* Quote token an exact-coins-out buy of `tokens` costs right now, on whichever venue the coin
+* trades. Pass `pool.packTokens` for the pack price.
 *
 * Use `resolveVenue` when you also need the account list, which every transaction builder does.
 * This is for a price display.
@@ -2055,37 +2672,44 @@ async function curveQuote(client, mint, tokens, options = {}) {
 	return (await resolveVenue(client, {
 		mint,
 		user: options.user ?? mint,
-		...options.venue ? { venue: options.venue } : {}
+		...options.venue ? { venue: options.venue } : {},
+		...options.quote ? { quote: options.quote } : {}
 	})).quoteBuy(tokens);
 }
-/** WSOL a sale of `tokens` returns right now, net of the venue's fees. */
+/** Quote token a sale of `tokens` returns right now, net of the venue's fees. */
 async function sellQuote(client, mint, tokens, options = {}) {
 	return (await resolveVenue(client, {
 		mint,
 		user: options.user ?? mint,
-		...options.venue ? { venue: options.venue } : {}
+		...options.venue ? { venue: options.venue } : {},
+		...options.quote ? { quote: options.quote } : {}
 	})).quoteSell(tokens);
 }
 /**
-* WSOL an exact-coins-out buy of `tokens` would cost on a curve that does not exist yet, fees
-* included.
+* Quote token an exact-coins-out buy of `tokens` would cost on a curve that does not exist yet,
+* fees included.
 *
 * This is what the seed costs. `initialize_pool` buys it in the same transaction that creates the
 * coin, so the curve is a brand-new LaunchLab curve with the pinned Gabox launch shape at that
 * moment. Exact, unless Raydium changes a fee rate between this read and the send.
 */
-async function newCurveBuyCost(client, tokens) {
+async function newCurveBuyCost(client, tokens, launch) {
 	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);
+	const settings = await fetchCurveSettings(client, launch.quoteConfig, ids);
+	return curveBuyExactOut(newCurveReserves(launch.raise, settings.migrateFee), settings.rates, tokens);
 }
-/** The starting reserves of a brand-new Gabox curve on this cluster. */
-function newCurveReserves(ids, migrateFee) {
+/**
+* The starting reserves of a brand-new Gabox curve.
+*
+* `raise` is `total_quote_fund_raising`, in the quote's own base units. It is the one launch number
+* the client picks, so the reserves follow it.
+*/
+function newCurveReserves(raise, migrateFee) {
 	return initialCurve({
 		supply: LAUNCH_SUPPLY,
 		totalBaseSell: LAUNCH_TOTAL_BASE_SELL,
-		quoteRaise: ids.launchQuoteRaise,
+		quoteRaise: raise,
 		migrateFee
 	});
 }
@@ -2136,11 +2760,11 @@ function withRemainingAccounts(instruction, remaining) {
 *
 * | Argument | Value |
 * | --- | --- |
-* | `decimals` | 6 |
+* | `decimals` | 6 (the coin; the quote keeps its own) |
 * | curve | `Constant` |
 * | `supply` | 1,000,000,000 coins |
 * | `total_base_sell` | 793,100,000 coins |
-* | `total_quote_fund_raising` | 85 SOL on mainnet, 3 SOL on devnet |
+* | `total_quote_fund_raising` | the caller's `raise`, pinned to 85 SOL on mainnet and 3 SOL on devnet for a WSOL pool |
 * | `migrate_type` | 1, which means graduate into a CPMM pool |
 * | `VestingParams` | all three fields 0 |
 * | `AmmCreatorFeeOn` | `QuoteToken` |
@@ -2187,12 +2811,12 @@ async function getLaunchInstruction(input, ids) {
 	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 { quoteMint, quoteTokenProgram } = input;
 	const poolState = await launchlabPoolAddress(ids.launchlab, mint.address, quoteMint);
 	const metas = order(LAUNCHLAB_INITIALIZE, {
 		payer: creator.address,
 		creator: creator.address,
-		global_config: ids.solGlobalConfig,
+		global_config: input.quoteConfig,
 		platform_config: ids.gaboxPlatform,
 		authority: ids.launchlabAuthority,
 		pool_state: poolState,
@@ -2202,7 +2826,7 @@ async function getLaunchInstruction(input, ids) {
 		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,
+		quote_token_program: quoteTokenProgram,
 		metadata_program: METAPLEX_PROGRAM_ADDRESS,
 		system_program: SYSTEM_PROGRAM_ADDRESS,
 		rent_program: RENT_SYSVAR_ADDRESS,
@@ -2226,7 +2850,7 @@ async function getLaunchInstruction(input, ids) {
 		curveTag: 0,
 		supply: LAUNCH_SUPPLY,
 		totalBaseSell: LAUNCH_TOTAL_BASE_SELL,
-		totalQuoteFundRaising: ids.launchQuoteRaise,
+		totalQuoteFundRaising: input.raise,
 		migrateType: 1,
 		totalLockedAmount: 0n,
 		cliffPeriod: 0n,
@@ -2247,36 +2871,41 @@ async function getLaunchInstruction(input, ids) {
 * 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.
+*   - **On the curve.** LaunchLab pays 0.5% of every trade into `[creator, quote_mint]` under
+*     LaunchLab. One vault per wallet **per quote asset**, not one per coin, so a single
+*     `claim_creator_fee` sweeps every coin that creator launched against that quote. A creator
+*     with a SOL machine and a USDC machine claims twice, once per quote.
 *   - **After graduation.** The CPMM pool keeps the creator's fee inside the pool account, and
 *     `collect_creator_fee` pays it out. That is per pool, so it takes one call per coin.
 *
-* Both instructions pay into the creator's WSOL associated token account. Every builder here closes
-* that account afterwards, so the creator ends up with plain SOL in their wallet.
+* Both instructions pay into the creator's associated token account for the quote mint, under that
+* mint's own token program. When the quote is WSOL, every builder here closes that account
+* afterwards, so the creator ends up with plain SOL. For any other quote the account is created if
+* missing and left alone: closing it would throw away a real balance.
 *
 * **Closing unwraps everything.** If the creator already held WSOL in that account before the
 * claim, closing turns that into SOL too. Nothing is lost, but the balance moves.
 */
-const base64 = getBase64Encoder();
 /**
-* Create the creator's WSOL account, if it is missing, and close it again at the end.
+* Create the creator's quote account, if it is missing, and close it again when it is WSOL.
 *
 * Raydium's own instructions create the account when they need to, but an idempotent create here
-* costs nothing and makes the flow the same whichever instruction runs. The close is what turns the
-* WSOL into SOL.
+* costs nothing and makes the flow the same whichever instruction runs. The close is what turns
+* WSOL into SOL, so it only belongs on a WSOL claim: closing a USDC account would throw the payout
+* away.
 */
-async function wrapAround(creator, middle) {
-	const account = await ata(creator.address, WSOL_MINT);
+async function wrapAround(creator, quote, middle) {
+	const account = await ata(creator.address, quote.mint, quote.tokenProgram);
+	const create = getCreateAssociatedTokenIdempotentInstruction({
+		payer: creator,
+		ata: account,
+		owner: creator.address,
+		mint: quote.mint,
+		tokenProgram: quote.tokenProgram
+	});
+	if (quote.mint !== "So11111111111111111111111111111111111111112") return [create, ...middle];
 	return [
-		getCreateAssociatedTokenIdempotentInstruction({
-			payer: creator,
-			ata: account,
-			owner: creator.address,
-			mint: WSOL_MINT,
-			tokenProgram: TOKEN_PROGRAM_ADDRESS
-		}),
+		create,
 		...middle,
 		getCloseAccountInstruction({
 			account,
@@ -2293,22 +2922,23 @@ function withSigner(accounts, signer) {
 	} : meta);
 }
 /**
-* The instructions of a curve fee claim: create the WSOL account, claim, close it.
+* The instructions of a curve fee claim, for one quote asset: create the quote account, claim, and
+* close it again when the quote is WSOL.
 *
-* This sweeps **every** coin this wallet launched, because LaunchLab keeps one vault per wallet per
-* quote asset. There is no per-coin version.
+* This sweeps **every** coin this wallet launched against that quote, because LaunchLab keeps one
+* vault per wallet per quote asset. There is no per-coin version, and a creator with machines in
+* two quote assets claims once per asset.
 */
-async function getClaimCreatorFeeInstructions(creator, ids) {
-	const quoteMint = WSOL_MINT;
-	return await wrapAround(creator, [{
+async function getClaimCreatorFeeInstructions(creator, ids, quote) {
+	return await wrapAround(creator, quote, [{
 		programAddress: ids.launchlab,
 		accounts: withSigner(order(LAUNCHLAB_CLAIM_CREATOR_FEE, {
 			creator: creator.address,
 			fee_vault_authority: await creatorFeeVaultAuthority(ids.launchlab),
-			creator_fee_vault: await creatorFeeVaultAddress(ids.launchlab, creator.address, quoteMint),
-			recipient_token_account: await ata(creator.address, quoteMint),
-			quote_mint: quoteMint,
-			token_program: TOKEN_PROGRAM_ADDRESS,
+			creator_fee_vault: await creatorFeeVaultAddress(ids.launchlab, creator.address, quote.mint),
+			recipient_token_account: await ata(creator.address, quote.mint, quote.tokenProgram),
+			quote_mint: quote.mint,
+			token_program: quote.tokenProgram,
 			system_program: SYSTEM_PROGRAM_ADDRESS,
 			associated_token_program: ASSOCIATED_TOKEN_PROGRAM_ADDRESS
 		}), creator),
@@ -2316,13 +2946,15 @@ async function getClaimCreatorFeeInstructions(creator, ids) {
 	}]);
 }
 /**
-* Claim the curve creator fee and receive it as SOL.
+* Claim the curve creator fee for one quote asset.
 *
-* One transaction, three instructions. It sweeps every coin this wallet launched on LaunchLab.
+* A WSOL claim arrives as SOL, because the builder closes the WSOL account. Any other quote arrives
+* as that token, in the creator's own account.
 */
 async function claimCreatorFee(client, input) {
 	const ids = raydiumIds(client.cluster);
-	const instructions = await getClaimCreatorFeeInstructions(input.creator, ids);
+	const quote = await quoteOf(client, input.quoteMint ?? "So11111111111111111111111111111111111111112");
+	const instructions = await getClaimCreatorFeeInstructions(input.creator, ids, quote);
 	return await buildMessage(client, input.creator, instructions, {
 		addressLookupTables: input.addressLookupTables,
 		computeUnitLimit: input.computeUnitLimit ?? 55e3,
@@ -2330,22 +2962,39 @@ async function claimCreatorFee(client, input) {
 	});
 }
 /**
-* The instructions of a graduated coin's fee collection: create the WSOL account, collect, close.
+* The token program a quote mint lives under. WSOL is always classic SPL Token, so that one needs
+* no read at all.
+*/
+async function quoteOf(client, mint) {
+	if (mint === "So11111111111111111111111111111111111111112") return {
+		mint,
+		tokenProgram: TOKEN_PROGRAM_ADDRESS
+	};
+	return {
+		mint,
+		tokenProgram: (await fetchQuoteDisplay(client, mint)).tokenProgram
+	};
+}
+/**
+* The instructions of a graduated coin's fee collection: create the quote account, collect, and
+* close it again when the quote is WSOL.
 *
 * This is per coin. `collect_creator_fee` pays out both sides of the pair, so anything owed in the
 * coin itself lands in the creator's coin account and stays there.
+*
+* The coin's quote asset comes from its Gabox pool, so a caller never has to name it.
 */
 async function getCollectCreatorFeeInstructions(client, input, ids = raydiumIds(client.cluster)) {
 	const { mint, creator } = input;
-	const quoteMint = WSOL_MINT;
-	const settings = await fetchCurveSettings(client, ids);
+	const quote = input.quote ?? await fetchQuoteBinding(client, mint);
+	const settings = await fetchCurveSettings(client, quote.config, ids);
 	const { address: poolState, pool } = await findCpmmPool(client, {
 		mint,
-		quoteMint,
+		quoteMint: quote.mint,
 		creator: creator.address,
 		cpswapConfig: settings.cpswapConfig
 	});
-	return await wrapAround(creator, [{
+	const collect = {
 		programAddress: ids.cpmm,
 		accounts: withSigner(order(CPMM_COLLECT_CREATOR_FEE, {
 			creator: creator.address,
@@ -2365,13 +3014,23 @@ async function getCollectCreatorFeeInstructions(client, input, ids = raydiumIds(
 			creator_fee_share: await cpmmCreatorFeeShare(ids.cpmm, creator.address, pool.ammConfig)
 		}), creator),
 		data: new Uint8Array(CPMM_COLLECT_CREATOR_FEE.discriminator)
-	}]);
+	};
+	return await wrapAround(creator, {
+		mint: quote.mint,
+		tokenProgram: quote.tokenProgram
+	}, [collect]);
 }
-/** Collect one graduated coin's CPMM creator fee and receive the WSOL side as SOL. */
+/**
+* Collect one graduated coin's CPMM creator fee.
+*
+* A WSOL-quoted coin pays the quote side out as SOL, because the builder closes the WSOL account.
+* Any other quote arrives as that token.
+*/
 async function collectCreatorFee(client, input) {
 	const instructions = await getCollectCreatorFeeInstructions(client, {
 		mint: input.mint,
-		creator: input.creator
+		creator: input.creator,
+		...input.quote ? { quote: input.quote } : {}
 	});
 	return await buildMessage(client, input.creator, instructions, {
 		addressLookupTables: input.addressLookupTables,
@@ -2380,27 +3039,28 @@ async function collectCreatorFee(client, input) {
 	});
 }
 /**
-* Read both places a creator's fees can sit.
+* Read both places a creator's fees can sit, for one quote asset.
+*
+* `quoteMint` defaults to wrapped SOL. LaunchLab keeps one vault per wallet per quote, so a creator
+* with machines in two quote assets reads this twice.
 *
 * `mint` is optional. Without it only the curve vault is read, which is the one number that covers
-* every coin at once. With it the coin's CPMM pool is read too, and a coin that has not graduated
-* reports zeros rather than failing.
+* every coin of that quote at once. With it the coin's CPMM pool is read too, and a coin that has
+* not graduated reports zeros rather than failing.
 */
 async function fetchCreatorFees(client, input) {
 	const ids = raydiumIds(client.cluster);
-	const quoteMint = WSOL_MINT;
+	const quoteMint = input.quoteMint ?? "So11111111111111111111111111111111111111112";
 	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;
+	const [vaultAccount] = await readAccounts(client.rpc, [vault]);
+	const curveQuote = vaultAccount ? tokenAccountAmount(vaultAccount.data) : 0n;
 	if (!input.mint) return {
-		curveLamports,
-		cpmmLamports: 0n,
+		quoteMint,
+		curveQuote,
+		cpmmQuote: 0n,
 		cpmmTokens: 0n
 	};
-	const settings = await fetchCurveSettings(client, ids);
+	const settings = await fetchCurveSettings(client, await launchlabGlobalConfig(ids.launchlab, quoteMint), ids);
 	try {
 		const { pool } = await findCpmmPool(client, {
 			mint: input.mint,
@@ -2411,14 +3071,16 @@ async function fetchCreatorFees(client, input) {
 		const [token0] = sortedMints(input.mint, quoteMint);
 		const baseIsToken0 = token0 === input.mint;
 		return {
-			curveLamports,
-			cpmmLamports: baseIsToken0 ? pool.creatorFeesToken1 : pool.creatorFeesToken0,
+			quoteMint,
+			curveQuote,
+			cpmmQuote: baseIsToken0 ? pool.creatorFeesToken1 : pool.creatorFeesToken0,
 			cpmmTokens: baseIsToken0 ? pool.creatorFeesToken0 : pool.creatorFeesToken1
 		};
 	} catch {
 		return {
-			curveLamports,
-			cpmmLamports: 0n,
+			quoteMint,
+			curveQuote,
+			cpmmQuote: 0n,
 			cpmmTokens: 0n
 		};
 	}
@@ -2438,22 +3100,25 @@ async function fetchCreatorFees(client, input) {
 */
 const u64 = getU64Encoder();
 /**
-* `buy_exact_in` on the curve: spend exactly `quoteIn` WSOL and take whatever coins it buys.
+* `buy_exact_in` on the curve: spend exactly `quoteIn` of the quote token and take whatever coins
+* it buys.
 *
 * LaunchLab caps the trade at what the curve has left to sell, so a spend larger than the rest of
-* the raise still succeeds and graduates the coin. Wrap the SOL into the user's WSOL ATA first and
-* close it afterwards, the same way the Gabox builders do.
+* the raise still succeeds and graduates the coin. Fund the user's quote ATA first. On a WSOL pool
+* that means wrapping the SOL and closing the account afterwards, the same way the Gabox builders
+* do.
 */
 async function getCurveBuyExactInInstruction(client, input, ids = raydiumIds(client.cluster)) {
 	if (input.quoteIn <= 0n) throw new Error("quoteIn must be positive");
 	if (input.minTokensOut < 0n) throw new Error("minTokensOut must not be negative");
-	const quoteMint = WSOL_MINT;
+	const quoteMint = input.quoteMint ?? "So11111111111111111111111111111111111111112";
+	const quoteTokenProgram = input.quoteTokenProgram ?? "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 	const poolState = await launchlabPoolAddress(ids.launchlab, input.mint, quoteMint);
 	const accounts = launchlabBuyExactInAccounts({
 		launchlab: ids.launchlab,
 		launchlabAuthority: ids.launchlabAuthority,
 		launchlabEventAuthority: ids.launchlabEventAuthority,
-		globalConfig: ids.solGlobalConfig,
+		globalConfig: await launchlabGlobalConfig(ids.launchlab, quoteMint),
 		platformConfig: ids.gaboxPlatform,
 		poolState,
 		mint: input.mint,
@@ -2462,7 +3127,8 @@ async function getCurveBuyExactInInstruction(client, input, ids = raydiumIds(cli
 		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),
+		userQuoteToken: await ata(input.user.address, quoteMint, quoteTokenProgram),
+		quoteTokenProgram,
 		platformFeeVault: await platformFeeVaultAddress(ids.launchlab, ids.gaboxPlatform, quoteMint),
 		creatorFeeVault: await creatorFeeVaultAddress(ids.launchlab, input.creator, quoteMint)
 	});
@@ -2537,6 +3203,7 @@ var raydium_exports = /* @__PURE__ */ __exportAll({
 	RENT_SYSVAR_ADDRESS: () => RENT_SYSVAR_ADDRESS,
 	SHARE_FEE_RATE: () => SHARE_FEE_RATE,
 	SYSTEM_PROGRAM_ADDRESS: () => SYSTEM_PROGRAM_ADDRESS,
+	TOKEN_2022_PROGRAM_ADDRESS: () => TOKEN_2022_PROGRAM_ADDRESS,
 	TOKEN_PROGRAM_ADDRESS: () => TOKEN_PROGRAM_ADDRESS,
 	WSOL_MINT: () => WSOL_MINT,
 	ata: () => ata,
@@ -2560,6 +3227,7 @@ var raydium_exports = /* @__PURE__ */ __exportAll({
 	curveBuyExactOut: () => curveBuyExactOut,
 	curveQuote: () => curveQuote,
 	curveSellExactIn: () => curveSellExactIn,
+	decodeBase64: () => decodeBase64,
 	decodeCpmmAmmConfig: () => decodeCpmmAmmConfig,
 	decodeCpmmPool: () => decodeCpmmPool,
 	decodeLaunchlabGlobalConfig: () => decodeLaunchlabGlobalConfig,
@@ -2567,12 +3235,17 @@ var raydium_exports = /* @__PURE__ */ __exportAll({
 	decodeLaunchlabPool: () => decodeLaunchlabPool,
 	fetchCreatorFees: () => fetchCreatorFees,
 	fetchCurveSettings: () => fetchCurveSettings,
+	fetchQuoteAsset: () => fetchQuoteAsset,
+	fetchQuoteBinding: () => fetchQuoteBinding,
+	fetchQuoteConfig: () => fetchQuoteConfig,
+	fetchQuoteDisplay: () => fetchQuoteDisplay,
 	findCpmmPool: () => findCpmmPool,
 	getClaimCreatorFeeInstructions: () => getClaimCreatorFeeInstructions,
 	getCollectCreatorFeeInstructions: () => getCollectCreatorFeeInstructions,
 	getCurveBuyExactInInstruction: () => getCurveBuyExactInInstruction,
 	getLaunchInstruction: () => getLaunchInstruction,
 	initialCurve: () => initialCurve,
+	isQuoteSupported: () => isQuoteSupported,
 	launchlabAuthority: () => launchlabAuthority,
 	launchlabBuyAccounts: () => launchlabBuyAccounts,
 	launchlabBuyExactInAccounts: () => launchlabBuyExactInAccounts,
@@ -2583,22 +3256,27 @@ var raydium_exports = /* @__PURE__ */ __exportAll({
 	launchlabSellAccounts: () => launchlabSellAccounts,
 	launchlabVaultAddress: () => launchlabVaultAddress,
 	metadataAddress: () => metadataAddress,
+	metaplexSymbol: () => metaplexSymbol,
+	mintDecimals: () => mintDecimals,
 	newCurveBuyCost: () => newCurveBuyCost,
 	newCurveReserves: () => newCurveReserves,
 	order: () => order,
 	platformFeeVaultAddress: () => platformFeeVaultAddress,
 	preFeeAmount: () => preFeeAmount,
+	quoteAccountFor: () => quoteAccountFor,
 	raydiumIds: () => raydiumIds,
+	readAccounts: () => readAccounts,
 	remainingBase: () => remainingBase,
 	resolveVenue: () => resolveVenue,
 	sellQuote: () => sellQuote,
 	sortedMints: () => sortedMints,
+	token2022Symbol: () => token2022Symbol,
 	tokenAccountAmount: () => tokenAccountAmount,
 	tokenAccountOwnerAndMint: () => tokenAccountOwnerAndMint,
 	totalCurveFeeRate: () => totalCurveFeeRate,
 	wsolAccountFor: () => wsolAccountFor
 });
 //#endregion
-export { 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 };
+export { computeBudgetInstructions as $, LAUNCHLAB_BUY_EXACT_OUT as $n, launchlabVaultAddress as $t, initialCurve as A, CPMM_SEEDS as An, metaplexSymbol as At, fetchQuoteAsset as B, RATE_DENOMINATOR as Bn, vaultAddress as Bt, ceilDiv as C, PACK_TOKENS as Cn, LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE as Ct, curveBuyExactIn as D, VRF_DEFAULT_QUEUE as Dn, decodeLaunchlabGlobalConfig as Dt, cpmmSwapBaseOutput as E, TIMEOUT_SLOTS as En, decodeCpmmPool as Et, cpmmSellAccounts as F, LAUNCHLAB_STATUS_TRADE as Fn, activityAddress as Ft, readAccounts as G, sortedMints as Gn, cpmmPoolAddress as Gt, fetchQuoteDisplay as H, SHARE_FEE_RATE as Hn, ata as Ht, launchlabBuyAccounts as I, LAUNCH_DECIMALS as In, associatedTokenAddress as It, COMPUTE_BUDGET_PROGRAM_ADDRESS as J, CPMM_COLLECT_CREATOR_FEE as Jn, launchlabAuthority as Jt, BUY_PACK_COMPUTE_UNITS as K, ASSOCIATED_TOKEN_PROGRAM_ADDRESS as Kn, creatorFeeVaultAddress as Kt, launchlabBuyExactInAccounts as L, METADATA_LIMITS as Ln, drawAddress as Lt, remainingBase as M, LAUNCHLAB_SEEDS as Mn, token2022Symbol as Mt, totalCurveFeeRate as N, LAUNCHLAB_STATUS_FUND as Nn, tokenAccountAmount as Nt, curveBuyExactOut as O, VRF_PROGRAM_ADDRESS as On, decodeLaunchlabPlatformConfig as Ot, cpmmBuyAccounts as P, LAUNCHLAB_STATUS_MIGRATE as Pn, tokenAccountOwnerAndMint as Pt, REDEEM_COMPUTE_UNITS as Q, LAUNCHLAB_BUY_EXACT_IN as Qn, launchlabPoolAddress as Qt, launchlabSellAccounts as R, METADATA_SEED as Rn, poolAddress as Rt, wsolAccountFor as S, MAX_ATTEMPTS as Sn, LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE as St, cpmmSwapBaseInput as T, SLOT_HASHES_SYSVAR as Tn, decodeCpmmAmmConfig as Tt, isQuoteSupported as U, compareAddresses as Un, cpmmAuthority as Ut, fetchQuoteConfig as V, RAYDIUM_IDS as Vn, vrfIdentityAddress as Vt, decodeBase64 as W, raydiumIds as Wn, cpmmCreatorFeeShare as Wt, DEFAULT_COMPUTE_UNIT_LIMIT as X, CPMM_SWAP_BASE_INPUT as Xn, launchlabGlobalConfig as Xt, CREATE_MACHINE_COMPUTE_UNITS as Y, CPMM_POOL_STATE_DISCRIMINATOR as Yn, launchlabEventAuthority as Yt, MAX_COMPUTE_UNIT_LIMIT as Z, CPMM_SWAP_BASE_OUTPUT as Zn, launchlabPlatformConfig as Zt, newCurveBuyCost as _, validatePack as _n, tiersOf as _t, fetchCreatorFees as a, MAX_MULTIPLIER_BPS as an, LAUNCHLAB_SELL_EXACT_IN as ar, POOL_MINT_OFFSET as at, resolveVenue as b, IDENTITY_SEED as bn, CPMM_POOL_STATE_HEAD_SIZE as bt, getLaunchInstruction as c, TIERS as cn, METAPLEX_PROGRAM_ADDRESS as cr, fetchPoolByMint as ct, cpmmPoolMatches as d, maxMultiplierBps as dn, RAYDIUM_MAINNET_IDS as dr, fetchWalletActivity as dt, metadataAddress as en, LAUNCHLAB_CLAIM_CREATOR_FEE as er, getSetComputeUnitLimitInstruction as et, creatorFeeOnInput as f, quote as fn, RENT_SYSVAR_ADDRESS as fr, listDraws as ft, findCpmmPool as g, uncappedMaximum as gn, WSOL_MINT as gr, quotePool as gt, fetchQuoteBinding as h, tierAmount as hn, TOKEN_PROGRAM_ADDRESS as hr, listPools as ht, collectCreatorFee as i, GaboxMathError as in, LAUNCHLAB_POOL_STATE_DISCRIMINATOR as ir, POOL_CREATOR_OFFSET as it, preFeeAmount as j, CREATOR_FEE_ON_QUOTE as jn, mintDecimals as jt, curveSellExactIn as k, CONSTANT_CURVE_TAG as kn, decodeLaunchlabPool as kt, buildMessage as l, averageMultiplierBps as ln, PLATFORM_ADMIN as lr, fetchPoolInventory as lt, fetchCurveSettings as m, seedTokens as mn, TOKEN_2022_PROGRAM_ADDRESS as mr, listDrawsByPurchaser as mt, getCurveBuyExactInInstruction as n, BPS as nn, LAUNCHLAB_INITIALIZE as nr, DRAW_POOL_OFFSET as nt, getClaimCreatorFeeInstructions as o, MIN_SEED_MULTIPLIER_BPS as on, LAUNCH_SUPPLY as or, fetchDraw as ot, curveQuote as p, resolveReservation as pn, SYSTEM_PROGRAM_ADDRESS as pr, listDrawsByPool as pt, CLAIM_COMPUTE_UNITS as q, CPMM_AMM_CONFIG_DISCRIMINATOR as qn, creatorFeeVaultAuthority as qt, claimCreatorFee as r, DEFAULT_TIERS as rn, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR as rr, DRAW_PURCHASER_OFFSET as rt, getCollectCreatorFeeInstructions as s, TICKETS as sn, LAUNCH_TOTAL_BASE_SELL as sr, fetchPoolAt as st, raydium_exports as t, platformFeeVaultAddress as tn, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR as tr, getSetComputeUnitPriceInstruction as tt, withRemainingAccounts as u, choose as un, RAYDIUM_DEVNET_IDS as ur, fetchVaultBalance as ut, newCurveReserves as v, validateTiers as vn, CPMM_AMM_CONFIG_HEAD_SIZE as vt, ceilDivRate as w, RETRY_SLOTS as wn, LAUNCHLAB_POOL_STATE_HEAD_SIZE as wt, sellQuote as x, INSTRUCTIONS_SYSVAR as xn, CPMM_POOL_STATE_SIZE as xt, quoteAccountFor as y, GABOX_PROGRAM_ID as yn, CPMM_POOL_OFFSETS as yt, order as z, MIGRATE_TO_CPMM as zn, scopedVrfIdentityAddress as zt };
 
-//# sourceMappingURL=raydium-B-l9V3O-.js.map
+//# sourceMappingURL=raydium-CU-tZzIk.js.map