@xgamesfun/solana 0.20.1 → 0.24.0

package/js/economy/model.mjs

@@ -16,12 +16,13 @@ export const FEES = Object.freeze({ player: 2_000_000n, project: 10_000n });
  * on `open_box` (order.rs), whoever sends `draw_lottery` (lottery.rs, its `payer`), the authority on `roll`
  * (roll.rs). Measured on devnet: 500,000 lamports per open.
  */
-export const ORACLE_FEE = 500_000n;
+export const ORACLE_FEE = 800_000n;
 /**
- * Put in the order itself on every purchase, with the player fee on top of it (order.rs: ESCROW_LAMPORTS + fee); what
- * a collectible's rent doesn't use goes back at settle, and a refund returns all of it (constants.rs).
+ * What js/play's throwaway settle key is funded with, in the purchase's own transaction, for each prize its settle may
+ * open or mint (`loot.SETTLE_RENT_UNIT`): whoever settles pays that rent, the order lends nothing. What the settle
+ * doesn't spend goes back to the player when the key empties itself, and all of it when the roll fails.
  */
-export const ESCROW_LAMPORTS = 6_000_000n;
+export const SETTLE_RENT_UNIT = 6_000_000n;
 /** Rent: (bytes + 128) × 5,080 lamports, as `solana rent` reads it on devnet and mainnet-beta. */
 export const RENT_PER_BYTE = 5_080n;
 export const ACCOUNT_OVERHEAD = 128n;
@@ -41,10 +42,17 @@ export const COLLECTIBLE_RENT = 3_100_000n;
 export const SIGNATURE_FEE = 5_000n;
 export const LAMPORTS_PER_SOL = 1_000_000_000n;
 export const WSOL = 'So11111111111111111111111111111111111111112';
-/** The program's limits. */
-export const LIMITS = Object.freeze({ shares: 4, entries: 8, callbackAccounts: 21, lines: 8, collectiblesPerCraft: 8, places: 8, tiers: 4, boosts: 4, growths: 4, gates: 4, odds: 4, vouchers: 3, deciders: 3, gateWallets: 16, nameBytes: 32, uriBytes: 200, keyBytes: 32, maxBoostBps: 1_000_000, maxTierBps: 110_000 });
-/** Attribute names the program writes itself, which a recipe cannot copy and `Set` cannot change (craft.rs, make.rs). */
-export const RESERVED_ATTRIBUTES = Object.freeze(['made', 'used', 'used_at', 'item_id', 'rarity', 'serial', 'origin']);
+/** The limits a spec meets: the chain's (the oracle's answer carries 21 accounts; a farm names a tier and a recipe a
+ * collectible's place in a byte; Bubblegum keeps a compressed NFT's link in 200 bytes and its name in 32) and the two
+ * caps that keep a farm's numbers from overflowing. Since loot 0.22 the program caps no count or size of its own. */
+export const LIMITS = Object.freeze({
+  callbackAccounts: 21, tiers: 256, collectiblesPerCraft: 255, vouchers: 3, compressedNameBytes: 32, compressedUriBytes: 200, maxBoostBps: 1_000_000, maxTierBps: 110_000,
+  // The program's caps on a record's lists (constants.rs, not in the IDL): a spec over one is refused before anything is signed.
+  boxEntries: 128, boxSlots: 32, boxOdds: 32, boxFates: 64, entryPrizes: 14, itemTraits: 64, traitKeyBytes: 64, recipeLines: 48, farmRules: 32, growthSteps: 128, contestSides: 1024, deciders: 32, collections: 32, lotteryRuns: 64, farmEnds: 100_000,
+});
+/** Attribute names the program writes itself, which a recipe cannot copy and `Set` cannot change (craft.rs, make.rs),
+ * and the two a collectible's life keeps (`lifeLines`: its uses and its next use). */
+export const RESERVED_ATTRIBUTES = Object.freeze(['made', 'used', 'next_use', 'item_id', 'rarity', 'serial', 'origin']);
 export const RARITIES = Object.freeze(['Common', 'Uncommon', 'Rare', 'Epic', 'Legendary', 'Mythic']);
 
 // ---------------------------------------------------------------- units
