@xgamesfun/solana 0.20.1 → 0.24.0

package/js/play/index.js

@@ -20,7 +20,7 @@
 // `spec` is the live xsolana.json (its `live` section names the project). `wallet` is { address, signTransaction(wire) →
 // signed wire }: `walletStandardSigner` makes one from a Wallet Standard wallet (Phantom, Solflare, Backpack).
 import { decodeBase58, encodeBase58 } from '../chain/base58.js';
-import { ownedAssetFilters, parseCoreAsset } from '../chain/core.js';
+import { ownedAssetFilters, parseCoreAsset, parseCoreCollection } from '../chain/core.js';
 import { ASSOCIATED_TOKEN_PROGRAM, associatedTokenAddress, COMPUTE_BUDGET_PROGRAM, NATIVE_MINT, SYSVAR_SLOT_HASHES, TOKEN_2022_PROGRAM, TOKEN_PROGRAM } from '../chain/pda.js';
 import { closeTokenAccount, computeUnitLimit, createAssociatedTokenAccountIdempotent, requestHeapFrame, syncNative, transferLamports, withSolWrap } from '../chain/programs.js';
 import { checkCluster, notMainnet, rpcClient } from '../chain/rpc.js';
@@ -28,8 +28,13 @@ import { MEMO_PROGRAM, mintPowers, resolveTransfers } from '../chain/token2022.j
 import { compileFitting, closeTableIx, deactivateTableIx, readTable, sendFitting, sendPlan, slotHashes, tablesOf, tableStep, transactionLocks, LOOKUP_TABLE_PROGRAM } from '../chain/lookup.js';
 import { compileMessage, readTransaction, wireTransaction } from '../chain/tx.js';
 import * as loot from '../client/index.js';
+import { browserStore, keyring } from './keys.js';
 
 // The options of a call made without any: read-only, and typed so the generated declarations take any option.
+/** A lottery's steps in `claims()`: each depends on the one before, so `claimAll` takes one of a lottery's a call. */
+const LOTTERY_STEPS = new Set(['reveal', 'cancel-draw', 'pull', 'payout']);
+/** The claims that are one transaction of the wallet's: `claimAll` signs them together. */
+const BATCHED = new Set(['contest', 'release', 'lookup-table', 'close-leaf', ...LOTTERY_STEPS]);
 const NO_OPTIONS = Object.freeze(/** @type {Record<string, any>} */ ({}));
 
 const CHAIN = 'solana:devnet';
@@ -39,24 +44,30 @@ const NOBODY = '11111111111111111111111111111111';
 /** A table made this many slots ago whose transaction never landed was never sent: its blockhashes ran out long since. */
 const TABLE_UNSENT_SLOTS = 300n;
 /** A compressed NFT's `prove_leaf`: its record stays good while the leaf is unchanged, so it may go in a transaction of its own first. */
-const PROVE_LEAF = loot.IDL.instructions.find((i) => i.name === 'prove_leaf').discriminator;
-const isProveLeaf = (ix) => ix.programId === loot.LOOT_PROGRAM && PROVE_LEAF.every((b, i) => ix.data[i] === b);
+const isProveLeaf = (ix) => ix.programId === loot.LOOT_PROGRAM && loot.instructionOf(ix.data)?.name === 'prove_leaf';
 /** A system account must keep this much (rent for 0 bytes) or be emptied. */
 const RENT_EMPTY = 890_880n;
 const SIGNATURE_FEE = 5_000n;
-/** What a box's open puts in its throwaway key: its one signature's fee, and the rent it must hold until then. */
-const BURNER_LAMPORTS = RENT_EMPTY + SIGNATURE_FEE;
 
-/** A signer from a Wallet Standard wallet and one of its accounts: the wallet signs, the app sends. */
+/**
+ * A signer from a Wallet Standard wallet and one of its accounts: the wallet signs, the app sends. With the wallet's
+ * `solana:signMessage`, also `signMessage(bytes)`: the app's settle keys are made from one signature of it a session,
+ * so a page that closes can make them again (`recover`).
+ */
 export function walletStandardSigner(wallet, account, chain = CHAIN) {
   const feature = wallet.features?.['solana:signTransaction'];
   if (!feature) throw new Error(`${wallet.name} cannot sign transactions.`);
+  const messages = wallet.features?.['solana:signMessage'];
   return {
     address: account.address,
     async signTransaction(wire) {
       const [out] = await feature.signTransaction({ account, transaction: wire, chain });
       return out.signedTransaction;
     },
+    ...(messages ? { async signMessage(message) {
+      const [out] = await messages.signMessage({ account, message });
+      return out.signature;
+    } } : {}),
   };
 }
 
@@ -118,14 +129,20 @@ function devnetOnly(client) {
  * The player's side of a live economy. `rpc` may be given instead of `rpcUrl` (any object with the client's rpc
  * methods: accounts, account, latestBlockhash, send, confirm, programAccounts, and call(method, params), the raw JSON
  * RPC request the devnet check, the slot and the compressed-NFT reads go through). `now` is the clock auctions are read
- * by (Unix seconds). Devnet only (`devnetOnly`): mainnet waits for an audit.
+ * by (Unix seconds). Devnet only (`devnetOnly`): mainnet waits for an audit. `keyStore`: where a settle key that can't
+ * be made again from the wallet's signature is kept, encrypted (`browserStore()` in a browser; null keeps keys in memory
+ * only).
  */
-export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc = null, wallet, programs = {}, now = () => Math.floor(Date.now() / 1000) }) {
+export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc = null, wallet, programs = {}, now = () => Math.floor(Date.now() / 1000), keyStore = browserStore() }) {
   const live = spec?.live;
   if (!live?.project) throw new Error('This economy is not live yet: its xsolana.json has no "live" section.');
   if (rpc && typeof rpc.call !== 'function') throw new Error('The rpc given has no call(method, params): a custom rpc needs it (the devnet check, the slot and compressed NFTs are read through it), as well as accounts, account, latestBlockhash, send, confirm and programAccounts.');
   const client = devnetOnly(rpc ?? rpcClient(notMainnet(rpcUrl)));
   const project = live.project;
+  /** The settle keys, each named by its job's account (`keys.js`): made again after a reload (`recover`). */
+  const keys = wallet?.address ? keyring({ wallet, project, store: keyStore }) : null;
+  /** The key for a job about `name` (an order's, a hold's address): one that can be made again, or a fresh one. */
+  const jobKey = async (name) => (keys ? keys.key(name) : freshKey());
   /** The project's Core collections: an NFT of one of them is the project's own (a project may have none). */
   const collections = live.collections ?? (live.collection ? [live.collection] : []);
   const ours = (collection) => collection != null && collections.includes(collection);
@@ -159,10 +176,10 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     return a?.owner === loot.LOOT_PROGRAM ? loot.decode(name, a.data) : null;
   };
   /** The key of the token a lottery's tickets are paid in: the spec's `ticketCurrency`, or the token of its mint. */
-  const ticketCurrencyOf = (l, lottery) => l.ticketCurrency ?? [...tokens.keys()].find((k) => mintOf(k) === lottery.mint) ?? currencyKey;
+  const ticketCurrencyOf = (l, lottery) => l.ticketCurrency ?? [...tokens.keys()].find((k) => mintOf(k) === lottery.terms.mint) ?? currencyKey;
   /** Farm hooks shared by all actions. Static lists resolve automatically. For dynamic hooks,
    * transfers[mint] describes every actual transfer, including fee-adjusted reward credit/payout, and in a farm that
-   * shares its pool the move's last one when a seat gave rewards back in it (an early exit, a lapsed upkeep, a watched
+   * shares its pool the move's last one when a seat gave rewards back in it (an early exit, a watched
    * NFT gone): from the farm's rewards vault back to its pool, the project the authority.
    * Explicit extra replaces resolution and must include all token hook/memo and Core adapter accounts. */
   const farmTokens = async (mints, create, { extra, transfers = {} } = {}) => {
@@ -255,17 +272,12 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * What `loot.prizeMetas` needs to give these prizes (`null`s are skipped): each pool's mint, each item (its kind, its
    * collection and its next serial; null for one never written), each NFT's kind (`nfts`, and `nft` for one), the
    * project's first collection, a compressed NFT's proof, which goes first in the transaction (`before`), and for a
-   * roll its box (`boxes`, null for one never written) and the mint of each pool its prizes name (`rollPools`, null for
-   * one never opened): a route the player pays or asks for passes the box's prize mints (`loot.rollMints`).
+   * roll its box, decoded (`boxes`, `boxesOf`).
    */
   async function prizeInputs(prizes, signer = wallet.address, winner = wallet.address) {
-    const out = { poolMints: {}, items: {}, nfts: {}, nft: undefined, collection: collections[0], before: [], boxes: {}, rollPools: {} };
+    const out = { poolMints: {}, items: {}, nfts: {}, nft: undefined, collection: collections[0], before: [] };
+    out.boxes = await boxesOf(prizes.filter(Boolean).flatMap((p) => (p.Roll ? [p.Roll[0]] : [])));
     for (const prize of prizes.filter(Boolean)) {
-      const rolled = prize.Roll?.[0];
-      if (rolled !== undefined && !(rolled in out.boxes)) {
-        const box = (out.boxes[rolled] = await readMaybe('LootBox', loot.pda.box(project, rolled)));
-        if (box) Object.assign(out.rollPools, await poolMintsOf(box));
-      }
       const pool = prize.Tokens?.from.Pool?.[0];
       if (pool !== undefined && !(pool in out.poolMints)) {
         const account = await client.account(loot.pda.pool(project, pool));
@@ -309,6 +321,14 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
   };
   /** The same for one the project holds: staked in escrow. */
   const escrowedIn = async (asset) => ((await ownerOf(asset).catch(() => null)) === project ? seatedIn(asset, ['escrow']) : null);
+  /** The same for one the project locks in the player's wallet: staked in a farm that freezes (a soulbound Core asset
+   * carries no lock to tell it is staked, so it goes alone). */
+  const lockedIn = async (asset) => {
+    const seated = await seatedIn(asset, ['freeze']);
+    if (!seated) return null;
+    const account = await client.account(asset);
+    return account?.owner === MPL_CORE && parseCoreAsset(account.data).soulbound ? null : seated;
+  };
   /** The player's collectibles of this project (in any of its collections), each with the item it is (its "item_id" attribute). */
   async function owned(owner = wallet?.address) {
     const found = (await Promise.all(collections.map((c) => client.programAccounts(MPL_CORE, ownedAssetFilters(owner, c))))).flat();
@@ -318,6 +338,12 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       return { asset: pubkey, ...a, itemId, item: itemId === null ? null : itemKeyOf(itemId) };
     });
   }
+  /** A token seat's refresh (`seat` decoded), with its booster's accounts (a compressed one proven first), to go first in
+   * a stake or a compound's transaction (`loot.stakeRefreshFirst`). */
+  async function refreshOf(f, farm, seat) {
+    const { before, ...nft } = seat.asset !== NOBODY ? await nftOf(seat.asset) : { before: [] };
+    return [...before, loot.refreshSeatIx({ signer: wallet.address, project, id: f.id, farm, by: seat.player, seat, ...nft })];
+  }
   /**
    * For a gate (the program's Gate: a Rule an NFT must pass, or a list of wallets), one of the player's NFTs that
    * passes it, so a page needn't find it; null when nothing is to be shown. A rule naming a collection the project has no
@@ -414,10 +440,30 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * Its size is checked before the wallet signs (`sendFitting`): a transaction too big for a legacy one goes as one v0
    * transaction with a lookup table the wallet makes first (one to three more approvals, and the table's rent until the
    * player closes it, which `claims()` lists); only when even that is too big does each compressed NFT's `prove_leaf`
-   * go alone, after the table and before the rest.
+   * go alone, after the table and before the rest. A compressed NFT's record closes in the same transaction, its prover
+   * signing (`loot.withLeafCloses`), so its rent comes straight back.
    */
+  /**
+   * The project's standing lookup tables (made at go-live, `spec.live.tables`), each as the chain holds it now: one
+   * deactivated (or gone) is left out, and a transaction then makes a table of its own as before.
+   */
+  let standingTables = null;
+  async function standing() {
+    standingTables ??= (async () => {
+      const addresses = spec.live?.tables ?? [];
+      const found = addresses.length ? await client.accounts(addresses) : [];
+      return addresses.flatMap((address, i) => {
+        const table = readTable(found[i] && { ...found[i], owner: found[i].owner ?? LOOKUP_TABLE_PROGRAM });
+        return table && table.deactivationSlot === null ? [{ address, addresses: table.addresses }] : [];
+      });
+    })();
+    return standingTables;
+  }
+
   async function send(instructions, extra = [], { keepWrapped = false } = {}) {
     if (!wallet?.address) throw new Error('Connect a wallet first.');
+    // A compressed NFT's record is closed in the transaction that used it, its prover signing: its rent comes back.
+    instructions = loot.withLeafCloses(instructions);
     if (!keepWrapped) instructions = await unwrapAfter(instructions);
     const sign = async (message) => {
       const { signers } = readTransaction(wireTransaction(message));
@@ -425,7 +471,41 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       return wallet.signTransaction(wireTransaction(message, sigs));
     };
     // The project first in a table, so claims() knows a table whose later steps were never sent as this project's.
-    return (await sendFitting({ rpc: client, payer: wallet.address, instructions, sign, alone: isProveLeaf, first: [project] }).catch(inWords)).signature;
+    return (await sendFitting({ rpc: client, payer: wallet.address, instructions, sign, alone: isProveLeaf, first: [project], standing: await standing() }).catch(inWords)).signature;
+  }
+
+  const sendNow = (...args) => send(...args);
+
+  /**
+   * Several independent steps of the player's, each one transaction (`lists`: their instructions), signed in one wallet
+   * prompt when the wallet signs several at once (`wallet.signTransactions`), then sent in order; one by one otherwise,
+   * and for a step too big for one transaction. Returns each step's { signature } or { error }.
+   */
+  async function sendBatch(lists) {
+    const settled = (p) => p.then((signature) => ({ signature }), (e) => ({ error: e.message }));
+    let signed = null;
+    let messages = [];
+    let lastValidBlockHeight = null;
+    if (wallet?.signTransactions && lists.length > 1) {
+      const latest = await client.latestBlockhash();
+      lastValidBlockHeight = latest.lastValidBlockHeight;
+      const tables = await standing();
+      for (const l of lists) messages.push(compileFitting({ payer: wallet.address, blockhash: latest.blockhash, instructions: await unwrapAfter(loot.withLeafCloses(l)), tables }));
+      const wires = messages.filter(Boolean).map((m) => wireTransaction(m));
+      const back = wires.length > 1 ? await wallet.signTransactions(wires).catch(() => null) : null;
+      if (back) signed = messages.map((m) => (m ? back.shift() : null));
+    }
+    const out = [];
+    for (const [i, l] of lists.entries()) {
+      const wire = signed?.[i];
+      const confirmed = async () => {
+        const signature = await client.send(wire).catch(inWords);
+        await client.confirm?.(signature, { lastValidBlockHeight });
+        return signature;
+      };
+      out.push(await settled(wire ? confirmed() : send(l)));
+    }
+    return out;
   }
 
   /**
@@ -434,6 +514,9 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * logs, when it is one of loot's (Anchor's codes start at 6000; the token programs' are small).
    */
   function inWords(e) {
+    // The program logs an error's name only (its text is compiled out): the IDL's sentence for it.
+    const logged = e?.logs ? loot.lootError(e.logs) : null;
+    if (logged) throw Object.assign(new Error(`${logged.msg} (${logged.name}).`, { cause: e }), { code: logged.code, name: logged.name, logs: e.logs });
     const said = String(e?.message ?? '');
     const m = /custom program error: 0x([0-9a-f]+)/i.exec(said);
     const failed = e?.logs?.find((line) => / failed: custom program error: 0x/i.test(line));
@@ -443,11 +526,12 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
   }
 
   /**
-   * Build, sign with `key` alone (it pays), send and confirm: a throwaway key's transaction. No wallet prompt. Legacy
-   * only: the key holds no rent for a lookup table.
+   * Build, sign with `key` alone (it pays), send and confirm: a throwaway key's transaction. No wallet prompt. Legacy,
+   * or v0 with the project's standing tables (which cost it nothing); the key holds no rent for a table of its own.
    */
   async function sendAs(key, instructions) {
-    return (await sendFitting({ rpc: client, payer: key.address, instructions, sign: async (message) => wireTransaction(message, [await key.sign(message)]), table: false }).catch(inWords)).signature;
+    instructions = loot.withLeafCloses(instructions);
+    return (await sendFitting({ rpc: client, payer: key.address, instructions, sign: async (message) => wireTransaction(message, [await key.sign(message)]), table: false, standing: await standing() }).catch(inWords)).signature;
   }
 
   /**
@@ -470,18 +554,112 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
   /** An NFT's kind as a route's `ticket` or `nft` takes it: without its asset. */
   const kindOnly = ({ asset: _, ...kind }) => kind;
 
