@xgamesfun/solana 0.20.1 → 0.25.0

package/js/approve/details.mjs

@@ -4,7 +4,7 @@
 // claim it. Addresses are written in full, so an owner sees a payee that an edit re-pointed before they sign.
 import { decodeBorsh } from '../chain/borsh.js';
 import { equalBytes, toHex } from '../chain/bytes.js';
-import { accountKind, decode, IDL, keyLeaf, merkleRoot } from '../client/index.js';
+import { accountKind, decode, IDL, instructionOf, keyLeaf, merkleRoot } from '../client/index.js';
 import { LOOT_PROGRAM, pda } from '../client/pda.js';
 import { fromUnits } from '../economy/model.mjs';
 import { grantArgs } from '../economy/plan.mjs';
@@ -13,12 +13,12 @@ const NOBODY = '11111111111111111111111111111111';
 const ZERO = new Uint8Array(32);
 
 /** An instruction's accounts by name, nested groups flattened, in the order the program takes them. */
-const leafNames = (list) => list.flatMap((a) => (a.accounts ? leafNames(a.accounts) : [a.name]));
+const leafNames = list => list.flatMap(a => (a.accounts ? leafNames(a.accounts) : [a.name]));
 
 /** A loot instruction read back: { name, args, accounts: { name: address } }, or null for another program's. */
 function readLootInstruction(ix) {
   if (ix.programId !== LOOT_PROGRAM) return null;
-  const def = IDL.instructions.find((i) => i.discriminator.length <= ix.data.length && i.discriminator.every((b, j) => ix.data[j] === b));
+  const def = instructionOf(ix.data);
   if (!def) return null;
   const args = {};
   let at = def.discriminator.length;
@@ -37,9 +37,9 @@ export function namesOf(m, { owner = null, treasury = null } = {}) {
     m,
     owner,
     treasury,
-    pools: new Map(m.pools.map((p) => [p.index, p.key])),
-    stashes: new Map(m.stashes.map((s) => [s.id, s.name ?? s.key])),
-    grants: new Map(m.grants.map((g) => [g.id, g])),
+    pools: new Map(m.pools.map(p => [p.index, p.key])),
+    stashes: new Map(m.stashes.map(s => [s.id, s.name ?? s.key])),
+    grants: new Map(m.grants.map(g => [g.id, g])),
   };
 }
 
@@ -57,7 +57,14 @@ export function stepDetails(instructions, names) {
 }
 
 /** The account each record an `upsert` writes is kept in on chain. */
