@gabox-labs/sdk 0.2.0 → 0.7.0

package/dist/index.js

@@ -1,844 +1,141 @@
-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 { Dt as POOL_DISCRIMINATOR, I as getFundPrizesInstruction, Ot as decodePool, Rt as DRAW_DISCRIMINATOR, W as getExpireDrawInstruction, _t as decodeWalletActivity, b as getRetryDrawInstruction, ft as findPoolPda, gt as WALLET_ACTIVITY_DISCRIMINATOR, ht as findActivityPda, k as getInitializePoolInstructionAsync, mt as findDrawPda, p as getSellTokensInstructionAsync, pt as findIdentityPda, st as getBuyPackInstructionAsync, zt as decodeDraw } from "./gabox-DGTCh34U.js";
+import { $ as computeBudgetInstructions, $t as launchlabVaultAddress, B as fetchQuoteAsset, Bt as vaultAddress, Cn as PACK_TOKENS, Dn as VRF_DEFAULT_QUEUE, E as cpmmSwapBaseOutput, En as TIMEOUT_SLOTS, Et as decodeCpmmPool, Ft as activityAddress, G as readAccounts, H as fetchQuoteDisplay, Ht as ata, I as launchlabBuyAccounts, In as LAUNCH_DECIMALS, It as associatedTokenAddress, J as COMPUTE_BUDGET_PROGRAM_ADDRESS, K as BUY_PACK_COMPUTE_UNITS, Kn as ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Kt as creatorFeeVaultAddress, Lt as drawAddress, Nt as tokenAccountAmount, O as curveBuyExactOut, On as VRF_PROGRAM_ADDRESS, Q as REDEEM_COMPUTE_UNITS, Qt as launchlabPoolAddress, Rt as poolAddress, S as wsolAccountFor, Sn as MAX_ATTEMPTS, T as cpmmSwapBaseInput, Tn as SLOT_HASHES_SYSVAR, Tt as decodeCpmmAmmConfig, Vt as vrfIdentityAddress, Wn as raydiumIds, X as DEFAULT_COMPUTE_UNIT_LIMIT, Xn as CPMM_SWAP_BASE_INPUT, Y as CREATE_MACHINE_COMPUTE_UNITS, Z as MAX_COMPUTE_UNIT_LIMIT, Zn as CPMM_SWAP_BASE_OUTPUT, _n as validatePack, _t as tiersOf, an as MAX_MULTIPLIER_BPS, at as POOL_MINT_OFFSET, b as resolveVenue, bn as IDENTITY_SEED, c as getLaunchInstruction, cn as TIERS, cr as METAPLEX_PROGRAM_ADDRESS, ct as fetchPoolByMint, dn as maxMultiplierBps, dt as fetchWalletActivity, et as getSetComputeUnitLimitInstruction, f as creatorFeeOnInput, fn as quote, ft as listDraws, gn as uncappedMaximum, gr as WSOL_MINT, gt as quotePool, hn as tierAmount, hr as TOKEN_PROGRAM_ADDRESS, ht as listPools, in as GaboxMathError, it as POOL_CREATOR_OFFSET, l as buildMessage, ln as averageMultiplierBps, lr as PLATFORM_ADMIN, lt as fetchPoolInventory, m as fetchCurveSettings, mn as seedTokens, mt as listDrawsByPurchaser, nn as BPS, nt as DRAW_POOL_OFFSET, on as MIN_SEED_MULTIPLIER_BPS, ot as fetchDraw, pn as resolveReservation, pr as SYSTEM_PROGRAM_ADDRESS, pt as listDrawsByPool, q as CLAIM_COMPUTE_UNITS, rn as DEFAULT_TIERS, rt as DRAW_PURCHASER_OFFSET, sn as TICKETS, sr as LAUNCH_TOTAL_BASE_SELL, st as fetchPoolAt, t as raydium_exports, tn as platformFeeVaultAddress, tt as getSetComputeUnitPriceInstruction, u as withRemainingAccounts, un as choose, ut as fetchVaultBalance, v as newCurveReserves, vn as validateTiers, wn as RETRY_SLOTS, xn as INSTRUCTIONS_SYSVAR, y as quoteAccountFor, yn as GABOX_PROGRAM_ID, z as order, zt as scopedVrfIdentityAddress } from "./raydium-CU-tZzIk.js";
+import { DRAW_RESOLVED_EVENT_DISCRIMINATOR, PACK_BOUGHT_EVENT_DISCRIMINATOR, POOL_CREATED_EVENT_DISCRIMINATOR, PRIZES_FUNDED_EVENT_DISCRIMINATOR, RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR, TOKENS_SOLD_EVENT_DISCRIMINATOR, getDrawResolvedEventDecoder, getPackBoughtEventDecoder, getPoolCreatedEventDecoder, getPrizesFundedEventDecoder, getRandomnessRetriedEventDecoder, getTokensSoldEventDecoder, t as generated_exports } from "./generated/index.js";
+import { AccountRole, address, createNoopSigner, createSolanaRpc, createSolanaRpcSubscriptions, getAddressDecoder, getBase64Encoder, getU64Encoder } from "@solana/kit";
+import { getCloseAccountInstruction, getCreateAssociatedTokenIdempotentInstruction, getSyncNativeInstruction } from "@solana-program/token";
 import { getTransferSolInstruction } from "@solana-program/system";
