@xgamesfun/solana 0.20.1 → 0.25.0

package/js/play/index.js

@@ -20,43 +20,86 @@
 // `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 { 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 { 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';
 import { MEMO_PROGRAM, mintPowers, resolveTransfers } from '../chain/token2022.js';
-import { compileFitting, closeTableIx, deactivateTableIx, readTable, sendFitting, sendPlan, slotHashes, tablesOf, tableStep, transactionLocks, LOOKUP_TABLE_PROGRAM } from '../chain/lookup.js';
+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';
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const sleep = ms => new Promise(r => setTimeout(r, ms));
 const MPL_CORE = loot.MPL_CORE_PROGRAM;
 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;
+          },
+        }
+      : {}),
   };
 }
 
@@ -64,7 +107,10 @@ export function walletStandardSigner(wallet, account, chain = CHAIN) {
 async function freshKey() {
   const pair = await globalThis.crypto.subtle.generateKey({ name: 'Ed25519' }, false, ['sign', 'verify']);
   const raw = new Uint8Array(await globalThis.crypto.subtle.exportKey('raw', pair.publicKey));
-  return { address: encodeBase58(raw), sign: async (message) => new Uint8Array(await globalThis.crypto.subtle.sign('Ed25519', pair.privateKey, message)) };
+  return {
+    address: encodeBase58(raw),
+    sign: async message => new Uint8Array(await globalThis.crypto.subtle.sign('Ed25519', pair.privateKey, message)),
+  };
 }
 
 /**
@@ -73,17 +119,28 @@ async function freshKey() {
  * some other amount.
  */
 export const units = (amount, decimals) => {
-  const text = typeof amount === 'number' && Number.isFinite(amount) && amount >= 0 ? plainNumber(amount) : typeof amount === 'string' ? amount.trim() : null;
+  const text =
+    typeof amount === 'number' && Number.isFinite(amount) && amount >= 0
+      ? plainNumber(amount)
+      : typeof amount === 'string'
+        ? amount.trim()
+        : null;
   const m = text === null ? null : /^(\d+)(?:\.(\d+))?$/.exec(text);
-  if (!m) throw new Error(`${typeof amount === 'string' ? JSON.stringify(amount) : String(amount)} is not an amount: write a plain number like 12 or 0.5.`);
+  if (!m)
+    throw new Error(
+      `${typeof amount === 'string' ? JSON.stringify(amount) : String(amount)} is not an amount: write a plain number like 12 or 0.5.`,
+    );
   const fraction = m[2] ?? '';
-  if (fraction.length > decimals && /[1-9]/.test(fraction.slice(decimals))) throw new Error(`${text} has more decimals than the token's ${decimals}.`);
+  if (fraction.length > decimals && /[1-9]/.test(fraction.slice(decimals)))
+    throw new Error(`${text} has more decimals than the token's ${decimals}.`);
   return BigInt(m[1] + fraction.padEnd(decimals, '0').slice(0, decimals));
 };
 /** A number as plain decimal text (1e-7 → "0.0000001"). */
-const plainNumber = (n) => (/e/i.test(String(n)) ? n.toFixed(20).replace(/\.?0+$/, '') : String(n));
+const plainNumber = n => (/e/i.test(String(n)) ? n.toFixed(20).replace(/\.?0+$/, '') : String(n));
 const show = (u, decimals) => {
-  const s = BigInt(u).toString().padStart(decimals + 1, '0');
+  const s = BigInt(u)
+    .toString()
+    .padStart(decimals + 1, '0');
   const f = s.slice(s.length - decimals).replace(/0+$/, '');
   return `${s.slice(0, s.length - decimals)}${f ? `.${f}` : ''}`;
 };
@@ -99,17 +156,20 @@ function devnetOnly(client) {
   if (!/^(https?|wss?):/i.test(String(client.url ?? ''))) return client;
   let checked = null;
   // A check that could not be made (the network did not answer) is made again on the next request.
-  const ready = () => (checked ??= checkCluster(client).catch((e) => {
-    checked = null;
-    throw e;
-  }));
+  const ready = () =>
+    (checked ??= checkCluster(client).catch(e => {
+      checked = null;
+      throw e;
+    }));
   return new Proxy(client, {
     get(target, key) {
       const value = Reflect.get(target, key, target);
-      return typeof value === 'function' ? async (...args) => {
-        await ready();
-        return value.apply(target, args);
-      } : value;
+      return typeof value === 'function'
+        ? async (...args) => {
+            await ready();
+            return value.apply(target, args);
+          }
+        : value;
     },
   });
 }
@@ -118,32 +178,54 @@ 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.');
+  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);
-  const tokens = new Map((spec.tokens ?? []).map((t) => [t.key, t]));
+  const ours = collection => collection != null && collections.includes(collection);
+  const tokens = new Map((spec.tokens ?? []).map(t => [t.key, t]));
   const currencyKey = spec.currency;
-  const mintOf = (key) => {
+  const mintOf = key => {
     const t = tokens.get(key ?? currencyKey);
     if (!t) throw new Error(`No token “${key}”.`);
-    return t.source === 'sol' ? NATIVE_MINT : spec.live.mints?.[t.key] ?? t.mint;
+    return t.source === 'sol' ? NATIVE_MINT : (spec.live.mints?.[t.key] ?? t.mint);
   };
-  const decimalsOf = (key) => {
+  const decimalsOf = key => {
     const t = tokens.get(key ?? currencyKey);
-    return t?.source === 'sol' ? 9 : t?.decimals ?? 0;
+    return t?.source === 'sol' ? 9 : (t?.decimals ?? 0);
+  };
+  programs = {
+    ...Object.fromEntries(
+      [...tokens.values()].map(t => [mintOf(t.key), t.program === 'token-2022' ? TOKEN_2022_PROGRAM : TOKEN_PROGRAM]),
+    ),
+    ...programs,
   };
-  programs = { ...Object.fromEntries([...tokens.values()].map(t => [mintOf(t.key), t.program === 'token-2022' ? TOKEN_2022_PROGRAM : TOKEN_PROGRAM])), ...programs };
-  const programOf = (mint) => programs[mint] ?? TOKEN_PROGRAM;
+  const programOf = mint => programs[mint] ?? TOKEN_PROGRAM;
   const part = (list, key) => {
-    const p = (spec[list] ?? []).find((x) => x.key === key);
+    const p = (spec[list] ?? []).find(x => x.key === key);
     if (!p) throw new Error(`No ${list.replace(/s$/, '')} “${key}” in this economy.`);
     return p;
   };
@@ -159,47 +241,61 @@ 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 = {} } = {}) => {
     const selected = [...new Set(mints)];
-    const resolved = await Promise.all(selected.map(async (mint) => {
-      if (extra !== undefined) {
-        const account = await client.account(mint);
-        if (![TOKEN_PROGRAM, TOKEN_2022_PROGRAM].includes(account?.owner)) throw new Error(`There is no supported token ${mint} on this network.`);
-        return { mint, tokenProgram: account.owner, extraAccounts: [] };
-      }
-      try {
-        return { mint, ...await resolveTransfers(client, mint, transfers[mint] ?? []) };
-      } catch (cause) {
-        throw new Error(`Cannot resolve farm transfers for ${mint}: ${cause.message} Supply exact transfers keyed by mint, or explicit extra hook/memo accounts.`, { cause });
-      }
-    }));
-    const tokenPrograms = { ...programs, ...Object.fromEntries(resolved.map(({ mint, tokenProgram }) => [mint, tokenProgram])) };
+    const resolved = await Promise.all(
+      selected.map(async mint => {
+        if (extra !== undefined) {
+          const account = await client.account(mint);
+          if (![TOKEN_PROGRAM, TOKEN_2022_PROGRAM].includes(account?.owner))
+            throw new Error(`There is no supported token ${mint} on this network.`);
+          return { mint, tokenProgram: account.owner, extraAccounts: [] };
+        }
+        try {
+          return { mint, ...(await resolveTransfers(client, mint, transfers[mint] ?? [])) };
+        } catch (cause) {
+          throw new Error(
+            `Cannot resolve farm transfers for ${mint}: ${cause.message} Supply exact transfers keyed by mint, or explicit extra hook/memo accounts.`,
+            { cause },
+          );
+        }
+      }),
+    );
+    const tokenPrograms = {
+      ...programs,
+      ...Object.fromEntries(resolved.map(({ mint, tokenProgram }) => [mint, tokenProgram])),
+    };
     return {
       programs: tokenPrograms,
-      extra: extra ?? resolved.flatMap((r) => r.extraAccounts),
-      before: [...new Set(create)].map((mint) => createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, mint, tokenPrograms[mint])),
+      extra: extra ?? resolved.flatMap(r => r.extraAccounts),
+      before: [...new Set(create)].map(mint =>
+        createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, mint, tokenPrograms[mint]),
+      ),
     };
   };