-  /** A throwaway key's leftover back to the player: all it holds less its own fee, so the key ends empty. */
-  const giveBack = (burner) => transferLamports(burner.address, wallet.address, BURNER_LAMPORTS - SIGNATURE_FEE);
+  /**
+   * The key job rule (AGENTS.md). A step after the wallet's prompt (a settle, an ask for a roll, a release) is sent by a
+   * throwaway key made in memory for that one job. `keyFor(pays)` makes it, and the transfer that funds it, which goes
+   * in the wallet's own transaction: what its steps pay (`pays`: their fees, an ask's oracle fee, the rent of what a
+   * settle opens or mints, `loot.settleRent`) and the rent minimum read from the cluster, plus one spare fee so it can
+   * always empty itself. A key pays for an account only with lamports the wallet gave it for that, and never makes a
+   * proof record: then the wallet sends that step. `key`: one made already (a box's open names it before it knows how
+   * many settles it funds).
+   */
+  async function keyFor(pays = SIGNATURE_FEE, key = null) {
+    key ??= await freshKey();
+    return { key, fund: transferLamports(wallet.address, key.address, (await rentEmpty()) + BigInt(pays) + SIGNATURE_FEE) };
+  }
+
+  /** The rent minimum of an account of no data, as the cluster says it (once). A key must hold it, past its fee, to pay
+   * a transaction's fee: a fee payer stays rent-exempt or ends empty. */
+  let rentMinimum = null;
+  const rentEmpty = async () => (rentMinimum ??= BigInt(await client.call('getMinimumBalanceForRentExemption', [0]).catch(() => Number(RENT_EMPTY))));
+
+  /** Whether `instructions` would land as `payer` sends them now (a dry run, with the standing tables when they need
+   * them), and the accounts `watch` as they would be after: { ok, accounts, error }, `error` loot's when it refused
+   * ({ code, name, msg }, `loot.lootError`). */
+  async function dryRun(payer, instructions, watch = []) {
+    const { blockhash } = await client.latestBlockhash();
+    const message = compileFitting({ payer, blockhash, instructions, tables: await standing() });
+    if (!message) return { ok: false, accounts: [], error: null };
+    let error = null;
+    const r = await client.simulate(wireTransaction(message), { accounts: watch, replaceBlockhash: true }).catch((e) => {
+      error = loot.lootError(e?.logs ?? []);
+      return null;
+    });
+    return { ok: Boolean(r), accounts: r?.accounts ?? [], error };
+  }
+
+  /** A throwaway key empties itself back to the wallet: all it holds now, less its own fee. Nothing when it holds no more
+   * than that fee (a settle of its that failed on chain took its fee: the wallet then pays the move, one more prompt). */
+  async function emptyKey(key) {
+    const left = BigInt(await client.balance(key.address).catch(() => 0n));
+    if (left >= (await rentEmpty()) + SIGNATURE_FEE) await sendAs(key, [transferLamports(key.address, wallet.address, left - SIGNATURE_FEE)]).catch(() => null);
+    else if (left > 0n) await send([transferLamports(key.address, wallet.address, left)], [key]).catch(() => null);
+    // A key kept in storage is dropped once it holds nothing.
+    if (key.name && !(BigInt(await client.balance(key.address).catch(() => 1n)) > 0n)) keys?.forget(key.name);
+  }
+
+  /** A key's job: its step (`build(signer)`), simulated as the key sends it, then sent by the key, or by the wallet when
+   * the simulation fails (one more prompt); then the key empties itself back to the wallet. Returns the signature. */
+  async function keyRun(key, build) {
+    const steps = await build(key.address);
+    const signature = (await dryRun(key.address, steps)).ok ? await sendAs(key, steps).catch(() => null) : null;
+    const sent = signature ?? (await send(await build(wallet.address)));
+    await emptyKey(key);
+    return sent;
+  }
+
+  /**
+   * Rolls in one prompt: a step that makes orders waiting for their roll (a craft, a buy, a mission left, a grant or a
+   * contest prize, a lot won) asks for each in the same transaction, and a throwaway key it funds then settles each (the
+   * key job rule: funded with each settle's fees and what it may open or mint, `loot.settleRent`). A dry run finds them:
+   * the accounts the step writes that come out as orders waiting (a limit can hold a round back, so only what it would
+   * make). A box with nothing in stock refuses the ask, and with it the step (`SoldOut`): nothing is sent, and the
+   * player is told. When the step and its asks would not land together for any other reason (a missing prize vault,
+   * too big a transaction), the step goes alone and its rolls wait in `claims()`. Returns { signature, rolls }.
+   */
+  async function sendRolling(instructions) {
+    const watch = [...new Set(instructions.filter((ix) => ix.programId === loot.LOOT_PROGRAM).flatMap((ix) => ix.keys.filter((k) => k.isWritable && !k.isSigner).map((k) => k.pubkey)))];
+    const after = (await dryRun(wallet.address, instructions, watch)).accounts;
+    const waiting = watch.flatMap((address, i) => {
+      const a = after[i];
+      if (a?.owner !== loot.LOOT_PROGRAM || loot.accountKind(a.data) !== 'Order') return [];
+      const order = loot.decode('Order', a.data);
+      return order.status === 'Waiting' && order.player === wallet.address ? [[address, order]] : [];
+    });
+    if (!waiting.length) return { signature: await send(instructions), rolls: [] };
+    const asks = [];
+    const funds = [];
+    const burners = [];
+    for (const [orderAddress, order] of waiting) {
+      const box = await read('LootBox', order.loot_box);
+      // Each order its own key, named by it (it can be made again after a reload, `recover`): its settle's fee, a spare
+      // for its parts and its give-back, and what its settle may open or mint. The ask names it as the order's settler.
+      const { key, fund } = await keyFor(SIGNATURE_FEE * 3n + loot.settleRent(box, Number(order.opens ?? 1), await itemsOf(box)), await jobKey(orderAddress));
+      asks.push(...(await asksFor(wallet.address, orderAddress, order, key.address)));
+      funds.push(fund);
+      burners.push(key);
+    }
+    const all = [...instructions, ...asks, ...funds];
+    const tried = await dryRun(wallet.address, all);
+    if (tried.error?.name === 'SoldOut') throw Object.assign(new Error('The box this rolls has nothing left to give right now (SoldOut): nothing was sent. Try again once it is restocked.'), { code: tried.error.code, name: 'SoldOut' });
+    // Too heavy to be answered: a step sent alone would pay for a roll that can only fail.
+    if (tried.error?.name === 'PackTooLarge') throw Object.assign(new Error('The box this rolls is too heavy for the oracle\'s answer as it stands (PackTooLarge): nothing was sent.'), { code: tried.error.code, name: 'PackTooLarge' });
+    if (!tried.ok) return { signature: await send(instructions), rolls: [] };
+    const signature = await send(all);
+    const rolls = [];
+    for (const [k, [orderAddress]] of waiting.entries()) rolls.push(await collect(orderAddress, { burner: burners[k], opened: true }));
+    return { signature, rolls };
+  }
 
   /**
    * Waits for an order's roll (the oracle answers a moment after the open), then settles it. With `burner` (the
    * throwaway key the open funded), the burner signs and pays the settle, and gives the rest back: no wallet prompt.
-   * Anyone may settle a rolled order: when someone did first, the burner only gives its lamports back. `putBack`: NFTs
+   * The order names it (`settler`), so it may settle; when the player or the project did first, the burner only gives its lamports back. `putBack`: NFTs
    * won that the player puts back into their stash in place of taking them (one whose collection now refuses to let it
    * move); the player signs that settle.
    */
   async function collect(orderAddress, options = {}) {
-    only(options, ['timeoutMs', 'burner', 'putBack', 'opened', 'landed'], 'collect');
+    only(options, ['timeoutMs', 'burner', 'putBack', 'opened', 'landed', 'keepBurner'], 'collect');
     try {
       return await collectOnce(orderAddress, options);
     } catch (e) {
@@ -490,18 +668,13 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       // needs no burner: the player signs that settle.
       const { burner } = options;
       if (!burner) throw e;
-      // All it holds now. While it can pay its own fee and stay rent-exempt until the transfer empties it, it sends it
-      // itself; after a settle of its that failed on chain (its fee taken) it holds only its rent, and the player's
-      // wallet pays the fee of the transaction that empties it (one more prompt, only then).
-      const left = BigInt(await client.balance(burner.address).catch(() => 0n));
-      if (left >= BURNER_LAMPORTS) await sendAs(burner, [transferLamports(burner.address, wallet.address, left - SIGNATURE_FEE)]).catch(() => null);
-      else if (left > 0n) await send([transferLamports(burner.address, wallet.address, left)], [burner]).catch(() => null);
+      await emptyKey(burner);
       if (!(await client.account(orderAddress))) return { order: orderAddress, settled: 'elsewhere', says: 'The order was settled already.' };
       throw e;
     }
   }
 
