@xgamesfun/solana 0.0.0-stage → 0.24.0

package/types/client/pda.d.ts

@@ -0,0 +1,95 @@
+import { MPL_CORE_PROGRAM } from '../chain/pda.js';
+export declare const LOOT_PROGRAM: string;
+/** MagicBlock's VRF program and its default queue, the only queue the program accepts. */
+export declare const VRF_PROGRAM = "Vrf1RNUjXmQGjmQrQLvJHs9SNkvDJEsRVFPkfSQUwGz";
+export declare const VRF_QUEUE = "Cuj97ggrhhidhbu39TijNVqE74xvKJ69gDervRUXAxGh";
+export { MPL_CORE_PROGRAM };
+export declare const BPF_LOADER_UPGRADEABLE = "BPFLoaderUpgradeab1e11111111111111111111111";
+/** Compressed NFTs: Bubblegum, and the account compression program and noop of its v2 trees. */
+export declare const BUBBLEGUM_PROGRAM = "BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY";
+export declare const COMPRESSION_PROGRAM = "mcmt6YrQEMKw8Mw43FmpRLmf7BqRnFMKmAcbxE3xkAW";
+export declare const NOOP_PROGRAM = "mnoopTCrg4p8ry25e4bcWA9XZjbNjMTfgYVGGEdRsf3";
+/** The PDA of these seeds under the loot program, with its bump. */
+export declare const lootAddress: (seeds: any, program?: string) => any;
+export declare const pda: {
+    platform: () => any;
+    /** A project: any wallet (its creator) opens as many as it likes, each with a number of its own (`id`, a u64). A
+     * new owner keeps the address. */
+    project: (creator: any, id?: number) => any;
+    /** The project's fee box: where the platform's fees on its transactions wait. */
+    fees: (project: any) => any;
+    pool: (project: any, index: any) => any;
+    item: (project: any, id: any) => any;
+    box: (project: any, id: any) => any;
+    /** NFTs the project holds to give away as prizes: a box entry of a stash gives one of them at random. */
+    stash: (project: any, id: any) => any;
+    /** A table of weighted rows the project writes and seals (a card among thousands, a trait's values), or commits by a Merkle root. */
+    table: (project: any, id: any) => any;
+    /** What the project keeps about a wallet (its player's profile: XP, level, rank). */
+    profile: (project: any, wallet: any) => any;
+    schedule: (project: any, id: any) => any;
+    lottery: (project: any, id: any) => any;
+    recipe: (project: any, id: any) => any;
+    contest: (project: any, id: any) => any;
+    /** An auction: an id is its seller's own. Its bids wait in the project's vault for its mint (`vault`). */
+    auction: (project: any, seller: any, id: any) => any;
+    farm: (project: any, id: any) => any;
+    grant: (project: any, id: any) => any;
+    order: (project: any, player: any, nonce: any) => any;
+    /** Every collectible the program mints of its own accord (an order's, a prize's, an auction's lot): its address
+     * names its item and its serial, minted once at most. */
+    itemAsset: (item: any, serial: any) => any;
+    /** A contest's pot, or a lottery's: `["pot", contest or lottery]`. */
+    pot: (record: any) => any;
+    /** One round of a lottery: its record, opened by the round's first purchase (`["round", lottery, incarnation, round]`). */
+    round: (lottery: any, incarnation: any, round: any) => any;
+    /** A lottery round's own token account of `mint`, which the round's record owns. */
+    roundTokens: (round: any, mint: any) => any;
+    /** A contest's list of entries, one record a player (page 0). */
+    entries: (contest: any, incarnation: any, page?: number) => any;
+    /** A hold names its NFT and its end (Unix seconds): a release sent late never finds a later hold of the NFT. */
+    hold: (asset: any, freeAt: any) => any;
+    /** An offer: an id is its maker's own. Its money waits in the project's vault for its mint (`vault`). */
+    offer: (project: any, maker: any, id: any) => any;
+    /** A lottery's own stash: the NFTs its places promise (`Prize::Held`), which leave only as its prizes. */
+    lotteryStash: (lottery: any) => any;
+    /** A contest's prize split by stake, set aside when it is decided: `["prize", contest]`. */
+    prizeVault: (contest: any) => any;
+    /** A sealed schedule's own vault, which only its runs pay out of: `["vest", schedule]`. */
+    vest: (schedule: any) => any;
+    /** A listing of an NFT for sale or for rent: one per NFT a project holds, so its address names the NFT. */
+    listing: (project: any, asset: any) => any;
+    staked: (farm: any) => any;
+    rewards: (farm: any) => any;
+    /** A farm's record of when its seats stop earning, for a farm that keeps one (`Farm.keeps_ends`). */
+    ends: (farm: any) => any;
+    /** A seat: a player's in a farm of tokens, a collectible's (its asset) in a farm of collectibles. */
+    seat: (farm: any, by: any) => any;
+    /** What the project writes about an NFT it has no authority over (its Sheet): `nft` is a Core asset, a Token Metadata mint or a compressed NFT's asset id. */
+    sheet: (project: any, nft: any) => any;
+    /** A compressed NFT as last proven (`prove_leaf`), read while the leaf is unchanged and its root is still in the tree's change log. */
+    leaf: (asset: any) => any;
+    /** The root of the traits the project vouches for, under its own `key` (a collection's address, by convention). */
+    traits: (project: any, key_: any) => any;
+    /** Bubblegum's config of a tree: `[tree]`. */
+    treeConfig: (tree: any) => any;
+    /** A compressed NFT's asset id: Bubblegum's `["asset", tree, nonce]`, `nonce` the count minted before it. */
+    compressedAsset: (tree: any, nonce: any) => any;
+    /** A wallet's counts in a project: how many times it bought from each box, crafted each recipe or held tickets in
+     * a lottery's round that limits it (`decodeCounts`). */
+    counts: (project: any, wallet: any) => any;
+    /** Shard `shard` of a grant's limit records: what each wallet, person, badge and voucher key claimed. */
+    claims: (grant: any, incarnation: any, shard: any) => any;
+    /** Shard `shard` of the rounds a grant paid. */
+    rounds: (grant: any, incarnation: any, shard: any) => any;
+    /** The program's identity, which signs its requests to the oracle. */
+    identity: () => any;
+    /** The identity the oracle signs callbacks with: the VRF program's PDA for this program. */
+    oracleIdentity: () => any;
+    /** The program's ProgramData account (its upgrade authority signs `init_platform`). */
+    programData: () => any;
+};
+/** `owner`'s associated token account of `mint` (owner may be a PDA: a project's vault, a pool is not one). */
+export declare const ata: (owner: any, mint: any, tokenProgram?: string) => any;
+/** A project's vault for `mint`: its associated token account, where every open order's payment is held. */
+export declare const vault: (project: any, mint: any, tokenProgram?: string) => any;

