@xgamesfun/solana 0.0.0-stage → 0.24.0

package/types/play/index.d.ts

@@ -0,0 +1,880 @@
+/**
+ * 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
+ * at most the token's decimals: "0x10", "1.2.3", "", "1e3", "-1" and an extra decimal place are refused, never read as
+ * some other amount.
+ */
+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. `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, 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;
+    rpcUrl?: string | undefined;
+    spec: any;
+    wallet: any;
+}): {
+    project: any;
+    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, 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
+     * (an NFT at random, or one it rolls on) is opened and settled instead. Returns { signature, assets, asset } for a
+     * purchase, or what `collect` returns for an open.
+     */
+    buy(itemKey: any, options?: {}): Promise<{
+        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;
+    } | {
+        signature: 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, 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;
+        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;
+    } | {
+        signature: 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<{
+        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;
+    }>;
+    /**
+     * 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). 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
+     * a payment with `any` (at least its `amount`). `chosenRecipient`: the wallet the player names for a share the
+     * payment lets them choose (a referrer), never their own. `holders`: asset → holder, for a holder's share (read
+     * now when not given).
+     */
+    pay(paymentKey: any, { amount: chosen, holders, chosenRecipient, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    /**
+     * Pays with one of the player's NFTs, any kind (`pay_nft`): burned (`to` null), or given to the wallet `to` (the
+     * treasury, a partner), straight from the player. The receipt (`PaidNft`) is the record an app admits the player
+     * by, with `reference` (32 bytes, or text the client hashes). Returns the signature.
+     */
+    payNft(asset: any, { to, reference, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    /**
+     * The lotteries: each one's ticket price now, its round and status, and its terms (`incarnation`, `revision`),
+     * 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<{
+        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
+     * most a ticket may cost, in base units. One of them is required: the price read now is never the bound.
+     * `chosenRecipient`: the wallet (or collectible) the player names for a share the lottery lets them choose (a
+     * referrer). A lottery whose ticket costs an NFT (`nft_ticket`) sells one ticket for one of the player's NFTs that
+     * passes its rule: `nft`, its address (held by the project until the draw, then burned, given on or stashed; back to
+     * the player if the round is cancelled). `listProof`: for a list gate.
+     */
+    buyTickets(lotteryKey: any, count?: number, { shown, chosenRecipient, listProof, nft: paidWith, listing, maxPrice, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    /**
+     * Writes an NFT's traits from the project's traits tree (`traits` in the spec) into its Sheet, where rules read them:
+     * anyone may, paying the Sheet's rent. `attributes` ([{ key, value }]) and `proof` come from the project's tree
+     * (`loot.traitsTree`); `key` names the tree (a collection's address), the spec's first when left out. Traits the
+     * Sheet already has are left as they are.
+     */
+    proveTraits(nft: any, attributes: any, proof: any, key?: any): Promise<any>;
+    /**
+     * Stakes `amount` (whole units) of a farm's token at lock tier `tier`. A farm with an end takes no stake at its end
+     * or after it, nor one whose lock would run past it: refused here, before the wallet signs.
+     */
+    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, keeping what the seat was credited.
+     */
+    unstake(farmKey: any, amount?: number, { forfeit, extra, transfers, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    /**
+     * Stakes one of the player's NFTs in a farm (its own seat, or as the booster of their token seat), of any kind: a
+     * Core asset, a Token Metadata NFT's mint (legacy or pNFT), or a compressed NFT's asset id. In a farm that watches,
+     * an NFT whose last staker sold it takes their seat over. A farm with an end takes none at its end or after it.
+     */
+    stakeNft(farmKey: any, asset: any, tier?: number, { extra, transfers, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    /**
+     * Releases the collectible after its lock: it grows on its way out (a farm with `growth`), and from its own seat
+     * takes its tier's prize (a mission: `prize.rs`). `forfeit` gives up rewards, and the prize, that cannot move.
+     * Returns the signature, or { signature, roll } when it makes a roll (a mission's result on the NFT, or a chest),
+     * 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, ...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.
+     */
+    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).
+     */
+    compound(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, 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.
+     */
+    staked(farmKey: any, player?: any): Promise<{
+        asset: any;
+        amount: number;
+        amountUnits: bigint;
+        tier: any;
+        since: number;
+        freeAt: number | null;
+        lockKey?: any;
+        boostPercent: number;
+        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). */
+    recipes(): Promise<any>;
+    /**
+     * 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. `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, 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).
+     * The hold's address names its end. Returns { signature, freeAt }.
+     */
+    hold(asset: any, seconds: any): Promise<{
+        signature: any;
+        freeAt: bigint;
+    }>;
+    /**
+     * A lender's offer to borrow against: `maker`'s offer number `id` in this project. Returns { address, offer, mint,
+     * amount, repay, lasts, risks }: `risks`, in words, each power over the loan's token that could make repaying fail
+     * (its freeze authority, a Token-2022 pause, a transfer hook, a permanent delegate) and who holds it. The program
+     * takes such tokens, and a lender who holds one can stop every repayment and take the NFT once it is due: show the
+     * risks before the player borrows.
+     */
+    loanOffer(maker: any, id: any): Promise<{
+        address: any;
+        offer: any;
+        mint: any;
+        program: any;
+        amount: any;
+        repay: any;
+        lasts: any;
+        risks: any[];
+    }>;
+    /**
+     * Borrows against the player's NFT `asset` from `maker`'s offer `id`: the NFT is held until the loan is repaid, or
+     * goes to the lender once it is due (`due`, Unix seconds; by default the longest the offer allows, less a minute).
+     * A loan whose token someone could freeze, pause, hook or move (`loanOffer`'s `risks`) is refused unless
+     * `acceptRisks` is true: the page shows the player who holds that power first. `extra`: a transfer hook's accounts.
+     */
+    borrow(maker: any, id: any, asset: any, { due, acceptRisks, extra, ...others }?: Readonly<Record<string, any>>): Promise<{
+        signature: any;
+        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
+     * claimed. `listProof`: for a list gate.
+     */
+    enter(id: any, side: any, amount: any, { shown, listProof, nft: staked, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    /**
+     * The auctions: each one's lot, high bid, the least the next bid must be, when it ends and how long is left, and
+     * whether the player leads. One no longer on chain has ended. `waiting`: SOL that came back to the player's
+     * wrapped-SOL account from a bid that was topped (`unwrap` turns it into plain SOL).
+     */
+    auctions(): Promise<any>;
+    /**
+     * 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.
+     */
+    bid(auctionKey: any, amount: any, { shown, listProof, nfts, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    /**
+     * 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. 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): 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>;
+    /**
+     * Lists one of the player's NFTs (any kind) for sale at `price` (whole units of `currency`, the economy's by
+     * default), `shares` taken first (a royalty, a platform's cut). The project holds it until it sells or is unlisted.
+     */
+    listForSale(asset: any, { price, currency, shares, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    /**
+     * Lists one of the player's NFTs for rent: `price` (whole units) a period of `lasts` seconds, a renter taking 1 to
+     * `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, ...others }?: Readonly<Record<string, any>>): Promise<any>;
+    /** The listing of `asset` (one account read), or null: { listing, asset, maker, mint, deal, renter, until }. */
+    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. */
+    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.
+     */
+    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`).
+     */
+    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. */
+    unlist(asset: any): Promise<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.
+     * `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.
+     */
+    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). */
+    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>;
+    /**
+     * 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 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
+     * lists and `collect` asks for and settles.
+     */
+    claimGrant(grantKey: any, options?: {}): Promise<any>;
+    /**
+     * Takes every prize a results server vouched for this wallet's wins, or put on a list (`server`: its URL;
+     * a results server), page by page. Each pays only this wallet, within the grant's limits. Returns [{ round, grant,
+     * signature }] for each claim made, and [{ round, grant, error }] for one that failed, without stopping the rest;
+     * wins already claimed are skipped (the program pays a wallet each round once per grant incarnation).
+     *
+     * `token`: the player's play-host sign-in for this game. A drop that gives NFTs from a stash gives one only at a
+     * signed-in claim, first come first served (the server answers `R-SIGN-IN` to a voucher request with no sign-in, so
+     * a stranger can't hand them out): with the token such a win is claimed through `POST /v1/claims`; without it, it is
+     * [{ round, grant, error }].
+     */
+    claimWins({ server, token, fetchImpl, ...others }?: Readonly<Record<string, any>>): Promise<{
+        round: any;
+        grant: any;
+        error: any;
+    }[]>;
+    /**
+     * 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.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`.
+     */
+    claims(): Promise<({
+        key?: undefined;
+        tree?: undefined;
+        kind: string;
+        order: any;
+        says: string;
+        id?: undefined;
+        side?: undefined;
+        hold?: undefined;
+        round?: undefined;
+        pulls?: undefined;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        tree?: undefined;
+        order?: undefined;
+        kind: string;
+        id: any;
+        side: any;
+        says: string;
+        hold?: undefined;
+        round?: undefined;
+        pulls?: undefined;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        tree?: undefined;
+        order?: undefined;
+        id?: undefined;
+        side?: undefined;
+        kind: string;
+        asset: any;
+        hold: any;
+        says: string;
+        round?: undefined;
+        pulls?: undefined;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        order?: undefined;
+        id?: undefined;
+        side?: undefined;
+        hold?: undefined;
+        kind: string;
+        asset: string;
+        tree: string;
+        says: string;
+        round?: undefined;
+        pulls?: undefined;
+        table?: undefined;
+    } | {
+        tree?: undefined;
+        order?: undefined;
+        id?: undefined;
+        side?: undefined;
+        hold?: undefined;
+        kind: string;
+        key: any;
+        says: string;
+        round?: undefined;
+        pulls?: undefined;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        tree?: undefined;
+        order?: undefined;
+        id?: undefined;
+        side?: undefined;
+        hold?: undefined;
+        kind: string;
+        key: any;
+        round: any;
+        says: string;
+        pulls?: undefined;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        tree?: undefined;
+        order?: undefined;
+        id?: undefined;
+        side?: undefined;
+        hold?: undefined;
+        kind: string;
+        key: any;
+        round: any;
+        pulls: any;
+        says: string;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        tree?: undefined;
+        order?: undefined;
+        id?: undefined;
+        side?: undefined;
+        hold?: undefined;
+        round?: undefined;
+        pulls?: undefined;
+        kind: string;
+        asset: any;
+        says: string;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        tree?: undefined;
+        order?: undefined;
+        id?: undefined;
+        side?: undefined;
+        hold?: undefined;
+        round?: undefined;
+        pulls?: 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.
+     */
+    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;
+        collection: string | null;
+        name: string;
+        uri: string;
+        attributes: {};
+        frozen: boolean;
+        soulbound: boolean;
+        asset: any;
+        itemId: number | null;
+        item: any;
+    }[]>;
+    /** What the player holds of each of the economy's tokens, in whole units. */
+    balances(owner?: any): Promise<{}>;
+};