@gabox-labs/sdk 0.2.0 → 0.6.0

package/dist/index.js

@@ -1,27 +1,69 @@
-import { $t as findPoolPda, Dn as decodePool, En as POOL_DISCRIMINATOR, Hn as fetchMaybeDraw, In as getPoolSize, Kt as getBindReferrerInstructionAsync, L as getInitializePoolInstructionAsync, Ln as DRAW_DISCRIMINATOR, Lt as getBuyPackInstruction, O as getRetryDrawInstruction, Qt as findReferralPda, Rn as decodeDraw, St as getClaimReferralInstructionAsync, W as getFundPrizesInstruction, Zt as findReferralLinkPda, an as decodeReferralLink, at as getExpireDrawInstruction, b as getSellPrizeInstruction, cn as fetchMaybeReferralLink, f as getSellTokensInstruction, in as REFERRAL_LINK_DISCRIMINATOR, kt as getClaimPrizeInstruction, mn as getReferralLinkSize, nn as findDrawPda, tn as findIdentityPda, yn as fetchMaybeReferral } from "./gaboxV2-CV2XltqC.js";
-import { $ as MAX_ATTEMPTS, Q as INSTRUCTIONS_SYSVAR, T as PUMP_GLOBAL, U as decodePumpGlobal, X as GABOX_PROGRAM_ID, Z as IDENTITY_SEED, at as RETRY_SLOTS, ct as TOKEN_2022_PROGRAM_ADDRESS, d as pumpBuyAccounts, dt as VRF_PROGRAM_ADDRESS, et as MAX_FEE_BPS, ft as WSOL_MINT, gt as PUMP_CREATE_TOKEN_PROGRAM_ADDRESS, h as swapCashbackAccount, i as getPumpCreateV2Instruction, it as REFERRAL_FEE_BPS, l as tokenAccountAmount, lt as TOKEN_PROGRAM_ADDRESS, mt as MAYHEM_PROGRAM_ADDRESS, n as venueBuyInstruction, nt as PROTOCOL_FEE_BPS, o as newCurveBuyCost, ot as SLOT_HASHES_SYSVAR, pt as ASSOCIATED_TOKEN_PROGRAM_ADDRESS, rt as PROTOCOL_FEE_COLLECTOR, s as resolveVenue, st as TIMEOUT_SLOTS, t as pump_exports, tt as PACK_TOKENS, u as wsolAccountFor, ut as VRF_DEFAULT_QUEUE, vt as PUMP_FEE_PROGRAM_ADDRESS, wt as SYSTEM_PROGRAM_ADDRESS, xt as PUMP_SWAP_PROGRAM_ADDRESS, yt as PUMP_PROGRAM_ADDRESS } from "./pump-D0K_0uiC.js";
-import { DRAW_RESOLVED_EVENT_DISCRIMINATOR, PACK_BOUGHT_EVENT_DISCRIMINATOR, POOL_CREATED_EVENT_DISCRIMINATOR, PRIZES_FUNDED_EVENT_DISCRIMINATOR, PRIZE_REDEEMED_EVENT_DISCRIMINATOR, RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR, TOKENS_SOLD_EVENT_DISCRIMINATOR, getDrawResolvedEventDecoder, getPackBoughtEventDecoder, getPoolCreatedEventDecoder, getPrizeRedeemedEventDecoder, getPrizesFundedEventDecoder, getRandomnessRetriedEventDecoder, getTokensSoldEventDecoder, t as generated_exports } from "./generated/index.js";
-import { address, appendTransactionMessageInstructions, compileTransaction, compressTransactionMessageUsingAddressLookupTables, createSolanaRpc, createSolanaRpcSubscriptions, createTransactionMessage, fetchEncodedAccount, fetchEncodedAccounts, getAddressEncoder, getBase58Decoder, getBase64Encoder, getBytesEncoder, getProgramDerivedAddress, getStructEncoder, getTransactionEncoder, getU32Encoder, getU64Encoder, getU8Encoder, pipe, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash } from "@solana/kit";
-import { TOKEN_PROGRAM_ADDRESS as TOKEN_PROGRAM_ADDRESS$1, getCreateAssociatedTokenIdempotentInstruction, getSyncNativeInstruction } from "@solana-program/token";
+import { B as COMPUTE_BUDGET_PROGRAM_ADDRESS, E as curveBuyExactOut, G as computeBudgetInstructions, H as DEFAULT_COMPUTE_UNIT_LIMIT, K as getSetComputeUnitLimitInstruction, Lt as raydiumIds, P as launchlabBuyAccounts, R as BUY_PACK_COMPUTE_UNITS, U as MAX_COMPUTE_UNIT_LIMIT, V as CREATE_MACHINE_COMPUTE_UNITS, W as REDEEM_COMPUTE_UNITS, _ as newCurveReserves, b as wsolAccountFor, c as getLaunchInstruction, cn as WSOL_MINT, ct as ata, en as LAUNCH_TOTAL_BASE_SELL, ft as creatorFeeVaultAddress, kt as LAUNCH_DECIMALS, l as buildMessage, m as fetchCurveSettings, nn as PLATFORM_ADMIN, on as SYSTEM_PROGRAM_ADDRESS, ot as tokenAccountAmount, q as getSetComputeUnitPriceInstruction, sn as TOKEN_PROGRAM_ADDRESS, t as raydium_exports, tn as METAPLEX_PROGRAM_ADDRESS, u as withRemainingAccounts, v as resolveVenue, vt as launchlabPoolAddress, xt as platformFeeVaultAddress, yt as launchlabVaultAddress, z as CLAIM_COMPUTE_UNITS, zt as ASSOCIATED_TOKEN_PROGRAM_ADDRESS } from "./raydium-B-l9V3O-.js";
+import { DRAW_DISCRIMINATOR, DRAW_RESOLVED_EVENT_DISCRIMINATOR, GABOX_PROGRAM_ADDRESS, PACK_BOUGHT_EVENT_DISCRIMINATOR, POOL_CREATED_EVENT_DISCRIMINATOR, POOL_DISCRIMINATOR, PRIZES_FUNDED_EVENT_DISCRIMINATOR, RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR, TOKENS_SOLD_EVENT_DISCRIMINATOR, WALLET_ACTIVITY_DISCRIMINATOR, decodeDraw, decodePool, decodeWalletActivity, findActivityPda, findDrawPda, findIdentityPda, findPoolPda, getBuyPackInstructionAsync, getDrawResolvedEventDecoder, getDrawSize, getExpireDrawInstruction, getFundPrizesInstruction, getInitializePoolInstructionAsync, getPackBoughtEventDecoder, getPoolCreatedEventDecoder, getPoolSize, getPrizesFundedEventDecoder, getRandomnessRetriedEventDecoder, getRetryDrawInstruction, getSellTokensInstructionAsync, getTokensSoldEventDecoder, getWalletActivitySize, t as generated_exports } from "./generated/index.js";
+import { address, createSolanaRpc, createSolanaRpcSubscriptions, fetchEncodedAccount, getAddressEncoder, getBase58Decoder, getBase64Encoder, getBytesEncoder, getProgramDerivedAddress } from "@solana/kit";
+import { getCloseAccountInstruction, getCreateAssociatedTokenIdempotentInstruction, getSyncNativeInstruction } from "@solana-program/token";
 import { getTransferSolInstruction } from "@solana-program/system";
+//#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-v2/src/math.rs`.
+* A bigint port of `programs/gabox/src/math.rs`.
 *
 * The point is that a client can show a buyer the exact prize table the program will freeze into
 * their `Draw`, before they pay. Every rounding step here matches the Rust, including the direction
-* of each division. `test/math.test.ts` runs the same vectors as `programs/gabox-v2/tests/
-* economics.rs`.
+* of each division. `test/math.test.ts` runs the same vectors as `programs/gabox/tests/math.rs`.
 *
 * All amounts are `bigint`, in the mint's smallest unit. `multiplierBps` and `tickets` are numbers
 * because both are `u32` in the program and both stay small.
 */
 /** Basis points. A multiplier of 10_000 pays back exactly one pack. */
 const BPS = 10000n;
-/** `math::share`. `bps` basis points of `amount`, rounded down. */
-function share(amount, bps) {
-	return amount * bps / BPS;
-}
+/**
+* `constants::MIN_SEED_MULTIPLIER_BPS`. The mandatory seed makes a 3x top prize payable on the
+* first pack, or the full top prize when the table's top tier is below 3x. A creator can add more
+* seed on top through `extraSeedTokens`.
+*/
+const MIN_SEED_MULTIPLIER_BPS = 3e4;
+/**
+* `constants::MAX_MULTIPLIER_BPS`. A table's top tier can be at most 20x. Seed beyond what a 20x
+* prize needs stays in the vault as backup for the draws after a top-tier hit.
+*/
+const MAX_MULTIPLIER_BPS = 2e5;
 /** Ticket counts must sum to this. A uniform 16-bit word then maps with no modulo bias. */
 const TICKETS = 65536;
 /** The prize table has exactly this many slots. Unused slots are all-zero. */
@@ -95,9 +137,10 @@ function tierAmount(base, multiplierBps) {
 /**
 * `math::validate`. Checks the table alone, with no base.
 *
-* Three rules, and each one closes a way to sell a bad ticket:
+* Four rules, and each one closes a way to sell a bad ticket:
 *   - ticket counts sum to exactly 65,536, so the 16-bit draw is uniform;
 *   - an unused row is all-zero, so a hidden multiplier cannot ride along;
+*   - a ticketed tier's multiplier is from 1 to `MAX_MULTIPLIER_BPS` (20x);
 *   - the expected multiplier over all tickets is at most 1x, so the table cannot promise more
 *     tokens than a pack buys. This bounds tokens, not cash value.
 */
@@ -113,6 +156,7 @@ function validateTiers(tiers) {
 			continue;
 		}
 		if (tier.multiplierBps <= 0) throw new GaboxMathError("InvalidDistribution", "a ticketed tier must pay something; it would sell a ticket that can only win zero");
+		if (tier.multiplierBps > 2e5) throw new GaboxMathError("InvalidDistribution", `tier ${index} multiplierBps exceeds the ${MAX_MULTIPLIER_BPS} maximum (20x)`);
 		count += BigInt(tier.tickets);
 		expected += BigInt(tier.multiplierBps) * BigInt(tier.tickets);
 	}
@@ -135,24 +179,30 @@ function validatePack(packTokens, tiers) {
 	}
 }
 /**
-* `math::seed_tokens`. The seed a table needs, in tokens.
+* `math::seed_tokens`. The mandatory seed a table needs, in tokens.
 *
-* The first pack must be able to pay the largest tier in full. The pack itself brings `packTokens`
-* into the vault, so the vault has to hold the rest beforehand:
+* The mandatory seed makes a 3x top prize payable on the first pack, or the full top prize when
+* the table's top tier is below 3x. A jackpot above 3x still shows the full table once later
+* packs grow the free vault; the mandatory seed alone does not have to fund it. The pack itself
+* brings `packTokens` into the vault, so the vault has to hold the rest beforehand:
 *
-*     seedTokens = uncappedMaximum(packTokens, tiers) - packTokens
+*     seedTokens = min(uncappedMaximum(packTokens, tiers), tierAmount(packTokens, MIN_SEED_MULTIPLIER_BPS)) - packTokens
 *
-* A 5x jackpot on a 1M-token pack needs a 4M-token seed. A table whose top tier pays exactly one
-* pack needs no seed. A top tier below one pack is refused: every ticket would lose.
+* A 20x or a 3x top tier on a 1M-token pack both need a 2M-token seed, since the mandatory seed
+* stops at the 3x minimum. A 2x top tier needs a 1M-token seed, already below the minimum. A
+* table whose top tier pays exactly one pack needs no seed. A top tier below one pack is refused:
+* every ticket would lose. `createMachine` lets a creator add more seed on top of this mandatory
+* amount through `extraSeedTokens`, for example to fund a top tier above 3x from the first pack.
 *
-* `initialize_pool` computes this number itself and buys exactly that many tokens on the curve.
+* Pool initialization computes this number itself and buys exactly that many tokens on the curve.
 * The creator only signs a maximum SOL cost.
 */
 function seedTokens(packTokens, tiers) {
 	validateTiers(tiers);
 	const largest = uncappedMaximum(packTokens, tiers);
 	if (largest < packTokens) throw new GaboxMathError("JackpotBelowOnePack", "the largest tier must pay at least one pack");
-	return largest - packTokens;
+	const minimum = tierAmount(packTokens, MIN_SEED_MULTIPLIER_BPS);
+	return (largest < minimum ? largest : minimum) - packTokens;
 }
 /**
 * `math::uncapped_maximum`. The largest tier's award for this base, before any inventory cap.
@@ -256,589 +306,284 @@ function averageMultiplierBps(tiers) {
 //#endregion
 //#region src/pdas.ts
 /**
-* Every program-derived address a client needs.
+* Gabox's own program-derived addresses.
 *
-* The three gabox PDAs come from the generated tree, which Codama built from the IDL's own seed
-* metadata. Re-exported here so callers have one import, and so the seeds stay in exactly one
-* place. The two written by hand are the ones Codama cannot generate: an ATA, and a PDA that lives
-* under a program other than ours.
-*/
-/** `['referral', referee]`. A wallet's permanent referral binding. */
-async function referralLinkAddress(referee) {
-	return (await findReferralLinkPda({ purchaser: referee }))[0];
-}
-/** `['referral', pool, referrer]`. A referrer's accrued rewards for one pool. */
-async function referralAddress(pool, referrer) {
-	return (await findReferralPda({
-		pool,
-		referralLink: referrer
-	}))[0];
-}
-/** `["pool", mint]`. One pool per coin, and the mint alone is the seed. */
-async function poolAddress(mint) {
-	return (await findPoolPda({ mint }))[0];
-}
-/** `["draw", pool, seq_u64_le]`. `seq` is `pool.nextSeq` at the moment of the purchase. */
-async function drawAddress(pool, seq) {
-	return (await findDrawPda({
-		pool,
-		seq
-	}))[0];
-}
-/**
-* `["identity"]` under gabox. This is the PDA gabox signs the VRF request with — the `identity`
-* account of the `Oracle` group on `buy_pack` and `retry_draw`.
-*/
-async function vrfIdentityAddress() {
-	return (await findIdentityPda())[0];
-}
-/**
-* `["identity", gabox_program_id]` under the **VRF program**. A different address from
-* `vrfIdentityAddress`, and it belongs to the other side: MagicBlock signs the `deliver_draw`
-* callback with it. A client never puts it in an instruction. It is here so a client can recognise
-* the signer on a callback transaction.
+* Raydium's live in `src/raydium/pdas.ts`, because they depend on the cluster. These do not: the
+* Gabox program id is the same everywhere.
+*
+* Classic SPL Token only. Both venues use it, and the accepted LaunchLab create instruction mints
+* the coin with it, so no derivation here takes a token program any more.
 */