package/types/client/policy.d.ts

@@ -0,0 +1,48 @@
+/** How long the oracle has to answer before a roll or a draw may be asked again, and a pending order refunded (seconds). */
+export declare const STALE_SECONDS: bigint;
+/** How long after a lottery's first ask the next ask cancels its round, and an asked order holding a payment or an NFT
+ * may be refunded (seconds). */
+export declare const LOTTERY_TIMEOUT_SECONDS: bigint;
+/**
+ * The earliest an order can be refunded, as `{ slot, at }` (the program wants a later slot than `slot` and a later
+ * second than `at`), or null when it never can be as it stands: a failed order from the next slot; a paid order the
+ * oracle never answered 10 minutes after it was asked (`STALE_SECONDS`); an asked roll holding a payment or an NFT 7 days
+ * after its first ask. A rolled order has an outcome to carry out, and is settled. A waiting roll, or an asked one holding
+ * nothing, is asked (again): `rollAskable`.
+ */
+export declare function orderRefundAt(order: any): {
+    slot: bigint;
+    at: null;
+} | {
+    slot: bigint;
+    at: bigint;
+} | {
+    slot: null;
+    at: bigint;
+} | null;
+/** Whether an order can be refunded at `slot` and `now` (Unix seconds, the chain's clock): `orderRefundAt`. */
+export declare function orderRefundable(order: any, slot: any, now: any): boolean;
+/**
+ * Whether its player or the project's keys may ask the oracle for a mission's or a recipe's roll at `slot` and `now`
+ * (Unix seconds, the chain's clock): never asked, or never answered within `STALE_SECONDS`. Once asked, a later ask comes
+ * in a later slot than the last (`SameSlot`: never the same seed twice), so a roll that found nothing in stock and waits
+ * again is asked from the next slot on.
+ */
+export declare const rollAskable: (order: any, slot: any, now: any) => boolean;
+/**
+ * Whether a contest is off at `now` (Unix seconds), as the program reads its verdict: called off, its result
+ * overdue, or short of its least pot once entries closed. Every entry of one that is off takes its money back.
+ */
+export declare function contestOff(contest: any, now: any): boolean;
+/** Whether a lottery round's draw (`round`: its decoded record) was asked for and the oracle has not answered within
+ * `STALE_SECONDS` by `now` (Unix seconds, the chain's clock): anyone may ask again. */
+export declare const lotteryDrawStuck: (round: any, now: any) => boolean;
+/**
+ * Whether a lottery round's draw (`round`: its decoded record) was asked for and the oracle has not answered within
+ * `LOTTERY_TIMEOUT_SECONDS` of the first ask (asking again doesn't move it) by `now` (Unix seconds, the chain's clock):
+ * the next ask of that round (`drawLotteryIx` with its address) cancels it, and every entry is refunded. A round nobody
+ * asked to draw is never cancelled.
+ */
+export declare const lotteryCancellable: (round: any, now: any) => boolean;
+/** A farm seat's `earns_until` when nothing ends its earning (i64::MAX): no tier term and no fuel it reads. */
+export declare const NO_END: bigint;

