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

package/lib/browser/external-rpc/handle-incoming-msg.js

@@ -0,0 +1,241 @@
+import { hexlify } from "ethers";
+import { createClaimOnAvs } from "../../avs/client/create-claim-on-avs.js";
+import { createClaimOnAttestor } from "../../client/index.js";
+import { benchmark } from "../../external-rpc/benchmark.js";
+import { generateRpcRequestId, getCurrentMemoryUsage, getWsApiUrlFromBaseUrl, RPC_MSG_BRIDGE, sendMessageToApp, waitForResponse } from "../../external-rpc/utils.js";
+import { ALL_ENC_ALGORITHMS, makeExternalRpcOprfOperator, makeExternalRpcZkOperator } from "../../external-rpc/zk.js";
+import { createClaimOnMechain } from "../../mechain/client/create-claim-on-mechain.js";
+import { extractHTMLElement, extractJSONValueIndex, generateRequstAndResponseFromTranscript } from "../../providers/http/utils.js";
+import { B64_JSON_REVIVER } from "../../utils/b64-json.js";
+import { AttestorError, getIdentifierFromClaimInfo, logger, makeLogger, uint8ArrayToStr } from "../../utils/index.js";
+async function handleIncomingMessage(data) {
+  let id = "";
+  try {
+    const req = typeof data === "string" ? JSON.parse(data, B64_JSON_REVIVER) : data;
+    id = req.id || "";
+    const rslt = await _handleIncomingMessage(req);
+    if (!rslt) {
+      return;
+    }
+    respond(rslt);
+  } catch (err) {
+    console.error("Error in RPC", { id, error: err });
+    respond({
+      type: "error",
+      data: {
+        message: err.message,
+        stack: err.stack
+      }
+    });
+  }
+  function respond(data2) {
+    const res = {
+      ...data2,
+      id,
+      isResponse: true
+    };
+    return sendMessageToApp(res);
+  }
+}
+async function _handleIncomingMessage(req) {
+  const { id: reqId, type: reqType } = req;
+  if (!reqId || !reqType) {
+    return;
+  }
+  RPC_MSG_BRIDGE.dispatch(req);
+  if ("isResponse" in req && req.isResponse) {
+    return;
+  }
+  if (!reqId) {
+    logger.warn({ req }, "Window RPC request missing ID");
+    return;
+  }
+  logger.info({ req }, "processing RPC request");
+  switch (req.type) {
+    case "createClaim":
+      const claimTunnelRes = await createClaimOnAttestor({
+        ...req.request,
+        context: req.request.context ? JSON.parse(req.request.context) : void 0,
+        zkOperators: getZkOperators(
+          req.request.zkOperatorMode,
+          req.request.zkEngine
+        ),
+        oprfOperators: getOprfOperators(
+          req.request.zkOperatorMode,
+          req.request.zkEngine
+        ),
+        client: {
+          url: getWsApiUrlFromBaseUrl(),
+          authRequest: req.request.authRequest
+        },
+        logger,
+        onStep(step) {
+          sendMessageToApp({
+            type: "createClaimStep",
+            step: { name: "attestor-progress", step },
+            id: req.id
+          });
+        },
+        updateProviderParams: req.request.updateProviderParams ? updateProviderParams : void 0
+      });
+      const response = mapToCreateClaimResponse(claimTunnelRes);
+      return { type: "createClaimDone", response };
+    case "createClaimOnAvs":
+      const avsRes = await createClaimOnAvs({
+        ...req.request,
+        payer: req.request.payer === "attestor" ? { attestor: getWsApiUrlFromBaseUrl() } : void 0,
+        context: req.request.context ? JSON.parse(req.request.context) : void 0,
+        zkOperators: getZkOperators(
+          req.request.zkOperatorMode,
+          req.request.zkEngine
+        ),
+        oprfOperators: getOprfOperators(
+          req.request.zkOperatorMode,
+          req.request.zkEngine
+        ),
+        logger,
+        onStep(step) {
+          sendMessageToApp({
+            type: "createClaimOnAvsStep",
+            step,
+            id: req.id
+          });
+        }
+      });
+      return {
+        type: "createClaimOnAvsDone",
+        response: avsRes
+      };
+    case "createClaimOnMechain":
+      const mechainRes = await createClaimOnMechain({
+        ...req.request,
+        context: req.request.context ? JSON.parse(req.request.context) : void 0,
+        zkOperators: getZkOperators(
+          req.request.zkOperatorMode,
+          req.request.zkEngine
+        ),
+        oprfOperators: getOprfOperators(
+          req.request.zkOperatorMode,
+          req.request.zkEngine
+        ),
+        client: { url: getWsApiUrlFromBaseUrl() },
+        logger,
+        onStep(step) {
+          sendMessageToApp({
+            type: "createClaimOnMechainStep",
+            step,
+            id: req.id
+          });
+        }
+      });
+      const claimResponses = [];
+      for (let i = 0; i < mechainRes.responses.length; i++) {
+        claimResponses[i] = mapToCreateClaimResponse(mechainRes.responses[i]);
+      }
+      return {
+        type: "createClaimOnMechainDone",
+        response: { taskId: mechainRes.taskId, data: claimResponses }
+      };
+    case "extractHtmlElement":
+      return {
+        type: "extractHtmlElementDone",
+        response: extractHTMLElement(
+          req.request.html,
+          req.request.xpathExpression,
+          req.request.contentsOnly
+        )
+      };
+    case "extractJSONValueIndex":
+      return {
+        type: "extractJSONValueIndexDone",
+        response: extractJSONValueIndex(
+          req.request.json,
+          req.request.jsonPath
+        )
+      };
+    case "getCurrentMemoryUsage":
+      return {
+        type: "getCurrentMemoryUsageDone",
+        response: await getCurrentMemoryUsage()
+      };
+    case "setLogLevel":
+      makeLogger(
+        true,
+        req.request.logLevel,
+        req.request.sendLogsToApp ? (level, message) => sendMessageToApp({
+          type: "log",
+          level,
+          message,
+          id: req.id
+        }) : void 0
+      );
+      return { type: "setLogLevelDone", response: void 0 };
+    case "benchmarkZK":
+      return { type: "benchmarkZKDone", response: await benchmark() };
+    case "ping":
+      return { type: "pingDone", response: { pong: (/* @__PURE__ */ new Date()).toJSON() } };
+    default:
+      break;
+  }
+}
+function getZkOperators(mode = "default", zkEngine = "snarkjs") {
+  if (mode === "default") {
+    return;
+  }
+  const operators = {};
+  for (const alg of ALL_ENC_ALGORITHMS) {
+    operators[alg] = makeExternalRpcZkOperator(alg, zkEngine);
+  }
+  return operators;
+}
+function getOprfOperators(mode = "default", zkEngine = "snarkjs") {
+  if (mode === "default") {
+    return;
+  }
+  const operators = {};
+  for (const alg of ALL_ENC_ALGORITHMS) {
+    operators[alg] = makeExternalRpcOprfOperator(alg, zkEngine);
+  }
+  return operators;
+}
+async function updateProviderParams(transcript, tlsVersion) {
+  const { req, res } = generateRequstAndResponseFromTranscript(
+    transcript,
+    tlsVersion
+  );
+  const id = generateRpcRequestId();
+  const waitForRes = waitForResponse("updateProviderParams", id);
+  sendMessageToApp({
+    type: "updateProviderParams",
+    id,
+    request: {
+      request: {
+        ...req,
+        body: req.body ? uint8ArrayToStr(req.body) : void 0
+      },
+      response: { ...res, body: uint8ArrayToStr(res.body) }
+    }
+  });
+  return waitForRes;
+}
+function mapToCreateClaimResponse(res) {
+  if (!res.claim) {
+    throw AttestorError.fromProto(res.error);
+  }
+  return {
+    identifier: getIdentifierFromClaimInfo(res.claim),
+    claimData: res.claim,
+    witnesses: [
+      {
+        id: res.signatures.attestorAddress,
+        url: getWsApiUrlFromBaseUrl()
+      }
+    ],
+    signatures: [
+      hexlify(res.signatures.claimSignature).toLowerCase()
+    ]
+  };
+}
+export {
+  handleIncomingMessage
+};

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

