@xgamesfun/solana 0.26.0 → 0.26.2

package/js/economy/plan.mjs

@@ -1,7 +1,8 @@
 // The setup plan: every instruction that puts an economy live on loot, in order, built with the client and
 // packed into transactions that fit. Nothing here signs or talks to the chain. Pure.
 //
-// A step is { id, part, says, signers, creates: [{ what, bytes }], build(ctx) → instructions }. `ctx` names the
+// A step is { id, part, says, signers, creates: [{ what, bytes, fee? }], build(ctx) → instructions } (`fee`: lamports
+// the program that makes the account keeps in it, on top of its rent: Token Metadata's). `ctx` names the
 // addresses a step needs: { owner, authority, project, collection, tree, treasury, mints: { tokenKey: mint }, keys: {
 // name: address } } where `keys` are the fresh keys this setup makes ("new:collection", "new:tree", "new:mint/points"), each of
 // which signs the step that creates it. `placeholderContext` fills every address with a stand-in, so a plan can be
@@ -20,8 +21,14 @@ import {
   TOKEN_PROGRAM,
 } from '../chain/pda.js';
 import { createTableIx, extendTableIx } from '../chain/lookup.js';
+import { createFungibleMetadataIx, METADATA_BYTES, METADATA_FEE, METADATA_LIMITS } from '../chain/metadata.js';
 import { MEMO_PROGRAM } from '../chain/token2022.js';