package/types/client/random.d.ts

@@ -0,0 +1,26 @@
+/** What a path's first word names (`random::tag`): an entry of a box, a stash's NFT, a lottery's ticket, a fresh trait. */
+export declare const TAG: Readonly<{
+    ENTRY: 1;
+    STASH: 2;
+    LOTTERY: 3;
+    TRAIT: 4;
+}>;
+/** The most words a path holds. */
+export declare const MAX_PATH = 8;
+/** A stream of the oracle's 32-byte `answer` at `path` (whole numbers): seed = sha256("loot-roll-v1" | answer | path as
+ * u32 little-endian words); its nth number the first 8 bytes, little-endian, of sha256(seed | n as u64 little-endian). */
+export declare function stream(answer: any, path?: any[]): {
+    next(): bigint;
+};
+/** A number from 0 to `n` - 1, every one as likely: a draw past the last whole multiple of `n` is drawn again. null for
+ * `n` 0. */
+export declare function uniform(s: any, n: any): number | null;
+/** The row `at` lands on, the weights walked in order. null past the last. */
+export declare function walk(weights: any, at: any): any;
+/** A row by weight (a weight of 0 never drawn); null when none weighs anything, or they sum past 64 bits. */
+export declare function weighted(s: any, weights: any): any;
+/** A number from `min` to `max`, both included, every one as likely (either order). */
+export declare function range(s: any, min: any, max: any): any;
+/** A fresh unit's range trait `t` (its place among the item's traits) as the program draws it at the mint: from the
+ * order's `answer`, `at` the unit's place in the order's `won`. */
+export declare const rangeTrait: (answer: any, at: any, t: any, min: any, max: any) => any;

package/types/client/sizes.d.ts

