@xgamesfun/solana 0.24.0 → 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."
@@ -22,13 +23,14 @@ and the spec differ (a limit, an amount, a key not set yet), change one of them
    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
@@ -78,6 +80,7 @@ money; it holds no files and serves nothing.
   `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.

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;

package/types/chain/lookup.d.ts

@@ -176,7 +176,7 @@ declare const pause: (ms: any) => Promise<any>;
  * 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, standing, sleep }: {
+export declare function sendFitting({ rpc, payer, instructions, sign, table, alone, first, standing, sleep, }: {
     alone?: (() => boolean) | undefined;
     first?: never[] | undefined;
     instructions: any;

package/types/client/accounts.d.ts

@@ -86,6 +86,17 @@ 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;
@@ -179,10 +190,20 @@ export declare function decodeTokenMetadata(data: any): {
     ruleSet: string | null;
 } | null;
 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 its pot's. */
+/** 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. */
@@ -250,7 +271,7 @@ export declare function partsOwed(r: any, i: any, { places }?: {
 })[];
 /**
  * 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 the round owes the lottery's pot (`i` = the shares' count), then after a
+ * 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): {
@@ -260,7 +281,7 @@ export declare function commonOwed(r: any): {
 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 share of the pot, a prize, or both. */
+/** 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 address of a lottery's current round's record (there or not). */
 export declare const roundAddress: (lotteryAddress: any, lottery: any) => any;

package/types/client/grant.d.ts

@@ -12,7 +12,7 @@ export declare const dayOf: (unixSeconds: any) => number;
 /** An i64 little-endian (two's complement), as the program reads `expires`. */
 export declare const i64LE: (value: any) => Uint8Array<any>;
 /** A voucher's body, which its key signs the sha256 of (`voucherBytes`). */
-export declare function voucherBody({ program, grant, incarnation, wallet, personHash, expires, rounds, round, amount }: {
+export declare function voucherBody({ program, grant, incarnation, wallet, personHash, expires, rounds, round, amount, }: {
     amount?: bigint | undefined;
     expires: any;
     grant: any;
@@ -123,7 +123,7 @@ export declare function shardBitsFor(wallets: any, rounds?: number): number;
  * order only (`askRollIx` then asks for it, in the same transaction when it fits). Send it with a compute limit of
  * `CLAIM_COMPUTE_UNITS`.
  */
-export declare function claimGrantIx({ project, id, grant, wallet, signer, count, rounds, round, expires, personHash, amount, proofs, proof, paidRounds, poolMint, item, nft, shown, listProof, programs, voucherKey, nonce, extra }: {
+export declare function claimGrantIx({ project, id, grant, wallet, signer, count, rounds, round, expires, personHash, amount, proofs, proof, paidRounds, poolMint, item, nft, shown, listProof, programs, voucherKey, nonce, extra, }: {
     amount?: bigint | undefined;
     count?: number | undefined;
     expires: any;

package/types/client/idl/loot.d.ts

@@ -4460,6 +4460,28 @@ declare const _default: {
             })[];
             variants?: undefined;
         };
+    } | {
+        name: string;
+        docs: string[];
+        type: {
+            fields?: undefined;
+            kind: string;
+            variants: ({
+                fields?: undefined;
+                name: string;
+            } | {
+                name: string;
+                fields: string[];
+            } | {
+                name: string;
+                fields: {
+                    name: string;
+                    type: {
+                        vec: string;
+                    };
+                }[];
+            })[];
+        };
     } | {
         name: string;
         docs: string[];

package/types/client/ix.d.ts

@@ -3452,7 +3452,7 @@ export declare const prizeRollNonce: (n: any) => bigint;
  * collectibles of the same item already made earlier in the instruction); `nft` the NFT's kind, as `piece` takes it
  * ({ collection, tokenMetadata, compressed }).
  */
-export declare function prizeMetas({ project, collection, prize, winner, nonce, poolMints, items, nft, made, projectMint, programs, lottery }: {
+export declare function prizeMetas({ project, collection, prize, winner, nonce, poolMints, items, nft, made, projectMint, programs, lottery, }: {
     collection: any;
     items?: {} | undefined;
     lottery: any;
@@ -3574,7 +3574,7 @@ export declare const createProjectIx: ({ owner, id, authority, treasury, collect
  * authority or treasury comes with the account at its key (`new_authority`, `new_treasury`), which the program checks
  * as `createProjectIx`'s.
  */
-export declare const updateProjectIx: ({ owner, project, authority, paused, treasury, collections, newOwner }: {
+export declare const updateProjectIx: ({ owner, project, authority, paused, treasury, collections, newOwner, }: {
     authority?: null | undefined;
     collections?: null | undefined;
     newOwner?: null | undefined;
@@ -3610,7 +3610,8 @@ export declare function withDefaults(def: any): {
 };
 /**
  * The owner writes one record (`def`: { Item: { id, args } }, { Box: … }, …), at its own address. A lottery names
- * its pot's mint, its pot (which its first write opens), its ticket mint, both token programs and the round it waits on
+ * its mint, the pot its terms pay from (which a write opens when it isn't open; pot 0's address for a lottery whose
+ * rounds pay from their own money, where any account will do), its ticket mint, both token programs and the round it waits on
  * (`lotteryState`: the lottery as it is, null for a new one; `idleRound`: its current round's record, or round 0's once
  * it drew once and ended: a lottery made again, edited once ended or made to repeat waits while that round runs or
  * still owes NFTs of its own stash), then its own stash when a place holds or draws an NFT of it. A box, a recipe, a grant or a lottery that
@@ -3629,9 +3630,10 @@ export declare function upsertIx({ owner, project, def: given, lotteryState }: {
 };
 /**
  * The owner closes the record at `target`, and its rent comes back: a grant's with the funds it held. A lottery
- * (`lottery`: its decoded record) sends what its pot holds to `to`, a token account of the pot's mint (the owner's own
- * by default), and closes the pot, once its current round has no record (one that drew once and ended: once its round 0
- * gave out every NFT of its own stash, `idleRound`).
+ * (`lottery`: its decoded record) sends what every pot it opened holds (`Lottery::pots`) to `to`, a token account of its
+ * mint (the owner's own by default), and closes each, once its current round has no record (one that drew once and
+ * ended: once its round 0 gave out every NFT of its own stash, `idleRound`), and once the round its `owing` names has
+ * moved in what it owes its pot (pull it first, `Part::Common`). One that never opened a pot names only those rounds.
  */
 export declare function closeRecordIx({ owner, project, target, lottery, schedule, programs, to, extra }: {
     extra?: never[] | undefined;
@@ -3651,7 +3653,7 @@ export declare function closeRecordIx({ owner, project, target, lottery, schedul
  * `player` (or a sponsor, or the project's own keys funding a pool) pays `amount` of `mint`, split at once by `shares`.
  * The rest goes to the project's `treasury` wallet. The player opens any account this pays into that is not there.
  */
-export declare function payIx({ player, project, mint, treasury, amount, shares, reference: ref, playerToken, holders, programs, extra }: {
+export declare function payIx({ player, project, mint, treasury, amount, shares, reference: ref, playerToken, holders, programs, extra, }: {
     amount: any;
     extra?: never[] | undefined;
     holders: any;
@@ -3679,7 +3681,7 @@ export declare function payIx({ player, project, mint, treasury, amount, shares,
  * The player opens the project's vault for the price's mint, and for each prize's, when it is not there. A box that
  * limits each wallet counts the purchase in the player's counts (`pda.counts`, its rent theirs).
  */
-export declare function openBoxIx({ player, project, box, boxAddress, nonce, maxPrice, count, items, shown, listProof, subject, chosenRecipient, chosen, settler, poolMints, playerToken, programs, extra }: {
+export declare function openBoxIx({ player, project, box, boxAddress, nonce, maxPrice, count, items, shown, listProof, subject, chosenRecipient, chosen, settler, poolMints, playerToken, programs, extra, }: {
     box: any;
     boxAddress: any;
     chosen?: null | undefined;
@@ -3714,7 +3716,7 @@ export declare function openBoxIx({ player, project, box, boxAddress, nonce, max
  * treasury wallet; `holders` maps a collectible a share pays to its holder; each roll the entry gives is made at the
  * next nonce from `nonce` (`buyRolls`). `shown`/`listProof` pass the box's gate.
  */
-export declare function buyIx({ player, project, box, boxAddress, maxPrice, count, treasury, chosenRecipient, chosen, nonce, shown, listProof, items, poolMints, nfts, holders, playerToken, programs, extra }: {
+export declare function buyIx({ player, project, box, boxAddress, maxPrice, count, treasury, chosenRecipient, chosen, nonce, shown, listProof, items, poolMints, nfts, holders, playerToken, programs, extra, }: {
     box: any;
     boxAddress: any;
     chosen?: null | undefined;
@@ -3757,7 +3759,7 @@ export declare function buyGives(box: any, count?: number): {
  * for a prize in a mint with a transfer hook, the hook's accounts (`extra`). The buyer's odds boosts were fixed at
  * purchase.
  */
-export declare function callbackRollIx({ order, orderState, box, boxAddress, randomness, project, poolMints, items, programs, extra }: {
+export declare function callbackRollIx({ order, orderState, box, boxAddress, randomness, project, poolMints, items, programs, extra, }: {
     box: any;
     boxAddress: any;
     extra?: never[] | undefined;
@@ -3782,7 +3784,7 @@ export declare function callbackRollIx({ order, orderState, box, boxAddress, ran
  *   Compressed  the item, the tree's config, the tree, the collection, Bubblegum's programs; for a fresh one, then its
  *           tables and the Sheet of the NFT it mints
  */
-export declare function wonAccounts({ order, items, nfts, prizeTo, putBack, programs, from, upto, tree, treeMinted, unminted }: {
+export declare function wonAccounts({ order, items, nfts, prizeTo, putBack, programs, from, upto, tree, treeMinted, unminted, }: {
     from?: number | undefined;
     items?: {} | undefined;
     nfts?: {} | undefined;
@@ -3851,7 +3853,7 @@ export declare const SETTLE_LAST = 4294967295;
  * (`settled`) up to it, and nothing more. The first call, whichever it is, splits the payment (its shares' accounts
  * ride on it).
  */
-export declare function settleIx({ signer, orderAddress, order, projectState, items, nfts, prizeTo, putBack, subject, handBack, holders, programs, upto, tree, treeMinted, unminted, extra }: {
+export declare function settleIx({ signer, orderAddress, order, projectState, items, nfts, prizeTo, putBack, subject, handBack, holders, programs, upto, tree, treeMinted, unminted, extra, }: {
     extra?: never[] | undefined;
     handBack?: boolean | undefined;
     holders: any;
@@ -3941,7 +3943,7 @@ export declare function askRollIx({ payer, orderAddress, order, box, settler, po
  * wallet), a collectible's holder or 'Burn', `amount` { Fixed: [n] } or { Bps: [bps] } of a pool. The authority opens the
  * account it pays into when it is not there; a collectible nobody holds gets nothing.
  */
-export declare function moveTokensIx({ authority, project, mint, from, to, amount, reference: ref, holders, programs, treasury, farm, extra }: {
+export declare function moveTokensIx({ authority, project, mint, from, to, amount, reference: ref, holders, programs, treasury, farm, extra, }: {
     amount: any;
     authority: any;
     extra?: never[] | undefined;
@@ -4014,7 +4016,7 @@ export declare const madeAssets: (project: any, item: any, itemState: any, count
  * (`piece`): `asset` and `collection` for a Core asset, with `tokenMetadata` for a Token Metadata NFT, or `compressed`
  * (after a `proveLeafIx`).
  */
-export declare function releaseIx({ signer, project, collection, asset, tokenMetadata: tm, compressed, hold, address, to, treasury, reference: ref, more }: {
+export declare function releaseIx({ signer, project, collection, asset, tokenMetadata: tm, compressed, hold, address, to, treasury, reference: ref, more, }: {
     address?: null | undefined;
     asset: any;
     collection: any;
@@ -4083,7 +4085,7 @@ export declare function verdictBytes({ program, contest, incarnation, side, expi
  * contest with a chosen share is decided naming its `recipient`, a wallet (a bounty's worker); a decider's verdict
  * signs it too (`verdictBytes`).
  */
-export declare function decideIx({ signer, project, projectState, contestAddress, contest, side, recipient, verdict, reference: ref, holders, prizeMint, programs, extra }: {
+export declare function decideIx({ signer, project, projectState, contestAddress, contest, side, recipient, verdict, reference: ref, holders, prizeMint, programs, extra, }: {
     contest: any;
     contestAddress: any;
     extra?: never[] | undefined;
@@ -4132,7 +4134,7 @@ export declare const callbackRandomIx: ({ project, reference: ref, randomness }:
  * lapse; only a sealed schedule's fixed amount pays every run due, up to `upto` runs made (`scheduleCatchesUp`).
  * `poolMint`: the mint of the pool it moves from (when it moves from one). `extra`: a hook's or a memo's accounts.
  */
-export declare function runScheduleIx({ payer, project, id, schedule, poolMint, holders, programs, treasury, upto, extra }: {
+export declare function runScheduleIx({ payer, project, id, schedule, poolMint, holders, programs, treasury, upto, extra, }: {
     extra?: never[] | undefined;
     holders: any;
     id: any;
@@ -4160,7 +4162,7 @@ export declare const currentRound: (lotteryAddress: any, lottery: any) => any;
  * `treasury` wallet. A lottery whose ticket costs an NFT sells one at a time, for `nft` ({ asset, collection,
  * tokenMetadata, compressed }, as `piece` takes it).
  */
-export declare function buyTicketsIx({ player, project, id, lottery, round, mint, count, shown, listProof, chosenRecipient, chosen, nft, holders, treasury, playerToken, programs, extra }: {
+export declare function buyTicketsIx({ player, project, id, lottery, round, mint, count, shown, listProof, chosenRecipient, chosen, nft, holders, treasury, playerToken, programs, extra, }: {
     chosen?: null | undefined;
     chosenRecipient?: null | undefined;
     count: any;
@@ -4188,15 +4190,19 @@ export declare function buyTicketsIx({ player, project, id, lottery, round, mint
  * round asked for (null when nobody bought into the current one: it moves on, or a lottery that draws once ends, with
  * no ask), and `roundAddress` its address when it is not the current round's (an older round still waiting for its
  * answer: asked again after `STALE_SECONDS`, or after the timeout cancelled, with no lottery account, so `lottery` may be
- * null then; without `round`, the current round's, with the lottery's terms). A round's first ask fixes its money: it takes
- * the lottery's pot, its mint and the round's account of it, then each run of token prizes in place order, its mint and
- * for a pool, the pool and the round's account of the mint (`poolMints`: a pool's index to its mint). With `skipHooked`
- * (the project's authority only) a hooked pool or pot gives the round nothing. `extra`: hook accounts.
+ * null then; without `round`, the current round's, with the lottery's terms). A round's first ask fixes its money. Paid
+ * from a pot, it takes the pot, its mint and the round's account of it, then, when the lottery names a round that may
+ * still owe a pot (`lottery.owing`), that round, its account of the mint and its pot (`owing`: that round's decoded
+ * record, whose terms name its pot; without it, or when the record is gone, the pot this round pays from). A round paid
+ * from its own money takes none of these. Then each run of token prizes in place order, its mint and for a pool, the
+ * pool and the round's account of the mint (`poolMints`: a pool's index to its mint). With `skipHooked` (the project's
+ * authority only) a hooked pool or pot gives the round nothing. `extra`: hook accounts.
  */
-export declare function drawLotteryIx({ payer, project, id, lottery, round, roundAddress, skipHooked, poolMints, extra }: {
+export declare function drawLotteryIx({ payer, project, id, lottery, round, roundAddress, owing, skipHooked, poolMints, extra, }: {
     extra?: never[] | undefined;
     id: any;
     lottery: any;
+    owing?: null | undefined;
     payer: any;
     poolMints?: {} | undefined;
     project: any;
@@ -4239,13 +4245,14 @@ export declare function stashNfts(r: any, stash: any): any;
  *   'Own'            entry `entry`'s own part: a refund, a no-loss ticket's price, or its NFT ticket back or where its
  *                    price sends it (`ticket` its kind as `piece` takes it; `handBack` when the wallet its price gives
  *                    it to is an account of the loot program; `hold`: made a hold for whoever it is owed to instead);
- *   { Pot: [run] }   the entry's places in the run, their part of the pot, paid into the buyer's account;
+ *   { Pot: [run] }   the entry's places in the run, their part of what the round pays from, paid into the buyer's account;
  *   { Prize: [run] } their prize: tokens into the buyer's account, or each place's prize (`prize`: { stash, the lottery's
  *                    own stash decoded, for NFTs not taken out yet (`stashNfts`); stashes, a project stash's id to its
  *                    decoded stash; nfts, an NFT's kind by its asset; hold, NFTs made holds; most, the most places a
  *                    pull carries; and what `prizeMetas` takes: collection, poolMints, items, projectMint }), a roll's
  *                    order at `prizeRollNonce(nonce + place)` (ask it in the same transaction: `pullRolls`);
- *   { Common: [i] }  a part owed in common: share `i`, the pot's (`i` = the shares' count), a pool's prize back after a
+ *   { Common: [i] }  a part owed in common: share `i`, what the places leave (`i` = the shares' count: to the pot, or
+ *                    to `rest` for a round paid from its own money; never owed when that burns), a pool's prize back after a
  *                    cancel (past it), paid where it goes (`holders`, `programs`); `toTreasury` when that can't take it
  *                    (a pool never opened, the pot closed since or made again in another mint, an account gone: a
  *                    holder nobody is is found here).
@@ -4253,7 +4260,7 @@ export declare function stashNfts(r: any, stash: any): any;
  * lottery is gone, so rent it lent goes to the owner). A round that owes nothing and waits only for its close is closed
  * by any pull.
  */
-export declare function pullIx({ payer, project, roundAddress: key, round: r, entry, part, projectState, ticket, handBack, hold, nonce, prize, holders, toTreasury, lotteryClosed, programs, extra }: {
+export declare function pullIx({ payer, project, roundAddress: key, round: r, entry, part, projectState, ticket, handBack, hold, nonce, prize, holders, toTreasury, lotteryClosed, programs, extra, }: {
     entry?: number | undefined;
     extra?: never[] | undefined;
     handBack?: boolean | undefined;
@@ -4462,7 +4469,7 @@ export declare const AUTH_RULES_PROGRAM = "auth9SigNpDKz4sJJ1DfCTuZrZNSAgh9sFD3r
  *   `burns`: burns a Core asset (false when left out); `reads`: reads its Sheet; `held`: reads it in the project's token
  *   account (an escrow farm).
  */
-export declare function piece({ project, asset, wallet, collection, hasAuthority, tokenMetadata: tm, compressed: c, moves, locks, writes, burns, reads, held }: {
+export declare function piece({ project, asset, wallet, collection, hasAuthority, tokenMetadata: tm, compressed: c, moves, locks, writes, burns, reads, held, }: {
     asset: any;
     burns?: boolean | undefined;
     collection: any;
@@ -4614,7 +4621,7 @@ export declare function nftPaid({ project, owner, then, asset, collection, hasAu
  * place), or given to the wallet `to` (the treasury, a partner). The receipt (`PaidNft`) is the record: an app admits the player when the NFT, where it went (`to`: a payment to the player's own wallet pays nothing) and the reference
  * are the ones it asked for. `extra`: Core's transfer adapters.
  */
-export declare function payNftIx({ player, project, asset, to, collection, hasAuthority, tokenMetadata: tm, compressed, reference: ref, extra }: {
+export declare function payNftIx({ player, project, asset, to, collection, hasAuthority, tokenMetadata: tm, compressed, reference: ref, extra, }: {
     asset: any;
     collection: any;
     compressed: any;
@@ -4702,7 +4709,7 @@ export declare function withLeafCloses(instructions: any): any;
  * (`pda.leaf`). A Token Metadata NFT's (`tokenMetadata`: true, or its kind) names its edition, which must be closed
  * too: its mint holds none, with no mint authority but its edition (`NotBurned` otherwise).
  */
-export declare const closeSheetIx: ({ project, nft, tree, burned, treasury, tokenMetadata: tm }: {
+export declare const closeSheetIx: ({ project, nft, tree, burned, treasury, tokenMetadata: tm, }: {
     burned?: any;
     nft: any;
     project: any;
@@ -4760,7 +4767,7 @@ export declare const proveTraitsIx: ({ signer, project, key, nft, attributes, pr
  * collection, hasAuthority, tokenMetadata, compressed }) go in the same call at the same tier, one fee, by their seats'
  * addresses. `extra` carries reward token hooks/memos and Core transfer adapter accounts.
  */
-export declare const stakeNftIx: ({ player, project, id, farm, asset, collection, hasAuthority, tokenMetadata: tm, compressed, previous, tier, programs, more, extra }: {
+export declare const stakeNftIx: ({ player, project, id, farm, asset, collection, hasAuthority, tokenMetadata: tm, compressed, previous, tier, programs, more, extra, }: {
     asset: any;
     collection: any;
     compressed: any;
@@ -4790,7 +4797,7 @@ export declare const stakeNftIx: ({ player, project, id, farm, asset, collection
  * in the same call, one fee, one transfer of rewards: by their seats' addresses, the `i`th's roll at `nonce + 2i` and its
  * prize's at `nonce + 2i + 1` (`seatNonces` says which NFT has which). One still locked refuses the whole call.
  */
-export declare const unstakeNftIx: ({ player, project, id, farm, asset, collection, hasAuthority, tokenMetadata: tm, compressed, forfeit, roll, nonce, tier, projectCollection, poolMints, items, nft, boxes, programs, more, extra }: {
+export declare const unstakeNftIx: ({ player, project, id, farm, asset, collection, hasAuthority, tokenMetadata: tm, compressed, forfeit, roll, nonce, tier, projectCollection, poolMints, items, nft, boxes, programs, more, extra, }: {
     asset: any;
     boxes?: {} | undefined;
     collection: any;
@@ -4829,7 +4836,7 @@ export declare const seatNonces: (project: any, id: any, farm: any, player: any,
  * (`NotProven`). `more` seats of the player's in the farm (each { by, held, tree }) collect in the same call, one fee,
  * one transfer.
  */
-export declare const harvestIx: ({ player, project, id, farm, by, held, tree, compound, programs, more, extra }: {
+export declare const harvestIx: ({ player, project, id, farm, by, held, tree, compound, programs, more, extra, }: {
     by?: any;
     compound?: boolean | undefined;
     extra?: never[] | undefined;
@@ -4854,7 +4861,7 @@ export declare const harvestIx: ({ player, project, id, farm, by, held, tree, co
  * NFT's token account that holds it, `holder`'s (its staker's, or a watched NFT's buyer's). `signer` pays for what the
  * write adds. `extra`: the reward mint's hook accounts.
  */
-export declare const refreshSeatIx: ({ signer, project, id, farm, by, seat, collection, hasAuthority, tokenMetadata: tm, compressed, holder, extra }: {
+export declare const refreshSeatIx: ({ signer, project, id, farm, by, seat, collection, hasAuthority, tokenMetadata: tm, compressed, holder, extra, }: {
     by: any;
     collection: any;
     compressed: any;
@@ -4881,7 +4888,9 @@ export declare const refreshSeatIx: ({ signer, project, id, farm, by, seat, coll
  * it lowers a number: its seat and farm follow it, and the raise may not lower a number that farm reads; for a `Trade` line the NFT traded in, as `piece` takes it: `{ asset, collection, tokenMetadata,
  * compressed }`). A collectible used that is staked in a farm holding it for the player (escrow) or locking it in their
  * wallet (freeze) is `{ asset, farm }`, `farm` that farm's id: its seat and farm follow it (a raise on it may not lower a
- * number its farm reads: `BadRecipe`). A `Staked` line names the farm its collectible
+ * number its farm reads: `BadRecipe`). One that boosts the player's token seat in a farm of tokens is
+ * `{ asset, farm, booster: true }`: the player's token seat (`["seat", farm, player]`) and that farm follow it, on a kept
+ * `Use` line or a `Show` line alike. A `Staked` line names the farm its collectible
  * is staked in (`Input::Staked { item, farm }`, escrowed or frozen there): its address, or `{ asset, farm }` with that
  * farm, and its seat and that farm follow it. Each item line passes its item's collection
  * (`items[id].collection`, the decoded Items; `collection` when not given), written for a burn: Core writes it as it
@@ -4892,7 +4901,7 @@ export declare const refreshSeatIx: ({ signer, project, id, farm, by, seat, coll
  * (`askRollIx`, in the same transaction when it fits).
  * A craft makes several Core calls: raise the compute limit. `extra`: a token's hook accounts.
  */
-export declare function craftIx({ player, project, collection, id, recipe, assets, times, nonce, holders, programs, treasury, poolMints, items, nfts, boxes, extra }: {
+export declare function craftIx({ player, project, collection, id, recipe, assets, times, nonce, holders, programs, treasury, poolMints, items, nfts, boxes, extra, }: {
     assets?: never[] | undefined;
     boxes?: {} | undefined;
     collection: any;
@@ -4921,7 +4930,7 @@ export declare const craftNewAssets: (recipe: any) => any;
  * asset (`collection` its own, Core's address for none), a Token Metadata NFT (`tokenMetadata`), or `compressed` (after
  * a `proveLeafIx`).
  */
-export declare function holdIx({ player, project, collection, asset, tokenMetadata: tm, compressed, freeAt, reference: ref, more }: {
+export declare function holdIx({ player, project, collection, asset, tokenMetadata: tm, compressed, freeAt, reference: ref, more, }: {
     asset: any;
     collection: any;
     compressed: any;
@@ -4944,7 +4953,7 @@ export declare function holdIx({ player, project, collection, asset, tokenMetada
  * treasury in its hold (`["hold", nft, 0]`, the signer paying its rent until anyone `release`s it to the treasury, one
  * NFT a call). `out` is never the project's own address nor another account of the program (`ToTheProject`).
  */
-export declare function stashIx({ signer, project, id, lottery, lotteryState, asset, out, drop, weight, collection, tokenMetadata: tm, compressed, more }: {
+export declare function stashIx({ signer, project, id, lottery, lotteryState, asset, out, drop, weight, collection, tokenMetadata: tm, compressed, more, }: {
     asset: any;
     collection: any;
     compressed: any;
@@ -4969,7 +4978,7 @@ export declare function stashIx({ signer, project, id, lottery, lotteryState, as
  * compressed }, as `piece` takes it), which the contest holds until it is claimed. `shown`/`listProof` pass its gate.
  * A new entry's record is the player's to pay (not refunded). `extra`: a hook's accounts.
  */
-export declare function enterIx({ player, project, id, contest, side, amount, shown, listProof, nft, playerToken, programs, extra }: {
+export declare function enterIx({ player, project, id, contest, side, amount, shown, listProof, nft, playerToken, programs, extra, }: {
     amount: any;
     contest: any;
     extra?: never[] | undefined;
@@ -5000,7 +5009,7 @@ export declare function enterIx({ player, project, id, contest, side, amount, sh
  * closes the contest (`projectState`: its treasury); a contest that owes nothing (nobody entered, every part claimed,
  * off by itself with none in) is closed by any claim, the `payer`'s. `extra`: a hook's accounts.
  */
-export declare function claimIx({ payer, project, projectState, id, contest, entries, player, nfts, kinds, nonce, collection, poolMints, items, nft, prizeMint, forgo, end, hold, programs, extra }: {
+export declare function claimIx({ payer, project, projectState, id, contest, entries, player, nfts, kinds, nonce, collection, poolMints, items, nft, prizeMint, forgo, end, hold, programs, extra, }: {
     collection: any;
     contest: any;
     end?: boolean | undefined;
@@ -5069,7 +5078,7 @@ export declare const MAX_BID_NFTS = 3;
  * (`held`, the kinds of `auction.held`, in order) back to its bidder; one that can't move now (`hold`: true for all, or a
  * list of assets) becomes a hold for them instead, `bidder` paying its rent until its release. `extra`: a hook's accounts.
  */
-export declare function bidIx({ bidder, project, id, auction, amount, shown, listProof, nfts, held, hold, bidderToken, programs, extra }: {
+export declare function bidIx({ bidder, project, id, auction, amount, shown, listProof, nfts, held, hold, bidderToken, programs, extra, }: {
     amount: any;
     auction: any;
     bidder: any;
@@ -5101,7 +5110,7 @@ export declare function bidIx({ bidder, project, id, auction, amount, shown, lis
  * piece nor proof), and a winning NFT of a bid a hold for `proceeds` (its hold's address in its piece's place); anyone
  * then delivers each with `releaseIx`, and the end's sender gets the rent back then.
  */
-export declare function endAuctionIx({ signer, project, projectState, id, auction, item, collection, tokenMetadata: tm, compressed, held, hold, reference: ref, nonce, holders, programs, extra }: {
+export declare function endAuctionIx({ signer, project, projectState, id, auction, item, collection, tokenMetadata: tm, compressed, held, hold, reference: ref, nonce, holders, programs, extra, }: {
     auction: any;
     collection: any;
     compressed: any;
@@ -5166,7 +5175,7 @@ export declare function closeOfferIx({ maker, project, id, offer, programs, extr
  * any kind, as `piece` takes it (`collection`, `hasAuthority` false for a Core asset of another collection,
  * `tokenMetadata`, or `compressed` after a `proveLeafIx`).
  */
-export declare function sellToOfferIx({ seller, project, projectState, id, offer, asset, collection, hasAuthority, tokenMetadata: tm, compressed, holders, programs, extra }: {
+export declare function sellToOfferIx({ seller, project, projectState, id, offer, asset, collection, hasAuthority, tokenMetadata: tm, compressed, holders, programs, extra, }: {
     asset: any;
     collection: any;
     compressed: any;
@@ -5191,7 +5200,7 @@ export declare function sellToOfferIx({ seller, project, projectState, id, offer
  * `pda.hold(asset, due)` until it is repaid (`repayIx`, then `releaseIx` sends it home) or, once due, sent to the
  * lender (`releaseIx` with `to` the lender); the loan goes to the borrower. The NFT is any kind, as `sellToOfferIx` takes it.
  */
-export declare function borrowIx({ borrower, project, id, offer, due, asset, collection, hasAuthority, tokenMetadata: tm, compressed, programs, extra }: {
+export declare function borrowIx({ borrower, project, id, offer, due, asset, collection, hasAuthority, tokenMetadata: tm, compressed, programs, extra, }: {
     asset: any;
     borrower: any;
     collection: any;
@@ -5239,7 +5248,7 @@ export declare const listingTerms: (listing: any) => Uint8Array<ArrayBuffer>;
  * goes to the project until it is sold or the listing is closed. The listing's address names the NFT
  * (`pda.listing(project, asset)`), so a game finds it, and its renter, with one account read.
  */
-export declare function openListingIx({ maker, project, asset, mint, deal, shares, collection, hasAuthority, tokenMetadata: tm, compressed, extra }: {
+export declare function openListingIx({ maker, project, asset, mint, deal, shares, collection, hasAuthority, tokenMetadata: tm, compressed, extra, }: {
     asset: any;
     collection: any;
     compressed: any;
@@ -5264,7 +5273,7 @@ export declare function openListingIx({ maker, project, asset, mint, deal, share
  * take's own accounts come a sale's compressed NFT's proof, then the shares' accounts, then (in `extra`) Core's
  * transfer adapters and any transfer hook's accounts, which the program finds by address after the shares'.
  */
-export declare function takeListingIx({ taker, project, projectState, listing, periods, collection, hasAuthority, tokenMetadata: tm, compressed, holders, programs, takerToken, extra }: {
+export declare function takeListingIx({ taker, project, projectState, listing, periods, collection, hasAuthority, tokenMetadata: tm, compressed, holders, programs, takerToken, extra, }: {
     collection: any;
     compressed: any;
     extra?: never[] | undefined;
@@ -5287,7 +5296,7 @@ export declare function takeListingIx({ taker, project, projectState, listing, p
  * Its maker closes a listing (`listing` the decoded Listing): the NFT goes home. While a rental runs it only stops (no
  * renter takes it again), and the same call once the rental is over takes it home. Free.
  */
-export declare function closeListingIx({ maker, project, listing, collection, hasAuthority, tokenMetadata: tm, compressed, extra }: {
+export declare function closeListingIx({ maker, project, listing, collection, hasAuthority, tokenMetadata: tm, compressed, extra, }: {
     collection: any;
     compressed: any;
     extra?: never[] | undefined;

package/types/client/pda.d.ts

@@ -39,8 +39,10 @@ export declare const pda: {
     /** Every collectible the program mints of its own accord (an order's, a prize's, an auction's lot): its address
      * names its item and its serial, minted once at most. */
     itemAsset: (item: any, serial: any) => any;
-    /** A contest's pot, or a lottery's: `["pot", contest or lottery]`. */
+    /** A contest's pot: `["pot", contest]`. */
     pot: (record: any) => any;
+    /** A lottery's pot `id` (below `MAX_POTS`), kept from round to round: `["pot", lottery, id]`. */
+    lotteryPot: (lottery: any, id: 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. */

package/types/economy/guide.d.mts

@@ -106,6 +106,11 @@ export declare const CONVENTIONS: string[];
  * then offer the nearest versions with their numbers, best first, and build the one the person picks. A feature that
  * ships later moves its entry to HOW.
  */
+/**
+ * What no code removes, only makes smaller: a wallet is not a person, the page can't be trusted, and bots play well.
+ * Said once in the guide, so every design starts from it.
+ */
+export declare const SAFETY: string[];
 export declare const CANNOT: {
     what: string;
     words: string;