@xgamesfun/solana 0.20.1 → 0.25.0

package/js/play/keys.js

@@ -0,0 +1,193 @@
+// The throwaway keys js/play settles with (the key job rule, AGENTS.md), made so a page that closes in the middle of a
+// job can find them again and finish it, or send their SOL back.
+//
+// A key is named by the account its job is about (an order, a hold). With a wallet that signs messages, every key comes
+// from one signature of the wallet's over a fixed text naming the project and the wallet, asked once a session: the
+// key's seed is sha256("loot settle key" | that signature | the name). Ed25519 signatures are deterministic, so after a
+// reload the same signature gives the same keys. A wallet that signs no messages, or whose signature of the text
+// changes from one session to the next (some MPC wallets), gets a random key instead, kept in the page's storage
+// encrypted with a device key the page can use but never read out (WebCrypto, IndexedDB); with no such storage, in
+// memory only, as before.
+import { addressBytes, encodeBase58 } from '../chain/base58.js';
+import { concat, fromBase64, randomBytes, toBase64, toHex, utf8 } from '../chain/bytes.js';
+import { sha256 } from '../chain/sha256.js';
+
+/** The PKCS #8 header of a raw 32-byte Ed25519 seed (RFC 8410). */
+const PKCS8_ED25519 = Uint8Array.from([
+  0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x04, 0x22, 0x04, 0x20,
+]);
+
+const DERIVED = 'derived';
+const fromBase64Url = text =>
+  fromBase64(
+    text
+      .replace(/-/g, '+')
+      .replace(/_/g, '/')
+      .padEnd(Math.ceil(text.length / 4) * 4, '='),
+  );
+
+/** An Ed25519 key from its 32-byte seed: { address, sign(message) }. */
+export async function keyFromSeed(seed, name = null) {
+  const subtle = globalThis.crypto.subtle;
+  const pkcs8 = concat(PKCS8_ED25519, seed);
+  const jwk = await subtle.exportKey(
+    'jwk',
+    await subtle.importKey('pkcs8', pkcs8, { name: 'Ed25519' }, true, ['sign']),
+  );
+  const signer = await subtle.importKey('pkcs8', pkcs8, { name: 'Ed25519' }, false, ['sign']);
+  return {
+    address: encodeBase58(fromBase64Url(jwk.x)),
+    name,
+    sign: async message => new Uint8Array(await subtle.sign('Ed25519', signer, message)),
+  };
+}
+
+/** The text a wallet signs once a session for its settle keys. It moves nothing and says so. */
+export const settleKeysText = (project, wallet) =>
+  `loot: the keys that settle your orders\nproject ${project}\nwallet ${wallet}\n\nSigning this moves nothing. A page that closes before it settles makes the same key again from it, to finish or send your SOL back.`;
+
+/**
+ * The page's storage of keys that can't be made again (`localStorage`), and a device key that encrypts them, kept in
+ * IndexedDB as a non-extractable AES-GCM key. Null where either is missing (then keys live in memory only).
+ */
+export function browserStore() {
+  const ls = globalThis.localStorage;
+  if (!ls || !globalThis.indexedDB) return null;
+  let device = null;
+  return {
+    get: k => ls.getItem(k),
+    set: (k, v) => ls.setItem(k, v),
+    remove: k => ls.removeItem(k),
+    keys: () => Array.from({ length: ls.length }, (_, i) => ls.key(i)).filter(Boolean),
+    cryptoKey: () => (device ??= deviceKey().catch(() => null)),
+  };
+}
+
+async function deviceKey() {
+  const db = await new Promise((resolve, reject) => {
+    const r = globalThis.indexedDB.open('loot-keys', 1);
+    r.onupgradeneeded = () => r.result.createObjectStore('keys');
+    r.onsuccess = () => resolve(r.result);
+    r.onerror = () => reject(r.error);
+  });
+  const found = await new Promise((resolve, reject) => {
+    const r = db.transaction('keys').objectStore('keys').get('device');
+    r.onsuccess = () => resolve(r.result ?? null);
+    r.onerror = () => reject(r.error);
+  });
+  if (found) return found;
+  const key = await globalThis.crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, false, [
+    'encrypt',
+    'decrypt',
+  ]);
+  await new Promise((resolve, reject) => {
+    const tx = db.transaction('keys', 'readwrite');
+    tx.objectStore('keys').put(key, 'device');
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+  });
+  return key;
+}
+
+/**
+ * The keys of `wallet` ({ address, signMessage? }) in `project`. `store`: `browserStore()`'s shape ({ get, set, remove,
+ * keys, cryptoKey }), or null. `key(name)` makes the key named by an address (asking the wallet for its signature the
+ * first time in a session); `again(name)` makes it again for a job left unfinished, or finds it stored, or null;
+ * `stored()` lists the names of keys stored; `forget(name)` drops a stored key once its job is done and it is empty.
+ * `how()` says how keys are made: 'derived', 'stored' or 'memory'.
+ */
+export function keyring({ wallet, project, store = null }) {
+  let root = null;
+  const prefix = () => `loot-key:${project}:${wallet.address}:`;
+  const checkName = () => `loot-key-check:${project}:${wallet.address}`;
+  const safe = (f, fallback = null) => {
+    try {
+      return f();
+    } catch {
+      return fallback;
+    }
+  };
+
+  /** The wallet's signature of `settleKeysText`, once a session; null when it signs no messages, refuses, or signs the
+   * text differently from an earlier session (then nothing it signed could be made again). */
+  function signature() {
+    if (!wallet?.signMessage) return Promise.resolve(null);
+    root ??= (async () => {
+      const sig = new Uint8Array(await wallet.signMessage(utf8(settleKeysText(project, wallet.address))));
+      if (sig.length !== 64) return null;
+      const mark = toHex(sha256(sha256(sig))).slice(0, 32);
+      const had = store ? safe(() => store.get(checkName())) : null;
+      if (had && had !== mark) return null;
+      if (!had && store) safe(() => store.set(checkName(), mark));
+      return sig;
+    })().catch(() => null);
+    return root;
+  }
+
+  const derived = (sig, name) => keyFromSeed(sha256(concat(utf8('loot settle key'), sig, addressBytes(name))), name);
+
+  async function seal(seed) {
+    const device = await store?.cryptoKey?.();
+    if (!device) return null;
+    const iv = randomBytes(12);
+    const sealed = new Uint8Array(await globalThis.crypto.subtle.encrypt({ name: 'AES-GCM', iv }, device, seed));
+    return toBase64(concat(iv, sealed));
+  }
+
+  async function open(text) {
+    const device = await store?.cryptoKey?.();
+    if (!device || !text) return null;
+    const bytes = fromBase64(text);
+    return new Uint8Array(
+      await globalThis.crypto.subtle.decrypt(
+        { name: 'AES-GCM', iv: bytes.subarray(0, 12) },
+        device,
+        bytes.subarray(12),
+      ),
+    );
+  }
+
+  return {
+    async how() {
+      if (await signature()) return 'derived';
+      return store && (await store.cryptoKey?.()) ? 'stored' : 'memory';
+    },
+
+    /** The key named `name` (an address) for a new job. */
+    async key(name) {
+      const sig = await signature();
+      if (sig) {
+        // Its name is kept, so `recover` finds it once its job's account is gone.
+        if (store) safe(() => store.set(prefix() + name, DERIVED));
+        return derived(sig, name);
+      }
+      const seed = randomBytes(32);
+      const sealed = store ? await seal(seed).catch(() => null) : null;
+      if (sealed) safe(() => store.set(prefix() + name, sealed));
+      return keyFromSeed(seed, name);
+    },
+
+    /** The key named `name` again, for a job left unfinished: made again from the wallet's signature, or read from
+     * storage; null when neither can. `ask`: false to make it only from a signature already given this session. */
+    async again(name, { ask = true } = {}) {
+      const sig = ask || root ? await signature() : null;
+      if (sig) return derived(sig, name);
+      const text = store ? safe(() => store.get(prefix() + name)) : null;
+      const seed = text && text !== DERIVED ? await open(text).catch(() => null) : null;
+      return seed ? keyFromSeed(seed, name) : null;
+    },
+
+    /** The names of the keys this page stored for the wallet (none when keys are made from its signature). */
+    stored() {
+      if (!store) return [];
+      const p = prefix();
+      return safe(() => store.keys(), [])
+        .filter(k => k.startsWith(p))
+        .map(k => k.slice(p.length));
+    },
+
+    forget(name) {
+      if (store && name) safe(() => store.remove(prefix() + name));
+    },
+  };
+}

