@reclaimprotocol/attestor-core 5.0.4 → 5.0.6

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

@@ -1,233 +0,0 @@
-import { utils } from 'ethers';
-import { createClaimOnAvs } from "../avs/client/create-claim-on-avs.js";
-import { createClaimOnAttestor } from "../client/index.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";
-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);
-    }
-}
-async function _handleIncomingMessage(req) {
-    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') {
-    // 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') {
-    // 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)
-                    : 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: [
-            utils
-                .hexlify(res.signatures.claimSignature)
-                .toLowerCase()
-        ]
-    };
-}

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

@@ -1,82 +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') {
-    // @ts-expect-error
-    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') {
-    function binaryStringToUint8Array(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');
-    }
-    // @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;
-            }
-        };
-    };
-    globalThis.clearTimeout = (id) => {
-        if (typeof id === 'object' && !!id && 'abort' in id) {
-            id.abort();
-        }
-    };
-}

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

@@ -1,20 +0,0 @@
-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') {
-    // @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') {
-    // @ts-expect-error
-    globalThis.WebSocket = RPCWebSocket;
-}

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

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

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

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

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

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

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 "./handle-incoming-msg.js";
-import { getWsApiUrlFromBaseUrl } from "./utils.js";
-import { logger, makeLogger } from "../utils/index.js";
-makeLogger(true);
-setCryptoImplementation(webcryptoCrypto);
-/**
- * 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";

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

@@ -1,22 +0,0 @@
-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);
-/**
- * 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 };

package/lib/external-rpc/types.js

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

package/lib/external-rpc/utils.js

@@ -1,100 +0,0 @@
-import { WS_PATHNAME } from "../config/index.js";
-import { EventBus } from "./event-bus.js";
-import { B64_JSON_REPLACER } from "../utils/b64-json.js";
-import { AttestorError } from "../utils/error.js";
-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;
-        }
-    }
-}
-export function generateRpcRequestId() {
-    return Math.random().toString(36).slice(2);
-}
-/**
- * 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}`;
-}
-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;
-}
-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();
-        });
-    });
-}
-/**
- * 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);
-}

package/lib/external-rpc/zk.js

@@ -1,63 +0,0 @@
-import { rpcRequest } from "./utils.js";
-import { logger, makeDefaultZkOperator } from "../utils/index.js";
-export const ALL_ENC_ALGORITHMS = [
-    'aes-256-ctr',
-    'aes-128-ctr',
-    'chacha20',
-];
-/**
- * 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 });
-}
-/**
- * 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 });
-}