@@ -111,8 +119,8 @@ export function toSeconds(duration) {
 }
 
 /**
- * How long what lands in a farm's rewards pool takes to be released to its seats, in seconds (a farm that shares its
- * pool, `farm.rs` `release_span`): its longest lock tier, and a day at least.
+ * How long what lands in a farm's rewards vault takes to be released to its seats, in seconds (a farm that shares what
+ * lands, `farm.rs` `release_span`): its longest lock tier, and a day at least.
  */
 export const releaseSeconds = (f) => Math.max(86_400, ...(f.tiers ?? []).map((t) => toSeconds(t.lock ?? 0)));
 
@@ -123,16 +131,54 @@ export function releaseWords(f) {
   return s % 3_600 === 0 ? `${s / 3_600} hours` : `${s} seconds`;
 }
 
+/**
+ * What a run sent late does, in words (schedule.rs `catches_up`): a sealed schedule's fixed amount pays every run due;
+ * any other run pays once, for the latest run due, and the runs before it lapse.
+ */
+export const lateRunWords = (s) => (s.sealed && s.percent === undefined ? 'a run sent late pays every run due since' : 'a run missed is missed: one sent late pays once, for the latest run due, and the runs before it lapse');
+
+/**
+ * Whether a farm's boost reads a number its own growth writes (`refresh_seat` writes it): each level counts from when it is
+ * written, so a page or a keeper should refresh seats.
+ */
+export const boostReadsGrowth = (f) => (f.boosts ?? []).some((b) => b.when?.attribute && listOf(f.growth).some((g) => b.when.attribute === (g.attribute ?? 'xp') || ((g.levels ?? []).length > 0 && b.when.attribute === (g.level ?? 'level'))));
+
+/** A box's roll against what is in stock, in words (order.rs): the odds stay as written, whatever is left. */
+export const STOCK_WORDS = 'The odds stay as written whatever is in stock: a draw that lands on an outcome that can’t be given then (its pool short of the whole amount, its item or stash gone) is not made, no other outcome takes its place, and that draw’s worth of the price goes back at the settle; with no draw made at all, a paid open fails and is refunded, and a free roll goes back to waiting';
+
+/**
+ * What a box that rolls does once an outcome can't be given (`whenOut`, order.rs `WhenOut`), in words. `sold`: it is
+ * sold (an open checks the stock); a box only other routes roll (a prize, a mission) never stops a sale.
+ */
+export function whenOutWords(b, { sold = b.active !== false } = {}) {
+  if (b.whenOut === 'drawLeft' && !sold)
+    return 'When an outcome runs out (an item sold out, a pool short of its prize, a stash empty), a roll draws among the outcomes still there by their written weights, so the others’ chances rise; with nothing left at all, a free roll waits to be asked again and a paid one is refunded';
+  if (b.whenOut === 'drawLeft')
+    return 'When an outcome runs out (an item sold out, a pool short of its prize, a stash empty), the box keeps selling while its first draw has anything left, and a roll draws among the outcomes still there by their written weights: the others’ chances rise as one runs out, so a player can empty a common outcome to make a rare one likelier (a box selling a rare prize should stop selling instead, the default)';
+  if (!sold) return STOCK_WORDS;
+  return 'When an outcome runs out, the box stops selling: it isn’t sold while any outcome couldn’t cover this purchase’s draws and those of purchases still waiting for the oracle (an item’s units left, a pool’s tokens, a stash’s NFTs), so every roll is on the odds as written and nobody can buy their way to a refund on every miss; it sells again once the project restocks or edits the box (an outcome whose odds shrink with stock needs no cover). An outcome emptied another way all the same (another route sharing its pool, item or stash) makes no draw, no other outcome taking its place, and gives back that draw’s worth of the price at the settle; with no draw made at all, the open is refunded';
+}
+
 /**
  * What the end of a sharing farm that `runs` means, in words, or null (no end, or a fixed rate): its release keeps its
- * pace, so what it has not let go by the end stays in the pool, the project's, and so does what a seat gives back after
- * the end; a seat that may be dead (a watched NFT sold, an upkeep run out) is refreshed a release span before it.
+ * pace, so what it has not let go by the end stays in its vault, free for the authority to take back, and so does what
+ * a seat forfeits after the end.
  */
 export function farmEndWords(f) {
   if (!f.runs || f.rate) return null;
   const span = releaseWords(f);
-  const dead = [f.custody === 'watch' && 'a watched NFT sold', f.upkeepAttribute && 'an upkeep run out'].filter(Boolean);
-  return `what is not released by its end stays in the pool, the project’s, credited to nobody, and so does what a seat gives back after the end: fund it at least ${span} before its end (what lands later is released only in part, and what lands at or after the end not at all)${dead.length ? `, and refresh a seat you suspect is dead (${dead.join(', ')}) at least ${span} before the end, or what it was credited stays in the pool too` : ''}`;
+  return `what is not released by its end stays in its vault, credited to nobody (the authority may take back what is free there), and so does what a seat forfeits after the end: fund it at least ${span} before its end (what lands later is released only in part, and what lands at or after the end not at all)`;
+}
+
+/**
+ * The token a farm's rewards are in (`rewards`, a token key): by default its staked token, or for a farm of
+ * collectibles the project's currency. One that names a pool (as farms did before they had a vault of their own) is
+ * read as that pool's token, and the checker refuses it.
+ */
+export function farmRewardsToken(f, tokens, currencyKey, poolCurrency = new Map()) {
+  if (f.rewards && tokens.has(f.rewards)) return f.rewards;
+  if (f.rewards && poolCurrency.has(f.rewards)) return poolCurrency.get(f.rewards);
+  return f.stakes && f.stakes !== 'collectibles' ? f.stakes : currencyKey;
 }
 
 /** A raise's or a shift's `by`: a number, or for a time a duration, which may be negative ("-1d"). */