package/js/results/index.js

@@ -23,21 +23,37 @@ import { toHex } from '../chain/bytes.js';
 import { pda, voucherBytes } from '../client/index.js';
 import { canonicalJson, drawText, entryText, lockText, resultBytes, rosterHash } from './wire.js';
 
-export { canonicalJson, CERT_KINDS, CLUSTERS, drawText, entryText, giveawayHostText, hostCertText, lockText, NO_GRANT, RESULT_DOMAIN, resultBytes, revokeGiveawayText, revokeText, rosterHash } from './wire.js';
+export {
+  canonicalJson,
+  CERT_KINDS,
+  CLUSTERS,
+  drawText,
+  entryText,
+  giveawayHostText,
+  hostCertText,
+  lockText,
+  NO_GRANT,
+  RESULT_DOMAIN,
+  resultBytes,
+  revokeGiveawayText,
+  revokeText,
+  rosterHash,
+} from './wire.js';
 
 /** games.fun's results server, on its play host (devnet until the program's audit). */
 export const RESULTS_SERVER = 'https://play.xgames.fun/xsolana';
 
 const subtle = () => globalThis.crypto.subtle;
 /** A value as a query's value: encoded, so a `&`, `#` or `/` in it is part of the value. */
-const q = (value) => encodeURIComponent(String(value));
+const q = value => encodeURIComponent(String(value));
 /**
  * A value as one segment of a URL's path: encoded, so a `/` or `?` in it stays inside the segment. One that is empty,
  * `.` or `..` (which a URL reads as a step up the path, encoded or not) is refused.
  */
