@xgamesfun/solana 0.26.0 → 0.26.2

package/js/client/idl/loot.json

@@ -2,7 +2,7 @@
   "address": "9cwqM1TXytPnFZsLfmUyv2dg4uW6Ch9C6UJVPns7NFQ",
   "metadata": {
     "name": "loot",
-    "version": "0.26.0",
+    "version": "0.26.1",
     "spec": "0.1.0",
     "description": "Economy for Anything: one program every coin of a project passes through",
     "repository": "https://github.com/gamesfun/loot"
@@ -9551,7 +9551,7 @@
     {
       "code": 6141,
       "name": "PackTooLarge",
-      "msg": "A box's draws (one, or each open's times the opens bought together) must all fit one answer of the oracle's: fewer entries, prizes an entry or draws"
+      "msg": "A box's draws (one, or each open's times the opens bought together) must all fit one answer of the oracle's, and the sales one buy adds up one transaction: fewer entries, prizes an entry, draws or opens"
     },
     {
       "code": 6142,
@@ -11575,7 +11575,8 @@
             "docs": [
               "The carry: rounding of a share over the total weight, times `PRECISION`. The next move before",
               "the farm's end credits it to the seats there once it adds up to a share; a move that leaves no",
-              "weight, or any move once the farm is over, frees its whole tokens (`FarmSide::settle`)."
+              "weight, or any move once the farm is over, frees its whole tokens (`FarmSide::settle`), and so",
+              "does a walk that begins with no weight or where the weight reaches 0 (`Farm::walk`)."
             ],
             "type": "u128"
           },

package/js/client/sizes.js

@@ -1,7 +1,10 @@
 // Rent sizes from the current IDL. Fixed allocations reserve the largest enum and option forms,
 // matching Anchor InitSpace. Dynamic records use their actual encoded fields.
+import { addressBytes } from '../chain/base58.js';
 import { encodeAccount, encodeBorsh } from '../chain/borsh.js';
+import { uintLE, utf8 } from '../chain/bytes.js';
 import IDL from './idl/loot.js';
+import { lootAddress } from './pda.js';
 
 const scalar = { bool: 1, u8: 1, u16: 2, u32: 4, i32: 4, u64: 8, i64: 8, u128: 16, pubkey: 32 };
 // What a fixed-size account reserves for its lists and strings: a roll's fate (`Fate.shifts`, each key at most 32 bytes).
@@ -170,7 +173,7 @@ export function orderBytes(lootBox, shares = 0, opens = 1, items) {
 
 // What one oracle answer's roll spends, counted at no less than each part costs (`order.rs`'s `RollCost`, measured by
 // the program's `tests/roll_costs.rs` and `tests/roll_heap.rs`), against the compute and the heap the oracle gives its
-// answer, less a margin.
+// answer, less a margin. Every number of the program's count is here, and only here: a change of one is one edit.
 const ROLL_BUDGET = 300_000n;
 const ROLL_HEAP = 32n * 1024n - 512n;
 const COST = {
@@ -184,7 +187,14 @@ const COST = {
   tokens: 6_000n,
   draw: 9_000n,
   group: 250n,
+  row: 10n,
+  // One try of an address search, what the runtime charges (`COST_TRY`).
+  try: 1_500n,
+  // Reading a prize of an entry after its first (`COST_PRIZE`).
+  prize: 300n,
   reread: 1_000n,
+  // A draw of an entry that gives nothing, beyond its weighing (`COST_NOTHING`).
+  nothing: 1_100n,
   finish: 15_000n,
   won: 150n,
   drawn: 50n,
@@ -195,6 +205,22 @@ const COST = {
   slotEntry: 350n,
   openSlot: 150n,
 };
+/** 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 const MOST_DRAWS_A_PURCHASE = Number(ROLL_BUDGET / COST.weigh);
+/** The compute one transaction has, and what adding up one sale's price costs at most (`catalog.rs` `COST_SALE`). */
+const MAX_TX_CU = 1_400_000;
+const COST_SALE = 55;
+/** 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 const MOST_SALES_A_BUY = Math.floor(MAX_TX_CU / COST_SALE);
+/**
+ * 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 const ASSUMED_TRIES = 2;
 const BYTES = {
   start: 6_000n,
   prizeRead: 600n,
@@ -310,88 +336,152 @@ const accountOf = p => {
 };
 
 /**
- * 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`).
+ * 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 function drawsFit(
-  entries,
-  slots,
-  opens = 1,
-  { odds = 0, shares = 0, fates = 0, bytes = 0n, oracle = false } = {},
-) {
-  const given = typeof slots === 'number' || typeof slots === 'bigint' ? [{ count: slots, only: [] }] : (slots ?? []);
-  // A box with no slots draws once among every entry.
-  const list = given.length ? given : [{ count: 1, only: [] }];
-  const draws = list.reduce((n, s) => n + BigInt(s.count), 0n) * BigInt(opens);
-  // A box of one draw is held to the same answer: one past it would be refused at every purchase.
+export function searchTries(project, pool, id) {
+  if (!project) return ASSUMED_TRIES;
+  const [, bump] = pool ? lootAddress(pdaSeeds.pool(project, id)) : lootAddress(pdaSeeds.stash(project, id));
+  return 256 - bump;
+}
+const pdaSeeds = {
+  pool: (project, index) => [utf8('pool'), addressBytes(project), uintLE(index, 2)],
+  stash: (project, id) => [utf8('stash'), addressBytes(project), uintLE(id, 4)],
+};
+
+/**
+ * What a roll of `entries` spends, as the program's `RollCost::new` counts it from the box alone (no table rows, a
+ * stash of one group, a named NFT's stash of one row): `fixed` (reading the box, every entry's accounts, finding each
+ * pool's and stash's address), each entry's draw (`prizes`), its stock read again (`reread`), the prizes it gives, its
+ * heap, and the heap reading the box leaves used (`start`, the box's own `bytes` included). `project`: whose pools and
+ * stashes these are, to count each search exactly; without it, at `ASSUMED_TRIES` tries an address.
+ */
+function rollCost(entries, { odds = 0, shares = 0, fates = 0, bytes = 0n, project = null }) {
   const n = BigInt(entries.length);
+  // Each address is found by what finding it takes, once a prize names it (`draws_fit`'s `reads`): what a search cost is
+  // kept by the address's kind and id; once past the answer's budget nothing more is searched for (the box is refused).
+  const found = new Map();
+  let searched = 0n;
+  const reading = p => {
+    const pool = p.Tokens?.from?.Pool;
+    const stash = p.Stash ?? p.Nft?.stash;
+    if (pool == null && stash == null) return 0n;
+    const key = pool != null ? `pool ${pool[0] ?? pool}` : `stash ${stash[0] ?? stash}`;
+    let cost = found.get(key);
+    if (cost === undefined) {
+      if (searched > ROLL_BUDGET) cost = 0n;
+      else {
+        const id = Number(pool != null ? (pool[0] ?? pool) : (stash[0] ?? stash));
+        cost = COST.try * BigInt(searchTries(project, pool != null, id));
+        found.set(key, cost);
+      }
+    }
+    searched += cost;
+    return cost;
+  };
+  let fixed = COST.fixed + COST.odds * BigInt(odds) + COST.share * BigInt(shares) + COST.fate * BigInt(fates);
+  let start = BYTES.start + BigInt(outgrown(entries.length, ENTRY_BYTES)) + BigInt(bytes);
+  const prizes = [];
+  const reread = [];
+  const heap = [];
+  for (const e of entries) {
+    let [set, again, used] = [0n, 0n, BYTES.draw];
+    fixed += e.prizes.length ? COST.entry : COST.blank;
+    start += BYTES.entryRead;
+    e.prizes.forEach((p, k) => {
+      fixed += reading(p) + (k > 0 ? COST.prize : 0n);
+      start += BYTES.prizeRead;
+      if (p.Item != null || p.Compressed) [set, again] = [set + COST.item, again + COST.reread];
+      else if (p.Tokens) [set, again] = [set + COST.tokens, again + (p.Tokens.from.Pool ? COST.reread : 0n)];
+      else if (p.Stash != null) [set, again] = [set + COST.draw + COST.group, again + COST.reread];
+      else if (p.Nft) {
+        // A named NFT is searched for row by row: when its stock is read, again, and when it is taken (one row here).
+        fixed += COST.row;
+        [set, again] = [set + COST.item + COST.row, again + COST.reread + COST.row];
+      } else set += COST.item;
+      used += p.Tokens ? (p.Tokens.from.Pool ? BYTES.pooled : BYTES.minted) : BYTES.prize;
+    });
+    // A draw that gives nothing still draws, and keeps its draw's lists.
+    prizes.push(e.prizes.length ? set : COST.nothing);
+    reread.push(again);
+    heap.push(used);
+  }
   const weigh = COST.weigh + COST.weighEntry * n;
-  const reads = entries.map(e => e.prizes.map(accountOf));
-  const cost = entries.map(e =>
-    e.prizes.reduce(
-      (c, p) => {
-        if (p.Item != null || p.Compressed || p.Nft)
-          return { set: c.set + COST.item, again: c.again + COST.reread, bytes: c.bytes + BYTES.prize };
-        if (p.Tokens)
-          return {
-            set: c.set + COST.tokens,
-            again: c.again + (p.Tokens.from.Pool ? COST.reread : 0n),
-            bytes: c.bytes + (p.Tokens.from.Pool ? BYTES.pooled : BYTES.minted),
-          };
-        if (p.Stash != null)
-          return { set: c.set + COST.draw + COST.group, again: c.again + COST.reread, bytes: c.bytes + BYTES.prize };
-        return { set: c.set + COST.item, again: c.again, bytes: c.bytes + BYTES.prize };
-      },
-      { set: 0n, again: 0n, bytes: BYTES.draw },
-    ),
-  );
-  const next = entries.map(
-    (_, i) =>
-      weigh +
-      cost[i].set +
-      cost.reduce((sum, c, j) => (j === i || reads[i].some(a => a && reads[j].includes(a)) ? sum + c.again : sum), 0n),
-  );
   const most = BigInt(Math.max(1, ...entries.map(e => e.prizes.length)));
+  return { fixed, start, weigh, prizes, reread, heap, knowing: COST.pair * n * n * most * most };
+}
+
+/** The entries whose stock a draw of entry `i` reads again: itself, and each naming an account it names. */
+const sharing = (entries, i) => {
+  const reads = entries.map(e => e.prizes.map(accountOf));
+  return entries.map((_, j) => j).filter(j => j === i || reads[i].some(a => a && reads[j].includes(a)));
+};
+
+/**
+ * Whether `opens` opens by `list` (slots, never empty) fit one answer (`RollCost::fits`): each draw at the dearest its
+ * slot could make, which entries share accounts found first when there are several draws. `next`: each entry's draw.
+ * `heap`: the answer's heap counts too.
+ */
+function fitsOne(cost, entries, list, opens, next, heap) {
+  const n = BigInt(entries.length);
+  const draws = list.reduce((d, s) => d + BigInt(s.count), 0n) * BigInt(opens);
   let spent =
-    COST.fixed +
-    COST.pair * n * n * most * most +
-    entries.reduce((c, e) => c + (e.prizes.length ? COST.entry : COST.blank), 0n);
-  let used =
-    BYTES.start +
-    BigInt(outgrown(entries.length, ENTRY_BYTES)) +
-    BigInt(bytes) +
-    BYTES.entryRead * n +
-    BYTES.prizeRead * BigInt(entries.reduce((c, e) => c + e.prizes.length, 0));
-  let won = 0n;
-  spent +=
-    (COST.slot + COST.slotEntry * n) * BigInt(Math.max(1, list.length)) +
+    cost.fixed +
+    (COST.slot + COST.slotEntry * n) * BigInt(list.length) +
     COST.openSlot * BigInt(list.length) * BigInt(opens) +
-    COST.odds * BigInt(odds) +
-    COST.share * BigInt(shares) +
-    COST.fate * BigInt(fates);
+    (draws > 1n ? cost.knowing : 0n);
+  let used = cost.start;
+  let won = 0n;
   for (const s of list) {
     const count = BigInt(s.count) * BigInt(opens);
     const among = entries.map((_, i) => i).filter(i => !(s.only ?? []).length || (s.only ?? []).includes(i));
     const dearest = f => among.reduce((m, i) => (f(i) > m ? f(i) : m), 0n);
     spent += count * dearest(i => next[i]);
-    used += count * dearest(i => cost[i].bytes);
+    used += count * dearest(i => cost.heap[i]);
     won += count * dearest(i => BigInt(entries[i].prizes.length));
   }
-  const rolls = oracle || entries.length > 1 || entries.some(e => e.prizes.some(p => p.Stash != null));
   return (
     spent + COST.finish + COST.won * won + COST.drawn * draws <= ROLL_BUDGET &&
-    (!rolls || used + BYTES.finish + BYTES.won * won + draws <= ROLL_HEAP)
+    (!heap || used + BYTES.finish + BYTES.won * won + draws <= ROLL_HEAP)
   );
 }
 
+/**
+ * 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, 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 function drawsFit(
+  entries,
+  slots,
+  opens = 1,
+  { odds = 0, shares = 0, fates = 0, bytes = 0n, oracle = false, project = null, purchase = false } = {},
+) {
+  const given = typeof slots === 'number' || typeof slots === 'bigint' ? [{ count: slots, only: [] }] : (slots ?? []);
+  // A box with no slots draws once among every entry.
+  const list = given.length ? given : [{ count: 1, only: [] }];
+  const draws = list.reduce((d, s) => d + BigInt(s.count), 0n) * BigInt(opens);
+  if (purchase && draws > BigInt(MOST_DRAWS_A_PURCHASE)) return false;
+  const cost = rollCost(entries, { odds, shares, fates, bytes, project });
+  const heap = purchase || oracle || entries.length > 1 || entries.some(e => e.prizes.some(p => p.Stash != null));
+  // Reading the box alone already past the answer: refused before its entries are compared.
+  if (cost.fixed > ROLL_BUDGET || (heap && cost.start > ROLL_HEAP)) return false;
+  // Each entry's draw reads again the stock of the entries sharing its accounts; a purchase of one draw, its own alone.
+  const again = i => (purchase && draws <= 1n ? [] : sharing(entries, i)).reduce((s, j) => s + cost.reread[j], 0n);
+  const next = entries.map((_, i) => cost.weigh + cost.prizes[i] + again(i));
+  return fitsOne(cost, entries, list, opens, next, heap);
+}
+
 // What one `buy` takes, as the program counts it at the box's write (`catalog::buy_fits`): a transaction holds 64
 // accounts, 64 instructions and 1,400,000 compute units.
-const BUY = { accounts: 15, calls: 7, cu: 30_000, most: { accounts: 64, calls: 64, cu: 1_400_000 } };
+const BUY = { accounts: 15, calls: 7, cu: 30_000, most: { accounts: 64, calls: 64, cu: MAX_TX_CU } };
 const sameJson = (a, b) =>
   JSON.stringify(a, (_, v) => (typeof v === 'bigint' ? String(v) : v)) ===
   JSON.stringify(b, (_, v) => (typeof v === 'bigint' ? String(v) : v));
@@ -444,6 +534,28 @@ export function buyFits(box, draws = box.slots?.length ? box.slots.reduce((n, s)
   return accounts <= BUY.most.accounts && calls <= BUY.most.calls && cu <= BUY.most.cu;
 }
 
+/**
+ * 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 function boxFits(box, { project = box.project ?? null } = {}) {
+  const entries = box.entries ?? [];
+  const rolls = entries.length > 1 || entries.some(e => e.prizes.some(p => p.Stash != null));
+  const byBuy = rolls || box.subject != null || buyFits(box);
+  if (!byBuy && entries.some(e => e.prizes.some(p => p.Roll != null))) return false;
+  return drawsFit(entries, box.slots?.length ? box.slots : 1, 1, {
+    odds: (box.odds ?? []).length,
+    shares: (box.shares ?? []).length,
+    fates: (box.fates ?? []).length,
+    bytes: boxBytes(box),
+    oracle: !byBuy,
+    project,
+  });
+}
+
 /** The most program rent and fee one order takes from its player, in lamports (0.01 SOL): a client cap (`opensAnOrder`). */
 export const ORDER_COST_CAP = 10_000_000n;
 /** Rent a byte, as devnet and mainnet-beta charge it ((bytes + 128) × 5,080 lamports). */
@@ -452,7 +564,8 @@ const RENT_PER_BYTE = 5_080n;
 const PLAYER_FEE = 2_000_000n;
 
 /**
- * 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.
@@ -467,10 +580,11 @@ export function opensAnOrder(
       shares,
       fates: (lootBox.fates ?? []).length,
       bytes: boxBytes(lootBox),
-      oracle: true,
+      project: lootBox.project ?? null,
+      purchase: true,
     }) && (BigInt(orderBytes(lootBox, shares, n, items)) + 128n) * rentPerByte + PLAYER_FEE <= ORDER_COST_CAP;
   let n = 1;
-  while (n < 4096 && fits(n + 1)) n += 1;
+  while (n < MOST_DRAWS_A_PURCHASE && fits(n + 1)) n += 1;
   return n;
 }
 

package/js/economy/check.mjs

@@ -9,11 +9,12 @@ import { gateList } from '../client/grant.js';
 import { MAX_BID_NFTS, MAX_SHARES } from '../client/ix.js';
 import { MAX_POTS } from '../client/accounts.js';
 import { vault } from '../client/pda.js';
-import { boxBytes, buyFits, drawsFit, MAX_ORDER_BYTES, tableBudget } from '../client/sizes.js';
+import { ASSUMED_TRIES, boxBytes, buyFits, drawsFit, MAX_ORDER_BYTES, tableBudget } from '../client/sizes.js';
 import { TOKEN_2022_PROGRAM, TOKEN_PROGRAM } from '../chain/pda.js';
 import { addressBytes, encodeBase58 } from '../chain/base58.js';
 import { isOnCurve } from '../chain/curve.js';
 import { utf8 } from '../chain/bytes.js';
+import { METADATA_LIMITS } from '../chain/metadata.js';
 import { sha256 } from '../chain/sha256.js';
 import {
   FEES,
@@ -59,7 +60,7 @@ import {
   weights,
 } from './model.mjs';
 // plan.mjs imports check() in turn: each module only calls the other's functions, never at load time.
-import { boxArgs, boxOrderBytes, placeholderContext, recipeArgs, setupSteps, stepBytes } from './plan.mjs';
+import { boxArgs, boxOrderBytes, placeholderContext, recipeArgs, setupSteps, stepAloneBytes } from './plan.mjs';
 import { findSecrets } from './secrets.mjs';
 import { simulate } from './simulate.mjs';
 import { BUDGET, MAX_TRANSACTION_BYTES, transactionLocks, transactionSize, WALLET_ROOM } from './txsize.mjs';
@@ -685,10 +686,16 @@ export function dateWords(seconds) {
 }
 
 /**
- * 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 function check(economy, { network = 'devnet', now = Math.floor(Date.now() / 1000) } = {}) {
+export function check(
+  economy,
+  { network = 'devnet', now = Math.floor(Date.now() / 1000), project = economy?.live?.project ?? null } = {},
+) {
   const refusals = [];
   const warnings = [];
   const refuse = (code, where, message, fix) => refusals.push({ code, where, message, fix });
@@ -1007,6 +1014,33 @@ export function check(economy, { network = 'devnet', now = Math.floor(Date.now()
         `“${t.key}” is a token the project makes when the economy goes live, but it names the mint ${t.mint}: the setup would never make it, and would mint from an address the project has no say over.`,
         'Remove "mint" for a token the setup makes, or make it an existing token (source "existing", with its "decimals").',
       );
+    // A token the setup makes is named on chain as it is made (its Token Metadata record), and the record takes so
+    // many bytes of each, not characters: a longer one would be refused on chain, in the middle of going live. One
+    // with no name or ticker at all would be written blank, and show as an unknown token for the record's price. A
+    // token that is live already is not named again: its words here stay labels, as they were.
+    if (source === 'game' && !economy.live?.mints?.[t.key])
+      for (const [field, what] of [
+        ['name', 'name'],
+        ['symbol', 'ticker'],
+        ['uri', 'link'],
+      ]) {
+        const value = String(tok[field] ?? '');
+        const bytes = utf8(value).length;
+        if (bytes > METADATA_LIMITS[field])
+          refuse(
+            'E-TOKEN',
+            `${where}.${field}`,
+            `The ${what} of “${t.key}” is ${bytes} bytes, and a token’s ${what} on chain is at most ${METADATA_LIMITS[field]} (a letter outside plain English takes two or more).`,
+            `Shorten it to ${METADATA_LIMITS[field]} bytes${field === 'uri' ? ', for instance with a shorter path or host' : ''}.`,
+          );
+        else if (field !== 'uri' && !value.trim())
+          refuse(
+            'E-TOKEN',
+            `${where}.${field}`,
+            `“${t.key}” has an empty ${what}: going live writes it on chain as it is, and wallets would show a token with no ${what}.`,
+            `Give it a ${what}, or leave "${field}" out (${field === 'symbol' ? 'its key in capitals is used' : 'its ticker is used'}).`,
+          );
+      }
     if (t.supply !== undefined && source !== 'game')
       refuse(
         'E-TOKEN',
@@ -2398,7 +2432,9 @@ export function check(economy, { network = 'devnet', now = Math.floor(Date.now()
     // rolls, or one outcome of items, with no outcome that burns the payment and no NFT to roll on (BadEntries).
     const slots = b.slots ?? [];
     const outs = b.outcomes ?? [];
+    const heldBefore = refusals.length;
     answerHolds(b, where);
+    const answerRefused = refusals.length > heldBefore;
     for (const [i, o] of outs.entries()) {
       const given = outcomeParts(o);
       tooMany(
@@ -2555,8 +2591,10 @@ export function check(economy, { network = 'devnet', now = Math.floor(Date.now()
     // Every draw of one open fits one answer of the oracle's (PackTooLarge): a pack past it could only draw its first
     // cards, so the program refuses the box. A box that doesn't roll sells by `buy`, the whole purchase in one
     // transaction, or through the oracle when one `buy` can't carry it (`buyFits`): then the answer's heap counts, and it
-    // can't give a roll, which only `buy` gives (catalog.rs). The heap counts the box's own bytes too (`boxBytes`).
-    if (cards > 1 && outs.length) {
+    // can't give a roll, which only `buy` gives (catalog.rs). The heap counts the box's own bytes too (`boxBytes`), and
+    // the compute finding each pool's and stash's address its prizes name (exact with the project, else assumed).
+    // A box of one draw is held to the same count: past it the program refuses the box when it is written.
+    if (outs.length && (cards > 1 || !answerRefused)) {
       const args = (() => {
         try {
           return boxArgs(b, m);
@@ -2566,38 +2604,45 @@ export function check(economy, { network = 'devnet', now = Math.floor(Date.now()
       })();
       const entries = args?.entries;
       if (entries) {
-        const byBuy = boxRolls(b, m) || Boolean(b.rollsOn) || buyFits(args, cards);
+        const byBuy = boxRolls(b, m) || Boolean(b.rollsOn) || buyFits(args, Math.max(1, cards));
         const extras = {
           odds: args.odds.length,
           shares: args.shares.length,
           fates: args.fates.length,
           bytes: boxBytes(args),
           oracle: !byBuy,
+          project,
         };
+        const searches = entries.some(e => e.prizes.some(p => p.Tokens?.from?.Pool || p.Stash != null || p.Nft));
+        const searched = searches
+          ? project
+            ? ' (finding the address of each pool and stash it names counted for this project)'
+            : ` (finding the address of each pool and stash it names counted at ${ASSUMED_TRIES} tries each, as no wallet is named yet: the check with your wallet counts it exactly)`
+          : '';
+        const drawn = slots.length ? slots.map(s => ({ count: s.count, only: s.from ?? [] })) : 1;
         if (!byBuy && entries.some(e => e.prizes.some(p => p.Roll != null)))
           refuse(
             'E-ODDS',
             `${where}.slots`,
-            `${label(b)} gives a roll, which only a sale in one step gives, but ${cards} of what it gives don’t fit one transaction (its accounts, its instructions or its compute), so the program refuses the box (PackTooLarge).`,
+            `${label(b)} gives a roll, which only a sale in one step gives, but ${Math.max(1, cards)} of what it gives don’t fit one transaction (its accounts, its instructions or its compute), so the program refuses the box (PackTooLarge).`,
             'Fewer cards an open, fewer prizes in its outcome, or fewer shares in its split.',
           );
-        else if (
-          !drawsFit(
-            entries,
-            slots.map(s => ({ count: s.count, only: s.from ?? [] })),
-            1,
-            extras,
-          )
-        ) {
+        else if (cards > 1 && !drawsFit(entries, drawn, 1, extras)) {
           let most = cards - 1;
           while (most > 1 && !drawsFit(entries, most, 1, extras)) most -= 1;
           refuse(
             'E-ODDS',
             `${where}.slots`,
-            `${label(b)} draws ${cards} cards an open among ${outs.length} outcome${outs.length === 1 ? '' : 's'}: more than one answer of the oracle’s can draw (about ${most} here), so the program refuses the box (PackTooLarge).`,
+            `${label(b)} draws ${cards} cards an open among ${outs.length} outcome${outs.length === 1 ? '' : 's'}: more than one answer of the oracle’s can draw (about ${most} here${searched}), so the program refuses the box (PackTooLarge).`,
             'Fewer cards an open (sell two packs instead of one), fewer outcomes, fewer prizes in an outcome, or a smaller box (fewer odds, shares, slots or outcomes that act on the NFT).',
           );
-        }
+        } else if (cards <= 1 && !drawsFit(entries, drawn, 1, extras))
+          refuse(
+            'E-ODDS',
+            `${where}.outcomes`,
+            `${label(b)} is too long for one answer of the oracle’s to draw it once${searched}, so the program refuses the box when it is written (PackTooLarge).`,
+            'Fewer outcomes, fewer prizes in an outcome, fewer pools or stashes named, or a smaller box (fewer odds, shares or slots). Put a long weighted list in a table or a stash, drawn by one outcome.',
+          );
       }
     }
     if (cards > 1 && b.rollsOn)
@@ -5700,7 +5745,7 @@ export function check(economy, { network = 'devnet', now = Math.floor(Date.now()
     for (const step of setup?.steps ?? []) {
       let bytes;
       try {
-        bytes = stepBytes(step.build(ctx), ctx);
+        bytes = stepAloneBytes(step, ctx);
       } catch {
         continue;
       }

package/js/economy/cost.mjs

@@ -47,11 +47,19 @@ export function setupCost(plan, economy) {
   const m = model(economy);
   // An account that grows (a live stash taking more NFTs) pays rent for its new bytes only.
   const rentOf = c => (c.grows ? BigInt(c.bytes) * RENT_PER_BYTE : rent(c.bytes));
+  // `fee`: what the program that makes an account keeps in it on top of its rent (Token Metadata's, for a token's name
+  // on chain). It is not rent: it never comes back.
   const accounts = plan.transactions
     .flatMap(t => t.steps)
     .flatMap(s => s.creates ?? [])
-    .map(c => ({ ...c, lamports: rentOf(c).toString(), sol: sol(rentOf(c)) }));
+    .map(c => ({
+      ...c,
+      lamports: rentOf(c).toString(),
+      sol: sol(rentOf(c)),
+      ...(c.fee ? { feeSol: sol(BigInt(c.fee)) } : {}),
+    }));
   const rentLamports = accounts.reduce((n, a) => n + BigInt(a.lamports), 0n);
+  const metadataLamports = accounts.reduce((n, a) => n + BigInt(a.fee ?? 0), 0n);
   const charged = plan.transactions.flatMap(t => t.steps).filter(s => !NO_FEE_STEP.test(s.id));
   const feeLamports = BigInt(charged.length) * FEES.project;
   const networkLamports = plan.transactions.reduce((n, t) => n + BigInt(t.signers.length) * SIGNATURE_FEE, 0n);
@@ -76,7 +84,7 @@ export function setupCost(plan, economy) {
   for (const l of m.lotteries) if (steps.has(`rent:lottery:${l.key}`)) seedLamports += roundRentOf(l, m);
   for (const sc of m.schedules)
     if (sc.sealed && (sc.fundFrom ?? 'wallet') === 'wallet') putIn(sc.currency, sc.fund, `fund:${sc.key}`);
-  const total = rentLamports + feeLamports + networkLamports + seedLamports;
+  const total = rentLamports + metadataLamports + feeLamports + networkLamports + seedLamports;
   const notes = [];
   if (accounts.some(a => a.approx))
     notes.push('Accounts marked “about” are sized roughly (a Core collection or an external token account).');
@@ -96,6 +104,7 @@ export function setupCost(plan, economy) {
   return {
     accounts,
     rentSol: sol(rentLamports),
+    metadataFeesSol: sol(metadataLamports),
     programFeesSol: sol(feeLamports),
     networkFeesSol: sol(networkLamports),
     seeds,
@@ -483,6 +492,8 @@ export function explainCost(c) {
   ];
   lines.push(
     `  rent ${s.rentSol} SOL for ${s.accounts.length} accounts; program fees ${s.programFeesSol} SOL; network fees ${s.networkFeesSol} SOL${
+      s.metadataFeesSol ? `; Token Metadata’s fees ${s.metadataFeesSol} SOL (a token’s name on chain)` : ''
+    }${
       Object.keys(s.seeds).length
         ? `; seeds ${Object.entries(s.seeds)
             .map(([k, v]) => `${v} ${k}`)
@@ -490,7 +501,10 @@ export function explainCost(c) {
         : ''
     }.`,
   );
-  for (const a of s.accounts) lines.push(`  ${a.approx ? 'about ' : ''}${a.sol} SOL: ${a.what} (${a.bytes} bytes)`);
+  for (const a of s.accounts)
+    lines.push(
+      `  ${a.approx ? 'about ' : ''}${a.sol} SOL: ${a.what} (${a.bytes} bytes)${a.feeSol ? `, and ${a.feeSol} SOL Token Metadata keeps for it` : ''}`,
+    );
   lines.push('While it runs (for a player, quote the “in all” number: it is what leaves their wallet for good):');
   for (const r of c.actions) {
     const deposits = r.deposits.map(d => `${d.sol} SOL for ${d.what} (back: ${d.back})`).join('; ');

package/js/economy/explain.mjs

@@ -204,6 +204,18 @@ export function explainEconomy(economy, { now = Math.floor(Date.now() / 1000) }
   );
   if (economy.prompt) lines.push(`Asked for: “${economy.prompt}”`);
 
+  // A token the setup makes is named on chain as it is made (plan.mjs): what wallets will show, and that a picture
+  // needs its link before going live. One that is live already keeps what it has.
+  section(
+    'The tokens going live makes',
+    [...m.tokens.values()]
+      .filter(t => t.source === 'game' && !economy.live?.mints?.[t.key])
+      .map(
+        t =>
+          `${t.symbol}${t.name !== t.symbol ? ` (“${t.name}”)` : ''}: ${t.fixedSupply ? `a fixed supply of ${num(t.supply)}, all of it to your wallet, and no more ever` : 'minted by the project as its rules say'}. It is named on chain as it is made, so wallets show ${t.uri ? 'its name, its ticker and the picture its link gives' : 'its name and ticker and no picture: for one, give it a `uri` (a link to a JSON file that names its `image`) before going live'}. Only your wallet can change the name, ticker and link later, and these tools don’t change a live token’s yet: get them right first.`,
+      ),
+  );
+
   const fee = num(sim.fees.playerSol);
   const actions = [];
   for (const it of sim.items) {
@@ -559,6 +571,8 @@ export function explainEconomy(economy, { now = Math.floor(Date.now() / 1000) }
   lines.push('', 'What setting it up costs');
   lines.push(
     `- About ${num(s.totalSol)} SOL in all, in ${plural(s.transactions, 'transaction')} (${plural(s.approvals, 'wallet approval')}): rent ${num(s.rentSol)} SOL for ${plural(s.accounts.length, 'account')}, program fees ${num(s.programFeesSol)} SOL, network fees ${num(s.networkFeesSol)} SOL${
+      s.metadataFeesSol ? `, Token Metadata’s fees ${num(s.metadataFeesSol)} SOL (a token’s name on chain)` : ''
+    }${
       Object.keys(s.seeds).length
         ? `, seeds ${Object.entries(s.seeds)
             .map(([k, v]) => `${num(v)} ${k}`)

package/js/economy/guide.mjs

@@ -10,7 +10,7 @@ const sol = lamports => Number(lamports) / Number(LAMPORTS_PER_SOL);
 export const PARTS = {
   tokens: {
     def: 'token',
-    says: 'The currencies: SOL, any existing mint by address (classic or Token-2022, coins from a token launchpad or an AMM included), or a token the game makes when it goes live: one the game mints as its rules say (points, tickets, shards, an emission), or one with a fixed `supply` minted once to the owner with minting turned off for good (a community token you keep). loot does not put a token on a market: for trading, launch it on a token launchpad or an AMM, then name the mint.',
+    says: 'The currencies: SOL, any existing mint by address (classic or Token-2022, coins from a token launchpad or an AMM included), or a token the game makes when it goes live: one the game mints as its rules say (points, tickets, shards, an emission), or one with a fixed `supply` minted once to the owner with minting turned off for good (a community token you keep). A token the game makes is named on chain as it is made (`name`, `symbol`, and `uri`: a link to a JSON file naming its picture), which is what wallets show; only the owner’s wallet can change that later, and changing them in a spec that is already live changes nothing on chain yet. loot does not put a token on a market: for trading, launch it on a token launchpad or an AMM, then name the mint.',
     acts: 'nobody: a token is a fact',
   },
   currency: {
@@ -39,7 +39,7 @@ export const PARTS = {
   boxes: {
     def: 'box',
     nested: ['outcome', 'odds', 'gate', 'rule', 'effect', 'rise', 'fall', 'split', 'perWalletEach'],
-    says: 'A paid (or free) roll on chain with MagicBlock’s verifiable randomness, optionally on an NFT (`rollsOn`: an enchant, a mission’s result, a risky forge), whose outcomes then move its numbers (`shifts`) and send it back, burn it or give it away (`then`; a box that can burn or give it away holds it until the roll settles): each outcome gives an item, a fixed prize from a pool, tokens minted (`tokens`), an NFT of a stash (picked at random, or a named one: `nft`), a roll of another box (`roll`), several of these together (`bundle`: { "gives": "bundle", "prizes": [...] }, a pack; it gives all it names or isn’t given, so it names a pool once, a stash’s random NFT beside nothing else of that stash, and two of an item need two left), or nothing. A box of one outcome with nothing random and no NFT it rolls on is bought in one step (`buy`): the price split and what it gives handed over at once, with no order and no oracle. A box takes an NFT as its price through `rollsOn` (which NFTs) and `then` (where the one paid goes: burned, given, or into a stash, a trade-in that becomes another player’s prize). A box is also the prize any route gives: a grant (`gives: { "roll": box }`), a lottery’s place (`{ "percent", "roll" }`), a contest’s winners (`roll`), an auction’s lot (`{ "roll": box }`), a mission’s tier and a recipe roll it for a winner, who gets whatever it gives; such a box is left `active: false`. How long a box can be is what one answer of the oracle’s holds (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 longer weighted list goes in a table or a stash, drawn by one outcome. A roll is on its written odds whatever is in stock, and `whenOut` says what a draw on an outcome that is out does: "stopSales" (the default) stops selling while one couldn’t be covered, a paid miss gives that draw’s worth back at the settle (with no draw made a paid open fails and is refunded), and a free roll goes back to waiting and is asked again until it hits; "drawLeft" draws among what is left; "giveNothing" keeps selling and a miss gives nothing, paid or free. Odds rules (`odds`) add any percent (99,900 makes an outcome a thousand times likelier; a weight stops at the largest, 4,294,967,295) and count on every route, read when a roll is first asked. A sale in one step sells only while its pools hold every fixed prize. A prize won is set aside for its winner at once. An edit of a box’s roll fails only a purchase still waiting (for its refund); any other roll waiting rolls on the box as edited. A gate (a collectible shown, a few wallets, or a list of any size: `{ "list": [address, …] }`, an allowlist whose proof each player passes) and odds can read what a player shows; `opens`/`closes` time a drop; `perWallet`/`perWalletEach` limit each wallet (one ticket per wallet). A split share "chosen" lets the buyer name a referrer; "chosen:<item>" the holder of a collectible they name (plot rent).',
+    says: 'A paid (or free) roll on chain with MagicBlock’s verifiable randomness, optionally on an NFT (`rollsOn`: an enchant, a mission’s result, a risky forge), whose outcomes then move its numbers (`shifts`) and send it back, burn it or give it away (`then`; a box that can burn or give it away holds it until the roll settles): each outcome gives an item, a fixed prize from a pool, tokens minted (`tokens`), an NFT of a stash (picked at random, or a named one: `nft`), a roll of another box (`roll`), several of these together (`bundle`: { "gives": "bundle", "prizes": [...] }, a pack; it gives all it names or isn’t given, so it names a pool once, a stash’s random NFT beside nothing else of that stash, and two of an item need two left), or nothing. A box of one outcome with nothing random and no NFT it rolls on is bought in one step (`buy`): the price split and what it gives handed over at once, with no order and no oracle. A box takes an NFT as its price through `rollsOn` (which NFTs) and `then` (where the one paid goes: burned, given, or into a stash, a trade-in that becomes another player’s prize). A box is also the prize any route gives: a grant (`gives: { "roll": box }`), a lottery’s place (`{ "percent", "roll" }`), a contest’s winners (`roll`), an auction’s lot (`{ "roll": box }`), a mission’s tier and a recipe roll it for a winner, who gets whatever it gives; such a box is left `active: false`. How long a box can be is what one answer of the oracle’s holds (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; fewer where its outcomes name pools or stashes, each search for one’s address counted: sixteen stashes fit 9 draws an open where finding them takes 36 tries): a longer weighted list goes in a table or a stash, drawn by one outcome. A roll is on its written odds whatever is in stock, and `whenOut` says what a draw on an outcome that is out does: "stopSales" (the default) stops selling while one couldn’t be covered, a paid miss gives that draw’s worth back at the settle (with no draw made a paid open fails and is refunded), and a free roll goes back to waiting and is asked again until it hits; "drawLeft" draws among what is left; "giveNothing" keeps selling and a miss gives nothing, paid or free. Odds rules (`odds`) add any percent (99,900 makes an outcome a thousand times likelier; a weight stops at the largest, 4,294,967,295) and count on every route, read when a roll is first asked. A sale in one step sells only while its pools hold every fixed prize. A prize won is set aside for its winner at once. An edit of a box’s roll fails only a purchase still waiting (for its refund); any other roll waiting rolls on the box as edited. A gate (a collectible shown, a few wallets, or a list of any size: `{ "list": [address, …] }`, an allowlist whose proof each player passes) and odds can read what a player shows; `opens`/`closes` time a drop; `perWallet`/`perWalletEach` limit each wallet (one ticket per wallet). A split share "chosen" lets the buyer name a referrer; "chosen:<item>" the holder of a collectible they name (plot rent).',
     acts: `the player opens (${sol(FEES.player)} SOL + ${sol(ORACLE_FEE)} SOL to the oracle); its player, a key they named or the project’s keys settle. Chance that pays money is flagged`,
   },
   payments: {