@@ -0,0 +1,101 @@
+/** The space reserved by a fixed-size account, including its discriminator. */
+export declare function allocationBytes(name: any): any;
+/** The exact bytes of a dynamically allocated account. */
+export declare const accountBytes: (name: any, value: any) => number;
+/** A seat; a loan's hold (with room for its debt); a hold a player asks for, made without one (`Hold::PLAIN`). */
+export declare const ACCOUNT_BYTES: Readonly<{
+    Seat: any;
+    Loan: any;
+    Hold: number;
+}>;
+/** A project's bytes with `collections` collections, as the program sizes the account. */
+export declare const projectBytes: (collections?: number) => number;
+/** The most accounts the oracle's answer to a roll carries (`MAX_CALLBACK_ACCOUNTS`). */
+export declare const MAX_CALLBACK_ACCOUNTS = 21;
+/**
+ * The most accounts a roll of `entries` hands the oracle (`catalog::callback_accounts`): the order, the box and the
+ * ticket; one for each prize that needs one at the roll (an item, a pool, a stash); and with tokens, the two token
+ * programs, the project, and a mint and a vault for each source of tokens.
+ */
+export declare function callbackAccounts(entries: any): number;
+/**
+ * How many fresh items' table accounts the oracle's answer to a roll of `entries` can carry (`order::table_budget`):
+ * what the box's own accounts leave of `MAX_CALLBACK_ACCOUNTS`. Negative: the box can't be rolled at all.
+ */
+export declare const tableBudget: (entries: any) => number;
+/** The most an order can be (`MAX_ORDER_BYTES`, not in the IDL): a box whose one open's order would be more is refused
+ * at its upsert (`BadEntries`). In practice a pack is bounded first by what one oracle answer draws (`drawsFit`). */
+export declare const MAX_ORDER_BYTES = 10240;
+/**
+ * The rows of fresh items' tables a draw of each entry writes into its order (`order::rows_of`), walked with the box's
+ * table budget as the roll's accounts are (`entryAccounts`: an item whose tables don't fit what is left draws none).
+ * `items` maps an item's id to its decoded Item; one left out is taken as not fresh.
+ */
+export declare function entryRows(entries: any, items?: {}): any;
+/**
+ * The bytes of an order of `lootBox` with `shares` shares and `opens` opens. With `items` (an item's id to its decoded
+ * Item), as `open_box` sizes it (`Order::sized`): each draw at its dearest entry's prizes as the `Won` they become (an
+ * item 14 bytes, tokens or an NFT 41, a roll none) and 4 bytes for each table row its fresh items draw now
+ * (`entryRows`); its odds and its largest fate. Without `items`, as a roll made inside another call sizes it (a craft,
+ * a grant's claim, a mission, a roll lot: `Order::space_for`): the box's whole table budget a draw for a box that
+ * gives items. A pack's order grows with its cards.
+ */
+export declare function orderBytes(lootBox: any, shares: number | undefined, opens: number | undefined, items: any): number;
+/**
+ * The heap reading a box takes beyond its entries (`order::box_bytes`): its odds, gate, shares, subject, slots and
+ * fates, read whole with it, by their bytes and their number. `box`: the box's args, as `upsertBoxIx` takes them.
+ */
+export declare function boxBytes({ odds, gate, shares, subject, slots, fates }: {
+    fates?: never[] | undefined;
+    gate?: null | undefined;
+    odds?: never[] | undefined;
+    shares?: never[] | undefined;
+    slots?: never[] | undefined;
+    subject?: null | undefined;
+}): bigint;
+/**
+ * Whether all of `opens` opens of `entries` by `slots` fit one oracle answer (`order::draws_fit`), each draw at the
+ * dearest its slot could make, with what is known from the box alone (no table rows, a stash of one group), its `odds`,
+ * `shares` and `fates` counted, and `bytes` (`boxBytes`) of heap reading the box takes beyond its entries. `slots` may
+ * be a number: that many draws among every entry. The answer's heap counts for a box that rolls, or one sold through
+ * the oracle (`oracle`: a box that doesn't roll but one `buy` can't carry, `buyFits`). The program refuses a box whose
+ * one open doesn't fit at its upsert, and a purchase that doesn't at `open_box`, where it also reads what the accounts
+ * hold (`PackTooLarge`).
+ */
+export declare function drawsFit(entries: any, slots: any, opens?: number, { odds, shares, fates, bytes, oracle }?: {
+    bytes?: bigint | undefined;
+    fates?: number | undefined;
+    odds?: number | undefined;
+    oracle?: boolean | undefined;
+    shares?: number | undefined;
+}): boolean;
+/**
+ * Whether one `buy` of a box that doesn't roll (one entry, given `draws` times: its slots' counts) fits one transaction
+ * (`catalog::buy_fits`): its accounts, its instructions and its compute, each prize's at the most it takes. A named NFT
+ * is given once at most. A box that doesn't fit sells through the oracle (`open_box`), its answer's heap counted
+ * (`drawsFit` with `oracle`), and can't give a roll (`PackTooLarge`). `box`: the box's args.
+ */
+export declare function buyFits(box: any, draws?: any): boolean;
+/** The most program rent and fee one order takes from its player, in lamports (0.01 SOL): a client cap (`opensAnOrder`). */
+export declare const ORDER_COST_CAP = 10000000n;
+/**
+ * The most opens of `lootBox` a client puts in one order: what one oracle answer draws (`drawsFit`), and what keeps the
+ * order's rent and the player's fee within `ORDER_COST_CAP` (`orderBytes` with `items`, so with the box's shares). At
+ * least one: a box whose one open is over the cap is still bought one open an order. A purchase of more is several
+ * orders, each its own answer.
+ */
+export declare function opensAnOrder(lootBox: any, { shares, items, rentPerByte }?: {
+    items?: {} | undefined;
+    rentPerByte?: bigint | undefined;
+    shares?: any;
+}): number;
+export declare const LIST_HEAD_BYTES = 7;
+/** A limit record (a wallet's count of a box, a recipe or a lottery round; a grant's claim count): key, count, window, in it. */
+export declare const LIMIT_RECORD_BYTES = 28;
+/** A round a grant paid a wallet: its key alone. */
+export declare const ROUND_RECORD_BYTES = 16;
+/** A contest's entry: of tokens, and of NFTs (the NFT, its place on its side, the picks taken). */
+export declare const CONTEST_ENTRY_BYTES: Readonly<{
+    tokens: 43;
+    nfts: 83;
+}>;