+/** `["pool", mint]`. One pool per coin. */
+const poolAddress = async (mint) => (await findPoolPda({ mint }))[0];
+/** `["draw", pool, seq]`, with the sequence as eight little-endian bytes. */
+const drawAddress = async (pool, seq) => (await findDrawPda({
+	pool,
+	seq
+}))[0];
+/** The per-wallet `WalletActivity` PDA. `buy_pack` derives it from the purchaser automatically. */
+const activityAddress = async (wallet) => (await findActivityPda({ purchaser: wallet }))[0];
+/** `["identity"]` under Gabox. The PDA the program signs its randomness request with. */
+const vrfIdentityAddress = async () => (await findIdentityPda())[0];
+/** `["identity", gabox_program_id]` under the VRF program. MagicBlock signs the callback with it. */
 async function scopedVrfIdentityAddress() {
 	return await getProgramDerivedAddress({
 		programAddress: VRF_PROGRAM_ADDRESS,
 		seeds: [getBytesEncoder().encode(IDENTITY_SEED), getAddressEncoder().encode(GABOX_PROGRAM_ID)]
 	});
 }
-/**
-* An associated token account. The seed order is `[owner, token_program, mint]`, which is the ATA
-* program's own order and not the argument order most callers remember.
-*/
-async function associatedTokenAddress(owner, mint, tokenProgram = TOKEN_2022_PROGRAM_ADDRESS) {
-	const encoder = getAddressEncoder();
-	const [address] = await getProgramDerivedAddress({
-		programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-		seeds: [
-			encoder.encode(owner),
-			encoder.encode(tokenProgram),
-			encoder.encode(mint)
-		]
-	});
-	return address;
-}
-/**
-* The protocol fee collector's WSOL ATA, under classic SPL Token. A sale on PumpSwap pays its
-* protocol fee here. The account must exist before the first PumpSwap sale; see `DEPLOYMENT.md`.
-*/
-async function feeCollectorWsolAddress() {
-	return await associatedTokenAddress(PROTOCOL_FEE_COLLECTOR, WSOL_MINT, TOKEN_PROGRAM_ADDRESS);
-}
-/**
-* The pool's prize inventory: the pool PDA's ATA for the mint's own token program.
-*
-* `tokenProgram` defaults to Token-2022 because Pump `create_v2` mints there, and every machine is
-* built on a coin Pump created. Pass the mint's real owner if you have it.
-*/
-async function vaultAddress(mint, tokenProgram = TOKEN_2022_PROGRAM_ADDRESS) {
-	return await associatedTokenAddress(await poolAddress(mint), mint, tokenProgram);
-}
+/** An associated token account under classic SPL Token. */
+const associatedTokenAddress = async (owner, mint, tokenProgram = TOKEN_PROGRAM_ADDRESS) => await ata(owner, mint, tokenProgram);
+/** The prize vault: the pool PDA's own associated token account for the coin. */
+const vaultAddress = async (mint) => await associatedTokenAddress(await poolAddress(mint), mint);
 //#endregion
 //#region src/accounts.ts
-/**
-* Reading gabox state: pools, draws, and the vault balance that turns a pool into an offer.
-*
-* The decoders are the generated ones. What this file adds is the queries — the discriminator and
-* `memcmp` filters that let a client list every machine, or every draw a wallet is waiting on,
-* without an indexer.
-*
-* # The offsets are computed, not counted
-*
-* A `memcmp` filter is a byte offset into an account. Counting field widths by hand is how a filter
-* silently matches nothing. Each offset below is built from the widths of the fields before it, in
-* the same order `state.rs` declares them, so the arithmetic is visible and a field inserted in the
-* middle changes it.
-*/
+/** Account readers and bounded discovery scans. Old pool layouts are intentionally unsupported. */
 const DISCRIMINATOR = 8;
-/** `Draw.pool` sits straight after the discriminator. */
 const DRAW_POOL_OFFSET = DISCRIMINATOR;
-/** `Draw.purchaser` sits after the discriminator and `pool`. */
 const DRAW_PURCHASER_OFFSET = 40;
-/** `Pool.creator` sits straight after the discriminator. */
 const POOL_CREATOR_OFFSET = DISCRIMINATOR;
-/** `Pool.mint` sits after the discriminator and `creator`. */
 const POOL_MINT_OFFSET = 40;
-/** `ReferralLink.referrer` sits after the discriminator and `referee`. */
-const REFERRAL_LINK_REFERRER_OFFSET = 40;
 const base58 = getBase58Decoder();
-const base64$1 = getBase64Encoder();
-/** A `memcmp` filter wants base58, and both discriminators and addresses arrive as other things. */
+const base64 = getBase64Encoder();
 const asBase58 = (bytes) => base58.decode(bytes);
 const memcmp = (offset, bytes) => ({ memcmp: {
 	offset: BigInt(offset),
 	bytes,
 	encoding: "base58"
 } });
-async function scan(rpc, filters, decode) {
-	return (await rpc.getProgramAccounts(GABOX_PROGRAM_ID, {
-		encoding: "base64",
-		commitment: "confirmed",
-		filters
-	}).send()).map(({ pubkey, account }) => decode({
-		address: pubkey,
-		data: new Uint8Array(base64$1.encode(account.data[0]))
-	}));
-}
-/** Wrap raw bytes in the shape the generated decoders expect. */
 const encoded = (address, data) => ({
 	address,
 	data,
+	exists: true,
 	executable: false,
 	lamports: 0n,
 	programAddress: GABOX_PROGRAM_ID,
 	space: BigInt(data.length)
 });
-/** The pool for a coin, or `null` when the coin has no machine. */
 async function fetchPoolByMint(client, mint) {
 	return await fetchPoolAt(client, await poolAddress(mint));
 }
-/**
-* A pool by its own address, or `null`.
-*
-* `fetchPoolByMint` is the usual way in, because a coin's mint is the natural key. This one is for
-* the other direction: a `Draw` names its pool and not its mint, so a client holding a draw reads
-* the pool to learn which coin it belongs to.
-*/
 async function fetchPoolAt(client, address) {
 	return decodeCurrentPool(await fetchEncodedAccount(client.rpc, address, { commitment: "confirmed" }));
 }
-/** `null` for a missing pool; an error for one on the older devnet layout. */
 function decodeCurrentPool(account) {
 	if (!account.exists) return null;
-	if (account.data.length !== getPoolSize()) throw new Error(`Machine ${account.address} uses an older devnet account layout and needs migration or recreation.`);
+	if (account.data.length !== getPoolSize()) throw new Error(`pool ${account.address} is not a Gabox pool and is intentionally unsupported`);
 	return decodePool(account).data;
 }
-/** A draw by address, or `null`. Delivered and legacy-claimed draws are closed. */
+function decodeCurrentDraw(account) {
+	if (!account.exists) return null;
+	if (account.data.length !== getDrawSize()) throw new Error(`draw ${account.address} is not a Gabox draw and is intentionally unsupported`);
+	return decodeDraw(account).data;
+}
 async function fetchDraw(client, address) {
-	const account = await fetchMaybeDraw(client.rpc, address, { commitment: "confirmed" });
-	return account.exists ? account.data : null;
+	return decodeCurrentDraw(await fetchEncodedAccount(client.rpc, address, { commitment: "confirmed" }));
 }
