@xgamesfun/solana 0.0.0-stage → 0.24.0

package/types/economy/live.d.mts

@@ -0,0 +1,124 @@
+import { randomBytes } from '../chain/bytes.js';
+/** A key for each fresh account the plan creates. Their secret halves are made by whoever signs (the page). */
+export declare function freshAddresses(names: any, random?: typeof randomBytes): {
+    [k: string]: any;
+};
+/**
+ * The transactions that put `economy` live for `owner`, with `keys` the addresses of the fresh accounts (each signs
+ * the transaction that creates it). `live`: what is already live (a change publishes only what differs).
+ */
+export declare function prepare(economy: any, { owner, keys, live, now, rent, only, slot }: {
+    keys: any;
+    live?: null | undefined;
+    now?: number | undefined;
+    only?: null | undefined;
+    owner: any;
+    rent: any;
+    slot?: 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[];
+} | {
+    ok: boolean;
+    refusals: any[];
+    warnings: any[];
+    steps?: undefined;
+    transactions?: undefined;
+    approvals?: undefined;
+    freshKeys?: undefined;
+    ctx: {
+        owner: any;
+        authority: any;
+        collection: any;
+        tree: any;
+        project: any;
+        treasury: any;
+        mints: {};
+        keys: any;
+        rent: any;
+        slot: null;
+    };
+} | {
+    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[];
+    ctx: {
+        owner: any;
+        authority: any;
+        collection: any;
+        tree: any;
+        project: any;
+        treasury: any;
+        mints: {};
+        keys: any;
+        rent: any;
+        slot: null;
+    };
+};
+/**
+ * The parts of an economy whose widest transaction passes a legacy transaction, so a player sends it in one approval
+ * only with the project's standing lookup table: a box's open or settle and a craft the checker sizes past one
+ * (W-TX-V0, W-SETTLE-V0), an auction whose bids are NFTs (each moves with its own accounts), and a farm of another
+ * collection's NFTs (a pNFT's stake and exit carry its token record and rule set). [{ where, why }]
+ */
+export declare function wideParts(m: any, warnings?: any[]): {
+    where: any;
+    why: string;
+}[];
+/**
+ * The spec once its setup landed: every part keeps the program number it was given, and `live` names the game, its
+ * collection, the treasury, the mints made and the program, with a copy of what is now on chain.
+ */
+export declare function recordLanded(economy: any, { ctx, signatures, at, now }: {
+    at?: string | undefined;
+    ctx: any;
+    now: any;
+    signatures?: never[] | undefined;
+}): any;
+/**
+ * What a change to a live economy publishes: the parts that are new or differ from what is on chain (`live.published`),
+ * as the part ids setupSteps takes (`only`), and in words what cannot change. `settings`: the project's own settings
+ * the spec changes (its authority, treasury, collections), which a publish never writes.
+ */
+export declare function changedParts(economy: any): {
+    only: null;
+    fixed: never[];
+    removed: never[];
+    settings: never[];
+} | {
+    only: Set<any>;
+    fixed: string[];
+    removed: string[];
+    settings: string[];
+};

package/types/economy/model.d.mts

@@ -0,0 +1,431 @@
+/** The two flat fees, in lamports, as the platform sets them by default; the program caps each at 0.01 SOL. */
+export declare const FEES: Readonly<{
+    player: 2000000n;
+    project: 10000n;
+}>;
+/**
+ * What MagicBlock's VRF oracle queue (Cuj97ggr…, ephemeral-vrf-sdk 0.17.2 consts.rs DEFAULT_QUEUE) takes for each
+ * random number asked of it: VRF_LAMPORTS_COST = 500,000 lamports, 0.0005 SOL (magicblock-labs/ephemeral-vrf,
+ * api/src/consts.rs; the high-priority queue's 800,000 is not the one loot uses). Paid by whoever asks: the player
+ * on `open_box` (order.rs), whoever sends `draw_lottery` (lottery.rs, its `payer`), the authority on `roll`
+ * (roll.rs). Measured on devnet: 500,000 lamports per open.
+ */
+export declare const ORACLE_FEE = 800000n;
+/**
+ * What js/play's throwaway settle key is funded with, in the purchase's own transaction, for each prize its settle may
+ * open or mint (`loot.SETTLE_RENT_UNIT`): whoever settles pays that rent, the order lends nothing. What the settle
+ * doesn't spend goes back to the player when the key empties itself, and all of it when the roll fails.
+ */
+export declare const SETTLE_RENT_UNIT = 6000000n;
+/** Rent: (bytes + 128) × 5,080 lamports, as `solana rent` reads it on devnet and mainnet-beta. */
+export declare const RENT_PER_BYTE = 5080n;
+export declare const ACCOUNT_OVERHEAD = 128n;
+/**
+ * The most rent a byte has cost on any Solana cluster: 3,480 lamports a byte-year for two years, the rate before
+ * devnet and mainnet lowered it (a local validator and LiteSVM still charge it). An RPC that asks more is not believed.
+ */
+export declare const MOST_RENT_PER_BYTE = 6960n;
+export declare const rent: (bytes: any) => bigint;
+/**
+ * A collectible's Core account, paid from the SOL its order holds (or by whoever gives it): its rent (a Core asset of
+ * about 190 bytes) plus Metaplex Core's creation fee of 0.0015 SOL, which the account keeps. The full simulation
+ * measures 0.00309 to 0.00313 SOL across its fixtures.
+ */
+export declare const COLLECTIBLE_RENT = 3100000n;
+/** The network's base fee per signature. Priority fees are extra and up to the wallet. */
+export declare const SIGNATURE_FEE = 5000n;
+export declare const LAMPORTS_PER_SOL = 1000000000n;
+export declare const WSOL = "So11111111111111111111111111111111111111112";
+/** The limits a spec meets: the chain's (the oracle's answer carries 21 accounts; a farm names a tier and a recipe a
+ * collectible's place in a byte; Bubblegum keeps a compressed NFT's link in 200 bytes and its name in 32) and the two
+ * caps that keep a farm's numbers from overflowing. Since loot 0.22 the program caps no count or size of its own. */
+export declare const LIMITS: Readonly<{
+    callbackAccounts: 21;
+    tiers: 256;
+    collectiblesPerCraft: 255;
+    vouchers: 3;
+    compressedNameBytes: 32;
+    compressedUriBytes: 200;
+    maxBoostBps: 1000000;
+    maxTierBps: 110000;
+    boxEntries: 128;
+    boxSlots: 32;
+    boxOdds: 32;
+    boxFates: 64;
+    entryPrizes: 14;
+    itemTraits: 64;
+    traitKeyBytes: 64;
+    recipeLines: 48;
+    farmRules: 32;
+    growthSteps: 128;
+    contestSides: 1024;
+    deciders: 32;
+    collections: 32;
+    lotteryRuns: 64;
+    farmEnds: 100000;
+}>;
+/** Attribute names the program writes itself, which a recipe cannot copy and `Set` cannot change (craft.rs, make.rs),
+ * and the two a collectible's life keeps (`lifeLines`: its uses and its next use). */
+export declare const RESERVED_ATTRIBUTES: readonly string[];
+export declare const RARITIES: readonly string[];
+/** A refusal raised while reading a value; the checker turns it into a refusal with a code. */
+export declare class SpecError extends Error {
+    code: any;
+    fix: any;
+    constructor(code: any, message: any, fix: any);
+}
+/** A plain decimal string for an amount written as a number or text (no exponent). */
+export declare function decimalText(amount: any): string;
+/** "0.1" of a currency with 9 decimals → 100000000n. Refuses more decimals than the currency has. */
+export declare function toUnits(amount: any, decimals: any): bigint;
+/** 100000000n with 9 decimals → "0.1". */
+export declare function fromUnits(units: any, decimals: any): string;
+/** A count written as an amount (a contest of NFTs counts NFTs): 2 or "2" → 2n. Null when it is not a whole number. */
+export declare function wholeCount(value: any): bigint | null;
+/** 2.5 (percent) → 250 basis points. Null when it is not a whole number of hundredths. */
+export declare function toBps(percent: any): number | null;
+/** "7d" → 604800. A number is seconds already. */
+export declare function toSeconds(duration: any): number;
+/**
+ * How long what lands in a farm's rewards vault takes to be released to its seats, in seconds (a farm that shares what
+ * lands, `farm.rs` `release_span`): its longest lock tier, and a day at least.
+ */
+export declare const releaseSeconds: (f: any) => number;
+/** A farm's release span in words: "a day", "30 days", "36 hours". */
+export declare function releaseWords(f: any): string;
+/**
+ * What a run sent late does, in words (schedule.rs `catches_up`): a sealed schedule's fixed amount pays every run due;
+ * any other run pays once, for the latest run due, and the runs before it lapse.
+ */
+export declare const lateRunWords: (s: any) => "a run missed is missed: one sent late pays once, for the latest run due, and the runs before it lapse" | "a run sent late pays every run due since";
+/**
+ * Whether a farm's boost reads a number its own growth writes (`refresh_seat` writes it): each level counts from when it is
+ * written, so a page or a keeper should refresh seats.
+ */
+export declare const boostReadsGrowth: (f: any) => any;
+/** A box's roll against what is in stock, in words (order.rs): the odds stay as written, whatever is left. */
+export declare const STOCK_WORDS = "The odds stay as written whatever is in stock: a draw that lands on an outcome that can\u2019t be given then (its pool short of the whole amount, its item or stash gone) is not made, no other outcome takes its place, and that draw\u2019s worth of the price goes back at the settle; with no draw made at all, a paid open fails and is refunded, and a free roll goes back to waiting";
+/**
+ * What a box that rolls does once an outcome can't be given (`whenOut`, order.rs `WhenOut`), in words. `sold`: it is
+ * sold (an open checks the stock); a box only other routes roll (a prize, a mission) never stops a sale.
+ */
+export declare function whenOutWords(b: any, { sold }?: {
+    sold?: boolean | undefined;
+}): "The odds stay as written whatever is in stock: a draw that lands on an outcome that can’t be given then (its pool short of the whole amount, its item or stash gone) is not made, no other outcome takes its place, and that draw’s worth of the price goes back at the settle; with no draw made at all, a paid open fails and is refunded, and a free roll goes back to waiting" | "When an outcome runs out (an item sold out, a pool short of its prize, a stash empty), a roll draws among the outcomes still there by their written weights, so the others’ chances rise; with nothing left at all, a free roll waits to be asked again and a paid one is refunded" | "When an outcome runs out (an item sold out, a pool short of its prize, a stash empty), the box keeps selling while its first draw has anything left, and a roll draws among the outcomes still there by their written weights: the others’ chances rise as one runs out, so a player can empty a common outcome to make a rare one likelier (a box selling a rare prize should stop selling instead, the default)" | "When an outcome runs out, the box stops selling: it isn’t sold while any outcome couldn’t cover this purchase’s draws and those of purchases still waiting for the oracle (an item’s units left, a pool’s tokens, a stash’s NFTs), so every roll is on the odds as written and nobody can buy their way to a refund on every miss; it sells again once the project restocks or edits the box (an outcome whose odds shrink with stock needs no cover). An outcome emptied another way all the same (another route sharing its pool, item or stash) makes no draw, no other outcome taking its place, and gives back that draw’s worth of the price at the settle; with no draw made at all, the open is refunded";
+/**
+ * What the end of a sharing farm that `runs` means, in words, or null (no end, or a fixed rate): its release keeps its
+ * pace, so what it has not let go by the end stays in its vault, free for the authority to take back, and so does what
+ * a seat forfeits after the end.
+ */
+export declare function farmEndWords(f: any): string | null;
+/**
+ * The token a farm's rewards are in (`rewards`, a token key): by default its staked token, or for a farm of
+ * collectibles the project's currency. One that names a pool (as farms did before they had a vault of their own) is
+ * read as that pool's token, and the checker refuses it.
+ */
+export declare function farmRewardsToken(f: any, tokens: any, currencyKey: any, poolCurrency?: Map<any, any>): any;
+/** A raise's or a shift's `by`: a number, or for a time a duration, which may be negative ("-1d"). */
+export declare function toBy(by: any): any;
+/** "publish", "publish+7d" or a date → Unix seconds, counted from `now` (Unix seconds) for the first two. */
+export declare function toTime(time: any, now: any): any;
+export declare const rarityNumber: (rarity: any) => number;
+export declare const utf8Bytes: (s: any) => number;
+export declare const isAddress: (s: any) => boolean;
+/** Where an NFT paid goes, in the program's words (`Spend`, `Then`): "burn", "treasury" (its wallet, filled in at go-live), { giveTo }, or { stash }. */
+export declare const spendOf: (then: any, m: any) => "Burn" | {
+    Stash: any[];
+    Give?: undefined;
+} | {
+    Stash?: undefined;
+    Give: any[];
+};
+/**
+ * The spec with references resolved and ids given. Unknown references stay as they are (the checker reports
+ * them); call `check` first when it matters.
+ */
+export declare function model(economy: any, { now }?: {
+    now?: number | undefined;
+}): {
+    now: number;
+    name: any;
+    authority: any;
+    /** The wallet whose account for the currency is the treasury, when it isn't the owner's ("wallet:<address>"). */
+    treasuryWallet: any;
+    tokens: Map<any, any>;
+    currencyKey: any;
+    currency: any;
+    /** The collection the setup makes (null when the spec says `"collection": false`: a project of tokens only). */
+    collection: any;
+    /** Core collections the owner already has that the project also takes (its update authority is the owner). */
+    collections: any;
+    /** How many compressed NFTs the project's tree holds (`compressedTree`), when a prize gives one. */
+    treeHolds: any;
+    /** The project's number among its owner's: its address is ["project", owner, number]. */
+    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 NFTs a stash lists, each as the program's `piece` takes it: a Core asset (`asset`, its `collection`: its own, the
+ * stash's, or the game's when neither says), a Token Metadata NFT (`mint`, `programmable`, `ruleSet`), or a compressed
+ * NFT (`compressed`, its asset id).
+ */
+export declare function stashNfts(s: any): any;
+/**
+ * A prize as the spec writes it (`$defs/prize`), read the one way: a line { gives, … } as a recipe's `out` lines are:
+ * "item" (`item`), "tokens" (`amount`, `from` "mint" with `currency`, or "pool:<key>"),
+ * "nft" (`nft`, an address the stash `stash` lists) or "roll" (a roll of `box`; in a recipe, on the collectible kept
+ * at `on`). A grant's older `gives` ({ item }, { pool, amount }, { roll }) reads as its line. Null for none.
+ */
+export declare function prizeLine(p: any): any;
+/** The pool a prize line pays from: tokens' "pool:<key>". */
+export declare const prizePool: (p: any) => any;
+/** The token a prize line pays in: its pool's, or the one it mints. */
+export declare const prizeToken: (p: any, m: any) => any;
+/**
+ * Every prize the spec gives (prize.rs): a grant's, a lottery place's, a contest's winners', a mission tier's and a
+ * recipe's `out` lines. [{ prize (a line), where, by, route, strict, once }] `strict`: the route refuses a prize it
+ * can't give (a grant's claim, a craft); any other goes on without it. `once`: the route gives it once at most (a
+ * grant of one claim in all).
+ */
+export declare function prizes(m: any): any[];
+/**
+ * The project's tree of compressed NFTs (`open_tree`), when a prize gives one (`"compressed": true`), else null: deep
+ * enough for `treeHolds` (14 to 20 levels, Bubblegum's sizes for a buffer of 64), its canopy keeping a proof at 10
+ * nodes or a few more (at most 8 levels: past that the rent grows faster than the proofs shrink). { depth, buffer,
+ * canopy, bytes }
+ */
+export declare function compressedTree(m: any): {
+    depth: number;
+    buffer: number;
+    canopy: number;
+    bytes: number;
+} | null;
+/**
+ * Every route that gives a roll of a box, with the box it names: a prize's roll (`prizes`), an auction's lot, a
+ * mission's roll on the NFT leaving it and a recipe's roll on a collectible it keeps. [{ box, by, route }]
+ */
+export declare function prizeRolls(m: any): {
+    box: any;
+    by: any;
+    route: any;
+}[];
+/**
+ * Every roll of a box any route makes, for the checks keyed on "a box something rolls": `prizeRolls`, every box
+ * outcome's (or bundle part's) roll of another box (route "box", made at its settle), and, followed through chains,
+ * each route that rolls a box whose outcome rolls another (a grant's roll of “mid”, whose outcome rolls “inner”, is a
+ * roll of “inner” by the grant, `through` ["mid"]). [{ box, by, route, through? }]
+ */
+export declare function rollsOf(m: any): {
+    box: any;
+    by: any;
+    route: any;
+}[];
+/** A prize line in words: "one Badge", "100 GOLD from “rewards”", "100 GOLD, minted", "the NFT ab12…cd34 of “vault”", "a roll of “Chest”". */
+export declare function prizeWords(p: any, m: any): string;
+/**
+ * What one box outcome gives (catalog.rs), each in the box's own words: "item", "pay" (a fixed amount from a pool),
+ * "stash" (an NFT of a stash at random), "mint"
+ * (tokens minted), "nft" (one NFT a stash lists) or "roll" (a roll of another box). A bundle gives its `prizes`; "burn"
+ * and "nothing" give none.
+ */
+export declare function outcomeParts(o: any): any;
+/** Whether a box leaves its outcome to the oracle (catalog.rs `rolls`): more than one outcome, or an NFT at random. */
+/** How many draws one open of a box makes: its slots' counts, or one. */
+export declare const drawsOf: (b: any) => any;
+/** Whether a box's prize costs its settle a collectible's rent: an item minted as a Core NFT, or a fresh compressed one
+ * (its traits' Sheet). A plain compressed NFT costs no rent. */
+export declare const holdsRent: (p: any, m: any) => boolean;
+/**
+ * The units of `SETTLE_RENT_UNIT` a settle of box `b`'s order may spend (`loot.settleRent`), which js/play funds its
+ * throwaway settle key with and gets back unspent: for each draw, each part of the richest outcome that opens an
+ * account (a collectible, a fresh compressed NFT's Sheet, a stash's NFT); once an order, each source of tokens it may
+ * pay, and the fate of the NFT it rolls on.
+ */
+export declare function settleUnits(b: any, m: any): number;
+export declare const boxRolls: (b: any, m: any) => any;
+/** Whether a box sells with `buy`, in one transaction (buy.rs): it doesn't roll and rolls on no NFT, any number of draws
+ * a sale (a fixed pack: its prizes given once for each draw). */
+export declare const boxBuys: (b: any, m: any) => boolean;
+/**
+ * What a recipe's lines owe the life of each collectible they take (an item's `life`), as the program's needs and
+ * raises (craft.rs `Need`, `Raise`), at each collectible's place in the recipe (each burned unit, then each kept one, in
+ * line order; a pay line takes none): ready after `readyAfter` (`made` older than it), for `lasts` (`made` within it),
+ * on every line that takes it; `uses` times (`used` raised by 1 up to it) and a `cooldown` (`next_use` passed, then
+ * raised to that far from now) on a line that uses it or takes it staked; a renew line counts its uses from 0 again.
+ * { needs, raises }, in the program's shapes.
+ */
+export declare function lifeLines(r: any, m: any): {
+    needs: any[];
+    raises: any[];
+};
+/** A lottery's place as { percent, prize }: a number is a share of the pot and no prize. */
+export declare const placeOf: (p: any) => {
+    percent: any;
+    prize: any;
+    times: any;
+};
+/** "pool:house" → { kind: 'pool', key: 'house' }; "burn" → { kind: 'burn' }. */
+export declare function destination(to: any): {
+    kind: string;
+    key?: undefined;
+} | {
+    kind: string;
+    key: string;
+};
+/** The share with its basis points, or null bps when the percent is not whole hundredths. */
+export declare const sharesOf: (split: any) => any;
+/**
+ * The program's `To` for a destination, with pool indexes resolved (the IDL's own shape). A wallet ("wallet:<address>")
+ * is paid at its own token account of the part's currency (the program opens it when it is not there); "treasury" is the game's treasury wallet's; "chosen"
+ * (or "chosen:<item>") is the one the buyer names when they buy; "lottery:<key>" is that lottery's pot
+ * ("@pot:<id>") and "farm:<key>" that farm's rewards vault ("@rewards:<id>"), which the plan resolves once the game is
+ * known.
+ */
+export declare function toEnum(to: any, m: any): "Burn" | "Treasury" | {
+    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)[];
+};
+/**
+ * The program's `Rule` for a spec rule: which NFTs (a collection's, or an item's the game mints), an attribute and its
+ * test. With neither, the collection the game has authority over: `@collection`, filled in when the economy goes live.
+ */
+export declare function ruleOf(rule: any, m: any): {
+    of: {
+        Item: any[];
+        Collection?: undefined;
+    } | {
+        Item?: undefined;
+        Collection: any[];
+    };
+    key: any;
+    test: any;
+} | null;
+/** One thing or a list of them, as a list: a farm's `gate` and `growth` take either. */
+export declare const listOf: (x: any) => any[];
+/**
+ * The program's `Gate` for a spec gate: a few wallets (`wallets`), a list of any size (`list`: an allowlist, its root and
+ * depth: the client's `gateList`), a stake (`staked`: at least `atLeast` of a farm's token in the wallet's seat; the farm's address
+ * is "@farm:<id>", filled in when the project is known), or a rule a collectible the player shows must pass.
+ */
+export declare const gateOf: (gate: any, m: any) => {
+    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;
+/** The program's `PerWallet` for a part's "perWallet" (in all) and "perWalletEach" ({ count, every }). */
+export declare const perWalletOf: (part: any) => {
+    total: any;
+    per_window: any;
+    window: number;
+};
+/** The program's `Window` for a part's "opens" and "closes" (times; 0 leaves a side open). */
+export declare const windowOf: (part: any, now: any) => {
+    opens_at: bigint;
+    closes_at: bigint;
+};
+/** A lottery's split of ticket money: its own, and "cutPercent" as a share to the treasury. */
+export declare const lotterySplit: (l: any) => any[];
+/** The program's `Effect` for a spec effect: a flat share, or a share per point of the attribute. */
+export declare function effectOf(effect: any): {
+    PerPoint: {
+        bps: number;
+        most: any;
+    };
+    Flat?: undefined;
+} | {
+    PerPoint?: undefined;
+    Flat: number[];
+};
+/** A box's outcomes with their program weights: chances become whole weights (hundredths of a basis point). */
+export declare function weights(box: any): any;
+/** Every place the spec names a pool as somewhere money leaves from, with what takes it. */
+export declare function poolTakers(m: any): any[];
+/** Every place the spec sends money into a pool. */
+export declare function poolFillers(m: any): any[];
+/**
+ * Every place the spec sends money into a farm's rewards vault ("farm:<key>"): a split's share, a schedule that pays it,
+ * a craft that pays it, the owner's seed, an early exit's fee into its own vault. [{ farm, by, how }]
+ */
+export declare function farmFillers(m: any): {
+    farm: any;
+    by: string;
+    how: string;
+}[];