-//#region src/math.ts
-/**
-* A bigint port of `programs/gabox-v2/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`.
-*
-* 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;
-}
-/** Ticket counts must sum to this. A uniform 16-bit word then maps with no modulo bias. */
-const TICKETS = 65536;
-/** The prize table has exactly this many slots. Unused slots are all-zero. */
-const TIERS = 8;
-/** Thrown by every function here. `code` matches a `GaboxError` variant name. */
-var GaboxMathError = class extends Error {
-	code;
-	constructor(code, message) {
-		super(`${code}: ${message}`);
-		this.name = "GaboxMathError";
-		this.code = code;
-	}
-};
-const U64_MAX = (1n << 64n) - 1n;
-const U32_MAX = 4294967295;
-/**
-* The default prize table. The program does not enforce this table: it accepts any table that
-* passes `validateTiers`. This is only the table the Gabox app creates its pools with, and the
-* starting point for a client that has no reason to pick another one.
-*
-* Common 75% at 0.52x, Rare 20% at 1.2x, Epic 4% at 3x, Mythic 1% at 20x. Expected payout is
-* 0.9499x of a pack, so the seed is 19 packs.
-*/
-const DEFAULT_TIERS = Object.freeze([
-	Object.freeze({
-		multiplierBps: 5201,
-		tickets: 49153
-	}),
-	Object.freeze({
-		multiplierBps: 12e3,
-		tickets: 13107
-	}),
-	Object.freeze({
-		multiplierBps: 3e4,
-		tickets: 2621
-	}),
-	Object.freeze({
-		multiplierBps: 2e5,
-		tickets: 655
-	}),
-	Object.freeze({
-		multiplierBps: 0,
-		tickets: 0
-	}),
-	Object.freeze({
-		multiplierBps: 0,
-		tickets: 0
-	}),
-	Object.freeze({
-		multiplierBps: 0,
-		tickets: 0
-	}),
-	Object.freeze({
-		multiplierBps: 0,
-		tickets: 0
-	})
-]);
-function checkedU64(value, what) {
-	if (value < 0n || value > U64_MAX) throw new GaboxMathError("Arithmetic", `${what} does not fit in u64`);
-	return value;
-}
-/** Tier fields encode as program `u32`s. Reject JavaScript-only values before `BigInt` or codecs. */
-function checkedU32(value, what) {
-	if (!Number.isInteger(value) || value < 0 || value > U32_MAX) throw new GaboxMathError("InvalidDistribution", `${what} must be an integer from 0 to ${U32_MAX}`);
-	return value;
-}
-/** `math::tokens`. Floor division, and an overflow past u64 is an error, not a wrap. */
-function tierAmount(base, multiplierBps) {
-	return checkedU64(base * BigInt(checkedU32(multiplierBps, "multiplierBps")) / BPS, "tier amount");
-}
-/**
-* `math::validate`. Checks the table alone, with no base.
-*
-* Three 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;
-*   - the expected multiplier over all tickets is at most 1x, so the table cannot promise more
-*     tokens than a pack buys. This bounds tokens, not cash value.
-*/
-function validateTiers(tiers) {
-	if (tiers.length !== 8) throw new GaboxMathError("InvalidDistribution", `expected 8 tiers, got ${tiers.length}`);
-	let count = 0n;
-	let expected = 0n;
-	for (const [index, tier] of tiers.entries()) {
-		checkedU32(tier.tickets, `tier ${index} tickets`);
-		checkedU32(tier.multiplierBps, `tier ${index} multiplierBps`);
-		if (tier.tickets === 0) {
-			if (tier.multiplierBps !== 0) throw new GaboxMathError("InvalidDistribution", "a tier with no tickets must have no multiplier");
-			continue;
-		}
-		if (tier.multiplierBps <= 0) throw new GaboxMathError("InvalidDistribution", "a ticketed tier must pay something; it would sell a ticket that can only win zero");
-		count += BigInt(tier.tickets);
-		expected += BigInt(tier.multiplierBps) * BigInt(tier.tickets);
-	}
-	if (count !== BigInt(65536)) throw new GaboxMathError("InvalidDistribution", `tickets must sum to ${TICKETS}, they sum to ${count}`);
-	if (expected > 10000n * BigInt(65536)) throw new GaboxMathError("UnfundedExpectation", "the expected token award exceeds the tokens a pack buys");
-}
-/**
-* `math::validate_pack`. Every ticketed tier must pay at least one token for a pack of this size.
-*
-* The program checks this once at creation. At `PACK_TOKENS` no sane table fails it; it exists so
-* a table cannot sell a ticket that can only win zero.
-*/
-function validatePack(packTokens, tiers) {
-	if (packTokens <= 0n) throw new GaboxMathError("ZeroAmount", "packTokens must be positive");
-	checkedU64(packTokens, "pack tokens");
-	validateTiers(tiers);
-	for (const [i, tier] of tiers.entries()) {
-		if (tier.tickets === 0) continue;
-		if (tierAmount(packTokens, tier.multiplierBps) === 0n) throw new GaboxMathError("PackTooSmall", `tier ${i} rounds to zero tokens at this pack size`);
-	}
-}
-/**
-* `math::seed_tokens`. The 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:
-*
-*     seedTokens = uncappedMaximum(packTokens, tiers) - 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.
-*
-* `initialize_pool` 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;
-}
-/**
-* `math::uncapped_maximum`. The largest tier's award for this base, before any inventory cap.
-*
-* At `packTokens` this is the jackpot in tokens. `seedTokens` is this minus one pack.
-*/
-function uncappedMaximum(base, tiers) {
-	validateTiers(tiers);
-	let largest = 0n;
-	for (const tier of tiers) {
-		if (tier.tickets === 0) continue;
-		const amount = tierAmount(base, tier.multiplierBps);
-		if (amount > largest) largest = amount;
-	}
-	return largest;
-}
-/**
-* `math::quote`. The offer a pack of `base` tokens would freeze right now. `base` is always
-* `pool.packTokens`; the parameter stays general so the vectors can use small numbers.
-*
-* `inventory` is the vault's token balance and `reserved` is `pool.reserved`. The difference is
-* free inventory. This pack's own `base` is added to it, because the purchase and the offer are
-* one transaction — the tokens are in the vault before the draw is written.
-*
-* Every amount is capped at what is actually available. A tier that rounds to zero tokens is an
-* error: the pool must not sell a ticket that can only win nothing.
-*/
-function quote(base, tiers, inventory, reserved) {
-	validateTiers(tiers);
-	if (inventory < reserved) throw new GaboxMathError("InsolventInventory", "the vault holds less than the pool has already reserved");
-	const available = checkedU64(inventory - reserved + base, "available inventory");
-	const prizes = Array.from({ length: 8 }, () => ({
-		amount: 0n,
-		tickets: 0
-	}));
-	let maximum = 0n;
-	let minimum = U64_MAX;
-	for (const [i, tier] of tiers.entries()) {
-		if (tier.tickets === 0) continue;
-		const uncapped = tierAmount(base, tier.multiplierBps);
-		if (uncapped === 0n) throw new GaboxMathError("PackTooSmall", `tier ${i} rounds to zero tokens at this pack size`);
-		const amount = uncapped < available ? uncapped : available;
-		prizes[i] = {
-			amount,
-			tickets: tier.tickets
-		};
-		if (amount > maximum) maximum = amount;
-		if (amount < minimum) minimum = amount;
-	}
-	return {
-		prizes,
-		maximum,
-		minimum
-	};
-}
-/**
-* `math::choose`. Which prize a 16-bit ticket wins.
-*
-* The rows are consecutive ranges in table order, so this is a running total and a comparison.
-* A ticket past the last row returns `0`, which cannot happen for a validated table.
-*/
-function choose(prizes, ticket) {
-	let end = 0;
-	for (const prize of prizes) {
-		end += prize.tickets;
-		if (ticket < end) return prize.amount;
-	}
-	return 0n;
-}
-/** `math::resolve_reservation`. Release the unwon part of a maximum, keep the award reserved. */
-function resolveReservation(reserved, maximum, award) {
-	if (award > maximum) throw new GaboxMathError("InsolventInventory", "the award exceeds the reserved maximum");
-	if (reserved < maximum) throw new GaboxMathError("Arithmetic", "the pool has reserved less than this draw holds");
-	return checkedU64(reserved - maximum + award, "reserved");
-}
-/** The largest `multiplierBps` on any ticketed row. `0` for a table with no rows. */
-function maxMultiplierBps(tiers) {
-	validateTiers(tiers);
-	let largest = 0;
-	for (const tier of tiers) {
-		if (tier.tickets === 0) continue;
-		if (tier.multiplierBps > largest) largest = tier.multiplierBps;
-	}
-	return largest;
-}
-/**
-* The expected multiplier over all 65,536 tickets, in basis points. Rounded down.
-*
-* `validateTiers` caps this at 10,000. A table at 9,800 keeps 2% of every pack's tokens in the
-* vault on average, which is what lets a pool survive a run of top-tier wins.
-*/
-function averageMultiplierBps(tiers) {
-	validateTiers(tiers);
-	let weighted = 0n;
-	for (const tier of tiers) {
-		if (tier.tickets === 0) continue;
-		weighted += BigInt(tier.multiplierBps) * BigInt(tier.tickets);
-	}
-	return Number(weighted / BigInt(TICKETS));
-}
-//#endregion
-//#region src/pdas.ts
-/**
-* Every program-derived address a client needs.
-*
-* 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.
-*/
-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);
-}
-//#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.
-*/
-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 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,
-	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.`);
-	return decodePool(account).data;
-}
-/** A draw by address, or `null`. Delivered and legacy-claimed draws are closed. */
-async function fetchDraw(client, address) {
-	const account = await fetchMaybeDraw(client.rpc, address, { commitment: "confirmed" });
-	return account.exists ? account.data : null;
-}
-/** 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;
-}
-/**
-* 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.
-*/
-async function listPools(client) {
-	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))];
-	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 }) => ({
-		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 { 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])));
-}
-/**
-* 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;
-	return {
-		pool,
-		poolAddress: address,
-		vault: pool.vault,
-		inventory,
-		reserved,
-		free: inventory >= reserved ? inventory - 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
-}));
-/**
-* 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;
-}
-//#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 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 event = decodeEvent(bytes);
-		if (event) events.push(event);
+		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-18T11:04:06.369Z.
 * 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 +214,54 @@ 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"),
+	address("USDCoctVLVnvTXBEuP9s8hntucdJokbo17RwHuNXemT"),
+	address("4wHbNkobu7iARU9MbCEqDSAq6JuQreGupG2Jsf2R3DFP"),
+	address("5Eu2G2USTy1pqphmQzQ2SBXWrBq5sdhgEh7hso9R2xix"),
+	address("A9qBhPy4k5UYW72hSgAkh1Epr2do69P54yzzcMV3yv6b"),
+	address("Aw93pmXP52u6WSW2HcafRxua1LDht5MZhhXaaR7qCjsN"),
+	address("CPLUA2NTYSGjsB1E9iXT3MrPn69WRFJvKTdJZw5NdEjh"),
+	address("7LnqjXdqJEdccWZQs5YJobQ8MDmcK4sG2oo4Ty4LBC8c")
 ];
 const DEVNET_ADDRESS_LOOKUP_TABLES = { [DEVNET_LOOKUP_TABLE_ADDRESS]: [...DEVNET_LOOKUP_TABLE_ADDRESSES] };
 /**
@@ -931,67 +275,614 @@ const DEVNET_ADDRESS_LOOKUP_TABLES = { [DEVNET_LOOKUP_TABLE_ADDRESS]: [...DEVNET
 function defaultAddressLookupTables(cluster) {
 	return cluster === "devnet" ? { ...DEVNET_ADDRESS_LOOKUP_TABLES } : {};
 }
+/** The address lookup table program. It owns every table account. */
+const LOOKUP_TABLE_PROGRAM = address("AddressLookupTab1e1111111111111111111111111");
+/**
+* The fixed part of a table account, before its addresses: a 4-byte discriminator, the two slot
+* fields, the start index, the optional authority, and two padding bytes.
+*/
+const LOOKUP_TABLE_HEADER = 56;
+/**
+* Read lookup tables off chain by address, for compressing against tables this SDK does not pin.
+*
+* A router picks its own tables per quote, so their contents are only known at run time, and a
+* message can only be compressed against a table whose addresses are loaded. An address with no
+* account, a wrong owner, or a malformed body is skipped rather than failing the whole route: the
+* message then carries those accounts in full, which is correct, only larger.
+*/
+async function fetchAddressLookupTables(client, addresses) {
+	const wanted = [...new Set(addresses)];
+	if (wanted.length === 0) return {};
+	const { value } = await client.rpc.getMultipleAccounts(wanted, {
+		encoding: "base64",
+		commitment: "confirmed"
+	}).send();
+	const decoder = getAddressDecoder();
+	const tables = {};
+	for (const [index, account] of value.entries()) {
+		if (!account || account.owner !== LOOKUP_TABLE_PROGRAM) continue;
+		const data = Buffer.from(account.data[0], "base64");
+		const body = data.length - LOOKUP_TABLE_HEADER;
+		if (body <= 0 || body % 32 !== 0) continue;
+		const stored = [];
+		for (let at = LOOKUP_TABLE_HEADER; at < data.length; at += 32) stored.push(decoder.decode(new Uint8Array(data.subarray(at, at + 32))));
+		tables[wanted[index]] = stored;
+	}
+	return tables;
+}
+//#endregion
+//#region src/route/leg.ts
+/**
+* The margin added to an exact-in fallback, in basis points.
+*
+* An exact-in quote prices one spend. The spend that buys the amount wanted is worked out from that
+* price, and the price moves against a larger spend, so the result is always a little short without
+* a margin. 1% is the same order as the slippage a caller already signs for on the pack itself.
+*/
+const EXACT_IN_MARGIN_BPS = 100n;
+/**
+* The first exact-in quote's size, in lamports, when a pair has no exact-out route.
+*
+* It exists only to learn a price, so it is small enough that its own impact on the route is
+* small, and large enough that a route quotes it at all. The real spend is worked out from the
+* price it returns and re-quoted.
+*/
+const PROBE_LAMPORTS = 100000000n;
+/** How many times the exact-in fallback re-quotes before it gives up. */
+const EXACT_IN_ATTEMPTS = 3;
+/**
+* A swap that leaves at least `amount` of `quoteMint` in the user's quote account, paid for in SOL.
+*
+* Exact-out when the pair has such a route, so the buyer spends only what the pack costs. Exact-in
+* otherwise, which overshoots on purpose: the leftover quote stays in the buyer's own account.
+*/
+async function routeQuoteIn(client, provider, input) {
+	const { quoteMint, amount, user } = input;
+	if (amount <= 0n) throw new Error("the quote amount to buy must be positive");
+	if (quoteMint === "So11111111111111111111111111111111111111112") throw new Error("a WSOL-quoted pool needs no route: the builders wrap SOL themselves");
+	try {
+		const route = await provider.exactOut(client, WSOL_MINT, quoteMint, amount, user);
+		if (route.outAmount < amount) throw new Error(`the exact-out route buys ${route.outAmount} of ${quoteMint}, which is below the ${amount} the pack costs`);
+		return route;
+	} catch (exactOutFailure) {
+		return await exactInFallback(client, provider, quoteMint, amount, user, exactOutFailure);
+	}
+}
+/**
+* Work out the SOL that buys `amount` of the quote at the exact-in price, then swap it.
+*
+* The first quote is a small probe, only to learn a price. Every later quote scales the last one by
+* what it actually returned, so an impact the probe did not show is corrected rather than guessed
+* at. Three quotes at most, and a route that still falls short is an error rather than a buy that
+* fails on chain.
+*/
+async function exactInFallback(client, provider, quoteMint, amount, user, exactOutFailure) {
+	let spend = PROBE_LAMPORTS;
+	let last;
+	for (let attempt = 0; attempt < EXACT_IN_ATTEMPTS; attempt++) {
+		let route;
+		try {
+			route = await provider.exactIn(client, WSOL_MINT, quoteMint, spend, user);
+		} catch (exactInFailure) {
+			throw new Error(`no route from SOL to ${quoteMint}. Exact-out failed with "${messageOf(exactOutFailure)}" and exact-in with "${messageOf(exactInFailure)}".`);
+		}
+		last = route;
+		if (route.outAmount >= amount) return route;
+		if (route.outAmount <= 0n) break;
+		const scaled = ceilDiv(route.inAmount * amount, route.outAmount);
+		const next = scaled + scaled * EXACT_IN_MARGIN_BPS / 10000n;
+		if (next <= spend) break;
+		spend = next;
+	}
+	throw new Error(`no route from SOL to ${quoteMint} buys ${amount}. The best exact-in quote returned ${last?.outAmount ?? 0n} for ${last?.inAmount ?? spend} lamports, and exact-out failed with "${messageOf(exactOutFailure)}".`);
+}
+/**
+* A swap that turns exactly `amount` of `quoteMint` into SOL.
+*
+* `sellTokens` uses it on the proceeds floor it already signs for, so the amount swapped is one the
+* sale is guaranteed to have produced. Anything the sale paid above that floor stays in the
+* seller's quote account.
+*/
+async function routeQuoteOut(client, provider, input) {
+	const { quoteMint, amount, user } = input;
+	if (amount <= 0n) throw new Error("the quote amount to sell must be positive");
+	if (quoteMint === "So11111111111111111111111111111111111111112") throw new Error("a WSOL-quoted pool needs no route: the builders unwrap SOL themselves");
+	return await provider.exactIn(client, quoteMint, WSOL_MINT, amount, user);
+}
+/**
+* Refuse a route that would touch Gabox state, or that does not settle in the account the program
+* binds.
+*
+* `forbidden` is every Gabox account the transaction itself uses, plus the Gabox program id.
+* `settlesIn` is the user's quote associated token account: the swap has to name it, because that
+* is where `buy_pack` measures the quote it spends and where `sell_tokens` measures the proceeds.
+*/
+function assertRouteIsSafe(route, expect) {
+	const forbidden = new Set(expect.forbidden);
+	let settles = false;
+	for (const instruction of route.instructions) {
+		if (forbidden.has(instruction.programAddress)) throw new Error(`the route calls ${instruction.programAddress}, which is a Gabox program or account. A route must never touch Gabox state.`);
+		for (const account of instruction.accounts ?? []) {
+			if (forbidden.has(account.address)) throw new Error(`the route names the Gabox account ${account.address}. A route must never touch Gabox state.`);
+			if (account.address === expect.settlesIn) settles = true;
+		}
+	}
+	if (!settles) throw new Error(`the route never names ${expect.settlesIn}, the quote account the program settles in. The swap would pay somewhere the buy cannot spend from.`);
+}
+/**
+* What `amount` of a quote token costs in SOL, through the client's route provider.
+*
+* `null` when the client has no provider, or when the provider has no exact-out route. A price is a
+* display, so a missing one is not an error. A WSOL amount is already SOL and comes back unchanged.
+*
+* No fallback to exact-in here on purpose: an exact-in price answers a different question, and a
+* display that silently swapped the two would be wrong rather than missing.
+*/
+async function solPriceOf(client, quoteMint, amount) {
+	if (quoteMint === "So11111111111111111111111111111111111111112") return amount;
+	if (!client.route || amount <= 0n) return null;
+	try {
+		return (await client.route.exactOut(client, WSOL_MINT, quoteMint, amount, quoteMint)).inAmount;
+	} catch {
+		return null;
+	}
+}
+/** `ceil(numerator / denominator)` for non-negative values. */
+function ceilDiv(numerator, denominator) {
+	return (numerator + denominator - 1n) / denominator;
+}
+const messageOf = (cause) => cause instanceof Error ? cause.message : String(cause);
 //#endregion
 //#region src/offer.ts
 /**
-* The full offer for one machine. Two round trips: the pool and its vault, then the venue.
+* The full offer for one machine. Three round trips: the pool and its vault, the venue, then the
+* quote mint and its metadata. A non-SOL pool adds one HTTP call to the route provider for
+* `solAmount`.
+*
+* Throws when the coin has no pool.
+*/
+async function getOffer(client, mint, options = {}) {
+	const inventory = await fetchPoolInventory(client, mint);
+	if (!inventory) throw new Error(`no gabox pool for mint ${mint}`);
+	const { pool } = inventory;
+	const venue = await resolveVenue(client, {
+		mint,
+		user: options.user ?? pool.creator,
+		quote: {
+			mint: pool.quoteMint,
+			config: pool.quoteConfig,
+			tokenProgram: pool.quoteTokenProgram
+		},
+		...options.venue ? { venue: options.venue } : {}
+	});
+	const quoteAmount = venue.quoteBuy(pool.packTokens);
+	const display = await fetchQuoteDisplay(client, pool.quoteMint);
+	return offerFromState(inventory, venue.kind, quoteAmount, {
+		quoteDecimals: display.decimals,
+		quoteSymbol: display.symbol,
+		solAmount: await solPriceOf(client, pool.quoteMint, quoteAmount)
+	});
+}
+/**
+* The same computation with the reads already done. Useful when a caller holds a `ResolvedVenue`
+* and wants to re-price without touching the network. `quoteAmount` is
+* `venue.quoteBuy(pool.packTokens)`.
+*
+* `display` is optional: a caller that only wants the prize numbers can leave it out, and the three
+* display fields then report the quote's own base units with no symbol and no SOL price.
+*/
+function offerFromState(inventory, venue, quoteAmount, display = {
+	quoteDecimals: 0,
+	quoteSymbol: null,
+	solAmount: null
+}) {
+	const { pool } = inventory;
+	const tiers = tiersOf(pool);
+	const offer = quote(pool.packTokens, tiers, inventory.inventory, inventory.reserved);
+	const uncapped = uncappedMaximum(pool.packTokens, tiers);
+	return {
+		mint: pool.mint,
+		pool: inventory.poolAddress,
+		packTokens: pool.packTokens,
+		quoteAmount,
+		quoteMint: pool.quoteMint,
+		quoteDecimals: display.quoteDecimals,
+		quoteSymbol: display.quoteSymbol,
+		solAmount: display.solAmount,
+		seedQuoteAmount: pool.seedQuoteAmount,
+		seedTokens: seedTokens(pool.packTokens, tiers),
+		venue,
+		prizes: offer.prizes,
+		maximum: offer.maximum,
+		minimum: offer.minimum,
+		uncapped,
+		inventory: inventory.inventory,
+		reserved: inventory.reserved,
+		free: inventory.free,
+		isFirstPack: pool.nextSeq === 0n,
+		isSeeded: offer.maximum === uncapped,
+		maxMultiplierBps: maxMultiplierBps(tiers),
+		averageMultiplierBps: averageMultiplierBps(tiers)
+	};
+}
+/**
+* How short of the top prize a pool is, in tokens. `0` when it pays the whole table.
+*
+* The pack brings its own `packTokens` into the vault before the offer is computed, so the vault
+* only has to hold `uncapped - packTokens` beforehand. Anything already reserved by another draw
+* does not count. A donation of this size through `fund_prizes` uncaps the top prize again.
+*/
+function seedShortfall(offer) {
+	const needed = offer.uncapped > offer.packTokens ? offer.uncapped - offer.packTokens : 0n;
+	return offer.free >= needed ? 0n : needed - offer.free;
+}
+//#endregion
+//#region src/route/cpmm.ts
+/**
+* A route provider backed by one Raydium CPMM pool.
+*
+* Jupiter does not serve devnet, so a devnet machine quoted in a test token needs a route this SDK
+* can build itself. Given a CPMM pool that holds the SOL/quote pair, this provider swaps through
+* it with the same two instructions Gabox already forwards for a graduated coin, priced with the
+* same bigint port of Raydium's math.
+*
+* It works anywhere such a pool exists, mainnet included. It is not a router: it uses the one pool
+* the caller names and nothing else.
+*
+* # Wrapping
+*
+* CPMM settles in WSOL, never in native SOL. So the route wraps the SOL it spends and closes the
+* WSOL account afterwards, exactly as Jupiter's `wrapAndUnwrapSol` does. A sale into SOL creates
+* the WSOL account, swaps into it, and closes it, which is what turns the proceeds into SOL.
+*
+* # No signer objects
+*
+* The user is an address, not a signer. Every signing slot is marked as a signer and left for the
+* fee payer to sign, the same way a Jupiter instruction arrives. The wallet paying for the Gabox
+* transaction is the same wallet, so its one signature covers all of them.
+*
+* That is not a shortcut, it is required. Kit refuses to sign a message that carries two distinct
+* signer objects for one address: `signTransactionMessageWithSigners` fails with "Multiple distinct
+* signers were identified for address". The token and system builders below only accept a signer,
+* so `withoutSigners` strips the object again and keeps the role.
+*/
+const u64 = getU64Encoder();
+/**
+* The slippage this provider signs for on a pool swap, in basis points. 1%, the same as the
+* Jupiter provider's default. It only widens the on-chain bound; the price itself is exact.
+*/
+const CPMM_ROUTE_SLIPPAGE_BPS = 100n;
+/**
+* The compute units one swap through this provider adds to a transaction.
+*
+* Measured on devnet on 2026-09-18 against one Raydium CPMM pool, as the difference from the same
+* builder with no route: `55,110` and `29,272` on `createMachine`, `21,488` and `52,980` on
+* `buyPack`, and `30,138` and `51,138` on `sellTokens`. The spread is wide because which token
+* accounts already exist changes from run to run, so this rounds up to the top of it.
+*
+* It is a safe figure here and nowhere else: this provider always uses exactly one pool. A router
+* that may pick several hops states its own number; see `JUPITER_DEFAULT_COMPUTE_UNITS`.
+*/
+const CPMM_ROUTE_COMPUTE_UNITS = 75e3;
+/**
+* Swap through one named Raydium CPMM pool.
+*
+* The pool must hold the pair the route asks for. On devnet the SOL/USDC-test pool with the most
+* liquidity is `5Eu2G2USTy1pqphmQzQ2SBXWrBq5sdhgEh7hso9R2xix`, under the fee tier
+* `A9qBhPy4k5UYW72hSgAkh1Epr2do69P54yzzcMV3yv6b`.
+*/
+function raydiumCpmmRoute(poolAddress) {
+	return {
+		exactOut: async (client, input, output, amount, user) => await swap(client, poolAddress, {
+			input,
+			output,
+			amount,
+			user,
+			mode: "exactOut"
+		}),
+		exactIn: async (client, input, output, amount, user) => await swap(client, poolAddress, {
+			input,
+			output,
+			amount,
+			user,
+			mode: "exactIn"
+		})
+	};
+}
+async function swap(client, poolAddress, request) {
+	const { input, output, amount, user, mode } = request;
+	if (amount <= 0n) throw new Error("the route amount must be positive");
+	const ids = raydiumIds(client.cluster);
+	const [poolAccount] = await readAccounts(client.rpc, [poolAddress]);
+	if (!poolAccount || poolAccount.owner !== ids.cpmm) throw new Error(`${poolAddress} is not a Raydium CPMM pool on ${client.cluster}`);
+	const pool = decodeCpmmPool(poolAccount.data);
+	const inputIsToken0 = pool.token0Mint === input;
+	if (!(inputIsToken0 ? pool.token1Mint === output : pool.token1Mint === input && pool.token0Mint === output)) throw new Error(`the CPMM pool at ${poolAddress} holds ${pool.token0Mint} and ${pool.token1Mint}, not ${input} and ${output}`);
+	const inputVault = inputIsToken0 ? pool.token0Vault : pool.token1Vault;
+	const outputVault = inputIsToken0 ? pool.token1Vault : pool.token0Vault;
+	const inputTokenProgram = inputIsToken0 ? pool.token0Program : pool.token1Program;
+	const outputTokenProgram = inputIsToken0 ? pool.token1Program : pool.token0Program;
+	const [configAccount, inputVaultAccount, outputVaultAccount] = await readAccounts(client.rpc, [
+		pool.ammConfig,
+		inputVault,
+		outputVault
+	]);
+	if (!configAccount) throw new Error(`the CPMM pool at ${poolAddress} names a fee tier that is not on chain`);
+	if (!inputVaultAccount || !outputVaultAccount) throw new Error(`the CPMM pool at ${poolAddress} has no reserve accounts`);
+	const config = decodeCpmmAmmConfig(configAccount.data);
+	const owed = (token0) => token0 ? pool.protocolFeesToken0 + pool.fundFeesToken0 + pool.creatorFeesToken0 : pool.protocolFeesToken1 + pool.fundFeesToken1 + pool.creatorFeesToken1;
+	const sides = {
+		inputReserve: tokenAccountAmount(inputVaultAccount.data) - owed(inputIsToken0),
+		outputReserve: tokenAccountAmount(outputVaultAccount.data) - owed(!inputIsToken0)
+	};
+	if (sides.inputReserve <= 0n || sides.outputReserve <= 0n) throw new Error(`the CPMM pool at ${poolAddress} has no tradable reserves`);
+	const rates = {
+		tradeFeeRate: config.tradeFeeRate,
+		creatorFeeRate: pool.enableCreatorFee ? config.creatorFeeRate : 0n,
+		creatorFeeOnInput: creatorFeeOnInput(pool, input)
+	};
+	const userInput = await ata(user, input, inputTokenProgram);
+	const userOutput = await ata(user, output, outputTokenProgram);
+	const abi = mode === "exactOut" ? CPMM_SWAP_BASE_OUTPUT : CPMM_SWAP_BASE_INPUT;
+	const accounts = order(abi, {
+		payer: user,
+		authority: ids.cpmmAuthority,
+		amm_config: pool.ammConfig,
+		pool_state: poolAddress,
+		input_token_account: userInput,
+		output_token_account: userOutput,
+		input_vault: inputVault,
+		output_vault: outputVault,
+		input_token_program: inputTokenProgram,
+		output_token_program: outputTokenProgram,
+		input_token_mint: input,
+		output_token_mint: output,
+		observation_state: pool.observationKey
+	});
+	const exactOut = mode === "exactOut";
+	const priced = exactOut ? cpmmSwapBaseOutput(sides, rates, amount) : cpmmSwapBaseInput(sides, rates, amount);
+	const inAmount = exactOut ? widen(priced) : amount;
+	const outAmount = exactOut ? amount : narrow(priced);
+	return {
+		instructions: wrap({
+			user,
+			input,
+			output,
+			userInput,
+			userOutput,
+			inputTokenProgram,
+			outputTokenProgram,
+			lamportsIn: inAmount,
+			middle: [{
+				programAddress: ids.cpmm,
+				accounts,
+				data: new Uint8Array([
+					...abi.discriminator,
+					...u64.encode(exactOut ? inAmount : amount),
+					...u64.encode(exactOut ? amount : outAmount)
+				])
+			}]
+		}),
+		lookupTables: {},
+		inAmount,
+		outAmount,
+		mode,
+		computeUnits: CPMM_ROUTE_COMPUTE_UNITS
+	};
+}
+/** Add the slippage margin to a cost the caller signs as a maximum. */
+const widen = (amount) => amount + amount * CPMM_ROUTE_SLIPPAGE_BPS / 10000n;
+/** Take the slippage margin off a payout the caller signs as a minimum. */
+const narrow = (amount) => amount - amount * CPMM_ROUTE_SLIPPAGE_BPS / 10000n;
+/**
+* Create the two token accounts the swap needs, wrap the SOL it spends, and close the WSOL account
+* afterwards.
+*
+* Only one side is ever WSOL here: a Gabox pool quoted in WSOL never uses a route at all.
+*/
+function wrap(input) {
+	const payer = createNoopSigner(input.user);
+	const createAta = (account, mint, tokenProgram) => withoutSigners(getCreateAssociatedTokenIdempotentInstruction({
+		payer,
+		ata: account,
+		owner: input.user,
+		mint,
+		tokenProgram
+	}));
+	const before = [createAta(input.userInput, input.input, input.inputTokenProgram), createAta(input.userOutput, input.output, input.outputTokenProgram)];
+	const after = [];
+	if (input.input === "So11111111111111111111111111111111111111112") {
+		before.push(withoutSigners(getTransferSolInstruction({
+			source: payer,
+			destination: input.userInput,
+			amount: input.lamportsIn
+		})), getSyncNativeInstruction({ account: input.userInput }));
+		after.push(closeWsol(input.userInput, payer));
+	}
+	if (input.output === "So11111111111111111111111111111111111111112") after.push(closeWsol(input.userOutput, payer));
+	return [
+		...before,
+		...input.middle,
+		...after
+	];
+}
+/**
+* Close a WSOL account, sending every lamport in it back to the owner as SOL.
+*
+* The owner has to sign, so it goes in as a signer and comes out as a plain signing slot.
+*/
+const closeWsol = (account, owner) => withoutSigners(getCloseAccountInstruction({
+	account,
+	destination: owner.address,
+	owner
+}));
+/**
+* Drop every attached signer object, keeping each account's address and role.
+*
+* A signing slot stays a signing slot: the compiled message still requires that signature, and the
+* wallet paying for the transaction provides it. What goes away is the second signer object for an
+* address the fee payer already covers, which kit refuses to sign.
+*/
+function withoutSigners(instruction) {
+	const accounts = (instruction.accounts ?? []).map((account) => ({
+		address: account.address,
+		role: account.role
+	}));
+	return {
+		...instruction,
+		accounts
+	};
+}
+//#endregion
+//#region src/route/jupiter.ts
+/**
+* The Jupiter route provider.
+*
+* Jupiter is an HTTP service, not a program this SDK builds instructions for. Two calls per route:
+*
+*   1. `GET /swap/v1/quote` prices the swap and returns a quote object.
+*   2. `POST /swap/v1/swap-instructions` turns that quote into instructions.
+*
+* The response gives `setupInstructions`, `swapInstruction` and `cleanupInstruction`, each as a
+* program id, a list of accounts and base64 data. This module decodes those into kit instructions
+* and leaves everything else alone. Jupiter's own compute budget instructions are dropped: every
+* builder in this SDK sets its own budget, and two `SetComputeUnitLimit` instructions in one message
+* is one too many. Their **number** is kept, though: it is Jupiter's own answer to "how much does
+* this route cost", and a builder adds it to its own limit.
+*
+* `wrapAndUnwrapSol: true` is always sent, so Jupiter creates the wallet's WSOL account, funds it
+* from the wallet's lamports and closes it again inside its own instructions. That is what makes
+* "pay in SOL" true from the wallet's side.
+*
+* # No Jupiter package
+*
+* The public surface of this SDK is `@solana/kit` only. Nothing here imports a Jupiter package; the
+* response is plain JSON and the decoding below is a dozen lines.
+*
+* # Exact-out is not always available
+*
+* Jupiter answers `NO_ROUTES_FOUND` for an exact-out quote whenever the best route has more than
+* one hop. Verified on 2026-09-18: SOL to USDC quotes exact-out, while SOL to the stock token
+* `XsDoVfqeBukxuZHWhdvWHBhgEHjGNst4MLodqsJHzoB` only quotes exact-in. `routeQuoteIn` in `leg.ts`
+* handles that fallback; this file only reports the failure.
+*/
+/** Jupiter's free endpoint. The keyed host `https://api.jup.ag/swap/v1` has the same shape. */
+const JUPITER_LITE_URL = "https://lite-api.jup.ag/swap/v1";
+/** The slippage Jupiter prices a route with when the caller names none. 1%. */
+const JUPITER_DEFAULT_SLIPPAGE_BPS = 100;
+/**
+* The compute units a Jupiter route is assumed to need when the response carries no limit.
 *
-* Throws when the coin has no pool.
+* Jupiter normally sends a `SetComputeUnitLimit` of its own, and that number is what this SDK uses.
+* When it does not, this is the fallback: enough for a route through several pools, and still far
+* below the 1,400,000-unit ceiling once the Gabox instruction's own budget is added. A caller who
+* knows better passes `computeUnitLimit` to the builder.
 */
