@xgamesfun/solana 0.20.1 → 0.25.0

package/js/chain/base58.js

@@ -30,7 +30,13 @@ export function encodeBase58(bytes) {
     if (byte !== 0) break;
     zeros += '1';
   }
-  return zeros + digits.reverse().map((d) => ALPHABET[d]).join('');
+  return (
+    zeros +
+    digits
+      .reverse()
+      .map(d => ALPHABET[d])
+      .join('')
+  );
 }
 
 export function decodeBase58(text) {

package/js/chain/borsh.js

@@ -14,7 +14,7 @@ const INT = { i32: 4, i64: 8 };
 const ADDRESS_BYTES = 32;
 
 function typeDef(idl, name) {
-  const def = idl.types.find((t) => t.name === name);
+  const def = idl.types.find(t => t.name === name);
   if (!def) throw new Error(`Unknown IDL type ${name}`);
   return def;
 }
@@ -35,17 +35,21 @@ function encodeScalar(type, value, out) {
   else if (type === 'string') {
     const bytes = utf8(String(value));
     out.push(uintLE(bytes.length, 4), bytes);
+  } else if (type === 'bytes') {
+    // A list of bytes (`Vec<u8>`): its length, then the bytes.
+    const bytes = Uint8Array.from(value);
+    out.push(uintLE(bytes.length, 4), bytes);
   } else throw new Error(`Unsupported IDL type ${type}`);
 }
 
 /** A variant's field list: named ({ name, type }) or tuple (bare types). */
-const isNamed = (fields) => typeof fields[0] === 'object' && fields[0] !== null && 'name' in fields[0];
+const isNamed = fields => typeof fields[0] === 'object' && fields[0] !== null && 'name' in fields[0];
 
 function encodeDefined(idl, name, value, out) {
   const def = typeDef(idl, name).type;
   if (def.kind === 'enum') {
     const variantName = typeof value === 'string' ? value : Object.keys(value ?? {})[0];
-    const index = def.variants.findIndex((v) => v.name === variantName);
+    const index = def.variants.findIndex(v => v.name === variantName);
     if (index < 0) throw new Error(`${name} has no variant ${String(variantName)}`);
     out.push(Uint8Array.of(index));
     const fields = def.variants[index].fields ?? [];
@@ -67,7 +71,9 @@ function encodeDefined(idl, name, value, out) {
  * a number past a byte) is refused rather than written as other bytes.
  */
 function byteArray(value, length) {
-  const bytes = value instanceof Uint8Array || (Array.isArray(value) && value.every((b) => Number.isInteger(b) && b >= 0 && b <= 255));
+  const bytes =
+    value instanceof Uint8Array ||
+    (Array.isArray(value) && value.every(b => Number.isInteger(b) && b >= 0 && b <= 255));
   if (!bytes) throw new TypeError(`Expected ${length} bytes: a Uint8Array or an array of integers from 0 to 255`);
   if (value.length !== length) throw new Error(`Expected ${length} bytes, got ${value.length}`);
   return Uint8Array.from(value);
@@ -110,7 +116,7 @@ export function encodeBorsh(idl, type, value) {
 
 /** An instruction's data: its discriminator, then each argument in IDL order. */
 export function encodeInstruction(idl, name, args) {
-  const ix = idl.instructions.find((i) => i.name === name);
+  const ix = idl.instructions.find(i => i.name === name);
   if (!ix) throw new Error(`Unknown instruction ${name}`);
   const out = [Uint8Array.from(ix.discriminator)];
   for (const arg of ix.args) {
@@ -122,7 +128,7 @@ export function encodeInstruction(idl, name, args) {
 
 /** An account's bytes as the program writes them: its discriminator, then its fields. */
 export function encodeAccount(idl, name, value) {
-  const account = idl.accounts.find((a) => a.name === name);
+  const account = idl.accounts.find(a => a.name === name);
   if (!account) throw new Error(`Unknown account type ${name}`);
   return concat(Uint8Array.from(account.discriminator), encodeBorsh(idl, { defined: { name } }, value));
 }
@@ -146,6 +152,11 @@ function decodeScalar(type, data, at) {
     if (at + 4 + length > data.length) throw new RangeError('string runs past the end of the data');
     return [fromUtf8(data.subarray(at + 4, at + 4 + length)), at + 4 + length];
   }
+  if (type === 'bytes') {
+    const length = Number(readUintLE(data, at, 4));
+    if (at + 4 + length > data.length) throw new RangeError('bytes run past the end of the data');
+    return [data.slice(at + 4, at + 4 + length), at + 4 + length];
+  }
   throw new Error(`Unsupported IDL type ${type}`);
 }
 
@@ -209,11 +220,12 @@ function decodeAt(idl, type, data, at) {
 /** One value of `type` at `offset`: [value, next offset]. */
 export const decodeBorsh = (idl, type, data, offset = 0) => decodeAt(idl, type, data, offset);
 
-const startsWith = (data, prefix) => data.length >= prefix.length && equalBytes(data.subarray(0, prefix.length), Uint8Array.from(prefix));
+const startsWith = (data, prefix) =>
+  data.length >= prefix.length && equalBytes(data.subarray(0, prefix.length), Uint8Array.from(prefix));
 
 /** An account of the named type, after checking its discriminator. Bytes after the fields are left alone. */
 export function decodeAccount(idl, name, data) {
-  const account = idl.accounts.find((a) => a.name === name);
+  const account = idl.accounts.find(a => a.name === name);
   if (!account) throw new Error(`Unknown account type ${name}`);
   if (!startsWith(data, account.discriminator)) throw new Error(`Not a ${name} account`);
   return decodeDefined(idl, name, data, account.discriminator.length)[0];
@@ -221,7 +233,7 @@ export function decodeAccount(idl, name, data) {
 
 /** Whether the data starts with the named account's discriminator. */
 export function isAccount(idl, name, data) {
-  const account = idl.accounts.find((a) => a.name === name);
+  const account = idl.accounts.find(a => a.name === name);
   return Boolean(account) && startsWith(data, account.discriminator);
 }
 
@@ -254,8 +266,9 @@ export function decodeEvents(idl, logs) {
     } catch {
       continue;
     }
-    const event = (idl.events ?? []).find((e) => startsWith(bytes, e.discriminator));
-    if (event) out.push({ name: event.name, data: decodeDefined(idl, event.name, bytes, event.discriminator.length)[0] });
+    const event = (idl.events ?? []).find(e => startsWith(bytes, e.discriminator));
+    if (event)
+      out.push({ name: event.name, data: decodeDefined(idl, event.name, bytes, event.discriminator.length)[0] });
   }
   return out;
 }

package/js/chain/bytes.js

@@ -7,10 +7,10 @@ const decoder = new TextDecoder();
 const BASE64_CHUNK = 0x8000;
 
 /** UTF-8 bytes of a string. */
-export const utf8 = (text) => encoder.encode(text);
+export const utf8 = text => encoder.encode(text);
 
 /** A string from UTF-8 bytes. */
-export const fromUtf8 = (bytes) => decoder.decode(bytes);
+export const fromUtf8 = bytes => decoder.decode(bytes);
 
 /** The parts, one after another. */
 export function concat(...parts) {
@@ -39,17 +39,18 @@ export function equalBytes(a, b) {
 
 export function toBase64(bytes) {
   let text = '';
-  for (let i = 0; i < bytes.length; i += BASE64_CHUNK) text += String.fromCharCode(...bytes.subarray(i, i + BASE64_CHUNK));
+  for (let i = 0; i < bytes.length; i += BASE64_CHUNK)
+    text += String.fromCharCode(...bytes.subarray(i, i + BASE64_CHUNK));
   return btoa(text);
 }
 
 /** Standard base64 to bytes; throws on anything that is not base64. */
 export function fromBase64(text) {
   if (typeof text !== 'string' || !/^[A-Za-z0-9+/]*={0,2}$/.test(text)) throw new Error('Not base64');
-  return Uint8Array.from(atob(text), (c) => c.charCodeAt(0));
+  return Uint8Array.from(atob(text), c => c.charCodeAt(0));
 }
 
-export const toHex = (bytes) => Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
+export const toHex = bytes => Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
 
 export function fromHex(text) {
   if (typeof text !== 'string' || text.length % 2 || /[^0-9a-f]/i.test(text)) throw new Error('Not hex');
@@ -81,7 +82,8 @@ export function uintLE(value, size) {
 export function intLE(value, size) {
   const v = toBigInt(value);
   const bits = BigInt(size * 8);
-  if (v < -(1n << (bits - 1n)) || v >= 1n << (bits - 1n)) throw new RangeError(`${value} does not fit in a signed ${size}-byte integer`);
+  if (v < -(1n << (bits - 1n)) || v >= 1n << (bits - 1n))
+    throw new RangeError(`${value} does not fit in a signed ${size}-byte integer`);
   return uintLE(v < 0n ? v + (1n << bits) : v, size);
 }
 
@@ -90,7 +92,8 @@ export function intLE(value, size) {
  * lost its low digits, so it is refused rather than turned into some other value.
  */
 export function toBigInt(value) {
-  if (typeof value === 'number' && !Number.isSafeInteger(value)) throw new RangeError(`${value} is not a safe integer: pass it as a bigint`);
+  if (typeof value === 'number' && !Number.isSafeInteger(value))
+    throw new RangeError(`${value} is not a safe integer: pass it as a bigint`);
   return BigInt(value);
 }
 
@@ -138,4 +141,4 @@ export function readCompactU16(bytes, offset) {
 }
 
 /** Random bytes from the platform's CSPRNG (WebCrypto in browsers and Node 24). */
-export const randomBytes = (n) => globalThis.crypto.getRandomValues(new Uint8Array(n));
+export const randomBytes = n => globalThis.crypto.getRandomValues(new Uint8Array(n));

package/js/chain/core.js

@@ -9,14 +9,21 @@ import { meta } from './programs.js';
 export { MPL_CORE_PROGRAM };
 /** MPL Core `CreateCollectionV2`. */
 const CREATE_COLLECTION_V2 = 21;
-const PLUGIN = { Royalties: 0, FreezeDelegate: 1, UpdateDelegate: 4, PermanentFreezeDelegate: 5, Attributes: 6, BubblegumV2: 15 };
+const PLUGIN = {
+  Royalties: 0,
+  FreezeDelegate: 1,
+  UpdateDelegate: 4,
+  PermanentFreezeDelegate: 5,
+  Attributes: 6,
+  BubblegumV2: 15,
+};
 const ASSET_V1 = 1;
 const COLLECTION_V1 = 5;
 const PLUGIN_HEADER = 3;
 const UPDATE_AUTHORITY_COLLECTION = 2;
 
 /** A Borsh string as Core writes it. */
-const coreString = (text) => {
+const coreString = text => {
   const bytes = utf8(text);
   return concat(uintLE(bytes.length, 4), bytes);
 };
@@ -27,8 +34,17 @@ const coreString = (text) => {
  * it also carries Bubblegum's plugin, so compressed NFTs can be minted into it. The collection address signs too (a
  * fresh key).
  */
-export function createCollectionInstruction({ collection, creator, name, uri, royaltyBps = 500, project, compressed = false }) {
-  if (!project) throw new Error('createCollectionInstruction needs the loot project that mints into the collection (`project`).');
+export function createCollectionInstruction({
+  collection,
+  creator,
+  name,
+  uri,
+  royaltyBps = 500,
+  project,
+  compressed = false,
+}) {
+  if (!project)
+    throw new Error('createCollectionInstruction needs the loot project that mints into the collection (`project`).');
   const data = concat(
     Uint8Array.of(CREATE_COLLECTION_V2),
     coreString(name),
@@ -64,7 +80,7 @@ export function createCollectionInstruction({ collection, creator, name, uri, ro
 
 function reader(data, start) {
   let at = start;
-  const need = (n) => {
+  const need = n => {
     if (at + n > data.length) throw new RangeError('read past the end of the account');
   };
   return {
@@ -150,14 +166,26 @@ export function parseCoreAsset(data) {
   return asset;
 }
 
-/** Decode the start of a Core CollectionV1: { updateAuthority, name, uri, numMinted, currentSize }. */
+/** Decode the start of a Core CollectionV1: { updateAuthority, name, uri, numMinted, currentSize, bubblegum (whether it
+ * carries Bubblegum's plugin, BubblegumV2: compressed NFTs can be minted into it) }. */
 export function parseCoreCollection(data) {
   if (data[0] !== COLLECTION_V1) throw new Error('Not a Core collection');
   const r = reader(data, 1);
   const updateAuthority = r.address();
   const name = r.text();
   const uri = r.text();
-  return { updateAuthority, name, uri, numMinted: r.u32(), currentSize: r.u32() };
+  const out = { updateAuthority, name, uri, numMinted: r.u32(), currentSize: r.u32(), bubblegum: false };
+  if (r.at >= data.length || data[r.at] !== PLUGIN_HEADER) return out;
+  r.skip(1);
+  const registry = reader(data, Number(r.u64()) + 1);
+  const plugins = registry.u32();
+  for (let i = 0; i < plugins; i++) {
+    const type = registry.byte();
+    if (registry.byte() === 3) registry.skip(32);
+    registry.u64();
+    if (type === PLUGIN.BubblegumV2) out.bubblegum = true;
+  }
+  return out;
 }
 
 /** getProgramAccounts filters for Core assets owned by `owner` in `collection` (no indexer needed). */

package/js/chain/curve.js

@@ -9,7 +9,7 @@ const P = 2n ** 255n - 19n;
 const D = 37095705934669439343138083508754565189542113879843219016388785533085940283555n;
 const Y_MASK = (1n << 255n) - 1n;
 
-const mod = (a) => {
+const mod = a => {
   const r = a % P;
   return r >= 0n ? r : r + P;
 };

package/js/chain/lookup.js

@@ -26,38 +26,65 @@ const meta = (pubkey, isSigner, isWritable) => ({ pubkey, isSigner, isWritable }
 const ix = (keys, data) => ({ programId: LOOKUP_TABLE_PROGRAM, keys, data });
 
 /** The table `authority` makes at `slot` (a recent slot: the table's address names it): [address, bump]. */
-export const tableAddress = (authority, slot) => findProgramAddress([addressBytes(authority), uintLE(slot, 8)], LOOKUP_TABLE_PROGRAM);
+export const tableAddress = (authority, slot) =>
+  findProgramAddress([addressBytes(authority), uintLE(slot, 8)], LOOKUP_TABLE_PROGRAM);
 
 /** Makes the table `authority` owns at `slot`, its rent paid by `payer`. Returns { address, instruction }. */
 export function createTableIx({ authority, payer = authority, slot }) {
   const [address, bump] = tableAddress(authority, slot);
-  const instruction = ix([meta(address, false, true), meta(authority, true, false), meta(payer, true, true), meta(SYSTEM_PROGRAM, false, false)], concat(uintLE(0, 4), uintLE(slot, 8), Uint8Array.of(bump)));
+  const instruction = ix(
+    [
+      meta(address, false, true),
+      meta(authority, true, false),
+      meta(payer, true, true),
+      meta(SYSTEM_PROGRAM, false, false),
+    ],
+    concat(uintLE(0, 4), uintLE(slot, 8), Uint8Array.of(bump)),
+  );
   return { address, instruction };
 }
 
 /** Adds `addresses` to `table`, the rent of its growth paid by `payer`. */
 export const extendTableIx = ({ table, authority, payer = authority, addresses }) =>
-  ix([meta(table, false, true), meta(authority, true, false), meta(payer, true, true), meta(SYSTEM_PROGRAM, false, false)], concat(uintLE(2, 4), uintLE(addresses.length, 8), ...addresses.map(addressBytes)));
+  ix(
+    [
+      meta(table, false, true),
+      meta(authority, true, false),
+      meta(payer, true, true),
+      meta(SYSTEM_PROGRAM, false, false),
+    ],
+    concat(uintLE(2, 4), uintLE(addresses.length, 8), ...addresses.map(addressBytes)),
+  );
 
 /** Freezes `table`: nobody can add to it or close it after. */
-export const freezeTableIx = ({ table, authority }) => ix([meta(table, false, true), meta(authority, true, false)], uintLE(1, 4));
+export const freezeTableIx = ({ table, authority }) =>
+  ix([meta(table, false, true), meta(authority, true, false)], uintLE(1, 4));
 
 /** Deactivates `table`: transactions can still use it until it cools down, then it can be closed. */
-export const deactivateTableIx = ({ table, authority }) => ix([meta(table, false, true), meta(authority, true, false)], uintLE(3, 4));
+export const deactivateTableIx = ({ table, authority }) =>
+  ix([meta(table, false, true), meta(authority, true, false)], uintLE(3, 4));
 
 /** Closes a cooled-down `table`: its rent goes to `recipient`. */
-export const closeTableIx = ({ table, authority, recipient = authority }) => ix([meta(table, false, true), meta(authority, true, false), meta(recipient, false, true)], uintLE(4, 4));
+export const closeTableIx = ({ table, authority, recipient = authority }) =>
+  ix([meta(table, false, true), meta(authority, true, false), meta(recipient, false, true)], uintLE(4, 4));
 
 /**
  * A table's account read back: { authority (null once frozen), deactivationSlot (null while active),
  * lastExtendedSlot, addresses }, or null when `account` is not a lookup table.
  */
 export function readTable(account) {
-  if (!account || account.owner !== LOOKUP_TABLE_PROGRAM || account.data.length < TABLE_HEADER_BYTES || readUintLE(account.data, 0, 4) !== 1n) return null;
+  if (
+    !account ||
+    account.owner !== LOOKUP_TABLE_PROGRAM ||
+    account.data.length < TABLE_HEADER_BYTES ||
+    readUintLE(account.data, 0, 4) !== 1n
+  )
+    return null;
   const data = account.data;
   const deactivation = readUintLE(data, 4, 8);
   const addresses = [];
-  for (let at = TABLE_HEADER_BYTES; at + 32 <= data.length; at += 32) addresses.push(encodeBase58(data.subarray(at, at + 32)));
+  for (let at = TABLE_HEADER_BYTES; at + 32 <= data.length; at += 32)
+    addresses.push(encodeBase58(data.subarray(at, at + 32)));
   return {
     authority: data[21] === 1 ? encodeBase58(data.subarray(22, 54)) : null,
     deactivationSlot: deactivation === ACTIVE ? null : deactivation,
@@ -67,7 +94,7 @@ export function readTable(account) {
 }
 
 /** The filter that finds the tables `authority` owns (getProgramAccounts on LOOKUP_TABLE_PROGRAM). */
-export const tablesOf = (authority) => [{ memcmp: { offset: 22, bytes: authority } }];
+export const tablesOf = authority => [{ memcmp: { offset: 22, bytes: authority } }];
 
 /**
  * The slots the SlotHashes sysvar holds (its account's data: a count, then a slot and a hash each), newest first. It
@@ -95,7 +122,8 @@ export const SLOT_HASHES_HELD = 512;
 export function tableStep(table, slot, recent = null) {
   if (table.deactivationSlot === null) return 'active';
   if (BigInt(slot) <= table.deactivationSlot) return 'cooling';
-  if (recent) return recent.length >= SLOT_HASHES_HELD && recent.every((s) => s > table.deactivationSlot) ? 'close' : 'cooling';
+  if (recent)
+    return recent.length >= SLOT_HASHES_HELD && recent.every(s => s > table.deactivationSlot) ? 'close' : 'cooling';
   return BigInt(slot) > table.deactivationSlot + TABLE_COOLDOWN_SLOTS ? 'close' : 'cooling';
 }
 
@@ -105,17 +133,21 @@ export function tableStep(table, slot, recent = null) {
  * (`asV0`).
  */
 export function transactionLocks(payer, instructions, { asV0 = false } = {}) {
-  return new Set([payer, ...instructions.flatMap((i) => [i.programId, ...i.keys.map((k) => k.pubkey)])]).size + (asV0 ? 2 : 0);
+  return (
+    new Set([payer, ...instructions.flatMap(i => [i.programId, ...i.keys.map(k => k.pubkey)])]).size + (asV0 ? 2 : 0)
+  );
 }
 
 /** The accounts of `instructions` a table can hold: every one that is neither a signer nor a program they call, once. */
 export function tableAccounts(instructions) {
-  const signers = new Set(instructions.flatMap((i) => i.keys.filter((k) => k.isSigner).map((k) => k.pubkey)));
-  const programs = new Set(instructions.map((i) => i.programId));
-  return [...new Set(instructions.flatMap((i) => i.keys.map((k) => k.pubkey)))].filter((a) => !signers.has(a) && !programs.has(a));
+  const signers = new Set(instructions.flatMap(i => i.keys.filter(k => k.isSigner).map(k => k.pubkey)));
+  const programs = new Set(instructions.map(i => i.programId));
+  return [...new Set(instructions.flatMap(i => i.keys.map(k => k.pubkey)))].filter(
+    a => !signers.has(a) && !programs.has(a),
+  );
 }
 
-const sizeOf = (input) => {
+const sizeOf = input => {
   try {
     return transactionSize(compileMessage(input));
   } catch {
@@ -151,14 +183,23 @@ export function planTable({ payer, blockhash, slot, instructions, first = [] })
   const final = [...instructions, deactivateTableIx({ table: address, authority: payer })];
   // A transaction locks at most 64 accounts, its programs and those it loads from a table included.
   if (transactionLocks(payer, final) > MAX_ACCOUNT_LOCKS) return null;
-  if (sizeOf({ payer, blockhash, instructions: final, version: 0, lookupTables: [table] }) > MAX_TRANSACTION_BYTES) return null;
+  if (sizeOf({ payer, blockhash, instructions: final, version: 0, lookupTables: [table] }) > MAX_TRANSACTION_BYTES)
+    return null;
   const steps = [];
   let step = [create];
   let left = addresses;
   while (left.length) {
     // As many addresses as fit this step's transaction.
     let n = left.length;
-    while (n > 0 && sizeOf({ payer, blockhash, instructions: [...step, extendTableIx({ table: address, authority: payer, addresses: left.slice(0, n) })] }) > MAX_TRANSACTION_BYTES) n--;
+    while (
+      n > 0 &&
+      sizeOf({
+        payer,
+        blockhash,
+        instructions: [...step, extendTableIx({ table: address, authority: payer, addresses: left.slice(0, n) })],
+      }) > MAX_TRANSACTION_BYTES
+    )
+      n--;
     if (n === 0) {
       // Not one address fits beside the table's creation: the creation goes alone. Not one fits a transaction of its
       // own: no table can be made for this payer.
@@ -187,17 +228,23 @@ export function planTable({ payer, blockhash, slot, instructions, first = [] })
  * null when nothing fits: more accounts than a transaction locks, or instructions too long even as v0.
  */
 export function sendPlan({ payer, blockhash = SYSTEM_PROGRAM, instructions, alone = () => false }) {
-  if (compileFitting({ payer, blockhash, instructions })) return { legacy: true, first: [], budget: [], rest: instructions, table: false };
-  if (planTable({ payer, blockhash, slot: 0n, instructions })) return { legacy: false, first: [], budget: [], rest: instructions, table: true };
-  const budget = instructions.filter((i) => i.programId === COMPUTE_BUDGET_PROGRAM);
-  const first = instructions.filter((i) => alone(i));
-  const rest = instructions.filter((i) => !alone(i));
-  if (!first.length || first.some((i) => !compileFitting({ payer, blockhash, instructions: [...budget, i] }))) return null;
-  if (compileFitting({ payer, blockhash, instructions: rest })) return { legacy: false, first, budget, rest, table: false };
-  return planTable({ payer, blockhash, slot: 0n, instructions: rest }) ? { legacy: false, first, budget, rest, table: true } : null;
+  if (compileFitting({ payer, blockhash, instructions }))
+    return { legacy: true, first: [], budget: [], rest: instructions, table: false };
+  if (planTable({ payer, blockhash, slot: 0n, instructions }))
+    return { legacy: false, first: [], budget: [], rest: instructions, table: true };
+  const budget = instructions.filter(i => i.programId === COMPUTE_BUDGET_PROGRAM);
+  const first = instructions.filter(i => alone(i));
+  const rest = instructions.filter(i => !alone(i));
+  if (!first.length || first.some(i => !compileFitting({ payer, blockhash, instructions: [...budget, i] })))
+    return null;
+  if (compileFitting({ payer, blockhash, instructions: rest }))
+    return { legacy: false, first, budget, rest, table: false };
+  return planTable({ payer, blockhash, slot: 0n, instructions: rest })
+    ? { legacy: false, first, budget, rest, table: true }
+    : null;
 }
 
-const pause = (ms) => new Promise((r) => setTimeout(r, ms));
+const pause = ms => new Promise(r => setTimeout(r, ms));
 /** The tables this page made, by address: two sends never name the same one, even in one slot. */
 const madeHere = new Set();
 
@@ -222,25 +269,54 @@ async function freshSlot(rpc, payer) {
  * first (`planTable`); else the table first, then each compressed NFT's prove_leaf alone, then the rest as v0 (or the
  * proofs then a legacy rest, when that fits with no table). The v0 transaction is compiled against the table as the
  * chain holds it. `sign(message)` → the signed wire transaction. `rpc`: the client's (latestBlockhash, send, confirm,
- * account, call('getSlot')). `table: false` sends no lookup table (a throwaway key holds no rent for one); `first`:
+ * account, call('getSlot')). `standing`: tables already made ([{ address, addresses }], a project's, active), tried
+ * first: one v0 transaction with them when they hold enough. `table: false` sends no lookup table of its own (a throwaway
+ * key holds no rent for one); `first`:
  * addresses a table holds first (`planTable`). Throws a
  * plain sentence when it can't be sent. Returns { signature (the last transaction's), table (its address, or null),
  * steps (the signatures of the transactions before it) }.
  */
-export async function sendFitting({ rpc, payer, instructions, sign, table = true, alone = () => false, first = [], sleep = pause }) {
-  const sendOne = async (build) => {
+export async function sendFitting({
+  rpc,
+  payer,
+  instructions,
+  sign,
+  table = true,
+  alone = () => false,
+  first = [],
+  standing = [],
+  sleep = pause,
+}) {
+  const sendOne = async build => {
     const { blockhash, lastValidBlockHeight } = await rpc.latestBlockhash();
     const message = build(blockhash);
     const signature = await rpc.send(await sign(message));
     await rpc.confirm?.(signature, { lastValidBlockHeight });
     return signature;
   };
-  const plain = (list) => sendOne((bh) => compileMessage({ payer, blockhash: bh, instructions: list }));
+  const plain = list => sendOne(bh => compileMessage({ payer, blockhash: bh, instructions: list }));
   const { blockhash } = await rpc.latestBlockhash();
   const plan = sendPlan({ payer, blockhash, instructions, alone });
-  if (!plan) throw new Error(`This transaction is too large to send even as a v0 one with a lookup table: it names ${tableAccounts(instructions).length + 1} accounts or more (a transaction locks at most 64), or its instructions are too long.`);
+  if (!plan)
+    throw new Error(
+      `This transaction is too large to send even as a v0 one with a lookup table: it names ${tableAccounts(instructions).length + 1} accounts or more (a transaction locks at most 64), or its instructions are too long.`,
+    );
   if (plan.legacy) return { signature: await plain(instructions), table: null, steps: [] };
-  if (plan.table && !table) throw new Error(`This transaction takes ${sizeOf({ payer, blockhash, instructions })} bytes, more than the ${MAX_TRANSACTION_BYTES} a legacy one holds, and this key holds no rent for a lookup table.`);
+  // Standing tables (a project's, made at go-live; each still active) that hold enough of its accounts: one v0
+  // transaction with them, and no table of its own.
+  const fits = standing.length && compileFitting({ payer, blockhash, instructions, tables: standing });
+  if (fits && fits[0] === 0x80)
+    return {
+      signature: await sendOne(bh =>
+        compileMessage({ payer, blockhash: bh, instructions, version: 0, lookupTables: standing }),
+      ),
+      table: null,
+      steps: [],
+    };
+  if (plan.table && !table)
+    throw new Error(
+      `This transaction takes ${sizeOf({ payer, blockhash, instructions })} bytes, more than the ${MAX_TRANSACTION_BYTES} a legacy one holds, and this key holds no rent for a lookup table.`,
+    );
   const steps = [];
   const proofs = async () => {
     for (const ix of plan.first) steps.push(await plain([...plan.budget, ix]));
@@ -258,16 +334,28 @@ export async function sendFitting({ rpc, payer, instructions, sign, table = true
   let usable = false;
   for (let i = 0; i < 40 && !usable; i++) {
     held = readTable(await rpc.account(made.table.address));
-    usable = Boolean(held && made.table.addresses.every((a) => held.addresses.includes(a)) && BigInt(await rpc.call('getSlot', [{ commitment: 'confirmed' }])) > held.lastExtendedSlot);
+    usable = Boolean(
+      held &&
+      made.table.addresses.every(a => held.addresses.includes(a)) &&
+      BigInt(await rpc.call('getSlot', [{ commitment: 'confirmed' }])) > held.lastExtendedSlot,
+    );
     if (!usable) await sleep(400);
   }
-  if (!held || !made.table.addresses.every((a) => held.addresses.includes(a))) throw new Error(`The lookup table ${made.table.address} doesn't hold this transaction's accounts yet: try again in a moment.`);
+  if (!held || !made.table.addresses.every(a => held.addresses.includes(a)))
+    throw new Error(
+      `The lookup table ${made.table.address} doesn't hold this transaction's accounts yet: try again in a moment.`,
+    );
   // Sent before the slot passes the table's last addition, the transaction would be refused for addresses it can't load.
-  if (!usable) throw new Error(`The lookup table ${made.table.address} is made, but the network has not moved past the slot it was last added to: try again in a moment.`);
+  if (!usable)
+    throw new Error(
+      `The lookup table ${made.table.address} is made, but the network has not moved past the slot it was last added to: try again in a moment.`,
+    );
   await proofs();
   const tables = [{ address: made.table.address, addresses: held.addresses }];
   const message = compileFitting({ payer, blockhash, instructions: made.final, tables });
   if (!message || message[0] !== 0x80) throw new Error('This transaction doesn’t fit even with its lookup table.');
-  const signature = await sendOne((bh) => compileMessage({ payer, blockhash: bh, instructions: made.final, version: 0, lookupTables: tables }));
+  const signature = await sendOne(bh =>
+    compileMessage({ payer, blockhash: bh, instructions: made.final, version: 0, lookupTables: tables }),
+  );
   return { signature, table: made.table.address, steps };
 }

package/js/chain/mint.js

@@ -20,7 +20,9 @@ function option(data, at) {
 function paddedString(data, at) {
   const length = Number(readUintLE(data, at, 4));
   if (at + 4 + length > data.length) throw new RangeError('string past the end');
-  const value = fromUtf8(data.subarray(at + 4, at + 4 + length)).replaceAll('\0', '').trim();
+  const value = fromUtf8(data.subarray(at + 4, at + 4 + length))
+    .replaceAll('\0', '')
+    .trim();
   return { value, next: at + 4 + length };
 }
 
@@ -62,7 +64,9 @@ function token2022Metadata(data) {
 export function parseMint(address, owner, data, metadataData = null) {
   const program = owner === TOKEN_PROGRAM ? 'spl-token' : owner === TOKEN_2022_PROGRAM ? 'token-2022' : null;
   if (!program) return null;
-  const mintLayout = data.length === MINT_BYTES || (program === 'token-2022' && data.length > ACCOUNT_TYPE_OFFSET && data[ACCOUNT_TYPE_OFFSET] === ACCOUNT_TYPE_MINT);
+  const mintLayout =
+    data.length === MINT_BYTES ||
+    (program === 'token-2022' && data.length > ACCOUNT_TYPE_OFFSET && data[ACCOUNT_TYPE_OFFSET] === ACCOUNT_TYPE_MINT);
   if (!mintLayout || data[45] !== 1) return null;
   let meta = null;
   if (metadataData) {

package/js/chain/pda.js

@@ -24,7 +24,7 @@ const MAX_SEEDS = 16;
 
 /** The address for these seeds (bump included), or null when it lands on the curve (not a valid PDA). */
 export function createProgramAddress(seeds, programId) {
-  if (seeds.length > MAX_SEEDS || seeds.some((s) => s.length > MAX_SEED_BYTES)) throw new Error('Invalid PDA seeds');
+  if (seeds.length > MAX_SEEDS || seeds.some(s => s.length > MAX_SEED_BYTES)) throw new Error('Invalid PDA seeds');
   const hash = sha256(concat(...seeds, addressBytes(programId), MARKER));
   return isOnCurve(hash) ? null : encodeBase58(hash);
 }
@@ -34,7 +34,7 @@ const found = new Map();
 
 /** The canonical PDA and its bump: the highest bump whose address is off the curve. */
 export function findProgramAddress(seeds, programId) {
-  const key = `${programId}:${seeds.map((s) => Array.from(s).join(',')).join('|')}`;
+  const key = `${programId}:${seeds.map(s => Array.from(s).join(',')).join('|')}`;
   if (found.has(key)) return found.get(key);
   for (let bump = 255; bump >= 0; bump--) {
     const address = createProgramAddress([...seeds, Uint8Array.of(bump)], programId);

package/js/chain/programs.js

@@ -35,19 +35,19 @@ export function transferLamports(from, to, lamports) {
 }
 
 /** Compute Budget `RequestHeapFrame`: the transaction's programs get a heap of `bytes` (a multiple of 1 KiB, 32 KiB to 256 KiB). */
-export const requestHeapFrame = (bytes) => ({
+export const requestHeapFrame = bytes => ({
   programId: COMPUTE_BUDGET_PROGRAM,
   keys: [],
   data: concat(Uint8Array.of(REQUEST_HEAP_FRAME), uintLE(bytes, 4)),
 });
 
-export const computeUnitLimit = (units) => ({
+export const computeUnitLimit = units => ({
   programId: COMPUTE_BUDGET_PROGRAM,
   keys: [],
   data: concat(Uint8Array.of(SET_COMPUTE_UNIT_LIMIT), uintLE(units, 4)),
 });
 
-export const computeUnitPrice = (microLamports) => ({
+export const computeUnitPrice = microLamports => ({
   programId: COMPUTE_BUDGET_PROGRAM,
   keys: [],
   data: concat(Uint8Array.of(SET_COMPUTE_UNIT_PRICE), uintLE(microLamports, 8)),
@@ -69,7 +69,7 @@ export function createAssociatedTokenAccountIdempotent(payer, owner, mint, token
   };
 }
 
-export const syncNative = (account) => ({
+export const syncNative = account => ({
   programId: TOKEN_PROGRAM,
   keys: [meta(account, false, true)],
   data: Uint8Array.of(TOKEN_SYNC_NATIVE),
@@ -89,8 +89,8 @@ export const closeTokenAccount = (account, destination, owner) => ({
 export function withSolWrap(player, mint, price, instructions) {
   if (mint !== NATIVE_MINT) return instructions;
   const wrapped = associatedTokenAddress(player, NATIVE_MINT);
-  const budget = instructions.filter((ix) => ix.programId === COMPUTE_BUDGET_PROGRAM);
-  const rest = instructions.filter((ix) => ix.programId !== COMPUTE_BUDGET_PROGRAM);
+  const budget = instructions.filter(ix => ix.programId === COMPUTE_BUDGET_PROGRAM);
+  const rest = instructions.filter(ix => ix.programId !== COMPUTE_BUDGET_PROGRAM);
   return [
     ...budget,
     createAssociatedTokenAccountIdempotent(player, player, NATIVE_MINT),