@xgamesfun/solana 0.24.0 → 0.25.0

package/js/play/index.js

@@ -21,11 +21,39 @@
 // signed wire }: `walletStandardSigner` makes one from a Wallet Standard wallet (Phantom, Solflare, Backpack).
 import { decodeBase58, encodeBase58 } from '../chain/base58.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 {
+  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';
@@ -38,13 +66,13 @@ const BATCHED = new Set(['contest', 'release', 'lookup-table', 'close-leaf', ...
 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 isProveLeaf = (ix) => ix.programId === loot.LOOT_PROGRAM && loot.instructionOf(ix.data)?.name === 'prove_leaf';
+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;
@@ -64,10 +92,14 @@ export function walletStandardSigner(wallet, account, chain = CHAIN) {
       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;
-    } } : {}),
+    ...(messages
+      ? {
+          async signMessage(message) {
+            const [out] = await messages.signMessage({ account, message });
+            return out.signature;
+          },
+        }
+      : {}),
   };
 }
 
@@ -75,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)),
+  };
 }
 
 /**
@@ -84,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}` : ''}`;
 };
@@ -110,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;
     },
   });
 }
@@ -133,34 +182,50 @@ function devnetOnly(client) {
  * 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), keyStore = browserStore() }) {
+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());
+  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 };
-  const programOf = (mint) => programs[mint] ?? TOKEN_PROGRAM;
+  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 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;
   };
@@ -176,7 +241,8 @@ 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.terms.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 watched
@@ -184,39 +250,52 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * 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);
@@ -237,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 }.
@@ -254,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),
@@ -276,7 +364,7 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    */
   async function prizeInputs(prizes, signer = wallet.address, winner = wallet.address) {
     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]] : [])));
+    out.boxes = await boxesOf(prizes.filter(Boolean).flatMap(p => (p.Roll ? [p.Roll[0]] : [])));
     for (const prize of prizes.filter(Boolean)) {
       const pool = prize.Tokens?.from.Pool?.[0];
       if (pool !== undefined && !(pool in out.poolMints)) {
@@ -297,33 +385,50 @@ 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 lockedIn = async asset => {
     const seated = await seatedIn(asset, ['freeze']);
     if (!seated) return null;
     const account = await client.account(asset);
@@ -331,7 +436,9 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
   };
   /** 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;
@@ -342,7 +449,10 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * 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 })];
+    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
@@ -360,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) {
@@ -379,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}.`,
+    );
   }
 
   /**
@@ -425,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;
   }
 
   /**
@@ -465,13 +591,27 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     // 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], standing: await standing() }).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);
@@ -482,7 +622,11 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * 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 }));
+    const settled = p =>
+      p.then(
+        signature => ({ signature }),
+        e => ({ error: e.message }),
+      );
     let signed = null;
     let messages = [];
     let lastValidBlockHeight = null;
@@ -490,10 +634,18 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       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));
+      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));
+      if (back) signed = messages.map(m => (m ? back.shift() : null));
     }
     const out = [];
     for (const [i, l] of lists.entries()) {
@@ -516,13 +668,22 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
   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 });
+    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,
+    });
   }
 
   /**
@@ -531,7 +692,16 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    */
   async function sendAs(key, instructions) {
     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;
+    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;
   }
 
   /**
@@ -542,12 +712,50 @@ 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.`,
+        );
     }
   }
 
@@ -565,13 +773,19 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    */
   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) };
+    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))));
+  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
@@ -581,7 +795,7 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     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) => {
+    const r = await client.simulate(wireTransaction(message), { accounts: watch, replaceBlockhash: true }).catch(e => {
       error = loot.lootError(e?.logs ?? []);
       return null;
     });
@@ -592,7 +806,8 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * 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);
+    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);
@@ -618,7 +833,13 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * 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 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];
@@ -634,20 +855,36 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       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));
+      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' });
+    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.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 }));
+    for (const [k, [orderAddress]] of waiting.entries())
+      rolls.push(await collect(orderAddress, { burner: burners[k], opened: true }));
     return { signature, rolls };
   }
 
@@ -669,12 +906,16 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const { burner } = options;
       if (!burner) throw e;
       await emptyKey(burner);
-      if (!(await client.account(orderAddress))) return { order: orderAddress, settled: 'elsewhere', says: 'The order was settled already.' };
+      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, keepBurner = false } = {}) {
+  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 () => {
@@ -700,16 +941,29 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     }
     // 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.');
+      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 && !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++) {
@@ -727,17 +981,26 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     }
     // 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 {};
