@xgamesfun/solana 0.26.4 → 0.27.1

package/types/play/index.d.ts

@@ -60,13 +60,14 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         settled: null;
         says: string;
     } | {
-        says?: undefined;
         order: any;
         won: any;
         assets: any;
         settled: any;
         parts?: any[] | undefined;
         asset?: any;
+        gone?: any[] | undefined;
+        says?: string | undefined;
     } | {
         signature: any;
         assets: any[];
@@ -80,13 +81,14 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
             settled: null;
             says: string;
         } | {
-            says?: undefined;
             order: any;
             won: any;
             assets: any;
             settled: any;
             parts?: any[] | undefined;
             asset?: any;
+            gone?: any[] | undefined;
+            says?: string | undefined;
         })[] | undefined;
     } | {
         orders: ({
@@ -98,70 +100,24 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
             settled: null;
             says: string;
         } | {
-            says?: undefined;
-            order: any;
-            won: any;
-            assets: any;
-            settled: any;
-            parts?: any[] | undefined;
-            asset?: any;
-        })[];
-        won: any[];
-        assets: any[];
-        parts: any[];
-    } | {
-        order: any;
-        settled: string;
-        says: string;
-        orders: ({
-            order: any;
-            settled: string;
-            says: string;
-        } | {
-            order: any;
-            settled: null;
-            says: string;
-        } | {
-            says?: undefined;
-            order: any;
-            won: any;
-            assets: any;
-            settled: any;
-            parts?: any[] | undefined;
-            asset?: any;
-        })[];
-        won: any[];
-        assets: any[];
-        parts: any[];
-    } | {
-        order: any;
-        settled: null;
-        says: string;
-        orders: ({
-            order: any;
-            settled: string;
-            says: string;
-        } | {
-            order: any;
-            settled: null;
-            says: string;
-        } | {
-            says?: undefined;
             order: any;
             won: any;
             assets: any;
             settled: any;
             parts?: any[] | undefined;
             asset?: any;
+            gone?: any[] | undefined;
+            says?: string | undefined;
         })[];
         won: any[];
         assets: any[];
         parts: any[];
     } | {
-        says?: undefined;
         order: any;
         settled: any;
         asset?: any;
+        gone?: any[] | undefined;
+        says?: string | undefined;
         orders: ({
             order: any;
             settled: string;
@@ -171,13 +127,14 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
             settled: null;
             says: string;
         } | {
-            says?: undefined;
             order: any;
             won: any;
             assets: any;
             settled: any;
             parts?: any[] | undefined;
             asset?: any;
+            gone?: any[] | undefined;
+            says?: string | undefined;
         })[];
         won: any[];
         assets: any[];
@@ -197,13 +154,14 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         settled: null;
         says: string;
     } | {
-        says?: undefined;
         order: any;
         won: any;
         assets: any;
         settled: any;
         parts?: any[] | undefined;
         asset?: any;
+        gone?: any[] | undefined;
+        says?: string | undefined;
     } | {
         signature: any;
         assets: any[];
@@ -217,13 +175,14 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
             settled: null;
             says: string;
         } | {
-            says?: undefined;
             order: any;
             won: any;
             assets: any;
             settled: any;
             parts?: any[] | undefined;
             asset?: any;
+            gone?: any[] | undefined;
+            says?: string | undefined;
         })[] | undefined;
     } | {
         orders: ({
@@ -235,70 +194,24 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
             settled: null;
             says: string;
         } | {
-            says?: undefined;
             order: any;
             won: any;
             assets: any;
             settled: any;
             parts?: any[] | undefined;
             asset?: any;
+            gone?: any[] | undefined;
+            says?: string | undefined;
         })[];
         won: any[];
         assets: any[];
         parts: any[];
     } | {
-        order: any;
-        settled: string;
-        says: string;
-        orders: ({
-            order: any;
-            settled: string;
-            says: string;
-        } | {
-            order: any;
-            settled: null;
-            says: string;
-        } | {
-            says?: undefined;
-            order: any;
-            won: any;
-            assets: any;
-            settled: any;
-            parts?: any[] | undefined;
-            asset?: any;
-        })[];
-        won: any[];
-        assets: any[];
-        parts: any[];
-    } | {
-        order: any;
-        settled: null;
-        says: string;
-        orders: ({
-            order: any;
-            settled: string;
-            says: string;
-        } | {
-            order: any;
-            settled: null;
-            says: string;
-        } | {
-            says?: undefined;
-            order: any;
-            won: any;
-            assets: any;
-            settled: any;
-            parts?: any[] | undefined;
-            asset?: any;
-        })[];
-        won: any[];
-        assets: any[];
-        parts: any[];
-    } | {
-        says?: undefined;
         order: any;
         settled: any;
         asset?: any;
+        gone?: any[] | undefined;
+        says?: string | undefined;
         orders: ({
             order: any;
             settled: string;
@@ -308,13 +221,14 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
             settled: null;
             says: string;
         } | {
-            says?: undefined;
             order: any;
             won: any;
             assets: any;
             settled: any;
             parts?: any[] | undefined;
             asset?: any;
+            gone?: any[] | undefined;
+            says?: string | undefined;
         })[];
         won: any[];
         assets: any[];
@@ -330,13 +244,14 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         settled: null;
         says: string;
     } | {
-        says?: undefined;
         order: any;
         won: any;
         assets: any;
         settled: any;
         parts?: any[] | undefined;
         asset?: any;
+        gone?: any[] | undefined;
+        says?: string | undefined;
     }>;
     /**
      * Finds the settle keys a page that closed left holding the player's SOL, and finishes their jobs: a key whose order
@@ -369,7 +284,9 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         key: string;
         swept: bigint;
     })[]>;
-    /** Gives an order's payment back once its time has come (a roll that failed or never came). */
+    /** Gives an order's payment back once its time has come (a roll that failed or never came). An NFT the project
+     * held for the roll goes back with it; one it no longer holds (its collection took it back or burned it) is not
+     * looked for, and the whole payment goes back all the same. */
     refund(orderAddress: any): Promise<any>;
     /** Asks the oracle for a roll a mission, a recipe or a prize made (its player or the project's keys may; the asker
      * pays the oracle). Its first ask fixes its odds: the player's profile, and an NFT they show (`shown`; by default
@@ -550,18 +467,31 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
             settled: null;
             says: string;
         } | {
-            says?: undefined;
             order: any;
             won: any;
             assets: any;
             settled: any;
             parts?: any[] | undefined;
             asset?: any;
+            gone?: any[] | undefined;
+            says?: string | undefined;
         } | undefined;
     }>;
     /**
      * Hands an NFT of any kind to the project until a time (a hold): `seconds` from now, or `{ until }` (Unix seconds).
      * The hold's address names its end. Returns { signature, freeAt }.
+     *
+     * Like every route that hands an NFT in (`stakeNft` in escrow, `borrow`, `enter`, `bid`, `listForSale`,
+     * `listForRent`, a ticket paid with an NFT, a box that rolls on one), it first clears what an earlier owner of the
+     * NFT left in this project: a hold or a listing that stayed open when whoever controls the NFT's collection took it
+     * out of the project's hands. Left open, such a record could take the NFT once the project holds it again. The
+     * player holds the NFT now, so the program closes each on that proof (a hold by `release`, a listing by
+     * `take_listing`, nothing sent or paid), in front of the deposit in the same transaction, or in a transaction of
+     * their own before it when the two do not fit one. The closes cost the player their transaction fee only: each
+     * record's rent goes to whoever that record names (a hold's payer, a listing's maker), never to the player. Only
+     * what can't be closed still refuses the deposit, in words (a listing whose rental still runs: the program keeps
+     * it until the rental has run); `acceptLeftover: true` goes ahead all the same. NFTs of the project's own
+     * collections are not read.
      */
     hold(asset: any, seconds: any, { acceptLeftover, ...others }?: Readonly<Record<string, any>>): Promise<{
         signature: any;
@@ -613,7 +543,9 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
      * borrower in the same instruction: one prompt. `repay`: the debt the payer was shown (`loan()`'s, in base units);
      * the program refuses any other (`TermsChanged`). An NFT its collection took back or burned while the project held
      * it is refused here, before anything is signed: the program takes no repayment for it, and the borrower keeps what
-     * they borrowed. When the NFT can't move now (frozen for now, or its collection refuses the move), or `home` is
+     * they borrowed. Such a loan is closed for nothing instead: `claims()` lists it for its borrower and its lender, and
+     * `claim` of it closes the hold (nothing is repaid, and the hold's rent goes back to whoever paid it). When the NFT
+     * can't move now (frozen for now, or its collection refuses the move), or `home` is
      * false, the money goes alone, so the loan does not fall due: the hold is then over, and anyone sends the NFT home
      * once it can move (`claims()` lists it). A compressed NFT is proven in the same transaction; the money alone for one
      * whose proof keeps going out of date goes without it. Returns { signature, home }, and `says` when the NFT waits.
@@ -644,7 +576,9 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
      * Bids `amount` (whole units) on an auction. The bid it tops goes back to its bidder in the same transaction
      * (the program opens their account again if they closed it, paid by this bidder). In SOL, only what the player's
      * wrapped-SOL account does not hold already is wrapped, and the account stays open: if this bid is topped, it comes
-     * back there.
+     * back there. In an auction of NFT bids, an NFT of the topped bid that the project no longer holds (its collection
+     * took it back or burned it) can't go back: the bid makes it a hold for its bidder and closes that hold on the
+     * proof in the same transaction, so a high bid with an NFT gone can still be topped.
      */
     bid(auctionKey: any, amount: any, { shown, listProof, nfts, acceptLeftover, ...others }?: Readonly<Record<string, any>>): Promise<any>;
     /**
@@ -659,23 +593,42 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
      * the sale is called off on that evidence, which anyone may: the bid goes back to its bidder (`{ calledOff: true }`).
      * With no bid, the lot goes home to its seller. An end too big for one transaction otherwise makes each NFT that may
      * be a hold one, and sends each on with a release after it (`releases`).
+     * An NFT that is gone is never sent, whatever its kind, and the result says so (`gone: true`, and `says`, what the
+     * end did in words): a lot gone with no bid stays where it is and the auction closes, its rent to its seller; a
+     * sale with the lot or an NFT of the bid gone is called off, and what the project still holds goes back; for the
+     * project's own lot, or a lot that went first, the end passes the bid's NFT that is gone over and pays the rest.
+     * A hold made at the end whose NFT goes before its release is closed on the proof: its entry in `releases` is
+     * then `{ asset, gone: true, closed }`, `closed` the signature.
      */
     endAuction(auctionKey: any, { holders, ...others }?: Readonly<Record<string, any>>): Promise<{
-        says?: undefined;
         owedPaid: any;
         waiting?: undefined;
+        gone: boolean;
+        says: string;
+        paid: any;
+    } | {
+        owedPaid: any;
+        waiting?: undefined;
+        gone?: undefined;
+        says?: undefined;
         paid: any;
-        releases?: undefined;
     } | {
         owedPaid: any;
         waiting?: undefined;
         paid: null;
         says: string;
-        releases?: undefined;
     } | {
-        says?: undefined;
         owedPaid: any;
         waiting?: undefined;
+        gone: boolean;
+        says: string;
+        paid: any;
+        releases: any[];
+    } | {
+        owedPaid: any;
+        waiting?: undefined;
+        gone?: undefined;
+        says?: undefined;
         paid: any;
         releases: any[];
     } | {
@@ -687,7 +640,6 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         waiting: boolean;
         says: string;
     } | {
-        says?: undefined;
         winner?: any;
         asset?: any;
         waiting?: undefined;
@@ -702,23 +654,34 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
             settled: null;
             says: string;
         } | {
-            says?: undefined;
             order: any;
             won: any;
             assets: any;
             settled: any;
             parts?: any[] | undefined;
             asset?: any;
+            gone?: any[] | undefined;
+            says?: string | undefined;
         } | undefined;
-    } | {
         says?: undefined;
+    } | {
         winner?: any;
         asset?: any;
         waiting?: undefined;
         signature: any;
         lotFirst: boolean;
+        gone: boolean;
+        says: string;
+        paid: any;
+    } | {
+        winner?: any;
+        asset?: any;
+        waiting?: undefined;
+        signature: any;
+        lotFirst: boolean;
+        gone?: undefined;
+        says?: undefined;
         paid: any;
-        releases?: undefined;
     } | {
         winner?: any;
         asset?: any;
@@ -727,14 +690,24 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         lotFirst: boolean;
         paid: null;
         says: string;
-        releases?: undefined;
     } | {
-        says?: undefined;
         winner?: any;
         asset?: any;
         waiting?: undefined;
         signature: any;
         lotFirst: boolean;
+        gone: boolean;
+        says: string;
+        paid: any;
+        releases: any[];
+    } | {
+        winner?: any;
+        asset?: any;
+        waiting?: undefined;
+        signature: any;
+        lotFirst: boolean;
+        gone?: undefined;
+        says?: undefined;
         paid: any;
         releases: any[];
     }>;
@@ -745,21 +718,34 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
      * an NFT of the winning bid is gone (`endAuction` does it then). Refused once the lot went to its winner (`CantCallOff`).
      */
     callOffSale(auctionKey: any, { ...others }?: Readonly<Record<string, any>>): Promise<{
-        says?: undefined;
         owedPaid: any;
         waiting?: undefined;
+        gone: boolean;
+        says: string;
+        paid: any;
+    } | {
+        owedPaid: any;
+        waiting?: undefined;
+        gone?: undefined;
+        says?: undefined;
         paid: any;
-        releases?: undefined;
     } | {
         owedPaid: any;
         waiting?: undefined;
         paid: null;
         says: string;
-        releases?: undefined;
     } | {
-        says?: undefined;
         owedPaid: any;
         waiting?: undefined;
+        gone: boolean;
+        says: string;
+        paid: any;
+        releases: any[];
+    } | {
+        owedPaid: any;
+        waiting?: undefined;
+        gone?: undefined;
+        says?: undefined;
         paid: any;
         releases: any[];
     } | {
@@ -771,7 +757,6 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         waiting: boolean;
         says: string;
     } | {
-        says?: undefined;
         winner?: any;
         asset?: any;
         waiting?: undefined;
@@ -786,23 +771,34 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
             settled: null;
             says: string;
         } | {
-            says?: undefined;
             order: any;
             won: any;
             assets: any;
             settled: any;
             parts?: any[] | undefined;
             asset?: any;
+            gone?: any[] | undefined;
+            says?: string | undefined;
         } | undefined;
-    } | {
         says?: undefined;
+    } | {
+        winner?: any;
+        asset?: any;
+        waiting?: undefined;
+        signature: any;
+        lotFirst: boolean;
+        gone: boolean;
+        says: string;
+        paid: any;
+    } | {
         winner?: any;
         asset?: any;
         waiting?: undefined;
         signature: any;
         lotFirst: boolean;
+        gone?: undefined;
+        says?: undefined;
         paid: any;
-        releases?: undefined;
     } | {
         winner?: any;
         asset?: any;
@@ -811,14 +807,24 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         lotFirst: boolean;
         paid: null;
         says: string;
-        releases?: undefined;
     } | {
-        says?: undefined;
         winner?: any;
         asset?: any;
         waiting?: undefined;
         signature: any;
         lotFirst: boolean;
+        gone: boolean;
+        says: string;
+        paid: any;
+        releases: any[];
+    } | {
+        winner?: any;
+        asset?: any;
+        waiting?: undefined;
+        signature: any;
+        lotFirst: boolean;
+        gone?: undefined;
+        says?: undefined;
         paid: any;
         releases: any[];
     }>;
@@ -839,24 +845,76 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
      * `maxPeriods` at once. Nobody can end a rental early; the next renter takes it once one is over, until it is unlisted.
      */
     listForRent(asset: any, { price, lasts, maxPeriods, currency, shares, acceptLeftover, ...others }?: Readonly<Record<string, any>>): Promise<any>;
-    /** The listing of `asset` (one account read), or null: { listing, asset, maker, mint, deal, renter, until }. */
+    /**
+     * The listing of `asset` (one account read), or null: { listing, asset, maker, mint, deal, renter, until }. One more
+     * read says whether the project still holds the NFT: when whoever controls its collection took it back or burned
+     * it, the listing is flagged `gone` with `says`, what that means in words. There is then nothing to buy or rent,
+     * and the listing can be closed for nothing (`unlist` by its maker, `closeGone` by anyone).
+     */
     listing(asset: any): Promise<any>;
     /** Who rents `asset` now (one account read, then a check that the project still holds it), or null. */
     rentedTo(asset: any): Promise<any>;
-    /** The project's listings, a maker's (`maker`) or all: one search of the program's accounts. */
+    /**
+     * The project's listings, a maker's (`maker`) or all: one search of the program's accounts, then one read of the
+     * listed NFTs together, which flags a listing `gone` (with `says`) when the project no longer holds its NFT: a
+     * Core asset held by another or burned, a Token Metadata NFT whose token left the project's account. A compressed
+     * NFT is not read here (an indexer's answer for each): `listing(asset)` says it for one.
+     */
     listings({ maker, ...others }?: Readonly<Record<string, any>>): Promise<any>;
     /**
      * Buys a listed NFT at the terms the player saw: `listing`, as `listing()` or `listings()` showed it. It is
      * required: the terms signed are those, never the listing read now, so a price or a share changed since is refused.
+     * A listing whose NFT the project no longer holds (its collection took it back or burned it) is refused in words
+     * before anything is signed: nothing is there to buy, and anyone can close that listing for nothing (`closeGone`).
      */
     buyListing(asset: any, { listing, ...others }?: Readonly<Record<string, any>>): Promise<any>;
     /**
      * Rents a listed NFT for `periods` periods, at the terms the player saw: `listing`, as `listing()` or `listings()`
-     * showed it (required, as for `buyListing`).
+     * showed it (required, as for `buyListing`). One whose NFT the project no longer holds is refused in words, as
+     * `buyListing` refuses it.
      */
     rentListing(asset: any, { periods, listing, ...others }?: Readonly<Record<string, any>>): Promise<any>;
-    /** Takes a listed NFT home (its maker). While a rental runs it only stops the listing; call again once it is over. */
+    /**
+     * Takes a listed NFT home (its maker). While a rental runs it only stops the listing; call again once it is over.
+     * A listing whose NFT the project no longer holds (its collection took it back or burned it) closes without it, on
+     * that proof: nothing is sent, and the listing's rent comes back to its maker. While a rental of it still runs,
+     * that close too only stops the listing, and closes it once the rental has run.
+     */
     unlist(asset: any): Promise<any>;
+    /**
+     * Closes what this project still records of an NFT it no longer holds (`asset`: whoever controls its collection
+     * took it out of the project's hands or burned it): each hold of it (`release`), its listing (`take_listing`),
+     * and its row on each of the project's stashes that lists it (`stash`, out), on the proof that it is gone. Anyone
+     * may, at any time, also while a hold runs and for a loan before it is due: nothing is sent or paid, and a loan's
+     * debt ends unpaid. The sender pays the transaction's fee only; each record's rent goes to whoever that record
+     * names (a hold's payer, a listing's maker), never to the sender, and a stash keeps the rent its row no longer
+     * needs (it goes to the sender only when that is one of the project's keys). With its row off a stash, no roll
+     * draws the NFT, and a prize that names it is passed over in place of failing on an NFT that can't move.
+     * What is left is in `waits`: a listing whose rental still runs (the program keeps a running rental, and the
+     * listing closes once it has run), and a lottery's own stash that lists the NFT (`kind` 'lottery-stash', with its
+     * `lottery`, the lottery's id): only the project's keys take a row out of that one (`unraffle`), gone or not.
+     * Refused in words, with nothing sent, when the project still holds the NFT or nothing shows it gone.
+     * Besides one search of the NFT's holds, this makes one search of the project's stashes, which returns every
+     * stash of the project whole (36 bytes for each NFT a stash lists): a stash's rows have no fixed place to look in.
+     * Returns { signature, closed: [{ kind, address }], unstashed: [{ address, id }], waits: [{ kind, address }] }:
+     * `closed` the holds and the listing it closed, `unstashed` the project's stashes it took the row off;
+     * `signature` is null when there was nothing to close.
+     */
+    closeGone(asset: any): Promise<{
+        signature: any;
+        closed: {
+            kind: any;
+            address: any;
+        }[];
+        unstashed: {
+            address: any;
+            id: number;
+        }[];
+        waits: {
+            kind: any;
+            address: any;
+        }[];
+    }>;
     /**
      * The project's owner raffles an NFT they hold, as lottery `id`: the NFT goes into the lottery's own stash, where
      * nothing but the lottery can take it while a place names it; the winner gets it before any ticket money moves.
@@ -867,7 +925,13 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
      * owner they are.
      */
     raffle(id: any, nft: any, { price, currency, drawsAt, minSold, perWallet, shares, ...others }?: Readonly<Record<string, any>>): Promise<any>;
-    /** The raffle's owner takes the NFT back out of lottery `id`'s own stash once nothing promises it (the lottery ended, or no place names it). */
+    /**
+     * The raffle's owner takes the NFT back out of lottery `id`'s own stash once nothing promises it (the lottery
+     * ended, or no place names it). When the project no longer holds the NFT (its collection took it back or burned
+     * it), only its row comes off the stash, on that proof: nothing is sent, and the owner gets no NFT back. Only the
+     * project's owner or authority may, gone or not: a lottery's own stash is theirs alone (`NotAuthority` for anyone
+     * else; `closeGone` leaves it and says so). Returns the signature.
+     */
     unraffle(id: any, nft: any): Promise<any>;
     /** Turns what waits in the player's wrapped-SOL account (a bid that was topped) into plain SOL. */
     unwrap(): Promise<any>;
@@ -899,17 +963,187 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
     }[]>;
     /**
      * What this player can finish now, themselves: a box to settle or refund, a contest entry to claim, a held
-     * collectible to take home, an auction they won (or one off by the clock: their bid back), a lottery place they
+     * collectible to take home, a hold of theirs or a loan they made or took whose NFT the project no longer holds (its
+     * collection took it back or burned it: listed at any time, also while the hold runs, as a `release` flagged
+     * `gone`, whose claim closes the hold and sends nothing), an auction they won (or one off by the clock: their bid back), a lottery place they
      * won, a draw that is due (anyone may reveal it, or ask again when the oracle never answered; it takes 0.0008
      * SOL), and a drawn lottery's unpaid places, which anyone may pay so the next round can open. [{ kind, says, … }];
      * a winner's first claim of a contest of tokens carries `potUnits` and `prizeUnits`, its part as the decision wrote
      * it (base units, as text). Pass one to `claim`.
+     * A `pull`, a `contest` or an `auction` whose claim would hand out an NFT the project no longer holds is flagged
+     * `gone` too, with `assets` (those NFTs) and `says`, what the claim does about each in words: a ticket's NFT, a
+     * place's NFT, a contest's entry or a loser's NFT picked is not sent anywhere and its part closes; an auction with
+     * its lot or an NFT of its winning bid gone is called off, or ended without it. Show `says` before the player signs.
      */
