@gabox-labs/sdk 0.7.1 → 0.9.0

package/dist/{raydium-CU-tZzIk.js → raydium-DXUJ-g1p.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { Dt as POOL_DISCRIMINATOR, Et as getWalletActivitySize, Jt as getDrawSize, Lt as getPoolSize, Ot as decodePool, Rt as DRAW_DISCRIMINATOR, _t as decodeWalletActivity, ft as findPoolPda, ht as findActivityPda, mt as findDrawPda, pt as findIdentityPda, t as GABOX_PROGRAM_ADDRESS, zt as decodeDraw } from "./gabox-DGTCh34U.js";
-import { AccountRole, Endian, addEncoderSizePrefix, appendTransactionMessageInstructions, compileTransaction, compressTransactionMessageUsingAddressLookupTables, createTransactionMessage, fetchEncodedAccount, fixDecoderSize, getAddressDecoder, getAddressEncoder, getBase58Decoder, getBase64Encoder, getBooleanDecoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, getTransactionEncoder, getU16Decoder, getU16Encoder, getU32Encoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, getUtf8Encoder, pipe, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash } from "@solana/kit";
+import { $t as getPoolSize, At as findDrawPda, Ht as getWalletActivitySize, Nt as decodeWalletActivity, Ot as findPoolPda, Ut as POOL_DISCRIMINATOR, Wt as decodePool, en as DRAW_DISCRIMINATOR, jt as findActivityPda, kt as findIdentityPda, t as GABOX_PROGRAM_ADDRESS, tn as decodeDraw, un as getDrawSize } from "./gabox-CuyJYmrS.js";
+import { AccountRole, Endian, addEncoderSizePrefix, appendTransactionMessageInstructions, compileTransaction, compressTransactionMessageUsingAddressLookupTables, createTransactionMessage, fetchEncodedAccount, fixDecoderSize, getAddressDecoder, getAddressEncoder, getBase58Decoder, getBase64Encoder, getBooleanDecoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, getTransactionEncoder, getU128Decoder, 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 = {
@@ -603,6 +603,69 @@ const LAUNCHLAB_CLAIM_CREATOR_FEE = {
 	]
 };
 /**
+* `claim_platform_fee_from_vault` on `LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj` — not in interfaces.json (the program never builds it).
+*/
+const LAUNCHLAB_CLAIM_PLATFORM_FEE_FROM_VAULT = {
+	name: "claim_platform_fee_from_vault",
+	discriminator: new Uint8Array([
+		117,
+		241,
+		198,
+		168,
+		248,
+		218,
+		80,
+		29
+	]),
+	accounts: [
+		{
+			name: "platform_fee_wallet",
+			writable: true,
+			signer: true
+		},
+		{
+			name: "fee_vault_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "platform_config",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "platform_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 = {
@@ -878,6 +941,14 @@ const CPMM_COLLECT_CREATOR_FEE = {
 * `test/raydium-pdas.test.ts` derives each PDA again and compares.
 */
 const ADDRESS_ENCODER = getAddressEncoder();
+const LOCK_MAINNET_IDS = {
+	lock: "LockrWmn6K5twhz3y9w1dQERbmgSaRkfnTeTKbpofwE",
+	lockAuthority: "3f7GcQFG397GAaEnv51zR6tsTVihYRydnydDD1cXekxH"
+};
+const LOCK_DEVNET_IDS = {
+	lock: "DRay25Usp3YJAi7beckgpGUC7mGJ2cR1AVPxhYfwVCUX",
+	lockAuthority: "7qWVV8UY2bRJfDLP4s37YzBPKUkVB46DStYJBpYbQzu3"
+};
 /**
 * 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.
@@ -891,9 +962,18 @@ const LAUNCH_DECIMALS = 6;
 * 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
+	"mainnet-beta": {
+		...RAYDIUM_MAINNET_IDS,
+		...LOCK_MAINNET_IDS
+	},
+	devnet: {
+		...RAYDIUM_DEVNET_IDS,
+		...LOCK_DEVNET_IDS
+	},
+	localnet: {
+		...RAYDIUM_MAINNET_IDS,
+		...LOCK_MAINNET_IDS
+	}
 };
 /** The Raydium deployment one cluster trades on. Throws for a cluster this SDK does not know. */
 function raydiumIds(cluster) {
@@ -916,7 +996,9 @@ const LAUNCHLAB_SEEDS = {
 	/** `["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"
+	creatorFeeVaultAuthority: "creator_fee_vault_auth_seed",
+	/** `["platform_fee_vault_auth_seed"]`, the authority over every platform fee vault. */
+	platformFeeVaultAuthority: "platform_fee_vault_auth_seed"
 };
 /** CPMM's PDA seeds. */
 const CPMM_SEEDS = {
@@ -931,6 +1013,15 @@ const CPMM_SEEDS = {
 	/** `["creator_fee_share", creator, amm_config]`. */
 	creatorFeeShare: "creator_fee_share"
 };
+/** The SPL Memo program. The lock program's `collect_cp_fees` lists it and never writes to it. */
+const MEMO_PROGRAM_ADDRESS = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+/** The lock program's PDA seeds. */
+const LOCK_SEEDS = {
+	/** `["lock_cp_authority_seed"]`. */
+	authority: "lock_cp_authority_seed",
+	/** `["locked_liquidity", fee_nft_mint]`. One record per locked position. */
+	lockedLiquidity: "locked_liquidity"
+};
 /** Metaplex's metadata PDA seed: `["metadata", metaplex, mint]`. */
 const METADATA_SEED = "metadata";
 /**
@@ -973,43 +1064,6 @@ 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`.
@@ -1038,6 +1092,12 @@ const MAX_MULTIPLIER_BPS = 2e5;
 const TICKETS = 65536;
 /** The prize table has exactly this many slots. Unused slots are all-zero. */
 const TIERS = 8;
+/**
+* `constants::MAX_BATCH_SIZE`. The most packs one `buy_packs` call opens. A limit per purchase,
+* not on pending packs: any number of buyers and overlapping purchases are fine, because every
+* pending draw carries its own reservation.
+*/
+const MAX_BATCH_SIZE = 5;
 /** Thrown by every function here. `code` matches a `GaboxError` variant name. */
 var GaboxMathError = class extends Error {
 	code;
@@ -1242,6 +1302,124 @@ function choose(prizes, ticket) {
 	}
 	return 0n;
 }
+/** A ticket is a `u16`: the first two bytes of the pack's hash, little-endian. */
+function checkedTicket(ticket) {
+	if (!Number.isInteger(ticket) || ticket < 0 || ticket >= 65536) throw new GaboxMathError("Arithmetic", `a ticket is an integer from 0 to 65535`);
+	return ticket;
+}
+/** `count` is a `u8` the program bounds at `MAX_BATCH_SIZE`. Zero is refused before any trade. */
+function checkedCount(count) {
+	if (!Number.isInteger(count) || count < 1) throw new GaboxMathError("ZeroAmount", "a purchase opens at least one pack");
+	if (count > 5) throw new GaboxMathError("TooManyPacks", `a purchase opens at most 5 packs`);
+	return count;
+}
+/**
+* `math::uncapped`. Every tier's award for this base before any inventory cap, `0n` on an unused
+* row. A ticketed tier that would pay nothing is refused, the same as in `quote`.
+*/
+function uncappedAmounts(base, tiers) {
+	validateTiers(tiers);
+	return tiers.map((tier, i) => {
+		if (tier.tickets === 0) return 0n;
+		const amount = tierAmount(base, tier.multiplierBps);
+		if (amount === 0n) throw new GaboxMathError("PackTooSmall", `tier ${i} rounds to zero tokens at this pack size`);
+		return amount;
+	});
+}
+/** `math::min_tier`. The ticketed tier with the smallest award. Expiry pays it for every pack. */
+function minTier(uncapped, tiers) {
+	let best = null;
+	for (const [i, tier] of tiers.entries()) {
+		if (tier.tickets === 0) continue;
+		if (best === null || uncapped[i] < uncapped[best]) best = i;
+	}
+	return best ?? 0;
+}
+/**
+* `math::choose_index`. Which tier a 16-bit ticket lands on: the rows are consecutive ranges in
+* table order. Exactly 65,536 tickets, so there is no modulo and no bias.
+*/
+function chooseIndex(tiers, ticket) {
+	checkedTicket(ticket);
+	let end = 0;
+	let last = 0;
+	for (const [i, tier] of tiers.entries()) {
+		if (tier.tickets === 0) continue;
+		last = i;
+		end += tier.tickets;
+		if (ticket < end) return i;
+	}
+	return last;
+}
+/**
+* `math::reserve_for`. What a purchase of `count` packs adds to `pool.reserved`:
+* `min(count * uncappedMax, free + count * packTokens)`. Settlement in order can never pay more
+* than either bound, so this is the least reservation that keeps the vault solvent whatever the
+* outcomes. With `count = 1` it is exactly the single pack's capped maximum.
+*/
+function reserveFor(count, packTokens, uncappedMax, free) {
+	checkedCount(count);
+	const byPrizes = checkedU64(uncappedMax * BigInt(count), "reservation");
+	const byVault = checkedU64(free + packTokens * BigInt(count), "reservation");
+	return byPrizes < byVault ? byPrizes : byVault;
+}
+/**
+* `math::settle_with`. Settle a batch in order from explicit tickets.
+*
+* Pack k's table caps every tier at what the vault can pay after packs 1..k-1 paid out, counting
+* the batch's own tokens as they arrive: pack 1 sees `freeSnapshot + packTokens`, and every later
+* pack sees the remainder plus one more pack. So no pack can lose its own base to an earlier pack,
+* and the total never exceeds `reserveFor(...)`.
+*
+* With `timedOut` every pack pays its smallest tier, and `tickets` is ignored.
+*/
+function settleWith(tiers, packTokens, freeSnapshot, count, tickets, timedOut = false) {
+	checkedCount(count);
+	const uncapped = uncappedAmounts(packTokens, tiers);
+	const fallback = minTier(uncapped, tiers);
+	let avail = checkedU64(freeSnapshot + packTokens, "available inventory");
+	let total = 0n;
+	const results = [];
+	for (let k = 0; k < count; k++) {
+		let tier;
+		if (timedOut) tier = fallback;
+		else {
+			const ticket = tickets[k];
+			if (ticket === void 0) throw new GaboxMathError("Arithmetic", `no ticket for pack ${k} of ${count}`);
+			tier = chooseIndex(tiers, ticket);
+		}
+		const cap = uncapped[tier];
+		const amount = cap < avail ? cap : avail;
+		results.push({
+			tier,
+			amount
+		});
+		total = checkedU64(total + amount, "settlement total");
+		avail = checkedU64(avail - amount + packTokens, "available inventory");
+	}
+	return {
+		total,
+		results
+	};
+}
+/**
+* The top prize each pack of a purchase can still win if every pack before it won its own top
+* prize: the worst case for the later packs, which is what a buyer should see next to the first
+* pack's table. `caps[0]` is the first pack's capped maximum; on a deep vault every entry is the
+* uncapped jackpot, on a thin one the later entries fall towards one pack.
+*/
+function perPackCaps(tiers, packTokens, freeSnapshot, count) {
+	checkedCount(count);
+	const uncapped = uncappedMaximum(packTokens, tiers);
+	let avail = checkedU64(freeSnapshot + packTokens, "available inventory");
+	const caps = [];
+	for (let k = 0; k < count; k++) {
+		const cap = uncapped < avail ? uncapped : avail;
+		caps.push(cap);
+		avail = checkedU64(avail - cap + packTokens, "available inventory");
+	}
+	return caps;
+}
 /** `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");
@@ -1274,6 +1452,43 @@ function averageMultiplierBps(tiers) {
 	return Number(weighted / BigInt(TICKETS));
 }
 //#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_packs` 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/raydium/pdas.ts
 /**
 * Every Raydium address a Gabox transaction derives.
@@ -1337,6 +1552,11 @@ const platformFeeVaultAddress = async (launchlab, platformConfig, quoteMint) =>
 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)]);
+/**
+* `["platform_fee_vault_auth_seed"]`. The authority `claim_platform_fee_from_vault` signs the
+* payout with.
+*/
+const platformFeeVaultAuthority = async (launchlab) => await derive(launchlab, [utf8.encode(LAUNCHLAB_SEEDS.platformFeeVaultAuthority)]);
 /** `["metadata", metaplex, mint]` under Metaplex. LaunchLab's create instruction writes it. */
 const metadataAddress = async (mint) => await derive(METAPLEX_PROGRAM_ADDRESS, [
 	utf8.encode(METADATA_SEED),
@@ -1379,6 +1599,13 @@ const cpmmCreatorFeeShare = async (cpmm, creator, ammConfig) => await derive(cpm
 	address$1.encode(creator),
 	address$1.encode(ammConfig)
 ]);
+/** `["lock_cp_authority_seed"]`. The lock program's authority, which owns every locked LP vault. */
+const lockAuthority = async (lock) => await derive(lock, [utf8.encode(LOCK_SEEDS.authority)]);
+/**
+* `["locked_liquidity", fee_nft_mint]`. The record of one locked position: which pool, how much LP,
+* and the checkpoint the next fee harvest is measured from.
+*/
+const lockedLiquidityAddress = async (lock, feeNftMint) => await derive(lock, [utf8.encode(LOCK_SEEDS.lockedLiquidity), address$1.encode(feeNftMint)]);
 /** 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),
@@ -1398,12 +1625,30 @@ const ata = async (owner, mint, tokenProgram = TOKEN_PROGRAM_ADDRESS) => await d
 */
 /** `["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({
+/**
+* `["draw", pool, purchaser, nonce]`, with the nonce as eight little-endian bytes. The buyer's
+* client picks the nonce, so two buyers, or two purchases of one buyer, never name the same draw.
+* The pool's sequence counter is not in the address any more; the program assigns `seqStart`
+* when the purchase executes.
+*/
+const drawAddress = async (pool, purchaser, nonce) => (await findDrawPda({
 	pool,
-	seq
+	purchaser,
+	nonce
 }))[0];
-/** The per-wallet `WalletActivity` PDA. `buy_pack` derives it from the purchaser automatically. */
+/**
+* A random `u64` nonce for one purchase. `buyPacks` draws one per build. A nonce that is still in
+* use fails the purchase at the program; one whose draw already closed names a new draw, so a
+* rebuilt transaction must never reuse the nonce of a purchase that may have landed.
+*/
+function randomNonce() {
+	const bytes = /* @__PURE__ */ new Uint8Array(8);
+	crypto.getRandomValues(bytes);
+	let nonce = 0n;
+	for (let i = 7; i >= 0; i--) nonce = nonce << 8n | BigInt(bytes[i]);
+	return nonce;
+}
+/** The per-wallet `WalletActivity` PDA. `buy_packs` 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];
@@ -1440,7 +1685,8 @@ const vaultAddress = async (mint) => await associatedTokenAddress(await poolAddr
 const DISCRIMINATOR$1 = 8;
 const u8 = getU8Decoder();
 const u16 = getU16Decoder();
-const u64$1 = getU64Decoder();
+const u64$2 = getU64Decoder();
+const u128 = getU128Decoder();
 const addressAt = getAddressDecoder();
 const bool = getBooleanDecoder();
 /** Refuse an account that is too short or carries another type's discriminator. */
@@ -1462,7 +1708,7 @@ function atLeast(data, size, what) {
 */
 function tokenAccountAmount(data) {
 	if (data.length < 72) throw new Error("not a token account: fewer than 72 bytes");
-	return u64$1.decode(data, 64);
+	return u64$2.decode(data, 64);
 }
 /** The `mint` and `owner` of an SPL token account: bytes 0 to 32 and 32 to 64. */
 function tokenAccountOwnerAndMint(data) {
@@ -1542,27 +1788,27 @@ function token2022Symbol(data) {
 }
 /** Offsets follow the `PoolState` field list in `idl/raydium_launchpad.json`. */
 const LAUNCHLAB_POOL_HEAD = getStructDecoder([
-	["epoch", u64$1],
+	["epoch", u64$2],
 	["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],
+	["supply", u64$2],
+	["totalBaseSell", u64$2],
+	["virtualBase", u64$2],
+	["virtualQuote", u64$2],
+	["realBase", u64$2],
+	["realQuote", u64$2],
+	["totalQuoteFundRaising", u64$2],
+	["quoteProtocolFee", u64$2],
+	["platformFee", u64$2],
+	["migrateFee", u64$2],
+	["vestingTotalLockedAmount", u64$2],
+	["vestingCliffPeriod", u64$2],
+	["vestingUnlockPeriod", u64$2],
+	["vestingStartTime", u64$2],
+	["vestingAllocatedShareAmount", u64$2],
 	["globalConfig", addressAt],
 	["platformConfig", addressAt],
 	["baseMint", addressAt],
@@ -1603,17 +1849,17 @@ function decodeLaunchlabPool(data) {
 	};
 }
 const LAUNCHLAB_GLOBAL_CONFIG_HEAD = getStructDecoder([
-	["epoch", u64$1],
+	["epoch", u64$2],
 	["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],
+	["migrateFee", u64$2],
+	["tradeFeeRate", u64$2],
+	["maxShareFeeRate", u64$2],
+	["minBaseSupply", u64$2],
+	["maxLockRate", u64$2],
+	["minBaseSellRate", u64$2],
+	["minBaseMigrateRate", u64$2],
+	["minQuoteFundRaising", u64$2],
 	["quoteMint", addressAt]
 ]);
 const LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE = 115;
@@ -1635,13 +1881,13 @@ function decodeLaunchlabGlobalConfig(data) {
 * are fixed byte arrays, so this is the same length for every platform.
 */
 const LAUNCHLAB_PLATFORM_CONFIG_HEAD = getStructDecoder([
-	["epoch", u64$1],
+	["epoch", u64$2],
 	["platformFeeWallet", addressAt],
 	["platformNftWallet", addressAt],
-	["platformScale", u64$1],
-	["creatorScale", u64$1],
-	["burnScale", u64$1],
-	["feeRate", u64$1]
+	["platformScale", u64$2],
+	["creatorScale", u64$2],
+	["burnScale", u64$2],
+	["feeRate", u64$2]
 ]);
 const PLATFORM_CPSWAP_CONFIG_OFFSET = 688;
 const PLATFORM_CREATOR_FEE_RATE_OFFSET = 720;
@@ -1655,7 +1901,7 @@ function decodeLaunchlabPlatformConfig(data) {
 	return {
 		platformFeeWallet: head.platformFeeWallet,
 		feeRate: head.feeRate,
-		creatorFeeRate: u64$1.decode(data, PLATFORM_CREATOR_FEE_RATE_OFFSET),
+		creatorFeeRate: u64$2.decode(data, PLATFORM_CREATOR_FEE_RATE_OFFSET),
 		cpswapConfig: addressAt.decode(data, PLATFORM_CPSWAP_CONFIG_OFFSET),
 		platformCpCreator: addressAt.decode(data, PLATFORM_CP_CREATOR_OFFSET)
 	};
@@ -1676,18 +1922,18 @@ const CPMM_POOL_HEAD = getStructDecoder([
 	["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],
+	["lpSupply", u64$2],
+	["protocolFeesToken0", u64$2],
+	["protocolFeesToken1", u64$2],
+	["fundFeesToken0", u64$2],
+	["fundFeesToken1", u64$2],
+	["openTime", u64$2],
+	["recentEpoch", u64$2],
 	["creatorFeeOn", u8],
 	["enableCreatorFee", bool],
 	["padding1", fixDecoderSize(getBytesDecoder(), 6)],
-	["creatorFeesToken0", u64$1],
-	["creatorFeesToken1", u64$1]
+	["creatorFeesToken0", u64$2],
+	["creatorFeesToken1", u64$2]
 ]);
 const CPMM_POOL_STATE_HEAD_SIZE = 413;
 /**
@@ -1715,12 +1961,14 @@ function decodeCpmmPool(data) {
 		poolCreator: head.poolCreator,
 		token0Vault: head.token0Vault,
 		token1Vault: head.token1Vault,
+		lpMint: head.lpMint,
 		token0Mint: head.token0Mint,
 		token1Mint: head.token1Mint,
 		token0Program: head.token0Program,
 		token1Program: head.token1Program,
 		observationKey: head.observationKey,
 		status: head.status,
+		lpSupply: head.lpSupply,
 		mint0Decimals: head.mint0Decimals,
 		mint1Decimals: head.mint1Decimals,
 		protocolFeesToken0: head.protocolFeesToken0,
@@ -1738,13 +1986,13 @@ const CPMM_AMM_CONFIG_HEAD = getStructDecoder([
 	["bump", u8],
 	["disableCreatePool", bool],
 	["index", u16],
-	["tradeFeeRate", u64$1],
-	["protocolFeeRate", u64$1],
-	["fundFeeRate", u64$1],
-	["createPoolFee", u64$1],
+	["tradeFeeRate", u64$2],
+	["protocolFeeRate", u64$2],
+	["fundFeeRate", u64$2],
+	["createPoolFee", u64$2],
 	["protocolOwner", addressAt],
 	["fundOwner", addressAt],
-	["creatorFeeRate", u64$1]
+	["creatorFeeRate", u64$2]
 ]);
 const CPMM_AMM_CONFIG_HEAD_SIZE = 116;
 function decodeCpmmAmmConfig(data) {
@@ -1760,12 +2008,48 @@ function decodeCpmmAmmConfig(data) {
 		creatorFeeRate: head.creatorFeeRate
 	};
 }
+/** `sha256("account:LockedCpLiquidityState")[0..8]`. */
+const LOCKED_CP_LIQUIDITY_DISCRIMINATOR = new Uint8Array([
+	25,
+	10,
+	238,
+	197,
+	207,
+	234,
+	73,
+	22
+]);
+const LOCKED_CP_LIQUIDITY = getStructDecoder([
+	["lockedLpAmount", u64$2],
+	["claimedLpAmount", u64$2],
+	["unclaimedLpAmount", u64$2],
+	["lastLp", u64$2],
+	["lastK", u128],
+	["recentEpoch", u64$2],
+	["poolId", addressAt],
+	["feeNftMint", addressAt],
+	["lockedOwner", addressAt],
+	["lockedLpMint", addressAt]
+]);
+/** Six numbers and four addresses after the discriminator. The account itself is 256 bytes. */
+const LOCKED_CP_LIQUIDITY_HEAD_SIZE = 192;
+function decodeLockedCpLiquidity(data) {
+	checked(data, LOCKED_CP_LIQUIDITY_DISCRIMINATOR, "locked liquidity record");
+	atLeast(data, 192, "locked liquidity record");
+	return LOCKED_CP_LIQUIDITY.decode(data, DISCRIMINATOR$1);
+}
 //#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;
+/**
+* The `settled` byte: after pool, purchaser, nonce, bump, seq_start, count, two slots, attempts,
+* eight tiers, pack_tokens, free_snapshot and reserved. `test/surface.test.ts` pins it against the
+* generated encoder.
+*/
+const DRAW_SETTLED_OFFSET = 195;
 const POOL_CREATOR_OFFSET = DISCRIMINATOR;
 const POOL_MINT_OFFSET = 40;
 const base58 = getBase58Decoder();
@@ -1811,7 +2095,7 @@ function decodeCurrentWalletActivity(account) {
 }
 /**
 * 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.
+* `buy_packs` 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" }));
@@ -1840,6 +2124,23 @@ async function listDraws(client, query = {}) {
 }
 const listDrawsByPool = async (client, pool) => await listDraws(client, { pool });
 const listDrawsByPurchaser = async (client, purchaser) => await listDraws(client, { purchaser });
+/**
+* A purchaser's draws that settled without paying: the callback could not use the purchaser's coin
+* account, so the tokens wait in the vault as `owed` until `claimPrize` or `claimPrizeTo` pays
+* them. A pending draw is not in this list, and a paid one no longer exists.
+*/
+async function fetchOwedDraws(client, purchaser) {
+	const filters = [
+		memcmp$1(0, asBase58(DRAW_DISCRIMINATOR)),
+		{ dataSize: BigInt(getDrawSize()) },
+		memcmp$1(40, purchaser),
+		memcmp$1(195, asBase58(new Uint8Array([1])))
+	];
+	return (await scan(client.rpc, filters, (address, data) => ({
+		address,
+		data: decodeDraw(encoded(address, data)).data
+	}))).filter((row) => row.data.settled && row.data.owed > 0n);
+}
 async function fetchVaultBalance(client, mint) {
 	const vault = await vaultAddress(mint);
 	const { value } = await client.rpc.getAccountInfo(vault, {
@@ -1923,9 +2224,18 @@ const CREATE_MACHINE_COMPUTE_UNITS = 35e4;
 * 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.
+*
+* One figure for every `count` from 1 to `MAX_BATCH_SIZE`: a purchase of five packs is still one
+* trade, one draw and one request. The per-pack work runs in the oracle's callback, on the oracle's
+* own budget. The devnet end-to-end test re-measures count 1 and 5.
 */
 const BUY_PACK_COMPUTE_UNITS = 235e3;
 /**
+* `claim_prize`: create the purchaser's ATA when it is missing, one transfer, close the draw. An
+* estimate until the devnet run measures it; a caller may override it.
+*/
+const CLAIM_PRIZE_COMPUTE_UNITS = 8e4;
+/**
 * 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.
 */
@@ -1936,6 +2246,15 @@ const REDEEM_COMPUTE_UNITS = 125e3;
 * on a pool quoted in another token is cheaper, `17,635`, because nothing has to be unwrapped.
 */
 const CLAIM_COMPUTE_UNITS = 55e3;
+/**
+* A harvest of one locked CPMM position: `collect_cp_fees` on the lock program, which withdraws
+* LP through CPMM and pays both sides out.
+*
+* Measured at `102,221` on devnet on 2026-09-19 (tx `5s7xvy23…`), with both token accounts
+* created in the same transaction and the WSOL one closed again. `82,697` of that is the lock
+* program itself.
+*/
+const HARVEST_COMPUTE_UNITS = 15e4;
 /** `ComputeBudgetInstruction`'s discriminants. Positional and append-only upstream. */
 const SET_COMPUTE_UNIT_LIMIT = 2;
 const SET_COMPUTE_UNIT_PRICE = 3;
@@ -2894,7 +3213,7 @@ async function getLaunchInstruction(input, ids) {
 * WSOL into SOL, so it only belongs on a WSOL claim: closing a USDC account would throw the payout
 * away.
 */
-async function wrapAround(creator, quote, middle) {
+async function wrapAround$1(creator, quote, middle) {
 	const account = await ata(creator.address, quote.mint, quote.tokenProgram);
 	const create = getCreateAssociatedTokenIdempotentInstruction({
 		payer: creator,
@@ -2915,7 +3234,7 @@ async function wrapAround(creator, quote, middle) {
 	];
 }
 /** Attach a signer to the one slot the ABI marks as signing. Roles never change here. */
-function withSigner(accounts, signer) {
+function withSigner$1(accounts, signer) {
 	return accounts.map((meta) => (meta.role === AccountRole.READONLY_SIGNER || meta.role === AccountRole.WRITABLE_SIGNER) && meta.address === signer.address ? {
 		...meta,
 		signer
@@ -2930,9 +3249,9 @@ function withSigner(accounts, signer) {
 * two quote assets claims once per asset.
 */
 async function getClaimCreatorFeeInstructions(creator, ids, quote) {
-	return await wrapAround(creator, quote, [{
+	return await wrapAround$1(creator, quote, [{
 		programAddress: ids.launchlab,
-		accounts: withSigner(order(LAUNCHLAB_CLAIM_CREATOR_FEE, {
+		accounts: withSigner$1(order(LAUNCHLAB_CLAIM_CREATOR_FEE, {
 			creator: creator.address,
 			fee_vault_authority: await creatorFeeVaultAuthority(ids.launchlab),
 			creator_fee_vault: await creatorFeeVaultAddress(ids.launchlab, creator.address, quote.mint),
@@ -2953,7 +3272,7 @@ async function getClaimCreatorFeeInstructions(creator, ids, quote) {
 */
 async function claimCreatorFee(client, input) {
 	const ids = raydiumIds(client.cluster);
-	const quote = await quoteOf(client, input.quoteMint ?? "So11111111111111111111111111111111111111112");
+	const quote = await quoteOf$1(client, input.quoteMint ?? "So11111111111111111111111111111111111111112");
 	const instructions = await getClaimCreatorFeeInstructions(input.creator, ids, quote);
 	return await buildMessage(client, input.creator, instructions, {
 		addressLookupTables: input.addressLookupTables,
@@ -2965,7 +3284,7 @@ async function claimCreatorFee(client, input) {
 * 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) {
+async function quoteOf$1(client, mint) {
 	if (mint === "So11111111111111111111111111111111111111112") return {
 		mint,
 		tokenProgram: TOKEN_PROGRAM_ADDRESS
@@ -2996,7 +3315,7 @@ async function getCollectCreatorFeeInstructions(client, input, ids = raydiumIds(
 	});
 	const collect = {
 		programAddress: ids.cpmm,
-		accounts: withSigner(order(CPMM_COLLECT_CREATOR_FEE, {
+		accounts: withSigner$1(order(CPMM_COLLECT_CREATOR_FEE, {
 			creator: creator.address,
 			authority: ids.cpmmAuthority,
 			pool_state: poolState,
@@ -3015,7 +3334,7 @@ async function getCollectCreatorFeeInstructions(client, input, ids = raydiumIds(
 		}), creator),
 		data: new Uint8Array(CPMM_COLLECT_CREATOR_FEE.discriminator)
 	};
-	return await wrapAround(creator, {
+	return await wrapAround$1(creator, {
 		mint: quote.mint,
 		tokenProgram: quote.tokenProgram
 	}, [collect]);
@@ -3086,6 +3405,400 @@ async function fetchCreatorFees(client, input) {
 	}
 }
 //#endregion
+//#region src/raydium/platform.ts
+/**
+* Collecting the platform's share of trading.
+*
+* Gabox charges no fee of its own. The platform's income is the share Raydium pays out of its own
+* revenue, and it sits in two different places depending on where a coin trades:
+*
+*   - **On the curve.** LaunchLab pays 0.5% of every trade into `[platform_config, quote_mint]`
+*     under LaunchLab. One vault per quote asset for the whole platform, not one per coin, so a
+*     single `claim_platform_fee_from_vault` sweeps every coin on that quote. Only the wallet the
+*     platform config names as `platform_fee_wallet` can sign it.
+*   - **After graduation.** LaunchLab moves the whole pool into a CPMM pool and locks 100% of the
+*     LP under Raydium's lock program. The lock mints one fee NFT to the platform NFT wallet. The
+*     LP earns the pool's trade fee, and `collect_cp_fees` on the lock program pays the NFT holder
+*     that growth. One position per graduated coin, so it takes one call per coin.
+*
+* Both flows pay into the signer's associated token account. When a side is WSOL, the builders
+* close that account afterwards, so the wallet ends up with plain SOL. Any other token is created if
+* missing and left alone, because closing it would throw away a real balance.
+*
+* **Closing unwraps everything.** If the wallet already held WSOL in that account, closing turns it
+* into SOL too. Nothing is lost, but the balance moves.
+*/
+const u64$1 = getU64Encoder();
+/**
+* Create the signer's token account for one mint, if it is missing, and close it again when the
+* mint is WSOL. The close is what turns WSOL into SOL, so it only belongs on a WSOL side.
+*/
+async function wrapAround(signer, sides, middle) {
+	const before = [];
+	const after = [];
+	for (const side of sides) {
+		const account = await ata(signer.address, side.mint, side.tokenProgram);
+		before.push(getCreateAssociatedTokenIdempotentInstruction({
+			payer: signer,
+			ata: account,
+			owner: signer.address,
+			mint: side.mint,
+			tokenProgram: side.tokenProgram
+		}));
+		if (side.mint === "So11111111111111111111111111111111111111112") after.push(getCloseAccountInstruction({
+			account,
+			destination: signer.address,
+			owner: signer
+		}));
+	}
+	return [
+		...before,
+		...middle,
+		...after
+	];
+}
+/** 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 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 platform fee claim, for one quote asset: create the quote account, claim,
+* and close it again when the quote is WSOL.
+*
+* This sweeps **every** coin launched against that quote, because LaunchLab keeps one platform
+* vault per quote asset. `feeWallet` must be the wallet the platform config names, or LaunchLab
+* refuses the claim.
+*/
+async function getClaimPlatformFeeInstructions(feeWallet, ids, quote) {
+	const claim = {
+		programAddress: ids.launchlab,
+		accounts: withSigner(order(LAUNCHLAB_CLAIM_PLATFORM_FEE_FROM_VAULT, {
+			platform_fee_wallet: feeWallet.address,
+			fee_vault_authority: await platformFeeVaultAuthority(ids.launchlab),
+			platform_config: ids.gaboxPlatform,
+			platform_fee_vault: await platformFeeVaultAddress(ids.launchlab, ids.gaboxPlatform, quote.mint),
+			recipient_token_account: await ata(feeWallet.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
+		}), feeWallet),
+		data: new Uint8Array(LAUNCHLAB_CLAIM_PLATFORM_FEE_FROM_VAULT.discriminator)
+	};
+	return await wrapAround(feeWallet, [quote], [claim]);
+}
+/**
+* Claim the curve platform fee for one quote asset.
+*
+* A WSOL claim arrives as SOL, because the builder closes the WSOL account. Any other quote arrives
+* as that token, in the fee wallet's own account.
+*/
+async function claimPlatformFee(client, input) {
+	const ids = raydiumIds(client.cluster);
+	const quote = await quoteOf(client, input.quoteMint ?? "So11111111111111111111111111111111111111112");
+	const instructions = await getClaimPlatformFeeInstructions(input.feeWallet, ids, quote);
+	return await buildMessage(client, input.feeWallet, instructions, {
+		addressLookupTables: input.addressLookupTables,
+		computeUnitLimit: input.computeUnitLimit ?? 55e3,
+		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+	});
+}
+/**
+* What the platform can claim from the curve right now, for one quote asset, in base units.
+*
+* `quoteMint` defaults to wrapped SOL. One vault per quote asset, so a platform with coins on two
+* quotes reads this twice. A vault that does not exist yet reads as zero.
+*/
+async function fetchPlatformFees(client, input = {}) {
+	const ids = raydiumIds(client.cluster);
+	const quoteMint = input.quoteMint ?? "So11111111111111111111111111111111111111112";
+	const vault = await platformFeeVaultAddress(ids.launchlab, ids.gaboxPlatform, quoteMint);
+	const [account] = await readAccounts(client.rpc, [vault]);
+	return {
+		quoteMint,
+		curveQuote: account ? tokenAccountAmount(account.data) : 0n
+	};
+}
+/**
+* `collect_cp_fees` on the lock program. There is no public IDL for it. The account list and the
+* discriminator come from Raydium's own SDK and from the `pinocchio-raydium-locking-program`
+* client crate, and the devnet harvest in `test/devnet.e2e.test.ts` runs it.
+*/
+const LOCK_COLLECT_CP_FEES = {
+	name: "collect_cp_fees",
+	discriminator: new Uint8Array([
+		8,
+		30,
+		51,
+		199,
+		209,
+		184,
+		247,
+		133
+	]),
+	accounts: [
+		{
+			name: "authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "fee_nft_owner",
+			writable: false,
+			signer: true
+		},
+		{
+			name: "fee_nft_account",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "locked_liquidity",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "cpmm_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "cp_authority",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "pool_state",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "lp_mint",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "recipient_token_0_account",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "recipient_token_1_account",
+			writable: true,
+			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: "locked_lp_vault",
+			writable: true,
+			signer: false
+		},
+		{
+			name: "token_program",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "token_program_2022",
+			writable: false,
+			signer: false
+		},
+		{
+			name: "memo_program",
+			writable: false,
+			signer: false
+		}
+	]
+};
+/** Integer square root, rounded down. */
+function isqrt(value) {
+	if (value < 0n) throw new Error("isqrt of a negative number");
+	if (value < 2n) return value;
+	let x = BigInt(Math.floor(Math.sqrt(Number(value))));
+	for (;;) {
+		const y = x + value / x >> 1n;
+		if (y >= x) break;
+		x = y;
+	}
+	while (x * x > value) x -= 1n;
+	while ((x + 1n) * (x + 1n) <= value) x += 1n;
+	return x;
+}
+/**
+* The LP tokens a locked position may withdraw as fees.
+*
+* Every swap leaves its fee in the vaults, so one LP token buys a little more of the pool after
+* each trade than before it. The record keeps the pool's `x * y` and LP supply from its last
+* checkpoint. The LP tokens that still hold exactly the checkpoint's liquidity are
+* `locked * sqrt(last_k) / last_lp * supply / sqrt(k)`; everything above that is fee growth.
+*
+* The division rounds the kept part up, so the answer never claims a unit the pool does not owe.
+*/
+function lockedFeeLp(lock, pool) {
+	if (lock.lockedLpAmount === 0n || lock.lastLp === 0n || pool.lpSupply === 0n) return 0n;
+	const rootNow = isqrt(pool.vault0 * pool.vault1);
+	if (rootNow === 0n) return 0n;
+	const numerator = lock.lockedLpAmount * isqrt(lock.lastK) * pool.lpSupply;
+	const denominator = lock.lastLp * rootNow;
+	const keep = (numerator + denominator - 1n) / denominator;
+	return keep >= lock.lockedLpAmount ? 0n : lock.lockedLpAmount - keep;
+}
+/**
+* Every locked CPMM position `owner` holds a fee NFT for, with what each one can harvest.
+*
+* Three reads: the wallet's token accounts, then the lock record behind every NFT-shaped one, then
+* the pool and the two vaults of every record found. A token account of one unit and zero decimals
+* is not always a lock NFT, so the record decides: no record, not a position.
+*/
+async function fetchLockedPositions(client, owner, ids = raydiumIds(client.cluster)) {
+	const { value: accounts } = await client.rpc.getTokenAccountsByOwner(owner, { programId: TOKEN_PROGRAM_ADDRESS }, {
+		encoding: "jsonParsed",
+		commitment: "confirmed"
+	}).send();
+	const nftMints = [];
+	for (const { account } of accounts) {
+		const info = account.data.parsed.info;
+		if (info.tokenAmount.decimals === 0 && info.tokenAmount.amount === "1") nftMints.push(info.mint);
+	}
+	if (nftMints.length === 0) return [];
+	const records = await Promise.all(nftMints.map((mint) => lockedLiquidityAddress(ids.lock, mint)));
+	const found = [];
+	for (const [index, account] of (await readAccounts(client.rpc, records)).entries()) {
+		if (!account || account.owner !== ids.lock) continue;
+		const lock = decodeLockedCpLiquidity(account.data);
+		if (lock.feeNftMint !== nftMints[index]) continue;
+		found.push({
+			feeNftMint: nftMints[index],
+			record: records[index],
+			lock
+		});
+	}
+	if (found.length === 0) return [];
+	const decoded = (await readAccounts(client.rpc, found.map((entry) => entry.lock.poolId))).map((account) => account && account.owner === ids.cpmm ? decodeCpmmPool(account.data) : null);
+	const vaults = await readAccounts(client.rpc, decoded.flatMap((pool) => pool ? [pool.token0Vault, pool.token1Vault] : []));
+	const positions = [];
+	let cursor = 0;
+	for (const [index, entry] of found.entries()) {
+		const pool = decoded[index];
+		if (!pool) continue;
+		const raw0 = vaults[cursor];
+		const raw1 = vaults[cursor + 1];
+		cursor += 2;
+		if (!raw0 || !raw1 || pool.lpMint !== entry.lock.lockedLpMint) continue;
+		const vault0 = tokenAccountAmount(raw0.data) - pool.protocolFeesToken0 - pool.fundFeesToken0 - pool.creatorFeesToken0;
+		const vault1 = tokenAccountAmount(raw1.data) - pool.protocolFeesToken1 - pool.fundFeesToken1 - pool.creatorFeesToken1;
+		const claimableLp = lockedFeeLp(entry.lock, {
+			vault0,
+			vault1,
+			lpSupply: pool.lpSupply
+		});
+		positions.push({
+			...entry,
+			poolAddress: entry.lock.poolId,
+			pool,
+			vault0,
+			vault1,
+			claimableLp,
+			claimableToken0: pool.lpSupply === 0n ? 0n : claimableLp * vault0 / pool.lpSupply,
+			claimableToken1: pool.lpSupply === 0n ? 0n : claimableLp * vault1 / pool.lpSupply
+		});
+	}
+	return positions;
+}
+/**
+* The instructions of one harvest: create the two token accounts, collect, and close the WSOL one
+* when a side is WSOL.
+*
+* `feeLp` defaults to everything the position can withdraw now. The lock program refuses more than
+* that, so a caller that passes its own number keeps it at or below `position.claimableLp`.
+*/
+async function getHarvestLockedFeesInstructions(owner, ids, position, feeLp = position.claimableLp) {
+	if (feeLp <= 0n) throw new Error("nothing to harvest: the position has earned no fee LP yet");
+	const { pool } = position;
+	const collect = {
+		programAddress: ids.lock,
+		accounts: withSigner(order(LOCK_COLLECT_CP_FEES, {
+			authority: ids.lockAuthority,
+			fee_nft_owner: owner.address,
+			fee_nft_account: await ata(owner.address, position.feeNftMint, TOKEN_PROGRAM_ADDRESS),
+			locked_liquidity: position.record,
+			cpmm_program: ids.cpmm,
+			cp_authority: ids.cpmmAuthority,
+			pool_state: position.poolAddress,
+			lp_mint: pool.lpMint,
+			recipient_token_0_account: await ata(owner.address, pool.token0Mint, pool.token0Program),
+			recipient_token_1_account: await ata(owner.address, pool.token1Mint, pool.token1Program),
+			token_0_vault: pool.token0Vault,
+			token_1_vault: pool.token1Vault,
+			vault_0_mint: pool.token0Mint,
+			vault_1_mint: pool.token1Mint,
+			locked_lp_vault: await ata(ids.lockAuthority, pool.lpMint, TOKEN_PROGRAM_ADDRESS),
+			token_program: TOKEN_PROGRAM_ADDRESS,
+			token_program_2022: TOKEN_2022_PROGRAM_ADDRESS,
+			memo_program: MEMO_PROGRAM_ADDRESS
+		}), owner),
+		data: new Uint8Array([...LOCK_COLLECT_CP_FEES.discriminator, ...u64$1.encode(feeLp)])
+	};
+	return await wrapAround(owner, [{
+		mint: pool.token0Mint,
+		tokenProgram: pool.token0Program
+	}, {
+		mint: pool.token1Mint,
+		tokenProgram: pool.token1Program
+	}], [collect]);
+}
+/**
+* Harvest one locked position's fees.
+*
+* A pool with WSOL on one side pays that side out as SOL, because the builder closes the WSOL
+* account. The other side arrives as that token, in the owner's own account.
+*/
+async function harvestLockedFees(client, input) {
+	const ids = raydiumIds(client.cluster);
+	const instructions = await getHarvestLockedFeesInstructions(input.owner, ids, input.position, input.feeLp);
+	return await buildMessage(client, input.owner, instructions, {
+		addressLookupTables: input.addressLookupTables,
+		computeUnitLimit: input.computeUnitLimit ?? 15e4,
+		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+	});
+}
+//#endregion
 //#region src/raydium/trade.ts
 /**
 * A venue trade a wallet sends on its own, outside any Gabox instruction.
@@ -3176,6 +3889,7 @@ var raydium_exports = /* @__PURE__ */ __exportAll({
 	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_CLAIM_PLATFORM_FEE_FROM_VAULT: () => LAUNCHLAB_CLAIM_PLATFORM_FEE_FROM_VAULT,
 	LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR: () => LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR,
 	LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE: () => 115,
 	LAUNCHLAB_INITIALIZE: () => LAUNCHLAB_INITIALIZE,
@@ -3191,6 +3905,11 @@ var raydium_exports = /* @__PURE__ */ __exportAll({
 	LAUNCH_DECIMALS: () => 6,
 	LAUNCH_SUPPLY: () => LAUNCH_SUPPLY,
 	LAUNCH_TOTAL_BASE_SELL: () => LAUNCH_TOTAL_BASE_SELL,
+	LOCKED_CP_LIQUIDITY_DISCRIMINATOR: () => LOCKED_CP_LIQUIDITY_DISCRIMINATOR,
+	LOCKED_CP_LIQUIDITY_HEAD_SIZE: () => 192,
+	LOCK_COLLECT_CP_FEES: () => LOCK_COLLECT_CP_FEES,
+	LOCK_SEEDS: () => LOCK_SEEDS,
+	MEMO_PROGRAM_ADDRESS: () => MEMO_PROGRAM_ADDRESS,
 	METADATA_LIMITS: () => METADATA_LIMITS,
 	METADATA_SEED: () => METADATA_SEED,
 	METAPLEX_PROGRAM_ADDRESS: () => METAPLEX_PROGRAM_ADDRESS,
@@ -3210,6 +3929,7 @@ var raydium_exports = /* @__PURE__ */ __exportAll({
 	ceilDiv: () => ceilDiv,
 	ceilDivRate: () => ceilDivRate,
 	claimCreatorFee: () => claimCreatorFee,
+	claimPlatformFee: () => claimPlatformFee,
 	collectCreatorFee: () => collectCreatorFee,
 	compareAddresses: () => compareAddresses,
 	cpmmAuthority: () => cpmmAuthority,
@@ -3233,17 +3953,23 @@ var raydium_exports = /* @__PURE__ */ __exportAll({
 	decodeLaunchlabGlobalConfig: () => decodeLaunchlabGlobalConfig,
 	decodeLaunchlabPlatformConfig: () => decodeLaunchlabPlatformConfig,
 	decodeLaunchlabPool: () => decodeLaunchlabPool,
+	decodeLockedCpLiquidity: () => decodeLockedCpLiquidity,
 	fetchCreatorFees: () => fetchCreatorFees,
 	fetchCurveSettings: () => fetchCurveSettings,
+	fetchLockedPositions: () => fetchLockedPositions,
+	fetchPlatformFees: () => fetchPlatformFees,
 	fetchQuoteAsset: () => fetchQuoteAsset,
 	fetchQuoteBinding: () => fetchQuoteBinding,
 	fetchQuoteConfig: () => fetchQuoteConfig,
 	fetchQuoteDisplay: () => fetchQuoteDisplay,
 	findCpmmPool: () => findCpmmPool,
 	getClaimCreatorFeeInstructions: () => getClaimCreatorFeeInstructions,
+	getClaimPlatformFeeInstructions: () => getClaimPlatformFeeInstructions,
 	getCollectCreatorFeeInstructions: () => getCollectCreatorFeeInstructions,
 	getCurveBuyExactInInstruction: () => getCurveBuyExactInInstruction,
+	getHarvestLockedFeesInstructions: () => getHarvestLockedFeesInstructions,
 	getLaunchInstruction: () => getLaunchInstruction,
+	harvestLockedFees: () => harvestLockedFees,
 	initialCurve: () => initialCurve,
 	isQuoteSupported: () => isQuoteSupported,
 	launchlabAuthority: () => launchlabAuthority,
@@ -3255,6 +3981,9 @@ var raydium_exports = /* @__PURE__ */ __exportAll({
 	launchlabPoolAddress: () => launchlabPoolAddress,
 	launchlabSellAccounts: () => launchlabSellAccounts,
 	launchlabVaultAddress: () => launchlabVaultAddress,
+	lockAuthority: () => lockAuthority,
+	lockedFeeLp: () => lockedFeeLp,
+	lockedLiquidityAddress: () => lockedLiquidityAddress,
 	metadataAddress: () => metadataAddress,
 	metaplexSymbol: () => metaplexSymbol,
 	mintDecimals: () => mintDecimals,
@@ -3262,6 +3991,7 @@ var raydium_exports = /* @__PURE__ */ __exportAll({
 	newCurveReserves: () => newCurveReserves,
 	order: () => order,
 	platformFeeVaultAddress: () => platformFeeVaultAddress,
+	platformFeeVaultAuthority: () => platformFeeVaultAuthority,
 	preFeeAmount: () => preFeeAmount,
 	quoteAccountFor: () => quoteAccountFor,
 	raydiumIds: () => raydiumIds,
@@ -3277,6 +4007,6 @@ var raydium_exports = /* @__PURE__ */ __exportAll({
 	wsolAccountFor: () => wsolAccountFor
 });
 //#endregion
-export { computeBudgetInstructions as $, LAUNCHLAB_BUY_EXACT_OUT as $n, launchlabVaultAddress as $t, initialCurve as A, CPMM_SEEDS as An, metaplexSymbol as At, fetchQuoteAsset as B, RATE_DENOMINATOR as Bn, vaultAddress as Bt, ceilDiv as C, PACK_TOKENS as Cn, LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE as Ct, curveBuyExactIn as D, VRF_DEFAULT_QUEUE as Dn, decodeLaunchlabGlobalConfig as Dt, cpmmSwapBaseOutput as E, TIMEOUT_SLOTS as En, decodeCpmmPool as Et, cpmmSellAccounts as F, LAUNCHLAB_STATUS_TRADE as Fn, activityAddress as Ft, readAccounts as G, sortedMints as Gn, cpmmPoolAddress as Gt, fetchQuoteDisplay as H, SHARE_FEE_RATE as Hn, ata as Ht, launchlabBuyAccounts as I, LAUNCH_DECIMALS as In, associatedTokenAddress as It, COMPUTE_BUDGET_PROGRAM_ADDRESS as J, CPMM_COLLECT_CREATOR_FEE as Jn, launchlabAuthority as Jt, BUY_PACK_COMPUTE_UNITS as K, ASSOCIATED_TOKEN_PROGRAM_ADDRESS as Kn, creatorFeeVaultAddress as Kt, launchlabBuyExactInAccounts as L, METADATA_LIMITS as Ln, drawAddress as Lt, remainingBase as M, LAUNCHLAB_SEEDS as Mn, token2022Symbol as Mt, totalCurveFeeRate as N, LAUNCHLAB_STATUS_FUND as Nn, tokenAccountAmount as Nt, curveBuyExactOut as O, VRF_PROGRAM_ADDRESS as On, decodeLaunchlabPlatformConfig as Ot, cpmmBuyAccounts as P, LAUNCHLAB_STATUS_MIGRATE as Pn, tokenAccountOwnerAndMint as Pt, REDEEM_COMPUTE_UNITS as Q, LAUNCHLAB_BUY_EXACT_IN as Qn, launchlabPoolAddress as Qt, launchlabSellAccounts as R, METADATA_SEED as Rn, poolAddress as Rt, wsolAccountFor as S, MAX_ATTEMPTS as Sn, LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE as St, cpmmSwapBaseInput as T, SLOT_HASHES_SYSVAR as Tn, decodeCpmmAmmConfig as Tt, isQuoteSupported as U, compareAddresses as Un, cpmmAuthority as Ut, fetchQuoteConfig as V, RAYDIUM_IDS as Vn, vrfIdentityAddress as Vt, decodeBase64 as W, raydiumIds as Wn, cpmmCreatorFeeShare as Wt, DEFAULT_COMPUTE_UNIT_LIMIT as X, CPMM_SWAP_BASE_INPUT as Xn, launchlabGlobalConfig as Xt, CREATE_MACHINE_COMPUTE_UNITS as Y, CPMM_POOL_STATE_DISCRIMINATOR as Yn, launchlabEventAuthority as Yt, MAX_COMPUTE_UNIT_LIMIT as Z, CPMM_SWAP_BASE_OUTPUT as Zn, launchlabPlatformConfig as Zt, newCurveBuyCost as _, validatePack as _n, tiersOf as _t, fetchCreatorFees as a, MAX_MULTIPLIER_BPS as an, LAUNCHLAB_SELL_EXACT_IN as ar, POOL_MINT_OFFSET as at, resolveVenue as b, IDENTITY_SEED as bn, CPMM_POOL_STATE_HEAD_SIZE as bt, getLaunchInstruction as c, TIERS as cn, METAPLEX_PROGRAM_ADDRESS as cr, fetchPoolByMint as ct, cpmmPoolMatches as d, maxMultiplierBps as dn, RAYDIUM_MAINNET_IDS as dr, fetchWalletActivity as dt, metadataAddress as en, LAUNCHLAB_CLAIM_CREATOR_FEE as er, getSetComputeUnitLimitInstruction as et, creatorFeeOnInput as f, quote as fn, RENT_SYSVAR_ADDRESS as fr, listDraws as ft, findCpmmPool as g, uncappedMaximum as gn, WSOL_MINT as gr, quotePool as gt, fetchQuoteBinding as h, tierAmount as hn, TOKEN_PROGRAM_ADDRESS as hr, listPools as ht, collectCreatorFee as i, GaboxMathError as in, LAUNCHLAB_POOL_STATE_DISCRIMINATOR as ir, POOL_CREATOR_OFFSET as it, preFeeAmount as j, CREATOR_FEE_ON_QUOTE as jn, mintDecimals as jt, curveSellExactIn as k, CONSTANT_CURVE_TAG as kn, decodeLaunchlabPool as kt, buildMessage as l, averageMultiplierBps as ln, PLATFORM_ADMIN as lr, fetchPoolInventory as lt, fetchCurveSettings as m, seedTokens as mn, TOKEN_2022_PROGRAM_ADDRESS as mr, listDrawsByPurchaser as mt, getCurveBuyExactInInstruction as n, BPS as nn, LAUNCHLAB_INITIALIZE as nr, DRAW_POOL_OFFSET as nt, getClaimCreatorFeeInstructions as o, MIN_SEED_MULTIPLIER_BPS as on, LAUNCH_SUPPLY as or, fetchDraw as ot, curveQuote as p, resolveReservation as pn, SYSTEM_PROGRAM_ADDRESS as pr, listDrawsByPool as pt, CLAIM_COMPUTE_UNITS as q, CPMM_AMM_CONFIG_DISCRIMINATOR as qn, creatorFeeVaultAuthority as qt, claimCreatorFee as r, DEFAULT_TIERS as rn, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR as rr, DRAW_PURCHASER_OFFSET as rt, getCollectCreatorFeeInstructions as s, TICKETS as sn, LAUNCH_TOTAL_BASE_SELL as sr, fetchPoolAt as st, raydium_exports as t, platformFeeVaultAddress as tn, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR as tr, getSetComputeUnitPriceInstruction as tt, withRemainingAccounts as u, choose as un, RAYDIUM_DEVNET_IDS as ur, fetchVaultBalance as ut, newCurveReserves as v, validateTiers as vn, CPMM_AMM_CONFIG_HEAD_SIZE as vt, ceilDivRate as w, RETRY_SLOTS as wn, LAUNCHLAB_POOL_STATE_HEAD_SIZE as wt, sellQuote as x, INSTRUCTIONS_SYSVAR as xn, CPMM_POOL_STATE_SIZE as xt, quoteAccountFor as y, GABOX_PROGRAM_ID as yn, CPMM_POOL_OFFSETS as yt, order as z, MIGRATE_TO_CPMM as zn, scopedVrfIdentityAddress as zt };
+export { readAccounts as $, uncappedMaximum as $n, poolAddress as $t, wsolAccountFor as A, VRF_PROGRAM_ADDRESS as An, LAUNCHLAB_CLAIM_PLATFORM_FEE_FROM_VAULT as Ar, CPMM_AMM_CONFIG_HEAD_SIZE as At, remainingBase as B, checkedCount as Bn, RAYDIUM_DEVNET_IDS as Br, decodeCpmmPool as Bt, fetchQuoteBinding as C, INSTRUCTIONS_SYSVAR as Cn, CPMM_COLLECT_CREATOR_FEE as Cr, fetchWalletActivity as Ct, quoteAccountFor as D, SLOT_HASHES_SYSVAR as Dn, LAUNCHLAB_BUY_EXACT_IN as Dr, listPools as Dt, newCurveReserves as E, RETRY_SLOTS as En, CPMM_SWAP_BASE_OUTPUT as Er, listDrawsByPurchaser as Et, curveBuyExactIn as F, MAX_MULTIPLIER_BPS as Fn, LAUNCHLAB_SELL_EXACT_IN as Fr, LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE as Ft, launchlabBuyExactInAccounts as G, perPackCaps as Gn, TOKEN_PROGRAM_ADDRESS as Gr, metaplexSymbol as Gt, cpmmBuyAccounts as H, chooseIndex as Hn, RENT_SYSVAR_ADDRESS as Hr, decodeLaunchlabPlatformConfig as Ht, curveBuyExactOut as I, MIN_SEED_MULTIPLIER_BPS as In, LAUNCH_SUPPLY as Ir, LAUNCHLAB_POOL_STATE_HEAD_SIZE as It, fetchQuoteAsset as J, resolveReservation as Jn, tokenAccountAmount as Jt, launchlabSellAccounts as K, quote as Kn, WSOL_MINT as Kr, mintDecimals as Kt, curveSellExactIn as L, TICKETS as Ln, LAUNCH_TOTAL_BASE_SELL as Lr, LOCKED_CP_LIQUIDITY_DISCRIMINATOR as Lt, ceilDivRate as M, DEFAULT_TIERS as Mn, LAUNCHLAB_INITIALIZE as Mr, CPMM_POOL_STATE_HEAD_SIZE as Mt, cpmmSwapBaseInput as N, GaboxMathError as Nn, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR as Nr, CPMM_POOL_STATE_SIZE as Nt, resolveVenue as O, TIMEOUT_SLOTS as On, LAUNCHLAB_BUY_EXACT_OUT as Or, quotePool as Ot, cpmmSwapBaseOutput as P, MAX_BATCH_SIZE as Pn, LAUNCHLAB_POOL_STATE_DISCRIMINATOR as Pr, LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE as Pt, decodeBase64 as Q, uncappedAmounts as Qn, drawAddress as Qt, initialCurve as R, TIERS as Rn, METAPLEX_PROGRAM_ADDRESS as Rr, LOCKED_CP_LIQUIDITY_HEAD_SIZE as Rt, fetchCurveSettings as S, IDENTITY_SEED as Sn, CPMM_AMM_CONFIG_DISCRIMINATOR as Sr, fetchVaultBalance as St, newCurveBuyCost as T, PACK_TOKENS as Tn, CPMM_SWAP_BASE_INPUT as Tr, listDrawsByPool as Tt, cpmmSellAccounts as U, maxMultiplierBps as Un, SYSTEM_PROGRAM_ADDRESS as Ur, decodeLaunchlabPool as Ut, totalCurveFeeRate as V, choose as Vn, RAYDIUM_MAINNET_IDS as Vr, decodeLaunchlabGlobalConfig as Vt, launchlabBuyAccounts as W, minTier as Wn, TOKEN_2022_PROGRAM_ADDRESS as Wr, decodeLockedCpLiquidity as Wt, fetchQuoteDisplay as X, settleWith as Xn, activityAddress as Xt, fetchQuoteConfig as Y, seedTokens as Yn, tokenAccountOwnerAndMint as Yt, isQuoteSupported as Z, tierAmount as Zn, associatedTokenAddress as Zt, buildMessage as _, lockedLiquidityAddress as _n, SHARE_FEE_RATE as _r, fetchDraw as _t, fetchLockedPositions as a, cpmmAuthority as an, LAUNCHLAB_SEEDS as ar, DEFAULT_COMPUTE_UNIT_LIMIT as at, creatorFeeOnInput as b, platformFeeVaultAuthority as bn, sortedMints as br, fetchPoolByMint as bt, getHarvestLockedFeesInstructions as c, creatorFeeVaultAddress as cn, LAUNCHLAB_STATUS_TRADE as cr, REDEEM_COMPUTE_UNITS as ct, claimCreatorFee as d, launchlabEventAuthority as dn, MEMO_PROGRAM_ADDRESS as dr, getSetComputeUnitPriceInstruction as dt, randomNonce as en, validatePack as er, BUY_PACK_COMPUTE_UNITS as et, collectCreatorFee as f, launchlabGlobalConfig as fn, METADATA_LIMITS as fr, DRAW_POOL_OFFSET as ft, getLaunchInstruction as g, lockAuthority as gn, RAYDIUM_IDS as gr, POOL_MINT_OFFSET as gt, getCollectCreatorFeeInstructions as h, launchlabVaultAddress as hn, RATE_DENOMINATOR as hr, POOL_CREATOR_OFFSET as ht, claimPlatformFee as i, ata as in, CREATOR_FEE_ON_QUOTE as ir, CREATE_MACHINE_COMPUTE_UNITS as it, ceilDiv as j, BPS as jn, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR as jr, CPMM_POOL_OFFSETS as jt, sellQuote as k, VRF_DEFAULT_QUEUE as kn, LAUNCHLAB_CLAIM_CREATOR_FEE as kr, tiersOf as kt, harvestLockedFees as l, creatorFeeVaultAuthority as ln, LAUNCH_DECIMALS as lr, computeBudgetInstructions as lt, getClaimCreatorFeeInstructions as m, launchlabPoolAddress as mn, MIGRATE_TO_CPMM as mr, DRAW_SETTLED_OFFSET as mt, getCurveBuyExactInInstruction as n, vaultAddress as nn, CONSTANT_CURVE_TAG as nr, CLAIM_PRIZE_COMPUTE_UNITS as nt, fetchPlatformFees as o, cpmmCreatorFeeShare as on, LAUNCHLAB_STATUS_FUND as or, HARVEST_COMPUTE_UNITS as ot, fetchCreatorFees as p, launchlabPlatformConfig as pn, METADATA_SEED as pr, DRAW_PURCHASER_OFFSET as pt, order as q, reserveFor as qn, token2022Symbol as qt, LOCK_COLLECT_CP_FEES as r, vrfIdentityAddress as rn, CPMM_SEEDS as rr, COMPUTE_BUDGET_PROGRAM_ADDRESS as rt, getClaimPlatformFeeInstructions as s, cpmmPoolAddress as sn, LAUNCHLAB_STATUS_MIGRATE as sr, MAX_COMPUTE_UNIT_LIMIT as st, raydium_exports as t, scopedVrfIdentityAddress as tn, validateTiers as tr, CLAIM_COMPUTE_UNITS as tt, lockedFeeLp as u, launchlabAuthority as un, LOCK_SEEDS as ur, getSetComputeUnitLimitInstruction as ut, withRemainingAccounts as v, metadataAddress as vn, compareAddresses as vr, fetchOwedDraws as vt, findCpmmPool as w, MAX_ATTEMPTS as wn, CPMM_POOL_STATE_DISCRIMINATOR as wr, listDraws as wt, curveQuote as x, GABOX_PROGRAM_ID as xn, ASSOCIATED_TOKEN_PROGRAM_ADDRESS as xr, fetchPoolInventory as xt, cpmmPoolMatches as y, platformFeeVaultAddress as yn, raydiumIds as yr, fetchPoolAt as yt, preFeeAmount as z, averageMultiplierBps as zn, PLATFORM_ADMIN as zr, decodeCpmmAmmConfig as zt };
 
-//# sourceMappingURL=raydium-CU-tZzIk.js.map
+//# sourceMappingURL=raydium-DXUJ-g1p.js.map