-async function getOffer(client, mint, options = {}) {
-	const inventory = await fetchPoolInventory(client, mint);
-	if (!inventory) throw new Error(`no gabox pool for mint ${mint}`);
-	const venue = await resolveVenue(client, {
-		mint,
-		user: options.user ?? inventory.pool.creator,
-		...options.venue ? { venue: options.venue } : {}
+const JUPITER_DEFAULT_COMPUTE_UNITS = 4e5;
+/** `ComputeBudgetInstruction::SetComputeUnitLimit`, whose data is the tag then a u32 of units. */
+const SET_COMPUTE_UNIT_LIMIT = 2;
+const base64 = getBase64Encoder();
+/**
+* A route provider backed by Jupiter. Use it on mainnet, where Jupiter has the liquidity.
+*
+* It makes read-only HTTP calls and never sends a transaction: the instructions come back to the
+* caller, who signs them together with the Gabox instruction.
+*/
+function jupiterRoute(options = {}) {
+	const url = (options.url ?? "https://lite-api.jup.ag/swap/v1").replace(/\/+$/, "");
+	const slippageBps = options.slippageBps ?? 100;
+	const build = async (client, input, output, amount, user, swapMode) => {
+		if (amount <= 0n) throw new Error("the route amount must be positive");
+		const quote = await fetchQuote(url, {
+			input,
+			output,
+			amount,
+			swapMode,
+			slippageBps
+		});
+		const response = await fetchSwapInstructions(url, quote, user);
+		const threshold = BigInt(String(quote.otherAmountThreshold));
+		return await routeFrom(client, response, {
+			inAmount: swapMode === "ExactOut" ? threshold : BigInt(String(quote.inAmount)),
+			outAmount: swapMode === "ExactOut" ? BigInt(String(quote.outAmount)) : threshold,
+			mode: swapMode === "ExactOut" ? "exactOut" : "exactIn"
+		});
+	};
+	return {
+		exactOut: async (client, input, output, amount, user) => await build(client, input, output, amount, user, "ExactOut"),
+		exactIn: async (client, input, output, amount, user) => await build(client, input, output, amount, user, "ExactIn")
+	};
+}
+async function fetchQuote(url, input) {
+	const query = new URLSearchParams({
+		inputMint: input.input,
+		outputMint: input.output,
+		amount: input.amount.toString(),
+		swapMode: input.swapMode,
+		slippageBps: String(input.slippageBps)
 	});
-	return offerFromState(inventory, venue.kind, venue.quoteBuy(inventory.pool.packTokens));
+	const response = await fetch(`${url}/quote?${query.toString()}`);
+	const body = await response.json();
+	if (!response.ok || body.error) throw new Error(`Jupiter has no ${input.swapMode} route from ${input.input} to ${input.output}: ` + `${body.errorCode ?? response.status} ${body.error ?? ""}`.trim());
+	return body;
+}
+async function fetchSwapInstructions(url, quoteResponse, userPublicKey) {
+	const response = await fetch(`${url}/swap-instructions`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			quoteResponse,
+			userPublicKey,
+			wrapAndUnwrapSol: true
+		})
+	});
+	const body = await response.json();
+	if (!response.ok || body.error || !body.swapInstruction) throw new Error(`Jupiter could not build the swap instructions: ${response.status} ${body.error ?? ""}`.trim());
+	return body;
 }
 /**
-* 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
-* `venue.quoteBuy(pool.packTokens)`.
+* Turn a decoded `swap-instructions` response into a `Route`.
+*
+* Exported so a test can read a recorded response without making an HTTP call. The lookup tables
+* are read through the client, because the response names them by address only.
 */