@@ -0,0 +1,3 @@
+export * from './types.ts';
+export * from './handle-incoming-msg.ts';
+export * from './utils.ts';

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

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./handle-incoming-msg.js";
+export * from "./utils.js";

package/lib/browser/external-rpc/jsc-polyfills/1.d.ts

@@ -0,0 +1,14 @@
+import type { ExternalRPCIncomingMsg, ExternalRPCOutgoingMsg } from '#src/external-rpc/types.ts';
+declare global {
+    function readline(): string;
+    function print(...args: any[]): void;
+    function debug(...args: any[]): void;
+    function quit(): void;
+    type JSCIncomingMsg = ExternalRPCIncomingMsg | {
+        type: 'quit';
+    } | {
+        type: 'init';
+        attestorBaseUrl: string;
+    };
+    type JSCOutgoingMsg = ExternalRPCOutgoingMsg;
+}

package/lib/browser/external-rpc/jsc-polyfills/1.js

@@ -0,0 +1,80 @@
+import { TextDecoder, TextEncoder } from "@kayahr/text-encoding";
+import { crypto, uint8ArrayToBinaryStr } from "@reclaimprotocol/tls";
+import { fromByteArray, toByteArray } from "base64-js";
+import { EventTarget } from "event-target-shim";
+if (typeof global === "undefined") {
+  globalThis.global = globalThis;
+}
+if (typeof console === "undefined") {
+  globalThis.console = {
+    log: print,
+    error: print,
+    warn: print,
+    info: print,
+    debug: print
+  };
+}
+if (typeof globalThis.crypto === "undefined") {
+  globalThis.crypto = {
+    // @ts-expect-error
+    getRandomValues(arr) {
+      const randVals = crypto.randomBytes(arr.length);
+      for (let i = 0; i < arr.length; i++) {
+        arr[i] = randVals[i];
+      }
+      return arr;
+    },
+    randomBytes(length) {
+      return crypto.randomBytes(length);
+    }
+  };
+}
+if (typeof globalThis.TextEncoder === "undefined") {
+  globalThis.TextEncoder = TextEncoder;
+}
+if (typeof globalThis.TextDecoder === "undefined") {
+  globalThis.TextDecoder = TextDecoder;
+}
+if (typeof globalThis.EventTarget === "undefined") {
+  globalThis.EventTarget = EventTarget;
+}
+if (typeof globalThis.atob === "undefined") {
+  globalThis.atob = (a) => uint8ArrayToBinaryStr(toByteArray(a));
+}
+if (typeof globalThis.btoa === "undefined") {
+  let binaryStringToUint8Array = function(binaryString) {
+    const uint8Array = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      uint8Array[i] = binaryString.charCodeAt(i);
+    }
+    return uint8Array;
+  };
+  globalThis.btoa = (b) => fromByteArray(binaryStringToUint8Array(b));
+}
+if (typeof globalThis.clearTimeout === "undefined") {
+  const ogSettimeout = globalThis.setTimeout;
+  if (!ogSettimeout) {
+    throw new Error("setTimeout is not defined, no polyfill yet");
+  }
+  globalThis.setTimeout = (fn, delayMs, ...args) => {
+    let aborted = false;
+    const abortableFn = (...args2) => {
+      if (aborted) {
+        return;
+      }
+      return fn(...args2);
+    };
+    const val = ogSettimeout(abortableFn, delayMs, ...args);
+    return {
+      original: val,
+      abort() {
+        aborted = true;
+      }
+    };
+  };
+  globalThis.clearTimeout = (id) => {
+    if (typeof id === "object" && !!id && "abort" in id) {
+      id.abort();
+    }
+  };
+}