-  async function collectOnce(orderAddress, { timeoutMs = 60_000, burner = null, putBack = [], opened = false, landed = null } = {}) {
+  async function collectOnce(orderAddress, { timeoutMs = 60_000, burner = null, putBack = [], opened = false, landed = null, keepBurner = false } = {}) {
     const started = Date.now();
     // `landed`: the slot one's own open landed in; the order is read from a node that has seen it.
     const current = async () => {
@@ -516,8 +689,8 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       order = await current();
     }
     // A roll a mission or a recipe made waits to be asked for (or asked again, the oracle never having answered):
-    // anyone asks, here the player.
-    if (order && loot.rollAskable(order, await slotNow())) {
+    // its player or the project's keys ask, here the player.
+    if (order && loot.rollAskable(order, await slotNow(), await chainNow())) {
       await askRoll(orderAddress);
       order = await current();
     }
@@ -525,8 +698,12 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       await sleep(1500);
       order = await current();
     }
+    // A free roll whose answer found nothing at all in stock waits again: for a restock, or for its player to end it.
+    if (order?.status === 'Waiting') {
+      throw new Error('The box this rolls had nothing left to give when the roll landed, so the roll waits: collect it again once the box is restocked. Collected while the box is still empty, the player\'s own ask ends it with nothing.');
+    }
     if (!order) {
-      if (burner) await sendAs(burner, [giveBack(burner)]);
+      if (burner && !keepBurner) await emptyKey(burner);
       // One's own open still not seen after that: say so plainly, never that it was settled (claims() lists it).
       if (opened) return { order: orderAddress, settled: null, says: 'The network doesn’t show this order yet: collect it again in a moment (claims() lists it).' };
       return { order: orderAddress, settled: 'elsewhere', says: 'The order was settled already.' };
@@ -544,64 +721,117 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     // What the roll set aside: each item it gave (its kind and collection) and each NFT's kind (a compressed one
     // proven first).
     const items = {};
-    for (const won of order.won) if (won.Item && !(won.Item.item in items)) items[won.Item.item] = await read('Item', loot.pda.item(project, won.Item.item));
+    for (const won of order.won) {
+      const id = won.Item?.item ?? won.Compressed?.item;
+      if (id !== undefined && !(id in items)) items[id] = await read('Item', loot.pda.item(project, id));
+    }
+    // A compressed prize is minted into the tree its box names (any of the project's with room), the next NFT it mints.
+    const treeOf = async () => {
+      if (!order.won.some((w) => w.Compressed)) return {};
+      const box = await read('LootBox', order.loot_box);
+      const tree = box.entries.flatMap((e) => e.prizes).find((p) => p.Compressed)?.Compressed.tree;
+      const config = (await client.account(loot.pda.treeConfig(tree)))?.data;
+      // An item's collection without Bubblegum's plugin mints nothing: the prizes after it take its place in the tree.
+      const unminted = [];
+      for (const c of new Set(order.won.filter((w) => w.Compressed).map((w) => items[w.Compressed.item]?.collection).filter(Boolean))) {
+        const data = (await client.account(c))?.data;
+        if (!data || !parseCoreCollection(data).bubblegum) unminted.push(c);
+      }
+      return { tree, unminted, treeMinted: config ? config.subarray(80, 88).reduce((n, b, i) => n | (BigInt(b) << BigInt(8 * i)), 0n) : 0n };
+    };
     const holders = await holdersOf(order.shares);
     // Given by its fate to a wallet that is an account of the loot program, the NFT goes back to the player.
     const gives = order.held ? order.fate?.then?.Give?.[0] : undefined;
     const handBack = gives !== undefined && loot.handsBack(await client.account(gives));
-    /** The settle as `signer` sends it, and what goes before it: each compressed NFT's proof, a fresh token account. */
-    const settleBy = async (signer) => {
+    /** The settle's part up to `upto` (`loot.SETTLE_LAST`: all that is left; 0: the split alone) as `signer` sends it,
+     * and what goes before it: each compressed NFT's proof, a fresh token account. */
+    const settleBy = async (signer, upto = loot.SETTLE_LAST) => {
       const nfts = {};
       const proving = [];
-      for (const won of order.won) {
+      const end = Math.min(order.won.length, upto);
+      for (const won of order.won.slice(Number(order.settled ?? 0), end)) {
         if (won.Nft && !putBack.includes(won.Nft.nft)) {
-          // A Token Metadata NFT's settle is the wallet's to send (it pays rent: `paysRent`), so the wallet opens any fresh account.
+          // A fresh token account a Token Metadata NFT needs (its holder's own can't take it) is the wallet's to open: a
+          // settle with anything before it is the wallet's to send.
           const { before, hasAuthority: _, ...kind } = await nftOf(won.Nft.nft, signer, { to: order.player, payer: wallet.address });
           nfts[won.Nft.nft] = kind;
           proving.push(...before);
         }
       }
       // The NFT the roll was on: its kind, and for a compressed one a proof first.
-      const { before: subjectProof, ...subject } = order.subject !== NOBODY ? await nftOf(order.subject, signer) : { before: [] };
-      const ix = loot.settleIx({ signer, orderAddress, order, projectState: g, items, nfts, putBack, subject, handBack, holders, programs });
+      const { before: subjectProof, ...subject } = order.subject && order.subject !== NOBODY ? await nftOf(order.subject, signer) : { before: [] };
+      const ix = loot.settleIx({ signer, orderAddress, order, projectState: g, items, nfts, putBack, subject, handBack, holders, programs, upto, ...(await treeOf()) });
       return { ix, nfts, before: [...subjectProof, ...proving].filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM) };
     };
+    // An order whose settle doesn't fit one transaction (the instruction trace, 64 accounts, 1,232 bytes) settles in
+    // parts, each its own transaction, from where the last stopped. The first splits the payment, its shares' accounts
+    // with it (alone, `upto` 0, when not even one prize fits beside them); parts that hand prizes over (`upto` where
+    // each stops), as many as the trace holds (`settlePartEnd`) and fewer until they fit; then a last part
+    // (`SETTLE_LAST`) with the NFT rolled on. The burner sends each, paying what each mints with what the open funded it
+    // with; the player's wallet, a part it can't.
+    const signatures = [];
+    // A key the order doesn't name can't settle it (`Order::settler`): then the player signs.
+    const by = burner && !putBack.length && order.settler === burner.address ? burner.address : wallet.address;
+    const fits = async (instructions) => Boolean(compileFitting({ payer: by, blockhash: NOBODY, instructions, tables: await standing() })) && transactionLocks(by, instructions) <= 64;
+    const part = async (end) => [computeUnitLimit(loot.settleComputeUnits(order)), (await settleBy(by, end)).ix];
+    const sendPart = async (end) => signatures.push(by === wallet.address ? await send(await part(end)) : await sendAs(burner, await part(end)));
+    for (;;) {
+      const from = Number(order.settled ?? 0);
+      if (from >= order.won.length) break;
+      let end = loot.settlePartEnd(order, from, items);
+      if (end >= order.won.length && (await fits(await part(loot.SETTLE_LAST)))) break;
+      while (end > from + 1 && !(await fits(await part(end)))) end--;
+      await sendPart(Number(order.drew ?? 0) > 0 && !(await fits(await part(end))) ? 0 : end);
+      order = await current();
+      if (!order) return { order: orderAddress, settled: 'elsewhere', says: 'The order was settled already.' };
+    }
     // Room for every move the shape makes (`loot.settleComputeUnits`), and for a settle of several NFTs the bigger heap
     // the program's allocator uses (`loot.settleHeapFrame`).
     const heap = loot.settleHeapFrame(order);
     const budget = [computeUnitLimit(loot.settleComputeUnits(order)), ...(heap ? [requestHeapFrame(heap)] : [])];
-    // The settle opens any account it pays into that is not there, paid by whoever signs it. A burner holds no rent
-    // to spare: the open made the player's accounts of the prizes' mints and of the payees, so it settles alone unless
-    // the settle pays rent of its own (a roll won makes an order; a Token Metadata NFT goes into a new token account),
-    // needs a proof first, or doesn't fit a legacy transaction (a lookup table's rent is the wallet's to pay). An NFT put
-    // back into its stash (one its collection no longer lets move) is the player's own choice: they sign.
-    let signature;
-    const byBurner = burner && !putBack.length ? await settleBy(burner.address) : null;
-    const paysRent = (built) => order.won.some((w) => w.Roll || (w.Nft && built.nfts[w.Nft.nft]?.tokenMetadata));
-    const alone = byBurner && !paysRent(byBurner) && !byBurner.before.length ? [...budget, byBurner.ix, giveBack(burner)] : null;
-    // The burner's transaction counts its compute limit: a settle within about 40 bytes of the legacy limit goes from the
-    // wallet (one prompt) rather than without one, as a settle with the default limit can run out (205,794 units on
-    // devnet) and the burner holds the fee of one try only.
-    if (alone && compileFitting({ payer: burner.address, blockhash: NOBODY, instructions: alone })) signature = await sendAs(burner, alone);
-    else {
+    // The settle opens or mints what the order won (a collectible, a token account, a Sheet, the fate's writes), paid by
+    // whoever signs it: the burner, with what the open funded it with (`loot.settleRent`). It settles alone unless the
+    // settle needs something first (a proof, a fresh token account) or doesn't fit a legacy transaction (a lookup
+    // table's rent is the wallet's to pay), and only when a dry run says it lands as the burner sends it; else the
+    // wallet settles (one more prompt). An NFT put back into its stash (one its collection no longer lets move) is the
+    // player's own choice: they sign.
+    let signature = null;
+    let emptied = false;
+    const byBurner = burner && !putBack.length && order.settler === burner.address ? await settleBy(burner.address) : null;
+    const alone = byBurner && !byBurner.before.length ? [...budget, byBurner.ix] : null;
+    const legacy = (instructions) => Boolean(compileFitting({ payer: burner.address, blockhash: NOBODY, instructions }));
+    const tried = alone && legacy(alone) ? await dryRun(burner.address, alone, [burner.address]) : null;
+    if (tried?.ok) {
+      // Its last settle gives back all the burner holds after it, in the same transaction, as the dry run says it will
+      // hold (its fee and what the settle opened taken); when that doesn't land as one, the burner empties itself after.
+      const left = BigInt(tried.accounts[0]?.lamports ?? 0);
+      const back = !keepBurner && left > 0n ? [...alone, transferLamports(burner.address, wallet.address, left)] : null;
+      if (back && legacy(back) && (await dryRun(burner.address, back)).ok) signature = await sendAs(burner, back).catch(() => null);
+      emptied = Boolean(signature);
+      signature ??= await sendAs(burner, alone).catch(() => null);
+    }
+    if (!signature) {
       // The wallet's settle: as a v0 transaction with a lookup table when it doesn't fit a legacy one (`send`).
       const { ix, before } = await settleBy(wallet.address);
       signature = await send([...budget, ...before, ix]);
-      if (burner) await sendAs(burner, [giveBack(burner)]);
     }
-    const assets = wonAssets(orderAddress, order).map((a) => (putBack.includes(a) ? null : a));
-    return { order: orderAddress, won: order.won, assets, settled: signature, ...(assets.find(Boolean) ? { asset: assets.find(Boolean) } : {}) };
+    // The burner gives back what it holds after its last settle (a purchase of several orders: after the last order's).
+    if (burner && !keepBurner && !emptied) await emptyKey(burner);
+    else if (burner && emptied) keys?.forget(burner.name);
+    const assets = wonAssets(order).map((a) => (putBack.includes(a) ? null : a));
+    return { order: orderAddress, won: order.won, assets, settled: signature, ...(signatures.length ? { parts: [...signatures, signature] } : {}), ...(assets.find(Boolean) ? { asset: assets.find(Boolean) } : {}) };
   }
 
   /**
    * For each prize an order won, what it is now: the collectible minted (`["asset", item, serial]`), the NFT handed
-   * over, the order a roll won is made in; null for tokens. A normal item is the project's backend's to deliver.
+   * over; null for tokens. A normal item is the project's backend's to deliver.
    */
-  function wonAssets(orderAddress, order) {
-    return order.won.map((won, k) => {
+  function wonAssets(order) {
+    return order.won.map((won) => {
       if (won.Item) return loot.pda.itemAsset(loot.pda.item(project, won.Item.item), won.Item.serial);
       if (won.Nft) return won.Nft.nft;
-      if (won.Roll) return loot.pda.order(project, order.player, loot.rollNonce(orderAddress, order.requested_slot, k));
+      // A compressed NFT's asset id is the tree's count when it was minted: read from its settle's receipt or the
+      // player's assets (`claims`), not from the order.
       return null;
     });
   }
@@ -609,6 +839,23 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
   /** A nonce for an order no other order of the player's is at. */
   const freshNonce = () => BigInt(Date.now()) * 1000n + BigInt(Math.floor(Math.random() * 1000));
 
+  /** Each box of `ids`, decoded (null for one never written), by id. */
+  async function boxesOf(ids) {
+    const out = {};
+    for (const id of new Set(ids)) out[id] = await readMaybe('LootBox', loot.pda.box(project, id));
+    return out;
+  }
+
+  /** Each item a box's prizes name, decoded (null for one never written), by id: a fresh one's tables go with its roll. */
+  async function itemsOf(box) {
+    const out = {};
+    for (const p of box.entries.flatMap((e) => e.prizes)) {
+      const id = p.Item?.[0] ?? p.Compressed?.item;
+      if (id !== undefined && !(id in out)) out[id] = await readMaybe('Item', loot.pda.item(project, id));
+    }
+    return out;
+  }
+
   /** The mint of each pool a box's tokens come from (null for a pool not opened). */
   async function poolMintsOf(box) {
     const prizePools = [...new Set(box.entries.flatMap((e) => e.prizes).map((p) => p.Tokens?.from.Pool?.[0]).filter((p) => p !== undefined))];
@@ -616,12 +863,21 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     return Object.fromEntries(prizePools.map((p, i) => [p, pools[i] ? encodeBase58(pools[i].data.subarray(0, 32)) : null]));
   }
 
-  /** Asks the oracle for a roll a mission, a recipe or a prize made (`Waiting`): the player pays the oracle. */
-  async function askRoll(orderAddress) {
-    const order = await read('Order', orderAddress);
+  /** The instructions that ask the oracle for the roll of `order` (at `orderAddress`), `payer` paying it. Each prize
+   * mint's token program is read from the mint when the app wasn't given it (`programs`): the ask opens the project's
+   * vault of it. */
+  async function asksFor(payer, orderAddress, order, settler) {
     const box = await read('LootBox', order.loot_box);
     const poolMints = await poolMintsOf(box);
-    return send([computeUnitLimit(400_000), ...loot.askRollIx({ payer: wallet.address, orderAddress, order, box, poolMints, programs })]);
+    const mints = [...Object.values(poolMints), ...box.entries.flatMap((e) => e.prizes.map((p) => p.Tokens?.from.Mint?.[0]))].filter((x) => x && !programs[x]);
+    const owners = mints.length ? await client.accounts(mints) : [];
+    const known = { ...programs, ...Object.fromEntries(mints.map((x, i) => [x, owners[i]?.owner ?? TOKEN_PROGRAM])) };
+    return loot.askRollIx({ payer, orderAddress, order, box, settler, poolMints, items: await itemsOf(box), programs: known });
+  }
+
+  /** Asks the oracle for a roll a mission, a recipe or a prize made (`Waiting`): the player pays the oracle. */
+  async function askRoll(orderAddress) {
+    return send([computeUnitLimit(400_000), ...(await asksFor(wallet.address, orderAddress, await read('Order', orderAddress)))]);
   }
 
   /**
@@ -651,19 +907,23 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     throw new Error(`${method} doesn’t take ${unknown.map((k) => `“${k}”`).join(', ')}${hint}. It takes: ${takes.join(', ')}.`);
   }
   /** What `buy` and `openBox` take: a box bought at once (`buyBox`) or opened (`open`). */
-  const BOX_OPTIONS = ['shown', 'listProof', 'maxPrice', 'listing', 'chosenRecipient', 'on', 'oneSignature'];
+  const BOX_OPTIONS = ['shown', 'listProof', 'maxPrice', 'listing', 'chosenRecipient', 'on', 'oneSignature', 'count'];
 
   /**
-   * Buys a box that needs no roll (a shop item, a bundle: one entry, nothing random, no NFT rolled on) in one
-   * transaction: the price is split and every prize given at once, with no order to settle. `shown` (an NFT for its
-   * gate), `listProof` (for a list gate), `chosenRecipient` (the wallet, or collectible, a share the box lets the buyer
-   * name goes to). Returns { signature, assets }: for each prize, the collectible minted or the NFT given (null for
-   * tokens or a normal item), and for a roll the order it is made in.
+   * Buys `count` of a box that needs no roll (a shop item, a bundle, a fixed pack: one entry, nothing random, no NFT
+   * rolled on) in one transaction: the price is split and every prize given at once, once for each draw of each, with
+   * no order to settle. A roll the box gives (`Prize::Roll`) is asked for in the same transaction and settled by a
+   * throwaway key after (`sendRolling`: still one prompt). `shown` (an NFT for its gate), `listProof` (for a list gate),
+   * `chosenRecipient` (the wallet, or collectible, a share the box lets the buyer name goes to). Returns { signature,
+   * assets }: for each prize given, the collectible minted or the NFT given (null for tokens or a normal item), and for
+   * a roll the order it is made in; with `rolls`, what each roll gave. `orNull`: a pack (more than one draw in all)
+   * whose purchase doesn't fit one legacy transaction, or the instruction trace, returns null, sending nothing.
    */
-  async function buyBox(boxId, part, { shown = null, listProof, maxPrice, listing, chosenRecipient = null } = {}) {
+  async function buyBox(boxId, part, { shown = null, listProof, maxPrice, listing, chosenRecipient = null, count = 1, orNull = false } = {}) {
     const g = await projectNow();
     const box = await read('LootBox', loot.pda.box(project, boxId));
-    const bound = boundOf({ ...box, currencyKey: part?.currency }, part?.name ?? `box ${boxId}`, { maxPrice, listing }, part?.key);
+    if (!Number.isInteger(count) || count < 1) throw new Error('Buy a whole number, one at least (count).');
+    const bound = boundOf({ ...box, currencyKey: part?.currency }, part?.name ?? `box ${boxId}`, { maxPrice, listing }, part?.key) * BigInt(count);
     shown ??= await passing(box.gate, 'buy this');
     listProof = listProofOf(box.gate, part?.gate?.list, listProof);
     const mint = box.currency;
@@ -672,9 +932,10 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     const nonce = freshNonce();
     const choosesHolder = box.shares.some((s) => s.to.Chosen && s.to.Chosen.item != null);
     const holders = await holdersOf(loot.chosenShares(box.shares, chosenRecipient));
-    const ix = loot.buyIx({ player: wallet.address, project, box, maxPrice: bound, treasury: g.treasury, chosenRecipient, chosen: choosesHolder ? chosenRecipient : null, nonce, shown, listProof, items: given.items, poolMints: given.poolMints, nfts: given.nfts, boxes: given.boxes, rollPools: given.rollPools, holders, programs });
+    const ix = loot.buyIx({ player: wallet.address, project, box, maxPrice: bound, count, treasury: g.treasury, chosenRecipient, chosen: choosesHolder ? chosenRecipient : null, nonce, shown, listProof, items: given.items, poolMints: given.poolMints, nfts: given.nfts, holders, programs });
     const made = {};
-    const assets = entry.prizes.map((prize, k) => {
+    const gives = loot.buyGives(box, count);
+    const assets = gives.map(({ prize, k }) => {
       if (prize.Item) {
         const id = prize.Item[0];
         const item = given.items[id];
@@ -685,8 +946,14 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       if (prize.Roll) return loot.pda.order(project, wallet.address, loot.prizeRollNonce(nonce + BigInt(k)));
       return null;
     });
-    const signature = await send(withSolWrap(wallet.address, mint, box.price, [computeUnitLimit(600_000), ...given.before.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM), ix]));
-    return { signature, assets, ...(assets.find(Boolean) ? { asset: assets.find(Boolean) } : {}) };
+    const rollsMade = gives.filter((x) => x.prize.Roll).length;
+    const instructions = withSolWrap(wallet.address, mint, bound, [computeUnitLimit(rollsMade || gives.length > 2 ? 1_400_000 : 600_000), ...given.before.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM), ix]);
+    if (orNull && gives.length > 1) {
+      const fits = compileFitting({ payer: wallet.address, blockhash: NOBODY, instructions }) && transactionLocks(wallet.address, instructions) <= 64;
+      if (!fits || !(await dryRun(wallet.address, instructions)).ok) return null;
+    }
+    const { signature, rolls } = rollsMade ? await sendRolling(instructions) : { signature: await send(instructions), rolls: [] };
+    return { signature, assets, ...(assets.find(Boolean) ? { asset: assets.find(Boolean) } : {}), ...(rolls.length ? { rolls } : {}) };
   }
 
   /**
@@ -696,10 +963,14 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * referrer, a plot). `on`: the NFT a box that rolls on one takes (an NFT whose price it is, a sword to enchant).
    * `listProof`: for a list gate.
    */
-  async function open(boxId, part, { shown = null, on = null, maxPrice, listing, oneSignature = true, chosenRecipient = null, listProof } = {}) {
+  async function open(boxId, part, { shown = null, on = null, maxPrice, listing, oneSignature = true, chosenRecipient = null, listProof, count = 1 } = {}) {
     const g = await projectNow();
     const box = await read('LootBox', loot.pda.box(project, boxId));
-    const bound = boundOf({ ...box, currencyKey: part?.currency }, part?.name ?? `box ${boxId}`, { maxPrice, listing }, part?.key);
+    // `count` packs in one purchase: one wallet prompt, one oracle answer, each at the price the one before it left.
+    if (!Number.isInteger(count) || count < 1) throw new Error('Open a whole number of packs, one at least (count).');
+    const bound = boundOf({ ...box, currencyKey: part?.currency }, part?.name ?? `box ${boxId}`, { maxPrice, listing }, part?.key) * BigInt(count);
+    // Each item a prize names: a fresh one's tables go with the purchase.
+    const items = await itemsOf(box);
     // A box that rolls on an NFT takes the one the player brings (`on`), whatever its kind.
     if (box.subject && !on) throw new Error('This box rolls on an NFT: say which (on).');
     const brought = box.subject ? await nftOf(on) : { before: [] };
@@ -716,15 +987,22 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     const prizeMints = [...new Set([...Object.values(poolMints).filter(Boolean), ...minted])];
     const choosesHolder = box.shares.some((s) => s.to.Chosen && s.to.Chosen.item != null);
     const chosen = chosenRecipient && choosesHolder ? chosenRecipient : null;
-    const ix = loot.openBoxIx({ player: wallet.address, project, box, nonce, maxPrice: bound, shown, listProof, subject, chosenRecipient, chosen, poolMints, programs });
+    // A purchase of more opens than one order takes (`loot.opensAnOrder`: what one oracle answer draws, and an order's
+    // rent and fee within 0.01 SOL) is several orders, each its own answer, all in this one transaction: one prompt.
+    const each = loot.opensAnOrder(box, { items });
+    const orders = [];
+    for (let left = count, k = 0n; left > 0; left -= each, k++) {
+      const n = Math.min(each, left);
+      // Its key, named by the order as its settler (made again after a reload: `recover`), when the settle needs no prompt.
+      const settlerKey = oneSignature ? ((await jobKey(loot.pda.order(project, wallet.address, nonce + k))) ?? (await freshKey())) : null;
+      orders.push({ nonce: nonce + k, n, settlerKey, ix: loot.openBoxIx({ settler: settlerKey?.address, player: wallet.address, project, box, nonce: nonce + k, maxPrice: (bound / BigInt(count)) * BigInt(n), count: n, items, shown, listProof, subject, chosenRecipient, chosen, poolMints, programs }) });
+    }
     const before = [...proving, createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, mint, programOf(mint))];
     // (A compressed NFT's proof brings its own compute limit, the transaction's only one.)
-    let burner = null;
     let solPrize = false;
     if (oneSignature) {
-      // The burner's settle pays no rent: the player opens here every account it will pay into (their prize's, and
-      // each wallet a share of the sale pays: a referrer, a plot's holder, the treasury).
-      burner = await freshKey();
+      // The player opens here every account the settle will pay into (their prize's, and each wallet a share of the
+      // sale pays: a referrer, a plot's holder, the treasury), so the burner's settle opens none of them.
       for (const prizeMint of prizeMints) {
         solPrize ||= prizeMint === NATIVE_MINT;
         before.push(createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, prizeMint, programOf(prizeMint)));
@@ -738,31 +1016,28 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       // account: it stays open for the settle too.
       solPrize ||= mint === NATIVE_MINT && paid.has(wallet.address);
     }
-    const after = burner ? [transferLamports(wallet.address, burner.address, BURNER_LAMPORTS)] : [];
+    // Each order's burner, named by the order (made again after a reload: `recover`), holds the fee of each settle part
+    // its order may take (`settleParts`) and of its give-back, and what its settle may mint or open (`settleRent`: the
+    // order lends nothing); it gives back what it doesn't use.
+    const addresses = orders.map((o) => loot.pda.order(project, wallet.address, o.nonce));
+    const burners = [];
+    const after = [];
+    if (oneSignature) {
+      for (const o of orders) {
+        const { key, fund } = await keyFor(SIGNATURE_FEE * BigInt(loot.settleParts(box, o.n) + 1) + loot.settleRent(box, o.n, items), o.settlerKey);
+        burners.push(key);
+        after.push(fund);
+      }
+    }
     // A SOL prize, or a share of the sale, lands in the player's wrapped-SOL account, which the prompt-less settle
     // can't open: it stays open, and the player's next transaction unwraps it.
-    let instructions = withSolWrap(wallet.address, mint, box.price, [...before, ix, ...after]);
+    let instructions = withSolWrap(wallet.address, mint, BigInt(box.price) * BigInt(count), [...before, ...orders.map((o) => o.ix), ...after]);
     if (solPrize) instructions = instructions.filter((x) => !(x.programId === TOKEN_PROGRAM && x.data?.[0] === 9 && x.keys[0]?.pubkey === associatedTokenAddress(wallet.address, NATIVE_MINT)));
     const signature = await send(instructions, [], { keepWrapped: solPrize });
     // The slot it landed in: the order is read from a node that has seen it (a load-balanced RPC's node lagging
     // behind answers nothing for an order just opened).
     const landed = (await client.signatureStatus?.(signature).catch(() => null))?.slot ?? null;
-    return { signature, orderAddress: loot.pda.order(project, wallet.address, nonce), burner, landed };
-  }
-
-  /**
-   * A prize of a share of a pool that comes to nothing is refused when it is given at once (a buy's, a craft's:
-   * PrizeNotCovered): say the pool is empty before the player signs.
-   */
-  async function poolShareGiven(prizes) {
-    for (const p of prizes) {
-      const bps = p?.Tokens?.amount.Bps?.[0];
-      const pool = p?.Tokens?.from.Pool?.[0];
-      if (bps === undefined || pool === undefined) continue;
-      const data = (await client.account(loot.pda.pool(project, pool)))?.data;
-      const held = data ? data.subarray(64, 72).reduce((n, b, i) => n | (BigInt(b) << BigInt(8 * i)), 0n) : 0n;
-      if ((held * BigInt(bps)) / 10_000n === 0n) throw new Error(`Its prize is a share of pool ${pool}, and the pool is empty: nothing to give yet.`);
-    }
+    return { signature, orderAddress: addresses[0], orderAddresses: addresses, burner: burners[0] ?? null, burners, landed };
   }
 
   /**
@@ -780,18 +1055,25 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     if (was.some((b, i) => b !== is[i])) throw new Error('This listing has changed since the player was shown it: show them its terms as they are now first.');
   }
 
-  /** A box bought at once when it needs no roll (`buyBox`), or opened and collected. */
+  /** A box bought at once when it needs no roll (`buyBox`: a shop item, a bundle, a fixed pack of any count), or
+   * opened and collected: one that rolls, gives a fresh item (its traits are rolled), or rolls on an NFT. A fixed pack
+   * too big for one transaction is opened instead (the oracle answers it like any box). */
   async function buyOrOpen(boxId, part, options) {
     const box = await read('LootBox', loot.pda.box(project, boxId));
-    if (!loot.boxRolls(box.entries) && !box.subject) {
-      await poolShareGiven(box.entries.flatMap((e) => e.prizes ?? []));
-      return buyBox(boxId, part, options);
+    if (!loot.boxRolls(box.entries) && !box.subject && !loot.boxFresh(box.entries, await itemsOf(box))) {
+      const { on: _on, oneSignature: _one, ...buying } = options ?? {};
+      const bought = await buyBox(boxId, part, { ...buying, orNull: true });
+      if (bought) return bought;
     }
-    const { orderAddress, burner, landed } = await open(boxId, part, options);
-    return collect(orderAddress, { burner, opened: true, landed });
+    const { orderAddresses, burners, landed } = await open(boxId, part, options);
+    if (orderAddresses.length === 1) return collect(orderAddresses[0], { burner: burners[0] ?? null, opened: true, landed });
+    // Several orders of one purchase: each collected in turn by its own burner.
+    const got = [];
+    for (const [k, address] of orderAddresses.entries()) got.push(await collect(address, { burner: burners[k] ?? null, opened: true, landed }));
+    return { ...got.at(-1), orders: got, won: got.flatMap((g) => g.won ?? []), assets: got.flatMap((g) => g.assets ?? []), parts: got.flatMap((g) => g.parts ?? [g.settled]) };
   }
 
-  /** The current slot (an order's deadlines count in slots). */
+  /** The current slot (a later ask or a refund of a failed order needs a later slot; an order's deadlines count in seconds: `chainNow`). */
   const slotNow = async () => BigInt(await client.call('getSlot', [{ commitment: 'confirmed' }]));
   /** The slots the SlotHashes sysvar holds now (a lookup table closes once its deactivation slot has left them). */
   const recentSlots = async () => slotHashes((await client.account(SYSVAR_SLOT_HASHES))?.data);
@@ -803,6 +1085,25 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     return v >= 1n << 63n ? v - (1n << 64n) : v;
   };
 
+  /** How many ends farm `f` has passed and not walked yet (`loot.endsToWalk`), and its decoded record: 0 for one that keeps none. */
+  async function endsOf(f, farm) {
+    if (!farm.keeps_ends) return { left: 0, ends: [] };
+    const data = (await client.account(loot.pda.ends(loot.pda.farm(project, f.id))))?.data;
+    const ends = data ? loot.decodeEnds(data) : [];
+    return { left: loot.endsToWalk(farm, ends, await chainNow()), ends };
+  }
+
+  /**
+   * A move of farm `f` as it can land: every move walks the ends the farm has passed first, each some compute, so one with
+   * ends to walk asks for all a transaction has, and one with more than that holds is refused in words, nothing signed.
+   */
+  async function walking(f, farm, instructions) {
+    const { left } = await endsOf(f, farm);
+    if (!left) return instructions;
+    if (left > loot.MOVE_WALK_ROOM) throw Object.assign(new Error(`“${f.name ?? f.key}” has passed ${left} times seats stop earning since anyone last moved it, more than one transaction can walk: walk it first (app.walkFarm: anyone may, it is free, and nothing is lost by the wait).`), { name: 'FarmNeedsWalk' });
+    return [computeUnitLimit(loot.WALK_COMPUTE_UNITS), ...instructions.filter((x) => !(x.programId === COMPUTE_BUDGET_PROGRAM && x.data[0] === 2))];
+  }
+
   /**
    * Refuses a stake a farm would refuse (`FarmOver`) before anything is signed: a farm with an end takes none at its end
    * or after it, nor one at a tier whose lock would run past it. `f` is the spec's farm, `farm` the decoded one.
@@ -823,19 +1124,149 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
   }
 
   /**
-   * A lottery's current round: the lottery, its purchases ([{ address, value }], each a LotteryContribution; every one
-   * still there is of this round), and for a drawn round whose purchases are all finished, the winning purchases still
-   * to be paid ([{ contribution, winner }]).
+   * A lottery and its rounds that have a record: the current one (null when nobody bought into it yet), and the two
+   * before it while they wait for their draw or still pay out (the ask moves the lottery on, so a round drawing or
+   * owing parts is an older one). Each { address, round } (`loot.decodeRound`).
    */
   async function roundOf(l) {
     const address = loot.pda.lottery(project, l.id);
     const lottery = await read('Lottery', address);
-    const found = await client.programAccounts(loot.LOOT_PROGRAM, [{ memcmp: { offset: 0, bytes: encodeBase58(Uint8Array.of(loot.TAGS.LotteryContribution)) } }, { memcmp: { offset: 1, bytes: address } }]);
-    const contributions = found.map(({ pubkey, account }) => ({ address: pubkey, value: loot.decode('LotteryContribution', account.data) }));
-    if (lottery.status !== 'Drawn' || BigInt(lottery.pending) > 0n) return { lottery, contributions, winners: [] };
-    // Once every purchase is finished, those left are the winners not paid yet.
-    const winners = contributions.filter(({ value }) => value.done).map((contribution) => ({ contribution, winner: contribution.value.player }));
-    return { lottery, contributions, winners };
+    const back = [1, 2].filter((k) => lottery.round >= k).map((k) => loot.pda.round(address, lottery.incarnation, lottery.round - k));
+    const keys = [loot.currentRound(address, lottery), ...back];
+    const found = await client.accounts(keys);
+    const rounds = keys.map((key, i) => ({ address: key, round: found[i]?.owner === loot.LOOT_PROGRAM ? loot.decodeRound(found[i].data) : null }));
+    return { address, lottery, current: rounds[0].round, rounds: rounds.filter((r) => r.round) };
+  }
+
+  /**
+   * The tail a round's transfers need: each mint's transfer-hook accounts (its extra-account metas, read as every
+   * hooked transfer of the client reads them), once each; none for a mint with no hook. A hook whose list names each
+   * transfer can't be resolved ahead and is left out (the call then fails on it).
+   */
+  async function hookTail(mints) {
+    const out = new Map();
+    for (const mint of new Set(mints.filter((x) => x && x !== NOBODY))) {
+      const resolved = await resolveTransfers(client, mint).catch(() => null);
+      for (const m of resolved?.extraAccounts ?? []) {
+        const had = out.get(m.pubkey);
+        out.set(m.pubkey, had ? { ...had, isWritable: had.isWritable || m.isWritable } : m);
+      }
+    }
+    return [...out.values()];
+  }
+  /** The mints a round's ask and pulls move: its pot's, its payment's and each token run's. */
+  const roundMints = (r, poolMints = {}) => [r.terms.mint, loot.paymentMint(r.terms), ...r.terms.places.map((p) => p.prize?.Tokens?.from).filter(Boolean).map((from) => (from.Pool ? poolMints[from.Pool[0]] : from.Mint?.[0] ?? from.Vest?.[0]))];
+
+  /** Each pool a round's places give tokens from, mapped to its mint (one never opened: the economy's currency). */
+  async function roundPoolMints(terms) {
+    const out = {};
+    for (const p of terms.places) {
+      const pool = p.prize?.Tokens?.from.Pool?.[0];
+      if (pool === undefined || pool in out) continue;
+      const account = await client.account(loot.pda.pool(project, pool));
+      out[pool] = account ? encodeBase58(account.data.subarray(0, 32)) : mintOf();
+    }
+    return out;
+  }
+
+  /** The ask for a round's draw (`round` decoded, `key` its address; null for the current round with no record). */
+  async function drawStep(l, lottery, key, round, signer) {
+    const terms = round?.terms ?? lottery.terms;
+    const poolMints = await roundPoolMints(terms);
+    const extra = await hookTail(roundMints({ terms }, poolMints));
+    return [computeUnitLimit(600_000), loot.drawLotteryIx({ payer: signer, project, id: l.id, lottery, round, roundAddress: key, poolMints, extra })];
+  }
+
+  /**
+   * When a draw of round `r` (at `key`) would cancel it (an open round short of its least tickets; a waiting one past
+   * the timeout), the pulls of `who`'s own parts as the cancelled round owes them (a few entries' worth), to go right
+   * after the draw in its transaction; none otherwise. The round's close rides on them when they are all it owes.
+   */
+  async function cancelPulls(key, r, who) {
+    const short = r.status === 'Open' && BigInt(r.sold) < BigInt(r.terms.min_sold ?? 0) && BigInt(now()) >= BigInt(r.terms.draws_at);
+    if (!short && !loot.lotteryCancellable(r, await chainNow())) return [];
+    // As the program cancels it: every entry's own part owed, and what the ask moved in owed back.
+    const potOwed = BigInt(r.pot_arrived) > BigInt(r.to_pot) ? BigInt(r.pot_arrived) - BigInt(r.to_pot) : 0n;
+    const pools = r.prizes.filter((p) => !p.minted && BigInt(p.arrived) > 0n).length;
+    const cancelled = { ...r, status: 'Cancelled', pot_owed: potOwed, owed: Number(r.owns) + (potOwed > 0n ? 1 : 0) + pools };
+    const mine = r.entries.flatMap((e, i) => (e.buyer === who && loot.partsOwed(cancelled, i).length ? [{ entry: i, parts: loot.partsOwed(cancelled, i) }] : [])).slice(0, 4);
+    const settles = mine.reduce((n, { entry, parts }) => n + parts.reduce((m, p) => m + pullSettles(cancelled, entry, p), 0), 0);
+    const out = [];
+    for (const [k, { entry, parts }] of mine.entries()) out.push(...(await pulls(key, cancelled, entry, parts, who, { closes: settles >= cancelled.owed && k === mine.length - 1 })).instructions);
+    return out;
+  }
+
+  /** The nonce a pull of entry `i` of the round at `key` names: a place's roll is made at `prizeRollNonce(nonce + place)`. */
+  const pullNonce = (key, i) => loot.prizeNonce(key, BigInt(i));
+
+  /** How many of a round's owed parts a pull of `part` (of entry `i`) settles. */
+  const pullSettles = (r, i, part) => {
+    if (part === 'Own' || part.Common) return 1;
+    const run = Number((part.Pot ?? part.Prize)[0]);
+    return part.Pot || loot.tokenRun(r, run) ? loot.placesPulled(r, i, run, Boolean(part.Prize)) : loot.prizePlacesOwed(r, i, run).length;
+  };
+
+  /**
+   * The pulls of `parts` of entry `i` of a round (`partsOwed`; `i` null for parts owed in common, `commonOwed`), signed by
+   * `signer`, and the rolls they make ([{ order, box }], `loot.pullRolls`). With `closes`, the last pull carries the
+   * round's close (when the parts it pays are the last owed).
+   */
+  async function pulls(key, r, i, parts, signer, { closes = false } = {}) {
+    const e = i == null ? null : r.entries[i];
+    const out = [];
+    const rolls = [];
+    const g = await projectNow();
+    // A run's token prize is in its own mint: the prizes the round recorded name each.
+    const extra = await hookTail([...roundMints(r), ...r.prizes.map((p) => p.mint)]);
+    for (const [k, part] of parts.entries()) {
+      const more = {};
+      if (part === 'Own' && e.nft !== NOBODY) {
+        const then = r.status === 'Cancelled' || r.terms.returns ? null : r.terms.nft_ticket?.then;
+        more.handBack = Boolean(then?.Give) && loot.handsBack(await client.account(then.Give[0]));
+        const to = !then || more.handBack ? e.buyer : then.Give ? then.Give[0] : undefined;
+        const { before = [], hasAuthority: _, ...kind } = await nftOf(e.nft, signer, { to });
+        out.push(...before);
+        more.ticket = kind;
+      } else if (part.Prize && !loot.tokenRun(r, Number(part.Prize[0]))) {
+        // Each of the entry's places in the run: an NFT of the lottery's own stash (which one, as the pull takes them
+        // out), a project stash's NFT, an item, or a roll (asked in the same transaction).
+        const run = Number(part.Prize[0]);
+        const given = r.terms.places[run].prize;
+        const inputs = await prizeInputs([given], signer, e.buyer);
+        out.push(...inputs.before);
+        const stash = loot.ownStash(r.terms.places[run]) ? loot.decodeStash((await client.account(loot.pda.lotteryStash(r.lottery)))?.data ?? null) : null;
+        if (stash) {
+          const predicted = loot.stashNfts(r, stash);
+          for (const place of loot.prizePlacesOwed(r, i, run)) {
+            const nft = predicted[loot.nftSlot(r, place)];
+            if (!nft || inputs.nfts[nft]) continue;
+            const { before, hasAuthority: _, ...kind } = await nftOf(nft, signer, { to: e.buyer });
+            inputs.nfts[nft] = kind;
+            out.push(...before);
+          }
+        }
+        const stashes = given.Nft ? { [given.Nft.stash]: loot.decodeStash((await client.account(loot.pda.stash(project, given.Nft.stash)))?.data ?? null) ?? { nfts: [] } } : {};
+        more.prize = { stash, stashes, nfts: inputs.nfts, collection: inputs.collection, poolMints: inputs.poolMints, items: inputs.items, projectMint: mintOf() };
+        more.nonce = pullNonce(key, i);
+        rolls.push(...loot.pullRolls({ project, round: r, entry: i, part, nonce: more.nonce }));
+      } else if (part.Common) {
+        // Where a part owed in common goes: a share's payee (a collectible's holder now), the pot, a pool; one that can't
+        // take it (a pool never opened, the pot closed since, an account gone) sends it to the treasury.
+        const c = Number(part.Common[0]);
+        const n = r.terms.shares.length;
+        const to = c < n ? r.terms.shares[c].to : c === n ? { Account: [loot.pda.pot(r.lottery)] } : r.terms.places[Number(r.prizes[c - n - 1].run)].prize.Tokens.from;
+        if (to.Holder) more.holders = await holdersOf([{ to }]);
+        const target = to.Pool ? loot.pda.pool(project, to.Pool[0]) : to.Account?.[0];
+        // A pot or pool made again in another mint can't take it either: the program sends it to the treasury.
+        const mint = c < n ? loot.paymentMint(r.terms) : c === n ? r.terms.mint : r.prizes[c - n - 1].mint;
+        const held = target ? await client.account(target) : null;
+        if (target && (!held || encodeBase58(held.data.subarray(0, 32)) !== mint)) more.toTreasury = true;
+      }
+      const last = k === parts.length - 1;
+      const round = closes && last ? { ...r, owed: pullSettles(r, i, part) } : { ...r, owed: Number.MAX_SAFE_INTEGER };
+      out.push(loot.pullIx({ payer: signer, project, roundAddress: key, round, entry: i ?? 0, part, projectState: g, programs, extra, ...more }));
+    }
+    return { instructions: out, rolls };
   }
 
   return {
@@ -856,14 +1287,15 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       });
     },
 
-    /** The boxes: price now and each outcome's chance. */
+    /** The boxes: price now, each outcome's chance as written, and what the box does once an outcome runs out
+     * (`whenOut`: 'stopSales', it isn't sold until restocked; 'drawLeft', it draws among what is left). */
     async boxes() {
       const list = spec.boxes ?? [];
       const accounts = await client.accounts(list.map((b) => loot.pda.box(project, b.id)));
       return list.map((b, i) => {
         const box = accounts[i] && loot.decode('LootBox', accounts[i].data);
         const total = box ? box.entries.reduce((n, e) => n + e.weight, 0) : 0;
-        return { key: b.key, name: b.name, price: box ? show(box.price, decimalsOf(b.currency)) : null, priceUnits: box?.price ?? null, currency: tokens.get(b.currency ?? currencyKey)?.symbol, active: Boolean(box?.active), outcomes: (b.outcomes ?? []).map((o, j) => ({ ...o, chancePercent: box ? (100 * box.entries[j].weight) / total : o.chance })) };
+        return { key: b.key, name: b.name, price: box ? show(box.price, decimalsOf(b.currency)) : null, priceUnits: box?.price ?? null, currency: tokens.get(b.currency ?? currencyKey)?.symbol, active: Boolean(box?.active), whenOut: box?.when_out === 'DrawLeft' ? 'drawLeft' : 'stopSales', outcomes: (b.outcomes ?? []).map((o, j) => ({ ...o, chancePercent: box ? (100 * box.entries[j].weight) / total : o.chance })) };
       });
     },
 
@@ -881,7 +1313,8 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
 
     /**
      * Opens a box (shows a collectible for its gate or odds when given): a box that needs no roll is bought at once
-     * (`buy`); one that rolls waits for the roll and collects it.
+     * (`buy`); one that rolls waits for the roll and collects it, settling a pack in as many parts as it needs. `count`
+     * opens several packs in one purchase: one wallet prompt and one oracle answer (`maxPrice` is a pack's).
      */
     async openBox(boxKey, options = {}) {
       only(options, BOX_OPTIONS, 'openBox');
@@ -892,6 +1325,49 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     /** Collects an order opened earlier (its roll arrived after the app stopped waiting). */
     collect,
 
+    /**
+     * Finds the settle keys a page that closed left holding the player's SOL, and finishes their jobs: a key whose order
+     * has rolled settles it (no prompt); one whose order is gone, failed or due its refund sends its SOL back; one whose
+     * order still waits for its roll keeps it for later. Each key is made again from the wallet's signature (asked once
+     * a session, `walletStandardSigner`'s `signMessage`), or read from the page's storage (`keyStore`) when the wallet
+     * signs no messages. Returns [{ name, key, settled } | { name, key, swept } | { name, key, waiting }].
+     */
+    async recover() {
+      if (!keys) throw new Error('Connect a wallet first.');
+      const me = wallet.address;
+      const tag = (t) => ({ memcmp: { offset: 0, bytes: encodeBase58(Uint8Array.of(loot.TAGS[t])) } });
+      const at = (offset, bytes) => ({ memcmp: { offset, bytes } });
+      const orders = new Map();
+      for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [tag('Order'), at(1, project), at(33, me)])) orders.set(pubkey, loot.decode('Order', account.data));
+      const holds = (await client.programAccounts(loot.LOOT_PROGRAM, [tag('Hold'), at(1, project), at(65, me)])).map((h) => h.pubkey);
+      // Keys are named by an order of the wallet's, a hold (a loan's release), or an auction (the releases after its end).
+      const names = [...new Set([...orders.keys(), ...holds, ...(spec.auctions ?? []).map((a) => auctionAt(a)), ...keys.stored()])];
+      if (!names.length) return [];
+      const made = (await Promise.all(names.map((name) => keys.again(name)))).filter(Boolean);
+      const held = made.length ? await client.accounts(made.map((k) => k.address)) : [];
+      const [slot, time] = [await slotNow(), await chainNow()];
+      const out = [];
+      for (const [i, key] of made.entries()) {
+        const lamports = BigInt(held[i]?.lamports ?? 0);
+        if (lamports === 0n) {
+          keys.forget(key.name);
+          continue;
+        }
+        const order = orders.get(key.name);
+        const due = order ? loot.orderRefundable(order, slot, time) : false;
+        if (order?.status === 'Rolled' && slot > BigInt(order.requested_slot) && !due) {
+          const got = await collect(key.name, { burner: key }).catch((e) => ({ error: e.message }));
+          out.push({ name: key.name, key: key.address, ...(got.error ? { error: got.error } : { settled: got.settled, won: got.won }) });
+        } else if (order && ['Pending', 'Asked', 'Waiting'].includes(order.status) && !due) {
+          out.push({ name: key.name, key: key.address, waiting: order.status });
+        } else {
+          await emptyKey(key);
+          out.push({ name: key.name, key: key.address, swept: lamports });
+        }
+      }
+      return out;
+    },
+
     /** Gives an order's payment back once its time has come (a roll that failed or never came). */
     async refund(orderAddress) {
       const order = await read('Order', orderAddress);
@@ -900,7 +1376,9 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       return send([...before, loot.refundIx({ signer: wallet.address, orderAddress, order, subject, programs })]);
     },
 
-    /** Asks the oracle for a roll a mission, a recipe or a prize made (anyone may; the asker pays the oracle). */
+    /** Asks the oracle for a roll a mission, a recipe or a prize made (anyone may; the asker pays the oracle). On a box
+     * with nothing in stock only the order's player may ask, a slot after it was made or last asked, and that ends the
+     * roll there with nothing, no oracle (a lot its winner paid for fails, for its refund). */
     askRoll: (orderAddress) => askRoll(orderAddress),
 
     /**
@@ -956,16 +1434,22 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
      */
     async lotteries() {
       const list = spec.lotteries ?? [];
-      const accounts = await client.accounts(list.map((l) => loot.pda.lottery(project, l.id)));
-      return list.map((l, i) => {
-        const lottery = accounts[i]?.owner === loot.LOOT_PROGRAM ? loot.decode('Lottery', accounts[i].data) : null;
+      const out = [];
+      for (const l of list) {
+        const there = await client.account(loot.pda.lottery(project, l.id));
+        // The terms on sale are the round's own copy once someone bought into it, the lottery's before.
+        const { lottery, current } = there?.owner === loot.LOOT_PROGRAM ? await roundOf(l) : { lottery: null, current: null };
+        const copy = current ?? lottery;
+        const terms = copy?.terms;
         const currency = lottery ? ticketCurrencyOf(l, lottery) : l.ticketCurrency ?? currencyKey;
-        return {
-          key: l.key, name: l.name, price: lottery ? show(lottery.price, decimalsOf(currency)) : null, priceUnits: lottery?.price ?? null,
-          currency: tokens.get(currency)?.symbol ?? currency, status: lottery?.status ?? null, round: lottery?.round ?? null, sold: lottery?.sold ?? null,
-          drawsAt: lottery ? Number(lottery.draws_at) : null, nftTicket: Boolean(lottery?.nft_ticket), incarnation: lottery?.incarnation ?? null, revision: lottery?.revision ?? null,
-        };
-      });
+        const ended = lottery && Number(lottery.every) === 0 && lottery.round > 0;
+        out.push({
+          key: l.key, name: l.name, price: terms ? show(terms.price, decimalsOf(currency)) : null, priceUnits: terms?.price ?? null,
+          currency: tokens.get(currency)?.symbol ?? currency, status: !lottery ? null : ended ? 'Ended' : current?.status ?? 'Open', round: lottery?.round ?? null, sold: lottery ? current?.sold ?? 0n : null,
+          drawsAt: terms ? Number(terms.draws_at) : null, nftTicket: Boolean(lottery?.terms.nft_ticket), incarnation: lottery?.incarnation ?? null, revision: copy?.revision ?? null,
+        });
+      }
+      return out;
     },
 
     /**
@@ -984,46 +1468,60 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       if (listing && listing.key !== undefined && listing.key !== l.key) throw new Error(`That listing is “${listing.key}”, not “${l.key}”.`);
       const given = maxPrice ?? listing?.priceUnits;
       if (given === undefined || given === null) throw new Error(`Say the terms the player was shown for “${name}”: pass the lottery lotteries() showed (listing), or maxPrice (a ticket's most, in base units). The price read now is never the bound.`);
-      const current = await read('Lottery', loot.pda.lottery(project, l.id));
-      // The terms signed are those shown: a lottery written again or changed since is refused here, and by the
-      // program (TermsChanged) if it changes after this read.
+      const { lottery: onChain, current: openRound } = await roundOf(l);
+      // A round whose draw is due takes no more tickets: its draw goes first, in this same transaction (the buyer pays
+      // the oracle's fee for it), and moves the lottery on, so this purchase is the next round's first. A lottery that
+      // draws once has no next round.
+      const due = openRound?.status === 'Open' && BigInt(now()) >= BigInt(openRound.terms.draws_at) ? openRound : null;
+      if (due && Number(onChain.every) === 0) throw new Error(`The one draw of “${l.name}” is due: it takes no more tickets. Reveal it (claims() lists it).`);
+      const draw = due ? (await drawStep(l, onChain, null, due, wallet.address)).filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM) : [];
+      const current = due ? { ...onChain, round: onChain.round + 1 } : onChain;
+      const round = due ? null : openRound;
+      // The terms signed are those shown: the round's own copy once someone bought into it, the lottery's before. A
+      // lottery written again or changed since is refused here, and by the program (TermsChanged) if it changes after
+      // this read.
+      const { terms, revision } = round ?? current;
       if (listing && (listing.incarnation == null || listing.revision == null)) throw new Error(`That listing of “${name}” names no terms (incarnation, revision): pass the lottery lotteries() showed.`);
-      if (listing && (BigInt(listing.incarnation) !== BigInt(current.incarnation) || Number(listing.revision) !== Number(current.revision))) throw new Error(`“${name}” has changed since the player was shown it: show them the lottery as it is now first.`);
-      const lottery = listing ? { ...current, incarnation: BigInt(listing.incarnation), revision: Number(listing.revision) } : current;
+      if (listing && (BigInt(listing.incarnation) !== BigInt(current.incarnation) || Number(listing.revision) !== Number(revision))) throw new Error(`“${name}” has changed since the player was shown it: show them the lottery as it is now first.`);
+      const lottery = current;
       const currency = ticketCurrencyOf(l, lottery);
-      if (BigInt(lottery.price) > BigInt(given)) throw new Error(`A ticket of “${name}” now costs ${show(lottery.price, decimalsOf(currency))}, more than the ${show(BigInt(given), decimalsOf(currency))} the player was shown: show them the new price first.`);
-      if (lottery.status === 'Ended') throw new Error(`“${l.name}” has drawn and ended.`);
+      if (BigInt(terms.price) > BigInt(given)) throw new Error(`A ticket of “${name}” now costs ${show(terms.price, decimalsOf(currency))}, more than the ${show(BigInt(given), decimalsOf(currency))} the player was shown: show them the new price first.`);
+      if (Number(lottery.every) === 0 && lottery.round > 0) throw new Error(`“${l.name}” has drawn and ended.`);
       shown ??= await passing(lottery.gate, 'buy a ticket');
       listProof = listProofOf(lottery.gate, l.gate?.list, listProof);
       let nft;
       const before = [];
-      if (lottery.nft_ticket) {
+      if (terms.nft_ticket) {
         if (!paidWith) throw new Error(`A ticket of “${l.name}” costs an NFT: say which (nft).`);
         if (BigInt(count) !== 1n) throw new Error('An NFT pays for one ticket at a time.');
         const { before: proof, ...kind } = await nftOf(paidWith);
         nft = { asset: paidWith, ...kind };
         before.push(...proof);
       }
-      const mint = l.ticketCurrency ? mintOf(l.ticketCurrency) : lottery.mint;
-      const choosesHolder = lottery.shares.some((s) => s.to.Chosen && s.to.Chosen.item != null);
-      const nonce = freshNonce();
-      const ix = loot.buyTicketsIx({ player: wallet.address, project, id: l.id, lottery, mint, count: BigInt(count), nonce, shown, listProof, chosenRecipient, chosen: choosesHolder ? chosenRecipient : null, nft, programs });
-      // A round that reached its date with no ticket sold moves on by itself when a ticket is bought.
-      const due = lottery.status === 'Open' && BigInt(now()) >= BigInt(lottery.draws_at);
-      if (due && BigInt(lottery.sold) > 0n) throw new Error('This round’s draw is due: reveal it first (claims() lists it), then buy for the next one.');
-      // A ticket paid with an NFT: its way out must land too, the NFT handed on at the draw or back to its
-      // buyer when the round is cancelled, each sized before the NFT goes in.
+      const mint = loot.paymentMint(terms);
+      const { shares } = terms;
+      const choosesHolder = shares.some((s) => s.to.Chosen && s.to.Chosen.item != null);
+      // A share the buyer chooses is paid now, from their own account: to the holder of the collectible they chose (read
+      // now), the wallet they named, or with no choice the treasury.
+      const holders = choosesHolder && chosenRecipient ? await holdersOf([{ to: { Holder: [chosenRecipient] } }]) : {};
+      // A payment mint with a transfer hook: its accounts ride along.
+      const extra = await hookTail([mint]);
+      const ix = loot.buyTicketsIx({ player: wallet.address, project, id: l.id, lottery, round, mint, count: BigInt(count), shown, listProof, chosenRecipient, chosen: choosesHolder ? chosenRecipient : null, nft, holders, treasury: (await projectNow()).treasury, programs, extra });
+      // An overdue round nobody bought into moves to its next date by itself when a ticket is bought.
+      // A ticket paid with an NFT: its way out must land too, the NFT handed on once the round is drawn or back to its
+      // buyer when it is cancelled, each sized before the NFT goes in.
       if (nft) {
         const g = await projectNow();
-        const contribution = { player: wallet.address, asset: paidWith, done: false, round: lottery.round, count: 1n, shares: lottery.shares };
-        const contributionAddress = loot.pda.contribution(loot.pda.lottery(project, l.id), wallet.address, nonce);
+        const entry = { buyer: wallet.address, nft: paidWith, start: 0n, end: 1n, amount: 0n, paid: 0n };
         for (const status of ['Drawn', 'Cancelled']) {
-          const exit = [computeUnitLimit(1_400_000), ...before.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM), loot.finishLotteryContributionIx({ payer: wallet.address, project, id: l.id, lottery: { ...lottery, status }, contributionAddress, contribution, treasury: g.treasury, ticket: kindOnly(nft), programs })];
+          const r = { lottery: loot.pda.lottery(project, l.id), status, terms, accounts: [], owed: 2, opener: wallet.address, entries: [entry] };
+          const exit = [computeUnitLimit(1_400_000), ...before.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM), loot.pullIx({ payer: wallet.address, project, roundAddress: loot.currentRound(r.lottery, lottery), round: r, entry: 0, part: 'Own', projectState: g, ticket: kindOnly(nft), programs })];
           if (!sendPlan({ payer: wallet.address, instructions: exit, alone: isProveLeaf }))
-            throw new Error(`Not bought: this NFT couldn't come out of “${l.name}” again (${status === 'Drawn' ? 'handed on at the draw' : 'back to you if the round is cancelled'}): that transaction would lock more accounts than one can (${transactionLocks(wallet.address, exit, { asV0: true })} with its lookup table; at most 64), so it would stay with the lottery.`);
+            throw new Error(`Not bought: this NFT couldn't come out of “${l.name}” again (${status === 'Drawn' ? 'handed on once the round is drawn' : 'back to you if the round is cancelled'}): that transaction would lock more accounts than one can (${transactionLocks(wallet.address, exit, { asV0: true })} with its lookup table; at most 64), so it would stay with the lottery.`);
         }
       }
-      return send([...before, ...withSolWrap(wallet.address, mint, lottery.price * BigInt(count), [ix])]);
+      const buy = [...before, ...withSolWrap(wallet.address, mint, BigInt(terms.price) * BigInt(count), [ix])];
+      return send(draw.length ? [computeUnitLimit(800_000), ...draw, ...buy.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM)] : buy);
     },
 
     /**
@@ -1048,33 +1546,25 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       shown ??= await passing(farm.gates, 'stake here');
       const mint = farm.farmed.Tokens.mint;
       const value = units(amount, decimalsOf(f.stakes));
-      // Moving to, or topping up on, a tier whose rewards wait for its lock (an early exit) first takes what the seat
-      // may take now (HarvestFirst), in the same transaction; a seat can't move to a larger exit fee while locked.
+      // While its lock runs, a seat moves only to a tier with no early exit, or one whose early exit costs at least as
+      // much as its own (`ExitWhileLocked`): never to a way out it didn't have, or a cheaper one.
       const mine = await readMaybe('Seat', loot.pda.seat(loot.pda.farm(project, f.id), wallet.address));
-      let harvestFirst = false;
-      if (mine && BigInt(mine.amount) > 0n) {
-        const [from, to] = [farm.tiers[mine.tier], farm.tiers[tier]];
-        const locked = (await chainNow()) < BigInt(mine.since) + BigInt(from.lock);
-        if (locked && Number(to.exit_bps) > Number(from.exit_bps)) throw new Error('While its lock runs, this stake can\'t move to a tier with a larger early-exit fee.');
-        harvestFirst = Number(to.exit_bps) > 0 && !(Number(from.exit_bps) > 0 && locked);
+      if (mine && BigInt(mine.amount) > 0n && Number(mine.tier) !== Number(tier)) {
+        const [from, to] = [Number(farm.tiers[mine.tier].exit_bps), Number(farm.tiers[tier].exit_bps)];
+        const locked = (await chainNow()) < BigInt(mine.since) + BigInt(farm.tiers[mine.tier].lock);
+        if (locked && !(to === 0 || (from > 0 && to >= from))) throw new Error('While its lock runs, this stake can only move to a tier with no early exit, or one whose early exit costs at least as much as its own.');
       }
-      const token = await farmTokens([mint, farm.rewards_mint], harvestFirst ? [farm.rewards_mint] : [], { extra, transfers });
+      const token = await farmTokens([mint], [], { extra, transfers });
       const ix = loot.stakeTokensIx({ player: wallet.address, project, id: f.id, farm, amount: value, tier, shown, ...token });
-      const harvest = harvestFirst ? [...token.before, loot.harvestIx({ player: wallet.address, project, id: f.id, farm, ...token })] : [];
-      // A new tier on a seat with a booster that grows: its growth so far is written first, in the same transaction.
-      const seat = farm.growth.length ? await readMaybe('Seat', loot.pda.seat(loot.pda.farm(project, f.id), wallet.address)) : null;
-      const before = [];
-      if (seat && seat.tier !== tier && seat.asset !== NOBODY) {
-        const { before: proof, ...nft } = await nftOf(seat.asset);
-        before.push(...proof, loot.refreshSeatIx({ signer: wallet.address, project, id: f.id, farm, by: wallet.address, seat, ...nft }));
-      }
-      return send([...before, ...harvest, ...withSolWrap(wallet.address, mint, value, [ix])]);
+      // A seat with a booster on (its boost is read again), or one whose growth the stake changes, is refreshed first, in
+      // the same transaction.
+      const before = loot.stakeRefreshFirst(farm, mine, { tier, now: await chainNow() }) ? await refreshOf(f, farm, mine) : [];
+      return send(await walking(f, farm, [...before, ...withSolWrap(wallet.address, mint, value, [ix])]));
     },
 
     /**
      * Takes `amount` out once its lock has run (0: only rewards); `forfeit` gives up rewards that cannot move. Before the
-     * lock, a tier with an early exit lets it leave for its fee, and gives up what the seat is owed; in a farm that
-     * unbonds, what is taken out waits first (`withdraw` takes it out once free).
+     * lock, a tier with an early exit lets it leave for its fee, keeping what the seat was credited.
      */
     async unstake(farmKey, amount = 0, { forfeit = false, extra, transfers, ...others } = NO_OPTIONS) {
       only(others, ['forfeit', 'extra', 'transfers'], 'unstake');
@@ -1083,7 +1573,15 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const value = units(amount, decimalsOf(f.stakes));
       const mints = [...(value > 0n ? [farm.farmed.Tokens.mint] : []), ...(!forfeit ? [farm.rewards_mint] : [])];
       const token = await farmTokens(mints, mints, { extra, transfers });
-      return send([...token.before, loot.unstakeTokensIx({ player: wallet.address, project, id: f.id, farm, amount: value, forfeit, ...token })]);
+      // An exit that would lose what the seat grew since its last refresh writes it first, in the same transaction.
+      const by = wallet.address;
+      const seat = await readMaybe('Seat', loot.pda.seat(loot.pda.farm(project, f.id), by));
+      const first = [];
+      if (seat && loot.refreshFirst(farm, seat, value, forfeit)) {
+        const { before, ...nft } = seat.asset !== NOBODY ? await nftOf(seat.asset) : { before: [] };
+        first.push(...before, loot.refreshSeatIx({ signer: wallet.address, project, id: f.id, farm, by, seat, ...nft, extra: token.extra }));
+      }
+      return send(await walking(f, farm, [...token.before, ...first, loot.unstakeTokensIx({ player: wallet.address, project, id: f.id, farm, amount: value, forfeit, ...token })]));
     },
 
     /**
@@ -1100,23 +1598,18 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const { before, ...nft } = await nftOf(asset);
       const seat = farm.custody === 'Watch' && farm.farmed === 'Collectibles' ? await readMaybe('Seat', loot.pda.seat(loot.pda.farm(project, f.id), asset)) : null;
       const previous = seat && seat.player !== wallet.address ? seat.player : null;
-      // A booster boosts a stake: a farm of tokens takes one only on a seat with tokens staked (NotFarmed). Putting
-      // one on starts the lock again, so on a tier whose rewards wait for its lock what the seat may take now is
-      // harvested first, in the same transaction (HarvestFirst).
-      const harvest = [];
+      // A booster boosts a stake: a farm of tokens takes one only on a seat with tokens staked (NotFarmed). In a farm
+      // whose growth writes the profile, the seat is refreshed first, in the same transaction (`boosterRefreshFirst`).
+      const refresh = [];
       if (farm.farmed.Tokens) {
         const mine = await readMaybe('Seat', loot.pda.seat(loot.pda.farm(project, f.id), wallet.address));
         if (!mine || BigInt(mine.amount) === 0n) throw new Error(`Stake some ${f.stakes} in “${f.name ?? f.key}” first: a booster boosts a stake.`);
-        const t = farm.tiers[mine.tier];
-        if (Number(t.exit_bps) > 0 && (await chainNow()) >= BigInt(mine.since) + BigInt(t.lock)) {
-          const rewards = await farmTokens([farm.rewards_mint], [farm.rewards_mint], { extra, transfers });
-          harvest.push(...rewards.before, loot.harvestIx({ player: wallet.address, project, id: f.id, farm, ...rewards }));
-        }
+        if (loot.boosterRefreshFirst(farm)) refresh.push(...(await refreshOf(f, farm, mine)));
       }
       // Its way out must land too: its unstake from this tier, with the tier's
       // prize and as a forfeit, is sized before it goes in, and an NFT that could never come back out isn't staked.
       if (!farm.farmed.Tokens) await exitFits(f, farm, asset, nft, before, tier, token);
-      return send([...before, ...harvest, loot.stakeNftIx({ player: wallet.address, project, id: f.id, farm, asset, ...nft, previous, tier, ...token })]);
+      return send(await walking(f, farm, [...refresh, ...before, loot.stakeNftIx({ player: wallet.address, project, id: f.id, farm, asset, ...nft, previous, tier, ...token })]));
     },
 
     /**
@@ -1139,12 +1632,49 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const prize = farm.tiers[seat.tier]?.prize ?? null;
       // A forfeit takes no prize: none of its accounts (`unstakeNftIx`).
       const given = await prizeInputs([forfeit ? null : prize]);
-      // A mission's roll on the NFT is at the NFT's nonce (`nonceOn`): one at a time on it.
+      // A mission's roll on the NFT: on a box that holds it, at the NFT's own nonce (one at a time on it), else at
+      // `prizeRollNonce` of the one named (`namedRollNonce`).
       const nonce = roll != null ? loot.nonceOn(asset) : freshNonce();
-      const ix = loot.unstakeNftIx({ player: wallet.address, project, id: f.id, farm, asset, ...nft, forfeit, roll, nonce, tier: seat.tier, projectCollection: given.collection, poolMints: given.poolMints, items: given.items, nft: given.nft, ...token });
-      const signature = await send([...before, ...given.before, ...token.before, ix]);
-      if (roll != null) return { signature, roll: loot.pda.order(project, wallet.address, nonce) };
-      return prize?.Roll && !forfeit ? { signature, roll: loot.pda.order(project, wallet.address, loot.prizeRollNonce(nonce + 1n)) } : signature;
+      const boxes = roll != null ? { [roll]: await read('LootBox', loot.pda.box(project, roll)) } : {};
+      // A roll still at the NFT's order address blocks the leave, unless it was asked and came back with nothing to give
+      // (Waiting, asked once): that one stands in for this. Any other is asked (its player or the project's keys), answered and settled first.
+      if (roll != null) {
+        const at = loot.pda.order(project, wallet.address, loot.namedRollNonce(boxes[roll], asset, nonce));
+        const there = await readMaybe('Order', at);
+        if (there && !(there.status === 'Waiting' && BigInt(there.asked_first) !== 0n))
+          throw new Error(`This NFT's last mission roll (${at}) hasn't finished: it must be asked, answered and settled before the NFT can leave. claims() lists the step; collect it (app.collect), then leave.`);
+      }
+      const ix = loot.unstakeNftIx({ player: wallet.address, project, id: f.id, farm, asset, ...nft, forfeit, roll, nonce, tier: seat.tier, projectCollection: given.collection, poolMints: given.poolMints, items: given.items, nft: given.nft, boxes, ...token });
+      const { signature, rolls } = await sendRolling(await walking(f, farm, [...before, ...given.before, ...token.before, ix]));
+      const rolled = rolls.length ? { rolled: rolls[0] } : {};
+      if (roll != null) return { signature, roll: loot.pda.order(project, wallet.address, loot.namedRollNonce(boxes[roll], asset, nonce)), ...rolled };
+      return prize?.Roll && !forfeit ? { signature, roll: loot.pda.order(project, wallet.address, loot.prizeRollNonce(nonce + 1n)), ...rolled } : signature;
+    },
+
+    /**
+     * What farm `farmKey` has to walk: `{ ends, needsWalk, parts }`, the times its seats stop earning it has passed and not
+     * yet credited up to, whether a move can no longer do them in its own transaction, and how many transactions
+     * `walkFarm` would take. Every move walks them first; nothing is lost however long they wait.
+     */
+    async farmWalk(farmKey) {
+      const f = part('farms', farmKey);
+      const { left } = await endsOf(f, await read('Farm', loot.pda.farm(project, f.id)));
+      return { ends: left, needsWalk: left > loot.MOVE_WALK_ROOM, parts: Math.ceil(left / loot.WALK_PER_TX) };
+    },
+
+    /**
+     * Walks a farm up to now in parts (`walk_farm`), for one that has passed more ends than a move can walk: one transaction
+     * for every `loot.WALK_PER_TX` ends, oldest first. Anyone may send it, and it costs only the network fee. Returns their
+     * signatures, none when there is nothing to walk.
+     */
+    async walkFarm(farmKey, { perTx = loot.WALK_PER_TX, ...others } = NO_OPTIONS) {
+      only(others, ['perTx'], 'walkFarm');
+      const f = part('farms', farmKey);
+      const farm = await read('Farm', loot.pda.farm(project, f.id));
+      const { ends } = await endsOf(f, farm);
+      const out = [];
+      for (const ix of loot.walkFarmParts({ project, id: f.id, farm, ends, now: await chainNow(), perTx })) out.push(await send([computeUnitLimit(loot.WALK_COMPUTE_UNITS), ix]));
+      return out;
     },
 
     /**
@@ -1152,16 +1682,16 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
      * and reads its boosts again. Anyone may send it; the player pays for what the write adds. `by`: the collectible,
      * or the player for their token seat's booster.
      */
-    async refresh(farmKey, by, { extra, transfers, ...others } = NO_OPTIONS) {
+    async refresh(farmKey, by, { extra, ...others } = NO_OPTIONS) {
+      // `transfers` (a token's transfer plan) is taken and needs nothing: a refresh moves no tokens.
       only(others, ['extra', 'transfers'], 'refresh');
       const f = part('farms', farmKey);
       const farm = await read('Farm', loot.pda.farm(project, f.id));
       const seat = await read('Seat', loot.pda.seat(loot.pda.farm(project, f.id), by));
       const held = seat.asset !== NOBODY;
       const { before, ...nft } = held ? await nftOf(seat.asset) : { before: [], hasAuthority: true };
-      // Like every move, it brings the farm's rewards in (and sends back what a seat gave up): the mint's hook accounts.
-      const token = await farmTokens([farm.rewards_mint], [], { extra, transfers });
-      return send([...before, loot.refreshSeatIx({ signer: wallet.address, project, id: f.id, farm, by, seat, ...nft, extra: token.extra })]);
+      // A refresh moves no tokens (a farm's rewards are numbers until a seat is paid): only a collectible's own tail.
+      return send(await walking(f, farm, [...before, loot.refreshSeatIx({ signer: wallet.address, project, id: f.id, farm, by, seat, ...nft, extra: extra ?? [] })]));
     },
 
     /**
@@ -1172,13 +1702,6 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       only(others, ['compound', 'extra', 'transfers'], 'harvest');
       const f = part('farms', farmKey);
       const farm = await read('Farm', loot.pda.farm(project, f.id));
-      // A tier with an early exit keeps its rewards until its lock has run (RewardsLocked).
-      if (farm.farmed.Tokens) {
-        const seat = await readMaybe('Seat', loot.pda.seat(loot.pda.farm(project, f.id), by));
-        const tier = seat && farm.tiers[seat.tier];
-        const ends = tier ? BigInt(seat.since) + BigInt(tier.lock) : 0n;
-        if (tier && Number(tier.exit_bps) > 0 && (await chainNow()) < ends) throw new Error(`This stake can leave early, so its rewards wait for its lock: harvest after ${new Date(Number(ends) * 1000).toISOString()}. Leaving early gives them up.`);
-      }
       const token = await farmTokens([farm.rewards_mint], [farm.rewards_mint], { extra, transfers });
       // In a farm that watches: what shows the seat's NFT is still the player's (a compressed one proven first).
       let [held, tree, before] = [null, null, []];
@@ -1191,31 +1714,28 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
           before = nft.compressed ? nft.before : [];
         }
       }
-      return send([...before, ...token.before, loot.harvestIx({ player: wallet.address, project, id: f.id, farm, by, held, tree, compound, ...token })]);
+      // A compound stakes more: a seat with a booster on, or whose growth reads the amount, is refreshed first.
+      const seat = compound ? await readMaybe('Seat', loot.pda.seat(loot.pda.farm(project, f.id), by)) : null;
+      const first = loot.stakeRefreshFirst(farm, seat, { compound: true }) ? await refreshOf(f, farm, seat) : [];
+      return send(await walking(f, farm, [...before, ...token.before, ...first, loot.harvestIx({ player: wallet.address, project, id: f.id, farm, by, held, tree, compound, ...token })]));
     },
 
     /**
      * Adds what a token seat is owed to its stake, without restarting its lock (a farm of tokens whose rewards are the
-     * staked token). The farm's toll, if any, is taken first.
+     * staked token).
      */
     async compound(farmKey, opts = {}) {
       only(opts, ['extra', 'transfers'], 'compound');
       return this.harvest(farmKey, wallet.address, { ...opts, compound: true });
     },
 
-    /** Takes out the tokens whose unbonding wait is over (a farm with `unbond`), and what the seat is owed. */
-    async withdraw(farmKey, opts = {}) {
-      only(opts, ['forfeit', 'extra', 'transfers'], 'withdraw');
-      return this.unstake(farmKey, 0, opts);
-    },
-
     /**
      * The player's seats in a farm (the wallet's, or `player`'s): each one's NFT (`asset`, null for a token seat with
      * no booster), what it holds staked (`amount`, in whole units of the staked token, a number for display that can
      * round past 2^53 base units; `amountUnits`, in base units exactly, a bigint; 1 for an NFT), its tier, when it
      * came in (`since`) and when its lock is over (`freeAt`, unix seconds; null when the NFT says it, `lockKey`), its
-     * boost in percent, and what it is owed now: `waiting` (whole units of the rewards, `rewards` their token) and
-     * `owedUnits` (base units). What it is owed is the program's own sum, from a refresh of the seat dry-run on the
+     * boost in percent, until when it earns (`earnsUntil`, unix seconds, null for no end: a tier's term, an upkeep), and
+     * what it is owed now: `waiting` (whole units of the rewards, `rewards` their token) and `owedUnits` (base units). What it is owed is the program's own sum, from a refresh of the seat dry-run on the
      * network (nothing is signed or sent): what the farm released or its rate paid since its last move is in it, by the
      * farm's rounding. When the dry run fails, it is what the seat was last credited, and `counted` is false.
      * One search of the chain, and one dry run per seat: read it when the page opens and after a stake or a harvest.
@@ -1227,12 +1747,14 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const farm = await read('Farm', farmAddress);
       const rewards = [...tokens.values()].find((t) => mintOf(t.key) === farm.rewards_mint);
       const nfts = f.stakes === 'collectibles';
-      const found = await client.programAccounts(loot.LOOT_PROGRAM, [
+      // A seat names its player (offset 1), not its farm: a seat of this farm is the one at its own address here.
+      const found = (await client.programAccounts(loot.LOOT_PROGRAM, [
         { memcmp: { offset: 0, bytes: encodeBase58(Uint8Array.of(loot.TAGS.Seat)) } },
-        { memcmp: { offset: 1, bytes: farmAddress } },
-        { memcmp: { offset: 33, bytes: player } },
-      ]);
-      const token = await farmTokens([farm.rewards_mint], []).catch(() => ({ extra: [] }));
+        { memcmp: { offset: 1, bytes: player } },
+      ])).filter(({ pubkey, account }) => {
+        const seat = loot.decode('Seat', account.data);
+        return pubkey === loot.pda.seat(farmAddress, nfts ? seat.asset : player);
+      });
       const { blockhash } = await client.latestBlockhash();
       // Who the dry run names as the refresh's signer and fee payer: the network wants one that holds SOL, whoever it is
       // (nothing is signed): the player, else the wallet looking, else the project's authority.
@@ -1250,7 +1772,7 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
           payer ??= await funded();
           const { before, ...nft } = held ? await nftOf(seat.asset, payer) : { before: [] };
           const by = nfts ? seat.asset : player;
-          const ix = loot.refreshSeatIx({ signer: payer, project, id: f.id, farm, by, seat, ...nft, extra: token.extra });
+          const ix = loot.refreshSeatIx({ signer: payer, project, id: f.id, farm, by, seat, ...nft });
           const message = compileMessage({ payer, blockhash, instructions: [...before, ix] });
           const after = (await client.simulate(wireTransaction(message), { accounts: [pubkey], replaceBlockhash: true })).accounts[0];
           if (after?.data) [seat, counted] = [loot.decode('Seat', after.data), true];
@@ -1270,6 +1792,8 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
           rewards: rewards?.key ?? null,
           waiting: show(seat.owed, rewards ? decimalsOf(rewards.key) : 0),
           owedUnits: BigInt(seat.owed),
+          // Until when it earns and grows (unix seconds): its tier's term or its fuel, the sooner; null for no end.
+          earnsUntil: BigInt(seat.earns_until) >= loot.NO_END ? null : Number(seat.earns_until),
           counted,
         });
       }
@@ -1290,31 +1814,33 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
      * Crafts a recipe, handing in `assets` (the collectibles it burns or uses, in the recipe's order). `version`: the
      * recipe's version the page showed the player (`recipes()`, or the listing itself as `listing`), so a recipe the
      * owner changed since is refused rather than crafted on terms the player never saw. It is required: the version
-     * read now is never signed in its place.
+     * read now is never signed in its place. `extra`: the tail a Core collection's plugins need when the craft moves or
+     * rolls on a Core NFT (sent after the Memo program's account, as on every other Core move).
      */
-    async craft(recipeKey, assets = [], times = 1, { version, listing, ...others } = NO_OPTIONS) {
-      only(others, ['version', 'listing'], 'craft');
+    async craft(recipeKey, assets = [], times = 1, { version, listing, extra = [], ...others } = NO_OPTIONS) {
+      only(others, ['version', 'listing', 'extra'], 'craft');
       const r = part('recipes', recipeKey);
       version ??= listing?.version ?? undefined;
       if (version === undefined || version === null) throw new Error(`Say which version of “${r.name ?? recipeKey}” the player was shown: pass the listing recipes() showed (listing), or its version. The version read now is never signed in its place.`);
       const current = await read('Recipe', loot.pda.recipe(project, r.id));
       const recipe = { ...current, version };
-      await poolShareGiven(recipe.outputs.filter((o) => o.Prize).map((o) => o.Prize[0] ?? o.Prize));
       const pays = recipe.inputs.filter((i) => i.Pay).map((i) => i.Pay);
       const holders = await holdersOf(pays.map((p) => ({ to: p.to })));
       const treasury = (await projectNow()).treasury;
       // An NFT a `show` line takes, by its address: as the project's, a Core asset of another collection, or a Token
       // Metadata mint, which the craft reads differently.
       // Where the collectibles of input `i` start among those handed in.
-      const at = (i) => recipe.inputs.slice(0, i).reduce((n, x) => n + (x.Burn?.count ?? (x.Use || x.Renew || x.Show || x.Staked || x.Trade ? 1 : 0)), 0);
+      const at = (i) => recipe.inputs.slice(0, i).reduce((n, x) => n + (x.Burn?.count ?? (x.Use || x.Show || x.Staked || x.Trade ? 1 : 0)), 0);
       const shownAt = new Set(recipe.inputs.flatMap((input, i) => (input.Show ? [at(i)] : [])));
       // An NFT a `trade` line takes in, any kind: read for its kind (a compressed one proven first).
       const tradedAt = new Set(recipe.inputs.flatMap((input, i) => (input.Trade ? [at(i)] : [])));
       const proving = [];
       // A collectible used or renewed that is staked in escrow, in the project's hands: its farm, found by its seat.
-      const keptAt = new Set(recipe.inputs.flatMap((input, i) => (input.Use || input.Renew ? [at(i)] : [])));
+      const keptAt = new Set(recipe.inputs.flatMap((input, i) => (input.Use ? [at(i)] : [])));
       // One a `staked` line takes: on its seat in the farm the line names, escrowed or frozen there.
       const stakedAt = new Map(recipe.inputs.flatMap((input, i) => (input.Staked ? [[at(i), input.Staked.farm]] : [])));
+      // The places a raise lowers a number on.
+      const lowered = new Set((recipe.raises ?? []).filter((raise) => BigInt(raise.shift.by) < 0n).map((raise) => Number(raise.place)));
       const handed = await Promise.all(assets.map(async (nft, i) => {
         if (stakedAt.has(i) && typeof nft === 'string') {
           const farm = stakedAt.get(i);
@@ -1324,21 +1850,25 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
           }
           return { asset: nft, farm };
         }
-        if (keptAt.has(i) && typeof nft === 'string') return (await escrowedIn(nft)) ?? nft;
+        if (keptAt.has(i) && typeof nft === 'string') return (await escrowedIn(nft)) ?? (await lockedIn(nft)) ?? nft;
         if (tradedAt.has(i) && typeof nft === 'string') {
           const { before, ...kind } = await nftOf(nft);
           proving.push(...before);
           return { asset: nft, ...kind };
         }
         if (!shownAt.has(i) || typeof nft !== 'string') return nft;
+        // Shown on a seat of a farm that freezes, with a raise lowering a number on it: its seat and farm go with it.
+        const seated = lowered.has(i) ? await lockedIn(nft) : null;
+        const on = seated ? { farm: seated.farm } : {};
         const account = await client.account(nft);
-        if (account?.owner !== MPL_CORE) return { mint: nft, owner: wallet.address };
+        if (account?.owner !== MPL_CORE) return { mint: nft, owner: wallet.address, ...on };
         const theirs = await collectionOf(nft);
-        return ours(theirs) ? nft : { asset: nft, collection: theirs };
+        return ours(theirs) ? (seated ? { asset: nft, ...on } : nft) : { asset: nft, collection: theirs, ...on };
       }));
       // A recipe that rolls makes its roll in an order of the player's, which `collect` then finishes.
       const rolls = recipe.outputs.some((o) => o.RollOn || o.Prize?.[0]?.Roll);
-      // A roll on a collectible kept is at that collectible's nonce (`nonceOn`): one at a time on it.
+      // A roll on a collectible kept is named by that collectible's nonce (`nonceOn`): on a box that holds it, its
+      // order is there, one at a time on it (`namedRollNonce`).
       const rollOn = recipe.outputs.find((o) => o.RollOn)?.RollOn;
       const nonce = rollOn ? loot.nonceOn(typeof assets[rollOn.place] === 'string' ? assets[rollOn.place] : assets[rollOn.place].asset) : freshNonce();
       // A roll on a kept collectible (`RollOn`) passes its box's prize mints as a roll given does.
@@ -1358,12 +1888,12 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         return [loot.pda.itemAsset(loot.pda.item(project, id), Number(items[id].issued) + counts[id])];
       });
       const before = [...proving, ...given.before].filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM);
-      let instructions = [computeUnitLimit(1_000_000), ...before, loot.craftIx({ player: wallet.address, project, collection: collections[0], id: r.id, recipe, assets: handed, times, nonce, holders, programs, treasury, poolMints: given.poolMints, items, nfts: given.nfts, boxes: given.boxes, rollPools: given.rollPools })];
+      let instructions = [computeUnitLimit(rolls ? 1_400_000 : 1_000_000), ...before, loot.craftIx({ player: wallet.address, project, collection: collections[0], id: r.id, recipe, assets: handed, times, nonce, holders, programs, treasury, poolMints: given.poolMints, items, nfts: given.nfts, boxes: given.boxes, extra })];
       // Fuel bought for a staked collectible counts once its seat is refreshed: in the same transaction.
       for (const raise of recipe.raises ?? []) {
         const asset = assets[raise.place];
         if (typeof asset !== 'string') continue;
-        for (const f of (spec.farms ?? []).filter((x) => x.upkeepAttribute === raise.key)) {
+        for (const f of (spec.farms ?? []).filter((x) => x.upkeepAttribute === raise.shift.key)) {
           const seat = await readMaybe('Seat', loot.pda.seat(loot.pda.farm(project, f.id), asset));
           if (!seat) continue;
           const farm = await read('Farm', loot.pda.farm(project, f.id));
@@ -1372,9 +1902,12 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         }
       }
       for (const p of pays) instructions = withSolWrap(wallet.address, p.mint, p.amount * BigInt(times), instructions);
-      const signature = await send(instructions);
-      // A roll on a collectible kept is at its nonce; a prize's roll at `prizeRollNonce` of the craft's.
-      return { signature, made, ...(rolls ? { roll: loot.pda.order(project, wallet.address, rollOn ? nonce : loot.prizeRollNonce(nonce)) } : {}) };
+      // A roll on a collectible kept is at its nonce; a prize's roll at `prizeRollNonce` of the craft's. Asked for in the
+      // craft's own transaction and settled by a key after: one prompt.
+      const on = rollOn && (typeof assets[rollOn.place] === 'string' ? assets[rollOn.place] : assets[rollOn.place].asset);
+      const roll = rolls ? loot.pda.order(project, wallet.address, rollOn ? loot.namedRollNonce(given.boxes[rollOn.box_id], on, nonce) : loot.prizeRollNonce(nonce)) : null;
+      const { signature, rolls: rolled } = await sendRolling(instructions);
+      return { signature, made, ...(roll ? { roll } : {}), ...(rolled.length ? { rolled: rolled[0] } : {}) };
     },
 
     /**
@@ -1432,6 +1965,50 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       return { signature, due, hold: loot.pda.hold(asset, due) };
     },
 
+    /**
+     * The loan on `asset` (held until `due`), as a page shows it before anyone repays: { lender, mint, repay (base units),
+     * due, paid }. `repay` is what `repay` then takes as the amount shown. Null when it holds no loan.
+     */
+    async loan(asset, due) {
+      const hold = await readMaybe('Hold', loot.pda.hold(asset, due));
+      if (!hold?.debt) return null;
+      return { lender: hold.debt.lender, mint: hold.debt.mint, repay: BigInt(hold.debt.repay), due: Number(hold.free_at), borrower: hold.player };
+    },
+
+    /**
+     * Repays the loan on `asset` (held until `due`), the player's own or a friend's, then sends the NFT home to its
+     * borrower. `repay`: the debt the payer was shown (`loan()`'s, in base units); the program refuses any other
+     * (`TermsChanged`). The repay goes in the wallet's transaction alone, with what it opens (the borrower's Token
+     * Metadata account), so a release that fails never undoes a repay that must land before the loan is due; the same
+     * transaction funds a throwaway key that sends the release (anyone may), a pNFT's or a compressed NFT's too: the key
+     * is funded for what that release opens (a pNFT's token account and record, a compressed NFT's proof record, which
+     * comes back in the same transaction). Returns { signature, released }.
+     */
+    async repay(asset, due, { repay, extra = [], ...others } = NO_OPTIONS) {
+      only(others, ['repay', 'extra'], 'repay');
+      const hold = await read('Hold', loot.pda.hold(asset, due));
+      if (!hold.debt) throw new Error('This NFT is held for no loan left to repay.');
+      if (repay === undefined || repay === null) throw new Error('Say the debt the payer was shown (repay, from loan()): the amount read now is never paid in its place.');
+      if (BigInt(repay) !== BigInt(hold.debt.repay)) throw new Error(`This loan now asks ${hold.debt.repay}, not the ${repay} shown: show the payer the loan as it is now first.`);
+      const { before, hasAuthority: _, ...nft } = await nftOf(asset, wallet.address, { to: hold.player });
+      const collection = nft.collection ?? (await collectionOf(asset)) ?? MPL_CORE;
+      // A pNFT's or a compressed NFT's release opens something (a token account and record, a proof record): its key
+      // is funded for it, and makes its own proof and accounts as it sends the release.
+      const heavy = before.some(isProveLeaf) || Boolean(nft.tokenMetadata?.programmable);
+      const opens = heavy ? [] : before.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM);
+      const at = loot.pda.hold(asset, due);
+      const { key, fund } = await keyFor(heavy ? loot.SETTLE_RENT_UNIT + SIGNATURE_FEE : SIGNATURE_FEE, await jobKey(at));
+      const repaid = loot.repayIx({ payer: wallet.address, project, hold, repay, programs, extra });
+      const signature = await send(withSolWrap(wallet.address, hold.debt.mint, BigInt(hold.debt.repay), [...opens, repaid, fund]));
+      // Repaid, the hold is a plain one that is over (no debt, `free_at` 0) at the address its loan named.
+      const release = async (signer) => {
+        const { before: first, hasAuthority: _h, ...kind } = heavy ? await nftOf(asset, signer, { to: hold.player }) : { before: [], ...nft };
+        return [...first, loot.releaseIx({ signer, project, asset, ...kind, collection, hold: { ...hold, debt: null, free_at: 0 }, address: at })];
+      };
+      const released = await keyRun(key, release);
+      return { signature, released };
+    },
+
     /**
      * Backs `side` of contest number `id` (the authority opens contests while the project runs) with `amount`; a contest
      * of NFTs takes one of the player's NFTs that passes its rule instead (`nft`, its address), held until it is
@@ -1486,7 +2063,10 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
           secondsLeft: Number(ends > at ? ends - at : 0n),
           open: nextBid !== null && at >= x.starts_at && at < ends,
           over: at >= ends,
-          ...(x.nft_bids ? { nftBids: true, held: x.held } : {}),
+          // The lot went at its end, and its seller's account couldn't take the money then: the next end pays it and closes it.
+          ...(BigInt(x.proceeds_owed) > 0n ? { delivered: true, proceedsOwed: show(x.proceeds_owed, dec) } : {}),
+          // A bid of NFTs: a picker of 1 to `maxNfts` (and at least `nextBid`) of the player's NFTs.
+          ...(x.nft_bids ? { nftBids: true, held: x.held, maxNfts: loot.MAX_BID_NFTS } : {}),
           ...(tokens.get(a.currency ?? currencyKey)?.source === 'sol' ? { waiting } : {}),
         };
       });
@@ -1509,6 +2089,8 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       if (auction.nft_bids) {
         const bundle = nfts ?? (Array.isArray(amount) ? amount : null);
         if (!bundle?.length) throw new Error('This auction takes NFTs as bids: say which (nfts).');
+        if (bundle.length > loot.MAX_BID_NFTS) throw new Error(`A bid holds at most ${loot.MAX_BID_NFTS} NFTs.`);
+        if (auction.held.length >= loot.MAX_BID_NFTS) throw new Error(`The high bid holds ${loot.MAX_BID_NFTS} NFTs, the most a bid holds: it can't be topped.`);
         const before = [];
         const kindOf = async (asset, to) => {
           const { before: proof, ...kind } = await nftOf(asset, wallet.address, { to });
@@ -1542,16 +2124,22 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     /**
      * Ends an auction that is over (anyone can; the winner usually does): the lot to the highest bidder, a new
      * collectible minted for them at the address its item and serial name, however long after the end it is sent. A
-     * roll lot makes the winner's roll of its box (`order`), which `collect` asks for and settles.
+     * roll lot makes the winner's roll of its box (`order`), which `collect` asks for and settles. An end too big for one
+     * transaction makes each NFT a hold and sends each home with a release after it (`releases`).
      */
     async endAuction(auctionKey, { holders, ...others } = NO_OPTIONS) {
       only(others, ['holders'], 'endAuction');
       const a = part('auctions', auctionKey);
       const auction = await read('Auction', auctionAt(a));
       const g = await projectNow();
+      // The lot went at an earlier end: this one pays what its seller is owed and closes the auction.
+      if (BigInt(auction.proceeds_owed) > 0n) {
+        const memo = programOf(auction.mint) === TOKEN_2022_PROGRAM ? [{ pubkey: MEMO_PROGRAM, isSigner: false, isWritable: false }] : [];
+        return { signature: await send([loot.endAuctionIx({ signer: wallet.address, project, projectState: g, id: a.id, auction, programs, extra: memo })]), owedPaid: auction.proceeds_owed };
+      }
       const sold = auction.high > 0n;
       const item = auction.lot.Item ? await read('Item', loot.pda.item(project, auction.lot.Item[0])) : null;
-      const made = sold && item?.kind === 'Collectible' ? loot.pda.itemAsset(loot.pda.item(project, auction.lot.Item[0]), auction.serial) : null;
+      const made = sold && item?.kind === 'Collectible' ? loot.pda.itemAsset(loot.pda.item(project, auction.lot.Item[0]), auction.pin) : null;
       const memo = programOf(auction.mint) === TOKEN_2022_PROGRAM ? [{ pubkey: MEMO_PROGRAM, isSigner: false, isWritable: false }] : [];
       holders ??= sold ? await holdersOf(auction.shares) : {};
       const lot = auction.lot.Asset?.[0];
@@ -1569,18 +2157,46 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         }
       }
       const ix = loot.endAuctionIx({ signer: wallet.address, project, projectState: g, id: a.id, auction, item, ...nft, collection, held, holders, programs, extra: memo });
-      const signature = await send([computeUnitLimit(800_000), ...before.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM), ix]);
-      // A roll lot sold: the winner's roll, made at the default nonce, waits for anyone to ask it (`collect`).
+      let all = [computeUnitLimit(800_000), ...before.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM), ix];
+      // An end that can't fit one transaction (a compressed lot's long proof, a hooked mint, many shares) makes each NFT
+      // a hold for whoever it goes to, then sends each home with its own release: anyone may, and the rent comes back.
+      const holds = lot || (sold && auction.nft_bids) ? !sendPlan({ payer: wallet.address, instructions: all, alone: isProveLeaf }) : false;
+      if (holds) {
+        // The end's own transaction funds a throwaway key that sends each release after it (anyone may): each one's
+        // fees, and what it may open (a pNFT's token account and record, a compressed NFT's proof record). One the key
+        // can't send, the wallet does.
+        const outs = [...(lot ? [[lot, sold ? auction.high_bidder : auction.seller]] : []), ...(sold && auction.nft_bids ? auction.held.map((x) => [x, proceeds]) : [])];
+        const { key, fund } = await keyFor(BigInt(outs.length) * (2n * SIGNATURE_FEE + loot.SETTLE_RENT_UNIT), await jobKey(auctionAt(a)));
+        all = [computeUnitLimit(800_000), loot.endAuctionIx({ signer: wallet.address, project, projectState: g, id: a.id, auction, item, ...nft, collection, held, hold: true, holders, programs, extra: memo }), fund];
+        const signature = await send(all);
+        const releases = [];
+        for (const [asset, to] of outs) {
+          const release = async (signer) => {
+            const hold = await read('Hold', loot.pda.hold(asset, 0));
+            const { before: proof, hasAuthority: _h, ...kind } = await nftOf(asset, signer, { to });
+            return [...proof, loot.releaseIx({ signer, project, asset, ...kind, collection: kind.compressed || kind.tokenMetadata ? undefined : (await collectionOf(asset)) ?? MPL_CORE, hold, to })];
+          };
+          const steps = await release(key.address);
+          const byKey = (await dryRun(key.address, steps)).ok ? await sendAs(key, steps).catch(() => null) : null;
+          releases.push(byKey ?? (await send(await release(wallet.address))));
+        }
+        await emptyKey(key);
+        return { signature, releases, ...(sold ? { winner: auction.high_bidder } : {}) };
+      }
+      // A roll lot sold: the winner's roll, made at the default nonce, waits for its winner or the project's keys to ask it (`collect`); the winner
+      // ending it asks in the same transaction and a key settles it.
       const roll = sold && auction.lot.Roll ? loot.pda.order(project, auction.high_bidder, loot.prizeRollNonce(loot.prizeNonce(auctionAt(a), BigInt(auction.last_bid_at)))) : null;
-      return { signature, ...(sold ? { winner: auction.high_bidder } : {}), ...(made ? { asset: made } : {}), ...(roll ? { order: roll } : {}) };
+      const { signature, rolls } = roll && auction.high_bidder === wallet.address ? await sendRolling(all) : { signature: await send(all), rolls: [] };
+      return { signature, ...(sold ? { winner: auction.high_bidder } : {}), ...(made ? { asset: made } : {}), ...(roll ? { order: roll } : {}), ...(rolls.length ? { rolled: rolls[0] } : {}) };
     },
 
     /**
-     * Runs a schedule that is due (an emission into a pool, a rent or a drip): anyone may, and nothing is paid to
-     * whoever sends it but the network fee. `holders`: asset → holder, for a schedule that pays a collectible's holder.
+     * Runs a schedule that is due (an emission into a pool, a rent or a drip): the project's owner or authority, or who it
+     * pays, may (a sealed burn: anyone), and nothing is paid to whoever sends it but the network fee. A run missed is missed:
+     * this pays once, for the latest run due, and the runs before it lapse; only a sealed fixed amount pays every run due. `holders`: asset → holder, for a schedule that pays a collectible's holder.
      * Returns null when it isn't due yet.
      */
-    async runSchedule(scheduleKey, { holders, most = 20, ...others } = NO_OPTIONS) {
+    async runSchedule(scheduleKey, { holders, most, ...others } = NO_OPTIONS) {
       only(others, ['holders', 'most'], 'runSchedule');
       const sc = part('schedules', scheduleKey);
       const address = loot.pda.schedule(project, sc.id);
@@ -1589,13 +2205,15 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       // A sealed schedule's vault: past its last run, whatever arrived since is due once more.
       const vault = from.Vest ? await client.account(loot.pda.vest(address)) : null;
       const held = vault ? vault.data.subarray(64, 72).reduce((n, b, i) => n | (BigInt(b) << BigInt(8 * i)), 0n) : 0n;
-      // Runs due by the chain's clock, each its own instruction: one too many would fail them all.
-      const due = Math.min(loot.runsDue(schedule, await chainNow(), held), most);
+      // Every run due by the chain's clock (`most`: at most that many of a sealed fixed amount's, the only one paid run by
+      // run; a long backlog of those takes a few calls).
+      const due = Math.min(loot.runsDue(schedule, await chainNow(), held), most ?? Infinity);
       if (!due) return null;
       const poolMint = from.Pool ? encodeBase58((await client.account(loot.pda.pool(project, from.Pool[0]))).data.subarray(0, 32)) : null;
       holders ??= await holdersOf([{ to: schedule.action.to }]);
       const treasury = (await projectNow()).treasury;
-      return send(Array.from({ length: due }, () => loot.runScheduleIx({ payer: wallet.address, project, id: sc.id, schedule, poolMint, holders, programs, treasury })));
+      // A sealed fixed amount's backlog is a step for each halving: room for the longest the program takes a call.
+      return send([computeUnitLimit(1_400_000), loot.runScheduleIx({ payer: wallet.address, project, id: sc.id, schedule, poolMint, holders, programs, treasury, upto: Number(schedule.runs) + due })]);
     },
 
     // ---------------------------------------------------------------- listings
@@ -1696,18 +2314,20 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       only(others, ['price', 'currency', 'drawsAt', 'minSold', 'perWallet', 'shares'], 'raffle');
       const kind = await nftOf(nft);
       const { before, hasAuthority: _, ...piece } = kind;
-      await send([...before, loot.stashIx({ signer: wallet.address, project, lottery: id, asset: nft, ...piece })]);
+      const lotteryState = await readMaybe('Lottery', loot.pda.lottery(project, id));
+      await send([...before, loot.stashIx({ signer: wallet.address, project, lottery: id, lotteryState, asset: nft, ...piece })]);
       const args = {
         price: units(price, decimalsOf(currency)), mint: mintOf(currency), shares, places: [{ bps: 0, prize: { Held: [nft] } }],
         ticket_mint: NOBODY, every: 0n, draws_at: BigInt(drawsAt), gate: null, per_wallet: perWallet, min_sold: BigInt(minSold),
       };
-      return send([loot.upsertIx({ owner: wallet.address, project, def: { Lottery: { id, args } } })]);
+      return send([loot.upsertIx({ owner: wallet.address, project, def: { Lottery: { id, args } }, lotteryState })]);
     },
 
     /** The raffle's owner takes the NFT back out of lottery `id`'s own stash once nothing promises it (the lottery ended, or no place names it). */
     async unraffle(id, nft) {
       const { before, hasAuthority: _, ...piece } = await nftOf(nft, wallet.address, { to: wallet.address });
-      return send([...before, loot.stashIx({ signer: wallet.address, project, lottery: id, asset: nft, out: wallet.address, ...piece })]);
+      const lotteryState = await readMaybe('Lottery', loot.pda.lottery(project, id));
+      return send([...before, loot.stashIx({ signer: wallet.address, project, lottery: id, lotteryState, asset: nft, out: wallet.address, ...piece })]);
     },
 
     /** Turns what waits in the player's wrapped-SOL account (a bid that was topped) into plain SOL. */
@@ -1720,7 +2340,7 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     /**
      * Claims a grant for the connected wallet: from the approved list (the proof comes from xsolana.json, or is given:
      * `proof`, `personHash` and the `round` the list pays, as a results server's list answers them), or with a voucher
-     * a server signed ({ publicKey, signature, incarnation, round, expires, personHash, amount }). A list in xsolana.json names
+     * a server signed ({ publicKey, signature, incarnation, round and amount, or rounds: [{ id, amount }], expires, personHash }). A list in xsolana.json names
      * no round (zeros). `amount` (a voucher's, or `options.amount` for a list's leaf): the tokens this claim gives, in
      * base units, up to the grant's own, for a grant of a fixed amount of tokens (a reward by rank); absent or 0 gives
      * the grant's prize as it is. A grant that gives a roll of a box makes the wallet's roll, which `claims()` then
@@ -1734,8 +2354,12 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const grant = await read('Grant', address);
       shown ??= await passing(grant.gate, 'claim this');
       const gateProof = listProofOf(grant.gate, gspec.gate?.list, options.listProof);
-      const receipt = await client.account(loot.pda.grantReceipt(address, grant.incarnation, wallet.address));
-      const count = loot.readReceiptAccount(receipt)?.count ?? 0;
+      // What the grant has paid this wallet: its count of claims (an open claim's roll is named by it), and the rounds
+      // paid (one paid already is skipped).
+      const bits = grant.shard_bits;
+      const [claimsShard, roundsShard] = await client.accounts([loot.pda.claims(address, grant.incarnation, loot.shardOf(loot.limitKey('wallet', wallet.address), bits)), loot.pda.rounds(address, grant.incarnation, loot.walletShard(grant, wallet.address))]);
+      const count = loot.readLimit(loot.readListAccount(claimsShard), loot.limitKey('wallet', wallet.address)).count;
+      const paidRounds = loot.readListAccount(roundsShard);
       // What its prize needs: a pool's mint, the item, an NFT's kind (a compressed one proven first).
       const prized = await prizeInputs([grant.gives]);
       const pool = grant.gives.Tokens?.from.Pool?.[0];
@@ -1746,7 +2370,7 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const keys = gspec.keys ?? [];
       if (voucher) {
         if (voucher.incarnation == null || BigInt(voucher.incarnation) !== grant.incarnation) throw new Error('This voucher belongs to a different grant incarnation.');
-        const message = loot.voucherBytes({ grant: address, incarnation: grant.incarnation, wallet: wallet.address, personHash: voucher.personHash, round: voucher.round, expires: voucher.expires, amount: BigInt(voucher.amount ?? 0) });
+        const message = loot.voucherBytes({ grant: address, incarnation: grant.incarnation, wallet: wallet.address, personHash: voucher.personHash, rounds: voucher.rounds, round: voucher.round, expires: voucher.expires, amount: BigInt(voucher.amount ?? 0) });
         const signature = typeof voucher.signature === 'string' ? decodeBase58(voucher.signature) : voucher.signature;
         instructions.push(loot.ed25519Ix({ publicKey: voucher.publicKey, signature, message }));
         // A key under the grant's key root (a promo code's) proves it is one of them.
@@ -1769,18 +2393,17 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       } else if ((gspec.vouchers ?? []).length || keys.length) {
         throw new Error('This grant pays a wallet a voucher key signs for: pass the voucher.');
       }
-      // A share of a pool that comes to nothing is refused (PrizeNotCovered): say the pool is empty instead.
-      if (grant.gives.Tokens?.amount.Bps && pool !== undefined) {
-        const held = (await client.account(loot.pda.pool(project, pool)))?.data;
-        const amount = held ? held.subarray(64, 72).reduce((n, b, i) => n | (BigInt(b) << BigInt(8 * i)), 0n) : 0n;
-        if (amount * BigInt(grant.gives.Tokens.amount.Bps[0]) / 10_000n === 0n) throw new Error('This grant pays a share of its pool, and the pool is empty: nothing to claim yet.');
-      }
       // What this claim gives: the amount the voucher or the list's leaf names (0: the grant's prize as it is).
       const amount = BigInt((voucher ? voucher.amount : listAmount) ?? 0);
-      const most = grant.gives.Tokens?.amount.Fixed?.[0];
+      const most = grant.gives.Tokens?.amount;
       if (amount > 0n && (most === undefined || amount > BigInt(most))) throw new Error(`This claim names ${amount} tokens, more than this grant gives${most === undefined ? ' (it gives no fixed amount of tokens)' : ` (${most})`}.`);
-      instructions.push(loot.claimGrantIx({ project, id: gspec.id, grant, wallet: wallet.address, signer: wallet.address, count, round: voucher?.round ?? listRound, expires: voucher?.expires, personHash: voucher?.personHash ?? listPerson, amount, proof, poolMint, item, nft: prized.nft, boxes: prized.boxes, rollPools: prized.rollPools, shown, listProof: gateProof, programs, voucherKey: voucher?.publicKey }));
-      return send(instructions);
+      instructions.push(loot.claimGrantIx({ project, id: gspec.id, grant, wallet: wallet.address, signer: wallet.address, count, rounds: voucher?.rounds, round: voucher?.round ?? listRound, expires: voucher?.expires, personHash: voucher?.personHash ?? listPerson, amount, proof, paidRounds, poolMint, item, nft: prized.nft, shown, listProof: gateProof, programs, voucherKey: voucher?.publicKey }));
+      // A claim's records and prizes can pass the 200,000 compute units a transaction has by default.
+      const all = [computeUnitLimit(grant.gives.Roll ? 1_400_000 : loot.CLAIM_COMPUTE_UNITS), ...instructions.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM)];
+      if (!grant.gives.Roll) return send(all);
+      // A roll's orders are asked for in the claim's own transaction and settled by a key after: one prompt.
+      const { signature, rolls } = await sendRolling(all);
+      return rolls.length ? { signature, rolls } : signature;
     },
 
     /**
@@ -1836,14 +2459,17 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         }
       };
       const claimed = async (grantId, incarnation, round) => {
-        const grant = loot.pda.grant(project, grantId);
-        incarnation ??= (await read('Grant', grant)).incarnation;
-        return loot.readReceiptAccount(await client.account(loot.pda.grantReceipt(grant, incarnation, wallet.address)))?.claimed(round) ?? false;
+        const address = loot.pda.grant(project, grantId);
+        const grant = await read('Grant', address);
+        if (incarnation != null && BigInt(incarnation) !== BigInt(grant.incarnation)) return false;
+        const shard = await client.account(loot.pda.rounds(address, grant.incarnation, loot.walletShard(grant, wallet.address)));
+        return loot.roundPaid(loot.readListAccount(shard), wallet.address, round);
       };
       const out = [];
       const take = async (round, grant, claim) => {
         try {
-          out.push({ round, grant, signature: await claim() });
+          const r = await claim();
+          out.push({ round, grant, ...(typeof r === 'string' ? { signature: r } : r) });
         } catch (e) {
           out.push({ round, grant, error: e.message });
         }
@@ -1883,7 +2509,7 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     /**
      * What this player can finish now, themselves: a box to settle or refund, a contest entry to claim, a held
      * collectible to take home, an auction they won (or one off by the clock: their bid back), a lottery place they
-     * won, a draw that is due (anyone may reveal it, or ask again when the oracle never answered; it takes 0.0005
+     * won, a draw that is due (anyone may reveal it, or ask again when the oracle never answered; it takes 0.0008
      * SOL), and a drawn lottery's unpaid places, which anyone may pay so the next round can open. [{ kind, says, … }];
      * pass one to `claim`.
      */
@@ -1894,80 +2520,124 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const at = (offset, bytes) => ({ memcmp: { offset, bytes } });
       const slot = await slotNow();
       const time = BigInt(now());
+      const chainTime = await chainNow();
       for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [tag('Order'), at(1, project), at(33, me)])) {
         const o = loot.decode('Order', account.data);
         const opened = BigInt(o.requested_slot);
-        const refundAt = loot.orderRefundSlot(o);
-        if (refundAt !== null && slot >= refundAt) out.push({ kind: 'refund', order: pubkey, says: 'Your payment back for an order that never finished.' });
+        if (loot.orderRefundable(o, slot, chainTime)) out.push({ kind: 'refund', order: pubkey, says: 'Your payment back for an order that never finished.' });
         else if (o.status === 'Rolled' && slot > opened) out.push({ kind: 'settle', order: pubkey, says: 'What your box rolled.' });
-        else if (loot.rollAskable(o, slot)) out.push({ kind: 'settle', order: pubkey, says: 'A roll you won (a mission’s, a recipe’s, a prize’s): ask for it and see what it gives (one whose box has nothing left to give waits until it has).' });
+        else if (loot.rollAskable(o, slot, chainTime)) out.push({ kind: 'settle', order: pubkey, says: 'A roll you won (a mission’s, a recipe’s, a prize’s): ask for it and see what it gives (one whose box has nothing left to give waits until it has).' });
       }