-function offerFromState(inventory, venue, quoteLamports) {
-	const { pool } = inventory;
-	const tiers = tiersOf(pool);
-	const offer = quote(pool.packTokens, tiers, inventory.inventory, inventory.reserved);
-	const uncapped = uncappedMaximum(pool.packTokens, tiers);
+async function routeFrom(client, response, amounts) {
 	return {
-		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,
-		venue,
-		prizes: offer.prizes,
-		maximum: offer.maximum,
-		minimum: offer.minimum,
-		uncapped,
-		inventory: inventory.inventory,
-		reserved: inventory.reserved,
-		free: inventory.free,
-		isFirstPack: pool.nextSeq === 0n,
-		isSeeded: offer.maximum === uncapped,
-		maxMultiplierBps: maxMultiplierBps(tiers),
-		averageMultiplierBps: averageMultiplierBps(tiers)
+		instructions: [
+			...(response.setupInstructions ?? []).map(toKitInstruction),
+			toKitInstruction(response.swapInstruction),
+			...response.cleanupInstruction ? [toKitInstruction(response.cleanupInstruction)] : []
+		],
+		lookupTables: await fetchAddressLookupTables(client, response.addressLookupTableAddresses ?? []),
+		computeUnits: computeUnitsOf(response),
+		...amounts
 	};
 }
 /**
-* How short of the top prize a pool is, in tokens. `0` when it pays the whole table.
+* The unit limit Jupiter asked for, or `JUPITER_DEFAULT_COMPUTE_UNITS` when it asked for none.
 *
-* The pack brings its own `packTokens` into the vault before the offer is computed, so the vault
-* only has to hold `uncapped - packTokens` beforehand. Anything already reserved by another draw
-* does not count. A donation of this size through `fund_prizes` uncaps the top prize again.
+* `SetComputeUnitLimit` is five bytes: the tag `2`, then the units as a little-endian u32. Any other
+* compute budget instruction, such as a unit price, is skipped.
 */
-function seedShortfall(offer) {
-	const needed = offer.uncapped > offer.packTokens ? offer.uncapped - offer.packTokens : 0n;
-	return offer.free >= needed ? 0n : needed - offer.free;
+function computeUnitsOf(response) {
+	for (const instruction of response.computeBudgetInstructions ?? []) {
+		const data = new Uint8Array(base64.encode(instruction.data));
+		if (data.length < 5 || data[0] !== SET_COMPUTE_UNIT_LIMIT) continue;
+		return new DataView(data.buffer, data.byteOffset).getUint32(1, true);
+	}
+	return JUPITER_DEFAULT_COMPUTE_UNITS;
+}
+/** One Jupiter instruction as a kit instruction. The roles come from the two booleans. */
+function toKitInstruction(instruction) {
+	const accounts = instruction.accounts.map((account) => ({
+		address: account.pubkey,
+		role: account.isSigner ? account.isWritable ? AccountRole.WRITABLE_SIGNER : AccountRole.READONLY_SIGNER : account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY
+	}));
+	return {
+		programAddress: instruction.programId,
+		accounts,
+		data: new Uint8Array(base64.encode(instruction.data))
+	};
 }
 //#endregion
 //#region src/rpc.ts
@@ -1054,8 +945,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) {
@@ -1083,311 +974,451 @@ function createClient(config) {
 		wsUrl,
 		rpc: createSolanaRpc(url),
 		rpcSubscriptions: createSolanaRpcSubscriptions(wsUrl),
-		addressLookupTables: config.addressLookupTables ?? defaultAddressLookupTables(cluster)
+		addressLookupTables: config.addressLookupTables ?? defaultAddressLookupTables(cluster),
+		route: config.route === void 0 ? defaultRoute(cluster) : config.route
 	};
 }
-//#endregion
-//#region src/tx/message.ts
 /**
-* Assembling a transaction message.
+* The swap provider a cluster gets when the caller names none.
 *
-* 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.
+* Jupiter on mainnet, nothing anywhere else. Jupiter's API only prices mainnet liquidity, and a
+* devnet caller has to say which pool to route through, so there is nothing to guess.
 */
+function defaultRoute(cluster) {
+	return cluster === "mainnet-beta" ? jupiterRoute() : null;
+}
+//#endregion
+//#region src/tx/wsol.ts
 /**
-* Build the message. One RPC read, for the blockhash.
+* Wrapping and unwrapping SOL around a venue trade.
+*
+* 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) {
+/** 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 {
-		...instruction,
-		accounts: [...instruction.accounts ?? [], ...remaining]
+		account,
+		instructions
 	};
 }
+/** 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/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;
+//#region src/tx/quoteLeg.ts
+/**
+* Getting the quote token into, and out of, the wallet's own quote account.
+*
+* Gabox settles in the pool's quote asset and nothing else. Both venues move that token in and out
+* of one account: the wallet's associated token account for the quote mint, under the quote's own
+* token program. The program pins that address and measures the exact delta there. So every builder
+* in this directory has to make sure the account exists, and holds what the trade will spend.
+*
+* Three shapes, and which one applies follows from the pool's quote and the caller's choice:
+*
+*   - **A WSOL pool.** The wallet pays in SOL already. Create the WSOL account, move the lamports
+*     into it, `syncNative`, and close it afterwards so the change and any proceeds come back as
+*     SOL. This is what every 0.6.0 flow did, unchanged.
+*   - **Another quote, paying in that quote.** The wallet already holds the token. Create the
+*     account if it is missing and leave it alone: it is not WSOL, so closing it would be wrong.
+*   - **Another quote, paying in SOL.** A route turns SOL into the quote token in the same
+*     transaction, before `buy_pack`. A sale does the reverse afterwards. `routeQuoteIn` and
+*     `routeQuoteOut` build those, and `assertRouteIsSafe` checks the result before it is used.
+*
+* Nothing here ever splits the work across two transactions. A swap that settles separately would
+* leave the wallet holding a token it never asked for whenever the second half failed.
+*/
+/** Create the wallet's quote account if it is missing. Idempotent, so a second create is free. */
+function createQuoteAccount(owner, venue) {
+	return getCreateAssociatedTokenIdempotentInstruction({
+		payer: owner,
+		ata: venue.userQuoteToken,
+		owner: owner.address,
+		mint: venue.quoteMint,
+		tokenProgram: venue.quoteTokenProgram
+	});
+}
+/**
+* The leg that puts `maxQuoteIn` of the quote token in the buyer's quote account.
+*
+* `payWith` decides where it comes from. On a WSOL pool the choice makes no difference: the quote
+* token is SOL either way, so the builder wraps it.
+*/
+async function quoteLegIn(client, input) {
+	const { venue, payer, maxQuoteIn, payWith } = input;
+	if (venue.quoteMint === "So11111111111111111111111111111111111111112") {
+		const wsol = await fundWsol(payer, maxQuoteIn);
+		return {
+			before: wsol.instructions,
+			after: [unwrapWsol(payer, wsol.account)],
+			lookupTables: {},
+			mode: null,
+			solAmount: maxQuoteIn,
+			computeUnits: 0
+		};
+	}
+	if (payWith === "quote") return {
+		before: [createQuoteAccount(payer, venue)],
+		after: [],
+		lookupTables: {},
+		mode: null,
+		solAmount: null,
+		computeUnits: 0
+	};
+	const route = await routeQuoteIn(client, providerOf(client, venue.quoteMint), {
+		quoteMint: venue.quoteMint,
+		amount: maxQuoteIn,
+		user: payer.address
+	});
+	assertRouteIsSafe(route, {
+		forbidden: [GABOX_PROGRAM_ID, ...input.gaboxAccounts],
+		settlesIn: venue.userQuoteToken
+	});
 	return {
-		link,
-		referrer,
-		referral: await referralAddress(pool, referrer)
+		before: route.instructions,
+		after: [],
+		lookupTables: route.lookupTables,
+		mode: route.mode,
+		solAmount: route.inAmount,
+		computeUnits: route.computeUnits
 	};
 }
-/** 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 }
+/**
+* The leg around a sale: make sure the quote account exists, and turn the proceeds into SOL when
+* the seller asked for SOL.
+*
+* The swap is an exact-in of `minQuoteOutput`, the floor the seller already signs for on the sale
+* itself. Anything the venue pays above that floor stays in the seller's quote account: a swap can
+* only spend what the sale is guaranteed to have produced.
+*/
+async function quoteLegOut(client, input) {
+	const { venue, seller, minQuoteOutput, receive } = input;
+	if (venue.quoteMint === "So11111111111111111111111111111111111111112") {
+		const wsol = await fundWsol(seller, 0n);
+		return {
+			before: wsol.instructions,
+			after: [unwrapWsol(seller, wsol.account)],
+			lookupTables: {},
+			mode: null,
+			solAmount: null,
+			computeUnits: 0
+		};
+	}
+	const create = createQuoteAccount(seller, venue);
+	if (receive === "quote") return {
+		before: [create],
+		after: [],
+		lookupTables: {},
+		mode: null,
+		solAmount: null,
+		computeUnits: 0
+	};
+	const route = await routeQuoteOut(client, providerOf(client, venue.quoteMint), {
+		quoteMint: venue.quoteMint,
+		amount: minQuoteOutput,
+		user: seller.address
 	});
-}
-/** 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 }
+	assertRouteIsSafe(route, {
+		forbidden: [GABOX_PROGRAM_ID, ...input.gaboxAccounts],
+		settlesIn: venue.userQuoteToken
 	});
+	return {
+		before: [create],
+		after: route.instructions,
+		lookupTables: route.lookupTables,
+		mode: route.mode,
+		solAmount: route.outAmount,
+		computeUnits: route.computeUnits
+	};
+}
+/** The client's route provider, with a message that says what to do when it has none. */
+function providerOf(client, quoteMint) {
+	if (!client.route) throw new Error(`this ${client.cluster} client has no route provider, so it cannot pay in SOL for a pool quoted in ${quoteMint}. Pass \`route\` to createClient — raydiumCpmmRoute(pool) for a CPMM pool that holds the SOL pair — or pay in the quote token itself.`);
+	return client.route;
 }
-//#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 compute limit a builder asks for: its own budget plus whatever the route needs.
 *
-* # 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
+* Capped at the runtime's ceiling. Jupiter often asks for the whole 1,400,000 units rather than
+* estimating, and a request above the ceiling is rejected outright, so the sum has to be clamped
+* rather than passed through.
+*/
+function computeUnitsWithRoute(own, leg) {
+	return Math.min(own + leg.computeUnits, MAX_COMPUTE_UNIT_LIMIT);
+}
+/**
+* Add the route to a "transaction is too large" error.
 *
-* 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.
+* `buildMessage` already refuses a message above the 1,232-byte limit. When a swap is in the same
+* message, the reason is usually the swap, and the fix is not to split the transaction: the two
+* halves have to settle together. So the message says what a caller can actually do instead.
 */
+function routeSizeHint(cause, leg) {
+	if (leg.mode === null) return cause;
+	if (!(cause instanceof Error) || !cause.message.includes("Solana allows 1232")) return cause;
+	return new Error(`${cause.message} The swap and the Gabox instruction share one transaction on purpose, so this SDK never splits them. Supply more address lookup tables, or pay in the quote token.`, { cause });
+}
+//#endregion
+//#region src/tx/buyPack.ts
 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,
+		quote: {
+			mint: pool.quoteMint,
+			config: pool.quoteConfig,
+			tokenProgram: pool.quoteTokenProgram
+		},
 		...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,
+		quoteTokenProgram: pool.quoteTokenProgram,
 		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)
