@xgamesfun/solana 0.0.0-stage → 0.20.1

package/types/play/index.d.ts

@@ -0,0 +1,469 @@
+/** A signer from a Wallet Standard wallet and one of its accounts: the wallet signs, the app sends. */
+export declare function walletStandardSigner(wallet: any, account: any, chain?: string): {
+    address: any;
+    signTransaction(wire: any): Promise<any>;
+};
+/**
+ * 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.
+ */
+export declare function solanaApp({ spec, rpcUrl, rpc, wallet, programs, now }: {
+    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 and each outcome's chance. */
+    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;
+        asset?: any;
+    } | {
+        signature: any;
+        assets: any;
+        asset?: 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.
+     */
+    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;
+        asset?: any;
+    } | {
+        signature: any;
+        assets: any;
+        asset?: 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;
+        asset?: any;
+    }>;
+    /** 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). */
+    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<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, 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).
+     */
+    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>;
+    /**
+     * 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>;
+    /**
+     * 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). The farm's toll, if any, is taken first.
+     */
+    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
+     * 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;
+        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.
+     */
+    craft(recipeKey: any, assets?: any[], times?: number, { version, listing, ...others }?: Readonly<Record<string, any>>): Promise<{
+        signature: any;
+        made: any;
+        roll?: any;
+    }>;
+    /**
+     * 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;
+    }>;
+    /**
+     * 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.
+     */
+    endAuction(auctionKey: any, { holders, ...others }?: Readonly<Record<string, any>>): Promise<{
+        signature: any;
+        winner?: any;
+        asset?: any;
+        order?: any;
+    }>;
+    /**
+     * 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.
+     * 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, expires, personHash, amount }). 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.0005
+     * 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;
+        kind: string;
+        order: any;
+        says: string;
+        entry?: undefined;
+        id?: undefined;
+        side?: undefined;
+        hold?: undefined;
+        contribution?: undefined;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        order?: undefined;
+        kind: string;
+        entry: any;
+        id: any;
+        side: any;
+        says: string;
+        hold?: undefined;
+        contribution?: undefined;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        order?: undefined;
+        entry?: undefined;
+        id?: undefined;
+        side?: undefined;
+        kind: string;
+        asset: any;
+        hold: any;
+        says: string;
+        contribution?: undefined;
+        table?: undefined;
+    } | {
+        order?: undefined;
+        entry?: undefined;
+        id?: undefined;
+        side?: undefined;
+        hold?: undefined;
+        kind: string;
+        key: any;
+        says: string;
+        contribution?: undefined;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        order?: undefined;
+        entry?: undefined;
+        id?: undefined;
+        side?: undefined;
+        hold?: undefined;
+        kind: string;
+        key: any;
+        contribution: any;
+        says: string;
+        asset?: undefined;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        order?: undefined;
+        entry?: undefined;
+        id?: undefined;
+        side?: undefined;
+        hold?: undefined;
+        contribution?: undefined;
+        kind: string;
+        asset: any;
+        says: string;
+        table?: undefined;
+    } | {
+        key?: undefined;
+        order?: undefined;
+        entry?: undefined;
+        id?: undefined;
+        side?: undefined;
+        hold?: undefined;
+        contribution?: 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, ...others }?: Readonly<Record<string, 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<{}>;
+};

package/types/results/index.d.ts

@@ -0,0 +1,155 @@
+export { canonicalJson, CERT_KINDS, CLUSTERS, drawText, entryText, giveawayHostText, hostCertText, lockText, NO_GRANT, RESULT_DOMAIN, resultBytes, revokeGiveawayText, revokeText, rosterHash } from './wire.js';
+/** games.fun's results server, on its play host (devnet until the program's audit). */
+export declare const RESULTS_SERVER = "https://play.xgames.fun/xsolana";
+/** A fresh round id: 16 random bytes, in hex. Make it when the round starts. */
+export declare const newRound: () => string;
+/**
+ * A fresh Ed25519 key: { address, sign(bytes) → Promise<64 bytes>, secret }. `secret` is its 32-byte seed in base58,
+ * for a host server to keep in its secret store; a page's session key never needs it.
+ */
+export declare function newKey(): Promise<{
+    address: string;
+    secret: string;
+    sign: (message: any) => Promise<Uint8Array<ArrayBuffer>>;
+}>;
+/** The key a host server kept (`secret`: its seed in base58). */
+export declare function keyFromSecret(secret: any): Promise<{
+    address: string;
+    secret: string;
+    sign: (message: any) => Promise<Uint8Array<ArrayBuffer>>;
+}>;
+/** One signer's signature of a result: { key, signature }. `signer` is a key from newKey, or anything with sign(). */
+export declare function signResult(signer: any, result: any, cluster?: string): Promise<{
+    key: any;
+    signature: string;
+}>;
+/**
+ * A host server reports a round. `cert`: the owner's { text, signature } certifying `signer`, the host key. Retrying
+ * with the same result is safe: it is the same answer. Returns the server's answer, { result, vouchers }, or throws its
+ * { code, why }.
+ */
+export declare function report({ server, cert, signer, game, round, endedAt, winners, cluster, fetchImpl }: {
+    cert: any;
+    cluster?: string | undefined;
+    endedAt: any;
+    fetchImpl?: typeof fetch | undefined;
+    game: any;
+    round: any;
+    server: any;
+    signer: any;
+    winners: any;
+}): Promise<any>;
+/** A wallet's vouchers for a round it won: [{ grant, publicKey, signature, round, expires, … }]. */
+export declare function fetchVouchers({ server, game, round, wallet, fetchImpl }: {
+    fetchImpl?: typeof fetch | undefined;
+    game: any;
+    round: any;
+    server: any;
+    wallet: any;
+}): Promise<any>;
+/**
+ * A loot grant voucher the host key signs itself, for a host server whose key the grant names (no results server
+ * involved): the program checks it and pays only `wallet`, within the grant's limits. `round` is the result's round id
+ * (16 bytes hex): the program pays a wallet each round once, ever, so the voucher may be signed again, any time, and
+ * still pays once. `incarnation` is the grant's (`Grant.incarnation`): a voucher pays only the grant it was signed
+ * for, never one written again at the same address. `now` is the cluster's clock (unix s); the voucher lives
+ * `seconds` from it, 30 days at most. `amount`: the tokens this claim gives, in base units, for a grant of a fixed amount
+ * of tokens (a rank's reward), at most the grant's; 0 (the default) gives the grant's prize as it is.
+ * Returns { wallet, grant, incarnation, publicKey, signature, round, expires, personHash, amount } for js/play claimGrant,
+ * plain JSON (`incarnation` and `amount` as decimal text), so a server can send it as it is.
+ */
+export declare function signVoucher({ signer, game, grant, incarnation, wallet, round, now, seconds, personHash, amount }: {
+    amount?: bigint | undefined;
+    game: any;
+    grant: any;
+    incarnation: any;
+    now: any;
+    personHash?: null | undefined;
+    round: any;
+    seconds?: number | undefined;
+    signer: any;
+    wallet: any;
+}): Promise<{
+    wallet: any;
+    grant: any;
+    incarnation: string;
+    publicKey: any;
+    signature: string;
+    round: any;
+    expires: number;
+    personHash: string;
+    amount: string;
+}>;
+/**
+ * A draw, from the organizer's side and the players'. `signMessage(text) → signature bytes` is the organizer's wallet
+ * (its signMessage) or a host key's sign; `by` its address; `cert` the owner's host certificate when `by` is a host key.
+ */
+export declare const draws: {
+    open: ({ server, signMessage, by, cert, rates, fetchImpl, ...spec }: {
+        [x: string]: any;
+        by: any;
+        cert?: null | undefined;
+        fetchImpl?: typeof fetch | undefined;
+        rates?: null | undefined;
+        server: any;
+        signMessage: any;
+    }) => Promise<any>;
+    /** A player enters with their play-host token, or with their wallet's signature (`wallet`, `signMessage`). */
+    enter: ({ server, game, draw, token, wallet, signMessage, cluster, fetchImpl }: {
+        cluster?: string | undefined;
+        draw: any;
+        fetchImpl?: typeof fetch | undefined;
+        game: any;
+        server: any;
+        signMessage?: null | undefined;
+        token?: null | undefined;
+        wallet?: null | undefined;
+    }) => Promise<any>;
+    /** Locks the players the server holds now to `beacon`, a drand round still to come. Checks their hash itself. */
+    lock: ({ server, game, draw, beacon, signMessage, by, cert, cluster, net, fetchImpl }: {
+        beacon: any;
+        by: any;
+        cert?: null | undefined;
+        cluster?: string | undefined;
+        draw: any;
+        fetchImpl?: typeof fetch | undefined;
+        game: any;
+        net?: string | undefined;
+        server: any;
+        signMessage: any;
+    }) => Promise<any>;
+    /** The draw as anyone may check it; settled, with its result, once its beacon round is out. */
+    get: ({ server, game, draw, fetchImpl }: {
+        draw: any;
+        fetchImpl?: typeof fetch | undefined;
+        game: any;
+        server: any;
+    }) => Promise<any>;
+};
+/** A giveaway, from its appointed host's page. */
+export declare const giveaways: {
+    /** Opens one: `cert` the owner's appointment, `token` the host's play-host sign-in, `session` a key from newKey(). */
+    open: ({ server, game, cert, token, giveaway, winners, endsBy, session, fetchImpl }: {
+        cert: any;
+        endsBy: any;
+        fetchImpl?: typeof fetch | undefined;
+        game: any;
+        giveaway: any;
+        server: any;
+        session: any;
+        token: any;
+        winners: any;
+    }) => Promise<any>;
+    /** Reports its result, signed by its session key. `grant`: the host's grant (each winner is paid from it). */
+    report: ({ server, game, giveaway, session, endedAt, winners, grant, cluster, fetchImpl }: {
+        cluster?: string | undefined;
+        endedAt: any;
+        fetchImpl?: typeof fetch | undefined;
+        game: any;
+        giveaway: any;
+        grant: any;
+        server: any;
+        session: any;
+        winners: any;
+    }) => Promise<any>;
+};