@xgamesfun/solana 0.24.0 → 0.25.1

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/cost.d.mts

@@ -11,7 +11,7 @@ export declare function setupCost(plan: any, economy: any): {
     notes: string[];
 };
 /**
- * What each action costs whoever signs it while the economy runs: games.fun's fee, the network's, and for anything
+ * What each action costs whoever signs it while the economy runs: xgames.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 fee (`oracleSol`, model.mjs ORACLE_FEE).
  */

package/types/economy/explain.d.mts

@@ -1,3 +1,6 @@
+export declare const ruleWords: (r: any) => string;
+/** A gate in a sentence: "Only players who show …", "Only the wallets it names …", "Only wallets with … staked …". */
+export declare const gateWords: (gate: any, verb: any, m: any) => string;
 export declare function explainEconomy(economy: any, { now }?: {
     now?: number | undefined;
 }): {

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;

package/types/economy/model.d.mts

@@ -111,7 +111,7 @@ export declare const STOCK_WORDS = "The odds stay as written whatever is in stoc
  */
 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";
+}): "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. A free roll (a prize, a recipe’s, a mission’s chest) is on the odds as written too: a draw on an outcome that is out misses and gives nothing back (a pack keeps what its other draws won; a roll that drew nothing waits to be asked again), so emptying a shared source before asking steers nothing. A pack that should draw among what is left needs \"whenOut\": \"drawLeft\"" | "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 anything an outcome takes (an item’s units left, a pool’s tokens, a stash’s NFTs) couldn’t cover, at the most any outcome sharing it takes in one draw, this purchase’s draws and those of purchases still waiting for the oracle, 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 its vault, free for the authority to take back, and so does what
@@ -275,7 +275,7 @@ 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. */
+/** A lottery's place as { percent, prize }: a number is a percent of what the round pays from, and no prize. */
 export declare const placeOf: (p: any) => {
     percent: any;
     prize: any;
@@ -295,7 +295,7 @@ 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>") and "farm:<key>" that farm's rewards vault ("@rewards:<id>"), which the plan resolves once the game is
+ * ("@pot:<lottery id>:<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" | {
@@ -401,6 +401,51 @@ export declare const windowOf: (part: any, now: any) => {
     opens_at: bigint;
     closes_at: bigint;
 };
+/** Whether lottery `l` pays its places from a pot it keeps (`"pot"`, `PaysFrom::Pot`); false when each round pays from
+ * its own ticket money and sends what its places leave to `"rest"` (`PaysFrom::Round`). */
+export declare const keepsPot: (l: any) => boolean;
+/** The program's `PaysFrom` for a lottery: `{ Pot: [id] }` or `{ Round: { rest } }` (its `rest` as `toEnum` gives it). */
+export declare const paysFromOf: (l: any, m: any) => {
+    Pot: any[];
+    Round?: undefined;
+} | {
+    Pot?: undefined;
+    Round: {
+        rest: string | {
+            Pool: any[];
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+        } | {
+            Pool?: undefined;
+            Account: (string | undefined)[];
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+        } | {
+            Pool?: undefined;
+            Account?: undefined;
+            Wallet: (string | undefined)[];
+            Chosen?: undefined;
+            Holder?: undefined;
+        } | {
+            Pool?: undefined;
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen: {
+                item: any;
+            };
+            Holder?: undefined;
+        } | {
+            Pool?: undefined;
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder: (string | undefined)[];
+        };
+    };
+};
 /** A lottery's split of ticket money: its own, and "cutPercent" as a share to the treasury. */
 export declare const lotterySplit: (l: any) => any[];
 /** The program's `Effect` for a spec effect: a flat share, or a share per point of the attribute. */

package/types/economy/plan.d.mts

@@ -405,13 +405,55 @@ export declare function prizeArgs(p: any, m: any): "Raffled" | {
  */
 export declare const listLeaves: (list: any, t: any) => any;
 /**
- * A lottery's args: its own pot in `currency` (the project's by default), ticket money split by `split` (and
- * `cutPercent` to the treasury) with the rest into the pot. No `every` draws once, at `firstDraw`.
+ * A lottery's args: its money in `currency` (the project's by default), ticket money split by `split` (and
+ * `cutPercent` to the treasury) with the rest for the places, which are paid from its pot (`pot`) or from each round's
+ * own money, what they leave going to `rest` (`paysFromOf`). No `every` draws once, at `firstDraw`.
  */
 export declare function lotteryArgs(l: any, m: any): {
     terms: {
         price: bigint;
         mint: string;
+        pays_from: {
+            Pot: any[];
+            Round?: undefined;
+        } | {
+            Pot?: undefined;
+            Round: {
+                rest: string | {
+                    Pool: any[];
+                    Account?: undefined;
+                    Wallet?: undefined;
+                    Chosen?: undefined;
+                    Holder?: undefined;
+                } | {
+                    Account: (string | undefined)[];
+                    Wallet?: undefined;
+                    Chosen?: undefined;
+                    Holder?: undefined;
+                    Pool?: undefined;
+                } | {
+                    Account?: undefined;
+                    Wallet: (string | undefined)[];
+                    Chosen?: undefined;
+                    Holder?: undefined;
+                    Pool?: undefined;
+                } | {
+                    Account?: undefined;
+                    Wallet?: undefined;
+                    Chosen: {
+                        item: any;
+                    };
+                    Holder?: undefined;
+                    Pool?: undefined;
+                } | {
+                    Account?: undefined;
+                    Wallet?: undefined;
+                    Chosen?: undefined;
+                    Holder: (string | undefined)[];
+                    Pool?: undefined;
+                };
+            };
+        };
         shares: any;
         places: any;
         ticket_mint: string;

package/types/economy/review.d.mts

@@ -0,0 +1,45 @@
+import { TRUST_LEVELS, TRUST_WORDS } from './trust.mjs';
+/** Severities, most serious first. */
+export declare const SEVERITIES: readonly string[];
+export { TRUST_LEVELS, TRUST_WORDS };
+/**
+ * The review of an economy: { ok, routes, findings, tradeoffs }. `ok` is false when there is a high finding, or when
+ * the spec does not check (then `refusals` says why, and the rest is empty).
+ */
+export declare function review(economy: any, { now }?: {
+    now?: number | undefined;
+}): {
+    ok: boolean;
+    refusals: any[];
+    routes: never[];
+    findings: never[];
+    tradeoffs: string;
+} | {
+    refusals?: undefined;
+    ok: boolean;
+    routes: ({
+        kind: string;
+        key: any;
+        name: any;
+        trigger: string;
+        enforced: any[];
+        trusts: any[];
+        trust: any;
+        ceiling: string;
+        feeds: any[];
+    } | {
+        kind: string;
+        key: any;
+        name: any;
+        trigger: string;
+        enforced: any[];
+        trusts: any;
+        trust: null;
+        ceiling: string;
+        feeds: any[];
+    })[];
+    findings: any[];
+    tradeoffs: string;
+};
+/** A review in words, for the terminal and the tool's text. */
+export declare function describeReview(r: any, name?: string): string;

package/types/economy/trust.d.mts

@@ -0,0 +1,8 @@
+/** The trust levels a voucher grant declares, strongest first. */
+export declare const TRUST_LEVELS: readonly string[];
+/** Each trust level in words: what the server does, and what a cheater still gets. */
+export declare const TRUST_WORDS: Readonly<{
+    decides: "the server decides the result itself (it runs the game or the match; the page sends only inputs): nothing the page says can forge one, though a bot that plays well still earns what a good player does";
+    replays: "the server runs the page’s inputs again and reads the result itself: a forged result fails, though a bot that plays well still earns, and one that knows the run’s randomness up front can search for the best run offline";
+    bounds: "the page runs the game and reports the result, and the server checks only its pace, order and daily caps: a script that waits as long as a person would gets every reward, up to the limits";
+}>;

package/types/index.d.ts

@@ -3,6 +3,7 @@ export { simulate, explain } from './economy/simulate.mjs';
 export { plan, setupSteps, playSteps } from './economy/plan.mjs';
 export { cost, explainCost } from './economy/cost.mjs';
 export { explainEconomy } from './economy/explain.mjs';
+export { review, describeReview, SEVERITIES, TRUST_LEVELS, TRUST_WORDS } from './economy/review.mjs';
 export { model } from './economy/model.mjs';
 export { prepare, recordLanded, changedParts } from './economy/live.mjs';
 export { guideText, catalog, CANNOT } from './economy/guide.mjs';