-  const farmCollection = async (asset) => {
+  const farmCollection = async asset => {
     const account = await client.account(asset);
     // Core tombstones and missing assets remain valid farm-cleanup paths.
     return account?.owner === MPL_CORE && account.data[0] === 1
-      ? parseCoreAsset(account.data).collection ?? collections[0]
+      ? (parseCoreAsset(account.data).collection ?? collections[0])
       : collections[0];
   };
   /** The Core collection an asset is in, or null. */
-  const collectionOf = async (asset) => {
+  const collectionOf = async asset => {
     const account = await client.account(asset);
-    return account?.owner === MPL_CORE && account.data[0] === 1 ? parseCoreAsset(account.data).collection ?? null : null;
+    return account?.owner === MPL_CORE && account.data[0] === 1
+      ? (parseCoreAsset(account.data).collection ?? null)
+      : null;
   };
   /** A Token Metadata NFT's { programmable, ruleSet } from its metadata, or null for anything else (a Core asset). */
-  const tokenMetadataOf = async (asset) => {
+  const tokenMetadataOf = async asset => {
     const account = await client.account(asset);
     if (account?.owner !== TOKEN_PROGRAM) return null;
     return loot.decodeTokenMetadata((await client.account(loot.tokenMetadata.metadata(asset)))?.data);
@@ -220,7 +316,9 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const fresh = loot.freshNftAccount({ payer, holder, mint: asset, index, there: await client.account(address) });
       if (fresh) return { into: fresh.address, before: fresh.instructions };
     }
-    throw new Error(`${holder}'s accounts of the NFT ${asset} can't take it (owned by another key, or frozen), and no fresh one could be opened.`);
+    throw new Error(
+      `${holder}'s accounts of the NFT ${asset} can't take it (owned by another key, or frozen), and no fresh one could be opened.`,
+    );
   }
   /**
    * What a route needs of an NFT, whatever its kind: { collection, hasAuthority, tokenMetadata, compressed, before }.
@@ -237,12 +335,19 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         const proof = await client.call('getAssetProof', { id: asset });
         const tree = await client.account(das.compression.tree);
         const compressed = loot.compressedFromDas({ asset: das, proof, treeData: tree.data });
-        return { compressed, hasAuthority: false, before: [computeUnitLimit(1_000_000), loot.proveLeafIx({ signer, compressed })] };
+        return {
+          compressed,
+          hasAuthority: false,
+          before: [computeUnitLimit(1_000_000), loot.proveLeafIx({ signer, compressed })],
+        };
       }
     }
     const tokenMetadata = await tokenMetadataOf(asset);
     // A Token Metadata mint is taken only as an NFT: one token, no decimals, none more ever minted (NotAnNft).
-    if (tokenMetadata && account && !loot.isNftMint(asset, account.data)) throw new Error(`${asset} is a semi-fungible item (several units, or a mint that can still mint): only an NFT is taken.`);
+    if (tokenMetadata && account && !loot.isNftMint(asset, account.data))
+      throw new Error(
+        `${asset} is a semi-fungible item (several units, or a mint that can still mint): only an NFT is taken.`,
+      );
     const { into, before } = tokenMetadata && to ? await nftInto(asset, to, payer) : { into: null, before: [] };
     return {
       collection: await farmCollection(asset),
@@ -255,17 +360,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));
@@ -285,39 +385,75 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     return out;
   }
   /** The Sheet the project keeps of an NFT it has no authority over: { key: value } of what the project wrote. */
-  const sheetOf = async (nft) => {
+  const sheetOf = async nft => {
     const found = await client.account(loot.pda.sheet(project, nft));
-    return Object.fromEntries((loot.decodeSheet(found?.owner === loot.LOOT_PROGRAM ? found.data : null)?.attributes ?? []).map((a) => [a.key, a.value]));
+    return Object.fromEntries(
+      (loot.decodeSheet(found?.owner === loot.LOOT_PROGRAM ? found.data : null)?.attributes ?? []).map(a => [
+        a.key,
+        a.value,
+      ]),
+    );
   };
   let projectState = null;
   const projectNow = async () => (projectState ??= await read('Project', project));
   /** A spec auction's address: it names the seller, which xsolana.json records once it is live. */
-  const auctionAt = (a) => {
+  const auctionAt = a => {
     if (!a.seller) throw new Error(`The auction “${a.key}” has no seller in xsolana.json: publish the economy again.`);
     return loot.pda.auction(project, a.seller, a.id);
   };
 
-  const itemKeyOf = (id) => (spec.items ?? []).find((it) => it.id === Number(id))?.key ?? null;
+  const itemKeyOf = id => (spec.items ?? []).find(it => it.id === Number(id))?.key ?? null;
   /** Who holds a collectible now. */
-  const ownerOf = async (asset) => parseCoreAsset((await client.account(asset)).data).owner;
+  const ownerOf = async asset => parseCoreAsset((await client.account(asset)).data).owner;
   /** `{ asset, farm }` for a Core asset on its seat in one of the economy's farms of these custodies, or null. */
   const seatedIn = async (asset, custodies = ['escrow', 'freeze']) => {
-    for (const f of (spec.farms ?? []).filter((x) => x.stakes === 'collectibles' && custodies.includes(x.custody ?? 'escrow'))) {
+    for (const f of (spec.farms ?? []).filter(
+      x => x.stakes === 'collectibles' && custodies.includes(x.custody ?? 'escrow'),
+    )) {
       if (await readMaybe('Seat', loot.pda.seat(loot.pda.farm(project, f.id), asset))) return { asset, farm: f.id };
     }
+    // Or boosting the player's token seat in a farm of tokens: that seat, not one of its own (`booster`).
+    for (const f of (spec.farms ?? []).filter(
+      x => x.stakes !== 'collectibles' && custodies.includes(x.custody ?? 'escrow'),
+    )) {
+      const seat = wallet?.address
+        ? await readMaybe('Seat', loot.pda.seat(loot.pda.farm(project, f.id), wallet.address))
+        : null;
+      if (seat?.asset === asset) return { asset, farm: f.id, booster: true };
+    }
     return null;
   };
   /** The same for one the project holds: staked in escrow. */
-  const escrowedIn = async (asset) => ((await ownerOf(asset).catch(() => null)) === project ? seatedIn(asset, ['escrow']) : null);
+  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();
+    const found = (
+      await Promise.all(collections.map(c => client.programAccounts(MPL_CORE, ownedAssetFilters(owner, c))))
+    ).flat();
     return found.map(({ pubkey, account }) => {
       const a = parseCoreAsset(account.data);
       const itemId = a.attributes?.item_id !== undefined ? Number(a.attributes.item_id) : null;
       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
@@ -334,14 +470,18 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     if (gate.Staked) {
       const { farm, at_least: atLeast } = gate.Staked;
       const seat = await readMaybe('Seat', loot.pda.seat(farm, wallet.address));
-      const f = (spec.farms ?? []).find((x) => loot.pda.farm(project, x.id) === farm);
+      const f = (spec.farms ?? []).find(x => loot.pda.farm(project, x.id) === farm);
       const t = f ? tokens.get(f.stakes) : null;
       const needs = t ? `${show(atLeast, decimalsOf(t.key))} ${t.symbol ?? t.key}` : `${atLeast} (in base units)`;
       const where = f ? `“${f.name}”` : 'its farm';
-      if (!seat || BigInt(seat.amount) < BigInt(atLeast)) throw new Error(`You need at least ${needs} staked in ${where} to ${what}.`);
+      if (!seat || BigInt(seat.amount) < BigInt(atLeast))
+        throw new Error(`You need at least ${needs} staked in ${where} to ${what}.`);
       // Only a locked stake counts: its tier's lock still running.
       const lock = BigInt((await read('Farm', farm)).tiers[seat.tier]?.lock ?? 0);
-      if (lock === 0n || BigInt(now()) >= BigInt(seat.since) + lock) throw new Error(`Your stake in ${where} counts only while it is locked: stake in a tier with a lock (staking again starts a new one) to ${what}.`);
+      if (lock === 0n || BigInt(now()) >= BigInt(seat.since) + lock)
+        throw new Error(
+          `Your stake in ${where} counts only while it is locked: stake in a tier with a lock (staking again starts a new one) to ${what}.`,
+        );
       return null;
     }
     if (gate.Wallets) {
@@ -353,30 +493,38 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     if (!rules.length) return null;
     const rule = rules[0];
     const atLeast = rule.test?.AtLeast?.[0];
-    const equals = rule.test?.Equals?.text;
+    const equals = rule.test?.OneOf?.texts?.length === 1 ? rule.test.OneOf.texts[0] : undefined;
     const item = rule.of?.Item?.[0];
-    const named = rules.map((r) => r.of?.Collection?.[0]).find((c) => c && !ours(c));
+    const named = rules.map(r => r.of?.Collection?.[0]).find(c => c && !ours(c));
     const other = named ?? null;
     const passes = (r, c) => {
       if (r.of?.Item?.[0] !== undefined && c.itemId !== Number(r.of.Item[0])) return false;
       const value = c.attributes?.[r.key];
       if (r.test?.AtLeast?.[0] !== undefined) return Number(value) >= Number(r.test.AtLeast[0]);
-      if (r.test?.Equals?.text !== undefined) return String(value) === String(r.test.Equals.text);
+      if (r.test?.OneOf?.texts)
+        return r.test.OneOf.texts.map(String).includes(String(r.key === 'item_id' ? c.itemId : value));
       return true;
     };
-    const pass = (c) => rules.every((r) => passes(r, c));
+    const pass = c => rules.every(r => passes(r, c));
     if (other) {
       const found = await client.programAccounts(MPL_CORE, ownedAssetFilters(wallet.address, other));
       for (const { pubkey, account } of found) {
         const a = parseCoreAsset(account.data);
         if (pass({ attributes: { ...a.attributes, ...(await sheetOf(pubkey)) } })) return { asset: pubkey };
       }
-      throw new Error(`You need an NFT of the collection ${other}${atLeast !== undefined ? ` with ${rule.key} ${atLeast} or more` : equals !== undefined ? ` whose ${rule.key} is ${equals}` : ''} to ${what}.`);
+      throw new Error(
+        `You need an NFT of the collection ${other}${atLeast !== undefined ? ` with ${rule.key} ${atLeast} or more` : equals !== undefined ? ` whose ${rule.key} is ${equals}` : ''} to ${what}.`,
+      );
     }
     const found = (await owned()).find(pass);
     if (found) return found.asset;
-    const needs = item !== undefined ? `a ${(spec.items ?? []).find((it) => it.id === Number(item))?.name ?? 'collectible of this project'}` : 'a collectible of this project';
-    throw new Error(`You need ${needs}${atLeast !== undefined ? ` with ${rule.key} ${atLeast} or more` : equals !== undefined ? ` whose ${rule.key} is ${equals}` : ''} to ${what}.`);
+    const needs =
+      item !== undefined
+        ? `a ${(spec.items ?? []).find(it => it.id === Number(item))?.name ?? 'collectible of this project'}`
+        : 'a collectible of this project';
+    throw new Error(
+      `You need ${needs}${atLeast !== undefined ? ` with ${rule.key} ${atLeast} or more` : equals !== undefined ? ` whose ${rule.key} is ${equals}` : ''} to ${what}.`,
+    );
   }
 
   /**
@@ -399,13 +547,17 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    */
   async function unwrapAfter(instructions) {
     const wrapped = associatedTokenAddress(wallet.address, NATIVE_MINT);
-    const opens = instructions.some((ix) => ix.programId === ASSOCIATED_TOKEN_PROGRAM && ix.keys[1]?.pubkey === wrapped);
-    const closes = instructions.some((ix) => ix.programId === TOKEN_PROGRAM && ix.data?.[0] === 9 && ix.keys[0]?.pubkey === wrapped);
+    const opens = instructions.some(ix => ix.programId === ASSOCIATED_TOKEN_PROGRAM && ix.keys[1]?.pubkey === wrapped);
+    const closes = instructions.some(
+      ix => ix.programId === TOKEN_PROGRAM && ix.data?.[0] === 9 && ix.keys[0]?.pubkey === wrapped,
+    );
     if (closes) return instructions;
     const close = closeTokenAccount(wrapped, wallet.address, wallet.address);
     if (opens || (await client.account(wrapped))) return [...instructions, close];
-    const touches = instructions.some((ix) => ix.keys?.some((k) => k.pubkey === wrapped));
-    return touches ? [createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, NATIVE_MINT), ...instructions, close] : instructions;
+    const touches = instructions.some(ix => ix.keys?.some(k => k.pubkey === wrapped));
+    return touches
+      ? [createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, NATIVE_MINT), ...instructions, close]
+      : instructions;
   }
 
   /**
@@ -414,18 +566,98 @@ 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 sign = async message => {
       const { signers } = readTransaction(wireTransaction(message));
-      const sigs = await Promise.all(signers.map(async (s) => (extra.find((k) => k.address === s) ? extra.find((k) => k.address === s).sign(message) : new Uint8Array(64))));
+      const sigs = await Promise.all(
+        signers.map(async s =>
+          extra.find(k => k.address === s) ? extra.find(k => k.address === s).sign(message) : new Uint8Array(64),
+        ),
+      );
       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,20 +666,42 @@ 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));
+    const failed = e?.logs?.find(line => / failed: custom program error: 0x/i.test(line));
     const known = m && (!failed || failed.includes(loot.LOOT_PROGRAM)) ? loot.ERRORS[parseInt(m[1], 16)] : null;
     if (!known) throw e;
-    throw Object.assign(new Error(`${known.msg} (${known.name}).`, { cause: e }), { code: parseInt(m[1], 16), name: known.name, logs: e.logs });
+    throw Object.assign(new Error(`${known.msg} (${known.name}).`, { cause: e }), {
+      code: parseInt(m[1], 16),
+      name: known.name,
+      logs: e.logs,
+    });
   }
 
   /**
-   * 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;
   }
 
   /**
@@ -458,30 +712,191 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     const prize = farm.tiers[tier]?.prize ?? null;
     const given = await prizeInputs([prize]);
     // The rewards' accounts as the stake resolved them (a hook that needs each transfer named is sized without them).
-    const token = { ...staking, before: [createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, farm.rewards_mint, staking.programs[farm.rewards_mint] ?? TOKEN_PROGRAM)] };
-    const exit = (forfeit) => [...before, ...(forfeit ? [] : [...given.before, ...token.before]), loot.unstakeNftIx({ player: wallet.address, project, id: f.id, farm, asset, ...nft, forfeit, roll: farm.tiers[tier]?.roll ?? null, nonce: 1n, tier, projectCollection: given.collection, poolMints: given.poolMints, items: given.items, nft: given.nft, ...token })];
+    const token = {
+      ...staking,
+      before: [
+        createAssociatedTokenAccountIdempotent(
+          wallet.address,
+          wallet.address,
+          farm.rewards_mint,
+          staking.programs[farm.rewards_mint] ?? TOKEN_PROGRAM,
+        ),
+      ],
+    };
+    const exit = forfeit => [
+      ...before,
+      ...(forfeit ? [] : [...given.before, ...token.before]),
+      loot.unstakeNftIx({
+        player: wallet.address,
+        project,
+        id: f.id,
+        farm,
+        asset,
+        ...nft,
+        forfeit,
+        roll: farm.tiers[tier]?.roll ?? null,
+        nonce: 1n,
+        tier,
+        projectCollection: given.collection,
+        poolMints: given.poolMints,
+        items: given.items,
+        nft: given.nft,
+        ...token,
+      }),
+    ];
     for (const forfeit of [false, true]) {
-      const instructions = exit(forfeit).filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM);
-      if (!sendPlan({ payer: wallet.address, instructions: [computeUnitLimit(1_400_000), ...instructions], alone: isProveLeaf }))
-        throw new Error(`Not staked: this NFT couldn't come back out of “${f.name ?? f.key}”. Its unstake${forfeit ? ', even giving up the rewards,' : ''} would lock more accounts than one transaction can (${transactionLocks(wallet.address, [computeUnitLimit(1_400_000), ...instructions], { asV0: true })} with its lookup table; at most 64), so it would stay in the farm.`);
+      const instructions = exit(forfeit).filter(x => x.programId !== COMPUTE_BUDGET_PROGRAM);
+      if (
+        !sendPlan({
+          payer: wallet.address,
+          instructions: [computeUnitLimit(1_400_000), ...instructions],
+          alone: isProveLeaf,
+        })
+      )
+        throw new Error(
+          `Not staked: this NFT couldn't come back out of “${f.name ?? f.key}”. Its unstake${forfeit ? ', even giving up the rewards,' : ''} would lock more accounts than one transaction can (${transactionLocks(wallet.address, [computeUnitLimit(1_400_000), ...instructions], { asV0: true })} with its lookup table; at most 64), so it would stay in the farm.`,
+        );
     }
   }
 
   /** 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 +905,17 @@ 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);
-      if (!(await client.account(orderAddress))) return { order: orderAddress, settled: 'elsewhere', says: 'The order was settled already.' };
+      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 +930,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,14 +939,31 @@ 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).' };
+      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.' };
     }
-    if (order.status === 'Pending') throw new Error('The oracle has not rolled yet: try collecting again in a minute (an order never rolled refunds after about 10 minutes).');
-    if (order.status === 'Asked') throw new Error('The oracle has not rolled yet: try collecting again in a minute (a roll never answered is asked again after about 10 minutes).');
+    if (order.status === 'Pending')
+      throw new Error(
+        'The oracle has not rolled yet: try collecting again in a minute (an order never rolled refunds after about 10 minutes).',
+      );
+    if (order.status === 'Asked')
+      throw new Error(
+        'The oracle has not rolled yet: try collecting again in a minute (a roll never answered is asked again after about 10 minutes).',
+      );
     if (order.status === 'Failed') throw new Error('The roll failed (the box changed or ran out): refund the order.');
     // An order closes only in a later slot than the one it was opened in.
     for (let i = 0; i < 20 && client.call; i++) {
@@ -544,64 +975,157 @@ 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.
-          const { before, hasAuthority: _, ...kind } = await nftOf(won.Nft.nft, signer, { to: order.player, payer: wallet.address });
+          // 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 });
-      return { ix, nfts, before: [...subjectProof, ...proving].filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM) };
+      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,19 +1133,69 @@ 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))];
-    const pools = prizePools.length ? await client.accounts(prizePools.map((p) => loot.pda.pool(project, p))) : [];
-    return Object.fromEntries(prizePools.map((p, i) => [p, pools[i] ? encodeBase58(pools[i].data.subarray(0, 32)) : null]));
+    const prizePools = [
+      ...new Set(
+        box.entries
+          .flatMap(e => e.prizes)
+          .map(p => p.Tokens?.from.Pool?.[0])
+          .filter(p => p !== undefined),
+      ),
+    ];
+    const pools = prizePools.length ? await client.accounts(prizePools.map(p => loot.pda.pool(project, p))) : [];
+    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))),
+    ]);
   }
 
   /**
@@ -631,11 +1205,18 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * the wallet is asked.
    */
   function boundOf(box, name, { maxPrice, listing } = {}, key) {
-    if (listing && key !== undefined && listing.key !== undefined && listing.key !== key) throw new Error(`That listing is “${listing.key}”, not “${key}”.`);
+    if (listing && key !== undefined && listing.key !== undefined && listing.key !== key)
+      throw new Error(`That listing is “${listing.key}”, not “${key}”.`);
     const given = maxPrice ?? listing?.priceUnits;
-    if (given === undefined || given === null) throw new Error(`Say the most the player agreed to pay for “${name}”: pass the listing shop() or boxes() showed (listing), or maxPrice in base units. The price read now is never the bound.`);
+    if (given === undefined || given === null)
+      throw new Error(
+        `Say the most the player agreed to pay for “${name}”: pass the listing shop() or boxes() showed (listing), or maxPrice in base units. The price read now is never the bound.`,
+      );
     const bound = BigInt(given);
-    if (BigInt(box.price) > bound) throw new Error(`The price of “${name}” is now ${show(box.price, decimalsOf(box.currencyKey))}, more than the ${show(bound, decimalsOf(box.currencyKey))} the player was shown: show them the new price first.`);
+    if (BigInt(box.price) > bound)
+      throw new Error(
+        `The price of “${name}” is now ${show(box.price, decimalsOf(box.currencyKey))}, more than the ${show(bound, decimalsOf(box.currencyKey))} the player was shown: show them the new price first.`,
+      );
     return bound;
   }
 
@@ -645,48 +1226,100 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * was given, or what is left of it once the options it takes are read; `takes`: those it takes, said in the error.
    */
   function only(options, takes, method) {
-    const unknown = Object.keys(options ?? {}).filter((k) => !takes.includes(k) && options[k] !== undefined);
+    const unknown = Object.keys(options ?? {}).filter(k => !takes.includes(k) && options[k] !== undefined);
     if (!unknown.length) return;
-    const hint = unknown.includes('choice') && takes.includes('chosenRecipient') ? ' (a buyer’s choice is `chosenRecipient`)' : '';
-    throw new Error(`${method} doesn’t take ${unknown.map((k) => `“${k}”`).join(', ')}${hint}. It takes: ${takes.join(', ')}.`);
+    const hint =
+      unknown.includes('choice') && takes.includes('chosenRecipient') ? ' (a buyer’s choice is `chosenRecipient`)' : '';
+    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;
     const [entry] = box.entries;
     const given = await prizeInputs(entry.prizes);
     const nonce = freshNonce();
-    const choosesHolder = box.shares.some((s) => s.to.Chosen && s.to.Chosen.item != null);
+    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];
         made[id] = (made[id] ?? 0) + 1;
-        return item?.kind === 'Collectible' ? loot.pda.itemAsset(loot.pda.item(project, id), Number(item.issued) + made[id]) : null;
+        return item?.kind === 'Collectible'
+          ? loot.pda.itemAsset(loot.pda.item(project, id), Number(item.issued) + made[id])
+          : null;
       }
       if (prize.Nft) return prize.Nft.nft;
       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,15 +1329,36 @@ 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: [] };
     const { before: proving, hasAuthority, ...kind } = brought;
-    const subject = box.subject ? { asset: on, hasAuthority, ...kind, collection: kind.collection ?? (await collectionOf(on)) ?? MPL_CORE } : undefined;
+    const subject = box.subject
+      ? { asset: on, hasAuthority, ...kind, collection: kind.collection ?? (await collectionOf(on)) ?? MPL_CORE }
+      : undefined;
     if (!box.subject) shown ??= await passing(box.gate, 'buy this');
     listProof = listProofOf(box.gate, part?.gate?.list, listProof);
     const mint = box.currency;
@@ -712,57 +1366,123 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     const nonce = box.subject && loot.boxHolds(box) ? loot.nonceOn(on) : freshNonce();
     // Each pool's mint, and each mint tokens are minted from: what is won waits in the project's vault for its mint.
     const poolMints = await poolMintsOf(box);
-    const minted = box.entries.flatMap((e) => e.prizes).map((p) => p.Tokens?.from.Mint?.[0]).filter(Boolean);
+    const minted = box.entries
+      .flatMap(e => e.prizes)
+      .map(p => p.Tokens?.from.Mint?.[0])
+      .filter(Boolean);
     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 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 });
-    const before = [...proving, createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, mint, programOf(mint))];
+    // 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)));
+        before.push(
+          createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, prizeMint, programOf(prizeMint)),
+        );
       }
       const shares = loot.chosenShares(box.shares, chosenRecipient);
       const holders = await holdersOf(shares);
