@xgamesfun/solana 0.24.0 → 0.25.1

package/js/client/pda.js

@@ -16,13 +16,13 @@ export const BUBBLEGUM_PROGRAM = 'BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY';
 export const COMPRESSION_PROGRAM = 'mcmt6YrQEMKw8Mw43FmpRLmf7BqRnFMKmAcbxE3xkAW';
 export const NOOP_PROGRAM = 'mnoopTCrg4p8ry25e4bcWA9XZjbNjMTfgYVGGEdRsf3';
 
-const seed = (s) => utf8(s);
-const key = (a) => addressBytes(a);
-const u8 = (n) => uintLE(n, 1);
-const u16 = (n) => uintLE(n, 2);
-const u32 = (n) => uintLE(n, 4);
-const u64 = (n) => uintLE(n, 8);
-const i64 = (n) => intLE(n, 8);
+const seed = s => utf8(s);
+const key = a => addressBytes(a);
+const u8 = n => uintLE(n, 1);
+const u16 = n => uintLE(n, 2);
+const u32 = n => uintLE(n, 4);
+const u64 = n => uintLE(n, 8);
+const i64 = n => intLE(n, 8);
 
 /** The PDA of these seeds under the loot program, with its bump. */
 export const lootAddress = (seeds, program = LOOT_PROGRAM) => findProgramAddress(seeds, program);
