@xgamesfun/solana 0.20.1 → 0.25.0

package/types/play/index.d.ts

@@ -1,7 +1,12 @@
-/** A signer from a Wallet Standard wallet and one of its accounts: the wallet signs, the app sends. */
+/**
+ * A signer from a Wallet Standard wallet and one of its accounts: the wallet signs, the app sends. With the wallet's
+ * `solana:signMessage`, also `signMessage(bytes)`: the app's settle keys are made from one signature of it a session,
+ * so a page that closes can make them again (`recover`).
+ */
 export declare function walletStandardSigner(wallet: any, account: any, chain?: string): {
     address: any;
     signTransaction(wire: any): Promise<any>;
+    signMessage?: ((message: any) => Promise<any>) | undefined;
 };
 /**
  * An amount in whole units of a token ("12", "0.5", or a number) in its base units. Only a plain decimal is taken, with
@@ -13,9 +18,18 @@ export declare const units: (amount: any, decimals: any) => bigint;
  * The player's side of a live economy. `rpc` may be given instead of `rpcUrl` (any object with the client's rpc
  * methods: accounts, account, latestBlockhash, send, confirm, programAccounts, and call(method, params), the raw JSON
  * RPC request the devnet check, the slot and the compressed-NFT reads go through). `now` is the clock auctions are read
- * by (Unix seconds). Devnet only (`devnetOnly`): mainnet waits for an audit.
+ * by (Unix seconds). Devnet only (`devnetOnly`): mainnet waits for an audit. `keyStore`: where a settle key that can't
+ * be made again from the wallet's signature is kept, encrypted (`browserStore()` in a browser; null keeps keys in memory
+ * only).
  */