-      const payees = shares.flatMap((s) => (s.to === 'Treasury' ? [g.treasury] : s.to.Wallet ? [s.to.Wallet[0]] : s.to.Holder && holders[s.to.Holder[0]] ? [holders[s.to.Holder[0]]] : []));
+      const payees = shares.flatMap(s =>
+        s.to === 'Treasury'
+          ? [g.treasury]
+          : s.to.Wallet
+            ? [s.to.Wallet[0]]
+            : s.to.Holder && holders[s.to.Holder[0]]
+              ? [holders[s.to.Holder[0]]]
+              : [],
+      );
       const paid = new Set([g.treasury, ...payees]);
-      for (const payee of paid) before.push(createAssociatedTokenAccountIdempotent(wallet.address, payee, mint, programOf(mint)));
+      for (const payee of paid)
+        before.push(createAssociatedTokenAccountIdempotent(wallet.address, payee, mint, programOf(mint)));
       // A sale that pays the player themselves (the owner buying from their own shop) pays into their wrapped-SOL
       // 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]);
-    if (solPrize) instructions = instructions.filter((x) => !(x.programId === TOKEN_PROGRAM && x.data?.[0] === 9 && x.keys[0]?.pubkey === associatedTokenAddress(wallet.address, NATIVE_MINT)));
+    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,
+    };
   }
 
   /**
@@ -771,27 +1491,51 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * program would refuse them too: TermsChanged).
    */
   async function shownListing(asset, listing, kind) {
-    if (!listing) throw new Error('Say the terms the player was shown: pass the listing listing() or listings() showed (listing). The listing read now is never signed in its place.');
+    if (!listing)
+      throw new Error(
+        'Say the terms the player was shown: pass the listing listing() or listings() showed (listing). The listing read now is never signed in its place.',
+      );
     if (listing.asset !== asset) throw new Error(`That listing is of ${listing.asset}, not ${asset}.`);
-    if (!listing.deal?.[kind]) throw new Error(kind === 'Sell' ? 'That listing is for rent, not for sale.' : 'That listing is for sale, not for rent.');
+    if (!listing.deal?.[kind])
+      throw new Error(
+        kind === 'Sell' ? 'That listing is for rent, not for sale.' : 'That listing is for sale, not for rent.',
+      );
     const listed = await readMaybe('Listing', loot.pda.listing(project, asset));
     if (!listed) throw new Error(`${asset} is not listed any more.`);
     const [was, is] = [loot.listingTerms(listing), loot.listingTerms(listed)];
-    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.');
+    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 +1547,34 @@ 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.
@@ -811,8 +1583,13 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     const at = await chainNow();
     if (loot.farmOpenFor(farm, tier, at)) return;
     const ends = new Date(Number(farm.ends_at) * 1000).toISOString();
-    if (at >= BigInt(farm.ends_at)) throw new Error(`“${f.name ?? f.key}” ended at ${ends}: it takes no stake any more. Stakes in it can still leave and harvest.`);
-    throw new Error(`“${f.name ?? f.key}” ends at ${ends}, and lock tier ${tier} would run past it: stake at a tier with a shorter lock.`);
+    if (at >= BigInt(farm.ends_at))
+      throw new Error(
+        `“${f.name ?? f.key}” ended at ${ends}: it takes no stake any more. Stakes in it can still leave and harvest.`,
+      );
+    throw new Error(
+      `“${f.name ?? f.key}” ends at ${ends}, and lock tier ${tier} would run past it: stake at a tier with a shorter lock.`,
+    );
   }
 
   /** Who holds each collectible a split's holder shares name now: { asset: holder }. */
