@reclaimprotocol/attestor-core 5.0.1-beta.2 → 5.0.1-beta.22

package/lib/server/handlers/completeClaimOnChain.js

@@ -1,29 +1,24 @@
-import { EventLog } from "ethers";
+import { EventLog } from 'ethers';
 import { getContracts } from "../../avs/utils/contracts.js";
 import { getEnvVariable } from "../../utils/env.js";
 import { AttestorError, ethersStructToPlainObject } from "../../utils/index.js";
-const ACCEPT_CLAIM_PAYMENT_REQUESTS = getEnvVariable("ACCEPT_CLAIM_PAYMENT_REQUESTS") === "1";
-const completeClaimOnChain = async ({ chainId: chainIdNum, taskIndex, completedTaskJson }) => {
-  if (!ACCEPT_CLAIM_PAYMENT_REQUESTS) {
-    throw new AttestorError(
-      "ERROR_PAYMENT_REFUSED",
-      "Payment requests are not accepted at this time"
-    );
-  }
-  const chainId = chainIdNum.toString();
-  const { contract } = getContracts(chainId.toString());
-  const task = JSON.parse(completedTaskJson);
-  const tx = await contract.taskCompleted(task, taskIndex);
-  const rslt = await tx.wait();
-  const logs = rslt?.logs ?? [];
-  const eventLogs = logs.filter((log) => log instanceof EventLog);
-  const obj = eventLogs[0]?.args;
-  const plainObj = ethersStructToPlainObject(obj);
-  return {
-    txHash: rslt?.hash ?? "",
-    taskCompletedObjectJson: JSON.stringify(plainObj)
-  };
-};
-export {
-  completeClaimOnChain
+const ACCEPT_CLAIM_PAYMENT_REQUESTS = getEnvVariable('ACCEPT_CLAIM_PAYMENT_REQUESTS') === '1';
+export const completeClaimOnChain = async ({ chainId: chainIdNum, taskIndex, completedTaskJson }) => {
+    if (!ACCEPT_CLAIM_PAYMENT_REQUESTS) {
+        throw new AttestorError('ERROR_PAYMENT_REFUSED', 'Payment requests are not accepted at this time');
+    }
+    const chainId = chainIdNum.toString();
+    const { contract } = getContracts(chainId.toString());
+    const task = JSON.parse(completedTaskJson);
+    const tx = await contract.taskCompleted(task, taskIndex);
+    const rslt = await tx.wait();
+    // check task created event was emitted
+    const logs = rslt?.logs ?? [];
+    const eventLogs = logs.filter((log) => log instanceof EventLog);
+    const obj = eventLogs[0]?.args;
+    const plainObj = ethersStructToPlainObject(obj);
+    return {
+        txHash: rslt?.hash ?? '',
+        taskCompletedObjectJson: JSON.stringify(plainObj)
+    };
 };

package/lib/server/handlers/createClaimOnChain.js

@@ -2,31 +2,25 @@ import { getContracts } from "../../avs/utils/contracts.js";
 import { createNewClaimRequestOnChain } from "../../avs/utils/tasks.js";
 import { getEnvVariable } from "../../utils/env.js";
 import { AttestorError, ethersStructToPlainObject } from "../../utils/index.js";
-const ACCEPT_CLAIM_PAYMENT_REQUESTS = getEnvVariable("ACCEPT_CLAIM_PAYMENT_REQUESTS") === "1";
-const createClaimOnChain = async ({ chainId: chainIdNum, jsonCreateClaimRequest, requestSignature }) => {
-  if (!ACCEPT_CLAIM_PAYMENT_REQUESTS) {
-    throw new AttestorError(
-      "ERROR_PAYMENT_REFUSED",
-      "Payment requests are not accepted at this time"
-    );
-  }
-  const chainId = chainIdNum.toString();
-  const { wallet } = getContracts(chainId.toString());
-  const request = JSON.parse(jsonCreateClaimRequest);
-  const { task, tx } = await createNewClaimRequestOnChain({
-    request,
-    owner: request.owner,
-    payer: wallet,
-    chainId,
-    requestSignature
-  });
-  const plainTask = ethersStructToPlainObject(task);
-  return {
-    txHash: tx?.hash ?? "",
-    taskIndex: Number(task.taskIndex),
-    jsonTask: JSON.stringify(plainTask)
-  };
-};
-export {
-  createClaimOnChain
+const ACCEPT_CLAIM_PAYMENT_REQUESTS = getEnvVariable('ACCEPT_CLAIM_PAYMENT_REQUESTS') === '1';
+export const createClaimOnChain = async ({ chainId: chainIdNum, jsonCreateClaimRequest, requestSignature }) => {
+    if (!ACCEPT_CLAIM_PAYMENT_REQUESTS) {
+        throw new AttestorError('ERROR_PAYMENT_REFUSED', 'Payment requests are not accepted at this time');
+    }
+    const chainId = chainIdNum.toString();
+    const { wallet } = getContracts(chainId.toString());
+    const request = JSON.parse(jsonCreateClaimRequest);
+    const { task, tx } = await createNewClaimRequestOnChain({
+        request,
+        owner: request.owner,
+        payer: wallet,
+        chainId,
+        requestSignature: requestSignature
+    });
+    const plainTask = ethersStructToPlainObject(task);
+    return {
+        txHash: tx?.hash ?? '',
+        taskIndex: Number(task.taskIndex),
+        jsonTask: JSON.stringify(plainTask)
+    };
 };

package/lib/server/handlers/createTaskOnMechain.js

@@ -1,57 +1,47 @@
-import { Contract, JsonRpcProvider, randomBytes, Wallet } from "ethers";
+import { Contract, JsonRpcProvider, randomBytes, Wallet } from 'ethers';
 import { governanceABI } from "../../mechain/abis/governanceABI.js";
 import { taskABI } from "../../mechain/abis/taskABI.js";
 import { GOVERNANCE_CONTRACT_ADDRESS, RPC_URL, TASK_CONTRACT_ADDRESS } from "../../mechain/constants/index.js";
 import { getEnvVariable } from "../../utils/env.js";
-const createTaskOnMechain = async ({
-  timestamp
-}) => {
-  const { taskContract } = await getContracts();
-  const seed = randomBytes(32);
-  const result = await taskContract.createNewTaskRequest.staticCall(
-    seed,
-    timestamp
-  );
-  const taskId = result[0];
-  const requiredAttestors = await taskContract.requiredAttestors();
-  const hosts = [];
-  for (let i = 0; i < requiredAttestors; i++) {
-    hosts.push(result[1][i].host);
-  }
-  const tx = await taskContract.createNewTaskRequest(seed, timestamp);
-  await tx.wait();
-  return {
-    taskId,
-    requiredAttestors,
-    hosts
-  };
+export const createTaskOnMechain = async ({ timestamp }) => {
+    const { taskContract } = await getContracts();
+    const seed = randomBytes(32);
+    // Perform a static call to fetch taskId and attestors for the next task
+    const result = await taskContract.createNewTaskRequest.staticCall(seed, timestamp);
+    const taskId = result[0];
+    // Fetch requiredAttestors to determine how many proofs to request
+    const requiredAttestors = await taskContract.requiredAttestors();
+    const hosts = [];
+    // Fetch attestors's WebSocket URI, e.g. wss://attestor.reclaimprotocol.org:444/ws
+    for (let i = 0; i < requiredAttestors; i++) {
+        hosts.push(result[1][i].host);
+    }
+    // Perform the call that was statically-called previously
+    const tx = await taskContract.createNewTaskRequest(seed, timestamp);
+    await tx.wait();
+    return {
+        taskId: taskId,
+        requiredAttestors: requiredAttestors,
+        hosts: hosts
+    };
 };
 async function getContracts() {
-  const privateKey = getEnvVariable("MECHAIN_PRIVATE_KEY");
-  const taskContractAddress = getEnvVariable("TASK_CONTRACT_ADDRESS") || TASK_CONTRACT_ADDRESS;
-  const governanceContractAddress = getEnvVariable("GOVERNANCE_CONTRACT_ADDRESS") || GOVERNANCE_CONTRACT_ADDRESS;
-  if (!privateKey) {
-    throw new Error("MECHAIN_PRIVATE_KEY environment variable is not set");
-  }
-  try {
-    const provider = new JsonRpcProvider(RPC_URL);
-    await provider.getNetwork();
-    const signer = new Wallet(privateKey, provider);
-    const taskContract = new Contract(
-      taskContractAddress,
-      taskABI,
-      signer
-    );
-    const governanceContract = new Contract(
-      governanceContractAddress,
-      governanceABI,
-      signer
-    );
-    return { taskContract, governanceContract };
-  } catch (error) {
-    throw new Error(`Failed to initialize contracts: ${error.message || error}`);
-  }
+    const privateKey = getEnvVariable('MECHAIN_PRIVATE_KEY');
+    const taskContractAddress = getEnvVariable('TASK_CONTRACT_ADDRESS') || TASK_CONTRACT_ADDRESS;
+    const governanceContractAddress = getEnvVariable('GOVERNANCE_CONTRACT_ADDRESS') || GOVERNANCE_CONTRACT_ADDRESS;
+    if (!privateKey) {
+        throw new Error('MECHAIN_PRIVATE_KEY environment variable is not set');
+    }
+    try {
+        const provider = new JsonRpcProvider(RPC_URL);
+        // Validate connection to provider
+        await provider.getNetwork();
+        const signer = new Wallet(privateKey, provider);
+        const taskContract = new Contract(taskContractAddress, taskABI, signer);
+        const governanceContract = new Contract(governanceContractAddress, governanceABI, signer);
+        return { taskContract, governanceContract };
+    }
+    catch (error) {
+        throw new Error(`Failed to initialize contracts: ${error.message || error}`);
+    }
 }
-export {
-  createTaskOnMechain
-};

package/lib/server/handlers/createTunnel.js

@@ -1,98 +1,93 @@
-import { makeTcpTunnel } from "../../server/tunnels/make-tcp-tunnel.js";
-import { getApm } from "../../server/utils/apm.js";
-import { resolveHostnames } from "../../server/utils/dns.js";
+import { makeTcpTunnel } from "../tunnels/make-tcp-tunnel.js";
+import { getApm } from "../utils/apm.js";
+import { resolveHostnames } from "../utils/dns.js";
 import { AttestorError } from "../../utils/index.js";
-const createTunnel = async ({ id, ...opts }, { tx, logger, client }) => {
-  if (client.tunnels[id]) {
-    throw AttestorError.badRequest(`Tunnel "${id}" already exists`);
-  }
-  const allowedHosts = client.metadata?.auth?.data?.hostWhitelist;
-  if (allowedHosts?.length && !allowedHosts.includes(opts.host)) {
-    throw AttestorError.badRequest(
-      `Host "${opts.host}" not allowed by auth request`
-    );
-  }
-  let cancelBgp;
-  const apm = getApm();
-  const sessionTx = apm?.startTransaction("tunnelConnection", { childOf: tx });
-  sessionTx?.setLabel("tunnelId", id.toString());
-  sessionTx?.setLabel("hostPort", `${opts.host}:${opts.port}`);
-  sessionTx?.setLabel("geoLocation", opts.geoLocation);
-  sessionTx?.setLabel("proxySessionId", opts.proxySessionId);
-  try {
-    const tunnel = await makeTcpTunnel({
-      ...opts,
-      logger,
-      onMessage(message) {
-        if (!client.isOpen) {
-          logger.warn("client is closed, dropping message");
-          return;
+export const createTunnel = async ({ id, ...opts }, { tx, logger, client }) => {
+    if (client.tunnels[id]) {
+        throw AttestorError.badRequest(`Tunnel "${id}" already exists`);
+    }
+    const allowedHosts = client.metadata?.auth?.data?.hostWhitelist;
+    if (allowedHosts?.length && !allowedHosts.includes(opts.host)) {
+        throw AttestorError.badRequest(`Host "${opts.host}" not allowed by auth request`);
+    }
+    let cancelBgp;
+    const apm = getApm();
+    const sessionTx = apm
+        ?.startTransaction('tunnelConnection', { childOf: tx });
+    sessionTx?.setLabel('tunnelId', id.toString());
+    sessionTx?.setLabel('hostPort', `${opts.host}:${opts.port}`);
+    sessionTx?.setLabel('geoLocation', opts.geoLocation);
+    sessionTx?.setLabel('proxySessionId', opts.proxySessionId);
+    try {
+        const tunnel = await makeTcpTunnel({
+            ...opts,
+            logger,
+            onMessage(message) {
+                if (!client.isOpen) {
+                    logger.warn('client is closed, dropping message');
+                    return;
+                }
+                return client
+                    .sendMessage({ tunnelMessage: { tunnelId: id, message } });
+            },
+            onClose(err) {
+                cancelBgp?.();
+                if (err) {
+                    apm?.captureError(err, { parent: sessionTx });
+                    sessionTx?.setOutcome('failure');
+                }
+                else {
+                    sessionTx?.setOutcome('success');
+                }
+                sessionTx?.end();
+                if (!client.isOpen) {
+                    return;
+                }
+                client.sendMessage({
+                    tunnelDisconnectEvent: {
+                        tunnelId: id,
+                        error: err
+                            ? AttestorError
+                                .fromError(err)
+                                .toProto()
+                            : undefined
+                    }
+                })
+                    .catch(err => {
+                    logger.error({ err }, 'failed to send tunnel disconnect event');
+                });
+            },
+        });
+        try {
+            await checkForBgp(tunnel);
         }
-        return client.sendMessage({ tunnelMessage: { tunnelId: id, message } });
-      },
-      onClose(err) {
-        cancelBgp?.();
-        if (err) {
-          apm?.captureError(err, { parent: sessionTx });
-          sessionTx?.setOutcome("failure");
-        } else {
-          sessionTx?.setOutcome("success");
+        catch (err) {
+            logger.warn({ err, host: opts.host }, 'failed to start BGP overlap check');
         }
+        client.tunnels[id] = tunnel;
+        return {};
+    }
+    catch (err) {
+        apm?.captureError(err, { parent: sessionTx });
+        sessionTx?.setOutcome('failure');
         sessionTx?.end();
-        if (!client.isOpen) {
-          return;
+        cancelBgp?.();
+        throw err;
+    }
+    async function checkForBgp(tunnel) {
+        if (!client.bgpListener) {
+            return;
         }
-        client.sendMessage({
-          tunnelDisconnectEvent: {
-            tunnelId: id,
-            error: err ? AttestorError.fromError(err).toProto() : void 0
-          }
-        }).catch((err2) => {
-          logger.error(
-            { err: err2 },
-            "failed to send tunnel disconnect event"
-          );
+        // listen to all IPs for the host -- in case any of them
+        // has a BGP announcement overlap, we'll close the tunnel
+        // so the user can retry
+        const ips = await resolveHostnames(opts.host);
+        cancelBgp = client.bgpListener.onOverlap(ips, (info) => {
+            logger.warn({ info, host: opts.host }, 'BGP announcement overlap detected');
+            // track how many times we've seen a BGP overlap
+            sessionTx?.addLabels({ bgpOverlap: true, ...info });
+            void tunnel?.close(new AttestorError('ERROR_BGP_ANNOUNCEMENT_OVERLAP', `BGP announcement overlap detected for ${opts.host}`));
         });
-      }
-    });
-    try {
-      await checkForBgp(tunnel);
-    } catch (err) {
-      logger.warn(
-        { err, host: opts.host },
-        "failed to start BGP overlap check"
-      );
+        logger.debug({ ips }, 'checking for BGP overlap');
     }
-    client.tunnels[id] = tunnel;
-    return {};
-  } catch (err) {
-    apm?.captureError(err, { parent: sessionTx });
-    sessionTx?.setOutcome("failure");
-    sessionTx?.end();
-    cancelBgp?.();
-    throw err;
-  }
-  async function checkForBgp(tunnel) {
-    if (!client.bgpListener) {
-      return;
-    }
-    const ips = await resolveHostnames(opts.host);
-    cancelBgp = client.bgpListener.onOverlap(ips, (info) => {
-      logger.warn(
-        { info, host: opts.host },
-        "BGP announcement overlap detected"
-      );
-      sessionTx?.addLabels({ bgpOverlap: true, ...info });
-      void tunnel?.close(
-        new AttestorError(
-          "ERROR_BGP_ANNOUNCEMENT_OVERLAP",
-          `BGP announcement overlap detected for ${opts.host}`
-        )
-      );
-    });
-    logger.debug({ ips }, "checking for BGP overlap");
-  }
-};
-export {
-  createTunnel
 };

package/lib/server/handlers/disconnectTunnel.js

@@ -1,8 +1,5 @@
-const disconnectTunnel = async ({ id }, { client }) => {
-  const tunnel = client.getTunnel(id);
-  await tunnel.close();
-  return {};
-};
-export {
-  disconnectTunnel
+export const disconnectTunnel = async ({ id }, { client }) => {
+    const tunnel = client.getTunnel(id);
+    await tunnel.close();
+    return {};
 };

package/lib/server/handlers/fetchCertificateBytes.js

@@ -1,57 +1,41 @@
-import { concatenateUint8Arrays, loadX509FromPem } from "@reclaimprotocol/tls";
+import { concatenateUint8Arrays, loadX509FromPem } from '@reclaimprotocol/tls';
 import { CERT_ALLOWED_MIMETYPES, MAX_CERT_SIZE_BYTES } from "../../config/index.js";
 import { AttestorError } from "../../utils/error.js";
-const fetchCertificateBytes = async ({ url }) => {
-  const res = await fetch(url, {
-    redirect: "follow",
-    signal: AbortSignal.timeout(1e4)
-  });
-  if (!res.ok) {
-    res.body?.cancel("Not ok");
-    throw new AttestorError(
-      "ERROR_CERTIFICATE_FETCH_FAILED",
-      `Failed to fetch certificate from URL: ${url}, status: ${res.status}`
-    );
-  }
-  const contentType = res.headers.get("content-type");
-  if (!contentType || !CERT_ALLOWED_MIMETYPES.includes(contentType)) {
-    res.body?.cancel("Mismatch");
-    throw new AttestorError(
-      "ERROR_CERTIFICATE_FETCH_FAILED",
-      `Invalid content-type when fetching certificate from URL: ${url}, content-type: ${contentType}`
-    );
-  }
-  if (!res.body) {
-    throw new AttestorError(
-      "ERROR_CERTIFICATE_FETCH_FAILED",
-      `No body in response when fetching certificate from URL: ${url}`
-    );
-  }
-  let total = 0;
-  const byteArr = [];
-  for await (const chunk of res.body) {
-    total += chunk.length;
-    if (total > MAX_CERT_SIZE_BYTES) {
-      res.body.cancel("Too many bytes");
-      throw new AttestorError(
-        "ERROR_CERTIFICATE_FETCH_FAILED",
-        `Certificate size exceeds maximum limit of ${MAX_CERT_SIZE_BYTES}b`
-      );
+export const fetchCertificateBytes = async ({ url }) => {
+    const res = await fetch(url, {
+        redirect: 'follow',
+        signal: AbortSignal.timeout(10_000)
+    });
+    if (!res.ok) {
+        res.body?.cancel('Not ok');
+        throw new AttestorError('ERROR_CERTIFICATE_FETCH_FAILED', `Failed to fetch certificate from URL: ${url}, status: ${res.status}`);
     }
-    byteArr.push(chunk);
-  }
-  const bytes = concatenateUint8Arrays(byteArr);
-  try {
-    const cert = loadX509FromPem(bytes);
-    TLS_INTERMEDIATE_CA_CACHE[url] = cert;
-  } catch (err) {
-    throw new AttestorError(
-      "ERROR_CERTIFICATE_FETCH_FAILED",
-      `Failed to parse certificate, error: ${err.message}`
-    );
-  }
-  return { bytes: concatenateUint8Arrays(byteArr) };
-};
-export {
-  fetchCertificateBytes
+    const contentType = res.headers.get('content-type');
+    if (!contentType || !CERT_ALLOWED_MIMETYPES.includes(contentType)) {
+        res.body?.cancel('Mismatch');
+        throw new AttestorError('ERROR_CERTIFICATE_FETCH_FAILED', `Invalid content-type when fetching certificate from URL: ${url},`
+            + ` content-type: ${contentType}`);
+    }
+    if (!res.body) {
+        throw new AttestorError('ERROR_CERTIFICATE_FETCH_FAILED', `No body in response when fetching certificate from URL: ${url}`);
+    }
+    let total = 0;
+    const byteArr = [];
+    for await (const chunk of res.body) {
+        total += chunk.length;
+        if (total > MAX_CERT_SIZE_BYTES) {
+            res.body.cancel('Too many bytes');
+            throw new AttestorError('ERROR_CERTIFICATE_FETCH_FAILED', `Certificate size exceeds maximum limit of ${MAX_CERT_SIZE_BYTES}b`);
+        }
+        byteArr.push(chunk);
+    }
+    const bytes = concatenateUint8Arrays(byteArr);
+    try {
+        const cert = loadX509FromPem(bytes);
+        TLS_INTERMEDIATE_CA_CACHE[url] = cert;
+    }
+    catch (err) {
+        throw new AttestorError('ERROR_CERTIFICATE_FETCH_FAILED', `Failed to parse certificate, error: ${err.message}`);
+    }
+    return { bytes: concatenateUint8Arrays(byteArr) };
 };

package/lib/server/handlers/index.js

@@ -1,25 +1,22 @@
-import { claimTeeBundle } from "../../server/handlers/claimTeeBundle.js";
-import { claimTunnel } from "../../server/handlers/claimTunnel.js";
-import { completeClaimOnChain } from "../../server/handlers/completeClaimOnChain.js";
-import { createClaimOnChain } from "../../server/handlers/createClaimOnChain.js";
-import { createTaskOnMechain } from "../../server/handlers/createTaskOnMechain.js";
-import { createTunnel } from "../../server/handlers/createTunnel.js";
-import { disconnectTunnel } from "../../server/handlers/disconnectTunnel.js";
-import { fetchCertificateBytes } from "../../server/handlers/fetchCertificateBytes.js";
-import { init } from "../../server/handlers/init.js";
-import { toprf } from "../../server/handlers/toprf.js";
-const HANDLERS = {
-  createTunnel,
-  disconnectTunnel,
-  claimTunnel,
-  claimTeeBundle,
-  init,
-  createClaimOnChain,
-  completeClaimOnChain,
-  toprf,
-  createTaskOnMechain,
-  fetchCertificateBytes
-};
-export {
-  HANDLERS
+import { claimTeeBundle } from "./claimTeeBundle.js";
+import { claimTunnel } from "./claimTunnel.js";
+import { completeClaimOnChain } from "./completeClaimOnChain.js";
+import { createClaimOnChain } from "./createClaimOnChain.js";
+import { createTaskOnMechain } from "./createTaskOnMechain.js";
+import { createTunnel } from "./createTunnel.js";
+import { disconnectTunnel } from "./disconnectTunnel.js";
+import { fetchCertificateBytes } from "./fetchCertificateBytes.js";
+import { init } from "./init.js";
+import { toprf } from "./toprf.js";
+export const HANDLERS = {
+    createTunnel,
+    disconnectTunnel,
+    claimTunnel,
+    claimTeeBundle,
+    init,
+    createClaimOnChain,
+    completeClaimOnChain,
+    toprf,
+    createTaskOnMechain,
+    fetchCertificateBytes
 };

package/lib/server/handlers/init.js

@@ -1,33 +1,32 @@
-import { getBytes } from "ethers";
-import { getAttestorAddress } from "../../server/utils/generics.js";
+import { getBytes } from 'ethers';
+import { getAttestorAddress } from "../utils/generics.js";
 import { assertValidAuthRequest } from "../../utils/auth.js";
 import { getEnvVariable } from "../../utils/env.js";
 import { AttestorError } from "../../utils/index.js";
 import { SIGNATURES } from "../../utils/signatures/index.js";
-const TOPRF_PUBLIC_KEY = getEnvVariable("TOPRF_PUBLIC_KEY");
-const init = async (initRequest, { client }) => {
-  if (client.isInitialised) {
-    throw AttestorError.badRequest("Client already initialised");
-  }
-  if (!SIGNATURES[initRequest.signatureType]) {
-    throw AttestorError.badRequest("Unsupported signature type");
-  }
-  if (initRequest.clientVersion <= 0) {
-    throw AttestorError.badRequest("Unsupported client version");
-  }
-  await assertValidAuthRequest(initRequest.auth, initRequest.signatureType);
-  if (initRequest.auth?.data) {
-    client.logger = client.logger.child({
-      userId: initRequest.auth.data.id
-    });
-  }
-  client.metadata = initRequest;
-  client.isInitialised = true;
-  return {
-    toprfPublicKey: TOPRF_PUBLIC_KEY ? getBytes(TOPRF_PUBLIC_KEY) : new Uint8Array(),
-    attestorAddress: getAttestorAddress(initRequest.signatureType)
-  };
-};
-export {
-  init
+const TOPRF_PUBLIC_KEY = getEnvVariable('TOPRF_PUBLIC_KEY');
+export const init = async (initRequest, { client }) => {
+    if (client.isInitialised) {
+        throw AttestorError.badRequest('Client already initialised');
+    }
+    if (!SIGNATURES[initRequest.signatureType]) {
+        throw AttestorError.badRequest('Unsupported signature type');
+    }
+    if (initRequest.clientVersion <= 0) {
+        throw AttestorError.badRequest('Unsupported client version');
+    }
+    await assertValidAuthRequest(initRequest.auth, initRequest.signatureType);
+    if (initRequest.auth?.data) {
+        client.logger = client.logger.child({
+            userId: initRequest.auth.data.id
+        });
+    }
+    client.metadata = initRequest;
+    client.isInitialised = true;
+    return {
+        toprfPublicKey: TOPRF_PUBLIC_KEY
+            ? getBytes(TOPRF_PUBLIC_KEY)
+            : new Uint8Array(),
+        attestorAddress: getAttestorAddress(initRequest.signatureType)
+    };
 };

package/lib/server/handlers/toprf.js

@@ -1,19 +1,16 @@
-import { getBytes } from "ethers";
+import { getBytes } from 'ethers';
 import { getEnvVariable } from "../../utils/env.js";
 import { getEngineString, makeDefaultOPRFOperator } from "../../utils/index.js";
-const toprf = async ({ maskedData, engine }, { logger }) => {
-  const PRIVATE_KEY_STR = getEnvVariable("TOPRF_SHARE_PRIVATE_KEY");
-  const PUBLIC_KEY_STR = getEnvVariable("TOPRF_SHARE_PUBLIC_KEY");
-  if (!PRIVATE_KEY_STR || !PUBLIC_KEY_STR) {
-    throw new Error("private/public keys not set. Cannot execute OPRF");
-  }
-  const PRIVATE_KEY = getBytes(PRIVATE_KEY_STR);
-  const PUBLIC_KEY = getBytes(PUBLIC_KEY_STR);
-  const engineStr = getEngineString(engine);
-  const operator = makeDefaultOPRFOperator("chacha20", engineStr, logger);
-  const res = await operator.evaluateOPRF(PRIVATE_KEY, maskedData);
-  return { ...res, publicKeyShare: PUBLIC_KEY };
-};
-export {
-  toprf
+export const toprf = async ({ maskedData, engine }, { logger }) => {
+    const PRIVATE_KEY_STR = getEnvVariable('TOPRF_SHARE_PRIVATE_KEY');
+    const PUBLIC_KEY_STR = getEnvVariable('TOPRF_SHARE_PUBLIC_KEY');
+    if (!PRIVATE_KEY_STR || !PUBLIC_KEY_STR) {
+        throw new Error('private/public keys not set. Cannot execute OPRF');
+    }
+    const PRIVATE_KEY = getBytes(PRIVATE_KEY_STR);
+    const PUBLIC_KEY = getBytes(PUBLIC_KEY_STR);
+    const engineStr = getEngineString(engine);
+    const operator = makeDefaultOPRFOperator('chacha20', engineStr, logger);
+    const res = await operator.evaluateOPRF(PRIVATE_KEY, maskedData);
+    return { ...res, publicKeyShare: PUBLIC_KEY };
 };