package/lib/browser/external-rpc/jsc-polyfills/2.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/browser/external-rpc/jsc-polyfills/2.js

@@ -0,0 +1,15 @@
+import { URL as WHATWG_URL } from "whatwg-url";
+import { CloseEventPolyfill, ErrorEventPolyfill, EventPolyfill, MessageEventPolyfill } from "../../../external-rpc/jsc-polyfills/event.js";
+import { RPCWebSocket } from "../../../external-rpc/jsc-polyfills/ws.js";
+if (typeof globalThis.URL === "undefined") {
+  globalThis.URL = WHATWG_URL;
+}
+if (typeof globalThis.Event === "undefined") {
+  globalThis.Event = EventPolyfill;
+  globalThis.ErrorEvent = ErrorEventPolyfill;
+  globalThis.CloseEvent = CloseEventPolyfill;
+  globalThis.MessageEvent = MessageEventPolyfill;
+}
+if (typeof globalThis.WebSocket === "undefined") {
+  globalThis.WebSocket = RPCWebSocket;
+}

package/lib/browser/external-rpc/jsc-polyfills/event.d.ts

@@ -0,0 +1,10 @@
+export declare class EventPolyfill implements Event {
+    type: string;
+    constructor(type: string, eventInitDict?: EventInit);
+}
+export declare class ErrorEventPolyfill extends EventPolyfill {
+}
+export declare class CloseEventPolyfill extends EventPolyfill {
+}
+export declare class MessageEventPolyfill extends EventPolyfill {
+}

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

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