@@ -823,19 +1600,246 @@ 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). A
+   * round paid from a pot first moves in what the round before left it (`lottery.owing`): that round's record says
+   * which pot (gone, any will do). */
+  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));
+    const first = !round || round.status === 'Open';
+    const owingAt =
+      first && lottery?.owing && lottery.owing !== NOBODY && loot.potIdOf(terms) != null
+        ? await client.account(lottery.owing)
+        : null;
+    const owing = owingAt?.owner === loot.LOOT_PROGRAM ? loot.decodeRound(owingAt.data) : null;
+    // That round's answer says what it left the pot: until it lands (or the round is cancelled), this draw waits.
+    if (owing?.status === 'Drawing')
+      throw new Error(
+        `The round of “${l.name ?? l.key}” before this one still waits for the oracle’s answer, and this round is paid from the same pot: its draw waits until that answer lands, or that round is cancelled (anyone may ask again after ${loot.STALE_SECONDS} seconds).`,
+      );
+    return [
+      computeUnitLimit(600_000),
+      loot.drawLotteryIx({
+        payer: signer,
+        project,
+        id: l.id,
+        lottery,
+        round,
+        roundAddress: key,
+        owing,
+        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), what the places leave (the
+        // pot, or the `rest` a round paid from its own money names), 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
+              ? loot.leftoverTo(r.lottery, r.terms)
+              : 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 {
@@ -846,24 +1850,47 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
 
     /** The shop: every item with a price (or free), its price now and what is left. */
     async shop() {
-      const items = (spec.items ?? []).filter((it) => Number.isInteger(it.shopBox));
-      const accounts = await client.accounts(items.flatMap((it) => [loot.pda.box(project, it.shopBox), loot.pda.item(project, it.id)]));
+      const items = (spec.items ?? []).filter(it => Number.isInteger(it.shopBox));
+      const accounts = await client.accounts(
+        items.flatMap(it => [loot.pda.box(project, it.shopBox), loot.pda.item(project, it.id)]),
+      );
       return items.map((it, i) => {
         const box = accounts[2 * i] && loot.decode('LootBox', accounts[2 * i].data);
         const item = accounts[2 * i + 1] && loot.decode('Item', accounts[2 * i + 1].data);
         const dec = decimalsOf(currencyKey);
-        return { key: it.key, name: it.name, price: box ? show(box.price, dec) : null, priceUnits: box?.price ?? null, currency: tokens.get(currencyKey)?.symbol ?? currencyKey, active: Boolean(box?.active && item?.active), left: item?.max_supply ? item.max_supply - item.issued : null };
+        return {
+          key: it.key,
+          name: it.name,
+          price: box ? show(box.price, dec) : null,
+          priceUnits: box?.price ?? null,
+          currency: tokens.get(currencyKey)?.symbol ?? currencyKey,
+          active: Boolean(box?.active && item?.active),
+          left: item?.max_supply ? item.max_supply - item.issued : null,
+        };
       });
     },
 
-    /** 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)));
+      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 +1908,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,16 +1920,78 @@ 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);
       // An NFT the project held for the roll goes back.
-      const { before = [], hasAuthority: _, ...subject } = order.held ? await nftOf(order.subject, wallet.address, { to: order.player }) : {};
+      const {
+        before = [],
+        hasAuthority: _,
+        ...subject
+      } = order.held ? await nftOf(order.subject, wallet.address, { to: order.player }) : {};
       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). */
-    askRoll: (orderAddress) => askRoll(orderAddress),
+    /** 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),
 
     /**
      * Pays a payment of the economy (an entry, an attempt, a tip). `amount`: what the player chose, in whole units, for
@@ -918,21 +2008,54 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       if (chosen !== undefined && !p.any) throw new Error(`“${p.name}” has a set amount: ${p.amount}.`);
       const amount = chosen === undefined ? least : units(chosen, decimalsOf(p.currency));
       if (amount < least || amount <= 0n) throw new Error(`“${p.name}” takes at least ${p.amount}.`);
-      const pools = new Map((spec.pools ?? []).map((x) => [x.key, x.index]));
+      const pools = new Map((spec.pools ?? []).map(x => [x.key, x.index]));
       // `pay` takes its shares from the payer each time: a "chosen" share pays the wallet they name, and with none named
       // it is left out, so what it would pay goes to the treasury with the rest (as a purchase's does).
-      if (chosenRecipient && chosenRecipient === wallet.address) throw new Error('A payer can’t name their own wallet for a share they choose.');
-      const shares = (p.split ?? []).flatMap((s) => {
+      if (chosenRecipient && chosenRecipient === wallet.address)
+        throw new Error('A payer can’t name their own wallet for a share they choose.');
+      const shares = (p.split ?? []).flatMap(s => {
         const [kind, key] = s.to.split(':');
         const bps = Math.round(s.percent * 100);
-        if (kind === 'chosen' && key) throw new Error(`“${p.name}” pays the holder of a “${key}” the payer names: a payment can’t check the collectible, so its split takes a chosen wallet only.`);
+        if (kind === 'chosen' && key)
+          throw new Error(
+            `“${p.name}” pays the holder of a “${key}” the payer names: a payment can’t check the collectible, so its split takes a chosen wallet only.`,
+          );
         if (kind === 'chosen') return chosenRecipient ? [{ to: { Wallet: [chosenRecipient] }, bps }] : [];
-        const pot = (lotteryKey) => loot.pda.pot(loot.pda.lottery(project, part('lotteries', lotteryKey).id));
-        const to = kind === 'burn' ? 'Burn' : kind === 'pool' ? { Pool: [pools.get(key)] } : kind === 'account' ? { Account: [key] } : kind === 'wallet' ? { Wallet: [key] } : kind === 'treasury' ? 'Treasury' : kind === 'lottery' ? { Account: [pot(key)] } : { Holder: [key] };
+        const pot = lotteryKey => {
+          const l = part('lotteries', lotteryKey);
+          if (!Number.isInteger(l.pot))
+            throw new Error(
+              `“${l.name ?? lotteryKey}” pays each round from its own ticket money: it keeps no pot to pay into.`,
+            );
+          return loot.pda.lotteryPot(loot.pda.lottery(project, l.id), l.pot);
+        };
+        const to =
+          kind === 'burn'
+            ? 'Burn'
+            : kind === 'pool'
+              ? { Pool: [pools.get(key)] }
+              : kind === 'account'
+                ? { Account: [key] }
+                : kind === 'wallet'
+                  ? { Wallet: [key] }
+                  : kind === 'treasury'
+                    ? 'Treasury'
+                    : kind === 'lottery'
+                      ? { Account: [pot(key)] }
+                      : { Holder: [key] };
         return [{ to, bps }];
       });
-      holders ??= shares.some((x) => x.to.Holder) ? await holdersOf(shares) : undefined;
-      const ix = loot.payIx({ player: wallet.address, project, mint, treasury: g.treasury, amount, shares, holders, programs });
+      holders ??= shares.some(x => x.to.Holder) ? await holdersOf(shares) : undefined;
+      const ix = loot.payIx({
+        player: wallet.address,
+        project,
+        mint,
+        treasury: g.treasury,
+        amount,
+        shares,
+        holders,
+        programs,
+      });
       return send(withSolWrap(wallet.address, mint, amount, [ix]));
     },
 
@@ -944,7 +2067,8 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     async payNft(asset, { to = null, reference, ...others } = NO_OPTIONS) {
       only(others, ['to', 'reference'], 'payNft');
       // An NFT paid goes to a wallet: never the project's address or an account of the program (ToTheProject).
-      if (to && (to === project || (await client.account(to))?.owner === loot.LOOT_PROGRAM)) throw new Error('An NFT paid can’t go to the project or an account of the program: name a wallet, or burn it.');
+      if (to && (to === project || (await client.account(to))?.owner === loot.LOOT_PROGRAM))
+        throw new Error('An NFT paid can’t go to the project or an account of the program: name a wallet, or burn it.');
       const { before, ...nft } = await nftOf(asset);
       return send([...before, loot.payNftIx({ player: wallet.address, project, asset, to, ...nft, reference })]);
     },
@@ -956,16 +2080,32 @@ 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 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 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);
+        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;
     },
 
     /**
@@ -977,53 +2117,135 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
      * passes its rule: `nft`, its address (held by the project until the draw, then burned, given on or stashed; back to
      * the player if the round is cancelled). `listProof`: for a list gate.
      */
-    async buyTickets(lotteryKey, count = 1, { shown, chosenRecipient = null, listProof, nft: paidWith, listing, maxPrice, ...others } = NO_OPTIONS) {
+    async buyTickets(
+      lotteryKey,
+      count = 1,
+      { shown, chosenRecipient = null, listProof, nft: paidWith, listing, maxPrice, ...others } = NO_OPTIONS,
+    ) {
       only(others, ['shown', 'chosenRecipient', 'listProof', 'nft', 'listing', 'maxPrice'], 'buyTickets');
       const l = part('lotteries', lotteryKey);
       const name = l.name ?? lotteryKey;
-      if (listing && listing.key !== undefined && listing.key !== l.key) throw new Error(`That listing is “${listing.key}”, not “${l.key}”.`);
+      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.
-      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 (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 { 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(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 +2270,39 @@ 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 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])]);
+      const token = await farmTokens([mint], [], { extra, transfers });
+      const ix = loot.stakeTokensIx({
+        player: wallet.address,
+        project,
+        id: f.id,
+        farm,
+        amount: value,
+        tier,
+        shown,
+        ...token,
+      });
+      // 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 +2311,24 @@ 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 }),
+        ]),
+      );
     },
 
     /**
@@ -1098,25 +2343,30 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       await openFor(f, farm, tier);
       const token = await farmTokens([farm.rewards_mint], [], { extra, transfers });
       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 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 (!mine || BigInt(mine.amount) === 0n)
+          throw new Error(`Stake some ${f.stakes} in “${f.name ?? f.key}” first: a booster boosts a stake.`);
+        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 }),
+        ]),
+      );
     },
 
     /**
@@ -1129,9 +2379,15 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       only(others, ['forfeit', 'extra', 'transfers'], 'unstakeNft');
       const f = part('farms', farmKey);
       const farm = await read('Farm', loot.pda.farm(project, f.id));
-      const token = await farmTokens(forfeit ? [] : [farm.rewards_mint], forfeit || farm.farmed.Tokens ? [] : [farm.rewards_mint], { extra, transfers });
+      const token = await farmTokens(
+        forfeit ? [] : [farm.rewards_mint],
+        forfeit || farm.farmed.Tokens ? [] : [farm.rewards_mint],
+        { extra, transfers },
+      );
       // Held in escrow, it comes back into the player's account (frozen in place, it never left it).
-      const { before, ...nft } = await nftOf(asset, wallet.address, { to: farm.custody === 'Escrow' ? wallet.address : undefined });
+      const { before, ...nft } = await nftOf(asset, wallet.address, {
+        to: farm.custody === 'Escrow' ? wallet.address : undefined,
+      });
       // Leaving a mission that rolls: its roll is made in an order of the player's, which `collect` then finishes; its
       // prize's roll (a chest) at the next nonce.
       const seat = await read('Seat', loot.pda.seat(loot.pda.farm(project, f.id), asset));
@@ -1139,12 +2395,78 @@ 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 +2474,21 @@ 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 +2499,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 +2511,35 @@ 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.
@@ -1225,20 +2549,25 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const f = part('farms', farmKey);
       const farmAddress = loot.pda.farm(project, f.id);
       const farm = await read('Farm', farmAddress);
-      const rewards = [...tokens.values()].find((t) => mintOf(t.key) === farm.rewards_mint);
+      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, [
-        { 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: [] }));
+      // 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: 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.
       let payer;
       const funded = async () => {
-        for (const a of [player, wallet?.address, live.authority].filter(Boolean)) if ((await client.balance(a).catch(() => 0n)) > 0n) return a;
+        for (const a of [player, wallet?.address, live.authority].filter(Boolean))
+          if ((await client.balance(a).catch(() => 0n)) > 0n) return a;
         return player;
       };
       const out = [];
@@ -1250,9 +2579,11 @@ 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];
+          const after = (
+            await client.simulate(wireTransaction(message), { accounts: [pubkey], replaceBlockhash: true })
+          ).accounts[0];
           if (after?.data) [seat, counted] = [loot.decode('Seat', after.data), true];
         } catch {
           // The seat as it was last credited.
@@ -1270,6 +2601,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,
         });
       }
@@ -1279,7 +2612,7 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     /** The recipes: whether each is on, and its version now (what `craft` takes as the terms the player was shown). */
     async recipes() {
       const list = spec.recipes ?? [];
-      const accounts = await client.accounts(list.map((r) => loot.pda.recipe(project, r.id)));
+      const accounts = await client.accounts(list.map(r => loot.pda.recipe(project, r.id)));
       return list.map((r, i) => {
         const recipe = accounts[i] && loot.decode('Recipe', accounts[i].data);
         return { key: r.key, name: r.name, active: Boolean(recipe?.active), version: recipe ? recipe.version : null };
@@ -1290,59 +2623,79 @@ 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.`);
+      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 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]] : [])));
-      const handed = await Promise.all(assets.map(async (nft, i) => {
-        if (stakedAt.has(i) && typeof nft === 'string') {
-          const farm = stakedAt.get(i);
-          if (!(await readMaybe('Seat', loot.pda.seat(loot.pda.farm(project, farm), nft)))) {
-            const name = (spec.farms ?? []).find((f) => f.id === farm)?.name ?? `farm ${farm}`;
-            throw new Error(`${nft} is not staked in “${name}”, where this recipe takes it.`);
+      // 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);
+            if (!(await readMaybe('Seat', loot.pda.seat(loot.pda.farm(project, farm), nft)))) {
+              const name = (spec.farms ?? []).find(f => f.id === farm)?.name ?? `farm ${farm}`;
+              throw new Error(`${nft} is not staked in “${name}”, where this recipe takes it.`);
+            }
+            return { asset: nft, farm };
           }
-          return { asset: nft, farm };
-        }
-        if (keptAt.has(i) && typeof nft === 'string') return (await escrowedIn(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;
-        const account = await client.account(nft);
-        if (account?.owner !== MPL_CORE) return { mint: nft, owner: wallet.address };
-        const theirs = await collectionOf(nft);
-        return ours(theirs) ? nft : { asset: nft, collection: theirs };
-      }));
+          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, ...on };
+          const theirs = await collectionOf(nft);
+          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.
-      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();
+      const rolls = recipe.outputs.some(o => o.RollOn || o.Prize?.[0]?.Roll);
+      // 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.
-      const given = await prizeInputs(recipe.outputs.map((o) => o.Prize?.[0] ?? (o.RollOn ? { Roll: [o.RollOn.box_id] } : null)));
+      const given = await prizeInputs(
+        recipe.outputs.map(o => o.Prize?.[0] ?? (o.RollOn ? { Roll: [o.RollOn.box_id] } : null)),
+      );
       // Each item a line takes passes its collection.
       const items = { ...given.items };
       for (const input of recipe.inputs) {
@@ -1351,30 +2704,64 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       }
       // The collectibles it makes, each at its item's next serial.
       const counts = {};
-      const made = recipe.outputs.flatMap((o) => {
+      const made = recipe.outputs.flatMap(o => {
         const id = o.Prize?.[0]?.Item?.[0];
         if (id === undefined || items[id]?.kind !== 'Collectible') return [];
         counts[id] = (counts[id] ?? 0) + 1;
         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 })];
+      const before = [...proving, ...given.before].filter(x => x.programId !== COMPUTE_BUDGET_PROGRAM);
+      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));
           const { before, ...nft } = await nftOf(asset);
-          instructions.push(...before, loot.refreshSeatIx({ signer: wallet.address, project, id: f.id, farm, by: asset, seat, ...nft }));
+          instructions.push(
+            ...before,
+            loot.refreshSeatIx({ signer: wallet.address, project, id: f.id, farm, by: asset, seat, ...nft }),
+          );
         }
       }
       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] } : {}) };
     },
 
     /**
@@ -1384,7 +2771,17 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     async hold(asset, seconds) {
       const freeAt = BigInt(typeof seconds === 'object' ? seconds.until : now() + Number(seconds));
       const { before, hasAuthority: _, ...nft } = await nftOf(asset);
-      const signature = await send([...before, loot.holdIx({ player: wallet.address, project, asset, ...nft, collection: nft.collection ?? (await collectionOf(asset)) ?? MPL_CORE, freeAt })]);
+      const signature = await send([
+        ...before,
+        loot.holdIx({
+          player: wallet.address,
+          project,
+          asset,
+          ...nft,
+          collection: nft.collection ?? (await collectionOf(asset)) ?? MPL_CORE,
+          freeAt,
+        }),
+      ]);
       return { signature, freeAt };
     },
 
@@ -1401,12 +2798,30 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       if (!offer.deal.Lend) throw new Error(`The offer ${address} buys NFTs; it lends nothing.`);
       const account = await client.account(offer.mint);
       if (!account) throw new Error(`The loan's token ${offer.mint} is not on this cluster.`);
-      const lender = (who) => (who === maker ? ' That is the lender: they could keep you from repaying and take your NFT when the loan is due.' : '');
-      const risks = mintPowers(account).map((p) => {
-        if (p.power === 'freeze') return { ...p, says: `${p.holder} can freeze accounts of the loan's token, which makes repaying fail.${lender(p.holder)}` };
-        if (p.power === 'pause') return { ...p, says: `${p.holder ?? 'Its pause authority'} can pause every transfer of the loan's token, which makes repaying fail${p.paused ? ' (it is paused now)' : ''}.${lender(p.holder)}` };
-        if (p.power === 'hook') return { ...p, says: `Every transfer of the loan's token runs the program ${p.holder}${p.authority ? `, which ${p.authority} can change` : ''}; it can refuse a repayment.${lender(p.authority)}` };
-        return { ...p, says: `${p.holder} can move anyone's tokens of the loan's token, the ones you would repay with too.${lender(p.holder)}` };
+      const lender = who =>
+        who === maker
+          ? ' That is the lender: they could keep you from repaying and take your NFT when the loan is due.'
+          : '';
+      const risks = mintPowers(account).map(p => {
+        if (p.power === 'freeze')
+          return {
+            ...p,
+            says: `${p.holder} can freeze accounts of the loan's token, which makes repaying fail.${lender(p.holder)}`,
+          };
+        if (p.power === 'pause')
+          return {
+            ...p,
+            says: `${p.holder ?? 'Its pause authority'} can pause every transfer of the loan's token, which makes repaying fail${p.paused ? ' (it is paused now)' : ''}.${lender(p.holder)}`,
+          };
+        if (p.power === 'hook')
+          return {
+            ...p,
+            says: `Every transfer of the loan's token runs the program ${p.holder}${p.authority ? `, which ${p.authority} can change` : ''}; it can refuse a repayment.${lender(p.authority)}`,
+          };
+        return {
+          ...p,
+          says: `${p.holder} can move anyone's tokens of the loan's token, the ones you would repay with too.${lender(p.holder)}`,
+        };
       });
       const { amount, repay, lasts } = offer.deal.Lend;
       return { address, offer, mint: offer.mint, program: account.owner, amount, repay, lasts, risks };
@@ -1421,17 +2836,111 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     async borrow(maker, id, asset, { due, acceptRisks = false, extra = [], ...others } = NO_OPTIONS) {
       only(others, ['due', 'acceptRisks', 'extra'], 'borrow');
       const loan = await this.loanOffer(maker, id);
-      if (loan.risks.length && acceptRisks !== true) throw new Error(`Repaying this loan can be blocked. ${loan.risks.map((r) => r.says).join(' ')} Borrow only if the player accepts this: pass acceptRisks: true.`);
+      if (loan.risks.length && acceptRisks !== true)
+        throw new Error(
+          `Repaying this loan can be blocked. ${loan.risks.map(r => r.says).join(' ')} Borrow only if the player accepts this: pass acceptRisks: true.`,
+        );
       const lasts = BigInt(loan.lasts);
       due = BigInt(due ?? BigInt(now()) + lasts - (lasts > 120n ? 60n : 0n));
       const { before, ...nft } = await nftOf(asset);
       const collection = nft.collection ?? (await collectionOf(asset)) ?? MPL_CORE;
       const loanPrograms = { ...programs, [loan.mint]: loan.program };
-      const ix = loot.borrowIx({ borrower: wallet.address, project, id, offer: loan.offer, due, asset, ...nft, collection, programs: loanPrograms, extra });
-      const signature = await send([...before, createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, loan.mint, loan.program), ix]);
+      const ix = loot.borrowIx({
+        borrower: wallet.address,
+        project,
+        id,
+        offer: loan.offer,
+        due,
+        asset,
+        ...nft,
+        collection,
+        programs: loanPrograms,
+        extra,
+      });
+      const signature = await send([
+        ...before,
+        createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, loan.mint, loan.program),
+        ix,
+      ]);
       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
@@ -1445,11 +2954,39 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       if (contest.nft) {
         if (!staked) throw new Error('This contest takes an NFT: say which (nft).');
         const { before, ...kind } = await nftOf(staked);
-        return send([...before, loot.enterIx({ player: wallet.address, project, id, contest, side, amount: 1n, shown, listProof, nft: { asset: staked, ...kind }, programs })]);
+        return send([
+          ...before,
+          loot.enterIx({
+            player: wallet.address,
+            project,
+            id,
+            contest,
+            side,
+            amount: 1n,
+            shown,
+            listProof,
+            nft: { asset: staked, ...kind },
+            programs,
+          }),
+        ]);
       }
-      const t = [...tokens.values()].find((x) => mintOf(x.key) === contest.mint);
-      const value = units(amount, t?.source === 'sol' ? 9 : t?.decimals ?? 0);
-      return send(withSolWrap(wallet.address, contest.mint, value, [loot.enterIx({ player: wallet.address, project, id, contest, side, amount: value, shown, listProof, programs })]));
+      const t = [...tokens.values()].find(x => mintOf(x.key) === contest.mint);
+      const value = units(amount, t?.source === 'sol' ? 9 : (t?.decimals ?? 0));
+      return send(
+        withSolWrap(wallet.address, contest.mint, value, [
+          loot.enterIx({
+            player: wallet.address,
+            project,
+            id,
+            contest,
+            side,
+            amount: value,
+            shown,
+            listProof,
+            programs,
+          }),
+        ]),
+      );
     },
 
     /**
@@ -1459,13 +2996,22 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
      */
     async auctions() {
       const list = spec.auctions ?? [];
-      const accounts = await client.accounts(list.map((a) => auctionAt(a)));
+      const accounts = await client.accounts(list.map(a => auctionAt(a)));
       const at = BigInt(now());
-      const wrapped = wallet?.address ? await client.account(associatedTokenAddress(wallet.address, NATIVE_MINT)) : null;
-      const waiting = wrapped ? show(new DataView(wrapped.data.buffer, wrapped.data.byteOffset).getBigUint64(64, true), 9) : '0';
+      const wrapped = wallet?.address
+        ? await client.account(associatedTokenAddress(wallet.address, NATIVE_MINT))
+        : null;
+      const waiting = wrapped
+        ? show(new DataView(wrapped.data.buffer, wrapped.data.byteOffset).getBigUint64(64, true), 9)
+        : '0';
       return list.map((a, i) => {
         const x = accounts[i] && loot.decode('Auction', accounts[i].data);
-        const base = { key: a.key, name: a.name, lot: a.lot, currency: tokens.get(a.currency ?? currencyKey)?.symbol ?? a.currency ?? currencyKey };
+        const base = {
+          key: a.key,
+          name: a.name,
+          lot: a.lot,
+          currency: tokens.get(a.currency ?? currencyKey)?.symbol ?? a.currency ?? currencyKey,
+        };
         if (!x) return { ...base, ended: true };
         // Bids of NFTs count NFTs.
         const dec = x.nft_bids ? 0 : decimalsOf(a.currency);
@@ -1486,7 +3032,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 +3058,9 @@ 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 });
@@ -1520,8 +3072,18 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         // The bid it tops goes back to its bidder: into a fresh account of theirs when their own can't take it.
         const held = [];
         for (const asset of auction.held) held.push(await kindOf(asset, auction.high_bidder));
-        const ix = loot.bidIx({ bidder: wallet.address, project, id: a.id, auction, shown, listProof, nfts: bid, held, programs });
-        return send([computeUnitLimit(800_000), ...before.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM), ix]);
+        const ix = loot.bidIx({
+          bidder: wallet.address,
+          project,
+          id: a.id,
+          auction,
+          shown,
+          listProof,
+          nfts: bid,
+          held,
+          programs,
+        });
+        return send([computeUnitLimit(800_000), ...before.filter(x => x.programId !== COMPUTE_BUDGET_PROGRAM), ix]);
       }
       const mint = auction.mint;
       const value = units(amount, decimalsOf(a.currency));
@@ -1531,34 +3093,81 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         const have = await client.account(wrapped);
         const held = have ? new DataView(have.data.buffer, have.data.byteOffset).getBigUint64(64, true) : 0n;
         instructions.push(createAssociatedTokenAccountIdempotent(wallet.address, wallet.address, NATIVE_MINT));
-        if (value > held) instructions.push(transferLamports(wallet.address, wrapped, value - held), syncNative(wrapped));
+        if (value > held)
+          instructions.push(transferLamports(wallet.address, wrapped, value - held), syncNative(wrapped));
       }
       // A Token-2022 account can ask for a memo on every transfer into it: the Memo program rides along.
-      const memo = programOf(mint) === TOKEN_2022_PROGRAM ? [{ pubkey: MEMO_PROGRAM, isSigner: false, isWritable: false }] : [];
-      instructions.push(loot.bidIx({ bidder: wallet.address, project, id: a.id, auction, amount: value, shown, listProof, programs, extra: memo }));
+      const memo =
+        programOf(mint) === TOKEN_2022_PROGRAM ? [{ pubkey: MEMO_PROGRAM, isSigner: false, isWritable: false }] : [];
+      instructions.push(
+        loot.bidIx({
+          bidder: wallet.address,
+          project,
+          id: a.id,
+          auction,
+          amount: value,
+          shown,
+          listProof,
+          programs,
+          extra: memo,
+        }),
+      );
       return send(instructions, [], { keepWrapped: true });
     },
 
     /**
      * 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 memo = programOf(auction.mint) === TOKEN_2022_PROGRAM ? [{ pubkey: MEMO_PROGRAM, isSigner: false, isWritable: false }] : [];
+      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];
       // The lot goes to its winner (back to its seller, unsold); a winning bid of NFTs to whoever the rest of a bid in
       // tokens would go to: the seller of an NFT, the treasury for a new item.
-      const { before, hasAuthority: _, ...nft } = lot ? await nftOf(lot, wallet.address, { to: sold ? auction.high_bidder : auction.seller }) : { before: [] };
-      const collection = lot && !nft.compressed && !nft.tokenMetadata ? (await collectionOf(lot)) ?? MPL_CORE : undefined;
+      const {
+        before,
+        hasAuthority: _,
+        ...nft
+      } = lot ? await nftOf(lot, wallet.address, { to: sold ? auction.high_bidder : auction.seller }) : { before: [] };
+      const collection =
+        lot && !nft.compressed && !nft.tokenMetadata ? ((await collectionOf(lot)) ?? MPL_CORE) : undefined;
       const proceeds = auction.lot.Asset ? auction.seller : g.treasury;
       const held = [];
       if (sold && auction.nft_bids) {
@@ -1568,19 +3177,115 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
           held.push(kind);
         }
       }
-      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`).
-      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 ix = loot.endAuctionIx({
+        signer: wallet.address,
+        project,
+        projectState: g,
+        id: a.id,
+        auction,
+        item,
+        ...nft,
+        collection,
+        held,
+        holders,
+        programs,
+        extra: memo,
+      });
+      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;
+      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 +3294,30 @@ 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;
+      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
@@ -1608,7 +3330,18 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       only(others, ['price', 'currency', 'shares'], 'listForSale');
       const mint = mintOf(currency);
       const { before, ...nft } = await nftOf(asset);
-      return send([...before, loot.openListingIx({ maker: wallet.address, project, asset, mint, deal: { Sell: { price: units(price, decimalsOf(currency)) } }, shares, ...nft })]);
+      return send([
+        ...before,
+        loot.openListingIx({
+          maker: wallet.address,
+          project,
+          asset,
+          mint,
+          deal: { Sell: { price: units(price, decimalsOf(currency)) } },
+          shares,
+          ...nft,
+        }),
+      ]);
     },
 
     /**
@@ -1619,14 +3352,29 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       only(others, ['price', 'lasts', 'maxPeriods', 'currency', 'shares'], 'listForRent');
       const mint = mintOf(currency);
       const { before, ...nft } = await nftOf(asset);
-      return send([...before, loot.openListingIx({ maker: wallet.address, project, asset, mint, deal: { Rent: { price: units(price, decimalsOf(currency)), lasts, max_periods: maxPeriods } }, shares, ...nft })]);
+      return send([
+        ...before,
+        loot.openListingIx({
+          maker: wallet.address,
+          project,
+          asset,
+          mint,
+          deal: { Rent: { price: units(price, decimalsOf(currency)), lasts, max_periods: maxPeriods } },
+          shares,
+          ...nft,
+        }),
+      ]);
     },
 
     /** The listing of `asset` (one account read), or null: { listing, asset, maker, mint, deal, renter, until }. */
     async listing(asset) {
       const listing = await readMaybe('Listing', loot.pda.listing(project, asset));
       if (!listing) return null;
-      return { listing: loot.pda.listing(project, asset), ...listing, renter: loot.renterOf(listing, await chainNow()) };
+      return {
+        listing: loot.pda.listing(project, asset),
+        ...listing,
+        renter: loot.renterOf(listing, await chainNow()),
+      };
     },
 
     /** Who rents `asset` now (one account read, then a check that the project still holds it), or null. */
@@ -1642,7 +3390,11 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     /** The project's listings, a maker's (`maker`) or all: one search of the program's accounts. */
     async listings({ maker, ...others } = NO_OPTIONS) {
       only(others, ['maker'], 'listings');
-      const filters = [{ memcmp: { offset: 0, bytes: encodeBase58(Uint8Array.of(loot.TAGS.Listing)) } }, { memcmp: { offset: 1, bytes: project } }, ...(maker ? [{ memcmp: { offset: 33, bytes: maker } }] : [])];
+      const filters = [
+        { memcmp: { offset: 0, bytes: encodeBase58(Uint8Array.of(loot.TAGS.Listing)) } },
+        { memcmp: { offset: 1, bytes: project } },
+        ...(maker ? [{ memcmp: { offset: 33, bytes: maker } }] : []),
+      ];
       const time = await chainNow();
       return (await client.programAccounts(loot.LOOT_PROGRAM, filters)).map(({ pubkey, account }) => {
         const listing = loot.decode('Listing', account.data);
@@ -1659,7 +3411,20 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       await shownListing(asset, listing, 'Sell');
       const { before, ...nft } = await nftOf(asset, wallet.address, { to: wallet.address });
       const holders = await holdersOf(listing.shares ?? []);
-      return send([...before, ...withSolWrap(wallet.address, listing.mint, listing.deal.Sell.price, [loot.takeListingIx({ taker: wallet.address, project, projectState: await projectNow(), listing, holders, programs, ...nft })])]);
+      return send([
+        ...before,
+        ...withSolWrap(wallet.address, listing.mint, listing.deal.Sell.price, [
+          loot.takeListingIx({
+            taker: wallet.address,
+            project,
+            projectState: await projectNow(),
+            listing,
+            holders,
+            programs,
+            ...nft,
+          }),
+        ]),
+      ]);
     },
 
     /**
@@ -1673,7 +3438,21 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const total = BigInt(listing.deal.Rent.price) * BigInt(periods);
       // A compressed NFT is read by its record, proven first in the same transaction.
       const { before, compressed } = await nftOf(asset);
-      return send([...(compressed ? before : []), ...withSolWrap(wallet.address, listing.mint, total, [loot.takeListingIx({ taker: wallet.address, project, projectState: await projectNow(), listing, periods, compressed, holders, programs })])]);
+      return send([
+        ...(compressed ? before : []),
+        ...withSolWrap(wallet.address, listing.mint, total, [
+          loot.takeListingIx({
+            taker: wallet.address,
+            project,
+            projectState: await projectNow(),
+            listing,
+            periods,
+            compressed,
+            holders,
+            programs,
+          }),
+        ]),
+      ]);
     },
 
     /** Takes a listed NFT home (its maker). While a rental runs it only stops the listing; call again once it is over. */
@@ -1690,24 +3469,63 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
      * nothing but the lottery can take it while a place names it; the winner gets it before any ticket money moves.
      * `price` (whole units of `currency`) a ticket, `drawsAt` (Unix seconds) its one draw, `minSold` the least tickets
      * (fewer: the round is cancelled and refunded), `shares` where the ticket money goes (the seller's own wallet by
-     * default: the treasury). A seller runs it in a project of their own, whose owner they are.
+     * default: the treasury). Its one place takes no money, so it keeps no pot: the round pays from its own ticket
+     * money, and what the shares leave goes to the treasury too. A seller runs it in a project of their own, whose
+     * owner they are.
      */
-    async raffle(id, nft, { price, currency, drawsAt, minSold = 0, perWallet = 0, shares = [{ to: 'Treasury', bps: 10_000 }], ...others } = NO_OPTIONS) {
+    async raffle(
+      id,
+      nft,
+      {
+        price,
+        currency,
+        drawsAt,
+        minSold = 0,
+        perWallet = 0,
+        shares = [{ to: 'Treasury', bps: 10_000 }],
+        ...others
+      } = NO_OPTIONS,
+    ) {
       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),
+        price: units(price, decimalsOf(currency)),
+        mint: mintOf(currency),
+        pays_from: { Round: { rest: 'Treasury' } },
+        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 +3538,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
@@ -1728,14 +3546,28 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
      */
     async claimGrant(grantKey, options = {}) {
       only(options, ['voucher', 'proof', 'personHash', 'round', 'amount', 'shown', 'listProof'], 'claimGrant');
-      let { voucher = null, proof: given = null, personHash: listPerson = null, round: listRound = null, amount: listAmount = 0n, shown } = options;
+      let {
+        voucher = null,
+        proof: given = null,
+        personHash: listPerson = null,
+        round: listRound = null,
+        amount: listAmount = 0n,
+        shown,
+      } = options;
       const gspec = part('grants', grantKey);
       const address = loot.pda.grant(project, gspec.id);
       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];
@@ -1745,23 +3577,50 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       let proof = [];
       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) });