-      for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [tag('Entry'), at(33, me)])) {
-        const entry = loot.decode('Entry', account.data);
-        const c = await client.account(entry.contest);
-        if (!c) continue;
-        const contest = loot.decode('Contest', c.data);
+      for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [tag('Contest'), at(1, project)])) {
+        const contest = loot.decode('Contest', account.data);
         const off = loot.contestOff(contest, time);
-        if (contest.project !== project || !(off || contest.verdict === 'Won')) continue;
-        const won = contest.winner === entry.side;
-        // A loser's NFT waits for the winners: it goes to the opener once they have all claimed.
-        if (contest.nft && !off && !won && entry.asset !== NOBODY && BigInt(contest.unclaimed) > 0n) continue;
-        const says = off ? 'Your entry back: the contest is off.' : won ? (contest.nft ? 'Your NFT back, and one of the losers’.' : contest.prize != null ? 'Your share of the pot, and your prize.' : 'Your share of the pot.') : 'Close your entry (your side lost).';
-        out.push({ kind: 'contest', entry: pubkey, id: contest.id, side: entry.side, says });
+        if (!(off || contest.verdict === 'Won')) continue;
+        const list = await client.account(loot.contestEntries(pubkey, contest));
+        const entry = list?.owner === loot.LOOT_PROGRAM ? loot.decodeEntries(list.data).find((e) => e.player === me) : null;
+        if (!entry) continue;
+        const won = !off && Number(contest.winner) === Number(entry.side);
+        const first = won && !(entry.bits & loot.CLAIMED);
+        // Owed: its money back (off) or its part of the pot (won), its own NFT while the contest holds it, a winner's
+        // prize with its first claim, and the losers' NFTs its share still lets it pick. A loser of a contest of tokens
+        // is owed nothing, and never sends a transaction.
+        const picks = won && contest.nft && !(entry.bits & loot.ENDED) && Number(entry.taken) < loot.shareOf(contest, entry);
+        const owed = (contest.nft ? Number(entry.amount) === 1 && (off || won) : BigInt(entry.amount) > 0n && (off || first)) || first || picks;
+        if (!owed) continue;
+        const says = off ? 'Your entry back: the contest is off.' : contest.nft ? `Your NFT back${picks ? ', and your pick of the losers’' : ''}.` : contest.prize != null ? 'Your share of the pot, and your prize.' : 'Your share of the pot.';
+        out.push({ kind: 'contest', id: contest.id, side: entry.side, says });
+      }
+      // The player's holds; the project's treasury wallet's also those owed to the treasury (a hold whose player is the
+      // project's own address: a dropped stash NFT, a lottery's or an auction's NFT owed to it).
+      const g = await projectNow();
+      const holdsOf = [me, ...(g.treasury === me ? [project] : [])];
+      const holds = (await Promise.all(holdsOf.map((who) => client.programAccounts(loot.LOOT_PROGRAM, [tag('Hold'), at(1, project), at(65, who)])))).flat();
+      for (const { pubkey, account } of holds) {
+        const hold = loot.decode('Hold', account.data);
+        // A repaid loan is a plain hold that is over (no debt, `free_at` 0): its NFT goes home whenever. An unpaid one's
+        // is the lender's once due.
+        if (!hold.debt && time >= BigInt(hold.free_at)) out.push({ kind: 'release', asset: hold.asset, hold: pubkey, says: hold.player === project ? 'An NFT owed to the treasury: send it there.' : 'Your collectible back: its hold is over.' });
       }
