@xgamesfun/solana 0.27.0 → 0.27.2

package/types/play/index.d.ts

@@ -576,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>;
     /**
@@ -591,22 +593,41 @@ 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<{
         owedPaid: any;
         waiting?: undefined;
+        gone: boolean;
+        says: string;
         paid: any;
+    } | {
+        owedPaid: any;
+        waiting?: undefined;
+        gone?: undefined;
         says?: undefined;
-        releases?: undefined;
+        paid: any;
     } | {
         owedPaid: any;
         waiting?: undefined;
         paid: null;
         says: string;
-        releases?: 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[];
@@ -649,9 +670,18 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         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;
-        releases?: undefined;
+        paid: any;
     } | {
         winner?: any;
         asset?: any;
@@ -660,13 +690,23 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         lotFirst: boolean;
         paid: null;
         says: string;
-        releases?: 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[];
@@ -680,18 +720,31 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
     callOffSale(auctionKey: any, { ...others }?: Readonly<Record<string, any>>): Promise<{
         owedPaid: any;
         waiting?: undefined;
+        gone: boolean;
+        says: string;
         paid: any;
+    } | {
+        owedPaid: any;
+        waiting?: undefined;
+        gone?: undefined;
         says?: undefined;
-        releases?: undefined;
+        paid: any;
     } | {
         owedPaid: any;
         waiting?: undefined;
         paid: null;
         says: string;
-        releases?: 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[];
@@ -734,9 +787,18 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         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;
-        releases?: undefined;
+        paid: any;
     } | {
         winner?: any;
         asset?: any;
@@ -745,13 +807,23 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         lotFirst: boolean;
         paid: null;
         says: string;
-        releases?: 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[];
@@ -811,14 +883,22 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
     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`) and its listing (`take_listing`),
-     * 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. A
-     * listing whose rental still runs is left (`waits`): the program keeps a running rental, and the listing closes
-     * once it has run. Refused in words, with nothing sent, when the project still holds the NFT or nothing shows it
-     * gone. Returns { signature, closed: [{ kind, address }], waits: [{ kind, address }] }; `signature` is null when
-     * there was nothing to close.
+     * 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;
@@ -826,6 +906,10 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
             kind: any;
             address: any;
         }[];
+        unstashed: {
+            address: any;
+            id: number;
+        }[];
         waits: {
             kind: any;
             address: any;
@@ -841,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>;
@@ -880,15 +970,20 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
      * 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<({
         key?: undefined;
         tree?: undefined;
+        gone?: undefined;
         kind: string;
         order: any;
         says: string;
+        assets?: undefined;
         round?: undefined;
-        pulls?: undefined;
         asset?: undefined;
         table?: undefined;
     } | {
@@ -898,11 +993,27 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         kind: string;
         id: any;
         side: any;
+        gone: boolean;
+        assets: any[];
         says: string;
         potUnits?: string | undefined;
         prizeUnits?: string | undefined;
         round?: undefined;
-        pulls?: 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;
     } | {
@@ -914,48 +1025,63 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         hold: any;
         gone: boolean;
         says: string;
+        assets?: undefined;
         round?: undefined;
-        pulls?: undefined;
         table?: undefined;
     } | {
         key?: undefined;
         tree?: undefined;
+        gone?: undefined;
         order?: undefined;
         kind: string;
         asset: any;
         hold: any;
         says: string;
+        assets?: undefined;
         round?: undefined;
-        pulls?: 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;
-        pulls?: undefined;
+        asset?: undefined;
         table?: undefined;
     } | {
         tree?: undefined;
+        gone?: undefined;
         order?: undefined;
+        assets?: undefined;
         kind: string;
         key: any;
         says: string;
         round?: undefined;
-        pulls?: undefined;
         asset?: undefined;
         table?: undefined;
     } | {
         tree?: undefined;
+        gone?: undefined;
         order?: undefined;
+        assets?: undefined;
         kind: string;
         key: any;
         round: any;
         says: string;
-        pulls?: undefined;
         asset?: undefined;
         table?: undefined;
     } | {
@@ -965,15 +1091,30 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
         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;
-        pulls?: undefined;
         kind: string;
         asset: any;
         says: string;
@@ -981,9 +1122,10 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
     } | {
         key?: undefined;
         tree?: undefined;
+        gone?: undefined;
         order?: undefined;
+        assets?: undefined;
         round?: undefined;
-        pulls?: undefined;
         asset?: undefined;
         kind: string;
         table: any;
@@ -993,8 +1135,15 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, ke
      * 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; the first found by default):
-     * only the winner can, while any are left.
+     * 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>;
     /**