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

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

@@ -1,241 +1,232 @@
-import { hexlify } from "ethers";
+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 { benchmark } from "./benchmark.js";
+import { generateRpcRequestId, getCurrentMemoryUsage, getWsApiUrlFromBaseUrl, RPC_MSG_BRIDGE, sendMessageToApp, waitForResponse } from "./utils.js";
+import { ALL_ENC_ALGORITHMS, makeExternalRpcOprfOperator, makeExternalRpcZkOperator } from "./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;
+export 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(data) {
+        const res = {
+            ...data,
+            id,
+            isResponse: true
+        };
+        return sendMessageToApp(res);
     }
-    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;
-  }
+    const { id: reqId, type: reqType } = req;
+    // ignore any messages not for us
+    if (!reqId || !reqType) {
+        return;
+    }
+    RPC_MSG_BRIDGE.dispatch(req);
+    // ignore response messages
+    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)
+                    : undefined,
+                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
+                    : undefined,
+            });
+            const response = mapToCreateClaimResponse(claimTunnelRes);
+            return { type: 'createClaimDone', response };
+        case 'createClaimOnAvs':
+            const avsRes = await createClaimOnAvs({
+                ...req.request,
+                payer: req.request.payer === 'attestor'
+                    ? { attestor: getWsApiUrlFromBaseUrl() }
+                    : undefined,
+                context: req.request.context
+                    ? JSON.parse(req.request.context)
+                    : undefined,
+                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)
+                    : undefined,
+                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,
+                }))
+                : undefined);
+            return { type: 'setLogLevelDone', response: undefined };
+        case 'benchmarkZK':
+            return { type: 'benchmarkZKDone', response: await benchmark() };
+        case 'ping':
+            return { type: 'pingDone', response: { pong: 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 getZkOperators(mode = 'default', zkEngine = 'snarkjs') {
+    // use default snarkJS ops
+    if (mode === 'default') {
+        return;
+    }
+    // the native app/window calling implements
+    // a ZK operator & wants to use it
+    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;
+function getOprfOperators(mode = 'default', zkEngine = 'snarkjs') {
+    // use default webview ops
+    if (mode === 'default') {
+        return;
+    }
+    // the native app/window calling implements
+    // a ZK operator & wants to use it
+    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;
+    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)
+                    : undefined
+            },
+            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()
-    ]
-  };
+    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 +1,82 @@
-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;
+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 = {
+if (typeof console === 'undefined') {
     // @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);
-    }
-  };
+    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.TextEncoder === 'undefined') {
+    globalThis.TextEncoder = TextEncoder;
 }
-if (typeof globalThis.TextDecoder === "undefined") {
-  globalThis.TextDecoder = TextDecoder;
+if (typeof globalThis.TextDecoder === 'undefined') {
+    globalThis.TextDecoder = TextDecoder;
 }
-if (typeof globalThis.EventTarget === "undefined") {
-  globalThis.EventTarget = EventTarget;
+if (typeof globalThis.EventTarget === 'undefined') {
+    globalThis.EventTarget = EventTarget;
 }
-if (typeof globalThis.atob === "undefined") {
-  globalThis.atob = (a) => uint8ArrayToBinaryStr(toByteArray(a));
+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);
+if (typeof globalThis.btoa === 'undefined') {
+    function binaryStringToUint8Array(binaryString) {
+        const uint8Array = new Uint8Array(binaryString.length);
+        for (let i = 0; i < binaryString.length; i++) {
+            uint8Array[i] = binaryString.charCodeAt(i);
+        }
+        return uint8Array;
     }
-    return uint8Array;
-  };
-  globalThis.btoa = (b) => fromByteArray(binaryStringToUint8Array(b));
+    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);
+if (typeof globalThis.clearTimeout === 'undefined') {
+    const ogSettimeout = globalThis.setTimeout;
+    if (!ogSettimeout) {
+        throw new Error('setTimeout is not defined, no polyfill yet');
+    }
+    // @ts-expect-error
+    globalThis.setTimeout = (fn, delayMs, ...args) => {
+        let aborted = false;
+        const abortableFn = (...args) => {
+            if (aborted) {
+                return;
+            }
+            return fn(...args);
+        };
+        const val = ogSettimeout(abortableFn, delayMs, ...args);
+        return {
+            original: val,
+            abort() {
+                aborted = true;
+            }
+        };
     };
-    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();
+        }
     };
-  };
-  globalThis.clearTimeout = (id) => {
-    if (typeof id === "object" && !!id && "abort" in id) {
-      id.abort();
-    }
-  };
 }

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

@@ -1,15 +1,20 @@
-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;
+import { URL as WHATWG_URL } from 'whatwg-url';
+import { CloseEventPolyfill, ErrorEventPolyfill, EventPolyfill, MessageEventPolyfill } from "./event.js";
+import { RPCWebSocket } from "./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.Event === 'undefined') {
+    // @ts-expect-error
+    globalThis.Event = EventPolyfill;
+    // @ts-expect-error
+    globalThis.ErrorEvent = ErrorEventPolyfill;
+    // @ts-expect-error
+    globalThis.CloseEvent = CloseEventPolyfill;
+    // @ts-expect-error
+    globalThis.MessageEvent = MessageEventPolyfill;
 }
-if (typeof globalThis.WebSocket === "undefined") {
-  globalThis.WebSocket = RPCWebSocket;
+if (typeof globalThis.WebSocket === 'undefined') {
+    // @ts-expect-error
+    globalThis.WebSocket = RPCWebSocket;
 }