@xgamesfun/solana 0.0.0-stage → 0.20.1

package/types/economy/plan.d.mts

@@ -0,0 +1,1013 @@
+/** Most transactions one wallet approval carries. */
+export declare const PER_APPROVAL = 12;
+export declare function itemArgs(it: any): {
+    kind: string;
+    rarity: number;
+    soulbound: boolean;
+    burnable: boolean;
+    name: any;
+    uri: any;
+    max_supply: any;
+    life: {
+        ready_after: number;
+        lasts: number;
+        uses: any;
+        cooldown: number;
+    } | null;
+    active: boolean;
+    collection: any;
+};
+/** The program's `Prize` for one part of a box outcome (`model.outcomeParts`). */
+export declare function partPrize(o: any, m: any): {
+    Stash: any[];
+} | {
+    Item?: undefined;
+    Compressed: {
+        item: any;
+        tree: string;
+    };
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Compressed?: undefined;
+    Item: any[];
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Item?: undefined;
+    Compressed?: undefined;
+    Held: any[];
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Item?: undefined;
+    Compressed?: undefined;
+    Held?: undefined;
+    Nft: {
+        stash: any;
+        nft: any;
+    };
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Item?: undefined;
+    Compressed?: undefined;
+    Held?: undefined;
+    Nft?: undefined;
+    Roll: any[];
+    Tokens?: undefined;
+} | {
+    Item?: undefined;
+    Compressed?: undefined;
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens: {
+        from: {
+            Pool: any[];
+            Mint?: undefined;
+        } | {
+            Pool?: undefined;
+            Mint: string[];
+        };
+        amount: {
+            Bps: number[];
+            Fixed?: undefined;
+        };
+    };
+} | {
+    Item?: undefined;
+    Compressed?: undefined;
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens: {
+        from: {
+            Pool: any[];
+            Mint?: undefined;
+        } | {
+            Pool?: undefined;
+            Mint: string[];
+        };
+        amount: {
+            Bps?: undefined;
+            Fixed: 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;
+    active: boolean;
+    shares: 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;
+            } | {
+                Item?: undefined;
+                Collection: any[];
+            };
+            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;
+        } | {
+            Item?: undefined;
+            Collection: any[];
+        };
+        key: any;
+        test: any;
+    } | null;
+    fates: any;
+};
+/** Where an outcome sends the NFT a box rolls on: back, 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) => "Back" | "Burn" | {
+    Give?: undefined;
+    Stash: any[];
+} | {
+    Stash?: undefined;
+    Give: any[];
+};
+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: {
+            Pool?: undefined;
+            Mint: string[];
+            Vest?: undefined;
+        };
+        to: {
+            Pool: any[];
+        };
+        amount: {
+            Fixed: bigint[];
+        };
+        halve_every: any;
+    } | {
+        from: {
+            Pool?: undefined;
+            Vest: string[];
+            Mint?: undefined;
+        };
+        to: string | {
+            Pool: any[];
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+        } | {
+            Pool?: 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)[];
+        };
+        amount: {
+            Bps: number[];
+            Fixed?: undefined;
+        } | {
+            Fixed: bigint[];
+            Bps?: undefined;
+        };
+        halve_every: any;
+    } | {
+        from: {
+            Vest?: undefined;
+            Pool: any[];
+            Mint?: undefined;
+        };
+        to: string | {
+            Pool: any[];
+            Account?: undefined;
+            Wallet?: undefined;
+            Chosen?: undefined;
+            Holder?: undefined;
+        } | {
+            Pool?: 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)[];
+        };
+        amount: {
+            Bps: number[];
+            Fixed?: undefined;
+        } | {
+            Fixed: bigint[];
+            Bps?: undefined;
+        };
+        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): {
+    Item?: undefined;
+    Compressed: {
+        item: any;
+        tree: string;
+    };
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Compressed?: undefined;
+    Item: any[];
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Item?: undefined;
+    Compressed?: undefined;
+    Held: any[];
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Item?: undefined;
+    Compressed?: undefined;
+    Held?: undefined;
+    Nft: {
+        stash: any;
+        nft: any;
+    };
+    Roll?: undefined;
+    Tokens?: undefined;
+} | {
+    Item?: undefined;
+    Compressed?: undefined;
+    Held?: undefined;
+    Nft?: undefined;
+    Roll: any[];
+    Tokens?: undefined;
+} | {
+    Item?: undefined;
+    Compressed?: undefined;
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens: {
+        from: {
+            Pool: any[];
+            Mint?: undefined;
+        } | {
+            Pool?: undefined;
+            Mint: string[];
+        };
+        amount: {
+            Bps: number[];
+            Fixed?: undefined;
+        };
+    };
+} | {
+    Item?: undefined;
+    Compressed?: undefined;
+    Held?: undefined;
+    Nft?: undefined;
+    Roll?: undefined;
+    Tokens: {
+        from: {
+            Pool: any[];
+            Mint?: undefined;
+        } | {
+            Pool?: undefined;
+            Mint: string[];
+        };
+        amount: {
+            Bps?: undefined;
+            Fixed: 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): {
+    price: bigint;
+    mint: string;
+    shares: any;
+    places: any;
+    ticket_mint: string;
+    every: bigint;
+    draws_at: 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;
+            } | {
+                Item?: undefined;
+                Collection: any[];
+            };
+            key: any;
+            test: any;
+        } | null)[];
+    } | null;
+    per_wallet: any;
+    nft_ticket: {
+        rule: {
+            of: {
+                Item: any[];
+                Collection?: undefined;
+            } | {
+                Item?: undefined;
+                Collection: any[];
+            };
+            key: any;
+            test: any;
+        } | null;
+        then: string | {
+            Stash: any[];
+            Give?: undefined;
+        } | {
+            Stash?: undefined;
+            Give: any[];
+        };
+    } | null;
+    returns: boolean;
+    min_sold: 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;
+            } | {
+                Item?: undefined;
+                Collection: any[];
+            };
+            key: any;
+            test: any;
+        } | null)[];
+    } | null;
+    deciders: any;
+    min_pot: bigint;
+    stake: bigint;
+    prize: {
+        Item?: undefined;
+        Compressed: {
+            item: any;
+            tree: string;
+        };
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Compressed?: undefined;
+        Item: any[];
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Item?: undefined;
+        Compressed?: undefined;
+        Held: any[];
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Item?: undefined;
+        Compressed?: undefined;
+        Held?: undefined;
+        Nft: {
+            stash: any;
+            nft: any;
+        };
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Item?: undefined;
+        Compressed?: undefined;
+        Held?: undefined;
+        Nft?: undefined;
+        Roll: any[];
+        Tokens?: undefined;
+    } | {
+        Item?: undefined;
+        Compressed?: undefined;
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens: {
+            from: {
+                Pool: any[];
+                Mint?: undefined;
+            } | {
+                Pool?: undefined;
+                Mint: string[];
+            };
+            amount: {
+                Bps: number[];
+                Fixed?: undefined;
+            };
+        };
+    } | {
+        Item?: undefined;
+        Compressed?: undefined;
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens: {
+            from: {
+                Pool: any[];
+                Mint?: undefined;
+            } | {
+                Pool?: undefined;
+                Mint: string[];
+            };
+            amount: {
+                Bps?: undefined;
+                Fixed: bigint[];
+            };
+        };
+    } | null;
+    prize_split: boolean;
+    nft: {
+        of: {
+            Item: any[];
+            Collection?: undefined;
+        } | {
+            Item?: undefined;
+            Collection: any[];
+        };
+        key: any;
+        test: any;
+    } | null;
+};
+export declare function farmArgs(f: any, m: any): {
+    custody: any;
+    rewards_pool: any;
+    tiers: any;
+    boosts: any;
+    max_boost_bps: number;
+    gates: ({
+        of: {
+            Item: any[];
+            Collection?: undefined;
+        } | {
+            Item?: undefined;
+            Collection: any[];
+        };
+        key: any;
+        test: any;
+    } | null)[];
+    rate: {
+        per_day: bigint;
+        mints: boolean;
+    } | null;
+    growth: {
+        key: any;
+        per_day: any;
+        level: any;
+        steps: any;
+        streak: boolean;
+    }[];
+    ends_at: bigint;
+    lock_key: any;
+    upkeep_key: any;
+    exit_to: string | {
+        Pool: any[];
+    } | null;
+    unbond: number;
+    toll: {
+        bps: number;
+        to: string | {
+            Pool: any[];
+        };
+    } | null;
+};
+/** A fee's sink (`Sink`): "burn", or "pool:<key>", one of the project's pools. */
+export declare const sinkOf: (to: any, m: any) => "Burn" | {
+    Pool: 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;
+            } | {
+                Item?: undefined;
+                Collection: any[];
+            };
+            key: any;
+            test: any;
+        } | null)[];
+    } | null;
+    nft_bids: {
+        of: {
+            Item: any[];
+            Collection?: undefined;
+        } | {
+            Item?: undefined;
+            Collection: any[];
+        };
+        key: any;
+        test: any;
+    } | null;
+};
+export declare function grantArgs(g: any, m: any): {
+    gives: {
+        Item?: undefined;
+        Compressed: {
+            item: any;
+            tree: string;
+        };
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Compressed?: undefined;
+        Item: any[];
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Item?: undefined;
+        Compressed?: undefined;
+        Held: any[];
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Item?: undefined;
+        Compressed?: undefined;
+        Held?: undefined;
+        Nft: {
+            stash: any;
+            nft: any;
+        };
+        Roll?: undefined;
+        Tokens?: undefined;
+    } | {
+        Item?: undefined;
+        Compressed?: undefined;
+        Held?: undefined;
+        Nft?: undefined;
+        Roll: any[];
+        Tokens?: undefined;
+    } | {
+        Item?: undefined;
+        Compressed?: undefined;
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens: {
+            from: {
+                Pool: any[];
+                Mint?: undefined;
+            } | {
+                Pool?: undefined;
+                Mint: string[];
+            };
+            amount: {
+                Bps: number[];
+                Fixed?: undefined;
+            };
+        };
+    } | {
+        Item?: undefined;
+        Compressed?: undefined;
+        Held?: undefined;
+        Nft?: undefined;
+        Roll?: undefined;
+        Tokens: {
+            from: {
+                Pool: any[];
+                Mint?: undefined;
+            } | {
+                Pool?: undefined;
+                Mint: string[];
+            };
+            amount: {
+                Bps?: undefined;
+                Fixed: 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;
+        per_day: any;
+        total: any;
+        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;
+            } | {
+                Item?: undefined;
+                Collection: any[];
+            };
+            key: any;
+            test: any;
+        } | null)[];
+    } | null;
+};
+/**
+ * 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 the seed of its rewards pool lands, and anyone may stake in between. That is safe: a sharing
+ * farm credits nothing at once, and releases what lands in its pool 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;
+        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;
+    };
+};
+/** A stash's bytes before its NFTs: its tag, its project, its id and its count (`stash.rs`); each NFT adds 32. */
+export declare const STASH_HEAD_BYTES = 41;
+/** 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;
+/** 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;
+};
+/**
+ * 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[];
+}[];
+/**
+ * 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[];
+    }[];
+    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[];