package/lib/browser/external-rpc/jsc-polyfills/index.d.ts

@@ -0,0 +1,2 @@
+import '#src/external-rpc/jsc-polyfills/1.ts';
+import '#src/external-rpc/jsc-polyfills/2.ts';

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

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

package/lib/browser/external-rpc/jsc-polyfills/ws.d.ts

@@ -0,0 +1,21 @@
+export declare class RPCWebSocket extends EventTarget implements WebSocket {
+    #private;
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSING: 2;
+    readonly CLOSED: 3;
+    readonly id: string;
+    readonly binaryType: BinaryType;
+    readonly bufferedAmount: number;
+    readonly extensions: string;
+    readonly url: string;
+    readonly protocol: string;
+    readyState: number;
+    onopen: ((this: WebSocket, ev: Event) => any) | null;
+    onerror: ((this: WebSocket, ev: Event) => any) | null;
+    onclose: ((this: WebSocket, ev: CloseEvent) => any) | null;
+    onmessage: ((this: WebSocket, ev: MessageEvent<any>) => any) | null;
+    constructor(url: string);
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+}

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

@@ -0,0 +1,83 @@
+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");
+    }
+    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;
+    }
+    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;
+    }
+  };
+}
+export {
+  RPCWebSocket
+};

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

@@ -0,0 +1,6 @@
+/**
+ * For browsers only. Sets up the current window to listen for RPC requests
+ * from React Native or other windows
+ */
+export declare function setupWindowRpc(baseUrl?: string, channel?: string): void;
+export * from '#src/index.ts';

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

@@ -0,0 +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 { 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");
+}
+export * from "../../index.js";
+export {
+  setupWindowRpc
+};

package/lib/browser/external-rpc/setup-jsc.d.ts

@@ -0,0 +1,24 @@
+import '#src/external-rpc/jsc-polyfills/index.ts';
+import * as AttestorRPCImport from '#src/external-rpc/index.ts';
+declare global {
+    /**
+     * `sendMessage` function should be provided by the host of the JS environment for sending messages to host
+     */
+    function sendMessage(channelName: string, message: any): void | Promise<void>;
+    var AttestorRPC: typeof AttestorRPCImport & {
+        /**
+         * Sets up the library to run in JS environments like QuickJS or JavascriptCore.
+         *
+         * RPC will communicate with user by sending messages using `AttestorRPCChannel` by `<channel>.postMessage(message: string)`,
+         * for example: `globalThis['attestor-core'].postMessage(message: string)`.
+         *
+         * @param baseUrl
+         * @param channel The name of the channel for sending messages. Default channel is 'attestor-core'.
+         */
+        setupJsRpc(baseUrl: string, channel?: string): void;
+    };
+}
+/**
+ * Sets up the library to run in JS environments like QuickJS or JavascriptCore.
+ */
+export declare function setupJsRpc(baseUrl: string, channel?: string): void;

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

@@ -0,0 +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 { 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;
+}
+globalThis.AttestorRPC = { ...AttestorRPCImport, setupJsRpc };
+export {
+  setupJsRpc
+};