-const seg = (value) => {
+const seg = value => {
   const text = String(value);
-  if (text === '' || text === '.' || text === '..') throw new RangeError(`${JSON.stringify(text)} can't be a part of a path.`);
+  if (text === '' || text === '.' || text === '..')
+    throw new RangeError(`${JSON.stringify(text)} can't be a part of a path.`);
   return encodeURIComponent(text);
 };
 
@@ -58,7 +74,25 @@ export async function newKey() {
 export async function keyFromSecret(secret) {
   const seed = decodeBase58(secret);
   if (seed.length !== 32) throw new Error('A host key secret is 32 bytes in base58.');
-  const pkcs8 = new Uint8Array([0x30, 0x2e, 0x02, 0x01, 0x00, 0x30, 0x05, 0x06, 0x03, 0x2b, 0x65, 0x70, 0x04, 0x22, 0x04, 0x20, ...seed]);
+  const pkcs8 = new Uint8Array([
+    0x30,
+    0x2e,
+    0x02,
+    0x01,
+    0x00,
+    0x30,
+    0x05,
+    0x06,
+    0x03,
+    0x2b,
+    0x65,
+    0x70,
+    0x04,
+    0x22,
+    0x04,
+    0x20,
+    ...seed,
+  ]);
   const privateKey = await subtle().importKey('pkcs8', pkcs8, { name: 'Ed25519' }, true, ['sign']);
   const jwk = await subtle().exportKey('jwk', privateKey);
   return keyOf(privateKey, base64url(jwk.x), jwk.d);
@@ -68,13 +102,13 @@ function keyOf(privateKey, publicBytes, d) {
   return {
     address: encodeBase58(publicBytes),
     secret: encodeBase58(base64url(d)),
-    sign: async (message) => new Uint8Array(await subtle().sign({ name: 'Ed25519' }, privateKey, message)),
+    sign: async message => new Uint8Array(await subtle().sign({ name: 'Ed25519' }, privateKey, message)),
   };
 }
 
 function base64url(text) {
   const bin = atob(text.replace(/-/g, '+').replace(/_/g, '/'));
-  return Uint8Array.from(bin, (c) => c.charCodeAt(0));
+  return Uint8Array.from(bin, c => c.charCodeAt(0));
 }
 
 /** One signer's signature of a result: { key, signature }. `signer` is a key from newKey, or anything with sign(). */
@@ -87,7 +121,17 @@ export async function signResult(signer, result, cluster = 'devnet') {
  * with the same result is safe: it is the same answer. Returns the server's answer, { result, vouchers }, or throws its
  * { code, why }.
  */
-export async function report({ server, cert, signer, game, round, endedAt, winners, cluster = 'devnet', fetchImpl = globalThis.fetch }) {
+export async function report({
+  server,
+  cert,
+  signer,
+  game,
+  round,
+  endedAt,
+  winners,
+  cluster = 'devnet',
+  fetchImpl = globalThis.fetch,
+}) {
   const result = { game, round, endedAt, winners };
   const all = [await signResult(signer, result, cluster)];
   const response = await fetchImpl(`${server.replace(/\/$/, '')}/v1/results`, {
@@ -104,14 +148,26 @@ export async function report({ server, cert, signer, game, round, endedAt, winne
  */
 async function answerOf(response) {
   const answer = await response.json().catch(() => null);
-  if (!response.ok) throw Object.assign(new Error(answer?.error?.why ?? `The results server answered ${response.status}${response.statusText ? ` ${response.statusText}` : ''}.`), { code: answer?.error?.code, status: response.status });
-  if (answer === null || typeof answer !== 'object') throw Object.assign(new Error(`The results server answered ${response.status} with no JSON.`), { status: response.status });
+  if (!response.ok)
+    throw Object.assign(
+      new Error(
+        answer?.error?.why ??
+          `The results server answered ${response.status}${response.statusText ? ` ${response.statusText}` : ''}.`,
+      ),
+      { code: answer?.error?.code, status: response.status },
+    );
+  if (answer === null || typeof answer !== 'object')
+    throw Object.assign(new Error(`The results server answered ${response.status} with no JSON.`), {
+      status: response.status,
+    });
   return answer;
 }
 
 /** A wallet's vouchers for a round it won: [{ grant, publicKey, signature, round, expires, … }]. */
 export async function fetchVouchers({ server, game, round, wallet, fetchImpl = globalThis.fetch }) {
-  const response = await fetchImpl(`${server.replace(/\/$/, '')}/v1/vouchers?game=${q(game)}&round=${q(round)}&wallet=${q(wallet)}`);
+  const response = await fetchImpl(
+    `${server.replace(/\/$/, '')}/v1/vouchers?game=${q(game)}&round=${q(round)}&wallet=${q(wallet)}`,
+  );
   return (await answerOf(response)).vouchers;
 }
 
@@ -126,19 +182,56 @@ export async function fetchVouchers({ server, game, round, wallet, fetchImpl = g
  * Returns { wallet, grant, incarnation, publicKey, signature, round, expires, personHash, amount } for js/play claimGrant,
  * plain JSON (`incarnation` and `amount` as decimal text), so a server can send it as it is.
  */
-export async function signVoucher({ signer, game, grant, incarnation, wallet, round, now, seconds = 7 * 86_400, personHash = null, amount = 0n }) {
-  if (!(Number(seconds) > 0)) throw new RangeError('A voucher lives some seconds from now (`seconds` above 0): one that has run out already pays nothing.');
+export async function signVoucher({
+  signer,
+  game,
+  grant,
+  incarnation,
+  wallet,
+  round,
+  now,
+  seconds = 7 * 86_400,
+  personHash = null,
+  amount = 0n,
+}) {
+  if (!(Number(seconds) > 0))
+    throw new RangeError(
+      'A voucher lives some seconds from now (`seconds` above 0): one that has run out already pays nothing.',
+    );
   if (Number(seconds) > 30 * 86_400) throw new Error('A voucher lives 30 days at most.');
   // The cluster's clock comes as a number or a bigint (an RPC's, a decoded Clock's); `expires` is a number either way.
   const expires = Math.floor(typeof now === 'bigint' ? Number(now) : now) + Number(seconds);
-  if (!Number.isSafeInteger(expires)) throw new RangeError('A voucher needs the cluster\'s clock (`now`, unix seconds).');
-  const message = voucherBytes({ grant: pda.grant(game, grant), incarnation, wallet, personHash, round, expires, amount: BigInt(amount) });
-  return { wallet, grant, incarnation: String(BigInt(incarnation)), publicKey: signer.address, signature: encodeBase58(await signer.sign(message)), round, expires, personHash: personHash ?? '0'.repeat(64), amount: String(BigInt(amount)) };
+  if (!Number.isSafeInteger(expires))
+    throw new RangeError("A voucher needs the cluster's clock (`now`, unix seconds).");
+  const message = voucherBytes({
+    grant: pda.grant(game, grant),
+    incarnation,
+    wallet,
+    personHash,
+    round,
+    expires,
+    amount: BigInt(amount),
+  });
+  return {
+    wallet,
+    grant,
+    incarnation: String(BigInt(incarnation)),
+    publicKey: signer.address,
+    signature: encodeBase58(await signer.sign(message)),
+    round,
+    expires,
+    personHash: personHash ?? '0'.repeat(64),
+    amount: String(BigInt(amount)),
+  };
 }
 
 /** Posts JSON to the server and answers its body, or throws its { code, why }. */
 async function post(server, path, body, fetchImpl) {
-  const response = await fetchImpl(`${server.replace(/\/$/, '')}${path}`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) });
+  const response = await fetchImpl(`${server.replace(/\/$/, '')}${path}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
   return answerOf(response);
 }
 
@@ -151,34 +244,134 @@ const fetchJson = async (server, path, fetchImpl) => answerOf(await fetchImpl(`$
  */
 export const draws = {
   open: async ({ server, signMessage, by, cert = null, rates = null, fetchImpl = globalThis.fetch, ...spec }) => {
-    const ratesHash = rates ? Array.from(new Uint8Array(await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(canonicalJson(rates)))), (b) => b.toString(16).padStart(2, '0')).join('') : 'default';
+    const ratesHash = rates
+      ? Array.from(
+          new Uint8Array(
+            await globalThis.crypto.subtle.digest('SHA-256', new TextEncoder().encode(canonicalJson(rates))),
+          ),
+          b => b.toString(16).padStart(2, '0'),
+        ).join('')
+      : 'default';
     const text = drawText({ ...spec, rates: ratesHash });
-    return post(server, '/v1/draws', { text, signature: encodeBase58(await signMessage(new TextEncoder().encode(text))), by, ...(cert ? { cert } : {}), ...(rates ? { rates } : {}) }, fetchImpl);
+    return post(
+      server,
+      '/v1/draws',
+      {
+        text,
+        signature: encodeBase58(await signMessage(new TextEncoder().encode(text))),
+        by,
+        ...(cert ? { cert } : {}),
+        ...(rates ? { rates } : {}),
+      },
+      fetchImpl,
+    );
   },
   /** A player enters with their play-host token, or with their wallet's signature (`wallet`, `signMessage`). */
-  enter: async ({ server, game, draw, token = null, wallet = null, signMessage = null, cluster = 'devnet', fetchImpl = globalThis.fetch }) => {
+  enter: async ({
+    server,
+    game,
+    draw,
+    token = null,
+    wallet = null,
+    signMessage = null,
+    cluster = 'devnet',
+    fetchImpl = globalThis.fetch,
+  }) => {
     if (token) return post(server, `/v1/draws/${seg(game)}/${seg(draw)}/entries`, { token }, fetchImpl);
     const text = entryText({ cluster, game, draw });
-    return post(server, `/v1/draws/${seg(game)}/${seg(draw)}/entries`, { wallet, text, signature: encodeBase58(await signMessage(new TextEncoder().encode(text))) }, fetchImpl);
+    return post(
+      server,
+      `/v1/draws/${seg(game)}/${seg(draw)}/entries`,
+      { wallet, text, signature: encodeBase58(await signMessage(new TextEncoder().encode(text))) },
+      fetchImpl,
+    );
   },
   /** Locks the players the server holds now to `beacon`, a drand round still to come. Checks their hash itself. */
-  lock: async ({ server, game, draw, beacon, signMessage, by, cert = null, cluster = 'devnet', net = 'quicknet', fetchImpl = globalThis.fetch }) => {
+  lock: async ({
+    server,
+    game,
+    draw,
+    beacon,
+    signMessage,
+    by,
+    cert = null,
+    cluster = 'devnet',
+    net = 'quicknet',
+    fetchImpl = globalThis.fetch,
+  }) => {
     const { draw: view } = await fetchJson(server, `/v1/draws/${seg(game)}/${seg(draw)}`, fetchImpl);
-    const text = lockText({ cluster, game, draw, roster: await rosterHash(view.entries), players: view.entries.length, beacon, net });
-    return post(server, `/v1/draws/${seg(game)}/${seg(draw)}/lock`, { text, signature: encodeBase58(await signMessage(new TextEncoder().encode(text))), by, ...(cert ? { cert } : {}) }, fetchImpl);
+    const text = lockText({
+      cluster,
+      game,
+      draw,
+      roster: await rosterHash(view.entries),
+      players: view.entries.length,
+      beacon,
+      net,
+    });
+    return post(
+      server,
+      `/v1/draws/${seg(game)}/${seg(draw)}/lock`,
+      {
+        text,
+        signature: encodeBase58(await signMessage(new TextEncoder().encode(text))),
+        by,
+        ...(cert ? { cert } : {}),
+      },
+      fetchImpl,
+    );
   },
   /** The draw as anyone may check it; settled, with its result, once its beacon round is out. */
-  get: async ({ server, game, draw, fetchImpl = globalThis.fetch }) => (await fetchJson(server, `/v1/draws/${seg(game)}/${seg(draw)}`, fetchImpl)).draw,
+  get: async ({ server, game, draw, fetchImpl = globalThis.fetch }) =>
+    (await fetchJson(server, `/v1/draws/${seg(game)}/${seg(draw)}`, fetchImpl)).draw,
 };
 
 /** A giveaway, from its appointed host's page. */
 export const giveaways = {
   /** Opens one: `cert` the owner's appointment, `token` the host's play-host sign-in, `session` a key from newKey(). */
-  open: async ({ server, game, cert, token, giveaway, winners, endsBy, session, fetchImpl = globalThis.fetch }) => post(server, `/v1/giveaways/${seg(game)}`, { cert, token, giveaway, winners, endsBy, session: session.address }, fetchImpl),
+  open: async ({ server, game, cert, token, giveaway, winners, endsBy, session, fetchImpl = globalThis.fetch }) =>
+    post(
+      server,
+      `/v1/giveaways/${seg(game)}`,
+      { cert, token, giveaway, winners, endsBy, session: session.address },
+      fetchImpl,
+    ),
   /** Reports its result, signed by its session key. `grant`: the host's grant (each winner is paid from it). */
-  report: async ({ server, game, giveaway, session, endedAt, winners, grant, cluster = 'devnet', fetchImpl = globalThis.fetch }) => {
-    const signed = winners.map((w) => ({ wallet: w.wallet, place: w.place, grant }));
-    const signature = encodeBase58(await session.sign(resultBytes({ cluster, game, round: giveaway, endedAt, winners: signed })));
-    return post(server, `/v1/giveaways/${seg(game)}/${seg(giveaway)}/result`, { endedAt, winners: winners.map(({ wallet, place }) => ({ wallet, place })), signature }, fetchImpl);
+  report: async ({
+    server,
+    game,
+    giveaway,
+    session,
+    endedAt,
+    winners,
+    grant,
+    cluster = 'devnet',
+    fetchImpl = globalThis.fetch,
+  }) => {
+    const signed = winners.map(w => ({ wallet: w.wallet, place: w.place, grant }));
+    const signature = encodeBase58(
+      await session.sign(resultBytes({ cluster, game, round: giveaway, endedAt, winners: signed })),
+    );
+    return post(
+      server,
+      `/v1/giveaways/${seg(game)}/${seg(giveaway)}/result`,
+      { endedAt, winners: winners.map(({ wallet, place }) => ({ wallet, place })), signature },
+      fetchImpl,
+    );
   },
 };
+
+// What a game's server checks: a wallet's collectibles, a wallet's signed proof, promo codes (server.js).
+export {
+  codeAddresses,
+  codeKey,
+  codeVoucher,
+  collectiblesOf,
+  holds,
+  makeCodes,
+  normalizeCode,
+  proofRequest,
+  proofText,
+  readProof,
+  verifyProof,
+} from './server.js';