@xgamesfun/solana 0.20.1 → 0.25.0

package/js/economy/plan.mjs

@@ -7,16 +7,71 @@
 // which signs the step that creates it. `placeholderContext` fills every address with a stand-in, so a plan can be
 // sized and shown before anyone connects a wallet.
 import { encodeBase58 } from '../chain/base58.js';
+import { encodeBorsh } from '../chain/borsh.js';
+import IDL from '../client/idl/loot.js';
 import { createCollectionInstruction } from '../chain/core.js';
-import { NATIVE_MINT, TOKEN_2022_PROGRAM, TOKEN_PROGRAM } from '../chain/pda.js';
+import {
+  ASSOCIATED_TOKEN_PROGRAM,
+  NATIVE_MINT,
+  SYSTEM_PROGRAM,
+  SYSVAR_INSTRUCTIONS,
+  SYSVAR_SLOT_HASHES,
+  TOKEN_2022_PROGRAM,
+  TOKEN_PROGRAM,
+} from '../chain/pda.js';
+import { createTableIx, extendTableIx } from '../chain/lookup.js';
+import { MEMO_PROGRAM } from '../chain/token2022.js';
 import { createAssociatedTokenAccountIdempotent, syncNative, transferLamports } from '../chain/programs.js';
-import { createAccountIx, initializeMint2Ix, MINT_BYTES, mintToIx, setAuthorityIx, transferCheckedIx } from '../chain/token.js';
+import {
+  createAccountIx,
+  initializeMint2Ix,
+  MINT_BYTES,
+  mintToIx,
+  setAuthorityIx,
+  transferCheckedIx,
+} from '../chain/token.js';
 import { compileMessage, transactionSize } from '../chain/tx.js';
 import { sha256 } from '../chain/sha256.js';
 import { utf8 } from '../chain/bytes.js';
 import * as loot from '../client/index.js';
 import { check } from './check.mjs';
-import { ACCOUNT_OVERHEAD, boxBuys, boxRolls, compressedTree, destination, effectOf, gateOf, LIMITS, listOf, lotterySplit, model, MOST_RENT_PER_BYTE, outcomeBurns, outcomeParts, perWalletOf, placeOf, prizeLine, prizePool, prizeRolls, prizeToken, rarityNumber, ruleOf, sharesOf, spendOf, stashNfts, toBy, toEnum, toSeconds, toTime, toUnits, weights, wholeCount, windowOf } from './model.mjs';
+import {
+  ACCOUNT_OVERHEAD,
+  boxBuys,
+  rent,
+  RENT_PER_BYTE,
+  boxRolls,
+  compressedTree,
+  destination,
+  effectOf,
+  gateOf,
+  listOf,
+  lotterySplit,
+  model,
+  MOST_RENT_PER_BYTE,
+  paysFromOf,
+  outcomeParts,
+  perWalletOf,
+  placeOf,
+  lifeLines,
+  prizeLine,
+  prizePool,
+  prizeRolls,
+  prizeToken,
+  rarityNumber,
+  ruleOf,
+  sharesOf,
+  spendOf,
+  stashNfts,
+  toBy,
+  toEnum,
+  toSeconds,
+  toTime,
+  toUnits,
+  weights,
+  wholeCount,
+  windowOf,
+} from './model.mjs';
 import { BUDGET } from './txsize.mjs';
 
 const owner = 'owner';
@@ -24,17 +79,27 @@ const owner = 'owner';
 export const PER_APPROVAL = 12;
 
 const amount = (value, t) => toUnits(value ?? 0, t?.decimals ?? 0);
-const shares = (split, m) => sharesOf(split).map((s) => ({ to: toEnum(s.to, m), bps: s.bps ?? 0 }));
-const rise = (r, t) => (r ? { step: amount(r.step ?? 0, t), growth_bps: Math.round((r.growthPercent ?? 0) * 100) } : null);
-const fall = (f, t, now) => (f ? { step: amount(f.step, t), every: toSeconds(f.every), floor: amount(f.floor ?? 0, t), since: BigInt(toTime(f.start, now)), shared: f.clock === 'shared' } : null);
-const tokenProgramOf = (t) => (t?.program === 'token-2022' ? TOKEN_2022_PROGRAM : TOKEN_PROGRAM);
+const shares = (split, m) => sharesOf(split).map(s => ({ to: toEnum(s.to, m), bps: s.bps ?? 0 }));
+const rise = (r, t) =>
+  r ? { step: amount(r.step ?? 0, t), growth_bps: Math.round((r.growthPercent ?? 0) * 100) } : null;
+const fall = (f, t, now) =>
+  f
+    ? {
+        step: amount(f.step, t),
+        every: toSeconds(f.every),
+        floor: amount(f.floor ?? 0, t),
+        since: BigInt(toTime(f.start, now)),
+        shared: f.clock === 'shared',
+      }
+    : null;
+const tokenProgramOf = t => (t?.program === 'token-2022' ? TOKEN_2022_PROGRAM : TOKEN_PROGRAM);
 
 // ---------------------------------------------------------------- spec parts → the program's args
 
