@gabox-labs/sdk 0.8.0 → 0.9.0

package/dist/index.js

@@ -1,11 +1,19 @@
-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 readAccounts, $t as vrfIdentityAddress, A as wsolAccountFor, An as tierAmount, Bn as SLOT_HASHES_SYSVAR, Cn as TIERS, Ct as listDrawsByPurchaser, D as quoteAccountFor, Dn as quote, Dr as PLATFORM_ADMIN, E as newCurveReserves, En as maxMultiplierBps, Er as METAPLEX_PROGRAM_ADDRESS, Et as tiersOf, Fn as IDENTITY_SEED, Gt as tokenAccountAmount, Hn as VRF_DEFAULT_QUEUE, I as curveBuyExactOut, In as INSTRUCTIONS_SYSVAR, It as decodeCpmmAmmConfig, J as fetchQuoteAsset, Jt as associatedTokenAddress, Ln as MAX_ATTEMPTS, Lt as decodeCpmmPool, Mn as validatePack, N as cpmmSwapBaseInput, Nn as validateTiers, Nr as TOKEN_PROGRAM_ADDRESS, O as resolveVenue, On as resolveReservation, P as cpmmSwapBaseOutput, Pn as GABOX_PROGRAM_ID, Pr as WSOL_MINT, Qt as vaultAddress, Rn as PACK_TOKENS, S as fetchCurveSettings, Sn as TICKETS, St as listDrawsByPool, Tn as choose, Tr as LAUNCH_TOTAL_BASE_SELL, Tt as quotePool, Un as VRF_PROGRAM_ADDRESS, Vn as TIMEOUT_SLOTS, W as launchlabBuyAccounts, X as fetchQuoteDisplay, Xt as poolAddress, Yt as drawAddress, Zn as LAUNCH_DECIMALS, Zt as scopedVrfIdentityAddress, _ as buildMessage, _n as BPS, _t as fetchPoolByMint, at as HARVEST_COMPUTE_UNITS, b as creatorFeeOnInput, bn as MAX_MULTIPLIER_BPS, bt as fetchWalletActivity, ct as computeBudgetInstructions, dn as launchlabVaultAddress, dt as DRAW_POOL_OFFSET, en as ata, et as BUY_PACK_COMPUTE_UNITS, ft as DRAW_PURCHASER_OFFSET, g as getLaunchInstruction, gt as fetchPoolAt, hn as platformFeeVaultAddress, ht as fetchDraw, in as creatorFeeVaultAddress, it as DEFAULT_COMPUTE_UNIT_LIMIT, jn as uncappedMaximum, jr as SYSTEM_PROGRAM_ADDRESS, kn as seedTokens, lr as ASSOCIATED_TOKEN_PROGRAM_ADDRESS, lt as getSetComputeUnitLimitInstruction, mr as CPMM_SWAP_BASE_OUTPUT, mt as POOL_MINT_OFFSET, nt as COMPUTE_BUDGET_PROGRAM_ADDRESS, ot as MAX_COMPUTE_UNIT_LIMIT, pr as CPMM_SWAP_BASE_INPUT, pt as POOL_CREATOR_OFFSET, q as order, qt as activityAddress, rt as CREATE_MACHINE_COMPUTE_UNITS, sr as raydiumIds, st as REDEEM_COMPUTE_UNITS, t as raydium_exports, tt as CLAIM_COMPUTE_UNITS, un as launchlabPoolAddress, ut as getSetComputeUnitPriceInstruction, v as withRemainingAccounts, vn as DEFAULT_TIERS, vt as fetchPoolInventory, wn as averageMultiplierBps, wt as listPools, xn as MIN_SEED_MULTIPLIER_BPS, xt as listDraws, yn as GaboxMathError, yt as fetchVaultBalance, zn as RETRY_SLOTS } from "./raydium-DIF1WOvI.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 { At as findDrawPda, Ct as getBuyPacksInstructionAsync, I as getFundPrizesInstruction, Mt as WALLET_ACTIVITY_DISCRIMINATOR, Nt as decodeWalletActivity, Ot as findPoolPda, Ut as POOL_DISCRIMINATOR, W as getExpireDrawInstruction, Wt as decodePool, b as getRetryDrawInstruction, en as DRAW_DISCRIMINATOR, ht as getClaimPrizeInstructionAsync, jt as findActivityPda, k as getInitializePoolInstructionAsync, kt as findIdentityPda, p as getSellTokensInstructionAsync, st as getClaimPrizeToInstructionAsync, tn as decodeDraw } from "./gabox-CuyJYmrS.js";
+import { $ as readAccounts, $n as uncappedMaximum, $t as poolAddress, A as wsolAccountFor, An as VRF_PROGRAM_ADDRESS, Bn as checkedCount, Bt as decodeCpmmPool, Cn as INSTRUCTIONS_SYSVAR, Ct as fetchWalletActivity, D as quoteAccountFor, Dn as SLOT_HASHES_SYSVAR, Dt as listPools, E as newCurveReserves, En as RETRY_SLOTS, Er as CPMM_SWAP_BASE_OUTPUT, Et as listDrawsByPurchaser, Fn as MAX_MULTIPLIER_BPS, Gn as perPackCaps, Gr as TOKEN_PROGRAM_ADDRESS, Hn as chooseIndex, I as curveBuyExactOut, In as MIN_SEED_MULTIPLIER_BPS, J as fetchQuoteAsset, Jn as resolveReservation, Jt as tokenAccountAmount, Kn as quote, Kr as WSOL_MINT, Ln as TICKETS, Lr as LAUNCH_TOTAL_BASE_SELL, Mn as DEFAULT_TIERS, N as cpmmSwapBaseInput, Nn as GaboxMathError, O as resolveVenue, On as TIMEOUT_SLOTS, Ot as quotePool, P as cpmmSwapBaseOutput, Pn as MAX_BATCH_SIZE, Qn as uncappedAmounts, Qt as drawAddress, Rn as TIERS, Rr as METAPLEX_PROGRAM_ADDRESS, S as fetchCurveSettings, Sn as IDENTITY_SEED, St as fetchVaultBalance, Tn as PACK_TOKENS, Tr as CPMM_SWAP_BASE_INPUT, Tt as listDrawsByPool, Un as maxMultiplierBps, Ur as SYSTEM_PROGRAM_ADDRESS, Vn as choose, W as launchlabBuyAccounts, Wn as minTier, X as fetchQuoteDisplay, Xn as settleWith, Xt as activityAddress, Yn as seedTokens, Zn as tierAmount, Zt as associatedTokenAddress, _ as buildMessage, _t as fetchDraw, at as DEFAULT_COMPUTE_UNIT_LIMIT, b as creatorFeeOnInput, bt as fetchPoolByMint, cn as creatorFeeVaultAddress, ct as REDEEM_COMPUTE_UNITS, dt as getSetComputeUnitPriceInstruction, en as randomNonce, er as validatePack, et as BUY_PACK_COMPUTE_UNITS, ft as DRAW_POOL_OFFSET, g as getLaunchInstruction, gt as POOL_MINT_OFFSET, hn as launchlabVaultAddress, ht as POOL_CREATOR_OFFSET, in as ata, it as CREATE_MACHINE_COMPUTE_UNITS, jn as BPS, kn as VRF_DEFAULT_QUEUE, kt as tiersOf, lr as LAUNCH_DECIMALS, lt as computeBudgetInstructions, mn as launchlabPoolAddress, mt as DRAW_SETTLED_OFFSET, nn as vaultAddress, nt as CLAIM_PRIZE_COMPUTE_UNITS, ot as HARVEST_COMPUTE_UNITS, pt as DRAW_PURCHASER_OFFSET, q as order, qn as reserveFor, rn as vrfIdentityAddress, rt as COMPUTE_BUDGET_PROGRAM_ADDRESS, st as MAX_COMPUTE_UNIT_LIMIT, t as raydium_exports, tn as scopedVrfIdentityAddress, tr as validateTiers, tt as CLAIM_COMPUTE_UNITS, ut as getSetComputeUnitLimitInstruction, v as withRemainingAccounts, vt as fetchOwedDraws, wn as MAX_ATTEMPTS, wt as listDraws, xn as GABOX_PROGRAM_ID, xr as ASSOCIATED_TOKEN_PROGRAM_ADDRESS, xt as fetchPoolInventory, yn as platformFeeVaultAddress, yr as raydiumIds, yt as fetchPoolAt, zn as averageMultiplierBps, zr as PLATFORM_ADMIN, zt as decodeCpmmAmmConfig } from "./raydium-DXUJ-g1p.js";
+import { DRAW_RESOLVED_EVENT_DISCRIMINATOR, PACKS_BOUGHT_EVENT_DISCRIMINATOR, POOL_CREATED_EVENT_DISCRIMINATOR, PRIZES_FUNDED_EVENT_DISCRIMINATOR, PRIZE_CLAIMED_EVENT_DISCRIMINATOR, RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR, TOKENS_SOLD_EVENT_DISCRIMINATOR, getDrawResolvedEventDecoder, getPacksBoughtEventDecoder, getPoolCreatedEventDecoder, getPrizeClaimedEventDecoder, getPrizesFundedEventDecoder, getRandomnessRetriedEventDecoder, getTokensSoldEventDecoder, t as generated_exports } from "./generated/index.js";
+import { AccountRole, address, createNoopSigner, createSolanaRpc, createSolanaRpcSubscriptions, getAddressDecoder, getAddressEncoder, getBase64Encoder, getU64Encoder } from "@solana/kit";
 import { getCloseAccountInstruction, getCreateAssociatedTokenIdempotentInstruction, getSyncNativeInstruction } from "@solana-program/token";
 import { getTransferSolInstruction } from "@solana-program/system";
 //#region src/events.ts
