@xgamesfun/solana 0.0.0-stage → 0.20.1

package/types/economy/model.d.mts

@@ -0,0 +1,363 @@
+/** 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 = 500000n;
+/**
+ * Put in the order itself on every purchase, with the player fee on top of it (order.rs: ESCROW_LAMPORTS + fee); what
+ * a collectible's rent doesn't use goes back at settle, and a refund returns all of it (constants.rs).
+ */
+export declare const ESCROW_LAMPORTS = 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 program's limits. */
+export declare const LIMITS: Readonly<{
+    shares: 4;
+    entries: 8;
+    callbackAccounts: 21;
+    lines: 8;
+    collectiblesPerCraft: 8;
+    places: 8;
+    tiers: 4;
+    boosts: 4;
+    growths: 4;
+    gates: 4;
+    odds: 4;
+    vouchers: 3;
+    deciders: 3;
+    gateWallets: 16;
+    nameBytes: 32;
+    uriBytes: 200;
+    keyBytes: 32;
+    maxBoostBps: 1000000;
+    maxTierBps: 110000;
+}>;
+/** Attribute names the program writes itself, which a recipe cannot copy and `Set` cannot change (craft.rs, make.rs). */
+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 pool takes to be released to its seats, in seconds (a farm that shares its
+ * pool, `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 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 the pool, the project's, and so does what a seat gives back after
+ * the end; a seat that may be dead (a watched NFT sold, an upkeep run out) is refreshed a release span before it.
+ */
+export declare function farmEndWords(f: any): string | null;
+/** 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;
+    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>"), "share" (`percent` of `pool`),
+ * "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: a share's, or 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", "10% of “jackpot”", "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, at most three prizes an entry), each in the box's own words: "item",
+ * "pay" (a fixed amount from a pool), "share" (a percent of 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 an outcome burns the payment in place of the box's split: "burn", or a bundle that says `burns`. */
+export declare const outcomeBurns: (o: any) => boolean;
+/** Whether a box leaves its outcome to the oracle (catalog.rs `rolls`): more than one outcome, or an NFT at random. */
+export declare const boxRolls: (b: any) => any;
+/** Whether a box sells with `buy`, in one transaction (buy.rs): it doesn't roll, and rolls on no NFT. */
+export declare const boxBuys: (b: any) => boolean;
+/** 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;
+};
+/** "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>", 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[];