@gabox-labs/sdk 0.6.0 → 0.7.1

package/dist/index.js

@@ -1,457 +1,9 @@
-import { B as COMPUTE_BUDGET_PROGRAM_ADDRESS, E as curveBuyExactOut, G as computeBudgetInstructions, H as DEFAULT_COMPUTE_UNIT_LIMIT, K as getSetComputeUnitLimitInstruction, Lt as raydiumIds, P as launchlabBuyAccounts, R as BUY_PACK_COMPUTE_UNITS, U as MAX_COMPUTE_UNIT_LIMIT, V as CREATE_MACHINE_COMPUTE_UNITS, W as REDEEM_COMPUTE_UNITS, _ as newCurveReserves, b as wsolAccountFor, c as getLaunchInstruction, cn as WSOL_MINT, ct as ata, en as LAUNCH_TOTAL_BASE_SELL, ft as creatorFeeVaultAddress, kt as LAUNCH_DECIMALS, l as buildMessage, m as fetchCurveSettings, nn as PLATFORM_ADMIN, on as SYSTEM_PROGRAM_ADDRESS, ot as tokenAccountAmount, q as getSetComputeUnitPriceInstruction, sn as TOKEN_PROGRAM_ADDRESS, t as raydium_exports, tn as METAPLEX_PROGRAM_ADDRESS, u as withRemainingAccounts, v as resolveVenue, vt as launchlabPoolAddress, xt as platformFeeVaultAddress, yt as launchlabVaultAddress, z as CLAIM_COMPUTE_UNITS, zt as ASSOCIATED_TOKEN_PROGRAM_ADDRESS } from "./raydium-B-l9V3O-.js";
-import { DRAW_DISCRIMINATOR, DRAW_RESOLVED_EVENT_DISCRIMINATOR, GABOX_PROGRAM_ADDRESS, PACK_BOUGHT_EVENT_DISCRIMINATOR, POOL_CREATED_EVENT_DISCRIMINATOR, POOL_DISCRIMINATOR, PRIZES_FUNDED_EVENT_DISCRIMINATOR, RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR, TOKENS_SOLD_EVENT_DISCRIMINATOR, WALLET_ACTIVITY_DISCRIMINATOR, decodeDraw, decodePool, decodeWalletActivity, findActivityPda, findDrawPda, findIdentityPda, findPoolPda, getBuyPackInstructionAsync, getDrawResolvedEventDecoder, getDrawSize, getExpireDrawInstruction, getFundPrizesInstruction, getInitializePoolInstructionAsync, getPackBoughtEventDecoder, getPoolCreatedEventDecoder, getPoolSize, getPrizesFundedEventDecoder, getRandomnessRetriedEventDecoder, getRetryDrawInstruction, getSellTokensInstructionAsync, getTokensSoldEventDecoder, getWalletActivitySize, t as generated_exports } from "./generated/index.js";
-import { address, createSolanaRpc, createSolanaRpcSubscriptions, fetchEncodedAccount, getAddressEncoder, getBase58Decoder, getBase64Encoder, getBytesEncoder, getProgramDerivedAddress } from "@solana/kit";
+import { Dt as POOL_DISCRIMINATOR, I as getFundPrizesInstruction, Ot as decodePool, Rt as DRAW_DISCRIMINATOR, W as getExpireDrawInstruction, _t as decodeWalletActivity, b as getRetryDrawInstruction, ft as findPoolPda, gt as WALLET_ACTIVITY_DISCRIMINATOR, ht as findActivityPda, k as getInitializePoolInstructionAsync, mt as findDrawPda, p as getSellTokensInstructionAsync, pt as findIdentityPda, st as getBuyPackInstructionAsync, zt as decodeDraw } from "./gabox-DGTCh34U.js";
+import { $ as computeBudgetInstructions, $t as launchlabVaultAddress, B as fetchQuoteAsset, Bt as vaultAddress, Cn as PACK_TOKENS, Dn as VRF_DEFAULT_QUEUE, E as cpmmSwapBaseOutput, En as TIMEOUT_SLOTS, Et as decodeCpmmPool, Ft as activityAddress, G as readAccounts, H as fetchQuoteDisplay, Ht as ata, I as launchlabBuyAccounts, In as LAUNCH_DECIMALS, It as associatedTokenAddress, J as COMPUTE_BUDGET_PROGRAM_ADDRESS, K as BUY_PACK_COMPUTE_UNITS, Kn as ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Kt as creatorFeeVaultAddress, Lt as drawAddress, Nt as tokenAccountAmount, O as curveBuyExactOut, On as VRF_PROGRAM_ADDRESS, Q as REDEEM_COMPUTE_UNITS, Qt as launchlabPoolAddress, Rt as poolAddress, S as wsolAccountFor, Sn as MAX_ATTEMPTS, T as cpmmSwapBaseInput, Tn as SLOT_HASHES_SYSVAR, Tt as decodeCpmmAmmConfig, Vt as vrfIdentityAddress, Wn as raydiumIds, X as DEFAULT_COMPUTE_UNIT_LIMIT, Xn as CPMM_SWAP_BASE_INPUT, Y as CREATE_MACHINE_COMPUTE_UNITS, Z as MAX_COMPUTE_UNIT_LIMIT, Zn as CPMM_SWAP_BASE_OUTPUT, _n as validatePack, _t as tiersOf, an as MAX_MULTIPLIER_BPS, at as POOL_MINT_OFFSET, b as resolveVenue, bn as IDENTITY_SEED, c as getLaunchInstruction, cn as TIERS, cr as METAPLEX_PROGRAM_ADDRESS, ct as fetchPoolByMint, dn as maxMultiplierBps, dt as fetchWalletActivity, et as getSetComputeUnitLimitInstruction, f as creatorFeeOnInput, fn as quote, ft as listDraws, gn as uncappedMaximum, gr as WSOL_MINT, gt as quotePool, hn as tierAmount, hr as TOKEN_PROGRAM_ADDRESS, ht as listPools, in as GaboxMathError, it as POOL_CREATOR_OFFSET, l as buildMessage, ln as averageMultiplierBps, lr as PLATFORM_ADMIN, lt as fetchPoolInventory, m as fetchCurveSettings, mn as seedTokens, mt as listDrawsByPurchaser, nn as BPS, nt as DRAW_POOL_OFFSET, on as MIN_SEED_MULTIPLIER_BPS, ot as fetchDraw, pn as resolveReservation, pr as SYSTEM_PROGRAM_ADDRESS, pt as listDrawsByPool, q as CLAIM_COMPUTE_UNITS, rn as DEFAULT_TIERS, rt as DRAW_PURCHASER_OFFSET, sn as TICKETS, sr as LAUNCH_TOTAL_BASE_SELL, st as fetchPoolAt, t as raydium_exports, tn as platformFeeVaultAddress, tt as getSetComputeUnitPriceInstruction, u as withRemainingAccounts, un as choose, ut as fetchVaultBalance, v as newCurveReserves, vn as validateTiers, wn as RETRY_SLOTS, xn as INSTRUCTIONS_SYSVAR, y as quoteAccountFor, yn as GABOX_PROGRAM_ID, z as order, zt as scopedVrfIdentityAddress } from "./raydium-CU-tZzIk.js";
+import { DRAW_RESOLVED_EVENT_DISCRIMINATOR, PACK_BOUGHT_EVENT_DISCRIMINATOR, POOL_CREATED_EVENT_DISCRIMINATOR, PRIZES_FUNDED_EVENT_DISCRIMINATOR, RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR, TOKENS_SOLD_EVENT_DISCRIMINATOR, getDrawResolvedEventDecoder, getPackBoughtEventDecoder, getPoolCreatedEventDecoder, getPrizesFundedEventDecoder, getRandomnessRetriedEventDecoder, getTokensSoldEventDecoder, t as generated_exports } from "./generated/index.js";
+import { AccountRole, address, createNoopSigner, createSolanaRpc, createSolanaRpcSubscriptions, getAddressDecoder, getBase64Encoder, getU64Encoder } from "@solana/kit";
 import { getCloseAccountInstruction, getCreateAssociatedTokenIdempotentInstruction, getSyncNativeInstruction } from "@solana-program/token";
 import { getTransferSolInstruction } from "@solana-program/system";