@@ -206,21 +252,14 @@ export function model(economy, { now = 0 } = {}) {
   const tokens = new Map((e.tokens ?? []).map((t) => [t.key, tokenOf(t)]));
   const currencyKey = e.currency ?? (tokens.size === 1 ? [...tokens.keys()][0] : undefined);
   const currency = tokens.get(currencyKey);
-  // A farm that names no rewards pool pays nothing (staking only to qualify): it gets an empty pool of its own, which
-  // the program needs to exist (farm.rs) and nothing ever fills. Once live, its number is kept on the farm
-  // (`rewardsIndex`, live.mjs `recordLanded`), so a pool added later never takes it.
-  const unpaid = (e.farms ?? []).filter((f) => !f.rewards);
-  const hidden = unpaid.map((f) => ({ key: `${f.key}-rewards`, currency: f.stakes !== 'collectibles' ? f.stakes : currencyKey, about: `${f.key}: pays nothing`, farm: f.key, ...(Number.isInteger(f.rewardsIndex) ? { index: f.rewardsIndex } : {}) }));
-  const listed = [...(e.pools ?? []), ...hidden];
-  // Numbers are given in this order: the pools that have one, then the empty pool of a farm already live that has no
-  // number written (it went live before numbers were kept, and took the first free one then, before any pool added
-  // since), then the rest in the spec's order.
-  const landed = (key) => Number.isInteger(unpaid.find((f) => f.key === key)?.id);
-  const rank = (p) => (Number.isInteger(p.index) ? 0 : p.farm && landed(p.farm) ? 1 : 2);
-  const order = [...listed.keys()].sort((a, b) => rank(listed[a]) - rank(listed[b]));
+  // Numbers are given in this order: the pools that have one, then the rest in the spec's order.
+  const listed = e.pools ?? [];
+  const order = [...listed.keys()].sort((a, b) => Number(!Number.isInteger(listed[a].index)) - Number(!Number.isInteger(listed[b].index)));
   const assigned = assignIds(order.map((i) => listed[i]), 'index', 0);
   const pools = listed.map((_, i) => assigned[order.indexOf(i)]);
-  const farms = (e.farms ?? []).map((f) => (f.rewards ? f : { ...f, rewards: `${f.key}-rewards`, unpaid: true }));
+  // A farm's rewards land in a vault of its own: `rewardsToken` is their token.
+  const poolCurrency = new Map(pools.map((p) => [p.key, p.currency]));
+  const farms = (e.farms ?? []).map((f) => ({ ...f, rewardsToken: farmRewardsToken(f, tokens, currencyKey, poolCurrency) }));
   // A raffle: its NFT is first place's prize, held in the lottery's own stash.
   const lotteries = (e.lotteries ?? []).map((l) => {
     if (!l.raffle) return l;
@@ -247,6 +286,7 @@ export function model(economy, { now = 0 } = {}) {
     items: assignIds(e.items ?? [], 'id', 1),
     pools,
     stashes: assignIds(e.stashes ?? [], 'id', 1),
+    tables: assignIds(e.tables ?? [], 'id', 1),
     boxes: [],
     payments: e.payments ?? [],
     recipes: assignIds(e.recipes ?? [], 'id', 1),
@@ -290,6 +330,7 @@ export function model(economy, { now = 0 } = {}) {
   m.item = index(m.items);
   m.pool = index(m.pools);
   m.stash = index(m.stashes);
+  m.table = index(m.tables);
   m.box = index(m.allBoxes);
   m.recipe = index(m.recipes);
   m.farm = index(m.farms);
@@ -312,16 +353,17 @@ export function model(economy, { now = 0 } = {}) {
  */
 export function stashNfts(s) {
   return (s.nfts ?? []).map((n) => {
-    if (typeof n === 'string') return { kind: 'core', asset: n, collection: s.collection ?? null };
-    if (n.mint) return { kind: 'token-metadata', asset: n.mint, programmable: Boolean(n.programmable), ruleSet: n.ruleSet ?? null };
-    if (n.compressed) return { kind: 'compressed', asset: n.compressed };
-    return { kind: 'core', asset: n.asset, collection: n.collection ?? s.collection ?? null };
+    if (typeof n === 'string') return { kind: 'core', asset: n, collection: s.collection ?? null, weight: 1 };
+    const weight = n.weight ?? 1;
+    if (n.mint) return { kind: 'token-metadata', asset: n.mint, programmable: Boolean(n.programmable), ruleSet: n.ruleSet ?? null, weight };
+    if (n.compressed) return { kind: 'compressed', asset: n.compressed, weight };
+    return { kind: 'core', asset: n.asset, collection: n.collection ?? s.collection ?? null, weight };
   });
 }
 
 /**
  * A prize as the spec writes it (`$defs/prize`), read the one way: a line { gives, … } as a recipe's `out` lines are:
- * "item" (`item`), "tokens" (`amount`, `from` "mint" with `currency`, or "pool:<key>"), "share" (`percent` of `pool`),
+ * "item" (`item`), "tokens" (`amount`, `from` "mint" with `currency`, or "pool:<key>"),
  * "nft" (`nft`, an address the stash `stash` lists) or "roll" (a roll of `box`; in a recipe, on the collectible kept
  * at `on`). A grant's older `gives` ({ item }, { pool, amount }, { roll }) reads as its line. Null for none.
  */
@@ -334,8 +376,8 @@ export function prizeLine(p) {
   return null;
 }
 
-/** The pool a prize line pays from: a share's, or tokens' "pool:<key>". */
-export const prizePool = (p) => (p?.gives === 'share' ? p.pool : p?.gives === 'tokens' && p.from?.startsWith('pool:') ? p.from.slice(5) : null);
+/** The pool a prize line pays from: tokens' "pool:<key>". */
+export const prizePool = (p) => (p?.gives === 'tokens' && p.from?.startsWith('pool:') ? p.from.slice(5) : null);
 
 /** The token a prize line pays in: its pool's, or the one it mints. */
 export const prizeToken = (p, m) => (prizePool(p) ? m.poolToken(prizePool(p)) : p?.gives === 'tokens' ? m.tokens.get(p.currency ?? m.currencyKey) : null);
@@ -364,7 +406,8 @@ export function prizes(m) {
  * canopy, bytes }
  */
 export function compressedTree(m) {
-  if (!prizes(m).some((p) => p.prize.gives === 'item' && p.prize.compressed)) return null;
+  const boxGives = m.allBoxes.some((b) => (b.outcomes ?? []).flatMap(outcomeParts).some((o) => o.gives === 'item' && o.compressed));
+  if (!boxGives && !prizes(m).some((p) => p.prize.gives === 'item' && p.prize.compressed)) return null;
   const depth = Math.min(20, Math.max(14, Math.ceil(Math.log2(Math.max(1, m.treeHolds)))));
   const canopy = Math.min(depth - 10, 8);
   return { depth, buffer: 64, canopy, bytes: treeSize(depth, 64, canopy) };
@@ -406,13 +449,13 @@ export function rollsOf(m) {
   return rolls;
 }
 
-/** A prize line in words: "one Badge", "100 GOLD from “rewards”", "100 GOLD, minted", "10% of “jackpot”", "the NFT ab12…cd34 of “vault”", "a roll of “Chest”". */
+/** A prize line in words: "one Badge", "100 GOLD from “rewards”", "100 GOLD, minted", "the NFT ab12…cd34 of “vault”", "a roll of “Chest”". */
 export function prizeWords(p, m) {
   const line = prizeLine(p);
   if (!line) return 'nothing';
   const sym = (key) => m.tokens.get(key)?.symbol ?? key;
   if (line.gives === 'item') return `one ${m.item.get(line.item)?.name ?? line.item}${line.compressed ? ' (compressed)' : ''}`;
-  if (line.gives === 'share') return `${line.percent}% of “${line.pool}”`;
+  if (line.gives === 'raffled') return 'an NFT drawn at random from the lottery’s own stash';
   if (line.gives === 'nft' && line.held) return `the NFT ${String(line.nft).slice(0, 4)}…${String(line.nft).slice(-4)} (held in the lottery’s own stash until it is won)`;
   if (line.gives === 'nft') return `the NFT ${String(line.nft).slice(0, 4)}…${String(line.nft).slice(-4)} of “${m.stash.get(line.stash)?.name ?? line.stash}”`;
   if (line.gives === 'roll') return `a roll of “${m.box.get(line.box)?.name ?? line.box}”`;
@@ -422,30 +465,81 @@ export function prizeWords(p, m) {
 }
 
 /**
- * What one box outcome gives (catalog.rs, at most three prizes an entry), each in the box's own words: "item",
- * "pay" (a fixed amount from a pool), "share" (a percent of a pool), "stash" (an NFT of a stash at random), "mint"
+ * What one box outcome gives (catalog.rs), each in the box's own words: "item", "pay" (a fixed amount from a pool),
+ * "stash" (an NFT of a stash at random), "mint"
  * (tokens minted), "nft" (one NFT a stash lists) or "roll" (a roll of another box). A bundle gives its `prizes`; "burn"
  * and "nothing" give none.
  */
 export function outcomeParts(o) {
   if (!o) return [];
   if (o.gives === 'bundle') return (o.prizes ?? []).flatMap(outcomeParts);
-  if (o.gives === 'burn' || o.gives === 'nothing') return [];
+  if (o.gives === 'nothing') return [];
   if (o.gives === 'tokens') return [o.from?.startsWith('pool:') ? { gives: 'pay', pool: o.from.slice(5), amount: o.amount } : { gives: 'mint', currency: o.currency, amount: o.amount }];
   return [o];
 }
 
-/** Whether an outcome burns the payment in place of the box's split: "burn", or a bundle that says `burns`. */
-export const outcomeBurns = (o) => o?.gives === 'burn' || Boolean(o?.burns);
-
 /** Whether a box leaves its outcome to the oracle (catalog.rs `rolls`): more than one outcome, or an NFT at random. */
-export const boxRolls = (b) => (b.outcomes ?? []).length > 1 || (b.outcomes ?? []).flatMap(outcomeParts).some((p) => p.gives === 'stash');
+/** How many draws one open of a box makes: its slots' counts, or one. */
+export const drawsOf = (b) => ((b.slots ?? []).length ? b.slots.reduce((n, s) => n + Number(s.count), 0) : 1);
+
+/** Whether a box's prize costs its settle a collectible's rent: an item minted as a Core NFT, or a fresh compressed one
+ * (its traits' Sheet). A plain compressed NFT costs no rent. */
+export const holdsRent = (p, m) => p.gives === 'item' && (!p.compressed || (m?.item.get(p.item)?.drawn ?? []).length > 0);
+
+/**
+ * The units of `SETTLE_RENT_UNIT` a settle of box `b`'s order may spend (`loot.settleRent`), which js/play funds its
+ * throwaway settle key with and gets back unspent: for each draw, each part of the richest outcome that opens an
+ * account (a collectible, a fresh compressed NFT's Sheet, a stash's NFT); once an order, each source of tokens it may
+ * pay, and the fate of the NFT it rolls on.
+ */
+export function settleUnits(b, m) {
+  const opens = (p) => holdsRent(p, m) || p.gives === 'stash' || p.gives === 'nft';
+  const parts = (b.outcomes ?? []).map((o) => outcomeParts(o));
+  const most = Math.max(0, ...parts.map((ps) => ps.filter(opens).length));
+  const sources = new Set(parts.flat().filter((p) => ['tokens', 'pay', 'mint'].includes(p.gives)).map((p) => prizePool(p) ?? `mint:${p.currency ?? ''}`));
+  return drawsOf(b) * most + sources.size + (b.rollsOn ? 1 : 0);
+}
+
+export const boxRolls = (b, m) => (b.outcomes ?? []).length > 1 || (b.outcomes ?? []).flatMap(outcomeParts).some((p) => p.gives === 'stash' || (p.gives === 'item' && (m?.item.get(p.item)?.drawn ?? []).length > 0));
 
-/** Whether a box sells with `buy`, in one transaction (buy.rs): it doesn't roll, and rolls on no NFT. */
-export const boxBuys = (b) => !boxRolls(b) && !b.rollsOn;
+/** Whether a box sells with `buy`, in one transaction (buy.rs): it doesn't roll and rolls on no NFT, any number of draws
+ * a sale (a fixed pack: its prizes given once for each draw). */
+export const boxBuys = (b, m) => !boxRolls(b, m) && !b.rollsOn;
+
+/** The most a raise lowers a number by (an i32's least but one): a renew's, which counts a collectible's uses from 0. */
+const RENEW_BY = -2_147_483_647;
+
+/**
+ * What a recipe's lines owe the life of each collectible they take (an item's `life`), as the program's needs and
+ * raises (craft.rs `Need`, `Raise`), at each collectible's place in the recipe (each burned unit, then each kept one, in
+ * line order; a pay line takes none): ready after `readyAfter` (`made` older than it), for `lasts` (`made` within it),
+ * on every line that takes it; `uses` times (`used` raised by 1 up to it) and a `cooldown` (`next_use` passed, then
+ * raised to that far from now) on a line that uses it or takes it staked; a renew line counts its uses from 0 again.
+ * { needs, raises }, in the program's shapes.
+ */
+export function lifeLines(r, m) {
+  const places = (r.in ?? []).flatMap((l) => (l.takes === 'pay' ? [] : Array(l.takes === 'burn' ? l.count ?? 1 : 1).fill(l)));
+  const needs = [];
+  const raises = [];
+  places.forEach((l, place) => {
+    const it = l.item ? m.item.get(l.item) : null;
+    if (!it?.life || it.kind === 'normal') return;
+    const [ready, lasts, uses, cooldown] = [toSeconds(it.life.readyAfter ?? 0), toSeconds(it.life.lasts ?? 0), it.life.uses ?? 0, toSeconds(it.life.cooldown ?? 0)];
+    if (ready) needs.push({ place, key: 'made', test: { Older: [ready] } });
+    if (lasts) needs.push({ place, key: 'made', test: { Within: [lasts] } });
+    if (l.takes === 'renew') raises.push({ place, shift: { key: 'used', by: RENEW_BY, most: 0, from_now: false } });
+    if (l.takes !== 'use' && l.takes !== 'staked') return;
+    if (uses) raises.push({ place, shift: { key: 'used', by: 1, most: uses, from_now: false } });
+    if (cooldown) {
+      needs.push({ place, key: 'next_use', test: 'Passed' });
+      raises.push({ place, shift: { key: 'next_use', by: cooldown, most: cooldown, from_now: true } });
+    }
+  });
+  return { needs, raises };
+}
 
 /** A lottery's place as { percent, prize }: a number is a share of the pot and no prize. */
-export const placeOf = (p) => (typeof p === 'object' && p !== null ? { percent: p.percent ?? 0, prize: prizeLine(p.prize) } : { percent: p, prize: null });
+export const placeOf = (p) => (typeof p === 'object' && p !== null ? { percent: p.percent ?? 0, prize: prizeLine(p.prize), times: p.times ?? 1 } : { percent: p, prize: null, times: 1 });
 
 /** "pool:house" → { kind: 'pool', key: 'house' }; "burn" → { kind: 'burn' }. */
 export function destination(to) {
@@ -463,7 +557,8 @@ export const sharesOf = (split) => (split ?? []).map((s) => ({ ...destination(s.
  * The program's `To` for a destination, with pool indexes resolved (the IDL's own shape). A wallet ("wallet:<address>")
  * is paid at its own token account of the part's currency (the program opens it when it is not there); "treasury" is the game's treasury wallet's; "chosen"
  * (or "chosen:<item>") is the one the buyer names when they buy; "lottery:<key>" is that lottery's pot
- * ("@pot:<id>", which the plan resolves once the game is known).
+ * ("@pot:<id>") and "farm:<key>" that farm's rewards vault ("@rewards:<id>"), which the plan resolves once the game is
+ * known.
  */
 export function toEnum(to, m) {
   const d = destination(to);
@@ -473,6 +568,7 @@ export function toEnum(to, m) {
   if (d.kind === 'account') return { Account: [d.key] };
   if (d.kind === 'wallet') return { Wallet: [d.key] };
   if (d.kind === 'lottery') return { Account: [`@pot:${m.lottery.get(d.key)?.id ?? 0}`] };
+  if (d.kind === 'farm') return { Account: [`@rewards:${m.farm.get(d.key)?.id ?? 0}`] };
   if (d.kind === 'chosen') return { Chosen: { item: d.key ? (m.item.get(d.key)?.id ?? 0) : null } };
   return { Holder: [d.key] };
 }
@@ -544,8 +640,8 @@ export function weights(box) {
 export function poolTakers(m) {
   const takers = [];
   const add = (pool, by, how) => pool && takers.push({ pool, by, how });
-  for (const b of m.allBoxes) for (const o of (b.outcomes ?? []).flatMap(outcomeParts)) if (o.gives === 'pay' || o.gives === 'share') add(o.pool, `box:${b.key}`, o.gives === 'pay' ? 'pays prizes' : 'pays a share as a prize');
-  for (const p of prizes(m)) add(prizePool(p.prize), p.by, p.prize.gives === 'share' ? `pays a share as a prize (${p.route})` : `pays prizes (${p.route})`);
+  for (const b of m.allBoxes) for (const o of (b.outcomes ?? []).flatMap(outcomeParts)) if (o.gives === 'pay') add(o.pool, `box:${b.key}`, 'pays prizes');
+  for (const p of prizes(m)) add(prizePool(p.prize), p.by, `pays prizes (${p.route})`);
   for (const s of m.schedules) {
     if (s.does === 'burn') add(s.pool, `schedule:${s.key}`, 'burns a share');
     if (s.does === 'move') add(s.from, `schedule:${s.key}`, 'moves a share out');
@@ -553,12 +649,6 @@ export function poolTakers(m) {
     // from a vault of its own and names no pool.
     if (s.does === 'pay') add(s.from, `schedule:${s.key}`, 'pays out on a timer');
   }
-  for (const f of m.farms) {
-    // Sharing what arrives releases all of the pool over its release span; a fixed rate from it takes the rate; a
-    // minted one takes nothing.
-    if (!f.rate) add(f.rewards, `farm:${f.key}`, 'releases everything to its seats');
-    else if (!f.rate.minted) add(f.rewards, `farm:${f.key}`, 'pays its fixed rate');
-  }
   for (const d of m.decisions) if (d.does === 'payout' || d.does === 'burn') add(d.pool, `decision:${d.key}`, d.does === 'payout' ? 'pays out on the authority’s word' : 'burns on the authority’s word');
   return takers;
 }
@@ -581,3 +671,28 @@ export function poolFillers(m) {
   for (const a of m.auctions) fromSplit(a.split, `auction:${a.key}`);
   return fillers;
 }
+
+/**
+ * Every place the spec sends money into a farm's rewards vault ("farm:<key>"): a split's share, a schedule that pays it,
+ * a craft that pays it, the owner's seed, an early exit's fee into its own vault. [{ farm, by, how }]
+ */
+export function farmFillers(m) {
+  const fillers = [];
+  const add = (to, by, how) => {
+    const d = destination(to ?? '');
+    if (d.kind === 'farm') fillers.push({ farm: d.key, by, how });
+  };
+  const fromSplit = (split, by) => sharesOf(split).forEach((s) => add(s.to, by, `${s.percent}% of each payment`));
+  for (const f of m.farms) {
+    if (Number(f.seed ?? 0) > 0) fillers.push({ farm: f.key, by: `farm:${f.key}`, how: 'the owner’s seed' });
+    if (f.exitFeeTo === 'rewards') fillers.push({ farm: f.key, by: `farm:${f.key}`, how: 'early-exit fees' });
+  }
+  for (const b of m.allBoxes) fromSplit(b.split, b.shopOf ? `item:${b.shopOf}` : `box:${b.key}`);
+  for (const p of m.payments) fromSplit(p.split, `payment:${p.key}`);
+  for (const r of m.recipes) for (const i of r.in ?? []) if (i.takes === 'pay') add(i.to, `recipe:${r.key}`, 'a craft pays in');
+  for (const s of m.schedules) if (s.does === 'pay' || s.does === 'issue') add(s.to, `schedule:${s.key}`, s.does === 'issue' ? 'mints into it on a timer' : 'pays in on a timer');
+  for (const l of m.lotteries) fromSplit(lotterySplit(l), `lottery:${l.key}`);
+  for (const c of m.contests) fromSplit(c.split, `contest:${c.key}`);
+  for (const a of m.auctions) fromSplit(a.split, `auction:${a.key}`);
+  return fillers;
+}