@xgamesfun/solana 0.24.0 → 0.25.1

package/js/client/accounts.js

@@ -49,41 +49,109 @@ export const TAGS = Object.freeze({
 const BY_TAG = Object.fromEntries(Object.entries(TAGS).map(([name, tag]) => [tag, name]));
 
 /** The kind of a loot account from its first byte, or null. */
-export const accountKind = (data) => (data?.length ? BY_TAG[data[0]] ?? null : null);
+export const accountKind = data => (data?.length ? (BY_TAG[data[0]] ?? null) : null);
 
 /**
  * The records the program writes by hand, as IDL types: a lottery round's header and what it keeps (`LotteryRound`,
  * tag 16), and a contest's entry. The client reads them with the same Borsh codec as any account.
  */
 const RECORDS = [
-  { name: 'Round', type: { kind: 'enum', variants: ['Open', 'Drawing', 'Drawn', 'Cancelled'].map((name) => ({ name })) } },
-  { name: 'TokenPrize', type: { kind: 'struct', fields: [{ name: 'run', type: 'u16' }, { name: 'mint', type: 'pubkey' }, { name: 'each', type: 'u64' }, { name: 'sent', type: 'u64' }, { name: 'arrived', type: 'u64' }, { name: 'minted', type: 'bool' }] } },
-  { name: 'Opened', type: { kind: 'struct', fields: [{ name: 'mint', type: 'pubkey' }, { name: 'by', type: 'pubkey' }] } },
+  {
+    name: 'Round',
+    type: { kind: 'enum', variants: ['Open', 'Drawing', 'Drawn', 'Cancelled'].map(name => ({ name })) },
+  },
+  {
+    name: 'TokenPrize',
+    type: {
+      kind: 'struct',
+      fields: [
+        { name: 'run', type: 'u16' },
+        { name: 'mint', type: 'pubkey' },
+        { name: 'each', type: 'u64' },
+        { name: 'sent', type: 'u64' },
+        { name: 'arrived', type: 'u64' },
+        { name: 'minted', type: 'bool' },
+      ],
+    },
+  },
+  {
+    name: 'Opened',
+    type: {
+      kind: 'struct',
+      fields: [
+        { name: 'mint', type: 'pubkey' },
+        { name: 'by', type: 'pubkey' },
+      ],
+    },
+  },
   {
     name: 'LotteryRound',
     type: {
       kind: 'struct',
       fields: [
-        ['project', 'pubkey'], ['lottery', 'pubkey'], ['id', 'u32'], ['incarnation', 'u64'], ['round', 'u32'], ['bump', 'u8'], ['opener', 'pubkey'], ['lent', 'u64'], ['head', 'u32'],
+        ['project', 'pubkey'],
+        ['lottery', 'pubkey'],
+        ['id', 'u32'],
+        ['incarnation', 'u64'],
+        ['round', 'u32'],
+        ['bump', 'u8'],
+        ['opener', 'pubkey'],
+        ['lent', 'u64'],
+        ['head', 'u32'],
         ['status', { defined: { name: 'Round' } }],
         // The terms, as the lottery's revision had them at the round's first purchase; whether its entries keep what
         // arrived (a payment mint with a transfer fee, or a share the buyer chooses, paid as they buy).
-        ['revision', 'u32'], ['terms', { defined: { name: 'LotteryTerms' } }], ['fee', 'bool'],
+        ['revision', 'u32'],
+        ['terms', { defined: { name: 'LotteryTerms' } }],
+        ['fee', 'bool'],
         // The totals, split at each purchase: what each share paid in common takes, the entries that own a part of
         // their own, and the parts owed now.
-        ['sold', 'u64'], ['to_pot', 'u64'], ['common', { vec: 'u64' }], ['owns', 'u32'], ['owed', 'u32'],
+        ['sold', 'u64'],
+        ['to_pot', 'u64'],
+        ['common', { vec: 'u64' }],
+        ['owns', 'u32'],
+        ['owed', 'u32'],
         // The draw, and the money the ask fixed: the pot's (what the round owes the pot back: `pot_owed`).
-        ['asked_first', 'u64'], ['asked_slot', 'u64'], ['first_asked_at', 'i64'], ['asked_at', 'i64'], ['answer', { array: ['u8', 32] }], ['first', 'u64'],
-        ['pot_total', 'u64'], ['pot_sent', 'u64'], ['pot_arrived', 'u64'], ['pot_owed', 'u64'], ['paid', 'bytes'],
-        ['prizes', { vec: { defined: { name: 'TokenPrize' } } }], ['accounts', { vec: { defined: { name: 'Opened' } } }],
+        ['asked_first', 'u64'],
+        ['asked_slot', 'u64'],
+        ['first_asked_at', 'i64'],
+        ['asked_at', 'i64'],
+        ['answer', { array: ['u8', 32] }],
+        ['first', 'u64'],
+        ['pot_total', 'u64'],
+        ['pot_sent', 'u64'],
+        ['pot_arrived', 'u64'],
+        ['pot_owed', 'u64'],
+        ['paid', 'bytes'],
+        ['prizes', { vec: { defined: { name: 'TokenPrize' } } }],
+        ['accounts', { vec: { defined: { name: 'Opened' } } }],
         // The NFT of the lottery's own stash each place that holds or draws one got, in place order, and how many.
-        ['nfts', { vec: 'pubkey' }], ['assigned', 'u32'],
+        ['nfts', { vec: 'pubkey' }],
+        ['assigned', 'u32'],
+      ].map(([name, type]) => ({ name, type })),
+    },
+  },
+  {
+    name: 'ContestEntry',
+    type: {
+      kind: 'struct',
+      fields: [
+        ['player', 'pubkey'],
+        ['side', 'u16'],
+        ['amount', 'u64'],
+        ['bits', 'u8'],
+        ['nft', 'pubkey'],
+        ['place', 'u32'],
+        ['taken', 'u32'],
       ].map(([name, type]) => ({ name, type })),
     },
   },
-  { name: 'ContestEntry', type: { kind: 'struct', fields: [['player', 'pubkey'], ['side', 'u16'], ['amount', 'u64'], ['bits', 'u8'], ['nft', 'pubkey'], ['place', 'u32'], ['taken', 'u32']].map(([name, type]) => ({ name, type })) } },
 ];
-const IDLX = { ...IDL, types: [...IDL.types, ...RECORDS], accounts: [...IDL.accounts, { name: 'LotteryRound', discriminator: [TAGS.LotteryRound] }] };
+const IDLX = {
+  ...IDL,
+  types: [...IDL.types, ...RECORDS],
+  accounts: [...IDL.accounts, { name: 'LotteryRound', discriminator: [TAGS.LotteryRound] }],
+};
 
 /** A loot account of the named kind (one the IDL describes, or a `LotteryRound`). Throws when the data is not one. */
 export const decode = (name, data) => decodeAccount(IDLX, name, data);
@@ -97,7 +165,8 @@ export function decodeAny(data) {
   if (kind === 'Ends') return { kind, value: decodeEnds(data) };
   if (kind === 'LotteryRound') return { kind, value: decodeRound(data) };
   if (kind === 'Sheet') return { kind, value: decodeSheet(data) };
-  if (kind === 'Table') return data[37] === PAYLOAD.Nft ? { kind: 'Stash', value: decodeStash(data) } : { kind, value: decodeTable(data) };
+  if (kind === 'Table')
+    return data[37] === PAYLOAD.Nft ? { kind: 'Stash', value: decodeStash(data) } : { kind, value: decodeTable(data) };
   if (kind === 'Proven') return { kind, value: decodeProven(data) };
   if (kind === 'Traits') return { kind, value: decodeTraits(data) };
   return { kind, value: decode(kind, data) };
@@ -124,28 +193,38 @@ export function decodeList(data) {
  * it, the weight that stops earning then, and the seats that still need the record.
  */
 export function decodeEnds(data) {
-  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Ends || data.length < 7) throw new Error('Not a record of ends');
+  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Ends || data.length < 7)
+    throw new Error('Not a record of ends');
   const width = Number(readUintLE(data, 1, 2));
   const count = Number(readUintLE(data, 3, 4));
-  if (width !== END_BYTES || data.length !== 7 + width * count) throw new Error('The record of ends does not match its records');
+  if (width !== END_BYTES || data.length !== 7 + width * count)
+    throw new Error('The record of ends does not match its records');
   return Array.from({ length: count }, (_, i) => {
     const at = 7 + width * i;
     let time = 0n;
     for (let b = 0; b < 8; b++) time = (time << 8n) | BigInt(data[at + b]);
-    return { at: time, rewardPerWeight: readUintLE(data, at + 8, 16), weight: readUintLE(data, at + 24, 16), seats: Number(readUintLE(data, at + 40, 4)) };
+    return {
+      at: time,
+      rewardPerWeight: readUintLE(data, at + 8, 16),
+      weight: readUintLE(data, at + 24, 16),
+      seats: Number(readUintLE(data, at + 40, 4)),
+    };
   });
 }
 
 /** The first 16 bytes of the sha256 of `parts` (addresses, bytes or u64s): a record's key in a list. */
-export const recordKey16 = (...parts) => sha256(concat(...parts.map((p) => (typeof p === 'string' ? addressBytes(p) : p instanceof Uint8Array ? p : uintLE(p, 8))))).subarray(0, 16);
+export const recordKey16 = (...parts) =>
+  sha256(
+    concat(...parts.map(p => (typeof p === 'string' ? addressBytes(p) : p instanceof Uint8Array ? p : uintLE(p, 8)))),
+  ).subarray(0, 16);
 
 /** The key of a wallet's count for a box, a recipe (incarnation 0) or a lottery (its incarnation), in its counts. */
 export const countKey = (record, incarnation = 0) => recordKey16(record, BigInt(incarnation));
 
 /** What the limit record at `key` counts in a decoded list (`decodeList`, or null for none): { count, window, inWindow }. */
 export function readLimit(list, key) {
-  const record = list?.records.find((r) => compareBytes(r.subarray(0, 16), key) === 0);
-  const n = (i) => (record ? Number(readUintLE(record, 16 + 4 * i, 4)) : 0);
+  const record = list?.records.find(r => compareBytes(r.subarray(0, 16), key) === 0);
+  const n = i => (record ? Number(readUintLE(record, 16 + 4 * i, 4)) : 0);
   return { count: n(0), window: n(1), inWindow: n(2) };
 }
 
@@ -153,7 +232,13 @@ export function readLimit(list, key) {
  * as the list). Any other owner or layout is refused. */
 export function readListAccount(account) {
   if (account == null) return null;
-  if (account.owner === SYSTEM_PROGRAM && account.data instanceof Uint8Array && account.data.length === 0 && !account.executable) return null;
+  if (
+    account.owner === SYSTEM_PROGRAM &&
+    account.data instanceof Uint8Array &&
+    account.data.length === 0 &&
+    !account.executable
+  )
+    return null;
   if (account.owner !== LOOT_PROGRAM || account.executable) throw new Error('The list has an invalid owner.');
   return decodeList(account.data);
 }
@@ -165,7 +250,7 @@ export function readListAccount(account) {
  */
 export function decodeEntries(data) {
   const { width, records } = decodeList(data);
-  return records.map((r) => {
+  return records.map(r => {
     const full = new Uint8Array(83);
     full.set(r.subarray(0, Math.min(width, 83)));
     return decodeBorsh(IDLX, { defined: { name: 'ContestEntry' } }, full)[0];
@@ -178,14 +263,38 @@ export const ENDED = 2;
 
 /** How many losers' NFTs a winner of a contest of NFTs takes: the share fixed at the decision, one more for an early
  * place on its side. */
-export const shareOf = (contest, entry) => Number(contest.share) + (Number(entry.place) < Number(contest.extras) ? 1 : 0);
+export const shareOf = (contest, entry) =>
+  Number(contest.share) + (Number(entry.place) < Number(contest.extras) ? 1 : 0);
+
+/**
+ * What a winning entry that put in `amount` takes with its first claim of a decided contest of tokens: its part of what
+ * the decision wrote (`pot_won`, the pot once the shares were taken; `prize_won`, a split prize's vault), by what it put
+ * in against its side's total. The winners claimed before it took `won × claimed ÷ total`, so the parts add up exactly
+ * whatever the order: `{ pot, prize }` (the prize part is 0 when the claim forgoes it). Tokens sent to the pot after the
+ * decision are nobody's.
+ */
+export function contestWinnings(contest, amount) {
+  const total = BigInt(contest.sides[contest.winner] ?? 0) || 1n;
+  const claimed = total - BigInt(contest.unclaimed);
+  const part = won => (BigInt(won) * (claimed + BigInt(amount))) / total - (BigInt(won) * claimed) / total;
+  return { pot: part(contest.pot_won), prize: part(contest.prize_won) };
+}
 
 /** What a count allows `n` more of at `now` under `limit` ({ total, per_window, window }, 0 is no limit; a lottery's
  * window is its round plus one, given as `window`). */
-export function countAllows(count, limit, now, n = 1, window = Number(limit.window) ? Math.floor(Number(now) / Number(limit.window)) + 1 : 0) {
+export function countAllows(
+  count,
+  limit,
+  now,
+  n = 1,
+  window = Number(limit.window) ? Math.floor(Number(now) / Number(limit.window)) + 1 : 0,
+) {
   const total = (count?.count ?? 0) + n;
   const inWindow = (count && count.window === window ? count.inWindow : 0) + n;
-  return (!Number(limit.total) || total <= Number(limit.total)) && (!Number(limit.per_window) || inWindow <= Number(limit.per_window));
+  return (
+    (!Number(limit.total) || total <= Number(limit.total)) &&
+    (!Number(limit.per_window) || inWindow <= Number(limit.per_window))
+  );
 }
 
 /**
@@ -194,7 +303,8 @@ export function countAllows(count, limit, now, n = 1, window = Number(limit.wind
  */
 export function decodeSheet(data) {
   if (data == null || data.length === 0) return null;
-  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Sheet || data.length < 69) throw new Error('Not a Sheet account');
+  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Sheet || data.length < 69)
+    throw new Error('Not a Sheet account');
   const { attributes, head } = attributesAt(data, 'Sheet');
   return { project: head(1), nft: head(33), attributes };
 }
@@ -203,7 +313,8 @@ export function decodeSheet(data) {
  * the wallet (its XP, level, rank). Its layout is a Sheet's, under its own tag. */
 export function decodeProfile(data) {
   if (data == null || data.length === 0) return null;
-  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Profile || data.length < 69) throw new Error('Not a Profile account');
+  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Profile || data.length < 69)
+    throw new Error('Not a Profile account');
   const { attributes, head } = attributesAt(data, 'Profile');
   return { project: head(1), wallet: head(33), attributes };
 }
@@ -224,7 +335,7 @@ function attributesAt(data, name) {
   // Each attribute takes 8 bytes at least (two empty texts).
   if (count * 8 > data.length - at) throw new Error(`${name} account is truncated`);
   const attributes = Array.from({ length: count }, () => ({ key: text(), value: text() }));
-  return { attributes, end: at, head: (from) => encodeBase58(data.subarray(from, from + 32)) };
+  return { attributes, end: at, head: from => encodeBase58(data.subarray(from, from + 32)) };
 }
 
 /** What a table's rows carry (its payload byte). */
@@ -245,16 +356,25 @@ export function tableRowAt(len, r) {
  */
 export function decodeTable(data) {
   if (data == null || data.length === 0) return null;
-  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Table || data.length < TABLE_HEAD) throw new Error('Not a Table account');
-  const payload = Object.keys(PAYLOAD).find((k) => PAYLOAD[k] === data[37]);
+  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Table || data.length < TABLE_HEAD)
+    throw new Error('Not a Table account');
+  const payload = Object.keys(PAYLOAD).find(k => PAYLOAD[k] === data[37]);
   if (!payload || payload === 'Nft') throw new Error('Not a Table account');
   const count = Number(readUintLE(data, 39, 4));
-  const head = { project: encodeBase58(data.subarray(1, 33)), id: Number(readUintLE(data, 33, 4)), payload, sealed: data[38] === 1, count, total: readUintLE(data, 43, 8) };
+  const head = {
+    project: encodeBase58(data.subarray(1, 33)),
+    id: Number(readUintLE(data, 33, 4)),
+    payload,
+    sealed: data[38] === 1,
+    count,
+    total: readUintLE(data, 43, 8),
+  };
   const len = payload === 'Label' ? 40 : 8;
   if (count && tableRowAt(len, count - 1) + len > data.length) throw new Error('Table account is truncated');
   const rows = Array.from({ length: count }, (_, r) => {
     const at = tableRowAt(len, r);
-    const label = payload === 'Label' ? new TextDecoder().decode(data.subarray(at + 8, at + 40)).replace(/\0+$/, '') : '';
+    const label =
+      payload === 'Label' ? new TextDecoder().decode(data.subarray(at + 8, at + 40)).replace(/\0+$/, '') : '';
     return { weight: Number(readUintLE(data, at, 4)), left: Number(readUintLE(data, at + 4, 4)), label };
   });
   return { ...head, rows };
@@ -264,11 +384,17 @@ export function decodeTable(data) {
  * give away and the weight each is drawn by, as a table of NFTs keeps them (a row: its weight, then the NFT). */
 export function decodeStash(data) {
   if (data == null || data.length === 0) return null;
-  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Table || data[37] !== PAYLOAD.Nft || data.length < TABLE_HEAD) throw new Error('Not a Stash account');
+  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Table || data[37] !== PAYLOAD.Nft || data.length < TABLE_HEAD)
+    throw new Error('Not a Stash account');
   const count = Number(readUintLE(data, 39, 4));
   if (count && tableRowAt(36, count - 1) + 36 > data.length) throw new Error('Stash account is truncated');
   const rows = Array.from({ length: count }, (_, r) => tableRowAt(36, r));
-  return { project: encodeBase58(data.subarray(1, 33)), id: Number(readUintLE(data, 33, 4)), nfts: rows.map((at) => encodeBase58(data.subarray(at + 4, at + 36))), weights: rows.map((at) => Number(readUintLE(data, at, 4))) };
+  return {
+    project: encodeBase58(data.subarray(1, 33)),
+    id: Number(readUintLE(data, 33, 4)),
+    nfts: rows.map(at => encodeBase58(data.subarray(at + 4, at + 36))),
+    weights: rows.map(at => Number(readUintLE(data, at, 4))),
+  };
 }
 
 /**
@@ -279,9 +405,10 @@ export function decodeStash(data) {
 export function decodeProven(data) {
   // Its shortest: the tag, five addresses, the root, data hash and creator hash, no asset data hash, the flags and
   // nonce, and its payer.
-  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Proven || data.length < 1 + 32 * 8 + 1 + 1 + 8 + 32) throw new Error('Not a Proven account');
-  const key = (at) => encodeBase58(data.subarray(at, at + 32));
-  const none = (k) => (k === NO_ADDRESS ? null : k);
+  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Proven || data.length < 1 + 32 * 8 + 1 + 1 + 8 + 32)
+    throw new Error('Not a Proven account');
+  const key = at => encodeBase58(data.subarray(at, at + 32));
+  const none = k => (k === NO_ADDRESS ? null : k);
   const root = 1 + 32 * 5;
   let at = root + 32 * 3; // the five addresses, then the root, data hash and creator hash
   if (data[at] !== 0 && data[at] !== 1) throw new Error('Proven account has an unknown asset data hash flag');
@@ -290,15 +417,27 @@ export function decodeProven(data) {
   if (at + 1 + 8 + 32 > data.length) throw new Error('Proven account is truncated');
   const flags = data[at];
   return {
-    asset: key(1), tree: key(33), owner: none(key(65)), delegate: none(key(97)), collection: none(key(129)),
-    flags, nonce: readUintLE(data, at + 1, 8), root: toHex(data.subarray(root, root + 32)), payer: key(at + 9),
+    asset: key(1),
+    tree: key(33),
+    owner: none(key(65)),
+    delegate: none(key(97)),
+    collection: none(key(129)),
+    flags,
+    nonce: readUintLE(data, at + 1, 8),
+    root: toHex(data.subarray(root, root + 32)),
+    payer: key(at + 9),
   };
 }
 
 /** The traits a project vouches for (`["traits", project, key]`): { project, key, root (hex) }. */
 export function decodeTraits(data) {
-  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Traits || data.length < 97) throw new Error('Not a Traits account');
-  return { project: encodeBase58(data.subarray(1, 33)), key: encodeBase58(data.subarray(33, 65)), root: toHex(data.subarray(65, 97)) };
+  if (!(data instanceof Uint8Array) || data[0] !== TAGS.Traits || data.length < 97)
+    throw new Error('Not a Traits account');
+  return {
+    project: encodeBase58(data.subarray(1, 33)),
+    key: encodeBase58(data.subarray(33, 65)),
+    root: toHex(data.subarray(65, 97)),
+  };
 }
 
 /**
@@ -310,11 +449,11 @@ export function decodeTokenMetadata(data) {
   if (!(data instanceof Uint8Array) || data[0] !== 4) return null;
   let at = 33;
   const key = () => encodeBase58(data.subarray(at, (at += 32)));
-  const skip = (n) => (at += n);
+  const skip = n => (at += n);
   const str = () => skip(4 + Number(readUintLE(data, at, 4)));
   const some = () => at < data.length && data[at++] === 1;
   const mint = key();
-  str(), str(), str(), skip(2);
+  (str(), str(), str(), skip(2));
   if (some()) skip(34 * Number(readUintLE(data, at, 4)) + 4);
   skip(2);
   if (some()) skip(1); // edition nonce
@@ -346,13 +485,26 @@ export function decodeTokenMetadata(data) {
 const END_BITS = (1n << 48n) - 1n;
 export const OWN_PAID = 1n << 63n;
 
-/** The mint a lottery's tickets are paid in (`terms`: a Lottery's or a round's): its ticket mint, burned, or its pot's. */
-export const paymentMint = (terms) => (ticketsBurn(terms) ? terms.ticket_mint : terms.mint);
+/** The mint a lottery's tickets are paid in (`terms`: a Lottery's or a round's): its ticket mint, burned, or `mint`. */
+export const paymentMint = terms => (ticketsBurn(terms) ? terms.ticket_mint : terms.mint);
 /** Whether a lottery's tickets are burned: they are paid in a ticket mint of its own. */
-export const ticketsBurn = (terms) => Boolean(terms.ticket_mint) && terms.ticket_mint !== NO_ADDRESS;
+export const ticketsBurn = terms => Boolean(terms.ticket_mint) && terms.ticket_mint !== NO_ADDRESS;
+
+/** The most pots one lottery keeps (`MAX_POTS`): a pot's id is below it. */
+export const MAX_POTS = Number(IDL.constants.find(c => c.name === 'MAX_POTS').value);
+/** The pot a lottery's places are paid from (`terms.pays_from`: `{ Pot: [id] }`), or null when each round pays from its
+ * own ticket money (`{ Round: { rest } }`). */
+export const potIdOf = terms => (terms?.pays_from?.Pot ? Number(terms.pays_from.Pot[0]) : null);
+/** Where what a round's places leave goes (`Part::Common` past the shares): its pot, or the `rest` a round paid from
+ * its own money names (`lotteryAddress`: the lottery's). */
+export const leftoverTo = (lotteryAddress, terms) =>
+  potIdOf(terms) != null ? { Account: [pda.lotteryPot(lotteryAddress, potIdOf(terms))] } : terms.pays_from.Round.rest;
+/** The ids of the pots a lottery opened (`Lottery::pots`, one bit an id), lowest first: a close empties each. */
+export const lotteryPots = lottery =>
+  Array.from({ length: MAX_POTS }, (_, id) => id).filter(id => (Number(lottery.pots ?? 0) >> id) & 1);
 
 /** A share the buyer chooses (a referrer, a collectible's holder): paid out of the price as they buy, from their own account. */
-export const chosenAtPurchase = (share) => Boolean(share.to?.Chosen);
+export const chosenAtPurchase = share => Boolean(share.to?.Chosen);
 
 /** The bytes of one entry of a round: buyer, word, what arrived (`fee`: a fee mint, or a chosen share), the NFT ticket. */
 export const entryWidth = (fee, nft) => 40 + (fee ? 8 : 0) + (nft ? 32 : 0);
@@ -368,16 +520,24 @@ export function decodeRound(data) {
   const at = Number(r.head);
   const width = Number(readUintLE(data, at, 2));
   const count = Number(readUintLE(data, at + 2, 4));
-  if (width !== entryWidth(r.fee, r.terms.nft_ticket != null) || data.length !== at + 6 + width * count) throw new Error('LotteryRound entries do not match its header');
+  if (width !== entryWidth(r.fee, r.terms.nft_ticket != null) || data.length !== at + 6 + width * count)
+    throw new Error('LotteryRound entries do not match its header');
   let start = 0n;
   const entries = Array.from({ length: count }, (_, i) => {
     const e = data.subarray(at + 6 + width * i, at + 6 + width * (i + 1));
     const word = readUintLE(e, 32, 8);
     const end = word & END_BITS;
     let k = 40;
-    const take = (n) => e.subarray((k += n) - n, k);
+    const take = n => e.subarray((k += n) - n, k);
     const amount = r.fee ? readUintLE(take(8), 0, 8) : (end - start) * BigInt(r.terms.price);
-    const entry = { buyer: encodeBase58(e.subarray(0, 32)), start, end, paid: word & ~END_BITS, amount, nft: r.terms.nft_ticket ? encodeBase58(take(32)) : NO_ADDRESS };
+    const entry = {
+      buyer: encodeBase58(e.subarray(0, 32)),
+      start,
+      end,
+      paid: word & ~END_BITS,
+      amount,
+      nft: r.terms.nft_ticket ? encodeBase58(take(32)) : NO_ADDRESS,
+    };
     start = end;
     return entry;
   });
@@ -385,10 +545,10 @@ export function decodeRound(data) {
 }
 
 /** How many places a lottery's (or a round's) `places` are, every run counted (`Place.times`). */
-export const placeCount = (places) => places.reduce((n, p) => n + Number(p.times ?? 1), 0);
+export const placeCount = places => places.reduce((n, p) => n + Number(p.times ?? 1), 0);
 
 /** The places of a round that have a winner: every place, but no more than tickets. */
-export const roundWinners = (r) => Math.min(placeCount(r.terms.places), Number(r.sold));
+export const roundWinners = r => Math.min(placeCount(r.terms.places), Number(r.sold));
 
 /** The ticket that wins `place` of a drawn round: even steps around the list from first place's ticket. */
 export function ticketOfPlace(r, place) {
@@ -424,7 +584,10 @@ export function placesIn(r, run, start, end) {
   const step = sold / BigInt(roundWinners(r));
   const d = (BigInt(start) + sold - BigInt(r.first)) % sold;
   const len = BigInt(end) - BigInt(start);
-  for (const [a, b] of [[d, d + len < sold ? d + len : sold], [0n, d + len > sold ? d + len - sold : 0n]]) {
+  for (const [a, b] of [
+    [d, d + len < sold ? d + len : sold],
+    [0n, d + len > sold ? d + len - sold : 0n],
+  ]) {
     let p = Number((a + step - 1n) / step);
     for (p = Math.max(p, from); p < to && BigInt(p) * step < b; p++) out.push(p);
   }
@@ -478,13 +641,17 @@ export const placePaid = (r, place, prize) => {
  * what it takes: [{ place, amount }]. A pull pays all of them. */
 function unpaidPlaces(r, i, run, prize) {
   const e = r.entries[i];
-  const k = prize ? r.prizes.findIndex((p) => Number(p.run) === run) : -1;
+  const k = prize ? r.prizes.findIndex(p => Number(p.run) === run) : -1;
   if (prize && k < 0) return [];
-  const runs = k >= 0
-    ? [[BigInt(r.prizes[k].each), runPlaces(r, run)[1] - runPlaces(r, run)[0]]]
-    : r.terms.places.map((p, j) => [bpsOf(r.pot_total, p.bps), runPlaces(r, j)[1] - runPlaces(r, j)[0]]);
-  const [sent, arrived, from] = k >= 0 ? [r.prizes[k].sent, r.prizes[k].arrived, runPlaces(r, run)[0]] : [r.pot_sent, r.pot_arrived, 0];
-  return placesIn(r, run, e.start, e.end).filter((p) => !placePaid(r, p, prize)).map((place) => ({ place, amount: splitPart(runs, sent, arrived, place - from) }));
+  const runs =
+    k >= 0
+      ? [[BigInt(r.prizes[k].each), runPlaces(r, run)[1] - runPlaces(r, run)[0]]]
+      : r.terms.places.map((p, j) => [bpsOf(r.pot_total, p.bps), runPlaces(r, j)[1] - runPlaces(r, j)[0]]);
+  const [sent, arrived, from] =
+    k >= 0 ? [r.prizes[k].sent, r.prizes[k].arrived, runPlaces(r, run)[0]] : [r.pot_sent, r.pot_arrived, 0];
+  return placesIn(r, run, e.start, e.end)
+    .filter(p => !placePaid(r, p, prize))
+    .map(place => ({ place, amount: splitPart(runs, sent, arrived, place - from) }));
 }
 
 /** What entry `i`'s places in run `run` take and are not paid yet, of its pot part or (`prize`) its token prize. */
@@ -492,18 +659,19 @@ export const placesOwed = (r, i, run, prize) => unpaidPlaces(r, i, run, prize).r
 
 /** How many of the round's owed parts a pull of `{ Pot: [run] }` or a token `{ Prize: [run] }` for entry `i` settles:
  * its places there that take more than nothing (one pull pays them all). */
-export const placesPulled = (r, i, run, prize) => unpaidPlaces(r, i, run, prize).filter((p) => p.amount > 0n).length;
+export const placesPulled = (r, i, run, prize) => unpaidPlaces(r, i, run, prize).filter(p => p.amount > 0n).length;
 
 /** Whether run `run` of a round's places gives tokens (its prize is fixed at the ask, a `TokenPrize`). */
 export const tokenRun = (r, run) => Boolean(r.terms.places[run]?.prize?.Tokens);
 
 /** A place whose prize is an NFT of the lottery's own stash (`Held`, `Raffled`): assigned by the pulls, in place order. */
-export const ownStash = (place) => Boolean(place.prize?.Held) || place.prize === 'Raffled' || place.prize?.Raffled !== undefined;
+export const ownStash = place =>
+  Boolean(place.prize?.Held) || place.prize === 'Raffled' || place.prize?.Raffled !== undefined;
 
 /** Entry `i`'s places in run `run` whose prize (not tokens) is not given yet, lowest first. */
 export const prizePlacesOwed = (r, i, run) => {
   const e = r.entries[i];
-  return placesIn(r, run, e.start, e.end).filter((p) => !placePaid(r, p, true));
+  return placesIn(r, run, e.start, e.end).filter(p => !placePaid(r, p, true));
 };
 
 /** Where in `r.nfts` the NFT of `place` is (a place of a run that holds or draws one of the lottery's own stash). */
@@ -533,7 +701,7 @@ export function stashPlacesWon(r) {
 export function awaitsNfts(r, i, run) {
   if (!ownStash(r.terms.places[run])) return false;
   const places = prizePlacesOwed(r, i, run);
-  return places.some((p) => nftSlot(r, p) >= Number(r.assigned));
+  return places.some(p => nftSlot(r, p) >= Number(r.assigned));
 }
 
 /**
@@ -553,44 +721,54 @@ export function partsOwed(r, i, { places = true } = {}) {
   for (let run = 0; run < r.terms.places.length; run++) {
     const prize = r.terms.places[run].prize;
     if (placesOwed(r, i, run, false) > 0n) parts.push({ Pot: [run] });
-    if (tokenRun(r, run) ? placesOwed(r, i, run, true) > 0n : prize != null && prizePlacesOwed(r, i, run).length > 0) parts.push({ Prize: [run] });
+    if (tokenRun(r, run) ? placesOwed(r, i, run, true) > 0n : prize != null && prizePlacesOwed(r, i, run).length > 0)
+      parts.push({ Prize: [run] });
   }
   return parts;
 }
 
 /**
  * The parts of a round owed in common, of no entry (`{ Common: [i] }`): each share paid in common once drawn (one that
- * burns is burned at the close), then what the round owes the lottery's pot (`i` = the shares' count), then after a
+ * burns is burned at the close), then what its places leave, owed to its pot or to `rest` (`i` = the shares' count), then after a
  * cancel each pool's token prize back to its pool (past it).
  */
 export function commonOwed(r) {
   const n = r.terms.shares.length;
   const out = [];
-  if (r.status === 'Drawn') r.terms.shares.forEach((s, i) => s.to !== 'Burn' && BigInt(r.common[i] ?? 0) > 0n && out.push({ Common: [i] }));
-  if ((r.status === 'Drawn' || r.status === 'Cancelled') && BigInt(r.pot_owed) > 0n) out.push({ Common: [n] });
-  if (r.status === 'Cancelled') r.prizes.forEach((p, k) => !p.minted && BigInt(p.arrived) > 0n && out.push({ Common: [n + 1 + k] }));
+  if (r.status === 'Drawn')
+    r.terms.shares.forEach((s, i) => s.to !== 'Burn' && BigInt(r.common[i] ?? 0) > 0n && out.push({ Common: [i] }));
+  // What the places leave, to the pot or to `rest`: a burned rest stays for the close to burn, and is no part owed.
+  if (
+    (r.status === 'Drawn' || r.status === 'Cancelled') &&
+    BigInt(r.pot_owed) > 0n &&
+    leftoverTo(r.lottery, r.terms) !== 'Burn'
+  )
+    out.push({ Common: [n] });
+  if (r.status === 'Cancelled')
+    r.prizes.forEach((p, k) => !p.minted && BigInt(p.arrived) > 0n && out.push({ Common: [n + 1 + k] }));
   return out;
 }
 
 /** The entry of a round holding `ticket`. */
-export const entryOf = (r, ticket) => r.entries.findIndex((e) => e.start <= BigInt(ticket) && BigInt(ticket) < e.end);
+export const entryOf = (r, ticket) => r.entries.findIndex(e => e.start <= BigInt(ticket) && BigInt(ticket) < e.end);
 
 /** Whether a round is done and owes nothing: the next pull closes it, given its close's accounts. */
-export const roundFinished = (r) => (r.status === 'Drawn' || r.status === 'Cancelled') && Number(r.owed) === 0;
+export const roundFinished = r => (r.status === 'Drawn' || r.status === 'Cancelled') && Number(r.owed) === 0;
 
-/** Whether a lottery's place wins something: a share of the pot, a prize, or both. */
-export const placeSet = (place) => Number(place.bps) > 0 || place.prize != null;
+/** Whether a lottery's place wins something: a part of what the round pays from, a prize, or both. */
+export const placeSet = place => Number(place.bps) > 0 || place.prize != null;
 
 /** The address of a lottery's current round's record (there or not). */
 export const roundAddress = (lotteryAddress, lottery) => pda.round(lotteryAddress, lottery.incarnation, lottery.round);
 
 /** Whether a lottery (decoded) drew once and has ended. */
-export const lotteryEnded = (lottery) => Number(lottery.every) === 0 && Number(lottery.round) > 0;
+export const lotteryEnded = lottery => Number(lottery.every) === 0 && Number(lottery.round) > 0;
 
 /** The round a lottery's close, its write again and its own stash's moves name (`lottery::check_idle`): its current
  * round's, or once a lottery that draws once has ended, round 0's (which keeps its stash's NFTs until its places took
  * them out). */
-export const idleRound = (lotteryAddress, lottery) => pda.round(lotteryAddress, lottery.incarnation, lotteryEnded(lottery) ? 0 : lottery.round);
+export const idleRound = (lotteryAddress, lottery) =>
+  pda.round(lotteryAddress, lottery.incarnation, lotteryEnded(lottery) ? 0 : lottery.round);
 
 /**
  * Who rents a listed NFT at `now` (Unix seconds), from its decoded Listing (or null for none): the renter's wallet while
@@ -602,7 +780,7 @@ export function renterOf(listing, now) {
 }
 
 /** Whether a schedule pays every run due when it is sent late (`schedule::catches_up`): only a sealed fixed amount. */
-export const scheduleCatchesUp = (schedule) => Boolean(schedule.action?.from?.Vest && schedule.action?.amount?.Fixed);
+export const scheduleCatchesUp = schedule => Boolean(schedule.action?.from?.Vest && schedule.action?.amount?.Fixed);
 
 /**
  * How many runs of a schedule are due at `now` (Unix seconds, the chain's clock, never the computer's). One `run_schedule`
@@ -612,7 +790,8 @@ export const scheduleCatchesUp = (schedule) => Boolean(schedule.action?.from?.Ve
  * (`vaultBalance`), which goes where it always went.
  */
 export function runsDue(schedule, now, vaultBalance = 0n) {
-  const runs = Number(schedule.runs), max = Number(schedule.max_runs);
+  const runs = Number(schedule.runs),
+    max = Number(schedule.max_runs);
   if (max > 0 && runs >= max) return schedule.action?.from?.Vest && BigInt(vaultBalance) > 0n ? 1 : 0;
   if (!schedule.active || BigInt(now) < BigInt(schedule.next_at)) return 0;
   const due = Number((BigInt(now) - BigInt(schedule.next_at)) / BigInt(schedule.every)) + 1;
@@ -630,16 +809,22 @@ export function runsDue(schedule, now, vaultBalance = 0n) {
  */
 export function receipts(tx, err) {
   if (Array.isArray(tx)) {
-    if (err === undefined) throw new Error("loot.receipts(logs, err) needs the transaction's meta.err (null when it succeeded): a failed transaction keeps its logs");
+    if (err === undefined)
+      throw new Error(
+        "loot.receipts(logs, err) needs the transaction's meta.err (null when it succeeded): a failed transaction keeps its logs",
+      );
     return err === null ? decodeEvents(IDL, tx) : [];
   }
   const meta = tx?.meta;
-  if (!meta || meta.err === undefined) throw new Error('loot.receipts(tx) needs the transaction getTransaction returns, with its meta.err and meta.logMessages');
+  if (!meta || meta.err === undefined)
+    throw new Error(
+      'loot.receipts(tx) needs the transaction getTransaction returns, with its meta.err and meta.logMessages',
+    );
   return meta.err === null ? decodeEvents(IDL, meta.logMessages ?? []) : [];
 }
 
 /** The program's errors by code: { code: { name, msg } }. */
-export const ERRORS = Object.freeze(Object.fromEntries(IDL.errors.map((e) => [e.code, { name: e.name, msg: e.msg }])));
+export const ERRORS = Object.freeze(Object.fromEntries(IDL.errors.map(e => [e.code, { name: e.name, msg: e.msg }])));
 
 /**
  * The loot error in a failed transaction's logs ("custom program error: 0x…", or Anchor's "Error Code: …" line), or
@@ -671,7 +856,12 @@ export function lootError(logs) {
     // A line that names no program (a log line, or an error's own text) is the running program's, when it is known.
     if (running.length && running.at(-1) !== LOOT_PROGRAM) continue;
     const named = /Error Code: (\w+)\. Error Number: (\d+)\. Error Message: (.+?)\.?$/.exec(line);
-    if (named) return { code: Number(named[2]), name: named[1], msg: ERRORS[Number(named[2])]?.name === named[1] ? ERRORS[Number(named[2])].msg : named[3] };
+    if (named)
+      return {
+        code: Number(named[2]),
+        name: named[1],
+        msg: ERRORS[Number(named[2])]?.name === named[1] ? ERRORS[Number(named[2])].msg : named[3],
+      };
     const m = /custom program error: 0x([0-9a-f]+)/i.exec(line);
     if (m && ERRORS[parseInt(m[1], 16)]) return { code: parseInt(m[1], 16), ...ERRORS[parseInt(m[1], 16)] };
   }