+      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 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))) {
+      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 };
+      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.
@@ -753,15 +1016,34 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         if (won.Nft && !putBack.includes(won.Nft.nft)) {
           // 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 });
+          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 && 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) };
+      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
@@ -772,9 +1054,12 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     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)));
+    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;
@@ -797,16 +1082,18 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     // 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 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 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);
+      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);
     }
@@ -818,8 +1105,15 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     // 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) } : {}) };
+    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) } : {}),
+    };
   }
 
   /**
@@ -827,7 +1121,7 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * over; null for tokens. A normal item is the project's backend's to deliver.
    */
   function wonAssets(order) {
-    return order.won.map((won) => {
+    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;
       // A compressed NFT's asset id is the tree's count when it was minted: read from its settle's receipt or the
@@ -849,7 +1143,7 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
   /** 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)) {
+    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));
     }
@@ -858,9 +1152,18 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
 
   /** 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]),
+    );
   }
 
   /** The instructions that ask the oracle for the roll of `order` (at `orderAddress`), `payer` paying it. Each prize
@@ -869,15 +1172,30 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
   async function asksFor(payer, orderAddress, order, settler) {
     const box = await read('LootBox', order.loot_box);
     const poolMints = await poolMintsOf(box);
-    const mints = [...Object.values(poolMints), ...box.entries.flatMap((e) => e.prizes.map((p) => p.Tokens?.from.Mint?.[0]))].filter((x) => x && !programs[x]);
+    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 });
+    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)))]);
+    return send([
+      computeUnitLimit(400_000),
+      ...(await asksFor(wallet.address, orderAddress, await read('Order', orderAddress))),
+    ]);
   }
 
   /**
@@ -887,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;
   }
 
@@ -901,10 +1226,13 @@ 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', 'count'];
@@ -919,20 +1247,43 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * 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, count = 1, orNull = false } = {}) {
+  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));
     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);
+    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, count, treasury: g.treasury, chosenRecipient, chosen: choosesHolder ? chosenRecipient : null, nonce, shown, listProof, items: given.items, poolMints: given.poolMints, nfts: given.nfts, 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 gives = loot.buyGives(box, count);
     const assets = gives.map(({ prize, k }) => {
@@ -940,20 +1291,35 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         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 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]);
+    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;
+      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 } : {}) };
+    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 } : {}),
+    };
   }
 
   /**
@@ -963,19 +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, count = 1 } = {}) {
+  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));
     // `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);
+    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;
@@ -983,9 +1366,12 @@ 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;
     // 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.
@@ -994,10 +1380,36 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     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 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))];
+    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 solPrize = false;
     if (oneSignature) {
@@ -1005,13 +1417,24 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       // 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);
@@ -1019,25 +1442,47 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     // 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 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);
+        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, 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)));
+    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: addresses[0], orderAddresses: addresses, burner: burners[0] ?? null, burners, landed };
+    return {
+      signature,
+      orderAddress: addresses[0],
+      orderAddresses: addresses,
+      burner: burners[0] ?? null,
+      burners,
+      landed,
+    };
   }
 
   /**
@@ -1046,13 +1491,22 @@ 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`: a shop item, a bundle, a fixed pack of any count), or
@@ -1066,11 +1520,19 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       if (bought) return bought;
     }
     const { orderAddresses, burners, landed } = await open(boxId, part, options);
-    if (orderAddresses.length === 1) return collect(orderAddresses[0], { burner: burners[0] ?? null, opened: true, landed });
+    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]) };
+    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 (a later ask or a refund of a failed order needs a later slot; an order's deadlines count in seconds: `chainNow`). */
@@ -1100,8 +1562,17 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
   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))];
+    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)),
+    ];
   }
 
   /**
@@ -1112,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 }. */
@@ -1131,11 +1607,16 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
   async function roundOf(l) {
     const address = loot.pda.lottery(project, l.id);
     const lottery = await read('Lottery', address);
-    const back = [1, 2].filter((k) => lottery.round >= k).map((k) => loot.pda.round(address, lottery.incarnation, lottery.round - k));
+    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) };
+    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) };
   }
 
   /**
@@ -1145,7 +1626,7 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    */
   async function hookTail(mints) {
     const out = new Map();
-    for (const mint of new Set(mints.filter((x) => x && x !== NOBODY))) {
+    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);
@@ -1155,7 +1636,14 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     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]))];
+  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) {
@@ -1169,12 +1657,38 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     return out;
   }
 
