@xgamesfun/solana 0.0.0-stage → 0.24.0

package/types/economy/plan.d.mts

@@ -0,0 +1,1014 @@
+/** Most transactions one wallet approval carries. */
+export declare const PER_APPROVAL = 12;
+export declare function itemArgs(it: any, m: any): {
+    kind: string;
+    rarity: number;
+    soulbound: boolean;
+    burnable: boolean;
+    name: any;
+    uri: any;
+    max_supply: any;
+    active: boolean;
+    collection: any;
+    traits: any;
+};
+/**
+ * The bytes of an order of box `b` (`orderBytes`), its spec's names standing in as addresses, with the shares its split
+ * stores. `opened`: an open's (`open_box`, `Order::sized`: each draw at its dearest outcome's prizes as they are kept,
+ * rows only for the tables its fresh items draw); otherwise a roll made inside another call (a craft, a grant's claim,
+ * a mission, a lottery's place, a roll lot: `Order::space_for`, the box's whole table budget a draw).
+ */
+export declare const boxOrderBytes: (b: any, m: any, opens?: number, { opened }?: {
+    opened?: boolean | undefined;
+}) => number;
+/** The most bytes of rows one table write carries: what a 1,232-byte transaction leaves after the upsert's accounts,
+ * its signature and its own bytes. */
+export declare const TABLE_BATCH_BYTES = 800;
+/** A spec table's rows as the program takes them ({ weight, left, label }), in batches that fit a transaction each. */
+export declare function tableBatches(t: any): never[][];
+/** The program's `Prize` for one part of a box outcome (`model.outcomeParts`). */
+export declare function partPrize(o: any, m: any): "Raffled" | {
+    Stash: any[];
+} | {
+    Compressed: {
+        item: any;
+        tree: string;
+    };
+    Item?: undefined;
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Compressed?: undefined;
+    Item: any[];
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Compressed?: undefined;
+    Item?: undefined;
+    Held: any[];
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Compressed?: undefined;
+    Item?: undefined;
+    Held?: undefined;
+    Nft: {
+        stash: any;
+        nft: any;
+    };
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Compressed?: undefined;
+    Item?: undefined;
+    Held?: undefined;
+    Nft?: undefined;
+    Roll: any[];
+    Tokens?: undefined;
+} | {
+    Compressed?: undefined;
+    Item?: undefined;
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens: {
+        from: {
+            Pool: any[];
+            Mint?: undefined;
+        } | {
+            Pool?: undefined;
+            Mint: string[];
+        };
+        amount: bigint;
+    };
+};
+export declare function boxArgs(b: any, m: any): {
+    price: bigint;
+    currency: string;
+    rise: {
+        step: bigint;
+        growth_bps: number;
+    } | null;
+    fall: {
+        step: bigint;
+        every: number;
+        floor: bigint;
+        since: bigint;
+        shared: boolean;
+    } | null;
+    stock_odds: boolean;
+    when_out: string;
+    active: boolean;
+    shares: any;
+    slots: any;
+    entries: any;
+    gate: {
+        Wallets: any[];
+        Staked?: undefined;
+        List?: undefined;
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked: {
+            farm: string;
+            at_least: bigint;
+        };
+        List?: undefined;
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked?: undefined;
+        List: {
+            root: any;
+            depth: number;
+        };
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked?: undefined;
+        List?: undefined;
+        Holds: ({
+            of: {
+                Item: any[];
+                Collection?: undefined;
+            } | {
+                Collection: any[];
+                Item?: undefined;
+            };
+            key: any;
+            test: any;
+        } | null)[];
+    } | null;
+    odds: any;
+    window: {
+        opens_at: bigint;
+        closes_at: bigint;
+    };
+    per_wallet: {
+        total: any;
+        per_window: any;
+        window: number;
+    };
+    subject: {
+        of: {
+            Item: any[];
+            Collection?: undefined;
+        } | {
+            Collection: any[];
+            Item?: undefined;
+        };
+        key: any;
+        test: any;
+    } | null;
+    fates: any;
+};
+/** Where an outcome sends the NFT a box rolls on: back (null), burned, given (the treasury's wallet is filled in when the economy goes live), or into a stash. */
+export declare const thenOf: (then: any, m: any) => "Burn" | {
+    Give?: undefined;
+    Stash: any[];
+} | {
+    Stash?: undefined;
+    Give: any[];
+} | null;
+export declare function recipeArgs(r: any, m: any): {
+    active: boolean;
+    inputs: any;
+    outputs: any;
+    needs: any[];
+    keeps: any;
+    raises: any[];
+    window: {
+        opens_at: bigint;
+        closes_at: bigint;
+    };
+    per_wallet: {
+        total: any;
+        per_window: any;
+        window: number;
+    };
+};
+export declare function scheduleArgs(s: any, m: any): {
+    active: boolean;
+    action: {
+        from: {
+            Mint: string[];
+            Vest?: undefined;
+            Pool?: undefined;
+        };
+        to: string | {
+            Pool: any[];
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+        } | {
+            Account: (string | undefined)[];
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+            Pool?: undefined;
+        } | {
+            Account?: undefined;
+            Wallet: (string | undefined)[];
+            Chosen?: undefined;
+            Holder?: undefined;
+            Pool?: undefined;
+        } | {
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen: {
+                item: any;
+            };
+            Holder?: undefined;
+            Pool?: undefined;
+        } | {
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder: (string | undefined)[];
+            Pool?: undefined;
+        };
+        amount: {
+            Fixed: bigint[];
+        };
+        halve_every: any;
+    } | {
+        from: {
+            Vest: string[];
+            Pool?: undefined;
+            Mint?: undefined;
+        };
+        to: string | {
+            Pool: any[];
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+        } | {
+            Account: (string | undefined)[];
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+            Pool?: undefined;
+        } | {
+            Account?: undefined;
+            Wallet: (string | undefined)[];
+            Chosen?: undefined;
+            Holder?: undefined;
+            Pool?: undefined;
+        } | {
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen: {
+                item: any;
+            };
+            Holder?: undefined;
+            Pool?: undefined;
+        } | {
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder: (string | undefined)[];
+            Pool?: undefined;
+        };
+        amount: {
+            Bps: number[];
+            Fixed?: undefined;
+        } | {
+            Bps?: undefined;
+            Fixed: bigint[];
+        };
+        halve_every: any;
+    } | {
+        from: {
+            Vest?: undefined;
+            Pool: any[];
+            Mint?: undefined;
+        };
+        to: string | {
+            Pool: any[];
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+        } | {
+            Account: (string | undefined)[];
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+            Pool?: undefined;
+        } | {
+            Account?: undefined;
+            Wallet: (string | undefined)[];
+            Chosen?: undefined;
+            Holder?: undefined;
+            Pool?: undefined;
+        } | {
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen: {
+                item: any;
+            };
+            Holder?: undefined;
+            Pool?: undefined;
+        } | {
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder: (string | undefined)[];
+            Pool?: undefined;
+        };
+        amount: {
+            Fixed?: undefined;
+            Bps: number[];
+        } | {
+            Bps?: undefined;
+            Fixed: bigint[];
+        };
+        halve_every: any;
+    };
+    every: bigint;
+    next_at: bigint;
+    max_runs: any;
+};
+/**
+ * The program's `Prize` for a prize line (`model.prizeLine`): tokens minted or from a pool (a fixed amount, or a share
+ * of the pool), an item (a compressed NFT of it into the project's tree, "@tree"), one NFT of a stash, or a roll of a box.
+ */
+export declare function prizeArgs(p: any, m: any): "Raffled" | {
+    Compressed: {
+        item: any;
+        tree: string;
+    };
+    Item?: undefined;
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Compressed?: undefined;
+    Item: any[];
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Compressed?: undefined;
+    Item?: undefined;
+    Held: any[];
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Compressed?: undefined;
+    Item?: undefined;
+    Held?: undefined;
+    Nft: {
+        stash: any;
+        nft: any;
+    };
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Compressed?: undefined;
+    Item?: undefined;
+    Held?: undefined;
+    Nft?: undefined;
+    Roll: any[];
+    Tokens?: undefined;
+} | {
+    Compressed?: undefined;
+    Item?: undefined;
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens: {
+        from: {
+            Pool: any[];
+            Mint?: undefined;
+        } | {
+            Pool?: undefined;
+            Mint: string[];
+        };
+        amount: bigint;
+    };
+};
+/**
+ * A grant list's leaves: a plain address is the grant's amount in round 0; an entry { wallet, amount, round } names
+ * its own amount (whole units of `t`, the grant's token) and round, so one wallet listed under several rounds claims
+ * each once (monthly vesting, a season's airdrop).
+ */
+export declare const listLeaves: (list: any, t: any) => any;
+/**
+ * A lottery's args: its own pot in `currency` (the project's by default), ticket money split by `split` (and
+ * `cutPercent` to the treasury) with the rest into the pot. No `every` draws once, at `firstDraw`.
+ */
+export declare function lotteryArgs(l: any, m: any): {
+    terms: {
+        price: bigint;
+        mint: string;
+        shares: any;
+        places: any;
+        ticket_mint: string;
+        draws_at: bigint;
+        nft_ticket: {
+            rule: {
+                of: {
+                    Item: any[];
+                    Collection?: undefined;
+                } | {
+                    Collection: any[];
+                    Item?: undefined;
+                };
+                key: any;
+                test: any;
+            } | null;
+            then: string | {
+                Stash: any[];
+                Give?: undefined;
+            } | {
+                Stash?: undefined;
+                Give: any[];
+            };
+        } | null;
+        returns: boolean;
+        min_sold: bigint;
+    };
+    every: bigint;
+    gate: {
+        Wallets: any[];
+        Staked?: undefined;
+        List?: undefined;
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked: {
+            farm: string;
+            at_least: bigint;
+        };
+        List?: undefined;
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked?: undefined;
+        List: {
+            root: any;
+            depth: number;
+        };
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked?: undefined;
+        List?: undefined;
+        Holds: ({
+            of: {
+                Item: any[];
+                Collection?: undefined;
+            } | {
+                Collection: any[];
+                Item?: undefined;
+            };
+            key: any;
+            test: any;
+        } | null)[];
+    } | null;
+    per_wallet: any;
+};
+/**
+ * A lottery round's header as its first purchase sizes it (`LotteryRound::new`: its `head`), and the token accounts a
+ * round may open (`accounts`: the payment mint's, the pot's, one for each run whose prize comes from a pool). The
+ * header holds a copy of the terms, a total for each share, two bits a place, a record for each run of tokens and an
+ * NFT slot for each place of the lottery's own stash.
+ */
+export declare function roundSize(l: any, m: any): {
+    head: number;
+    accounts: any;
+};
+/** How many rounds of a lottery are open or still paying out at once, and how many purchases a round takes, as the
+ * spec expects them (`expect`): by default two rounds of a lottery that draws again (one selling, one paying out) and
+ * one of a lottery that draws once; a round's purchases from the scenario's purchases a day over a round, else 100. */
+export declare function roundsExpected(l: any, m: any): {
+    rounds: any;
+    entries: any;
+};
+/**
+ * The SOL, in lamports, a lottery holds for its rounds' rent: the spec's `roundRent` (0 turns it off), or by default
+ * what its expected rounds take at once (`roundsExpected`), each its header, its token accounts and its expected
+ * entries' bytes (`LotteryRound.lent`: in a round the lottery opened, its spare SOL pays each entry while it covers
+ * them, so buyers pay no program rent for a ticket), at devnet's and mainnet's rent, rounded up to 0.001 SOL. Short
+ * of it (a busier round, a cluster that charges more), the first buyer fronts the header and later buyers pay their
+ * own entries. Each round gives back what it took when it closes; the lottery gives the rest back to the owner when it closes.
+ */
+export declare function roundRentOf(l: any, m: any): bigint;
+/**
+ * The args the authority opens a contest with, `at` (Unix seconds) its opening: its sides, when entries close and the
+ * result is due, its split, its gate (a list of wallets for a duel), the keys that may decide it, the least pot (an
+ * all-or-nothing crowdfund) and the stake every entry puts in.
+ */
+export declare function contestArgs(c: any, m: any, at?: any): {
+    sides: any;
+    closes_at: bigint;
+    result_by: bigint;
+    shares: any;
+    gate: {
+        Wallets: any[];
+        Staked?: undefined;
+        List?: undefined;
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked: {
+            farm: string;
+            at_least: bigint;
+        };
+        List?: undefined;
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked?: undefined;
+        List: {
+            root: any;
+            depth: number;
+        };
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked?: undefined;
+        List?: undefined;
+        Holds: ({
+            of: {
+                Item: any[];
+                Collection?: undefined;
+            } | {
+                Collection: any[];
+                Item?: undefined;
+            };
+            key: any;
+            test: any;
+        } | null)[];
+    } | null;
+    deciders: any;
+    min_pot: bigint;
+    stake: bigint;
+    prize: string | {
+        Compressed: {
+            item: any;
+            tree: string;
+        };
+        Item?: undefined;
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Compressed?: undefined;
+        Item: any[];
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Compressed?: undefined;
+        Item?: undefined;
+        Held: any[];
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Compressed?: undefined;
+        Item?: undefined;
+        Held?: undefined;
+        Nft: {
+            stash: any;
+            nft: any;
+        };
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Compressed?: undefined;
+        Item?: undefined;
+        Held?: undefined;
+        Nft?: undefined;
+        Roll: any[];
+        Tokens?: undefined;
+    } | {
+        Compressed?: undefined;
+        Item?: undefined;
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens: {
+            from: {
+                Pool: any[];
+                Mint?: undefined;
+            } | {
+                Pool?: undefined;
+                Mint: string[];
+            };
+            amount: bigint;
+        };
+    } | null;
+    prize_split: boolean;
+    nft: {
+        of: {
+            Item: any[];
+            Collection?: undefined;
+        } | {
+            Collection: any[];
+            Item?: undefined;
+        };
+        key: any;
+        test: any;
+    } | null;
+    cap: any;
+};
+export declare function farmArgs(f: any, m: any): {
+    custody: any;
+    tiers: any;
+    boosts: any;
+    max_boost_bps: number;
+    gates: ({
+        of: {
+            Item: any[];
+            Collection?: undefined;
+        } | {
+            Collection: any[];
+            Item?: undefined;
+        };
+        key: any;
+        test: any;
+    } | null)[];
+    rate: {
+        per_day: bigint;
+        mints: boolean;
+        shared: boolean;
+        halve_every: number;
+    } | null;
+    growth: {
+        key: any;
+        per_day: any;
+        level: any;
+        steps: any;
+        streak: boolean;
+        profile: boolean;
+        at_least: bigint;
+    }[];
+    ends_at: bigint;
+    lock_key: any;
+    upkeep_key: any;
+    exit_to: string | {
+        Pool: any[];
+    } | null;
+};
+/** A fee's sink (`Sink`): "burn", "rewards" (the farm's own vault), or "pool:<key>", one of the project's pools. */
+export declare const sinkOf: (to: any, m: any) => "Burn" | "Rewards" | {
+    Pool: any[];
+};
+/** Whether a spec's farm keeps a record of when its seats stop earning (`loot.farmKeepsEnds`): a tier's term or an upkeep,
+ * and it pays something. Each different time waiting costs whoever writes it `loot.END_BYTES` of rent. */
+export declare const farmEnds: (f: any) => any;
+/** An auction's args: its lot, reserve, least raise, times and split. "start" is when it goes live unless it says. */
+export declare function auctionArgs(a: any, m: any): {
+    lot: {
+        Asset: any[];
+    } | {
+        Roll: any[];
+    } | {
+        Item: any[];
+    };
+    reserve: bigint;
+    min_raise_bps: number;
+    starts_at: bigint;
+    ends_at: bigint;
+    extend: number;
+    shares: any;
+    gate: {
+        Wallets: any[];
+        Staked?: undefined;
+        List?: undefined;
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked: {
+            farm: string;
+            at_least: bigint;
+        };
+        List?: undefined;
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked?: undefined;
+        List: {
+            root: any;
+            depth: number;
+        };
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked?: undefined;
+        List?: undefined;
+        Holds: ({
+            of: {
+                Item: any[];
+                Collection?: undefined;
+            } | {
+                Collection: any[];
+                Item?: undefined;
+            };
+            key: any;
+            test: any;
+        } | null)[];
+    } | null;
+    nft_bids: {
+        of: {
+            Item: any[];
+            Collection?: undefined;
+        } | {
+            Collection: any[];
+            Item?: undefined;
+        };
+        key: any;
+        test: any;
+    } | null;
+};
+export declare function grantArgs(g: any, m: any): {
+    gives: string | {
+        Compressed: {
+            item: any;
+            tree: string;
+        };
+        Item?: undefined;
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Compressed?: undefined;
+        Item: any[];
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Compressed?: undefined;
+        Item?: undefined;
+        Held: any[];
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Compressed?: undefined;
+        Item?: undefined;
+        Held?: undefined;
+        Nft: {
+            stash: any;
+            nft: any;
+        };
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Compressed?: undefined;
+        Item?: undefined;
+        Held?: undefined;
+        Nft?: undefined;
+        Roll: any[];
+        Tokens?: undefined;
+    } | {
+        Compressed?: undefined;
+        Item?: undefined;
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens: {
+            from: {
+                Pool: any[];
+                Mint?: undefined;
+            } | {
+                Pool?: undefined;
+                Mint: string[];
+            };
+            amount: bigint;
+        };
+    };
+    vouchers: any[];
+    list_root: any;
+    key_root: any;
+    open: boolean;
+    limits: {
+        wallet: {
+            total: any;
+            per_window: any;
+            window: number;
+        };
+        per_person: any;
+        per_key: any;
+        all: {
+            total: any;
+            per_window: any;
+            window: number;
+        };
+        window: {
+            opens_at: bigint;
+            closes_at: bigint;
+        };
+    };
+    active: boolean;
+    gate: {
+        Wallets: any[];
+        Staked?: undefined;
+        List?: undefined;
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked: {
+            farm: string;
+            at_least: bigint;
+        };
+        List?: undefined;
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked?: undefined;
+        List: {
+            root: any;
+            depth: number;
+        };
+        Holds?: undefined;
+    } | {
+        Wallets?: undefined;
+        Staked?: undefined;
+        List?: undefined;
+        Holds: ({
+            of: {
+                Item: any[];
+                Collection?: undefined;
+            } | {
+                Collection: any[];
+                Item?: undefined;
+            };
+            key: any;
+            test: any;
+        } | null)[];
+    } | null;
+    shard_bits: number;
+};
+/**
+ * Every step that sets the economy up, in order: the tokens the project mints, the collection, the project, the pools, items, boxes (the shop's too), recipes, schedules, lotteries, grants,
+ * farms, auctions, then the seeds and the grants' funds. `only` limits it to these part ids (a change to a live economy).
+ *
+ * A farm opens before its seed lands in its rewards vault, and anyone may stake in between. That is safe: a sharing
+ * farm credits nothing at once, and releases what lands in its vault over its longest lock (a day at least) to the
+ * seats there as it is released, its clock stopped while nobody is in. A seed that lands
+ * before the first stake or after it is released the same way from that stake on, so seeding first would change nothing.
+ */
+export declare function setupSteps(economy: any, { now, only, live: given }?: {
+    live?: null | undefined;
+    now?: number | undefined;
+    only?: null | undefined;
+}): {
+    steps: any[];
+    model: {
+        now: number;
+        name: any;
+        authority: any;
+        treasuryWallet: any;
+        tokens: Map<any, any>;
+        currencyKey: any;
+        currency: any;
+        collection: any;
+        collections: any;
+        treeHolds: any;
+        projectNumber: any;
+        items: any;
+        pools: any;
+        stashes: any;
+        tables: any;
+        boxes: never[];
+        payments: any;
+        recipes: any;
+        schedules: any;
+        lotteries: any;
+        farms: any;
+        contests: any;
+        auctions: any;
+        holds: any;
+        grants: any;
+        traits: any;
+        decisions: any;
+        scenario: any;
+        live: any;
+    };
+};
+/** The token accounts going live opens (`setupSteps`): [{ who ('the treasury', 'the project' or a wallet), token }], each
+ * once, for the coins the economy takes in. */
+export declare function goLiveAccounts(m: any): any[];
+/**
+ * The addresses a project's transactions name most, for its standing lookup table: loot's own fixed accounts (the
+ * platform, the oracle's), the project and its fee box, its treasury and collections, each coin's mint, its vault and
+ * the treasury's account of it, then each pool, item, box and stash. Each a function of the go-live context.
+ */
+export declare function standingAddresses(m: any): any[];
+/** A stash's bytes with `n` NFTs: a table of NFTs (`table.rs`): its 51-byte header, a total for each group of 4,096
+ * rows and each block of 64, and 36 bytes an NFT (its weight and its address). */
+export declare const stashBytes: (n: any) => number;
+/** Who puts a spec's auction up, and so is named in its address: the owner for a collectible it holds, the authority for a new unit of an item. */
+export declare const auctionSeller: (a: any, ctx: any) => any;
+export declare const recordBytesOf: (kind: any, body: any) => number;
+/** A farm's bytes as `open_farm` writes it: its args and its numbers. */
+export declare const farmBytes: (f: any, m: any) => number;
+/** Exact initial contest record size for its configured shares, gate, sides and deciders. */
+export declare const contestBytes: (contest: any, m: any) => number;
+/** Stand-in addresses for every name a plan uses, so it can be built and sized without a wallet. */
+export declare function placeholderContext(m: any, { rent }?: {
+    rent?: ((bytes: any) => bigint) | undefined;
+}): {
+    owner: string;
+    authority: any;
+    collection: string | null;
+    tree: string | null;
+    project: any;
+    treasury: any;
+    mints: {};
+    keys: {
+        'new:collection'?: string | undefined;
+        'new:tree'?: string | undefined;
+    };
+    rent: (bytes: any) => bigint;
+    slot: bigint;
+};
+/**
+ * What of `live` is made. While a setup is landing (`partial`), the project, its collection, its tree and each mint the
+ * setup makes count only once the step that makes it landed (`landed`): a setup cut short makes the rest again, with
+ * this session's fresh keys, instead of naming an account that was never made. What was live before a change, and
+ * that the change does not make, counts as it is. The treasury and authority count only with the project. The approval
+ * page holds what is left against the chain before it builds on it (`js/approve/live-check.mjs`).
+ */
+export declare function madeSoFar(live: any): any;
+/** The context of a real setup: the owner's wallet, fresh keys for what it creates, and what is live already. */
+export declare function setupContext(m: any, { owner: ownerKey, keys, live: given, rent }: {
+    keys: any;
+    live?: {} | undefined;
+    owner: any;
+    rent: any;
+}): {
+    owner: any;
+    authority: any;
+    collection: any;
+    tree: any;
+    project: any;
+    treasury: any;
+    mints: {};
+    keys: any;
+    rent: any;
+};
+/** The bytes of a transaction of `instructions` the owner pays for: what `pack` holds against the budget. */
+export declare const stepBytes: (instructions: any, ctx: any) => number;
+/** Packs steps into transactions under the size budget, one signer set at a time; each step whole. */
+export declare function pack(steps: any, ctx: any): {
+    signer: string;
+    steps: any[];
+    built: any[];
+    instructions: any;
+    signers: any[];
+    alone: boolean;
+}[];
+/**
+ * The plan for a spec: refusals, or every step packed into transactions. With `ctx` the transactions carry the
+ * real instructions; without it they are built on stand-in addresses (for sizing, cost and showing).
+ */
+export declare function plan(economy: any, { now, ctx, only, live }?: {
+    ctx?: null | undefined;
+    live?: null | undefined;
+    now?: number | undefined;
+    only?: null | undefined;
+}): {
+    ok: boolean;
+    refusals: any[];
+    warnings: any[];
+    steps?: undefined;
+    transactions?: undefined;
+    approvals?: undefined;
+    freshKeys?: undefined;
+} | {
+    refusals?: undefined;
+    ok: boolean;
+    warnings: any[];
+    steps: any[];
+    transactions: {
+        signer: string;
+        steps: any[];
+        built: any[];
+        instructions: any;
+        signers: any[];
+        alone: boolean;
+    }[];
+    approvals: number;
+    freshKeys: any[];
+};
+/** What each part needs while the economy runs: the instruction, and who signs it. */
+export declare function playSteps(economy: any): any[];