@gabox-labs/sdk 0.1.1 → 0.2.0

package/CHANGELOG.md

@@ -3,7 +3,29 @@
 All notable changes to `@gabox-labs/sdk`. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and the project uses [Semantic Versioning](https://semver.org/) with the `0.x` rule from `CONTRIBUTING.md`.
 
-## [Unreleased]
+## [0.2.0] - 2026-09-13
+
+### Breaking
+
+- `createMachine` now accepts an optional `tiers` table instead of required `riskProfile` and
+  `jackpotBps` inputs. `seedCostEstimate` now takes the same optional table. Both default to
+  `DEFAULT_TIERS`, the Gabox app's 20× top-prize table.
+- Removed `jackpotTiers` and `RiskProfile`. Pass an explicit validated eight-row `Tier[]` to use a
+  different prize table.
+
+### Security
+
+- `expireDraw` is documented and generated from the program revision that only permits expiry of
+  an expired `Pending` draw. A `Ready` draw is rejected with `NotPending`, preserving its resolved
+  award for normal delivery.
+
+### Changed
+
+- Code generation validates the complete program IDL and Pump ABI before replacing generated code
+  or committed IDL snapshots. A failed ABI cross-check now leaves the SDK unchanged.
+- The matching devnet program upgrade is verified at slot `497869792`. Its first 586,304 deployed
+  bytes match the reviewed SBF SHA-256 `fdbbed4161a9f2f22ce02547dc3e9ec67a22020ab58be9403d04e31464dadf89`;
+  its 595,976-byte allocation has only zero padding beyond that build.
 
 ## [0.1.1] - 2026-09-11
 

package/README.md

@@ -35,8 +35,8 @@ one pack, each with a number of tickets out of 65,536. Verifiable randomness (Ma
 one prize, and the tokens are sent straight to the buyer's wallet. The buyer signs once, at
 purchase. Keeping the prize needs nothing else. Selling it later is one more transaction.
 
-The **creator** chooses the jackpot size (for example 5×) and a risk profile. The creator buys the
-tokens that back the jackpot at creation, and earns a fee on every pack.
+The **creator** chooses an eight-row prize table, or uses `DEFAULT_TIERS`. The creator buys the
+tokens that back the table's top prize at creation, and earns a fee on every pack.
 
 ---
 
@@ -162,11 +162,11 @@ per unit), and `addressLookupTables`. The defaults are generous.
 ### Create a machine
 
 ```ts
-import { createMachine, seedCostEstimate } from '@gabox-labs/sdk';
+import { createMachine, DEFAULT_TIERS, seedCostEstimate } from '@gabox-labs/sdk';
 import { generateKeyPairSigner } from '@solana/kit';
 
 const mintKeypair = await generateKeyPairSigner();
-const seed = await seedCostEstimate(gabox, 50_000, 'balanced');
+const seed = await seedCostEstimate(gabox); // DEFAULT_TIERS
 
 const message = await createMachine(gabox, {
   creator,                  // TransactionSigner. Pays for everything.
@@ -175,8 +175,7 @@ const message = await createMachine(gabox, {
   symbol: 'CAT',
   uri: 'https://…/metadata.json',
   feeBps: 100,              // the creator's fee per pack, 0–100 bps (max 1%)
-  riskProfile: 'balanced',  // 'conservative' | 'balanced' | 'jackpot'
-  jackpotBps: 50_000,       // the top prize: 5× one pack
+  tiers: DEFAULT_TIERS,     // optional; the default is a 20× top prize
   maxSeedLamports: (seed.lamports * 105n) / 100n,
 });
 ```
@@ -184,15 +183,16 @@ const message = await createMachine(gabox, {
 One transaction, two signers: the creator and the new mint. The creator pays for the coin, the
 pool, and the **seed**.
 
-The seed is the inventory that backs the jackpot. The first pack must be able to pay the top prize
-in full. A 5× jackpot needs four extra packs of tokens in the vault; a 10× jackpot needs nine. A 1×
-jackpot needs no seed. `seedCostEstimate` tells you what that costs on a fresh Pump curve, in
-lamports and tokens. `maxSeedLamports` is the creator's slippage cap on that buy.
+The seed is the inventory that backs the top prize. The first pack must be able to pay that prize in
+full. `DEFAULT_TIERS` has 75%, 20%, 4%, and 1% odds at 0.52×, 1.2×, 3×, and 20× respectively, and
+needs nineteen extra packs in the vault. `seedCostEstimate` tells you what that costs on a fresh
+Pump curve, in lamports and tokens. `maxSeedLamports` is the creator's slippage cap on that buy.
 
-- `jackpotBps` is the largest prize, in basis points of one pack. `10_000` is 1×. `50_000` is 5×.
-- `riskProfile` decides how the odds are spread. Every profile returns 95% of a pack's value on
-  average. `conservative` keeps more of it in the common prize; `jackpot` moves more into the rare
-  ones. See `jackpotTiers(jackpotBps, profile)` to preview the table before creating.
+`tiers` is optional and defaults to `DEFAULT_TIERS`, the table the Gabox app creates pools with. A
+creator may instead supply an eight-row `Tier[]`. The SDK validates it locally and the program
+validates it again: ticket counts must total 65,536, unused rows must be all-zero, expected payout
+cannot exceed one pack, each live tier must pay at least one token, and the largest prize must be at
+least one pack. `seedCostEstimate(gabox, tiers)` previews the exact custom table before creating.
 
 ### Price a pack
 
@@ -350,9 +350,10 @@ if (state?.canExpire) await expireDraw(gabox, { payer, pool, draw });
 
 - `retryDraw` asks for randomness again. Allowed 300 slots after the last attempt, up to 3 attempts
   in total. The payer covers the request fee, capped by `maxVrfDebit`.
-- `expireDraw` settles a draw that never received randomness, 216,000 slots (about one day) after
-  the purchase. It pays the **smallest prize** on the draw's table. It is not a refund. Tell buyers
-  this before they pay.
+- `expireDraw` settles a **pending** draw that never received randomness, 216,000 slots (about one
+  day) after the purchase. It pays the **smallest prize** on the draw's table. It is not a refund.
+  It rejects a `Ready` draw: randomness has already resolved that outcome and the normal delivery
+  path must pay it. Tell buyers this before they pay.
 
 Use `drawAvailability` to show a countdown instead of sending a transaction that fails.
 
@@ -429,6 +430,7 @@ The ones a UI will meet:
 | `RetryTooSoon`       | `retryDraw` before 300 slots passed                                        |
 | `RetryUnavailable`   | `retryDraw` after 3 attempts, or on a draw that is no longer pending       |
 | `NotExpired`         | `expireDraw` before the deadline                                           |
+| `NotPending`         | `expireDraw` on a draw whose randomness has already resolved               |
 | `InvalidReferral`    | a self-referral, or a link that does not match                             |
 | `ZeroAmount`         | a zero `amount` or a zero `minQuoteOutput`                                 |
 
@@ -493,10 +495,10 @@ This repository is agent-ready.
 ## Status
 
 - **Devnet only.** Mainnet is not live.
-- The devnet program is being upgraded to the build this SDK targets. Until that upgrade lands,
-  transactions built by this SDK do not match the deployed program, and `fetchPoolByMint` reports
-  machines from the previous build as an "older devnet account layout". Watch the
-  [changelog](CHANGELOG.md) for the release that marks the upgrade done.
+- The devnet program revision this SDK targets is live and verified at slot `497869792`; see the
+  [0.2.0 changelog](CHANGELOG.md).
+  Machines from the previous account layout remain incompatible: `fetchPoolByMint` excludes them,
+  and direct reads report an "older devnet account layout" migration requirement.
 - The Pump bonding-curve route has an end-to-end test on devnet (`GABOX_DEVNET_E2E=1`). The
   PumpSwap route (coins that graduated off the curve) has unit coverage only.
 - The API is `0.x`. Breaking changes bump the minor version and are listed in the changelog.

package/dist/index.d.ts

@@ -44,8 +44,15 @@ export declare class GaboxMathError extends Error {
   readonly code: string;
   constructor(code: string, message: string);
 }
-/** Creator-facing presets. The creator picks the jackpot size; the profile chooses its odds. */
-export type RiskProfile = "conservative" | "balanced" | "jackpot";
+/**
+ * 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.
+ */
+export declare const DEFAULT_TIERS: readonly Readonly<Tier>[];
 /** `math::tokens`. Floor division, and an overflow past u64 is an error, not a wrap. */
 export declare function tierAmount(base: bigint, multiplierBps: number): bigint;
 /**
@@ -57,14 +64,14 @@ export declare function tierAmount(base: bigint, multiplierBps: number): bigint;
  *   - 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.
  */
-export declare function validateTiers(tiers: readonly Tier[]): void;
+export declare function validateTiers(tiers: readonly Readonly<Tier>[]): void;
 /**
  * `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.
  */
-export declare function validatePack(packTokens: bigint, tiers: readonly Tier[]): void;
+export declare function validatePack(packTokens: bigint, tiers: readonly Readonly<Tier>[]): void;
 /**
  * `math::seed_tokens`. The seed a table needs, in tokens.
  *
@@ -79,26 +86,13 @@ export declare function validatePack(packTokens: bigint, tiers: readonly Tier[])
  * `initialize_pool` computes this number itself and buys exactly that many tokens on the curve.
  * The creator only signs a maximum SOL cost.
  */
-export declare function seedTokens(packTokens: bigint, tiers: readonly Tier[]): bigint;
-/**
- * Derive a fully valid four-outcome rarity ladder from a jackpot multiplier and a risk preset.
- *
- * Mythic is exactly `jackpotBps`. Rare and Epic interpolate between sub-1x launch values
- * and Mythic as the jackpot grows, so the four payouts remain strictly ordered even at 1x.
- * The profile assigns fixed slices of one pack's EV budget to the three higher rarities. Whatever
- * remains of the 95% target becomes Common. Integer rounding is always downward, so the result
- * cannot cross the program's 100% expected-value ceiling.
- *
- * The seed this table needs is `seedTokens(packTokens, tiers)`: `(jackpotBps - 10_000)` bps of
- * one pack.
- */
-export declare function jackpotTiers(jackpotBps: number, profile: RiskProfile): Tier[];
+export declare function seedTokens(packTokens: bigint, tiers: readonly Readonly<Tier>[]): bigint;
 /**
  * `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.
  */
-export declare function uncappedMaximum(base: bigint, tiers: readonly Tier[]): bigint;
+export declare function uncappedMaximum(base: bigint, tiers: readonly Readonly<Tier>[]): bigint;
 /**
  * `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.
@@ -110,7 +104,7 @@ export declare function uncappedMaximum(base: bigint, tiers: readonly Tier[]): b
  * 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.
  */
-export declare function quote(base: bigint, tiers: readonly Tier[], inventory: bigint, reserved: bigint): Offer;
+export declare function quote(base: bigint, tiers: readonly Readonly<Tier>[], inventory: bigint, reserved: bigint): Offer;
 /**
  * `math::choose`. Which prize a 16-bit ticket wins.
  *
@@ -121,14 +115,14 @@ export declare function choose(prizes: readonly Prize[], ticket: number): bigint
 /** `math::resolve_reservation`. Release the unwon part of a maximum, keep the award reserved. */
 export declare function resolveReservation(reserved: bigint, maximum: bigint, award: bigint): bigint;
 /** The largest `multiplierBps` on any ticketed row. `0` for a table with no rows. */
-export declare function maxMultiplierBps(tiers: readonly Tier[]): number;
+export declare function maxMultiplierBps(tiers: readonly Readonly<Tier>[]): number;
 /**
  * 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.
  */
-export declare function averageMultiplierBps(tiers: readonly Tier[]): number;
+export declare function averageMultiplierBps(tiers: readonly Readonly<Tier>[]): number;
 //#endregion
 //#region src/accounts.d.ts
 /** `Draw.pool` sits straight after the discriminator. */
@@ -593,13 +587,12 @@ export type CreateMachineInput = {
   uri: string;
   /** The creator's fee per pack, in bps of what the venue charges. `0` to `MAX_FEE_BPS`. Immutable. */
   feeBps: number;
-  /** Controls how much probability moves from Common into Rare, Epic, and Mythic. */
-  riskProfile: RiskProfile;
   /**
-   * The jackpot: the largest tier's multiplier, in bps. `10_000` is 1x and needs no seed;
-   * `50_000` is 5x and seeds four packs of tokens. Immutable.
+   * The prize table. Immutable once the pool exists. Must pass `validateTiers` and
+   * `validatePack(PACK_TOKENS, tiers)`; the program checks both again on-chain. Defaults to
+   * `DEFAULT_TIERS`, the table the Gabox app uses.
    */
-  jackpotBps: number;
+  tiers?: readonly Readonly<Tier>[];
   /**
    * The creator's slippage cap on the seed buy, in lamports. Pump fails the buy above it.
    * Take `seedCostEstimate` and add a margin. Ignored for a 1x jackpot, which buys nothing.
@@ -619,14 +612,17 @@ export type CreateMachineInput = {
  */
 export declare function createMachine(client: GaboxClient, input: CreateMachineInput): Promise<GaboxTransactionMessage>;
 /**
- * What the seed for this jackpot costs, fees included, and how many tokens it is.
+ * What the seed for this table costs, fees included, and how many tokens it is.
  *
  * The coin does not exist yet, so the price is Pump's default new curve. Nothing else trades on
  * it before `initialize_pool` runs in the same transaction, so this is exact up to a change in
  * Pump's fee settings between the read and the send. Add a small margin for `maxSeedLamports`.
+ *
+ * Defaults to `DEFAULT_TIERS`. Throws if `tiers` fails `validateTiers`/`validatePack`, or if the
+ * seed is bigger than a fresh Pump curve can sell in one buy.
  */
-export declare function seedCostEstimate(client: GaboxClient, jackpotBps: number, riskProfile: RiskProfile): Promise<{
-  tiers: Tier[];
+export declare function seedCostEstimate(client: GaboxClient, tiers?: readonly Readonly<Tier>[]): Promise<{
+  tiers: readonly Tier[];
   seedTokens: bigint;
   lamports: bigint;
 }>;
@@ -667,19 +663,19 @@ export type DrawAvailability = {
   attempts: number;
   /** Slots remaining before a retry is allowed. `0` when it is allowed now. */
   slotsUntilRetry: bigint;
-  /** Slots remaining before the draw can be expired. `0` when it can be expired now. */
+  /** Slots remaining before an unanswered draw reaches its expiry deadline. */
   slotsUntilExpiry: bigint;
   /** All three conditions the program checks for `retry_draw`, together. */
   canRetry: boolean;
-  /** The one condition `expire_draw` checks. */
+  /** True only when the draw is still `Pending` and its expiry deadline passed. */
   canExpire: boolean;
 };
 /**
  * What a client may do to a draw right now.
  *
- * Reads the draw and the current slot, and reproduces the program's three retry conditions and its
- * one expiry condition. Showing a disabled button with a countdown beats sending a transaction that
- * fails with `RetryTooSoon`.
+ * Reads the draw and the current slot, and reproduces the program's three retry conditions and the
+ * pending-status-plus-deadline expiry conditions. Showing a disabled button with a countdown beats
+ * sending a transaction that fails with `RetryTooSoon` or `NotPending`.
  */
 export declare function drawAvailability(client: GaboxClient, draw: Address): Promise<DrawAvailability | null>;
 //#endregion

package/dist/index.js

@@ -36,45 +36,61 @@ var GaboxMathError = class extends Error {
 	}
 };
 const U64_MAX = (1n << 64n) - 1n;
-const U32_MAX = (1n << 32n) - 1n;
+const U32_MAX = 4294967295;
 /**
-* All profiles target a 95% token return. These are slices of one pack's expected-value budget
-* assigned to Rare, Epic, and Mythic respectively. A riskier profile moves more of that budget
-* out of Common and into every higher rarity; the ticket counts still decrease as rarity rises.
+* 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 RISK_PROFILES = {
-	conservative: {
-		rarityEvBps: [
-			1000n,
-			600n,
-			300n
-		],
-		targetEvBps: 9500n
-	},
-	balanced: {
-		rarityEvBps: [
-			1400n,
-			1000n,
-			700n
-		],
-		targetEvBps: 9500n
-	},
-	jackpot: {
-		rarityEvBps: [
-			1800n,
-			1500n,
-			1200n
-		],
-		targetEvBps: 9500n
-	}
-};
+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(multiplierBps) / BPS, "tier amount");
+	return checkedU64(base * BigInt(checkedU32(multiplierBps, "multiplierBps")) / BPS, "tier amount");
 }
 /**
 * `math::validate`. Checks the table alone, with no base.
@@ -89,7 +105,9 @@ 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 tier of tiers) {
+	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;
@@ -110,6 +128,7 @@ function validateTiers(tiers) {
 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`);
@@ -130,64 +149,18 @@ function validatePack(packTokens, tiers) {
 * 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");
 	return largest - packTokens;
 }
 /**
-* Derive a fully valid four-outcome rarity ladder from a jackpot multiplier and a risk preset.
-*
-* Mythic is exactly `jackpotBps`. Rare and Epic interpolate between sub-1x launch values
-* and Mythic as the jackpot grows, so the four payouts remain strictly ordered even at 1x.
-* The profile assigns fixed slices of one pack's EV budget to the three higher rarities. Whatever
-* remains of the 95% target becomes Common. Integer rounding is always downward, so the result
-* cannot cross the program's 100% expected-value ceiling.
-*
-* The seed this table needs is `seedTokens(packTokens, tiers)`: `(jackpotBps - 10_000)` bps of
-* one pack.
-*/
-function jackpotTiers(jackpotBps, profile) {
-	const settings = RISK_PROFILES[profile];
-	if (!settings) throw new GaboxMathError("InvalidDistribution", `unknown risk profile: ${profile}`);
-	if (!Number.isInteger(jackpotBps) || jackpotBps < Number(10000n)) throw new GaboxMathError("JackpotBelowOnePack", "jackpotBps must be a whole number of at least 10_000 (1x)");
-	if (BigInt(jackpotBps) > U32_MAX) throw new GaboxMathError("Arithmetic", "jackpotBps does not fit in u32");
-	const maximum = BigInt(jackpotBps);
-	const totalTickets = BigInt(TICKETS);
-	const growth = maximum - BPS;
-	const rarityMultipliers = [
-		9600n + growth / 8n,
-		9800n + growth / 3n,
-		maximum
-	];
-	const rarityTickets = rarityMultipliers.map((multiplier, index) => settings.rarityEvBps[index] * totalTickets / multiplier);
-	if (rarityTickets.some((tickets) => tickets < 1n)) throw new GaboxMathError("UnfundedExpectation", `jackpot ladder is too large for the ${profile} profile's minimum one-ticket odds`);
-	const commonTickets = totalTickets - rarityTickets.reduce((sum, tickets) => sum + tickets, 0n);
-	if (commonTickets < 1n) throw new GaboxMathError("InvalidDistribution", "risk profile leaves no Common tickets");
-	const rarityExpected = rarityTickets.reduce((sum, tickets, index) => sum + rarityMultipliers[index] * tickets, 0n);
-	const commonMultiplier = (settings.targetEvBps * totalTickets - rarityExpected) / commonTickets;
-	if (commonMultiplier < 1n || commonMultiplier >= rarityMultipliers[0]) throw new GaboxMathError("PackTooSmall", "risk profile cannot derive an ordered, non-zero Common multiplier");
-	const tiers = Array.from({ length: 8 }, () => ({
-		multiplierBps: 0,
-		tickets: 0
-	}));
-	tiers[0] = {
-		multiplierBps: Number(commonMultiplier),
-		tickets: Number(commonTickets)
-	};
-	for (let index = 0; index < rarityMultipliers.length; index += 1) tiers[index + 1] = {
-		multiplierBps: Number(rarityMultipliers[index]),
-		tickets: Number(rarityTickets[index])
-	};
-	validateTiers(tiers);
-	if (maxMultiplierBps(tiers) !== jackpotBps) throw new GaboxMathError("InvalidDistribution", "the ladder lost its jackpot tier");
-	return tiers;
-}
-/**
 * `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;
@@ -208,6 +181,7 @@ function uncappedMaximum(base, tiers) {
 * 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 }, () => ({
@@ -256,6 +230,7 @@ function resolveReservation(reserved, maximum, award) {
 }
 /** 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;
@@ -270,6 +245,7 @@ function maxMultiplierBps(tiers) {
 * 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;
@@ -1328,11 +1304,14 @@ function wsolPreparation$2(purchaser, lamports) {
 * straight into the vault. The Pump buy accounts ride along as `remainingAccounts`, in the same
 * order `buy_pack` uses.
 *
-* The seed follows from the jackpot. A creator chooses a jackpot multiplier and a risk profile,
-* and the SDK derives a valid tier table. The program then buys exactly
-* `(jackpot - 1x) * PACK_TOKENS` tokens as the seed, so the first pack can pay the jackpot in
-* full. The creator only signs a maximum SOL cost for that buy. The seed buy moves the curve, so
-* a bigger jackpot means a slightly higher starting pack price.
+* The seed follows from the tier table. The program accepts any table that passes `math::validate`;
+* it does not enforce one table. A creator may pass their own `tiers`; the default is
+* `DEFAULT_TIERS`. The program buys exactly `largestTierAmount - PACK_TOKENS` tokens as the seed,
+* so the first pack can pay the top tier in full. The creator only signs a maximum SOL cost for
+* that buy. The seed buy moves the curve, so a bigger jackpot means a slightly higher starting
+* pack price. A fresh Pump curve only holds so many tokens (`Global.initialRealTokenReserves`),
+* so a table whose seed exceeds that cannot be created; `createMachine` and `seedCostEstimate`
+* both check this before spending anything.
 *
 * # Two signers
 *
@@ -1347,10 +1326,14 @@ function wsolPreparation$2(purchaser, lamports) {
 * does not exist yet, so every other account is a derivation.
 */
 async function createMachine(client, input) {
-	const { creator, mintKeypair, name, symbol, uri, feeBps, riskProfile, jackpotBps, maxSeedLamports } = input;
+	const { creator, mintKeypair, name, symbol, uri, feeBps, maxSeedLamports } = input;
 	if (!Number.isInteger(feeBps) || feeBps < 0 || feeBps > 100) throw new Error(`feeBps must be a whole number from 0 to 100`);
-	const tiers = jackpotTiers(jackpotBps, riskProfile);
-	if (seedTokens(PACK_TOKENS, tiers) > 0n && maxSeedLamports <= 0n) throw new Error("maxSeedLamports must be positive when the jackpot needs a seed");
+	const tiers = cloneTiers(input.tiers ?? DEFAULT_TIERS);
+	validateTiers(tiers);
+	validatePack(PACK_TOKENS, tiers);
+	const seed = seedTokens(PACK_TOKENS, tiers);
+	if (seed > 0n && maxSeedLamports <= 0n) throw new Error("maxSeedLamports must be positive when the jackpot needs a seed");
+	await assertSeedFitsFreshCurve(client, seed);
 	const mint = mintKeypair.address;
 	const create = getPumpCreateV2Instruction({
 		mint: mintKeypair,
@@ -1383,21 +1366,50 @@ async function createMachine(client, input) {
 	});
 }
 /**
-* What the seed for this jackpot costs, fees included, and how many tokens it is.
+* What the seed for this table costs, fees included, and how many tokens it is.
 *
 * The coin does not exist yet, so the price is Pump's default new curve. Nothing else trades on
 * it before `initialize_pool` runs in the same transaction, so this is exact up to a change in
 * Pump's fee settings between the read and the send. Add a small margin for `maxSeedLamports`.
+*
+* Defaults to `DEFAULT_TIERS`. Throws if `tiers` fails `validateTiers`/`validatePack`, or if the
+* seed is bigger than a fresh Pump curve can sell in one buy.
 */
-async function seedCostEstimate(client, jackpotBps, riskProfile) {
-	const tiers = jackpotTiers(jackpotBps, riskProfile);
-	const seed = seedTokens(PACK_TOKENS, tiers);
+async function seedCostEstimate(client, tiers = DEFAULT_TIERS) {
+	const copiedTiers = cloneTiers(tiers);
+	validateTiers(copiedTiers);
+	validatePack(PACK_TOKENS, copiedTiers);
+	const seed = seedTokens(PACK_TOKENS, copiedTiers);
+	await assertSeedFitsFreshCurve(client, seed);
 	return {
-		tiers,
+		tiers: copiedTiers,
 		seedTokens: seed,
 		lamports: seed === 0n ? 0n : await newCurveBuyCost(client, seed)
 	};
 }
+/** A mutable encoded-table shape, owned by this call and safe to pass to Codama's builder. */
+function cloneTiers(tiers) {
+	return tiers.map(({ multiplierBps, tickets }) => ({
+		multiplierBps,
+		tickets
+	}));
+}
+/**
+* Pump's quote silently caps at the curve's real token reserves, so a seed above them would look
+* cheap instead of failing. A fresh curve holds `Global.initialRealTokenReserves`
+* (793,100,000 tokens today), so a jackpot above about 794x of a 1,000,000-token pack cannot be
+* seeded. This throws before any buy is attempted.
+*/
+async function assertSeedFitsFreshCurve(client, seed) {
+	if (seed === 0n) return;
+	const { value } = await client.rpc.getAccountInfo(PUMP_GLOBAL, {
+		encoding: "base64",
+		commitment: "confirmed"
+	}).send();
+	if (!value) throw new Error(`Pump's Global account is missing at ${PUMP_GLOBAL}`);
+	const global = decodePumpGlobal(new Uint8Array(getBase64Encoder().encode(value.data[0])));
+	if (seed > global.initialRealTokenReserves) throw new Error(`the seed (${seed} tokens) is bigger than a fresh Pump curve holds (${global.initialRealTokenReserves} tokens); this table's top tier cannot be seeded on a new coin`);
+}
 /**
 * The Pump buy accounts for the seed, built without reading the bonding curve.
 *
@@ -1473,9 +1485,9 @@ async function expireDraw(client, input) {
 /**
 * What a client may do to a draw right now.
 *
-* Reads the draw and the current slot, and reproduces the program's three retry conditions and its
-* one expiry condition. Showing a disabled button with a countdown beats sending a transaction that
-* fails with `RetryTooSoon`.
+* Reads the draw and the current slot, and reproduces the program's three retry conditions and the
+* pending-status-plus-deadline expiry conditions. Showing a disabled button with a countdown beats
+* sending a transaction that fails with `RetryTooSoon` or `NotPending`.
 */
 async function drawAvailability(client, draw) {
 	const record = await fetchDraw(client, draw);
@@ -1758,6 +1770,6 @@ async function oracleAccounts() {
 	};
 }
 //#endregion
-export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BIND_REFERRER_COMPUTE_UNITS, BPS, BUY_PACK_COMPUTE_UNITS, CLUSTER_ENDPOINTS, COMPUTE_BUDGET_PROGRAM_ADDRESS, CREATE_MACHINE_COMPUTE_UNITS, DEFAULT_COMPUTE_UNIT_LIMIT, 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, MAX_ATTEMPTS, MAX_COMPUTE_UNIT_LIMIT, MAX_FEE_BPS, MAYHEM_PROGRAM_ADDRESS, PACK_TOKENS, POOL_CREATOR_OFFSET, POOL_DISCRIMINATOR, POOL_MINT_OFFSET, PROTOCOL_FEE_BPS, PROTOCOL_FEE_COLLECTOR, PUMP_FEE_PROGRAM_ADDRESS, PUMP_PROGRAM_ADDRESS, PUMP_SWAP_PROGRAM_ADDRESS, REDEEM_COMPUTE_UNITS, REFERRAL_FEE_BPS, REFERRAL_LINK_REFERRER_OFFSET, RETRY_SLOTS, SLOT_HASHES_SYSVAR, SYSTEM_PROGRAM_ADDRESS, TICKETS, TIERS, TIMEOUT_SLOTS, TOKEN_2022_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, VRF_DEFAULT_QUEUE, VRF_PROGRAM_ADDRESS, WSOL_MINT, assertClusterUrl, associatedTokenAddress, averageMultiplierBps, bindReferrer, buildMessage, buyPack, choose, claimPrize, claimReferral, clusterNamedBy, computeBudgetInstructions, createClient, createMachine, decodeDraw, decodeEvent, decodeEvents, decodePool, defaultAddressLookupTables, drawAddress, drawAvailability, expireDraw, feeCollectorWsolAddress, fetchDraw, fetchEvents, fetchPoolAt, fetchPoolByMint, fetchPoolInventory, fetchReferralReward, fetchVaultBalance, findDrawPda, findIdentityPda, findPoolPda, findReferralLinkPda, fundPrizes, fundPrizesWithBuy, generated_exports as generated, getOffer, getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, jackpotTiers, listDraws, listDrawsByPool, listDrawsByPurchaser, listPools, listReferralLinksByReferrer, maxMultiplierBps, offerFor, offerFromState, oracleAccounts, poolAddress, pump_exports as pump, pumpSeedBuyAccounts, quote, quoteSellPrize, referralAddress, referralLinkAddress, resolveReferral, resolveReservation, retryDraw, scopedVrfIdentityAddress, seedCostEstimate, seedShortfall, seedTokens, sellPrize, sellTokens, share, tierAmount, tiersOf, uncappedMaximum, validatePack, validateTiers, vaultAddress, vrfIdentityAddress, watchDraw, websocketUrlFor, withRemainingAccounts };
+export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BIND_REFERRER_COMPUTE_UNITS, BPS, BUY_PACK_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, MAX_ATTEMPTS, MAX_COMPUTE_UNIT_LIMIT, MAX_FEE_BPS, MAYHEM_PROGRAM_ADDRESS, PACK_TOKENS, POOL_CREATOR_OFFSET, POOL_DISCRIMINATOR, POOL_MINT_OFFSET, PROTOCOL_FEE_BPS, PROTOCOL_FEE_COLLECTOR, PUMP_FEE_PROGRAM_ADDRESS, PUMP_PROGRAM_ADDRESS, PUMP_SWAP_PROGRAM_ADDRESS, REDEEM_COMPUTE_UNITS, REFERRAL_FEE_BPS, REFERRAL_LINK_REFERRER_OFFSET, RETRY_SLOTS, SLOT_HASHES_SYSVAR, SYSTEM_PROGRAM_ADDRESS, TICKETS, TIERS, TIMEOUT_SLOTS, TOKEN_2022_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, VRF_DEFAULT_QUEUE, VRF_PROGRAM_ADDRESS, WSOL_MINT, assertClusterUrl, associatedTokenAddress, averageMultiplierBps, bindReferrer, buildMessage, buyPack, choose, claimPrize, claimReferral, clusterNamedBy, computeBudgetInstructions, createClient, createMachine, decodeDraw, decodeEvent, decodeEvents, decodePool, defaultAddressLookupTables, drawAddress, drawAvailability, expireDraw, feeCollectorWsolAddress, fetchDraw, fetchEvents, fetchPoolAt, fetchPoolByMint, fetchPoolInventory, fetchReferralReward, fetchVaultBalance, findDrawPda, findIdentityPda, findPoolPda, findReferralLinkPda, fundPrizes, fundPrizesWithBuy, generated_exports as generated, getOffer, getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, listDraws, listDrawsByPool, listDrawsByPurchaser, listPools, listReferralLinksByReferrer, maxMultiplierBps, offerFor, offerFromState, oracleAccounts, poolAddress, pump_exports as pump, pumpSeedBuyAccounts, quote, quoteSellPrize, referralAddress, referralLinkAddress, resolveReferral, resolveReservation, retryDraw, scopedVrfIdentityAddress, seedCostEstimate, seedShortfall, seedTokens, sellPrize, sellTokens, share, tierAmount, tiersOf, uncappedMaximum, validatePack, validateTiers, vaultAddress, vrfIdentityAddress, watchDraw, websocketUrlFor, withRemainingAccounts };
 
 //# sourceMappingURL=index.js.map