-      for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [tag('Hold'), at(1, project), at(65, me)])) {
+      // A loan this wallet made that is overdue and unpaid: its NFT is the lender's to take.
+      for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [tag('Hold'), at(1, project)])) {
         const hold = loot.decode('Hold', account.data);
-        // A repaid loan's NFT goes home whenever; an unpaid one's is the lender's once due.
-        if (hold.debt?.paid) out.push({ kind: 'release', asset: hold.asset, hold: pubkey, says: 'Your collectible back: your loan is repaid.' });
-        else if (!hold.debt && time >= BigInt(hold.free_at)) out.push({ kind: 'release', asset: hold.asset, hold: pubkey, says: 'Your collectible back: its hold is over.' });
+        if (hold.debt?.lender === me && time >= BigInt(hold.free_at)) out.push({ kind: 'release', asset: hold.asset, hold: pubkey, says: 'A loan you made is overdue and unpaid: take its NFT.' });
+      }
+      // A compressed NFT's proof record this wallet paid for and left open: closing it brings its rent back.
+      for (const { account } of await client.programAccounts(loot.LOOT_PROGRAM, [tag('Proven')])) {
+        const leaf = (() => {
+          try {
+            return loot.decodeProven(account.data);
+          } catch {
+            return null;
+          }
+        })();
+        if (leaf?.payer === me) out.push({ kind: 'close-leaf', asset: leaf.asset, tree: leaf.tree, says: 'A compressed NFT’s proof record you paid for: close it, and its rent comes back.' });
       }
       const auctions = spec.auctions ?? [];
       const found = await client.accounts(auctions.map((a) => auctionAt(a)));
       auctions.forEach((a, i) => {
         const x = found[i] && loot.decode('Auction', found[i].data);
-        if (!x || x.high_bidder !== me || time < loot.auctionEnds(x)) return;
-        out.push({ kind: 'auction', key: a.key, says: `You won “${a.name}”: take it.` });
+        if (!x || time < loot.auctionEnds(x)) return;
+        // The lot went at its end, and its seller's account couldn't take the money then: only the money is left to pay.
+        if (BigInt(x.proceeds_owed) > 0n) {
+          if (x.seller === me) out.push({ kind: 'auction', key: a.key, says: `The winner of “${a.name}” has the lot, and your account couldn’t take the money then: end it again once it can, and it is paid to you.` });
+          return;
+        }
+        if (x.high_bidder === me) out.push({ kind: 'auction', key: a.key, says: `You won “${a.name}”: take it.` });
+        // The seller's own auction, over: ending it pays them (or brings an unsold lot home).
+        else if (x.seller === me) out.push({ kind: 'auction', key: a.key, says: BigInt(x.high) > 0n ? `Your auction “${a.name}” is over: end it, and the winning bid is paid to you.` : `Your auction “${a.name}” ended with no bid: take your lot back.` });
       });
       for (const l of spec.lotteries ?? []) {
         // A lottery the page names but nobody has written yet (a raffle still to open) has nothing to finish.
         if (!(await client.account(loot.pda.lottery(project, l.id)))) continue;
-        const { lottery, contributions, winners } = await roundOf(l);
-        if (loot.lotteryCancellable(lottery, slot)) out.push({ kind: 'cancel-draw', key: l.key, says: `The oracle never answered the draw of “${l.name}”: make ticket payments refundable.` });
-        else if (lottery.status === 'Open' && time >= BigInt(lottery.draws_at) && BigInt(lottery.sold) > 0n) out.push({ kind: 'reveal', key: l.key, says: `The draw of “${l.name}” is due: reveal the winners.` });
-        else if (loot.lotteryDrawStuck(lottery, slot)) out.push({ kind: 'reveal', key: l.key, says: `The oracle never answered the draw of “${l.name}”: ask it again.` });
-        const open = contributions.filter(({ value }) => !value.done);
-        // A drawn round gives every place's prize first; its money moves after.
-        const owed = contributions.filter(({ value }) => loot.lotteryStep(lottery, value) === 'prizes');
-        if (owed.length) {
-          const mine = owed.find(({ value }) => value.player === me);
-          out.push({ kind: 'lottery-prize', key: l.key, contribution: (mine ?? owed[0]).address,
-            says: mine ? `Take your prize in “${l.name}”.` : `Give the winners of “${l.name}” their prizes, so its draw can complete.` });
-        } else if (lottery.status === 'Drawn' && open.length) {
-          out.push({ kind: 'complete-draw', key: l.key, contribution: open[0].address, says: `Complete the draw of “${l.name}” so its winners can collect.` });
+        const { current, rounds } = await roundOf(l);
+        const bought = (r) => r.entries.some((e) => e.buyer === me);
+        if (current?.status === 'Open' && time >= BigInt(current.terms.draws_at)) {
+          const short = BigInt(current.sold) < BigInt(current.terms.min_sold ?? 0);
+          out.push({ kind: 'reveal', key: l.key, says: short ? `“${l.name}” sold fewer tickets than it needs: call it off${bought(current) ? ' and take your ticket payment back, in one step' : ''}.` : `The draw of “${l.name}” is due: reveal the winners.` });
         }
-        if (lottery.status === 'Cancelled' && open.length) {
-          const mine = open.find(({ value }) => value.player === me) ?? open[0];
-          out.push({ kind: 'ticket-refund', key: l.key, contribution: mine.address,
-            says: mine.value.player === me ? `Recover your ticket payment for “${l.name}”.` : `Return a ticket payment for “${l.name}” so its next round can open.` });
-        }
-        if (winners.some((w) => w.winner === me)) out.push({ kind: 'prize', key: l.key, says: `You won a place in “${l.name}”.` });
-        else if (winners.length) {
-          // A place that rolls makes its winner's roll, whose order the payer funds (its rent and SOL go to the winner).
-          const rolls = lottery.places.some((p) => p.prize?.Roll) ? ', and about 0.005 SOL (0.011 when its box can give an item) for each place won that gives a roll, which goes to the winner' : '';
-          out.push({ kind: 'payout', key: l.key, says: `Pay the winners of “${l.name}” so its next round can open (about 0.002 SOL of account rent for each winner who has no account for the prize yet${rolls}; it stays with the winner).` });
+        for (const { address: round, round: r } of rounds) {
+          // The ask moved the lottery on: a round waiting for the oracle is an older one, asked again by its address,
+          // and after the timeout the next ask cancels it.
+          if (loot.lotteryCancellable(r, chainTime)) out.push({ kind: 'cancel-draw', key: l.key, round, says: `The oracle never answered the draw of “${l.name}”: call it off${bought(r) ? ' and take your ticket payment back, in one step' : ', so every ticket is refunded'}.` });
+          else if (loot.lotteryDrawStuck(r, chainTime)) out.push({ kind: 'reveal', key: l.key, round, says: `The oracle never answered the draw of “${l.name}”: ask it again.` });
+          if (r.status !== 'Drawn' && r.status !== 'Cancelled') continue;
+          // What this wallet is owed: a refund, its NFT ticket, its places' parts of the pot and their prizes.
+          const mine = r.entries.flatMap((e, i) => {
+            const parts = e.buyer === me ? loot.partsOwed(r, i) : [];
+            return parts.length ? [{ entry: i, parts }] : [];
+          });
+          if (mine.length) out.push({ kind: 'pull', key: l.key, round, pulls: mine, says: r.status === 'Cancelled' ? `Recover your ticket payment for “${l.name}”.` : `Take what you are owed in “${l.name}”.` });
+          // Anyone may pay everyone else what they are owed, and the parts owed in common (about 0.002 SOL of account
+          // rent for each payee who has no account for it yet, which stays with them): the last pull closes the round,
+          // and its rent goes back to whoever fronted it (the lottery, or its first buyer).
+          const others = r.entries.flatMap((e, i) => (loot.partsOwed(r, i).length && !mine.some((m) => m.entry === i) ? [i] : []));
+          const fronted = r.opener === me;
+          if (others.length || loot.commonOwed(r).length || (loot.roundFinished(r) && !mine.length))
+            out.push({ kind: 'payout', key: l.key, round, says: fronted ? `Pay everyone of “${l.name}” what they are owed: the round then closes, and your deposit for it comes back.` : `Pay the others of “${l.name}” what they are owed, so its round can close.` });
         }
       }
-      // Tokens whose unbonding wait is over, in a farm of tokens.
-      const chainTime = await chainNow();
-      for (const f of (spec.farms ?? []).filter((x) => x.stakes !== 'collectibles')) {
-        const seat = await readMaybe('Seat', loot.pda.seat(loot.pda.farm(project, f.id), me));
-        const free = seat ? loot.withdrawable(seat, chainTime) : 0n;
-        if (free > 0n) out.push({ kind: 'withdraw', key: f.key, says: `Your tokens leaving “${f.name ?? f.key}” are free: take them out.` });
+      // A farm idle past more ends than a move can walk: anyone may walk it, in parts.
+      for (const f of spec.farms ?? []) {
+        const farm = await readMaybe('Farm', loot.pda.farm(project, f.id));
+        if (!farm?.keeps_ends) continue;
+        const { left } = await endsOf(f, farm);
+        if (left > loot.MOVE_WALK_ROOM) out.push({ kind: 'walk', key: f.key, says: `“${f.name ?? f.key}” must be caught up before anyone can move it: ${left} seats’ end times to walk, in ${Math.ceil(left / loot.WALK_PER_TX)} transactions. It is free but for the network fee, and nothing is lost by the wait.` });
       }
       // A sealed schedule that pays this wallet: its runs that are due (vesting nobody can take back).
       for (const sc of spec.schedules ?? []) {
         const schedule = await readMaybe('Schedule', loot.pda.schedule(project, sc.id));
-        if (!schedule?.action.from.Vest || schedule.action.to.Wallet?.[0] !== me) continue;
+        if (!schedule) continue;
+        if (!schedule.action.from.Vest) {
+          // Any other schedule that is due: it waits for the project's keys or whoever it pays.
+          const state = await projectNow();
+          const to = schedule.action.to;
+          if ([state.owner, state.authority].includes(me) || to.Wallet?.[0] === me || (to.Treasury !== undefined && state.treasury === me)) {
+            if (loot.runsDue(schedule, chainTime) > 0) out.push({ kind: 'schedule', key: sc.key, says: `“${sc.name ?? sc.key}” is due to run: send it.` });
+          }
+          continue;
+        }
+        if (schedule.action.to.Wallet?.[0] !== me) continue;
         const vault = await client.account(loot.pda.vest(loot.pda.schedule(project, sc.id)));
         const held = vault ? vault.data.subarray(64, 72).reduce((n, b, i) => n | (BigInt(b) << BigInt(8 * i)), 0n) : 0n;
         if (loot.runsDue(schedule, chainTime, held) > 0) out.push({ kind: 'vest', key: sc.key, says: `What has vested of “${sc.name ?? sc.key}”: claim it.` });
@@ -1987,7 +2657,8 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const recent = mineTables.length ? await recentSlots() : [];
       for (const { pubkey, account } of mineTables) {
         const table = readTable({ ...account, owner: account.owner ?? LOOKUP_TABLE_PROGRAM });
-        if (!table || table.authority !== me) continue;
+        // The project's standing tables are never a transaction's own: never retired here.
+        if (!table || table.authority !== me || (spec.live?.tables ?? []).includes(pubkey)) continue;
         const step = tableStep(table, slot, recent);
         const rent = show(BigInt(account.lamports ?? 0), 9);
         if (step === 'close') out.push({ kind: 'lookup-table', table: pubkey, says: `${rent} SOL of rent back from a lookup table a large transaction of yours used.` });
@@ -2002,48 +2673,69 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
      * which loser's NFT they take (`{ take: asset }`, the NFT of a losing entry that still holds one; the first found by default):
      * only the winner can, while any are left.
      */
-    async claim(c, { take, ...others } = NO_OPTIONS) {
-      only(others, ['take'], 'claim');
+    async claim(c, { take, build = false, ...others } = NO_OPTIONS) {
+      only(others, ['take', 'build'], 'claim');
       const me = wallet.address;
+      // `build`: its instructions, unsent, for a step that is one transaction of the wallet's (`claimAll` signs several
+      // at once); null for one that is not (a roll to wait for, a refund, a step of another flow).
+      if (build && !BATCHED.has(c.kind)) return null;
+      const send = build ? async (instructions) => instructions : sendNow;
       const g = await projectNow();
-      if (c.kind === 'settle') return (await collect(c.order)).settled;
-      if (c.kind === 'refund') return this.refund(c.order);
+      if (c.kind === 'settle' || c.kind === 'refund') {
+        // A settle key this order's open funded (made again from this session's signature, or stored): it settles with
+        // no prompt, or gives its SOL back before the refund.
+        const key = keys ? await keys.again(c.order, { ask: false }) : null;
+        const funded = key && BigInt(await client.balance(key.address).catch(() => 0n)) > 0n ? key : null;
+        if (c.kind === 'settle') return (await collect(c.order, funded ? { burner: funded } : {})).settled;
+        if (funded) await emptyKey(funded);
+        return this.refund(c.order);
+      }
       if (c.kind === 'contest') {
         const contestAddress = loot.pda.contest(project, c.id);
         const contest = await read('Contest', contestAddress);
-        const won = contest.verdict === 'Won' && contest.winner === c.side;
-        const given = await prizeInputs([won ? contest.prize : null]);
-        // A contest of NFTs: the entry's own NFT, and for a winner while losers' NFTs are left, a losing entry's.
-        const nfts = {};
+        const entries = loot.decodeEntries((await client.account(loot.contestEntries(contestAddress, contest))).data);
+        const i = entries.findIndex((e) => e.player === me);
+        const own = entries[i];
+        const won = contest.verdict === 'Won' && Number(contest.winner) === Number(own.side);
+        const given = await prizeInputs([won && !(own.bits & loot.CLAIMED) ? contest.prize : null]);
+        // A contest of NFTs: the entry's own NFT while the contest holds it, and for a winner the losers' NFTs its share
+        // lets it pick (`take`: one asset, or several; the first left by default), as many as fit.
+        const nfts = [];
+        const kinds = {};
         if (contest.nft) {
-          const entry = await read('Entry', loot.pda.entry(contestAddress, me));
-          nfts.entry = entry;
-          const kindOf = async (asset, to = me) => {
+          const kindOf = async (asset, to) => {
             const { before, hasAuthority: _, ...kind } = await nftOf(asset, me, { to });
             given.before.push(...before);
-            return kind;
+            kinds[asset] = kind;
           };
-          // A losing entry's own NFT goes to the contest's opener once winners have taken theirs.
-          const lost = contest.verdict === 'Won' && !won;
-          if (entry.asset !== NOBODY) nfts.own = await kindOf(entry.asset, lost ? contest.opener : me);
-          if (won && Number(contest.losers) > 0) {
-            const found = await client.programAccounts(loot.LOOT_PROGRAM, [{ memcmp: { offset: 0, bytes: encodeBase58(Uint8Array.of(loot.TAGS.Entry)) } }, { memcmp: { offset: 1, bytes: contestAddress } }]);
-            const left = found.map(({ account }) => loot.decode('Entry', account.data)).filter((e) => e.side !== contest.winner && e.asset !== NOBODY);
-            const losing = take ? left.find((e) => e.asset === take) : left[0];
-            if (take && !losing) throw new Error(`${take} is not a loser’s NFT left in this contest.`);
-            if (losing) nfts.taking = { player: losing.player, side: losing.side, asset: losing.asset, kind: await kindOf(losing.asset) };
+          if (Number(own.amount) === 1) {
+            nfts.push(i);
+            await kindOf(own.nft, me);
+          }
+          const share = won && !(own.bits & loot.ENDED) ? loot.shareOf(contest, own) - Number(own.taken) : 0;
+          const left = entries.map((e, j) => ({ e, j })).filter(({ e }) => Number(e.side) !== Number(contest.winner) && Number(e.amount) === 1);
+          const wanted = take ? [take].flat() : [];
+          const picked = (wanted.length ? left.filter(({ e }) => wanted.includes(e.nft)) : left).slice(0, Math.min(share, 4));
+          if (wanted.length && picked.length < Math.min(wanted.length, share)) throw new Error(`${wanted.join(', ')} is not a loser’s NFT left in this contest for you to pick.`);
+          for (const { e, j } of picked) {
+            nfts.push(j);
+            await kindOf(e.nft, me);
           }
         }
-        return send([computeUnitLimit(800_000), ...given.before.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM), loot.claimIx({ payer: me, project, id: c.id, contest, player: me, side: c.side, collection: given.collection, poolMints: given.poolMints, items: given.items, nft: given.nft, ...nfts, programs })]);
+        const claimed = [computeUnitLimit(800_000), ...given.before.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM), loot.claimIx({ payer: me, project, projectState: g, id: c.id, contest, entries, player: me, nfts: contest.nft ? nfts : undefined, kinds, collection: given.collection, poolMints: given.poolMints, items: given.items, nft: given.nft, programs })];
+        // A prize that rolls: asked for in the claim's own transaction and settled by a key after (one prompt).
+        return contest.prize?.Roll && !build ? (await sendRolling(claimed)).signature : send(claimed);
       }
       if (c.kind === 'release') {
         const hold = await read('Hold', c.hold);
         const { before, hasAuthority: _, ...nft } = await nftOf(c.asset, me, { to: me });
-        return send([...before, loot.releaseIx({ signer: me, project, asset: c.asset, ...nft, collection: (await collectionOf(c.asset)) ?? MPL_CORE, hold })]);
+        // An overdue loan's NFT goes to its lender.
+        return send([...before, loot.releaseIx({ signer: me, project, asset: c.asset, ...nft, collection: (await collectionOf(c.asset)) ?? MPL_CORE, hold, address: c.hold, treasury: g.treasury, ...(hold.debt ? { to: hold.debt.lender } : {}) })]);
       }
       if (c.kind === 'auction') return (await this.endAuction(c.key)).signature;
-      if (c.kind === 'withdraw') return this.withdraw(c.key);
-      if (c.kind === 'vest') return this.runSchedule(c.key);
+      if (c.kind === 'close-leaf') return send([loot.closeLeafIx({ asset: c.asset, tree: c.tree, payer: me })]);
+      if (c.kind === 'walk') return this.walkFarm(c.key);
+      if (c.kind === 'vest' || c.kind === 'schedule') return this.runSchedule(c.key);
       if (c.kind === 'unlist') return this.unlist(c.asset);
       if (c.kind === 'lookup-table') {
         const table = readTable(await client.account(c.table));
@@ -2051,41 +2743,95 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         if (!step || step === 'cooling') return null;
         return send([step === 'close' ? closeTableIx({ table: c.table, authority: me }) : deactivateTableIx({ table: c.table, authority: me })], [], { keepWrapped: true });
       }
+      if (!LOTTERY_STEPS.has(c.kind)) throw new Error(`Nothing to do for a claim of kind ${c.kind}.`);
       const l = part('lotteries', c.key);
-      if (c.kind === 'reveal') return send([loot.drawLotteryIx({ payer: me, project, id: l.id })]);
-      if (c.kind === 'cancel-draw') return send([loot.cancelLotteryIx({ project, id: l.id })]);
-      if (c.kind === 'lottery-prize') {
-        const { lottery, contributions } = await roundOf(l);
-        const found = contributions.find(({ address }) => address === c.contribution);
-        if (!found || loot.lotteryStep(lottery, found.value) !== 'prizes') return null;
-        const given = await prizeInputs(lottery.places.map((p) => p.prize), me, found.value.player);
-        return send([computeUnitLimit(600_000), ...given.before.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM), loot.finishLotteryContributionIx({ payer: me, project, id: l.id, lottery, contributionAddress: found.address, contribution: found.value, collection: given.collection, poolMints: given.poolMints, items: given.items, nfts: given.nfts, programs })]);
+      // An older round, named by its address, needs no lottery: one closed since never strands it.
+      const lottery = c.round ? await readMaybe('Lottery', loot.pda.lottery(project, l.id)) : await read('Lottery', loot.pda.lottery(project, l.id));
+      const key = c.round ?? loot.currentRound(loot.pda.lottery(project, l.id), lottery);
+      const found = await client.account(key);
+      const r = found?.owner === loot.LOOT_PROGRAM ? loot.decodeRound(found.data) : null;
+      // The ask: the current round's once due, or an older round's again (after the timeout, it cancels the round).
+      if (c.kind === 'reveal' || c.kind === 'cancel-draw') {
+        const steps = await drawStep(l, lottery, c.round ?? null, r, me);
+        // A draw that cancels the round (short of its least tickets, or the oracle never answered by the timeout)
+        // refunds in the same transaction: this wallet's own parts are pulled right after it.
+        const refunds = r ? await cancelPulls(key, r, me) : [];
+        if (refunds.length) {
+          const all = [computeUnitLimit(1_400_000), ...[...steps, ...refunds].filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM)];
+          if ((await dryRun(me, all)).ok) return build ? all : send(all);
+        }
+        return build ? steps : send(steps);
+      }
+      if (!r) return null;
+      // Pulls: this wallet's own parts, or (`payout`) everyone's and the parts owed in common, a few to a transaction;
+      // when they are the last owed, the last pull closes the round. A round that owes nothing is only closed.
+      // A named stash NFT that is gone refuses a stranger's pull: only its winner or a project key passes it over.
+      const projectKey = me === g.owner || me === g.authority;
+      const stranger = async (i, p) => {
+        const named = p.Prize ? r.terms.places[Number(p.Prize[0])].prize?.Nft : null;
+        if (!named || projectKey || r.entries[i].buyer === me) return false;
+        const stash = loot.decodeStash((await client.account(loot.pda.stash(project, named.stash)))?.data ?? null);
+        return !stash?.nfts.includes(named.nft);
+      };
+      const theirs = [];
+      if (c.kind !== 'pull') for (const i of r.entries.keys()) {
+        const parts = [];
+        for (const p of loot.partsOwed(r, i)) if (!(await stranger(i, p))) parts.push(p);
+        if (parts.length) theirs.push({ entry: i, parts });
       }
-      if (c.kind === 'complete-draw' || c.kind === 'ticket-refund') {
-        const { lottery, contributions } = await roundOf(l);
-        const found = contributions.find(({ address }) => address === c.contribution);
-        if (!found || found.value.done || lottery.status !== (c.kind === 'ticket-refund' ? 'Cancelled' : 'Drawn') || !loot.lotteryStep(lottery, found.value)) return null;
-        // A ticket an NFT paid for passes that NFT, which the project holds: back to its buyer when the round is
-        // cancelled or gives tickets back, to the wallet its price names when it is given on.
-        const then = lottery.status === 'Drawn' ? lottery.nft_ticket?.then : null;
-        // Given to a wallet that is an account of the loot program, it goes back to its buyer.
-        const handBack = Boolean(then?.Give) && loot.handsBack(await client.account(then.Give[0]));
-        const to = !then || handBack ? found.value.player : then.Give ? then.Give[0] : undefined;
-        const { before = [], hasAuthority: _, ...ticket } = found.value.asset !== NOBODY ? await nftOf(found.value.asset, me, { to }) : {};
-        return send([...before, loot.finishLotteryContributionIx({ payer: me, project, id: l.id, lottery, contributionAddress: found.address, contribution: found.value, treasury: g.treasury, ticket, handBack, programs })]);
+      const owed = c.kind === 'pull' ? c.pulls : [...loot.commonOwed(r).map((p) => ({ entry: null, parts: [p] })), ...theirs];
+      if (!owed.length) {
+        if (!loot.roundFinished(r)) return null;
+        const close = [loot.pullIx({ payer: me, project, roundAddress: key, round: r, projectState: g, programs })];
+        return build ? close : send(close);
       }
-      if (c.kind === 'prize' || c.kind === 'payout') {
-        // Every unpaid winner, three a transaction, each paid every place's share of the pot they won (their prizes went
-        // first): the round ends once all are paid, and the next opens. Each winner's account of the pot's mint is
-        // opened when they have none, paid by whoever sends it.
-        const { lottery, winners } = await roundOf(l);
-        const mine = winners.filter((w) => w.winner === me);
-        const chosen = [...mine, ...winners.filter((w) => w.winner !== me)].slice(0, 3);
-        if (!chosen.length) return null;
-        const pay = (w) => loot.finishLotteryContributionIx({ payer: me, project, id: l.id, lottery, contributionAddress: w.contribution.address, contribution: w.contribution.value, treasury: g.treasury, programs });
-        return send(chosen.map(pay));
+      const batch = owed.slice(0, 4);
+      const settles = batch.reduce((n, { entry, parts }) => n + parts.reduce((m, p) => m + pullSettles(r, entry, p), 0), 0);
+      const closes = settles >= Number(r.owed);
+      const instructions = [computeUnitLimit(1_400_000)];
+      const rolls = [];
+      for (const [k, { entry, parts }] of batch.entries()) {
+        const built = await pulls(key, r, entry, parts, me, { closes: closes && k === batch.length - 1 });
+        instructions.push(...built.instructions.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM));
+        rolls.push(...built.rolls);
       }
-      throw new Error(`Nothing to do for a claim of kind ${c.kind}.`);
+      // A place's roll is asked for in the pull's own transaction (catalog P1): the winner's own, with a key that settles
+      // it after (one prompt); someone else's, asked for when the box can give, else left for its winner to ask.
+      if (!rolls.length) return build ? instructions : send(instructions);
+      if (c.kind === 'pull' && !build) return (await sendRolling(instructions)).signature;
+      const asks = [];
+      for (const { order, box } of rolls) asks.push(...(await asksFor(me, order, { project, loot_box: loot.pda.box(project, box) })));
+      const all = [...instructions, ...asks];
+      const asked = (await dryRun(me, all)).ok ? all : instructions;
+      return build ? asked : send(asked);
+    },
+
+    /**
+     * Everything in `list` (by default `claims()`) taken in as few prompts as it can: each step that is one transaction
+     * of the wallet's is built first and the lot signed in one prompt when the wallet signs several at once
+     * (`wallet.signTransactions`); a lottery's steps depend on each other, so one of each lottery a call. The rest (a roll
+     * to settle, a refund, an auction to end…) go one by one after. Returns [{ claim, signature } | { claim, error }].
+     */
+    async claimAll(list) {
+      list ??= await this.claims();
+      const [built, alone, lotteries] = [[], [], new Set()];
+      const out = [];
+      for (const c of list) {
+        if (!BATCHED.has(c.kind)) {
+          alone.push(c);
+          continue;
+        }
+        const lottery = LOTTERY_STEPS.has(c.kind) ? c.key : null;
+        if (lottery !== null && lotteries.has(lottery)) continue;
+        const instructions = await this.claim(c, { build: true }).catch((e) => (out.push({ claim: c, error: e.message }), null));
+        if (!instructions?.length) continue;
+        if (lottery !== null) lotteries.add(lottery);
+        built.push([c, instructions]);
+      }
+      const sent = await sendBatch(built.map(([, instructions]) => instructions));
+      out.push(...built.map(([claim], i) => ({ claim, ...sent[i] })));
+      for (const claim of alone) out.push(await this.claim(claim).then((signature) => ({ claim, signature }), (e) => ({ claim, error: e.message })));
+      return out;
     },
 
     /** The player's collectibles of this project: [{ asset, item, itemId, name, uri, attributes, frozen }]. `item` is its key in the spec. */