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

package/lib/client/utils/message-handler.js

@@ -1,97 +1,87 @@
 import { RPCMessages } from "../../proto/api.js";
 import { AttestorError, extractArrayBufferFromWsData, getRpcRequest, getRpcRequestType, getRpcResponseType } from "../../utils/index.js";
-async function wsMessageHandler(data) {
-  const buff = await extractArrayBufferFromWsData(data);
-  const { messages } = RPCMessages.decode(buff);
-  for (const msg of messages) {
-    await handleMessage.call(this, msg);
-  }
-}
-function handleMessage(msg) {
-  this.logger?.trace({ msg }, "received message");
-  if (msg.connectionTerminationAlert) {
-    const err = AttestorError.fromProto(
-      msg.connectionTerminationAlert
-    );
-    this.logger?.warn(
-      {
-        err: err.code !== "ERROR_NO_ERROR" ? err : void 0
-      },
-      "received connection termination alert"
-    );
-    this.dispatchRPCEvent("connection-terminated", err);
-    return;
-  }
-  const rpcRequest = getRpcRequest(msg);
-  if (rpcRequest) {
-    if (rpcRequest.direction === "response" && rpcRequest.type === "error") {
-      this.dispatchRPCEvent("rpc-response", {
-        id: msg.id,
-        error: AttestorError.fromProto(msg.requestError)
-      });
-      return;
-    }
-    const resType = getRpcResponseType(rpcRequest.type);
-    if (rpcRequest.direction === "response") {
-      this.dispatchRPCEvent("rpc-response", {
-        id: msg.id,
-        type: rpcRequest.type,
-        data: msg[resType]
-      });
-      return;
+export async function wsMessageHandler(data) {
+    // extract array buffer from WS data & decode proto
+    const buff = await extractArrayBufferFromWsData(data);
+    const { messages } = RPCMessages.decode(buff);
+    for (const msg of messages) {
+        await handleMessage.call(this, msg);
     }
-    if (!this.isInitialised && rpcRequest.type !== "init") {
-      this.logger.warn(
-        { type: rpcRequest.type },
-        "RPC request received before initialisation"
-      );
-      void this.sendMessage({
-        id: msg.id,
-        requestError: AttestorError.badRequest("Initialise connection first").toProto()
-      });
-      return;
+}
+export function handleMessage(msg) {
+    this.logger?.trace({ msg }, 'received message');
+    // handle connection termination alert
+    if (msg.connectionTerminationAlert) {
+        const err = AttestorError.fromProto(msg.connectionTerminationAlert);
+        this.logger?.warn({
+            err: err.code !== 'ERROR_NO_ERROR'
+                ? err
+                : undefined
+        }, 'received connection termination alert');
+        this.dispatchRPCEvent('connection-terminated', err);
+        return;
     }
-    return new Promise((resolve, reject) => {
-      this.dispatchRPCEvent("rpc-request", {
-        requestId: msg.id,
-        type: rpcRequest.type,
-        data: msg[getRpcRequestType(rpcRequest.type)],
-        respond: (res) => {
-          if (!this.isOpen) {
-            this.logger?.debug(
-              { type: rpcRequest.type, res },
-              "connection closed before responding"
-            );
-            reject(new Error("connection closed"));
+    const rpcRequest = getRpcRequest(msg);
+    if (rpcRequest) {
+        if (rpcRequest.direction === 'response'
+            && rpcRequest.type === 'error') {
+            this.dispatchRPCEvent('rpc-response', {
+                id: msg.id,
+                error: AttestorError.fromProto(msg.requestError)
+            });
             return;
-          }
-          if ("code" in res) {
-            reject(res);
-            return this.sendMessage({
-              id: msg.id,
-              requestError: res.toProto()
+        }
+        const resType = getRpcResponseType(rpcRequest.type);
+        if (rpcRequest.direction === 'response') {
+            this.dispatchRPCEvent('rpc-response', {
+                id: msg.id,
+                type: rpcRequest.type,
+                data: msg[resType]
             });
-          }
-          resolve();
-          return this.sendMessage({ id: msg.id, [resType]: res });
+            return;
         }
-      });
-    });
-  }
-  if (msg.tunnelMessage) {
-    this.dispatchRPCEvent("tunnel-message", msg.tunnelMessage);
-    return;
-  }
-  if (msg.tunnelDisconnectEvent) {
-    this.dispatchRPCEvent(
-      "tunnel-disconnect-event",
-      msg.tunnelDisconnectEvent
-    );
-    return;
-  }
-  this.logger.warn({ msg }, "unhandled message");
+        if (!this.isInitialised && rpcRequest.type !== 'init') {
+            this.logger.warn({ type: rpcRequest.type }, 'RPC request received before initialisation');
+            void this.sendMessage({
+                id: msg.id,
+                requestError: AttestorError
+                    .badRequest('Initialise connection first')
+                    .toProto()
+            });
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            this.dispatchRPCEvent('rpc-request', {
+                requestId: msg.id,
+                type: rpcRequest.type,
+                data: msg[getRpcRequestType(rpcRequest.type)],
+                respond: (res) => {
+                    if (!this.isOpen) {
+                        this.logger?.debug({ type: rpcRequest.type, res }, 'connection closed before responding');
+                        reject(new Error('connection closed'));
+                        return;
+                    }
+                    if ('code' in res) {
+                        reject(res);
+                        return this.sendMessage({
+                            id: msg.id,
+                            requestError: res.toProto()
+                        });
+                    }
+                    resolve();
+                    return this
+                        .sendMessage({ id: msg.id, [resType]: res });
+                },
+            });
+        });
+    }
+    if (msg.tunnelMessage) {
+        this.dispatchRPCEvent('tunnel-message', msg.tunnelMessage);
+        return;
+    }
+    if (msg.tunnelDisconnectEvent) {
+        this.dispatchRPCEvent('tunnel-disconnect-event', msg.tunnelDisconnectEvent);
+        return;
+    }
+    this.logger.warn({ msg }, 'unhandled message');
 }
-export {
-  handleMessage,
-  wsMessageHandler
-};

package/lib/config/index.js

@@ -1,62 +1,44 @@
 import { AttestorVersion, ServiceSignatureType } from "../proto/api.js";
-const DEFAULT_ZK_CONCURRENCY = 10;
-const RECLAIM_USER_AGENT = "reclaim/0.0.1";
-const DEFAULT_HTTPS_PORT = 443;
-const WS_PATHNAME = "/ws";
-const BROWSER_RPC_PATHNAME = "/browser-rpc";
-const ATTESTOR_ADDRESS_PATHNAME = "/address";
-const DEFAULT_REMOTE_FILE_FETCH_BASE_URL = `${BROWSER_RPC_PATHNAME}/resources`;
-const API_SERVER_PORT = 8001;
-const CONNECTION_TIMEOUT_MS = 1e4;
-const DNS_SERVERS = [
-  "8.8.8.8",
-  "8.8.4.4"
+export const DEFAULT_ZK_CONCURRENCY = 10;
+export const RECLAIM_USER_AGENT = 'reclaim/0.0.1';
+export const DEFAULT_HTTPS_PORT = 443;
+export const WS_PATHNAME = '/ws';
+export const BROWSER_RPC_PATHNAME = '/browser-rpc';
+export const ATTESTOR_ADDRESS_PATHNAME = '/address';
+export const DEFAULT_REMOTE_FILE_FETCH_BASE_URL = `${BROWSER_RPC_PATHNAME}/resources`;
+export const API_SERVER_PORT = 8001;
+// 10s
+export const CONNECTION_TIMEOUT_MS = 10_000;
+export const DNS_SERVERS = [
+    '8.8.8.8',
+    '8.8.4.4'
 ];
-const MAX_CLAIM_TIMESTAMP_DIFF_S = 10 * 60;
-const CURRENT_ATTESTOR_VERSION = AttestorVersion.ATTESTOR_VERSION_3_0_0;
-const DEFAULT_METADATA = {
-  signatureType: ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH,
-  clientVersion: CURRENT_ATTESTOR_VERSION,
-  auth: void 0
+// 10m
+export const MAX_CLAIM_TIMESTAMP_DIFF_S = 10 * 60;
+export const CURRENT_ATTESTOR_VERSION = AttestorVersion.ATTESTOR_VERSION_3_0_0;
+export const DEFAULT_METADATA = {
+    signatureType: ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH,
+    clientVersion: CURRENT_ATTESTOR_VERSION,
+    auth: undefined
 };
-const PROVIDER_CTX = { version: CURRENT_ATTESTOR_VERSION };
-const PING_INTERVAL_MS = 1e4;
-const MAX_NO_DATA_INTERVAL_MS = 3e4;
-const MAX_PAYLOAD_SIZE = 512 * 1024 * 1024;
-const DEFAULT_AUTH_EXPIRY_S = 15 * 60;
-const DEFAULT_RPC_TIMEOUT_MS = 9e4;
-const TOPRF_DOMAIN_SEPARATOR = "reclaim-toprf";
-const MAX_CERT_SIZE_BYTES = 10 * 1024 * 1024 * 1024;
-const CERT_ALLOWED_MIMETYPES = [
-  "application/x-x509-ca-cert",
-  "application/x-x509-user-cert",
-  "application/pkix-cert",
-  "application/pkcs7-mime",
-  "application/octet-stream"
+export const PROVIDER_CTX = { version: CURRENT_ATTESTOR_VERSION };
+export const PING_INTERVAL_MS = 10_000;
+/**
+ * Maximum interval in seconds to wait for before assuming
+ * the connection is dead
+ * @default 30s
+ */
+export const MAX_NO_DATA_INTERVAL_MS = 30_000;
+export const MAX_PAYLOAD_SIZE = 512 * 1024 * 1024; // 512MB
+export const DEFAULT_AUTH_EXPIRY_S = 15 * 60; // 15m
+export const DEFAULT_RPC_TIMEOUT_MS = 90_000;
+export const TOPRF_DOMAIN_SEPARATOR = 'reclaim-toprf';
+export const MAX_CERT_SIZE_BYTES = 10 * 1024 * 1024 * 1024; // 10MB
+export const CERT_ALLOWED_MIMETYPES = [
+    'application/x-x509-ca-cert',
+    'application/x-x509-user-cert',
+    'application/pkix-cert',
+    'application/pkcs7-mime',
+    'application/octet-stream'
 ];
-const BGP_WS_URL = "wss://ris-live.ripe.net/v1/ws/?client=reclaim-hijack-detector";
-export {
-  API_SERVER_PORT,
-  ATTESTOR_ADDRESS_PATHNAME,
-  BGP_WS_URL,
-  BROWSER_RPC_PATHNAME,
-  CERT_ALLOWED_MIMETYPES,
-  CONNECTION_TIMEOUT_MS,
-  CURRENT_ATTESTOR_VERSION,
-  DEFAULT_AUTH_EXPIRY_S,
-  DEFAULT_HTTPS_PORT,
-  DEFAULT_METADATA,
-  DEFAULT_REMOTE_FILE_FETCH_BASE_URL,
-  DEFAULT_RPC_TIMEOUT_MS,
-  DEFAULT_ZK_CONCURRENCY,
-  DNS_SERVERS,
-  MAX_CERT_SIZE_BYTES,
-  MAX_CLAIM_TIMESTAMP_DIFF_S,
-  MAX_NO_DATA_INTERVAL_MS,
-  MAX_PAYLOAD_SIZE,
-  PING_INTERVAL_MS,
-  PROVIDER_CTX,
-  RECLAIM_USER_AGENT,
-  TOPRF_DOMAIN_SEPARATOR,
-  WS_PATHNAME
-};
+export const BGP_WS_URL = 'wss://ris-live.ripe.net/v1/ws/?client=reclaim-hijack-detector';

package/lib/external-rpc/benchmark.js

@@ -1,82 +1,69 @@
-import {
-  crypto,
-  encryptWrappedRecord,
-  SUPPORTED_CIPHER_SUITE_MAP
-} from "@reclaimprotocol/tls";
+import { crypto, encryptWrappedRecord, SUPPORTED_CIPHER_SUITE_MAP } from '@reclaimprotocol/tls';
 import { strToUint8Array } from "../utils/generics.js";
 import { logger } from "../utils/logger.js";
 import { makeZkProofGenerator } from "../utils/zk.js";
 const ZK_CIPHER_SUITES = [
-  "TLS_CHACHA20_POLY1305_SHA256",
-  "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
-  "TLS_AES_128_GCM_SHA256"
+    'TLS_CHACHA20_POLY1305_SHA256',
+    'TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384',
+    'TLS_AES_128_GCM_SHA256'
 ];
-async function benchmark() {
-  let benchmarkRes = "";
-  for (const cipherSuite of ZK_CIPHER_SUITES) {
-    const now = Date.now();
-    const alg = cipherSuite.includes("CHACHA20") ? "CHACHA20-POLY1305" : cipherSuite.includes("AES_256_GCM") ? "AES-256-GCM" : "AES-128-GCM";
-    const keylength = alg === "AES-128-GCM" ? 16 : 32;
-    const key = Buffer.alloc(keylength, 0);
-    const {
-      ivLength: fixedIvLength
-    } = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
-    const fixedIv = Buffer.alloc(fixedIvLength, 0);
-    const encKey = await crypto.importKey(alg, key);
-    const vectors = [
-      {
-        plaintext: `My cool API secret is "my name jeff". Please don't reveal it`
-      }
-    ];
-    const proofGenerator = await makeZkProofGenerator({
-      logger,
-      cipherSuite
-    });
-    for (const { plaintext } of vectors) {
-      const plaintextArr = strToUint8Array(plaintext);
-      const { ciphertext, iv } = await encryptWrappedRecord(
-        plaintextArr,
-        {
-          key: encKey,
-          iv: fixedIv,
-          recordNumber: 0,
-          recordHeaderOpts: {
-            type: "WRAPPED_RECORD"
-          },
-          cipherSuite,
-          version: cipherSuite.includes("ECDHE_") ? "TLS1_2" : "TLS1_3"
+export async function benchmark() {
+    let benchmarkRes = '';
+    for (const cipherSuite of ZK_CIPHER_SUITES) {
+        const now = Date.now();
+        const alg = cipherSuite.includes('CHACHA20')
+            ? 'CHACHA20-POLY1305'
+            : (cipherSuite.includes('AES_256_GCM')
+                ? 'AES-256-GCM'
+                : 'AES-128-GCM');
+        const keylength = alg === 'AES-128-GCM' ? 16 : 32;
+        const key = Buffer.alloc(keylength, 0);
+        const { ivLength: fixedIvLength, } = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite];
+        const fixedIv = Buffer.alloc(fixedIvLength, 0);
+        const encKey = await crypto.importKey(alg, key);
+        const vectors = [
+            {
+                plaintext: 'My cool API secret is "my name jeff". Please don\'t reveal it'
+            }
+        ];
+        const proofGenerator = await makeZkProofGenerator({
+            logger,
+            cipherSuite,
+        });
+        for (const { plaintext } of vectors) {
+            const plaintextArr = strToUint8Array(plaintext);
+            const { ciphertext, iv } = await encryptWrappedRecord(plaintextArr, {
+                key: encKey,
+                iv: fixedIv,
+                recordNumber: 0,
+                recordHeaderOpts: {
+                    type: 'WRAPPED_RECORD'
+                },
+                cipherSuite,
+                version: cipherSuite.includes('ECDHE_')
+                    ? 'TLS1_2'
+                    : 'TLS1_3',
+            });
+            const packet = {
+                type: 'ciphertext',
+                encKey,
+                iv,
+                recordNumber: 0,
+                plaintext: plaintextArr,
+                ciphertext,
+                fixedIv: new Uint8Array(0),
+                data: ciphertext
+            };
+            await proofGenerator.addPacketToProve(packet, {
+                type: 'zk',
+                redactedPlaintext: plaintextArr,
+            }, () => { }, () => {
+                throw new Error('should not be called in benchmark');
+            });
+            await proofGenerator.generateProofs();
         }
-      );
-      const packet = {
-        type: "ciphertext",
-        encKey,
-        iv,
-        recordNumber: 0,
-        plaintext: plaintextArr,
-        ciphertext,
-        fixedIv: new Uint8Array(0),
-        data: ciphertext
-      };
-      await proofGenerator.addPacketToProve(
-        packet,
-        {
-          type: "zk",
-          redactedPlaintext: plaintextArr
-        },
-        () => {
-        },
-        () => {
-          throw new Error("should not be called in benchmark");
-        }
-      );
-      await proofGenerator.generateProofs();
+        benchmarkRes = benchmarkRes + `Benchmark ${alg} ok. Took ${Date.now() - now} ms \n`;
     }
-    benchmarkRes = benchmarkRes + `Benchmark ${alg} ok. Took ${Date.now() - now} ms 
-`;
-  }
-  logger.info(benchmarkRes);
-  return benchmarkRes;
+    logger.info(benchmarkRes);
+    return benchmarkRes;
 }
-export {
-  benchmark
-};

package/lib/external-rpc/event-bus.js

@@ -1,17 +1,14 @@
-class EventBus {
-  #listeners = [];
-  addListener(fn) {
-    this.#listeners.push(fn);
-    return () => {
-      this.#listeners = this.#listeners.filter((l) => l !== fn);
-    };
-  }
-  dispatch(data) {
-    for (const listener of this.#listeners) {
-      listener(data);
+export class EventBus {
+    #listeners = [];
+    addListener(fn) {
+        this.#listeners.push(fn);
+        return () => {
+            this.#listeners = this.#listeners.filter(l => l !== fn);
+        };
+    }
+    dispatch(data) {
+        for (const listener of this.#listeners) {
+            listener(data);
+        }
     }
-  }
 }
-export {
-  EventBus
-};