-//#region src/ids.ts
-/** `declare_id!` in `programs/gabox/src/lib.rs`. */
-const GABOX_PROGRAM_ID = GABOX_PROGRAM_ADDRESS;
-/** MagicBlock's ephemeral VRF program. `vrf.rs` pins it and refuses any other. */
-const VRF_PROGRAM_ADDRESS = "Vrf1RNUjXmQGjmQrQLvJHs9SNkvDJEsRVFPkfSQUwGz";
-/**
-* MagicBlock's default oracle queue. The program pins this one address, so a pool creator cannot
-* point a draw at an oracle they control.
-*/
-const VRF_DEFAULT_QUEUE = "Cuj97ggrhhidhbu39TijNVqE74xvKJ69gDervRUXAxGh";
-/** The seed of both identity PDAs. See `pdas.ts` — there are two, under different programs. */
-const IDENTITY_SEED = new Uint8Array([
-	105,
-	100,
-	101,
-	110,
-	116,
-	105,
-	116,
-	121
-]);
-const SLOT_HASHES_SYSVAR = "SysvarS1otHashes111111111111111111111111111";
-const INSTRUCTIONS_SYSVAR = "Sysvar1nstructions1111111111111111111111111";
-/** `constants.rs`. A retry may not run sooner than this after the last attempt. */
-const RETRY_SLOTS = 300n;
-/** `constants.rs`. After this many slots from the purchase, anyone may expire the draw. */
-const TIMEOUT_SLOTS = 216000n;
-/** `constants.rs`. Three requests in total, counting the one `buy_pack` makes. */
-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.
-*/
-const PACK_TOKENS = 1000000n * 1000000n;
-//#endregion
-//#region src/math.ts
-/**
-* 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/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. */
-const BPS = 10000n;
-/**
-* `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`.
-*/
-const MIN_SEED_MULTIPLIER_BPS = 3e4;
-/**
-* `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.
-*/
-const MAX_MULTIPLIER_BPS = 2e5;
-/** Ticket counts must sum to this. A uniform 16-bit word then maps with no modulo bias. */
-const TICKETS = 65536;
-/** The prize table has exactly this many slots. Unused slots are all-zero. */
-const TIERS = 8;
-/** Thrown by every function here. `code` matches a `GaboxError` variant name. */
-var GaboxMathError = class extends Error {
-	code;
-	constructor(code, message) {
-		super(`${code}: ${message}`);
-		this.name = "GaboxMathError";
-		this.code = code;
-	}
-};
-const U64_MAX = (1n << 64n) - 1n;
-const U32_MAX = 4294967295;
-/**
-* The default prize table. The program does not enforce this table: it accepts any table that
-* passes `validateTiers`. This is only the table the Gabox app creates its pools with, and the
-* starting point for a client that has no reason to pick another one.
-*
-* Common 75% at 0.52x, Rare 20% at 1.2x, Epic 4% at 3x, Mythic 1% at 20x. Expected payout is
-* 0.9499x of a pack, so the seed is 19 packs.
-*/
-const DEFAULT_TIERS = Object.freeze([
-	Object.freeze({
-		multiplierBps: 5201,
-		tickets: 49153
-	}),
-	Object.freeze({
-		multiplierBps: 12e3,
-		tickets: 13107
-	}),
-	Object.freeze({
-		multiplierBps: 3e4,
-		tickets: 2621
-	}),
-	Object.freeze({
-		multiplierBps: 2e5,
-		tickets: 655
-	}),
-	Object.freeze({
-		multiplierBps: 0,
-		tickets: 0
-	}),
-	Object.freeze({
-		multiplierBps: 0,
-		tickets: 0
-	}),
-	Object.freeze({
-		multiplierBps: 0,
-		tickets: 0
-	}),
-	Object.freeze({
-		multiplierBps: 0,
-		tickets: 0
-	})
-]);
-function checkedU64(value, what) {
-	if (value < 0n || value > U64_MAX) throw new GaboxMathError("Arithmetic", `${what} does not fit in u64`);
-	return value;
-}
-/** Tier fields encode as program `u32`s. Reject JavaScript-only values before `BigInt` or codecs. */
-function checkedU32(value, what) {
-	if (!Number.isInteger(value) || value < 0 || value > U32_MAX) throw new GaboxMathError("InvalidDistribution", `${what} must be an integer from 0 to ${U32_MAX}`);
-	return value;
-}
-/** `math::tokens`. Floor division, and an overflow past u64 is an error, not a wrap. */
-function tierAmount(base, multiplierBps) {
-	return checkedU64(base * BigInt(checkedU32(multiplierBps, "multiplierBps")) / BPS, "tier amount");
-}
-/**
-* `math::validate`. Checks the table alone, with no base.
-*
-* 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.
-*/
-function validateTiers(tiers) {
-	if (tiers.length !== 8) throw new GaboxMathError("InvalidDistribution", `expected 8 tiers, got ${tiers.length}`);
-	let count = 0n;
-	let expected = 0n;
-	for (const [index, tier] of tiers.entries()) {
-		checkedU32(tier.tickets, `tier ${index} tickets`);
-		checkedU32(tier.multiplierBps, `tier ${index} multiplierBps`);
-		if (tier.tickets === 0) {
-			if (tier.multiplierBps !== 0) throw new GaboxMathError("InvalidDistribution", "a tier with no tickets must have no multiplier");
-			continue;
-		}
-		if (tier.multiplierBps <= 0) throw new GaboxMathError("InvalidDistribution", "a ticketed tier must pay something; it would sell a ticket that can only win zero");
-		if (tier.multiplierBps > 2e5) throw new GaboxMathError("InvalidDistribution", `tier ${index} multiplierBps exceeds the ${MAX_MULTIPLIER_BPS} maximum (20x)`);
-		count += BigInt(tier.tickets);
-		expected += BigInt(tier.multiplierBps) * BigInt(tier.tickets);
-	}
-	if (count !== BigInt(65536)) throw new GaboxMathError("InvalidDistribution", `tickets must sum to ${TICKETS}, they sum to ${count}`);
-	if (expected > 10000n * BigInt(65536)) throw new GaboxMathError("UnfundedExpectation", "the expected token award exceeds the tokens a pack buys");
-}
-/**
-* `math::validate_pack`. Every ticketed tier must pay at least one token for a pack of this size.
-*
-* The program checks this once at creation. At `PACK_TOKENS` no sane table fails it; it exists so
-* a table cannot sell a ticket that can only win zero.
-*/
-function validatePack(packTokens, tiers) {
-	if (packTokens <= 0n) throw new GaboxMathError("ZeroAmount", "packTokens must be positive");
-	checkedU64(packTokens, "pack tokens");
-	validateTiers(tiers);
-	for (const [i, tier] of tiers.entries()) {
-		if (tier.tickets === 0) continue;
-		if (tierAmount(packTokens, tier.multiplierBps) === 0n) throw new GaboxMathError("PackTooSmall", `tier ${i} rounds to zero tokens at this pack size`);
-	}
-}
-/**
-* `math::seed_tokens`. The mandatory seed a table needs, in tokens.
-*
-* 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 = min(uncappedMaximum(packTokens, tiers), tierAmount(packTokens, MIN_SEED_MULTIPLIER_BPS)) - packTokens
-*
-* 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.
-*
-* Pool initialization computes this number itself and buys exactly that many tokens on the curve.
-* The creator only signs a maximum SOL cost.
-*/
-function seedTokens(packTokens, tiers) {
-	validateTiers(tiers);
-	const largest = uncappedMaximum(packTokens, tiers);
-	if (largest < packTokens) throw new GaboxMathError("JackpotBelowOnePack", "the largest tier must pay at least one pack");
-	const minimum = tierAmount(packTokens, MIN_SEED_MULTIPLIER_BPS);
-	return (largest < minimum ? largest : minimum) - packTokens;
-}
-/**
-* `math::uncapped_maximum`. The largest tier's award for this base, before any inventory cap.
-*
-* At `packTokens` this is the jackpot in tokens. `seedTokens` is this minus one pack.
-*/
-function uncappedMaximum(base, tiers) {
-	validateTiers(tiers);
-	let largest = 0n;
-	for (const tier of tiers) {
-		if (tier.tickets === 0) continue;
-		const amount = tierAmount(base, tier.multiplierBps);
-		if (amount > largest) largest = amount;
-	}
-	return largest;
-}
-/**
-* `math::quote`. The offer a pack of `base` tokens would freeze right now. `base` is always
-* `pool.packTokens`; the parameter stays general so the vectors can use small numbers.
-*
-* `inventory` is the vault's token balance and `reserved` is `pool.reserved`. The difference is
-* free inventory. This pack's own `base` is added to it, because the purchase and the offer are
-* one transaction — the tokens are in the vault before the draw is written.
-*
-* Every amount is capped at what is actually available. A tier that rounds to zero tokens is an
-* error: the pool must not sell a ticket that can only win nothing.
-*/
-function quote(base, tiers, inventory, reserved) {
-	validateTiers(tiers);
-	if (inventory < reserved) throw new GaboxMathError("InsolventInventory", "the vault holds less than the pool has already reserved");
-	const available = checkedU64(inventory - reserved + base, "available inventory");
-	const prizes = Array.from({ length: 8 }, () => ({
-		amount: 0n,
-		tickets: 0
-	}));
-	let maximum = 0n;
-	let minimum = U64_MAX;
-	for (const [i, tier] of tiers.entries()) {
-		if (tier.tickets === 0) continue;
-		const uncapped = tierAmount(base, tier.multiplierBps);
-		if (uncapped === 0n) throw new GaboxMathError("PackTooSmall", `tier ${i} rounds to zero tokens at this pack size`);
-		const amount = uncapped < available ? uncapped : available;
-		prizes[i] = {
-			amount,
-			tickets: tier.tickets
-		};
-		if (amount > maximum) maximum = amount;
-		if (amount < minimum) minimum = amount;
-	}
-	return {
-		prizes,
-		maximum,
-		minimum
-	};
-}
-/**
-* `math::choose`. Which prize a 16-bit ticket wins.
-*
-* The rows are consecutive ranges in table order, so this is a running total and a comparison.
-* A ticket past the last row returns `0`, which cannot happen for a validated table.
-*/
-function choose(prizes, ticket) {
-	let end = 0;
-	for (const prize of prizes) {
-		end += prize.tickets;
-		if (ticket < end) return prize.amount;
-	}
-	return 0n;
-}
-/** `math::resolve_reservation`. Release the unwon part of a maximum, keep the award reserved. */
-function resolveReservation(reserved, maximum, award) {
-	if (award > maximum) throw new GaboxMathError("InsolventInventory", "the award exceeds the reserved maximum");
-	if (reserved < maximum) throw new GaboxMathError("Arithmetic", "the pool has reserved less than this draw holds");
-	return checkedU64(reserved - maximum + award, "reserved");
-}
-/** The largest `multiplierBps` on any ticketed row. `0` for a table with no rows. */
-function maxMultiplierBps(tiers) {
-	validateTiers(tiers);
-	let largest = 0;
-	for (const tier of tiers) {
-		if (tier.tickets === 0) continue;
-		if (tier.multiplierBps > largest) largest = tier.multiplierBps;
-	}
-	return largest;
-}
-/**
-* The expected multiplier over all 65,536 tickets, in basis points. Rounded down.
-*
-* `validateTiers` caps this at 10,000. A table at 9,800 keeps 2% of every pack's tokens in the
-* vault on average, which is what lets a pool survive a run of top-tier wins.
-*/
-function averageMultiplierBps(tiers) {
-	validateTiers(tiers);
-	let weighted = 0n;
-	for (const tier of tiers) {
-		if (tier.tickets === 0) continue;
-		weighted += BigInt(tier.multiplierBps) * BigInt(tier.tickets);
-	}
-	return Number(weighted / BigInt(TICKETS));
-}
-//#endregion
-//#region src/pdas.ts
-/**
-* Gabox's own program-derived addresses.
-*
-* Raydium's live in `src/raydium/pdas.ts`, because they depend on the cluster. These do not: the
-* Gabox program id is the same everywhere.
-*
-* Classic SPL Token only. Both venues use it, and the accepted LaunchLab create instruction mints
-* the coin with it, so no derivation here takes a token program any more.
-*/
-/** `["pool", mint]`. One pool per coin. */
-const poolAddress = async (mint) => (await findPoolPda({ mint }))[0];
-/** `["draw", pool, seq]`, with the sequence as eight little-endian bytes. */
-const drawAddress = async (pool, seq) => (await findDrawPda({
-	pool,
-	seq
-}))[0];
-/** The per-wallet `WalletActivity` PDA. `buy_pack` derives it from the purchaser automatically. */
-const activityAddress = async (wallet) => (await findActivityPda({ purchaser: wallet }))[0];
-/** `["identity"]` under Gabox. The PDA the program signs its randomness request with. */
-const vrfIdentityAddress = async () => (await findIdentityPda())[0];
-/** `["identity", gabox_program_id]` under the VRF program. MagicBlock signs the callback with it. */
-async function scopedVrfIdentityAddress() {
-	return await getProgramDerivedAddress({
-		programAddress: VRF_PROGRAM_ADDRESS,
-		seeds: [getBytesEncoder().encode(IDENTITY_SEED), getAddressEncoder().encode(GABOX_PROGRAM_ID)]
-	});
-}
-/** An associated token account under classic SPL Token. */
-const associatedTokenAddress = async (owner, mint, tokenProgram = TOKEN_PROGRAM_ADDRESS) => await ata(owner, mint, tokenProgram);
-/** The prize vault: the pool PDA's own associated token account for the coin. */
-const vaultAddress = async (mint) => await associatedTokenAddress(await poolAddress(mint), mint);
-//#endregion
-//#region src/accounts.ts
-/** Account readers and bounded discovery scans. Old pool layouts are intentionally unsupported. */
-const DISCRIMINATOR = 8;
-const DRAW_POOL_OFFSET = DISCRIMINATOR;
-const DRAW_PURCHASER_OFFSET = 40;
-const POOL_CREATOR_OFFSET = DISCRIMINATOR;
-const POOL_MINT_OFFSET = 40;
-const base58 = getBase58Decoder();
-const base64 = getBase64Encoder();
-const asBase58 = (bytes) => base58.decode(bytes);
-const memcmp = (offset, bytes) => ({ memcmp: {
-	offset: BigInt(offset),
-	bytes,
-	encoding: "base58"
-} });
-const encoded = (address, data) => ({
-	address,
-	data,
-	exists: true,
-	executable: false,
-	lamports: 0n,
-	programAddress: GABOX_PROGRAM_ID,
-	space: BigInt(data.length)
-});
-async function fetchPoolByMint(client, mint) {
-	return await fetchPoolAt(client, await poolAddress(mint));
-}
-async function fetchPoolAt(client, address) {
-	return decodeCurrentPool(await fetchEncodedAccount(client.rpc, address, { commitment: "confirmed" }));
-}
-function decodeCurrentPool(account) {
-	if (!account.exists) return null;
-	if (account.data.length !== getPoolSize()) throw new Error(`pool ${account.address} is not a Gabox pool and is intentionally unsupported`);
-	return decodePool(account).data;
-}
-function decodeCurrentDraw(account) {
-	if (!account.exists) return null;
-	if (account.data.length !== getDrawSize()) throw new Error(`draw ${account.address} is not a Gabox draw and is intentionally unsupported`);
-	return decodeDraw(account).data;
-}
-async function fetchDraw(client, address) {
-	return decodeCurrentDraw(await fetchEncodedAccount(client.rpc, address, { commitment: "confirmed" }));
-}
-function decodeCurrentWalletActivity(account) {
-	if (!account.exists) return null;
-	if (account.data.length !== getWalletActivitySize()) throw new Error(`activity account ${account.address} is not a Gabox WalletActivity and is intentionally unsupported`);
-	return decodeWalletActivity(account).data;
-}
-/**
-* 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.
-*/
-async function fetchWalletActivity(client, wallet) {
-	return decodeCurrentWalletActivity(await fetchEncodedAccount(client.rpc, await activityAddress(wallet), { commitment: "confirmed" }));
-}
-async function scan(rpc, filters, decode) {
-	return (await rpc.getProgramAccounts(GABOX_PROGRAM_ID, {
-		encoding: "base64",
-		commitment: "confirmed",
-		filters
-	}).send()).map(({ pubkey, account }) => decode(pubkey, new Uint8Array(base64.encode(account.data[0]))));
-}
-async function listPools(client) {
-	return await scan(client.rpc, [memcmp(0, asBase58(POOL_DISCRIMINATOR)), { dataSize: BigInt(getPoolSize()) }], (address, data) => ({
-		address,
-		data: decodePool(encoded(address, data)).data
-	}));
-}
-async function listDraws(client, query = {}) {
-	const filters = [memcmp(0, asBase58(DRAW_DISCRIMINATOR)), { dataSize: BigInt(getDrawSize()) }];
-	if (query.pool) filters.push(memcmp(8, query.pool));
-	if (query.purchaser) filters.push(memcmp(40, query.purchaser));
-	return await scan(client.rpc, filters, (address, data) => ({
-		address,
-		data: decodeDraw(encoded(address, data)).data
-	}));
-}
-const listDrawsByPool = async (client, pool) => await listDraws(client, { pool });
-const listDrawsByPurchaser = async (client, purchaser) => await listDraws(client, { purchaser });
-async function fetchVaultBalance(client, mint) {
-	const vault = await vaultAddress(mint);
-	const { value } = await client.rpc.getAccountInfo(vault, {
-		encoding: "base64",
-		commitment: "confirmed"
-	}).send();
-	return value ? tokenAccountAmount(new Uint8Array(base64.encode(value.data[0]))) : 0n;
-}
-async function fetchPoolInventory(client, mint) {
-	const poolPda = await poolAddress(mint);
-	const vaultPda = await vaultAddress(mint);
-	const { value } = await client.rpc.getMultipleAccounts([poolPda, vaultPda], {
-		encoding: "base64",
-		commitment: "confirmed"
-	}).send();
-	const poolAccount = value[0];
-	if (!poolAccount) return null;
-	const pool = decodeCurrentPool(encoded(poolPda, new Uint8Array(base64.encode(poolAccount.data[0]))));
-	if (!pool) return null;
-	if (pool.vault !== vaultPda) throw new Error(`pool ${poolPda} has an unexpected vault; it is not a supported Gabox pool`);
-	const vaultAccount = value[1];
-	const inventory = vaultAccount ? tokenAccountAmount(new Uint8Array(base64.encode(vaultAccount.data[0]))) : 0n;
-	return {
-		poolAddress: poolPda,
-		pool,
-		inventory,
-		reserved: pool.reserved,
-		free: inventory > pool.reserved ? inventory - pool.reserved : 0n
-	};
-}
-const tiersOf = (pool) => pool.tiers.map(({ multiplierBps, tickets }) => ({
-	multiplierBps,
-	tickets
-}));
-const quotePool = (inventory) => quote(inventory.pool.packTokens, tiersOf(inventory.pool), inventory.inventory, inventory.reserved);
-//#endregion
 //#region src/events.ts
 /** Decode Gabox's Anchor events. Draw accounts are closed on delivery; use `DrawResolved` as final state. */
 const b64 = getBase64Encoder();
