@xgamesfun/solana 0.20.1 → 0.25.0

package/skills/xsolana-economy/references/telling-the-person.md

@@ -7,7 +7,8 @@ and the spec differ (a limit, an amount, a key not set yet), change one of them
 1. **What each play costs and is worth.** Lead with the tools' "in all" number: "A cast costs about 0.0234 SOL in
    all (0.02 SOL, the 0.002 SOL player fee, the oracle and the network, and the Perch's rent when one is caught), and
    gives back 0.01 SOL in prizes on average (50%), plus a Perch 3 casts in 10." For a box of items, the odds; for a
-   lottery, what the pot reaches and what each place wins; for a farm, a day of rewards per unit staked and what the
+   lottery, where its places are paid from (its pot, which gifts and what earlier rounds left fill, or each round's own
+   ticket money, which nothing from outside can change), what that reaches and what each place wins; for a farm, a day of rewards per unit staked and what the
    lock tiers multiply.
 2. **Where the money goes.** "55% of each cast goes into the pond that pays the Golden Carp, 5% into the monthly
    draw's pot, and the other 40% to your treasury."
@@ -17,18 +18,19 @@ and the spec differ (a limit, an amount, a key not set yet), change one of them
    the odds players are shown don't hold until then (`W-PRIZE-SEED`).
 4. **What going live costs.** "About 12.51 SOL on devnet, in one wallet approval: 12.5 SOL is the pond's seed, the
    rest is rent and fees."
-5. **Who does what while it runs** (`after-launch.md` has the table): what anyone can send (a draw, a schedule, an
-   auction's end, claims), what only they can (a contest's result, a payout, a held item, a collectible's new level)
+5. **Who does what while it runs** (`after-launch.md` has the table): what anyone can send (a draw, an
+   auction's end, claims), what only they can (a contest's result, a payout, a held item, a collectible's new level, each run of a schedule that isn't sealed: without them or a server holding a project key, an emission stops)
    and how often, and what happens if nobody does. If a payout rewards a result the game reports (a clear, a win,
    a score): "Checking that a player really did it is up to you, on your own server: a game runs in the player's
    browser, and the program trusts the authority's signature."
-6. **Flags for the law.** `W-CHANCE-PRIZE`: "Players pay for a chance at money. That is gambling in many places once
+6. **Flags for the law, once.** `W-CHANCE-PRIZE`: "Players pay for a chance at money. That is gambling in many places once
    it is real money; this runs on devnet only." `W-CHANCE-ITEMS`: "Players pay for random items they can resell: some
    places treat that as gambling, and many require the odds to be shown." `W-REVENUE-SHARE`: "Stakers are paid from
-   what players spend; regulators look at that when they decide whether a token is a security." Say them every time
-   they are raised. Before they go live, every time: "The program isn't independently audited and comes as is, with
-   no warranty: you use it at your own risk, and making sure this is legal where you offer it is up to you." The
-   approval page shows all of this too, and keeps Approve off until the owner ticks that they read it.
+   what players spend; regulators look at that when they decide whether a token is a security." Say each once, the
+   first time the checker raises it; then leave them, saying them again only when the person asks or a flag of a new
+   kind appears, and keep them out of pages and apps unless asked. The approval page shows them, with the program's
+   status (not independently audited, as is, at their own risk, theirs to make legal where they offer it), and keeps
+   Approve off until the owner ticks that they read it.
 7. **For an auction**, say how it ends, in their words: "The highest bid when the 48 hours are up wins. Each bid must
    be at least 0.5 SOL and 5% over the last; a bid in the last 10 minutes gives everyone 10 more. Whoever is outbid
    has their SOL back at once, in the same transaction. With no bid, the lot goes back (an item's unit is never
@@ -39,7 +41,46 @@ and the spec differ (a limit, an amount, a key not set yet), change one of them
 8. **Anything else the checker warned about**, in a sentence each (a mint that can freeze accounts, a free box bots
    can drain, a grant with no limits or no funds).
 
+## What stays the project's job
+
+Say these whenever the spec has the part they name, before the person goes live. The program holds the rules and the
+money; it holds no files and serves nothing.
+
+- **Images and metadata are off the chain.** An item's `uri` points at a file the project hosts; the program keeps no
+  images. A fresh item's `uri` with `{attribute}` in it (`https://…/hero/{color}/{power}.json`) becomes a different link
+  for every value drawn: the project hosts a file for every value a table or range can give (every row's label, every
+  number from `min` to `max`), or a server that renders them on request. A link with nothing behind it is a card
+  that shows no picture, for good.
+- **Large tables cost rent the owner pays, never back**: about 8 bytes a row of numbers and 40 a row of labels, at
+  5,080 lamports (0.00000508 SOL) a byte: 1,000 labels about 0.2 SOL, 100,000 numbers about 4.1 SOL. Quote
+  `xsolana_cost` for the real figure.
+- **A pack's cards each cost a collectible's rent when settled.** Whoever settles pays what the settle mints: Core
+  keeps about 0.0031 SOL in each card the player gets. The page lends its throwaway settle key 0.006 SOL for each Core
+  card it may mint, in the purchase's one prompt, and the key sends back what it didn't spend. A plain compressed card
+  costs none. A pack of fixed cards (nothing random) is bought in one step, its cards minted in the purchase; a pack
+  too big for one transaction settles in parts (about 14 Core cards a part), which the page sends.
+- **When an outcome runs out, the project chooses what its box does (`whenOut`), and should hear the trade-off.**
+  An outcome runs out when its item sells out, its pool can't cover its whole prize, or its stash empties. With
+  `"stopSales"` (the default) the box isn't sold while any outcome couldn't cover this purchase and those still waiting
+  for the oracle: every roll is on the odds written, nobody can buy their way to a rare once the commons are gone, and
+  the project restocks or edits the box to sell again (a pool holds its prize for every draw waiting; a named NFT is in
+  one waiting purchase at a time). With `"drawLeft"` the box keeps selling and draws among what is left, by the written
+  weights: the others' chances rise as one runs out, so anyone watching the stock can empty a common outcome and then
+  open for the rare at better odds. Put it as: "stop selling keeps your odds honest; keep selling never stalls but lets
+  a player tilt the odds". A box selling a rare prize keeps the default; `drawLeft` suits a box of alike prizes, or one
+  only other routes roll (a grant's, a mission's), where nothing is sold. `xsolana_check` says what each does to the
+  box (W-WHEN-OUT, W-OUT-OF-STOCK, W-PRIZE-SEED, W-STASH) and `xsolana_simulate` the day it stops or each outcome runs out.
+- **A prize the program can't give right now is out of stock, not an error.** A prize in a token with a transfer hook
+  (or confidential transfers) is never moved by a roll. An outcome emptied by another route after a purchase (another
+  box sharing its pool, item or stash) can't be given: a draw that lands on it 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 a paid open is refunded and a
+  free roll waits to be asked again, and a box with nothing in stock is refused (SoldOut).
+- **The oracle's answer reads at most 21 accounts**, so a box's distinct prize accounts (its items, pools, stashes,
+  the mints and vaults of its tokens, a fresh item's tables) are bounded by that, however many outcomes it has.
+  `xsolana_check` counts them.
+
 Don'ts:
+
 - Don't show mints, account addresses, PDAs, lamports or instruction names unless asked.
 - Don't promise returns, profits or "passive income". Say what the program does, with the numbers.
 - Don't hide a gap: if loot can't do what they asked, the first line says so and offers the nearest thing.
@@ -60,8 +101,8 @@ Don'ts:
   set (`traits`): say who proves them, and when.
 - **Rolls that can fail**: a box, a mission or a recipe that can burn or give away the NFT it rolls on holds it from
   the moment the roll is made until it is settled. Say the odds in plain numbers, which stats raise them, and what a
-  loss means (burned, or given to whom). Nobody can back out of a roll once it is made; anyone (the page, a keeper)
-  asks the oracle for it and settles it.
+  loss means (burned, or given to whom). Nobody can back out of a roll once it is made; the player or the project's keys ask the oracle
+  for it, and the player, a key they named or the project's keys settle it.
 - **NFT custody** (a farm, a mission): Escrow is the default: the NFT moves to the project while it is staked.
   Freeze keeps it in the player's wallet, locked, with the project the only key that unlocks it; a soulbound
   collectible needs Freeze. Watch holds nothing: say plainly that a staked NFT can be sold, that its seller then
@@ -69,12 +110,15 @@ Don'ts:
   at once: a guild frozen, its missions watched. Either way the NFT issuer's own controls still apply: an issuer who
   can block transfers, or (under Freeze) one whose later metadata or plugin changes stop the unfreeze, can keep an
   NFT from coming back, and forfeiting rewards doesn't get around that. Never promise an unconditional exit.
-- **A farm releases everything in its rewards pool** to its stakers, over its longest lock (a day at least), by
-  weight as it is released: give each farm a pool of its own (`W-POOL-SHARED`). Whoever stakes first is credited all
-  that is released while they are alone, so say early stakers share the first rewards among few. A farm that
-  `runs` takes no stake at its end, and what it has not released by then stays in the pool, the project's, as does
-  what a seat gives back after it: say to fund it at least its release span before the end, and to refresh a seat
-  they suspect is dead (a watched NFT sold, an upkeep run out) a span before it. A sharing farm of a token with a
+- **A farm releases everything that lands in its own rewards vault** to its stakers, over its longest lock (a day at
+  least), by weight as it is released. Something must send it rewards: its `seed`, a share `"farm:<key>"` of a sale,
+  or a schedule that pays or mints into `"farm:<key>"` (`W-FARM-DRY` when nothing does). Whoever stakes first is
+  credited all that is released while they are alone, so say early stakers share the first rewards among few. A farm
+  that `runs` takes no stake at its end, and what it has not released by then stays in its vault (the authority may
+  take back what is free there), as does what a seat forfeits after it: say to fund it at least its release span
+  before the end. What a seat earned by its term (`earnsFor`) or its fuel is exact however late it is next touched, and
+  nobody has to act at that time. Such a farm keeps a record of those times: each new one costs whoever writes it 44 bytes
+  of rent (about 0.00022 SOL), not refunded on leaving. A sharing farm of a token with a
   great many base units (a memecoin) that pays a reward of few units rounds each seat's share to nothing
   (`W-FARM-ROUNDING`). A farm with
   a fixed `rate` pays the same to each NFT instead; minted, it grows the token's supply every day it runs, which
@@ -83,7 +127,7 @@ Don'ts:
   (`W-FARM-MINT-ROOM`, for a rate that could get there).
 - **Levels written by staking are attributes on the NFT** (or in the project's Sheet of it, for an NFT the project
   has no authority over): marketplaces show them, anyone can read them, and the person's other mechanics can use
-  them. They grow only when a seat is refreshed or the NFT leaves: the page refreshes (`app.refresh`).
+  them. They grow only when a seat is refreshed or the NFT leaves: the page refreshes (`app.refresh`). A boost that reads a level the farm's own growth writes counts each level from when it is written, so a seat refreshed often earns more than one refreshed rarely: have the page or a keeper refresh seats (anyone may, for free).
 - **Grants pay their claims' rent from their own funds** (`fund`, in SOL, held in the grant): the player pays the
   0.002 SOL player fee and the network fee to claim, once, even when the prize is a roll. A first claim of a token
   prize also opens the winner's account from the funds:

package/types/chain/core.d.ts

@@ -6,7 +6,7 @@ export { MPL_CORE_PROGRAM };
  * it also carries Bubblegum's plugin, so compressed NFTs can be minted into it. The collection address signs too (a
  * fresh key).
  */
-export declare function createCollectionInstruction({ collection, creator, name, uri, royaltyBps, project, compressed }: {
+export declare function createCollectionInstruction({ collection, creator, name, uri, royaltyBps, project, compressed, }: {
     collection: any;
     compressed?: boolean | undefined;
     creator: any;
@@ -33,13 +33,15 @@ export declare function parseCoreAsset(data: any): {
     frozen: boolean;
     soulbound: boolean;
 };
-/** Decode the start of a Core CollectionV1: { updateAuthority, name, uri, numMinted, currentSize }. */
+/** Decode the start of a Core CollectionV1: { updateAuthority, name, uri, numMinted, currentSize, bubblegum (whether it
+ * carries Bubblegum's plugin, BubblegumV2: compressed NFTs can be minted into it) }. */
 export declare function parseCoreCollection(data: any): {
     updateAuthority: string;
     name: string;
     uri: string;
     numMinted: number;
     currentSize: number;
+    bubblegum: boolean;
 };
 /** getProgramAccounts filters for Core assets owned by `owner` in `collection` (no indexer needed). */
 export declare const ownedAssetFilters: (owner: any, collection: any) => {

package/types/chain/lookup.d.ts

@@ -169,12 +169,14 @@ declare const pause: (ms: any) => Promise<any>;
  * first (`planTable`); else the table first, then each compressed NFT's prove_leaf alone, then the rest as v0 (or the
  * proofs then a legacy rest, when that fits with no table). The v0 transaction is compiled against the table as the
  * chain holds it. `sign(message)` → the signed wire transaction. `rpc`: the client's (latestBlockhash, send, confirm,
- * account, call('getSlot')). `table: false` sends no lookup table (a throwaway key holds no rent for one); `first`:
+ * account, call('getSlot')). `standing`: tables already made ([{ address, addresses }], a project's, active), tried
+ * first: one v0 transaction with them when they hold enough. `table: false` sends no lookup table of its own (a throwaway
+ * key holds no rent for one); `first`:
  * addresses a table holds first (`planTable`). Throws a
  * plain sentence when it can't be sent. Returns { signature (the last transaction's), table (its address, or null),
  * steps (the signatures of the transactions before it) }.
  */
-export declare function sendFitting({ rpc, payer, instructions, sign, table, alone, first, sleep }: {
+export declare function sendFitting({ rpc, payer, instructions, sign, table, alone, first, standing, sleep, }: {
     alone?: (() => boolean) | undefined;
     first?: never[] | undefined;
     instructions: any;
@@ -182,6 +184,7 @@ export declare function sendFitting({ rpc, payer, instructions, sign, table, alo
     rpc: any;
     sign: any;
     sleep?: typeof pause | undefined;
+    standing?: never[] | undefined;
     table?: boolean | undefined;
 }): Promise<{
     signature: any;

package/types/chain/rpc.d.ts

@@ -18,7 +18,9 @@ export declare function notMainnet(url: any): any;
  * let through). `rpc` has `call`. Returns the genesis hash.
  */
 export declare function checkCluster(rpc: any): Promise<any>;
-/** The program's own words for a failed run (`AnchorError … Error Message: …`), else the last error log line. */
+/** The program's own words for a failed run (`AnchorError … Error Message: …`), else the last error log line. A program
+ * built without its errors' text logs the error's name as its message: then the name alone (the client's IDL has
+ * the sentence: `loot.lootError`). */
 export declare function programError(err: any, logs: any): any;
 /** A client for one RPC URL. `fetchImpl` and `sleepImpl` are for tests. */
 export declare function rpcClient(url: any, { fetchImpl, sleepImpl }?: {

package/types/client/accounts.d.ts

@@ -1,5 +1,8 @@
-export { MAX_RECEIPT_ROUNDS } from './sizes.js';
-/** Account tags: each account's first byte, as the program writes it. */
+/** The bytes of one time in a farm's record of ends (`decodeEnds`): rent its writer pays, not refunded when a seat leaves. */
+export declare const END_BYTES = 44;
+/** The bytes of a farm's record of ends with no time in it, its owner's rent at `open_farm`. */
+export declare const ENDS_HEAD_BYTES = 7;
+/** Account tags: each account's first byte, as the program writes it; every list of records (`decodeList`) is 26. */
 export declare const TAGS: Readonly<{
     Platform: 1;
     Project: 2;
@@ -11,23 +14,24 @@ export declare const TAGS: Readonly<{
     Recipe: 8;
     Hold: 9;
     Contest: 10;
-    Entry: 11;
     Sheet: 12;
     Traits: 13;
-    Grant: 14;
-    Receipt: 15;
-    LotteryContribution: 16;
+    LotteryRound: 16;
     Farm: 17;
     Seat: 18;
     Proven: 19;
     Auction: 20;
-    Stash: 21;
     Offer: 22;
     Listing: 23;
+    Profile: 24;
+    Grant: 27;
+    Table: 25;
+    List: 26;
+    Ends: 29;
 }>;
 /** The kind of a loot account from its first byte, or null. */
 export declare const accountKind: (data: any) => string | null;
-/** A loot account of the named kind (one the IDL describes). Throws when the data is not one. */
+/** A loot account of the named kind (one the IDL describes, or a `LotteryRound`). Throws when the data is not one. */
 export declare const decode: (name: any, data: any) => any;
 /** Any loot account: { kind, value }, or null for data that is no loot account. */
 export declare function decodeAny(data: any): {
@@ -35,18 +39,67 @@ export declare function decodeAny(data: any): {
     value: any;
 } | null;
 /**
- * A counter (a Receipt): a wallet's on a box, a lottery, a recipe or a grant, a person's or a key's on
- * a grant. { count (lifetime where tracked), window (the window `inWindow` counts), inWindow, rounds (the first 8
- * bytes of sha256 of each round a grant paid it, by voucher or list, in order), claimed(round) }. A round it holds
- * was paid once and can never be paid again.
+ * A list of records (tag 26, `list.rs`): { width, records } in their order: a wallet's counts
+ * (`["counts", project, wallet]`) and a grant's claims are limit records (28 bytes, `readLimit`), a grant's rounds 16
+ * bytes, a contest's entries 43 or 83 (`decodeEntries`).
  */
-export declare function decodeReceipt(data: any): {
+export declare function decodeList(data: any): {
+    width: number;
+    records: Uint8Array<ArrayBufferLike>[];
+};
+/**
+ * A farm's record of when its seats stop earning (`["ends", farm]`, tag 29; `Farm.keeps_ends`): its times in order, each
+ * `{ at, rewardPerWeight, weight, seats }`: the time (Unix seconds), `reward_per_weight` there once the farm has walked past
+ * it, the weight that stops earning then, and the seats that still need the record.
+ */
+export declare function decodeEnds(data: any): {
+    at: bigint;
+    rewardPerWeight: bigint;
+    weight: bigint;
+    seats: number;
+}[];
+/** The first 16 bytes of the sha256 of `parts` (addresses, bytes or u64s): a record's key in a list. */
+export declare const recordKey16: (...parts: any[]) => Uint8Array<ArrayBuffer>;
+/** The key of a wallet's count for a box, a recipe (incarnation 0) or a lottery (its incarnation), in its counts. */
+export declare const countKey: (record: any, incarnation?: number) => Uint8Array<ArrayBuffer>;
+/** What the limit record at `key` counts in a decoded list (`decodeList`, or null for none): { count, window, inWindow }. */
+export declare function readLimit(list: any, key: any): {
     count: number;
     window: number;
     inWindow: number;
-    rounds: Uint8Array<ArrayBuffer>[];
-    claimed: (round: any) => boolean;
 };
+/** A fetched list account, or null for none (or an empty System account someone sent SOL to, which the program opens
+ * as the list). Any other owner or layout is refused. */
+export declare function readListAccount(account: any): {
+    width: number;
+    records: Uint8Array<ArrayBufferLike>[];
+} | null;
+/**
+ * A contest's entries (`["entries", contest, incarnation, 0]`), in the list's order (by player): [{ player, side,
+ * amount (0 once paid or refunded; 1 while a contest of NFTs holds its NFT), bits (`CLAIMED`, `ENDED`), nft, place (how
+ * many entered its side before it), taken (the losers' NFTs a winner took) }]. A claim names an entry by its index here.
+ */
+export declare function decodeEntries(data: any): any[];
+/** A winner's first claim came (its prize given or forgone); a winner ended its picks early. */
+export declare const CLAIMED = 1;
+export declare const ENDED = 2;
+/** How many losers' NFTs a winner of a contest of NFTs takes: the share fixed at the decision, one more for an early
+ * place on its side. */
+export declare const shareOf: (contest: any, entry: any) => number;
+/**
+ * What a winning entry that put in `amount` takes with its first claim of a decided contest of tokens: its part of what
+ * the decision wrote (`pot_won`, the pot once the shares were taken; `prize_won`, a split prize's vault), by what it put
+ * in against its side's total. The winners claimed before it took `won × claimed ÷ total`, so the parts add up exactly
+ * whatever the order: `{ pot, prize }` (the prize part is 0 when the claim forgoes it). Tokens sent to the pot after the
+ * decision are nobody's.
+ */
+export declare function contestWinnings(contest: any, amount: any): {
+    pot: bigint;
+    prize: bigint;
+};
+/** What a count allows `n` more of at `now` under `limit` ({ total, per_window, window }, 0 is no limit; a lottery's
+ * window is its round plus one, given as `window`). */
+export declare function countAllows(count: any, limit: any, now: any, n?: number, window?: number): boolean;
 /**
  * A Sheet (`["sheet", project, nft]`): what the project wrote about an NFT it has no authority over. Returns { project, nft,
  * attributes: [{ key, value }] }. A Sheet never written reads as none: pass `null` data for no account.
@@ -59,11 +112,49 @@ export declare function decodeSheet(data: any): {
         value: string;
     }[];
 } | null;
-/** A stash (`["stash", project, id]`): { project, id, nfts }, the NFTs the project holds to give away, in no order. */
+/** A player's profile (`["profile", project, wallet]`): { project, wallet, attributes }, what the project keeps about
+ * the wallet (its XP, level, rank). Its layout is a Sheet's, under its own tag. */
+export declare function decodeProfile(data: any): {
+    project: string;
+    wallet: string;
+    attributes: {
+        key: string;
+        value: string;
+    }[];
+} | null;
+/** What a table's rows carry (its payload byte). */
+export declare const PAYLOAD: Readonly<{
+    Number: 0;
+    Label: 1;
+    Nft: 2;
+}>;
+/** Where row `r` of a table of `len`-byte rows is: groups of 64 blocks of 64 rows, each led by its weight in stock. */
+export declare function tableRowAt(len: any, r: any): number;
+/**
+ * A table (`["table", project, id]`, `table.rs`): { project, id, payload ('Number' | 'Label'), sealed, count, total
+ * (the weight in stock), rows: [{ weight, left, label }] }. A row's `left` is `NO_LIMIT` (4294967295) for a stock that
+ * never runs out.
+ */
+export declare function decodeTable(data: any): {
+    project: string;
+    id: number;
+    payload: string;
+    sealed: boolean;
+    count: number;
+    total: bigint;
+    rows: {
+        weight: number;
+        left: number;
+        label: string;
+    }[];
+} | null;
+/** A stash (`["stash", project, id]`, or a lottery's own): { project, id, nfts, weights }, the NFTs the project holds to
+ * give away and the weight each is drawn by, as a table of NFTs keeps them (a row: its weight, then the NFT). */
 export declare function decodeStash(data: any): {
     project: string;
     id: number;
     nfts: string[];
+    weights: number[];
 } | null;
 /**
  * A compressed NFT's record (`["leaf", asset]`, `prove_leaf`): { asset, tree, owner (null once burned), delegate,
@@ -98,52 +189,121 @@ export declare function decodeTokenMetadata(data: any): {
     programmable: boolean;
     ruleSet: string | null;
 } | null;
-/** A fetched receipt, or null for a missing/prefunded empty System account. Other owners/layouts are refused. */
-export declare function readReceiptAccount(account: any): {
-    count: number;
-    window: number;
-    inWindow: number;
-    rounds: Uint8Array<ArrayBuffer>[];
-    claimed: (round: any) => boolean;
-} | null;
-/** What a counter allows `n` more of at `now` under `limit` ({ total, per_window, window }, 0 is no limit). */
-export declare function receiptAllows(receipt: any, limit: any, now: any, n?: number): boolean;
-/** The contribution among `contributions` ([{ address, value }], decoded LotteryContributions) that holds `ticket`. */
-export declare const contributionOf: (contributions: any, ticket: any) => any;
-/** Whether a lottery's place wins something: a share of the pot, a roll, or both (as the program counts a place set). */
+export declare const OWN_PAID: bigint;
+/** The mint a lottery's tickets are paid in (`terms`: a Lottery's or a round's): its ticket mint, burned, or `mint`. */
+export declare const paymentMint: (terms: any) => any;
+/** Whether a lottery's tickets are burned: they are paid in a ticket mint of its own. */
+export declare const ticketsBurn: (terms: any) => boolean;
+/** The most pots one lottery keeps (`MAX_POTS`): a pot's id is below it. */
+export declare const MAX_POTS: number;
+/** The pot a lottery's places are paid from (`terms.pays_from`: `{ Pot: [id] }`), or null when each round pays from its
+ * own ticket money (`{ Round: { rest } }`). */
+export declare const potIdOf: (terms: any) => number | null;
+/** Where what a round's places leave goes (`Part::Common` past the shares): its pot, or the `rest` a round paid from
+ * its own money names (`lotteryAddress`: the lottery's). */
+export declare const leftoverTo: (lotteryAddress: any, terms: any) => any;
+/** The ids of the pots a lottery opened (`Lottery::pots`, one bit an id), lowest first: a close empties each. */
+export declare const lotteryPots: (lottery: any) => number[];
+/** A share the buyer chooses (a referrer, a collectible's holder): paid out of the price as they buy, from their own account. */
+export declare const chosenAtPurchase: (share: any) => boolean;
+/** The bytes of one entry of a round: buyer, word, what arrived (`fee`: a fee mint, or a chosen share), the NFT ticket. */
+export declare const entryWidth: (fee: any, nft: any) => number;
+/**
+ * A lottery round (`["round", lottery, incarnation, round]`): its header (`status` 'Open' | 'Drawing' | 'Drawn' |
+ * 'Cancelled', the terms it copied, `sold`, `owed`, the draw and the money the ask fixed, `nfts` the NFT of the
+ * lottery's own stash each such place got), and `entries`, one a purchase: { buyer, start, end (its tickets), paid (its
+ * own part's bit), amount (what reached the round), nft (its NFT ticket) }.
+ */
+export declare function decodeRound(data: any): any;
+/** How many places a lottery's (or a round's) `places` are, every run counted (`Place.times`). */
+export declare const placeCount: (places: any) => any;
+/** The places of a round that have a winner: every place, but no more than tickets. */
+export declare const roundWinners: (r: any) => number;
+/** The ticket that wins `place` of a drawn round: even steps around the list from first place's ticket. */
+export declare function ticketOfPlace(r: any, place: any): bigint;
+/** The run of places that holds `place`, and its first place. */
+export declare function runOf(r: any, place: any): any[];
+/** The places of run `run` with a winner: [first, end). */
+export declare function runPlaces(r: any, run: any): number[];
+/** The places of run `run` whose ticket is in `start..end` (an entry's), in order. */
+export declare function placesIn(r: any, run: any, start: any, end: any): any[];
+/**
+ * What place `place` (counted from the first place of `runs`) takes of a pass-through amount, as the program splits it:
+ * runs of `[a, n]` (n places taking `a` each), `sent` what the places are owed and `arrived` what the round holds for
+ * them; the last place with a part takes what the others leave.
+ */
+export declare function splitPart(runs: any, sent: any, arrived: any, place: any): number | bigint;
+/** Whether place `place`'s part is paid: its pot part's bit (every place's first), or with `prize` its prize's (after
+ * every place's pot bit). */
+export declare const placePaid: (r: any, place: any, prize: any) => boolean;
+/** What entry `i`'s places in run `run` take and are not paid yet, of its pot part or (`prize`) its token prize. */
+export declare const placesOwed: (r: any, i: any, run: any, prize: any) => bigint;
+/** How many of the round's owed parts a pull of `{ Pot: [run] }` or a token `{ Prize: [run] }` for entry `i` settles:
+ * its places there that take more than nothing (one pull pays them all). */
+export declare const placesPulled: (r: any, i: any, run: any, prize: any) => number;
+/** Whether run `run` of a round's places gives tokens (its prize is fixed at the ask, a `TokenPrize`). */
+export declare const tokenRun: (r: any, run: any) => boolean;
+/** A place whose prize is an NFT of the lottery's own stash (`Held`, `Raffled`): assigned by the pulls, in place order. */
+export declare const ownStash: (place: any) => boolean;
+/** Entry `i`'s places in run `run` whose prize (not tokens) is not given yet, lowest first. */
+export declare const prizePlacesOwed: (r: any, i: any, run: any) => any[];
+/** Where in `r.nfts` the NFT of `place` is (a place of a run that holds or draws one of the lottery's own stash). */
+export declare function nftSlot(r: any, place: any): number;
+/** How many places of a round win an NFT of the lottery's own stash (every such place with a winner). */
+export declare function stashPlacesWon(r: any): number;
+/** Whether entry `i`'s places in run `run` (an NFT of the lottery's own stash) wait for their NFTs to be taken out
+ * (`LotteryRound::assign`): a pull with the stash alone does it, and `r.nfts` then names each. */
+export declare function awaitsNfts(r: any, i: any, run: any): boolean;
+/**
+ * The parts entry `i` of a round is owed now, in the order a keeper pulls them (`pullIx`'s `part`): its own ('Own': a
+ * refund, a no-loss ticket's price, its NFT ticket back or where its price sends it), and with `places`, its places'
+ * parts of the pot ({ Pot: [run] }) and prizes ({ Prize: [run] }). Parts owed in common (a share, the pot's, a pool's
+ * prize back) are no entry's: `commonOwed`.
+ */
+export declare function partsOwed(r: any, i: any, { places }?: {
+    places?: boolean | undefined;
+}): (string | {
+    Pot: number[];
+    Prize?: undefined;
+} | {
+    Pot?: undefined;
+    Prize: number[];
+})[];
+/**
+ * The parts of a round owed in common, of no entry (`{ Common: [i] }`): each share paid in common once drawn (one that
+ * burns is burned at the close), then what its places leave, owed to its pot or to `rest` (`i` = the shares' count), then after a
+ * cancel each pool's token prize back to its pool (past it).
+ */
+export declare function commonOwed(r: any): {
+    Common: any[];
+}[];
+/** The entry of a round holding `ticket`. */
+export declare const entryOf: (r: any, ticket: any) => any;
+/** Whether a round is done and owes nothing: the next pull closes it, given its close's accounts. */
+export declare const roundFinished: (r: any) => boolean;
+/** Whether a lottery's place wins something: a part of what the round pays from, a prize, or both. */
 export declare const placeSet: (place: any) => boolean;
-/** The places of a lottery that have a winner this round: as many as are set, but no more than tickets. */
-export declare function lotteryWinners(lottery: any): number;
-/** The ticket that wins `place` of a drawn lottery: even steps around the list from first place's ticket. */
-export declare function ticketOfPlace(lottery: any, place: any): bigint;
-/** The places of a drawn lottery whose winning ticket is in `first..end` (a contribution's), in order. */
-export declare function placesWon(lottery: any, first: any, end: any): number[];
-/** The places of a drawn round that have a winner and a prize, in order: what it gives before its money moves. */
-export declare const prizePlaces: (lottery: any) => number[];
-/** The places a contribution won whose prize is not given yet (`Lottery.given`): its next step gives them. */
-export declare function lotteryOwed(lottery: any, contribution: any): number[];
-/** Whether every place's prize of a drawn round is given, so its money may move (`PrizesFirst`). */
-export declare const prizesGiven: (lottery: any) => boolean;
-/** The lowest place of a drawn round whose prize is not given yet, or null: prizes go in place order (`PlacesInOrder`). */
-export declare const nextPrizePlace: (lottery: any) => number | null;
-/**
- * What a contribution's next `finish_lottery_contribution` does, or null for nothing yet:
- *   'prizes'  give the prize of the next place it won, one place a call (a drawn round gives every prize before any money moves);
- *   'refund'  its tickets back to its buyer (a cancelled round, or a lottery that returns them);
- *   'finish'  its money through the shares into the pot, its tickets burned, or its NFT ticket spent (only once every
- *             prize of the round is given);
- *   'pay'     its places' shares of the pot, once every contribution of the round is finished.
- */
-export declare function lotteryStep(lottery: any, contribution: any): "finish" | "pay" | "prizes" | "refund" | null;
+/** The address of a lottery's current round's record (there or not). */
+export declare const roundAddress: (lotteryAddress: any, lottery: any) => any;
+/** Whether a lottery (decoded) drew once and has ended. */
+export declare const lotteryEnded: (lottery: any) => boolean;
+/** The round a lottery's close, its write again and its own stash's moves name (`lottery::check_idle`): its current
+ * round's, or once a lottery that draws once has ended, round 0's (which keeps its stash's NFTs until its places took
+ * them out). */
+export declare const idleRound: (lotteryAddress: any, lottery: any) => any;
 /**
  * Who rents a listed NFT at `now` (Unix seconds), from its decoded Listing (or null for none): the renter's wallet while
  * a rental runs, else null (a sale listing, or a rental that is over).
  */
 export declare function renterOf(listing: any, now: any): any;
+/** Whether a schedule pays every run due when it is sent late (`schedule::catches_up`): only a sealed fixed amount. */
+export declare const scheduleCatchesUp: (schedule: any) => boolean;
 /**
- * How many runs of a schedule are due at `now` (Unix seconds, the chain's clock, never the computer's): each its own
- * `run_schedule`, several in one transaction to catch up; one too many fails the whole transaction. A sealed schedule
- * past its last run is due once whenever its vault holds something (`vaultBalance`), which goes where it always went.
+ * How many runs of a schedule are due at `now` (Unix seconds, the chain's clock, never the computer's). One `run_schedule`
+ * makes them all. A sealed schedule's fixed amount pays each of them (`scheduleCatchesUp`; up to its `upto`, the runs made
+ * after it: `schedule.runs` plus these, and a long backlog takes a few calls). Any other run pays once, for the latest
+ * run due, and those before it lapse. A sealed schedule past its last run is due once whenever its vault holds something
+ * (`vaultBalance`), which goes where it always went.
  */
 export declare function runsDue(schedule: any, now: any, vaultBalance?: bigint): number;
 /**
@@ -166,7 +326,8 @@ export declare const ERRORS: Readonly<{
 }>;
 /**
  * The loot error in a failed transaction's logs ("custom program error: 0x…", or Anchor's "Error Code: …" line), or
- * null. Only loot's own: another program the transaction calls (Bubblegum, the VRF program, …) has codes of its own
+ * null: { code, name, msg }, `msg` the IDL's sentence (the program's own log names the error only: its text is
+ * compiled out). Only loot's own: another program the transaction calls (Bubblegum, the VRF program, …) has codes of its own
  * that may be the same numbers, so an error is loot's only when loot is the program that logged it or failed with it.
  * The first program that fails is where the error came from; the programs that called it fail after it with the same
  * code.