-export function itemArgs(it) {
+export function itemArgs(it, m) {
   const kind = it.kind === 'normal' ? 'Normal' : 'Collectible';
-  // A collectible is minted into its own `collection`, or the one the setup makes ("@collection" until it exists).
-  const life = it.life && kind !== 'Normal' ? { ready_after: toSeconds(it.life.readyAfter), lasts: toSeconds(it.life.lasts), uses: it.life.uses ?? 0, cooldown: toSeconds(it.life.cooldown) } : null;
+  // A collectible is minted into its own `collection`, or the one the setup makes ("@collection" until it exists). Its
+  // life is written into each recipe that takes it (`lifeLines`).
   return {
     kind,
     rarity: rarityNumber(it.rarity),
@@ -43,19 +108,73 @@ export function itemArgs(it) {
     name: it.name,
     uri: it.uri ?? '',
     max_supply: it.supply ?? 0,
-    life,
     active: it.active !== false,
-    collection: kind === 'Normal' ? NOBODY : it.collection ?? '@collection',
+    collection: kind === 'Normal' ? NOBODY : (it.collection ?? '@collection'),
+    // A fresh collectible's traits, each drawn per unit (a table's row, or a number in a range).
+    traits:
+      kind === 'Normal'
+        ? []
+        : (it.drawn ?? []).map(t => ({
+            key: t.attribute,
+            from:
+              t.table !== undefined
+                ? { Table: [m?.table.get(t.table)?.id ?? 0] }
+                : { Range: { min: BigInt(t.min ?? 0), max: BigInt(t.max ?? 0) } },
+          })),
   };
 }
 
+/**
+ * The bytes of an order of box `b` (`orderBytes`), its spec's names standing in as addresses, with the shares its split
+ * stores. `opened`: an open's (`open_box`, `Order::sized`: each draw at its dearest outcome's prizes as they are kept,
+ * rows only for the tables its fresh items draw); otherwise a roll made inside another call (a craft, a grant's claim,
+ * a mission, a lottery's place, a roll lot: `Order::space_for`, the box's whole table budget a draw).
+ */
+export const boxOrderBytes = (b, m, opens = 1, { opened = false } = {}) => {
+  const args = boxArgs(b, m);
+  const items = opened ? Object.fromEntries(m.items.map(it => [it.id, itemArgs(it, m)])) : undefined;
+  return loot.orderBytes(placeholders(args), (args.shares ?? []).length, opens, items);
+};
+
+/** The most bytes of rows one table write carries: what a 1,232-byte transaction leaves after the upsert's accounts,
+ * its signature and its own bytes. */
+export const TABLE_BATCH_BYTES = 800;
+
+/** A spec table's rows as the program takes them ({ weight, left, label }), in batches that fit a transaction each. */
+export function tableBatches(t) {
+  const rows = t.rows.map(r => ({
+    weight: r.weight,
+    left: r.stock ?? 4294967295,
+    label: t.kind === 'numbers' ? '' : String(r.label ?? ''),
+  }));
+  const batches = [[]];
+  let bytes = 0;
+  for (const r of rows) {
+    const size = 12 + new TextEncoder().encode(r.label).length;
+    if (bytes + size > TABLE_BATCH_BYTES && batches.at(-1).length) (batches.push([]), (bytes = 0));
+    batches.at(-1).push(r);
+    bytes += size;
+  }
+  return batches;
+}
+
 /** The program's `Prize` for one part of a box outcome (`model.outcomeParts`). */
 export function partPrize(o, m) {
+  // An item, or a compressed NFT of it, minted at the settle into the project's tree.
+  if (o.gives === 'item' && o.compressed) return { Compressed: { item: m.item.get(o.item)?.id ?? 0, tree: '@tree' } };
   if (o.gives === 'item') return { Item: [m.item.get(o.item)?.id ?? 0] };
   if (o.gives === 'stash') return { Stash: [m.stash.get(o.stash)?.id ?? 0] };
-  if (o.gives === 'pay') return { Tokens: { from: { Pool: [m.pool.get(o.pool)?.index ?? 0] }, amount: { Fixed: [amount(o.amount, m.poolToken(o.pool))] } } };
-  if (o.gives === 'share') return { Tokens: { from: { Pool: [m.pool.get(o.pool)?.index ?? 0] }, amount: { Bps: [Math.round((o.percent ?? 0) * 100)] } } };
-  if (o.gives === 'mint') return { Tokens: { from: { Mint: [`@mint:${o.currency ?? m.currencyKey}`] }, amount: { Fixed: [amount(o.amount, m.tokens.get(o.currency ?? m.currencyKey))] } } };
+  if (o.gives === 'pay')
+    return {
+      Tokens: { from: { Pool: [m.pool.get(o.pool)?.index ?? 0] }, amount: amount(o.amount, m.poolToken(o.pool)) },
+    };
+  if (o.gives === 'mint')
+    return {
+      Tokens: {
+        from: { Mint: [`@mint:${o.currency ?? m.currencyKey}`] },
+        amount: amount(o.amount, m.tokens.get(o.currency ?? m.currencyKey)),
+      },
+    };
   return prizeArgs(o, m);
 }
 
@@ -68,60 +187,95 @@ export function boxArgs(b, m) {
     rise: rise(b.rise, t),
     fall: fall(b.fall, t, m.now),
     stock_odds: !!b.stockOdds,
+    when_out: b.whenOut === 'drawLeft' ? 'DrawLeft' : 'StopSales',
     active: b.active !== false,
     shares: shares(b.split, m),
-    // An entry gives its prizes (a bundle up to three), and may burn the payment in place of the split.
-    entries: (b.outcomes ?? []).map((o, i) => ({ prizes: outcomeParts(o).map((part) => partPrize(part, m)), burns: outcomeBurns(o), weight: w[i] })),
+    // What one open draws: each slot so many draws among the outcomes it names (all, when none), no outcome twice
+    // when distinct. None is one draw among every outcome.
+    slots: (b.slots ?? []).map(s => ({
+      count: s.count,
+      only: s.from ?? [],
+      distinct: Boolean(s.distinct),
+      share: Math.round((s.share ?? 0) * 100),
+    })),
+    // An entry gives its prizes (a bundle of any number), and may burn the payment in place of the split.
+    entries: (b.outcomes ?? []).map((o, i) => ({
+      prizes: outcomeParts(o).map(part => partPrize(part, m)),
+      weight: w[i],
+    })),
     gate: gateOf(b.gate, m),
-    odds: (b.odds ?? []).map((o) => ({ entry: o.outcome, boost: { rule: ruleOf(o.when, m), effect: effectOf(o.add) } })),
+    odds: (b.odds ?? []).map(o => ({ entry: o.outcome, boost: { rule: ruleOf(o.when, m), effect: effectOf(o.add) } })),
     window: windowOf(b, m.now),
     per_wallet: perWalletOf(b),
     // A box that rolls on an NFT: the rule it must pass, and what each outcome does to it.
     subject: b.rollsOn ? ruleOf(b.rollsOn, m) : null,
     fates: (b.outcomes ?? []).flatMap((o, i) => {
-      const shifts = (o.shifts ?? []).map((x) => ({ key: x.attribute, by: toBy(x.by), most: toSeconds(x.upTo ?? 0), from_now: Boolean(x.fromNow) }));
+      const shifts = (o.shifts ?? []).map(x => ({
+        key: x.attribute,
+        by: toBy(x.by),
+        most: toSeconds(x.upTo ?? 0),
+        from_now: Boolean(x.fromNow),
+      }));
       // An outcome's own `then`, or the box's: an NFT taken as its price goes there whatever the roll gives.
       const then = thenOf(o.then ?? b.then, m);
-      return shifts.length || then !== 'Back' ? [{ entry: i, shifts, then }] : [];
+      return shifts.length || then !== null ? [{ entry: i, shifts, then }] : [];
     }),
   };
 }
 
-/** Where an outcome sends the NFT a box rolls on: back, burned, given (the treasury's wallet is filled in when the economy goes live), or into a stash. */
+/** Where an outcome sends the NFT a box rolls on: back (null), burned, given (the treasury's wallet is filled in when the economy goes live), or into a stash. */
 export const thenOf = (then, m) => {
-  if (!then || then === 'back') return 'Back';
+  if (!then || then === 'back') return null;
   if (then === 'burn') return 'Burn';
   if (then.stash) return { Stash: [m?.stash.get(then.stash)?.id ?? 0] };
   return { Give: [then === 'treasury' ? '@treasury' : then.giveTo] };
 };
 
-/** The most a raise names (a u32): a farm’s time moved as written, with no cap of its own until 2106. */
-const NO_CAP = 4_294_967_295;
-/** Whether `key` is a time a farm of the spec keeps on what it stakes (its lock, its upkeep). */
-const farmTime = (key, m) => m.farms.some((f) => f.lockAttribute === key || f.upkeepAttribute === key);
-
 export function recipeArgs(r, m) {
-  const tok = (key) => m.tokens.get(key ?? m.currencyKey);
-  const inputs = (r.in ?? []).map((l) => {
+  const tok = key => m.tokens.get(key ?? m.currencyKey);
+  const inputs = (r.in ?? []).map(l => {
     if (l.takes === 'burn') return { Burn: { item: m.item.get(l.item)?.id ?? 0, count: l.count ?? 1 } };
     if (l.takes === 'use') return { Use: { item: m.item.get(l.item)?.id ?? 0 } };
     // A staked one names the farm it sits in (craft.rs): the craft takes it only from its seat there.
-    if (l.takes === 'staked') return { Staked: { item: m.item.get(l.item)?.id ?? 0, farm: m.farm.get(l.farm)?.id ?? 0 } };
-    if (l.takes === 'renew') return { Renew: { item: m.item.get(l.item)?.id ?? 0 } };
+    if (l.takes === 'staked')
+      return { Staked: { item: m.item.get(l.item)?.id ?? 0, farm: m.farm.get(l.farm)?.id ?? 0 } };
+    // A renew keeps the collectible as a use does; its life's raise counts its uses from 0 again (`lifeLines`).
+    if (l.takes === 'renew') return { Use: { item: m.item.get(l.item)?.id ?? 0 } };
     if (l.takes === 'show') return { Show: { collection: l.collection ?? '@collection' } };
     // A trade-in: one NFT of `collection`, any kind, burned, given on, or put in a stash.
     if (l.takes === 'trade') return { Trade: { collection: l.collection ?? '@collection', then: spendOf(l.then, m) } };
-    return { Pay: { mint: `@mint:${l.currency ?? m.currencyKey}`, amount: amount(l.amount, tok(l.currency)), to: toEnum(l.to, m) } };
+    return {
+      Pay: {
+        mint: `@mint:${l.currency ?? m.currencyKey}`,
+        amount: amount(l.amount, tok(l.currency)),
+        to: toEnum(l.to, m),
+      },
+    };
   });
+  const life = lifeLines(r, m);
   // A line is a prize (prize.rs), or a roll on a collectible it keeps (`on`).
-  const outputs = (r.out ?? []).map((l) => (l.gives === 'roll' && l.on !== undefined ? { RollOn: { box_id: m.box.get(l.box)?.id ?? 0, place: l.on } } : { Prize: [prizeArgs(l, m)] }));
+  const outputs = (r.out ?? []).map(l =>
+    l.gives === 'roll' && l.on !== undefined
+      ? { RollOn: { box_id: m.box.get(l.box)?.id ?? 0, place: l.on } }
+      : { Prize: [prizeArgs(l, m)] },
+  );
   return {
     active: r.active !== false,
     inputs,
     outputs,
-    needs: (r.needs ?? []).map((n) => ({ place: n.place, key: n.key, at_least: n.atLeast })),
-    keeps: (r.keeps ?? []).map((k) => ({ key: k.key, from: k.from, to: k.to })),
-    raises: (r.raises ?? []).map((x) => ({ place: x.place, key: x.key, by: toBy(x.by), most: x.upTo === undefined && farmTime(x.key, m) && !x.fromNow ? NO_CAP : toSeconds(x.upTo ?? 0), from_now: Boolean(x.fromNow) })),
+    // The recipe's own needs and raises, then what the life of each collectible it takes adds (`lifeLines`).
+    needs: [
+      ...(r.needs ?? []).map(n => ({ place: n.place, key: n.key, test: { AtLeast: [n.atLeast ?? 0] } })),
+      ...life.needs,
+    ],
+    keeps: (r.keeps ?? []).map(k => ({ key: k.key, from: k.from, to: k.to })),
+    raises: [
+      ...(r.raises ?? []).map(x => ({
+        place: x.place,
+        shift: { key: x.key, by: toBy(x.by), most: toSeconds(x.upTo ?? 0), from_now: Boolean(x.fromNow) },
+      })),
+      ...life.raises,
+    ],
     window: windowOf(r, m.now),
     per_wallet: perWalletOf(r),
   };
@@ -129,11 +283,18 @@ export function recipeArgs(r, m) {
 
 export function scheduleArgs(s, m) {
   const every = toSeconds(s.every);
-  const poolOf = (key) => m.pool.get(key)?.index ?? 0;
+  const poolOf = key => m.pool.get(key)?.index ?? 0;
   let action;
   if (s.does === 'issue') {
-    const t = m.tokens.get(s.currency ?? m.pool.get(s.pool)?.currency);
-    action = { from: { Mint: [`@mint:${t?.key}`] }, to: { Pool: [poolOf(s.pool)] }, amount: { Fixed: [amount(s.amount, t)] }, halve_every: s.halveEvery ?? 0 };
+    // Minted into a pool, or into a farm's rewards vault ("to": "farm:<key>"): an emission its stakers share.
+    const farm = destination(s.to ?? '').kind === 'farm' ? m.farm.get(destination(s.to).key) : null;
+    const t = m.tokens.get(s.currency ?? (farm ? farm.rewardsToken : m.pool.get(s.pool)?.currency));
+    action = {
+      from: { Mint: [`@mint:${t?.key}`] },
+      to: farm ? toEnum(s.to, m) : { Pool: [poolOf(s.pool)] },
+      amount: { Fixed: [amount(s.amount, t)] },
+      halve_every: s.halveEvery ?? 0,
+    };
   } else if (s.sealed) {
     // A sealed schedule pays from its own vault, in `currency`.
     const t = m.tokens.get(s.currency ?? m.currencyKey);
@@ -146,7 +307,13 @@ export function scheduleArgs(s, m) {
     const how = s.percent !== undefined ? { Bps: [Math.round(s.percent * 100)] } : { Fixed: [amount(s.amount, t)] };
     action = { from: { Pool: [poolOf(from)] }, to, amount: how, halve_every: s.halveEvery ?? 0 };
   }
-  return { active: s.active !== false, action, every: BigInt(every), next_at: BigInt(s.start ? toTime(s.start, m.now) : m.now + every), max_runs: s.maxRuns ?? 0 };
+  return {
+    active: s.active !== false,
+    action,
+    every: BigInt(every),
+    next_at: BigInt(s.start ? toTime(s.start, m.now) : m.now + every),
+    max_runs: s.maxRuns ?? 0,
+  };
 }
 
 /**
@@ -155,16 +322,18 @@ export function scheduleArgs(s, m) {
  */
 export function prizeArgs(p, m) {
   const line = prizeLine(p);
-  if (line.gives === 'item' && line.compressed) return { Compressed: { item: m.item.get(line.item)?.id ?? 0, tree: '@tree' } };
+  if (line.gives === 'item' && line.compressed)
+    return { Compressed: { item: m.item.get(line.item)?.id ?? 0, tree: '@tree' } };
   if (line.gives === 'item') return { Item: [m.item.get(line.item)?.id ?? 0] };
   // An NFT a lottery's place holds in the lottery's own stash (a raffle), or one of a project stash.
   if (line.gives === 'nft' && line.held) return { Held: [line.nft] };
+  // An NFT drawn at random from the lottery's own stash (a raffle of many NFTs).
+  if (line.gives === 'raffled') return 'Raffled';
   if (line.gives === 'nft') return { Nft: { stash: m.stash.get(line.stash)?.id ?? 0, nft: line.nft } };
   if (line.gives === 'roll') return { Roll: [m.box.get(line.box)?.id ?? 0] };
   const pool = prizePool(line);
   const from = pool ? { Pool: [m.pool.get(pool)?.index ?? 0] } : { Mint: [`@mint:${line.currency ?? m.currencyKey}`] };
-  if (line.gives === 'share') return { Tokens: { from, amount: { Bps: [Math.round((line.percent ?? 0) * 100)] } } };
-  return { Tokens: { from, amount: { Fixed: [amount(line.amount, prizeToken(line, m))] } } };
+  return { Tokens: { from, amount: amount(line.amount, prizeToken(line, m)) } };
 }
 
 /**
@@ -172,14 +341,20 @@ export function prizeArgs(p, m) {
  * its own amount (whole units of `t`, the grant's token) and round, so one wallet listed under several rounds claims
  * each once (monthly vesting, a season's airdrop).
  */
-export const listLeaves = (list, t) => list.map((e) => (typeof e === 'string' ? loot.listLeaf(e, null) : loot.listLeaf(e.wallet, null, loot.listRound(e.round ?? 0), e.amount !== undefined ? amount(e.amount, t) : 0n)));
+export const listLeaves = (list, t) =>
+  list.map(e =>
+    typeof e === 'string'
+      ? loot.listLeaf(e, null)
+      : loot.listLeaf(e.wallet, null, loot.listRound(e.round ?? 0), e.amount !== undefined ? amount(e.amount, t) : 0n),
+  );
 
 /** A prize line's `Prize`, or null for none. */
 const prizeOrNull = (p, m) => (prizeLine(p) ? prizeArgs(p, m) : null);
 
 /**
- * A lottery's args: its own pot in `currency` (the project's by default), ticket money split by `split` (and
- * `cutPercent` to the treasury) with the rest into the pot. No `every` draws once, at `firstDraw`.
+ * A lottery's args: its money in `currency` (the project's by default), ticket money split by `split` (and
+ * `cutPercent` to the treasury) with the rest for the places, which are paid from its pot (`pot`) or from each round's
+ * own money, what they leave going to `rest` (`paysFromOf`). No `every` draws once, at `firstDraw`.
  */
 export function lotteryArgs(l, m) {
   const potKey = l.currency ?? m.currencyKey;
@@ -187,25 +362,103 @@ export function lotteryArgs(l, m) {
   const ticket = l.ticketCurrency ? m.tokens.get(l.ticketCurrency) : potToken;
   const every = toSeconds(l.every);
   return {
-    price: l.ticketNft ? 0n : amount(l.price, ticket),
-    mint: `@mint:${potKey}`,
-    shares: shares(lotterySplit(l), m),
-    // A place takes a share of the pot, a prize for its winner, or both.
-    places: (l.places ?? []).map(placeOf).map((p) => ({ bps: Math.round(p.percent * 100), prize: prizeOrNull(p.prize, m) })),
-    ticket_mint: l.ticketCurrency ? `@mint:${l.ticketCurrency}` : '11111111111111111111111111111111',
+    // What a round copies at its first purchase.
+    terms: {
+      price: l.ticketNft ? 0n : amount(l.price, ticket),
+      mint: `@mint:${potKey}`,
+      // Where the places are paid from: a pot kept from round to round, or each round's own money.
+      pays_from: paysFromOf(l, m),
+      shares: shares(lotterySplit(l), m),
+      // A place takes a share of the pot, a prize for its winner, or both.
+      // A run of `times` places alike: "places 2 to 201 each take 1%" is one.
+      places: (l.places ?? [])
+        .map(placeOf)
+        .map(p => ({ bps: Math.round(p.percent * 100), prize: prizeOrNull(p.prize, m), times: p.times })),
+      ticket_mint: l.ticketCurrency ? `@mint:${l.ticketCurrency}` : '11111111111111111111111111111111',
+      draws_at: BigInt(l.firstDraw ? toTime(l.firstDraw, m.now) : m.now + every),
+      // A ticket paid with one NFT that passes the rule, in place of tokens.
+      nft_ticket: l.ticketNft ? { rule: ruleOf(l.ticketNft.rule, m), then: spendOf(l.ticketNft.then, m) } : null,
+      // No loss: every ticket goes back to its buyer once the round is drawn; the winners take the pot alone.
+      returns: Boolean(l.noLoss),
+      // A least sale: a round that sold fewer tickets is cancelled at its draw and refunded.
+      min_sold: BigInt(l.minSold ?? 0),
+    },
     every: BigInt(every),
-    draws_at: BigInt(l.firstDraw ? toTime(l.firstDraw, m.now) : m.now + every),
     gate: gateOf(l.gate, m),
     per_wallet: l.perWallet ?? 0,
-    // A ticket paid with one NFT that passes the rule, in place of tokens.
-    nft_ticket: l.ticketNft ? { rule: ruleOf(l.ticketNft.rule, m), then: spendOf(l.ticketNft.then, m) } : null,
-    // No loss: every ticket goes back to its buyer once the round is drawn; the winners take the pot alone.
-    returns: Boolean(l.noLoss),
-    // A least sale: a round that sold fewer tickets is cancelled at its draw and refunded.
-    min_sold: BigInt(l.minSold ?? 0),
   };
 }
 
+/**
+ * A lottery round's header as its first purchase sizes it (`LotteryRound::new`: its `head`), and the token accounts a
+ * round may open (`accounts`: the payment mint's, the pot's, one for each run whose prize comes from a pool). The
+ * header holds a copy of the terms, a total for each share, two bits a place, a record for each run of tokens and an
+ * NFT slot for each place of the lottery's own stash.
+ */
+export function roundSize(l, m) {
+  const { terms } = placeholders(lotteryArgs(l, m));
+  const places = terms.places.reduce((n, p) => n + Number(p.times ?? 1), 0);
+  const tokens = terms.places.filter(p => p.prize?.Tokens).length;
+  const pools = terms.places.filter(p => p.prize?.Tokens?.from.Pool).length;
+  const own = terms.places
+    .filter(p => p.prize?.Held || p.prize === 'Raffled' || p.prize?.Raffled !== undefined)
+    .reduce((n, p) => n + Number(p.times ?? 1), 0);
+  const termsBytes = encodeBorsh(IDL, { defined: { name: 'LotteryTerms' } }, terms).length;
+  // The tag; project, lottery, id, incarnation, round, bump, opener, lent, head, status, revision; the terms; fee, sold,
+  // to_pot; common; owns, owed, the draw's slots and times, answer and first ticket, the pot's four numbers; paid; prizes (59
+  // bytes each); accounts (64 each); nfts; assigned.
+  const head =
+    1 +
+    130 +
+    termsBytes +
+    17 +
+    (4 + 8 * terms.shares.length) +
+    112 +
+    (4 + Math.ceil((2 * places) / 8)) +
+    (4 + 59 * tokens) +
+    (4 + 64 * (2 + pools)) +
+    (4 + 32 * own) +
+    4;
+  const payment = l.ticketCurrency ?? l.currency ?? m.currencyKey;
+  const accounts = (l.ticketNft ? 1 : payment === (l.currency ?? m.currencyKey) ? 1 : 2) + pools;
+  return { head, accounts };
+}
+
+/** How many rounds of a lottery are open or still paying out at once, and how many purchases a round takes, as the
+ * spec expects them (`expect`): by default two rounds of a lottery that draws again (one selling, one paying out) and
+ * one of a lottery that draws once; a round's purchases from the scenario's purchases a day over a round, else 100. */
+export function roundsExpected(l, m) {
+  const every = toSeconds(l.every ?? 0);
+  const perDay = Number(m.scenario?.perDay?.[`lottery:${l.key}`] ?? 0);
+  const days =
+    every > 0 ? every / 86_400 : l.firstDraw ? Math.max(1, (toTime(l.firstDraw, m.now) - m.now) / 86_400) : 1;
+  const rounds = l.expect?.rounds ?? (every > 0 ? 2 : 1);
+  const entries = l.expect?.entries ?? (perDay > 0 ? Math.ceil(perDay * days) : 100);
+  return { rounds, entries };
+}
+
+/**
+ * The SOL, in lamports, a lottery holds for its rounds' rent: the spec's `roundRent` (0 turns it off), or by default
+ * what its expected rounds take at once (`roundsExpected`), each its header, its token accounts and its expected
+ * entries' bytes (`LotteryRound.lent`: in a round the lottery opened, its spare SOL pays each entry while it covers
+ * them, so buyers pay no program rent for a ticket), at devnet's and mainnet's rent, rounded up to 0.001 SOL. Short
+ * of it (a busier round, a cluster that charges more), the first buyer fronts the header and later buyers pay their
+ * own entries. Each round gives back what it took when it closes; the lottery gives the rest back to the owner when it closes.
+ */
+export function roundRentOf(l, m) {
+  if (l.roundRent !== undefined) return toUnits(l.roundRent, 9);
+  const { head, accounts } = roundSize(l, m);
+  const { rounds, entries } = roundsExpected(l, m);
+  const width = loot.entryWidth(
+    lotterySplit(l).some(s => String(s.to).startsWith('chosen')),
+    Boolean(l.ticketNft),
+  );
+  // The header and its entries' list head (6 bytes), each token account, each entry's bytes.
+  const one = rent(head + 6) + BigInt(accounts) * rent(165) + BigInt(entries * width) * RENT_PER_BYTE;
+  const all = BigInt(rounds) * one;
+  return ((all + 999_999n) / 1_000_000n) * 1_000_000n;
+}
+
 /**
  * The args the authority opens a contest with, `at` (Unix seconds) its opening: its sides, when entries close and the
  * result is due, its split, its gate (a list of wallets for a duel), the keys that may decide it, the least pot (an
@@ -217,8 +470,16 @@ export function contestArgs(c, m, at = m.now) {
   // program refuses them at once): with no "entriesClose", an hour before the result is due (halfway for a contest
   // shorter than two hours); with no "resultDue", an hour after entries close.
   const deciders = (c.deciders ?? []).length > 0;
-  const due = c.resultDue === undefined && c.entriesClose !== undefined && deciders ? toSeconds(c.entriesClose) + 3600 : toSeconds(c.resultDue ?? c.entriesClose ?? '1d');
-  const closes = c.entriesClose !== undefined ? toSeconds(c.entriesClose) : deciders ? due - Math.min(3600, Math.floor(due / 2)) : due;
+  const due =
+    c.resultDue === undefined && c.entriesClose !== undefined && deciders
+      ? toSeconds(c.entriesClose) + 3600
+      : toSeconds(c.resultDue ?? c.entriesClose ?? '1d');
+  const closes =
+    c.entriesClose !== undefined
+      ? toSeconds(c.entriesClose)
+      : deciders
+        ? due - Math.min(3600, Math.floor(due / 2))
+        : due;
   return {
     sides: c.sides,
     closes_at: BigInt(at + closes),
@@ -227,62 +488,97 @@ export function contestArgs(c, m, at = m.now) {
     gate: gateOf(c.gate, m),
     deciders: c.deciders ?? [],
     // A contest of NFTs counts its pot in NFTs.
-    min_pot: c.stakeNft ? wholeCount(c.minPot) ?? 0n : amount(c.minPot ?? 0, t),
+    min_pot: c.stakeNft ? (wholeCount(c.minPot) ?? 0n) : amount(c.minPot ?? 0, t),
     stake: amount(c.stake ?? 0, t),
     prize: prizeOrNull(c.prize, m),
     // A token prize set aside whole at the decision and split among the winners by what each put in.
     prize_split: Boolean(c.prize?.split),
-    // Each entry stakes one NFT that passes this rule, and the NFTs are the pot.
+    // Each entry stakes one NFT that passes this rule, and the NFTs are the pot: each winner shares the losers', at most
+    // `losersEach` of them (none: no cap).
     nft: c.stakeNft ? ruleOf(c.stakeNft, m) : null,
+    cap: c.stakeNft && c.losersEach ? c.losersEach : null,
   };
 }
 
 export function farmArgs(f, m) {
-  const tiers = (f.tiers ?? [{ lock: 0, multiplier: 1 }]).map((t) => ({
+  const tiers = (f.tiers ?? [{ lock: 0, multiplier: 1 }]).map(t => ({
     lock: toSeconds(t.lock),
     bps: Math.round((t.multiplier ?? 1) * 10_000),
     prize: prizeOrNull(t.prize, m),
-    roll: t.roll ? m.box.get(t.roll)?.id ?? 0 : null,
+    roll: t.roll ? (m.box.get(t.roll)?.id ?? 0) : null,
     // A token seat may leave before this tier's lock by leaving this share of what it takes out.
     exit_bps: Math.round((t.exitFee ?? 0) * 100),
+    // How long a seat of this tier earns and grows from when its lock started (0: no end): a term.
+    earns_for: t.earnsFor ? toSeconds(t.earnsFor) : 0,
   }));
   // Every rule of its gate; with none, a farm of one item's collectibles takes that item.
   const named = listOf(f.gate);
-  const gates = f.stakes !== 'collectibles' ? [] : (named.length ? named : f.item ? [{ item: f.item, attribute: 'item_id' }] : []).map((r) => ruleOf(r, m));
+  const gates =
+    f.stakes !== 'collectibles'
+      ? []
+      : (named.length ? named : f.item ? [{ item: f.item, attribute: 'item_id' }] : []).map(r => ruleOf(r, m));
   // A rate is per NFT_UNIT of weight: one collectible, or 1,000,000 base units of a staked token.
-  const rewards = m.poolToken(f.rewards);
+  const rewards = m.tokens.get(f.rewardsToken);
   const staked = f.stakes === 'collectibles' ? null : m.tokens.get(f.stakes);
   const perDay = f.rate ? amount(f.rate.perDay, rewards) : 0n;
+  // A shared rate is the whole farm's a day, shared by weight; any other is for each unit of weight.
+  const shared = Boolean(f.rate?.shared);
   return {
     custody: { freeze: 'Freeze', watch: 'Watch' }[f.custody] ?? 'Escrow',
-    rewards_pool: m.pool.get(f.rewards)?.index ?? 0,
     tiers,
-    boosts: (f.boosts ?? []).map((b) => ({ rule: ruleOf(b.when, m), effect: effectOf(b.add) })),
+    boosts: (f.boosts ?? []).map(b => ({ rule: ruleOf(b.when, m), effect: effectOf(b.add) })),
     max_boost_bps: Math.round((f.maxBoostPercent ?? 0) * 100),
     gates,
-    rate: f.rate ? { per_day: staked ? (perDay * 1_000_000n) / 10n ** BigInt(staked.decimals ?? 0) : perDay, mints: Boolean(f.rate.minted) } : null,
-    growth: listOf(f.growth).map((g) => ({ key: g.attribute ?? 'xp', per_day: g.perDay, level: (g.levels ?? []).length ? g.level ?? 'level' : '', steps: g.levels ?? [], streak: Boolean(g.streak) })),
+    rate: f.rate
+      ? {
+          per_day: staked && !shared ? (perDay * 1_000_000n) / 10n ** BigInt(staked.decimals ?? 0) : perDay,
+          mints: Boolean(f.rate.minted),
+          shared,
+          halve_every: f.rate.halveEvery ? toSeconds(f.rate.halveEvery) : 0,
+        }
+      : null,
+    growth: listOf(f.growth).map(g => ({
+      key: g.attribute ?? 'xp',
+      per_day: g.perDay,
+      level: (g.levels ?? []).length ? (g.level ?? 'level') : '',
+      steps: g.levels ?? [],
+      streak: Boolean(g.streak),
+      profile: false,
+      at_least: 0n,
+    })),
     // A farm that runs for a time ends that long after it goes live.
     ends_at: f.runs ? BigInt(m.now + toSeconds(f.runs)) : 0n,
     // The times it keeps on what is staked: its lock, and an upkeep.
     lock_key: f.lockAttribute ?? '',
     upkeep_key: f.upkeepAttribute ?? '',
-    // Where an early exit's fee goes, how long a stake waits on its way out, and a toll on every payout of rewards.
+    // Where an early exit's fee goes.
     exit_to: f.exitFeeTo ? sinkOf(f.exitFeeTo, m) : null,
-    unbond: f.unbond ? toSeconds(f.unbond) : 0,
-    toll: f.toll ? { bps: Math.round(f.toll.percent * 100), to: sinkOf(f.toll.to, m) } : null,
   };
 }
 
-/** A fee's sink (`Sink`): "burn", or "pool:<key>", one of the project's pools. */
-export const sinkOf = (to, m) => (to === 'burn' ? 'Burn' : { Pool: [m.pool.get(String(to).replace(/^pool:/, ''))?.index ?? 0] });
+/** A fee's sink (`Sink`): "burn", "rewards" (the farm's own vault), or "pool:<key>", one of the project's pools. */
+export const sinkOf = (to, m) =>
+  to === 'burn'
+    ? 'Burn'
+    : to === 'rewards'
+      ? 'Rewards'
+      : { Pool: [m.pool.get(String(to).replace(/^pool:/, ''))?.index ?? 0] };
+
+/** Whether a spec's farm keeps a record of when its seats stop earning (`loot.farmKeepsEnds`): a tier's term or an upkeep,
+ * and it pays something. Each different time waiting costs whoever writes it `loot.END_BYTES` of rent. */
+export const farmEnds = f =>
+  ((f.tiers ?? []).some(t => t.earnsFor) || Boolean(f.upkeepAttribute)) && (!f.rate || Number(f.rate.perDay) > 0);
 
 /** An auction's args: its lot, reserve, least raise, times and split. "start" is when it goes live unless it says. */
 export function auctionArgs(a, m) {
   const t = m.priceToken(a);
   const startsAt = toTime(a.start, m.now);
   return {
-    lot: a.lot?.asset ? { Asset: [a.lot.asset] } : a.lot?.roll ? { Roll: [rollOf(a.lot.roll, m)] } : { Item: [m.item.get(a.lot?.item)?.id ?? 0] },
+    lot: a.lot?.asset
+      ? { Asset: [a.lot.asset] }
+      : a.lot?.roll
+        ? { Roll: [rollOf(a.lot.roll, m)] }
+        : { Item: [m.item.get(a.lot?.item)?.id ?? 0] },
     // With NFT bids, the reserve counts NFTs.
     reserve: a.bidNfts ? BigInt(a.reserve ?? 1) : amount(a.reserve ?? 0, t),
     min_raise_bps: Math.round((a.minRaise ?? 5) * 100),
@@ -298,7 +594,7 @@ export function auctionArgs(a, m) {
 
 const NOBODY = '11111111111111111111111111111111';
 /** The program id of the box a prize rolls (a box key), or null for none. */
-const rollOf = (box, m) => (box ? m.box.get(box)?.id ?? 0 : null);
+const rollOf = (box, m) => (box ? (m.box.get(box)?.id ?? 0) : null);
 
 export function grantArgs(g, m) {
   const gives = prizeArgs(g.prize ?? g.gives, m);
@@ -309,20 +605,24 @@ export function grantArgs(g, m) {
   return {
     gives,
     vouchers,
-    list_root: list.length ? loot.merkleRoot(listLeaves(list, prizeToken(prizeLine(g.prize ?? g.gives), m))) : new Uint8Array(32),
-    key_root: keys.length ? loot.merkleRoot(keys.map((k) => loot.keyLeaf(k))) : new Uint8Array(32),
+    list_root: list.length
+      ? loot.merkleRoot(listLeaves(list, prizeToken(prizeLine(g.prize ?? g.gives), m)))
+      : new Uint8Array(32),
+    key_root: keys.length ? loot.merkleRoot(keys.map(k => loot.keyLeaf(k))) : new Uint8Array(32),
     // A grant that names no voucher key and no list is one any wallet may claim, within its limits.
     open: !(g.vouchers ?? []).length && !list.length && !keys.length,
     limits: {
       wallet: perWalletOf(l),
       per_person: l.perPerson ?? 0,
       per_key: l.perKey ?? 0,
-      per_day: l.perDay ?? 0,
-      total: l.total ?? 0,
+      // Every wallet's claims together: in all, and a day (a window of 86,400 seconds, from the unix epoch).
+      all: { total: l.total ?? 0, per_window: l.perDay ?? 0, window: l.perDay ? 86_400 : 0 },
       window: windowOf({ opens: l.opens, closes: l.until }, m.now),
     },
     active: g.active !== false,
     gate: gateOf(g.gate, m),
+    // Its records in 2^bits lists, the fewest that keep each under ~100,000 over its life (wallets × rounds).
+    shard_bits: loot.shardBitsFor(g.wallets ?? list.length ?? 0, g.rounds ?? 1),
   };
 }
 
@@ -330,7 +630,8 @@ export function grantArgs(g, m) {
 
 /**
  * Replaces "@mint:<key>" strings anywhere in `value` with the mint `ctx` names, "@ata:<wallet>:<key>" with that
- * wallet's token account for it, "@pot:<id>" with a lottery's pot and "@farm:<id>" with a farm's address.
+ * wallet's token account for it, "@pot:<lottery id>:<pot id>" with a lottery's pot, "@farm:<id>" with a farm's address and "@rewards:<id>"
+ * with a farm's rewards vault.
  */
 function resolve(value, ctx) {
   if (value === '@treasury') {
@@ -355,9 +656,14 @@ function resolve(value, ctx) {
     if (!ctx.project) throw new Error('No project yet for a stake gate’s farm.');
     return loot.pda.farm(ctx.project, Number(value.slice(6)));
   }
+  if (typeof value === 'string' && value.startsWith('@rewards:')) {
+    if (!ctx.project) throw new Error('No project yet for a farm’s rewards vault.');
+    return loot.pda.rewards(loot.pda.farm(ctx.project, Number(value.slice(9))));
+  }
   if (typeof value === 'string' && value.startsWith('@pot:')) {
     if (!ctx.project) throw new Error('No project yet for a lottery’s pot.');
-    return loot.pda.pot(loot.pda.lottery(ctx.project, Number(value.slice(5))));
+    const [, lottery, pot] = value.split(':');
+    return loot.pda.lotteryPot(loot.pda.lottery(ctx.project, Number(lottery)), Number(pot));
   }
   if (typeof value === 'string' && value.startsWith('@ata:')) {
     const [, wallet, key, program] = value.split(':');
@@ -365,7 +671,7 @@ function resolve(value, ctx) {
     if (!mint) throw new Error(`No mint yet for the token “${key}”.`);
     return loot.ata(wallet, mint, program === 'token-2022' ? TOKEN_2022_PROGRAM : TOKEN_PROGRAM);
   }
-  if (Array.isArray(value)) return value.map((v) => resolve(v, ctx));
+  if (Array.isArray(value)) return value.map(v => resolve(v, ctx));
   if (value instanceof Uint8Array || typeof value !== 'object' || value === null) return value;
   return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, resolve(v, ctx)]));
 }
@@ -375,14 +681,14 @@ function resolve(value, ctx) {
 const encodedSize = loot.accountBytes;
 /** Bubblegum's config of a tree. */
 const TREE_CONFIG_BYTES = 96;
-const placeholderKey = (name) => encodeBase58(sha256(utf8(`loot-plan:${name}`)));
+const placeholderKey = name => encodeBase58(sha256(utf8(`loot-plan:${name}`)));
 
 /**
  * Every step that sets the economy up, in order: the tokens the project mints, the collection, the project, the pools, items, boxes (the shop's too), recipes, schedules, lotteries, grants,
  * farms, auctions, then the seeds and the grants' funds. `only` limits it to these part ids (a change to a live economy).
  *
- * A farm opens before the seed of its rewards pool lands, and anyone may stake in between. That is safe: a sharing
- * farm credits nothing at once, and releases what lands in its pool over its longest lock (a day at least) to the
+ * A farm opens before its seed lands in its rewards vault, and anyone may stake in between. That is safe: a sharing
+ * farm credits nothing at once, and releases what lands in its vault over its longest lock (a day at least) to the
  * seats there as it is released, its clock stopped while nobody is in. A seed that lands
  * before the first stake or after it is released the same way from that stake on, so seeding first would change nothing.
  */
@@ -390,15 +696,15 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
   const m = model(economy, { now });
   const live = madeSoFar(given);
   const steps = [];
-  const want = (id) => !only || only.has(id);
+  const want = id => !only || only.has(id);
   const landed = new Set(live?.landed ?? []);
-  const add = (step) => want(step.part) && !landed.has(step.id) && steps.push({ creates: [], signers: [owner], ...step });
-  const project = (ctx) => ctx.project;
+  const add = step => want(step.part) && !landed.has(step.id) && steps.push({ creates: [], signers: [owner], ...step });
+  const project = ctx => ctx.project;
   const fresh = !live?.project;
 
   // Tokens the project mints: a classic mint with the owner as its authority, handed to the project right after.
   for (const t of m.tokens.values()) {
-    if (t.source !== 'game' || live?.mints?.[t.key] || t.mint && !t.mint.startsWith('@')) continue;
+    if (t.source !== 'game' || live?.mints?.[t.key] || (t.mint && !t.mint.startsWith('@'))) continue;
     const key = `new:mint/${t.key}`;
     if (t.fixedSupply) {
       const supply = amount(t.supply, t);
@@ -407,12 +713,26 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
         part: `token:${t.key}`,
         says: `Make the token ${t.symbol} (${t.decimals} decimals) with a fixed supply of ${t.supply}, all of it to your wallet, then turn its minting off for good`,
         signers: [owner, key],
-        creates: [{ what: `the mint of ${t.symbol}`, bytes: MINT_BYTES }, { what: `your ${t.symbol} account`, bytes: 165 }],
-        build: (ctx) => [
-          createAccountIx({ from: ctx.owner, address: ctx.keys[key], lamports: ctx.rent(MINT_BYTES), space: MINT_BYTES, owner: TOKEN_PROGRAM }),
+        creates: [
+          { what: `the mint of ${t.symbol}`, bytes: MINT_BYTES },
+          { what: `your ${t.symbol} account`, bytes: 165 },
+        ],
+        build: ctx => [
+          createAccountIx({
+            from: ctx.owner,
+            address: ctx.keys[key],
+            lamports: ctx.rent(MINT_BYTES),
+            space: MINT_BYTES,
+            owner: TOKEN_PROGRAM,
+          }),
           initializeMint2Ix({ mint: ctx.keys[key], decimals: t.decimals, authority: ctx.owner }),
           createAssociatedTokenAccountIdempotent(ctx.owner, ctx.owner, ctx.keys[key]),
-          mintToIx({ mint: ctx.keys[key], to: loot.ata(ctx.owner, ctx.keys[key]), authority: ctx.owner, amount: supply }),
+          mintToIx({
+            mint: ctx.keys[key],
+            to: loot.ata(ctx.owner, ctx.keys[key]),
+            authority: ctx.owner,
+            amount: supply,
+          }),
           setAuthorityIx({ account: ctx.keys[key], current: ctx.owner, newAuthority: null }),
         ],
       });
@@ -424,8 +744,14 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
       says: `Make the token ${t.symbol} (${t.decimals} decimals), then hand its minting to the project`,
       signers: [owner, key],
       creates: [{ what: `the mint of ${t.symbol}`, bytes: MINT_BYTES }],
-      build: (ctx) => [
-        createAccountIx({ from: ctx.owner, address: ctx.keys[key], lamports: ctx.rent(MINT_BYTES), space: MINT_BYTES, owner: TOKEN_PROGRAM }),
+      build: ctx => [
+        createAccountIx({
+          from: ctx.owner,
+          address: ctx.keys[key],
+          lamports: ctx.rent(MINT_BYTES),
+          space: MINT_BYTES,
+          owner: TOKEN_PROGRAM,
+        }),
         initializeMint2Ix({ mint: ctx.keys[key], decimals: t.decimals, authority: ctx.owner }),
         setAuthorityIx({ account: ctx.keys[key], current: ctx.owner, newAuthority: ctx.project }),
       ],
@@ -443,20 +769,47 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
         part: 'project',
         says: `Make the collection “${c.name}”, with ${c.royaltyPercent ?? 5}% resale royalty to you; the project may mint into it${tree ? ', as Core NFTs or compressed ones' : ''}`,
         signers: [owner, 'new:collection'],
-        creates: [{ what: 'the collection', bytes: 1 + 32 + 4 + c.name.length + 4 + (c.uri ?? '').length + 140 + (tree ? 3 : 0), approx: true }],
-        build: (ctx) => [createCollectionInstruction({ collection: ctx.keys['new:collection'], creator: ctx.owner, project: ctx.project, name: c.name, uri: c.uri ?? '', royaltyBps: Math.round((c.royaltyPercent ?? 5) * 100), compressed: Boolean(tree) })],
+        creates: [
+          {
+            what: 'the collection',
+            bytes: 1 + 32 + 4 + c.name.length + 4 + (c.uri ?? '').length + 140 + (tree ? 3 : 0),
+            approx: true,
+          },
+        ],
+        build: ctx => [
+          createCollectionInstruction({
+            collection: ctx.keys['new:collection'],
+            creator: ctx.owner,
+            project: ctx.project,
+            name: c.name,
+            uri: c.uri ?? '',
+            royaltyBps: Math.round((c.royaltyPercent ?? 5) * 100),
+            compressed: Boolean(tree),
+          }),
+        ],
       });
     // The treasury is a wallet: the remainder of every split goes to its account of that mint, which the program
     // opens when it is not there. The project's vaults, and every account a share pays, open the same way when first
     // paid, so the setup opens none of them.
-    const collections = (ctx) => [...(ctx.collection ? [ctx.collection] : []), ...m.collections];
+    const collections = ctx => [...(ctx.collection ? [ctx.collection] : []), ...m.collections];
     const count = (c ? 1 : 0) + m.collections.length;
     add({
       id: 'project',
       part: 'project',
       says: `Open the project on the loot program${count ? ` with ${count === 1 ? 'its collection' : `its ${count} collections`}` : ', with no collection'}; ${m.authority === 'owner' ? 'your wallet' : m.authority} signs its decisions, and ${m.treasuryWallet ?? 'your wallet'} is its treasury`,
-      creates: [{ what: 'the project', bytes: loot.projectBytes(count) }, { what: 'the project’s fee box', bytes: 0 }],
-      build: (ctx) => [loot.createProjectIx({ owner: ctx.owner, id: m.projectNumber, collections: collections(ctx), treasury: ctx.treasury, authority: ctx.authority })],
+      creates: [
+        { what: 'the project', bytes: loot.projectBytes(count) },
+        { what: 'the project’s fee box', bytes: 0 },
+      ],
+      build: ctx => [
+        loot.createProjectIx({
+          owner: ctx.owner,
+          id: m.projectNumber,
+          collections: collections(ctx),
+          treasury: ctx.treasury,
+          authority: ctx.authority,
+        }),
+      ],
     });
   }
 
@@ -467,47 +820,222 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
       part: 'tree',
       says: `Open the project’s tree of compressed NFTs, for ${(2 ** tree.depth).toLocaleString('en-US')} of them in all`,
       signers: [owner, 'new:tree'],
-      creates: [{ what: 'the tree of compressed NFTs', bytes: tree.bytes }, { what: 'the tree’s config (Bubblegum’s)', bytes: TREE_CONFIG_BYTES }],
-      build: (ctx) => [
-        createAccountIx({ from: ctx.owner, address: ctx.keys['new:tree'], lamports: ctx.rent(tree.bytes), space: tree.bytes, owner: loot.COMPRESSION_PROGRAM }),
-        loot.openTreeIx({ signer: ctx.owner, project: project(ctx), tree: ctx.keys['new:tree'], maxDepth: tree.depth, maxBufferSize: tree.buffer }),
+      creates: [
+        { what: 'the tree of compressed NFTs', bytes: tree.bytes },
+        { what: 'the tree’s config (Bubblegum’s)', bytes: TREE_CONFIG_BYTES },
+      ],
+      build: ctx => [
+        createAccountIx({
+          from: ctx.owner,
+          address: ctx.keys['new:tree'],
+          lamports: ctx.rent(tree.bytes),
+          space: tree.bytes,
+          owner: loot.COMPRESSION_PROGRAM,
+        }),
+        loot.openTreeIx({
+          signer: ctx.owner,
+          project: project(ctx),
+          tree: ctx.keys['new:tree'],
+          maxDepth: tree.depth,
+          maxBufferSize: tree.buffer,
+        }),
       ],
     });
 
+  // The token accounts players' purchases would otherwise open (the owner pays their rent now, about 0.002 SOL each,
+  // so no player's purchase pays another wallet's): the treasury's of each coin the economy takes, the project's vault
+  // of each coin a box or an auction holds, and each fixed wallet's a split pays.
+  const accounts = goLiveAccounts(m);
+  if (fresh && accounts.length)
+    add({
+      id: 'accounts',
+      part: 'project',
+      says: `Open ${accounts.length} token account${accounts.length === 1 ? '' : 's'} the economy pays into (the treasury’s, the project’s vaults, the wallets its splits name), so no player’s purchase opens them`,
+      creates: accounts.map(x => ({
+        what: `${x.who}’s account of ${m.tokens.get(x.token)?.symbol ?? x.token}`,
+        bytes: 165,
+      })),
+      build: ctx =>
+        accounts.map(x =>
+          createAssociatedTokenAccountIdempotent(
+            ctx.owner,
+            x.who === 'the project' ? ctx.project : x.who === 'the treasury' ? ctx.treasury : x.who,
+            ctx.mints[x.token],
+            programsOf(ctx)[ctx.mints[x.token]] ?? TOKEN_PROGRAM,
+          ),
+        ),
+    });
+
+  // The project's standing lookup table (the owner its authority): the addresses its transactions name most, so a
+  // transaction too big for a legacy one goes as v0 with it in one approval, never with a table of its own. Made with
+  // the first of its addresses, then extended a group a step.
+  if (fresh) {
+    const named = standingAddresses(m);
+    groupsOf(named, TABLE_GROUP).forEach((group, i) =>
+      add({
+        id: i ? `table:${i}` : 'table',
+        part: 'project',
+        says: i
+          ? `Add ${group.length} more addresses to the project’s lookup table`
+          : `Make the project’s lookup table of the ${named.length} addresses its transactions name most, so a large one takes one approval`,
+        creates: i
+          ? [{ what: `room for ${group.length} addresses in the lookup table`, bytes: 32 * group.length, grows: true }]
+          : [{ what: 'the project’s lookup table', bytes: 56 + 32 * group.length }],
+        build: ctx => {
+          // With no recent slot known (a plan built offline), there is no table to make.
+          if (ctx.slot == null) return [];
+          const { address: table, instruction } = createTableIx({ authority: ctx.owner, slot: ctx.slot });
+          return [
+            ...(i ? [] : [instruction]),
+            extendTableIx({ table, authority: ctx.owner, addresses: group.map(at => at(ctx)).filter(Boolean) }),
+          ];
+        },
+      }),
+    );
+  }
+
   for (const p of m.pools) {
     const t = m.tokens.get(p.currency);
-    add({ id: `pool:${p.key}`, part: `pool:${p.key}`, says: `Open the pool “${p.key}” for ${t?.symbol}`, creates: [{ what: `the pool “${p.key}”`, bytes: 165 }], build: (ctx) => [loot.openPoolIx({ owner: ctx.owner, project: project(ctx), index: p.index, mint: ctx.mints[p.currency] })] });
+    add({
+      id: `pool:${p.key}`,
+      part: `pool:${p.key}`,
+      says: `Open the pool “${p.key}” for ${t?.symbol}`,
+      creates: [{ what: `the pool “${p.key}”`, bytes: 165 }],
+      build: ctx => [
+        loot.openPoolIx({ owner: ctx.owner, project: project(ctx), index: p.index, mint: ctx.mints[p.currency] }),
+      ],
+    });
   }
   const record = (part, def, says, kind, what, options = () => ({})) => {
     const [variant] = Object.keys(def);
     const bytes = recordBytesOf(kind, def[variant]);
-    // A lottery's first write opens its pot: a token account as well as the record.
-    const pot = kind === 'Lottery' ? [{ what: `${what}’s pot`, bytes: 165 }, { what: `${what}’s ticket escrow`, bytes: 165 }] : def.Schedule?.args.action.from.Vest ? [{ what: `${what}’s sealed vault`, bytes: 165 }] : [];
-    add({ id: `${part}:${kind}`, part, says, creates: [{ what, bytes }, ...pot], build: (ctx) => [loot.upsertIx({ owner: ctx.owner, project: project(ctx), def: resolve(def, ctx), ...options(ctx) })] });
+    // A lottery's write opens the pot it pays from: a token account as well as the record (each round holds its own
+    // money). One paid from each round's own money opens none.
+    const pot = def.Lottery?.args.terms.pays_from.Pot
+      ? [{ what: `${what}’s pot`, bytes: 165 }]
+      : def.Schedule?.args.action.from.Vest
+        ? [{ what: `${what}’s sealed vault`, bytes: 165 }]
+        : [];
+    add({
+      id: `${part}:${kind}`,
+      part,
+      says,
+      creates: [{ what, bytes }, ...pot],
+      build: ctx => [
+        loot.upsertIx({ owner: ctx.owner, project: project(ctx), def: resolve(def, ctx), ...options(ctx) }),
+      ],
+    });
   };
-  for (const it of m.items) record(`item:${it.key}`, { Item: { id: it.id, args: itemArgs(it) } }, `${it.active === false ? 'Switch off' : 'Write'} the item “${it.name}”`, 'Item', `the item “${it.name}”`);
+  // Each table, a batch of rows a transaction (`TABLE_BATCH_BYTES` of rows at most), sealed with its last batch.
+  for (const t of m.tables) {
+    const batches = tableBatches(t);
+    const len = t.kind === 'numbers' ? 8 : 40;
+    batches.forEach((rows, i) => {
+      const seal = i === batches.length - 1;
+      add({
+        id: `table:${t.key}:${i}`,
+        part: `table:${t.key}`,
+        says: `Write ${rows.length} row${rows.length === 1 ? '' : 's'} of the table “${t.key}”${seal ? ', and seal it: its weights never change from now on' : ''}`,
+        creates:
+          i === 0
+            ? [
+                {
+                  what: `the table “${t.key}”, ${t.rows.length} rows`,
+                  bytes: loot.tableRowAt(len, t.rows.length - 1) + len,
+                },
+              ]
+            : [],
+        build: ctx => [
+          loot.upsertIx({
+            owner: ctx.owner,
+            project: project(ctx),
+            def: { Table: { id: t.id, args: { payload: t.kind === 'numbers' ? 'Number' : 'Label', rows, seal } } },
+          }),
+        ],
+      });
+    });
+  }
+  for (const it of m.items)
+    record(
+      `item:${it.key}`,
+      { Item: { id: it.id, args: itemArgs(it, m) } },
+      `${it.active === false ? 'Switch off' : 'Write'} the item “${it.name}”`,
+      'Item',
+      `the item “${it.name}”`,
+    );
   // A box's line names its odds, so the owner sees what they approve (above all when a live box's odds change).
-  const odds = (b) => {
+  const odds = b => {
     const ws = weights(b);
     const total = ws.reduce((n, w) => n + w, 0) || 1;
-    const part = (o) => (o.gives === 'item' ? m.item.get(o.item)?.name ?? o.item : o.gives === 'stash' ? `an NFT of “${m.stash.get(o.stash)?.name ?? o.stash}”` : o.gives === 'pay' ? `${o.amount} ${m.poolToken(o.pool)?.symbol ?? ''}`.trim() : o.gives === 'share' ? `${o.percent}% of “${o.pool}”` : o.gives === 'mint' ? `${o.amount} ${m.tokens.get(o.currency ?? m.currencyKey)?.symbol ?? ''}`.trim() : o.gives === 'nft' ? `the NFT ${String(o.nft).slice(0, 4)}…` : o.gives === 'roll' ? `a roll of “${m.box.get(o.box)?.name ?? o.box}”` : '');
-    const what = (o) => outcomeParts(o).map(part).join(' + ') || (outcomeBurns(o) ? 'a burn' : 'nothing');
+    const part = o =>
+      o.gives === 'item'
+        ? (m.item.get(o.item)?.name ?? o.item)
+        : o.gives === 'stash'
+          ? `an NFT of “${m.stash.get(o.stash)?.name ?? o.stash}”`
+          : o.gives === 'pay'
+            ? `${o.amount} ${m.poolToken(o.pool)?.symbol ?? ''}`.trim()
+            : o.gives === 'share'
+              ? `${o.percent}% of “${o.pool}”`
+              : o.gives === 'mint'
+                ? `${o.amount} ${m.tokens.get(o.currency ?? m.currencyKey)?.symbol ?? ''}`.trim()
+                : o.gives === 'nft'
+                  ? `the NFT ${String(o.nft).slice(0, 4)}…`
+                  : o.gives === 'roll'
+                    ? `a roll of “${m.box.get(o.box)?.name ?? o.box}”`
+                    : '';
+    const what = o => outcomeParts(o).map(part).join(' + ') || 'nothing';
     return (b.outcomes ?? []).map((o, i) => `${what(o)} ${Math.round((ws[i] / total) * 10_000) / 100}%`).join(', ');
   };
-  const wasLive = new Set((live?.published?.boxes ?? []).map((b) => b.key));
-  for (const b of m.allBoxes) {
-    const says = b.shopOf ? `Put “${b.name}” in the shop at ${b.price} ${m.priceToken(b)?.symbol}` : `${b.active === false ? 'Switch off' : wasLive.has(b.key) ? 'Change' : 'Put on sale'} the box “${b.name}” at ${b.price} ${m.priceToken(b)?.symbol}${b.active === false ? '' : `: ${odds(b)}`}`;
-    record(b.shopOf ? `item:${b.shopOf}` : `box:${b.key}`, { Box: { id: b.id, args: boxArgs(b, m) } }, says, 'LootBox', b.shopOf ? `the shop listing of “${b.name}”` : `the box “${b.name}”`);
+  const wasLive = new Set((live?.published?.boxes ?? []).map(b => b.key));
+  // A box is written before any box that names it to roll (one may name itself): in that order.
+  const boxOrder = [];
+  const visit = (b, path = new Set()) => {
+    if (boxOrder.includes(b) || path.has(b)) return;
+    path.add(b);
+    for (const id of loot.defRolls({ Box: { args: boxArgs(b, m) } })) {
+      const named = m.allBoxes.find(x => x.id === id);
+      if (named && named !== b) visit(named, path);
+    }
+    boxOrder.push(b);
+  };
+  for (const b of m.allBoxes) visit(b);
+  for (const b of boxOrder) {
+    const says = b.shopOf
+      ? `Put “${b.name}” in the shop at ${b.price} ${m.priceToken(b)?.symbol}`
+      : `${b.active === false ? 'Switch off' : wasLive.has(b.key) ? 'Change' : 'Put on sale'} the box “${b.name}” at ${b.price} ${m.priceToken(b)?.symbol}${b.active === false ? '' : `: ${odds(b)}`}`;
+    record(
+      b.shopOf ? `item:${b.shopOf}` : `box:${b.key}`,
+      { Box: { id: b.id, args: boxArgs(b, m) } },
+      says,
+      'LootBox',
+      b.shopOf ? `the shop listing of “${b.name}”` : `the box “${b.name}”`,
+    );
   }
-  for (const r of m.recipes) record(`recipe:${r.key}`, { Recipe: { id: r.id, args: recipeArgs(r, m) } }, `Write the recipe “${r.name}”`, 'Recipe', `the recipe “${r.name}”`);
+  for (const r of m.recipes)
+    record(
+      `recipe:${r.key}`,
+      { Recipe: { id: r.id, args: recipeArgs(r, m) } },
+      `Write the recipe “${r.name}”`,
+      'Recipe',
+      `the recipe “${r.name}”`,
+    );
   for (const s of m.schedules) {
-    // A sealed schedule that pays a lottery's pot names the lottery when it is written (the pot is the project's own).
-    const pays = destination(s.to ?? '');
-    const lottery = s.sealed && pays.kind === 'lottery' ? m.lottery.get(pays.key) : null;
-    record(`schedule:${s.key}`, { Schedule: { id: s.id, args: scheduleArgs(s, m) } }, `${s.active === false ? 'Stop' : 'Start'} the ${s.sealed ? 'sealed ' : ''}schedule “${s.name ?? s.key}”`, 'Schedule', `the schedule “${s.name ?? s.key}”`, (ctx) => (lottery ? { lottery: loot.pda.lottery(project(ctx), lottery.id) } : {}));
+    record(
+      `schedule:${s.key}`,
+      { Schedule: { id: s.id, args: scheduleArgs(s, m) } },
+      `${s.active === false ? 'Stop' : 'Start'} the ${s.sealed ? 'sealed ' : ''}schedule “${s.name ?? s.key}”`,
+      'Schedule',
+      `the schedule “${s.name ?? s.key}”`,
+    );
     // A sealed schedule's vault is funded once, at go-live: from the owner's wallet, minted, or from a pool.
     const id = `fund:${s.key}`;
-    if (!s.sealed || !Number(s.fund ?? 0) || (live?.landed ?? []).includes(id) || live?.published?.schedules?.some((x) => x.key === s.key)) continue;
+    if (
+      !s.sealed ||
+      !Number(s.fund ?? 0) ||
+      (live?.landed ?? []).includes(id) ||
+      live?.published?.schedules?.some(x => x.key === s.key)
+    )
+      continue;
     const t = m.tokens.get(s.currency ?? m.currencyKey);
     const from = s.fundFrom ?? 'wallet';
     add({
@@ -516,51 +1044,126 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
       signers: from === 'wallet' || m.authority === 'owner' ? [owner] : ['authority'],
       says: `Put ${s.fund} ${t?.symbol ?? ''} in the sealed schedule “${s.name ?? s.key}”${from === 'wallet' ? ' from your wallet' : from === 'mint' ? ', minted' : ` from “${from.slice(5)}”`}: nobody can take it back`,
       creates: [],
-      build: (ctx) => {
+      build: ctx => {
         const mint = ctx.mints[t.key];
         const vest = loot.pda.vest(loot.pda.schedule(project(ctx), s.id));
         const value = amount(s.fund, t);
         if (from === 'wallet') {
           const tokenProgram = programsOf(ctx)[mint] ?? TOKEN_PROGRAM;
           // SOL is wrapped first, as a seed is: the owner's wallet holds it as plain SOL, the vault takes wrapped SOL.
-          const wrap = t.wsol ? [createAssociatedTokenAccountIdempotent(ctx.owner, ctx.owner, NATIVE_MINT), transferLamports(ctx.owner, loot.ata(ctx.owner, NATIVE_MINT), value), syncNative(loot.ata(ctx.owner, NATIVE_MINT))] : [];
-          return [...wrap, transferCheckedIx({ from: loot.ata(ctx.owner, mint, tokenProgram), mint, to: vest, owner: ctx.owner, amount: value, decimals: t.decimals ?? 0, tokenProgram })];
+          const wrap = t.wsol
+            ? [
+                createAssociatedTokenAccountIdempotent(ctx.owner, ctx.owner, NATIVE_MINT),
+                transferLamports(ctx.owner, loot.ata(ctx.owner, NATIVE_MINT), value),
+                syncNative(loot.ata(ctx.owner, NATIVE_MINT)),
+              ]
+            : [];
+          return [
+            ...wrap,
+            transferCheckedIx({
+              from: loot.ata(ctx.owner, mint, tokenProgram),
+              mint,
+              to: vest,
+              owner: ctx.owner,
+              amount: value,
+              decimals: t.decimals ?? 0,
+              tokenProgram,
+            }),
+          ];
         }
         const source = from === 'mint' ? { Mint: [mint] } : { Pool: [m.pool.get(from.slice(5))?.index ?? 0] };
-        return [loot.moveTokensIx({ authority: ctx.authority, project: project(ctx), mint, from: source, to: { Account: [vest] }, amount: { Fixed: [value] }, programs: programsOf(ctx) })];
+        return [
+          loot.moveTokensIx({
+            authority: ctx.authority,
+            project: project(ctx),
+            mint,
+            from: source,
+            to: { Account: [vest] },
+            amount: { Fixed: [value] },
+            programs: programsOf(ctx),
+          }),
+        ];
       },
     });
   }
   for (const l of m.lotteries) {
-    // A raffle's NFT goes into the lottery's own stash first: the lottery is written naming an NFT already there.
-    for (const p of (l.places ?? []).map(placeOf).filter((p) => p.prize?.held)) {
-      const id = `stash:lottery-${l.key}:${p.prize.nft}`;
-      if ((live?.landed ?? []).includes(id) || live?.published?.lotteries?.some((x) => x.key === l.key)) continue;
+    // A raffle's NFTs go into the lottery's own stash first, several a call: the lottery is written naming NFTs already
+    // there, or drawing from as many as its places.
+    const raffled = [
+      ...(l.places ?? [])
+        .map(placeOf)
+        .filter(p => p.prize?.held)
+        .map(p => ({ nft: p.prize.nft, collection: p.prize.collection })),
+      ...(l.nfts ?? []).map(n => (typeof n === 'string' ? { nft: n } : n)),
+    ];
+    const opened = live?.published?.lotteries?.some(x => x.key === l.key);
+    groupsOf(
+      raffled.filter(n => !(live?.landed ?? []).includes(`stash:lottery-${l.key}:${n.nft}`)),
+      STASH_GROUP,
+    ).forEach((group, i) => {
+      if (opened) return;
       add({
-        id,
+        id: `stash:lottery-${l.key}:${group.map(n => n.nft).join(',')}`,
         part: `lottery:${l.key}`,
-        says: `Put your NFT ${p.prize.nft} in the lottery “${l.name}”: it stays there until its winner takes it, and nobody, you included, can take it out before`,
-        creates: [{ what: `the lottery “${l.name}”’s stash`, bytes: STASH_HEAD_BYTES + 32 }],
-        build: (ctx) => [loot.stashIx({ signer: ctx.owner, project: project(ctx), lottery: l.id, asset: p.prize.nft, collection: p.prize.collection ?? ctx.collection })],
+        says: `Put your NFT${group.length === 1 ? ` ${group[0].nft}` : `s ${group.map(n => n.nft).join(', ')}`} in the lottery “${l.name}”: ${group.length === 1 ? 'it stays' : 'they stay'} there until ${group.length === 1 ? 'its winner takes it' : 'their winners take them'}, and nobody, you included, can take ${group.length === 1 ? 'it' : 'them'} out before`,
+        creates: i === 0 ? [{ what: `the lottery “${l.name}”’s stash`, bytes: stashBytes(raffled.length) }] : [],
+        build: ctx => [
+          loot.stashIx({
+            signer: ctx.owner,
+            project: project(ctx),
+            lottery: l.id,
+            asset: group[0].nft,
+            collection: group[0].collection ?? ctx.collection,
+            more: group.slice(1).map(n => ({ asset: n.nft, collection: n.collection ?? ctx.collection })),
+          }),
+        ],
       });
-    }
-    record(`lottery:${l.key}`, { Lottery: { id: l.id, args: lotteryArgs(l, m) } }, `Start the ${l.raffle ? 'raffle' : 'lottery'} “${l.name}”`, 'Lottery', `the lottery “${l.name}”`);
+    });
+    record(
+      `lottery:${l.key}`,
+      { Lottery: { id: l.id, args: lotteryArgs(l, m) } },
+      `Start the ${l.raffle ? 'raffle' : 'lottery'} “${l.name}”`,
+      'Lottery',
+      `the lottery “${l.name}”`,
+    );
   }
-  for (const g of m.grants) record(`grant:${g.key}`, { Grant: { id: g.id, args: grantArgs(g, m) } }, `Write the grant “${g.name}”`, 'Grant', `the grant “${g.name}”`);
+  for (const g of m.grants)
+    record(
+      `grant:${g.key}`,
+      { Grant: { id: g.id, args: grantArgs(g, m) } },
+      `Write the grant “${g.name}”`,
+      'Grant',
+      `the grant “${g.name}”`,
+    );
+  /** The boxes a farm's tiers roll, tier by tier (its roll, then a prize that is a roll). */
   for (const f of m.farms) {
     if (live?.farms?.includes(f.key)) continue;
-    const rewards = m.poolToken(f.rewards);
+    const rewards = m.tokens.get(f.rewardsToken);
     add({
       id: `farm:${f.key}`,
       part: `farm:${f.key}`,
-      says: `Open the farm “${f.name}”: stake ${f.stakes === 'collectibles' ? 'collectibles' : m.tokens.get(f.stakes)?.symbol}, earn ${rewards?.symbol} from “${f.rewards}”`,
-      creates: [{ what: `the farm “${f.name}”`, bytes: encodedSize('Farm', { project: NOBODY, id: 0, farmed: f.stakes === 'collectibles' ? 'Collectibles' : { Tokens: { mint: NOBODY } }, ...placeholders(farmArgs(f, m)), rewards_mint: NOBODY, rate_at: 0n, rate_carry: 0n, total_weight: 0n, reward_per_weight: 0n, reward_remainder: 0n, given: 0n, unreleased: 0n, released_at: 0n, release_ends: 0n, release_from: 0n, release_base: 0n }) }, { what: 'its rewards vault', bytes: 165 }, ...(f.stakes === 'collectibles' ? [] : [{ what: 'its stake vault', bytes: 165 }])],
-      build: (ctx) => [loot.openFarmIx({ owner: ctx.owner, project: project(ctx), id: f.id, args: resolve(farmArgs(f, m), ctx), rewardsMint: ctx.mints[rewards.key], stakedMint: f.stakes === 'collectibles' ? null : ctx.mints[f.stakes] })],
+      says: `Open the farm “${f.name}”: stake ${f.stakes === 'collectibles' ? 'collectibles' : m.tokens.get(f.stakes)?.symbol}, earn ${rewards?.symbol}${f.rate?.minted ? ', minted' : ' from its own rewards vault'}`,
+      creates: [
+        { what: `the farm “${f.name}”`, bytes: farmBytes(f, m) },
+        { what: 'its rewards vault', bytes: 165 },
+        ...(f.stakes === 'collectibles' ? [] : [{ what: 'its stake vault', bytes: 165 }]),
+        ...(farmEnds(f) ? [{ what: 'its record of when seats stop earning', bytes: loot.ENDS_HEAD_BYTES }] : []),
+      ],
+      build: ctx => [
+        loot.openFarmIx({
+          owner: ctx.owner,
+          project: project(ctx),
+          id: f.id,
+          args: resolve(farmArgs(f, m), ctx),
+          rewardsMint: ctx.mints[rewards.key],
+          stakedMint: f.stakes === 'collectibles' ? null : ctx.mints[f.stakes],
+        }),
+      ],
     });
   }
 
   // Traits the project vouches for from NFTs' off-chain metadata: one Merkle root per collection, signed once.
-  const vouched = new Map((live?.published?.traits ?? []).map((t) => [t.collection, t.root]));
+  const vouched = new Map((live?.published?.traits ?? []).map(t => [t.collection, t.root]));
   for (const t of m.traits) {
     if (vouched.get(t.collection) === t.root) continue;
     add({
@@ -568,7 +1171,14 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
       part: `traits:${t.collection}`,
       says: `Vouch for the traits of the NFTs of ${t.collection} (a root of their off-chain metadata)`,
       creates: [{ what: `the traits of ${t.collection}`, bytes: 1 + 32 * 3 }],
-      build: (ctx) => [loot.setTraitsIx({ signer: ctx.owner, project: project(ctx), key: t.collection, root: Uint8Array.from(t.root.match(/../g).map((h) => parseInt(h, 16))) })],
+      build: ctx => [
+        loot.setTraitsIx({
+          signer: ctx.owner,
+          project: project(ctx),
+          key: t.collection,
+          root: Uint8Array.from(t.root.match(/../g).map(h => parseInt(h, 16))),
+        }),
+      ],
     });
   }
 
@@ -576,30 +1186,68 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
   // needs a proof fetched when it is signed, so the checker leaves those to `loot.stashIx` after go-live.
   // What is in a live stash already: what its last publish listed, and the steps of this one that landed.
   const stashed = new Set([
-    ...(live?.published?.stashes ?? []).flatMap((s) => stashNfts(s).map((n) => `${s.key}:${n.asset}`)),
-    ...(live?.landed ?? []).filter((id) => id.startsWith('stash:')).map((id) => id.slice(6)),
+    ...(live?.published?.stashes ?? []).flatMap(s => stashNfts(s).map(n => `${s.key}:${n.asset}`)),
+    // A step puts in a group of NFTs: `stash:<key>:<asset>,<asset>…`.
+    ...(live?.landed ?? [])
+      .filter(id => id.startsWith('stash:'))
+      .flatMap(id => {
+        const [key, assets = ''] = id.slice(6).split(/:(.*)/s);
+        return assets.split(',').map(asset => `${key}:${asset}`);
+      }),
   ]);
   for (const s of m.stashes) {
     const nfts = stashNfts(s);
-    const putting = nfts.filter((n) => n.kind !== 'compressed' && !stashed.has(`${s.key}:${n.asset}`));
+    const putting = nfts.filter(n => n.kind !== 'compressed' && !stashed.has(`${s.key}:${n.asset}`));
     // The first NFT this plan puts in names the stash's rent: all of it for a new stash, what it grows by for one live already.
-    const fresh = !nfts.some((n) => stashed.has(`${s.key}:${n.asset}`));
-    for (const [i, n] of putting.entries()) {
+    const fresh = !nfts.some(n => stashed.has(`${s.key}:${n.asset}`));
+    // Several NFTs a call, each with its weight: Core NFTs a group of `STASH_GROUP`, Token Metadata ones two (each takes
+    // more accounts).
+    const kindOf = n => ({
+      asset: n.asset,
+      weight: n.weight,
+      collection: n.kind === 'core' ? n.collection : undefined,
+      tokenMetadata:
+        n.kind === 'token-metadata' ? { programmable: n.programmable, ruleSet: n.ruleSet ?? undefined } : undefined,
+    });
+    const groups = [
+      ...groupsOf(
+        putting.filter(n => n.kind === 'core'),
+        STASH_GROUP,
+      ),
+      ...groupsOf(
+        putting.filter(n => n.kind !== 'core'),
+        2,
+      ),
+    ];
+    for (const [i, group] of groups.entries()) {
       add({
-        id: `stash:${s.key}:${n.asset}`,
+        id: `stash:${s.key}:${group.map(n => n.asset).join(',')}`,
         part: `stash:${s.key}`,
-        says: `Put your NFT ${n.asset} in the stash “${s.name}”: the project holds it until a prize or a roll gives it away`,
-        creates: i > 0 ? [] : fresh ? [{ what: `the stash “${s.name}”, with ${putting.length} NFT${putting.length === 1 ? '' : 's'}`, bytes: STASH_HEAD_BYTES + 32 * putting.length }] : [{ what: `room for ${putting.length} more NFT${putting.length === 1 ? '' : 's'} in “${s.name}”`, bytes: 32 * putting.length, grows: true }],
-        build: (ctx) => [
-          loot.stashIx({
-            signer: ctx.owner,
-            project: project(ctx),
-            id: s.id,
-            asset: n.asset,
-            collection: n.kind === 'core' ? n.collection ?? ctx.collection : undefined,
-            tokenMetadata: n.kind === 'token-metadata' ? { programmable: n.programmable, ruleSet: n.ruleSet ?? undefined } : undefined,
-          }),
-        ],
+        says: `Put your NFT${group.length === 1 ? ` ${group[0].asset}` : `s ${group.map(n => n.asset).join(', ')}`} in the stash “${s.name}”: the project holds ${group.length === 1 ? 'it' : 'them'} until a prize or a roll gives ${group.length === 1 ? 'it' : 'them'} away`,
+        creates:
+          i > 0
+            ? []
+            : fresh
+              ? [
+                  {
+                    what: `the stash “${s.name}”, with ${putting.length} NFT${putting.length === 1 ? '' : 's'}`,
+                    bytes: stashBytes(putting.length),
+                  },
+                ]
+              : [
+                  {
+                    what: `room for ${putting.length} more NFT${putting.length === 1 ? '' : 's'} in “${s.name}”`,
+                    bytes: 36 * putting.length,
+                    grows: true,
+                  },
+                ],
+        build: ctx => {
+          const [first, ...more] = group.map(n => {
+            const k = kindOf(n);
+            return { ...k, collection: n.kind === 'core' ? (k.collection ?? ctx.collection) : undefined };
+          });
+          return [loot.stashIx({ signer: ctx.owner, project: project(ctx), id: s.id, ...first, more })];
+        },
       });
     }
   }
@@ -621,10 +1269,47 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
         : a.lot?.roll
           ? `Open the auction “${a.name}” of a roll of the box “${m.box.get(a.lot.roll)?.name ?? a.lot.roll}”, made for its winner at the end (${terms})`
           : `Open the auction “${a.name}” of one new “${m.item.get(a.lot?.item)?.name ?? a.lot?.item}” (${terms})`,
-      creates: [{ what: `the auction “${a.name}” (back when it ends)`, bytes: encodedSize('Auction', { project: NOBODY, id: 0, seller: NOBODY, mint: NOBODY, lot: args.lot, ours: false, serial: 0, reserve: 0n, min_raise_bps: 0, starts_at: 0n, ends_at: 0n, extend: 0, high_bidder: NOBODY, high: 0n, last_bid_at: 0n, shares: args.shares, gate: args.gate, nft_bids: placeholders(args).nft_bids, held: [] }) }],
-      build: (ctx) => {
+      // An auction of NFT bids is made with room for the most a bid holds (`MAX_BID_NFTS`), its seller's rent.
+      creates: [
+        {
+          what: `the auction “${a.name}” (back when it ends)`,
+          bytes:
+            encodedSize('Auction', {
+              project: NOBODY,
+              id: 0,
+              seller: NOBODY,
+              mint: NOBODY,
+              lot: args.lot,
+              ours: false,
+              pin: 0,
+              reserve: 0n,
+              min_raise_bps: 0,
+              starts_at: 0n,
+              ends_at: 0n,
+              extend: 0,
+              shares: args.shares,
+              gate: args.gate,
+              nft_bids: placeholders(args).nft_bids,
+              high_bidder: NOBODY,
+              high: 0n,
+              last_bid_at: 0n,
+              proceeds_owed: 0n,
+              held: [],
+            }) + (args.nft_bids ? 32 * loot.MAX_BID_NFTS : 0),
+        },
+      ],
+      build: ctx => {
         const seller = auctionSeller(a, ctx);
-        return [loot.openAuctionIx({ seller, project: project(ctx), collection: a.lot?.collection ?? ctx.collection, id: a.id, mint: ctx.mints[t.key], args: resolve(args, ctx) })];
+        return [
+          loot.openAuctionIx({
+            seller,
+            project: project(ctx),
+            collection: a.lot?.collection ?? ctx.collection,
+            id: a.id,
+            mint: ctx.mints[t.key],
+            args: resolve(args, ctx),
+          }),
+        ];
       },
     });
   }
@@ -641,48 +1326,259 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
         part: `seed:${p.key}`,
         signers: [signer],
         says: `Mint ${p.seed} ${t.symbol} into “${p.key}”`,
-        build: (ctx) => [loot.moveTokensIx({ authority: ctx.authority, project: project(ctx), mint: ctx.mints[t.key], from: { Mint: [ctx.mints[t.key]] }, to: { Pool: [p.index] }, amount: { Fixed: [units] }, reference: `seed ${p.key}` })],
+        build: ctx => [
+          loot.moveTokensIx({
+            authority: ctx.authority,
+            project: project(ctx),
+            mint: ctx.mints[t.key],
+            from: { Mint: [ctx.mints[t.key]] },
+            to: { Pool: [p.index] },
+            amount: { Fixed: [units] },
+            reference: `seed ${p.key}`,
+          }),
+        ],
       });
     } else {
       add({
         id: `seed:${p.key}`,
         part: `seed:${p.key}`,
         says: `Put ${p.seed} ${t.symbol} into “${p.key}”`,
-        build: (ctx) => [
-          ...(t.wsol ? [createAssociatedTokenAccountIdempotent(ctx.owner, ctx.owner, NATIVE_MINT), transferLamports(ctx.owner, loot.ata(ctx.owner, NATIVE_MINT), units), syncNative(loot.ata(ctx.owner, NATIVE_MINT))] : []),
-          loot.payIx({ player: ctx.owner, project: project(ctx), mint: ctx.mints[t.key], treasury: ctx.treasury, amount: units, shares: [{ to: { Pool: [p.index] }, bps: 10_000 }], reference: `seed ${p.key}`, programs: { [ctx.mints[t.key]]: tokenProgramOf(t) } }),
+        build: ctx => [
+          ...(t.wsol
+            ? [
+                createAssociatedTokenAccountIdempotent(ctx.owner, ctx.owner, NATIVE_MINT),
+                transferLamports(ctx.owner, loot.ata(ctx.owner, NATIVE_MINT), units),
+                syncNative(loot.ata(ctx.owner, NATIVE_MINT)),
+              ]
+            : []),
+          loot.payIx({
+            player: ctx.owner,
+            project: project(ctx),
+            mint: ctx.mints[t.key],
+            treasury: ctx.treasury,
+            amount: units,
+            shares: [{ to: { Pool: [p.index] }, bps: 10_000 }],
+            reference: `seed ${p.key}`,
+            programs: { [ctx.mints[t.key]]: tokenProgramOf(t) },
+          }),
         ],
       });
     }
   }
+  /** A seed in a token the project mints (no fixed supply): the owner's wallet holds none of it, so the authority
+   * mints it straight into its account, as a pool's seed is minted into the pool. */
+  const mintedSeed = (id, part, t, units, says, account) => {
+    const signer = m.authority === 'owner' ? owner : 'authority';
+    add({
+      id,
+      part,
+      signers: [signer],
+      says,
+      build: ctx => [
+        loot.moveTokensIx({
+          authority: ctx.authority,
+          project: project(ctx),
+          mint: ctx.mints[t.key],
+          from: { Mint: [ctx.mints[t.key]] },
+          to: { Account: [account(ctx)] },
+          amount: { Fixed: [units] },
+          reference: id.replace(/^seed:[a-z]+:/, 'seed '),
+        }),
+      ],
+    });
+  };
+  // A farm's seed: the owner puts it straight into the farm's rewards vault, once the farm is open.
+  for (const f of m.farms) {
+    if (!(Number(f.seed ?? 0) > 0) || live?.seeded?.includes(`farm:${f.key}`)) continue;
+    const t = m.tokens.get(f.rewardsToken);
+    const units = amount(f.seed, t);
+    if (t.gameMints) {
+      mintedSeed(
+        `seed:farm:${f.key}`,
+        `farm:${f.key}`,
+        t,
+        units,
+        `Mint ${f.seed} ${t.symbol} into the rewards of “${f.name}”`,
+        ctx => loot.pda.rewards(loot.pda.farm(project(ctx), f.id)),
+      );
+      continue;
+    }
+    add({
+      id: `seed:farm:${f.key}`,
+      part: `farm:${f.key}`,
+      says: `Put ${f.seed} ${t.symbol} into the rewards of “${f.name}”`,
+      build: ctx => {
+        const vault = loot.pda.rewards(loot.pda.farm(project(ctx), f.id));
+        return [
+          ...(t.wsol
+            ? [
+                createAssociatedTokenAccountIdempotent(ctx.owner, ctx.owner, NATIVE_MINT),
+                transferLamports(ctx.owner, loot.ata(ctx.owner, NATIVE_MINT), units),
+                syncNative(loot.ata(ctx.owner, NATIVE_MINT)),
+              ]
+            : []),
+          loot.payIx({
+            player: ctx.owner,
+            project: project(ctx),
+            mint: ctx.mints[t.key],
+            treasury: ctx.treasury,
+            amount: units,
+            shares: [{ to: { Account: [vault] }, bps: 10_000 }],
+            reference: `seed ${f.key}`,
+            programs: programsOf(ctx),
+          }),
+        ];
+      },
+    });
+  }
   // A lottery's seed: the owner puts it straight into the lottery's pot.
   for (const l of m.lotteries) {
     if (!(Number(l.seed ?? 0) > 0) || live?.seeded?.includes(`lottery:${l.key}`)) continue;
     const t = m.tokens.get(l.currency ?? m.currencyKey);
     const units = amount(l.seed, t);
+    if (t.gameMints) {
+      mintedSeed(
+        `seed:lottery:${l.key}`,
+        `lottery:${l.key}`,
+        t,
+        units,
+        `Mint ${l.seed} ${t.symbol} into the pot of “${l.name}”`,
+        ctx => loot.pda.lotteryPot(loot.pda.lottery(project(ctx), l.id), l.pot),
+      );
+      continue;
+    }
     add({
       id: `seed:lottery:${l.key}`,
       part: `lottery:${l.key}`,
       says: `Put ${l.seed} ${t.symbol} into the pot of “${l.name}”`,
-      build: (ctx) => {
-        const pot = loot.pda.pot(loot.pda.lottery(project(ctx), l.id));
+      build: ctx => {
+        const pot = loot.pda.lotteryPot(loot.pda.lottery(project(ctx), l.id), l.pot);
         return [
-          ...(t.wsol ? [createAssociatedTokenAccountIdempotent(ctx.owner, ctx.owner, NATIVE_MINT), transferLamports(ctx.owner, loot.ata(ctx.owner, NATIVE_MINT), units), syncNative(loot.ata(ctx.owner, NATIVE_MINT))] : []),
-          loot.payIx({ player: ctx.owner, project: project(ctx), mint: ctx.mints[t.key], treasury: ctx.treasury, amount: units, shares: [{ to: { Account: [pot] }, bps: 10_000 }], reference: `seed ${l.key}`, programs: programsOf(ctx) }),
+          ...(t.wsol
+            ? [
+                createAssociatedTokenAccountIdempotent(ctx.owner, ctx.owner, NATIVE_MINT),
+                transferLamports(ctx.owner, loot.ata(ctx.owner, NATIVE_MINT), units),
+                syncNative(loot.ata(ctx.owner, NATIVE_MINT)),
+              ]
+            : []),
+          loot.payIx({
+            player: ctx.owner,
+            project: project(ctx),
+            mint: ctx.mints[t.key],
+            treasury: ctx.treasury,
+            amount: units,
+            shares: [{ to: { Account: [pot] }, bps: 10_000 }],
+            reference: `seed ${l.key}`,
+            programs: programsOf(ctx),
+          }),
         ];
       },
     });
   }
+  // SOL a lottery holds for its rounds' rent (`roundRentOf`: the spec's `roundRent`, or by default what its expected
+  // rounds and their entries take): each round borrows it at its first purchase (its header and payment account), each
+  // purchase's entry, and its ask (the pot's and pools' accounts), back at its close. A lottery live already keeps what
+  // it holds unless the spec names a `roundRent` to add.
+  for (const l of m.lotteries) {
+    const lamports = roundRentOf(l, m);
+    if (lamports <= 0n || (l.roundRent === undefined && (live?.published?.lotteries ?? []).some(x => x.key === l.key)))
+      continue;
+    const sol = Number(lamports) / 1e9;
+    add({
+      id: `rent:lottery:${l.key}`,
+      part: `lottery:${l.key}`,
+      says: `Put ${sol} SOL in “${l.name}” for its rounds’ rent and its tickets’ entries${l.roundRent === undefined ? ` (sized for ${roundsExpected(l, m).rounds} round${roundsExpected(l, m).rounds === 1 ? '' : 's'} of ${roundsExpected(l, m).entries} purchases at once)` : ''}, so no buyer pays program rent; each round gives it back when it closes`,
+      build: ctx => [transferLamports(ctx.owner, loot.pda.lottery(project(ctx), l.id), lamports)],
+    });
+  }
   for (const g of m.grants) {
     if (!(Number(g.fund ?? 0) > 0) || live?.funded?.includes(g.key)) continue;
     const lamports = toUnits(g.fund, 9);
-    add({ id: `fund:${g.key}`, part: `fund:${g.key}`, says: `Put ${g.fund} SOL in the funds of the grant “${g.name}” (they pay each claim’s rent)`, build: (ctx) => [transferLamports(ctx.owner, loot.pda.grant(project(ctx), g.id), lamports)] });
+    add({
+      id: `fund:${g.key}`,
+      part: `fund:${g.key}`,
+      says: `Put ${g.fund} SOL in the funds of the grant “${g.name}” (they pay each claim’s rent)`,
+      build: ctx => [transferLamports(ctx.owner, loot.pda.grant(project(ctx), g.id), lamports)],
+    });
   }
-  return { steps, model: m };
+  // The authority's steps go last: the owner approves theirs in one batch, the authority theirs in another.
+  return {
+    steps: [
+      ...steps.filter(x => !x.signers.includes('authority')),
+      ...steps.filter(x => x.signers.includes('authority')),
+    ],
+    model: m,
+  };
+}
+
+/** The token accounts going live opens (`setupSteps`): [{ who ('the treasury', 'the project' or a wallet), token }], each
+ * once, for the coins the economy takes in. */
+export function goLiveAccounts(m) {
+  const out = new Map();
+  const add = (who, token) => token && out.set(`${who}|${token}`, { who, token });
+  const takes = (part, token = part.currency ?? m.currencyKey) => {
+    add('the treasury', token);
+    for (const s of sharesOf(part.split)) if (s.kind === 'wallet') add(s.key, token);
+  };
+  for (const b of m.allBoxes) (takes(b), add('the project', b.currency ?? m.currencyKey));
+  for (const p of m.payments) takes(p);
+  for (const l of m.lotteries) if (!l.ticketNft) takes(l, l.ticketCurrency ?? l.currency ?? m.currencyKey);
+  for (const a of m.auctions) if (!a.bidNfts) (takes(a), add('the project', a.currency ?? m.currencyKey));
+  return [...out.values()];
+}
+
+/** How many addresses one step adds to the project's lookup table (each extension its own transaction). */
+const TABLE_GROUP = 24;
+
+/**
+ * The addresses a project's transactions name most, for its standing lookup table: loot's own fixed accounts (the
+ * platform, the oracle's), the project and its fee box, its treasury and collections, each coin's mint, its vault and
+ * the treasury's account of it, then each pool, item, box and stash. Each a function of the go-live context.
+ */
+export function standingAddresses(m) {
+  const fixed = [
+    loot.LOOT_PROGRAM,
+    loot.pda.platform(),
+    loot.pda.identity(),
+    loot.VRF_PROGRAM,
+    loot.VRF_QUEUE,
+    loot.MPL_CORE_PROGRAM,
+    TOKEN_PROGRAM,
+    TOKEN_2022_PROGRAM,
+    ASSOCIATED_TOKEN_PROGRAM,
+    SYSTEM_PROGRAM,
+    SYSVAR_SLOT_HASHES,
+    SYSVAR_INSTRUCTIONS,
+    MEMO_PROGRAM,
+  ].map(a => () => a);
+  const programOf = (ctx, key) => programsOf(ctx)[ctx.mints[key]] ?? TOKEN_PROGRAM;
+  return [
+    ...fixed,
+    ctx => ctx.project,
+    ctx => loot.pda.fees(ctx.project),
+    ctx => ctx.treasury,
+    ...(m.collection ? [ctx => ctx.collection] : []),
+    ...[...m.tokens.values()].flatMap(t => [
+      ctx => ctx.mints[t.key],
+      ctx => ctx.mints[t.key] && loot.ata(ctx.project, ctx.mints[t.key], programOf(ctx, t.key)),
+      ctx => ctx.mints[t.key] && loot.ata(ctx.treasury, ctx.mints[t.key], programOf(ctx, t.key)),
+    ]),
+    ...m.pools.map(p => ctx => loot.pda.pool(ctx.project, p.index)),
+    ...m.items.map(it => ctx => loot.pda.item(ctx.project, it.id)),
+    ...m.allBoxes.map(b => ctx => loot.pda.box(ctx.project, b.id)),
+    ...m.stashes.map(s => ctx => loot.pda.stash(ctx.project, s.id)),
+  ].slice(0, 256);
 }
 
-/** A stash's bytes before its NFTs: its tag, its project, its id and its count (`stash.rs`); each NFT adds 32. */
-export const STASH_HEAD_BYTES = 41;
+/** How many Core NFTs one `stash` call puts in (`Piece::another`: three accounts each after the first). */
+const STASH_GROUP = 6;
+/** `list` in groups of `n`. */
+const groupsOf = (list, n) =>
+  Array.from({ length: Math.ceil(list.length / n) }, (_, i) => list.slice(i * n, i * n + n));
+
+/** A stash's bytes with `n` NFTs: a table of NFTs (`table.rs`): its 51-byte header, a total for each group of 4,096
+ * rows and each block of 64, and 36 bytes an NFT (its weight and its address). */
+export const stashBytes = n => (n ? loot.tableRowAt(36, n - 1) + 36 : 51);
 
 /** Who puts a spec's auction up, and so is named in its address: the owner for a collectible it holds, the authority for a new unit of an item. */
 export const auctionSeller = (a, ctx) => (a.lot?.asset ? ctx.owner : ctx.authority);
@@ -690,31 +1586,98 @@ export const auctionSeller = (a, ctx) => (a.lot?.asset ? ctx.owner : ctx.authori
 export const recordBytesOf = (kind, body) => {
   const args = body.args;
   const base = {
-    Item: () => ({ project: NOBODY, item_id: 0, ...placeholders(args), issued: 0, voided: 0 }),
-    LootBox: () => ({ project: NOBODY, box_id: 0, ...placeholders(args), version: 0 }),
+    Item: () => ({ project: NOBODY, item_id: 0, ...placeholders(args), issued: 0, voided: 0, compressed: false }),
+    LootBox: () => ({ project: NOBODY, box_id: 0, ...placeholders(args), in_flight: 0n, version: 0 }),
     Recipe: () => ({ project: NOBODY, id: 0, version: 0, ...placeholders(args) }),
     Schedule: () => ({ project: NOBODY, id: 0, ...placeholders(args), runs: 0 }),
-    Lottery: () => ({ project: NOBODY, id: 0, pot_bump: 0, funds_bump: 0, incarnation: 0n, revision: 0, pending: 0, ...placeholders(args), places: [...(args.places ?? []).map((p) => (typeof p === 'object' ? { prize: null, ...p } : { bps: p, prize: null })), ...Array(LIMITS.places).fill({ bps: 0, prize: null })].slice(0, LIMITS.places), round: 0, status: 'Open', sold: 0n, asked_first: 0n, asked_slot: 0n, first_ticket: 0n, paid: 0, pot_at_payout: 0n, given: 0 }),
-    Grant: () => ({ project: NOBODY, id: 0, incarnation: 0n, ...placeholders(args), counters: { claimed: 0, today: 0, day: 0n } }),
+    // Its terms and its round number: each round keeps the rest in a record of its own.
+    Lottery: () => ({
+      project: NOBODY,
+      id: 0,
+      incarnation: 0n,
+      revision: 0,
+      ...placeholders(loot.withDefaults({ Lottery: { args } }).Lottery.args),
+      round: 0,
+      pots: 0,
+      owing: NOBODY,
+    }),
+    Grant: () => ({
+      project: NOBODY,
+      id: 0,
+      incarnation: 0n,
+      ...placeholders(args),
+      counted: { count: 0, window: 0, in_window: 0 },
+    }),
   }[kind];
   return encodedSize(kind, base());
 };
+/** A farm's bytes as `open_farm` writes it: its args and its numbers. */
+export const farmBytes = (f, m) =>
+  encodedSize('Farm', {
+    project: NOBODY,
+    id: 0,
+    farmed: f.stakes === 'collectibles' ? 'Collectibles' : { Tokens: { mint: NOBODY } },
+    ...placeholders(farmArgs(f, m)),
+    rewards_mint: NOBODY,
+    rate_carry: 0n,
+    opened_at: 0n,
+    total_weight: 0n,
+    reward_per_weight: 0n,
+    reward_remainder: 0n,
+    owed: 0n,
+    clock: 0n,
+    unreleased: 0n,
+    release_ends: 0n,
+    release_from: 0n,
+    release_base: 0n,
+    keeps_ends: farmEnds(f),
+  });
 /** Exact initial contest record size for its configured shares, gate, sides and deciders. */
-export const contestBytes = (contest, m) => encodedSize('Contest', { project: NOBODY, id: 0, incarnation: 0n, opener: NOBODY, mint: NOBODY, ...placeholders(contestArgs(contest, m)), verdict: 'Open', winner: 0, entries: 0, unclaimed: 0n, sides: Array(contest.sides).fill(0n), losers: 0 });
+export const contestBytes = (contest, m) =>
+  encodedSize('Contest', {
+    project: NOBODY,
+    id: 0,
+    incarnation: 0n,
+    opener: NOBODY,
+    mint: NOBODY,
+    decided_at: 0n,
+    ...placeholders(contestArgs(contest, m)),
+    verdict: 'Open',
+    winner: 0,
+    owed: 0n,
+    unclaimed: 0n,
+    pot_won: 0n,
+    prize_won: 0n,
+    sides: Array(contest.sides).fill(0n),
+    share: 0,
+    extras: 0,
+    picks: 0,
+  });
 /** Args with "@mint:" names standing in as addresses, for sizing. */
-const placeholders = (args) => resolve(args, { project: placeholderKey('project'), collection: placeholderKey('new:collection'), tree: placeholderKey('new:tree'), treasury: placeholderKey('treasury'), mints: new Proxy({}, { get: (_, k) => placeholderKey(`mint/${String(k)}`) }) });
+const placeholders = args =>
+  resolve(args, {
+    project: placeholderKey('project'),
+    collection: placeholderKey('new:collection'),
+    tree: placeholderKey('new:tree'),
+    treasury: placeholderKey('treasury'),
+    mints: new Proxy({}, { get: (_, k) => placeholderKey(`mint/${String(k)}`) }),
+  });
 /** The token program of each Token-2022 mint a context names (the program's account lists name it). */
-const programsOf = (ctx) => ctx.tokenPrograms ?? {};
+const programsOf = ctx => ctx.tokenPrograms ?? {};
 
 // ---------------------------------------------------------------- contexts
 
 /** Stand-in addresses for every name a plan uses, so it can be built and sized without a wallet. */
-export function placeholderContext(m, { rent = (bytes) => (BigInt(bytes) + ACCOUNT_OVERHEAD) * MOST_RENT_PER_BYTE } = {}) {
+export function placeholderContext(
+  m,
+  { rent = bytes => (BigInt(bytes) + ACCOUNT_OVERHEAD) * MOST_RENT_PER_BYTE } = {},
+) {
   const ownerKey = placeholderKey('owner');
   const collection = m.collection ? placeholderKey('new:collection') : null;
   const tree = compressedTree(m) ? placeholderKey('new:tree') : null;
   const mints = {};
-  for (const t of m.tokens.values()) mints[t.key] = t.mint?.startsWith('@') ? placeholderKey(`new:mint/${t.key}`) : t.mint;
+  for (const t of m.tokens.values())
+    mints[t.key] = t.mint?.startsWith('@') ? placeholderKey(`new:mint/${t.key}`) : t.mint;
   return {
     owner: ownerKey,
     authority: m.authority === 'owner' ? ownerKey : m.authority,
@@ -723,8 +1686,15 @@ export function placeholderContext(m, { rent = (bytes) => (BigInt(bytes) + ACCOU
     project: loot.pda.project(ownerKey, m.projectNumber),
     treasury: m.treasuryWallet ?? ownerKey,
     mints,
-    keys: { ...(collection ? { 'new:collection': collection } : {}), ...(tree ? { 'new:tree': tree } : {}), ...Object.fromEntries([...m.tokens.values()].map((t) => [`new:mint/${t.key}`, placeholderKey(`new:mint/${t.key}`)])) },
+    keys: {
+      ...(collection ? { 'new:collection': collection } : {}),
+      ...(tree ? { 'new:tree': tree } : {}),
+      ...Object.fromEntries(
+        [...m.tokens.values()].map(t => [`new:mint/${t.key}`, placeholderKey(`new:mint/${t.key}`)]),
+      ),
+    },
     rent,
+    slot: 0n,
   };
 }
 
@@ -750,7 +1720,8 @@ export function madeSoFar(live) {
   }
   if (!made('project', 'collection')) delete out.collection;
   if (!made('tree', 'tree')) delete out.tree;
-  if (live.mints) out.mints = Object.fromEntries(Object.entries(live.mints).filter(([key]) => made(`token:${key}`, `token:${key}`)));
+  if (live.mints)
+    out.mints = Object.fromEntries(Object.entries(live.mints).filter(([key]) => made(`token:${key}`, `token:${key}`)));
   return out;
 }
 
@@ -759,13 +1730,17 @@ export function setupContext(m, { owner: ownerKey, keys, live: given = {}, rent
   const live = madeSoFar(given) ?? {};
   // A setup goes on only in the owner's own project: never in one a file names for them.
   const own = loot.pda.project(ownerKey, m.projectNumber);
-  if (live.project && live.project !== own) throw new Error(`The live section names the project ${live.project}, which is not the project ${own} of the wallet ${ownerKey}.`);
+  if (live.project && live.project !== own)
+    throw new Error(
+      `The live section names the project ${live.project}, which is not the project ${own} of the wallet ${ownerKey}.`,
+    );
   const collection = live.collection ?? keys['new:collection'] ?? null;
   const tree = live.tree ?? keys['new:tree'] ?? null;
   const mints = {};
   // A mint the spec names by its address is that one, whatever the live section says; one the setup makes is the
   // live section's once it landed (checked against the chain by the approval page), else this setup's fresh key.
-  for (const t of m.tokens.values()) mints[t.key] = t.mint && !t.mint.startsWith('@') ? t.mint : live.mints?.[t.key] ?? keys[`new:mint/${t.key}`];
+  for (const t of m.tokens.values())
+    mints[t.key] = t.mint && !t.mint.startsWith('@') ? t.mint : (live.mints?.[t.key] ?? keys[`new:mint/${t.key}`]);
   return {
     owner: ownerKey,
     authority: m.authority === 'owner' ? ownerKey : m.authority,
@@ -782,17 +1757,21 @@ export function setupContext(m, { owner: ownerKey, keys, live: given = {}, rent
 // ---------------------------------------------------------------- packing
 
 /** The bytes of a transaction of `instructions` the owner pays for: what `pack` holds against the budget. */
-export const stepBytes = (instructions, ctx) => transactionSize(compileMessage({ payer: ctx.owner, blockhash: placeholderKey('blockhash'), instructions }));
+export const stepBytes = (instructions, ctx) =>
+  transactionSize(compileMessage({ payer: ctx.owner, blockhash: placeholderKey('blockhash'), instructions }));
 
 /** Packs steps into transactions under the size budget, one signer set at a time; each step whole. */
 export function pack(steps, ctx) {
   const transactions = [];
   let current = null;
-  const sizeOf = (instructions) => stepBytes(instructions, ctx);
+  const sizeOf = instructions => stepBytes(instructions, ctx);
   for (const step of steps) {
     const instructions = step.build(ctx);
+    // A step with nothing to send (the lookup table of a plan built with no recent slot) is left out.
+    if (!instructions.length) continue;
     const signerKind = step.signers.includes('authority') ? 'authority' : 'owner';
-    if (current && current.signer === signerKind) {
+    // A write that names boxes to roll takes all the compute a transaction has: alone.
+    if (current && current.signer === signerKind && !step.alone && !current.alone) {
       const next = [...current.instructions, ...instructions];
       if (sizeOf(next) <= BUDGET) {
         current.instructions = next;
@@ -805,7 +1784,14 @@ export function pack(steps, ctx) {
     const size = sizeOf(instructions);
     if (size > BUDGET) throw new Error(`The step “${step.says}” is ${size} bytes: too big for one transaction.`);
     // `built`: each step's own instructions, in the order of `steps`.
-    current = { signer: signerKind, steps: [step], built: [instructions], instructions, signers: [...step.signers] };
+    current = {
+      signer: signerKind,
+      steps: [step],
+      built: [instructions],
+      instructions,
+      signers: [...step.signers],
+      alone: Boolean(step.alone),
+    };
     transactions.push(current);
   }
   for (const t of transactions) t.bytes = sizeOf(t.instructions);
@@ -820,7 +1806,12 @@ export function plan(economy, { now = Math.floor(Date.now() / 1000), ctx = null,
   const checked = check(economy, { now });
   if (!checked.ok) return { ok: false, refusals: checked.refusals, warnings: checked.warnings };
   const { steps, model: m } = setupSteps(economy, { now, only, live });
-  if (ctx) ctx.tokenPrograms ??= Object.fromEntries([...m.tokens.values()].filter((t) => t.program === 'token-2022' && ctx.mints[t.key]).map((t) => [ctx.mints[t.key], TOKEN_2022_PROGRAM]));
+  if (ctx)
+    ctx.tokenPrograms ??= Object.fromEntries(
+      [...m.tokens.values()]
+        .filter(t => t.program === 'token-2022' && ctx.mints[t.key])
+        .map(t => [ctx.mints[t.key], TOKEN_2022_PROGRAM]),
+    );
   const context = ctx ?? placeholderContext(m);
   const transactions = pack(steps, context);
   return {
@@ -828,8 +1819,11 @@ export function plan(economy, { now = Math.floor(Date.now() / 1000), ctx = null,
     warnings: checked.warnings,
     steps,
     transactions,
-    approvals: Math.max(1, Math.ceil(transactions.filter((t) => t.signer === 'owner').length / PER_APPROVAL)) + (transactions.some((t) => t.signer === 'authority') ? 1 : 0),
-    freshKeys: [...new Set(steps.flatMap((s) => s.signers.filter((x) => x.startsWith('new:'))))],
+    // A wallet approves up to PER_APPROVAL transactions at once: the owner's, then the authority's (its steps go last).
+    approvals:
+      Math.max(1, Math.ceil(transactions.filter(t => t.signer === 'owner').length / PER_APPROVAL)) +
+      Math.ceil(transactions.filter(t => t.signer === 'authority').length / PER_APPROVAL),
+    freshKeys: [...new Set(steps.flatMap(s => s.signers.filter(x => x.startsWith('new:'))))],
   };
 }
 
@@ -841,47 +1835,140 @@ export function playSteps(economy) {
   // A shop item, and any box with one outcome and nothing random, sells in one instruction: price split, prize given.
   for (const b of m.shop) {
     const it = m.item.get(b.shopOf);
-    add(`item:${it.key}`, 'buy', 'player', it.kind === 'normal' ? `buy “${it.name}”: the project’s backend delivers it from the receipt` : `buy “${it.name}”: minted to them at once`);
+    add(
+      `item:${it.key}`,
+      'buy',
+      'player',
+      it.kind === 'normal'
+        ? `buy “${it.name}”: the project’s backend delivers it from the receipt`
+        : `buy “${it.name}”: minted to them at once`,
+    );
   }
   for (const b of m.boxes) {
-    if (boxBuys(b)) {
+    if (boxBuys(b, m)) {
       add(`box:${b.key}`, 'buy', 'player', `buy “${b.name}”: what it gives, at once`);
       continue;
     }
     add(`box:${b.key}`, 'open_box', 'player', `open “${b.name}”`);
-    if (boxRolls(b)) add(`box:${b.key}`, 'callback_roll', 'the oracle', 'roll it');
-    add(`box:${b.key}`, 'settle', 'anyone', 'carry out what it rolled');
+    if (boxRolls(b, m)) add(`box:${b.key}`, 'callback_roll', 'the oracle', 'roll it');
+    add(`box:${b.key}`, 'settle', 'the player, a key they named, or the project’s keys', 'carry out what it rolled');
   }
   for (const p of m.payments) add(`payment:${p.key}`, 'pay', 'player', `pay “${p.name}”`);
   add('payments', 'pay_nft', 'player', 'pay with an NFT (burned, or given to a wallet): the receipt is the record');
-  for (const s of m.stashes) add(`stash:${s.key}`, 'stash', 'the owner or the authority', `put an NFT it holds in “${s.name}”, or take one out to any wallet`);
-  for (const r of prizeRolls(m).filter((r) => !['mission', 'recipe'].includes(r.route))) {
-    add(r.by, 'ask_roll', 'anyone, who pays the oracle', `ask for the roll of “${m.box.get(r.box)?.name ?? r.box}” a winner got (${r.route})`);
-    add(r.by, 'settle', 'anyone', 'carry out what it rolled');
+  for (const s of m.stashes)
+    add(
+      `stash:${s.key}`,
+      'stash',
+      'the owner or the authority',
+      `put an NFT it holds in “${s.name}”, or take one out to any wallet`,
+    );
+  for (const r of prizeRolls(m).filter(r => !['mission', 'recipe'].includes(r.route))) {
+    add(
+      r.by,
+      'ask_roll',
+      'the winner or the project’s keys, who pay the oracle',
+      `ask for the roll of “${m.box.get(r.box)?.name ?? r.box}” a winner got (${r.route})`,
+    );
+    add(r.by, 'settle', 'the winner, a key they named, or the project’s keys', 'carry out what it rolled');
   }
   for (const r of m.recipes) add(`recipe:${r.key}`, 'craft', 'player', `craft “${r.name}”`);
-  for (const s of m.schedules) add(`schedule:${s.key}`, 'run_schedule', 'anyone', `run “${s.name ?? s.key}” when it is due`);
-  for (const l of m.lotteries) add(`lottery:${l.key}`, 'buy_tickets', 'player', 'buy tickets'), add(`lottery:${l.key}`, 'draw_lottery', 'anyone', 'ask for the draw when it is due'), add(`lottery:${l.key}`, 'finish_lottery_contribution', 'anyone', 'finish each purchase, then pay each winner');
+  for (const s of m.schedules)
+    add(
+      `schedule:${s.key}`,
+      'run_schedule',
+      'the project’s keys, or who it pays',
+      `run “${s.name ?? s.key}” when it is due`,
+    );
+  for (const l of m.lotteries)
+    (add(`lottery:${l.key}`, 'buy_tickets', 'player', 'buy tickets'),
+      add(`lottery:${l.key}`, 'draw_lottery', 'anyone', 'ask for the draw when it is due'),
+      add(
+        `lottery:${l.key}`,
+        'pull',
+        'anyone',
+        'pay one part: a refund, a place’s part of the pot or its prize, a share owed in common',
+      ));
   for (const f of m.farms) {
-    if (f.stakes === 'collectibles') add(`farm:${f.key}`, 'stake_nft', 'player', 'stake a collectible'), add(`farm:${f.key}`, 'unstake_nft', 'player', 'take it out once its lock has run');
-    else add(`farm:${f.key}`, 'stake_tokens', 'player', 'stake'), add(`farm:${f.key}`, 'unstake_tokens', 'player', 'unstake or collect'), add(`farm:${f.key}`, 'stake_nft', 'player', 'put a collectible on as a booster');
+    if (f.stakes === 'collectibles')
+      (add(`farm:${f.key}`, 'stake_nft', 'player', 'stake a collectible'),
+        add(`farm:${f.key}`, 'unstake_nft', 'player', 'take it out once its lock has run'));
+    else
+      (add(`farm:${f.key}`, 'stake_tokens', 'player', 'stake'),
+        add(`farm:${f.key}`, 'unstake_tokens', 'player', 'unstake or collect'),
+        add(`farm:${f.key}`, 'stake_nft', 'player', 'put a collectible on as a booster'));
     add(`farm:${f.key}`, 'harvest', 'player', 'collect rewards');
     add(`farm:${f.key}`, 'refresh_seat', 'anyone', 'read a seat’s boosts again');
+    if (farmEnds(f))
+      add(
+        `farm:${f.key}`,
+        'walk_farm',
+        'anyone',
+        'catch the farm up, in parts, when it has passed more end times than a move can walk',
+      );
   }
   for (const c of m.contests) {
     add(`contest:${c.key}`, 'open_contest', 'authority', `open “${c.name}”`);
     add(`contest:${c.key}`, 'enter', 'player', 'back a side');
-    add(`contest:${c.key}`, 'decide', 'authority (or anyone, to call it off once overdue)', 'name the side that won');
-    add(`contest:${c.key}`, 'claim', 'anyone', 'pay an entry');
+    add(
+      `contest:${c.key}`,
+      'decide',
+      'authority (or anyone sending a decider’s verdict)',
+      'name the side that won, or call it off before its result is due',
+    );
+    add(
+      `contest:${c.key}`,
+      'claim',
+      c.stakeNft || c.prize ? 'the winner or the project’s keys' : 'anyone',
+      'pay an entry',
+    );
   }
   for (const a of m.auctions) {
-    add(`auction:${a.key}`, 'open_auction', a.lot?.asset ? 'the owner, alone (a collectible of theirs)' : 'the authority, alone (a new unit of an item)', `put the lot up (at go-live)`);
+    add(
+      `auction:${a.key}`,
+      'open_auction',
+      a.lot?.asset ? 'the owner, alone (a collectible of theirs)' : 'the authority, alone (a new unit of an item)',
+      `put the lot up (at go-live)`,
+    );
     add(`auction:${a.key}`, 'bid', 'player', 'bid: the bid it tops goes back at once');
-    add(`auction:${a.key}`, 'end_auction', 'anyone once it is over; its seller, to call off one with no bid', 'sell to the high bidder, or send the lot home');
+    add(
+      `auction:${a.key}`,
+      'end_auction',
+      'anyone once it is over; its seller, to call off one with no bid',
+      'sell to the high bidder, or send the lot home',
+    );
   }
-  for (const h of m.holds) add(`hold:${h.key}`, 'hold', 'player', `hand in a “${h.item}” until ${h.until ?? `${h.for ?? 'the time they choose'} from then`}`), add(`hold:${h.key}`, 'release', 'authority while it runs, anyone after', 'say where it goes, or send it home');
-  for (const g of m.grants) add(`grant:${g.key}`, 'claim_grant', 'the winning wallet, which signs it (with a voucher, a list proof, or an open grant); anyone may pay its fees', `claim “${g.name}”`);
-  for (const d of m.decisions) add(`decision:${d.key}`, { payout: 'move_tokens', burn: 'move_tokens', issue: 'move_tokens', make: 'collectible', unmake: 'collectible', set: 'collectible', award: 'release', decide: 'decide', roll: 'roll', open_contest: 'open_contest' }[d.does], 'authority', d.when);
+  for (const h of m.holds)
+    (add(
+      `hold:${h.key}`,
+      'hold',
+      'player',
+      `hand in a “${h.item}” until ${h.until ?? `${h.for ?? 'the time they choose'} from then`}`,
+    ),
+      add(`hold:${h.key}`, 'release', 'authority while it runs, anyone after', 'say where it goes, or send it home'));
+  for (const g of m.grants)
+    add(
+      `grant:${g.key}`,
+      'claim_grant',
+      'the winning wallet, which signs it (with a voucher, a list proof, or an open grant); anyone may pay its fees',
+      `claim “${g.name}”`,
+    );
+  for (const d of m.decisions)
+    add(
+      `decision:${d.key}`,
+      {
+        payout: 'move_tokens',
+        burn: 'move_tokens',
+        issue: 'move_tokens',
+        make: 'collectible',
+        unmake: 'collectible',
+        set: 'collectible',
+        award: 'release',
+        decide: 'decide',
+        roll: 'roll',
+        open_contest: 'open_contest',
+      }[d.does],
+      'authority',
+      d.when,
+    );
   return rows;
 }
-