-    claims(): Promise<any[]>;
+    claims(): Promise<({
+        key?: undefined;
+        tree?: undefined;
+        gone?: undefined;
+        kind: string;
+        order: any;
+        says: string;
+        assets?: undefined;
+        round?: undefined;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        tree?: undefined;
+        order?: undefined;
+        kind: string;
+        id: any;
+        side: any;
+        gone: boolean;
+        assets: any[];
+        says: string;
+        potUnits?: string | undefined;
+        prizeUnits?: string | undefined;
+        round?: undefined;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        tree?: undefined;
+        gone?: undefined;
+        order?: undefined;
+        kind: string;
+        id: any;
+        side: any;
+        says: string;
+        potUnits?: string | undefined;
+        prizeUnits?: string | undefined;
+        assets?: undefined;
+        round?: undefined;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        tree?: undefined;
+        order?: undefined;
+        kind: string;
+        asset: any;
+        hold: any;
+        gone: boolean;
+        says: string;
+        assets?: undefined;
+        round?: undefined;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        tree?: undefined;
+        gone?: undefined;
+        order?: undefined;
+        kind: string;
+        asset: any;
+        hold: any;
+        says: string;
+        assets?: undefined;
+        round?: undefined;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        gone?: undefined;
+        order?: undefined;
+        kind: string;
+        asset: string;
+        tree: string;
+        says: string;
+        assets?: undefined;
+        round?: undefined;
+        table?: undefined;
+    } | {
+        tree?: undefined;
+        order?: undefined;
+        kind: string;
+        key: any;
+        gone: boolean;
+        assets: any[];
+        says: string;
+        round?: undefined;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        tree?: undefined;
+        gone?: undefined;
+        order?: undefined;
+        assets?: undefined;
+        kind: string;
+        key: any;
+        says: string;
+        round?: undefined;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        tree?: undefined;
+        gone?: undefined;
+        order?: undefined;
+        assets?: undefined;
+        kind: string;
+        key: any;
+        round: any;
+        says: string;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        tree?: undefined;
+        order?: undefined;
+        kind: string;
+        key: any;
+        round: any;
+        pulls: any;
+        gone: boolean;
+        assets: any[];
+        says: string;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        tree?: undefined;
+        gone?: undefined;
+        order?: undefined;
+        assets?: undefined;
+        kind: string;
+        key: any;
+        round: any;
+        pulls: any;
+        says: string;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        tree?: undefined;
+        gone?: undefined;
+        order?: undefined;
+        assets?: undefined;
+        round?: undefined;
+        kind: string;
+        asset: any;
+        says: string;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        tree?: undefined;
+        gone?: undefined;
+        order?: undefined;
+        assets?: undefined;
+        round?: undefined;
+        asset?: undefined;
+        kind: string;
+        table: any;
+        says: string;
+    })[]>;
     /**
-     * Finishes one of `claims()`, signed by this player. Returns the signature. A winner of a contest of NFTs picks
-     * which loser's NFT they take (`{ take: asset }`, the NFT of a losing entry that still holds one; the first found by default):
-     * only the winner can, while any are left.
+     * Finishes one of `claims()`, signed by this player. Returns the signature. A `release` flagged `gone` closes its
+     * hold on the proof that the project no longer holds the NFT: nothing is sent, the hold's rent goes back to whoever
+     * paid it, and a loan's debt ends unpaid. A winner of a contest of NFTs picks
+     * which loser's NFT they take (`{ take: asset }`, the NFT of a losing entry that still holds one; by default the
+     * first found that the project still holds): only the winner can, while any are left.
+     * An NFT a lottery's round or a contest owes that the project no longer holds (its collection took it back or
+     * burned it) is not sent anywhere, and the claim still finishes. A ticket whose price sends it on (burned, given,
+     * stashed) settles on the proof with nothing moved. A ticket going back to its buyer, a place's NFT and a
+     * contest's NFT are only handed out by the program, which reads nothing first: the claim has it make a hold of
+     * that NFT (`["hold", nft, 0]`) and closes that hold on the proof right after, in the same transaction when it
+     * fits. The signer pays that hold's rent and gets it back at once. The program's receipts for it are those of a
+     * hold made (`Held`, and `PrizeGiven` for a place's prize) and then `NftGone`: no `Released`.
      */
     claim(c: any, { take, build, ...others }?: Readonly<Record<string, any>>): Promise<any>;
     /**