@reclaimprotocol/attestor-core 5.0.1-beta.7 → 5.0.1

package/lib/browser/client/utils/attestor-pool.js

@@ -1,24 +0,0 @@
-import { AttestorClient } from "../../client/utils/client-socket.js";
-const POOL = {};
-function getAttestorClientFromPool(url, getCreateOpts = () => ({})) {
-  const key = url.toString();
-  let client = POOL[key];
-  let createReason;
-  if (client?.isClosed) {
-    createReason = "closed";
-  } else if (!client) {
-    createReason = "non-existent";
-  }
-  if (createReason) {
-    const createOpts = getCreateOpts();
-    createOpts?.logger?.info(
-      { key, createReason },
-      "creating new client"
-    );
-    client = POOL[key] = new AttestorClient({ ...createOpts, url });
-  }
-  return client;
-}
-export {
-  getAttestorClientFromPool
-};

package/lib/browser/client/utils/client-socket.d.ts

@@ -1,11 +0,0 @@
-import type { InitResponse } from '#src/proto/api.ts';
-import type { IAttestorClient, IAttestorClientCreateOpts, RPCRequestData, RPCResponseData, RPCType } from '#src/types/index.ts';
-import { AttestorSocket } from '#src/utils/socket-base.ts';
-export declare class AttestorClient extends AttestorSocket implements IAttestorClient {
-    private waitForInitPromise;
-    initResponse?: InitResponse;
-    constructor({ url, initMessages, signatureType, logger, authRequest, makeWebSocket }: IAttestorClientCreateOpts);
-    rpc<T extends RPCType>(type: T, request: Partial<RPCRequestData<T>>, timeoutMs?: number): Promise<Exclude<import("#src/proto/api.ts").RPCMessage[`${T}Response`], undefined>>;
-    waitForResponse<T extends RPCType>(id: number, timeoutMs?: number): Promise<RPCResponseData<T>>;
-    waitForInit: () => Promise<void>;
-}

package/lib/browser/client/utils/client-socket.js

@@ -1,120 +0,0 @@
-import { encodeBase64 } from "ethers";
-import { DEFAULT_METADATA, DEFAULT_RPC_TIMEOUT_MS } from "../../config/index.js";
-import { RPCMessages } from "../../proto/api.js";
-import { AttestorError, generateRpcMessageId, getRpcRequestType, logger as LOGGER, packRpcMessages } from "../../utils/index.js";
-import { AttestorSocket } from "../../utils/socket-base.js";
-import { makeWebSocket as defaultMakeWebSocket } from "../../utils/ws.js";
-class AttestorClient extends AttestorSocket {
-  waitForInitPromise;
-  initResponse;
-  constructor({
-    url,
-    initMessages = [],
-    signatureType = DEFAULT_METADATA.signatureType,
-    logger = LOGGER,
-    authRequest,
-    makeWebSocket = defaultMakeWebSocket
-  }) {
-    const initRequest = {
-      ...DEFAULT_METADATA,
-      signatureType,
-      auth: authRequest
-    };
-    const msg = packRpcMessages({ initRequest }, ...initMessages);
-    const initRequestBytes = RPCMessages.encode(msg).finish();
-    const initRequestB64 = encodeBase64(initRequestBytes);
-    url = new URL(url.toString());
-    url.searchParams.set("messages", initRequestB64);
-    super(
-      makeWebSocket(url),
-      initRequest,
-      logger
-    );
-    const initReqId = msg.messages[0].id;
-    this.waitForInitPromise = this.waitForResponse(initReqId, DEFAULT_RPC_TIMEOUT_MS).then((res) => {
-      logger.info("client initialised");
-      this.isInitialised = true;
-      this.initResponse = res;
-    });
-    this.waitForInitPromise.catch(() => {
-    });
-    this.addEventListener("connection-terminated", (ev) => logger.info({ err: ev.data }, "connection terminated"));
-  }
-  async rpc(type, request, timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
-    const msgId = generateRpcMessageId();
-    this.logger.debug({ type, id: msgId }, "sending rpc request");
-    const now = Date.now();
-    try {
-      const rslt = this.waitForResponse(msgId, timeoutMs);
-      await this.sendMessage({ id: msgId, [getRpcRequestType(type)]: request });
-      return await rslt;
-    } finally {
-      const timeTakenMs = Date.now() - now;
-      this.logger.debug({ type, timeTakenMs }, "received rpc response");
-    }
-  }
-  waitForResponse(id, timeoutMs = DEFAULT_RPC_TIMEOUT_MS) {
-    if (this.isClosed) {
-      throw new AttestorError(
-        "ERROR_NETWORK_ERROR",
-        "Client connection already closed"
-      );
-    }
-    return new Promise((resolve, reject) => {
-      const handler = (event) => {
-        if (event.data.id !== id) {
-          return;
-        }
-        removeHandlers();
-        if ("error" in event.data) {
-          reject(event.data.error);
-          return;
-        }
-        resolve(event.data.data);
-      };
-      const terminateHandler = (event) => {
-        removeHandlers();
-        if (event.data.code === "ERROR_NO_ERROR") {
-          reject(
-            new AttestorError(
-              "ERROR_NETWORK_ERROR",
-              event.data.message,
-              event.data.data
-            )
-          );
-          return;
-        }
-        reject(event.data);
-      };
-      const timeout = setTimeout(() => {
-        removeHandlers();
-        reject(
-          new AttestorError(
-            "ERROR_TIMEOUT",
-            `RPC request timed out after ${timeoutMs}ms`,
-            { id }
-          )
-        );
-      }, timeoutMs);
-      const removeHandlers = () => {
-        clearTimeout(timeout);
-        this.removeEventListener("rpc-response", handler);
-        this.removeEventListener("connection-terminated", terminateHandler);
-      };
-      this.addEventListener("rpc-response", handler);
-      this.addEventListener("connection-terminated", terminateHandler);
-    });
-  }
-  waitForInit = () => {
-    if (this.isClosed) {
-      throw new AttestorError(
-        "ERROR_NETWORK_ERROR",
-        "Client connection already closed"
-      );
-    }
-    return this.waitForInitPromise;
-  };
-}
-export {
-  AttestorClient
-};

