Formatting

src/lnurlcash/ops.testHarness.ts

@@ -1,69 +1,69 @@
-import {afterEach, expect} from 'vitest'
-import {createMockMint} from 'lnurlcash-conformance/mock-mint'
-import {bytesToHex, hexToBytes, utf8ToBytes} from '@noble/hashes/utils.js'
-import {sha256} from '@noble/hashes/sha2.js'
-import {buildNoteUrl, fetchNoteInfo} from 'lnurlcash-kit'
+import { afterEach, expect } from 'vitest';
+import { createMockMint } from 'lnurlcash-conformance/mock-mint';
+import { bytesToHex, hexToBytes, utf8ToBytes } from '@noble/hashes/utils.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { buildNoteUrl, fetchNoteInfo } from 'lnurlcash-kit';
 
-import type {Bearer} from './types'
-import {requiredValue} from './test-utils'
+import type { Bearer } from './types';
+import { requiredValue } from './test-utils';
 
-export type Mint = Awaited<ReturnType<typeof createMockMint>>
+export type Mint = Awaited<ReturnType<typeof createMockMint>>;
 
-const mints: Mint[] = []
+const mints: Mint[] = [];
 
 export const mint = async (options: Parameters<typeof createMockMint>[0] = {}): Promise<Mint> => {
-  const instance = await createMockMint(options)
-  mints.push(instance)
-  return instance
-}
+  const instance = await createMockMint(options);
+  mints.push(instance);
+  return instance;
+};
 
 afterEach(async () => {
-  await Promise.all(mints.splice(0).map((instance) => instance.close()))
-})
+  await Promise.all(mints.splice(0).map((instance) => instance.close()));
+});
 
 export const secret = (seed: string): string =>
-  bytesToHex(sha256(hexToBytes('00'.repeat(31) + seed)))
+  bytesToHex(sha256(hexToBytes('00'.repeat(31) + seed)));
 
-export const persistOutput = async (): Promise<void> => undefined
+export const persistOutput = async (): Promise<void> => undefined;
 
 // deterministic stand-in for the wallet's BIP-32 allocation path: answers
 // every reservation with fresh unique secrets, never reusing one
-let allocatedSecretCounter = 0
+let allocatedSecretCounter = 0;
 export const allocateOutputSecrets = (
   _server: string,
   count: number,
 ): Promise<readonly string[]> => {
-  const secrets = Array.from({length: count}, () => {
-    allocatedSecretCounter += 1
-    return bytesToHex(sha256(utf8ToBytes(`allocated-${allocatedSecretCounter}`)))
-  })
-  return Promise.resolve(secrets)
-}
+  const secrets = Array.from({ length: count }, () => {
+    allocatedSecretCounter += 1;
+    return bytesToHex(sha256(utf8ToBytes(`allocated-${allocatedSecretCounter}`)));
+  });
+  return Promise.resolve(secrets);
+};
 
 // the receive-rotation staging checkpoint - engine tests keep no wallet,
 // so staging is a recorded no-op for them
-export const stageRotation = async (): Promise<void> => undefined
+export const stageRotation = async (): Promise<void> => undefined;
 
 // the trusted signing keys a production caller would serve from the
 // trusted-mint registry: the mock mint's current key plus any it retired
-export const signatureKeysFor =
-  (instance: Mint) =>
-  (): readonly string[] =>
-    [instance.state.pubkey, ...instance.state.previousPubkeys]
+export const signatureKeysFor = (instance: Mint) => (): readonly string[] => [
+  instance.state.pubkey,
+  ...instance.state.previousPubkeys,
+];
 
 export const noteUrl = (instance: Mint, k1: string, amountMsat?: number): string =>
-  buildNoteUrl(`${instance.url}/w`, k1, amountMsat)
+  buildNoteUrl(`${instance.url}/w`, k1, amountMsat);
 
-let fixtureCounter = 0
+let fixtureCounter = 0;
 export const makeBearer = async (
   instance: Mint,
   k1: string,
   amountMsat: number,
 ): Promise<Bearer> => {
-  instance.state.creditNote(k1, amountMsat)
-  const url = noteUrl(instance, k1, amountMsat)
-  const info = await fetchNoteInfo(url)
-  fixtureCounter += 1
+  instance.state.creditNote(k1, amountMsat);
+  const url = noteUrl(instance, k1, amountMsat);
+  const info = await fetchNoteInfo(url);
+  fixtureCounter += 1;
   return {
     id: `fixture-${fixtureCounter}`,
     url,
@@ -73,29 +73,29 @@ export const makeBearer = async (
     mintPubkey: instance.state.pubkey,
     createdAt: Date.now(),
     updatedAt: Date.now(),
-  }
-}
+  };
+};
 
 export const settleLastInvoice = async (instance: Mint): Promise<string> => {
-  const paymentHash = requiredValue([...instance.state.invoices.keys()].at(-1))
-  const response = await fetch(`${instance.url}/_test/settle?payment_hash=${paymentHash}`)
-  if (!response.ok) throw new Error(`settle hook failed: ${response.status}`)
-  return requiredValue(instance.state.invoices.get(paymentHash)).preimage
-}
+  const paymentHash = requiredValue([...instance.state.invoices.keys()].at(-1));
+  const response = await fetch(`${instance.url}/_test/settle?payment_hash=${paymentHash}`);
+  if (!response.ok) throw new Error(`settle hook failed: ${response.status}`);
+  return requiredValue(instance.state.invoices.get(paymentHash)).preimage;
+};
 
 export const settleWhenRequested = async (instance: Mint): Promise<string> => {
   for (let attempt = 0; attempt < 200 && instance.state.invoices.size === 0; attempt++) {
-    await new Promise((resolve) => setTimeout(resolve, 10))
+    await new Promise((resolve) => setTimeout(resolve, 10));
   }
-  return settleLastInvoice(instance)
-}
+  return settleLastInvoice(instance);
+};
 
 export const expectBurned = async (instance: Mint, k1: string): Promise<void> => {
   for (let attempt = 0; attempt < 200 && instance.state.noteState(k1) !== 'burned'; attempt++) {
-    await new Promise((resolve) => setTimeout(resolve, 10))
+    await new Promise((resolve) => setTimeout(resolve, 10));
   }
-  expect(instance.state.noteState(k1)).toBe('burned')
-}
+  expect(instance.state.noteState(k1)).toBe('burned');
+};
 
 // a fetch wrapper that answers every /w/cb request with the response to
 // its SECOND, byte-identical send - the HTTP-stack GET retry a real client
@@ -105,13 +105,13 @@ export const expectBurned = async (instance: Mint, k1: string): Promise<void> =>
 // ever sees
 export const retryingCbFetch = (): typeof fetch => {
   const impl: typeof fetch = async (input, init) => {
-    const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url
+    const url = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
     if (url.includes('/w/cb')) {
-      const first = await fetch(input, init)
-      await first.arrayBuffer()
-      return fetch(input, init)
+      const first = await fetch(input, init);
+      await first.arrayBuffer();
+      return fetch(input, init);
     }
-    return fetch(input, init)
-  }
-  return impl
-}
+    return fetch(input, init);
+  };
+  return impl;
+};