-/** Accrued referral reward for one referrer and pool, or zero when no referred pack has settled. */
-async function fetchReferralReward(client, pool, referrer) {
-	const address = await referralAddress(pool, referrer);
-	const account = await fetchMaybeReferral(client.rpc, address, { commitment: "confirmed" });
-	return account.exists ? account.data : null;
+function decodeCurrentWalletActivity(account) {
+	if (!account.exists) return null;
+	if (account.data.length !== getWalletActivitySize()) throw new Error(`activity account ${account.address} is not a Gabox WalletActivity and is intentionally unsupported`);
+	return decodeWalletActivity(account).data;
 }
 /**
-* Every current-layout machine, by discriminator and account size. Older devnet
-* pools predate seed fields and must not be decoded with the current schema.
-*
-* There is no on-chain registry — the design says so on purpose — so discovery is this scan plus
-* the `PoolCreated` event. Public RPCs limit `getProgramAccounts`, so an app that lists machines
-* for users should cache the result rather than call this per page view.
+* A wallet's lifetime pack-buying activity, or `null` before it has bought its first pack.
+* `buy_pack` creates this account `init_if_needed`, so a fresh wallet has none yet.
 */
+async function fetchWalletActivity(client, wallet) {
+	return decodeCurrentWalletActivity(await fetchEncodedAccount(client.rpc, await activityAddress(wallet), { commitment: "confirmed" }));
+}
+async function scan(rpc, filters, decode) {
+	return (await rpc.getProgramAccounts(GABOX_PROGRAM_ID, {
+		encoding: "base64",
+		commitment: "confirmed",
+		filters
+	}).send()).map(({ pubkey, account }) => decode(pubkey, new Uint8Array(base64.encode(account.data[0]))));
+}
 async function listPools(client) {
-	return await scan(client.rpc, [memcmp(0, asBase58(POOL_DISCRIMINATOR)), { dataSize: BigInt(getPoolSize()) }], ({ address, data }) => ({
+	return await scan(client.rpc, [memcmp(0, asBase58(POOL_DISCRIMINATOR)), { dataSize: BigInt(getPoolSize()) }], (address, data) => ({
 		address,
 		data: decodePool(encoded(address, data)).data
 	}));
 }
-/** Every draw of one pool, pending or ready. Closed draws are gone and never appear. */
-async function listDrawsByPool(client, pool) {
-	return await listDraws(client, { pool });
-}
-/**
-* Every open draw of one wallet, across all pools. This is the "what am I owed" query.
-*
-* An address is already base58, so it goes into the filter unchanged.
-*/
-async function listDrawsByPurchaser(client, purchaser) {
-	return await listDraws(client, { purchaser });
-}
-/**
-* Open draws, narrowed by pool, by purchaser, or by both.
-*
-* Both filters in one scan, because a UI asks for exactly that: "my pulls on this machine". Two
-* separate scans and an intersection in the client would move twice the bytes and could disagree
-* with itself, since the two reads happen at different slots. With neither filter this lists every
-* open draw of every machine.
-*/
 async function listDraws(client, query = {}) {
-	const filters = [memcmp(0, asBase58(DRAW_DISCRIMINATOR))];
+	const filters = [memcmp(0, asBase58(DRAW_DISCRIMINATOR)), { dataSize: BigInt(getDrawSize()) }];
 	if (query.pool) filters.push(memcmp(8, query.pool));
 	if (query.purchaser) filters.push(memcmp(40, query.purchaser));
-	return await scan(client.rpc, filters, ({ address, data }) => ({
+	return await scan(client.rpc, filters, (address, data) => ({
 		address,
 		data: decodeDraw(encoded(address, data)).data
 	}));
 }
-/**
-* Every wallet bound to one referrer. This is the "who did I refer" query.
-*
-* A scan, because a link is seeded on the referee and nothing on chain indexes it by referrer.
-* The list is small in practice, and a dashboard reads it once per load, not per poll.
-*/
-async function listReferralLinksByReferrer(client, referrer) {
-	return await scan(client.rpc, [
-		memcmp(0, asBase58(REFERRAL_LINK_DISCRIMINATOR)),
-		{ dataSize: BigInt(getReferralLinkSize()) },
-		memcmp(40, referrer)
-	], ({ address, data }) => ({
-		address,
-		data: decodeReferralLink(encoded(address, data)).data
-	}));
-}
-/** The vault's token balance. `0` when the vault does not exist yet. */
-async function fetchVaultBalance(client, mint, tokenProgram) {
-	const vault = await vaultAddress(mint, tokenProgram);
+const listDrawsByPool = async (client, pool) => await listDraws(client, { pool });
+const listDrawsByPurchaser = async (client, purchaser) => await listDraws(client, { purchaser });
+async function fetchVaultBalance(client, mint) {
+	const vault = await vaultAddress(mint);
 	const { value } = await client.rpc.getAccountInfo(vault, {
 		encoding: "base64",
 		commitment: "confirmed"
 	}).send();
-	if (!value) return 0n;
-	return tokenAccountAmount(new Uint8Array(base64$1.encode(value.data[0])));
+	return value ? tokenAccountAmount(new Uint8Array(base64.encode(value.data[0]))) : 0n;
 }
-/**
-* A pool with its live inventory. This is the pair every price display needs: the tiers are
-* immutable, but what they actually pay depends on what is free in the vault right now.
-*
-* # Why one request reads both accounts
-*
-* The oracle callback lowers the vault and `pool.reserved` in one transaction, a few seconds after
-* a buy. Two separate reads can land on either side of it: the old `reserved` with the new, smaller
-* vault. That pair looks insolvent, and `quote` rightly refuses it. One `getMultipleAccounts` call
-* returns both accounts from the same slot, so the pair is always one the chain actually held.
-*/
 async function fetchPoolInventory(client, mint) {
-	const address = await poolAddress(mint);
-	const readPair = async (vault) => {
-		const [poolAccount, vaultAccount] = await fetchEncodedAccounts(client.rpc, [address, vault], { commitment: "confirmed" });
-		const pool = decodeCurrentPool(poolAccount);
-		if (!pool) return null;
-		return {
-			pool,
-			inventory: vaultAccount.exists ? tokenAccountAmount(vaultAccount.data) : 0n
-		};
-	};
-	const expectedVault = await vaultAddress(mint);
-	let pair = await readPair(expectedVault);
-	if (pair && pair.pool.vault !== expectedVault) pair = await readPair(pair.pool.vault);
-	if (!pair) return null;
-	const { pool, inventory } = pair;
-	const reserved = pool.reserved;
+	const poolPda = await poolAddress(mint);
+	const vaultPda = await vaultAddress(mint);
+	const { value } = await client.rpc.getMultipleAccounts([poolPda, vaultPda], {
+		encoding: "base64",
+		commitment: "confirmed"
+	}).send();
+	const poolAccount = value[0];
+	if (!poolAccount) return null;
+	const pool = decodeCurrentPool(encoded(poolPda, new Uint8Array(base64.encode(poolAccount.data[0]))));
+	if (!pool) return null;
+	if (pool.vault !== vaultPda) throw new Error(`pool ${poolPda} has an unexpected vault; it is not a supported Gabox pool`);
+	const vaultAccount = value[1];
+	const inventory = vaultAccount ? tokenAccountAmount(new Uint8Array(base64.encode(vaultAccount.data[0]))) : 0n;
 	return {
+		poolAddress: poolPda,
 		pool,
-		poolAddress: address,
-		vault: pool.vault,
 		inventory,
-		reserved,
-		free: inventory >= reserved ? inventory - reserved : 0n
+		reserved: pool.reserved,
+		free: inventory > pool.reserved ? inventory - pool.reserved : 0n
 	};
 }
-/** The generated `Tier` uses the same field names as `math.ts`, so this is only a widening. */
-const tiersOf = (pool) => pool.tiers.map((t) => ({
-	multiplierBps: t.multiplierBps,
-	tickets: t.tickets
+const tiersOf = (pool) => pool.tiers.map(({ multiplierBps, tickets }) => ({
+	multiplierBps,
+	tickets
 }));
-/**
-* The offer a pack of `base` tokens would freeze against this inventory. Pure — the same
-* computation `buy_pack` performs, and the reason a client can show real amounts before paying.
-*/
-const offerFor = (inventory, base) => quote(base, tiersOf(inventory.pool), inventory.inventory, inventory.reserved);
-//#endregion
-//#region src/compute.ts
-/**
-* The two `ComputeBudget` instructions the transaction builders prepend.
-*
-* # Why every gabox transaction needs one
-*
-* The default budget is 200,000 compute units for the whole transaction. `buy_pack` alone does a
-* CPI into Pump (which does its own CPIs into two token programs and its fee program), a
-* `transfer_checked`, an account init, a system transfer, and a CPI into MagicBlock's VRF program
-* that allocates a request account. `createMachine` adds Pump's `create_v2` to that, which mints a
-* Token-2022 coin with metadata. Neither fits in the default, and nothing on chain can raise its
-* own budget.
-*
-* # The numbers are headroom, not measurements
-*
-* They have not been measured on chain. They sit comfortably above what these instruction mixes
-* plausibly cost and comfortably below the 1,400,000 ceiling. **Measure them on devnet before they
-* matter**, because the prioritisation fee is `price x requested limit`: a request that is three
-* times too large costs three times too much on every pack. Until then, treat them as a starting
-* point a caller may override.
-*/
-const COMPUTE_BUDGET_PROGRAM_ADDRESS = "ComputeBudget111111111111111111111111111111";
-/** The runtime's per-transaction ceiling. A larger request is rejected outright. */
-const MAX_COMPUTE_UNIT_LIMIT = 14e5;
-/** What an instruction gets when no `SetComputeUnitLimit` is present. */
-const DEFAULT_COMPUTE_UNIT_LIMIT = 2e5;
-/**
-* UNVERIFIED: none of the three figures below has been measured on chain. They are headroom, chosen
-* above what these instruction mixes plausibly cost. Measure them on devnet before they matter: the
-* prioritisation fee is `price x requested limit`, so a request three times too large costs three
-* times too much on every pack.
-*/
-/** Pump `create_v2` plus `initialize_pool` plus a seed buy, in one transaction. */
-const CREATE_MACHINE_COMPUTE_UNITS = 6e5;
-/** A venue buy, an escrow transfer, a draw init and a VRF request. */
-const BUY_PACK_COMPUTE_UNITS = 5e5;
-/** A vault transfer, or a vault transfer plus a venue sale. */
-const REDEEM_COMPUTE_UNITS = 3e5;
-/** `bind_referrer` riding ahead of a pack: one small account init. */
-const BIND_REFERRER_COMPUTE_UNITS = 5e4;
-/** `ComputeBudgetInstruction`'s discriminants. Positional and append-only upstream. */
-const SET_COMPUTE_UNIT_LIMIT = 2;
-const SET_COMPUTE_UNIT_PRICE = 3;
-/** `[u8 discriminant, u32 units]` — five bytes. */
-const LIMIT_ENCODER = getStructEncoder([["discriminant", getU8Encoder()], ["units", getU32Encoder()]]);
-/** `[u8 discriminant, u64 microLamports]` — nine bytes. */
-const PRICE_ENCODER = getStructEncoder([["discriminant", getU8Encoder()], ["microLamports", getU64Encoder()]]);
-function getSetComputeUnitLimitInstruction(units) {
-	if (!Number.isInteger(units) || units < 0 || units > 14e5) throw new Error(`compute unit limit must be an integer in 0..=${MAX_COMPUTE_UNIT_LIMIT}, got ${units}`);
-	return {
-		programAddress: COMPUTE_BUDGET_PROGRAM_ADDRESS,
-		accounts: [],
-		data: LIMIT_ENCODER.encode({
-			discriminant: SET_COMPUTE_UNIT_LIMIT,
-			units
-		})
-	};
-}
-/**
-* `SetComputeUnitPrice(microLamports)` — the priority fee, per compute unit.
-*
-* No default, deliberately. The fee that lands a transaction is a property of the network at the
-* moment you send it. A hardcoded price is either money burnt on an idle chain or a transaction
-* that quietly stops landing under load. Sample `getRecentPrioritizationFees`, or take it from
-* config.
-*/
-function getSetComputeUnitPriceInstruction(microLamports) {
-	const price = BigInt(microLamports);
-	if (price < 0n) throw new Error(`compute unit price must not be negative, got ${price}`);
-	return {
-		programAddress: COMPUTE_BUDGET_PROGRAM_ADDRESS,
-		accounts: [],
-		data: PRICE_ENCODER.encode({
-			discriminant: SET_COMPUTE_UNIT_PRICE,
-			microLamports: price
-		})
-	};
-}
-/** The compute budget prefix a builder prepends: a limit, and a price only when one is asked for. */
-function computeBudgetInstructions(units, microLamports) {
-	const instructions = [getSetComputeUnitLimitInstruction(units)];
-	if (microLamports !== void 0) instructions.push(getSetComputeUnitPriceInstruction(microLamports));
-	return instructions;
-}
+const quotePool = (inventory) => quote(inventory.pool.packTokens, tiersOf(inventory.pool), inventory.inventory, inventory.reserved);
 //#endregion
 //#region src/events.ts
-/**
-* Events, and waiting for a draw to resolve.
-*
-* # Where the events are
-*
-* Anchor's `emit!` writes the event through `sol_log_data`, which the runtime renders as a log line
-* `Program data: <base64>`. So decoding an event is: find those lines, base64-decode each one,
-* match the first eight bytes against a discriminator, and hand the rest to the generated decoder.
-*
-* The design leans on this. There is no on-chain market registry, so `PoolCreated` is how a new
-* machine is discovered, and `DrawResolved` stays readable after the `Draw` account is closed and
-* its rent returned. The event is the audit trail; the account is only the pending state.
-*
-* # Waiting
-*
-* `watchDraw` subscribes to the draw account. A normal callback, retry callback, or expiry
-* delivers the prize and closes that account; the watcher then reconstructs the result from the
-* transaction's `PackBought` and `DrawResolved` events. It also accepts a legacy open `Ready`
-* account from a callback requested before automatic delivery.
-*/
-const base64 = getBase64Encoder();
-const startsWith = (data, discriminator) => {
-	if (data.length < discriminator.length) return false;
-	for (let i = 0; i < discriminator.length; i++) if (data[i] !== discriminator[i]) return false;
-	return true;
-};
-/** The prefix Anchor's `emit!` produces. Anything else in the log is not an event. */
-const PROGRAM_DATA = "Program data: ";
-/** Decode one `Program data:` payload, or `null` when it is not one of ours. */
+/** Decode Gabox's Anchor events. Draw accounts are closed on delivery; use `DrawResolved` as final state. */
+const b64 = getBase64Encoder();
+const starts = (a, b) => a.length >= b.length && b.every((v, i) => a[i] === v);
 function decodeEvent(data) {
-	if (startsWith(data, POOL_CREATED_EVENT_DISCRIMINATOR)) return {
+	if (starts(data, POOL_CREATED_EVENT_DISCRIMINATOR)) return {
 		name: "PoolCreated",
 		data: getPoolCreatedEventDecoder().decode(data)
 	};
-	if (startsWith(data, PRIZES_FUNDED_EVENT_DISCRIMINATOR)) return {
+	if (starts(data, PRIZES_FUNDED_EVENT_DISCRIMINATOR)) return {
 		name: "PrizesFunded",
 		data: getPrizesFundedEventDecoder().decode(data)
 	};
-	if (startsWith(data, PACK_BOUGHT_EVENT_DISCRIMINATOR)) return {
+	if (starts(data, PACK_BOUGHT_EVENT_DISCRIMINATOR)) return {
 		name: "PackBought",
 		data: getPackBoughtEventDecoder().decode(data)
 	};
-	if (startsWith(data, RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR)) return {
+	if (starts(data, RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR)) return {
 		name: "RandomnessRetried",
 		data: getRandomnessRetriedEventDecoder().decode(data)
 	};
-	if (startsWith(data, DRAW_RESOLVED_EVENT_DISCRIMINATOR)) return {
+	if (starts(data, DRAW_RESOLVED_EVENT_DISCRIMINATOR)) return {
 		name: "DrawResolved",
 		data: getDrawResolvedEventDecoder().decode(data)
 	};
-	if (startsWith(data, PRIZE_REDEEMED_EVENT_DISCRIMINATOR)) return {
-		name: "PrizeRedeemed",
-		data: getPrizeRedeemedEventDecoder().decode(data)
-	};
-	if (startsWith(data, TOKENS_SOLD_EVENT_DISCRIMINATOR)) return {
+	if (starts(data, TOKENS_SOLD_EVENT_DISCRIMINATOR)) return {
 		name: "TokensSold",
 		data: getTokensSoldEventDecoder().decode(data)
 	};
 	return null;
 }
+const BASE58 = "[1-9A-HJ-NP-Za-km-z]+";
+const INVOKE = new RegExp(`^Program (${BASE58}) invoke \\[(\\d+)\\]$`);
+const SUCCESS = new RegExp(`^Program (${BASE58}) success$`);
+const FAILED = new RegExp(`^Program (${BASE58}) failed: .*$`);
 /**
-* Every gabox event in a transaction's logs, in order.
-*
-* A log line that is not `Program data:`, or whose payload matches no discriminator, is skipped
-* rather than reported. Another program in the same transaction emits its own events, and they are
-* not an error here.
+* Decode only Gabox events committed by successful runtime frames. Program logs are emitted before
+* transaction commit and are forgeable by arbitrary programs, so `Program data` is authenticated
+* by the canonical invoke/success stack and buffered until every enclosing frame succeeds.
 */
 function decodeEvents(logs) {
-	const events = [];
+	const committed = [];
+	const stack = [];
+	const discardOpenFrames = () => {
+		stack.length = 0;
+	};
+	let malformed = false;
+	let transactionFailed = false;
 	for (const line of logs) {
-		if (!line.startsWith(PROGRAM_DATA)) continue;
-		const payload = line.slice(14).trim();
-		let bytes;
-		try {
-			bytes = new Uint8Array(base64.encode(payload));
-		} catch {
+		const invoke = INVOKE.exec(line);
+		if (invoke) {
+			if (Number(invoke[2]) !== stack.length + 1) {
+				malformed = true;
+				discardOpenFrames();
+				continue;
+			}
+			stack.push({
+				programId: invoke[1],
+				pending: []
+			});
 			continue;
 		}
-		const event = decodeEvent(bytes);
-		if (event) events.push(event);
+		const success = SUCCESS.exec(line);
+		const failed = FAILED.exec(line);
+		if (success || failed) {
+			const programId = (success ?? failed)[1];
+			const frame = stack.at(-1);
+			if (!frame || frame.programId !== programId) {
+				malformed = true;
+				discardOpenFrames();
+				continue;
+			}
+			stack.pop();
+			if (success) {
+				const parent = stack.at(-1);
+				if (parent) parent.pending.push(...frame.pending);
+				else committed.push(...frame.pending);
+			}
+			if (failed && stack.length === 0) transactionFailed = true;
+			continue;
+		}
+		const frame = stack.at(-1);
+		if (!line.startsWith("Program data: ") || frame?.programId !== GABOX_PROGRAM_ID) continue;
+		try {
+			const event = decodeEvent(new Uint8Array(b64.encode(line.slice(14).trim())));
+			if (event) frame.pending.push(event);
+		} catch {}
 	}
-	return events;
+	return malformed || transactionFailed || stack.length !== 0 ? [] : committed;
 }
-/** Fetch a transaction and decode the gabox events it emitted. */
 async function fetchEvents(client, signature) {
 	return await readEvents(client.rpc, signature);
 }
-/** The RPC half of `fetchEvents`, for the internal readers that already hold one. */
 async function readEvents(rpc, signature) {
-	return decodeEvents((await rpc.getTransaction(signature, {
+	const tx = await rpc.getTransaction(signature, {
 		commitment: "confirmed",
 		encoding: "json",
 		maxSupportedTransactionVersion: 0
-	}).send())?.meta?.logMessages ?? []);
-}
-/**
-* Watch one draw and resolve when its callback delivers the prize.
-*
-* The first notification is the account as it is now, so a draw that resolved before the call
-* resolves the promise immediately. Automatic delivery closes the account, so the watcher rebuilds
-* the resolved snapshot from the purchase and resolution events when it sees that closure.
-*
-* There is no timeout here on purpose. The program's own deadline is 216,000 slots, which is about
-* a day, and a UI should decide its own patience rather than inherit one.
-*/
-async function watchDraw(client, address, options = {}) {
-	const { rpc, rpcSubscriptions } = client;
-	const controller = new AbortController();
-	const abort = () => controller.abort(options.signal?.reason);
-	options.signal?.addEventListener("abort", abort, { once: true });
-	try {
-		const notifications = await rpcSubscriptions.accountNotifications(address, {
-			encoding: "base64",
-			commitment: "confirmed"
-		}).subscribe({ abortSignal: controller.signal });
-		const current = await readDraw(rpc, address);
-		if (current) {
-			options.onChange?.(current);
-			if (current.status === 1) return current;
-		} else {
-			const delivered = await readDeliveredDraw(rpc, address);
-			if (delivered) return delivered;
-		}
-		for await (const notification of notifications) {
-			const account = notification.value;
-			if (!account || account.data[0] === "") {
-				for (let attempt = 0; attempt < 10; attempt++) {
-					const delivered = await readDeliveredDraw(rpc, address);
-					if (delivered) return delivered;
-					await new Promise((resolve) => setTimeout(resolve, 500));
-				}
-				throw new Error(`draw ${address} closed before its resolution event became readable`);
+	}).send();
+	const meta = tx?.meta;
+	if (!tx || !meta || meta.err) return [];
+	return decodeEvents(meta.logMessages ?? []);
+}
+/** Poll final resolution events for one closed draw address. There is no separate Ready/claim state to poll instead. */
+async function findResolvedDraw(client, address) {
+	let before;
+	for (let page = 0; page < 10; page++) {
+		const rows = await client.rpc.getSignaturesForAddress(address, {
+			commitment: "confirmed",
+			limit: 100,
+			...before ? { before } : {}
+		}).send();
+		for (const row of rows) {
+			if (row.err) continue;
+			for (const event of await readEvents(client.rpc, row.signature)) {
+				if (event.name !== "DrawResolved") continue;
+				if (await drawAddress(event.data.pool, event.data.seq) === address) return {
+					...event.data,
+					address
+				};
 			}
-			const draw = decodeDrawBytes(address, new Uint8Array(base64.encode(account.data[0])));
-			options.onChange?.(draw);
-			if (draw.status === 1) return draw;
 		}
-		throw new Error(`the subscription for draw ${address} ended before it resolved`);
-	} finally {
-		options.signal?.removeEventListener("abort", abort);
-		controller.abort();
+		if (rows.length < 100) return null;
+		before = rows.at(-1)?.signature;
+		if (!before) return null;
 	}
-}
-function decodeDrawBytes(address, data) {
-	return decodeDraw({
-		address,
-		data,
-		executable: false,
-		lamports: 0n,
-		programAddress: GABOX_PROGRAM_ID,
-		space: BigInt(data.length)
-	}).data;
-}
-async function readDraw(rpc, address) {
-	const { value } = await rpc.getAccountInfo(address, {
-		encoding: "base64",
-		commitment: "confirmed"
-	}).send();
-	if (!value) return null;
-	return decodeDrawBytes(address, new Uint8Array(base64.encode(value.data[0])));
-}
-/** Recover the final snapshot after automatic delivery closed the draw account. */
-async function readDeliveredDraw(rpc, address) {
-	const signatures = await rpc.getSignaturesForAddress(address, {
-		commitment: "confirmed",
-		limit: 10
-	}).send();
-	const rows = await Promise.all(signatures.filter((row) => !row.err).map(async (row) => ({
-		slot: row.slot,
-		events: await readEvents(rpc, row.signature)
-	})));
-	const bought = rows.flatMap((row) => row.events.flatMap((event) => event.name === "PackBought" ? [{
-		slot: row.slot,
-		data: event.data
-	}] : []))[0];
-	const resolved = rows.flatMap((row) => row.events.flatMap((event) => event.name === "DrawResolved" ? [{
-		slot: row.slot,
-		data: event.data
-	}] : []))[0];
-	if (!bought || !resolved) return null;
-	if (bought.data.pool !== resolved.data.pool || bought.data.seq !== resolved.data.seq || bought.data.purchaser !== resolved.data.purchaser) return null;
-	const [derived, bump] = await findDrawPda({
-		pool: bought.data.pool,
-		seq: bought.data.seq
-	});
-	if (derived !== address) return null;
-	const ticketed = bought.data.prizes.filter((prize) => prize.tickets > 0);
-	if (ticketed.length === 0) return null;
-	const lastRetry = rows.flatMap((row) => row.events.flatMap((event) => event.name === "RandomnessRetried" && event.data.pool === bought.data.pool && event.data.seq === bought.data.seq ? [{
-		slot: row.slot,
-		attempt: event.data.attempt
-	}] : [])).reduce((latest, row) => !latest || row.slot > latest.slot ? row : latest, null);
-	return {
-		discriminator: DRAW_DISCRIMINATOR,
-		pool: bought.data.pool,
-		purchaser: bought.data.purchaser,
-		seq: bought.data.seq,
-		bump,
-		status: 1,
-		requestSlot: bought.slot,
-		lastAttemptSlot: lastRetry?.slot ?? bought.slot,
-		attempts: lastRetry?.attempt ?? 1,
-		maximum: ticketed.reduce((a, prize) => a > prize.amount ? a : prize.amount, 0n),
-		minimum: ticketed.reduce((a, prize) => a < prize.amount ? a : prize.amount, ticketed[0].amount),
-		prizes: bought.data.prizes,
-		amount: resolved.data.amount,
-		randomness: resolved.data.randomness,
-		timedOut: resolved.data.timedOut
-	};
+	return null;
 }
 //#endregion
 //#region src/lookupTables.ts
 /**
-* Shared devnet address lookup table, verified on 2026-09-10T13:05:37.919Z.
+* Shared devnet address lookup table, verified on 2026-09-18T07:26:38.218Z.
 * Generated by scripts/deploy-lookup-table.ts. Existing indices are immutable;
 * keep this table active while clients use it. Authority is the devnet deploy wallet.
 */
@@ -917,7 +662,47 @@ const DEVNET_LOOKUP_TABLE_ADDRESSES = [
 	address("Freijj9xKLefjrb5fHgT6KMbYG1XBP2mA83tqeXYUMYM"),
 	address("4uzPz9TPskXiiEZ6X78rqud8LvfdxkJBr5EKHgbx4azP"),
 	address("Hxzab4UjjVH2KjsdAqzdxGdYUpNN5FKhpu7iikB869uH"),
-	address("Frkwunr9dQM9d4TthfQ2unxC994XpkLMpkRP2e7yfirk")
+	address("Frkwunr9dQM9d4TthfQ2unxC994XpkLMpkRP2e7yfirk"),
+	address("E6ShohW57z5CJPBeEcFAEbvPqUyt6QxHcxnkh4hMaNrg"),
+	address("6z6GDdfb2AjR9ZhJmAUQ5cipJCVxQvLJhB2H8mCwTFBP"),
+	address("D9LwzTvJ5XoGxorcdaZvBgq7Qruqewu2P9WVsgSrKURd"),
+	address("4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU"),
+	address("GCow1cTVRa43v8EX1eVwVobiKXoyZjfQpwAvgpZ8B2KP"),
+	address("65LkFkYo9gMD6AwXTbSsxR3d28pCVbJp5AtE9NK3634n"),
+	address("8wDZLhae9WbNvm3eCgHVDrXUhJbd3gx6DnTnhsw45XEj"),
+	address("CPgoAkfWjiUZfNLRp94hD7BjmDSFy96mS8xcQKoPFB4H"),
+	address("GXVKyyXsoUihF1uzGCx7YXVqQ7kimUDAo3xyqULvgDyB"),
+	address("5tpFHeni6NYD6pQpkuReVPGtCJLyaXDq97FTJJzyZMjt"),
+	address("DNscAYMk2LW55Aq7FTj24mRbwVPZ6EgvCUoabhhtdVCW"),
+	address("7Q2wpniGesAyAkjACpg58BAcDjBKcdcX9a6RAgszVh4M"),
+	address("7gx9ZEwMSd1ifHBEgVaUsCkQmHTFJTWVs3C1bQABQ22T"),
+	address("GsVBKjffkB769p9tHTZWoAX3r9T6dXoDTJr3f7XutJH7"),
+	address("9NFrxdnmedHKHs1tnhYm9G5XTJh7Lt7xN6uxgZzwQNM7"),
+	address("BhMknQ4j9RZUbJk6GS4QJh8MSKxcqZHS2x9MZh2AH9hA"),
+	address("9NW32ymMo8Qx6DTbgkxtnD8Dh9hssQYpcyY2Brdpg2hs"),
+	address("5a8Gfgwx4hrCtYKgvjtX57FsirXPRN7Jzm9aXmn6hQs8"),
+	address("5KUNmCZatysY7fxLtTgo2bpkqevPRZZG8fkrh3e1P89F"),
+	address("HPfEytxa5JGqmGiVwrSepAcNTkWboxvtQKbyWN9DNCoQ"),
+	address("Gr5kHfDBd7GAdjK6Ct3EDC566XFPjCr3mLCkKVxJYrMD"),
+	address("HzCwuA6T48enyWvCJWrLhNvMpJJR43kddjMGFf6LyA9L"),
+	address("Do4esSd37h4uHz35piua8rRtcXDNt27re8NDqqZfjsGJ"),
+	address("2GC6K75FS6MpRrMZYXifinC2sVXP3htsJpayerx7ACci"),
+	address("FvEpzodkyvMzRHQo4q7fhvfa287hnjfr1oiumRtQXrse"),
+	address("8SwxZnhYHeC9S93ZFzLTd9dC2c44hfCdGyoXYzA7U6Db"),
+	address("6B1oS2LSDYHyXpRF9S8C6r5LffitosDrhie2WWsUtfRV"),
+	address("F2pzDCn3vqXcNWF6osLxSvVtf3CyTkHd4tRxhGjyRZQ9"),
+	address("DKESpHxobrT9Ra4snSXCD4cdhQMqpzmGhZN1HZ3sUYMY"),
+	address("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"),
+	address("SysvarRent111111111111111111111111111111111"),
+	address("DRay6fNdQ5J82H7xV6uq2aV3mNrUZ1J4PgSKsWgptcm6"),
+	address("5xqNaZXX5eUi4p5HU4oz9i5QnwRNT2y6oN7yyn4qENeq"),
+	address("4uAB7seenFJKPUXqYewAdfra2u6baBgjiXU8x1SC7Ycz"),
+	address("7ZR4zD7PYfY2XxoG1Gxcy2EgEeGYrpxrwzPuwdUBssEt"),
+	address("DdEeCPXbCAzHE2PZSoR3RZng4WA4bSztrezQznrJ4ooB"),
+	address("DRaycpLY18LhpbydsBWbVJtxpNv9oXPgjRSfpF2bWpYb"),
+	address("CXniRufdq5xL8t8jZAPxsPZDpuudwuJSPWnbcD5Y5Nxq"),
+	address("G7YfJJp1TX1VtzN4V2yhPNSU23AKPSy1U2miRdwAByK5"),
+	address("5WcPTEQ59UqpQzjZUPbU8QRGCbj7NeQNLDa7DbsLkLKT")
 ];
 const DEVNET_ADDRESS_LOOKUP_TABLES = { [DEVNET_LOOKUP_TABLE_ADDRESS]: [...DEVNET_LOOKUP_TABLE_ADDRESSES] };
 /**
@@ -950,10 +735,10 @@ async function getOffer(client, mint, options = {}) {
 }
 /**
 * The same computation with the reads already done. Useful when a caller holds a `ResolvedVenue`
-* and wants to re-price without touching the network. `quoteLamports` is
+* and wants to re-price without touching the network. `quoteAmount` is
 * `venue.quoteBuy(pool.packTokens)`.
 */
-function offerFromState(inventory, venue, quoteLamports) {
+function offerFromState(inventory, venue, quoteAmount) {
 	const { pool } = inventory;
 	const tiers = tiersOf(pool);
 	const offer = quote(pool.packTokens, tiers, inventory.inventory, inventory.reserved);
@@ -962,12 +747,10 @@ function offerFromState(inventory, venue, quoteLamports) {
 		mint: pool.mint,
 		pool: inventory.poolAddress,
 		packTokens: pool.packTokens,
-		quoteLamports,
-		feeBps: pool.feeBps,
-		feeLamports: share(quoteLamports, BigInt(pool.feeBps)),
-		protocolLamports: share(quoteLamports, PROTOCOL_FEE_BPS),
-		seedLamports: pool.seedLamports,
-		seedTokens: pool.seedTokens,
+		quoteAmount,
+		quoteMint: pool.quoteMint,
+		seedQuoteAmount: pool.seedQuoteAmount,
+		seedTokens: seedTokens(pool.packTokens, tiers),
 		venue,
 		prizes: offer.prizes,
 		maximum: offer.maximum,
@@ -1054,8 +837,8 @@ function clusterNamedBy(url) {
 */
 function assertClusterUrl(cluster, url) {
 	const named = clusterNamedBy(url);
-	if (cluster === "devnet" && named !== "devnet") throw new Error(`refusing to use ${url} as a devnet endpoint: it does not name devnet.\nEvery address in this SDK — the Pump programs, the MagicBlock queue, the pools — exists on every cluster, so a wrong URL is a live transaction, not an error. Pass { cluster: 'localnet' } for a local validator, or name the cluster the URL really is.`);
-	if (cluster !== "devnet" && named !== null && named !== cluster) throw new Error(`refusing to use ${url} as a ${cluster} endpoint: the URL names ${named}.\nEvery address in this SDK exists on every cluster, so a wrong URL is a live transaction, not an error. Pass the cluster the URL really names.`);
+	if (cluster === "devnet" && named !== "devnet") throw new Error(`refusing to use ${url} as a devnet endpoint: it does not name devnet.\nA Gabox program id, a MagicBlock queue and a pool address all exist on every cluster, so a wrong URL is a live transaction, not an error. Pass { cluster: 'localnet' } for a local validator, or name the cluster the URL really is.`);
+	if (cluster !== "devnet" && named !== null && named !== cluster) throw new Error(`refusing to use ${url} as a ${cluster} endpoint: the URL names ${named}.\nA Gabox address exists on every cluster, so a wrong URL is a live transaction, not an error. Pass the cluster the URL really names.`);
 }
 /** `https://x` becomes `wss://x`, `http://x` becomes `ws://x`. Anything else is returned as is. */
 function websocketUrlFor(url) {
@@ -1087,307 +870,201 @@ function createClient(config) {
 	};
 }
 //#endregion
-//#region src/tx/message.ts
+//#region src/tx/wsol.ts
 /**
-* Assembling a transaction message.
+* Wrapping and unwrapping SOL around a venue trade.
 *
-* Every builder in this directory ends here: compute budget first, then the program instructions,
-* with a fee payer and a blockhash lifetime. The result is a message a wallet can sign and send —
-* nothing in this SDK signs or sends anything itself.
-*/
-/**
-* Build the message. One RPC read, for the blockhash.
+* Both venues settle in WSOL, never in native SOL. So every builder in this directory does the same
+* three things around its Gabox instruction:
 *
-* The blockhash expires in about a minute, so build the message when the user is ready to sign
-* rather than when the page loads.
+*   1. create the wallet's WSOL associated token account, if it is missing;
+*   2. move the lamports it is going to spend into that account and `syncNative` it, so the token
+*      balance matches the lamports;
+*   3. close the account afterwards, which sends everything left back to the wallet as SOL.
+*
+* A sale needs no step 2: the proceeds arrive in the account, and the close is what turns them into
+* SOL.
+*
+* # Closing unwraps everything
+*
+* If the wallet already held WSOL in that account, the close turns that into SOL too. Nothing is
+* lost and the wallet still owns every lamport, but the balance moves out of the token account. A
+* wallet that keeps a WSOL position on purpose should build its own instructions instead of using
+* these builders.
 */
-async function buildMessage(client, feePayer, instructions, options) {
-	const { value: latestBlockhash } = await client.rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
-	const budget = computeBudgetInstructions(options.computeUnitLimit, options.computeUnitPrice);
-	const message = pipe(createTransactionMessage({ version: 0 }), (m) => setTransactionMessageFeePayerSigner(feePayer, m), (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m), (m) => appendTransactionMessageInstructions([...budget, ...instructions], m), (m) => compressTransactionMessageUsingAddressLookupTables(m, options.addressLookupTables ?? client.addressLookupTables));
-	const size = getTransactionEncoder().encode(compileTransaction(message)).length;
-	if (size > 1232) throw new Error(`Transaction is ${size} bytes; Solana allows 1232. Shorten metadata or supply additional address lookup tables.`);
-	return message;
-}
-/** Append `remainingAccounts` to a generated instruction, which is how a venue's list is passed. */
-function withRemainingAccounts(instruction, remaining) {
-	return {
-		...instruction,
-		accounts: [...instruction.accounts ?? [], ...remaining]
-	};
-}
-//#endregion
-//#region src/referral.ts
-/** Resolve the purchaser's permanent referral binding for a pack purchase. */
-async function resolveReferral(client, purchaser, pool) {
-	const link = await referralLinkAddress(purchaser);
-	const account = await fetchMaybeReferralLink(client.rpc, link, { commitment: "confirmed" });
-	if (!account.exists) return null;
-	const referrer = account.data.referrer;
+/** The wallet's WSOL account, and the instructions that put `lamports` of spendable WSOL in it. */
+async function fundWsol(owner, lamports) {
+	if (lamports < 0n) throw new Error("lamports must not be negative");
+	const account = await wsolAccountFor(owner.address);
+	const instructions = [getCreateAssociatedTokenIdempotentInstruction({
+		payer: owner,
+		ata: account,
+		owner: owner.address,
+		mint: WSOL_MINT,
+		tokenProgram: TOKEN_PROGRAM_ADDRESS
+	})];
+	if (lamports > 0n) instructions.push(getTransferSolInstruction({
+		source: owner,
+		destination: account,
+		amount: lamports
+	}), getSyncNativeInstruction({ account }));
 	return {
-		link,
-		referrer,
-		referral: await referralAddress(pool, referrer)
+		account,
+		instructions
 	};
 }
-/** Bind a wallet to a referrer. The purchaser signs and the binding is permanent. */
-async function bindReferrer(client, referee, referrer, options = {}) {
-	return await buildMessage(client, referee, [await getBindReferrerInstructionAsync({
-		referee,
-		referrer
-	})], {
-		addressLookupTables: options.addressLookupTables,
-		computeUnitLimit: options.computeUnitLimit ?? 8e4,
-		...options.computeUnitPrice === void 0 ? {} : { computeUnitPrice: options.computeUnitPrice }
-	});
-}
-/** Claim all accrued referral rewards for one pool. */
-async function claimReferral(client, referrer, pool, options = {}) {
-	return await buildMessage(client, referrer, [await getClaimReferralInstructionAsync({
-		referrer,
-		pool
-	})], {
-		addressLookupTables: options.addressLookupTables,
-		computeUnitLimit: options.computeUnitLimit ?? 8e4,
-		...options.computeUnitPrice === void 0 ? {} : { computeUnitPrice: options.computeUnitPrice }
+/** Close the WSOL account, sending every lamport in it back to the owner as SOL. */
+function unwrapWsol(owner, account) {
+	return getCloseAccountInstruction({
+		account,
+		destination: owner.address,
+		owner
 	});
 }
 //#endregion
 //#region src/tx/buyPack.ts
-/**
-* Buying a pack.
-*
-* One instruction does the whole thing: buy exactly `pool.packTokens` at the venue, move the
-* tokens into gabox custody, freeze a prize table into a new `Draw`, pay the creator's fee and
-* the protocol's 1% of the venue cost, and ask MagicBlock for randomness. Either all of it happens
-* or none of it does.
-*
-* # The three numbers the buyer signs
-*
-* `maxQuoteIn` is the slippage cap at the venue, in lamports (WSOL on PumpSwap). The token count
-* is fixed by the pool, so the cost is the only thing that moves. Set it from `offer.quoteLamports`
-* plus a margin, for example 2%.
-*
-* `minMaximum` is a floor on the top prize, in tokens. The table is fixed, so only an inventory
-* cap can lower it. Set it from `offer.maximum`.
-*
-* `maxTotalDebit` caps the venue debit plus the creator fee plus the protocol fee plus the VRF
-* request, measured in SOL and WSOL together. Both fees are a share of the venue debit, so budget
-* them from `maxQuoteIn`. It does **not** cover the rent Anchor pays for the `Draw` and any ATA it
-* creates, nor the transaction fee: the runtime charges those before the handler runs. Budget for
-* them separately.
-*
-* # PumpSwap needs WSOL first
-*
-* On the curve, Pump spends native SOL. On PumpSwap the quote is a classic WSOL token account, so
-* the buyer's WSOL ATA must exist and hold enough before the pack instruction runs. This builder
-* adds the create/fund/sync instructions when the route is PumpSwap. They are the buyer's own
-* instructions, signed by the buyer, and gabox never touches that account.
-*/
 async function buyPack(client, input) {
-	const { mint, purchaser } = input;
 	if (input.maxQuoteIn <= 0n) throw new Error("maxQuoteIn must be positive");
-	const inventory = await fetchPoolInventory(client, mint);
-	if (!inventory) throw new Error(`no gabox pool for mint ${mint}`);
+	if (input.maxNativeDebit < 0n) throw new Error("maxNativeDebit must not be negative");
+	const inventory = await fetchPoolInventory(client, input.mint);
+	if (!inventory) throw new Error(`no Gabox pool for mint ${input.mint}`);
 	const { pool, poolAddress } = inventory;
+	const purchaser = input.purchaser.address;
 	const venue = await resolveVenue(client, {
-		mint,
-		user: purchaser.address,
+		mint: input.mint,
+		user: purchaser,
 		...input.venue ? { venue: input.venue } : {}
 	});
 	const draw = await drawAddress(poolAddress, input.seq ?? pool.nextSeq);
-	let referral = await resolveReferral(client, purchaser.address, poolAddress);
-	let bind = null;
-	if (referral === null && input.referrer && canBind(purchaser.address, input.referrer)) {
-		const referrer = input.referrer;
-		bind = await getBindReferrerInstructionAsync({
-			referee: purchaser,
-			referrer
-		});
-		referral = {
-			link: await referralLinkAddress(purchaser.address),
-			referrer,
-			referral: await referralAddress(poolAddress, referrer)
-		};
-	}
-	const buy = getBuyPackInstruction({
-		purchaser,
+	const buy = await getBuyPackInstructionAsync({
+		purchaser: input.purchaser,
 		pool: poolAddress,
-		creator: pool.creator,
 		draw,
-		mint,
+		mint: input.mint,
+		quoteMint: pool.quoteMint,
 		vault: pool.vault,
-		userTokens: venueUserTokens(venue.buyAccounts, venue.kind),
 		venue: venue.program,
-		identity: await vrfIdentityAddress(),
-		tokenProgram: pool.tokenProgram,
 		maxQuoteIn: input.maxQuoteIn,
 		minMaximum: input.minMaximum,
-		maxTotalDebit: input.maxTotalDebit,
-		referralLink: referral?.link,
-		referral: referral?.referral
+		maxNativeDebit: input.maxNativeDebit
 	});
-	const remaining = input.cashback ? [...venue.buyAccounts, swapCashbackAccount(purchaser.address)] : venue.buyAccounts;
-	return await buildMessage(client, purchaser, [
-		...bind === null ? [] : [bind],
-		...venue.kind === "pumpswap" ? wsolPreparation$2(purchaser, input.wrapLamports ?? input.maxQuoteIn) : [],
-		withRemainingAccounts(buy, remaining)
-	], {
+	const wsol = await fundWsol(input.purchaser, input.maxQuoteIn);
+	const instructions = [
+		...wsol.instructions,
+		withRemainingAccounts(buy, venue.buyAccounts),
+		unwrapWsol(input.purchaser, wsol.account)
+	];
+	return await buildMessage(client, input.purchaser, instructions, {
 		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? 5e5 + (bind === null ? 0 : 5e4),
+		computeUnitLimit: input.computeUnitLimit ?? 24e4,
 		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
 	});
 }
-/** The default `Pubkey`: all zero bytes. `bind_referrer` refuses a link pointing at it. */
-const NO_REFERRER = "11111111111111111111111111111111";
-/**
-* The program refuses a self-referral and a link to the all-zero address. Both would take the
-* pack down with them, so the bind is skipped instead and the pack goes through unreferred.
-*/
-function canBind(purchaser, referrer) {
-	return referrer !== purchaser && referrer !== NO_REFERRER;
-}
-/**
-* The purchaser's base-token ATA, taken out of the venue account list rather than re-derived.
-*
-* `market.rs` requires `user_tokens` to equal the venue list's own `associated_base_user` (Pump) or
-* `user_base_token_account` (PumpSwap). Reading it back from the list makes the two agree by
-* construction instead of by two derivations that happen to match.
-*/
-function venueUserTokens(accounts, kind) {
-	const account = accounts[kind === "pump" ? 14 : 5];
-	if (!account) throw new Error(`the ${kind} account list is too short`);
-	return account.address;
-}
-/**
-* Create the buyer's WSOL account if needed, fund it, and sync its balance.
-*
-* `SyncNative` is the step people forget. A plain SOL transfer into a WSOL account raises its
-* lamports but not the `amount` field the token program reads, so the venue sees an empty account
-* until this instruction copies one to the other.
-*/
-function wsolPreparation$2(purchaser, lamports) {
-	const wsol = wsolAccountFor(purchaser.address);
-	return [
-		getCreateAssociatedTokenIdempotentInstruction({
-			payer: purchaser,
-			ata: wsol,
-			owner: purchaser.address,
-			mint: WSOL_MINT,
-			tokenProgram: TOKEN_PROGRAM_ADDRESS$1
-		}),
-		getTransferSolInstruction({
-			source: purchaser,
-			destination: wsol,
-			amount: lamports
-		}),
-		getSyncNativeInstruction({ account: wsol })
-	];
-}
 //#endregion
 //#region src/tx/createMachine.ts
 /**
-* Creating a machine: one transaction, two instructions, two signers.
-*
-* # Why it has to be one transaction
-*
-* `initialize_pool` reads the Instructions sysvar and refuses to run unless the same transaction
-* also carries a Pump `create_v2` for the same mint, signed by the same creator. That is what makes
-* "one pool per coin" true and stops anyone wrapping an existing coin in a machine. The create must
-* come **first**: the mint account has to exist and deserialize before Anchor validates
-* `initialize_pool`'s accounts.
-*
-* # The seed
-*
-* The creator owns none of the coin yet — it does not exist until this transaction runs. So
-* `initialize_pool` buys the seed on the curve itself, into the creator's own ATA, and moves it
-* straight into the vault. The Pump buy accounts ride along as `remainingAccounts`, in the same
-* order `buy_pack` uses.
-*
-* The seed follows from the tier table. The program accepts any table that passes `math::validate`;
-* it does not enforce one table. A creator may pass their own `tiers`; the default is
-* `DEFAULT_TIERS`. The program buys exactly `largestTierAmount - PACK_TOKENS` tokens as the seed,
-* so the first pack can pay the top tier in full. The creator only signs a maximum SOL cost for
-* that buy. The seed buy moves the curve, so a bigger jackpot means a slightly higher starting
-* pack price. A fresh Pump curve only holds so many tokens (`Global.initialRealTokenReserves`),
-* so a table whose seed exceeds that cannot be created; `createMachine` and `seedCostEstimate`
-* both check this before spending anything.
-*
-* # Two signers
-*
-* The mint keypair signs `create_v2` — Pump takes it as a signer rather than deriving it — and the
-* creator signs both instructions and pays for everything.
-*/
-/**
 * Build the transaction message. Sign it with both `creator` and `mintKeypair`.
 *
-* Reads Pump's `Global` account, because two of the buy accounts — the fee recipient and the
-* buyback fee recipient — are chosen from lists held there. Nothing else needs the chain: the coin
-* does not exist yet, so every other account is a derivation.
+* Reads LaunchLab's global config and the Gabox platform config, because the seed price depends on
+* their fee rates. Nothing else needs the chain: the coin does not exist yet, so every other
+* account is a derivation.
 */
 async function createMachine(client, input) {
-	const { creator, mintKeypair, name, symbol, uri, feeBps, maxSeedLamports } = input;
-	if (!Number.isInteger(feeBps) || feeBps < 0 || feeBps > 100) throw new Error(`feeBps must be a whole number from 0 to 100`);
+	const { creator, mintKeypair, name, symbol, uri, maxSeedQuoteIn, maxSeedNativeDebit } = input;
 	const tiers = cloneTiers(input.tiers ?? DEFAULT_TIERS);
 	validateTiers(tiers);
 	validatePack(PACK_TOKENS, tiers);
-	const seed = seedTokens(PACK_TOKENS, tiers);
-	if (seed > 0n && maxSeedLamports <= 0n) throw new Error("maxSeedLamports must be positive when the jackpot needs a seed");
-	await assertSeedFitsFreshCurve(client, seed);
+	const extraSeedTokens = input.extraSeedTokens ?? 0n;
+	if (extraSeedTokens < 0n) throw new Error("extraSeedTokens must not be negative");
+	const seed = seedTokens(PACK_TOKENS, tiers) + extraSeedTokens;
+	assertSeedFitsCurve(seed);
+	if (seed > 0n && maxSeedQuoteIn <= 0n) throw new Error("maxSeedQuoteIn must be positive when the jackpot needs a seed");
+	if (maxSeedQuoteIn < 0n) throw new Error("maxSeedQuoteIn must not be negative");
+	if (maxSeedNativeDebit < 0n) throw new Error("maxSeedNativeDebit must not be negative");
+	const ids = raydiumIds(client.cluster);
 	const mint = mintKeypair.address;
-	const create = getPumpCreateV2Instruction({
+	const quoteMint = WSOL_MINT;
+	const create = await getLaunchInstruction({
 		mint: mintKeypair,
-		user: creator,
+		creator,
 		name,
 		symbol,
-		uri,
-		creator: creator.address,
-		mayhemMode: false,
-		cashback: false
-	});
-	const venueAccounts = await pumpSeedBuyAccounts(client, {
+		uri
+	}, ids);
+	const poolState = await launchlabPoolAddress(ids.launchlab, mint, quoteMint);
+	const venueAccounts = launchlabBuyAccounts({
+		launchlab: ids.launchlab,
+		launchlabAuthority: ids.launchlabAuthority,
+		launchlabEventAuthority: ids.launchlabEventAuthority,
+		globalConfig: ids.solGlobalConfig,
+		platformConfig: ids.gaboxPlatform,
+		poolState,
 		mint,
+		quoteMint,
+		baseVault: await launchlabVaultAddress(ids.launchlab, poolState, mint),
+		quoteVault: await launchlabVaultAddress(ids.launchlab, poolState, quoteMint),
 		user: creator.address,
-		...input.feeRecipientIndex === void 0 ? {} : { feeRecipientIndex: input.feeRecipientIndex },
-		...input.buybackRecipientIndex === void 0 ? {} : { buybackRecipientIndex: input.buybackRecipientIndex }
+		userBaseToken: await ata(creator.address, mint),
+		userQuoteToken: await ata(creator.address, quoteMint),
+		platformFeeVault: await platformFeeVaultAddress(ids.launchlab, ids.gaboxPlatform, quoteMint),
+		creatorFeeVault: await creatorFeeVaultAddress(ids.launchlab, creator.address, quoteMint)
 	});
-	return await buildMessage(client, creator, [create, withRemainingAccounts(await getInitializePoolInstructionAsync({
+	const initialize = await getInitializePoolInstructionAsync({
 		creator,
 		mint,
-		tokenProgram: PUMP_CREATE_TOKEN_PROGRAM_ADDRESS,
-		venue: PUMP_PROGRAM_ADDRESS,
-		feeBps,
+		quoteMint,
+		venue: ids.launchlab,
 		tiers,
-		maxSeedLamports
-	}), venueAccounts)], {
+		maxSeedQuoteIn,
+		maxSeedNativeDebit,
+		extraSeedTokens
+	});
+	const wsol = await fundWsol(creator, maxSeedQuoteIn);
+	const instructions = [
+		create,
+		...wsol.instructions,
+		withRemainingAccounts(initialize, venueAccounts),
+		unwrapWsol(creator, wsol.account)
+	];
+	return await buildMessage(client, creator, instructions, {
 		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? 6e5,
+		computeUnitLimit: input.computeUnitLimit ?? 385e3,
 		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
 	});
 }
 /**
 * What the seed for this table costs, fees included, and how many tokens it is.
 *
-* The coin does not exist yet, so the price is Pump's default new curve. Nothing else trades on
-* it before `initialize_pool` runs in the same transaction, so this is exact up to a change in
-* Pump's fee settings between the read and the send. Add a small margin for `maxSeedLamports`.
+* The coin does not exist yet, so the price comes from the starting reserves LaunchLab derives from
+* the pinned launch shape. Nothing trades on the curve before `initialize_pool` runs in the same
+* transaction, so this is exact up to a change in Raydium's fee rates between the read and the
+* send.
 *
-* Defaults to `DEFAULT_TIERS`. Throws if `tiers` fails `validateTiers`/`validatePack`, or if the
-* seed is bigger than a fresh Pump curve can sell in one buy.
+* Defaults to `DEFAULT_TIERS` and no extra seed. Throws if `tiers` fails
+* `validateTiers`/`validatePack`, if `extraSeedTokens` is negative, or if the total seed is bigger
+* than the curve sells.
 */
-async function seedCostEstimate(client, tiers = DEFAULT_TIERS) {
+async function seedCostEstimate(client, tiers = DEFAULT_TIERS, options = {}) {
 	const copiedTiers = cloneTiers(tiers);
 	validateTiers(copiedTiers);
 	validatePack(PACK_TOKENS, copiedTiers);
-	const seed = seedTokens(PACK_TOKENS, copiedTiers);
-	await assertSeedFitsFreshCurve(client, seed);
+	const extraSeedTokens = options.extraSeedTokens ?? 0n;
+	if (extraSeedTokens < 0n) throw new Error("extraSeedTokens must not be negative");
+	const mandatorySeed = seedTokens(PACK_TOKENS, copiedTiers);
+	const seed = mandatorySeed + extraSeedTokens;
+	assertSeedFitsCurve(seed);
+	const ids = raydiumIds(client.cluster);
+	const settings = await fetchCurveSettings(client, ids);
 	return {
 		tiers: copiedTiers,
-		seedTokens: seed,
-		lamports: seed === 0n ? 0n : await newCurveBuyCost(client, seed)
+		seedTokens: mandatorySeed,
+		extraSeedTokens,
+		totalSeedTokens: seed,
+		quoteAmount: seed === 0n ? 0n : curveBuyExactOut(newCurveReserves(ids, settings.migrateFee), settings.rates, seed),
+		quoteMint: WSOL_MINT
 	};
 }
-/** A mutable encoded-table shape, owned by this call and safe to pass to Codama's builder. */
+/** A mutable table shape, owned by this call and safe to pass to Codama's builder. */
 function cloneTiers(tiers) {
 	return tiers.map(({ multiplierBps, tickets }) => ({
 		multiplierBps,
@@ -1395,67 +1072,25 @@ function cloneTiers(tiers) {
 	}));
 }
 /**
-* Pump's quote silently caps at the curve's real token reserves, so a seed above them would look
-* cheap instead of failing. A fresh curve holds `Global.initialRealTokenReserves`
-* (793,100,000 tokens today), so a jackpot above about 794x of a 1,000,000-token pack cannot be
-* seeded. This throws before any buy is attempted.
+* The curve sells `LAUNCH_TOTAL_BASE_SELL` coins in total, so a seed above that cannot be bought at
+* any price. A buy for more than the curve has left is capped rather than refused, so it would look
+* cheap instead of failing. This throws before any transaction is built.
 */
-async function assertSeedFitsFreshCurve(client, seed) {
-	if (seed === 0n) return;
-	const { value } = await client.rpc.getAccountInfo(PUMP_GLOBAL, {
-		encoding: "base64",
-		commitment: "confirmed"
-	}).send();
-	if (!value) throw new Error(`Pump's Global account is missing at ${PUMP_GLOBAL}`);
-	const global = decodePumpGlobal(new Uint8Array(getBase64Encoder().encode(value.data[0])));
-	if (seed > global.initialRealTokenReserves) throw new Error(`the seed (${seed} tokens) is bigger than a fresh Pump curve holds (${global.initialRealTokenReserves} tokens); this table's top tier cannot be seeded on a new coin`);
-}
-/**
-* The Pump buy accounts for the seed, built without reading the bonding curve.
-*
-* The curve does not exist yet — `create_v2` in the same transaction is what creates it — so
-* `resolveVenue` cannot be used here. Everything the account list needs is known anyway: the
-* creator vault follows from the `creator` argument that `create_v2` records on the curve, and the
-* two fee recipients come from `Global`.
-*/
-async function pumpSeedBuyAccounts(client, options) {
-	const { value } = await client.rpc.getAccountInfo(PUMP_GLOBAL, {
-		encoding: "base64",
-		commitment: "confirmed"
-	}).send();
-	if (!value) throw new Error(`Pump's Global account is missing at ${PUMP_GLOBAL}`);
-	const global = decodePumpGlobal(new Uint8Array(getBase64Encoder().encode(value.data[0])));
-	const recipients = [global.feeRecipient, ...global.feeRecipients];
-	const feeRecipient = recipients[options.feeRecipientIndex ?? randomIndex(recipients.length)];
-	const buyback = global.buybackFeeRecipients[options.buybackRecipientIndex ?? randomIndex(global.buybackFeeRecipients.length)];
-	if (!feeRecipient) throw new Error("Pump Global holds no fee recipient");
-	if (!buyback) throw new Error("Pump Global holds no buyback fee recipient");
-	return pumpBuyAccounts({
-		mint: options.mint,
-		user: options.user,
-		tokenProgram: PUMP_CREATE_TOKEN_PROGRAM_ADDRESS,
-		creator: options.user,
-		feeRecipient,
-		buybackFeeRecipient: buyback
-	});
+function assertSeedFitsCurve(seed) {
+	if (seed > 793100000000000n) throw new Error(`the seed (${seed} base units) is bigger than the whole curve sells (${LAUNCH_TOTAL_BASE_SELL}); this table's top tier cannot be seeded on a new coin`);
 }
-const randomIndex = (length) => {
-	if (length === 0) throw new Error("the list is empty");
-	return Math.floor(Math.random() * length);
-};
 //#endregion
 //#region src/tx/draw.ts
-/** A retry and an expiry are both small. The default budget is plenty. */
 const DRAW_COMPUTE_UNITS = 2e5;
 async function retryDraw(client, input) {
-	const retry = getRetryDrawInstruction({
+	const ix = await getRetryDrawInstruction({
 		payer: input.payer,
 		pool: input.pool,
 		draw: input.draw,
 		identity: await vrfIdentityAddress(),
 		maxVrfDebit: input.maxVrfDebit
 	});
-	return await buildMessage(client, input.payer, [retry], {
+	return await buildMessage(client, input.payer, [ix], {
 		addressLookupTables: input.addressLookupTables,
 		computeUnitLimit: input.computeUnitLimit ?? DRAW_COMPUTE_UNITS,
 		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
@@ -1463,295 +1098,94 @@ async function retryDraw(client, input) {
 }
 async function expireDraw(client, input) {
 	const draw = await fetchDraw(client, input.draw);
-	if (!draw) throw new Error(`no draw at ${input.draw}`);
-	if (draw.pool !== input.pool) throw new Error(`draw ${input.draw} does not belong to ${input.pool}`);
+	if (!draw || draw.pool !== input.pool) throw new Error("draw does not belong to pool or was already delivered");
 	const pool = await fetchPoolAt(client, input.pool);
 	if (!pool) throw new Error(`no pool at ${input.pool}`);
-	const expire = getExpireDrawInstruction({
+	const ix = getExpireDrawInstruction({
 		pool: input.pool,
 		draw: input.draw,
 		purchaser: draw.purchaser,
 		mint: pool.mint,
 		vault: pool.vault,
-		userTokens: await associatedTokenAddress(draw.purchaser, pool.mint, pool.tokenProgram),
-		tokenProgram: pool.tokenProgram
+		userTokens: await associatedTokenAddress(draw.purchaser, pool.mint)
 	});
-	return await buildMessage(client, input.payer, [expire], {
+	return await buildMessage(client, input.payer, [ix], {
 		addressLookupTables: input.addressLookupTables,
 		computeUnitLimit: input.computeUnitLimit ?? DRAW_COMPUTE_UNITS,
 		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
 	});
 }
-/**
-* What a client may do to a draw right now.
-*
-* Reads the draw and the current slot, and reproduces the program's three retry conditions and the
-* pending-status-plus-deadline expiry conditions. Showing a disabled button with a countdown beats
-* sending a transaction that fails with `RetryTooSoon` or `NotPending`.
-*/
-async function drawAvailability(client, draw) {
-	const record = await fetchDraw(client, draw);
-	if (!record) return null;
-	const slot = await client.rpc.getSlot({ commitment: "confirmed" }).send();
-	const now = BigInt(slot);
-	const retryAt = record.lastAttemptSlot + RETRY_SLOTS;
-	const expireAt = record.requestSlot + TIMEOUT_SLOTS;
+async function drawAvailability(client, address) {
+	const draw = await fetchDraw(client, address);
+	if (!draw) return null;
+	const now = BigInt(await client.rpc.getSlot({ commitment: "confirmed" }).send());
+	const retryAt = draw.lastAttemptSlot + RETRY_SLOTS;
+	const expireAt = draw.requestSlot + TIMEOUT_SLOTS;
 	const slotsUntilRetry = now >= retryAt ? 0n : retryAt - now;
 	const slotsUntilExpiry = now >= expireAt ? 0n : expireAt - now;
-	const pending = record.status === 0;
 	return {
-		status: record.status,
-		attempts: record.attempts,
+		attempts: draw.attempts,
 		slotsUntilRetry,
 		slotsUntilExpiry,
-		canRetry: pending && slotsUntilRetry === 0n && record.attempts < 3 && slotsUntilExpiry > 0n,
-		canExpire: pending && slotsUntilExpiry === 0n
+		canRetry: draw.attempts < 3 && slotsUntilRetry === 0n && slotsUntilExpiry > 0n,
+		canExpire: slotsUntilExpiry === 0n
 	};
 }
 //#endregion
 //#region src/tx/fundPrizes.ts
-/**
-* Donating prize inventory.
-*
-* `fund_prizes` moves tokens from any wallet into the pool's vault. It is a donation and it is
-* irrevocable: there is no withdrawal instruction, and no authority can move vault tokens. The only
-* way out of the vault is prize delivery.
-*
-* Funding raises what later packs can pay. It does not change the tiers, which are immutable, and
-* it does not change any draw that is already frozen — `math.quote` is computed at purchase time
-* and stored in the `Draw`.
-*/
 const FUND_COMPUTE_UNITS = 2e5;
-/** A venue buy plus the vault transfer. The buy is the expensive half. */
-const FUND_WITH_BUY_COMPUTE_UNITS = 4e5;
 async function fundPrizes(client, input) {
-	const { mint, funder, amount } = input;
-	if (amount <= 0n) throw new Error("amount must be positive");
-	const pool = await fetchPoolByMint(client, mint);
-	if (!pool) throw new Error(`no gabox pool for mint ${mint}`);
-	return await buildMessage(client, funder, [getFundPrizesInstruction({
-		funder,
-		pool: await poolAddress(mint),
-		mint,
-		source: input.source ?? await associatedTokenAddress(funder.address, mint, pool.tokenProgram),
+	if (input.amount <= 0n) throw new Error("amount must be positive");
+	const pool = await fetchPoolByMint(client, input.mint);
+	if (!pool) throw new Error(`no Gabox pool for mint ${input.mint}`);
+	const ix = getFundPrizesInstruction({
+		funder: input.funder,
+		pool: await poolAddress(input.mint),
+		mint: input.mint,
+		source: input.source ?? await associatedTokenAddress(input.funder.address, input.mint),
 		vault: pool.vault,
-		tokenProgram: pool.tokenProgram,
-		amount
-	})], {
-		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? FUND_COMPUTE_UNITS,
-		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
-	});
-}
-/**
-* Buy tokens at the venue with SOL and donate them to the vault, in one transaction.
-*
-* This is what a donor with SOL and no coins needs. `fundPrizes` moves tokens the donor already
-* holds; this one buys them first. Both are irrevocable — there is no withdrawal instruction, and
-* no authority can move vault tokens.
-*
-* Three instructions on the curve route: create the donor's token account if it is missing, buy,
-* donate. Pump creates the account itself, but the idempotent instruction costs nothing when it
-* already exists and it makes the transaction correct on its own terms. The PumpSwap route adds the
-* WSOL create/fund/sync prefix, for the same reason `buyPack` does: PumpSwap spends WSOL.
-*/
-async function fundPrizesWithBuy(client, input) {
-	const { mint, funder, tokens, maxQuoteIn } = input;
-	if (tokens <= 0n) throw new Error("tokens must be positive");
-	if (maxQuoteIn <= 0n) throw new Error("maxQuoteIn must be positive");
-	const pool = await fetchPoolByMint(client, mint);
-	if (!pool) throw new Error(`no gabox pool for mint ${mint}`);
-	const venue = await resolveVenue(client, {
-		mint,
-		user: funder.address,
-		...input.venue ? { venue: input.venue } : {}
+		amount: input.amount
 	});
-	const source = await associatedTokenAddress(funder.address, mint, pool.tokenProgram);
-	return await buildMessage(client, funder, [
-		...venue.kind === "pumpswap" ? wsolPreparation$1(funder, input.wrapLamports ?? maxQuoteIn) : [],
-		getCreateAssociatedTokenIdempotentInstruction({
-			payer: funder,
-			ata: source,
-			owner: funder.address,
-			mint,
-			tokenProgram: pool.tokenProgram
-		}),
-		venueBuyInstruction({
-			venue,
-			user: funder,
-			tokens,
-			maxQuoteIn
-		}),
-		getFundPrizesInstruction({
-			funder,
-			pool: await poolAddress(mint),
-			mint,
-			source,
-			vault: pool.vault,
-			tokenProgram: pool.tokenProgram,
-			amount: tokens
-		})
-	], {
+	return await buildMessage(client, input.funder, [ix], {
 		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? FUND_WITH_BUY_COMPUTE_UNITS,
+		computeUnitLimit: input.computeUnitLimit ?? FUND_COMPUTE_UNITS,
 		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
 	});
 }
-/** Create the donor's WSOL account if needed, fund it, and sync its balance. See `buyPack.ts`. */
-function wsolPreparation$1(funder, lamports) {
-	const wsol = wsolAccountFor(funder.address);
-	return [
-		getCreateAssociatedTokenIdempotentInstruction({
-			payer: funder,
-			ata: wsol,
-			owner: funder.address,
-			mint: WSOL_MINT,
-			tokenProgram: TOKEN_PROGRAM_ADDRESS$1
-		}),
-		getTransferSolInstruction({
-			source: funder,
-			destination: wsol,
-			amount: lamports
-		}),
-		getSyncNativeInstruction({ account: wsol })
-	];
-}
 //#endregion
 //#region src/tx/redeem.ts
-/**
-* Selling an automatically delivered prize, plus settlement helpers for legacy resolve-only draws.
-*
-* Every sale here goes through the program (`sell_tokens` or `sell_prize`), which does the venue
-* CPI and then pays the protocol 1% of what the sale returned. On Pump the proceeds and the fee are
-* native SOL. On PumpSwap both are WSOL: the proceeds land in the seller's WSOL account and the fee
-* moves from there to the collector's WSOL account. Add an unwrap afterwards if the seller wants
-* lamports.
-*
-* `minQuoteOutput` is the venue's own floor, checked before the fee. The seller keeps 99% of
-* whatever the venue paid above it.
-*/
-/**
-* Sell a prize that the VRF callback already delivered to the wallet, through `sell_tokens`.
-*
-* The program needs the coin's pool: it keeps the vault out of the venue's account list. A mint
-* with no pool cannot be sold this way; use a plain venue trade for that.
-*/
 async function sellTokens(client, input) {
-	const { mint, seller, amount, minQuoteOutput } = input;
-	if (amount <= 0n) throw new Error("amount must be positive");
-	if (minQuoteOutput <= 0n) throw new Error("minQuoteOutput must be positive");
-	const pool = await fetchPoolByMint(client, mint);
-	if (!pool) throw new Error(`no gabox pool for mint ${mint}`);
+	if (input.amount <= 0n || input.minQuoteOutput <= 0n) throw new Error("amount and minQuoteOutput must be positive");
+	if (input.maxNativeDebit < 0n) throw new Error("maxNativeDebit must not be negative");
+	const pool = await fetchPoolByMint(client, input.mint);
+	if (!pool) throw new Error(`no Gabox pool for mint ${input.mint}`);
 	const venue = await resolveVenue(client, {
-		mint,
-		user: seller.address,
+		mint: input.mint,
+		user: input.seller.address,
 		...input.venue ? { venue: input.venue } : {}
 	});
-	const sell = getSellTokensInstruction({
-		seller,
-		pool: await poolAddress(mint),
-		mint,
-		userTokens: await associatedTokenAddress(seller.address, mint, pool.tokenProgram),
+	const sell = await getSellTokensInstructionAsync({
+		seller: input.seller,
+		pool: await poolAddress(input.mint),
+		mint: input.mint,
+		quoteMint: pool.quoteMint,
 		venue: venue.program,
-		feeCollectorWsol: await feeCollectorWsolAddress(),
-		tokenProgram: pool.tokenProgram,
-		amount,
-		minQuoteOutput
-	});
-	return await buildMessage(client, seller, [...wsolPreparation(seller, venue), withRemainingAccounts(sell, venue.sellAccounts)], {
-		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? 3e5,
-		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+		amount: input.amount,
+		minQuoteOutput: input.minQuoteOutput,
+		maxNativeDebit: input.maxNativeDebit
 	});
-}
-/** Transfer a legacy resolve-only award into the purchaser's token account and close the draw. */
-async function claimPrize(client, input) {
-	const { mint, purchaser, draw } = input;
-	const pool = await fetchPoolByMint(client, mint);
-	if (!pool) throw new Error(`no gabox pool for mint ${mint}`);
-	return await buildMessage(client, purchaser, [getClaimPrizeInstruction({
-		purchaser,
-		pool: await poolAddress(mint),
-		draw,
-		mint,
-		vault: pool.vault,
-		userTokens: await associatedTokenAddress(purchaser.address, mint, pool.tokenProgram),
-		tokenProgram: pool.tokenProgram
-	})], {
-		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? 3e5,
-		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
-	});
-}
-/**
-* Claim and sell a legacy resolve-only draw in one transaction.
-*
-* The award is read off the draw so the caller can price the sale before signing. A draw that has
-* not resolved has no award yet, and this throws rather than building a sale of zero tokens.
-*/
-async function sellPrize(client, input) {
-	const { mint, purchaser, draw, minQuoteOutput } = input;
-	if (minQuoteOutput <= 0n) throw new Error("minQuoteOutput must be positive");
-	const pool = await fetchPoolByMint(client, mint);
-	if (!pool) throw new Error(`no gabox pool for mint ${mint}`);
-	const record = await fetchDraw(client, draw);
-	if (!record) throw new Error(`no draw at ${draw} — it may already be redeemed`);
-	if (record.amount === 0n) throw new Error(`draw ${draw} has no award yet; it has not resolved`);
-	const venue = await resolveVenue(client, {
-		mint,
-		user: purchaser.address,
-		...input.venue ? { venue: input.venue } : {}
-	});
-	const sell = getSellPrizeInstruction({
-		purchaser,
-		pool: await poolAddress(mint),
-		draw,
-		mint,
-		vault: pool.vault,
-		userTokens: await associatedTokenAddress(purchaser.address, mint, pool.tokenProgram),
-		tokenProgram: pool.tokenProgram,
-		venue: venue.program,
-		feeCollectorWsol: await feeCollectorWsolAddress(),
-		minQuoteOutput
-	});
-	return await buildMessage(client, purchaser, [...wsolPreparation(purchaser, venue), withRemainingAccounts(sell, venue.sellAccounts)], {
+	const wsol = await fundWsol(input.seller, 0n);
+	const instructions = [
+		...wsol.instructions,
+		withRemainingAccounts(sell, venue.sellAccounts),
+		unwrapWsol(input.seller, wsol.account)
+	];
+	return await buildMessage(client, input.seller, instructions, {
 		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? 3e5,
+		computeUnitLimit: input.computeUnitLimit ?? 135e3,
 		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
 	});
 }
-/**
-* On PumpSwap the proceeds land in the seller's WSOL account, so it has to exist before the sale.
-* Pump's own SDK does the same before its sells. The instruction is idempotent and the account is
-* the seller's own; gabox never touches it. Pump pays native SOL, so the curve route adds nothing.
-*/
-function wsolPreparation(seller, venue) {
-	if (venue.kind !== "pumpswap") return [];
-	return [getCreateAssociatedTokenIdempotentInstruction({
-		payer: seller,
-		ata: wsolAccountFor(seller.address),
-		owner: seller.address,
-		mint: WSOL_MINT,
-		tokenProgram: TOKEN_PROGRAM_ADDRESS$1
-	})];
-}
-/**
-* Quote the award held by a legacy open draw before the seller signs a floor.
-*
-* Read the draw, ask the venue, and subtract your own slippage tolerance to get `minQuoteOutput`.
-*/
-async function quoteSellPrize(client, mint, draw, user) {
-	const record = await fetchDraw(client, draw);
-	if (!record) throw new Error(`no draw at ${draw}`);
-	const venue = await resolveVenue(client, {
-		mint,
-		user
-	});
-	return {
-		award: record.amount,
-		grossOutput: venue.quoteSell(record.amount)
-	};
-}
 //#endregion
 //#region src/vrf.ts
 /**
@@ -1770,6 +1204,6 @@ async function oracleAccounts() {
 	};
 }
 //#endregion
-export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BIND_REFERRER_COMPUTE_UNITS, BPS, BUY_PACK_COMPUTE_UNITS, CLUSTER_ENDPOINTS, COMPUTE_BUDGET_PROGRAM_ADDRESS, CREATE_MACHINE_COMPUTE_UNITS, DEFAULT_COMPUTE_UNIT_LIMIT, DEFAULT_TIERS, DEVNET_ADDRESS_LOOKUP_TABLES, DEVNET_HTTP, DEVNET_LOOKUP_TABLE_ADDRESS, DEVNET_LOOKUP_TABLE_ADDRESSES, DEVNET_WS, DRAW_DISCRIMINATOR, DRAW_POOL_OFFSET, DRAW_PURCHASER_OFFSET, GABOX_PROGRAM_ID, GaboxMathError, IDENTITY_SEED, INSTRUCTIONS_SYSVAR, MAX_ATTEMPTS, MAX_COMPUTE_UNIT_LIMIT, MAX_FEE_BPS, MAYHEM_PROGRAM_ADDRESS, PACK_TOKENS, POOL_CREATOR_OFFSET, POOL_DISCRIMINATOR, POOL_MINT_OFFSET, PROTOCOL_FEE_BPS, PROTOCOL_FEE_COLLECTOR, PUMP_FEE_PROGRAM_ADDRESS, PUMP_PROGRAM_ADDRESS, PUMP_SWAP_PROGRAM_ADDRESS, REDEEM_COMPUTE_UNITS, REFERRAL_FEE_BPS, REFERRAL_LINK_REFERRER_OFFSET, RETRY_SLOTS, SLOT_HASHES_SYSVAR, SYSTEM_PROGRAM_ADDRESS, TICKETS, TIERS, TIMEOUT_SLOTS, TOKEN_2022_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, VRF_DEFAULT_QUEUE, VRF_PROGRAM_ADDRESS, WSOL_MINT, assertClusterUrl, associatedTokenAddress, averageMultiplierBps, bindReferrer, buildMessage, buyPack, choose, claimPrize, claimReferral, clusterNamedBy, computeBudgetInstructions, createClient, createMachine, decodeDraw, decodeEvent, decodeEvents, decodePool, defaultAddressLookupTables, drawAddress, drawAvailability, expireDraw, feeCollectorWsolAddress, fetchDraw, fetchEvents, fetchPoolAt, fetchPoolByMint, fetchPoolInventory, fetchReferralReward, fetchVaultBalance, findDrawPda, findIdentityPda, findPoolPda, findReferralLinkPda, fundPrizes, fundPrizesWithBuy, generated_exports as generated, getOffer, getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, listDraws, listDrawsByPool, listDrawsByPurchaser, listPools, listReferralLinksByReferrer, maxMultiplierBps, offerFor, offerFromState, oracleAccounts, poolAddress, pump_exports as pump, pumpSeedBuyAccounts, quote, quoteSellPrize, referralAddress, referralLinkAddress, resolveReferral, resolveReservation, retryDraw, scopedVrfIdentityAddress, seedCostEstimate, seedShortfall, seedTokens, sellPrize, sellTokens, share, tierAmount, tiersOf, uncappedMaximum, validatePack, validateTiers, vaultAddress, vrfIdentityAddress, watchDraw, websocketUrlFor, withRemainingAccounts };
+export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BPS, BUY_PACK_COMPUTE_UNITS, CLAIM_COMPUTE_UNITS, CLUSTER_ENDPOINTS, COMPUTE_BUDGET_PROGRAM_ADDRESS, CREATE_MACHINE_COMPUTE_UNITS, DEFAULT_COMPUTE_UNIT_LIMIT, DEFAULT_TIERS, DEVNET_ADDRESS_LOOKUP_TABLES, DEVNET_HTTP, DEVNET_LOOKUP_TABLE_ADDRESS, DEVNET_LOOKUP_TABLE_ADDRESSES, DEVNET_WS, DRAW_DISCRIMINATOR, DRAW_POOL_OFFSET, DRAW_PURCHASER_OFFSET, GABOX_PROGRAM_ID, GaboxMathError, IDENTITY_SEED, INSTRUCTIONS_SYSVAR, LAUNCH_DECIMALS, MAX_ATTEMPTS, MAX_COMPUTE_UNIT_LIMIT, MAX_MULTIPLIER_BPS, METAPLEX_PROGRAM_ADDRESS, MIN_SEED_MULTIPLIER_BPS, PACK_TOKENS, PLATFORM_ADMIN, POOL_CREATOR_OFFSET, POOL_DISCRIMINATOR, POOL_MINT_OFFSET, REDEEM_COMPUTE_UNITS, RETRY_SLOTS, SLOT_HASHES_SYSVAR, SYSTEM_PROGRAM_ADDRESS, TICKETS, TIERS, TIMEOUT_SLOTS, TOKEN_PROGRAM_ADDRESS, VRF_DEFAULT_QUEUE, VRF_PROGRAM_ADDRESS, WALLET_ACTIVITY_DISCRIMINATOR, WSOL_MINT, activityAddress, assertClusterUrl, associatedTokenAddress, averageMultiplierBps, buildMessage, buyPack, choose, clusterNamedBy, computeBudgetInstructions, createClient, createMachine, decodeDraw, decodeEvent, decodeEvents, decodePool, decodeWalletActivity, defaultAddressLookupTables, drawAddress, drawAvailability, expireDraw, fetchDraw, fetchEvents, fetchPoolAt, fetchPoolByMint, fetchPoolInventory, fetchVaultBalance, fetchWalletActivity, findActivityPda, findDrawPda, findIdentityPda, findPoolPda, findResolvedDraw, fundPrizes, fundWsol, generated_exports as generated, getOffer, getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, listDraws, listDrawsByPool, listDrawsByPurchaser, listPools, maxMultiplierBps, offerFromState, oracleAccounts, poolAddress, quote, quotePool, raydium_exports as raydium, resolveReservation, retryDraw, scopedVrfIdentityAddress, seedCostEstimate, seedShortfall, seedTokens, sellTokens, tierAmount, tiersOf, uncappedMaximum, unwrapWsol, validatePack, validateTiers, vaultAddress, vrfIdentityAddress, websocketUrlFor, withRemainingAccounts };
 
 //# sourceMappingURL=index.js.map