-/** Decode Gabox's Anchor events. Draw accounts are closed on delivery; use `DrawResolved` as final state. */
+/**
+* Decode Gabox's Anchor events.
+*
+* A paid delivery closes the draw account, so `DrawResolved` is its final state. An owed delivery
+* (`paid: false`) leaves the draw open and settled until `claim_prize` pays it, and `PrizeClaimed`
+* closes that story. Events are a convenience for indexers: what a pack won never depends on them.
+* An owed draw carries everything on chain (`settleDraw`), and a paid draw's randomness is in the
+* oracle's transaction on the ledger.
+*/
 const b64 = getBase64Encoder();
 const starts = (a, b) => a.length >= b.length && b.every((v, i) => a[i] === v);
 function decodeEvent(data) {
@@ -17,9 +25,9 @@ function decodeEvent(data) {
 		name: "PrizesFunded",
 		data: getPrizesFundedEventDecoder().decode(data)
 	};
-	if (starts(data, PACK_BOUGHT_EVENT_DISCRIMINATOR)) return {
-		name: "PackBought",
-		data: getPackBoughtEventDecoder().decode(data)
+	if (starts(data, PACKS_BOUGHT_EVENT_DISCRIMINATOR)) return {
+		name: "PacksBought",
+		data: getPacksBoughtEventDecoder().decode(data)
 	};
 	if (starts(data, RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR)) return {
 		name: "RandomnessRetried",
@@ -29,6 +37,10 @@ function decodeEvent(data) {
 		name: "DrawResolved",
 		data: getDrawResolvedEventDecoder().decode(data)
 	};
+	if (starts(data, PRIZE_CLAIMED_EVENT_DISCRIMINATOR)) return {
+		name: "PrizeClaimed",
+		data: getPrizeClaimedEventDecoder().decode(data)
+	};
 	if (starts(data, TOKENS_SOLD_EVENT_DISCRIMINATOR)) return {
 		name: "TokensSold",
 		data: getTokensSoldEventDecoder().decode(data)
@@ -107,7 +119,10 @@ async function readEvents(rpc, signature) {
 	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. */
+/**
+* The `DrawResolved` event of one draw, found through the draw address's own signature history.
+* `paid` says whether the tokens reached the purchaser in the callback or wait for a claim.
+*/
 async function findResolvedDraw(client, address) {
 	let before;
 	for (let page = 0; page < 10; page++) {
@@ -120,7 +135,7 @@ async function findResolvedDraw(client, address) {
 			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 {
+				if (event.data.draw === address) return {
 					...event.data,
 					address
 				};
@@ -439,9 +454,10 @@ const messageOf = (cause) => cause instanceof Error ? cause.message : String(cau
 * 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.
+* Throws when the coin has no pool, or when the curve has fewer whole packs left than `count`.
 */
 async function getOffer(client, mint, options = {}) {
+	const count = checkedCount(options.count ?? 1);
 	const inventory = await fetchPoolInventory(client, mint);
 	if (!inventory) throw new Error(`no gabox pool for mint ${mint}`);
 	const { pool } = inventory;
@@ -455,18 +471,18 @@ async function getOffer(client, mint, options = {}) {
 		},
 		...options.venue ? { venue: options.venue } : {}
 	});
-	const quoteAmount = venue.quoteBuy(pool.packTokens);
+	const quoteAmount = venue.quoteBuy(pool.packTokens * BigInt(count));
 	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)
-	});
+	}, count);
 }
 /**
 * 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)`.
+* `venue.quoteBuy(pool.packTokens * count)`.
 *
 * `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.
@@ -475,7 +491,8 @@ function offerFromState(inventory, venue, quoteAmount, display = {
 	quoteDecimals: 0,
 	quoteSymbol: null,
 	solAmount: null
-}) {
+}, count = 1) {
+	checkedCount(count);
 	const { pool } = inventory;
 	const tiers = tiersOf(pool);
 	const offer = quote(pool.packTokens, tiers, inventory.inventory, inventory.reserved);
@@ -484,6 +501,7 @@ function offerFromState(inventory, venue, quoteAmount, display = {
 		mint: pool.mint,
 		pool: inventory.poolAddress,
 		packTokens: pool.packTokens,
+		count,
 		quoteAmount,
 		quoteMint: pool.quoteMint,
 		quoteDecimals: display.quoteDecimals,
@@ -496,9 +514,12 @@ function offerFromState(inventory, venue, quoteAmount, display = {
 		maximum: offer.maximum,
 		minimum: offer.minimum,
 		uncapped,
+		perPackCaps: perPackCaps(tiers, pool.packTokens, inventory.free, count),
+		batchReserved: reserveFor(count, pool.packTokens, uncapped, inventory.free),
 		inventory: inventory.inventory,
 		reserved: inventory.reserved,
 		free: inventory.free,
+		freeSnapshot: inventory.free,
 		isFirstPack: pool.nextSeq === 0n,
 		isSeeded: offer.maximum === uncapped,
 		maxMultiplierBps: maxMultiplierBps(tiers),
@@ -988,6 +1009,57 @@ function defaultRoute(cluster) {
 	return cluster === "mainnet-beta" ? jupiterRoute() : null;
 }
 //#endregion
+//#region src/settle.ts
+/**
+* Reproduce a batch's settlement from the randomness the oracle published.
+*
+* The program settles every pack of a purchase inside one callback, from one 32-byte randomness:
+* pack k's ticket is the first two bytes of `sha256(randomness || pool || seqStart || k)`, read
+* little-endian, and its prize table is capped at what the vault can pay after the packs before it.
+* Everything that goes in is either on the `Draw` account or in the `DrawResolved` event, so anyone
+* can recompute what each pack won. `math.ts` holds the pure part; this file adds the hash, which
+* is asynchronous because it goes through WebCrypto.
+*/
+/** `math::ticket`. Pack `k`'s 16-bit ticket for this pool and purchase. */
+async function ticketFor(randomness, pool, seqStart, k) {
+	if (randomness.length !== 32) throw new Error("randomness is 32 bytes");
+	const bytes = /* @__PURE__ */ new Uint8Array(73);
+	bytes.set(randomness, 0);
+	bytes.set(getAddressEncoder().encode(pool), 32);
+	bytes.set(getU64Encoder().encode(seqStart), 64);
+	bytes[72] = k;
+	const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+	return hash[0] | hash[1] << 8;
+}
+/** `math::settle`. What the callback paid, or owed, for this purchase. */
+async function settle(input) {
+	const timedOut = input.timedOut ?? false;
+	const tickets = timedOut ? [] : await Promise.all(Array.from({ length: input.count }, (_, k) => ticketFor(input.randomness, input.pool, input.seqStart, k)));
+	return settleWith(input.tiers, input.packTokens, input.freeSnapshot, input.count, tickets, timedOut);
+}
+/**
+* The settlement of a draw that is still on chain: settled but not yet claimed. The account alone
+* carries everything, so this needs no event and no indexer. `total` equals `draw.owed`.
+*
+* A pending draw (`settled === false`) has no randomness yet; this throws for it.
+*/
+async function settleDraw(draw) {
+	if (!draw.settled) throw new Error("the draw is not settled yet; there is no randomness to settle from");
+	return await settle({
+		tiers: draw.tiers.map(({ multiplierBps, tickets }) => ({
+			multiplierBps,
+			tickets
+		})),
+		packTokens: draw.packTokens,
+		freeSnapshot: draw.freeSnapshot,
+		count: draw.count,
+		pool: draw.pool,
+		seqStart: draw.seqStart,
+		randomness: draw.randomness,
+		timedOut: draw.timedOut
+	});
+}
+//#endregion
 //#region src/tx/wsol.ts
 /**
 * Wrapping and unwrapping SOL around a venue trade.
@@ -1210,8 +1282,9 @@ function routeSizeHint(cause, leg) {
 	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) {
+//#region src/tx/buyPacks.ts
+async function buyPacks(client, input) {
+	const count = checkedCount(input.count);
 	if (input.maxQuoteIn <= 0n) throw new Error("maxQuoteIn must be positive");
 	if (input.maxNativeDebit < 0n) throw new Error("maxNativeDebit must not be negative");
 	const inventory = await fetchPoolInventory(client, input.mint);
@@ -1228,8 +1301,14 @@ async function buyPack(client, input) {
 		},
 		...input.venue ? { venue: input.venue } : {}
 	});
-	const draw = await drawAddress(poolAddress, input.seq ?? pool.nextSeq);
-	const buy = await getBuyPackInstructionAsync({
+	const tokens = pool.packTokens * BigInt(count);
+	if (venue.kind === "launchlab" && venue.remainingCurveBase < tokens) {
+		const left = venue.remainingCurveBase / pool.packTokens;
+		throw new Error(`the curve has ${left} whole pack(s) left and this purchase asks for ${count}. The program needs the exact amount, so buy fewer packs or wait for the coin to graduate.`);
+	}
+	const nonce = input.nonce ?? randomNonce();
+	const draw = await drawAddress(poolAddress, purchaser, nonce);
+	const buy = await getBuyPacksInstructionAsync({
 		purchaser: input.purchaser,
 		pool: poolAddress,
 		draw,
@@ -1238,8 +1317,10 @@ async function buyPack(client, input) {
 		vault: pool.vault,
 		venue: venue.program,
 		quoteTokenProgram: pool.quoteTokenProgram,
+		count,
+		nonce,
 		maxQuoteIn: input.maxQuoteIn,
-		minMaximum: input.minMaximum,
+		minFirstMaximum: input.minFirstMaximum,
 		maxNativeDebit: input.maxNativeDebit
 	});
 	const leg = await quoteLegIn(client, {
@@ -1261,18 +1342,33 @@ async function buyPack(client, input) {
 		...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 }
-		});
+		return {
+			message: 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 }
+			}),
+			draw,
+			nonce,
+			seqStart: pool.nextSeq,
+			count
+		};
 	} catch (cause) {
 		throw routeSizeHint(cause, leg);
 	}
 }
+/** One pack: `buyPacks` with `count: 1`. Same result shape, so the draw address is known. */
+async function buyPack(client, input) {
+	const { minMaximum, ...rest } = input;
+	return await buyPacks(client, {
+		...rest,
+		count: 1,
+		minFirstMaximum: minMaximum
+	});
+}
 //#endregion
 //#region src/tx/createMachine.ts
 /**
@@ -1435,6 +1531,12 @@ function assertSeedFitsCurve(seed) {
 //#endregion
 //#region src/tx/draw.ts
 const DRAW_COMPUTE_UNITS = 2e5;
+const options = (input, computeUnitLimit) => ({
+	...input.addressLookupTables === void 0 ? {} : { addressLookupTables: input.addressLookupTables },
+	computeUnitLimit: input.computeUnitLimit ?? computeUnitLimit,
+	...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+});
+/** Another randomness request for a draw whose earlier attempts have not landed. Any signer. */
 async function retryDraw(client, input) {
 	const ix = await getRetryDrawInstruction({
 		payer: input.payer,
@@ -1443,15 +1545,17 @@ async function retryDraw(client, input) {
 		identity: await vrfIdentityAddress(),
 		maxVrfDebit: input.maxVrfDebit
 	});
-	return await buildMessage(client, input.payer, [ix], {
-		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? DRAW_COMPUTE_UNITS,
-		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
-	});
+	return await buildMessage(client, input.payer, [ix], options(input, DRAW_COMPUTE_UNITS));
 }
+/**
+* Fix a timed-out purchase at every pack's smallest tier, from `TIMEOUT_SLOTS` after the purchase.
+* Any signer. The purchaser's ATA address is passed whether or not the account exists: the program
+* pays it if it can and owes the total otherwise.
+*/
 async function expireDraw(client, input) {
 	const draw = await fetchDraw(client, input.draw);
 	if (!draw || draw.pool !== input.pool) throw new Error("draw does not belong to pool or was already delivered");
+	if (draw.settled) throw new Error("the draw is settled; use claimPrize to pay what it owes");
 	const pool = await fetchPoolAt(client, input.pool);
 	if (!pool) throw new Error(`no pool at ${input.pool}`);
 	const ix = getExpireDrawInstruction({
@@ -1462,12 +1566,45 @@ async function expireDraw(client, input) {
 		vault: pool.vault,
 		userTokens: await associatedTokenAddress(draw.purchaser, pool.mint)
 	});
-	return await buildMessage(client, input.payer, [ix], {
-		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? DRAW_COMPUTE_UNITS,
-		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+	return await buildMessage(client, input.payer, [ix], options(input, DRAW_COMPUTE_UNITS));
+}
+/** Pay an owed prize to the purchaser's coin ATA, creating it if needed. Permissionless. */
+async function claimPrize(client, input) {
+	const draw = await fetchDraw(client, input.draw);
+	if (!draw) throw new Error(`no draw at ${input.draw}; a paid draw is closed and owes nothing`);
+	if (!draw.settled) throw new Error("the draw is still pending; nothing is owed yet");
+	const pool = await fetchPoolAt(client, draw.pool);
+	if (!pool) throw new Error(`no pool at ${draw.pool}`);
+	const ix = await getClaimPrizeInstructionAsync({
+		payer: input.payer,
+		pool: draw.pool,
+		draw: input.draw,
+		purchaser: draw.purchaser,
+		mint: pool.mint,
+		vault: pool.vault,
+		userTokens: await associatedTokenAddress(draw.purchaser, pool.mint)
+	});
+	return await buildMessage(client, input.payer, [ix], options(input, CLAIM_PRIZE_COMPUTE_UNITS));
+}
+/** The purchaser pays their own owed prize to a coin account they name. */
+async function claimPrizeTo(client, input) {
+	const draw = await fetchDraw(client, input.draw);
+	if (!draw) throw new Error(`no draw at ${input.draw}; a paid draw is closed and owes nothing`);
+	if (!draw.settled) throw new Error("the draw is still pending; nothing is owed yet");
+	if (draw.purchaser !== input.purchaser.address) throw new Error("only the purchaser can redirect a prize");
+	const pool = await fetchPoolAt(client, draw.pool);
+	if (!pool) throw new Error(`no pool at ${draw.pool}`);
+	const ix = await getClaimPrizeToInstructionAsync({
+		purchaser: input.purchaser,
+		pool: draw.pool,
+		draw: input.draw,
+		mint: pool.mint,
+		vault: pool.vault,
+		destination: input.destination
 	});
+	return await buildMessage(client, input.purchaser, [ix], options(input, CLAIM_PRIZE_COMPUTE_UNITS));
 }
+/** What can still happen to a draw, or `null` when it is closed. */
 async function drawAvailability(client, address) {
 	const draw = await fetchDraw(client, address);
 	if (!draw) return null;
@@ -1476,12 +1613,17 @@ async function drawAvailability(client, address) {
 	const expireAt = draw.requestSlot + TIMEOUT_SLOTS;
 	const slotsUntilRetry = now >= retryAt ? 0n : retryAt - now;
 	const slotsUntilExpiry = now >= expireAt ? 0n : expireAt - now;
+	const pending = !draw.settled;
 	return {
 		attempts: draw.attempts,
+		settled: draw.settled,
+		owed: draw.owed,
 		slotsUntilRetry,
 		slotsUntilExpiry,
-		canRetry: draw.attempts < 3 && slotsUntilRetry === 0n && slotsUntilExpiry > 0n,
-		canExpire: slotsUntilExpiry === 0n
+		canDeliver: pending && slotsUntilExpiry > 0n,
+		canRetry: pending && draw.attempts < 3 && slotsUntilRetry === 0n && slotsUntilExpiry > 0n,
+		canExpire: pending && slotsUntilExpiry === 0n,
+		canClaim: draw.settled
 	};
 }
 //#endregion
@@ -1581,6 +1723,6 @@ async function oracleAccounts() {
 	};
 }
 //#endregion
-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, HARVEST_COMPUTE_UNITS, 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, quoteLegFromWallet, 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 };
+export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BPS, BUY_PACK_COMPUTE_UNITS, CLAIM_COMPUTE_UNITS, CLAIM_PRIZE_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, DRAW_SETTLED_OFFSET, EXACT_IN_MARGIN_BPS, GABOX_PROGRAM_ID, GaboxMathError, HARVEST_COMPUTE_UNITS, IDENTITY_SEED, INSTRUCTIONS_SYSVAR, JUPITER_DEFAULT_COMPUTE_UNITS, JUPITER_DEFAULT_SLIPPAGE_BPS, JUPITER_LITE_URL, LAUNCH_DECIMALS, MAX_ATTEMPTS, MAX_BATCH_SIZE, 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, buyPacks, checkedCount, choose, chooseIndex, claimPrize, claimPrizeTo, clusterNamedBy, computeBudgetInstructions, computeUnitsOf, computeUnitsWithRoute, createClient, createMachine, createQuoteAccount, decodeDraw, decodeEvent, decodeEvents, decodePool, decodeWalletActivity, defaultAddressLookupTables, defaultRoute, drawAddress, drawAvailability, expireDraw, fetchAddressLookupTables, fetchDraw, fetchEvents, fetchOwedDraws, 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, minTier, offerFromState, oracleAccounts, perPackCaps, poolAddress, providerOf, quote, quoteLegFromWallet, quoteLegIn, quoteLegOut, quotePool, randomNonce, raydium_exports as raydium, raydiumCpmmRoute, reserveFor, resolveReservation, retryDraw, routeFrom, routeQuoteIn, routeQuoteOut, routeSizeHint, scopedVrfIdentityAddress, seedCostEstimate, seedShortfall, seedTokens, sellTokens, settle, settleDraw, settleWith, solPriceOf, ticketFor, tierAmount, tiersOf, uncappedAmounts, uncappedMaximum, unwrapWsol, validatePack, validateTiers, vaultAddress, vrfIdentityAddress, websocketUrlFor, withRemainingAccounts };
 
 //# sourceMappingURL=index.js.map