@gabox-labs/sdk 0.7.1 → 0.9.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { DRAW_DISCRIMINATOR, Draw, DrawResolvedEvent, POOL_DISCRIMINATOR, PackBoughtEvent, Pool, PoolCreatedEvent, PrizesFundedEvent, RandomnessRetriedEvent, TokensSoldEvent, WALLET_ACTIVITY_DISCRIMINATOR, WalletActivity, decodeDraw, decodePool, decodeWalletActivity, findActivityPda, findDrawPda, findIdentityPda, findPoolPda, t as index_d_exports } from "./generated/index.js";
-import { $n as assertClusterUrl, Gn as CLUSTER_ENDPOINTS, J as buildMessage, Jn as DEVNET_HTTP, K as BuildOptions, Kn as ClientConfig, Nn as METAPLEX_PROGRAM_ADDRESS, Pn as PLATFORM_ADMIN, Qn as GaboxRpcSubscriptions, Vn as TOKEN_PROGRAM_ADDRESS, Wn as WSOL_MINT, Xn as GaboxClient, Y as withRemainingAccounts, Yn as DEVNET_WS, Zn as GaboxRpc, _n as ASSOCIATED_TOKEN_PROGRAM_ADDRESS, ar as RouteMode, er as clusterNamedBy, ir as Route, nr as defaultRoute, nt as VenueKind, on as LAUNCH_DECIMALS, or as RouteProvider, q as GaboxTransactionMessage, qn as Cluster, rr as websocketUrlFor, t as index_d_exports$1, tr as createClient, tt as ResolvedVenue, zn as SYSTEM_PROGRAM_ADDRESS } from "./index-CA0m7AKk.js";
+import { DRAW_DISCRIMINATOR, Draw, DrawResolvedEvent, POOL_DISCRIMINATOR, PacksBoughtEvent, Pool, PoolCreatedEvent, PrizeClaimedEvent, PrizesFundedEvent, RandomnessRetriedEvent, TokensSoldEvent, WALLET_ACTIVITY_DISCRIMINATOR, WalletActivity, decodeDraw, decodePool, decodeWalletActivity, findActivityPda, findDrawPda, findIdentityPda, findPoolPda, t as index_d_exports } from "./generated/index.js";
+import { Cr as createClient, Dr as RouteMode, Er as Route, Or as RouteProvider, Rn as ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Sr as clusterNamedBy, Tr as websocketUrlFor, _r as DEVNET_WS, br as GaboxRpcSubscriptions, ct as buildMessage, fr as WSOL_MINT, gr as DEVNET_HTTP, gt as VenueKind, hr as Cluster, ht as ResolvedVenue, lr as TOKEN_PROGRAM_ADDRESS, lt as withRemainingAccounts, mr as ClientConfig, nr as PLATFORM_ADMIN, ot as BuildOptions, pr as CLUSTER_ENDPOINTS, sr as SYSTEM_PROGRAM_ADDRESS, st as GaboxTransactionMessage, t as index_d_exports$1, tr as METAPLEX_PROGRAM_ADDRESS, vr as GaboxClient, wn as LAUNCH_DECIMALS, wr as defaultRoute, xr as assertClusterUrl, yr as GaboxRpc } from "./index-CQcBMEah.js";
 import { Address, AddressesByLookupTableAddress, Instruction, InstructionWithData, ProgramDerivedAddress, ReadonlyUint8Array, TransactionSigner } from "@solana/kit";
 //#region src/math.d.ts
 /**
@@ -29,6 +29,22 @@ export declare const MAX_MULTIPLIER_BPS = 200000;
 export declare const TICKETS = 65536;
 /** The prize table has exactly this many slots. Unused slots are all-zero. */
 export declare const TIERS = 8;
