@gabox-labs/sdk 0.6.0 → 0.7.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 { An as Cluster, Cn as SYSTEM_PROGRAM_ADDRESS, Dn as WSOL_MINT, Fn as GaboxRpcSubscriptions, G as VenueKind, I as BuildOptions, In as assertClusterUrl, L as GaboxTransactionMessage, Ln as clusterNamedBy, Mn as DEVNET_WS, Nn as GaboxClient, On as CLUSTER_ENDPOINTS, Pn as GaboxRpc, R as buildMessage, Rn as createClient, Wt as LAUNCH_DECIMALS, _n as METAPLEX_PROGRAM_ADDRESS, jn as DEVNET_HTTP, kn as ClientConfig, t as index_d_exports$1, tn as ASSOCIATED_TOKEN_PROGRAM_ADDRESS, vn as PLATFORM_ADMIN, wn as TOKEN_PROGRAM_ADDRESS, z as withRemainingAccounts, zn as websocketUrlFor } from "./index-BDfGvmgF.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
 /**
@@ -187,25 +187,26 @@ export declare const MAX_COMPUTE_UNIT_LIMIT = 1400000;
 export declare const DEFAULT_COMPUTE_UNIT_LIMIT = 200000;
 /**
  * LaunchLab `initialize_v2`, the WSOL wrap, pool initialization with a seed buy, and the WSOL
- * close, in one transaction. Measured at `293,004`, `264,249` and `268,749`. The first run is the
- * worst case: that creator had no LaunchLab fee vault yet, so the transaction created one.
+ * 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 = 385000;
+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 `164,717`, `167,723` and `181,225` on the curve, and `116,332`, `113,342` and
- * `119,334` on CPMM. The curve buy is dearer because a coin's first trade also creates the platform
+ * 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 = 240000;
+export declare const BUY_PACK_COMPUTE_UNITS = 235000;
 /**
- * A WSOL wrap, a venue sale, and the WSOL close. Measured at `93,827`, `93,827` and `101,327` on
- * the curve, and `61,041`, `64,041` and `67,041` on CPMM.
+ * 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 = 135000;
+export declare const REDEEM_COMPUTE_UNITS = 125000;
 /**
- * A creator fee claim: create the WSOL account, claim or collect, close it again. Measured at
- * `31,319` every run for the LaunchLab claim, and `40,959` every run for the CPMM collect.
+ * 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. */
@@ -298,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 = {
@@ -307,9 +317,18 @@ export type PackOffer = {
   packTokens: bigint;
   /** What the venue charges for `packTokens` right now, its own fees included. The pack price. */
   quoteAmount: bigint;
-  /** Always WSOL today. Both venues settle in it; there is no native-SOL path. */
+  /** The pool's quote asset. Both venues settle in it; there is no native-SOL path. */
   quoteMint: Address;
-  /** What the seed cost the creator at creation, in WSOL. Display only. */
+  /** 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;
@@ -351,17 +370,28 @@ export type GetOfferOptions = {
   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. `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, quoteAmount: 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.
  *
@@ -387,19 +417,250 @@ export declare const associatedTokenAddress: (owner: Address, mint: Address, tok
 /** 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
+/**
+ * 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 const CPMM_ROUTE_SLIPPAGE_BPS = 100n;
+/**
+ * The compute units one swap through this provider adds to a transaction.
+ *
+ * Measured on devnet on 2026-09-18 against one Raydium CPMM pool, as the difference from the same
+ * builder with no route: `55,110` and `29,272` on `createMachine`, `21,488` and `52,980` on
+ * `buyPack`, and `30,138` and `51,138` on `sellTokens`. The spread is wide because which token
+ * accounts already exist changes from run to run, so this rounds up to the top of it.
+ *
+ * It is a safe figure here and nowhere else: this provider always uses exactly one pool. A router
+ * that may pick several hops states its own number; see `JUPITER_DEFAULT_COMPUTE_UNITS`.
+ */
+export declare const CPMM_ROUTE_COMPUTE_UNITS = 75000;
+/**
+ * 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 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;
+};
+/**
+ * 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 jupiterRoute(options?: JupiterRouteOptions): RouteProvider;
+/**
+ * Turn a decoded `swap-instructions` response into a `Route`.
+ *
+ * Exported so a test can read a recorded response without making an HTTP call. The lookup tables
+ * are read through the client, because the response names them by address only.
+ */
+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/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;
+/**
+ * The compute limit a builder asks for: its own budget plus whatever the route needs.
+ *
+ * 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 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;
   purchaser: TransactionSigner;
   /**
-   * The venue slippage cap, in WSOL. This many lamports are wrapped before the buy, so it must
-   * cover the real price. Anything left comes back as SOL.
+   * 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;
   /** The floor on the top prize this pack may win. Refresh the offer if it fails. */
   minMaximum: bigint;
   /** Caps every lamport the handler sees: venue account rent and the VRF request. */
   maxNativeDebit: bigint;
+  /**
+   * 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. */
@@ -408,6 +669,10 @@ export type BuyPackInput = {
 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;
@@ -425,10 +690,23 @@ export type CreateMachineInput = {
    * `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;
   /**
-   * Seed slippage cap in WSOL, for `mandatory + extraSeedTokens` together. This is also the number
-   * of lamports wrapped into the creator's WSOL account before the buy, so it must cover the real
-   * cost. Anything left over comes back as SOL when the account is closed.
+   * 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;
+  /**
+   * 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.
    */
   maxSeedQuoteIn: bigint;
   /**
@@ -446,9 +724,9 @@ export type CreateMachineInput = {
 /**
  * Build the transaction message. Sign it with both `creator` and `mintKeypair`.
  *
- * Reads LaunchLab's global config and the Gabox platform config, because the seed price depends on
- * their fee rates. Nothing else needs the chain: the coin does not exist yet, so every other
- * account is a derivation.
+ * 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 = {
@@ -459,25 +737,41 @@ export type SeedCostEstimate = {
   extraSeedTokens: bigint;
   /** `seedTokens + extraSeedTokens`. What `createMachine` actually buys in the seed trade. */
   totalSeedTokens: bigint;
-  /** Exact fresh-curve cost in lamports, Raydium's fees included. */
+  /** Exact fresh-curve cost, in the quote token's base units, Raydium's fees included. */
   quoteAmount: bigint;
-  /** Always WSOL today. */
-  quoteMint: typeof WSOL_MINT;
+  /** 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 comes from the starting reserves LaunchLab derives from
- * the pinned launch shape. 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
+ * 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` and no extra seed. Throws if `tiers` fails
- * `validateTiers`/`validatePack`, if `extraSeedTokens` is negative, or if the total seed is bigger
- * than the curve sells.
+ * `solAmount` is the same cost in SOL, priced through the client's route provider. It is `null`
+ * when the client has no provider, or when no route exists: a devnet client has none unless the
+ * caller passes `raydiumCpmmRoute(pool)`.
+ *
+ * Defaults to `DEFAULT_TIERS`, 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 seedCostEstimate(client: GaboxClient, tiers?: readonly Readonly<Tier>[], options?: {
   extraSeedTokens?: bigint;
+  quote?: QuoteChoice;
+  raise?: bigint;
 }): Promise<SeedCostEstimate>;
 //#endregion
 //#region src/tx/draw.d.ts
@@ -517,13 +811,18 @@ export type SellTokensInput = {
   mint: Address;
   seller: TransactionSigner;
   amount: bigint;
-  /** The venue's own floor on the WSOL it pays out. Nothing else is taken out of the sale. */
+  /** The venue's own floor on the quote token it pays out. Nothing else is taken out of the sale. */
   minQuoteOutput: bigint;
   /**
    * 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.
    */
   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;
 } & Partial<BuildOptions>;
 export declare function sellTokens(client: GaboxClient, input: SellTokensInput): Promise<GaboxTransactionMessage>;
@@ -558,5 +857,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, SYSTEM_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, WALLET_ACTIVITY_DISCRIMINATOR, WSOL_MINT, type WalletActivity, assertClusterUrl, buildMessage, clusterNamedBy, createClient, decodeDraw, decodePool, decodeWalletActivity, 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, 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