-	], {
-		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? 5e5 + (bind === null ? 0 : 5e4),
-		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+	const leg = await quoteLegIn(client, {
+		venue,
+		payer: input.purchaser,
+		maxQuoteIn: input.maxQuoteIn,
+		payWith: input.payWith ?? "sol",
+		gaboxAccounts: [
+			poolAddress,
+			pool.vault,
+			draw,
+			await activityAddress(purchaser),
+			await associatedTokenAddress(purchaser, input.mint)
+		]
 	});
-}
-/** 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 })
+	const instructions = [
+		...leg.before,
+		withRemainingAccounts(buy, venue.buyAccounts),
+		...leg.after
 	];
+	try {
+		return await buildMessage(client, input.purchaser, instructions, {
+			addressLookupTables: {
+				...input.addressLookupTables ?? client.addressLookupTables,
+				...leg.lookupTables
+			},
+			computeUnitLimit: input.computeUnitLimit ?? computeUnitsWithRoute(235e3, leg),
+			...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+		});
+	} catch (cause) {
+		throw routeSizeHint(cause, leg);
+	}
 }
 //#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
+* Reads the quote's LaunchLab config, the quote mint, and the Gabox platform config, because the
+* seed price and every quote-side account depend on them. 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 quote = await fetchQuoteAsset(client, input.quote?.mint ?? "So11111111111111111111111111111111111111112", ids);
+	const raise = resolveRaise(client, quote, input.raise, ids);
+	const create = await getLaunchInstruction({
 		mint: mintKeypair,
-		user: creator,
+		creator,
 		name,
 		symbol,
 		uri,
-		creator: creator.address,
-		mayhemMode: false,
-		cashback: false
-	});
-	const venueAccounts = await pumpSeedBuyAccounts(client, {
+		quoteMint: quote.mint,
+		quoteConfig: quote.config,
+		quoteTokenProgram: quote.tokenProgram,
+		raise
+	}, ids);
+	const poolState = await launchlabPoolAddress(ids.launchlab, mint, quote.mint);
+	const userQuoteToken = await quoteAccountFor(creator.address, quote.mint, quote.tokenProgram);
+	const venueAccounts = launchlabBuyAccounts({
+		launchlab: ids.launchlab,
+		launchlabAuthority: ids.launchlabAuthority,
+		launchlabEventAuthority: ids.launchlabEventAuthority,
+		globalConfig: quote.config,
+		platformConfig: ids.gaboxPlatform,
+		poolState,
 		mint,
+		quoteMint: quote.mint,
+		baseVault: await launchlabVaultAddress(ids.launchlab, poolState, mint),
+		quoteVault: await launchlabVaultAddress(ids.launchlab, poolState, quote.mint),
 		user: creator.address,
-		...input.feeRecipientIndex === void 0 ? {} : { feeRecipientIndex: input.feeRecipientIndex },
-		...input.buybackRecipientIndex === void 0 ? {} : { buybackRecipientIndex: input.buybackRecipientIndex }
+		userBaseToken: await ata(creator.address, mint),
+		userQuoteToken,
+		quoteTokenProgram: quote.tokenProgram,
+		platformFeeVault: await platformFeeVaultAddress(ids.launchlab, ids.gaboxPlatform, quote.mint),
+		creatorFeeVault: await creatorFeeVaultAddress(ids.launchlab, creator.address, quote.mint)
 	});
-	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: quote.mint,
+		quoteConfig: quote.config,
+		quoteTokenProgram: quote.tokenProgram,
+		venue: ids.launchlab,
 		tiers,
-		maxSeedLamports
-	}), venueAccounts)], {
-		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? 6e5,
-		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+		maxSeedQuoteIn,
+		maxSeedNativeDebit,
+		extraSeedTokens
+	});
+	const leg = await quoteLegIn(client, {
+		venue: {
+			quoteMint: quote.mint,
+			quoteTokenProgram: quote.tokenProgram,
+			userQuoteToken
+		},
+		payer: creator,
+		maxQuoteIn: maxSeedQuoteIn,
+		payWith: seed === 0n ? "quote" : input.payWith ?? "sol",
+		gaboxAccounts: [
+			await poolAddress(mint),
+			await vaultAddress(mint),
+			await ata(creator.address, mint)
+		]
 	});
+	const instructions = [
+		create,
+		...leg.before,
+		withRemainingAccounts(initialize, venueAccounts),
+		...leg.after
+	];
+	try {
+		return await buildMessage(client, creator, instructions, {
+			addressLookupTables: {
+				...input.addressLookupTables ?? client.addressLookupTables,
+				...leg.lookupTables
+			},
+			computeUnitLimit: input.computeUnitLimit ?? computeUnitsWithRoute(35e4, leg),
+			...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+		});
+	} catch (cause) {
+		throw routeSizeHint(cause, leg);
+	}
 }
 /**
 * 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 launch shape and the raise. 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.
+*
+* `solAmount` is the same cost in SOL, priced through the client's route provider. It is `null`
+* when the client has no provider, or when no route exists: a devnet client has none unless the
+* caller passes `raydiumCpmmRoute(pool)`.
 *
-* 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`, wrapped SOL and no extra seed. Throws if `tiers` fails
+* `validateTiers`/`validatePack`, if `extraSeedTokens` is negative, if the total seed is bigger
+* than the curve sells, or if the raise is missing or below what LaunchLab accepts.
 */