package/types/client/traits.d.ts

@@ -0,0 +1,12 @@
+/** A leaf: an NFT's address and its traits ([{ key, value }], in order). */
+export declare const traitsLeaf: (nft: any, attributes: any) => Uint8Array<ArrayBuffer>;
+/** Two nodes joined, the smaller first, so a proof needs no left or right. */
+export declare const traitsNode: (a: any, b: any) => Uint8Array<ArrayBuffer>;
+/**
+ * The tree of `entries` ([{ nft, attributes }]): { root, proof(nft) → [node, …] bottom up }. A node left without a pair
+ * at a level goes up as it is.
+ */
+export declare function traitsTree(entries: any): {
+    root: any;
+    proof(nft: any): any[];
+};

package/types/economy/check.d.mts

@@ -0,0 +1,100 @@
+/**
+ * The transaction a player sends to craft `recipe`, estimated (txsize.mjs): the craft's own accounts, then each
+ * line's (craft.rs; a roll's box and order), a compute limit (a big recipe needs more
+ * than the default) and, for each token it gives, the player's token account created if missing.
+ */
+export declare function craftSize(recipe: any, m: any, { detail }?: {
+    detail?: boolean | undefined;
+}): any;
+/**
+ * The transaction a player sends to open box `b`, estimated (txsize.mjs) as a wallet sends it: its compute limit and
+ * price, the player's token account of the box's currency created if missing (and for SOL, the wrap around the
+ * purchase), then `open_box` (order.rs): its own accounts (an NFT slot the program leaves empty stands in as the
+ * program's address), an account for each outcome that wins something, each prize mint with the game's vault for it,
+ * and the NFT the player shows for a gate or odds (at its largest, a Token Metadata one's mint, metadata, token
+ * account and Sheet).
+ */
+export declare function openBoxSize(b: any, m: any, { detail }?: {
+    detail?: boolean | undefined;
+}): any;
+/** The longest proof a compressed NFT's tree can leave: Bubblegum v2 refuses a smaller canopy. */
+export declare const LONGEST_PROOF = 17;
+/** How many accounts a transaction may lock: so the most a settle can name. */
+export declare const ACCOUNT_LOCKS = 64;
+/** A v0 transaction's lookup table and the lookup-table program: the transaction deactivates the table it loads from. */
+export declare const TABLE_LOCKS = 2;
+/**
+ * The accounts a settle of box `b` locks for outcome `o`, counted as the client builds it (`settleIx`, sent by anyone
+ * after a Compute Budget instruction, in a v0 transaction with a lookup table, the Sheets of NFTs it doesn't write left
+ * out), at its largest: { count, memo, picks, corePicks, payees, compressedSubject }. `memo`: a payee the project
+ * didn't pick (a holder's share, a buyer's chosen wallet, a wallet's) can turn on required memos for their own
+ * Token-2022 account at any time, and every settle then passes the memo program, one account more.
+ * Matches the program's own measurements: a roll on a compressed NFT of a 17-node
+ * proof is 41 with nothing won; each prize of tokens in a mint of its own 3, each holder's share 3, a hook asking
+ * one account of its own 3, a compressed NFT picked from a stash 22, a Core one of its own collection 2 (Core 1).
+ */
+export declare function settleAccounts(b: any, o: any, m: any, { proof }?: {
+    proof?: number | undefined;
+}): {
+    count: number;
+    keys: string[];
+    memo: boolean;
+    picks: number;
+    corePicks: number;
+    payees: number;
+    compressedSubject: boolean;
+};
+/** The compute a transaction may have: no settle can take more. */
+export declare const MAX_COMPUTE_UNITS = 1400000;
+/**
+ * The compute a settle of box `b`'s outcome `o` takes, estimated at its most from measurements on devnet's
+ * features: about 60,000 units for the settle itself, 250,000 for each Token Metadata
+ * NFT it moves (a pNFT's, with its rule set), 100,000 for a compressed one (or the NFT it rolls on, of a collection
+ * not the game's own), 60,000 for a Core one, 40,000 for each collectible it mints and 20,000 for a roll it makes, and
+ * 30,000 for each token payout (a prize, each share of the price, the treasury's), twice that in a coin with a
+ * transfer hook. Three pNFTs of stashes, the NFT rolled on and four holders' shares (measured 942,389 to 985,942)
+ * come out at about 1,170,000.
+ */
+export declare function settleUnits(b: any, o: any, m: any): number;
+/**
+ * The settle of box `b`'s outcome `o` as xsolana's senders build it (js/play, the keeper's sweep: `settleIx` after a
+ * compute limit, and a heap frame for three NFT moves or more), estimated (txsize.mjs) at its largest:
+ * { legacy: its bytes as a legacy transaction, tableRent: the lamports a lookup table of its accounts holds while it
+ * is open, locks: the accounts it locks (`settleAccounts`) }. A settle bigger than a legacy transaction goes as v0,
+ * its accounts loaded from a table its sender makes first.
+ */
+export declare function settleSize(b: any, o: any, m: any): {
+    legacy: any;
+    tableRent: bigint;
+    locks: number;
+};
+/**
+ * The transaction a player sends to buy box `b` (buy.rs), estimated as `openBoxSize` is: its compute limit and price,
+ * the player's token account of the currency created if missing, then `buy`: its own accounts, what the gate takes
+ * (a list's proof, or the NFT shown), the accounts its shares name, and each prize's (prize.rs; a roll's box and
+ * order), for each draw of a sale (a fixed amount of tokens once). `count`: the sales in one purchase.
+ */
+export declare function buySize(b: any, m: any, { detail, count }?: {
+    count?: number | undefined;
+    detail?: boolean | undefined;
+}): any;
+/** The address a plan stands in for the owner's wallet before one connects (plan.mjs `placeholderContext`). Nobody
+ * holds its key, and the approval page calls it "your wallet" until a wallet connects: no spec may name it. */
+export declare const STAND_IN_OWNER: string;
+/**
+ * Checks an economy spec. `now` (Unix seconds) dates "publish".
+ * Returns { ok, refusals: [{ code, where, message, fix }], warnings: [{ code, where, message, fix? }] }.
+ */
+export declare function check(economy: any, { network, now }?: {
+    network?: string | undefined;
+    now?: number | undefined;
+}): {
+    ok: boolean;
+    refusals: any[];
+    warnings: any[];
+};
+/** A one-line summary for each refusal and warning, as a person reads them. */
+export declare function describe({ refusals, warnings }: {
+    refusals: any;
+    warnings: any;
+}): string;