-const RECORD_ACCOUNT = { Item: 'Item', Box: 'LootBox', Schedule: 'Schedule', Lottery: 'Lottery', Recipe: 'Recipe', Grant: 'Grant' };
+const RECORD_ACCOUNT = {
+  Item: 'Item',
+  Box: 'LootBox',
+  Schedule: 'Schedule',
+  Lottery: 'Lottery',
+  Recipe: 'Recipe',
+  Grant: 'Grant',
+};
 
 /**
  * What is live for one step, read from the chain (`chain.account`): the lines of the records its `upsert`s write, as
@@ -68,15 +75,19 @@ export async function liveStepDetails(instructions, names, chain) {
   const reads = [];
   for (const ix of instructions) {
     const read = readLootInstruction(ix);
-    const [kind] = Object.keys(read?.name === 'upsert' ? read.args.def ?? {} : {});
+    const [kind] = Object.keys(read?.name === 'upsert' ? (read.args.def ?? {}) : {});
     if (!RECORD_ACCOUNT[kind]) continue;
     const account = await chain.account(read.accounts.target);
     if (!account) {
       reads.push(null);
       continue;
     }
-    if (account.owner !== LOOT_PROGRAM || accountKind(account.data) !== RECORD_ACCOUNT[kind]) throw new Error(`${read.accounts.target} is not the ${kind.toLowerCase()} it should be.`);
-    reads.push({ ...read, args: { def: { [kind]: { id: read.args.def[kind].id, args: decode(RECORD_ACCOUNT[kind], account.data) } } } });
+    if (account.owner !== LOOT_PROGRAM || accountKind(account.data) !== RECORD_ACCOUNT[kind])
+      throw new Error(`${read.accounts.target} is not the ${kind.toLowerCase()} it should be.`);
+    reads.push({
+      ...read,
+      args: { def: { [kind]: { id: read.args.def[kind].id, args: decode(RECORD_ACCOUNT[kind], account.data) } } },
+    });
   }
   return reads.length ? readDetails(reads.filter(Boolean), names) : null;
 }
@@ -86,26 +97,39 @@ function readDetails(reads, names) {
   const lines = [];
   for (const read of reads) {
     if (read?.unreadable) {
-      lines.push(`This step could not be read back (${read.unreadable}): check what it pays in your wallet before approving`);
+      lines.push(
+        `This step could not be read back (${read.unreadable}): check what it pays in your wallet before approving`,
+      );
       continue;
     }
     if (!read) continue;
     const owner = read.accounts.owner ?? read.accounts.seller;
     const project = read.accounts.project;
-    const pots = new Map(names.m.lotteries.map((l) => [pda.pot(pda.lottery(project, l.id)), l.name ?? l.key]));
+    const pots = new Map(
+      names.m.lotteries
+        .filter(l => Number.isInteger(l.pot))
+        .map(l => [pda.lotteryPot(pda.lottery(project, l.id), l.pot), l.name ?? l.key]),
+    );
+    const vaults = new Map(names.m.farms.map(f => [pda.rewards(pda.farm(project, f.id)), f.name ?? f.key]));
     // Before a wallet connects, the plan stands a made-up address in for it (one no spec may name): that one is not
     // shown. Once one is connected, only that wallet is called yours.
-    const yours = (a) => (names.owner == null ? 'your wallet' : a === names.owner ? `your wallet (${a})` : `the project’s owner, ${a}`);
-    const address = (a) => (a === owner ? yours(a) : a);
-    const wallet = (a) => (a === owner ? yours(a) : `the wallet ${a}`);
+    const yours = a =>
+      names.owner == null ? 'your wallet' : a === names.owner ? `your wallet (${a})` : `the project’s owner, ${a}`;
+    const address = a => (a === owner ? yours(a) : a);
+    const wallet = a => (a === owner ? yours(a) : `the wallet ${a}`);
     const treasury = () => `the treasury (${names.treasury ? address(names.treasury) : 'your wallet'})`;
-    const where = (to) => {
+    const where = to => {
       if (to === 'Treasury') return treasury();
       const [kind] = Object.keys(to);
       const v = to[kind];
       if (kind === 'Pool') return `the pool “${names.pools.get(v[0]) ?? v[0]}”`;
       if (kind === 'Wallet') return wallet(v[0]);
-      if (kind === 'Account') return pots.has(v[0]) ? `the pot of “${pots.get(v[0])}”` : `the token account ${v[0]}`;
+      if (kind === 'Account')
+        return pots.has(v[0])
+          ? `the pot of “${pots.get(v[0])}”`
+          : vaults.has(v[0])
+            ? `the rewards of the farm “${vaults.get(v[0])}”`
+            : `the token account ${v[0]}`;
       if (kind === 'Holder') return `whoever holds the NFT ${v[0]}`;
       if (kind === 'Chosen') return 'a wallet the buyer chooses';
       return JSON.stringify(to);
@@ -117,34 +141,63 @@ function readDetails(reads, names) {
     }
     // Where what a split leaves goes: a lottery's pot, an auction's seller (or the treasury for a new item), else the treasury.
     const def = read.args.def ?? {};
-    const restTo = def.Lottery ? 'its pot' : read.name === 'open_auction' ? (read.args.args?.lot?.Asset ? `the seller, ${address(read.accounts.seller)}` : treasury()) : treasury();
-    const to = (v) => (v === 'Burn' ? 'burned' : `to ${where(v)}`);
-    const isTo = (v) => v === 'Burn' || v === 'Treasury' || (v && typeof v === 'object' && ['Pool', 'Account', 'Holder', 'Wallet', 'Chosen'].some((k) => k in v) && Object.keys(v).length === 1);
+    const restTo = def.Lottery
+      ? def.Lottery.args?.terms?.pays_from?.Pot
+        ? 'its pot'
+        : 'the round’s places'
+      : read.name === 'open_auction'
+        ? read.args.args?.lot?.Asset
+          ? `the seller, ${address(read.accounts.seller)}`
+          : treasury()
+        : treasury();
+    const to = v => (v === 'Burn' ? 'burned' : `to ${where(v)}`);
+    const isTo = v =>
+      v === 'Burn' ||
+      v === 'Treasury' ||
+      (v &&
+        typeof v === 'object' &&
+        ['Pool', 'Account', 'Holder', 'Wallet', 'Chosen'].some(k => k in v) &&
+        Object.keys(v).length === 1);
     const grantId = read.args.def?.Grant?.id;
     if (read.args.def?.Grant) lines.push(...grantTerms(read.args.def.Grant.args, names));
-    const walk = (value) => {
+    const walk = value => {
       if (Array.isArray(value)) return value.forEach(walk);
       if (!value || typeof value !== 'object' || value instanceof Uint8Array) return;
       for (const [k, v] of Object.entries(value)) {
         if (k === 'shares' && Array.isArray(v)) {
           const rest = 10_000 - v.reduce((n, s) => n + Number(s.bps), 0);
-          const parts = v.map((s) => `${Number(s.bps) / 100}% ${to(s.to)}`);
+          const parts = v.map(s => `${Number(s.bps) / 100}% ${to(s.to)}`);
           if (rest > 0) parts.push(v.length ? `the rest (${rest / 100}%) to ${restTo}` : `all of it to ${restTo}`);
           lines.push(`Pays: ${parts.join(', ')}`);
-        } else if (k === 'to' && isTo(v)) lines.push(v === 'Burn' ? 'Burns the tokens it takes' : `Sends tokens to ${where(v)}`);
-        else if (k === 'Give' && Array.isArray(v) && typeof v[0] === 'string') lines.push(`Gives the NFT to ${address(v[0])}`);
+        } else if (k === 'pays_from' && v && typeof v === 'object') {
+          // Where a lottery's places are paid from: a pot kept from round to round, or each round's own money.
+          lines.push(
+            v.Pot
+              ? `Places paid from: its pot ${v.Pot[0]}, kept from round to round (what anyone sends it, yield and what earlier rounds left all count)`
+              : `Places paid from: each round’s own ticket money alone; what they leave is ${v.Round.rest === 'Burn' ? 'burned' : `sent to ${where(v.Round.rest)}`}`,
+          );
+        } else if (k === 'to' && isTo(v))
+          lines.push(v === 'Burn' ? 'Burns the tokens it takes' : `Sends tokens to ${where(v)}`);
+        else if (k === 'Give' && Array.isArray(v) && typeof v[0] === 'string')
+          lines.push(`Gives the NFT to ${address(v[0])}`);
         else if (k === 'vouchers' && Array.isArray(v)) {
-          const keys = v.filter((a) => a !== NOBODY);
+          const keys = v.filter(a => a !== NOBODY);
           if (keys.length) lines.push(`Voucher keys (each decides who gets it): ${keys.join(', ')}`);
         } else if (k === 'key_root' && v instanceof Uint8Array) {
           if (!equalBytes(v, ZERO)) {
             const listed = names.grants.get(grantId)?.keys ?? [];
-            const ours = listed.length && equalBytes(merkleRoot(listed.map((key) => keyLeaf(key))), v);
-            lines.push(ours ? `Voucher keys from its list (each decides who gets it): ${listed.join(', ')}` : `Voucher keys: a list with the root ${toHex(v)}, which is not the spec’s list`);
+            const ours = listed.length && equalBytes(merkleRoot(listed.map(key => keyLeaf(key))), v);
+            lines.push(
+              ours
+                ? `Voucher keys from its list (each decides who gets it): ${listed.join(', ')}`
+                : `Voucher keys: a list with the root ${toHex(v)}, which is not the spec’s list`,
+            );
           }
         } else if (k === 'list_root' && v instanceof Uint8Array) {
-          if (!equalBytes(v, ZERO)) lines.push(...listLines(v, names.grants.get(grantId), read.args.def.Grant.args.gives, names));
-        } else if (k === 'open' && v === true) lines.push('Open: any wallet may claim it, with no voucher and no list, within its limits');
+          if (!equalBytes(v, ZERO))
+            lines.push(...listLines(v, names.grants.get(grantId), read.args.def.Grant.args.gives, names));
+        } else if (k === 'open' && v === true)
+          lines.push('Open: any wallet may claim it, with no voucher and no list, within its limits');
         else walk(v);
       }
     };
@@ -157,36 +210,44 @@ function readDetails(reads, names) {
 function prizeToken(gives, m) {
   const from = gives?.Tokens?.from;
   if (!from) return null;
-  const key = from.Pool ? (m.pools.find((p) => p.index === from.Pool[0])?.currency ?? m.currencyKey) : [...m.tokens.values()].find((t) => t.mint === (from.Mint ?? from.Vest)?.[0])?.key;
+  const key = from.Pool
+    ? (m.pools.find(p => p.index === from.Pool[0])?.currency ?? m.currencyKey)
+    : [...m.tokens.values()].find(t => t.mint === (from.Mint ?? from.Vest)?.[0])?.key;
   return m.tokens.get(key) ?? null;
 }
 
 /** Base units of `token` in its own words ("100 COIN"), or as base units when the token is not known. */
