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

package/lib/external-rpc/jsc-polyfills/event.js

@@ -1,19 +1,14 @@
-class EventPolyfill {
-  type;
-  constructor(type, eventInitDict) {
-    this.type = type;
-    Object.assign(this, eventInitDict);
-  }
+// @ts-expect-error
+export class EventPolyfill {
+    type;
+    constructor(type, eventInitDict) {
+        this.type = type;
+        Object.assign(this, eventInitDict);
+    }
 }
-class ErrorEventPolyfill extends EventPolyfill {
+export class ErrorEventPolyfill extends EventPolyfill {
 }
-class CloseEventPolyfill extends EventPolyfill {
+export class CloseEventPolyfill extends EventPolyfill {
 }
-class MessageEventPolyfill extends EventPolyfill {
+export class MessageEventPolyfill extends EventPolyfill {
 }
-export {
-  CloseEventPolyfill,
-  ErrorEventPolyfill,
-  EventPolyfill,
-  MessageEventPolyfill
-};

package/lib/external-rpc/jsc-polyfills/index.js

@@ -1,2 +1,2 @@
-import "../../external-rpc/jsc-polyfills/1.js";
-import "../../external-rpc/jsc-polyfills/2.js";
+import "./1.js";
+import "./2.js";

package/lib/external-rpc/jsc-polyfills/ws.js

@@ -1,83 +1,81 @@
-import { RPC_MSG_BRIDGE, rpcRequest } from "../../external-rpc/utils.js";
-class RPCWebSocket extends EventTarget {
-  CONNECTING = 0;
-  OPEN = 1;
-  CLOSING = 2;
-  CLOSED = 3;
-  id = `ws_${Date.now()}`;
-  binaryType = "arraybuffer";
-  bufferedAmount = 0;
-  extensions = "";
-  url;
-  protocol;
-  readyState = this.CONNECTING;
-  onopen;
-  onerror;
-  onclose;
-  onmessage;
-  #cancelRpcBridge;
-  constructor(url) {
-    super();
-    this.url = url;
-    this.protocol = "";
-    this.#onMessage = this.#onMessage.bind(this);
-    rpcRequest({
-      type: "connectWs",
-      request: { id: this.id, url }
-    }).then(() => this.#callOpen(new Event("open"))).catch((error) => this.#callError(new ErrorEvent("error", { error })));
-  }
-  send(data) {
-    if (typeof data !== "string" && !ArrayBuffer.isView(data)) {
-      throw new TypeError("Data must be a string, Uint8Array or ArrayBuffer");
+import { RPC_MSG_BRIDGE, rpcRequest } from "../utils.js";
+export class RPCWebSocket extends EventTarget {
+    CONNECTING = 0;
+    OPEN = 1;
+    CLOSING = 2;
+    CLOSED = 3;
+    id = `ws_${Date.now()}`;
+    binaryType = 'arraybuffer';
+    bufferedAmount = 0;
+    extensions = '';
+    url;
+    protocol;
+    readyState = this.CONNECTING;
+    onopen;
+    onerror;
+    onclose;
+    onmessage;
+    #cancelRpcBridge;
+    constructor(url) {
+        super();
+        this.url = url;
+        this.protocol = '';
+        this.#onMessage = this.#onMessage.bind(this);
+        rpcRequest({
+            type: 'connectWs',
+            request: { id: this.id, url }
+        })
+            .then(() => this.#callOpen(new Event('open')))
+            .catch(error => this.#callError(new ErrorEvent('error', { error })));
     }
-    rpcRequest({ type: "sendWsMessage", request: { id: this.id, data } });
-  }
-  close(code, reason) {
-    this.readyState = this.CLOSING;
-    rpcRequest({
-      type: "disconnectWs",
-      request: { id: this.id, code, reason }
-    }).then(() => this.#callClose(new CloseEvent("close", { code, reason }))).catch((error) => this.#callError(new ErrorEvent("error", { error })));
-  }
-  #callOpen(ev) {
-    this.readyState = this.OPEN;
-    this.onopen?.call(this, ev);
-    this.dispatchEvent(ev);
-    this.#cancelRpcBridge?.();
-    this.#cancelRpcBridge = RPC_MSG_BRIDGE.addListener(this.#onMessage);
-  }
-  #callError(ev) {
-    this.readyState = this.CLOSED;
-    this.onerror?.call(this, ev);
-    this.dispatchEvent(ev);
-  }
-  #callClose(ev) {
-    this.readyState = this.CLOSED;
-    this.onclose?.call(this, ev);
-    this.dispatchEvent(ev);
-  }
-  #onMessage = (msg) => {
-    if (msg.type === "sendWsMessage" && msg.request.id === this.id) {
-      const data = msg.request.data;
-      const event = new MessageEvent("message", { data });
-      this.onmessage?.call(this, event);
-      this.dispatchEvent(event);
-      return;
+    send(data) {
+        if (typeof data !== 'string'
+            && !ArrayBuffer.isView(data)) {
+            throw new TypeError('Data must be a string, Uint8Array or ArrayBuffer');
+        }
+        rpcRequest({ type: 'sendWsMessage', request: { id: this.id, data: data } });
     }
-    if (msg.type === "disconnectWs" && msg.request.id === this.id) {
-      if (!msg.request.err) {
-        this.#callClose(
-          new CloseEvent("close", { code: 1e3, reason: "Normal Closure" })
-        );
-        return;
-      }
-      this.#callError(
-        new ErrorEvent("error", { error: new Error(msg.request.err) })
-      );
-      return;
+    close(code, reason) {
+        this.readyState = this.CLOSING;
+        rpcRequest({
+            type: 'disconnectWs',
+            request: { id: this.id, code, reason }
+        })
+            .then(() => this.#callClose(new CloseEvent('close', { code, reason })))
+            .catch(error => this.#callError(new ErrorEvent('error', { error })));
     }
-  };
+    #callOpen(ev) {
+        this.readyState = this.OPEN;
+        this.onopen?.call(this, ev);
+        this.dispatchEvent(ev);
+        this.#cancelRpcBridge?.();
+        this.#cancelRpcBridge = RPC_MSG_BRIDGE.addListener(this.#onMessage);
+    }
+    #callError(ev) {
+        this.readyState = this.CLOSED;
+        this.onerror?.call(this, ev);
+        this.dispatchEvent(ev);
+    }
+    #callClose(ev) {
+        this.readyState = this.CLOSED;
+        this.onclose?.call(this, ev);
+        this.dispatchEvent(ev);
+    }
+    #onMessage = (msg) => {
+        if (msg.type === 'sendWsMessage' && msg.request.id === this.id) {
+            const data = msg.request.data;
+            const event = new MessageEvent('message', { data });
+            this.onmessage?.call(this, event);
+            this.dispatchEvent(event);
+            return;
+        }
+        if (msg.type === 'disconnectWs' && msg.request.id === this.id) {
+            if (!msg.request.err) {
+                this.#callClose(new CloseEvent('close', { code: 1000, reason: 'Normal Closure' }));
+                return;
+            }
+            this.#callError(new ErrorEvent('error', { error: new Error(msg.request.err) }));
+            return;
+        }
+    };
 }
-export {
-  RPCWebSocket
-};

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

@@ -1,33 +1,33 @@
-import { setCryptoImplementation } from "@reclaimprotocol/tls";
-import { webcryptoCrypto } from "@reclaimprotocol/tls/webcrypto";
-import { handleIncomingMessage } from "../external-rpc/handle-incoming-msg.js";
-import { getWsApiUrlFromBaseUrl } from "../external-rpc/utils.js";
+import { setCryptoImplementation } from '@reclaimprotocol/tls';
+import { webcryptoCrypto } from '@reclaimprotocol/tls/webcrypto';
+import { handleIncomingMessage } from "./handle-incoming-msg.js";
+import { getWsApiUrlFromBaseUrl } from "./utils.js";
 import { logger, makeLogger } from "../utils/index.js";
 makeLogger(true);
 setCryptoImplementation(webcryptoCrypto);
-function setupWindowRpc(baseUrl, channel = "attestor-core") {
-  if (baseUrl) {
-    globalThis.ATTESTOR_BASE_URL = baseUrl;
-  } else if (typeof window !== "undefined" && window.location) {
-    globalThis.ATTESTOR_BASE_URL = window.location.toString();
-  } else {
-    throw new Error("No base URL provided and window.location unavailable");
-  }
-  if (channel) {
-    globalThis.RPC_CHANNEL_NAME = channel;
-  } else if (!globalThis.RPC_CHANNEL_NAME) {
-    throw new Error("No channel name provided and globalThis.RPC_CHANNEL_NAME unavailable");
-  }
-  if (typeof window !== "undefined") {
-    window.addEventListener(
-      "message",
-      (ev) => handleIncomingMessage(ev.data),
-      false
-    );
-  }
-  logger.info({ defaultUrl: getWsApiUrlFromBaseUrl() }, "window RPC setup");
+/**
+ * For browsers only. Sets up the current window to listen for RPC requests
+ * from React Native or other windows
+ */
+export function setupWindowRpc(baseUrl, channel = 'attestor-core') {
+    if (baseUrl) {
+        globalThis.ATTESTOR_BASE_URL = baseUrl;
+    }
+    else if (typeof window !== 'undefined' && window.location) {
+        globalThis.ATTESTOR_BASE_URL = window.location.toString();
+    }
+    else {
+        throw new Error('No base URL provided and window.location unavailable');
+    }
+    if (channel) {
+        globalThis.RPC_CHANNEL_NAME = channel;
+    }
+    else if (!globalThis.RPC_CHANNEL_NAME) {
+        throw new Error('No channel name provided and globalThis.RPC_CHANNEL_NAME unavailable');
+    }
+    if (typeof window !== 'undefined') {
+        window.addEventListener('message', ev => handleIncomingMessage(ev.data), false);
+    }
+    logger.info({ defaultUrl: getWsApiUrlFromBaseUrl() }, 'window RPC setup');
 }
 export * from "../index.js";
-export {
-  setupWindowRpc
-};

package/lib/external-rpc/setup-jsc.js

@@ -1,22 +1,22 @@
-import "../external-rpc/jsc-polyfills/index.js";
-1;
-import { setCryptoImplementation } from "@reclaimprotocol/tls";
-import { pureJsCrypto } from "@reclaimprotocol/tls/purejs-crypto";
-import * as AttestorRPCImport from "../external-rpc/index.js";
+import "./jsc-polyfills/index.js";
+1; // done to avoid eslint rule
+import { setCryptoImplementation } from '@reclaimprotocol/tls';
+import { pureJsCrypto } from '@reclaimprotocol/tls/purejs-crypto';
+import * as AttestorRPCImport from "./index.js";
 import { makeLogger } from "../utils/logger.js";
 setCryptoImplementation(pureJsCrypto);
 makeLogger(true);
-function setupJsRpc(baseUrl, channel = "attestor-core") {
-  globalThis.ATTESTOR_BASE_URL = baseUrl;
-  globalThis.RPC_CHANNEL_NAME = channel;
-  const rpcChannel = {
-    postMessage(message) {
-      return globalThis.sendMessage(channel, message);
-    }
-  };
-  globalThis[channel] = rpcChannel;
+/**
+ * Sets up the library to run in JS environments like QuickJS or JavascriptCore.
+ */
+export function setupJsRpc(baseUrl, channel = 'attestor-core') {
+    globalThis.ATTESTOR_BASE_URL = baseUrl;
+    globalThis.RPC_CHANNEL_NAME = channel;
+    const rpcChannel = {
+        postMessage(message) {
+            return globalThis.sendMessage(channel, message);
+        }
+    };
+    globalThis[channel] = rpcChannel;
 }
 globalThis.AttestorRPC = { ...AttestorRPCImport, setupJsRpc };
-export {
-  setupJsRpc
-};

package/lib/external-rpc/types.js

@@ -0,0 +1 @@
+import "../..";

package/lib/external-rpc/utils.js

@@ -1,100 +1,100 @@
 import { WS_PATHNAME } from "../config/index.js";
-import { EventBus } from "../external-rpc/event-bus.js";
+import { EventBus } from "./event-bus.js";
 import { B64_JSON_REPLACER } from "../utils/b64-json.js";
 import { AttestorError } from "../utils/error.js";
-const RPC_MSG_BRIDGE = new EventBus();
-async function getCurrentMemoryUsage() {
-  if (!window.crossOriginIsolated) {
-    return {
-      available: false,
-      content: "N/A (page not cross-origin-isolated)"
-    };
-  } else if (!performance.measureUserAgentSpecificMemory) {
-    return {
-      available: false,
-      content: "N/A (performance.measureUserAgentSpecificMemory() is not available)"
-    };
-  } else {
-    try {
-      const result = performance.measureUserAgentSpecificMemory();
-      const totalmb = Math.round(result.bytes / 1024 / 1024);
-      return { available: true, content: `${totalmb}mb` };
-    } catch (error) {
-      if (error instanceof DOMException && error.name === "SecurityError") {
-        return { available: false, content: `N/A (${error.message})` };
-      }
-      throw error;
+export const RPC_MSG_BRIDGE = new EventBus();
+// track memory usage
+export async function getCurrentMemoryUsage() {
+    if (!window.crossOriginIsolated) {
+        return {
+            available: false,
+            content: 'N/A (page not cross-origin-isolated)'
+        };
+    }
+    else if (!performance.measureUserAgentSpecificMemory) {
+        return {
+            available: false,
+            content: 'N/A (performance.measureUserAgentSpecificMemory() is not available)',
+        };
+    }
+    else {
+        try {
+            const result = performance.measureUserAgentSpecificMemory();
+            const totalmb = Math.round(result.bytes / 1024 / 1024);
+            return { available: true, content: `${totalmb}mb` };
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'SecurityError') {
+                return { available: false, content: `N/A (${error.message})` };
+            }
+            throw error;
+        }
     }
-  }
 }
-function generateRpcRequestId() {
-  return Math.random().toString(36).slice(2);
+export function generateRpcRequestId() {
+    return Math.random().toString(36).slice(2);
 }
-function getWsApiUrlFromBaseUrl() {
-  if (typeof ATTESTOR_BASE_URL !== "string") {
-    throw new Error("ATTESTOR_BASE_URL is not set");
-  }
-  const parsed = new URL(ATTESTOR_BASE_URL);
-  const { host, protocol } = parsed;
-  const wsProtocol = protocol === "https:" ? "wss:" : "ws:";
-  return `${wsProtocol}//${host}${WS_PATHNAME}`;
+/**
+ * The window RPC will be served from the same origin as the API server.
+ * so we can get the API server's origin from the location.
+ */
+export function getWsApiUrlFromBaseUrl() {
+    if (typeof ATTESTOR_BASE_URL !== 'string') {
+        throw new Error('ATTESTOR_BASE_URL is not set');
+    }
+    const parsed = new URL(ATTESTOR_BASE_URL);
+    const { host, protocol } = parsed;
+    const wsProtocol = protocol === 'https:' ? 'wss:' : 'ws:';
+    return `${wsProtocol}//${host}${WS_PATHNAME}`;
 }
-function rpcRequest(opts) {
-  const id = generateRpcRequestId();
-  const waitForRes = waitForResponse(opts.type, id);
-  sendMessageToApp({
-    id,
-    type: opts.type,
-    request: opts.request
-  });
-  return waitForRes;
+export function rpcRequest(opts) {
+    const id = generateRpcRequestId();
+    const waitForRes = waitForResponse(opts.type, id);
+    // @ts-expect-error
+    sendMessageToApp({
+        id,
+        type: opts.type,
+        request: opts.request,
+    });
+    return waitForRes;
 }
-function waitForResponse(type, requestId, timeoutMs = 6e4) {
-  const returnType = `${type}Done`;
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      reject(
-        new AttestorError(
-          "ERROR_INTERNAL",
-          `Timeout waiting for response: ${type}`,
-          { requestId }
-        )
-      );
-      cancel();
-    }, timeoutMs);
-    const cancel = RPC_MSG_BRIDGE.addListener((msg) => {
-      if (msg.id !== requestId) {
-        return;
-      }
-      if (msg.type === "error") {
-        reject(new Error(msg.data.message));
-      } else if (msg.type === returnType) {
-        resolve(msg.response);
-      } else {
-        return;
-      }
-      clearTimeout(timeout);
-      cancel();
+export function waitForResponse(type, requestId, timeoutMs = 60_000) {
+    const returnType = `${type}Done`;
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(new AttestorError('ERROR_INTERNAL', `Timeout waiting for response: ${type}`, { requestId }));
+            cancel();
+        }, timeoutMs);
+        const cancel = RPC_MSG_BRIDGE.addListener(msg => {
+            if (msg.id !== requestId) {
+                return;
+            }
+            if (msg.type === 'error') {
+                reject(new Error(msg.data.message));
+            }
+            else if (msg.type === returnType) {
+                resolve(msg.response);
+            }
+            else {
+                return;
+            }
+            clearTimeout(timeout);
+            cancel();
+        });
     });
-  });
 }
-function sendMessageToApp(data) {
-  const str = JSON.stringify(data, B64_JSON_REPLACER);
-  if (!RPC_CHANNEL_NAME) {
-    throw new Error("global RPC_CHANNEL_NAME is not set");
-  }
-  const channel = globalThis[RPC_CHANNEL_NAME];
-  if (!channel) {
-    throw new Error(`RPC channel ${RPC_CHANNEL_NAME} not set on globalThis`);
-  }
-  channel.postMessage(str);
+/**
+ * Sends a message back to the host app
+ * @param data
+ */
+export function sendMessageToApp(data) {
+    const str = JSON.stringify(data, B64_JSON_REPLACER);
+    if (!RPC_CHANNEL_NAME) {
+        throw new Error('global RPC_CHANNEL_NAME is not set');
+    }
+    const channel = globalThis[RPC_CHANNEL_NAME];
+    if (!channel) {
+        throw new Error(`RPC channel ${RPC_CHANNEL_NAME} not set on globalThis`);
+    }
+    channel.postMessage(str);
 }
-export {
-  RPC_MSG_BRIDGE,
-  generateRpcRequestId,
-  getCurrentMemoryUsage,
-  getWsApiUrlFromBaseUrl,
-  rpcRequest,
-  sendMessageToApp,
-  waitForResponse
-};

package/lib/external-rpc/zk.js

@@ -1,58 +1,63 @@
-import { rpcRequest } from "../external-rpc/utils.js";
+import { rpcRequest } from "./utils.js";
 import { logger, makeDefaultZkOperator } from "../utils/index.js";
-const ALL_ENC_ALGORITHMS = [
-  "aes-256-ctr",
-  "aes-128-ctr",
-  "chacha20"
+export const ALL_ENC_ALGORITHMS = [
+    'aes-256-ctr',
+    'aes-128-ctr',
+    'chacha20',
 ];
-function makeExternalRpcZkOperator(algorithm, zkEngine = "snarkjs") {
-  return {
-    async generateWitness(input) {
-      const operator = await makeDefaultZkOperator(algorithm, zkEngine, logger);
-      return operator.generateWitness(input);
-    },
-    groth16Prove(input) {
-      return callFnZk({ fn: "groth16Prove", args: [input] });
-    },
-    groth16Verify(publicSignals, proof) {
-      return callFnZk({ fn: "groth16Verify", args: [publicSignals, proof] });
-    }
-  };
+/**
+ * The goal of this RPC operator is if the attestor client
+ * is running in a WebView, it can call the native
+ * application to perform the ZK operations
+ */
+export function makeExternalRpcZkOperator(algorithm, zkEngine = 'snarkjs') {
+    return {
+        async generateWitness(input) {
+            const operator = await makeDefaultZkOperator(algorithm, zkEngine, logger);
+            return operator.generateWitness(input);
+        },
+        groth16Prove(input) {
+            return callFnZk({ fn: 'groth16Prove', args: [input] });
+        },
+        groth16Verify(publicSignals, proof) {
+            return callFnZk({ fn: 'groth16Verify', args: [publicSignals, proof] });
+        },
+    };
 }
 function callFnZk(request) {
-  return rpcRequest({ type: "executeZkFunctionV3", request });
+    return rpcRequest({ type: 'executeZkFunctionV3', request });
 }
-function makeExternalRpcOprfOperator(algorithm, zkEngine = "snarkjs") {
-  return {
-    async generateWitness(input) {
-      const operator = await makeDefaultZkOperator(algorithm, zkEngine, logger);
-      return operator.generateWitness(input);
-    },
-    groth16Prove(input) {
-      return callFnOprf({ fn: "groth16Prove", args: [input] });
-    },
-    groth16Verify(publicSignals, proof) {
-      return callFnOprf({ fn: "groth16Verify", args: [publicSignals, proof] });
-    },
-    generateThresholdKeys(total, threshold) {
-      return callFnOprf({ fn: "generateThresholdKeys", args: [total, threshold] });
-    },
-    generateOPRFRequestData(data, domainSeparator) {
-      return callFnOprf({ fn: "generateOPRFRequestData", args: [data, domainSeparator] });
-    },
-    finaliseOPRF(serverPublicKey, request, responses) {
-      return callFnOprf({ fn: "finaliseOPRF", args: [serverPublicKey, request, responses] });
-    },
-    evaluateOPRF(serverPrivateKey, request) {
-      return callFnOprf({ fn: "evaluateOPRF", args: [serverPrivateKey, request] });
-    }
-  };
+/**
+ * The goal of this RPC operator is if the attestor client
+ * is running in a WebView, it can call the native
+ * application to perform the OPRF operations
+ */
+export function makeExternalRpcOprfOperator(algorithm, zkEngine = 'snarkjs') {
+    return {
+        async generateWitness(input) {
+            const operator = await makeDefaultZkOperator(algorithm, zkEngine, logger);
+            return operator.generateWitness(input);
+        },
+        groth16Prove(input) {
+            return callFnOprf({ fn: 'groth16Prove', args: [input] });
+        },
+        groth16Verify(publicSignals, proof) {
+            return callFnOprf({ fn: 'groth16Verify', args: [publicSignals, proof] });
+        },
+        generateThresholdKeys(total, threshold) {
+            return callFnOprf({ fn: 'generateThresholdKeys', args: [total, threshold] });
+        },
+        generateOPRFRequestData(data, domainSeparator) {
+            return callFnOprf({ fn: 'generateOPRFRequestData', args: [data, domainSeparator] });
+        },
+        finaliseOPRF(serverPublicKey, request, responses) {
+            return callFnOprf({ fn: 'finaliseOPRF', args: [serverPublicKey, request, responses] });
+        },
+        evaluateOPRF(serverPrivateKey, request) {
+            return callFnOprf({ fn: 'evaluateOPRF', args: [serverPrivateKey, request] });
+        },
+    };
 }
 function callFnOprf(request) {
-  return rpcRequest({ type: "executeOprfFunctionV3", request });
+    return rpcRequest({ type: 'executeOprfFunctionV3', request });
 }
-export {
-  ALL_ENC_ALGORITHMS,
-  makeExternalRpcOprfOperator,
-  makeExternalRpcZkOperator
-};

package/lib/index.js

@@ -1,13 +1,9 @@
-import * as tls from "@reclaimprotocol/tls";
+export * as tls from '@reclaimprotocol/tls';
 export * from "./client/utils/client-socket.js";
 export * from "./config/index.js";
 export * from "./types/index.js";
 export * from "./utils/index.js";
 export * from "./providers/index.js";
-import * as proto from "./proto/api.js";
+export * as proto from "./proto/api.js";
 export * from "./client/index.js";
 export * from "./mechain/index.js";
-export {
-  proto,
-  tls
-};