-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 quote = await fetchQuoteAsset(client, options.quote?.mint ?? "So11111111111111111111111111111111111111112", ids);
+	const raise = resolveRaise(client, quote, options.raise, ids);
+	const settings = await fetchCurveSettings(client, quote.config, ids);
+	const quoteAmount = seed === 0n ? 0n : curveBuyExactOut(newCurveReserves(raise, settings.migrateFee), settings.rates, seed);
 	return {
 		tiers: copiedTiers,
-		seedTokens: seed,
-		lamports: seed === 0n ? 0n : await newCurveBuyCost(client, seed)
+		seedTokens: mandatorySeed,
+		extraSeedTokens,
+		totalSeedTokens: seed,
+		quoteAmount,
+		quoteMint: quote.mint,
+		quoteDecimals: quote.decimals,
+		quoteSymbol: quote.symbol,
+		raise,
+		solAmount: await solPriceOf(client, quote.mint, quoteAmount)
 	};
 }
-/** A mutable encoded-table shape, owned by this call and safe to pass to Codama's builder. */
+/**
+* The raise a launch uses, checked before anything is built.
+*
+* The program pins it for a WSOL pool, so a different value there is a launch that would be
+* refused on chain. Any other quote has no default and no pin: the caller names it, and LaunchLab's
+* own minimum for that quote is the floor.
+*/
+function resolveRaise(client, quote, raise, ids) {
+	if (quote.mint === "So11111111111111111111111111111111111111112") {
+		if (raise !== void 0 && raise !== ids.launchQuoteRaise) throw new Error(`a WSOL pool raises exactly ${ids.launchQuoteRaise} lamports on ${client.cluster}; the program refuses ${raise}. Leave \`raise\` out, or pick another quote asset.`);
+		return ids.launchQuoteRaise;
+	}
+	if (raise === void 0) throw new Error(`a pool quoted in ${quote.mint} needs a \`raise\`, in that token's base units. There is no default, because the same number means a different amount in every token.`);
+	if (raise < quote.minQuoteFundRaising) throw new Error(`LaunchLab takes at least ${quote.minQuoteFundRaising} base units of ${quote.mint} as a raise, and this launch asks for ${raise}`);
+	return raise;
+}
+/** 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 +1426,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.
-*/
-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`.
+* 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 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,294 +1452,117 @@ 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}`);
-	const venue = await resolveVenue(client, {
-		mint,
-		user: seller.address,
-		...input.venue ? { venue: input.venue } : {}
-	});
-	const sell = getSellTokensInstruction({
-		seller,
-		pool: await poolAddress(mint),
-		mint,
-		userTokens: await associatedTokenAddress(seller.address, mint, pool.tokenProgram),
-		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 }
-	});
-}
-/** 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`);
+	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: purchaser.address,
+		mint: input.mint,
+		user: input.seller.address,
+		quote: {
+			mint: pool.quoteMint,
+			config: pool.quoteConfig,
+			tokenProgram: pool.quoteTokenProgram
+		},
 		...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,
+	const gaboxPool = await poolAddress(input.mint);
+	const sell = await getSellTokensInstructionAsync({
+		seller: input.seller,
+		pool: gaboxPool,
+		mint: input.mint,
+		quoteMint: pool.quoteMint,
 		venue: venue.program,
-		feeCollectorWsol: await feeCollectorWsolAddress(),
-		minQuoteOutput
-	});
-	return await buildMessage(client, purchaser, [...wsolPreparation(purchaser, venue), withRemainingAccounts(sell, venue.sellAccounts)], {
-		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? 3e5,
-		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+		quoteTokenProgram: pool.quoteTokenProgram,
+		amount: input.amount,
+		minQuoteOutput: input.minQuoteOutput,
+		maxNativeDebit: input.maxNativeDebit
 	});
-}
-/**
-* 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
+	const leg = await quoteLegOut(client, {
+		venue,
+		seller: input.seller,
+		minQuoteOutput: input.minQuoteOutput,
+		receive: input.receive ?? "sol",
+		gaboxAccounts: [
+			gaboxPool,
+			await vaultAddress(input.mint),
+			await associatedTokenAddress(input.seller.address, input.mint)
+		]
 	});
-	return {
-		award: record.amount,
-		grossOutput: venue.quoteSell(record.amount)
-	};
+	const instructions = [
+		...leg.before,
+		withRemainingAccounts(sell, venue.sellAccounts),
+		...leg.after
+	];
+	try {
+		return await buildMessage(client, input.seller, instructions, {
+			addressLookupTables: {
+				...input.addressLookupTables ?? client.addressLookupTables,
+				...leg.lookupTables
+			},
+			computeUnitLimit: input.computeUnitLimit ?? computeUnitsWithRoute(125e3, leg),
+			...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+		});
+	} catch (cause) {
+		throw routeSizeHint(cause, leg);
+	}
 }
 //#endregion
 //#region src/vrf.ts
@@ -1770,6 +1582,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, CPMM_ROUTE_COMPUTE_UNITS, CPMM_ROUTE_SLIPPAGE_BPS, 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, EXACT_IN_MARGIN_BPS, GABOX_PROGRAM_ID, GaboxMathError, IDENTITY_SEED, INSTRUCTIONS_SYSVAR, JUPITER_DEFAULT_COMPUTE_UNITS, JUPITER_DEFAULT_SLIPPAGE_BPS, JUPITER_LITE_URL, 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, assertRouteIsSafe, associatedTokenAddress, averageMultiplierBps, buildMessage, buyPack, choose, clusterNamedBy, computeBudgetInstructions, computeUnitsOf, computeUnitsWithRoute, createClient, createMachine, createQuoteAccount, decodeDraw, decodeEvent, decodeEvents, decodePool, decodeWalletActivity, defaultAddressLookupTables, defaultRoute, drawAddress, drawAvailability, expireDraw, fetchAddressLookupTables, fetchDraw, fetchEvents, fetchPoolAt, fetchPoolByMint, fetchPoolInventory, fetchVaultBalance, fetchWalletActivity, findActivityPda, findDrawPda, findIdentityPda, findPoolPda, findResolvedDraw, fundPrizes, fundWsol, generated_exports as generated, getOffer, getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, jupiterRoute, listDraws, listDrawsByPool, listDrawsByPurchaser, listPools, maxMultiplierBps, offerFromState, oracleAccounts, poolAddress, providerOf, quote, quoteLegIn, quoteLegOut, quotePool, raydium_exports as raydium, raydiumCpmmRoute, resolveReservation, retryDraw, routeFrom, routeQuoteIn, routeQuoteOut, routeSizeHint, scopedVrfIdentityAddress, seedCostEstimate, seedShortfall, seedTokens, sellTokens, solPriceOf, tierAmount, tiersOf, uncappedMaximum, unwrapWsol, validatePack, validateTiers, vaultAddress, vrfIdentityAddress, websocketUrlFor, withRemainingAccounts };
 
 //# sourceMappingURL=index.js.map