+        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,
+          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.
         const at = keys.indexOf(voucher.publicKey);
-        proof = given ?? (at >= 0 ? loot.merkleProof(keys.map((k) => loot.keyLeaf(k)), at) : []);
+        proof =
+          given ??
+          (at >= 0
+            ? loot.merkleProof(
+                keys.map(k => loot.keyLeaf(k)),
+                at,
+              )
+            : []);
       } else if (given) {
         proof = given;
       } else if ((gspec.list ?? []).length) {
         // An entry is an address (the grant's amount, round 0), or { wallet, amount, round } (whole units of the grant's
         // token): a wallet listed under several rounds claims each once (`options.round`, a number; the first by default).
-        const list = gspec.list.map((e) => (typeof e === 'string' ? { wallet: e } : e));
+        const list = gspec.list.map(e => (typeof e === 'string' ? { wallet: e } : e));
         const mint = grant.gives.Tokens?.from.Mint?.[0] ?? poolMint;
-        const decimals = mint && list.some((e) => e.amount !== undefined) ? (await client.account(mint))?.data?.[44] ?? 0 : 0;
-        const leaves = list.map((e) => loot.listLeaf(e.wallet, null, loot.listRound(e.round ?? 0), e.amount !== undefined ? units(e.amount, decimals) : 0n));
-        const at = list.findIndex((e) => e.wallet === wallet.address && (typeof listRound !== 'number' || (e.round ?? 0) === listRound));
+        const decimals =
+          mint && list.some(e => e.amount !== undefined) ? ((await client.account(mint))?.data?.[44] ?? 0) : 0;
+        const leaves = list.map(e =>
+          loot.listLeaf(
+            e.wallet,
+            null,
+            loot.listRound(e.round ?? 0),
+            e.amount !== undefined ? units(e.amount, decimals) : 0n,
+          ),
+        );
+        const at = list.findIndex(
+          e => e.wallet === wallet.address && (typeof listRound !== 'number' || (e.round ?? 0) === listRound),
+        );
         if (at < 0) throw new Error('This wallet is not on the list for this grant.');
         proof = loot.merkleProof(leaves, at);
         listRound = loot.listRound(list[at].round ?? 0);
@@ -1769,18 +3628,46 @@ 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];
-      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);
+      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,
+          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;
     },
 
     /**
@@ -1801,49 +3688,69 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         const r = await fetchImpl(path.startsWith('http') ? path : `${base}${path}`, init);
         // The status first: a proxy's error page is no JSON, and says nothing a player can act on but its status.
         const body = await r.json().catch(() => null);
-        if (!r.ok) throw Object.assign(new Error(body?.error?.why ?? `The results server answered ${r.status}.`), { code: body?.error?.code, status: r.status });
-        if (body === null || typeof body !== 'object') throw new Error(`The results server answered ${r.status} with no JSON.`);
+        if (!r.ok)
+          throw Object.assign(new Error(body?.error?.why ?? `The results server answered ${r.status}.`), {
+            code: body?.error?.code,
+            status: r.status,
+          });
+        if (body === null || typeof body !== 'object')
+          throw new Error(`The results server answered ${r.status} with no JSON.`);
         return body;
       };
-      const get = (path) => ask(path);
+      const get = path => ask(path);
       // Where a list's proof is, as the server named it: a path on the server itself, or a whole URL on the server's own
       // origin. Any other place is refused before anything is fetched, so a server's answer can't send the page to
       // another host. A server given as a path (such as "/results") is on the page's own origin.
-      const proofAt = (proof) => {
+      const proofAt = proof => {
         const said = String(proof ?? '');
         let origin = null;
         let url = null;
         try {
           const home = new URL(`${base}/`, globalThis.location?.href);
           origin = home.origin;
-          url = new URL(said.startsWith('/') && !said.startsWith('//') ? `${home.href.replace(/\/$/, '')}${said}` : said, home);
+          url = new URL(
+            said.startsWith('/') && !said.startsWith('//') ? `${home.href.replace(/\/$/, '')}${said}` : said,
+            home,
+          );
         } catch {
           // not a URL at all: refused below
         }
-        if (!url || origin === null || origin === 'null' || url.origin !== origin) throw new Error(`The results server named a list's proof at “${said}”, which is not on the server itself (${origin ?? base}): it was not fetched.`);
+        if (!url || origin === null || origin === 'null' || url.origin !== origin)
+          throw new Error(
+            `The results server named a list's proof at “${said}”, which is not on the server itself (${origin ?? base}): it was not fetched.`,
+          );
         return url.href;
       };
       // Each value in a query is encoded: a round or a page the server named can't change the request's path.
-      const q = (value) => encodeURIComponent(String(value));
+      const q = value => encodeURIComponent(String(value));
       // A win's vouchers; a stash drop's NFT not given yet: the signed-in claim's, those for this wallet
-      const vouchersOf = async (round) => {
+      const vouchersOf = async round => {
         try {
           return (await get(`/v1/vouchers?game=${q(project)}&round=${q(round)}&wallet=${q(wallet.address)}`)).vouchers;
         } catch (e) {
           if (e.code !== 'R-SIGN-IN' || !token) throw e;
-          const { vouchers } = await ask('/v1/claims', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ game: project, round, token }) });
-          return vouchers.filter((v) => v.wallet === wallet.address);
+          const { vouchers } = await ask('/v1/claims', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ game: project, round, token }),
+          });
+          return vouchers.filter(v => v.wallet === wallet.address);
         }
       };
       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 });
         }
@@ -1854,20 +3761,29 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const pagesRead = new Set();
       for (let first = true; first || (page.next && !pagesRead.has(page.next)); first = false) {
         pagesRead.add(page.next);
-        page = await get(`/v1/wins?game=${q(project)}&wallet=${q(wallet.address)}${page.next ? `&before=${q(page.next)}` : ''}`);
-        for (const win of page.wins.filter((x) => x.grant !== null && x.grant !== undefined)) {
+        page = await get(
+          `/v1/wins?game=${q(project)}&wallet=${q(wallet.address)}${page.next ? `&before=${q(page.next)}` : ''}`,
+        );
+        for (const win of page.wins.filter(x => x.grant !== null && x.grant !== undefined)) {
           // one win that fails (its vouchers refused, a sign-in run out, a list not there) is its own error line, and
           // the rest go on (a refused POST /v1/claims must not stop every later win)
           try {
             for (const v of await vouchersOf(win.round)) {
-              const grantKey = (spec.grants ?? []).find((x) => x.id === v.grant)?.key;
+              const grantKey = (spec.grants ?? []).find(x => x.id === v.grant)?.key;
               if (!grantKey) continue;
               if (v.list) {
                 // Paid by a list the owner wrote from the draw: its proof names the round.
                 const list = await get(proofAt(v.proof));
-                const mine = list.winners.find((w) => w.wallet === wallet.address);
+                const mine = list.winners.find(w => w.wallet === wallet.address);
                 if (!mine || (await claimed(v.grant, null, list.round))) continue;
-                await take(win.round, v.grant, () => this.claimGrant(grantKey, { proof: mine.proof, personHash: mine.personHash, round: list.round, amount: mine.amount ?? 0 }));
+                await take(win.round, v.grant, () =>
+                  this.claimGrant(grantKey, {
+                    proof: mine.proof,
+                    personHash: mine.personHash,
+                    round: list.round,
+                    amount: mine.amount ?? 0,
+                  }),
+                );
               } else if (v.signature && !(await claimed(v.grant, v.incarnation, v.round))) {
                 await take(win.round, v.grant, () => this.claimGrant(grantKey, { voucher: v }));
               }
@@ -1883,100 +3799,274 @@ 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`.
+     * a winner's first claim of a contest of tokens carries `potUnits` and `prizeUnits`, its part as the decision wrote
+     * it (base units, as text). Pass one to `claim`.
      */
     async claims() {
       const me = wallet.address;
       const out = [];
-      const tag = (t) => ({ memcmp: { offset: 0, bytes: encodeBase58(Uint8Array.of(loot.TAGS[t])) } });
+      const tag = t => ({ memcmp: { offset: 0, bytes: encodeBase58(Uint8Array.of(loot.TAGS[t])) } });
       const at = (offset, bytes) => ({ memcmp: { offset, bytes } });
       const slot = await slotNow();
       const time = BigInt(now());
-      for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [tag('Order'), at(1, project), at(33, me)])) {
+      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.' });
-        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).' });
+        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, 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.';
+        // A winner's part of a contest of tokens is what the decision wrote, whoever claims first (`contestWinnings`).
+        const winnings = first && !contest.nft ? loot.contestWinnings(contest, entry.amount) : null;
+        out.push({
+          kind: 'contest',
+          id: contest.id,
+          side: entry.side,
+          says,
+          ...(winnings ? { potUnits: String(winnings.pot), prizeUnits: String(winnings.prize) } : {}),
+        });
       }