-  /** The ask for a round's draw (`round` decoded, `key` its address; null for the current round with no record). */
+  /** 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));
-    return [computeUnitLimit(600_000), loot.drawLotteryIx({ payer: signer, project, id: l.id, lottery, round, roundAddress: key, poolMints, extra })];
+    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,
+      }),
+    ];
   }
 
   /**
@@ -1183,16 +1697,38 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
    * 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);
+    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 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);
+    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;
   }
 
@@ -1203,7 +1739,9 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
   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;
+    return part.Pot || loot.tokenRun(r, run)
+      ? loot.placesPulled(r, i, run, Boolean(part.Prize))
+      : loot.prizePlacesOwed(r, i, run).length;
   };
 
   /**
@@ -1217,7 +1755,7 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     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)]);
+    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) {
@@ -1234,7 +1772,9 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         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;
+        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)) {
@@ -1245,16 +1785,36 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
             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() };
+        const stashes = given.Nft
+          ? {
+              [given.Nft.stash]: loot.decodeStash(
+                (await client.account(loot.pda.stash(project, given.Nft.stash)))?.data ?? null,
+              ) ?? { nfts: [] },
+            }
+          : {};
+        more.prize = {
+          stash,
+          stashes,
+          nfts: inputs.nfts,
+          collection: inputs.collection,
+          poolMints: inputs.poolMints,
+          items: inputs.items,
+          projectMint: mintOf(),
+        };
         more.nonce = pullNonce(key, i);
         rolls.push(...loot.pullRolls({ project, round: r, entry: i, part, nonce: more.nonce }));
       } else if (part.Common) {
-        // Where a part owed in common goes: a share's payee (a collectible's holder now), the pot, a pool; one that can't
-        // take it (a pool never opened, the pot closed since, an account gone) sends it to the treasury.
+        // 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 ? { Account: [loot.pda.pot(r.lottery)] } : r.terms.places[Number(r.prizes[c - n - 1].run)].prize.Tokens.from;
+        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.
@@ -1264,7 +1824,20 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       }
       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 }));
+      out.push(
+        loot.pullIx({
+          payer: signer,
+          project,
+          roundAddress: key,
+          round,
+          entry: i ?? 0,
+          part,
+          projectState: g,
+          programs,
+          extra,
+          ...more,
+        }),
+      );
     }
     return { instructions: out, rolls };
   }
@@ -1277,13 +1850,23 @@ 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,
+        };
       });
     },
 
@@ -1291,11 +1874,23 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
      * (`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), whenOut: box?.when_out === 'DrawLeft' ? 'drawLeft' : 'stopSales', 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,
+          })),
+        };
       });
     },
 
@@ -1335,16 +1930,25 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     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 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);
+      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()])];
+      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 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()) {
@@ -1356,8 +1960,12 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         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 }) });
+          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 {
@@ -1372,14 +1980,18 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     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). 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),
+    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
@@ -1396,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]));
     },
 
@@ -1422,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 })]);
     },
@@ -1438,15 +2084,25 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       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 { 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 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,
+          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;
@@ -1461,31 +2117,54 @@ 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.`);
+      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) : [];
+      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.`);
+      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(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 (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);
@@ -1500,13 +2179,30 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       }
       const mint = loot.paymentMint(terms);
       const { shares } = terms;
-      const choosesHolder = shares.some((s) => s.to.Chosen && s.to.Chosen.item != null);
+      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 });
+      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.
@@ -1514,14 +2210,42 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         const g = await projectNow();
         const entry = { buyer: wallet.address, nft: paidWith, start: 0n, end: 1n, amount: 0n, paid: 0n };
         for (const status of ['Drawn', 'Cancelled']) {
-          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 })];
+          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 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.`);
+            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.`,
+            );
         }
       }
       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);
+      return send(
+        draw.length
+          ? [computeUnitLimit(800_000), ...draw, ...buy.filter(x => x.programId !== COMPUTE_BUDGET_PROGRAM)]
+          : buy,
+      );
     },
 
     /**
@@ -1552,13 +2276,27 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       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.');
+        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], [], { extra, transfers });
-      const ix = loot.stakeTokensIx({ player: wallet.address, project, id: f.id, farm, amount: value, tier, shown, ...token });
+      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) : [];
+      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])]));
     },
 
@@ -1579,9 +2317,18 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       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 }));
+        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 })]));
+      return send(
+        await walking(f, farm, [
+          ...token.before,
+          ...first,
+          loot.unstakeTokensIx({ player: wallet.address, project, id: f.id, farm, amount: value, forfeit, ...token }),
+        ]),
+      );
     },
 
     /**
@@ -1596,20 +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). 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.`);
+        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(await walking(f, farm, [...refresh, ...before, 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 }),
+        ]),
+      );
     },
 
     /**
@@ -1622,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));
@@ -1642,13 +2405,41 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         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.`);
+          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 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;
+      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;
     },
 
     /**
@@ -1673,7 +2464,8 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       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]));
+      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;
     },
 
@@ -1691,7 +2483,12 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       const held = seat.asset !== NOBODY;
       const { before, ...nft } = held ? await nftOf(seat.asset) : { before: [], hasAuthority: true };
       // 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 ?? [] })]));
+      return send(
+        await walking(f, farm, [
+          ...before,
+          loot.refreshSeatIx({ signer: wallet.address, project, id: f.id, farm, by, seat, ...nft, extra: extra ?? [] }),
+        ]),
+      );
     },
 
     /**
@@ -1717,7 +2514,14 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       // 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 })]));
+      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 }),
+        ]),
+      );
     },
 
     /**
@@ -1745,13 +2549,15 @@ 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';
       // 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 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);
       });
@@ -1760,7 +2566,8 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       // (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 = [];
@@ -1774,7 +2581,9 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
           const by = nfts ? seat.asset : player;
           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.
@@ -1803,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 };
@@ -1821,16 +2630,22 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       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 };
-      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.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)] : [])));
@@ -1840,39 +2655,47 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       // One a `staked` line takes: on its seat in the farm the line names, escrowed or frozen there.
       const stakedAt = new Map(recipe.inputs.flatMap((input, i) => (input.Staked ? [[at(i), input.Staked.farm]] : [])));
       // The places a raise lowers a number on.
-      const lowered = new Set((recipe.raises ?? []).filter((raise) => BigInt(raise.shift.by) < 0n).map((raise) => Number(raise.place)));
-      const handed = await Promise.all(assets.map(async (nft, i) => {
-        if (stakedAt.has(i) && typeof nft === 'string') {
-          const farm = stakedAt.get(i);
-          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.`);
+      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)) ?? (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 };
-      }));
+          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);
+      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();
+      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) {
@@ -1881,31 +2704,62 @@ 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(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 })];
+      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.shift.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);
       // 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 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] } : {}) };
     },
@@ -1917,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 };
     },
 
@@ -1934,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 };
@@ -1954,14 +2836,32 @@ 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) };
     },
 
@@ -1972,7 +2872,13 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     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 };
+      return {
+        lender: hold.debt.lender,
+        mint: hold.debt.mint,
+        repay: BigInt(hold.debt.repay),
+        due: Number(hold.free_at),
+        borrower: hold.player,
+      };
     },
 
     /**
@@ -1988,22 +2894,48 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       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.`);
+      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 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 { 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]));
+      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 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 };
@@ -2022,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,
+          }),
+        ]),
+      );
     },
 
     /**
@@ -2036,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);
@@ -2090,7 +3059,8 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         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.`);
+        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 });
@@ -2102,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));
@@ -2113,11 +3093,25 @@ 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 });
     },
 
@@ -2134,19 +3128,46 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       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 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.pin) : 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) {
@@ -2156,25 +3177,77 @@ 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 });
-      let all = [computeUnitLimit(800_000), ...before.filter((x) => x.programId !== COMPUTE_BUDGET_PROGRAM), ix];
+      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;
+      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 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 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 })];
+            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;
@@ -2185,9 +3258,25 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       }
       // 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] } : {}) };
+      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] } : {}),
+      };
     },
 
     /**
@@ -2209,11 +3298,26 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       // 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;
       // 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 })]);
+      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
@@ -2226,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,
+        }),
+      ]);
     },
 
     /**
@@ -2237,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. */
@@ -2260,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);
@@ -2277,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,
+          }),
+        ]),
+      ]);
     },
 
     /**
@@ -2291,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. */
@@ -2308,17 +3469,43 @@ 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;
       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 })]);
