@xgamesfun/solana 0.20.1 → 0.24.0

package/js/economy/plan.mjs

@@ -7,8 +7,12 @@
 // 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 { compileMessage, transactionSize } from '../chain/tx.js';
@@ -16,7 +20,7 @@ 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, 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';
@@ -31,10 +35,10 @@ const tokenProgramOf = (t) => (t?.program === 'token-2022' ? TOKEN_2022_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 +47,51 @@ 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',
+    // 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,10 +104,14 @@ 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) } })),
     window: windowOf(b, m.now),
@@ -82,24 +122,19 @@ export function boxArgs(b, m) {
       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) => {
@@ -107,21 +142,24 @@ export function recipeArgs(r, m) {
     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 } };
+    // 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) } };
   });
+  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)] }));
   return {
     active: r.active !== false,
     inputs,
     outputs,
-    needs: (r.needs ?? []).map((n) => ({ place: n.place, key: n.key, at_least: n.atLeast })),
+    // 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, 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) })),
+    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),
   };
@@ -132,8 +170,10 @@ export function scheduleArgs(s, m) {
   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);
@@ -159,12 +199,13 @@ export function prizeArgs(p, m) {
   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)) } };
 }
 
 /**
@@ -187,25 +228,82 @@ 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}`,
+      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
@@ -232,8 +330,10 @@ export function contestArgs(c, m, at = m.now) {
     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,
   };
 }
 
@@ -245,37 +345,42 @@ export function farmArgs(f, m) {
     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));
   // 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) })),
     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) {
@@ -317,12 +422,14 @@ export function grantArgs(g, m) {
       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 +437,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:<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,6 +463,10 @@ 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))));
@@ -381,8 +493,8 @@ 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.
  */
@@ -474,6 +586,39 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
       ],
     });
 
+  // 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] })] });
@@ -481,30 +626,57 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
   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 first write opens its pot: a token account as well as the record (each round holds its own money).
+    const pot = kind === 'Lottery' ? [{ 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 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 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) {
+  // 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 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;
@@ -532,29 +704,32 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
     });
   }
   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}”`);
   }
   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 }])],
+      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] })],
     });
   }
@@ -577,29 +752,34 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
   // 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)),
+    // 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}`));
     // 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()) {
+    // 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,7 +801,8 @@ 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: [] }) }],
+      // 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) })];
@@ -655,6 +836,24 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
       });
     }
   }
+  // 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);
+    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;
@@ -673,16 +872,72 @@ export function setupSteps(economy, { now = 0, only = null, live: given = null }
       },
     });
   }
+  // 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)] });
   }
-  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,17 +945,24 @@ 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 }),
+    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, 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)}`) }) });
 /** The token program of each Token-2022 mint a context names (the program's account lists name it). */
@@ -725,6 +987,7 @@ export function placeholderContext(m, { rent = (bytes) => (BigInt(bytes) + ACCOU
     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}`)])) },
     rent,
+    slot: 0n,
   };
 }
 
@@ -791,8 +1054,11 @@ export function pack(steps, 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 +1071,7 @@ 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);
@@ -828,7 +1094,8 @@ 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),
+    // 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:'))))],
   };
 }
@@ -844,35 +1111,36 @@ export function playSteps(economy) {
     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');
+    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');
     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)`);