-      for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [tag('Hold'), at(1, project), at(65, me)])) {
+      // 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.',
+          });
+      }
+      // 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)));
+      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.` });
-        }
-        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.` });
+        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 (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.` });
+        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.` });
       }
       // The player's listings whose rental is over: their NFT can go home (or wait for the next renter).
       const mineListed = await client.programAccounts(loot.LOOT_PROGRAM, [tag('Listing'), at(1, project), at(33, me)]);
       for (const { account } of mineListed) {
         const listing = loot.decode('Listing', account.data);
-        if (listing.deal.Rent && listing.user !== NOBODY && !loot.renterOf(listing, chainTime)) out.push({ kind: 'unlist', asset: listing.asset, says: listing.stopped ? 'The rental of your stopped listing is over: take your NFT home.' : 'A rental of yours is over: take your NFT home, or leave it listed for the next renter.' });
+        if (listing.deal.Rent && listing.user !== NOBODY && !loot.renterOf(listing, chainTime))
+          out.push({
+            kind: 'unlist',
+            asset: listing.asset,
+            says: listing.stopped
+              ? 'The rental of your stopped listing is over: take your NFT home.'
+              : 'A rental of yours is over: take your NFT home, or leave it listed for the next renter.',
+          });
       }
       // The lookup tables a transaction of this player's too big for a legacy one made (`send`): each is deactivated by
       // the transaction it was made for, and its rent comes back once it has cooled down (about 513 slots). One of this
