@xgamesfun/solana 0.0.0-stage → 0.20.1

package/types/client/pda.d.ts

@@ -0,0 +1,91 @@
+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;
+declare const keyReceipt: (grant: any, incarnation: any, voucherKey: any) => 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;
+    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;
+    lotteryFunds: (lottery: any) => any;
+    lotteryReceipt: (lottery: any, incarnation: any, wallet: any) => any;
+    /** One purchase of a lottery's tickets, at a nonce of its buyer's. */
+    contribution: (lottery: any, player: any, nonce: any) => any;
+    /** A wallet's entry in a contest: one, on one side (another side is `OtherSide`). */
+    entry: (contest: any, player: any) => 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 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 counter on a box or recipe. Grants and lotteries also name their incarnation. */
+    receipt: (record: any, wallet: any) => any;
+    grantReceipt: (grant: any, incarnation: any, wallet: any) => any;
+    person: (grant: any, incarnation: any, personHash: any) => any;
+    /** How many times an NFT shown claimed an open grant its gate asks for one of: an address of its own, never a person's. */
+    badge: (grant: any, incarnation: any, nft: any) => any;
+    /** A voucher key's counter on a grant (a promo code's). */
+    code: typeof keyReceipt;
+    /** 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,23 @@
+export declare const STALE_SLOTS: bigint;
+export declare const LOTTERY_TIMEOUT_SLOTS: bigint;
+/**
+ * The earliest slot an order can be refunded in, or null when it never can be: a rolled order has an outcome anyone
+ * can carry out, and is settled, never refunded; a roll a mission or a recipe made waits for anyone to ask for it
+ * (`Waiting`), and once asked (`Asked`) is asked again if the oracle never answers (`rollAskable`).
+ */
+export declare function orderRefundSlot(order: any): bigint | null;
+/** Whether anyone may ask the oracle for a mission's or a recipe's roll at `slot`: never asked, or never answered. */
+export declare const rollAskable: (order: any, slot: 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's draw was asked for and the oracle has not answered within `STALE_SLOTS`: anyone may ask again. */
+export declare const lotteryDrawStuck: (lottery: any, slot: any) => boolean;
+/**
+ * Whether a lottery's draw was asked for and the oracle has not answered within `LOTTERY_TIMEOUT_SLOTS` of the first
+ * ask (asking again doesn't move it): anyone may cancel the round and refund it. A round nobody asked to draw is never
+ * cancelled.
+ */
+export declare const lotteryCancellable: (lottery: any, slot: any) => boolean;

package/types/client/sizes.d.ts

@@ -0,0 +1,13 @@
+/** 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;
+export declare const ACCOUNT_BYTES: Readonly<{
+    [k: string]: any;
+}>;
+/** A project's bytes with `collections` collections, as the program sizes the account. */
+export declare const projectBytes: (collections?: number) => number;
+export declare const MAX_RECEIPT_ROUNDS: number;
+export declare const RECEIPT_BASE_BYTES = 17;
+export declare const RECEIPT_ROUND_BYTES = 8;
+export declare function receiptBytes(rounds?: number): number;

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,105 @@
+/**
+ * The accounts a route the player pays or asks for (a craft, a buy, a grant's claim) passes after a roll's box and
+ * order (`order::askable`, the client's `rollMints`): for each token prize of box `key`, in order, its pool and the
+ * pool's mint, or the mint it mints from. Up to 10 distinct accounts a box.
+ */
+export declare function rollMintKeys(key: any, m: any): any;
+/**
+ * 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 with its box's prize mints, `rollMintKeys`), 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 with its
+ * box's prize mints, `rollMintKeys`).
+ */
+export declare function buySize(b: any, m: any, { detail }?: {
+    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,68 @@
+/** 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 0.0005 SOL (`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[];
+    }[];
+    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;
+}[];

package/types/economy/live.d.mts

@@ -0,0 +1,109 @@
+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 }: {
+    keys: any;
+    live?: null | undefined;
+    now?: number | undefined;
+    only?: null | undefined;
+    owner: any;
+    rent: any;
+}): {
+    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[];
+} | {
+    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;
+    };
+} | {
+    refusals?: undefined;
+    ok: boolean;
+    warnings: any[];
+    steps: any[];
+    transactions: {
+        signer: string;
+        steps: any[];
+        built: any[];
+        instructions: any;
+        signers: any[];
+    }[];
+    approvals: number;
+    freshKeys: any[];
+    ctx: {
+        owner: any;
+        authority: any;
+        collection: any;
+        tree: any;
+        project: any;
+        treasury: any;
+        mints: {};
+        keys: any;
+        rent: any;
+    };
+};
+/**
+ * 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[];
+};