@xgamesfun/solana 0.20.1 → 0.25.0

package/js/chain/rpc.js

@@ -29,7 +29,7 @@ export class RpcError extends Error {
   }
 }
 
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
 
 /** The first block of each public Solana cluster: it names the cluster whatever URL reaches it. */
 export const GENESIS = Object.freeze({
@@ -38,7 +38,8 @@ export const GENESIS = Object.freeze({
   testnet: '4uhcVJyU9pJkvQyS88uRDiswHXSCkY3zQawwpjk2NsNY',
 });
 
-const DEVNET_ONLY = 'loot runs on devnet only: mainnet waits for an audit. Unset XSOLANA_RPC_URL, or point it at a devnet RPC.';
+const DEVNET_ONLY =
+  'loot runs on devnet only: mainnet waits for an audit. Unset XSOLANA_RPC_URL, or point it at a devnet RPC.';
 
 /** Refuses an RPC URL that names mainnet. Returns the URL. */
 export function notMainnet(url) {
@@ -56,16 +57,18 @@ export async function checkCluster(rpc) {
   if (genesis === GENESIS.testnet) throw new RpcError(`${rpc.url ?? 'This RPC'} is on testnet. ${DEVNET_ONLY}`);
   return genesis;
 }
-const decodeAccount = (raw) =>
+const decodeAccount = raw =>
   raw ? { owner: raw.owner, lamports: raw.lamports, data: fromBase64(raw.data[0]), executable: raw.executable } : null;
 
-/** The program's own words for a failed run (`AnchorError … Error Message: …`), else the last error log line. */
+/** The program's own words for a failed run (`AnchorError … Error Message: …`), else the last error log line. A program
+ * built without its errors' text logs the error's name as its message: then the name alone (the client's IDL has
+ * the sentence: `loot.lootError`). */
 export function programError(err, logs) {
-  const anchor = logs?.find((line) => line.includes('AnchorError'));
+  const anchor = logs?.find(line => line.includes('AnchorError'));
   const said = anchor ? /Error Message: (.+?)\.?$/.exec(anchor)?.[1] : undefined;
   const code = anchor ? /Error Code: (\w+)/.exec(anchor)?.[1] : undefined;
-  const last = logs?.filter((l) => /error|failed|insufficient/i.test(l)).at(-1);
-  if (said) return code ? `${said} (${code})` : said;
+  const last = logs?.filter(l => /error|failed|insufficient/i.test(l)).at(-1);
+  if (said) return code && code !== said ? `${said} (${code})` : said;
   return last ?? (typeof err === 'string' ? err : JSON.stringify(err));
 }
 
@@ -115,7 +118,9 @@ export function rpcClient(url, { fetchImpl = globalThis.fetch, sleepImpl = sleep
         // A send whose preflight failed ("Transaction simulation failed: … custom program error: 0x17b5") carries the
         // logs, where the program says why in words.
         const logs = body?.error?.data?.logs;
-        const said = logs?.length ? `The network refused this in a dry run: ${programError(body.error.data.err, logs)}` : message;
+        const said = logs?.length
+          ? `The network refused this in a dry run: ${programError(body.error.data.err, logs)}`
+          : message;
         throw new RpcError(said, { code: body?.error?.code, logs });
       }
       return body.result;
@@ -126,7 +131,14 @@ export function rpcClient(url, { fetchImpl = globalThis.fetch, sleepImpl = sleep
     const out = [];
     for (let i = 0; i < addresses.length; i += ACCOUNTS_PER_CALL) {
       const batch = addresses.slice(i, i + ACCOUNTS_PER_CALL);
-      const r = await call('getMultipleAccounts', [batch, { encoding: 'base64', commitment, ...(minContextSlot != null ? { minContextSlot: Number(minContextSlot) } : {}) }]);
+      const r = await call('getMultipleAccounts', [
+        batch,
+        {
+          encoding: 'base64',
+          commitment,
+          ...(minContextSlot != null ? { minContextSlot: Number(minContextSlot) } : {}),
+        },
+      ]);
       out.push(...r.value.map(decodeAccount));
     }
     return out;
@@ -170,7 +182,7 @@ export function rpcClient(url, { fetchImpl = globalThis.fetch, sleepImpl = sleep
     },
     async programAccounts(program, filters) {
       const r = await call('getProgramAccounts', [program, { encoding: 'base64', commitment: 'confirmed', filters }]);
-      return r.map((x) => ({ pubkey: x.pubkey, account: decodeAccount(x.account) }));
+      return r.map(x => ({ pubkey: x.pubkey, account: decodeAccount(x.account) }));
     },
     /**
      * Dry-run a wire transaction (empty signature slots are fine). Throws with the program's reason when it fails.
@@ -188,11 +200,21 @@ export function rpcClient(url, { fetchImpl = globalThis.fetch, sleepImpl = sleep
         },
       ]);
       const value = r.value;
-      if (value.err) throw new RpcError(`The network refused this in a dry run: ${programError(value.err, value.logs)}`, { logs: value.logs });
-      return { unitsConsumed: value.unitsConsumed ?? null, logs: value.logs ?? [], accounts: (value.accounts ?? []).map(decodeAccount) };
+      if (value.err)
+        throw new RpcError(`The network refused this in a dry run: ${programError(value.err, value.logs)}`, {
+          logs: value.logs,
+        });
+      return {
+        unitsConsumed: value.unitsConsumed ?? null,
+        logs: value.logs ?? [],
+        accounts: (value.accounts ?? []).map(decodeAccount),
+      };
     },
     async send(wire) {
-      return call('sendTransaction', [toBase64(wire), { encoding: 'base64', preflightCommitment: 'confirmed', maxRetries: 3 }]);
+      return call('sendTransaction', [
+        toBase64(wire),
+        { encoding: 'base64', preflightCommitment: 'confirmed', maxRetries: 3 },
+      ]);
     },
     signatureStatus,
     /** Wait until a sent transaction is confirmed; throws with the program's reason when it failed. */
@@ -201,13 +223,19 @@ export function rpcClient(url, { fetchImpl = globalThis.fetch, sleepImpl = sleep
       for (let poll = 0; Date.now() < deadline; poll++) {
         const status = await signatureStatus(signature);
         if (status?.err) {
-          const tx = await call('getTransaction', [signature, { commitment: 'confirmed', maxSupportedTransactionVersion: 0 }]).catch(() => null);
-          throw new RpcError(`Transaction ${signature} failed: ${programError(status.err, tx?.meta?.logMessages)}`, { logs: tx?.meta?.logMessages });
+          const tx = await call('getTransaction', [
+            signature,
+            { commitment: 'confirmed', maxSupportedTransactionVersion: 0 },
+          ]).catch(() => null);
+          throw new RpcError(`Transaction ${signature} failed: ${programError(status.err, tx?.meta?.logMessages)}`, {
+            logs: tx?.meta?.logMessages,
+          });
         }
         if (status?.confirmationStatus === 'confirmed' || status?.confirmationStatus === 'finalized') return signature;
         if (lastValidBlockHeight !== null && poll % 5 === 4) {
           const height = await call('getBlockHeight', [{ commitment: 'confirmed' }]).catch(() => 0);
-          if (height > lastValidBlockHeight) throw new RpcError(`Transaction ${signature} expired before it landed. Try again.`);
+          if (height > lastValidBlockHeight)
+            throw new RpcError(`Transaction ${signature} expired before it landed. Try again.`);
         }
         await sleepImpl(CONFIRM_POLL_MS);
       }

package/js/chain/token.js

@@ -28,7 +28,15 @@ export function createAccountWithSeedIx({ from, address, seed, lamports, space,
   return {
     programId: SYSTEM_PROGRAM,
     keys: [meta(from, true, true), meta(address, false, true)],
-    data: concat(uintLE(3, 4), addressBytes(from), uintLE(text.length, 8), text, uintLE(lamports, 8), uintLE(space, 8), addressBytes(owner)),
+    data: concat(
+      uintLE(3, 4),
+      addressBytes(from),
+      uintLE(text.length, 8),
+      text,
+      uintLE(lamports, 8),
+      uintLE(space, 8),
+      addressBytes(owner),
+    ),
   };
 }
 
@@ -81,5 +89,8 @@ export const transferCheckedIx = ({ from, mint, to, owner, amount, decimals, tok
 export const setAuthorityIx = ({ account, current, kind = 0, newAuthority, tokenProgram = TOKEN_PROGRAM }) => ({
   programId: tokenProgram,
   keys: [meta(account, false, true), meta(current, true, false)],
-  data: concat(Uint8Array.of(6, kind), newAuthority ? concat(Uint8Array.of(1), addressBytes(newAuthority)) : Uint8Array.of(0)),
+  data: concat(
+    Uint8Array.of(6, kind),
+    newAuthority ? concat(Uint8Array.of(1), addressBytes(newAuthority)) : Uint8Array.of(0),
+  ),
 });

package/js/chain/token2022.js

@@ -19,11 +19,18 @@ export const MEMO_PROGRAM = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';
 export const EXECUTE_DISCRIMINATOR = Uint8Array.of(105, 37, 101, 197, 75, 251, 102, 26);
 
 const ACCOUNT_TYPE_MINT = 1;
-const EXTENSION = { DefaultAccountState: 6, MemoTransfer: 8, PermanentDelegate: 12, TransferHook: 14, PausableConfig: 26 };
+const EXTENSION = {
+  DefaultAccountState: 6,
+  MemoTransfer: 8,
+  PermanentDelegate: 12,
+  TransferHook: 14,
+  PausableConfig: 26,
+};
 const META_BYTES = 35;
 
 function checkedSlice(data, at, length, what) {
-  if (!Number.isInteger(at) || !Number.isInteger(length) || at < 0 || length < 0 || at + length > data.length) throw new RangeError(`${what} runs past the data`);
+  if (!Number.isInteger(at) || !Number.isInteger(length) || at < 0 || length < 0 || at + length > data.length)
+    throw new RangeError(`${what} runs past the data`);
   return data.subarray(at, at + length);
 }
 
@@ -57,7 +64,12 @@ export function hookProgramOf(mintData) {
  * each reads the setting once, as it opens, and a refund or payout opened into a frozen account would never land.
  */
 export function mayStartFrozen({ owner, data }) {
-  if (owner !== TOKEN_2022_PROGRAM || data.length <= TOKEN_ACCOUNT_BYTES || data[TOKEN_ACCOUNT_BYTES] !== ACCOUNT_TYPE_MINT) return false;
+  if (
+    owner !== TOKEN_2022_PROGRAM ||
+    data.length <= TOKEN_ACCOUNT_BYTES ||
+    data[TOKEN_ACCOUNT_BYTES] !== ACCOUNT_TYPE_MINT
+  )
+    return false;
   const state = extension(data, EXTENSION.DefaultAccountState);
   if (!state) return false;
   const freezer = data.length >= 50 && readUintLE(data, 46, 4) !== 0n;
@@ -73,10 +85,16 @@ export function mayStartFrozen({ owner, data }) {
 export function mintPowers({ owner, data }) {
   const out = [];
   if (owner !== TOKEN_PROGRAM && owner !== TOKEN_2022_PROGRAM) return out;
-  const option = (at) => (data.length >= at + 36 && readUintLE(data, at, 4) === 1n ? encodeBase58(data.subarray(at + 4, at + 36)) : null);
+  const option = at =>
+    data.length >= at + 36 && readUintLE(data, at, 4) === 1n ? encodeBase58(data.subarray(at + 4, at + 36)) : null;
   const freezer = option(46);
   if (freezer) out.push({ power: 'freeze', holder: freezer });
-  if (owner !== TOKEN_2022_PROGRAM || data.length <= TOKEN_ACCOUNT_BYTES || data[TOKEN_ACCOUNT_BYTES] !== ACCOUNT_TYPE_MINT) return out;
+  if (
+    owner !== TOKEN_2022_PROGRAM ||
+    data.length <= TOKEN_ACCOUNT_BYTES ||
+    data[TOKEN_ACCOUNT_BYTES] !== ACCOUNT_TYPE_MINT
+  )
+    return out;
   const address = (value, at) => {
     const a = value && value.length >= at + 32 ? encodeBase58(value.subarray(at, at + 32)) : null;
     return a === NO_ADDRESS ? null : a;
@@ -97,7 +115,8 @@ export function requiresMemo(accountData) {
 }
 
 /** The hook's list of extra accounts for this mint. */
-export const validationAddress = (mint, hookProgram) => pdaOf([utf8('extra-account-metas'), addressBytes(mint)], hookProgram);
+export const validationAddress = (mint, hookProgram) =>
+  pdaOf([utf8('extra-account-metas'), addressBytes(mint)], hookProgram);
 
 /** The ExtraAccountMeta entries of an "extra-account-metas" account: [{ discriminator, config, isSigner, isWritable }]. */
 export function readExtraMetas(data) {
@@ -113,7 +132,12 @@ export function readExtraMetas(data) {
       return Array.from({ length: count }, (_, i) => {
         const o = at + 16 + i * META_BYTES;
         if (o + META_BYTES > at + 12 + length) throw new RangeError('extra account list runs past its entry');
-        return { discriminator: data[o], config: data.subarray(o + 1, o + 33), isSigner: data[o + 33] !== 0, isWritable: data[o + 34] !== 0 };
+        return {
+          discriminator: data[o],
+          config: data.subarray(o + 1, o + 33),
+          isSigner: data[o + 33] !== 0,
+          isWritable: data[o + 34] !== 0,
+        };
       });
     }
     at += 12 + length;
@@ -124,7 +148,7 @@ export function readExtraMetas(data) {
 /** The seeds a PDA entry packs into its 32 bytes: [{ literal } | { ixData: [index, length] } | { key: index } | { data: [account, at, length] }]. */
 function unpackSeeds(config) {
   const seeds = [];
-  for (let at = 0; at < config.length && config[at] !== 0; ) {
+  for (let at = 0; at < config.length && config[at] !== 0;) {
     const kind = config[at];
     if (kind === 1) {
       seeds.push({ literal: checkedSlice(config, at + 2, config[at + 1], 'literal seed') });
@@ -182,8 +206,12 @@ async function resolveFor(mint, hookProgram, validation, metas, transfer, read)
 }
 
 /** Whether the hook's list depends on which transfer it is (an account, the amount or account data). */
-const perTransfer = (metas) =>
-  metas.some((m) => m.discriminator >= 128 || (m.discriminator === 1 && unpackSeeds(m.config).some((s) => !s.literal && !(s.key === 1 || s.key === 4))));
+const perTransfer = metas =>
+  metas.some(
+    m =>
+      m.discriminator >= 128 ||
+      (m.discriminator === 1 && unpackSeeds(m.config).some(s => !s.literal && !(s.key === 1 || s.key === 4))),
+  );
 
 /**
  * The accounts to append after an instruction's own remaining accounts so every transfer of `mint` it makes can run:
@@ -205,13 +233,20 @@ export async function transferExtras(rpc, mint, transfers = []) {
   if (!list) throw new Error('The transfer hook account list is missing.');
   if (list.owner !== hookProgram) throw new Error('The transfer hook account list has the wrong owner.');
   const metas = readExtraMetas(list.data);
-  const read = async (address) => (await rpc.accounts([address]))[0]?.data ?? null;
-  const cases = perTransfer(metas) ? transfers : [{ source: NO_ADDRESS, destination: NO_ADDRESS, authority: NO_ADDRESS, amount: 0n }];
+  const read = async address => (await rpc.accounts([address]))[0]?.data ?? null;
+  const cases = perTransfer(metas)
+    ? transfers
+    : [{ source: NO_ADDRESS, destination: NO_ADDRESS, authority: NO_ADDRESS, amount: 0n }];
   if (!cases.length) throw new Error('This token’s transfer hook needs to know each transfer; pass them.');
-  for (const transfer of cases) for (const m of await resolveFor(mint, hookProgram, validation, metas, transfer, read)) extras.push(m);
+  for (const transfer of cases)
+    for (const m of await resolveFor(mint, hookProgram, validation, metas, transfer, read)) extras.push(m);
   // One entry per address; writable if any transfer needs it writable.
   const merged = new Map();
-  for (const m of extras) merged.set(m.pubkey, merged.has(m.pubkey) ? { ...m, isWritable: m.isWritable || merged.get(m.pubkey).isWritable } : m);
+  for (const m of extras)
+    merged.set(
+      m.pubkey,
+      merged.has(m.pubkey) ? { ...m, isWritable: m.isWritable || merged.get(m.pubkey).isWritable } : m,
+    );
   return [...merged.values()];
 }
 
@@ -220,7 +255,11 @@ export function associatedAccountSize(mintAccount) {
   if (mintAccount?.owner === TOKEN_PROGRAM) return TOKEN_ACCOUNT_BYTES;
   if (mintAccount?.owner !== TOKEN_2022_PROGRAM) throw new Error('The mint is not owned by a supported token program.');
   const data = mintAccount.data;
-  if (data.length !== MINT_BYTES && (data.length < TOKEN_ACCOUNT_BYTES + 1 || data[TOKEN_ACCOUNT_BYTES] !== ACCOUNT_TYPE_MINT)) throw new Error('Invalid Token-2022 mint layout.');
+  if (
+    data.length !== MINT_BYTES &&
+    (data.length < TOKEN_ACCOUNT_BYTES + 1 || data[TOKEN_ACCOUNT_BYTES] !== ACCOUNT_TYPE_MINT)
+  )
+    throw new Error('Invalid Token-2022 mint layout.');
   const required = new Map([[7, 0]]); // ImmutableOwner, set by the associated token program.
   for (let at = TOKEN_ACCOUNT_BYTES + 1; at + 4 <= data.length;) {
     const kind = Number(readUintLE(data, at, 2));
@@ -242,6 +281,6 @@ export async function resolveTransfers(rpc, mint, transfers = []) {
   const [account] = await rpc.accounts([mint]);
   if (!account) throw new Error(`There is no token ${mint} on this network.`);
   const accountSize = associatedAccountSize(account);
-  const cached = { accounts: async (keys) => keys.length === 1 && keys[0] === mint ? [account] : rpc.accounts(keys) };
+  const cached = { accounts: async keys => (keys.length === 1 && keys[0] === mint ? [account] : rpc.accounts(keys)) };
   return { tokenProgram: account.owner, accountSize, extraAccounts: await transferExtras(cached, mint, transfers) };
 }

package/js/chain/tx.js

@@ -33,14 +33,14 @@ function mergedAccounts(payer, instructions) {
 }
 
 /** The order a message lists accounts in: signers first, writable before read-only; payer at the head. */
-const rank = (m) => (m.isSigner ? 0 : 2) + (m.isWritable ? 0 : 1);
+const rank = m => (m.isSigner ? 0 : 2) + (m.isWritable ? 0 : 1);
 
 function compileInstructions(instructions, index) {
-  return instructions.map((ix) =>
+  return instructions.map(ix =>
     concat(
       Uint8Array.of(index.get(ix.programId)),
       compactU16(ix.keys.length),
-      Uint8Array.from(ix.keys.map((k) => index.get(k.pubkey))),
+      Uint8Array.from(ix.keys.map(k => index.get(k.pubkey))),
       compactU16(ix.data.length),
       ix.data,
     ),
@@ -57,10 +57,10 @@ export function compileMessage({ payer, blockhash, instructions, version = 'lega
   const lookups = [];
   if (version === 0) {
     for (const table of lookupTables) {
-      const drain = (writable) => {
+      const drain = writable => {
         const indexes = [];
         const keys = [];
-        accounts = accounts.filter((m) => {
+        accounts = accounts.filter(m => {
           if (m.isSigner || m.invoked || m.isWritable !== writable) return true;
           const at = table.addresses.indexOf(m.pubkey);
           if (at < 0) return true;
@@ -74,30 +74,36 @@ export function compileMessage({ payer, blockhash, instructions, version = 'lega
       const w = drain(true);
       const r = drain(false);
       if (w.indexes.length || r.indexes.length)
-        lookups.push({ address: table.address, writable: w.indexes, readonly: r.indexes, writableKeys: w.keys, readonlyKeys: r.keys });
+        lookups.push({
+          address: table.address,
+          writable: w.indexes,
+          readonly: r.indexes,
+          writableKeys: w.keys,
+          readonlyKeys: r.keys,
+        });
     }
   }
   const [head, ...rest] = accounts;
   const statics = [head, ...rest.sort((a, b) => rank(a) - rank(b))];
-  const loaded = [...lookups.flatMap((l) => l.writableKeys), ...lookups.flatMap((l) => l.readonlyKeys)];
+  const loaded = [...lookups.flatMap(l => l.writableKeys), ...lookups.flatMap(l => l.readonlyKeys)];
   const index = new Map([...statics.map((m, i) => [m.pubkey, i]), ...loaded.map((k, i) => [k, statics.length + i])]);
   if (index.size > 256) throw new Error('Too many accounts for one transaction');
-  const signers = statics.filter((m) => m.isSigner);
+  const signers = statics.filter(m => m.isSigner);
   const header = Uint8Array.of(
     signers.length,
-    signers.filter((m) => !m.isWritable).length,
-    statics.filter((m) => !m.isSigner && !m.isWritable).length,
+    signers.filter(m => !m.isWritable).length,
+    statics.filter(m => !m.isSigner && !m.isWritable).length,
   );
   const body = concat(
     header,
     compactU16(statics.length),
-    ...statics.map((m) => addressBytes(m.pubkey)),
+    ...statics.map(m => addressBytes(m.pubkey)),
     addressBytes(blockhash),
     compactU16(instructions.length),
     ...compileInstructions(instructions, index),
   );
   if (version !== 0) return body;
-  const tables = lookups.map((l) =>
+  const tables = lookups.map(l =>
     concat(
       addressBytes(l.address),
       compactU16(l.writable.length),
@@ -122,13 +128,13 @@ export function readMessage(message) {
     at += n;
     return bytes;
   };
-  const length = (what) => {
+  const length = what => {
     if (at >= message.length) throw new Error(`Truncated message: ${what} runs past its end`);
     const prefix = readCompactU16(message, at);
     at += prefix.size;
     return prefix.value;
   };
-  const address = (what) => encodeBase58(take(32, what));
+  const address = what => encodeBase58(take(32, what));
   let version = 'legacy';
   if (message.length && message[0] & V0_PREFIX) {
     version = message[0] & 0x7f;
@@ -145,8 +151,8 @@ export function readMessage(message) {
   const instructions = [];
   for (let i = 0; i < ixCount; i++) {
     const [programIndex] = take(1, 'an instruction');
-    const accountIndexes = Array.from(take(length('an instruction\'s accounts'), 'an instruction\'s accounts'));
-    const data = take(length('an instruction\'s data'), 'an instruction\'s data').slice();
+    const accountIndexes = Array.from(take(length("an instruction's accounts"), "an instruction's accounts"));
+    const data = take(length("an instruction's data"), "an instruction's data").slice();
     instructions.push({ programIndex, accountIndexes, data });
   }
   const lookups = [];
@@ -154,8 +160,12 @@ export function readMessage(message) {
     const n = length('the lookup table count');
     for (let i = 0; i < n; i++) {
       const tableAddress = address('a lookup table');
-      const writable = Array.from(take(length('a lookup table\'s writable indexes'), 'a lookup table\'s writable indexes'));
-      const readonly = Array.from(take(length('a lookup table\'s read-only indexes'), 'a lookup table\'s read-only indexes'));
+      const writable = Array.from(
+        take(length("a lookup table's writable indexes"), "a lookup table's writable indexes"),
+      );
+      const readonly = Array.from(
+        take(length("a lookup table's read-only indexes"), "a lookup table's read-only indexes"),
+      );
       lookups.push({ address: tableAddress, writable, readonly });
     }
   }
@@ -173,7 +183,7 @@ export function signersOf(message) {
 export function wireTransaction(message, signatures = []) {
   const count = readMessage(message).header.numRequiredSignatures;
   const slots = Array.from({ length: count }, (_, i) => signatures[i] ?? new Uint8Array(SIGNATURE_BYTES));
-  if (slots.some((s) => s.length !== SIGNATURE_BYTES)) throw new Error('A signature is 64 bytes');
+  if (slots.some(s => s.length !== SIGNATURE_BYTES)) throw new Error('A signature is 64 bytes');
   return concat(compactU16(count), ...slots, message);
 }
 
@@ -203,16 +213,16 @@ export function withSignature(wire, signer, signature) {
 }
 
 /** The transaction's id: its first signature, in base58. */
-export const transactionId = (wire) => encodeBase58(readTransaction(wire).signatures[0]);
+export const transactionId = wire => encodeBase58(readTransaction(wire).signatures[0]);
 
 /** Whether a signature slot is still empty. */
-export const isEmptySignature = (signature) => signature.every((b) => b === 0);
+export const isEmptySignature = signature => signature.every(b => b === 0);
 
 /** Whether two wire transactions carry the same message. */
 export const sameMessage = (a, b) => equalBytes(readTransaction(a).message, readTransaction(b).message);
 
 /** The size this message's transaction takes on the wire. */
-export const transactionSize = (message) => wireTransaction(message).length;
+export const transactionSize = message => wireTransaction(message).length;
 
 /** Whether these instructions fit one transaction from this payer. */
 export function fits(input) {