@reclaimprotocol/attestor-core 5.0.1-beta.13 → 5.0.1-beta.16

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

@@ -1,241 +0,0 @@
-import { hexlify } from "ethers";
-import { createClaimOnAvs } from "#src/avs/client/create-claim-on-avs.js";
-import { createClaimOnAttestor } from "#src/client/index.js";
-import { benchmark } from "#src/external-rpc/benchmark.js";
-import { generateRpcRequestId, getCurrentMemoryUsage, getWsApiUrlFromBaseUrl, RPC_MSG_BRIDGE, sendMessageToApp, waitForResponse } from "#src/external-rpc/utils.js";
-import { ALL_ENC_ALGORITHMS, makeExternalRpcOprfOperator, makeExternalRpcZkOperator } from "#src/external-rpc/zk.js";
-import { createClaimOnMechain } from "#src/mechain/client/create-claim-on-mechain.js";
-import { extractHTMLElement, extractJSONValueIndex, generateRequstAndResponseFromTranscript } from "#src/providers/http/utils.js";
-import { B64_JSON_REVIVER } from "#src/utils/b64-json.js";
-import { AttestorError, getIdentifierFromClaimInfo, logger, makeLogger, uint8ArrayToStr } from "#src/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/external-rpc/jsc-polyfills/1.js

@@ -1,80 +0,0 @@
-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/external-rpc/jsc-polyfills/2.js

@@ -1,15 +0,0 @@
-import { URL as WHATWG_URL } from "whatwg-url";
-import { CloseEventPolyfill, ErrorEventPolyfill, EventPolyfill, MessageEventPolyfill } from "#src/external-rpc/jsc-polyfills/event.js";
-import { RPCWebSocket } from "#src/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/external-rpc/jsc-polyfills/event.js

@@ -1,19 +0,0 @@
-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/external-rpc/jsc-polyfills/index.js

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

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

@@ -1,83 +0,0 @@
-import { RPC_MSG_BRIDGE, rpcRequest } from "#src/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/external-rpc/setup-browser.js

@@ -1,33 +0,0 @@
-import { setCryptoImplementation } from "@reclaimprotocol/tls";
-import { webcryptoCrypto } from "@reclaimprotocol/tls/webcrypto";
-import { handleIncomingMessage } from "#src/external-rpc/handle-incoming-msg.js";
-import { getWsApiUrlFromBaseUrl } from "#src/external-rpc/utils.js";
-import { logger, makeLogger } from "#src/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 "#src/index.js";
-export {
-  setupWindowRpc
-};

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

@@ -1,22 +0,0 @@
-import "#src/external-rpc/jsc-polyfills/index.js";
-1;
-import { setCryptoImplementation } from "@reclaimprotocol/tls";
-import { pureJsCrypto } from "@reclaimprotocol/tls/purejs-crypto";
-import * as AttestorRPCImport from "#src/external-rpc/index.js";
-import { makeLogger } from "#src/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
-};

package/lib/external-rpc/utils.js

@@ -1,100 +0,0 @@
-import { WS_PATHNAME } from "#src/config/index.js";
-import { EventBus } from "#src/external-rpc/event-bus.js";
-import { B64_JSON_REPLACER } from "#src/utils/b64-json.js";
-import { AttestorError } from "#src/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;
-    }
-  }
-}
-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}`;
-}
-function rpcRequest(opts) {
-  const id = generateRpcRequestId();
-  const waitForRes = waitForResponse(opts.type, id);
-  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();
-    });
-  });
-}
-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 +0,0 @@
-import { rpcRequest } from "#src/external-rpc/utils.js";
-import { logger, makeDefaultZkOperator } from "#src/utils/index.js";
-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] });
-    }
-  };
-}
-function callFnZk(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] });
-    }
-  };
-}
-function callFnOprf(request) {
-  return rpcRequest({ type: "executeOprfFunctionV3", request });
-}
-export {
-  ALL_ENC_ALGORITHMS,
-  makeExternalRpcOprfOperator,
-  makeExternalRpcZkOperator
-};