+/**
+ * `constants::MAX_BATCH_SIZE`. The most packs one `buy_packs` call opens. A limit per purchase,
+ * not on pending packs: any number of buyers and overlapping purchases are fine, because every
+ * pending draw carries its own reservation.
+ */
+export declare const MAX_BATCH_SIZE = 5;
+/** One pack's outcome inside a settled batch: the tier it landed on and the tokens it pays. */
+export type PackResult = {
+  tier: number;
+  amount: bigint;
+};
+/** What a batch pays: every pack's result in order, and their sum. */
+export type Settlement = {
+  total: bigint;
+  results: PackResult[];
+};
 /** One row of the immutable prize table. Counts, not cumulative thresholds. */
 export type Tier = {
   /** `floor(base * multiplierBps / 10_000)` tokens. `0` only on an unused row. */
@@ -126,6 +142,45 @@ export declare function quote(base: bigint, tiers: readonly Readonly<Tier>[], in
  * A ticket past the last row returns `0`, which cannot happen for a validated table.
  */
 export declare function choose(prizes: readonly Prize[], ticket: number): bigint;
+/** `count` is a `u8` the program bounds at `MAX_BATCH_SIZE`. Zero is refused before any trade. */
+export declare function checkedCount(count: number): number;
+/**
+ * `math::uncapped`. Every tier's award for this base before any inventory cap, `0n` on an unused
+ * row. A ticketed tier that would pay nothing is refused, the same as in `quote`.
+ */
+export declare function uncappedAmounts(base: bigint, tiers: readonly Readonly<Tier>[]): bigint[];
+/** `math::min_tier`. The ticketed tier with the smallest award. Expiry pays it for every pack. */
+export declare function minTier(uncapped: readonly bigint[], tiers: readonly Readonly<Tier>[]): number;
+/**
+ * `math::choose_index`. Which tier a 16-bit ticket lands on: the rows are consecutive ranges in
+ * table order. Exactly 65,536 tickets, so there is no modulo and no bias.
+ */
+export declare function chooseIndex(tiers: readonly Readonly<Tier>[], ticket: number): number;
+/**
+ * `math::reserve_for`. What a purchase of `count` packs adds to `pool.reserved`:
+ * `min(count * uncappedMax, free + count * packTokens)`. Settlement in order can never pay more
+ * than either bound, so this is the least reservation that keeps the vault solvent whatever the
+ * outcomes. With `count = 1` it is exactly the single pack's capped maximum.
+ */
+export declare function reserveFor(count: number, packTokens: bigint, uncappedMax: bigint, free: bigint): bigint;
+/**
+ * `math::settle_with`. Settle a batch in order from explicit tickets.
+ *
+ * Pack k's table caps every tier at what the vault can pay after packs 1..k-1 paid out, counting
+ * the batch's own tokens as they arrive: pack 1 sees `freeSnapshot + packTokens`, and every later
+ * pack sees the remainder plus one more pack. So no pack can lose its own base to an earlier pack,
+ * and the total never exceeds `reserveFor(...)`.
+ *
+ * With `timedOut` every pack pays its smallest tier, and `tickets` is ignored.
+ */
+export declare function settleWith(tiers: readonly Readonly<Tier>[], packTokens: bigint, freeSnapshot: bigint, count: number, tickets: readonly number[], timedOut?: boolean): Settlement;
+/**
+ * The top prize each pack of a purchase can still win if every pack before it won its own top
+ * prize: the worst case for the later packs, which is what a buyer should see next to the first
+ * pack's table. `caps[0]` is the first pack's capped maximum; on a deep vault every entry is the
+ * uncapped jackpot, on a thin one the later entries fall towards one pack.
+ */
+export declare function perPackCaps(tiers: readonly Readonly<Tier>[], packTokens: bigint, freeSnapshot: bigint, count: number): bigint[];
 /** `math::resolve_reservation`. Release the unwon part of a maximum, keep the award reserved. */
 export declare function resolveReservation(reserved: bigint, maximum: bigint, award: bigint): bigint;
 /** The largest `multiplierBps` on any ticketed row. `0` for a table with no rows. */
@@ -141,6 +196,12 @@ export declare function averageMultiplierBps(tiers: readonly Readonly<Tier>[]):
 //#region src/accounts.d.ts
 export declare const DRAW_POOL_OFFSET = 8;
 export declare const DRAW_PURCHASER_OFFSET: number;
+/**
+ * The `settled` byte: after pool, purchaser, nonce, bump, seq_start, count, two slots, attempts,
+ * eight tiers, pack_tokens, free_snapshot and reserved. `test/surface.test.ts` pins it against the
+ * generated encoder.
+ */
+export declare const DRAW_SETTLED_OFFSET: number;
 export declare const POOL_CREATOR_OFFSET = 8;
 export declare const POOL_MINT_OFFSET: number;
 export declare function fetchPoolByMint(client: GaboxClient, mint: Address): Promise<Pool | null>;
@@ -148,7 +209,7 @@ export declare function fetchPoolAt(client: GaboxClient, address: Address): Prom
 export declare function fetchDraw(client: GaboxClient, address: Address): Promise<Draw | null>;
 /**
  * A wallet's lifetime pack-buying activity, or `null` before it has bought its first pack.
- * `buy_pack` creates this account `init_if_needed`, so a fresh wallet has none yet.
+ * `buy_packs` creates this account `init_if_needed`, so a fresh wallet has none yet.
  */
 export declare function fetchWalletActivity(client: GaboxClient, wallet: Address): Promise<WalletActivity | null>;
 export type PoolRecord = {
@@ -167,6 +228,12 @@ export type DrawQuery = {
 export declare function listDraws(client: GaboxClient, query?: DrawQuery): Promise<DrawRecord[]>;
 export declare const listDrawsByPool: (client: GaboxClient, pool: Address) => Promise<DrawRecord[]>;
 export declare const listDrawsByPurchaser: (client: GaboxClient, purchaser: Address) => Promise<DrawRecord[]>;
+/**
+ * A purchaser's draws that settled without paying: the callback could not use the purchaser's coin
+ * account, so the tokens wait in the vault as `owed` until `claimPrize` or `claimPrizeTo` pays
+ * them. A pending draw is not in this list, and a paid one no longer exists.
+ */
+export declare function fetchOwedDraws(client: GaboxClient, purchaser: Address): Promise<DrawRecord[]>;
 export declare function fetchVaultBalance(client: GaboxClient, mint: Address): Promise<bigint>;
 export type PoolInventory = {
   poolAddress: Address;
@@ -196,8 +263,17 @@ export declare const CREATE_MACHINE_COMPUTE_UNITS = 350000;
  * Measured at `178,690`, `163,686` and `157,692` on the curve, and `113,891`, `110,922` and
  * `106,387` on CPMM. The curve buy is dearer because a coin's first trade also creates the platform
  * and creator fee vaults.
+ *
+ * One figure for every `count` from 1 to `MAX_BATCH_SIZE`: a purchase of five packs is still one
+ * trade, one draw and one request. The per-pack work runs in the oracle's callback, on the oracle's
+ * own budget. The devnet end-to-end test re-measures count 1 and 5.
  */
 export declare const BUY_PACK_COMPUTE_UNITS = 235000;
+/**
+ * `claim_prize`: create the purchaser's ATA when it is missing, one transfer, close the draw. An
+ * estimate until the devnet run measures it; a caller may override it.
+ */
+export declare const CLAIM_PRIZE_COMPUTE_UNITS = 80000;
 /**
  * A WSOL wrap, a venue sale, and the WSOL close. Measured at `94,246`, `86,745` and `88,246` on the
  * curve, and `61,545`, `55,576` and `57,046` on CPMM.
@@ -209,6 +285,15 @@ export declare const REDEEM_COMPUTE_UNITS = 125000;
  * on a pool quoted in another token is cheaper, `17,635`, because nothing has to be unwrapped.
  */
 export declare const CLAIM_COMPUTE_UNITS = 55000;
+/**
+ * A harvest of one locked CPMM position: `collect_cp_fees` on the lock program, which withdraws
+ * LP through CPMM and pays both sides out.
+ *
+ * Measured at `102,221` on devnet on 2026-09-19 (tx `5s7xvy23…`), with both token accounts
+ * created in the same transaction and the WSOL one closed again. `82,697` of that is the lock
+ * program itself.
+ */
+export declare const HARVEST_COMPUTE_UNITS = 150000;
 /** An instruction for the compute budget program: no accounts, all of it in the data. */
 export type ComputeBudgetInstruction = Instruction<string, readonly []> & InstructionWithData<ReadonlyUint8Array>;
 export declare function getSetComputeUnitLimitInstruction(units: number): ComputeBudgetInstruction;
@@ -232,14 +317,17 @@ export type GaboxEvent = {
   name: 'PrizesFunded';
   data: PrizesFundedEvent;
 } | {
-  name: 'PackBought';
-  data: PackBoughtEvent;
+  name: 'PacksBought';
+  data: PacksBoughtEvent;
 } | {
   name: 'RandomnessRetried';
   data: RandomnessRetriedEvent;
 } | {
   name: 'DrawResolved';
   data: DrawResolvedEvent;
+} | {
+  name: 'PrizeClaimed';
+  data: PrizeClaimedEvent;
 } | {
   name: 'TokensSold';
   data: TokensSoldEvent;
@@ -255,7 +343,10 @@ export declare function fetchEvents(client: GaboxClient, signature: string): Pro
 export type ResolvedDraw = DrawResolvedEvent & {
   address: Address;
 };
-/** 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.
+ */
 export declare function findResolvedDraw(client: GaboxClient, address: Address): Promise<ResolvedDraw | null>;
 //#endregion
 //#region src/ids.d.ts
@@ -276,7 +367,7 @@ export declare const INSTRUCTIONS_SYSVAR: Address;
 export declare const RETRY_SLOTS = 300n;
 /** `constants.rs`. After this many slots from the purchase, anyone may expire the draw. */
 export declare const TIMEOUT_SLOTS = 216000n;
-/** `constants.rs`. Three requests in total, counting the one `buy_pack` makes. */
+/** `constants.rs`. Three requests in total, counting the one `buy_packs` makes. */
 export declare const MAX_ATTEMPTS = 3;
 /**
  * `constants.rs`. Tokens in one pack, in base units: 1,000,000 tokens at the fixed 6 decimals, or
@@ -315,7 +406,12 @@ export type PackOffer = {
   pool: Address;
   /** The fixed token count of one pack. Every prize is a multiple of this. */
   packTokens: bigint;
-  /** What the venue charges for `packTokens` right now, its own fees included. The pack price. */
+  /** How many packs this offer prices, 1 to `MAX_BATCH_SIZE`. */
+  count: number;
+  /**
+   * What the venue charges for `count` packs right now, its own fees included. The whole purchase
+   * price, in the quote token.
+   */
   quoteAmount: bigint;
   /** The pool's quote asset. Both venues settle in it; there is no native-SOL path. */
   quoteMint: Address;
@@ -324,8 +420,8 @@ export type PackOffer = {
   /** The quote mint's symbol, from Metaplex or Token-2022 metadata. `null` when it has none. */
   quoteSymbol: string | null;
   /**
-   * The same pack price in lamports, through the client's route provider. Equal to `quoteAmount` on
-   * a WSOL pool, and `null` when no route can price it.
+   * The same purchase price in lamports, through the client's route provider. Equal to
+   * `quoteAmount` on a WSOL pool, and `null` when no route can price it.
    */
   solAmount: bigint | null;
   /** What the seed cost the creator at creation, in the quote token. Display only. */
@@ -334,21 +430,33 @@ export type PackOffer = {
   seedTokens: bigint;
   /** Which venue the buy would route to right now. */
   venue: VenueKind;
-  /** The frozen prize table this pack would get: real amounts, already capped by inventory. */
+  /** The first pack's prize table: real amounts, already capped by inventory. */
   prizes: Prize[];
-  /** The top prize, after the cap. Sign `minMaximum` just below this. */
+  /** The first pack's top prize, after the cap. Sign `minFirstMaximum` just below this. */
   maximum: bigint;
-  /** The smallest prize. Also what a timed-out draw pays. */
+  /** The first pack's smallest prize. Also what a timed-out pack pays. */
   minimum: bigint;
   /**
    * The top prize with no inventory cap: the jackpot in tokens. Equal to `maximum` unless the
    * inventory cap bites.
    */
   uncapped: bigint;
+  /**
+   * The top prize each pack can still win if every pack before it won its own top prize. One
+   * entry per pack; `perPackCaps[0]` equals `maximum`.
+   */
+  perPackCaps: bigint[];
+  /**
+   * What this purchase would add to `pool.reserved`:
+   * `min(count * uncapped, free + count * packTokens)`.
+   */
+  batchReserved: bigint;
   /** Vault balance, `pool.reserved`, and the difference. */
   inventory: bigint;
   reserved: bigint;
   free: bigint;
+  /** The same as `free`: the `Draw.freeSnapshot` this purchase would record. */
+  freeSnapshot: bigint;
   /** `pool.nextSeq === 0`. No pack has been sold yet. */
   isFirstPack: boolean;
   /**
@@ -364,6 +472,8 @@ export type PackOffer = {
   averageMultiplierBps: number;
 };
 export type GetOfferOptions = {
+  /** How many packs to price. Defaults to one. */
+  count?: number;
   /** Force a venue instead of reading the LaunchLab pool's `status`. */
   venue?: VenueKind;
   /** The buyer, when you already know it. Only changes the account list, never the numbers. */
@@ -374,7 +484,7 @@ export type GetOfferOptions = {
  * 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`.
  */
 export declare function getOffer(client: GaboxClient, mint: Address, options?: GetOfferOptions): Promise<PackOffer>;
 /** The three display fields `getOffer` reads separately from the price. */
@@ -386,12 +496,12 @@ export type QuoteDisplayFields = {
 /**
  * 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.
  */
-export declare function offerFromState(inventory: PoolInventory, venue: VenueKind, quoteAmount: bigint, display?: QuoteDisplayFields): PackOffer;
+export declare function offerFromState(inventory: PoolInventory, venue: VenueKind, quoteAmount: bigint, display?: QuoteDisplayFields, count?: number): PackOffer;
 /**
  * How short of the top prize a pool is, in tokens. `0` when it pays the whole table.
  *
@@ -404,9 +514,20 @@ export declare function seedShortfall(offer: PackOffer): bigint;
 //#region src/pdas.d.ts
 /** `["pool", mint]`. One pool per coin. */
 export declare const poolAddress: (mint: Address) => Promise<Address>;
-/** `["draw", pool, seq]`, with the sequence as eight little-endian bytes. */
-export declare const drawAddress: (pool: Address, seq: bigint) => Promise<Address>;
-/** The per-wallet `WalletActivity` PDA. `buy_pack` derives it from the purchaser automatically. */
+/**
+ * `["draw", pool, purchaser, nonce]`, with the nonce as eight little-endian bytes. The buyer's
+ * client picks the nonce, so two buyers, or two purchases of one buyer, never name the same draw.
+ * The pool's sequence counter is not in the address any more; the program assigns `seqStart`
+ * when the purchase executes.
+ */
+export declare const drawAddress: (pool: Address, purchaser: Address, nonce: bigint) => Promise<Address>;
+/**
+ * A random `u64` nonce for one purchase. `buyPacks` draws one per build. A nonce that is still in
+ * use fails the purchase at the program; one whose draw already closed names a new draw, so a
+ * rebuilt transaction must never reuse the nonce of a purchase that may have landed.
+ */
+export declare function randomNonce(): bigint;
+/** The per-wallet `WalletActivity` PDA. `buy_packs` derives it from the purchaser automatically. */
 export declare const activityAddress: (wallet: Address) => Promise<Address>;
 /** `["identity"]` under Gabox. The PDA the program signs its randomness request with. */
 export declare const vrfIdentityAddress: () => Promise<Address>;
@@ -565,6 +686,32 @@ export declare function assertRouteIsSafe(route: Route, expect: {
  */
 export declare function solPriceOf(client: GaboxClient, quoteMint: Address, amount: bigint): Promise<bigint | null>;
 //#endregion
+//#region src/settle.d.ts
+/** `math::ticket`. Pack `k`'s 16-bit ticket for this pool and purchase. */
+export declare function ticketFor(randomness: Uint8Array | ReadonlyUint8Array, pool: Address, seqStart: bigint, k: number): Promise<number>;
+export type SettleInput = {
+  /** The pool's tier table, as the draw snapshotted it. */
+  tiers: readonly Readonly<Tier>[];
+  packTokens: bigint;
+  /** `vault - reserved` at purchase, before the batch's own tokens. */
+  freeSnapshot: bigint;
+  count: number;
+  pool: Address;
+  seqStart: bigint;
+  randomness: Uint8Array | ReadonlyUint8Array;
+  /** An expired draw pays every pack its smallest tier; the randomness is then all zero. */
+  timedOut?: boolean;
+};
+/** `math::settle`. What the callback paid, or owed, for this purchase. */
+export declare function settle(input: SettleInput): Promise<Settlement>;
+/**
+ * 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.
+ */
+export declare function settleDraw(draw: Draw): Promise<Settlement>;
+//#endregion
 //#region src/tx/quoteLeg.d.ts
 /** Where the money for a purchase comes from. */
 export type PayWith = 'sol' | 'quote';
@@ -653,18 +800,22 @@ export declare function computeUnitsWithRoute(own: number, leg: QuoteLeg): numbe
  */
 export declare function routeSizeHint(cause: unknown, leg: QuoteLeg): unknown;
 //#endregion
-//#region src/tx/buyPack.d.ts
-export type BuyPackInput = {
+//#region src/tx/buyPacks.d.ts
+export type BuyPacksInput = {
   mint: Address;
   purchaser: TransactionSigner;
+  /** How many packs, 1 to `MAX_BATCH_SIZE`. */
+  count: number;
+  /** The draw's nonce. Left out, a random one is drawn. */
+  nonce?: bigint;
   /**
-   * The venue slippage cap, in the pool's quote token. The transaction puts this much of the quote
-   * token in the buyer's quote account before the buy, so it must cover the real price. Anything
-   * left over stays there, or comes back as SOL on a WSOL pool.
+   * The venue slippage cap for the whole batch, in the pool's quote token. The transaction puts
+   * this much of the quote token in the buyer's quote account before the buy, so it must cover the
+   * real price. Anything left over stays there, or comes back as SOL on a WSOL pool.
    */
   maxQuoteIn: bigint;
-  /** The floor on the top prize this pack may win. Refresh the offer if it fails. */
-  minMaximum: bigint;
+  /** The floor on the first pack's top prize. Refresh the offer if it fails. */
+  minFirstMaximum: bigint;
   /** Caps every lamport the handler sees: venue account rent and the VRF request. */
   maxNativeDebit: bigint;
   /**
@@ -674,10 +825,26 @@ export type BuyPackInput = {
   payWith?: PayWith;
   /** Force a venue instead of reading the LaunchLab pool's `status`. */
   venue?: VenueKind;
-  /** Pin `pool.nextSeq` to make a rebuild fail rather than buy a second pack. */
-  seq?: bigint;
 } & Partial<BuildOptions>;
-export declare function buyPack(client: GaboxClient, input: BuyPackInput): Promise<GaboxTransactionMessage>;
+export type BuyPacksResult = {
+  message: GaboxTransactionMessage;
+  /** The draw this purchase opens. Watch it with `fetchDraw` and `findResolvedDraw`. */
+  draw: Address;
+  nonce: bigint;
+  /**
+   * `pool.nextSeq` when the message was built. The program assigns the real `seqStart` when the
+   * purchase executes, so another buyer landing first moves it; read it from `PacksBought`.
+   */
+  seqStart: bigint;
+  count: number;
+};
+export declare function buyPacks(client: GaboxClient, input: BuyPacksInput): Promise<BuyPacksResult>;
+export type BuyPackInput = Omit<BuyPacksInput, 'count' | 'minFirstMaximum'> & {
+  /** The floor on the top prize this pack may win. Refresh the offer if it fails. */
+  minMaximum: bigint;
+};
+/** One pack: `buyPacks` with `count: 1`. Same result shape, so the draw address is known. */
+export declare function buyPack(client: GaboxClient, input: BuyPackInput): Promise<BuyPacksResult>;
 //#endregion
 //#region src/tx/createMachine.d.ts
 /** Which quote asset a new machine is priced in. Defaults to wrapped SOL. */
@@ -789,20 +956,49 @@ export type RetryDrawInput = {
   draw: Address;
   maxVrfDebit: bigint;
 } & Partial<BuildOptions>;
+/** Another randomness request for a draw whose earlier attempts have not landed. Any signer. */
 export declare function retryDraw(client: GaboxClient, input: RetryDrawInput): Promise<GaboxTransactionMessage>;
 export type ExpireDrawInput = {
   payer: TransactionSigner;
   pool: Address;
   draw: Address;
 } & Partial<BuildOptions>;
+/**
+ * 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.
+ */
 export declare function expireDraw(client: GaboxClient, input: ExpireDrawInput): Promise<GaboxTransactionMessage>;
+export type ClaimPrizeInput = {
+  /** Any signer. Pays the transaction and, when the purchaser's ATA is missing, its rent. */
+  payer: TransactionSigner;
+  draw: Address;
+} & Partial<BuildOptions>;
+/** Pay an owed prize to the purchaser's coin ATA, creating it if needed. Permissionless. */
+export declare function claimPrize(client: GaboxClient, input: ClaimPrizeInput): Promise<GaboxTransactionMessage>;
+export type ClaimPrizeToInput = {
+  /** The draw's purchaser. Nobody else can redirect a prize. */
+  purchaser: TransactionSigner;
+  draw: Address;
+  /** Any existing classic token account for the coin that the purchaser owns. Nothing is created. */
+  destination: Address;
+} & Partial<BuildOptions>;
+/** The purchaser pays their own owed prize to a coin account they name. */
+export declare function claimPrizeTo(client: GaboxClient, input: ClaimPrizeToInput): Promise<GaboxTransactionMessage>;
 export type DrawAvailability = {
   attempts: number;
+  /** True once the callback or an expiry fixed the outcome. `owed` is then what a claim pays. */
+  settled: boolean;
+  owed: bigint;
   slotsUntilRetry: bigint;
   slotsUntilExpiry: bigint;
+  /** The oracle's callback is still accepted: pending, and before the deadline. */
+  canDeliver: boolean;
   canRetry: boolean;
   canExpire: boolean;
+  canClaim: boolean;
 };
+/** What can still happen to a draw, or `null` when it is closed. */
 export declare function drawAvailability(client: GaboxClient, address: Address): Promise<DrawAvailability | null>;
 //#endregion
 //#region src/tx/fundPrizes.d.ts
@@ -865,5 +1061,5 @@ export type OracleAccounts = {
  */
 export declare function oracleAccounts(): Promise<OracleAccounts>;
 //#endregion
-export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BuildOptions, CLUSTER_ENDPOINTS, ClientConfig, Cluster, DEVNET_HTTP, DEVNET_WS, DRAW_DISCRIMINATOR, type Draw, GaboxClient, GaboxRpc, GaboxRpcSubscriptions, GaboxTransactionMessage, LAUNCH_DECIMALS, METAPLEX_PROGRAM_ADDRESS, PLATFORM_ADMIN, POOL_DISCRIMINATOR, type Pool, Route, RouteMode, RouteProvider, SYSTEM_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, WALLET_ACTIVITY_DISCRIMINATOR, WSOL_MINT, type WalletActivity, assertClusterUrl, buildMessage, clusterNamedBy, createClient, decodeDraw, decodePool, decodeWalletActivity, defaultRoute, findActivityPda, findDrawPda, findIdentityPda, findPoolPda, index_d_exports as generated, index_d_exports$1 as raydium, websocketUrlFor, withRemainingAccounts };
+export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BuildOptions, CLUSTER_ENDPOINTS, ClientConfig, Cluster, DEVNET_HTTP, DEVNET_WS, DRAW_DISCRIMINATOR, type Draw, type DrawResolvedEvent, GaboxClient, GaboxRpc, GaboxRpcSubscriptions, GaboxTransactionMessage, LAUNCH_DECIMALS, METAPLEX_PROGRAM_ADDRESS, PLATFORM_ADMIN, POOL_DISCRIMINATOR, type PacksBoughtEvent, type Pool, type PoolCreatedEvent, type PrizeClaimedEvent, type PrizesFundedEvent, type RandomnessRetriedEvent, Route, RouteMode, RouteProvider, SYSTEM_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, type TokensSoldEvent, WALLET_ACTIVITY_DISCRIMINATOR, WSOL_MINT, type WalletActivity, assertClusterUrl, buildMessage, clusterNamedBy, createClient, decodeDraw, decodePool, decodeWalletActivity, defaultRoute, findActivityPda, findDrawPda, findIdentityPda, findPoolPda, index_d_exports as generated, index_d_exports$1 as raydium, websocketUrlFor, withRemainingAccounts };
 //# sourceMappingURL=index.d.ts.map