+      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 } }, lotteryState })]);
     },
@@ -2327,7 +3514,18 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
     async unraffle(id, nft) {
       const { before, hasAuthority: _, ...piece } = await nftOf(nft, wallet.address, { to: wallet.address });
       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 })]);
+      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. */
@@ -2348,7 +3546,14 @@ 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);
@@ -2357,7 +3562,10 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       // 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 [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).
@@ -2369,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, rounds: voucher.rounds, 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);
@@ -2396,10 +3631,39 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       // 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;
-      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 }));
+      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)];
+      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);
@@ -2424,45 +3688,62 @@ 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 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)));
+        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 = [];
@@ -2480,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 }));
               }
@@ -2511,56 +3801,112 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
      * 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.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());
       const chainTime = await chainNow();
-      for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [tag('Order'), at(1, project), at(33, me)])) {
+      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);
-        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).' });
+        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('Contest'), at(1, project)])) {
+      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 (!(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;
+        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;
+        const picks =
+          won && contest.nft && !(entry.bits & loot.ENDED) && Number(entry.taken) < loot.shareOf(contest, entry);
+        const owed =
+          (contest.nft ? Number(entry.amount) === 1 && (off || won) : BigInt(entry.amount) > 0n && (off || first)) ||
+          first ||
+          picks;
         if (!owed) continue;
-        const says = off ? 'Your entry back: the contest is off.' : contest.nft ? `Your NFT back${picks ? ', and your pick of the losers’' : ''}.` : contest.prize != null ? 'Your share of the pot, and your prize.' : 'Your share of the pot.';
-        out.push({ kind: 'contest', id: contest.id, side: entry.side, says });
+        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) } : {}),
+        });
       }
       // 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();
