@xgamesfun/solana 0.26.0 → 0.26.1

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,7 +9,7 @@ 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';
@@ -59,7 +59,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 +685,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 });
@@ -2398,7 +2404,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 +2563,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 +2576,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 +5717,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/guide.mjs

@@ -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: {

package/js/economy/plan.mjs

@@ -21,7 +21,12 @@ import {
 } from '../chain/pda.js';
 import { createTableIx, extendTableIx } from '../chain/lookup.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 +39,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,
@@ -944,6 +949,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 +1794,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 +1815,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 +1851,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)