@gabox-labs/sdk 0.2.0 → 0.7.0

package/dist/index.d.ts

@@ -1,22 +1,30 @@
-import { DRAW_DISCRIMINATOR, Draw, DrawResolvedEvent, DrawStatus, POOL_DISCRIMINATOR, PackBoughtEvent, Pool, PoolCreatedEvent, PrizeRedeemedEvent, PrizesFundedEvent, RandomnessRetriedEvent, Referral, ReferralLink, TokensSoldEvent, decodeDraw, decodePool, findDrawPda, findIdentityPda, findPoolPda, findReferralLinkPda, t as index_d_exports } from "./generated/index.js";
-import { At as ClientConfig, Bt as websocketUrlFor, Ct as PUMP_SWAP_PROGRAM_ADDRESS, Et as SYSTEM_PROGRAM_ADDRESS, Ft as GaboxRpc, It as GaboxRpcSubscriptions, Lt as assertClusterUrl, Mt as DEVNET_HTTP, Nt as DEVNET_WS, Pt as GaboxClient, Rt as clusterNamedBy, bt as PUMP_FEE_PROGRAM_ADDRESS, ct as VenueKind, gt as MAYHEM_PROGRAM_ADDRESS, ht as ASSOCIATED_TOKEN_PROGRAM_ADDRESS, jt as Cluster, kt as CLUSTER_ENDPOINTS, t as index_d_exports$1, xt as PUMP_PROGRAM_ADDRESS, zt as createClient } from "./index-BxvSkzCO.js";
-import { AccountMeta, Address, AddressesByLookupTableAddress, Instruction, InstructionWithData, ProgramDerivedAddress, ReadonlyUint8Array, TransactionMessage, TransactionMessageWithBlockhashLifetime, TransactionMessageWithFeePayerSigner, TransactionSigner } from "@solana/kit";
+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-C4at2cZ_.js";
+import { Address, AddressesByLookupTableAddress, Instruction, InstructionWithData, ProgramDerivedAddress, ReadonlyUint8Array, TransactionSigner } from "@solana/kit";
 //#region src/math.d.ts
 /**
- * A bigint port of `programs/gabox-v2/src/math.rs`.
+ * A bigint port of `programs/gabox/src/math.rs`.
  *
  * The point is that a client can show a buyer the exact prize table the program will freeze into
  * their `Draw`, before they pay. Every rounding step here matches the Rust, including the direction
- * of each division. `test/math.test.ts` runs the same vectors as `programs/gabox-v2/tests/
- * economics.rs`.
+ * of each division. `test/math.test.ts` runs the same vectors as `programs/gabox/tests/math.rs`.
  *
  * All amounts are `bigint`, in the mint's smallest unit. `multiplierBps` and `tickets` are numbers
  * because both are `u32` in the program and both stay small.
  */
 /** Basis points. A multiplier of 10_000 pays back exactly one pack. */
 export declare const BPS = 10000n;
-/** `math::share`. `bps` basis points of `amount`, rounded down. */
-export declare function share(amount: bigint, bps: bigint): bigint;
+/**
+ * `constants::MIN_SEED_MULTIPLIER_BPS`. The mandatory seed makes a 3x top prize payable on the
+ * first pack, or the full top prize when the table's top tier is below 3x. A creator can add more
+ * seed on top through `extraSeedTokens`.
+ */
+export declare const MIN_SEED_MULTIPLIER_BPS = 30000;
+/**
+ * `constants::MAX_MULTIPLIER_BPS`. A table's top tier can be at most 20x. Seed beyond what a 20x
+ * prize needs stays in the vault as backup for the draws after a top-tier hit.
+ */
+export declare const MAX_MULTIPLIER_BPS = 200000;
 /** Ticket counts must sum to this. A uniform 16-bit word then maps with no modulo bias. */
 export declare const TICKETS = 65536;
 /** The prize table has exactly this many slots. Unused slots are all-zero. */
@@ -33,7 +41,7 @@ export type Prize = {
   amount: bigint;
   tickets: number;
 };
