@gabox-labs/sdk 0.7.1 → 0.8.0

package/dist/{raydium-CU-tZzIk.js → raydium-DIF1WOvI.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 { 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";
 /**
@@ -1337,6 +1428,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 +1475,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),
@@ -1440,7 +1543,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 +1566,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 +1646,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 +1707,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 +1739,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 +1759,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 +1780,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 +1819,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 +1844,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,6 +1866,36 @@ 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. */
@@ -1936,6 +2072,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 +3039,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 +3060,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 +3075,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 +3098,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 +3110,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 +3141,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 +3160,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 +3231,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 +3715,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 +3731,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 +3755,7 @@ var raydium_exports = /* @__PURE__ */ __exportAll({
 	ceilDiv: () => ceilDiv,
 	ceilDivRate: () => ceilDivRate,
 	claimCreatorFee: () => claimCreatorFee,
+	claimPlatformFee: () => claimPlatformFee,
 	collectCreatorFee: () => collectCreatorFee,
 	compareAddresses: () => compareAddresses,
 	cpmmAuthority: () => cpmmAuthority,
@@ -3233,17 +3779,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 +3807,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 +3817,7 @@ var raydium_exports = /* @__PURE__ */ __exportAll({
 	newCurveReserves: () => newCurveReserves,
 	order: () => order,
 	platformFeeVaultAddress: () => platformFeeVaultAddress,
+	platformFeeVaultAuthority: () => platformFeeVaultAuthority,
 	preFeeAmount: () => preFeeAmount,
 	quoteAccountFor: () => quoteAccountFor,
 	raydiumIds: () => raydiumIds,
@@ -3277,6 +3833,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 $, MEMO_PROGRAM_ADDRESS as $n, vrfIdentityAddress as $t, wsolAccountFor as A, tierAmount as An, RENT_SYSVAR_ADDRESS as Ar, CPMM_POOL_STATE_SIZE as At, remainingBase as B, SLOT_HASHES_SYSVAR as Bn, decodeLaunchlabPool as Bt, fetchQuoteBinding as C, TIERS as Cn, LAUNCHLAB_SELL_EXACT_IN as Cr, listDrawsByPurchaser as Ct, quoteAccountFor as D, quote as Dn, PLATFORM_ADMIN as Dr, CPMM_AMM_CONFIG_HEAD_SIZE as Dt, newCurveReserves as E, maxMultiplierBps as En, METAPLEX_PROGRAM_ADDRESS as Er, tiersOf as Et, curveBuyExactIn as F, IDENTITY_SEED as Fn, LOCKED_CP_LIQUIDITY_HEAD_SIZE as Ft, launchlabBuyExactInAccounts as G, CPMM_SEEDS as Gn, tokenAccountAmount as Gt, cpmmBuyAccounts as H, VRF_DEFAULT_QUEUE as Hn, metaplexSymbol as Ht, curveBuyExactOut as I, INSTRUCTIONS_SYSVAR as In, decodeCpmmAmmConfig as It, fetchQuoteAsset as J, LAUNCHLAB_STATUS_FUND as Jn, associatedTokenAddress as Jt, launchlabSellAccounts as K, CREATOR_FEE_ON_QUOTE as Kn, tokenAccountOwnerAndMint as Kt, curveSellExactIn as L, MAX_ATTEMPTS as Ln, decodeCpmmPool as Lt, ceilDivRate as M, validatePack as Mn, TOKEN_2022_PROGRAM_ADDRESS as Mr, LAUNCHLAB_PLATFORM_CONFIG_HEAD_SIZE as Mt, cpmmSwapBaseInput as N, validateTiers as Nn, TOKEN_PROGRAM_ADDRESS as Nr, LAUNCHLAB_POOL_STATE_HEAD_SIZE as Nt, resolveVenue as O, resolveReservation as On, RAYDIUM_DEVNET_IDS as Or, CPMM_POOL_OFFSETS as Ot, cpmmSwapBaseOutput as P, GABOX_PROGRAM_ID as Pn, WSOL_MINT as Pr, LOCKED_CP_LIQUIDITY_DISCRIMINATOR as Pt, decodeBase64 as Q, LOCK_SEEDS as Qn, vaultAddress as Qt, initialCurve as R, PACK_TOKENS as Rn, decodeLaunchlabGlobalConfig as Rt, fetchCurveSettings as S, TICKETS as Sn, LAUNCHLAB_POOL_STATE_DISCRIMINATOR as Sr, listDrawsByPool as St, newCurveBuyCost as T, choose as Tn, LAUNCH_TOTAL_BASE_SELL as Tr, quotePool as Tt, cpmmSellAccounts as U, VRF_PROGRAM_ADDRESS as Un, mintDecimals as Ut, totalCurveFeeRate as V, TIMEOUT_SLOTS as Vn, decodeLockedCpLiquidity as Vt, launchlabBuyAccounts as W, CONSTANT_CURVE_TAG as Wn, token2022Symbol as Wt, fetchQuoteDisplay as X, LAUNCHLAB_STATUS_TRADE as Xn, poolAddress as Xt, fetchQuoteConfig as Y, LAUNCHLAB_STATUS_MIGRATE as Yn, drawAddress as Yt, isQuoteSupported as Z, LAUNCH_DECIMALS as Zn, scopedVrfIdentityAddress as Zt, buildMessage as _, BPS as _n, LAUNCHLAB_CLAIM_CREATOR_FEE as _r, fetchPoolByMint as _t, fetchLockedPositions as a, creatorFeeVaultAuthority as an, SHARE_FEE_RATE as ar, HARVEST_COMPUTE_UNITS as at, creatorFeeOnInput as b, MAX_MULTIPLIER_BPS as bn, LAUNCHLAB_INITIALIZE as br, fetchWalletActivity as bt, getHarvestLockedFeesInstructions as c, launchlabGlobalConfig as cn, sortedMints as cr, computeBudgetInstructions as ct, claimCreatorFee as d, launchlabVaultAddress as dn, CPMM_COLLECT_CREATOR_FEE as dr, DRAW_POOL_OFFSET as dt, ata as en, METADATA_LIMITS as er, BUY_PACK_COMPUTE_UNITS as et, collectCreatorFee as f, lockAuthority as fn, CPMM_POOL_STATE_DISCRIMINATOR as fr, DRAW_PURCHASER_OFFSET as ft, getLaunchInstruction as g, platformFeeVaultAuthority as gn, LAUNCHLAB_BUY_EXACT_OUT as gr, fetchPoolAt as gt, getCollectCreatorFeeInstructions as h, platformFeeVaultAddress as hn, LAUNCHLAB_BUY_EXACT_IN as hr, fetchDraw as ht, claimPlatformFee as i, creatorFeeVaultAddress as in, RAYDIUM_IDS as ir, DEFAULT_COMPUTE_UNIT_LIMIT as it, ceilDiv as j, uncappedMaximum as jn, SYSTEM_PROGRAM_ADDRESS as jr, LAUNCHLAB_GLOBAL_CONFIG_HEAD_SIZE as jt, sellQuote as k, seedTokens as kn, RAYDIUM_MAINNET_IDS as kr, CPMM_POOL_STATE_HEAD_SIZE as kt, harvestLockedFees as l, launchlabPlatformConfig as ln, ASSOCIATED_TOKEN_PROGRAM_ADDRESS as lr, getSetComputeUnitLimitInstruction as lt, getClaimCreatorFeeInstructions as m, metadataAddress as mn, CPMM_SWAP_BASE_OUTPUT as mr, POOL_MINT_OFFSET as mt, getCurveBuyExactInInstruction as n, cpmmCreatorFeeShare as nn, MIGRATE_TO_CPMM as nr, COMPUTE_BUDGET_PROGRAM_ADDRESS as nt, fetchPlatformFees as o, launchlabAuthority as on, compareAddresses as or, MAX_COMPUTE_UNIT_LIMIT as ot, fetchCreatorFees as p, lockedLiquidityAddress as pn, CPMM_SWAP_BASE_INPUT as pr, POOL_CREATOR_OFFSET as pt, order as q, LAUNCHLAB_SEEDS as qn, activityAddress as qt, LOCK_COLLECT_CP_FEES as r, cpmmPoolAddress as rn, RATE_DENOMINATOR as rr, CREATE_MACHINE_COMPUTE_UNITS as rt, getClaimPlatformFeeInstructions as s, launchlabEventAuthority as sn, raydiumIds as sr, REDEEM_COMPUTE_UNITS as st, raydium_exports as t, cpmmAuthority as tn, METADATA_SEED as tr, CLAIM_COMPUTE_UNITS as tt, lockedFeeLp as u, launchlabPoolAddress as un, CPMM_AMM_CONFIG_DISCRIMINATOR as ur, getSetComputeUnitPriceInstruction as ut, withRemainingAccounts as v, DEFAULT_TIERS as vn, LAUNCHLAB_CLAIM_PLATFORM_FEE_FROM_VAULT as vr, fetchPoolInventory as vt, findCpmmPool as w, averageMultiplierBps as wn, LAUNCH_SUPPLY as wr, listPools as wt, curveQuote as x, MIN_SEED_MULTIPLIER_BPS as xn, LAUNCHLAB_PLATFORM_CONFIG_DISCRIMINATOR as xr, listDraws as xt, cpmmPoolMatches as y, GaboxMathError as yn, LAUNCHLAB_GLOBAL_CONFIG_DISCRIMINATOR as yr, fetchVaultBalance as yt, preFeeAmount as z, RETRY_SLOTS as zn, decodeLaunchlabPlatformConfig as zt };
 
-//# sourceMappingURL=raydium-CU-tZzIk.js.map
+//# sourceMappingURL=raydium-DIF1WOvI.js.map