-const tokens = (units, token) => (token ? `${fromUnits(BigInt(units), token.decimals ?? 0)} ${token.symbol ?? token.key}` : `${units} base units`);
+const tokens = (units, token) =>
+  token ? `${fromUnits(BigInt(units), token.decimals ?? 0)} ${token.symbol ?? token.key}` : `${units} base units`;
 
 /** A prize in words, from its bytes. Named by the spec's parts; an NFT or a tree is not a payee, so its address is left out. */
 function prizeWords(gives, m) {
   const [kind] = Object.keys(gives ?? {});
   const v = gives?.[kind];
-  const named = (list, id, field = 'id') => list.find((x) => x[field] === id);
-  const stash = (id) => `the stash “${named(m.stashes, id)?.name ?? named(m.stashes, id)?.key ?? id}”`;
-  const item = (id) => `the item “${named(m.items, id)?.name ?? named(m.items, id)?.key ?? id}”`;
+  const named = (list, id, field = 'id') => list.find(x => x[field] === id);
+  const stash = id => `the stash “${named(m.stashes, id)?.name ?? named(m.stashes, id)?.key ?? id}”`;
+  const item = id => `the item “${named(m.items, id)?.name ?? named(m.items, id)?.key ?? id}”`;
   if (kind === 'Tokens') {
-    const from = v.from.Pool ? `from the pool “${m.pools.find((p) => p.index === v.from.Pool[0])?.key ?? v.from.Pool[0]}”` : v.from.Mint ? `minted from ${v.from.Mint[0]}` : `from the vault ${v.from.Vest[0]}`;
-    const amount = v.amount.Fixed ? tokens(v.amount.Fixed[0], prizeToken(gives, m)) : `${Number(v.amount.Bps[0]) / 100}% of what it holds`;
+    const from = v.from.Pool
+      ? `from the pool “${m.pools.find(p => p.index === v.from.Pool[0])?.key ?? v.from.Pool[0]}”`
+      : v.from.Mint
+        ? `minted from ${v.from.Mint[0]}`
+        : `from the vault ${v.from.Vest[0]}`;
+    const amount = tokens(v.amount, prizeToken(gives, m));
     return `${amount} ${from}`;
   }
   if (kind === 'Item') return item(v[0]);
   if (kind === 'Nft') return `an NFT of ${stash(v.stash)}`;
   if (kind === 'Stash') return `an NFT of ${stash(v[0])} at random`;
-  if (kind === 'Roll') return `a roll of the box “${m.allBoxes.find((b) => b.id === v[0])?.name ?? m.allBoxes.find((b) => b.id === v[0])?.key ?? v[0]}”`;
+  if (kind === 'Roll')
+    return `a roll of the box “${m.allBoxes.find(b => b.id === v[0])?.name ?? m.allBoxes.find(b => b.id === v[0])?.key ?? v[0]}”`;
   if (kind === 'Compressed') return `a compressed NFT of ${item(v.item)}`;
   if (kind === 'Held') return 'an NFT the lottery holds';
   return 'nothing';
 }
 