package/lib/browser/client/utils/message-handler.d.ts

@@ -1,4 +0,0 @@
-import type { RPCMessage } from '#src/proto/api.ts';
-import type { IAttestorSocket } from '#src/types/index.ts';
-export declare function wsMessageHandler(this: IAttestorSocket, data: unknown): Promise<void>;
-export declare function handleMessage(this: IAttestorSocket, msg: RPCMessage): Promise<void> | undefined;

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

@@ -1,97 +0,0 @@
-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;
-    }
-    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/browser/config/index.d.ts

@@ -1,31 +0,0 @@
-import type { InitRequest } from '#src/proto/api.ts';
-export declare const DEFAULT_ZK_CONCURRENCY = 10;
-export declare const RECLAIM_USER_AGENT = "reclaim/0.0.1";
-export declare const DEFAULT_HTTPS_PORT = 443;
-export declare const WS_PATHNAME = "/ws";
-export declare const BROWSER_RPC_PATHNAME = "/browser-rpc";
-export declare const ATTESTOR_ADDRESS_PATHNAME = "/address";
-export declare const DEFAULT_REMOTE_FILE_FETCH_BASE_URL = "/browser-rpc/resources";
-export declare const API_SERVER_PORT = 8001;
-export declare const CONNECTION_TIMEOUT_MS = 10000;
-export declare const DNS_SERVERS: string[];
-export declare const MAX_CLAIM_TIMESTAMP_DIFF_S: number;
-export declare const CURRENT_ATTESTOR_VERSION: 5;
-export declare const DEFAULT_METADATA: InitRequest;
-export declare const PROVIDER_CTX: {
-    version: 5;
-};
-export declare const PING_INTERVAL_MS = 10000;
-/**
- * Maximum interval in seconds to wait for before assuming
- * the connection is dead
- * @default 30s
- */
-export declare const MAX_NO_DATA_INTERVAL_MS = 30000;
-export declare const MAX_PAYLOAD_SIZE: number;
-export declare const DEFAULT_AUTH_EXPIRY_S: number;
-export declare const DEFAULT_RPC_TIMEOUT_MS = 90000;
-export declare const TOPRF_DOMAIN_SEPARATOR = "reclaim-toprf";
-export declare const MAX_CERT_SIZE_BYTES: number;
-export declare const CERT_ALLOWED_MIMETYPES: string[];
-export declare const BGP_WS_URL = "wss://ris-live.ripe.net/v1/ws/?client=reclaim-hijack-detector";

package/lib/browser/config/index.js

@@ -1,62 +0,0 @@
-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"
-];
-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
-};
-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"
-];
-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
-};

package/lib/browser/external-rpc/benchmark.d.ts

@@ -1 +0,0 @@
-export declare function benchmark(): Promise<string>;

package/lib/browser/external-rpc/benchmark.js

@@ -1,82 +0,0 @@
-import {
-  crypto,
-  encryptWrappedRecord,
-  SUPPORTED_CIPHER_SUITE_MAP
-} from "../utils/tls-imports.js";
-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"
-];
-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();
-    }
-    benchmarkRes = benchmarkRes + `Benchmark ${alg} ok. Took ${Date.now() - now} ms 
-`;
-  }
-  logger.info(benchmarkRes);
-  return benchmarkRes;
-}
-export {
-  benchmark
-};

package/lib/browser/external-rpc/event-bus.d.ts

@@ -1,7 +0,0 @@
-type EventHandlerFn<T> = (data: T) => void;
-export declare class EventBus<T> {
-    #private;
-    addListener(fn: EventHandlerFn<T>): () => void;
-    dispatch(data: T): void;
-}
-export {};

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

@@ -1,17 +0,0 @@
-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
-};

package/lib/browser/external-rpc/handle-incoming-msg.d.ts

@@ -1,2 +0,0 @@
-import type { ExternalRPCIncomingMsg } from '#src/external-rpc/types.ts';
-export declare function handleIncomingMessage(data: string | ExternalRPCIncomingMsg): Promise<void>;