@xgamesfun/solana 0.20.1 → 0.24.0

package/types/client/pda.d.ts

@@ -11,7 +11,6 @@ export declare const COMPRESSION_PROGRAM = "mcmt6YrQEMKw8Mw43FmpRLmf7BqRnFMKmAcb
 export declare const NOOP_PROGRAM = "mnoopTCrg4p8ry25e4bcWA9XZjbNjMTfgYVGGEdRsf3";
 /** The PDA of these seeds under the loot program, with its bump. */
 export declare const lootAddress: (seeds: any, program?: string) => any;
-declare const keyReceipt: (grant: any, incarnation: any, voucherKey: any) => any;
 export declare const pda: {
     platform: () => any;
     /** A project: any wallet (its creator) opens as many as it likes, each with a number of its own (`id`, a u64). A
@@ -24,6 +23,10 @@ export declare const pda: {
     box: (project: any, id: any) => any;
     /** NFTs the project holds to give away as prizes: a box entry of a stash gives one of them at random. */
     stash: (project: any, id: any) => any;
+    /** A table of weighted rows the project writes and seals (a card among thousands, a trait's values), or commits by a Merkle root. */
+    table: (project: any, id: any) => any;
+    /** What the project keeps about a wallet (its player's profile: XP, level, rank). */
+    profile: (project: any, wallet: any) => any;
     schedule: (project: any, id: any) => any;
     lottery: (project: any, id: any) => any;
     recipe: (project: any, id: any) => any;
@@ -38,12 +41,12 @@ export declare const pda: {
     itemAsset: (item: any, serial: any) => any;
     /** A contest's pot, or a lottery's: `["pot", contest or lottery]`. */
     pot: (record: any) => any;
-    lotteryFunds: (lottery: any) => any;
-    lotteryReceipt: (lottery: any, incarnation: any, wallet: any) => any;
-    /** One purchase of a lottery's tickets, at a nonce of its buyer's. */
-    contribution: (lottery: any, player: any, nonce: any) => any;
-    /** A wallet's entry in a contest: one, on one side (another side is `OtherSide`). */
-    entry: (contest: any, player: any) => any;
+    /** One round of a lottery: its record, opened by the round's first purchase (`["round", lottery, incarnation, round]`). */
+    round: (lottery: any, incarnation: any, round: any) => any;
+    /** A lottery round's own token account of `mint`, which the round's record owns. */
+    roundTokens: (round: any, mint: any) => any;
+    /** A contest's list of entries, one record a player (page 0). */
+    entries: (contest: any, incarnation: any, page?: number) => any;
     /** A hold names its NFT and its end (Unix seconds): a release sent late never finds a later hold of the NFT. */
     hold: (asset: any, freeAt: any) => any;
     /** An offer: an id is its maker's own. Its money waits in the project's vault for its mint (`vault`). */
@@ -58,6 +61,8 @@ export declare const pda: {
     listing: (project: any, asset: any) => any;
     staked: (farm: any) => any;
     rewards: (farm: any) => any;
+    /** A farm's record of when its seats stop earning, for a farm that keeps one (`Farm.keeps_ends`). */
+    ends: (farm: any) => any;
     /** A seat: a player's in a farm of tokens, a collectible's (its asset) in a farm of collectibles. */
     seat: (farm: any, by: any) => any;
     /** What the project writes about an NFT it has no authority over (its Sheet): `nft` is a Core asset, a Token Metadata mint or a compressed NFT's asset id. */
@@ -70,14 +75,13 @@ export declare const pda: {
     treeConfig: (tree: any) => any;
     /** A compressed NFT's asset id: Bubblegum's `["asset", tree, nonce]`, `nonce` the count minted before it. */
     compressedAsset: (tree: any, nonce: any) => any;
-    /** A wallet's counter on a box or recipe. Grants and lotteries also name their incarnation. */
-    receipt: (record: any, wallet: any) => any;
-    grantReceipt: (grant: any, incarnation: any, wallet: any) => any;
-    person: (grant: any, incarnation: any, personHash: any) => any;
-    /** How many times an NFT shown claimed an open grant its gate asks for one of: an address of its own, never a person's. */
-    badge: (grant: any, incarnation: any, nft: any) => any;
-    /** A voucher key's counter on a grant (a promo code's). */
-    code: typeof keyReceipt;
+    /** A wallet's counts in a project: how many times it bought from each box, crafted each recipe or held tickets in
+     * a lottery's round that limits it (`decodeCounts`). */
+    counts: (project: any, wallet: any) => any;
+    /** Shard `shard` of a grant's limit records: what each wallet, person, badge and voucher key claimed. */
+    claims: (grant: any, incarnation: any, shard: any) => any;
+    /** Shard `shard` of the rounds a grant paid. */
+    rounds: (grant: any, incarnation: any, shard: any) => any;
     /** The program's identity, which signs its requests to the oracle. */
     identity: () => any;
     /** The identity the oracle signs callbacks with: the VRF program's PDA for this program. */

package/types/client/policy.d.ts

@@ -1,23 +1,48 @@
-export declare const STALE_SLOTS: bigint;
-export declare const LOTTERY_TIMEOUT_SLOTS: bigint;
+/** How long the oracle has to answer before a roll or a draw may be asked again, and a pending order refunded (seconds). */
+export declare const STALE_SECONDS: bigint;
+/** How long after a lottery's first ask the next ask cancels its round, and an asked order holding a payment or an NFT
+ * may be refunded (seconds). */
+export declare const LOTTERY_TIMEOUT_SECONDS: bigint;
 /**
- * The earliest slot an order can be refunded in, or null when it never can be: a rolled order has an outcome anyone
- * can carry out, and is settled, never refunded; a roll a mission or a recipe made waits for anyone to ask for it
- * (`Waiting`), and once asked (`Asked`) is asked again if the oracle never answers (`rollAskable`).
+ * The earliest an order can be refunded, as `{ slot, at }` (the program wants a later slot than `slot` and a later
+ * second than `at`), or null when it never can be as it stands: a failed order from the next slot; a paid order the
+ * oracle never answered 10 minutes after it was asked (`STALE_SECONDS`); an asked roll holding a payment or an NFT 7 days
+ * after its first ask. A rolled order has an outcome to carry out, and is settled. A waiting roll, or an asked one holding
+ * nothing, is asked (again): `rollAskable`.
  */
-export declare function orderRefundSlot(order: any): bigint | null;
-/** Whether anyone may ask the oracle for a mission's or a recipe's roll at `slot`: never asked, or never answered. */
-export declare const rollAskable: (order: any, slot: any) => boolean;
+export declare function orderRefundAt(order: any): {
+    slot: bigint;
+    at: null;
+} | {
+    slot: bigint;
+    at: bigint;
+} | {
+    slot: null;
+    at: bigint;
+} | null;
+/** Whether an order can be refunded at `slot` and `now` (Unix seconds, the chain's clock): `orderRefundAt`. */
+export declare function orderRefundable(order: any, slot: any, now: any): boolean;
+/**
+ * Whether its player or the project's keys may ask the oracle for a mission's or a recipe's roll at `slot` and `now`
+ * (Unix seconds, the chain's clock): never asked, or never answered within `STALE_SECONDS`. Once asked, a later ask comes
+ * in a later slot than the last (`SameSlot`: never the same seed twice), so a roll that found nothing in stock and waits
+ * again is asked from the next slot on.
+ */
+export declare const rollAskable: (order: any, slot: any, now: any) => boolean;
 /**
  * Whether a contest is off at `now` (Unix seconds), as the program reads its verdict: called off, its result
  * overdue, or short of its least pot once entries closed. Every entry of one that is off takes its money back.
  */
 export declare function contestOff(contest: any, now: any): boolean;
-/** Whether a lottery's draw was asked for and the oracle has not answered within `STALE_SLOTS`: anyone may ask again. */
-export declare const lotteryDrawStuck: (lottery: any, slot: any) => boolean;
+/** Whether a lottery round's draw (`round`: its decoded record) was asked for and the oracle has not answered within
+ * `STALE_SECONDS` by `now` (Unix seconds, the chain's clock): anyone may ask again. */
+export declare const lotteryDrawStuck: (round: any, now: any) => boolean;
 /**
- * Whether a lottery's draw was asked for and the oracle has not answered within `LOTTERY_TIMEOUT_SLOTS` of the first
- * ask (asking again doesn't move it): anyone may cancel the round and refund it. A round nobody asked to draw is never
- * cancelled.
+ * Whether a lottery round's draw (`round`: its decoded record) was asked for and the oracle has not answered within
+ * `LOTTERY_TIMEOUT_SECONDS` of the first ask (asking again doesn't move it) by `now` (Unix seconds, the chain's clock):
+ * the next ask of that round (`drawLotteryIx` with its address) cancels it, and every entry is refunded. A round nobody
+ * asked to draw is never cancelled.
  */
-export declare const lotteryCancellable: (lottery: any, slot: any) => boolean;
+export declare const lotteryCancellable: (round: any, now: any) => boolean;
+/** A farm seat's `earns_until` when nothing ends its earning (i64::MAX): no tier term and no fuel it reads. */
+export declare const NO_END: bigint;

package/types/client/random.d.ts

@@ -0,0 +1,26 @@
+/** What a path's first word names (`random::tag`): an entry of a box, a stash's NFT, a lottery's ticket, a fresh trait. */
+export declare const TAG: Readonly<{
+    ENTRY: 1;
+    STASH: 2;
+    LOTTERY: 3;
+    TRAIT: 4;
+}>;
+/** The most words a path holds. */
+export declare const MAX_PATH = 8;
+/** A stream of the oracle's 32-byte `answer` at `path` (whole numbers): seed = sha256("loot-roll-v1" | answer | path as
+ * u32 little-endian words); its nth number the first 8 bytes, little-endian, of sha256(seed | n as u64 little-endian). */
+export declare function stream(answer: any, path?: any[]): {
+    next(): bigint;
+};
+/** A number from 0 to `n` - 1, every one as likely: a draw past the last whole multiple of `n` is drawn again. null for
+ * `n` 0. */
+export declare function uniform(s: any, n: any): number | null;
+/** The row `at` lands on, the weights walked in order. null past the last. */
+export declare function walk(weights: any, at: any): any;
+/** A row by weight (a weight of 0 never drawn); null when none weighs anything, or they sum past 64 bits. */
+export declare function weighted(s: any, weights: any): any;
+/** A number from `min` to `max`, both included, every one as likely (either order). */
+export declare function range(s: any, min: any, max: any): any;
+/** A fresh unit's range trait `t` (its place among the item's traits) as the program draws it at the mint: from the
+ * order's `answer`, `at` the unit's place in the order's `won`. */
+export declare const rangeTrait: (answer: any, at: any, t: any, min: any, max: any) => any;

package/types/client/sizes.d.ts

@@ -2,12 +2,100 @@
 export declare function allocationBytes(name: any): any;
 /** The exact bytes of a dynamically allocated account. */
 export declare const accountBytes: (name: any, value: any) => number;
+/** A seat; a loan's hold (with room for its debt); a hold a player asks for, made without one (`Hold::PLAIN`). */
 export declare const ACCOUNT_BYTES: Readonly<{
-    [k: string]: any;
+    Seat: any;
+    Loan: any;
+    Hold: number;
 }>;
 /** A project's bytes with `collections` collections, as the program sizes the account. */
 export declare const projectBytes: (collections?: number) => number;
-export declare const MAX_RECEIPT_ROUNDS: number;
-export declare const RECEIPT_BASE_BYTES = 17;
-export declare const RECEIPT_ROUND_BYTES = 8;
-export declare function receiptBytes(rounds?: number): number;
+/** The most accounts the oracle's answer to a roll carries (`MAX_CALLBACK_ACCOUNTS`). */
+export declare const MAX_CALLBACK_ACCOUNTS = 21;
+/**
+ * The most accounts a roll of `entries` hands the oracle (`catalog::callback_accounts`): the order, the box and the
+ * ticket; one for each prize that needs one at the roll (an item, a pool, a stash); and with tokens, the two token
+ * programs, the project, and a mint and a vault for each source of tokens.
+ */
+export declare function callbackAccounts(entries: any): number;
+/**
+ * How many fresh items' table accounts the oracle's answer to a roll of `entries` can carry (`order::table_budget`):
+ * what the box's own accounts leave of `MAX_CALLBACK_ACCOUNTS`. Negative: the box can't be rolled at all.
+ */
+export declare const tableBudget: (entries: any) => number;
+/** The most an order can be (`MAX_ORDER_BYTES`, not in the IDL): a box whose one open's order would be more is refused
+ * at its upsert (`BadEntries`). In practice a pack is bounded first by what one oracle answer draws (`drawsFit`). */
+export declare const MAX_ORDER_BYTES = 10240;
+/**
+ * The rows of fresh items' tables a draw of each entry writes into its order (`order::rows_of`), walked with the box's
+ * table budget as the roll's accounts are (`entryAccounts`: an item whose tables don't fit what is left draws none).
+ * `items` maps an item's id to its decoded Item; one left out is taken as not fresh.
+ */
+export declare function entryRows(entries: any, items?: {}): any;
+/**
+ * The bytes of an order of `lootBox` with `shares` shares and `opens` opens. With `items` (an item's id to its decoded
+ * Item), as `open_box` sizes it (`Order::sized`): each draw at its dearest entry's prizes as the `Won` they become (an
+ * item 14 bytes, tokens or an NFT 41, a roll none) and 4 bytes for each table row its fresh items draw now
+ * (`entryRows`); its odds and its largest fate. Without `items`, as a roll made inside another call sizes it (a craft,
+ * a grant's claim, a mission, a roll lot: `Order::space_for`): the box's whole table budget a draw for a box that
+ * gives items. A pack's order grows with its cards.
+ */
+export declare function orderBytes(lootBox: any, shares: number | undefined, opens: number | undefined, items: any): number;
+/**
+ * The heap reading a box takes beyond its entries (`order::box_bytes`): its odds, gate, shares, subject, slots and
+ * fates, read whole with it, by their bytes and their number. `box`: the box's args, as `upsertBoxIx` takes them.
+ */
+export declare function boxBytes({ odds, gate, shares, subject, slots, fates }: {
+    fates?: never[] | undefined;
+    gate?: null | undefined;
+    odds?: never[] | undefined;
+    shares?: never[] | undefined;
+    slots?: never[] | undefined;
+    subject?: null | undefined;
+}): bigint;
+/**
+ * Whether all of `opens` opens of `entries` by `slots` fit one oracle answer (`order::draws_fit`), each draw at the
+ * dearest its slot could make, with what is known from the box alone (no table rows, a stash of one group), its `odds`,
+ * `shares` and `fates` counted, and `bytes` (`boxBytes`) of heap reading the box takes beyond its entries. `slots` may
+ * be a number: that many draws among every entry. The answer's heap counts for a box that rolls, or one sold through
+ * the oracle (`oracle`: a box that doesn't roll but one `buy` can't carry, `buyFits`). The program refuses a box whose
+ * one open doesn't fit at its upsert, and a purchase that doesn't at `open_box`, where it also reads what the accounts
+ * hold (`PackTooLarge`).
+ */
+export declare function drawsFit(entries: any, slots: any, opens?: number, { odds, shares, fates, bytes, oracle }?: {
+    bytes?: bigint | undefined;
+    fates?: number | undefined;
+    odds?: number | undefined;
+    oracle?: boolean | undefined;
+    shares?: number | undefined;
+}): boolean;
+/**
+ * Whether one `buy` of a box that doesn't roll (one entry, given `draws` times: its slots' counts) fits one transaction
+ * (`catalog::buy_fits`): its accounts, its instructions and its compute, each prize's at the most it takes. A named NFT
+ * is given once at most. A box that doesn't fit sells through the oracle (`open_box`), its answer's heap counted
+ * (`drawsFit` with `oracle`), and can't give a roll (`PackTooLarge`). `box`: the box's args.
+ */
+export declare function buyFits(box: any, draws?: any): boolean;
+/** The most program rent and fee one order takes from its player, in lamports (0.01 SOL): a client cap (`opensAnOrder`). */
+export declare const ORDER_COST_CAP = 10000000n;
+/**
+ * The most opens of `lootBox` a client puts in one order: what one oracle answer draws (`drawsFit`), and what keeps the
+ * order's rent and the player's fee within `ORDER_COST_CAP` (`orderBytes` with `items`, so with the box's shares). At
+ * least one: a box whose one open is over the cap is still bought one open an order. A purchase of more is several
+ * orders, each its own answer.
+ */
+export declare function opensAnOrder(lootBox: any, { shares, items, rentPerByte }?: {
+    items?: {} | undefined;
+    rentPerByte?: bigint | undefined;
+    shares?: any;
+}): number;
+export declare const LIST_HEAD_BYTES = 7;
+/** A limit record (a wallet's count of a box, a recipe or a lottery round; a grant's claim count): key, count, window, in it. */
+export declare const LIMIT_RECORD_BYTES = 28;
+/** A round a grant paid a wallet: its key alone. */
+export declare const ROUND_RECORD_BYTES = 16;
+/** A contest's entry: of tokens, and of NFTs (the NFT, its place on its side, the picks taken). */
+export declare const CONTEST_ENTRY_BYTES: Readonly<{
+    tokens: 43;
+    nfts: 83;
+}>;

package/types/economy/check.d.mts

@@ -1,12 +1,6 @@
-/**
- * The accounts a route the player pays or asks for (a craft, a buy, a grant's claim) passes after a roll's box and
- * order (`order::askable`, the client's `rollMints`): for each token prize of box `key`, in order, its pool and the
- * pool's mint, or the mint it mints from. Up to 10 distinct accounts a box.
- */
-export declare function rollMintKeys(key: any, m: any): any;
 /**
  * The transaction a player sends to craft `recipe`, estimated (txsize.mjs): the craft's own accounts, then each
- * line's (craft.rs; a roll's with its box's prize mints, `rollMintKeys`), a compute limit (a big recipe needs more
+ * line's (craft.rs; a roll's box and order), a compute limit (a big recipe needs more
  * than the default) and, for each token it gives, the player's token account created if missing.
  */
 export declare function craftSize(recipe: any, m: any, { detail }?: {
@@ -77,10 +71,11 @@ export declare function settleSize(b: any, o: any, m: any): {
 /**
  * The transaction a player sends to buy box `b` (buy.rs), estimated as `openBoxSize` is: its compute limit and price,
  * the player's token account of the currency created if missing, then `buy`: its own accounts, what the gate takes
- * (a list's proof, or the NFT shown), the accounts its shares name, and each prize's (prize.rs; a roll's with its
- * box's prize mints, `rollMintKeys`).
+ * (a list's proof, or the NFT shown), the accounts its shares name, and each prize's (prize.rs; a roll's box and
+ * order), for each draw of a sale (a fixed amount of tokens once). `count`: the sales in one purchase.
  */
-export declare function buySize(b: any, m: any, { detail }?: {
+export declare function buySize(b: any, m: any, { detail, count }?: {
+    count?: number | undefined;
     detail?: boolean | undefined;
 }): any;
 /** The address a plan stands in for the owner's wallet before one connects (plan.mjs `placeholderContext`). Nobody

package/types/economy/cost.d.mts

@@ -13,7 +13,7 @@ export declare function setupCost(plan: any, economy: any): {
 /**
  * What each action costs whoever signs it while the economy runs: games.fun's fee, the network's, and for anything
  * that asks MagicBlock's oracle for a random number (a box's open, a lottery's draw, the authority's `roll`) the
- * oracle's own 0.0005 SOL (`oracleSol`, model.mjs ORACLE_FEE).
+ * oracle's own fee (`oracleSol`, model.mjs ORACLE_FEE).
  */
 export declare function actionCosts(economy: any, { now }?: Readonly<Record<string, any>>): any[];
 /** Setup and play costs for a spec, or its refusals. */
@@ -41,6 +41,7 @@ export declare function cost(economy: any, { now, only, live }?: {
         built: any[];
         instructions: any;
         signers: any[];
+        alone: boolean;
     }[];
     approvals: number;
     freshKeys: any[];

package/types/economy/live.d.mts

@@ -7,13 +7,14 @@ export declare function freshAddresses(names: any, random?: typeof randomBytes):
  * The transactions that put `economy` live for `owner`, with `keys` the addresses of the fresh accounts (each signs
  * the transaction that creates it). `live`: what is already live (a change publishes only what differs).
  */
-export declare function prepare(economy: any, { owner, keys, live, now, rent, only }: {
+export declare function prepare(economy: any, { owner, keys, live, now, rent, only, slot }: {
     keys: any;
     live?: null | undefined;
     now?: number | undefined;
     only?: null | undefined;
     owner: any;
     rent: any;
+    slot?: null | undefined;
 }): {
     ok: boolean;
     refusals: any[];
@@ -33,6 +34,7 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         built: any[];
         instructions: any;
         signers: any[];
+        alone: boolean;
     }[];
     approvals: number;
     freshKeys: any[];
@@ -54,6 +56,7 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         mints: {};
         keys: any;
         rent: any;
+        slot: null;
     };
 } | {
     refusals?: undefined;
@@ -66,6 +69,7 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         built: any[];
         instructions: any;
         signers: any[];
+        alone: boolean;
     }[];
     approvals: number;
     freshKeys: any[];
@@ -79,8 +83,19 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         mints: {};
         keys: any;
         rent: any;
+        slot: null;
     };
 };
+/**
+ * The parts of an economy whose widest transaction passes a legacy transaction, so a player sends it in one approval
+ * only with the project's standing lookup table: a box's open or settle and a craft the checker sizes past one
+ * (W-TX-V0, W-SETTLE-V0), an auction whose bids are NFTs (each moves with its own accounts), and a farm of another
+ * collection's NFTs (a pNFT's stake and exit carry its token record and rule set). [{ where, why }]
+ */
+export declare function wideParts(m: any, warnings?: any[]): {
+    where: any;
+    why: string;
+}[];
 /**
  * The spec once its setup landed: every part keeps the program number it was given, and `live` names the game, its
  * collection, the treasury, the mints made and the program, with a copy of what is now on chain.

package/types/economy/model.d.mts

@@ -10,12 +10,13 @@ export declare const FEES: Readonly<{
  * on `open_box` (order.rs), whoever sends `draw_lottery` (lottery.rs, its `payer`), the authority on `roll`
  * (roll.rs). Measured on devnet: 500,000 lamports per open.
  */
-export declare const ORACLE_FEE = 500000n;
+export declare const ORACLE_FEE = 800000n;
 /**
- * Put in the order itself on every purchase, with the player fee on top of it (order.rs: ESCROW_LAMPORTS + fee); what
- * a collectible's rent doesn't use goes back at settle, and a refund returns all of it (constants.rs).
+ * What js/play's throwaway settle key is funded with, in the purchase's own transaction, for each prize its settle may
+ * open or mint (`loot.SETTLE_RENT_UNIT`): whoever settles pays that rent, the order lends nothing. What the settle
+ * doesn't spend goes back to the player when the key empties itself, and all of it when the roll fails.
  */
-export declare const ESCROW_LAMPORTS = 6000000n;
+export declare const SETTLE_RENT_UNIT = 6000000n;
 /** Rent: (bytes + 128) × 5,080 lamports, as `solana rent` reads it on devnet and mainnet-beta. */
 export declare const RENT_PER_BYTE = 5080n;
 export declare const ACCOUNT_OVERHEAD = 128n;
@@ -35,29 +36,36 @@ export declare const COLLECTIBLE_RENT = 3100000n;
 export declare const SIGNATURE_FEE = 5000n;
 export declare const LAMPORTS_PER_SOL = 1000000000n;
 export declare const WSOL = "So11111111111111111111111111111111111111112";
-/** The program's limits. */
+/** The limits a spec meets: the chain's (the oracle's answer carries 21 accounts; a farm names a tier and a recipe a
+ * collectible's place in a byte; Bubblegum keeps a compressed NFT's link in 200 bytes and its name in 32) and the two
+ * caps that keep a farm's numbers from overflowing. Since loot 0.22 the program caps no count or size of its own. */
 export declare const LIMITS: Readonly<{
-    shares: 4;
-    entries: 8;
     callbackAccounts: 21;
-    lines: 8;
-    collectiblesPerCraft: 8;
-    places: 8;
-    tiers: 4;
-    boosts: 4;
-    growths: 4;
-    gates: 4;
-    odds: 4;
+    tiers: 256;
+    collectiblesPerCraft: 255;
     vouchers: 3;
-    deciders: 3;
-    gateWallets: 16;
-    nameBytes: 32;
-    uriBytes: 200;
-    keyBytes: 32;
+    compressedNameBytes: 32;
+    compressedUriBytes: 200;
     maxBoostBps: 1000000;
     maxTierBps: 110000;
+    boxEntries: 128;
+    boxSlots: 32;
+    boxOdds: 32;
+    boxFates: 64;
+    entryPrizes: 14;
+    itemTraits: 64;
+    traitKeyBytes: 64;
+    recipeLines: 48;
+    farmRules: 32;
+    growthSteps: 128;
+    contestSides: 1024;
+    deciders: 32;
+    collections: 32;
+    lotteryRuns: 64;
+    farmEnds: 100000;
 }>;
-/** Attribute names the program writes itself, which a recipe cannot copy and `Set` cannot change (craft.rs, make.rs). */
+/** Attribute names the program writes itself, which a recipe cannot copy and `Set` cannot change (craft.rs, make.rs),
+ * and the two a collectible's life keeps (`lifeLines`: its uses and its next use). */
 export declare const RESERVED_ATTRIBUTES: readonly string[];
 export declare const RARITIES: readonly string[];
 /** A refusal raised while reading a value; the checker turns it into a refusal with a code. */
@@ -79,18 +87,43 @@ export declare function toBps(percent: any): number | null;
 /** "7d" → 604800. A number is seconds already. */
 export declare function toSeconds(duration: any): number;
 /**
- * How long what lands in a farm's rewards pool takes to be released to its seats, in seconds (a farm that shares its
- * pool, `farm.rs` `release_span`): its longest lock tier, and a day at least.
+ * How long what lands in a farm's rewards vault takes to be released to its seats, in seconds (a farm that shares what
+ * lands, `farm.rs` `release_span`): its longest lock tier, and a day at least.
  */
 export declare const releaseSeconds: (f: any) => number;
 /** A farm's release span in words: "a day", "30 days", "36 hours". */
 export declare function releaseWords(f: any): string;
+/**
+ * What a run sent late does, in words (schedule.rs `catches_up`): a sealed schedule's fixed amount pays every run due;
+ * any other run pays once, for the latest run due, and the runs before it lapse.
+ */
+export declare const lateRunWords: (s: any) => "a run missed is missed: one sent late pays once, for the latest run due, and the runs before it lapse" | "a run sent late pays every run due since";
+/**
+ * Whether a farm's boost reads a number its own growth writes (`refresh_seat` writes it): each level counts from when it is
+ * written, so a page or a keeper should refresh seats.
+ */
+export declare const boostReadsGrowth: (f: any) => any;
+/** A box's roll against what is in stock, in words (order.rs): the odds stay as written, whatever is left. */
+export declare const STOCK_WORDS = "The odds stay as written whatever is in stock: a draw that lands on an outcome that can\u2019t be given then (its pool short of the whole amount, its item or stash gone) is not made, no other outcome takes its place, and that draw\u2019s worth of the price goes back at the settle; with no draw made at all, a paid open fails and is refunded, and a free roll goes back to waiting";
+/**
+ * What a box that rolls does once an outcome can't be given (`whenOut`, order.rs `WhenOut`), in words. `sold`: it is
+ * sold (an open checks the stock); a box only other routes roll (a prize, a mission) never stops a sale.
+ */
+export declare function whenOutWords(b: any, { sold }?: {
+    sold?: boolean | undefined;
+}): "The odds stay as written whatever is in stock: a draw that lands on an outcome that can’t be given then (its pool short of the whole amount, its item or stash gone) is not made, no other outcome takes its place, and that draw’s worth of the price goes back at the settle; with no draw made at all, a paid open fails and is refunded, and a free roll goes back to waiting" | "When an outcome runs out (an item sold out, a pool short of its prize, a stash empty), a roll draws among the outcomes still there by their written weights, so the others’ chances rise; with nothing left at all, a free roll waits to be asked again and a paid one is refunded" | "When an outcome runs out (an item sold out, a pool short of its prize, a stash empty), the box keeps selling while its first draw has anything left, and a roll draws among the outcomes still there by their written weights: the others’ chances rise as one runs out, so a player can empty a common outcome to make a rare one likelier (a box selling a rare prize should stop selling instead, the default)" | "When an outcome runs out, the box stops selling: it isn’t sold while any outcome couldn’t cover this purchase’s draws and those of purchases still waiting for the oracle (an item’s units left, a pool’s tokens, a stash’s NFTs), so every roll is on the odds as written and nobody can buy their way to a refund on every miss; it sells again once the project restocks or edits the box (an outcome whose odds shrink with stock needs no cover). An outcome emptied another way all the same (another route sharing its pool, item or stash) makes no draw, no other outcome taking its place, and gives back that draw’s worth of the price at the settle; with no draw made at all, the open is refunded";
 /**
  * What the end of a sharing farm that `runs` means, in words, or null (no end, or a fixed rate): its release keeps its
- * pace, so what it has not let go by the end stays in the pool, the project's, and so does what a seat gives back after
- * the end; a seat that may be dead (a watched NFT sold, an upkeep run out) is refreshed a release span before it.
+ * pace, so what it has not let go by the end stays in its vault, free for the authority to take back, and so does what
+ * a seat forfeits after the end.
  */
 export declare function farmEndWords(f: any): string | null;
+/**
+ * The token a farm's rewards are in (`rewards`, a token key): by default its staked token, or for a farm of
+ * collectibles the project's currency. One that names a pool (as farms did before they had a vault of their own) is
+ * read as that pool's token, and the checker refuses it.
+ */
+export declare function farmRewardsToken(f: any, tokens: any, currencyKey: any, poolCurrency?: Map<any, any>): any;
 /** A raise's or a shift's `by`: a number, or for a time a duration, which may be negative ("-1d"). */
 export declare function toBy(by: any): any;
 /** "publish", "publish+7d" or a date → Unix seconds, counted from `now` (Unix seconds) for the first two. */
@@ -130,8 +163,9 @@ export declare function model(economy: any, { now }?: {
     /** The project's number among its owner's: its address is ["project", owner, number]. */
     projectNumber: any;
     items: any;
-    pools: any[];
+    pools: any;
     stashes: any;
+    tables: any;
     boxes: never[];
     payments: any;
     recipes: any;
@@ -155,12 +189,12 @@ export declare function model(economy: any, { now }?: {
 export declare function stashNfts(s: any): any;
 /**
  * A prize as the spec writes it (`$defs/prize`), read the one way: a line { gives, … } as a recipe's `out` lines are:
- * "item" (`item`), "tokens" (`amount`, `from` "mint" with `currency`, or "pool:<key>"), "share" (`percent` of `pool`),
+ * "item" (`item`), "tokens" (`amount`, `from` "mint" with `currency`, or "pool:<key>"),
  * "nft" (`nft`, an address the stash `stash` lists) or "roll" (a roll of `box`; in a recipe, on the collectible kept
  * at `on`). A grant's older `gives` ({ item }, { pool, amount }, { roll }) reads as its line. Null for none.
  */
 export declare function prizeLine(p: any): any;
-/** The pool a prize line pays from: a share's, or tokens' "pool:<key>". */
+/** The pool a prize line pays from: tokens' "pool:<key>". */
 export declare const prizePool: (p: any) => any;
 /** The token a prize line pays in: its pool's, or the one it mints. */
 export declare const prizeToken: (p: any, m: any) => any;
@@ -203,25 +237,49 @@ export declare function rollsOf(m: any): {
     by: any;
     route: any;
 }[];
-/** A prize line in words: "one Badge", "100 GOLD from “rewards”", "100 GOLD, minted", "10% of “jackpot”", "the NFT ab12…cd34 of “vault”", "a roll of “Chest”". */
+/** A prize line in words: "one Badge", "100 GOLD from “rewards”", "100 GOLD, minted", "the NFT ab12…cd34 of “vault”", "a roll of “Chest”". */
 export declare function prizeWords(p: any, m: any): string;
 /**
- * What one box outcome gives (catalog.rs, at most three prizes an entry), each in the box's own words: "item",
- * "pay" (a fixed amount from a pool), "share" (a percent of a pool), "stash" (an NFT of a stash at random), "mint"
+ * What one box outcome gives (catalog.rs), each in the box's own words: "item", "pay" (a fixed amount from a pool),
+ * "stash" (an NFT of a stash at random), "mint"
  * (tokens minted), "nft" (one NFT a stash lists) or "roll" (a roll of another box). A bundle gives its `prizes`; "burn"
  * and "nothing" give none.
  */
 export declare function outcomeParts(o: any): any;
-/** Whether an outcome burns the payment in place of the box's split: "burn", or a bundle that says `burns`. */
-export declare const outcomeBurns: (o: any) => boolean;
 /** Whether a box leaves its outcome to the oracle (catalog.rs `rolls`): more than one outcome, or an NFT at random. */
-export declare const boxRolls: (b: any) => any;
-/** Whether a box sells with `buy`, in one transaction (buy.rs): it doesn't roll, and rolls on no NFT. */
-export declare const boxBuys: (b: any) => boolean;
+/** How many draws one open of a box makes: its slots' counts, or one. */
+export declare const drawsOf: (b: any) => any;
+/** Whether a box's prize costs its settle a collectible's rent: an item minted as a Core NFT, or a fresh compressed one
+ * (its traits' Sheet). A plain compressed NFT costs no rent. */
+export declare const holdsRent: (p: any, m: any) => boolean;
+/**
+ * The units of `SETTLE_RENT_UNIT` a settle of box `b`'s order may spend (`loot.settleRent`), which js/play funds its
+ * throwaway settle key with and gets back unspent: for each draw, each part of the richest outcome that opens an
+ * account (a collectible, a fresh compressed NFT's Sheet, a stash's NFT); once an order, each source of tokens it may
+ * pay, and the fate of the NFT it rolls on.
+ */
+export declare function settleUnits(b: any, m: any): number;
+export declare const boxRolls: (b: any, m: any) => any;
+/** Whether a box sells with `buy`, in one transaction (buy.rs): it doesn't roll and rolls on no NFT, any number of draws
+ * a sale (a fixed pack: its prizes given once for each draw). */
+export declare const boxBuys: (b: any, m: any) => boolean;
+/**
+ * What a recipe's lines owe the life of each collectible they take (an item's `life`), as the program's needs and
+ * raises (craft.rs `Need`, `Raise`), at each collectible's place in the recipe (each burned unit, then each kept one, in
+ * line order; a pay line takes none): ready after `readyAfter` (`made` older than it), for `lasts` (`made` within it),
+ * on every line that takes it; `uses` times (`used` raised by 1 up to it) and a `cooldown` (`next_use` passed, then
+ * raised to that far from now) on a line that uses it or takes it staked; a renew line counts its uses from 0 again.
+ * { needs, raises }, in the program's shapes.
+ */
+export declare function lifeLines(r: any, m: any): {
+    needs: any[];
+    raises: any[];
+};
 /** A lottery's place as { percent, prize }: a number is a share of the pot and no prize. */
 export declare const placeOf: (p: any) => {
     percent: any;
     prize: any;
+    times: any;
 };
 /** "pool:house" → { kind: 'pool', key: 'house' }; "burn" → { kind: 'burn' }. */
 export declare function destination(to: any): {
@@ -237,7 +295,8 @@ export declare const sharesOf: (split: any) => any;
  * The program's `To` for a destination, with pool indexes resolved (the IDL's own shape). A wallet ("wallet:<address>")
  * is paid at its own token account of the part's currency (the program opens it when it is not there); "treasury" is the game's treasury wallet's; "chosen"
  * (or "chosen:<item>") is the one the buyer names when they buy; "lottery:<key>" is that lottery's pot
- * ("@pot:<id>", which the plan resolves once the game is known).
+ * ("@pot:<id>") and "farm:<key>" that farm's rewards vault ("@rewards:<id>"), which the plan resolves once the game is
+ * known.
  */
 export declare function toEnum(to: any, m: any): "Burn" | "Treasury" | {
     Pool: any[];
@@ -361,3 +420,12 @@ export declare function weights(box: any): any;
 export declare function poolTakers(m: any): any[];
 /** Every place the spec sends money into a pool. */
 export declare function poolFillers(m: any): any[];
+/**
+ * Every place the spec sends money into a farm's rewards vault ("farm:<key>"): a split's share, a schedule that pays it,
+ * a craft that pays it, the owner's seed, an early exit's fee into its own vault. [{ farm, by, how }]
+ */
+export declare function farmFillers(m: any): {
+    farm: any;
+    by: string;
+    how: string;
+}[];