@@ -34,7 +34,7 @@ export const pda = {
    * new owner keeps the address. */
   project: (creator, id = 0) => at(seed('project'), key(creator), u64(id)),
   /** The project's fee box: where the platform's fees on its transactions wait. */
-  fees: (project) => at(seed('fees'), key(project)),
+  fees: project => at(seed('fees'), key(project)),
   pool: (project, index) => at(seed('pool'), key(project), u16(index)),
   item: (project, id) => at(seed('item'), key(project), u32(id)),
   box: (project, id) => at(seed('box'), key(project), u32(id)),
@@ -56,8 +56,10 @@ export const pda = {
   /** Every collectible the program mints of its own accord (an order's, a prize's, an auction's lot): its address
    * names its item and its serial, minted once at most. */
   itemAsset: (item, serial) => at(seed('asset'), key(item), u32(serial)),
-  /** A contest's pot, or a lottery's: `["pot", contest or lottery]`. */
-  pot: (record) => at(seed('pot'), key(record)),
+  /** A contest's pot: `["pot", contest]`. */
+  pot: record => at(seed('pot'), key(record)),
+  /** A lottery's pot `id` (below `MAX_POTS`), kept from round to round: `["pot", lottery, id]`. */
+  lotteryPot: (lottery, id) => at(seed('pot'), key(lottery), u8(id)),
   /** One round of a lottery: its record, opened by the round's first purchase (`["round", lottery, incarnation, round]`). */
   round: (lottery, incarnation, round) => at(seed('round'), key(lottery), u64(incarnation), u32(round)),
   /** A lottery round's own token account of `mint`, which the round's record owns. */
@@ -69,27 +71,27 @@ export const pda = {
   /** An offer: an id is its maker's own. Its money waits in the project's vault for its mint (`vault`). */
   offer: (project, maker, id) => at(seed('offer'), key(project), key(maker), u32(id)),
   /** A lottery's own stash: the NFTs its places promise (`Prize::Held`), which leave only as its prizes. */
-  lotteryStash: (lottery) => at(seed('lottery_stash'), key(lottery)),
+  lotteryStash: lottery => at(seed('lottery_stash'), key(lottery)),
   /** A contest's prize split by stake, set aside when it is decided: `["prize", contest]`. */
-  prizeVault: (contest) => at(seed('prize'), key(contest)),
+  prizeVault: contest => at(seed('prize'), key(contest)),
   /** A sealed schedule's own vault, which only its runs pay out of: `["vest", schedule]`. */
-  vest: (schedule) => at(seed('vest'), key(schedule)),
+  vest: schedule => at(seed('vest'), key(schedule)),
   /** A listing of an NFT for sale or for rent: one per NFT a project holds, so its address names the NFT. */
   listing: (project, asset) => at(seed('listing'), key(project), key(asset)),
-  staked: (farm) => at(seed('staked'), key(farm)),
-  rewards: (farm) => at(seed('rewards'), key(farm)),
+  staked: farm => at(seed('staked'), key(farm)),
+  rewards: farm => at(seed('rewards'), key(farm)),
   /** A farm's record of when its seats stop earning, for a farm that keeps one (`Farm.keeps_ends`). */
-  ends: (farm) => at(seed('ends'), key(farm)),
+  ends: farm => at(seed('ends'), key(farm)),
   /** A seat: a player's in a farm of tokens, a collectible's (its asset) in a farm of collectibles. */
   seat: (farm, by) => at(seed('seat'), key(farm), key(by)),
   /** What the project writes about an NFT it has no authority over (its Sheet): `nft` is a Core asset, a Token Metadata mint or a compressed NFT's asset id. */
   sheet: (project, nft) => at(seed('sheet'), key(project), key(nft)),
   /** A compressed NFT as last proven (`prove_leaf`), read while the leaf is unchanged and its root is still in the tree's change log. */
-  leaf: (asset) => at(seed('leaf'), key(asset)),
+  leaf: asset => at(seed('leaf'), key(asset)),
   /** The root of the traits the project vouches for, under its own `key` (a collection's address, by convention). */
   traits: (project, key_) => at(seed('traits'), key(project), key(key_)),
   /** Bubblegum's config of a tree: `[tree]`. */
-  treeConfig: (tree) => findProgramAddress([key(tree)], BUBBLEGUM_PROGRAM)[0],
+  treeConfig: tree => findProgramAddress([key(tree)], BUBBLEGUM_PROGRAM)[0],
   /** A compressed NFT's asset id: Bubblegum's `["asset", tree, nonce]`, `nonce` the count minted before it. */
   compressedAsset: (tree, nonce) => findProgramAddress([seed('asset'), key(tree), u64(nonce)], BUBBLEGUM_PROGRAM)[0],
   /** A wallet's counts in a project: how many times it bought from each box, crafted each recipe or held tickets in

package/js/client/policy.js

@@ -20,7 +20,8 @@ export function orderRefundAt(order) {
   const slot = BigInt(order.requested_slot);
   if (order.status === 'Failed') return { slot, at: null };
   if (order.status === 'Pending') return { slot, at: BigInt(order.asked_at) + STALE_SECONDS };
-  if (order.status === 'Asked' && (BigInt(order.paid ?? 0) > 0n || order.held)) return { slot: null, at: BigInt(order.first_asked_at) + LOTTERY_TIMEOUT_SECONDS };
+  if (order.status === 'Asked' && (BigInt(order.paid ?? 0) > 0n || order.held))
+    return { slot: null, at: BigInt(order.first_asked_at) + LOTTERY_TIMEOUT_SECONDS };
   if (['Rolled', 'Waiting', 'Asked'].includes(order.status)) return null;
   throw new Error('Unknown order status.');
 }
@@ -39,7 +40,8 @@ export function orderRefundable(order, slot, now) {
  * again is asked from the next slot on.
  */
 export const rollAskable = (order, slot, now) =>
-  (order.status === 'Waiting' && (BigInt(order.asked_first ?? 0) === 0n || BigInt(slot) > BigInt(order.requested_slot))) ||
+  (order.status === 'Waiting' &&
+    (BigInt(order.asked_first ?? 0) === 0n || BigInt(slot) > BigInt(order.requested_slot))) ||
   (order.status === 'Asked' && BigInt(now) > BigInt(order.asked_at) + STALE_SECONDS);
 
 /**
@@ -50,12 +52,16 @@ export function contestOff(contest, now) {
   if (contest.verdict === 'Off') return true;
   if (contest.verdict !== 'Open') return false;
   const total = contest.sides.reduce((sum, side) => sum + BigInt(side), 0n);
-  return BigInt(now) > BigInt(contest.result_by) || (BigInt(now) >= BigInt(contest.closes_at) && total < BigInt(contest.min_pot ?? 0));
+  return (
+    BigInt(now) > BigInt(contest.result_by) ||
+    (BigInt(now) >= BigInt(contest.closes_at) && total < BigInt(contest.min_pot ?? 0))
+  );
 }
 
 /** Whether a lottery round's draw (`round`: its decoded record) was asked for and the oracle has not answered within
  * `STALE_SECONDS` by `now` (Unix seconds, the chain's clock): anyone may ask again. */
-export const lotteryDrawStuck = (round, now) => round?.status === 'Drawing' && BigInt(now) > BigInt(round.asked_at) + STALE_SECONDS;
+export const lotteryDrawStuck = (round, now) =>
+  round?.status === 'Drawing' && BigInt(now) > BigInt(round.asked_at) + STALE_SECONDS;
 
 /**
  * Whether a lottery round's draw (`round`: its decoded record) was asked for and the oracle has not answered within
@@ -63,7 +69,8 @@ export const lotteryDrawStuck = (round, now) => round?.status === 'Drawing' && B
  * the next ask of that round (`drawLotteryIx` with its address) cancels it, and every entry is refunded. A round nobody
  * asked to draw is never cancelled.
  */
-export const lotteryCancellable = (round, now) => round?.status === 'Drawing' && BigInt(now) > BigInt(round.first_asked_at) + LOTTERY_TIMEOUT_SECONDS;
+export const lotteryCancellable = (round, now) =>
+  round?.status === 'Drawing' && BigInt(now) > BigInt(round.first_asked_at) + LOTTERY_TIMEOUT_SECONDS;
 
 /** A farm seat's `earns_until` when nothing ends its earning (i64::MAX): no tier term and no fuel it reads. */
 export const NO_END = (1n << 63n) - 1n;

package/js/client/random.js

@@ -1,7 +1,7 @@
 // The loot program's rolling module (`src/random`), mirrored: every random choice it makes is drawn from a stream of
 // the oracle's answer, by a path that names what is drawn, with one unbiased sampler. A page shows from an order's
 // answer what each draw gave (and a fresh unit's range traits) exactly as the program drew them. Held to the
-// program's own vectors (`js/test/fixtures/roll-vectors.json`, from gamesfun-loot's `tests/fixtures`).
+// program's own vectors (`js/test/fixtures/roll-vectors.json`, from the program's own tests).
 import { concat, uintLE } from '../chain/bytes.js';
 import { sha256 } from '../chain/sha256.js';
 
@@ -15,7 +15,7 @@ const PREFIX = new TextEncoder().encode('loot-roll-v1');
 /** A stream of the oracle's 32-byte `answer` at `path` (whole numbers): seed = sha256("loot-roll-v1" | answer | path as
  * u32 little-endian words); its nth number the first 8 bytes, little-endian, of sha256(seed | n as u64 little-endian). */
 export function stream(answer, path = []) {
-  const words = path.slice(0, MAX_PATH).map((w) => uintLE(w, 4));
+  const words = path.slice(0, MAX_PATH).map(w => uintLE(w, 4));
   const seed = sha256(concat(PREFIX, Uint8Array.from(answer), ...words));
   let counter = 0n;
   return {

package/js/client/sizes.js

@@ -23,15 +23,18 @@ function maximum(type, path) {
     return 4 + bounds[path] * maximum(type.vec, path);
   }
   const name = type.defined.name;
-  const definition = IDL.types.find((entry) => entry.name === name)?.type;
+  const definition = IDL.types.find(entry => entry.name === name)?.type;
   if (!definition) throw new Error(`Missing current IDL type ${name}`);
-  const fields = (list) => (list ?? []).reduce((n, field) => n + maximum(field.type ?? field, `${name}.${field.name ?? ''}`), 0);
-  return definition.kind === 'enum' ? 1 + Math.max(...definition.variants.map((variant) => fields(variant.fields))) : fields(definition.fields);
+  const fields = list =>
+    (list ?? []).reduce((n, field) => n + maximum(field.type ?? field, `${name}.${field.name ?? ''}`), 0);
+  return definition.kind === 'enum'
+    ? 1 + Math.max(...definition.variants.map(variant => fields(variant.fields)))
+    : fields(definition.fields);
 }
 
 /** The space reserved by a fixed-size account, including its discriminator. */
 export function allocationBytes(name) {
-  const account = IDL.accounts.find((entry) => entry.name === name);
+  const account = IDL.accounts.find(entry => entry.name === name);
   if (!account) throw new Error(`Missing current IDL account ${name}`);
   return account.discriminator.length + maximum({ defined: { name } }, name);
 }
@@ -59,7 +62,7 @@ export const MAX_CALLBACK_ACCOUNTS = 21;
 export function callbackAccounts(entries) {
   const sources = new Set();
   let named = 0;
-  for (const prize of entries.flatMap((e) => e.prizes)) {
+  for (const prize of entries.flatMap(e => e.prizes)) {
     if (prize.Item || prize.Compressed || prize.Nft || prize.Stash) named += 1;
     else if (prize.Tokens) {
       if (prize.Tokens.from.Pool) named += 1;
@@ -73,9 +76,9 @@ export function callbackAccounts(entries) {
  * How many fresh items' table accounts the oracle's answer to a roll of `entries` can carry (`order::table_budget`):
  * what the box's own accounts leave of `MAX_CALLBACK_ACCOUNTS`. Negative: the box can't be rolled at all.
  */
-export const tableBudget = (entries) => MAX_CALLBACK_ACCOUNTS - callbackAccounts(entries);
+export const tableBudget = entries => MAX_CALLBACK_ACCOUNTS - callbackAccounts(entries);
 
-const draws = (lootBox) => (lootBox.slots?.length ? lootBox.slots.reduce((n, s) => n + Number(s.count), 0) : 1);
+const draws = lootBox => (lootBox.slots?.length ? lootBox.slots.reduce((n, s) => n + Number(s.count), 0) : 1);
 const ZERO = '11111111111111111111111111111111';
 
 /** The most an order can be (`MAX_ORDER_BYTES`, not in the IDL): a box whose one open's order would be more is refused
@@ -84,8 +87,8 @@ export const MAX_ORDER_BYTES = 10_240;
 
 /** The bytes a draw sets aside for a prize, as the `Won` it becomes (`Order::sized`): an item 14, tokens or an NFT 41,
  * a roll, a held NFT or a raffled place nothing. */
-const wonBytes = (p) => (p.Item || p.Compressed ? 14 : p.Tokens || p.Nft || p.Stash ? 41 : 0);
-const tableCount = (item) => (item?.traits ?? []).filter((t) => t.from?.Table).length;
+const wonBytes = p => (p.Item || p.Compressed ? 14 : p.Tokens || p.Nft || p.Stash ? 41 : 0);
+const tableCount = item => (item?.traits ?? []).filter(t => t.from?.Table).length;
 
 /**
  * The rows of fresh items' tables a draw of each entry writes into its order (`order::rows_of`), walked with the box's
@@ -94,13 +97,15 @@ const tableCount = (item) => (item?.traits ?? []).filter((t) => t.from?.Table).l
  */
 export function entryRows(entries, items = {}) {
   let budget = Math.max(0, tableBudget(entries));
-  return entries.map(({ prizes }) => prizes.reduce((n, p) => {
-    const id = p.Item?.[0] ?? p.Compressed?.item;
-    const t = id === undefined ? 0 : tableCount(items[id]);
-    if (t > budget) return n;
-    budget -= t;
-    return n + t;
-  }, 0));
+  return entries.map(({ prizes }) =>
+    prizes.reduce((n, p) => {
+      const id = p.Item?.[0] ?? p.Compressed?.item;
+      const t = id === undefined ? 0 : tableCount(items[id]);
+      if (t > budget) return n;
+      budget -= t;
+      return n + t;
+    }, 0),
+  );
 }
 
 /**
@@ -113,20 +118,52 @@ export function entryRows(entries, items = {}) {
  */
 export function orderBytes(lootBox, shares = 0, opens = 1, items) {
   const drawn = draws(lootBox) * Math.max(1, opens);
-  const aDraw = Math.max(0, ...lootBox.entries.map((e) => e.prizes.reduce((n, p) => n + wonBytes(p), 0)));
-  const gives = lootBox.entries.some((e) => e.prizes.some((p) => p.Item || p.Compressed));
-  const rows = items ? Math.max(0, ...entryRows(lootBox.entries, items)) : gives ? Math.max(0, tableBudget(lootBox.entries)) : 0;
+  const aDraw = Math.max(0, ...lootBox.entries.map(e => e.prizes.reduce((n, p) => n + wonBytes(p), 0)));
+  const gives = lootBox.entries.some(e => e.prizes.some(p => p.Item || p.Compressed));
+  const rows = items
+    ? Math.max(0, ...entryRows(lootBox.entries, items))
+    : gives
+      ? Math.max(0, tableBudget(lootBox.entries))
+      : 0;
   const fates = lootBox.fates ?? [];
-  const fate = fates.reduce((a, f) => (a && encodeBorsh(IDL, { defined: { name: 'Fate' } }, a).length >= encodeBorsh(IDL, { defined: { name: 'Fate' } }, f).length ? a : f), null);
+  const fate = fates.reduce(
+    (a, f) =>
+      a &&
+      encodeBorsh(IDL, { defined: { name: 'Fate' } }, a).length >=
+        encodeBorsh(IDL, { defined: { name: 'Fate' } }, f).length
+        ? a
+        : f,
+    null,
+  );
   const empty = {
-    project: ZERO, player: ZERO, mint: ZERO, loot_box: ZERO, box_version: 0,
+    project: ZERO,
+    player: ZERO,
+    mint: ZERO,
+    loot_box: ZERO,
+    box_version: 0,
     odds_bps: new Array(lootBox.odds?.length ?? 0).fill(0),
     status: 'Waiting',
     won: [],
-    paid: 0n, fee: 0n,
+    paid: 0n,
+    fee: 0n,
     shares: new Array(shares).fill({ to: { Account: [ZERO] }, bps: 0 }),
-    opens: 0, settled: 0, undrawn: 0, back: 0n, settler: ZERO, drew: 0, answer: new Uint8Array(32), drawn: [], reserved: 0n,
-    requested_slot: 0n, asked_first: 0n, asked_at: 0n, first_asked_at: 0n, counted: 0, subject: lootBox.subject ? ZERO : null, held: false, fate,
+    opens: 0,
+    settled: 0,
+    undrawn: 0,
+    back: 0n,
+    settler: ZERO,
+    drew: 0,
+    answer: new Uint8Array(32),
+    drawn: [],
+    reserved: 0n,
+    requested_slot: 0n,
+    asked_first: 0n,
+    asked_at: 0n,
+    first_asked_at: 0n,
+    counted: 0,
+    subject: lootBox.subject ? ZERO : null,
+    held: false,
+    fate,
   };
   return encodeAccount(IDL, 'Order', empty).length + drawn * (aDraw + rows * 4);
 }
@@ -136,42 +173,105 @@ export function orderBytes(lootBox, shares = 0, opens = 1, items) {
 // answer, less a margin.
 const ROLL_BUDGET = 300_000n;
 const ROLL_HEAP = 32n * 1024n - 512n;
-const COST = { fixed: 20_000n, entry: 3_500n, blank: 1_400n, weigh: 1_000n, weighEntry: 40n, pair: 150n, item: 1_500n, tokens: 6_000n, draw: 9_000n, group: 250n, reread: 1_000n, finish: 15_000n, won: 150n, drawn: 50n, odds: 1_000n, share: 1_000n, fate: 1_000n, slot: 500n, slotEntry: 350n, openSlot: 150n };
-const BYTES = { start: 6_000n, prizeRead: 600n, entryRead: 180n, minted: 700n, pooled: 1_000n, prize: 200n, draw: 40n, finish: 2_000n, won: 120n, boxByte: 2n, gateByte: 3n, odds: 100n, fate: 60n, slot: 64n };
+const COST = {
+  fixed: 20_000n,
+  entry: 3_500n,
+  blank: 1_400n,
+  weigh: 1_000n,
+  weighEntry: 40n,
+  pair: 150n,
+  item: 1_500n,
+  tokens: 6_000n,
+  draw: 9_000n,
+  group: 250n,
+  reread: 1_000n,
+  finish: 15_000n,
+  won: 150n,
+  drawn: 50n,
+  odds: 1_000n,
+  share: 1_000n,
+  fate: 1_000n,
+  slot: 500n,
+  slotEntry: 350n,
+  openSlot: 150n,
+};
+const BYTES = {
+  start: 6_000n,
+  prizeRead: 600n,
+  entryRead: 180n,
+  minted: 700n,
+  pooled: 1_000n,
+  prize: 200n,
+  draw: 40n,
+  finish: 2_000n,
+  won: 120n,
+  boxByte: 2n,
+  gateByte: 3n,
+  odds: 100n,
+  fate: 60n,
+  slot: 64n,
+};
 
 /** The Borsh length of `value` as IDL type `type`, an address counted as 32 bytes whatever stands in for it (a spec's
  * `@mint:…` before it goes live). */
 function borshLength(type, value) {
-  if (typeof type === 'string') return type === 'string' ? 4 + new TextEncoder().encode(String(value)).length : type === 'bytes' ? 4 + value.length : scalar[type];
+  if (typeof type === 'string')
+    return type === 'string'
+      ? 4 + new TextEncoder().encode(String(value)).length
+      : type === 'bytes'
+        ? 4 + value.length
+        : scalar[type];
   if (type.array) return type.array[1] * (type.array[0] === 'u8' ? 1 : borshLength(type.array[0], value?.[0]));
   if (type.vec) return 4 + (value ?? []).reduce((n, v) => n + borshLength(type.vec, v), 0);
   if (type.option) return value == null ? 1 : 1 + borshLength(type.option, value);
-  const definition = IDL.types.find((entry) => entry.name === type.defined.name).type;
+  const definition = IDL.types.find(entry => entry.name === type.defined.name).type;
   if (definition.kind === 'enum') {
     const name = typeof value === 'string' ? value : Object.keys(value)[0];
-    const fields = definition.variants.find((v) => v.name === name)?.fields ?? [];
+    const fields = definition.variants.find(v => v.name === name)?.fields ?? [];
     const payload = typeof value === 'string' ? [] : value[name];
-    return 1 + fields.reduce((n, f, i) => n + (typeof f === 'object' && 'name' in f ? borshLength(f.type, payload[f.name]) : borshLength(f, payload[i])), 0);
+    return (
+      1 +
+      fields.reduce(
+        (n, f, i) =>
+          n +
+          (typeof f === 'object' && 'name' in f ? borshLength(f.type, payload[f.name]) : borshLength(f, payload[i])),
+        0,
+      )
+    );
   }
   return definition.fields.reduce((n, f) => n + borshLength(f.type, value[f.name]), 0);
 }
 
-const defined = (name) => ({ defined: { name } });
+const defined = name => ({ defined: { name } });
 
 /**
  * The heap reading a box takes beyond its entries (`order::box_bytes`): its odds, gate, shares, subject, slots and
  * fates, read whole with it, by their bytes and their number. `box`: the box's args, as `upsertBoxIx` takes them.
  */
 export function boxBytes({ odds = [], gate = null, shares = [], subject = null, slots = [], fates = [] }) {
-  const slotsWritten = slots.map((s) => ({ only: [], distinct: false, share: 0, ...s }));
-  const fatesWritten = fates.map((f) => ({ then: null, ...f, shifts: (f.shifts ?? []).map((x) => ({ from_now: false, ...x })) }));
-  const bytes = borshLength({ vec: defined('Odds') }, odds) + borshLength({ vec: defined('Share') }, shares) + borshLength({ option: defined('Rule') }, subject)
-    + borshLength({ vec: defined('Slot') }, slotsWritten) + borshLength({ vec: defined('Fate') }, fatesWritten);
-  return BYTES.boxByte * BigInt(bytes) + BYTES.gateByte * BigInt(borshLength({ option: defined('Gate') }, gate)) + BYTES.odds * BigInt(odds.length) + BYTES.fate * BigInt(fates.length) + BYTES.slot * BigInt(slots.length);
+  const slotsWritten = slots.map(s => ({ only: [], distinct: false, share: 0, ...s }));
+  const fatesWritten = fates.map(f => ({
+    then: null,
+    ...f,
+    shifts: (f.shifts ?? []).map(x => ({ from_now: false, ...x })),
+  }));
+  const bytes =
+    borshLength({ vec: defined('Odds') }, odds) +
+    borshLength({ vec: defined('Share') }, shares) +
+    borshLength({ option: defined('Rule') }, subject) +
+    borshLength({ vec: defined('Slot') }, slotsWritten) +
+    borshLength({ vec: defined('Fate') }, fatesWritten);
+  return (
+    BYTES.boxByte * BigInt(bytes) +
+    BYTES.gateByte * BigInt(borshLength({ option: defined('Gate') }, gate)) +
+    BYTES.odds * BigInt(odds.length) +
+    BYTES.fate * BigInt(fates.length) +
+    BYTES.slot * BigInt(slots.length)
+  );
 }
 
 /** The account a prize reads, as a string, when it reads one the box can name: entries naming the same share it. */
-const accountOf = (p) => {
+const accountOf = p => {
   if (p.Item != null) return `item ${p.Item[0] ?? p.Item}`;
   if (p.Compressed) return `item ${p.Compressed.item}`;
   if (p.Tokens?.from?.Pool) return `pool ${p.Tokens.from.Pool[0] ?? p.Tokens.from.Pool}`;
@@ -189,41 +289,80 @@ const accountOf = (p) => {
  * one open doesn't fit at its upsert, and a purchase that doesn't at `open_box`, where it also reads what the accounts
  * hold (`PackTooLarge`).
  */
-export function drawsFit(entries, slots, opens = 1, { odds = 0, shares = 0, fates = 0, bytes = 0n, oracle = false } = {}) {
+export function drawsFit(
+  entries,
+  slots,
+  opens = 1,
+  { odds = 0, shares = 0, fates = 0, bytes = 0n, oracle = false } = {},
+) {
   const list = typeof slots === 'number' || typeof slots === 'bigint' ? [{ count: slots, only: [] }] : (slots ?? []);
   const draws = list.reduce((n, s) => n + BigInt(s.count), 0n) * BigInt(opens);
   if (draws <= 1n) return true;
   const n = BigInt(entries.length);
   const weigh = COST.weigh + COST.weighEntry * n;
-  const reads = entries.map((e) => e.prizes.map(accountOf));
-  const cost = entries.map((e) => e.prizes.reduce((c, p) => {
-    if (p.Item != null || p.Compressed || p.Nft) return { set: c.set + COST.item, again: c.again + COST.reread, bytes: c.bytes + BYTES.prize };
-    if (p.Tokens) return { set: c.set + COST.tokens, again: c.again + (p.Tokens.from.Pool ? COST.reread : 0n), bytes: c.bytes + (p.Tokens.from.Pool ? BYTES.pooled : BYTES.minted) };
-    if (p.Stash != null) return { set: c.set + COST.draw + COST.group, again: c.again + COST.reread, bytes: c.bytes + BYTES.prize };
-    return { set: c.set + COST.item, again: c.again, bytes: c.bytes + BYTES.prize };
-  }, { set: 0n, again: 0n, bytes: BYTES.draw }));
-  const next = entries.map((_, i) => weigh + cost[i].set + cost.reduce((sum, c, j) => (j === i || reads[i].some((a) => a && reads[j].includes(a)) ? sum + c.again : sum), 0n));
-  const most = BigInt(Math.max(1, ...entries.map((e) => e.prizes.length)));
-  let spent = COST.fixed + COST.pair * n * n * most * most + entries.reduce((c, e) => c + (e.prizes.length ? COST.entry : COST.blank), 0n);
-  let used = BYTES.start + BigInt(bytes) + BYTES.entryRead * n + BYTES.prizeRead * BigInt(entries.reduce((c, e) => c + e.prizes.length, 0));
+  const reads = entries.map(e => e.prizes.map(accountOf));
+  const cost = entries.map(e =>
+    e.prizes.reduce(
+      (c, p) => {
+        if (p.Item != null || p.Compressed || p.Nft)
+          return { set: c.set + COST.item, again: c.again + COST.reread, bytes: c.bytes + BYTES.prize };
+        if (p.Tokens)
+          return {
+            set: c.set + COST.tokens,
+            again: c.again + (p.Tokens.from.Pool ? COST.reread : 0n),
+            bytes: c.bytes + (p.Tokens.from.Pool ? BYTES.pooled : BYTES.minted),
+          };
+        if (p.Stash != null)
+          return { set: c.set + COST.draw + COST.group, again: c.again + COST.reread, bytes: c.bytes + BYTES.prize };
+        return { set: c.set + COST.item, again: c.again, bytes: c.bytes + BYTES.prize };
+      },
+      { set: 0n, again: 0n, bytes: BYTES.draw },
+    ),
+  );
+  const next = entries.map(
+    (_, i) =>
+      weigh +
+      cost[i].set +
+      cost.reduce((sum, c, j) => (j === i || reads[i].some(a => a && reads[j].includes(a)) ? sum + c.again : sum), 0n),
+  );
+  const most = BigInt(Math.max(1, ...entries.map(e => e.prizes.length)));
+  let spent =
+    COST.fixed +
+    COST.pair * n * n * most * most +
+    entries.reduce((c, e) => c + (e.prizes.length ? COST.entry : COST.blank), 0n);
+  let used =
+    BYTES.start +
+    BigInt(bytes) +
+    BYTES.entryRead * n +
+    BYTES.prizeRead * BigInt(entries.reduce((c, e) => c + e.prizes.length, 0));
   let won = 0n;
-  spent += (COST.slot + COST.slotEntry * n) * BigInt(Math.max(1, list.length)) + COST.openSlot * BigInt(list.length) * BigInt(opens) + COST.odds * BigInt(odds) + COST.share * BigInt(shares) + COST.fate * BigInt(fates);
+  spent +=
+    (COST.slot + COST.slotEntry * n) * BigInt(Math.max(1, list.length)) +
+    COST.openSlot * BigInt(list.length) * BigInt(opens) +
+    COST.odds * BigInt(odds) +
+    COST.share * BigInt(shares) +
+    COST.fate * BigInt(fates);
   for (const s of list) {
     const count = BigInt(s.count) * BigInt(opens);
-    const among = entries.map((_, i) => i).filter((i) => !(s.only ?? []).length || (s.only ?? []).includes(i));
-    const dearest = (f) => among.reduce((m, i) => (f(i) > m ? f(i) : m), 0n);
-    spent += count * dearest((i) => next[i]);
-    used += count * dearest((i) => cost[i].bytes);
-    won += count * dearest((i) => BigInt(entries[i].prizes.length));
+    const among = entries.map((_, i) => i).filter(i => !(s.only ?? []).length || (s.only ?? []).includes(i));
+    const dearest = f => among.reduce((m, i) => (f(i) > m ? f(i) : m), 0n);
+    spent += count * dearest(i => next[i]);
+    used += count * dearest(i => cost[i].bytes);
+    won += count * dearest(i => BigInt(entries[i].prizes.length));
   }
-  const rolls = oracle || entries.length > 1 || entries.some((e) => e.prizes.some((p) => p.Stash != null));
-  return spent + COST.finish + COST.won * won + COST.drawn * draws <= ROLL_BUDGET && (!rolls || used + BYTES.finish + BYTES.won * won + draws <= ROLL_HEAP);
+  const rolls = oracle || entries.length > 1 || entries.some(e => e.prizes.some(p => p.Stash != null));
+  return (
+    spent + COST.finish + COST.won * won + COST.drawn * draws <= ROLL_BUDGET &&
+    (!rolls || used + BYTES.finish + BYTES.won * won + draws <= ROLL_HEAP)
+  );
 }
 
 // What one `buy` takes, as the program counts it at the box's write (`catalog::buy_fits`): a transaction holds 64
 // accounts, 64 instructions and 1,400,000 compute units.
 const BUY = { accounts: 15, calls: 7, cu: 30_000, most: { accounts: 64, calls: 64, cu: 1_400_000 } };
-const sameJson = (a, b) => JSON.stringify(a, (_, v) => (typeof v === 'bigint' ? String(v) : v)) === JSON.stringify(b, (_, v) => (typeof v === 'bigint' ? String(v) : v));
+const sameJson = (a, b) =>
+  JSON.stringify(a, (_, v) => (typeof v === 'bigint' ? String(v) : v)) ===
+  JSON.stringify(b, (_, v) => (typeof v === 'bigint' ? String(v) : v));
 
 /**
  * Whether one `buy` of a box that doesn't roll (one entry, given `draws` times: its slots' counts) fits one transaction
@@ -231,13 +370,14 @@ const sameJson = (a, b) => JSON.stringify(a, (_, v) => (typeof v === 'bigint' ?
  * is given once at most. A box that doesn't fit sells through the oracle (`open_box`), its answer's heap counted
  * (`drawsFit` with `oracle`), and can't give a roll (`PackTooLarge`). `box`: the box's args.
  */
-export function buyFits(box, draws = (box.slots?.length ? box.slots.reduce((n, s) => n + Number(s.count), 0) : 1)) {
+export function buyFits(box, draws = box.slots?.length ? box.slots.reduce((n, s) => n + Number(s.count), 0) : 1) {
   const entry = box.entries?.[0];
   if (!entry) return true;
   let { accounts, calls, cu } = BUY;
   for (const share of box.shares ?? []) {
     const to = typeof share.to === 'string' ? share.to : Object.keys(share.to)[0];
-    const [a, c] = to === 'Burn' ? [0, 1] : to === 'Pool' || to === 'Account' ? [1, 1] : to === 'Holder' ? [3, 6] : [2, 6];
+    const [a, c] =
+      to === 'Burn' ? [0, 1] : to === 'Pool' || to === 'Account' ? [1, 1] : to === 'Holder' ? [3, 6] : [2, 6];
     accounts += a;
     calls += c;
     cu += 30_000;
@@ -247,11 +387,16 @@ export function buyFits(box, draws = (box.slots?.length ? box.slots.reduce((n, s
   const limit = box.per_wallet ?? {};
   if (Number(limit.total ?? 0) > 0 || Number(limit.per_window ?? 0) > 0) calls += 1;
   // A collectible's collection and Metaplex Core, named once for all of them.
-  if (entry.prizes.some((p) => p.Item != null)) accounts += 2;
+  if (entry.prizes.some(p => p.Item != null)) accounts += 2;
   for (const [i, p] of entry.prizes.entries()) {
-    const first = !entry.prizes.slice(0, i).some((q) => (accountOf(q) && accountOf(q) === accountOf(p)) || sameJson(q, p));
+    const first = !entry.prizes
+      .slice(0, i)
+      .some(q => (accountOf(q) && accountOf(q) === accountOf(p)) || sameJson(q, p));
     const gives = p.Tokens ? 1 : draws;
-    let once = 0, each = 0, c = 0, units = 0;
+    let once = 0,
+      each = 0,
+      c = 0,
+      units = 0;
     if (p.Tokens) [once, c, units] = [p.Tokens.from.Pool ? 3 : 2, 5, 30_000];
     else if (p.Item != null) [once, each, c, units] = [1, 1, 4, 40_000];
     else if (p.Compressed) [once, c, units] = [9, 6, 150_000];
@@ -280,8 +425,18 @@ const PLAYER_FEE = 2_000_000n;
  * least one: a box whose one open is over the cap is still bought one open an order. A purchase of more is several
  * orders, each its own answer.
  */
-export function opensAnOrder(lootBox, { shares = (lootBox.shares ?? []).length, items = {}, rentPerByte = RENT_PER_BYTE } = {}) {
-  const fits = (n) => drawsFit(lootBox.entries, lootBox.slots?.length ? lootBox.slots : 1, n, { odds: (lootBox.odds ?? []).length, shares, fates: (lootBox.fates ?? []).length, bytes: boxBytes(lootBox), oracle: true }) && (BigInt(orderBytes(lootBox, shares, n, items)) + 128n) * rentPerByte + PLAYER_FEE <= ORDER_COST_CAP;
+export function opensAnOrder(
+  lootBox,
+  { shares = (lootBox.shares ?? []).length, items = {}, rentPerByte = RENT_PER_BYTE } = {},
+) {
+  const fits = n =>
+    drawsFit(lootBox.entries, lootBox.slots?.length ? lootBox.slots : 1, n, {
+      odds: (lootBox.odds ?? []).length,
+      shares,
+      fates: (lootBox.fates ?? []).length,
+      bytes: boxBytes(lootBox),
+      oracle: true,
+    }) && (BigInt(orderBytes(lootBox, shares, n, items)) + 128n) * rentPerByte + PLAYER_FEE <= ORDER_COST_CAP;
   let n = 1;
   while (n < 4096 && fits(n + 1)) n += 1;
   return n;

package/js/client/traits.js

@@ -5,25 +5,34 @@ import { addressBytes } from '../chain/base58.js';
 import { compareBytes, concat, uintLE, utf8 } from '../chain/bytes.js';
 import { sha256 } from '../chain/sha256.js';
 
-const text = (s) => concat(uintLE(utf8(s).length, 4), utf8(s));
+const text = s => concat(uintLE(utf8(s).length, 4), utf8(s));
 
 /** A leaf: an NFT's address and its traits ([{ key, value }], in order). */
 export const traitsLeaf = (nft, attributes) =>
-  sha256(concat(Uint8Array.of(0), addressBytes(nft), uintLE(attributes.length, 4), ...attributes.map((a) => concat(text(a.key), text(a.value)))));
+  sha256(
+    concat(
+      Uint8Array.of(0),
+      addressBytes(nft),
+      uintLE(attributes.length, 4),
+      ...attributes.map(a => concat(text(a.key), text(a.value))),
+    ),
+  );
 
 /** Two nodes joined, the smaller first, so a proof needs no left or right. */
-export const traitsNode = (a, b) => (compareBytes(a, b) <= 0 ? sha256(concat(Uint8Array.of(1), a, b)) : sha256(concat(Uint8Array.of(1), b, a)));
+export const traitsNode = (a, b) =>
+  compareBytes(a, b) <= 0 ? sha256(concat(Uint8Array.of(1), a, b)) : sha256(concat(Uint8Array.of(1), b, a));
 
 /**
  * The tree of `entries` ([{ nft, attributes }]): { root, proof(nft) → [node, …] bottom up }. A node left without a pair
  * at a level goes up as it is.
  */
 export function traitsTree(entries) {
-  const levels = [entries.map((e) => traitsLeaf(e.nft, e.attributes))];
+  const levels = [entries.map(e => traitsLeaf(e.nft, e.attributes))];
   while (levels.at(-1).length > 1) {
     const below = levels.at(-1);
     const up = [];
-    for (let i = 0; i < below.length; i += 2) up.push(i + 1 < below.length ? traitsNode(below[i], below[i + 1]) : below[i]);
+    for (let i = 0; i < below.length; i += 2)
+      up.push(i + 1 < below.length ? traitsNode(below[i], below[i + 1]) : below[i]);
     levels.push(up);
   }
   const at = new Map(entries.map((e, i) => [e.nft, i]));