@gabox-labs/sdk 0.1.1

package/dist/index.js

@@ -0,0 +1,1763 @@
+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 { 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 = (1n << 32n) - 1n;
+/**
+* All profiles target a 95% token return. These are slices of one pack's expected-value budget
+* assigned to Rare, Epic, and Mythic respectively. A riskier profile moves more of that budget
+* out of Common and into every higher rarity; the ticket counts still decrease as rarity rises.
+*/
+const RISK_PROFILES = {
+	conservative: {
+		rarityEvBps: [
+			1000n,
+			600n,
+			300n
+		],
+		targetEvBps: 9500n
+	},
+	balanced: {
+		rarityEvBps: [
+			1400n,
+			1000n,
+			700n
+		],
+		targetEvBps: 9500n
+	},
+	jackpot: {
+		rarityEvBps: [
+			1800n,
+			1500n,
+			1200n
+		],
+		targetEvBps: 9500n
+	}
+};
+function checkedU64(value, what) {
+	if (value < 0n || value > U64_MAX) throw new GaboxMathError("Arithmetic", `${what} does not fit in u64`);
+	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(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 tier of tiers) {
+		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");
+	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) {
+	const largest = uncappedMaximum(packTokens, tiers);
+	if (largest < packTokens) throw new GaboxMathError("JackpotBelowOnePack", "the largest tier must pay at least one pack");
+	return largest - packTokens;
+}
+/**
+* Derive a fully valid four-outcome rarity ladder from a jackpot multiplier and a risk preset.
+*
+* Mythic is exactly `jackpotBps`. Rare and Epic interpolate between sub-1x launch values
+* and Mythic as the jackpot grows, so the four payouts remain strictly ordered even at 1x.
+* The profile assigns fixed slices of one pack's EV budget to the three higher rarities. Whatever
+* remains of the 95% target becomes Common. Integer rounding is always downward, so the result
+* cannot cross the program's 100% expected-value ceiling.
+*
+* The seed this table needs is `seedTokens(packTokens, tiers)`: `(jackpotBps - 10_000)` bps of
+* one pack.
+*/
+function jackpotTiers(jackpotBps, profile) {
+	const settings = RISK_PROFILES[profile];
+	if (!settings) throw new GaboxMathError("InvalidDistribution", `unknown risk profile: ${profile}`);
+	if (!Number.isInteger(jackpotBps) || jackpotBps < Number(10000n)) throw new GaboxMathError("JackpotBelowOnePack", "jackpotBps must be a whole number of at least 10_000 (1x)");
+	if (BigInt(jackpotBps) > U32_MAX) throw new GaboxMathError("Arithmetic", "jackpotBps does not fit in u32");
+	const maximum = BigInt(jackpotBps);
+	const totalTickets = BigInt(TICKETS);
+	const growth = maximum - BPS;
+	const rarityMultipliers = [
+		9600n + growth / 8n,
+		9800n + growth / 3n,
+		maximum
+	];
+	const rarityTickets = rarityMultipliers.map((multiplier, index) => settings.rarityEvBps[index] * totalTickets / multiplier);
+	if (rarityTickets.some((tickets) => tickets < 1n)) throw new GaboxMathError("UnfundedExpectation", `jackpot ladder is too large for the ${profile} profile's minimum one-ticket odds`);
+	const commonTickets = totalTickets - rarityTickets.reduce((sum, tickets) => sum + tickets, 0n);
+	if (commonTickets < 1n) throw new GaboxMathError("InvalidDistribution", "risk profile leaves no Common tickets");
+	const rarityExpected = rarityTickets.reduce((sum, tickets, index) => sum + rarityMultipliers[index] * tickets, 0n);
+	const commonMultiplier = (settings.targetEvBps * totalTickets - rarityExpected) / commonTickets;
+	if (commonMultiplier < 1n || commonMultiplier >= rarityMultipliers[0]) throw new GaboxMathError("PackTooSmall", "risk profile cannot derive an ordered, non-zero Common multiplier");
+	const tiers = Array.from({ length: 8 }, () => ({
+		multiplierBps: 0,
+		tickets: 0
+	}));
+	tiers[0] = {
+		multiplierBps: Number(commonMultiplier),
+		tickets: Number(commonTickets)
+	};
+	for (let index = 0; index < rarityMultipliers.length; index += 1) tiers[index + 1] = {
+		multiplierBps: Number(rarityMultipliers[index]),
+		tickets: Number(rarityTickets[index])
+	};
+	validateTiers(tiers);
+	if (maxMultiplierBps(tiers) !== jackpotBps) throw new GaboxMathError("InvalidDistribution", "the ladder lost its jackpot tier");
+	return tiers;
+}
+/**
+* `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) {
+	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) {
+	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) {
+	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) {
+	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. */
+function decodeEvent(data) {
+	if (startsWith(data, POOL_CREATED_EVENT_DISCRIMINATOR)) return {
+		name: "PoolCreated",
+		data: getPoolCreatedEventDecoder().decode(data)
+	};
+	if (startsWith(data, PRIZES_FUNDED_EVENT_DISCRIMINATOR)) return {
+		name: "PrizesFunded",
+		data: getPrizesFundedEventDecoder().decode(data)
+	};
+	if (startsWith(data, PACK_BOUGHT_EVENT_DISCRIMINATOR)) return {
+		name: "PackBought",
+		data: getPackBoughtEventDecoder().decode(data)
+	};
+	if (startsWith(data, RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR)) return {
+		name: "RandomnessRetried",
+		data: getRandomnessRetriedEventDecoder().decode(data)
+	};
+	if (startsWith(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 {
+		name: "TokensSold",
+		data: getTokensSoldEventDecoder().decode(data)
+	};
+	return null;
+}
+/**
+* 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.
+*/
+function decodeEvents(logs) {
+	const events = [];
+	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 {
+			continue;
+		}
+		const event = decodeEvent(bytes);
+		if (event) events.push(event);
+	}
+	return events;
+}
+/** 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, {
+		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`);
+			}
+			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();
+	}
+}
+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
+	};
+}
+//#endregion
+//#region src/lookupTables.ts
+/**
+* Shared devnet address lookup table, verified on 2026-09-10T13:05:37.919Z.
+* 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.
+*/
+const DEVNET_LOOKUP_TABLE_ADDRESS = address("Cx4ri1BU2bnDXPjnJykF3nbY2u4MD5pPvzFCJtNizWFa");
+const DEVNET_LOOKUP_TABLE_ADDRESSES = [
+	address("GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA"),
+	address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"),
+	address("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"),
+	address("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"),
+	address("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"),
+	address("pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA"),
+	address("pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ"),
+	address("11111111111111111111111111111111"),
+	address("MAyhSmzXzV1pTf7LsNkrNwkWKTo4ougAJ1PPg47MD4e"),
+	address("So11111111111111111111111111111111111111112"),
+	address("Vrf1RNUjXmQGjmQrQLvJHs9SNkvDJEsRVFPkfSQUwGz"),
+	address("Cuj97ggrhhidhbu39TijNVqE74xvKJ69gDervRUXAxGh"),
+	address("SysvarS1otHashes111111111111111111111111111"),
+	address("Sysvar1nstructions1111111111111111111111111"),
+	address("4wTV1YmiEkRvAtNtsSGPtUrqRYQMe5SKy2uB4Jjaxnjf"),
+	address("Ce6TQqeHC9p8KetsN6JsjHK7UTZk7nasjjnr7XxXp9F1"),
+	address("8Wf5TiAheLUqBrKXeYg2JtAFFMWtKdG2BSFgqUcPVwTt"),
+	address("Hq2wp8uJ9jCPsYgNHex8RtqdvMPfVGoYwjvF1ATiwn2Y"),
+	address("TSLvdd1pWpHVjahSpsvCXUbgwsL3JAcvokwaKt1eokM"),
+	address("13ec7XdrjF3h3YcqBTFDSReRcUFwbCnJaAQspM4j6DDJ"),
+	address("BwWK17cbHxwWBKZkUYvzxLcNQ1YVyaFezduWbtm2de6s"),
+	address("ADyA8hdefvWN2dbGGWFotbzWxrAvLW83WG6QCVXvJKqw"),
+	address("GS4CU59F31iL7aR2Q8zVS8DRrcRnXX1yjQ66TqNVQnaR"),
+	address("5PHirr8joyTMp9JMm6nW7hNDVyEYdkzDqazxPD7RaTjx"),
+	address("C2aFPdENg4A2HQsmrd5rTw5TaYBX5Ku887cWjbFKtZpw"),
+	address("7ahYg76P8bhifT1Uj3hNHGKRFPp6bLkx1ppNrWbnsfu2"),
+	address("68yFSZxzLWJXkxxRGydZ63C6mHx1NLEDWmwN9Lb5yySg"),
+	address("DLP9ADYpdQV4Z4UQDZof7iLHu2qqdzmMPjcAHDGe4jTt"),
+	address("6QgPshH1egekJ2TURfakiiApDdv98qfRuRe7RectX8xs"),
+	address("FmFPTNDmmVDhqzaqZYhnt4fj5fJP3pffcMWf2b5JnRTk"),
+	address("78i5hpHxbtmosSJdfJ74WzwdUr3eKWg9RbCPpBeAF78t"),
+	address("7611SPS3UkjsA43auxPpJpPVAkgEHg4dTVorK839GonW"),
+	address("8RMFYhsVsfdGCuWPFLxMCbSpSesiofabDdNorGqFrBNe"),
+	address("9GbQXDFHKLdr4BzZ8Cx2pkX2aM2Kg7yEeYnUCKjZGE4M"),
+	address("9GDepfBcjJMvNgmijXWVWa97Am7VZYCqXx7kJV44E9ij"),
+	address("3fyMEgHADGRrBnCVLU7u9AwpiMtmGDWViJzDQC8kgRa5"),
+	address("9ppkS5madL2uXozoEnMnZi5bKDq9jgdKkSavjWTS5NfW"),
+	address("C3PvwRFdKT6caSLxnwy8h67KWNevoboNDg6bwJZYzWB5"),
+	address("DDMCfwbcaNYTeMk1ca8tr8BQKFaUfFCWFwBJq8JcnyCw"),
+	address("FrYoobDtL7w1HrTjHAc8Ya7qQzEdJPhGXXFKskCDaA3p"),
+	address("DRDBsRMst21CJUhwD16pncgiXnBrFaRAPvA2G6SUQceE"),
+	address("J7JbDVnGKus2M9PKzH7ZbeCYugEYDgpGBfqKL85dQbU7"),
+	address("5YxQFdt3Tr9zJLvkFccqXVUwhdTWJQc1fFg2YPbxvxeD"),
+	address("HjQjngTDqoHE6aaGhUqfz9aQ7WZcBRjy5xB8PScLSr8i"),
+	address("9M4giFFMxmFGXtc3feFzRai56WbBqehoSeRE5GK7gf7"),
+	address("GAFuhgcd328SkkBYHpfadzmef9hTGAFRCi9QoCnsZQug"),
+	address("GXPFM2caqTtQYC2cJ5yJRi9VDkpsYZXzYdwYpGnLmtDL"),
+	address("AktftA98kSWAxn6kVSoqBXBELUArjKu2H9WmKB48ULFY"),
+	address("3BpXnfJaUTiwXnJNe7Ej1rcbzqTTQUvLShZaWazebsVR"),
+	address("6rVkF4HSgy1jrnC3HogfRgPHrq4CtLg5f11URpsC4i9D"),
+	address("5cjcW9wExnJJiqgLjq7DEG75Pm6JBgE1hNv4B2vHXUW6"),
+	address("GYH1Gae1wJytMSvMvw8JVcv7nuAbxi8i9erNVbERnzXd"),
+	address("EHAAiTxcdDwQ3U4bU6YcMsQGaekdzLS3B5SmYo46kJtL"),
+	address("CA7v8gHfbquYXyDnDx6QxWW8hmL1H7X6Y2RYDrGLnuck"),
+	address("5eHhjP8JaYkz83CWwvGU2uMUXefd3AazWGx4gpcuEEYD"),
+	address("CASRL2zkwDnppxEFQ4LgdwgR9pdz5Q8R8nEMKVZ9QoLp"),
+	address("A7hAgCzFw14fejgCp387JUJRMNyz4j89JKnhtKU8piqW"),
+	address("qkYdTGRPHbWTWuBMz45bCiU6a23axRqf6sBHm9295WY"),
+	address("12e2F4DKkD3Lff6WPYsU7Xd76SHPEyN9T8XSsTJNF8oT"),
+	address("GjJkcak9e4L2HsxSZqVsc81L7coChdR7F3ciJYnQcSnU"),
+	address("2Ej38XSkmpvXzoUg5ZLma7Y9rCiZVgxzTdvE3Kph5juM"),
+	address("2daQRytJgLzLLziPNQBNJ7w1Ltz3XqZG4dZxBamLAf7v"),
+	address("3PAxmkxnM2vHno9amWQCsaaFjYnPGcD87HZGx1ChVjPj"),
+	address("BWS634asUFdrpYpfofFA1CrGB9wEbh9gt8XswZ4AWz9J"),
+	address("4QZqaBNm2F7viBDhhs8AQ5wC9FshgLJEiLLFGoxZZrTn"),
+	address("4JaPhJE7WgQZ3xFbxn2spU97reA13SiM99wD3RF4Lqro"),
+	address("9xvDPD6G7NRCEu7W2M9vCLeo8we23Ww7pzQEhXcuJAmA"),
+	address("AHEgRGXFn8JbhXccWM4i1meRGPFbx8kzb9BGN6ocqRFL"),
+	address("CdkG7sp1LT9YLsDaTWREaQcX6W4gZySk3o1eSjoL2uTh"),
+	address("2pLUmsYktT7gR6P5hXs9Ldo6Vg1oQB2Q4NPbJqHUjZhq"),
+	address("Freijj9xKLefjrb5fHgT6KMbYG1XBP2mA83tqeXYUMYM"),
+	address("4uzPz9TPskXiiEZ6X78rqud8LvfdxkJBr5EKHgbx4azP"),
+	address("Hxzab4UjjVH2KjsdAqzdxGdYUpNN5FKhpu7iikB869uH"),
+	address("Frkwunr9dQM9d4TthfQ2unxC994XpkLMpkRP2e7yfirk")
+];
+const DEVNET_ADDRESS_LOOKUP_TABLES = { [DEVNET_LOOKUP_TABLE_ADDRESS]: [...DEVNET_LOOKUP_TABLE_ADDRESSES] };
+/**
+* The tables a client compresses with when its config names none.
+*
+* Only devnet has a shared table today. Mainnet gets one when the program is deployed there; until
+* then a mainnet or localnet client compresses with nothing, and a message over 1,232 bytes fails
+* in `buildMessage` with a request for tables. Pass `addressLookupTables` to `createClient` to
+* supply your own.
+*/
+function defaultAddressLookupTables(cluster) {
+	return cluster === "devnet" ? { ...DEVNET_ADDRESS_LOOKUP_TABLES } : {};
+}
+//#endregion
+//#region src/offer.ts
+/**
+* The full offer for one machine. Two round trips: the pool and its vault, then the venue.
+*
+* 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 venue = await resolveVenue(client, {
+		mint,
+		user: options.user ?? inventory.pool.creator,
+		...options.venue ? { venue: options.venue } : {}
+	});
+	return offerFromState(inventory, venue.kind, venue.quoteBuy(inventory.pool.packTokens));
+}
+/**
+* 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)`.
+*/
+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);
+	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)
+	};
+}
+/**
+* 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/rpc.ts
+/**
+* The client, and the cluster guard.
+*
+* `createClient` is the SDK's init step. It takes the cluster and the RPC endpoint once and returns
+* one object that every other chain-touching function in this SDK takes as its first argument: the
+* RPC, the subscriptions client, and the address lookup tables that cluster compresses with.
+*
+* # Why `cluster` has no default
+*
+* v1's simulator was one empty wallet away from running against mainnet. Nothing in the code said
+* which cluster it was pointed at; the answer lived in a shell variable and in the operator's head.
+* The failure would not have been a crash. It would have been real transactions on real money,
+* discovered afterwards.
+*
+* So the cluster is a property of the code, not of the environment. The caller names it in the
+* same call that names the URL, and the two are checked against each other:
+*
+*   - `devnet` needs a URL that names devnet. A URL that names nothing is refused too, because
+*     "I thought this was devnet" is exactly the accident this guard exists for.
+*   - `mainnet-beta` and `localnet` refuse a URL that names a different cluster. A URL that names
+*     nothing is allowed: private mainnet endpoints often do not say "mainnet", and a local
+*     validator never says anything.
+*
+* Mainnet is one word away. It is a word the caller has to write.
+*/
+/** Solana's public endpoints, and the test validator's default ports. */
+const CLUSTER_ENDPOINTS = {
+	devnet: {
+		url: "https://api.devnet.solana.com",
+		wsUrl: "wss://api.devnet.solana.com"
+	},
+	"mainnet-beta": {
+		url: "https://api.mainnet-beta.solana.com",
+		wsUrl: "wss://api.mainnet-beta.solana.com"
+	},
+	localnet: {
+		url: "http://127.0.0.1:8899",
+		wsUrl: "ws://127.0.0.1:8900"
+	}
+};
+const DEVNET_HTTP = CLUSTER_ENDPOINTS.devnet.url;
+const DEVNET_WS = CLUSTER_ENDPOINTS.devnet.wsUrl;
+/**
+* The cluster a URL names, from its text alone. A substring check, deliberately: providers spell
+* it many ways. `null` when the URL names none, which is a local validator or a private endpoint.
+*/
+function clusterNamedBy(url) {
+	const lower = url.toLowerCase();
+	if (lower.includes("devnet")) return "devnet";
+	if (lower.includes("mainnet")) return "mainnet-beta";
+	if (lower.includes("testnet")) return "testnet";
+	return null;
+}
+/**
+* Refuse a URL that contradicts the declared cluster. Exported so a script can check a URL before
+* it does anything else with it. The rules are in the file comment.
+*/
+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.`);
+}
+/** `https://x` becomes `wss://x`, `http://x` becomes `ws://x`. Anything else is returned as is. */
+function websocketUrlFor(url) {
+	if (url.startsWith("https://")) return `wss://${url.slice(8)}`;
+	if (url.startsWith("http://")) return `ws://${url.slice(7)}`;
+	return url;
+}
+/**
+* The SDK's init step. Call it once and pass the result everywhere.
+*
+* Both RPC clients are created together because everything in this SDK that watches a draw needs
+* the pair: the subscription reports the change, and the RPC reads the account that changed.
+*/
+function createClient(config) {
+	const { cluster } = config;
+	const defaults = CLUSTER_ENDPOINTS[cluster];
+	if (!defaults) throw new Error(`unknown cluster ${JSON.stringify(cluster)}; expected 'devnet', 'mainnet-beta' or 'localnet'`);
+	const url = config.url ?? defaults.url;
+	assertClusterUrl(cluster, url);
+	const wsUrl = config.wsUrl ?? (config.url === void 0 ? defaults.wsUrl : websocketUrlFor(url));
+	assertClusterUrl(cluster, wsUrl);
+	return {
+		cluster,
+		url,
+		wsUrl,
+		rpc: createSolanaRpc(url),
+		rpcSubscriptions: createSolanaRpcSubscriptions(wsUrl),
+		addressLookupTables: config.addressLookupTables ?? defaultAddressLookupTables(cluster)
+	};
+}
+//#endregion
+//#region src/tx/message.ts
+/**
+* Assembling a transaction message.
+*
+* Every builder in this directory ends here: compute budget first, then the program instructions,
+* with a fee payer and a blockhash lifetime. The result is a message a wallet can sign and send —
+* nothing in this SDK signs or sends anything itself.
+*/
+/**
+* Build the message. One RPC read, for the blockhash.
+*
+* The blockhash expires in about a minute, so build the message when the user is ready to sign
+* rather than when the page loads.
+*/
+async function buildMessage(client, feePayer, instructions, options) {
+	const { value: latestBlockhash } = await client.rpc.getLatestBlockhash({ commitment: "confirmed" }).send();
+	const budget = computeBudgetInstructions(options.computeUnitLimit, options.computeUnitPrice);
+	const message = pipe(createTransactionMessage({ version: 0 }), (m) => setTransactionMessageFeePayerSigner(feePayer, m), (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m), (m) => appendTransactionMessageInstructions([...budget, ...instructions], m), (m) => compressTransactionMessageUsingAddressLookupTables(m, options.addressLookupTables ?? client.addressLookupTables));
+	const size = getTransactionEncoder().encode(compileTransaction(message)).length;
+	if (size > 1232) throw new Error(`Transaction is ${size} bytes; Solana allows 1232. Shorten metadata or supply additional address lookup tables.`);
+	return message;
+}
+/** Append `remainingAccounts` to a generated instruction, which is how a venue's list is passed. */
+function withRemainingAccounts(instruction, remaining) {
+	return {
+		...instruction,
+		accounts: [...instruction.accounts ?? [], ...remaining]
+	};
+}
+//#endregion
+//#region src/referral.ts
+/** Resolve the purchaser's permanent referral binding for a pack purchase. */
+async function resolveReferral(client, purchaser, pool) {
+	const link = await referralLinkAddress(purchaser);
+	const account = await fetchMaybeReferralLink(client.rpc, link, { commitment: "confirmed" });
+	if (!account.exists) return null;
+	const referrer = account.data.referrer;
+	return {
+		link,
+		referrer,
+		referral: await referralAddress(pool, referrer)
+	};
+}
+/** Bind a wallet to a referrer. The purchaser signs and the binding is permanent. */
+async function bindReferrer(client, referee, referrer, options = {}) {
+	return await buildMessage(client, referee, [await getBindReferrerInstructionAsync({
+		referee,
+		referrer
+	})], {
+		addressLookupTables: options.addressLookupTables,
+		computeUnitLimit: options.computeUnitLimit ?? 8e4,
+		...options.computeUnitPrice === void 0 ? {} : { computeUnitPrice: options.computeUnitPrice }
+	});
+}
+/** Claim all accrued referral rewards for one pool. */
+async function claimReferral(client, referrer, pool, options = {}) {
+	return await buildMessage(client, referrer, [await getClaimReferralInstructionAsync({
+		referrer,
+		pool
+	})], {
+		addressLookupTables: options.addressLookupTables,
+		computeUnitLimit: options.computeUnitLimit ?? 8e4,
+		...options.computeUnitPrice === void 0 ? {} : { computeUnitPrice: options.computeUnitPrice }
+	});
+}
+//#endregion
+//#region src/tx/buyPack.ts
+/**
+* Buying a pack.
+*
+* One instruction does the whole thing: buy exactly `pool.packTokens` at the venue, move the
+* tokens into gabox custody, freeze a prize table into a new `Draw`, pay the creator's fee and
+* the protocol's 1% of the venue cost, and ask MagicBlock for randomness. Either all of it happens
+* or none of it does.
+*
+* # The three numbers the buyer signs
+*
+* `maxQuoteIn` is the slippage cap at the venue, in lamports (WSOL on PumpSwap). The token count
+* is fixed by the pool, so the cost is the only thing that moves. Set it from `offer.quoteLamports`
+* plus a margin, for example 2%.
+*
+* `minMaximum` is a floor on the top prize, in tokens. The table is fixed, so only an inventory
+* cap can lower it. Set it from `offer.maximum`.
+*
+* `maxTotalDebit` caps the venue debit plus the creator fee plus the protocol fee plus the VRF
+* request, measured in SOL and WSOL together. Both fees are a share of the venue debit, so budget
+* them from `maxQuoteIn`. It does **not** cover the rent Anchor pays for the `Draw` and any ATA it
+* creates, nor the transaction fee: the runtime charges those before the handler runs. Budget for
+* them separately.
+*
+* # PumpSwap needs WSOL first
+*
+* On the curve, Pump spends native SOL. On PumpSwap the quote is a classic WSOL token account, so
+* the buyer's WSOL ATA must exist and hold enough before the pack instruction runs. This builder
+* adds the create/fund/sync instructions when the route is PumpSwap. They are the buyer's own
+* instructions, signed by the buyer, and gabox never touches that account.
+*/
+async function buyPack(client, input) {
+	const { mint, purchaser } = input;
+	if (input.maxQuoteIn <= 0n) throw new Error("maxQuoteIn must be positive");
+	const inventory = await fetchPoolInventory(client, mint);
+	if (!inventory) throw new Error(`no gabox pool for mint ${mint}`);
+	const { pool, poolAddress } = inventory;
+	const venue = await resolveVenue(client, {
+		mint,
+		user: purchaser.address,
+		...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,
+		pool: poolAddress,
+		creator: pool.creator,
+		draw,
+		mint,
+		vault: pool.vault,
+		userTokens: venueUserTokens(venue.buyAccounts, venue.kind),
+		venue: venue.program,
+		identity: await vrfIdentityAddress(),
+		tokenProgram: pool.tokenProgram,
+		maxQuoteIn: input.maxQuoteIn,
+		minMaximum: input.minMaximum,
+		maxTotalDebit: input.maxTotalDebit,
+		referralLink: referral?.link,
+		referral: referral?.referral
+	});
+	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 }
+	});
+}
+/** The default `Pubkey`: all zero bytes. `bind_referrer` refuses a link pointing at it. */
+const NO_REFERRER = "11111111111111111111111111111111";
+/**
+* The program refuses a self-referral and a link to the all-zero address. Both would take the
+* pack down with them, so the bind is skipped instead and the pack goes through unreferred.
+*/
+function canBind(purchaser, referrer) {
+	return referrer !== purchaser && referrer !== NO_REFERRER;
+}
+/**
+* The purchaser's base-token ATA, taken out of the venue account list rather than re-derived.
+*
+* `market.rs` requires `user_tokens` to equal the venue list's own `associated_base_user` (Pump) or
+* `user_base_token_account` (PumpSwap). Reading it back from the list makes the two agree by
+* construction instead of by two derivations that happen to match.
+*/
+function venueUserTokens(accounts, kind) {
+	const account = accounts[kind === "pump" ? 14 : 5];
+	if (!account) throw new Error(`the ${kind} account list is too short`);
+	return account.address;
+}
+/**
+* Create the buyer's WSOL account if needed, fund it, and sync its balance.
+*
+* `SyncNative` is the step people forget. A plain SOL transfer into a WSOL account raises its
+* lamports but not the `amount` field the token program reads, so the venue sees an empty account
+* until this instruction copies one to the other.
+*/
+function wsolPreparation$2(purchaser, lamports) {
+	const wsol = wsolAccountFor(purchaser.address);
+	return [
+		getCreateAssociatedTokenIdempotentInstruction({
+			payer: purchaser,
+			ata: wsol,
+			owner: purchaser.address,
+			mint: WSOL_MINT,
+			tokenProgram: TOKEN_PROGRAM_ADDRESS$1
+		}),
+		getTransferSolInstruction({
+			source: purchaser,
+			destination: wsol,
+			amount: lamports
+		}),
+		getSyncNativeInstruction({ account: wsol })
+	];
+}
+//#endregion
+//#region src/tx/createMachine.ts
+/**
+* Creating a machine: one transaction, two instructions, two signers.
+*
+* # Why it has to be one transaction
+*
+* `initialize_pool` reads the Instructions sysvar and refuses to run unless the same transaction
+* also carries a Pump `create_v2` for the same mint, signed by the same creator. That is what makes
+* "one pool per coin" true and stops anyone wrapping an existing coin in a machine. The create must
+* come **first**: the mint account has to exist and deserialize before Anchor validates
+* `initialize_pool`'s accounts.
+*
+* # The seed
+*
+* The creator owns none of the coin yet — it does not exist until this transaction runs. So
+* `initialize_pool` buys the seed on the curve itself, into the creator's own ATA, and moves it
+* straight into the vault. The Pump buy accounts ride along as `remainingAccounts`, in the same
+* order `buy_pack` uses.
+*
+* The seed follows from the jackpot. A creator chooses a jackpot multiplier and a risk profile,
+* and the SDK derives a valid tier table. The program then buys exactly
+* `(jackpot - 1x) * PACK_TOKENS` tokens as the seed, so the first pack can pay the jackpot 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.
+*
+* # Two signers
+*
+* The mint keypair signs `create_v2` — Pump takes it as a signer rather than deriving it — and the
+* creator signs both instructions and pays for everything.
+*/
+/**
+* Build the transaction message. Sign it with both `creator` and `mintKeypair`.
+*
+* Reads Pump's `Global` account, because two of the buy accounts — the fee recipient and the
+* buyback fee recipient — are chosen from lists held there. Nothing else needs the chain: the coin
+* does not exist yet, so every other account is a derivation.
+*/
+async function createMachine(client, input) {
+	const { creator, mintKeypair, name, symbol, uri, feeBps, riskProfile, jackpotBps, maxSeedLamports } = input;
+	if (!Number.isInteger(feeBps) || feeBps < 0 || feeBps > 100) throw new Error(`feeBps must be a whole number from 0 to 100`);
+	const tiers = jackpotTiers(jackpotBps, riskProfile);
+	if (seedTokens(PACK_TOKENS, tiers) > 0n && maxSeedLamports <= 0n) throw new Error("maxSeedLamports must be positive when the jackpot needs a seed");
+	const mint = mintKeypair.address;
+	const create = getPumpCreateV2Instruction({
+		mint: mintKeypair,
+		user: creator,
+		name,
+		symbol,
+		uri,
+		creator: creator.address,
+		mayhemMode: false,
+		cashback: false
+	});
+	const venueAccounts = await pumpSeedBuyAccounts(client, {
+		mint,
+		user: creator.address,
+		...input.feeRecipientIndex === void 0 ? {} : { feeRecipientIndex: input.feeRecipientIndex },
+		...input.buybackRecipientIndex === void 0 ? {} : { buybackRecipientIndex: input.buybackRecipientIndex }
+	});
+	return await buildMessage(client, creator, [create, withRemainingAccounts(await getInitializePoolInstructionAsync({
+		creator,
+		mint,
+		tokenProgram: PUMP_CREATE_TOKEN_PROGRAM_ADDRESS,
+		venue: PUMP_PROGRAM_ADDRESS,
+		feeBps,
+		tiers,
+		maxSeedLamports
+	}), venueAccounts)], {
+		addressLookupTables: input.addressLookupTables,
+		computeUnitLimit: input.computeUnitLimit ?? 6e5,
+		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+	});
+}
+/**
+* What the seed for this jackpot 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`.
+*/
+async function seedCostEstimate(client, jackpotBps, riskProfile) {
+	const tiers = jackpotTiers(jackpotBps, riskProfile);
+	const seed = seedTokens(PACK_TOKENS, tiers);
+	return {
+		tiers,
+		seedTokens: seed,
+		lamports: seed === 0n ? 0n : await newCurveBuyCost(client, seed)
+	};
+}
+/**
+* The Pump buy accounts for the seed, built without reading the bonding curve.
+*
+* The curve does not exist yet — `create_v2` in the same transaction is what creates it — so
+* `resolveVenue` cannot be used here. Everything the account list needs is known anyway: the
+* creator vault follows from the `creator` argument that `create_v2` records on the curve, and the
+* two fee recipients come from `Global`.
+*/
+async function pumpSeedBuyAccounts(client, options) {
+	const { value } = await client.rpc.getAccountInfo(PUMP_GLOBAL, {
+		encoding: "base64",
+		commitment: "confirmed"
+	}).send();
+	if (!value) throw new Error(`Pump's Global account is missing at ${PUMP_GLOBAL}`);
+	const global = decodePumpGlobal(new Uint8Array(getBase64Encoder().encode(value.data[0])));
+	const recipients = [global.feeRecipient, ...global.feeRecipients];
+	const feeRecipient = recipients[options.feeRecipientIndex ?? randomIndex(recipients.length)];
+	const buyback = global.buybackFeeRecipients[options.buybackRecipientIndex ?? randomIndex(global.buybackFeeRecipients.length)];
+	if (!feeRecipient) throw new Error("Pump Global holds no fee recipient");
+	if (!buyback) throw new Error("Pump Global holds no buyback fee recipient");
+	return pumpBuyAccounts({
+		mint: options.mint,
+		user: options.user,
+		tokenProgram: PUMP_CREATE_TOKEN_PROGRAM_ADDRESS,
+		creator: options.user,
+		feeRecipient,
+		buybackFeeRecipient: buyback
+	});
+}
+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({
+		payer: input.payer,
+		pool: input.pool,
+		draw: input.draw,
+		identity: await vrfIdentityAddress(),
+		maxVrfDebit: input.maxVrfDebit
+	});
+	return await buildMessage(client, input.payer, [retry], {
+		addressLookupTables: input.addressLookupTables,
+		computeUnitLimit: input.computeUnitLimit ?? DRAW_COMPUTE_UNITS,
+		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+	});
+}
+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}`);
+	const pool = await fetchPoolAt(client, input.pool);
+	if (!pool) throw new Error(`no pool at ${input.pool}`);
+	const expire = 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
+	});
+	return await buildMessage(client, input.payer, [expire], {
+		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 its
+* one expiry condition. Showing a disabled button with a countdown beats sending a transaction that
+* fails with `RetryTooSoon`.
+*/
+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;
+	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,
+		slotsUntilRetry,
+		slotsUntilExpiry,
+		canRetry: pending && slotsUntilRetry === 0n && record.attempts < 3 && slotsUntilExpiry > 0n,
+		canExpire: pending && 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),
+		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 } : {}
+	});
+	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
+		})
+	], {
+		addressLookupTables: input.addressLookupTables,
+		computeUnitLimit: input.computeUnitLimit ?? FUND_WITH_BUY_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`);
+	const venue = await resolveVenue(client, {
+		mint,
+		user: purchaser.address,
+		...input.venue ? { venue: input.venue } : {}
+	});
+	const sell = getSellPrizeInstruction({
+		purchaser,
+		pool: await poolAddress(mint),
+		draw,
+		mint,
+		vault: pool.vault,
+		userTokens: await associatedTokenAddress(purchaser.address, mint, pool.tokenProgram),
+		tokenProgram: pool.tokenProgram,
+		venue: venue.program,
+		feeCollectorWsol: await feeCollectorWsolAddress(),
+		minQuoteOutput
+	});
+	return await buildMessage(client, purchaser, [...wsolPreparation(purchaser, venue), withRemainingAccounts(sell, venue.sellAccounts)], {
+		addressLookupTables: input.addressLookupTables,
+		computeUnitLimit: input.computeUnitLimit ?? 3e5,
+		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+	});
+}
+/**
+* On PumpSwap the proceeds land in the seller's WSOL account, so it has to exist before the sale.
+* Pump's own SDK does the same before its sells. The instruction is idempotent and the account is
+* the seller's own; gabox never touches it. Pump pays native SOL, so the curve route adds nothing.
+*/
+function wsolPreparation(seller, venue) {
+	if (venue.kind !== "pumpswap") return [];
+	return [getCreateAssociatedTokenIdempotentInstruction({
+		payer: seller,
+		ata: wsolAccountFor(seller.address),
+		owner: seller.address,
+		mint: WSOL_MINT,
+		tokenProgram: TOKEN_PROGRAM_ADDRESS$1
+	})];
+}
+/**
+* Quote the award held by a legacy open draw before the seller signs a floor.
+*
+* Read the draw, ask the venue, and subtract your own slippage tolerance to get `minQuoteOutput`.
+*/
+async function quoteSellPrize(client, mint, draw, user) {
+	const record = await fetchDraw(client, draw);
+	if (!record) throw new Error(`no draw at ${draw}`);
+	const venue = await resolveVenue(client, {
+		mint,
+		user
+	});
+	return {
+		award: record.amount,
+		grossOutput: venue.quoteSell(record.amount)
+	};
+}
+//#endregion
+//#region src/vrf.ts
+/**
+* Build the group. Nothing here reads the chain, so it is safe to call on every render.
+*
+* The generated instruction builders default `queue`, `program` and `slotHashes` on their own, so
+* passing this whole object is belt and braces. It is worth having anyway: a caller can show the
+* four accounts a draw request will touch before asking for a signature.
+*/
+async function oracleAccounts() {
+	return {
+		identity: await vrfIdentityAddress(),
+		queue: VRF_DEFAULT_QUEUE,
+		program: VRF_PROGRAM_ADDRESS,
+		slotHashes: SLOT_HASHES_SYSVAR
+	};
+}
+//#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, 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, jackpotTiers, 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 };
+
+//# sourceMappingURL=index.js.map