-export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }: {
+export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now, keyStore, }: {
+    keyStore?: {
+        get: (k: any) => string | null;
+        set: (k: any, v: any) => void;
+        remove: (k: any) => void;
+        keys: () => (string | null)[];
+        cryptoKey: () => any;
+    } | null | undefined;
     now?: (() => number) | undefined;
     programs?: {} | undefined;
     rpc?: null | undefined;
@@ -27,7 +41,8 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
     readonly address: any;
     /** The shop: every item with a price (or free), its price now and what is left. */
     shop(): Promise<any>;
-    /** The boxes: price now and each outcome's chance. */
+    /** The boxes: price now, each outcome's chance as written, and what the box does once an outcome runs out
+     * (`whenOut`: 'stopSales', it isn't sold until restocked; 'drawLeft', it draws among what is left). */
     boxes(): Promise<any>;
     /**
      * Buys a shop item, in one transaction (`buy`: the price split and the item given at once). A listing that rolls
@@ -48,15 +63,128 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
         won: any;
         assets: any;
         settled: any;
+        parts?: any[] | undefined;
         asset?: any;
     } | {
         signature: any;
-        assets: any;
+        assets: any[];
+        asset?: any;
+        rolls?: ({
+            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;
+        })[] | undefined;
+    } | {
+        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: 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;
+        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[];
     }>;
     /**
      * Opens a box (shows a collectible for its gate or odds when given): a box that needs no roll is bought at once
-     * (`buy`); one that rolls waits for the roll and collects it.
+     * (`buy`); one that rolls waits for the roll and collects it, settling a pack in as many parts as it needs. `count`
+     * opens several packs in one purchase: one wallet prompt and one oracle answer (`maxPrice` is a pack's).
      */
     openBox(boxKey: any, options?: {}): Promise<{
         order: any;
@@ -72,11 +200,123 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
         won: any;
         assets: any;
         settled: any;
+        parts?: any[] | undefined;
         asset?: any;
     } | {
         signature: any;
-        assets: any;
+        assets: any[];
         asset?: any;
+        rolls?: ({
+            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;
+        })[] | undefined;
+    } | {
+        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: 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;
+        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[];
     }>;
     /** Collects an order opened earlier (its roll arrived after the app stopped waiting). */
     collect: (orderAddress: any, options?: {}) => Promise<{
@@ -93,11 +333,45 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
         won: any;
         assets: any;
         settled: any;
+        parts?: any[] | undefined;
         asset?: any;
     }>;
+    /**
+     * Finds the settle keys a page that closed left holding the player's SOL, and finishes their jobs: a key whose order
+     * has rolled settles it (no prompt); one whose order is gone, failed or due its refund sends its SOL back; one whose
+     * order still waits for its roll keeps it for later. Each key is made again from the wallet's signature (asked once
+     * a session, `walletStandardSigner`'s `signMessage`), or read from the page's storage (`keyStore`) when the wallet
+     * signs no messages. Returns [{ name, key, settled } | { name, key, swept } | { name, key, waiting }].
+     */
+    recover(): Promise<({
+        name: null;
+        key: string;
+        error: any;
+        waiting?: undefined;
+        swept?: undefined;
+    } | {
+        name: null;
+        key: string;
+        settled: any;
+        won: any;
+        waiting?: undefined;
+        swept?: undefined;
+    } | {
+        name: null;
+        key: string;
+        waiting: any;
+        swept?: undefined;
+    } | {
+        waiting?: undefined;
+        name: null;
+        key: string;
+        swept: bigint;
+    })[]>;
     /** Gives an order's payment back once its time has come (a roll that failed or never came). */
     refund(orderAddress: any): Promise<any>;
-    /** Asks the oracle for a roll a mission, a recipe or a prize made (anyone may; the asker pays the oracle). */
+    /** Asks the oracle for a roll a mission, a recipe or a prize made (anyone may; the asker pays the oracle). On a box
+     * with nothing in stock only the order's player may ask, a slot after it was made or last asked, and that ends the
+     * roll there with nothing, no oracle (a lot its winner paid for fails, for its refund). */
     askRoll: (orderAddress: any) => Promise<any>;
     /**
      * Pays a payment of the economy (an entry, an attempt, a tip). `amount`: what the player chose, in whole units, for
@@ -117,7 +391,20 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
      * which `buyTickets` takes as the terms the player was shown. A lottery not written yet (a raffle still to open)
      * has a null price.
      */
-    lotteries(): Promise<any>;
+    lotteries(): Promise<{
+        key: any;
+        name: any;
+        price: string | null;
+        priceUnits: any;
+        currency: any;
+        status: any;
+        round: any;
+        sold: any;
+        drawsAt: number | null;
+        nftTicket: boolean;
+        incarnation: any;
+        revision: any;
+    }[]>;
     /**
      * Buys `count` tickets of a lottery, on the terms the player was shown: `listing`, the lottery as `lotteries()`
      * showed it (a lottery changed since, its price or anything else, is refused rather than paid), or `maxPrice`, the
@@ -142,8 +429,7 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
     stake(farmKey: any, amount: any, tier?: number, { shown, extra, transfers, ...others }?: Readonly<Record<string, any>>): Promise<any>;
     /**
      * Takes `amount` out once its lock has run (0: only rewards); `forfeit` gives up rewards that cannot move. Before the
-     * lock, a tier with an early exit lets it leave for its fee, and gives up what the seat is owed; in a farm that
-     * unbonds, what is taken out waits first (`withdraw` takes it out once free).
+     * lock, a tier with an early exit lets it leave for its fee, keeping what the seat was credited.
      */
     unstake(farmKey: any, amount?: number, { forfeit, extra, transfers, ...others }?: Readonly<Record<string, any>>): Promise<any>;
     /**
@@ -159,12 +445,28 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
      * which `collect` then finishes.
      */
     unstakeNft(farmKey: any, asset: any, { forfeit, extra, transfers, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    /**
+     * What farm `farmKey` has to walk: `{ ends, needsWalk, parts }`, the times its seats stop earning it has passed and not
+     * yet credited up to, whether a move can no longer do them in its own transaction, and how many transactions
+     * `walkFarm` would take. Every move walks them first; nothing is lost however long they wait.
+     */
+    farmWalk(farmKey: any): Promise<{
+        ends: any;
+        needsWalk: boolean;
+        parts: number;
+    }>;
+    /**
+     * Walks a farm up to now in parts (`walk_farm`), for one that has passed more ends than a move can walk: one transaction
+     * for every `loot.WALK_PER_TX` ends, oldest first. Anyone may send it, and it costs only the network fee. Returns their
+     * signatures, none when there is nothing to walk.
+     */
+    walkFarm(farmKey: any, { perTx, ...others }?: Readonly<Record<string, any>>): Promise<any[]>;
     /**
      * Writes what a staked collectible has grown (a farm with `growth`: its points and level, on it or in its Sheet)
      * and reads its boosts again. Anyone may send it; the player pays for what the write adds. `by`: the collectible,
      * or the player for their token seat's booster.
      */
-    refresh(farmKey: any, by: any, { extra, transfers, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    refresh(farmKey: any, by: any, { extra, ...others }?: Readonly<Record<string, any>>): Promise<any>;
     /**
      * Collects what a seat owes (the player's own, or one of their collectibles' seats). In a farm that watches, it
      * shows the seat's NFT is still theirs: the Core asset, or their token account of a Token Metadata NFT.
@@ -172,18 +474,16 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
     harvest(farmKey: any, by?: any, { compound, extra, transfers, ...others }?: Readonly<Record<string, any>>): Promise<any>;
     /**
      * Adds what a token seat is owed to its stake, without restarting its lock (a farm of tokens whose rewards are the
-     * staked token). The farm's toll, if any, is taken first.
+     * staked token).
      */
     compound(farmKey: any, opts?: {}): Promise<any>;
-    /** Takes out the tokens whose unbonding wait is over (a farm with `unbond`), and what the seat is owed. */
-    withdraw(farmKey: any, opts?: {}): Promise<any>;
     /**
      * The player's seats in a farm (the wallet's, or `player`'s): each one's NFT (`asset`, null for a token seat with
      * no booster), what it holds staked (`amount`, in whole units of the staked token, a number for display that can
      * round past 2^53 base units; `amountUnits`, in base units exactly, a bigint; 1 for an NFT), its tier, when it
      * came in (`since`) and when its lock is over (`freeAt`, unix seconds; null when the NFT says it, `lockKey`), its
-     * boost in percent, and what it is owed now: `waiting` (whole units of the rewards, `rewards` their token) and
-     * `owedUnits` (base units). What it is owed is the program's own sum, from a refresh of the seat dry-run on the
+     * boost in percent, until when it earns (`earnsUntil`, unix seconds, null for no end: a tier's term, an upkeep), and
+     * what it is owed now: `waiting` (whole units of the rewards, `rewards` their token) and `owedUnits` (base units). What it is owed is the program's own sum, from a refresh of the seat dry-run on the
      * network (nothing is signed or sent): what the farm released or its rate paid since its last move is in it, by the
      * farm's rounding. When the dry run fails, it is what the seat was last credited, and `counted` is false.
      * One search of the chain, and one dry run per seat: read it when the page opens and after a stake or a harvest.
@@ -200,6 +500,7 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
         rewards: any;
         waiting: string;
         owedUnits: bigint;
+        earnsUntil: number | null;
         counted: boolean;
     }[]>;
     /** The recipes: whether each is on, and its version now (what `craft` takes as the terms the player was shown). */
@@ -208,12 +509,30 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
      * Crafts a recipe, handing in `assets` (the collectibles it burns or uses, in the recipe's order). `version`: the
      * recipe's version the page showed the player (`recipes()`, or the listing itself as `listing`), so a recipe the
      * owner changed since is refused rather than crafted on terms the player never saw. It is required: the version
-     * read now is never signed in its place.
+     * read now is never signed in its place. `extra`: the tail a Core collection's plugins need when the craft moves or
+     * rolls on a Core NFT (sent after the Memo program's account, as on every other Core move).
      */
-    craft(recipeKey: any, assets?: any[], times?: number, { version, listing, ...others }?: Readonly<Record<string, any>>): Promise<{
+    craft(recipeKey: any, assets?: any[], times?: number, { version, listing, extra, ...others }?: Readonly<Record<string, any>>): Promise<{
         signature: any;
         made: any;
         roll?: any;
+        rolled?: {
+            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;
+        } | undefined;
     }>;
     /**
      * Hands an NFT of any kind to the project until a time (a hold): `seconds` from now, or `{ until }` (Unix seconds).
@@ -251,6 +570,30 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
         due: any;
         hold: any;
     }>;
+    /**
+     * The loan on `asset` (held until `due`), as a page shows it before anyone repays: { lender, mint, repay (base units),
+     * due, paid }. `repay` is what `repay` then takes as the amount shown. Null when it holds no loan.
+     */
+    loan(asset: any, due: any): Promise<{
+        lender: any;
+        mint: any;
+        repay: bigint;
+        due: number;
+        borrower: any;
+    } | null>;
+    /**
+     * Repays the loan on `asset` (held until `due`), the player's own or a friend's, then sends the NFT home to its
+     * borrower. `repay`: the debt the payer was shown (`loan()`'s, in base units); the program refuses any other
+     * (`TermsChanged`). The repay goes in the wallet's transaction alone, with what it opens (the borrower's Token
+     * Metadata account), so a release that fails never undoes a repay that must land before the loan is due; the same
+     * transaction funds a throwaway key that sends the release (anyone may), a pNFT's or a compressed NFT's too: the key
+     * is funded for what that release opens (a pNFT's token account and record, a compressed NFT's proof record, which
+     * comes back in the same transaction). Returns { signature, released }.
+     */
+    repay(asset: any, due: any, { repay, extra, ...others }?: Readonly<Record<string, any>>): Promise<{
+        signature: any;
+        released: any;
+    }>;
     /**
      * Backs `side` of contest number `id` (the authority opens contests while the project runs) with `amount`; a contest
      * of NFTs takes one of the player's NFTs that passes its rule instead (`nft`, its address), held until it is
@@ -273,17 +616,45 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
     /**
      * Ends an auction that is over (anyone can; the winner usually does): the lot to the highest bidder, a new
      * collectible minted for them at the address its item and serial name, however long after the end it is sent. A
-     * roll lot makes the winner's roll of its box (`order`), which `collect` asks for and settles.
+     * roll lot makes the winner's roll of its box (`order`), which `collect` asks for and settles. An end too big for one
+     * transaction makes each NFT a hold and sends each home with a release after it (`releases`).
      */
     endAuction(auctionKey: any, { holders, ...others }?: Readonly<Record<string, any>>): Promise<{
+        signature: any;
+        owedPaid: any;
+    } | {
+        owedPaid?: undefined;
+        signature: any;
+        releases: any[];
+        winner?: any;
+    } | {
+        owedPaid?: undefined;
         signature: any;
         winner?: any;
         asset?: any;
         order?: any;
+        rolled?: {
+            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;
+        } | undefined;
     }>;
     /**
-     * Runs a schedule that is due (an emission into a pool, a rent or a drip): anyone may, and nothing is paid to
-     * whoever sends it but the network fee. `holders`: asset → holder, for a schedule that pays a collectible's holder.
+     * Runs a schedule that is due (an emission into a pool, a rent or a drip): the project's owner or authority, or who it
+     * pays, may (a sealed burn: anyone), and nothing is paid to whoever sends it but the network fee. A run missed is missed:
+     * this pays once, for the latest run due, and the runs before it lapse; only a sealed fixed amount pays every run due. `holders`: asset → holder, for a schedule that pays a collectible's holder.
      * Returns null when it isn't due yet.
      */
     runSchedule(scheduleKey: any, { holders, most, ...others }?: Readonly<Record<string, any>>): Promise<any>;
@@ -320,7 +691,9 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
      * nothing but the lottery can take it while a place names it; the winner gets it before any ticket money moves.
      * `price` (whole units of `currency`) a ticket, `drawsAt` (Unix seconds) its one draw, `minSold` the least tickets
      * (fewer: the round is cancelled and refunded), `shares` where the ticket money goes (the seller's own wallet by
-     * default: the treasury). A seller runs it in a project of their own, whose owner they are.
+     * default: the treasury). Its one place takes no money, so it keeps no pot: the round pays from its own ticket
+     * money, and what the shares leave goes to the treasury too. A seller runs it in a project of their own, whose
+     * 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). */
@@ -330,7 +703,7 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
     /**
      * Claims a grant for the connected wallet: from the approved list (the proof comes from xsolana.json, or is given:
      * `proof`, `personHash` and the `round` the list pays, as a results server's list answers them), or with a voucher
-     * a server signed ({ publicKey, signature, incarnation, round, expires, personHash, amount }). A list in xsolana.json names
+     * a server signed ({ publicKey, signature, incarnation, round and amount, or rounds: [{ id, amount }], expires, personHash }). A list in xsolana.json names
      * no round (zeros). `amount` (a voucher's, or `options.amount` for a list's leaf): the tokens this claim gives, in
      * base units, up to the grant's own, for a grant of a fixed amount of tokens (a reward by rank); absent or 0 gives
      * the grant's prize as it is. A grant that gives a roll of a box makes the wallet's roll, which `claims()` then
@@ -356,90 +729,110 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
     /**
      * 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
-     * won, a draw that is due (anyone may reveal it, or ask again when the oracle never answered; it takes 0.0005
+     * 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, … }];
-     * pass one to `claim`.
+     * 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`.
      */
     claims(): Promise<({
         key?: undefined;
+        tree?: undefined;
         kind: string;
         order: any;
         says: string;
-        entry?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
-        contribution?: undefined;
+        round?: undefined;
+        pulls?: undefined;
         asset?: undefined;
         table?: undefined;
     } | {
         key?: undefined;
+        tree?: undefined;
         order?: undefined;
         kind: string;
-        entry: any;
         id: any;
         side: any;
         says: string;
+        potUnits?: string | undefined;
+        prizeUnits?: string | undefined;
         hold?: undefined;
-        contribution?: undefined;
+        round?: undefined;
+        pulls?: undefined;
         asset?: undefined;
         table?: undefined;
     } | {
         key?: undefined;
+        tree?: undefined;
         order?: undefined;
-        entry?: undefined;
-        id?: undefined;
-        side?: undefined;
         kind: string;
         asset: any;
         hold: any;
         says: string;
-        contribution?: undefined;
+        round?: undefined;
+        pulls?: undefined;
         table?: undefined;
     } | {
+        key?: undefined;
+        order?: undefined;
+        hold?: undefined;
+        kind: string;
+        asset: string;
+        tree: string;
+        says: string;
+        round?: undefined;
+        pulls?: undefined;
+        table?: undefined;
+    } | {
+        tree?: undefined;
         order?: undefined;
-        entry?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
         kind: string;
         key: any;
         says: string;
-        contribution?: undefined;
+        round?: undefined;
+        pulls?: undefined;
         asset?: undefined;
         table?: undefined;
     } | {
+        tree?: undefined;
         order?: undefined;
-        entry?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
         kind: string;
         key: any;
-        contribution: any;
+        round: any;
+        says: string;
+        pulls?: undefined;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        tree?: undefined;
+        order?: undefined;
+        hold?: undefined;
+        kind: string;
+        key: any;
+        round: any;
+        pulls: any;
         says: string;
         asset?: undefined;
         table?: undefined;
     } | {
         key?: undefined;
+        tree?: undefined;
         order?: undefined;
-        entry?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
-        contribution?: undefined;
+        round?: undefined;
+        pulls?: undefined;
         kind: string;
         asset: any;
         says: string;
         table?: undefined;
     } | {
         key?: undefined;
+        tree?: undefined;
         order?: undefined;
-        entry?: undefined;
-        id?: undefined;
-        side?: undefined;
         hold?: undefined;
-        contribution?: undefined;
+        round?: undefined;
+        pulls?: undefined;
         asset?: undefined;
         kind: string;
         table: any;
@@ -450,7 +843,14 @@ export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }:
      * 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.
      */
-    claim(c: any, { take, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    claim(c: any, { take, build, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    /**
+     * Everything in `list` (by default `claims()`) taken in as few prompts as it can: each step that is one transaction
+     * of the wallet's is built first and the lot signed in one prompt when the wallet signs several at once
+     * (`wallet.signTransactions`); a lottery's steps depend on each other, so one of each lottery a call. The rest (a roll
+     * to settle, a refund, an auction to end…) go one by one after. Returns [{ claim, signature } | { claim, error }].
+     */
+    claimAll(list: any): Promise<any[]>;
     /** The player's collectibles of this project: [{ asset, item, itemId, name, uri, attributes, frozen }]. `item` is its key in the spec. */
     collectibles: (owner?: any) => Promise<{
         owner: string;