-/** What `buy_pack` writes into the `Draw`. `minimum` is also the timeout payout. */
+/** What a pack buy writes into the `Draw`. `minimum` is also the timeout payout. */
 export type Offer = {
   prizes: Prize[];
   maximum: bigint;
@@ -58,9 +66,10 @@ export declare function tierAmount(base: bigint, multiplierBps: number): bigint;
 /**
  * `math::validate`. Checks the table alone, with no base.
  *
- * Three rules, and each one closes a way to sell a bad ticket:
+ * Four rules, and each one closes a way to sell a bad ticket:
  *   - ticket counts sum to exactly 65,536, so the 16-bit draw is uniform;
  *   - an unused row is all-zero, so a hidden multiplier cannot ride along;
+ *   - a ticketed tier's multiplier is from 1 to `MAX_MULTIPLIER_BPS` (20x);
  *   - the expected multiplier over all tickets is at most 1x, so the table cannot promise more
  *     tokens than a pack buys. This bounds tokens, not cash value.
  */
@@ -73,17 +82,22 @@ export declare function validateTiers(tiers: readonly Readonly<Tier>[]): void;
  */
 export declare function validatePack(packTokens: bigint, tiers: readonly Readonly<Tier>[]): void;
 /**
- * `math::seed_tokens`. The seed a table needs, in tokens.
+ * `math::seed_tokens`. The mandatory seed a table needs, in tokens.
  *
- * The first pack must be able to pay the largest tier in full. The pack itself brings `packTokens`
- * into the vault, so the vault has to hold the rest beforehand:
+ * The mandatory seed makes a 3x top prize payable on the first pack, or the full top prize when
+ * the table's top tier is below 3x. A jackpot above 3x still shows the full table once later
+ * packs grow the free vault; the mandatory seed alone does not have to fund it. The pack itself
+ * brings `packTokens` into the vault, so the vault has to hold the rest beforehand:
  *
- *     seedTokens = uncappedMaximum(packTokens, tiers) - packTokens
+ *     seedTokens = min(uncappedMaximum(packTokens, tiers), tierAmount(packTokens, MIN_SEED_MULTIPLIER_BPS)) - packTokens
  *
- * A 5x jackpot on a 1M-token pack needs a 4M-token seed. A table whose top tier pays exactly one
- * pack needs no seed. A top tier below one pack is refused: every ticket would lose.
+ * A 20x or a 3x top tier on a 1M-token pack both need a 2M-token seed, since the mandatory seed
+ * stops at the 3x minimum. A 2x top tier needs a 1M-token seed, already below the minimum. A
+ * table whose top tier pays exactly one pack needs no seed. A top tier below one pack is refused:
+ * every ticket would lose. `createMachine` lets a creator add more seed on top of this mandatory
+ * amount through `extraSeedTokens`, for example to fund a top tier above 3x from the first pack.
  *
- * `initialize_pool` computes this number itself and buys exactly that many tokens on the curve.
+ * Pool initialization computes this number itself and buys exactly that many tokens on the curve.
  * The creator only signs a maximum SOL cost.
  */
 export declare function seedTokens(packTokens: bigint, tiers: readonly Readonly<Tier>[]): bigint;
@@ -125,30 +139,18 @@ export declare function maxMultiplierBps(tiers: readonly Readonly<Tier>[]): numb
 export declare function averageMultiplierBps(tiers: readonly Readonly<Tier>[]): number;
 //#endregion
 //#region src/accounts.d.ts
-/** `Draw.pool` sits straight after the discriminator. */
 export declare const DRAW_POOL_OFFSET = 8;
-/** `Draw.purchaser` sits after the discriminator and `pool`. */
 export declare const DRAW_PURCHASER_OFFSET: number;
-/** `Pool.creator` sits straight after the discriminator. */
 export declare const POOL_CREATOR_OFFSET = 8;
-/** `Pool.mint` sits after the discriminator and `creator`. */
 export declare const POOL_MINT_OFFSET: number;
-/** `ReferralLink.referrer` sits after the discriminator and `referee`. */
-export declare const REFERRAL_LINK_REFERRER_OFFSET: number;
-/** The pool for a coin, or `null` when the coin has no machine. */
 export declare function fetchPoolByMint(client: GaboxClient, mint: Address): Promise<Pool | null>;
-/**
- * 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.
- */
 export declare function fetchPoolAt(client: GaboxClient, address: Address): Promise<Pool | null>;
-/** A draw by address, or `null`. Delivered and legacy-claimed draws are closed. */
 export declare function fetchDraw(client: GaboxClient, address: Address): Promise<Draw | null>;
-/** Accrued referral reward for one referrer and pool, or zero when no referred pack has settled. */
-export declare function fetchReferralReward(client: GaboxClient, pool: Address, referrer: Address): Promise<Referral | 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.
+ */
+export declare function fetchWalletActivity(client: GaboxClient, wallet: Address): Promise<WalletActivity | null>;
 export type PoolRecord = {
   address: Address;
   data: Pool;
@@ -157,81 +159,25 @@ export type DrawRecord = {
   address: Address;
   data: Draw;
 };
-/**
- * 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.
- */
 export declare function listPools(client: GaboxClient): Promise<PoolRecord[]>;
-/** Every draw of one pool, pending or ready. Closed draws are gone and never appear. */
-export declare function listDrawsByPool(client: GaboxClient, pool: Address): Promise<DrawRecord[]>;
-/**
- * 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.
- */
-export declare function listDrawsByPurchaser(client: GaboxClient, purchaser: Address): Promise<DrawRecord[]>;
 export type DrawQuery = {
-  /** A pool PDA. */
   pool?: Address;
-  /** A buyer's wallet. */
   purchaser?: Address;
 };
-/**
- * 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.
- */
 export declare function listDraws(client: GaboxClient, query?: DrawQuery): Promise<DrawRecord[]>;
-export type ReferralLinkRecord = {
-  address: Address;
-  data: ReferralLink;
-};
-/**
- * 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.
- */
-export declare function listReferralLinksByReferrer(client: GaboxClient, referrer: Address): Promise<ReferralLinkRecord[]>;
-/** The vault's token balance. `0` when the vault does not exist yet. */
-export declare function fetchVaultBalance(client: GaboxClient, mint: Address, tokenProgram?: Address): Promise<bigint>;
+export declare const listDrawsByPool: (client: GaboxClient, pool: Address) => Promise<DrawRecord[]>;
+export declare const listDrawsByPurchaser: (client: GaboxClient, purchaser: Address) => Promise<DrawRecord[]>;
+export declare function fetchVaultBalance(client: GaboxClient, mint: Address): Promise<bigint>;
 export type PoolInventory = {
-  pool: Pool;
   poolAddress: Address;
-  vault: Address;
-  /** The vault's whole token balance. */
+  pool: Pool;
   inventory: bigint;
-  /** `pool.reserved`: maximum awards reserved by pending draws. */
   reserved: bigint;
-  /** `inventory - reserved`. What a new pack's prizes can be paid from, besides its own tokens. */
   free: bigint;
 };
-/**
- * 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.
- */
 export declare function fetchPoolInventory(client: GaboxClient, mint: Address): Promise<PoolInventory | null>;
-/** The generated `Tier` uses the same field names as `math.ts`, so this is only a widening. */
 export declare const tiersOf: (pool: Pool) => Tier[];
-/**
- * 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.
- */
-export declare const offerFor: (inventory: PoolInventory, base: bigint) => Offer;
+export declare const quotePool: (inventory: PoolInventory) => Offer;
 //#endregion
 //#region src/compute.d.ts
 export declare const COMPUTE_BUDGET_PROGRAM_ADDRESS: Address;
@@ -240,19 +186,29 @@ export declare const MAX_COMPUTE_UNIT_LIMIT = 1400000;
 /** What an instruction gets when no `SetComputeUnitLimit` is present. */
 export declare const DEFAULT_COMPUTE_UNIT_LIMIT = 200000;
 /**
- * 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. */
-export declare const CREATE_MACHINE_COMPUTE_UNITS = 600000;
-/** A venue buy, an escrow transfer, a draw init and a VRF request. */
-export declare const BUY_PACK_COMPUTE_UNITS = 500000;
-/** A vault transfer, or a vault transfer plus a venue sale. */
-export declare const REDEEM_COMPUTE_UNITS = 300000;
-/** `bind_referrer` riding ahead of a pack: one small account init. */
-export declare const BIND_REFERRER_COMPUTE_UNITS = 50000;
+ * LaunchLab `initialize_v2`, the WSOL wrap, pool initialization with a seed buy, and the WSOL
+ * close, in one transaction. Measured at `266,488`, `258,988` and `267,988` over three devnet runs
+ * against the slot-500297753 build.
+ */
+export declare const CREATE_MACHINE_COMPUTE_UNITS = 350000;
+/**
+ * A WSOL wrap, a venue buy, an escrow transfer, a draw init, a VRF request and the WSOL close.
+ * 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.
+ */
+export declare const BUY_PACK_COMPUTE_UNITS = 235000;
+/**
+ * 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.
+ */
+export declare const REDEEM_COMPUTE_UNITS = 125000;
+/**
+ * A creator fee claim: create the quote account, claim or collect, and close it when it is WSOL.
+ * Measured at `31,319` every run for the LaunchLab claim and `40,959` for the CPMM collect. A claim
+ * on a pool quoted in another token is cheaper, `17,635`, because nothing has to be unwrapped.
+ */
+export declare const CLAIM_COMPUTE_UNITS = 55000;
 /** 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;
@@ -268,58 +224,6 @@ export declare function getSetComputeUnitPriceInstruction(microLamports: number
 /** The compute budget prefix a builder prepends: a limit, and a price only when one is asked for. */
 export declare function computeBudgetInstructions(units: number, microLamports?: number | bigint): ComputeBudgetInstruction[];
 //#endregion
-//#region src/ids.d.ts
-/** `declare_id!` in `programs/gabox-v2/src/lib.rs`. */
-export declare const GABOX_PROGRAM_ID: Address<"GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA">;
-/** Classic SPL Token. The quote side of every Pump trade uses it, because the quote is WSOL. */
-export declare const TOKEN_PROGRAM_ADDRESS: Address;
-/**
- * Token-2022. Pump `create_v2` mints here, so every coin a machine is built on is a Token-2022
- * mint and the pool vault ATA lives under this program.
- */
-export declare const TOKEN_2022_PROGRAM_ADDRESS: Address;
-/** Wrapped SOL. The quote mint on both venues. */
-export declare const WSOL_MINT: Address;
-/** MagicBlock's ephemeral VRF program. `vrf.rs` pins it and refuses any other. */
-export declare const VRF_PROGRAM_ADDRESS: Address;
-/**
- * MagicBlock's default oracle queue. The program pins this one address, so a pool creator cannot
- * point a draw at an oracle they control.
- */
-export declare const VRF_DEFAULT_QUEUE: Address;
-/** The seed of both identity PDAs. See `pdas.ts` — there are two, under different programs. */
-export declare const IDENTITY_SEED: Uint8Array<ArrayBuffer>;
-export declare const SLOT_HASHES_SYSVAR: Address;
-export declare const INSTRUCTIONS_SYSVAR: Address;
-/** `state.rs`. A retry may not run sooner than this after the last attempt. */
-export declare const RETRY_SLOTS = 300n;
-/** `state.rs`. After this many slots from the purchase, anyone may expire the draw. */
-export declare const TIMEOUT_SLOTS = 216000n;
-/** `state.rs`. Three requests in total, counting the one `buy_pack` makes. */
-export declare const MAX_ATTEMPTS = 3;
-/**
- * `state.rs`. Tokens in one pack, in base units: 1,000,000 tokens at Pump's fixed 6 decimals, or
- * 0.1% of the 1,000,000,000 supply. Every pool sells packs of this size. The venue decides what a
- * pack costs, so the pack price follows the coin. Read `pool.packTokens` rather than this when a
- * pool is at hand: a later program version may change the constant.
- */
-export declare const PACK_TOKENS: bigint;
-/** `state.rs`. The creator's per-pack fee, in bps of what the venue charged, may not exceed this. */
-export declare const MAX_FEE_BPS = 100;
-/** Referral reward: 1% of the creator fee, deducted from that fee. */
-export declare const REFERRAL_FEE_BPS = 100n;
-/** `state.rs`. The protocol's share of every pack's venue cost and of every sale's proceeds, in bps. */
-export declare const PROTOCOL_FEE_BPS = 100n;
-/**
- * `PROTOCOL_FEE_COLLECTOR` in `state.rs`. Every pack pays 1% of its venue cost here, on top of
- * that cost. Every sale through the program pays 1% of its proceeds here: SOL on Pump, WSOL (into the
- * collector's WSOL ATA) on PumpSwap. The same key holds the program's upgrade authority.
- *
- * The generated instructions pin it as an `address` constraint, and `test/instruction-data.test.ts`
- * checks this copy against the IDL.
- */
-export declare const PROTOCOL_FEE_COLLECTOR: Address;
-//#endregion
 //#region src/events.d.ts
 export type GaboxEvent = {
   name: 'PoolCreated';
@@ -336,42 +240,51 @@ export type GaboxEvent = {
 } | {
   name: 'DrawResolved';
   data: DrawResolvedEvent;
-} | {
-  name: 'PrizeRedeemed';
-  data: PrizeRedeemedEvent;
 } | {
   name: 'TokensSold';
   data: TokensSoldEvent;
 };
-/** Decode one `Program data:` payload, or `null` when it is not one of ours. */
 export declare function decodeEvent(data: Uint8Array): GaboxEvent | 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.
+ * Decode only Gabox events committed by successful runtime frames. Program logs are emitted before
+ * transaction commit and are forgeable by arbitrary programs, so `Program data` is authenticated
+ * by the canonical invoke/success stack and buffered until every enclosing frame succeeds.
  */
 export declare function decodeEvents(logs: readonly string[]): GaboxEvent[];
-/** Fetch a transaction and decode the gabox events it emitted. */
 export declare function fetchEvents(client: GaboxClient, signature: string): Promise<GaboxEvent[]>;
-export type WatchDrawOptions = {
-  /** Stop watching. The returned promise then rejects with the abort reason. */
-  signal?: AbortSignal;
-  /** Called on every account change, including the ones that are still `Pending`. */
-  onChange?: (draw: Draw) => void;
+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. */
+export declare function findResolvedDraw(client: GaboxClient, address: Address): Promise<ResolvedDraw | null>;
+//#endregion
+//#region src/ids.d.ts
+/** `declare_id!` in `programs/gabox/src/lib.rs`. */
+export declare const GABOX_PROGRAM_ID: Address<"GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA">;
+/** MagicBlock's ephemeral VRF program. `vrf.rs` pins it and refuses any other. */
+export declare const VRF_PROGRAM_ADDRESS: Address;
 /**
- * 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.
+ * MagicBlock's default oracle queue. The program pins this one address, so a pool creator cannot
+ * point a draw at an oracle they control.
+ */
+export declare const VRF_DEFAULT_QUEUE: Address;
+/** The seed of both identity PDAs. See `pdas.ts` — there are two, under different programs. */
+export declare const IDENTITY_SEED: Uint8Array<ArrayBuffer>;
+export declare const SLOT_HASHES_SYSVAR: Address;
+export declare const INSTRUCTIONS_SYSVAR: Address;
+/** `constants.rs`. A retry may not run sooner than this after the last attempt. */
+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. */
+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
+ * 0.1% of the 1,000,000,000 supply. Every pool sells packs of this size. The venue decides what a
+ * pack costs, so the pack price follows the coin. Read `pool.packTokens` rather than this when a
+ * pool is at hand: a later program version may change the constant.
  */
-export declare function watchDraw(client: GaboxClient, address: Address, options?: WatchDrawOptions): Promise<Draw>;
+export declare const PACK_TOKENS: bigint;
 //#endregion
 //#region src/lookupTables.d.ts
 export declare const DEVNET_LOOKUP_TABLE_ADDRESS: Address<"Cx4ri1BU2bnDXPjnJykF3nbY2u4MD5pPvzFCJtNizWFa">;
@@ -386,6 +299,15 @@ export declare const DEVNET_ADDRESS_LOOKUP_TABLES: AddressesByLookupTableAddress
  * supply your own.
  */
 export declare function defaultAddressLookupTables(cluster: Cluster): AddressesByLookupTableAddress;
+/**
+ * Read lookup tables off chain by address, for compressing against tables this SDK does not pin.
+ *
+ * A router picks its own tables per quote, so their contents are only known at run time, and a
+ * message can only be compressed against a table whose addresses are loaded. An address with no
+ * account, a wrong owner, or a malformed body is skipped rather than failing the whole route: the
+ * message then carries those accounts in full, which is correct, only larger.
+ */
+export declare function fetchAddressLookupTables(client: GaboxClient, addresses: Address[]): Promise<AddressesByLookupTableAddress>;
 //#endregion
 //#region src/offer.d.ts
 export type PackOffer = {
@@ -394,16 +316,21 @@ export type PackOffer = {
   /** 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. */
-  quoteLamports: bigint;
-  /** The creator's fee, in bps of `quoteLamports`. */
-  feeBps: number;
-  /** The creator's fee at this price, paid on top of `quoteLamports`. */
-  feeLamports: bigint;
-  /** The protocol's 1% of `quoteLamports`, also paid on top. */
-  protocolLamports: bigint;
-  /** What the seed cost the creator at creation. Display only. */
-  seedLamports: bigint;
-  /** Tokens the seed locked in the vault: `(maxMultiplier - 1x)` packs. */
+  quoteAmount: bigint;
+  /** The pool's quote asset. Both venues settle in it; there is no native-SOL path. */
+  quoteMint: Address;
+  /** The quote mint's decimals, so `quoteAmount` can be shown as a number. */
+  quoteDecimals: number;
+  /** 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.
+   */
+  solAmount: bigint | null;
+  /** What the seed cost the creator at creation, in the quote token. Display only. */
+  seedQuoteAmount: bigint;
+  /** Tokens the seed locked in the vault. Derived from the live table. */
   seedTokens: bigint;
   /** Which venue the buy would route to right now. */
   venue: VenueKind;
@@ -413,8 +340,10 @@ export type PackOffer = {
   maximum: bigint;
   /** The smallest prize. Also what a timed-out draw pays. */
   minimum: bigint;
-  /** The top prize with no inventory cap: the jackpot in tokens. Equal to `maximum` unless the
-   *  inventory cap bites. */
+  /**
+   * The top prize with no inventory cap: the jackpot in tokens. Equal to `maximum` unless the
+   * inventory cap bites.
+   */
   uncapped: bigint;
   /** Vault balance, `pool.reserved`, and the difference. */
   inventory: bigint;
@@ -435,23 +364,34 @@ export type PackOffer = {
   averageMultiplierBps: number;
 };
 export type GetOfferOptions = {
-  /** Force a venue instead of reading the bonding curve's `complete` flag. */
+  /** 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. */
   user?: Address;
 };
 /**
- * The full offer for one machine. Two round trips: the pool and its vault, then the venue.
+ * The full offer for one machine. Three round trips: the pool and its vault, the venue, then the
+ * quote mint and its metadata. A non-SOL pool adds one HTTP call to the route provider for
+ * `solAmount`.
  *
  * Throws when the coin has no pool.
  */
 export declare function getOffer(client: GaboxClient, mint: Address, options?: GetOfferOptions): Promise<PackOffer>;
+/** The three display fields `getOffer` reads separately from the price. */
+export type QuoteDisplayFields = {
+  quoteDecimals: number;
+  quoteSymbol: string | null;
+  solAmount: bigint | null;
+};
 /**
  * The same computation with the reads already done. Useful when a caller holds a `ResolvedVenue`
- * and wants to re-price without touching the network. `quoteLamports` is
+ * and wants to re-price without touching the network. `quoteAmount` is
  * `venue.quoteBuy(pool.packTokens)`.
+ *
+ * `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, quoteLamports: bigint): PackOffer;
+export declare function offerFromState(inventory: PoolInventory, venue: VenueKind, quoteAmount: bigint, display?: QuoteDisplayFields): PackOffer;
 /**
  * How short of the top prize a pool is, in tokens. `0` when it pays the whole table.
  *
@@ -462,337 +402,439 @@ export declare function offerFromState(inventory: PoolInventory, venue: VenueKin
 export declare function seedShortfall(offer: PackOffer): bigint;
 //#endregion
 //#region src/pdas.d.ts
-/** `['referral', referee]`. A wallet's permanent referral binding. */
-export declare function referralLinkAddress(referee: Address): Promise<Address>;
-/** `['referral', pool, referrer]`. A referrer's accrued rewards for one pool. */
-export declare function referralAddress(pool: Address, referrer: Address): Promise<Address>;
-/** `["pool", mint]`. One pool per coin, and the mint alone is the seed. */
-export declare function poolAddress(mint: Address): Promise<Address>;
-/** `["draw", pool, seq_u64_le]`. `seq` is `pool.nextSeq` at the moment of the purchase. */
-export declare function drawAddress(pool: Address, seq: bigint): Promise<Address>;
+/** `["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. */
+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>;
+/** `["identity", gabox_program_id]` under the VRF program. MagicBlock signs the callback with it. */
+export declare function scopedVrfIdentityAddress(): Promise<ProgramDerivedAddress>;
+/** An associated token account under classic SPL Token. */
+export declare const associatedTokenAddress: (owner: Address, mint: Address, tokenProgram?: Address) => Promise<Address>;
+/** The prize vault: the pool PDA's own associated token account for the coin. */
+export declare const vaultAddress: (mint: Address) => Promise<Address>;
+//#endregion
+//#region src/route/cpmm.d.ts
 /**
- * `["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`.
+ * The slippage this provider signs for on a pool swap, in basis points. 1%, the same as the
+ * Jupiter provider's default. It only widens the on-chain bound; the price itself is exact.
  */
-export declare function vrfIdentityAddress(): Promise<Address>;
+export declare const CPMM_ROUTE_SLIPPAGE_BPS = 100n;
 /**
- * `["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.
+ * The compute units one swap through this provider adds to a transaction.
+ *
+ * Measured on devnet on 2026-09-18 against one Raydium CPMM pool, as the difference from the same
+ * builder with no route: `55,110` and `29,272` on `createMachine`, `21,488` and `52,980` on
+ * `buyPack`, and `30,138` and `51,138` on `sellTokens`. The spread is wide because which token
+ * accounts already exist changes from run to run, so this rounds up to the top of it.
+ *
+ * It is a safe figure here and nowhere else: this provider always uses exactly one pool. A router
+ * that may pick several hops states its own number; see `JUPITER_DEFAULT_COMPUTE_UNITS`.
  */
-export declare function scopedVrfIdentityAddress(): Promise<ProgramDerivedAddress>;
+export declare const CPMM_ROUTE_COMPUTE_UNITS = 75000;
 /**
- * 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.
+ * Swap through one named Raydium CPMM pool.
+ *
+ * The pool must hold the pair the route asks for. On devnet the SOL/USDC-test pool with the most
+ * liquidity is `5Eu2G2USTy1pqphmQzQ2SBXWrBq5sdhgEh7hso9R2xix`, under the fee tier
+ * `A9qBhPy4k5UYW72hSgAkh1Epr2do69P54yzzcMV3yv6b`.
  */
-export declare function associatedTokenAddress(owner: Address, mint: Address, tokenProgram?: Address): Promise<Address>;
+export declare function raydiumCpmmRoute(poolAddress: Address): RouteProvider;
+//#endregion
+//#region src/route/jupiter.d.ts
+/** Jupiter's free endpoint. The keyed host `https://api.jup.ag/swap/v1` has the same shape. */
+export declare const JUPITER_LITE_URL = "https://lite-api.jup.ag/swap/v1";
+/** The slippage Jupiter prices a route with when the caller names none. 1%. */
+export declare const JUPITER_DEFAULT_SLIPPAGE_BPS = 100;
+/**
+ * The compute units a Jupiter route is assumed to need when the response carries no limit.
+ *
+ * Jupiter normally sends a `SetComputeUnitLimit` of its own, and that number is what this SDK uses.
+ * When it does not, this is the fallback: enough for a route through several pools, and still far
+ * below the 1,400,000-unit ceiling once the Gabox instruction's own budget is added. A caller who
+ * knows better passes `computeUnitLimit` to the builder.
+ */
+export declare const JUPITER_DEFAULT_COMPUTE_UNITS = 400000;
+export type JupiterRouteOptions = {
+  /** The base URL of the swap API. Defaults to the free `lite-api` host. */
+  url?: string;
+  /** Slippage for the quote, in basis points. Defaults to 100, which is 1%. */
+  slippageBps?: number;
+};
+/** One account as the swap-instructions response writes it. */
+type JupiterAccount = {
+  pubkey: string;
+  isSigner: boolean;
+  isWritable: boolean;
+};
+type JupiterInstruction = {
+  programId: string;
+  accounts: JupiterAccount[];
+  data: string;
+};
+/** The fields of a `swap-instructions` response this SDK reads. */
+export type JupiterSwapInstructions = {
+  /** Read for its unit limit only. These instructions are never copied into the message. */
+  computeBudgetInstructions?: JupiterInstruction[] | null;
+  setupInstructions?: JupiterInstruction[] | null;
+  swapInstruction: JupiterInstruction;
+  cleanupInstruction?: JupiterInstruction | null;
+  addressLookupTableAddresses?: string[] | null;
+};
 /**
- * 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`.
+ * A route provider backed by Jupiter. Use it on mainnet, where Jupiter has the liquidity.
+ *
+ * It makes read-only HTTP calls and never sends a transaction: the instructions come back to the
+ * caller, who signs them together with the Gabox instruction.
  */
-export declare function feeCollectorWsolAddress(): Promise<Address>;
+export declare function jupiterRoute(options?: JupiterRouteOptions): RouteProvider;
 /**
- * The pool's prize inventory: the pool PDA's ATA for the mint's own token program.
+ * Turn a decoded `swap-instructions` response into a `Route`.
  *
- * `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.
+ * Exported so a test can read a recorded response without making an HTTP call. The lookup tables
+ * are read through the client, because the response names them by address only.
  */
-export declare function vaultAddress(mint: Address, tokenProgram?: Address): Promise<Address>;
+export declare function routeFrom(client: GaboxClient, response: JupiterSwapInstructions, amounts: {
+  inAmount: bigint;
+  outAmount: bigint;
+  mode: Route['mode'];
+}): Promise<Route>;
+/**
+ * The unit limit Jupiter asked for, or `JUPITER_DEFAULT_COMPUTE_UNITS` when it asked for none.
+ *
+ * `SetComputeUnitLimit` is five bytes: the tag `2`, then the units as a little-endian u32. Any other
+ * compute budget instruction, such as a unit price, is skipped.
+ */
+export declare function computeUnitsOf(response: JupiterSwapInstructions): number;
+//#endregion
+//#region src/route/leg.d.ts
+/**
+ * The margin added to an exact-in fallback, in basis points.
+ *
+ * An exact-in quote prices one spend. The spend that buys the amount wanted is worked out from that
+ * price, and the price moves against a larger spend, so the result is always a little short without
+ * a margin. 1% is the same order as the slippage a caller already signs for on the pack itself.
+ */
+export declare const EXACT_IN_MARGIN_BPS = 100n;
+/**
+ * A swap that leaves at least `amount` of `quoteMint` in the user's quote account, paid for in SOL.
+ *
+ * Exact-out when the pair has such a route, so the buyer spends only what the pack costs. Exact-in
+ * otherwise, which overshoots on purpose: the leftover quote stays in the buyer's own account.
+ */
+export declare function routeQuoteIn(client: GaboxClient, provider: RouteProvider, input: {
+  quoteMint: Address;
+  amount: bigint;
+  user: Address;
+}): Promise<Route>;
+/**
+ * A swap that turns exactly `amount` of `quoteMint` into SOL.
+ *
+ * `sellTokens` uses it on the proceeds floor it already signs for, so the amount swapped is one the
+ * sale is guaranteed to have produced. Anything the sale paid above that floor stays in the
+ * seller's quote account.
+ */
+export declare function routeQuoteOut(client: GaboxClient, provider: RouteProvider, input: {
+  quoteMint: Address;
+  amount: bigint;
+  user: Address;
+}): Promise<Route>;
+/**
+ * Refuse a route that would touch Gabox state, or that does not settle in the account the program
+ * binds.
+ *
+ * `forbidden` is every Gabox account the transaction itself uses, plus the Gabox program id.
+ * `settlesIn` is the user's quote associated token account: the swap has to name it, because that
+ * is where `buy_pack` measures the quote it spends and where `sell_tokens` measures the proceeds.
+ */
+export declare function assertRouteIsSafe(route: Route, expect: {
+  forbidden: readonly Address[];
+  settlesIn: Address;
+}): void;
+/**
+ * What `amount` of a quote token costs in SOL, through the client's route provider.
+ *
+ * `null` when the client has no provider, or when the provider has no exact-out route. A price is a
+ * display, so a missing one is not an error. A WSOL amount is already SOL and comes back unchanged.
+ *
+ * No fallback to exact-in here on purpose: an exact-in price answers a different question, and a
+ * display that silently swapped the two would be wrong rather than missing.
+ */
+export declare function solPriceOf(client: GaboxClient, quoteMint: Address, amount: bigint): Promise<bigint | null>;
 //#endregion
-//#region src/tx/message.d.ts
-/**
- * What every builder returns: a version 0 message with a fee-payer signer and a blockhash
- * lifetime, ready for `signTransactionMessageWithSigners`.
- *
- * Named, and built only from types `@solana/kit` exports, so the published declaration file
- * refers to kit's types instead of copying them. `pipe`'s inferred type is a long intersection
- * of kit-internal brands, and a copy of a branded type is not assignable to the original.
- */
-export type GaboxTransactionMessage = Extract<TransactionMessage, {
-  version: 0;
-}> & TransactionMessageWithFeePayerSigner & TransactionMessageWithBlockhashLifetime;
-export type BuildOptions = {
-  /** Compute units to request. Each builder passes its own default. */
-  computeUnitLimit: number;
-  /** Priority fee in micro-lamports per compute unit. Left out, no price instruction is added. */
-  computeUnitPrice?: number | bigint;
-  /** Defaults to the client's tables, which the cluster chose. Pass `{}` to disable compression. */
-  addressLookupTables?: AddressesByLookupTableAddress;
+//#region src/tx/quoteLeg.d.ts
+/** Where the money for a purchase comes from. */
+export type PayWith = 'sol' | 'quote';
+/** What a sale pays out. */
+export type Receive = 'sol' | 'quote';
+/** The instructions that go around the Gabox instruction, and what the route did. */
+export type QuoteLeg = {
+  /** Everything that runs before the Gabox instruction. */
+  before: Instruction[];
+  /** Everything that runs after it. */
+  after: Instruction[];
+  /** The lookup tables the route's own instructions need, on top of the client's. */
+  lookupTables: AddressesByLookupTableAddress;
+  /** Which swap mode the route used, or `null` when no route was needed. */
+  mode: RouteMode | null;
+  /** SOL the route spends, or `null` when no route was needed. */
+  solAmount: bigint | null;
+  /**
+   * The compute units the route adds to the transaction, or `0` when there is no route.
+   *
+   * The builder adds this to its own limit, because the swap runs on the same budget. It comes from
+   * the route itself, so a Jupiter route through several pools asks for more than a single-pool one.
+   */
+  computeUnits: number;
 };
+/** The Gabox accounts a route must never name. */
+export type GaboxAccounts = readonly Address[];
+/** Create the wallet's quote account if it is missing. Idempotent, so a second create is free. */
+export declare function createQuoteAccount(owner: TransactionSigner, venue: Pick<ResolvedVenue, 'quoteMint' | 'quoteTokenProgram' | 'userQuoteToken'>): Instruction;
+/**
+ * The leg that puts `maxQuoteIn` of the quote token in the buyer's quote account.
+ *
+ * `payWith` decides where it comes from. On a WSOL pool the choice makes no difference: the quote
+ * token is SOL either way, so the builder wraps it.
+ */
+export declare function quoteLegIn(client: GaboxClient, input: {
+  venue: Pick<ResolvedVenue, 'quoteMint' | 'quoteTokenProgram' | 'userQuoteToken'>;
+  payer: TransactionSigner;
+  maxQuoteIn: bigint;
+  payWith: PayWith;
+  /** Gabox accounts a route must never name. The Gabox program id is added here. */
+  gaboxAccounts: GaboxAccounts;
+}): Promise<QuoteLeg>;
+/**
+ * The leg around a sale: make sure the quote account exists, and turn the proceeds into SOL when
+ * the seller asked for SOL.
+ *
+ * The swap is an exact-in of `minQuoteOutput`, the floor the seller already signs for on the sale
+ * itself. Anything the venue pays above that floor stays in the seller's quote account: a swap can
+ * only spend what the sale is guaranteed to have produced.
+ */
+export declare function quoteLegOut(client: GaboxClient, input: {
+  venue: Pick<ResolvedVenue, 'quoteMint' | 'quoteTokenProgram' | 'userQuoteToken'>;
+  seller: TransactionSigner;
+  minQuoteOutput: bigint;
+  receive: Receive;
+  gaboxAccounts: GaboxAccounts;
+}): Promise<QuoteLeg>;
+/** The client's route provider, with a message that says what to do when it has none. */
+export declare function providerOf(client: GaboxClient, quoteMint: Address): RouteProvider;
 /**
- * Build the message. One RPC read, for the blockhash.
+ * The compute limit a builder asks for: its own budget plus whatever the route needs.
  *
- * The blockhash expires in about a minute, so build the message when the user is ready to sign
- * rather than when the page loads.
+ * Capped at the runtime's ceiling. Jupiter often asks for the whole 1,400,000 units rather than
+ * estimating, and a request above the ceiling is rejected outright, so the sum has to be clamped
+ * rather than passed through.
  */
-export declare function buildMessage(client: GaboxClient, feePayer: TransactionSigner, instructions: Instruction[], options: BuildOptions): Promise<GaboxTransactionMessage>;
-/** Append `remainingAccounts` to a generated instruction, which is how a venue's list is passed. */
-export declare function withRemainingAccounts<T extends Instruction>(instruction: T, remaining: readonly NonNullable<T['accounts']>[number][]): T;
+export declare function computeUnitsWithRoute(own: number, leg: QuoteLeg): number;
+/**
+ * Add the route to a "transaction is too large" error.
+ *
+ * `buildMessage` already refuses a message above the 1,232-byte limit. When a swap is in the same
+ * message, the reason is usually the swap, and the fix is not to split the transaction: the two
+ * halves have to settle together. So the message says what a caller can actually do instead.
+ */
+export declare function routeSizeHint(cause: unknown, leg: QuoteLeg): unknown;
 //#endregion
 //#region src/tx/buyPack.d.ts
 export type BuyPackInput = {
   mint: Address;
-  /** Pays for everything and signs. Becomes `draw.purchaser`. */
   purchaser: TransactionSigner;
-  /** Slippage cap on the venue trade, in lamports (WSOL on PumpSwap). Must be positive. */
+  /**
+   * 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.
+   */
   maxQuoteIn: bigint;
-  /** Floor on the top prize, in tokens. */
+  /** The floor on the top prize this pack may win. Refresh the offer if it fails. */
   minMaximum: bigint;
-  /** Cap on venue debit + creator fee + protocol fee + VRF request, in lamports. Rent and tx fee
-   *  are extra. */
-  maxTotalDebit: bigint;
-  /** Force a venue. Left out, the bonding curve's `complete` flag decides. */
-  venue?: VenueKind;
+  /** Caps every lamport the handler sees: venue account rent and the VRF request. */
+  maxNativeDebit: bigint;
   /**
-   * Pin the draw's sequence number instead of reading `pool.nextSeq` now.
-   *
-   * The draw's address is `["draw", pool, seq]`, so a caller that has already told somebody which
-   * draw this purchase will create has to keep that promise if it rebuilds the message - after a
-   * stale blockhash, say. Rebuilding without a pin reads `nextSeq` again, and if the first attempt
-   * actually landed, the second one buys a **second pack** at the next sequence number rather than
-   * failing. With the pin it fails on the `init` constraint, which is the right outcome.
+   * Pay in SOL through a swap, or in the quote token the buyer already holds. Defaults to `'sol'`.
+   * A WSOL pool ignores it: its quote token is SOL.
    */
+  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;
-  /**
-   * Lamports to wrap into the buyer's WSOL account on the PumpSwap route. Left out, the builder
-   * wraps `maxQuoteIn`: the venue never takes more than that, and any surplus stays in the buyer's
-   * own WSOL account.
-   */
-  wrapLamports?: bigint;
-  /** Append PumpSwap's optional cashback account. Only for a cashback coin. */
-  cashback?: boolean;
-  /**
-   * A referrer to bind before the purchase, in the same transaction.
-   *
-   * A share link leaves the referrer's wallet in a cookie, and the first pack is where it matters:
-   * `bind_referrer` runs one instruction ahead of `buy_pack`, so the pack that converts the buyer
-   * is the pack that pays. Ignored when the buyer already has a link (the chain wins), when it
-   * names the buyer, or when it is the all-zero address. The link's rent is extra, on top of
-   * `maxTotalDebit`.
-   */
-  referrer?: Address;
 } & Partial<BuildOptions>;
 export declare function buyPack(client: GaboxClient, input: BuyPackInput): Promise<GaboxTransactionMessage>;
 //#endregion
 //#region src/tx/createMachine.d.ts
+/** Which quote asset a new machine is priced in. Defaults to wrapped SOL. */
+export type QuoteChoice = {
+  mint: Address;
+};
 export type CreateMachineInput = {
   /** Pays for everything and signs both instructions. Becomes `pool.creator`. */
   creator: TransactionSigner;
-  /** A fresh keypair for the coin. Signs `create_v2` and is never needed again. */
+  /** A fresh keypair for the coin. Signs `initialize_v2` and is never needed again. */
   mintKeypair: TransactionSigner;
+  /** At most 32 UTF-8 bytes. */
   name: string;
+  /** At most 10 UTF-8 bytes. */
   symbol: string;
-  /** The metadata URI Pump writes onto the mint. */
+  /** The metadata URI. At most 200 UTF-8 bytes. */
   uri: string;
-  /** The creator's fee per pack, in bps of what the venue charges. `0` to `MAX_FEE_BPS`. Immutable. */
-  feeBps: number;
   /**
    * The prize table. Immutable once the pool exists. Must pass `validateTiers` and
-   * `validatePack(PACK_TOKENS, tiers)`; the program checks both again on-chain. Defaults to
+   * `validatePack(PACK_TOKENS, tiers)`; the program checks both again on chain. Defaults to
    * `DEFAULT_TIERS`, the table the Gabox app uses.
    */
   tiers?: readonly Readonly<Tier>[];
+  /** The quote asset the machine is priced in. Defaults to wrapped SOL. */
+  quote?: QuoteChoice;
+  /**
+   * `total_quote_fund_raising`, in the quote's own base units. Required for a quote other than
+   * wrapped SOL; a WSOL pool uses the raise the program pins for this cluster.
+   */
+  raise?: bigint;
+  /**
+   * Pay for the seed in SOL through a swap, or in the quote token the creator already holds.
+   * Defaults to `'sol'`. A WSOL pool ignores it: its quote token is SOL.
+   */
+  payWith?: PayWith;
   /**
-   * The creator's slippage cap on the seed buy, in lamports. Pump fails the buy above it.
-   * Take `seedCostEstimate` and add a margin. Ignored for a 1x jackpot, which buys nothing.
+   * Seed slippage cap in the quote token, for `mandatory + extraSeedTokens` together. The
+   * transaction puts this much of the quote token in the creator's quote account before the buy, so
+   * it must cover the real cost. Anything left over stays there, or comes back as SOL on a WSOL
+   * pool.
    */
-  maxSeedLamports: bigint;
-  /** Which Pump fee recipient to use, as an index. Left out, one is picked at random. */
-  feeRecipientIndex?: number;
-  /** Same, for the buyback recipient list. */
-  buybackRecipientIndex?: number;
+  maxSeedQuoteIn: bigint;
+  /**
+   * A separate cap on the lamports the seed buy itself spends. LaunchLab creates its platform and
+   * creator fee vaults on a coin's first trade and charges that rent to the payer, which is the
+   * only SOL the buy touches. It is not the price.
+   */
+  maxSeedNativeDebit: bigint;
+  /**
+   * Extra tokens to seed on top of the mandatory amount `seedTokens(PACK_TOKENS, tiers)` computes.
+   * Defaults to `0n`. Must not be negative.
+   */
+  extraSeedTokens?: bigint;
 } & Partial<BuildOptions>;
 /**
  * Build the transaction message. Sign it with both `creator` and `mintKeypair`.
  *
- * Reads Pump's `Global` account, because two of the buy accounts — the fee recipient and the
- * buyback fee recipient — are chosen from lists held there. Nothing else needs the chain: the coin
+ * Reads the quote's LaunchLab config, the quote mint, and the Gabox platform config, because the
+ * seed price and every quote-side account depend on them. Nothing else needs the chain: the coin
  * does not exist yet, so every other account is a derivation.
  */
 export declare function createMachine(client: GaboxClient, input: CreateMachineInput): Promise<GaboxTransactionMessage>;
+export type SeedCostEstimate = {
+  tiers: readonly Tier[];
+  /** The mandatory seed alone: `seedTokens(PACK_TOKENS, tiers)`. */
+  seedTokens: bigint;
+  /** `options.extraSeedTokens`, defaulted to `0n`. */
+  extraSeedTokens: bigint;
+  /** `seedTokens + extraSeedTokens`. What `createMachine` actually buys in the seed trade. */
+  totalSeedTokens: bigint;
+  /** Exact fresh-curve cost, in the quote token's base units, Raydium's fees included. */
+  quoteAmount: bigint;
+  /** The quote asset the machine would be priced in. */
+  quoteMint: Address;
+  quoteDecimals: number;
+  /** The symbol Metaplex or Token-2022 records for the quote mint, when it has one. */
+  quoteSymbol: string | null;
+  /** `total_quote_fund_raising` the launch would use, in the quote's base units. */
+  raise: bigint;
+  /**
+   * What `quoteAmount` costs in SOL through the client's route provider, or `null` when there is
+   * no provider or no route. Equal to `quoteAmount` on a WSOL pool.
+   */
+  solAmount: bigint | null;
+};
 /**
  * What the seed for this table costs, fees included, and how many tokens it is.
  *
- * The coin does not exist yet, so the price is Pump's default new curve. Nothing else trades on
- * it before `initialize_pool` runs in the same transaction, so this is exact up to a change in
- * Pump's fee settings between the read and the send. Add a small margin for `maxSeedLamports`.
+ * The coin does not exist yet, so the price comes from the starting reserves LaunchLab derives from
+ * the launch shape and the raise. Nothing trades on the curve before `initialize_pool` runs in the
+ * same transaction, so this is exact up to a change in Raydium's fee rates between the read and the
+ * send.
  *
- * Defaults to `DEFAULT_TIERS`. Throws if `tiers` fails `validateTiers`/`validatePack`, or if the
- * seed is bigger than a fresh Pump curve can sell in one buy.
- */
-export declare function seedCostEstimate(client: GaboxClient, tiers?: readonly Readonly<Tier>[]): Promise<{
-  tiers: readonly Tier[];
-  seedTokens: bigint;
-  lamports: bigint;
-}>;
-/**
- * The Pump buy accounts for the seed, built without reading the bonding curve.
+ * `solAmount` is the same cost in SOL, priced through the client's route provider. It is `null`
+ * when the client has no provider, or when no route exists: a devnet client has none unless the
+ * caller passes `raydiumCpmmRoute(pool)`.
  *
- * 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`.
+ * Defaults to `DEFAULT_TIERS`, wrapped SOL and no extra seed. Throws if `tiers` fails
+ * `validateTiers`/`validatePack`, if `extraSeedTokens` is negative, if the total seed is bigger
+ * than the curve sells, or if the raise is missing or below what LaunchLab accepts.
  */
-export declare function pumpSeedBuyAccounts(client: GaboxClient, options: {
-  mint: Address;
-  user: Address;
-  feeRecipientIndex?: number;
-  buybackRecipientIndex?: number;
-}): Promise<AccountMeta[]>;
+export declare function seedCostEstimate(client: GaboxClient, tiers?: readonly Readonly<Tier>[], options?: {
+  extraSeedTokens?: bigint;
+  quote?: QuoteChoice;
+  raise?: bigint;
+}): Promise<SeedCostEstimate>;
 //#endregion
 //#region src/tx/draw.d.ts
 export type RetryDrawInput = {
-  /** Pays the oracle fee and the transaction fee. Any wallet. */
   payer: TransactionSigner;
   pool: Address;
   draw: Address;
-  /** Cap on what the oracle request may take from `payer`, in lamports. */
   maxVrfDebit: bigint;
 } & Partial<BuildOptions>;
 export declare function retryDraw(client: GaboxClient, input: RetryDrawInput): Promise<GaboxTransactionMessage>;
 export type ExpireDrawInput = {
-  /** Only pays the transaction fee. `expire_draw` itself has no signer account. */
   payer: TransactionSigner;
   pool: Address;
   draw: Address;
 } & Partial<BuildOptions>;
 export declare function expireDraw(client: GaboxClient, input: ExpireDrawInput): Promise<GaboxTransactionMessage>;
 export type DrawAvailability = {
-  status: DrawStatus;
   attempts: number;
-  /** Slots remaining before a retry is allowed. `0` when it is allowed now. */
   slotsUntilRetry: bigint;
-  /** Slots remaining before an unanswered draw reaches its expiry deadline. */
   slotsUntilExpiry: bigint;
-  /** All three conditions the program checks for `retry_draw`, together. */
   canRetry: boolean;
-  /** True only when the draw is still `Pending` and its expiry deadline passed. */
   canExpire: boolean;
 };
-/**
- * What a client may do to a draw right now.
- *
- * Reads the draw and the current slot, and reproduces the program's three retry conditions and the
- * pending-status-plus-deadline expiry conditions. Showing a disabled button with a countdown beats
- * sending a transaction that fails with `RetryTooSoon` or `NotPending`.
- */
-export declare function drawAvailability(client: GaboxClient, draw: Address): Promise<DrawAvailability | null>;
+export declare function drawAvailability(client: GaboxClient, address: Address): Promise<DrawAvailability | null>;
 //#endregion
 //#region src/tx/fundPrizes.d.ts
 export type FundPrizesInput = {
   mint: Address;
-  /** The donor. Signs, and the tokens leave its account. */
   funder: TransactionSigner;
-  /** Tokens to donate, in the mint's smallest unit. Must be positive. */
   amount: bigint;
-  /**
-   * The account the tokens come from. Defaults to the funder's associated token account, which is
-   * where a wallet holds them. Any token account the funder is the authority of works.
-   */
   source?: Address;
 } & Partial<BuildOptions>;
 export declare function fundPrizes(client: GaboxClient, input: FundPrizesInput): Promise<GaboxTransactionMessage>;
-export type FundPrizesWithBuyInput = {
-  mint: Address;
-  /** The donor. Buys the tokens, then gives them away. Signs both instructions. */
-  funder: TransactionSigner;
-  /** Exact tokens to buy and donate. `seedShortfall(offer)` is the amount that uncaps the top prize. */
-  tokens: bigint;
-  /** The donor's slippage cap on the buy, in lamports (WSOL on PumpSwap). */
-  maxQuoteIn: bigint;
-  /** Force a venue. Left out, the bonding curve's `complete` flag decides. */
-  venue?: VenueKind;
-  /**
-   * Lamports to wrap on the PumpSwap route. Left out, `maxQuoteIn`. The venue never takes more
-   * than that, and any surplus stays in the donor's own WSOL account.
-   */
-  wrapLamports?: bigint;
-} & Partial<BuildOptions>;
-/**
- * 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.
- */
-export declare function fundPrizesWithBuy(client: GaboxClient, input: FundPrizesWithBuyInput): Promise<GaboxTransactionMessage>;
 //#endregion
 //#region src/tx/redeem.d.ts
 export type SellTokensInput = {
   mint: Address;
-  /** Wallet that owns the tokens and signs the venue sale. */
   seller: TransactionSigner;
-  /** Exact token amount to sell. Must be positive. */
   amount: bigint;
-  /** Floor on the venue's net output, in lamports or WSOL, before the protocol fee. Must be
-   *  positive: the program rejects zero, because a zero floor is not slippage protection. */
+  /** The venue's own floor on the quote token it pays out. Nothing else is taken out of the sale. */
   minQuoteOutput: bigint;
-  /** Force a venue. Left out, the bonding curve's `complete` flag decides. */
-  venue?: VenueKind;
-} & Partial<BuildOptions>;
-/**
- * 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.
- */
-export declare function sellTokens(client: GaboxClient, input: SellTokensInput): Promise<GaboxTransactionMessage>;
-export type ClaimPrizeInput = {
-  mint: Address;
-  /** The wallet that bought the legacy pack. Only it can settle the draw. */
-  purchaser: TransactionSigner;
-  /** The draw to redeem. */
-  draw: Address;
-} & Partial<BuildOptions>;
-/** Transfer a legacy resolve-only award into the purchaser's token account and close the draw. */
-export declare function claimPrize(client: GaboxClient, input: ClaimPrizeInput): Promise<GaboxTransactionMessage>;
-export type SellPrizeInput = ClaimPrizeInput & {
   /**
-   * The seller's floor on the venue's net output, in lamports or WSOL. Must be positive: the
-   * program rejects zero, because a zero floor is not slippage protection.
-   *
-   * This is the venue's own net quote, before the protocol fee. It is not net of the transaction
-   * fee or of any rent the transaction pays.
+   * Caps the lamports the sale itself spends. A sale normally spends none, but LaunchLab charges
+   * the payer for a fee vault it has to create on a coin's first trade.
    */
-  minQuoteOutput: bigint;
-  /** Force a venue. Left out, the bonding curve's `complete` flag decides. */
+  maxNativeDebit: bigint;
+  /**
+   * Take the proceeds as SOL through a swap, or keep them in the quote token. Defaults to `'sol'`.
+   * A WSOL pool ignores it: its quote token is SOL.
+   */
+  receive?: Receive;
   venue?: VenueKind;
-};
-/**
- * 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.
- */
-export declare function sellPrize(client: GaboxClient, input: SellPrizeInput): Promise<GaboxTransactionMessage>;
-/**
- * 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`.
- */
-export declare function quoteSellPrize(client: GaboxClient, mint: Address, draw: Address, user: Address): Promise<{
-  award: bigint;
-  grossOutput: bigint;
-}>;
+} & Partial<BuildOptions>;
+export declare function sellTokens(client: GaboxClient, input: SellTokensInput): Promise<GaboxTransactionMessage>;
 //#endregion
-//#region src/referral.d.ts
-export type ReferralResolution = Readonly<{
-  link: Address;
-  referrer: Address;
-  referral: Address;
+//#region src/tx/wsol.d.ts
+/** The wallet's WSOL account, and the instructions that put `lamports` of spendable WSOL in it. */
+export declare function fundWsol(owner: TransactionSigner, lamports: bigint): Promise<{
+  account: Address;
+  instructions: Instruction[];
 }>;
-/** Resolve the purchaser's permanent referral binding for a pack purchase. */
-export declare function resolveReferral(client: GaboxClient, purchaser: Address, pool: Address): Promise<ReferralResolution | null>;
-/** Bind a wallet to a referrer. The purchaser signs and the binding is permanent. */
-export declare function bindReferrer(client: GaboxClient, referee: TransactionSigner, referrer: Address, options?: Partial<BuildOptions>): Promise<GaboxTransactionMessage>;
-/** Claim all accrued referral rewards for one pool. */
-export declare function claimReferral(client: GaboxClient, referrer: TransactionSigner, pool: Address, options?: Partial<BuildOptions>): Promise<GaboxTransactionMessage>;
+/** Close the WSOL account, sending every lamport in it back to the owner as SOL. */
+export declare function unwrapWsol(owner: TransactionSigner, account: Address): Instruction;
 //#endregion
 //#region src/vrf.d.ts
 /** The four accounts, named as the generated client names them. */
@@ -815,5 +857,5 @@ export type OracleAccounts = {
  */
 export declare function oracleAccounts(): Promise<OracleAccounts>;
 //#endregion
-export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, CLUSTER_ENDPOINTS, ClientConfig, Cluster, DEVNET_HTTP, DEVNET_WS, DRAW_DISCRIMINATOR, type Draw, GaboxClient, GaboxRpc, GaboxRpcSubscriptions, MAYHEM_PROGRAM_ADDRESS, POOL_DISCRIMINATOR, PUMP_FEE_PROGRAM_ADDRESS, PUMP_PROGRAM_ADDRESS, PUMP_SWAP_PROGRAM_ADDRESS, type Pool, type Referral, type ReferralLink, SYSTEM_PROGRAM_ADDRESS, assertClusterUrl, clusterNamedBy, createClient, decodeDraw, decodePool, findDrawPda, findIdentityPda, findPoolPda, findReferralLinkPda, index_d_exports as generated, index_d_exports$1 as pump, websocketUrlFor };
+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 };
 //# sourceMappingURL=index.d.ts.map