@xgamesfun/solana 0.25.3 → 0.26.0

package/types/client/ix.d.ts

@@ -1005,11 +1005,20 @@ export declare const instructionOf: (data: any) => {
     args: ({
         name: string;
         type: {
+            defined?: undefined;
             array: (string | number)[];
         };
     } | {
         name: string;
         type: string;
+    } | {
+        name: string;
+        type: {
+            array?: undefined;
+            defined: {
+                name: string;
+            };
+        };
     })[];
 } | {
     name: string;
@@ -3424,6 +3433,18 @@ export declare function shownAccounts(project: any, shown: any): {
  * one, or for a box's odds.
  */
 export declare const gateAccounts: (project: any, { gate, wallet, shown, listProof }?: Readonly<Record<string, any>>) => any[];
+/** Whether a rule reads the player's profile (`Of::Profile`), not an NFT. */
+export declare const readsProfile: (rule: any) => boolean;
+/**
+ * Whether a box's gate or odds read the player's profile (`profile` true) or an NFT (false), as the program's
+ * `LootBox::reads` tells: a gate on a rule, then each odds rule. A box may read both.
+ */
+export declare const boxReads: (box: any, profile: any) => boolean;
+/**
+ * What a player shows a gate with (`rules::shown_for`): their own profile, `["profile", project, wallet]`, for a gate on
+ * a rule that reads one; the NFT `shown` otherwise.
+ */
+export declare const shownFor: (project: any, gate: any, wallet: any, shown: any) => any;
 /**
  * A nonce a prize route names (its `nonce` argument), from what names the prize: a grant, its wallet and rounds, a
  * contest and its player, an auction and its last bid. Any nonce works (the sender picks it); the roll's order
@@ -3608,11 +3629,15 @@ export declare function withDefaults(def: any): {
     [x: string]: any;
     Lottery?: undefined;
 };
+/** The most "one of" texts a lottery's NFT ticket rule holds: the oracle's answer reads it (`lottery.rs`). */
+export declare const MAX_TICKET_TEXTS = 170;
+/** The most places of a lottery that give NFTs of its own stash (`MOST_OWN`): the oracle's answer loads their list. */
+export declare const MAX_OWN_STASH_PLACES = 256;
 /**
  * The owner writes one record (`def`: { Item: { id, args } }, { Box: … }, …), at its own address. A lottery names
  * 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
+ * (`lotteryState`: the lottery as it is, null for a new one; `idleRound`: its current round's record, or its last round'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
  * names a box to roll later passes that box after (`boxesAccounts`), which must be written: a box is written before
@@ -3632,7 +3657,7 @@ 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 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
+ * ended: once its last round 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 }: {
@@ -3675,13 +3700,14 @@ export declare function payIx({ player, project, mint, treasury, amount, shares,
  * numbers of the NFT it rolls on: at that NFT's, `nonceOn`, whatever `nonce` says). `poolMints` maps each pool its
  * prizes take tokens from to its mint (a pool's tokens won wait in the project's vault for that mint); one not given
  * is taken to be in the box's currency, one given as null is closed. `shown`: an NFT the player shows for the box's
- * gate or odds; `listProof`: for a list gate, the proof's nodes. `chosenRecipient`: the wallet (or, for a share with an
+ * gate or odds; the player's profile goes before it whenever the box's gate or odds read one (`boxReads`); `listProof`:
+ * for a list gate, the proof's nodes. `chosenRecipient`: the wallet (or, for a share with an
  * item, the collectible, `chosen`) the buyer names for a share the box lets them choose. Every open asks the oracle,
  * even of a box with nothing random (which sells in one step with `buyIx`, when it rolls on no NFT).
  * 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, profile, listProof, subject, chosenRecipient, chosen, settler, poolMints, playerToken, programs, extra, }: {
     box: any;
     boxAddress: any;
     chosen?: null | undefined;
@@ -3695,6 +3721,7 @@ export declare function openBoxIx({ player, project, box, boxAddress, nonce, max
     player: any;
     playerToken: any;
     poolMints: any;
+    profile: any;
     programs: any;
     project: any;
     settler?: string | undefined;
@@ -3780,12 +3807,15 @@ export declare function callbackRollIx({ order, orderState, box, boxAddress, ran
  *   Item    the item; for a collectible (`items[id]` its decoded Item), its collection, its address, Metaplex Core;
  *           for a fresh one (`drawn` set), then the table of each of its table traits
  *   Tokens  the mint, the project's vault for it, the player's account of it (`prizeTo`, when given)
+ * `giveUp`: the places in `won` of the prizes the player, settling their own order, gives up (tokens they can't receive
+ * stay in the project's vault; a collectible's serial is voided): the vault, or the item, goes in the receiver's place.
  *   Nft     the NFT as `piece` takes it (`nfts[nft]` its kind), going to the player, then a compressed NFT's proof
  *   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, giveUp, programs, from, upto, tree, treeMinted, unminted, }: {
     from?: number | undefined;
+    giveUp?: never[] | undefined;
     items?: {} | undefined;
     nfts?: {} | undefined;
     order: any;
@@ -3844,17 +3874,22 @@ export declare const SETTLE_LAST = 4294967295;
  * the settle opens or mints (Core assets, token accounts, Sheets, a stash's row, the fate's writes: the order lends
  * nothing, `settleRent`). `order` is the decoded Order; `projectState` the decoded Project; `items` and `nfts` as
  * `wonAccounts` takes them. `putBack`: NFTs won that the player, signing, puts back into their stash in place of taking
- * them (one its collection won't let move). `handBack`: the wallet the box's fate gives the NFT rolled on to
+ * them (one its collection won't let move). `giveUp`: the places in `won` of tokens or collectibles the player,
+ * signing, gives up because they can't receive them (an account its issuer froze, a collection that refuses the mint),
+ * so the rest of the order is not held up: tokens given up stay in the project's vault (`PrizeForgone` says which).
+ * `handBack`: the wallet the box's fate gives the NFT rolled on to
  * (`receiverOf`) is an account of the loot program (`handsBack` of it as read), so the program gives it back to the
  * player, and a Token Metadata NFT's `token` is the player's. `extra`: a hook's or a memo's accounts.
  *
  * `upto`, the part (`settle.rs`): `SETTLE_LAST` (the default, past the end) is the last part, all that is left (maybe
  * nothing); 0 gives no prize and only splits the payment; any other gives the prizes from where the last part stopped
  * (`settled`) up to it, and nothing more. The first call, whichever it is, splits the payment (its shares' accounts
- * ride on it).
+ * ride on it whenever `order.drew` is above 0, a roll that gave nothing included), and moves the numbers on an NFT
+ * rolled on that the project does not hold (that NFT's accounts ride on it, not on the last part).
  */
-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, giveUp, subject, handBack, holders, programs, upto, tree, treeMinted, unminted, extra, }: {
     extra?: never[] | undefined;
+    giveUp: any;
     handBack?: boolean | undefined;
     holders: any;
     items: any;
@@ -3922,8 +3957,9 @@ export declare function refundIx({ signer, orderAddress, order, subject, program
  * a free roll back to waiting (`Waiting`), for a restock or for its player to end it so. Once asked, every later ask
  * comes in a later slot than the last (`SameSlot`, `rollAskable`).
  */
-export declare function askRollIx({ payer, orderAddress, order, box, settler, poolMints, items, programs }: {
+export declare function askRollIx({ payer, orderAddress, order, box, settler, poolMints, items, programs, shown, first, }: {
     box: any;
+    first?: boolean | undefined;
     items?: {} | undefined;
     order: any;
     orderAddress: any;
@@ -3931,11 +3967,36 @@ export declare function askRollIx({ payer, orderAddress, order, box, settler, po
     poolMints: any;
     programs: any;
     settler?: string | undefined;
+    shown?: null | undefined;
 }): {
     programId: string;
     keys: any[];
     data: Uint8Array<any>;
 }[];
+/**
+ * What a roll's first ask reads for its box's odds (`ask_roll`): `profile`, the order's player's profile, when any odds
+ * rule of the box reads a profile; `nft`, an NFT the player shows, when any reads an NFT and the roll is on none (neither
+ * the box nor the order names one). Unlike a purchase, a gate is not read at the ask.
+ */
+export declare function askReads(box: any, order?: {}): {
+    profile: any;
+    nft: any;
+};
+/**
+ * Whether the next ask of `order` is its first, the one that reads the odds' accounts: it was never asked
+ * (`asked_first` 0, or an order not made yet), or its box was edited since (the edit cleared what it read).
+ */
+export declare const firstAsk: (order: any, box: any) => boolean;
+/**
+ * How much each NFT of `nfts` would raise a box's odds at a roll's first ask, by the box's rules on an NFT, and the one
+ * that raises the most: { best, raised }. `nfts`: [{ asset, itemId, attributes }] as read (a Core collectible of the
+ * project's: its item and its attributes). `raised` maps each asset to the basis points its rules add in all. A rule
+ * on time (`Ahead`, `Passed`, `Within`, `Older`) or on another collection counts nothing here; pass such an NFT by name.
+ */
+export declare function bestShown(box: any, nfts: any): {
+    best: any;
+    raised: {};
+};
 /**
  * The authority moves the project's tokens: `from` { Pool: [i] }, { Mint: [mint] } (newly minted) or { Farm: [id] } (what
  * that farm's rewards vault holds free, beyond what it owes its seats: a fixed amount; `farm`: the farm decoded, so its
@@ -3984,14 +4045,20 @@ export declare function collectibleIx({ authority, project, collection, asset, c
     keys: any[];
     data: Uint8Array<any>;
 };
+/**
+ * The attributes a make writes, as the program patches them onto nothing (`write_attributes`): the program's own keys
+ * dropped, a repeated key once with its last value, an empty value taking the key off.
+ */
+export declare function madeAttributes(attributes?: any[]): any[];
 /**
  * The authority makes one of item `item` (`itemState`: its decoded Item, for its collection and next serial) for each
  * of `owners`, in serial order (an owner may come more than once), with `attributes` written over the program's own: a
  * collectible at `pda.itemAsset(item, serial)` (`madeAssets` says which), or with `tree`, a compressed NFT minted into
- * that tree of the project's (no attributes: they go in its Sheet). A switched-off item still makes; one sold out
- * refuses the whole call (`PrizeNotCovered`).
+ * that tree of the project's, whose attributes go in its Sheet (`["sheet", project, asset id]`, after its 9 prize
+ * accounts): `treeMinted` is how many the tree has minted, so the first is `pda.compressedAsset(tree, treeMinted)`. A
+ * switched-off item still makes; one sold out refuses the whole call (`PrizeNotCovered`).
  */
-export declare function makeIx({ authority, project, item, itemState, owners, attributes, tree, reference: ref }: {
+export declare function makeIx({ authority, project, item, itemState, owners, attributes, tree, treeMinted, reference: ref, }: {
     attributes?: never[] | undefined;
     authority: any;
     item: any;
@@ -4000,6 +4067,7 @@ export declare function makeIx({ authority, project, item, itemState, owners, at
     project: any;
     reference: any;
     tree?: null | undefined;
+    treeMinted: any;
 }): {
     programId: string;
     keys: any[];
@@ -4239,6 +4307,17 @@ export declare const raffledNft: (stash: any, answer: any, place: any) => any;
  * taken out before the next. null for a place whose NFT isn't there (it gets nothing).
  */
 export declare function stashNfts(r: any, stash: any): any;
+/** The most of the lottery's own stash's NFTs one pull takes out for its places (`ASSIGN_DRAWS`), counted in draws: a
+ * named NFT's search counts one, and one more for each `ASSIGN_ROWS_A_DRAW` rows of the stash. A pull after carries on. */
+export declare const ASSIGN_DRAWS = 64;
+export declare const ASSIGN_ROWS_A_DRAW = 1000;
+/**
+ * How many of a drawn round's places that win an NFT of the lottery's own stash have theirs out of the stash after one
+ * more pull for a place up to `upto` (`LotteryRound::assign`): `r.assigned`, plus as many as one pull takes, in place
+ * order. `stash` is the lottery's own stash, decoded as it is now (its rows count for a named NFT's search). A pull
+ * stops at a place whose NFT is not out yet, so it carries accounts only for places below this.
+ */
+export declare function pullAssigns(r: any, stash: any, upto: any): number;
 /**
  * Anyone (`payer`) pulls `part` of the round at `roundAddress` (`round` decoded; `partsOwed` and `commonOwed` say what is
  * owed):
@@ -4256,9 +4335,15 @@ export declare function stashNfts(r: any, stash: any): any;
  *                    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).
- * The pull that leaves nothing owed closes the round (`projectState`: its treasury and owner; `lotteryClosed` when the
- * 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.
+ * The pull that leaves nothing owed closes the round (`projectState`: its treasury and owner). While the lottery is
+ * there, the close names it for the rent it lent; once it is gone (`lotteryClosed`), that rent goes to the project's
+ * owner, and only the owner's own closing pull may send it: anyone else's leaves the close off and the round waits. A
+ * round that owes nothing and waits only for its close is closed by any pull. A place's prize that is not tokens is
+ * given as far as `prize.most` places a pull (a run of rolls: two accounts a place; size it from a dry run), and the
+ * lottery's own stash's NFTs as far as one pull takes them out (`pullAssigns`): a pull that stops short carries no
+ * close, and the next carries on. Every pull of one entry's places names the same `nonce`: a place's roll is made at
+ * `prizeRollNonce(nonce + place)`, so a later pull with another nonce can land on an order an earlier pull made and fail
+ * ("already in use"). js/play names `prizeNonce(round, entry)` for every pull of an entry, whoever sends it.
  */
 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;
@@ -4284,9 +4369,13 @@ export declare function pullIx({ payer, project, roundAddress: key, round: r, en
     data: Uint8Array<any>;
 };
 /** The orders the rolls a `{ Prize: [run] }` pull of entry `entry` makes (a place's prize that is a roll), each with its
- * box: [{ order, box }], at `prizeRollNonce(nonce + place)` for the entry's buyer. Ask each in the pull's transaction. */
-export declare function pullRolls({ project, round: r, entry, part, nonce }: {
+ * box: [{ order, box }], at `prizeRollNonce(nonce + place)` for the entry's buyer, the first `most` of its places owed
+ * when the pull carries no more (`pullIx`'s `prize.most`). Ask each in the pull's transaction. Every pull of one entry's
+ * places names the same `nonce` (a different one can land on an order an earlier pull made, "already in use"): js/play
+ * names `prizeNonce(round, entry)` for all of them. */
+export declare function pullRolls({ project, round: r, entry, part, nonce, most }: {
     entry: any;
+    most?: null | undefined;
     nonce?: bigint | undefined;
     part: any;
     project: any;
@@ -4789,7 +4878,9 @@ export declare const stakeNftIx: ({ player, project, id, farm, asset, collection
 };
 /**
  * `player` takes an NFT out once its lock has run: it grows on its way out (a farm with growth writes on it, or on its
- * Sheet), and from its own seat takes its tier's prize. `forfeit` gives up the rewards and the prize. Leaving a tier
+ * Sheet), and from its own seat takes its tier's prize. `forfeit` gives up the rewards and the prize. `needPrize` (true
+ * by default): a mission prize that can't be given refuses the unstake (`PrizeNotCovered`) and the seat stays; false
+ * lets the NFT go home without it (`Unseated.prize_missed`). Leaving a tier
  * that rolls (`roll`: its box id, `boxes` its decoded box by id), the NFT is rolled on that box, in an order named by
  * `nonce` (`namedRollNonce`: the NFT's own on a box that holds it; its player or the project's keys then ask the oracle,
  * `askRollIx`, and settles); a box that can burn it or give it away keeps it in the project's hands until then. `more`
@@ -4797,7 +4888,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, needPrize, roll, nonce, tier, projectCollection, poolMints, items, nft, boxes, programs, more, extra, }: {
     asset: any;
     boxes?: {} | undefined;
     collection: any;
@@ -4809,6 +4900,7 @@ export declare const unstakeNftIx: ({ player, project, id, farm, asset, collecti
     id: any;
     items: any;
     more?: never[] | undefined;
+    needPrize?: boolean | undefined;
     nft: any;
     nonce?: bigint | undefined;
     player: any;
@@ -4896,12 +4988,17 @@ export declare const refreshSeatIx: ({ signer, project, id, farm, by, seat, coll
  * (`items[id].collection`, the decoded Items; `collection` when not given), written for a burn: Core writes it as it
  * burns a collectible. A recipe's `raises` write on the kept ones, in their Sheet when the project has no
  * authority over them. The player opens any account a line pays into that is not there. A roll it makes (a
- * `Prize::Roll` or a `RollOn`) passes its box and its order, nothing more; a `RollOn`'s order is where `namedRollNonce`
- * says, which reads the rolled box (`boxes`: a box's id to its decoded LootBox). Its player or the project's keys then ask for the roll
- * (`askRollIx`, in the same transaction when it fits).
+ * `Prize::Roll` or a `RollOn`) passes its box and its order, nothing more. A recipe may give several rolls: each is at
+ * the craft's `nonce` plus the rolls before it in the recipe's order (`craftRollNonces`); a `RollOn`'s order is where
+ * `namedRollNonce` says of that, which reads the rolled box (`boxes`: a box's id to its decoded LootBox). Its player or
+ * the project's keys then ask for the roll (`askRollIx`, in the same transaction when it fits).
+ * A payment line nobody can take goes to the treasury (`Crafted.to_treasury`): a collectible nobody holds or the project
+ * holds (`holders`: who holds each now, as read when building; if it changes hands before the craft lands, the craft
+ * fails cleanly), the project's own address, or an address `lootAccounts` names (wallets read as accounts of the loot
+ * program). The treasury's wallet and its account then follow that line's accounts (`treasury`).
  * 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, lootAccounts, extra, }: {
     assets?: never[] | undefined;
     boxes?: {} | undefined;
     collection: any;
@@ -4909,6 +5006,7 @@ export declare function craftIx({ player, project, collection, id, recipe, asset
     holders: any;
     id: any;
     items?: {} | undefined;
+    lootAccounts?: never[] | undefined;
     nfts?: {} | undefined;
     nonce?: bigint | undefined;
     player: any;
@@ -4923,6 +5021,18 @@ export declare function craftIx({ player, project, collection, id, recipe, asset
     keys: any[];
     data: Uint8Array<any>;
 };
+/**
+ * Whether a payment to `to` finds nobody to take it (`rail::Target::Nowhere`), so a recipe's line goes to the treasury:
+ * a collectible nobody holds, or the project holds (`holders`: who holds each now); a wallet that is the project's own
+ * address or an account of the loot program (`lootAccounts`, as read). A pool or a token account always takes it.
+ */
+export declare function paysNowhere(project: any, to: any, { holders, lootAccounts }?: Readonly<Record<string, any>>): any;
+/**
+ * The nonce each roll a craft of `recipe` makes is named at, in the recipe's outputs' order: [{ output, nonce }], the
+ * first at `nonce`, each next one more. A `RollOn` on an NFT its box holds is made at that NFT's own nonce
+ * (`namedRollNonce`), but counts all the same.
+ */
+export declare function craftRollNonces(recipe: any, nonce?: bigint): any;
 /** The collectibles a craft of `recipe` makes: one per `Item` prize among its outputs. */
 export declare const craftNewAssets: (recipe: any) => any;
 /**
@@ -4972,6 +5082,29 @@ export declare function stashIx({ signer, project, id, lottery, lotteryState, as
     keys: any[];
     data: Uint8Array<any>;
 };
+/**
+ * How many NFTs of one kind one `stash` call puts in, measured on the program (`tests/v026_stash_batch.rs`): in a legacy
+ * transaction, with a lookup table, and with a lookup table and the most memory asked for. A compressed NFT needs its
+ * proof in the same transaction (`proveLeafIx`): one a call.
+ */
+export declare const STASH_BATCH: Readonly<{
+    own: number[];
+    core: number[];
+    tokenMetadata: number[];
+    programmable: number[];
+    compressed: number[];
+}>;
+/** The kind of an NFT as `stashIx` takes it, for `STASH_BATCH`: the project's own Core collectible ('own'), another
+ * collection's Core NFT ('core', `hasAuthority` false), a Token Metadata NFT ('tokenMetadata', or 'programmable' for a
+ * pNFT) or a compressed one ('compressed'). */
+export declare const stashKind: (n: any) => "compressed" | "core" | "own" | "programmable" | "tokenMetadata";
+/**
+ * A long list of NFTs to put in a stash (each { asset, weight, collection, hasAuthority, tokenMetadata, compressed }, as
+ * `stashIx` takes them), split into calls of one kind each, as many a call as the measured sizes allow (`STASH_BATCH`):
+ * `lookupTable` when the transactions carry one, `heap` when they also ask for the most memory. Returns the calls, each
+ * a list of NFTs: the first is a call's own (`asset`…), the rest its `more`. Each call is one project fee.
+ */
+export declare function stashBatches(nfts: any, { lookupTable, heap }?: Readonly<Record<string, any>>): any[];
 /**
  * `player` backs `side` with `amount`, naming the contest's incarnation (which fixes its terms). `contest` is the
  * decoded Contest. A contest of NFTs (`contest.nft`) takes one NFT instead (`nft`: { asset, collection, tokenMetadata,
@@ -5047,11 +5180,13 @@ export declare const auctionEnds: (auction: any) => bigint;
 export declare function leastBid(auction: any): bigint | null;
 /**
  * `seller` opens its auction `id` of `args.lot` ({ Item: [id] }, { Asset: [address] } or { Roll: [box id] }), alone,
- * and pays its rent: a player for an NFT of the project's own collection they hold; the project's owner or authority for an
- * NFT of any kind it holds (`piece`: `collection` a Core asset's own, `tokenMetadata`, or `compressed` after a
- * `proveLeafIx`), a new unit of its item, or a roll of one of its boxes (a mystery lot: the box must be written, burn
- * no share of its price, and make an order with the auction's shares within one call's growth: `LotRefused`). Its
- * address names the seller, so an id is the seller's own.
+ * and pays its rent: anyone for an NFT of any kind and any collection they hold (`piece`: `collection` a Core asset's
+ * own, `tokenMetadata`, or `compressed` after a `proveLeafIx`); the project's owner or authority also for a new unit
+ * of its item (one the shop has switched off too), or a roll of one of its boxes (a mystery lot: the box must be
+ * written and make an order with the auction's shares within one call's growth, `LotRefused`; the auction's shares
+ * split the winning bid, so a share of the box that burns burns nothing here). Its address names the seller, so an id
+ * is the seller's own. An NFT lot of another collection can be stopped or taken back by whoever controls that
+ * collection while the project holds it: its seller is paid only when it reaches the winner (`endAuctionIx`).
  */
 export declare function openAuctionIx({ seller, project, collection, tokenMetadata: tm, compressed, id, mint, args }: {
     args: any;
@@ -5097,23 +5232,45 @@ export declare function bidIx({ bidder, project, id, auction, amount, shown, lis
     keys: any[];
     data: Uint8Array<any>;
 };
+/** How an auction's end goes, as `end_auction`'s `ending` takes it. With no bid each is the same: the lot goes home. */
+export declare const ENDINGS: readonly string[];
 /**
- * Anyone ends auction `id` once it is over (its seller calls off one with no bid). Sold: the lot goes to the high
- * bidder (an item that is a collectible is minted to them at `pda.itemAsset(item, serial)`; a roll of a box is made
- * for them in an order at `prizeRollNonce(nonce)`, `nonce` being `prizeNonce(auction, last_bid_at)` by default, which `signer` pays for), the price
- * through the shares, the rest to whoever owned the lot (the seller of an NFT, the treasury for the project's item or
- * roll), however long after the end it is sent. With no bid, the lot goes home. `signer` opens any account the end pays into that is
- * not there. `item` is the decoded Item of an item lot; for an NFT lot, `collection` its Core collection now (the
- * project's when left out), `tokenMetadata` for a Token Metadata NFT, or `compressed` (after a `proveLeafIx`).
- * `hold` (anyone may; true for all, or a list of assets): an end that wouldn't fit otherwise (a compressed lot's long
- * proof, a hooked mint, many shares) makes the NFT lot a hold for whoever it goes to (its hold passed as `order`, no
- * 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.
+ * Anyone ends auction `id` once it is over (its seller calls off one with no bid). `auction` is the decoded Auction,
+ * `ending` one of `ENDINGS` (with no bid each is the same: the lot goes home to its seller, or stays where it is when it
+ * is proven gone). With a bid in:
+ *   'Deliver' (the default): the lot goes to the high bidder and the winning bid through the shares to whoever owned the
+ *     lot (the seller of an NFT, the treasury for the project's item or roll), in one instruction, however long after the
+ *     end it is sent. An item that is a collectible is minted to the winner at `pda.itemAsset(item, serial)`; a roll of a
+ *     box is made for them in an order at `prizeRollNonce(nonce)`, `nonce` being `prizeNonce(auction, last_bid_at)` by
+ *     default, which `signer` pays for. An NFT lot that can't move now fails the end, which waits: send it again later.
+ *     Once the lot went first (`auction.proceeds_owed` above 0), it pays what the bid still owes and closes the auction:
+ *     the auction's address stands in for the lot, then the shares' accounts, then a bid's NFTs to the seller.
+ *   'LotFirst': an NFT lot only, for an end too wide for one transaction (a compressed lot's long proof with many shares
+ *     and a hooked coin): the lot goes to the winner now and the whole bid is written as owed; a later 'Deliver' pays it.
+ *     Its accounts are the lot's piece and proof, then the tail: no shares, no winning NFT.
+ *   'CallOff': an NFT lot's sale, before the lot moved (`CantCallOff` after): the winning bid goes back to its bidder
+ *     (tokens into their account, or its NFTs, each moved or made a hold for them) and the lot home to its seller (moved,
+ *     or made a hold for them). Anyone may when the lot or an NFT of the bid is proven gone (its collection took it back
+ *     or burned it): that one stays gone. Otherwise only the project's owner or authority, for the project fee.
+ * `signer` opens any account the end pays into that is not there. `item` is the decoded Item of an item lot; for an NFT
+ * lot, `collection` its Core collection now, `tokenMetadata` for a Token Metadata NFT, or `compressed` (after a
+ * `proveLeafIx`: a compressed lot's record must be current whenever it is read, with no bid too). The lot's accounts
+ * also show whether the project still holds it: for a Token Metadata lot that left, `evidence` names the token account
+ * that holds it now, or its mint when it was burned. `held`: the kinds of a winning bid's NFTs (`auction.held`, in order:
+ * { collection, tokenMetadata, evidence }).
+ * `hold` (true for every NFT it may apply to, or a list of assets): a lot going home (no bid, or the sale called off) is
+ * made a hold for its seller (its hold passed as `order`, the lot's accounts only showing it is held); an NFT of a bid
+ * going back on a call-off, or paid to the seller after the lot went first, or to the treasury for the project's own
+ * lot, is made a hold for whoever it goes to (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. A sold lot is never made a hold (`LotRefused`), nor an NFT
+ * of a bid that buys a player's lot: the two move together, or the end waits.
  */
-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, evidence, held, hold, ending, reference: ref, nonce, holders, programs, extra, }: {
     auction: any;
     collection: any;
     compressed: any;
+    ending?: string | undefined;
+    evidence?: null | undefined;
     extra?: never[] | undefined;
     held?: never[] | undefined;
     hold?: boolean | undefined;
@@ -5220,19 +5377,34 @@ export declare function borrowIx({ borrower, project, id, offer, due, asset, col
 };
 /**
  * Anyone (`payer`: the borrower, a friend) repays a loan before it is due (`hold` the decoded Hold, with its debt): the
- * debt's `repay` goes to the lender, and the NFT is the borrower's again. Only money moves: anyone then sends the NFT
- * home with `releaseIx` (in the same transaction, or later: a repaid loan's release has no deadline). Free. `repay`: the
- * debt the payer was shown (`hold.debt.repay` as read): any other amount is refused (`TermsChanged`). `extra`: a
- * transfer hook's accounts.
+ * debt's `repay` goes to the lender. With `home` (the default), the NFT goes home to its borrower in the same
+ * instruction and the hold closes, its rent (and a Token Metadata NFT's emptied account's) to the borrower; an NFT that
+ * can't move now (frozen, its collection's rule refuses, a proof out of date) fails the whole call, and nobody pays.
+ * Without `home`, only the money moves: the hold becomes a plain one that is over, and anyone sends the NFT home with
+ * `releaseIx` whenever it can move (for an NFT frozen for now, so the loan does not fall due meanwhile). Free.
+ * The NFT is any kind: `collection` for a Core asset, `tokenMetadata` for a Token Metadata NFT (`into`: the borrower's
+ * account it goes into, when their associated one can't take it), `compressed` for a compressed one. Either way its
+ * accounts must show the project still holds it: the program takes no repayment for an NFT its collection took back
+ * or burned (`NotTheNft`), nor one nothing shows (`NotProven`). Going home, a compressed NFT is proven
+ * (`proveLeafIx`, in the same transaction) and its proof goes first after the repayment's accounts; the money alone
+ * passes its record and tree, and goes through when the record shows nothing, so prove it in the same transaction when
+ * that fits and the repayment of an NFT that is gone is refused. `repay`: the debt the payer was shown
+ * (`hold.debt.repay` as read): any other amount is refused (`TermsChanged`). `address`: the hold's, when its `free_at`
+ * changed since its loan named it. `extra`: a transfer hook's accounts.
  */
-export declare function repayIx({ payer, project, hold, repay, payerToken, programs, extra }: {
+export declare function repayIx({ payer, project, hold, repay, home, address, collection, tokenMetadata: tm, compressed, payerToken, programs, extra, }: {
+    address?: null | undefined;
+    collection: any;
+    compressed: any;
     extra?: never[] | undefined;
     hold: any;
+    home?: boolean | undefined;
     payer: any;
     payerToken: any;
     programs: any;
     project: any;
     repay: any;
+    tokenMetadata: any;
 }): {
     programId: string;
     keys: any[];

package/types/economy/check.d.mts

@@ -81,6 +81,11 @@ export declare function buySize(b: any, m: any, { detail, count }?: {
 /** The address a plan stands in for the owner's wallet before one connects (plan.mjs `placeholderContext`). Nobody
  * holds its key, and the approval page calls it "your wallet" until a wallet connects: no spec may name it. */
 export declare const STAND_IN_OWNER: string;
+/** How far off a time may land before the checker asks whether its unit is right: three years. The program
+ * takes any time a date holds; a time written in milliseconds lands thousands of years out and locks what waits on it. */
+export declare const FAR_SECONDS: number;
+/** A Unix time in words, in English: "14 March 2031". Past what a date can show, the year alone. */
+export declare function dateWords(seconds: any): string;
 /**
  * Checks an economy spec. `now` (Unix seconds) dates "publish".
  * Returns { ok, refusals: [{ code, where, message, fix }], warnings: [{ code, where, message, fix? }] }.