-const times = (n) => `${n} claim${Number(n) === 1 ? '' : 's'}`;
-const when = (seconds) => new Date(Number(seconds) * 1000).toISOString().replace('.000Z', 'Z');
+const times = n => `${n} claim${Number(n) === 1 ? '' : 's'}`;
+const when = seconds => new Date(Number(seconds) * 1000).toISOString().replace('.000Z', 'Z');
 
 /** A grant's prize and its limits: what each claim takes from the project, and how many claims there can be. */
 function grantTerms(args, names) {
@@ -196,14 +257,19 @@ function grantTerms(args, names) {
     l.wallet?.per_window ? `each wallet ${times(l.wallet.per_window)} every ${l.wallet.window} seconds` : null,
     l.per_person ? `each person ${times(l.per_person)}` : null,
     l.per_key ? `each voucher key ${times(l.per_key)}` : null,
-    l.per_day ? `${times(l.per_day)} a day` : null,
-    l.total ? `${times(l.total)} in all` : null,
+    l.all?.per_window
+      ? `${times(l.all.per_window)} ${Number(l.all.window) === 86_400 ? 'a day' : `every ${l.all.window} seconds`}`
+      : null,
+    l.all?.total ? `${times(l.all.total)} in all` : null,
     BigInt(l.window?.opens_at ?? 0) ? `opens ${when(l.window.opens_at)}` : null,
     BigInt(l.window?.closes_at ?? 0) ? `closes ${when(l.window.closes_at)}` : null,
   ].filter(Boolean);
   // A voucher or a list entry may name an amount of its own, up to the grant's fixed amount (0 is the prize as it is).
-  const upTo = !args.open && args.gives?.Tokens?.amount?.Fixed ? 'up to ' : '';
-  return [`Each claim gets: ${upTo}${prizeWords(args.gives, names.m)}`, `Limits: ${limits.length ? limits.join(', ') : 'none'}`];
+  const upTo = !args.open && args.gives?.Tokens ? 'up to ' : '';
+  return [
+    `Each claim gets: ${upTo}${prizeWords(args.gives, names.m)}`,
+    `Limits: ${limits.length ? limits.join(', ') : 'none'}`,
+  ];
 }
 
 /**
@@ -212,13 +278,17 @@ function grantTerms(args, names) {
  */
 function listLines(root, g, gives, names) {
   const list = g?.list ?? [];
-  if (!list.length || !equalBytes(grantArgs(g, names.m).list_root, root)) return [`Its list: a list with the root ${toHex(root)}, which is not the spec’s list`];
+  if (!list.length || !equalBytes(grantArgs(g, names.m).list_root, root))
+    return [`Its list: a list with the root ${toHex(root)}, which is not the spec’s list`];
   const token = prizeToken(gives, names.m);
   return [
     `Only wallets on its list may claim it (${list.length} wallet${list.length === 1 ? '' : 's'}, root ${toHex(root)})`,
-    ...list.map((e) => {
+    ...list.map(e => {
       const entry = typeof e === 'string' ? { wallet: e } : e;
-      const gets = entry.amount !== undefined ? `gets ${entry.amount} ${token?.symbol ?? token?.key ?? 'tokens'}` : 'gets the prize above';
+      const gets =
+        entry.amount !== undefined
+          ? `gets ${entry.amount} ${token?.symbol ?? token?.key ?? 'tokens'}`
+          : 'gets the prize above';
       return `On its list, ${entry.wallet}: ${gets}${entry.round ? `, in round ${entry.round}` : ''}`;
     }),
   ];
@@ -230,23 +300,23 @@ function listLines(root, g, gives, names) {
  * lacks is listed as no longer so.
  */
 export function compareDetails(now, was) {
-  const topic = (line) => line.split(':')[0];
+  const topic = line => line.split(':')[0];
   const left = [...was];
-  const out = now.map((line) => {
+  const out = now.map(line => {
     const same = left.indexOf(line);
     if (same >= 0) return left.splice(same, 1)[0];
-    const i = left.findIndex((old) => topic(old) === topic(line));
+    const i = left.findIndex(old => topic(old) === topic(line));
     if (i < 0) return `${line} (new)`;
     const [old] = left.splice(i, 1);
     return `${line} (changed: it was ${old.slice(topic(old).length + 1).trim() || old})`;
   });
-  return [...out, ...left.map((old) => `No longer: ${old}`)];
+  return [...out, ...left.map(old => `No longer: ${old}`)];
 }
 
 const ADDRESS = /\b[1-9A-HJ-NP-Za-km-z]{32,44}\b/g;
 
 /** Every address the lines name, in the order they name them. */
-const addressesIn = (lines) => [...new Set(lines.flatMap((l) => l.match(ADDRESS) ?? []))];
+const addressesIn = lines => [...new Set(lines.flatMap(l => l.match(ADDRESS) ?? []))];
 
 /**
  * A warning for the page when the approval pays or trusts an address: on a change, those the live economy did not
@@ -254,7 +324,7 @@ const addressesIn = (lines) => [...new Set(lines.flatMap((l) => l.match(ADDRESS)
  */
 export function outsideAddresses(lines, { was = null, owner = null } = {}) {
   const known = new Set([...(was ? addressesIn(was) : []), ...(owner ? [owner] : [])]);
-  const outside = addressesIn(lines).filter((a) => !known.has(a));
+  const outside = addressesIn(lines).filter(a => !known.has(a));
   if (!outside.length) return null;
   return was
     ? `This change pays or trusts ${outside.length === 1 ? 'an address' : 'addresses'} the live economy does not: ${outside.join(', ')}. Approve only if you meant ${outside.length === 1 ? 'it' : 'each one'} (the lines below say what each gets).`

package/js/approve/ed25519.mjs

@@ -28,7 +28,11 @@ export function freshKeypair() {
 export function verifySignature(address, message, signature) {
   if (!signature || signature.length !== 64) return false;
   try {
-    const key = createPublicKey({ key: Buffer.concat([SPKI_ED25519, Buffer.from(addressBytes(address))]), format: 'der', type: 'spki' });
+    const key = createPublicKey({
+      key: Buffer.concat([SPKI_ED25519, Buffer.from(addressBytes(address))]),
+      format: 'der',
+      type: 'spki',
+    });
     return verify(null, Buffer.from(message), key, Buffer.from(signature));
   } catch {
     return false;

package/js/approve/live-check.mjs

@@ -30,19 +30,33 @@ export async function checkLive({ live, m, wallet, chain }) {
     return t?.source === 'game' && (!t.mint || t.mint.startsWith('@'));
   });
   if (!made.project && !setupMints.length && !made.collection && !made.tree) return { owner: wallet, project: own };
-  if (typeof chain.account !== 'function') throw new Error('The file says part of this economy is live already, and this connection cannot read the chain to check it: nothing was sent.');
-  const read = (address) => chain.account(address);
+  if (typeof chain.account !== 'function')
+    throw new Error(
+      'The file says part of this economy is live already, and this connection cannot read the chain to check it: nothing was sent.',
+    );
+  const read = address => chain.account(address);
 
   let owner = wallet;
   let project = own;
   if (made.project) {
     const account = await read(made.project);
-    if (!account || account.owner !== LOOT_PROGRAM || accountKind(account.data) !== 'Project') throw new LiveMismatch(`The file names the project ${made.project}, and there is no loot project at that address.`);
+    if (!account || account.owner !== LOOT_PROGRAM || accountKind(account.data) !== 'Project')
+      throw new LiveMismatch(
+        `The file names the project ${made.project}, and there is no loot project at that address.`,
+      );
     const state = decode('Project', account.data);
-    if (pda.project(state.owner, m.projectNumber) !== made.project) throw new LiveMismatch(`The file names the project ${made.project}, which is not project number ${m.projectNumber} of its owner ${state.owner}.`);
-    if (state.owner !== wallet && state.authority !== wallet) throw new LiveMismatch(`The file names the project ${made.project}, which belongs to the wallet ${state.owner}, not to the connected wallet ${wallet}. Your own project number ${m.projectNumber} is at ${own}.`);
-    if (made.treasury && made.treasury !== state.treasury) throw new LiveMismatch(`The file says the treasury is ${made.treasury}; on chain it is ${state.treasury}.`);
-    if (made.authority && made.authority !== state.authority) throw new LiveMismatch(`The file says the authority is ${made.authority}; on chain it is ${state.authority}.`);
+    if (pda.project(state.owner, m.projectNumber) !== made.project)
+      throw new LiveMismatch(
+        `The file names the project ${made.project}, which is not project number ${m.projectNumber} of its owner ${state.owner}.`,
+      );
+    if (state.owner !== wallet && state.authority !== wallet)
+      throw new LiveMismatch(
+        `The file names the project ${made.project}, which belongs to the wallet ${state.owner}, not to the connected wallet ${wallet}. Your own project number ${m.projectNumber} is at ${own}.`,
+      );
+    if (made.treasury && made.treasury !== state.treasury)
+      throw new LiveMismatch(`The file says the treasury is ${made.treasury}; on chain it is ${state.treasury}.`);
+    if (made.authority && made.authority !== state.authority)
+      throw new LiveMismatch(`The file says the authority is ${made.authority}; on chain it is ${state.authority}.`);
     owner = state.owner;
     project = made.project;
   }
@@ -51,13 +65,25 @@ export async function checkLive({ live, m, wallet, chain }) {
     const t = m.tokens.get(key);
     const account = await read(address);
     const mint = account ? parseMint(address, account.owner, account.data) : null;
-    if (!mint) throw new LiveMismatch(`The file says the setup made the token ${t.symbol ?? key} at ${address}, and there is no mint there.`);
-    if (mint.decimals !== (t.decimals ?? 0)) throw new LiveMismatch(`The mint ${address} the file names for ${t.symbol ?? key} has ${mint.decimals} decimals, not ${t.decimals ?? 0}.`);
+    if (!mint)
+      throw new LiveMismatch(
+        `The file says the setup made the token ${t.symbol ?? key} at ${address}, and there is no mint there.`,
+      );
+    if (mint.decimals !== (t.decimals ?? 0))
+      throw new LiveMismatch(
+        `The mint ${address} the file names for ${t.symbol ?? key} has ${mint.decimals} decimals, not ${t.decimals ?? 0}.`,
+      );
     // The setup hands a token's minting to the project, or turns it off for good (a fixed supply); it never keeps a
     // freeze authority.
     const minter = t.fixedSupply ? null : project;
-    if (mint.mintAuthority !== minter) throw new LiveMismatch(`The mint ${address} the file names for ${t.symbol ?? key} is minted by ${mint.mintAuthority ?? 'nobody'}, not ${minter ?? 'nobody'} as the setup leaves it.`);
-    if (mint.freezeAuthority) throw new LiveMismatch(`The mint ${address} the file names for ${t.symbol ?? key} can be frozen by ${mint.freezeAuthority}; the setup makes none that can.`);
+    if (mint.mintAuthority !== minter)
+      throw new LiveMismatch(
+        `The mint ${address} the file names for ${t.symbol ?? key} is minted by ${mint.mintAuthority ?? 'nobody'}, not ${minter ?? 'nobody'} as the setup leaves it.`,
+      );
+    if (mint.freezeAuthority)
+      throw new LiveMismatch(
+        `The mint ${address} the file names for ${t.symbol ?? key} can be frozen by ${mint.freezeAuthority}; the setup makes none that can.`,
+      );
   }
 
   if (made.collection) {
@@ -68,14 +94,24 @@ export async function checkLive({ live, m, wallet, chain }) {
     } catch {
       collection = null;
     }
-    if (!collection) throw new LiveMismatch(`The file names the collection ${made.collection}, and there is no Core collection there.`);
-    if (collection.updateAuthority !== owner) throw new LiveMismatch(`The collection ${made.collection} the file names belongs to ${collection.updateAuthority}, not to the project's owner ${owner}.`);
+    if (!collection)
+      throw new LiveMismatch(
+        `The file names the collection ${made.collection}, and there is no Core collection there.`,
+      );
+    if (collection.updateAuthority !== owner)
+      throw new LiveMismatch(
+        `The collection ${made.collection} the file names belongs to ${collection.updateAuthority}, not to the project's owner ${owner}.`,
+      );
   }
 
   if (made.tree) {
     const config = await read(pda.treeConfig(made.tree));
-    const creator = config?.owner === BUBBLEGUM_PROGRAM && config.data.length >= 40 ? encodeBase58(config.data.subarray(8, 40)) : null;
-    if (creator !== project) throw new LiveMismatch(`The file names the tree ${made.tree}, which is not a tree of the project ${project}.`);
+    const creator =
+      config?.owner === BUBBLEGUM_PROGRAM && config.data.length >= 40
+        ? encodeBase58(config.data.subarray(8, 40))
+        : null;
+    if (creator !== project)
+      throw new LiveMismatch(`The file names the tree ${made.tree}, which is not a tree of the project ${project}.`);
   }
   return { owner, project };
 }
@@ -91,28 +127,45 @@ export class MintMismatch extends Error {}
  * decimals, and is not read. Throws MintMismatch.
  */
 export async function checkMints({ m, chain }) {
-  const named = [...m.tokens.values()].filter((t) => t.mint && !t.mint.startsWith('@'));
+  const named = [...m.tokens.values()].filter(t => t.mint && !t.mint.startsWith('@'));
   // The routes that read a mint's default account state once, as they open, and refuse one that can start frozen.
   const once = new Map();
   const reads = (key, what) => key && !once.has(key) && once.set(key, what);
-  for (const l of m.lotteries) reads(l.currency ?? m.currencyKey, `the lottery ${l.name ?? l.key}`), reads(l.ticketCurrency, `the lottery ${l.name ?? l.key}`);
+  for (const l of m.lotteries)
+    (reads(l.currency ?? m.currencyKey, `the lottery ${l.name ?? l.key}`),
+      reads(l.ticketCurrency, `the lottery ${l.name ?? l.key}`));
   for (const c of m.contests) reads(c.currency ?? m.currencyKey, `the contest ${c.name ?? c.key}`);
   for (const a of m.auctions) reads(a.currency ?? m.currencyKey, `the auction ${a.name ?? a.key}`);
-  for (const s of m.schedules.filter((x) => x.sealed)) reads(s.currency ?? m.currencyKey, `the sealed schedule ${s.name ?? s.key}`);
+  for (const s of m.schedules.filter(x => x.sealed))
+    reads(s.currency ?? m.currencyKey, `the sealed schedule ${s.name ?? s.key}`);
   for (const t of named) {
     const what = `the token ${t.symbol ?? t.key} (“${t.key}”)`;
     if (t.wsol) {
-      if (t.decimals !== 9) throw new MintMismatch(`The spec gives ${what} ${t.decimals} decimals; its mint ${t.mint} is wrapped SOL, which has 9. Write "decimals": 9.`);
+      if (t.decimals !== 9)
+        throw new MintMismatch(
+          `The spec gives ${what} ${t.decimals} decimals; its mint ${t.mint} is wrapped SOL, which has 9. Write "decimals": 9.`,
+        );
       continue;
     }
-    if (typeof chain.account !== 'function') throw new MintMismatch(`This connection cannot read the chain, so the decimals of ${what} at ${t.mint} cannot be checked.`);
+    if (typeof chain.account !== 'function')
+      throw new MintMismatch(
+        `This connection cannot read the chain, so the decimals of ${what} at ${t.mint} cannot be checked.`,
+      );
     const account = await chain.account(t.mint);
     const mint = account ? parseMint(t.mint, account.owner, account.data) : null;
     if (!mint) throw new MintMismatch(`The spec names ${what} at ${t.mint}, and there is no token mint there.`);
-    if (mint.decimals !== t.decimals) throw new MintMismatch(`The spec gives ${what} ${t.decimals ?? 'no'} decimals; its mint ${t.mint} has ${mint.decimals}, so every amount in it would be ${scale(t.decimals ?? 0, mint.decimals)} what the page shows. Write "decimals": ${mint.decimals}.`);
-    if (mint.program !== t.program) throw new MintMismatch(`The spec says ${what} is a ${t.program} token; its mint ${t.mint} is ${mint.program}. Write "program": "${mint.program}".`);
+    if (mint.decimals !== t.decimals)
+      throw new MintMismatch(
+        `The spec gives ${what} ${t.decimals ?? 'no'} decimals; its mint ${t.mint} has ${mint.decimals}, so every amount in it would be ${scale(t.decimals ?? 0, mint.decimals)} what the page shows. Write "decimals": ${mint.decimals}.`,
+      );
+    if (mint.program !== t.program)
+      throw new MintMismatch(
+        `The spec says ${what} is a ${t.program} token; its mint ${t.mint} is ${mint.program}. Write "program": "${mint.program}".`,
+      );
     if (once.has(t.key) && mayStartFrozen(account))
-      throw new MintMismatch(`The mint ${t.mint} of ${what} has a default account state that starts new accounts frozen, or that its freeze authority can switch to frozen, so ${once.get(t.key)} would be refused as it opens (the program refuses such a mint wherever a refund or a payout goes into an account opened for it). Use another token there.`);
+      throw new MintMismatch(
+        `The mint ${t.mint} of ${what} has a default account state that starts new accounts frozen, or that its freeze authority can switch to frozen, so ${once.get(t.key)} would be refused as it opens (the program refuses such a mint wherever a refund or a payout goes into an account opened for it). Use another token there.`,
+      );
   }
   await checkTreasury({ m, chain });
 }
@@ -136,9 +189,13 @@ export async function checkTreasury({ m, chain }) {
   if (!treasury || typeof chain.account !== 'function') return;
   const account = await chain.account(treasury);
   if (!account || (account.owner === SYSTEM_PROGRAM && !account.executable)) return;
-  const what = HOLDS_A_VAULT[account.owner] ?? (account.executable ? 'a program' : `an account of the program ${account.owner}`);
-  throw new MintMismatch(`The spec’s treasury ${treasury} is ${what}: nobody can sign for what it would be paid, so every split’s rest would be stuck there. Name the wallet that signs (for a Squads multisig, its vault address; for a Realms DAO, its treasury).`);
+  const what =
+    HOLDS_A_VAULT[account.owner] ?? (account.executable ? 'a program' : `an account of the program ${account.owner}`);
+  throw new MintMismatch(
+    `The spec’s treasury ${treasury} is ${what}: nobody can sign for what it would be paid, so every split’s rest would be stuck there. Name the wallet that signs (for a Squads multisig, its vault address; for a Realms DAO, its treasury).`,
+  );
 }
 
 /** How much an amount written with `said` decimals is, on a mint of `real` decimals, against what it says. */
-const scale = (said, real) => (said > real ? `${10n ** BigInt(said - real)} times` : `1/${10n ** BigInt(real - said)} of`);
+const scale = (said, real) =>
+  said > real ? `${10n ** BigInt(said - real)} times` : `1/${10n ** BigInt(real - said)} of`;