@xgamesfun/solana 0.20.1 → 0.25.0

package/types/client/pda.d.ts

@@ -11,7 +11,6 @@ export declare const COMPRESSION_PROGRAM = "mcmt6YrQEMKw8Mw43FmpRLmf7BqRnFMKmAcb
 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
@@ -24,6 +23,10 @@ export declare const pda: {
     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;
@@ -36,14 +39,16 @@ export declare const pda: {
     /** 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]`. */
+    /** A contest's pot: `["pot", contest]`. */
     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 lottery's pot `id` (below `MAX_POTS`), kept from round to round: `["pot", lottery, id]`. */
+    lotteryPot: (lottery: any, id: 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`). */
@@ -58,6 +63,8 @@ export declare const pda: {
     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. */
@@ -70,14 +77,13 @@ export declare const pda: {
     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;
+    /** 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. */

package/types/client/policy.d.ts

@@ -1,23 +1,48 @@
-export declare const STALE_SLOTS: bigint;
-export declare const LOTTERY_TIMEOUT_SLOTS: bigint;
+/** 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 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`).
+ * 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 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;
+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'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 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'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.
+ * 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: (lottery: any, slot: any) => boolean;
+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

@@ -2,12 +2,100 @@
 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<{
-    [k: string]: any;
+    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;
-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;
+/** 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/economy/check.d.mts

@@ -1,12 +1,6 @@
-/**
- * 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
+ * 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 }?: {
@@ -77,10 +71,11 @@ export declare function settleSize(b: any, o: any, m: any): {
 /**
  * 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`).
+ * (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 }?: {
+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

package/types/economy/cost.d.mts

@@ -13,7 +13,7 @@ export declare function setupCost(plan: any, economy: any): {
 /**
  * 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).
+ * 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. */
@@ -41,6 +41,7 @@ export declare function cost(economy: any, { now, only, live }?: {
         built: any[];
         instructions: any;
         signers: any[];
+        alone: boolean;
     }[];
     approvals: number;
     freshKeys: any[];

package/types/economy/guide.d.mts

@@ -106,6 +106,11 @@ export declare const CONVENTIONS: string[];
  * 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.
  */
+/**
+ * What no code removes, only makes smaller: a wallet is not a person, the page can't be trusted, and bots play well.
+ * Said once in the guide, so every design starts from it.
+ */
+export declare const SAFETY: string[];
 export declare const CANNOT: {
     what: string;
     words: string;

package/types/economy/live.d.mts

@@ -7,13 +7,14 @@ export declare function freshAddresses(names: any, random?: typeof randomBytes):
  * 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 }: {
+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[];
@@ -33,6 +34,7 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         built: any[];
         instructions: any;
         signers: any[];
+        alone: boolean;
     }[];
     approvals: number;
     freshKeys: any[];
@@ -54,6 +56,7 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         mints: {};
         keys: any;
         rent: any;
+        slot: null;
     };
 } | {
     refusals?: undefined;
@@ -66,6 +69,7 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         built: any[];
         instructions: any;
         signers: any[];
+        alone: boolean;
     }[];
     approvals: number;
     freshKeys: any[];
@@ -79,8 +83,19 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         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.