@@ -1987,12 +4077,26 @@ 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.` });
-        else if (step === 'active' && table.addresses[0] === project && slot > table.lastExtendedSlot + TABLE_UNSENT_SLOTS)
-          out.push({ kind: 'lookup-table', table: pubkey, says: `A lookup table made for a large transaction of yours that was never sent: retire it, and its ${rent} SOL of rent comes back about two minutes later.` });
+        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.`,
+          });
+        else if (
+          step === 'active' &&
+          table.addresses[0] === project &&
+          slot > table.lastExtendedSlot + TABLE_UNSENT_SLOTS
+        )
+          out.push({
+            kind: 'lookup-table',
+            table: pubkey,
+            says: `A lookup table made for a large transaction of yours that was never sent: retire it, and its ${rent} SOL of rent comes back about two minutes later.`,
+          });
       }
       return out;
     },
@@ -2002,90 +4106,230 @@ 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));
         const step = table && tableStep(table, await slotNow(), await recentSlots());
         if (!step || step === 'cooling') return null;
-        return send([step === 'close' ? closeTableIx({ table: c.table, authority: me }) : deactivateTableIx({ table: c.table, authority: me })], [], { keepWrapped: true });
+        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 (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 })]);
+      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 });
+        }
+      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. */
@@ -2099,11 +4343,12 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         if (t.source === 'sol') out[t.key] = show(await client.balance(owner), 9);
         else if (mint) {
           const a = await client.account(loot.ata(owner, mint, programOf(mint)));
-          out[t.key] = a ? show(new DataView(a.data.buffer, a.data.byteOffset).getBigUint64(64, true), t.decimals ?? 0) : '0';
+          out[t.key] = a
+            ? show(new DataView(a.data.buffer, a.data.byteOffset).getBigUint64(64, true), t.decimals ?? 0)
+            : '0';
         }
       }
       return out;
     },
   };
 }
-