package/types/economy/cost.d.mts

@@ -0,0 +1,69 @@
+/** Setup cost from a plan (plan.mjs `plan`). */
+export declare function setupCost(plan: any, economy: any): {
+    accounts: any;
+    rentSol: any;
+    programFeesSol: any;
+    networkFeesSol: any;
+    seeds: {};
+    totalSol: any;
+    transactions: any;
+    approvals: any;
+    notes: string[];
+};
+/**
+ * What each action costs whoever signs it while the economy runs: games.fun's fee, the network's, and for anything
+ * that asks MagicBlock's oracle for a random number (a box's open, a lottery's draw, the authority's `roll`) the
+ * oracle's own fee (`oracleSol`, model.mjs ORACLE_FEE).
+ */
+export declare function actionCosts(economy: any, { now }?: Readonly<Record<string, any>>): any[];
+/** Setup and play costs for a spec, or its refusals. */
+/** `only` and `live`: a change to a live economy, priced as only what it publishes (live.mjs `changedParts`). */
+export declare function cost(economy: any, { now, only, live }?: {
+    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[];
+} | {
+    ok: boolean;
+    setup: {
+        accounts: any;
+        rentSol: any;
+        programFeesSol: any;
+        networkFeesSol: any;
+        seeds: {};
+        totalSol: any;
+        transactions: any;
+        approvals: any;
+        notes: string[];
+    };
+    actions: any[];
+    fees: {
+        playerSol: any;
+        projectSol: any;
+        oracleSol: any;
+    };
+};
+/** The cost in plain words. */
+export declare function explainCost(c: any): string;

package/types/economy/examples.d.mts

@@ -0,0 +1,27 @@
+/** Every worked example: { name, spec }. */
+export declare function examples(): any;
+/** One example's whole spec, by name. */
+export declare function example(name: any): any;
+export declare const ideas: () => any;
+/** The parts a spec uses, and features it shows. */
+export declare function partsUsed(spec: any): string[];
+/**
+ * What loot can't do exactly that `query` asks for, with the nearest versions: the closest few. `atLeast`: only limits
+ * that match at least this well (search passes the best matching capability's score: when a capability matches the
+ * words better, its "how" is the answer and a weaker "can't" beside it only misleads; a tie shows both).
+ */
+export declare function limits(query: any, { limit, atLeast }?: {
+    atLeast?: number | undefined;
+    limit?: number | undefined;
+}): any;
+/** Asks that look impossible but are one field or a short combination, closest to `query`. */
+export declare function hows(query: any, { limit }?: {
+    limit?: number | undefined;
+}): any;
+/** The examples, ideas, hows and limits closest to `query`. */
+export declare function search(query: any, { limit, fit }?: Readonly<Record<string, any>>): {
+    examples: any;
+    ideas: any;
+    hows: any;
+    limits: any;
+};

package/types/economy/explain.d.mts

@@ -0,0 +1,19 @@
+export declare function explainEconomy(economy: any, { now }?: {
+    now?: number | undefined;
+}): {
+    ok: boolean;
+    refusals: any[];
+    warnings: any[];
+    text: string;
+    needsAuthority?: undefined;
+    chance?: undefined;
+    setupSol?: undefined;
+} | {
+    refusals?: undefined;
+    ok: boolean;
+    text: string;
+    warnings: any[];
+    needsAuthority: boolean;
+    chance: boolean;
+    setupSol: any;
+};

package/types/economy/guide.d.mts

@@ -0,0 +1,140 @@
+/** Each part: what it is for, who acts at play time and its fee, and the nested shapes worth showing. */
+export declare const PARTS: {
+    tokens: {
+        def: string;
+        says: string;
+        acts: string;
+    };
+    currency: {
+        says: string;
+    };
+    collection: {
+        def: string;
+        says: string;
+    };
+    items: {
+        def: string;
+        nested: string[];
+        says: string;
+        acts: string;
+    };
+    pools: {
+        def: string;
+        says: string;
+        acts: string;
+    };
+    stashes: {
+        def: string;
+        says: string;
+        acts: string;
+    };
+    boxes: {
+        def: string;
+        nested: string[];
+        says: string;
+        acts: string;
+    };
+    payments: {
+        def: string;
+        nested: string[];
+        says: string;
+        acts: string;
+    };
+    recipes: {
+        def: string;
+        nested: string[];
+        says: string;
+        acts: string;
+    };
+    schedules: {
+        def: string;
+        says: string;
+        acts: string;
+    };
+    lotteries: {
+        def: string;
+        nested: string[];
+        says: string;
+        acts: string;
+    };
+    farms: {
+        def: string;
+        nested: string[];
+        says: string;
+        acts: string;
+    };
+    contests: {
+        def: string;
+        nested: string[];
+        says: string;
+        acts: string;
+    };
+    auctions: {
+        def: string;
+        nested: string[];
+        says: string;
+        acts: string;
+    };
+    holds: {
+        def: string;
+        says: string;
+        acts: string;
+    };
+    grants: {
+        def: string;
+        nested: string[];
+        says: string;
+        acts: string;
+    };
+    decisions: {
+        def: string;
+        says: string;
+        acts: string;
+    };
+    keys: {
+        says: string;
+    };
+    scenario: {
+        def: string;
+        says: string;
+    };
+};
+export declare const CONVENTIONS: string[];
+/**
+ * What no part of loot does, and the combinations that come closest: { what, words (to match a person's own words),
+ * why, nearest: [the version, and what it gives up] }. A limit is never the end of the answer: say what is missing,
+ * then offer the nearest versions with their numbers, best first, and build the one the person picks. A feature that
+ * ships later moves its entry to HOW.
+ */
+export declare const CANNOT: {
+    what: string;
+    words: string;
+    why: string;
+    nearest: string[];
+}[];
+/**
+ * Asks that look impossible but are one field or a short combination: { what, words, how }. Shown by xsolana_examples when a
+ * person's words match.
+ */
+export declare const HOW: {
+    what: string;
+    words: string;
+    how: string;
+}[];
+/** The parts (one, or all) with their fields from the schema. */
+export declare function catalog(only: any): {
+    part: string;
+    type: any;
+    says: string;
+    atPlayTime?: any;
+    fields: {
+        name: string;
+        type: any;
+        required?: boolean | undefined;
+        default?: any;
+        says?: any;
+    }[];
+    nested?: any;
+}[];
+/** The guide in words: every part (or one, with its nested shapes), the conventions and what loot cannot do. */
+export declare function guideText(only: any): string;

package/types/economy/legal.d.mts

@@ -0,0 +1,12 @@
+/** Each legal flag's sentence, for the person who approves, by the checker's warning code. */
+export declare const LEGAL: Readonly<{
+    'W-CHANCE-PRIZE': "Players pay for a chance at money (a box or a lottery that pays a prize, a bet on an outcome). That is gambling in many places: before real money, get a lawyer, and gate it by age and region.";
+    'W-CHANCE-ITEMS': "Players pay for random items they can resell (a loot box). Some places treat that as gambling and many require the odds shown: show them on the page, and get a lawyer before real money.";
+    'W-AUCTION-SHILL': "Anyone, the seller included, can bid to push an auction’s price up (shill bidding): a reserve is the honest way to set a floor.";
+    'W-REVENUE-SHARE': "Stakers are paid from what players spend, which regulators look at when they decide whether a token is a security: before real money, get a lawyer, or pay rewards from emissions instead.";
+}>;
+/** The legal flags a checker verdict raises, each once, in the order the checker raised them: [{ code, says }]. */
+export declare const legalFlags: (verdict: any) => {
+    code: any;
+    says: any;
+}[];