@@ -583,7 +135,7 @@ async function findResolvedDraw(client, address) {
 //#endregion
 //#region src/lookupTables.ts
 /**
-* Shared devnet address lookup table, verified on 2026-09-18T07:26:38.218Z.
+* Shared devnet address lookup table, verified on 2026-09-18T11:04:06.369Z.
 * Generated by scripts/deploy-lookup-table.ts. Existing indices are immutable;
 * keep this table active while clients use it. Authority is the devnet deploy wallet.
 */
@@ -702,7 +254,14 @@ const DEVNET_LOOKUP_TABLE_ADDRESSES = [
 	address("DRaycpLY18LhpbydsBWbVJtxpNv9oXPgjRSfpF2bWpYb"),
 	address("CXniRufdq5xL8t8jZAPxsPZDpuudwuJSPWnbcD5Y5Nxq"),
 	address("G7YfJJp1TX1VtzN4V2yhPNSU23AKPSy1U2miRdwAByK5"),
-	address("5WcPTEQ59UqpQzjZUPbU8QRGCbj7NeQNLDa7DbsLkLKT")
+	address("5WcPTEQ59UqpQzjZUPbU8QRGCbj7NeQNLDa7DbsLkLKT"),
+	address("USDCoctVLVnvTXBEuP9s8hntucdJokbo17RwHuNXemT"),
+	address("4wHbNkobu7iARU9MbCEqDSAq6JuQreGupG2Jsf2R3DFP"),
+	address("5Eu2G2USTy1pqphmQzQ2SBXWrBq5sdhgEh7hso9R2xix"),
+	address("A9qBhPy4k5UYW72hSgAkh1Epr2do69P54yzzcMV3yv6b"),
+	address("Aw93pmXP52u6WSW2HcafRxua1LDht5MZhhXaaR7qCjsN"),
+	address("CPLUA2NTYSGjsB1E9iXT3MrPn69WRFJvKTdJZw5NdEjh"),
+	address("7LnqjXdqJEdccWZQs5YJobQ8MDmcK4sG2oo4Ty4LBC8c")
 ];
 const DEVNET_ADDRESS_LOOKUP_TABLES = { [DEVNET_LOOKUP_TABLE_ADDRESS]: [...DEVNET_LOOKUP_TABLE_ADDRESSES] };
 /**
@@ -716,29 +275,207 @@ const DEVNET_ADDRESS_LOOKUP_TABLES = { [DEVNET_LOOKUP_TABLE_ADDRESS]: [...DEVNET
 function defaultAddressLookupTables(cluster) {
 	return cluster === "devnet" ? { ...DEVNET_ADDRESS_LOOKUP_TABLES } : {};
 }
+/** The address lookup table program. It owns every table account. */
+const LOOKUP_TABLE_PROGRAM = address("AddressLookupTab1e1111111111111111111111111");
+/**
+* The fixed part of a table account, before its addresses: a 4-byte discriminator, the two slot
+* fields, the start index, the optional authority, and two padding bytes.
+*/
+const LOOKUP_TABLE_HEADER = 56;
+/**
+* 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.
+*/
+async function fetchAddressLookupTables(client, addresses) {
+	const wanted = [...new Set(addresses)];
+	if (wanted.length === 0) return {};
+	const { value } = await client.rpc.getMultipleAccounts(wanted, {
+		encoding: "base64",
+		commitment: "confirmed"
+	}).send();
+	const decoder = getAddressDecoder();
+	const tables = {};
+	for (const [index, account] of value.entries()) {
+		if (!account || account.owner !== LOOKUP_TABLE_PROGRAM) continue;
+		const data = Buffer.from(account.data[0], "base64");
+		const body = data.length - LOOKUP_TABLE_HEADER;
+		if (body <= 0 || body % 32 !== 0) continue;
+		const stored = [];
+		for (let at = LOOKUP_TABLE_HEADER; at < data.length; at += 32) stored.push(decoder.decode(new Uint8Array(data.subarray(at, at + 32))));
+		tables[wanted[index]] = stored;
+	}
+	return tables;
+}
+//#endregion
+//#region src/route/leg.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.
+*/
+const EXACT_IN_MARGIN_BPS = 100n;
+/**
+* The first exact-in quote's size, in lamports, when a pair has no exact-out route.
+*
+* It exists only to learn a price, so it is small enough that its own impact on the route is
+* small, and large enough that a route quotes it at all. The real spend is worked out from the
+* price it returns and re-quoted.
+*/
+const PROBE_LAMPORTS = 100000000n;
+/** How many times the exact-in fallback re-quotes before it gives up. */
+const EXACT_IN_ATTEMPTS = 3;
+/**
+* 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.
+*/
+async function routeQuoteIn(client, provider, input) {
+	const { quoteMint, amount, user } = input;
+	if (amount <= 0n) throw new Error("the quote amount to buy must be positive");
+	if (quoteMint === "So11111111111111111111111111111111111111112") throw new Error("a WSOL-quoted pool needs no route: the builders wrap SOL themselves");
+	try {
+		const route = await provider.exactOut(client, WSOL_MINT, quoteMint, amount, user);
+		if (route.outAmount < amount) throw new Error(`the exact-out route buys ${route.outAmount} of ${quoteMint}, which is below the ${amount} the pack costs`);
+		return route;
+	} catch (exactOutFailure) {
+		return await exactInFallback(client, provider, quoteMint, amount, user, exactOutFailure);
+	}
+}
+/**
+* Work out the SOL that buys `amount` of the quote at the exact-in price, then swap it.
+*
+* The first quote is a small probe, only to learn a price. Every later quote scales the last one by
+* what it actually returned, so an impact the probe did not show is corrected rather than guessed
+* at. Three quotes at most, and a route that still falls short is an error rather than a buy that
+* fails on chain.
+*/
+async function exactInFallback(client, provider, quoteMint, amount, user, exactOutFailure) {
+	let spend = PROBE_LAMPORTS;
+	let last;
+	for (let attempt = 0; attempt < EXACT_IN_ATTEMPTS; attempt++) {
+		let route;
+		try {
+			route = await provider.exactIn(client, WSOL_MINT, quoteMint, spend, user);
+		} catch (exactInFailure) {
+			throw new Error(`no route from SOL to ${quoteMint}. Exact-out failed with "${messageOf(exactOutFailure)}" and exact-in with "${messageOf(exactInFailure)}".`);
+		}
+		last = route;
+		if (route.outAmount >= amount) return route;
+		if (route.outAmount <= 0n) break;
+		const scaled = ceilDiv(route.inAmount * amount, route.outAmount);
+		const next = scaled + scaled * EXACT_IN_MARGIN_BPS / 10000n;
+		if (next <= spend) break;
+		spend = next;
+	}
+	throw new Error(`no route from SOL to ${quoteMint} buys ${amount}. The best exact-in quote returned ${last?.outAmount ?? 0n} for ${last?.inAmount ?? spend} lamports, and exact-out failed with "${messageOf(exactOutFailure)}".`);
+}
+/**
+* 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.
+*/
+async function routeQuoteOut(client, provider, input) {
+	const { quoteMint, amount, user } = input;
+	if (amount <= 0n) throw new Error("the quote amount to sell must be positive");
+	if (quoteMint === "So11111111111111111111111111111111111111112") throw new Error("a WSOL-quoted pool needs no route: the builders unwrap SOL themselves");
+	return await provider.exactIn(client, quoteMint, WSOL_MINT, amount, user);
+}
+/**
+* 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.
+*/
+function assertRouteIsSafe(route, expect) {
+	const forbidden = new Set(expect.forbidden);
+	let settles = false;
+	for (const instruction of route.instructions) {
+		if (forbidden.has(instruction.programAddress)) throw new Error(`the route calls ${instruction.programAddress}, which is a Gabox program or account. A route must never touch Gabox state.`);
+		for (const account of instruction.accounts ?? []) {
+			if (forbidden.has(account.address)) throw new Error(`the route names the Gabox account ${account.address}. A route must never touch Gabox state.`);
+			if (account.address === expect.settlesIn) settles = true;
+		}
+	}
+	if (!settles) throw new Error(`the route never names ${expect.settlesIn}, the quote account the program settles in. The swap would pay somewhere the buy cannot spend from.`);
+}
+/**
+* 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.
+*/
+async function solPriceOf(client, quoteMint, amount) {
+	if (quoteMint === "So11111111111111111111111111111111111111112") return amount;
+	if (!client.route || amount <= 0n) return null;
+	try {
+		return (await client.route.exactOut(client, WSOL_MINT, quoteMint, amount, quoteMint)).inAmount;
+	} catch {
+		return null;
+	}
+}
+/** `ceil(numerator / denominator)` for non-negative values. */
+function ceilDiv(numerator, denominator) {
+	return (numerator + denominator - 1n) / denominator;
+}
+const messageOf = (cause) => cause instanceof Error ? cause.message : String(cause);
 //#endregion
 //#region src/offer.ts
 /**
-* 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.
 */
 async function getOffer(client, mint, options = {}) {
 	const inventory = await fetchPoolInventory(client, mint);
 	if (!inventory) throw new Error(`no gabox pool for mint ${mint}`);
+	const { pool } = inventory;
 	const venue = await resolveVenue(client, {
 		mint,
-		user: options.user ?? inventory.pool.creator,
+		user: options.user ?? pool.creator,
+		quote: {
+			mint: pool.quoteMint,
+			config: pool.quoteConfig,
+			tokenProgram: pool.quoteTokenProgram
+		},
 		...options.venue ? { venue: options.venue } : {}
 	});
-	return offerFromState(inventory, venue.kind, venue.quoteBuy(inventory.pool.packTokens));
+	const quoteAmount = venue.quoteBuy(pool.packTokens);
+	const display = await fetchQuoteDisplay(client, pool.quoteMint);
+	return offerFromState(inventory, venue.kind, quoteAmount, {
+		quoteDecimals: display.decimals,
+		quoteSymbol: display.symbol,
+		solAmount: await solPriceOf(client, pool.quoteMint, quoteAmount)
+	});
 }
 /**
 * 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.
 */
-function offerFromState(inventory, venue, quoteAmount) {
+function offerFromState(inventory, venue, quoteAmount, display = {
+	quoteDecimals: 0,
+	quoteSymbol: null,
+	solAmount: null
+}) {
 	const { pool } = inventory;
 	const tiers = tiersOf(pool);
 	const offer = quote(pool.packTokens, tiers, inventory.inventory, inventory.reserved);
@@ -749,6 +486,9 @@ function offerFromState(inventory, venue, quoteAmount) {
 		packTokens: pool.packTokens,
 		quoteAmount,
 		quoteMint: pool.quoteMint,
+		quoteDecimals: display.quoteDecimals,
+		quoteSymbol: display.quoteSymbol,
+		solAmount: display.solAmount,
 		seedQuoteAmount: pool.seedQuoteAmount,
 		seedTokens: seedTokens(pool.packTokens, tiers),
 		venue,
@@ -777,6 +517,374 @@ function seedShortfall(offer) {
 	return offer.free >= needed ? 0n : needed - offer.free;
 }
 //#endregion
+//#region src/route/cpmm.ts
+/**
+* A route provider backed by one Raydium CPMM pool.
+*
+* Jupiter does not serve devnet, so a devnet machine quoted in a test token needs a route this SDK
+* can build itself. Given a CPMM pool that holds the SOL/quote pair, this provider swaps through
+* it with the same two instructions Gabox already forwards for a graduated coin, priced with the
+* same bigint port of Raydium's math.
+*
+* It works anywhere such a pool exists, mainnet included. It is not a router: it uses the one pool
+* the caller names and nothing else.
+*
+* # Wrapping
+*
+* CPMM settles in WSOL, never in native SOL. So the route wraps the SOL it spends and closes the
+* WSOL account afterwards, exactly as Jupiter's `wrapAndUnwrapSol` does. A sale into SOL creates
+* the WSOL account, swaps into it, and closes it, which is what turns the proceeds into SOL.
+*
+* # No signer objects
+*
+* The user is an address, not a signer. Every signing slot is marked as a signer and left for the
+* fee payer to sign, the same way a Jupiter instruction arrives. The wallet paying for the Gabox
+* transaction is the same wallet, so its one signature covers all of them.
+*
+* That is not a shortcut, it is required. Kit refuses to sign a message that carries two distinct
+* signer objects for one address: `signTransactionMessageWithSigners` fails with "Multiple distinct
+* signers were identified for address". The token and system builders below only accept a signer,
+* so `withoutSigners` strips the object again and keeps the role.
+*/
+const u64 = getU64Encoder();
+/**
+* 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.
+*/
+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`.
+*/
+const CPMM_ROUTE_COMPUTE_UNITS = 75e3;
+/**
+* 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`.
+*/
+function raydiumCpmmRoute(poolAddress) {
+	return {
+		exactOut: async (client, input, output, amount, user) => await swap(client, poolAddress, {
+			input,
+			output,
+			amount,
+			user,
+			mode: "exactOut"
+		}),
+		exactIn: async (client, input, output, amount, user) => await swap(client, poolAddress, {
+			input,
+			output,
+			amount,
+			user,
+			mode: "exactIn"
+		})
+	};
+}
+async function swap(client, poolAddress, request) {
+	const { input, output, amount, user, mode } = request;
+	if (amount <= 0n) throw new Error("the route amount must be positive");
+	const ids = raydiumIds(client.cluster);
+	const [poolAccount] = await readAccounts(client.rpc, [poolAddress]);
+	if (!poolAccount || poolAccount.owner !== ids.cpmm) throw new Error(`${poolAddress} is not a Raydium CPMM pool on ${client.cluster}`);
+	const pool = decodeCpmmPool(poolAccount.data);
+	const inputIsToken0 = pool.token0Mint === input;
+	if (!(inputIsToken0 ? pool.token1Mint === output : pool.token1Mint === input && pool.token0Mint === output)) throw new Error(`the CPMM pool at ${poolAddress} holds ${pool.token0Mint} and ${pool.token1Mint}, not ${input} and ${output}`);
+	const inputVault = inputIsToken0 ? pool.token0Vault : pool.token1Vault;
+	const outputVault = inputIsToken0 ? pool.token1Vault : pool.token0Vault;
+	const inputTokenProgram = inputIsToken0 ? pool.token0Program : pool.token1Program;
+	const outputTokenProgram = inputIsToken0 ? pool.token1Program : pool.token0Program;
+	const [configAccount, inputVaultAccount, outputVaultAccount] = await readAccounts(client.rpc, [
+		pool.ammConfig,
+		inputVault,
+		outputVault
+	]);
+	if (!configAccount) throw new Error(`the CPMM pool at ${poolAddress} names a fee tier that is not on chain`);
+	if (!inputVaultAccount || !outputVaultAccount) throw new Error(`the CPMM pool at ${poolAddress} has no reserve accounts`);
+	const config = decodeCpmmAmmConfig(configAccount.data);
+	const owed = (token0) => token0 ? pool.protocolFeesToken0 + pool.fundFeesToken0 + pool.creatorFeesToken0 : pool.protocolFeesToken1 + pool.fundFeesToken1 + pool.creatorFeesToken1;
+	const sides = {
+		inputReserve: tokenAccountAmount(inputVaultAccount.data) - owed(inputIsToken0),
+		outputReserve: tokenAccountAmount(outputVaultAccount.data) - owed(!inputIsToken0)
+	};
+	if (sides.inputReserve <= 0n || sides.outputReserve <= 0n) throw new Error(`the CPMM pool at ${poolAddress} has no tradable reserves`);
+	const rates = {
+		tradeFeeRate: config.tradeFeeRate,
+		creatorFeeRate: pool.enableCreatorFee ? config.creatorFeeRate : 0n,
+		creatorFeeOnInput: creatorFeeOnInput(pool, input)
+	};
+	const userInput = await ata(user, input, inputTokenProgram);
+	const userOutput = await ata(user, output, outputTokenProgram);
+	const abi = mode === "exactOut" ? CPMM_SWAP_BASE_OUTPUT : CPMM_SWAP_BASE_INPUT;
+	const accounts = order(abi, {
+		payer: user,
+		authority: ids.cpmmAuthority,
+		amm_config: pool.ammConfig,
+		pool_state: poolAddress,
+		input_token_account: userInput,
+		output_token_account: userOutput,
+		input_vault: inputVault,
+		output_vault: outputVault,
+		input_token_program: inputTokenProgram,
+		output_token_program: outputTokenProgram,
+		input_token_mint: input,
+		output_token_mint: output,
+		observation_state: pool.observationKey
+	});
+	const exactOut = mode === "exactOut";
+	const priced = exactOut ? cpmmSwapBaseOutput(sides, rates, amount) : cpmmSwapBaseInput(sides, rates, amount);
+	const inAmount = exactOut ? widen(priced) : amount;
+	const outAmount = exactOut ? amount : narrow(priced);
+	return {
+		instructions: wrap({
+			user,
+			input,
+			output,
+			userInput,
+			userOutput,
+			inputTokenProgram,
+			outputTokenProgram,
+			lamportsIn: inAmount,
+			middle: [{
+				programAddress: ids.cpmm,
+				accounts,
+				data: new Uint8Array([
+					...abi.discriminator,
+					...u64.encode(exactOut ? inAmount : amount),
+					...u64.encode(exactOut ? amount : outAmount)
+				])
+			}]
+		}),
+		lookupTables: {},
+		inAmount,
+		outAmount,
+		mode,
+		computeUnits: CPMM_ROUTE_COMPUTE_UNITS
+	};
+}
+/** Add the slippage margin to a cost the caller signs as a maximum. */
+const widen = (amount) => amount + amount * CPMM_ROUTE_SLIPPAGE_BPS / 10000n;
+/** Take the slippage margin off a payout the caller signs as a minimum. */
+const narrow = (amount) => amount - amount * CPMM_ROUTE_SLIPPAGE_BPS / 10000n;
+/**
+* Create the two token accounts the swap needs, wrap the SOL it spends, and close the WSOL account
+* afterwards.
+*
+* Only one side is ever WSOL here: a Gabox pool quoted in WSOL never uses a route at all.
+*/
+function wrap(input) {
+	const payer = createNoopSigner(input.user);
+	const createAta = (account, mint, tokenProgram) => withoutSigners(getCreateAssociatedTokenIdempotentInstruction({
+		payer,
+		ata: account,
+		owner: input.user,
+		mint,
+		tokenProgram
+	}));
+	const before = [createAta(input.userInput, input.input, input.inputTokenProgram), createAta(input.userOutput, input.output, input.outputTokenProgram)];
+	const after = [];
+	if (input.input === "So11111111111111111111111111111111111111112") {
+		before.push(withoutSigners(getTransferSolInstruction({
+			source: payer,
+			destination: input.userInput,
+			amount: input.lamportsIn
+		})), getSyncNativeInstruction({ account: input.userInput }));
+		after.push(closeWsol(input.userInput, payer));
+	}
+	if (input.output === "So11111111111111111111111111111111111111112") after.push(closeWsol(input.userOutput, payer));
+	return [
+		...before,
+		...input.middle,
+		...after
+	];
+}
+/**
+* Close a WSOL account, sending every lamport in it back to the owner as SOL.
+*
+* The owner has to sign, so it goes in as a signer and comes out as a plain signing slot.
+*/
+const closeWsol = (account, owner) => withoutSigners(getCloseAccountInstruction({
+	account,
+	destination: owner.address,
+	owner
+}));
+/**
+* Drop every attached signer object, keeping each account's address and role.
+*
+* A signing slot stays a signing slot: the compiled message still requires that signature, and the
+* wallet paying for the transaction provides it. What goes away is the second signer object for an
+* address the fee payer already covers, which kit refuses to sign.
+*/
+function withoutSigners(instruction) {
+	const accounts = (instruction.accounts ?? []).map((account) => ({
+		address: account.address,
+		role: account.role
+	}));
+	return {
+		...instruction,
+		accounts
+	};
+}
+//#endregion
+//#region src/route/jupiter.ts
+/**
+* The Jupiter route provider.
+*
+* Jupiter is an HTTP service, not a program this SDK builds instructions for. Two calls per route:
+*
+*   1. `GET /swap/v1/quote` prices the swap and returns a quote object.
+*   2. `POST /swap/v1/swap-instructions` turns that quote into instructions.
+*
+* The response gives `setupInstructions`, `swapInstruction` and `cleanupInstruction`, each as a
+* program id, a list of accounts and base64 data. This module decodes those into kit instructions
+* and leaves everything else alone. Jupiter's own compute budget instructions are dropped: every
+* builder in this SDK sets its own budget, and two `SetComputeUnitLimit` instructions in one message
+* is one too many. Their **number** is kept, though: it is Jupiter's own answer to "how much does
+* this route cost", and a builder adds it to its own limit.
+*
+* `wrapAndUnwrapSol: true` is always sent, so Jupiter creates the wallet's WSOL account, funds it
+* from the wallet's lamports and closes it again inside its own instructions. That is what makes
+* "pay in SOL" true from the wallet's side.
+*
+* # No Jupiter package
+*
+* The public surface of this SDK is `@solana/kit` only. Nothing here imports a Jupiter package; the
+* response is plain JSON and the decoding below is a dozen lines.
+*
+* # Exact-out is not always available
+*
+* Jupiter answers `NO_ROUTES_FOUND` for an exact-out quote whenever the best route has more than
+* one hop. Verified on 2026-09-18: SOL to USDC quotes exact-out, while SOL to the stock token
+* `XsDoVfqeBukxuZHWhdvWHBhgEHjGNst4MLodqsJHzoB` only quotes exact-in. `routeQuoteIn` in `leg.ts`
+* handles that fallback; this file only reports the failure.
+*/
+/** Jupiter's free endpoint. The keyed host `https://api.jup.ag/swap/v1` has the same shape. */
+const JUPITER_LITE_URL = "https://lite-api.jup.ag/swap/v1";
+/** The slippage Jupiter prices a route with when the caller names none. 1%. */
+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.
+*/
+const JUPITER_DEFAULT_COMPUTE_UNITS = 4e5;
+/** `ComputeBudgetInstruction::SetComputeUnitLimit`, whose data is the tag then a u32 of units. */
+const SET_COMPUTE_UNIT_LIMIT = 2;
+const base64 = getBase64Encoder();
+/**
+* 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.
+*/
+function jupiterRoute(options = {}) {
+	const url = (options.url ?? "https://lite-api.jup.ag/swap/v1").replace(/\/+$/, "");
+	const slippageBps = options.slippageBps ?? 100;
+	const build = async (client, input, output, amount, user, swapMode) => {
+		if (amount <= 0n) throw new Error("the route amount must be positive");
+		const quote = await fetchQuote(url, {
+			input,
+			output,
+			amount,
+			swapMode,
+			slippageBps
+		});
+		const response = await fetchSwapInstructions(url, quote, user);
+		const threshold = BigInt(String(quote.otherAmountThreshold));
+		return await routeFrom(client, response, {
+			inAmount: swapMode === "ExactOut" ? threshold : BigInt(String(quote.inAmount)),
+			outAmount: swapMode === "ExactOut" ? BigInt(String(quote.outAmount)) : threshold,
+			mode: swapMode === "ExactOut" ? "exactOut" : "exactIn"
+		});
+	};
+	return {
+		exactOut: async (client, input, output, amount, user) => await build(client, input, output, amount, user, "ExactOut"),
+		exactIn: async (client, input, output, amount, user) => await build(client, input, output, amount, user, "ExactIn")
+	};
+}
+async function fetchQuote(url, input) {
+	const query = new URLSearchParams({
+		inputMint: input.input,
+		outputMint: input.output,
+		amount: input.amount.toString(),
+		swapMode: input.swapMode,
+		slippageBps: String(input.slippageBps)
+	});
+	const response = await fetch(`${url}/quote?${query.toString()}`);
+	const body = await response.json();
+	if (!response.ok || body.error) throw new Error(`Jupiter has no ${input.swapMode} route from ${input.input} to ${input.output}: ` + `${body.errorCode ?? response.status} ${body.error ?? ""}`.trim());
+	return body;
+}
+async function fetchSwapInstructions(url, quoteResponse, userPublicKey) {
+	const response = await fetch(`${url}/swap-instructions`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			quoteResponse,
+			userPublicKey,
+			wrapAndUnwrapSol: true
+		})
+	});
+	const body = await response.json();
+	if (!response.ok || body.error || !body.swapInstruction) throw new Error(`Jupiter could not build the swap instructions: ${response.status} ${body.error ?? ""}`.trim());
+	return body;
+}
+/**
+* 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.
+*/
+async function routeFrom(client, response, amounts) {
+	return {
+		instructions: [
+			...(response.setupInstructions ?? []).map(toKitInstruction),
+			toKitInstruction(response.swapInstruction),
+			...response.cleanupInstruction ? [toKitInstruction(response.cleanupInstruction)] : []
+		],
+		lookupTables: await fetchAddressLookupTables(client, response.addressLookupTableAddresses ?? []),
+		computeUnits: computeUnitsOf(response),
+		...amounts
+	};
+}
+/**
+* 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.
+*/
+function computeUnitsOf(response) {
+	for (const instruction of response.computeBudgetInstructions ?? []) {
+		const data = new Uint8Array(base64.encode(instruction.data));
+		if (data.length < 5 || data[0] !== SET_COMPUTE_UNIT_LIMIT) continue;
+		return new DataView(data.buffer, data.byteOffset).getUint32(1, true);
+	}
+	return JUPITER_DEFAULT_COMPUTE_UNITS;
+}
+/** One Jupiter instruction as a kit instruction. The roles come from the two booleans. */
+function toKitInstruction(instruction) {
+	const accounts = instruction.accounts.map((account) => ({
+		address: account.pubkey,
+		role: account.isSigner ? account.isWritable ? AccountRole.WRITABLE_SIGNER : AccountRole.READONLY_SIGNER : account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY
+	}));
+	return {
+		programAddress: instruction.programId,
+		accounts,
+		data: new Uint8Array(base64.encode(instruction.data))
+	};
+}
+//#endregion
 //#region src/rpc.ts
 /**
 * The client, and the cluster guard.
@@ -866,9 +974,19 @@ function createClient(config) {
 		wsUrl,
 		rpc: createSolanaRpc(url),
 		rpcSubscriptions: createSolanaRpcSubscriptions(wsUrl),
-		addressLookupTables: config.addressLookupTables ?? defaultAddressLookupTables(cluster)
+		addressLookupTables: config.addressLookupTables ?? defaultAddressLookupTables(cluster),
+		route: config.route === void 0 ? defaultRoute(cluster) : config.route
 	};
 }
+/**
+* The swap provider a cluster gets when the caller names none.
+*
+* Jupiter on mainnet, nothing anywhere else. Jupiter's API only prices mainnet liquidity, and a
+* devnet caller has to say which pool to route through, so there is nothing to guess.
+*/
+function defaultRoute(cluster) {
+	return cluster === "mainnet-beta" ? jupiterRoute() : null;
+}
 //#endregion
 //#region src/tx/wsol.ts
 /**
@@ -922,6 +1040,176 @@ function unwrapWsol(owner, account) {
 	});
 }
 //#endregion
+//#region src/tx/quoteLeg.ts
+/**
+* Getting the quote token into, and out of, the wallet's own quote account.
+*
+* Gabox settles in the pool's quote asset and nothing else. Both venues move that token in and out
+* of one account: the wallet's associated token account for the quote mint, under the quote's own
+* token program. The program pins that address and measures the exact delta there. So every builder
+* in this directory has to make sure the account exists, and holds what the trade will spend.
+*
+* Three shapes, and which one applies follows from the pool's quote and the caller's choice:
+*
+*   - **A WSOL pool.** The wallet pays in SOL already. Create the WSOL account, move the lamports
+*     into it, `syncNative`, and close it afterwards so the change and any proceeds come back as
+*     SOL. This is what every 0.6.0 flow did, unchanged.
+*   - **Another quote, paying in that quote.** The wallet already holds the token. Create the
+*     account if it is missing and leave it alone: it is not WSOL, so closing it would be wrong.
+*   - **Another quote, paying in SOL.** A route turns SOL into the quote token in the same
+*     transaction, before `buy_pack`. A sale does the reverse afterwards. `routeQuoteIn` and
+*     `routeQuoteOut` build those, and `assertRouteIsSafe` checks the result before it is used.
+*
+* The third shape belongs to packs only. A machine's seed is always paid by its creator, in the
+* machine's own quote token, so `createMachine` uses `quoteLegFromWallet` and never swaps.
+*
+* Nothing here ever splits the work across two transactions. A swap that settles separately would
+* leave the wallet holding a token it never asked for whenever the second half failed.
+*/
+/** Create the wallet's quote account if it is missing. Idempotent, so a second create is free. */
+function createQuoteAccount(owner, venue) {
+	return getCreateAssociatedTokenIdempotentInstruction({
+		payer: owner,
+		ata: venue.userQuoteToken,
+		owner: owner.address,
+		mint: venue.quoteMint,
+		tokenProgram: venue.quoteTokenProgram
+	});
+}
+/**
+* The leg for a wallet that already holds what it is about to spend. No swap.
+*
+* A WSOL pool is the one case where "already holds it" means lamports, so those are wrapped and the
+* account is closed again afterwards. Any other quote only needs its account to exist; closing it
+* would throw away a real balance.
+*
+* `createMachine` uses this and nothing else: the seed is always the creator's own money, in the
+* machine's quote token.
+*/
+async function quoteLegFromWallet(venue, payer, maxQuoteIn) {
+	if (venue.quoteMint === "So11111111111111111111111111111111111111112") {
+		const wsol = await fundWsol(payer, maxQuoteIn);
+		return {
+			before: wsol.instructions,
+			after: [unwrapWsol(payer, wsol.account)],
+			lookupTables: {},
+			mode: null,
+			solAmount: maxQuoteIn,
+			computeUnits: 0
+		};
+	}
+	return {
+		before: [createQuoteAccount(payer, venue)],
+		after: [],
+		lookupTables: {},
+		mode: null,
+		solAmount: null,
+		computeUnits: 0
+	};
+}
+/**
+* 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.
+*/
+async function quoteLegIn(client, input) {
+	const { venue, payer, maxQuoteIn, payWith } = input;
+	if (venue.quoteMint === "So11111111111111111111111111111111111111112" || payWith === "quote") return await quoteLegFromWallet(venue, payer, maxQuoteIn);
+	const route = await routeQuoteIn(client, providerOf(client, venue.quoteMint), {
+		quoteMint: venue.quoteMint,
+		amount: maxQuoteIn,
+		user: payer.address
+	});
+	assertRouteIsSafe(route, {
+		forbidden: [GABOX_PROGRAM_ID, ...input.gaboxAccounts],
+		settlesIn: venue.userQuoteToken
+	});
+	return {
+		before: route.instructions,
+		after: [],
+		lookupTables: route.lookupTables,
+		mode: route.mode,
+		solAmount: route.inAmount,
+		computeUnits: route.computeUnits
+	};
+}
+/**
+* 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.
+*/
+async function quoteLegOut(client, input) {
+	const { venue, seller, minQuoteOutput, receive } = input;
+	if (venue.quoteMint === "So11111111111111111111111111111111111111112") {
+		const wsol = await fundWsol(seller, 0n);
+		return {
+			before: wsol.instructions,
+			after: [unwrapWsol(seller, wsol.account)],
+			lookupTables: {},
+			mode: null,
+			solAmount: null,
+			computeUnits: 0
+		};
+	}
+	const create = createQuoteAccount(seller, venue);
+	if (receive === "quote") return {
+		before: [create],
+		after: [],
+		lookupTables: {},
+		mode: null,
+		solAmount: null,
+		computeUnits: 0
+	};
+	const route = await routeQuoteOut(client, providerOf(client, venue.quoteMint), {
+		quoteMint: venue.quoteMint,
+		amount: minQuoteOutput,
+		user: seller.address
+	});
+	assertRouteIsSafe(route, {
+		forbidden: [GABOX_PROGRAM_ID, ...input.gaboxAccounts],
+		settlesIn: venue.userQuoteToken
+	});
+	return {
+		before: [create],
+		after: route.instructions,
+		lookupTables: route.lookupTables,
+		mode: route.mode,
+		solAmount: route.outAmount,
+		computeUnits: route.computeUnits
+	};
+}
+/** The client's route provider, with a message that says what to do when it has none. */
+function providerOf(client, quoteMint) {
+	if (!client.route) throw new Error(`this ${client.cluster} client has no route provider, so it cannot pay in SOL for a pool quoted in ${quoteMint}. Pass \`route\` to createClient — raydiumCpmmRoute(pool) for a CPMM pool that holds the SOL pair — or pay in the quote token itself.`);
+	return client.route;
+}
+/**
+* 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.
+*/
+function computeUnitsWithRoute(own, leg) {
+	return Math.min(own + leg.computeUnits, MAX_COMPUTE_UNIT_LIMIT);
+}
+/**
+* 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.
+*/
+function routeSizeHint(cause, leg) {
+	if (leg.mode === null) return cause;
+	if (!(cause instanceof Error) || !cause.message.includes("Solana allows 1232")) return cause;
+	return new Error(`${cause.message} The swap and the Gabox instruction share one transaction on purpose, so this SDK never splits them. Supply more address lookup tables, or pay in the quote token.`, { cause });
+}
+//#endregion
 //#region src/tx/buyPack.ts
 async function buyPack(client, input) {
 	if (input.maxQuoteIn <= 0n) throw new Error("maxQuoteIn must be positive");
@@ -933,6 +1221,11 @@ async function buyPack(client, input) {
 	const venue = await resolveVenue(client, {
 		mint: input.mint,
 		user: purchaser,
+		quote: {
+			mint: pool.quoteMint,
+			config: pool.quoteConfig,
+			tokenProgram: pool.quoteTokenProgram
+		},
 		...input.venue ? { venue: input.venue } : {}
 	});
 	const draw = await drawAddress(poolAddress, input.seq ?? pool.nextSeq);
@@ -944,30 +1237,50 @@ async function buyPack(client, input) {
 		quoteMint: pool.quoteMint,
 		vault: pool.vault,
 		venue: venue.program,
+		quoteTokenProgram: pool.quoteTokenProgram,
 		maxQuoteIn: input.maxQuoteIn,
 		minMaximum: input.minMaximum,
 		maxNativeDebit: input.maxNativeDebit
 	});
-	const wsol = await fundWsol(input.purchaser, input.maxQuoteIn);
+	const leg = await quoteLegIn(client, {
+		venue,
+		payer: input.purchaser,
+		maxQuoteIn: input.maxQuoteIn,
+		payWith: input.payWith ?? "sol",
+		gaboxAccounts: [
+			poolAddress,
+			pool.vault,
+			draw,
+			await activityAddress(purchaser),
+			await associatedTokenAddress(purchaser, input.mint)
+		]
+	});
 	const instructions = [
-		...wsol.instructions,
+		...leg.before,
 		withRemainingAccounts(buy, venue.buyAccounts),
-		unwrapWsol(input.purchaser, wsol.account)
+		...leg.after
 	];
-	return await buildMessage(client, input.purchaser, instructions, {
-		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? 24e4,
-		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
-	});
+	try {
+		return await buildMessage(client, input.purchaser, instructions, {
+			addressLookupTables: {
+				...input.addressLookupTables ?? client.addressLookupTables,
+				...leg.lookupTables
+			},
+			computeUnitLimit: input.computeUnitLimit ?? computeUnitsWithRoute(235e3, leg),
+			...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+		});
+	} catch (cause) {
+		throw routeSizeHint(cause, leg);
+	}
 }
 //#endregion
 //#region src/tx/createMachine.ts
 /**
 * 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.
 */
 async function createMachine(client, input) {
 	const { creator, mintKeypair, name, symbol, uri, maxSeedQuoteIn, maxSeedNativeDebit } = input;
@@ -983,52 +1296,65 @@ async function createMachine(client, input) {
 	if (maxSeedNativeDebit < 0n) throw new Error("maxSeedNativeDebit must not be negative");
 	const ids = raydiumIds(client.cluster);
 	const mint = mintKeypair.address;
-	const quoteMint = WSOL_MINT;
+	const quote = await fetchQuoteAsset(client, input.quote?.mint ?? "So11111111111111111111111111111111111111112", ids);
+	const raise = resolveRaise(client, quote, input.raise, ids);
 	const create = await getLaunchInstruction({
 		mint: mintKeypair,
 		creator,
 		name,
 		symbol,
-		uri
+		uri,
+		quoteMint: quote.mint,
+		quoteConfig: quote.config,
+		quoteTokenProgram: quote.tokenProgram,
+		raise
 	}, ids);
-	const poolState = await launchlabPoolAddress(ids.launchlab, mint, quoteMint);
+	const poolState = await launchlabPoolAddress(ids.launchlab, mint, quote.mint);
+	const userQuoteToken = await quoteAccountFor(creator.address, quote.mint, quote.tokenProgram);
 	const venueAccounts = launchlabBuyAccounts({
 		launchlab: ids.launchlab,
 		launchlabAuthority: ids.launchlabAuthority,
 		launchlabEventAuthority: ids.launchlabEventAuthority,
-		globalConfig: ids.solGlobalConfig,
+		globalConfig: quote.config,
 		platformConfig: ids.gaboxPlatform,
 		poolState,
 		mint,
-		quoteMint,
+		quoteMint: quote.mint,
 		baseVault: await launchlabVaultAddress(ids.launchlab, poolState, mint),
-		quoteVault: await launchlabVaultAddress(ids.launchlab, poolState, quoteMint),
+		quoteVault: await launchlabVaultAddress(ids.launchlab, poolState, quote.mint),
 		user: creator.address,
 		userBaseToken: await ata(creator.address, mint),
-		userQuoteToken: await ata(creator.address, quoteMint),
-		platformFeeVault: await platformFeeVaultAddress(ids.launchlab, ids.gaboxPlatform, quoteMint),
-		creatorFeeVault: await creatorFeeVaultAddress(ids.launchlab, creator.address, quoteMint)
+		userQuoteToken,
+		quoteTokenProgram: quote.tokenProgram,
+		platformFeeVault: await platformFeeVaultAddress(ids.launchlab, ids.gaboxPlatform, quote.mint),
+		creatorFeeVault: await creatorFeeVaultAddress(ids.launchlab, creator.address, quote.mint)
 	});
 	const initialize = await getInitializePoolInstructionAsync({
 		creator,
 		mint,
-		quoteMint,
+		quoteMint: quote.mint,
+		quoteConfig: quote.config,
+		quoteTokenProgram: quote.tokenProgram,
 		venue: ids.launchlab,
 		tiers,
 		maxSeedQuoteIn,
 		maxSeedNativeDebit,
 		extraSeedTokens
 	});
-	const wsol = await fundWsol(creator, maxSeedQuoteIn);
+	const leg = await quoteLegFromWallet({
+		quoteMint: quote.mint,
+		quoteTokenProgram: quote.tokenProgram,
+		userQuoteToken
+	}, creator, maxSeedQuoteIn);
 	const instructions = [
 		create,
-		...wsol.instructions,
+		...leg.before,
 		withRemainingAccounts(initialize, venueAccounts),
-		unwrapWsol(creator, wsol.account)
+		...leg.after
 	];
 	return await buildMessage(client, creator, instructions, {
-		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? 385e3,
+		addressLookupTables: input.addressLookupTables ?? client.addressLookupTables,
+		computeUnitLimit: input.computeUnitLimit ?? 35e4,
 		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
 	});
 }
@@ -1036,13 +1362,17 @@ async function createMachine(client, input) {
 * 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 what that cost is worth in SOL, priced through the client's route provider. It is
+* a display: the creator pays in the quote token. 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.
 */
 async function seedCostEstimate(client, tiers = DEFAULT_TIERS, options = {}) {
 	const copiedTiers = cloneTiers(tiers);
@@ -1054,16 +1384,39 @@ async function seedCostEstimate(client, tiers = DEFAULT_TIERS, options = {}) {
 	const seed = mandatorySeed + extraSeedTokens;
 	assertSeedFitsCurve(seed);
 	const ids = raydiumIds(client.cluster);
-	const settings = await fetchCurveSettings(client, ids);
+	const quote = await fetchQuoteAsset(client, options.quote?.mint ?? "So11111111111111111111111111111111111111112", ids);
+	const raise = resolveRaise(client, quote, options.raise, ids);
+	const settings = await fetchCurveSettings(client, quote.config, ids);
+	const quoteAmount = seed === 0n ? 0n : curveBuyExactOut(newCurveReserves(raise, settings.migrateFee), settings.rates, seed);
 	return {
 		tiers: copiedTiers,
 		seedTokens: mandatorySeed,
 		extraSeedTokens,
 		totalSeedTokens: seed,
-		quoteAmount: seed === 0n ? 0n : curveBuyExactOut(newCurveReserves(ids, settings.migrateFee), settings.rates, seed),
-		quoteMint: WSOL_MINT
+		quoteAmount,
+		quoteMint: quote.mint,
+		quoteDecimals: quote.decimals,
+		quoteSymbol: quote.symbol,
+		raise,
+		solAmount: await solPriceOf(client, quote.mint, quoteAmount)
 	};
 }
+/**
+* The raise a launch uses, checked before anything is built.
+*
+* The program pins it for a WSOL pool, so a different value there is a launch that would be
+* refused on chain. Any other quote has no default and no pin: the caller names it, and LaunchLab's
+* own minimum for that quote is the floor.
+*/
+function resolveRaise(client, quote, raise, ids) {
+	if (quote.mint === "So11111111111111111111111111111111111111112") {
+		if (raise !== void 0 && raise !== ids.launchQuoteRaise) throw new Error(`a WSOL pool raises exactly ${ids.launchQuoteRaise} lamports on ${client.cluster}; the program refuses ${raise}. Leave \`raise\` out, or pick another quote asset.`);
+		return ids.launchQuoteRaise;
+	}
+	if (raise === void 0) throw new Error(`a pool quoted in ${quote.mint} needs a \`raise\`, in that token's base units. There is no default, because the same number means a different amount in every token.`);
+	if (raise < quote.minQuoteFundRaising) throw new Error(`LaunchLab takes at least ${quote.minQuoteFundRaising} base units of ${quote.mint} as a raise, and this launch asks for ${raise}`);
+	return raise;
+}
 /** A mutable table shape, owned by this call and safe to pass to Codama's builder. */
 function cloneTiers(tiers) {
 	return tiers.map(({ multiplierBps, tickets }) => ({
@@ -1162,29 +1515,53 @@ async function sellTokens(client, input) {
 	const venue = await resolveVenue(client, {
 		mint: input.mint,
 		user: input.seller.address,
+		quote: {
+			mint: pool.quoteMint,
+			config: pool.quoteConfig,
+			tokenProgram: pool.quoteTokenProgram
+		},
 		...input.venue ? { venue: input.venue } : {}
 	});
+	const gaboxPool = await poolAddress(input.mint);
 	const sell = await getSellTokensInstructionAsync({
 		seller: input.seller,
-		pool: await poolAddress(input.mint),
+		pool: gaboxPool,
 		mint: input.mint,
 		quoteMint: pool.quoteMint,
 		venue: venue.program,
+		quoteTokenProgram: pool.quoteTokenProgram,
 		amount: input.amount,
 		minQuoteOutput: input.minQuoteOutput,
 		maxNativeDebit: input.maxNativeDebit
 	});
-	const wsol = await fundWsol(input.seller, 0n);
+	const leg = await quoteLegOut(client, {
+		venue,
+		seller: input.seller,
+		minQuoteOutput: input.minQuoteOutput,
+		receive: input.receive ?? "sol",
+		gaboxAccounts: [
+			gaboxPool,
+			await vaultAddress(input.mint),
+			await associatedTokenAddress(input.seller.address, input.mint)
+		]
+	});
 	const instructions = [
-		...wsol.instructions,
+		...leg.before,
 		withRemainingAccounts(sell, venue.sellAccounts),
-		unwrapWsol(input.seller, wsol.account)
+		...leg.after
 	];
-	return await buildMessage(client, input.seller, instructions, {
-		addressLookupTables: input.addressLookupTables,
-		computeUnitLimit: input.computeUnitLimit ?? 135e3,
-		...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
-	});
+	try {
+		return await buildMessage(client, input.seller, instructions, {
+			addressLookupTables: {
+				...input.addressLookupTables ?? client.addressLookupTables,
+				...leg.lookupTables
+			},
+			computeUnitLimit: input.computeUnitLimit ?? computeUnitsWithRoute(125e3, leg),
+			...input.computeUnitPrice === void 0 ? {} : { computeUnitPrice: input.computeUnitPrice }
+		});
+	} catch (cause) {
+		throw routeSizeHint(cause, leg);
+	}
 }
 //#endregion
 //#region src/vrf.ts
@@ -1204,6 +1581,6 @@ async function oracleAccounts() {
 	};
 }
 //#endregion
-export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BPS, BUY_PACK_COMPUTE_UNITS, CLAIM_COMPUTE_UNITS, CLUSTER_ENDPOINTS, COMPUTE_BUDGET_PROGRAM_ADDRESS, CREATE_MACHINE_COMPUTE_UNITS, DEFAULT_COMPUTE_UNIT_LIMIT, DEFAULT_TIERS, DEVNET_ADDRESS_LOOKUP_TABLES, DEVNET_HTTP, DEVNET_LOOKUP_TABLE_ADDRESS, DEVNET_LOOKUP_TABLE_ADDRESSES, DEVNET_WS, DRAW_DISCRIMINATOR, DRAW_POOL_OFFSET, DRAW_PURCHASER_OFFSET, GABOX_PROGRAM_ID, GaboxMathError, IDENTITY_SEED, INSTRUCTIONS_SYSVAR, LAUNCH_DECIMALS, MAX_ATTEMPTS, MAX_COMPUTE_UNIT_LIMIT, MAX_MULTIPLIER_BPS, METAPLEX_PROGRAM_ADDRESS, MIN_SEED_MULTIPLIER_BPS, PACK_TOKENS, PLATFORM_ADMIN, POOL_CREATOR_OFFSET, POOL_DISCRIMINATOR, POOL_MINT_OFFSET, REDEEM_COMPUTE_UNITS, RETRY_SLOTS, SLOT_HASHES_SYSVAR, SYSTEM_PROGRAM_ADDRESS, TICKETS, TIERS, TIMEOUT_SLOTS, TOKEN_PROGRAM_ADDRESS, VRF_DEFAULT_QUEUE, VRF_PROGRAM_ADDRESS, WALLET_ACTIVITY_DISCRIMINATOR, WSOL_MINT, activityAddress, assertClusterUrl, associatedTokenAddress, averageMultiplierBps, buildMessage, buyPack, choose, clusterNamedBy, computeBudgetInstructions, createClient, createMachine, decodeDraw, decodeEvent, decodeEvents, decodePool, decodeWalletActivity, defaultAddressLookupTables, drawAddress, drawAvailability, expireDraw, fetchDraw, fetchEvents, fetchPoolAt, fetchPoolByMint, fetchPoolInventory, fetchVaultBalance, fetchWalletActivity, findActivityPda, findDrawPda, findIdentityPda, findPoolPda, findResolvedDraw, fundPrizes, fundWsol, generated_exports as generated, getOffer, getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, listDraws, listDrawsByPool, listDrawsByPurchaser, listPools, maxMultiplierBps, offerFromState, oracleAccounts, poolAddress, quote, quotePool, raydium_exports as raydium, resolveReservation, retryDraw, scopedVrfIdentityAddress, seedCostEstimate, seedShortfall, seedTokens, sellTokens, tierAmount, tiersOf, uncappedMaximum, unwrapWsol, validatePack, validateTiers, vaultAddress, vrfIdentityAddress, websocketUrlFor, withRemainingAccounts };
+export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BPS, BUY_PACK_COMPUTE_UNITS, CLAIM_COMPUTE_UNITS, CLUSTER_ENDPOINTS, COMPUTE_BUDGET_PROGRAM_ADDRESS, CPMM_ROUTE_COMPUTE_UNITS, CPMM_ROUTE_SLIPPAGE_BPS, CREATE_MACHINE_COMPUTE_UNITS, DEFAULT_COMPUTE_UNIT_LIMIT, DEFAULT_TIERS, DEVNET_ADDRESS_LOOKUP_TABLES, DEVNET_HTTP, DEVNET_LOOKUP_TABLE_ADDRESS, DEVNET_LOOKUP_TABLE_ADDRESSES, DEVNET_WS, DRAW_DISCRIMINATOR, DRAW_POOL_OFFSET, DRAW_PURCHASER_OFFSET, EXACT_IN_MARGIN_BPS, GABOX_PROGRAM_ID, GaboxMathError, IDENTITY_SEED, INSTRUCTIONS_SYSVAR, JUPITER_DEFAULT_COMPUTE_UNITS, JUPITER_DEFAULT_SLIPPAGE_BPS, JUPITER_LITE_URL, LAUNCH_DECIMALS, MAX_ATTEMPTS, MAX_COMPUTE_UNIT_LIMIT, MAX_MULTIPLIER_BPS, METAPLEX_PROGRAM_ADDRESS, MIN_SEED_MULTIPLIER_BPS, PACK_TOKENS, PLATFORM_ADMIN, POOL_CREATOR_OFFSET, POOL_DISCRIMINATOR, POOL_MINT_OFFSET, REDEEM_COMPUTE_UNITS, RETRY_SLOTS, SLOT_HASHES_SYSVAR, SYSTEM_PROGRAM_ADDRESS, TICKETS, TIERS, TIMEOUT_SLOTS, TOKEN_PROGRAM_ADDRESS, VRF_DEFAULT_QUEUE, VRF_PROGRAM_ADDRESS, WALLET_ACTIVITY_DISCRIMINATOR, WSOL_MINT, activityAddress, assertClusterUrl, assertRouteIsSafe, associatedTokenAddress, averageMultiplierBps, buildMessage, buyPack, choose, clusterNamedBy, computeBudgetInstructions, computeUnitsOf, computeUnitsWithRoute, createClient, createMachine, createQuoteAccount, decodeDraw, decodeEvent, decodeEvents, decodePool, decodeWalletActivity, defaultAddressLookupTables, defaultRoute, drawAddress, drawAvailability, expireDraw, fetchAddressLookupTables, fetchDraw, fetchEvents, fetchPoolAt, fetchPoolByMint, fetchPoolInventory, fetchVaultBalance, fetchWalletActivity, findActivityPda, findDrawPda, findIdentityPda, findPoolPda, findResolvedDraw, fundPrizes, fundWsol, generated_exports as generated, getOffer, getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, jupiterRoute, listDraws, listDrawsByPool, listDrawsByPurchaser, listPools, maxMultiplierBps, offerFromState, oracleAccounts, poolAddress, providerOf, quote, quoteLegFromWallet, quoteLegIn, quoteLegOut, quotePool, raydium_exports as raydium, raydiumCpmmRoute, resolveReservation, retryDraw, routeFrom, routeQuoteIn, routeQuoteOut, routeSizeHint, scopedVrfIdentityAddress, seedCostEstimate, seedShortfall, seedTokens, sellTokens, solPriceOf, tierAmount, tiersOf, uncappedMaximum, unwrapWsol, validatePack, validateTiers, vaultAddress, vrfIdentityAddress, websocketUrlFor, withRemainingAccounts };
 
 //# sourceMappingURL=index.js.map