@xgamesfun/solana 0.26.0 → 0.26.1

package/js/play/index.js

@@ -1489,6 +1489,11 @@ export function solanaApp({
     const g = await projectNow();
     const box = await read('LootBox', loot.pda.box(project, boxId));
     if (!Number.isInteger(count) || count < 1) throw new Error('Buy a whole number, one at least (count).');
+    // One `buy` prices at most so many sales (`PackTooLarge` past it): more is several purchases.
+    if (count > loot.MOST_SALES_A_BUY)
+      throw new Error(
+        `One purchase buys at most ${loot.MOST_SALES_A_BUY.toLocaleString('en-US')} (count): buy the rest in another.`,
+      );
     const bound =
       boundOf({ ...box, currencyKey: part?.currency }, part?.name ?? `box ${boxId}`, { maxPrice, listing }, part?.key) *
       BigInt(count);
@@ -2325,8 +2330,9 @@ export function solanaApp({
     const e = i == null ? null : r.entries[i];
     const out = [];
     const rolls = [];
-    // Whether a pull here wants the largest heap (a run of rolls), and whether one stops short of the part (a raffle's
-    // NFTs past what one pull takes out, a run of rolls past what one transaction carries): a next pull carries on.
+    // Whether a pull here wants the largest heap (a run of rolls, or several NFTs out of the round's own stash), and
+    // whether one stops short of the part (a raffle's NFTs past what one pull takes out or one transaction carries, a
+    // run of rolls past what one transaction carries): a next pull carries on.
     let heap = false;
     let partial = false;
     const g = await projectNow();
@@ -2382,10 +2388,12 @@ export function solanaApp({
           projectMint: mintOf(),
         };
         more.nonce = pullNonce(key, i);
-        // A run of places that each give a roll: two accounts a place, as many as one transaction carries, on the
-        // largest heap. The pull is sized from a dry run, largest first; the next pull carries on, and only the last
-        // carries the close.
-        if (given.Roll) {
+        // A run of places that each give a roll (two accounts a place), or several NFTs out of the round's own stash
+        // (each NFT's accounts, and heap the program does not give back: 8 Core moves in a round of some 125 places or
+        // more run past the default 32 KiB): as many places as one transaction carries, on the largest heap. The pull
+        // is sized from a dry run, largest first; the next pull carries on while the round still owes the entry, and
+        // only the last carries the close.
+        if (given.Roll || (stash && loot.prizePlacesOwed(r, i, run).length > 1)) {
           const owed = loot.prizePlacesOwed(r, i, run).length;
           const sized = async most => {
             const ix = loot.pullIx({
@@ -4928,7 +4936,7 @@ export function solanaApp({
         heap ||= built.heap;
         partial ||= built.partial;
       }
-      // A run of rolls asks for the largest heap.
+      // A run of rolls, or several NFTs out of the round's own stash, asks for the largest heap.
       if (heap) instructions.splice(1, 0, requestHeapFrame(loot.LARGE_SETTLE_HEAP));
       // A pull that stopped short of its part (a raffle's NFTs, 64 a pull; a run of rolls): sent, then the next carries
       // on while the round moves (its NFTs out, its places paid) and still owes it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xgamesfun/solana",
-  "version": "0.26.0",
+  "version": "0.26.1",
   "mcpName": "io.github.XGamesFun/solana-kit",
   "description": "Loot boxes, gacha, shops, lotteries, auctions, NFT staking, crafting and rewards on Solana without writing a smart contract: one shared program, its JS client, a CLI, and an MCP server and skill so Claude Code, Codex or any AI agent can design, check, simulate and launch an economy.",
   "license": "Apache-2.0",

package/release.json

@@ -1,8 +1,8 @@
 {
-  "version": "0.26.0",
+  "version": "0.26.1",
   "programId": "9cwqM1TXytPnFZsLfmUyv2dg4uW6Ch9C6UJVPns7NFQ",
-  "sbfBytes": 1779872,
-  "sbfSha256": "d5d4a2ca2bca79e8d4930b697cc3aecfcf54399aa85585c02e267ffbbdfda429",
-  "idlSha256": "4e1407b41c5947821d154472bd26c2df0fff9c750475239d444b2f5fd5d3d8dc",
-  "clientSha256": "e6b1783c6f68e342aa165474f1d3b96a7a24a3a981be4882ebcd7ae071e41e6e"
+  "sbfBytes": 1783800,
+  "sbfSha256": "af318ccfa4d2901076b85fcd1b4467b03253adf0de16e73a9dfc1ef8077b2c14",
+  "idlSha256": "0e88fc826a585cf17917cbc654e33b68232771769fe9aae1d5899a257940ff47",
+  "clientSha256": "01d85ff69999efc8b0641ce684dd060cf0ad421a8e125f91d620fef50bb5aedd"
 }

package/skills/xsolana-economy/SKILL.md

@@ -9,8 +9,8 @@ An economy is one JSON spec (`xsolana.json` in the project) on **loot**, a Solan
 writes or deploys a contract: the spec is checked, simulated and priced by the `xsolana_*` tools, and the project's
 owner puts it live by approving in their own wallet. It runs on **devnet** until the program is audited.
 
-The tools are the `xsolana_*` MCP tools. Without MCP, the same from a terminal: `npx -y @xgamesfun/solana@0.26.0 <guide|examples|check|simulate|cost|explain|review|publish|status> [xsolana.json]`,
-or `npx -y @xgamesfun/solana@0.26.0 tool <name> '<json>'` for any tool (always with the exact version).
+The tools are the `xsolana_*` MCP tools. Without MCP, the same from a terminal: `npx -y @xgamesfun/solana@0.26.1 <guide|examples|check|simulate|cost|explain|review|publish|status> [xsolana.json]`,
+or `npx -y @xgamesfun/solana@0.26.1 tool <name> '<json>'` for any tool (always with the exact version).
 
 ## Rules (always)
 
@@ -121,7 +121,7 @@ or `npx -y @xgamesfun/solana@0.26.0 tool <name> '<json>'` for any tool (always w
    level would cost. Run it again after every change that touches a route that pays.
 9. **When they say "put it live"**: `xsolana_publish` lists every step and its cost and gives the command. Tell them to
    run it themselves in the project folder, exactly as `xsolana_publish` gives it (it names the exact version:
-   `npx -y @xgamesfun/solana@0.26.0 approve xsolana.json`; never drop the version). It opens a page on their computer where
+   `npx -y @xgamesfun/solana@0.26.1 approve xsolana.json`; never drop the version). It opens a page on their computer where
    they connect a devnet wallet and approve; what lands is written back into `xsolana.json`. You publish nothing.
 10. **After it is live**: `xsolana_status` shows each part on chain; read it before acting on what the person says
     happened. A later change is the same loop: save, publish, and the approval sends only what changed. What only the

package/skills/xsolana-economy/references/telling-the-person.md

@@ -90,7 +90,8 @@ money; it holds no files and serves nothing.
   the mints and vaults of its tokens, a fresh item's tables) are bounded by that, however many outcomes it has.
   `xsolana_check` counts them. One answer also holds only so much of a box (measured: 128 outcomes that give
   nothing, 29 of token amounts, 18 each of its own item; 41 slots; 72 odds rules; 16 token prizes or 18 collectibles
-  in one outcome; 340 texts in a gate): a box past that is refused when written. Put a long weighted list in a table
+  in one outcome; 340 texts in a gate; fewer where outcomes name pools or stashes, since the write counts finding
+  each one's address): a box past that is refused when written. Put a long weighted list in a table
   or a stash, drawn by one outcome.
 - **The program takes any time, and the checker says a far one's date in words (W-FAR-TIME).** A time that looks like
   milliseconds, or lands more than three years out, locks the bids, tickets, NFTs or vault that wait on it until then.

package/types/client/sizes.d.ts

@@ -41,6 +41,19 @@ export declare function entryRows(entries: any, items?: {}): any;
  * 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 most draws one `open_box` takes in all, its count times the box's draws: what one answer could weigh, each draw
+ * at its weighing at least (`ROLL_BUDGET / COST_WEIGH`, 300). More is refused before any price is added up
+ * (`PackTooLarge`). */
+export declare const MOST_DRAWS_A_PURCHASE: number;
+/** The most sales one `buy` takes (`count`): what one transaction can price (`MAX_TX_CU / COST_SALE`, rounded down:
+ * 25,454). More is refused before any price is added up (`PackTooLarge`). */
+export declare const MOST_SALES_A_BUY: number;
+/**
+ * The tries counted for finding a pool's or a stash's address when the project is not known yet (a spec checked before
+ * any wallet is named): 2, what an address takes on average (half are found at the first try, a quarter at the second,
+ * and so on). With the project known, the count is exact: `256 - bump` tries an address.
+ */
+export declare const ASSUMED_TRIES = 2;
 /**
  * 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.
@@ -53,20 +66,30 @@ export declare function boxBytes({ odds, gate, shares, subject, slots, fates }:
     slots?: never[] | undefined;
     subject?: null | undefined;
 }): bigint;
+/**
+ * The tries finding a pool's (`pool` true) or a stash's address takes (`order::searched`: `256 - bump`), for `project`'s
+ * pool or stash `id`. With no project, `ASSUMED_TRIES`.
+ */
+export declare function searchTries(project: any, pool: any, id: any): number;
 /**
  * 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`).
+ * dearest its slot could make, with what is known from the box alone (no table rows, a stash of one group, a named
+ * NFT's stash of one row), 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`). `project`: the project the box is in, whose pools' and stashes' addresses the write searches for (each
+ * search counted at `256 - bump` tries of 1,500 units); without it, at `ASSUMED_TRIES` tries an address. The program
+ * refuses a box whose one open doesn't fit at its upsert (`PackTooLarge`). `purchase`: counted as `open_box` counts a
+ * purchase of `opens` instead (the answer's heap always; a draw's own stock read again only when there are several; at
+ * most `MOST_DRAWS_A_PURCHASE` draws in all), from what the box alone tells: the program reads the accounts too.
  */
-export declare function drawsFit(entries: any, slots: any, opens?: number, { odds, shares, fates, bytes, oracle }?: {
+export declare function drawsFit(entries: any, slots: any, opens?: number, { odds, shares, fates, bytes, oracle, project, purchase }?: {
     bytes?: bigint | undefined;
     fates?: number | undefined;
     odds?: number | undefined;
     oracle?: boolean | undefined;
+    project?: null | undefined;
+    purchase?: boolean | undefined;
     shares?: number | undefined;
 }): boolean;
 /**
@@ -76,10 +99,21 @@ export declare function drawsFit(entries: any, slots: any, opens?: number, { odd
  * (`drawsFit` with `oracle`), and can't give a roll (`PackTooLarge`). `box`: the box's args.
  */
 export declare function buyFits(box: any, draws?: any): boolean;
+/**
+ * Whether the program writes `box` (its args, as `upsertBoxIx` takes them, or a box read from the chain) as far as what
+ * it costs goes (`catalog::loot_box`, `PackTooLarge`): a box that doesn't roll sells by `buy` when one transaction carries
+ * the whole purchase (`buyFits`), else through the oracle, whose heap then counts and which can't give a roll; and every
+ * draw of one open fits one answer (`drawsFit`). `project`: whose pools and stashes the box names (a box read from the
+ * chain says); without it, each search at `ASSUMED_TRIES` tries.
+ */
+export declare function boxFits(box: any, { project }?: {
+    project?: 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
+ * The most opens of `lootBox` a client puts in one order: what one oracle answer draws (`drawsFit` as a purchase counts
+ * it, the box's project's searches counted when the box names it: a box read from the chain does), 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.

package/types/economy/check.d.mts

@@ -87,12 +87,16 @@ export declare const FAR_SECONDS: number;
 /** A Unix time in words, in English: "14 March 2031". Past what a date can show, the year alone. */
 export declare function dateWords(seconds: any): string;
 /**
- * Checks an economy spec. `now` (Unix seconds) dates "publish".
+ * Checks an economy spec. `now` (Unix seconds) dates "publish". `project`: the project's address, once a wallet is named
+ * (the plan for a real setup passes it; a live economy's file names it): a box's write searches for each of its pools'
+ * and stashes' addresses, and the checker counts each search exactly with it, else at an assumed 2 tries an address
+ * (`ASSUMED_TRIES`).
  * Returns { ok, refusals: [{ code, where, message, fix }], warnings: [{ code, where, message, fix? }] }.
  */
-export declare function check(economy: any, { network, now }?: {
+export declare function check(economy: any, { network, now, project }?: {
     network?: string | undefined;
     now?: number | undefined;
+    project?: any;
 }): {
     ok: boolean;
     refusals: any[];

package/types/economy/cost.d.mts

@@ -40,6 +40,7 @@ export declare function cost(economy: any, { now, only, live }?: {
         steps: any[];
         built: any[];
         instructions: any;
+        compute: boolean;
         signers: any[];
         alone: boolean;
     }[];

package/types/economy/live.d.mts

@@ -33,6 +33,7 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         steps: any[];
         built: any[];
         instructions: any;
+        compute: boolean;
         signers: any[];
         alone: boolean;
     }[];
@@ -68,6 +69,7 @@ export declare function prepare(economy: any, { owner, keys, live, now, rent, on
         steps: any[];
         built: any[];
         instructions: any;
+        compute: boolean;
         signers: any[];
         alone: boolean;
     }[];

package/types/economy/plan.d.mts

@@ -1031,12 +1031,19 @@ export declare function setupContext(m: any, { owner: ownerKey, keys, live: give
 };
 /** The bytes of a transaction of `instructions` the owner pays for: what `pack` holds against the budget. */
 export declare const stepBytes: (instructions: any, ctx: any) => number;
-/** Packs steps into transactions under the size budget, one signer set at a time; each step whole. */
+/** The bytes of a transaction of `step` alone, as `pack` sends it (its compute limit included). */
+export declare const stepAloneBytes: (step: any, ctx: any) => number;
+/**
+ * Packs steps into transactions under the size budget, one signer set at a time; each step whole. A transaction that
+ * carries a step needing more compute than an instruction has by default (`compute`: a box's write) asks for all a
+ * transaction can have, first.
+ */
 export declare function pack(steps: any, ctx: any): {
     signer: string;
     steps: any[];
     built: any[];
     instructions: any;
+    compute: boolean;
     signers: any[];
     alone: boolean;
 }[];
@@ -1067,6 +1074,7 @@ export declare function plan(economy: any, { now, ctx, only, live }?: {
         steps: any[];
         built: any[];
         instructions: any;
+        compute: boolean;
         signers: any[];
         alone: boolean;
     }[];