-import { createAssociatedTokenAccountIdempotent, syncNative, transferLamports } from '../chain/programs.js';
+import {
+  computeUnitLimit,
+  createAssociatedTokenAccountIdempotent,
+  syncNative,
+  transferLamports,
+} from '../chain/programs.js';
 import {
   createAccountIx,
   initializeMint2Ix,
@@ -34,7 +41,7 @@ import { compileMessage, transactionSize } from '../chain/tx.js';
 import { sha256 } from '../chain/sha256.js';
 import { utf8 } from '../chain/bytes.js';
 import * as loot from '../client/index.js';
-import { check } from './check.mjs';
+import { check, MAX_COMPUTE_UNITS } from './check.mjs';
 import {
   ACCOUNT_OVERHEAD,
   boxBuys,
@@ -727,18 +734,40 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
   const fresh = !live?.project;
 
   // Tokens the project mints: a classic mint with the owner as its authority, handed to the project right after.
+  // Each is named on chain in the same step (its Token Metadata record: the name, the ticker and the link wallets
+  // show), while the owner is still its mint authority: Token Metadata takes a record from nobody else, so a mint whose
+  // minting was handed on or turned off without one can never have one. The owner stays the record's update authority.
   for (const t of m.tokens.values()) {
     if (t.source !== 'game' || live?.mints?.[t.key] || (t.mint && !t.mint.startsWith('@'))) continue;
     const key = `new:mint/${t.key}`;
+    const named = `write its name on chain (“${t.name}”, ${t.symbol}, ${t.uri ? `with the link ${t.uri}` : 'no picture link'}: only your wallet can change it later, which these tools don’t do yet, and Token Metadata keeps ${Number(METADATA_FEE) / 1e9} SOL for it)`;
+    const record = { what: `the name of ${t.symbol} on chain`, bytes: METADATA_BYTES, fee: Number(METADATA_FEE) };
+    // The checker refuses a name, ticker or link too long for a record before any plan is made, except on a token
+    // that is live already, whose words are only labels. Such a token is made here only when a live economy is
+    // planned as if it were new (explain's cost of the whole setup, which is never sent): its record is left out.
+    const fits = ['name', 'symbol', 'uri'].every(f => utf8(String(t[f] ?? '')).length <= METADATA_LIMITS[f]);
+    const name = ctx =>
+      fits
+        ? [
+            createFungibleMetadataIx({
+              mint: ctx.keys[key],
+              authority: ctx.owner,
+              name: t.name,
+              symbol: t.symbol,
+              uri: t.uri ?? '',
+            }),
+          ]
+        : [];
     if (t.fixedSupply) {
       const supply = amount(t.supply, t);
       add({
         id: `token:${t.key}`,
         part: `token:${t.key}`,
-        says: `Make the token ${t.symbol} (${t.decimals} decimals) with a fixed supply of ${t.supply}, all of it to your wallet, then turn its minting off for good`,
+        says: `Make the token ${t.symbol} (${t.decimals} decimals) with a fixed supply of ${t.supply}, all of it to your wallet, ${named}, then turn its minting off for good`,
         signers: [owner, key],
         creates: [
           { what: `the mint of ${t.symbol}`, bytes: MINT_BYTES },
+          ...(fits ? [record] : []),
           { what: `your ${t.symbol} account`, bytes: 165 },
         ],
         build: ctx => [
@@ -750,6 +779,7 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
             owner: TOKEN_PROGRAM,
           }),
           initializeMint2Ix({ mint: ctx.keys[key], decimals: t.decimals, authority: ctx.owner }),
+          ...name(ctx),
           createAssociatedTokenAccountIdempotent(ctx.owner, ctx.owner, ctx.keys[key]),
           mintToIx({
             mint: ctx.keys[key],
@@ -765,9 +795,9 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
     add({
       id: `token:${t.key}`,
       part: `token:${t.key}`,
-      says: `Make the token ${t.symbol} (${t.decimals} decimals), then hand its minting to the project`,
+      says: `Make the token ${t.symbol} (${t.decimals} decimals), ${named}, then hand its minting to the project`,
       signers: [owner, key],
-      creates: [{ what: `the mint of ${t.symbol}`, bytes: MINT_BYTES }],
+      creates: [{ what: `the mint of ${t.symbol}`, bytes: MINT_BYTES }, ...(fits ? [record] : [])],
       build: ctx => [
         createAccountIx({
           from: ctx.owner,
@@ -777,6 +807,7 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
           owner: TOKEN_PROGRAM,
         }),
         initializeMint2Ix({ mint: ctx.keys[key], decimals: t.decimals, authority: ctx.owner }),
+        ...name(ctx),
         setAuthorityIx({ account: ctx.keys[key], current: ctx.owner, newAuthority: ctx.project }),
       ],
     });
@@ -944,6 +975,10 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
       id: `${part}:${kind}`,
       part,
       says,
+      // A box's write finds each of its pools' and stashes' addresses (1,500 units a try) and compares its entries
+      // pair by pair: a box of 16 stashes takes some 170,000 units, more where its addresses take more tries, past
+      // the 200,000 an instruction has by default. Its transaction asks for all a transaction can have.
+      compute: Boolean(def.Box),
       creates: [{ what, bytes }, ...pot],
       build: ctx => [
         loot.upsertIx({ owner: ctx.owner, project: project(ctx), def: resolve(def, ctx), ...options(ctx) }),
@@ -1785,7 +1820,18 @@ export function setupContext(m, { owner: ownerKey, keys, live: given = {}, rent
 export const stepBytes = (instructions, ctx) =>
   transactionSize(compileMessage({ payer: ctx.owner, blockhash: placeholderKey('blockhash'), instructions }));
 
-/** Packs steps into transactions under the size budget, one signer set at a time; each step whole. */
+/** `instructions`, led by a compute limit of all a transaction can have when `compute` (a box's write is in them). */
+const budgeted = (instructions, compute) =>
+  compute ? [computeUnitLimit(MAX_COMPUTE_UNITS), ...instructions] : instructions;
+
+/** The bytes of a transaction of `step` alone, as `pack` sends it (its compute limit included). */
+export const stepAloneBytes = (step, ctx) => stepBytes(budgeted(step.build(ctx), Boolean(step.compute)), ctx);
+
+/**
+ * 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 function pack(steps, ctx) {
   const transactions = [];
   let current = null;
@@ -1795,25 +1841,28 @@ export function pack(steps, ctx) {
     // A step with nothing to send (the lookup table of a plan built with no recent slot) is left out.
     if (!instructions.length) continue;
     const signerKind = step.signers.includes('authority') ? 'authority' : 'owner';
-    // A write that names boxes to roll takes all the compute a transaction has: alone.
     if (current && current.signer === signerKind && !step.alone && !current.alone) {
-      const next = [...current.instructions, ...instructions];
+      const compute = current.compute || Boolean(step.compute);
+      const next = budgeted([...current.built.flat(), ...instructions], compute);
       if (sizeOf(next) <= BUDGET) {
         current.instructions = next;
+        current.compute = compute;
         current.steps.push(step);
         current.built.push(instructions);
         current.signers = [...new Set([...current.signers, ...step.signers])];
         continue;
       }
     }
-    const size = sizeOf(instructions);
+    const alone = budgeted(instructions, Boolean(step.compute));
+    const size = sizeOf(alone);
     if (size > BUDGET) throw new Error(`The step “${step.says}” is ${size} bytes: too big for one transaction.`);
     // `built`: each step's own instructions, in the order of `steps`.
     current = {
       signer: signerKind,
       steps: [step],
       built: [instructions],
-      instructions,
+      instructions: alone,
+      compute: Boolean(step.compute),
       signers: [...step.signers],
       alone: Boolean(step.alone),
     };
@@ -1828,7 +1877,8 @@ export function pack(steps, ctx) {
  * real instructions; without it they are built on stand-in addresses (for sizing, cost and showing).
  */
 export function plan(economy, { now = Math.floor(Date.now() / 1000), ctx = null, only = null, live = null } = {}) {
-  const checked = check(economy, { now });
+  // With a real context the project is known: a box's write is checked with its own address searches counted.
+  const checked = check(economy, { now, ...(ctx?.project ? { project: ctx.project } : {}) });
   if (!checked.ok) return { ok: false, refusals: checked.refusals, warnings: checked.warnings };
   const { steps, model: m } = setupSteps(economy, { now, only, live });
   if (ctx)

package/js/economy/schema.json

@@ -363,7 +363,7 @@
       "type": "object",
       "required": ["key", "source"],
       "additionalProperties": false,
-      "description": "A currency. `sol`: SOL (players pay in wrapped SOL). `existing`: any mint by address, launched anywhere, classic or Token-2022, pump.fun included (xgames.fun takes no share of its fees). `project` (`game` is its older spelling): a token made when the economy goes live: the project mints it as its rules say (points, tickets, shards), or, with `supply`, a fixed supply minted once to the owner (a community token you keep).",
+      "description": "A currency. `sol`: SOL (players pay in wrapped SOL). `existing`: any mint by address, launched anywhere, classic or Token-2022, pump.fun included (xgames.fun takes no share of its fees). `project` (`game` is its older spelling): a token made when the economy goes live: the project mints it as its rules say (points, tickets, shards), or, with `supply`, a fixed supply minted once to the owner (a community token you keep). A token made this way is named on chain as it is made (its `name`, `symbol` and `uri`), which is what wallets show. Only the owner's wallet can change that later, and a change to them in a spec that is already live changes nothing on chain yet.",
       "properties": {
         "key": {
           "$ref": "#/$defs/key"
@@ -401,11 +401,12 @@
           "description": "Where the token trades, recorded for the app and not read or enforced by the tools: loot doesn't launch or trade tokens. A token launched elsewhere is `existing`, by its mint. `games.fun` is the older spelling of `xgames.fun`."
         },
         "uri": {
-          "$ref": "#/$defs/link"
+          "$ref": "#/$defs/link",
+          "description": "`project` only: a link to a JSON file that names the token's picture (`{ \"name\", \"symbol\", \"image\": \"https://…\" }`), at most 200 bytes. Going live writes it on chain with the token's name and ticker; without it wallets show the name and ticker and no picture."
         },
         "image": {
           "$ref": "#/$defs/link",
-          "description": "A picture of it, recorded for the app: the tools don't read it, and the setup doesn't write it to the mint."
+          "description": "A picture of it, recorded for the app: the tools don't read it, and the setup doesn't write it on chain (what wallets show is the `image` the JSON file at `uri` names)."
         },
         "powers": {
           "type": "object",

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.2",
   "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": "20e40ee24d808d10091a0bd9973c3c4883e9dd35da4a6beac97557dd85a362c8"
 }

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.2 <guide|examples|check|simulate|cost|explain|review|publish|status> [xsolana.json]`,
+or `npx -y @xgamesfun/solana@0.26.2 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.2 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.
@@ -116,6 +117,13 @@ Don'ts:
   otherwise, and until it is filled those prizes pay nothing.
 - **A token the project mints** (`source: "project"`) is how points, tickets, attempts and shards work; an existing coin
   needs its mint address and decimals from the person (ask; never guess an address).
+- **A token the setup makes is named on chain as it goes live**: its `name`, its `symbol` and its `uri` (a link to a
+  JSON file the project hosts, `{ "name", "symbol", "image": "https://…" }`), which is what wallets and explorers show.
+  Ask for the name, the ticker and a picture before going live: with no `uri` it shows by name and ticker with no
+  picture. Only the owner's wallet can change the three later (Token Metadata's rule, not loot's), and these tools
+  don't change a live token's yet, so get them right first. The record costs about 0.014 SOL (`xsolana_cost` says it:
+  rent, and 0.01 SOL Token Metadata keeps). A token that went live before the tools wrote one has none and
+  can't be given one: only a mint's own authority can name it, and its minting was handed on or turned off.
 - **NFTs the project has no authority over** (any collection but its own): they count as they are. Say that
   whatever their collection lets be written on an NFT (even by its holder) is what a gate or a boost reads, and that
   the project's notes about one (levels, uses) live in its Sheet, which the authority writes and pays for. Every

package/types/chain/metadata.d.ts

@@ -0,0 +1,40 @@
+/** A record's size: Token Metadata pads every one to it, whatever its name, ticker and link. */
+export declare const METADATA_BYTES = 607;
+/** What Token Metadata keeps in each record it makes, on top of the record's rent: its own fee. */
+export declare const METADATA_FEE = 10000000n;
+/** The longest name, ticker and link a record takes, in UTF-8 bytes. */
+export declare const METADATA_LIMITS: Readonly<{
+    name: 32;
+    symbol: 10;
+    uri: 200;
+}>;
+/** The address of a mint's Token Metadata record. */
+export declare const metadataAddress: (mint: any) => any;
+/**
+ * Token Metadata's CreateV1 for a fungible token whose mint exists: its name, its ticker and a link to a JSON file with
+ * its picture ('' for none). `authority` is the mint's authority and signs; it becomes the record's update authority,
+ * the only one who can change the record later. `payer` pays its rent and Token Metadata's fee (`METADATA_FEE`).
+ * The mint is listed read-only: this path of Token Metadata writes nothing to a mint that exists. That is the
+ * program's behaviour, not a lock: in a setup's own transaction the mint is writable all the same (the same
+ * transaction makes it), so the tests read its supply and authorities back after the record is made. The record says
+ * a fungible token whatever the decimals (CreateMetadataAccountV3 would call one of 0 decimals an asset, which
+ * wallets list with collectibles).
+ */
+export declare function createFungibleMetadataIx({ mint, authority, payer, name, symbol, uri }: {
+    authority: any;
+    mint: any;
+    name: any;
+    payer?: any;
+    symbol: any;
+    uri?: string | undefined;
+}): {
+    programId: string;
+    keys: {
+        pubkey: any;
+        isSigner: any;
+        isWritable: any;
+    }[];
+    data: Uint8Array<any>;
+};
+/** The update authority a Token Metadata record names (who can change its name, ticker and link). */
+export declare const metadataUpdateAuthority: (data: any) => string | null;

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

@@ -2,6 +2,7 @@
 export declare function setupCost(plan: any, economy: any): {
     accounts: any;
     rentSol: any;
+    metadataFeesSol: any;
     programFeesSol: any;
     networkFeesSol: any;
     seeds: {};
@@ -40,6 +41,7 @@ export declare function cost(economy: any, { now, only, live }?: {
         steps: any[];
         built: any[];
         instructions: any;
+        compute: boolean;
         signers: any[];
         alone: boolean;
     }[];
@@ -50,6 +52,7 @@ export declare function cost(economy: any, { now, only, live }?: {
     setup: {
         accounts: any;
         rentSol: any;
+        metadataFeesSol: any;
         programFeesSol: any;
         networkFeesSol: any;
         seeds: {};

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;
     }[];