+      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.' });
+        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)])) {
+      for (const { pubkey, account } of await client.programAccounts(loot.LOOT_PROGRAM, [
+        tag('Hold'),
+        at(1, project),
+      ])) {
         const hold = loot.decode('Hold', account.data);
-        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.' });
+        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')])) {
@@ -2571,50 +3917,106 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
             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.' });
+        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 || 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.` });
+          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.` });
+        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 { current, rounds } = await roundOf(l);
-        const bought = (r) => r.entries.some((e) => e.buyer === me);
+        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.` });
+          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.`,
+          });
         }
         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 (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}”.` });
+          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 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.` });
+            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.`,
+            });
         }
       }
       // A farm idle past more ends than a move can walk: anyone may walk it, in parts.
@@ -2622,7 +4024,12 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         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.` });
+        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 ?? []) {
@@ -2632,21 +4039,34 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
           // 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.` });
+          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
@@ -2661,9 +4081,22 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         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;
     },
@@ -2679,7 +4112,7 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       // `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 send = build ? async instructions => instructions : sendNow;
       const g = await projectNow();
       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
@@ -2694,7 +4127,7 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         const contestAddress = loot.pda.contest(project, c.id);
         const contest = await read('Contest', contestAddress);
         const entries = loot.decodeEntries((await client.account(loot.contestEntries(contestAddress, contest))).data);
-        const i = entries.findIndex((e) => e.player === me);
+        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]);
@@ -2713,16 +4146,41 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
             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 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.`);
+          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);
           }
         }
-        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 })];
+        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);
       }
@@ -2730,7 +4188,20 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         const hold = await read('Hold', c.hold);
         const { before, hasAuthority: _, ...nft } = await nftOf(c.asset, me, { to: me });
         // 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 } : {}) })]);
+        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 === 'close-leaf') return send([loot.closeLeafIx({ asset: c.asset, tree: c.tree, payer: me })]);
@@ -2741,12 +4212,22 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         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);
       // 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 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;
@@ -2757,7 +4238,10 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         // 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)];
+          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);
@@ -2774,25 +4258,30 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         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 (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);
       }
       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 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));
+        instructions.push(...built.instructions.filter(x => x.programId !== COMPUTE_BUDGET_PROGRAM));
         rolls.push(...built.rolls);
       }
       // A place's roll is asked for in the pull's own transaction (catalog P1): the winner's own, with a key that settles
@@ -2800,7 +4289,8 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
       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) })));
+      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);
@@ -2823,14 +4313,22 @@ export function solanaApp({ spec, rpcUrl = 'https://api.devnet.solana.com', rpc
         }
         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));
+        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 })));
+      for (const claim of alone)
+        out.push(
+          await this.claim(claim).then(
+            signature => ({ claim, signature }),
+            e => ({ claim, error: e.message }),
+          ),
+        );
       return out;
     },
 
@@ -2845,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;
     },
   };
 }
-