@reclaimprotocol/attestor-core 3.0.1

package/lib/window-rpc/setup-window-rpc.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupWindowRpc = setupWindowRpc;
+const tls_1 = require("@reclaimprotocol/tls");
+const create_claim_on_avs_1 = require("src/avs/client/create-claim-on-avs");
+const client_1 = require("src/client");
+const utils_1 = require("src/providers/http/utils");
+const utils_2 = require("src/utils");
+const benchmark_1 = require("src/utils/benchmark");
+const utils_3 = require("src/window-rpc/utils");
+const window_rpc_zk_1 = require("src/window-rpc/window-rpc-zk");
+class WindowRPCEvent extends Event {
+    constructor(data) {
+        super('message');
+        this.data = data;
+    }
+}
+const VALID_MODULES = [
+    'attestor-core',
+    'witness-sdk'
+];
+let logger = (0, utils_2.makeLogger)(true);
+/**
+ * Sets up the current window to listen for RPC requests
+ * from React Native or other windows
+ */
+function setupWindowRpc() {
+    window.addEventListener('message', handleMessage, false);
+    const windowMsgs = new EventTarget();
+    const defaultUrl = (0, utils_3.getWsApiUrlFromLocation)();
+    logger.info({ defaultUrl }, 'window RPC setup');
+    async function handleMessage(event) {
+        let id = '';
+        let channel = '';
+        try {
+            if (!event.data) {
+                return;
+            }
+            const req = (typeof event.data === 'string'
+                ? JSON.parse(event.data)
+                : event.data);
+            // ignore any messages not for us
+            if (!VALID_MODULES.includes(req.module)) {
+                return;
+            }
+            id = req.id;
+            channel = req.channel || '';
+            windowMsgs.dispatchEvent(new WindowRPCEvent(req));
+            // ignore response messages
+            if (('isResponse' in req && req.isResponse)) {
+                return;
+            }
+            if (!req.id) {
+                logger.warn({ req }, 'Window RPC request missing ID');
+                return;
+            }
+            logger.info({ req, origin: event.origin }, 'processing RPC request');
+            switch (req.type) {
+                case 'createClaim':
+                    const claimTunnelRes = await (0, client_1.createClaimOnAttestor)({
+                        ...req.request,
+                        context: req.request.context
+                            ? JSON.parse(req.request.context)
+                            : undefined,
+                        zkOperators: getZkOperators(req.request.zkOperatorMode, req.request.zkEngine),
+                        client: { url: defaultUrl },
+                        logger,
+                        onStep(step) {
+                            sendMessage({
+                                type: 'createClaimStep',
+                                step: {
+                                    name: req.module.includes('witness')
+                                        // backwards compatibility
+                                        ? 'witness-progress'
+                                        : 'attestor-progress',
+                                    step,
+                                },
+                                module: req.module,
+                                id: req.id,
+                            });
+                        },
+                        updateProviderParams: req.request.updateProviderParams
+                            ? updateProviderParams
+                            : undefined
+                    });
+                    const response = (0, utils_3.mapToCreateClaimResponse)(claimTunnelRes);
+                    respond({
+                        type: 'createClaimDone',
+                        response,
+                    });
+                    break;
+                case 'createClaimOnAvs':
+                    const avsRes = await (0, create_claim_on_avs_1.createClaimOnAvs)({
+                        ...req.request,
+                        payer: req.request.payer === 'attestor'
+                            ? { attestor: defaultUrl }
+                            : undefined,
+                        context: req.request.context
+                            ? JSON.parse(req.request.context)
+                            : undefined,
+                        zkOperators: getZkOperators(req.request.zkOperatorMode, req.request.zkEngine),
+                        logger,
+                        onStep(step) {
+                            sendMessage({
+                                type: 'createClaimOnAvsStep',
+                                step,
+                                module: req.module,
+                                id: req.id,
+                            });
+                        },
+                    });
+                    respond({
+                        type: 'createClaimOnAvsDone',
+                        response: avsRes,
+                    });
+                    break;
+                case 'extractHtmlElement':
+                    respond({
+                        type: 'extractHtmlElementDone',
+                        response: (0, utils_1.extractHTMLElement)(req.request.html, req.request.xpathExpression, req.request.contentsOnly),
+                    });
+                    break;
+                case 'extractJSONValueIndex':
+                    respond({
+                        type: 'extractJSONValueIndexDone',
+                        response: (0, utils_1.extractJSONValueIndex)(req.request.json, req.request.jsonPath),
+                    });
+                    break;
+                case 'getCurrentMemoryUsage':
+                    respond({
+                        type: 'getCurrentMemoryUsageDone',
+                        response: await (0, utils_3.getCurrentMemoryUsage)(),
+                    });
+                    break;
+                case 'setLogLevel':
+                    logger = (0, utils_2.makeLogger)(true, req.request.logLevel, req.request.sendLogsToApp
+                        ? (level, message) => (sendMessage({
+                            type: 'log',
+                            level,
+                            message,
+                            module: req.module,
+                            id: req.id,
+                        }))
+                        : undefined);
+                    respond({
+                        type: 'setLogLevelDone',
+                        response: undefined
+                    });
+                    break;
+                case 'benchmarkZK':
+                    respond({
+                        type: 'benchmarkZKDone',
+                        response: await (0, benchmark_1.Benchmark)(),
+                    });
+                    break;
+                default:
+                    break;
+            }
+        }
+        catch (err) {
+            logger.error({ msg: err.message, err, data: event.data }, 'error in RPC');
+            respond({
+                type: 'error',
+                data: {
+                    message: err.message,
+                    stack: err.stack,
+                }
+            });
+        }
+        function getZkOperators(zkOperatorMode = 'default', zkEngine = 'snarkJS') {
+            // use default snarkJS ops
+            if (zkOperatorMode === 'default') {
+                return;
+            }
+            // the native app/window calling implements
+            // a ZK operator & wants to use it
+            const operators = {};
+            for (const alg of window_rpc_zk_1.ALL_ENC_ALGORITHMS) {
+                operators[alg] = (0, window_rpc_zk_1.makeWindowRpcZkOperator)(alg, makeCommunicationBridge(), zkEngine);
+            }
+            return operators;
+        }
+        function makeCommunicationBridge() {
+            return {
+                send: sendMessage,
+                onMessage(cb) {
+                    windowMsgs.addEventListener('message', handle);
+                    return () => {
+                        windowMsgs.removeEventListener('message', handle);
+                    };
+                    function handle(msg) {
+                        cb(msg.data);
+                    }
+                },
+            };
+        }
+        function respond(data) {
+            const res = {
+                ...data,
+                id,
+                module: 'attestor-core',
+                isResponse: true
+            };
+            return sendMessage(res);
+        }
+        function sendMessage(data) {
+            var _a;
+            const str = JSON.stringify(data);
+            if (channel) {
+                (_a = window[channel]) === null || _a === void 0 ? void 0 : _a.postMessage(str);
+            }
+            else {
+                event.source.postMessage(str);
+            }
+        }
+        async function updateProviderParams(transcript, tlsVersion) {
+            const { req, res } = (0, utils_1.generateRequstAndResponseFromTranscript)(transcript, tlsVersion);
+            const bridge = makeCommunicationBridge();
+            const id = (0, utils_3.generateRpcRequestId)();
+            const waitForRes = (0, window_rpc_zk_1.waitForResponse)('updateProviderParams', id, bridge);
+            bridge.send({
+                type: 'updateProviderParams',
+                id,
+                request: {
+                    request: {
+                        ...req,
+                        body: req.body
+                            ? (0, tls_1.uint8ArrayToStr)(req.body)
+                            : undefined
+                    },
+                    response: { ...res, body: (0, tls_1.uint8ArrayToStr)(res.body) },
+                },
+                module: 'attestor-core'
+            });
+            return await waitForRes;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"setup-window-rpc.js","sourceRoot":"","sources":["../../src/window-rpc/setup-window-rpc.ts"],"names":[],"mappings":"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"}

package/lib/window-rpc/types.d.ts

@@ -0,0 +1,184 @@
+import type { EncryptionAlgorithm, ZKOperator } from '@reclaimprotocol/circom-symmetric-crypto';
+import type { TaskCompletedEventObject } from 'src/avs/contracts/ReclaimServiceManager';
+import type { CreateClaimOnAvsOpts, CreateClaimOnAvsStep } from 'src/avs/types';
+import type { extractHTMLElement, extractJSONValueIndex } from 'src/providers/http/utils';
+import type { AttestorData, CompleteClaimData, CreateClaimOnAttestorOpts, LogLevel, ProofGenerationStep, ProviderName, ProviderParams, ProviderSecretParams, ZKEngine } from 'src/types';
+import { HttpRequest, HttpResponse } from 'src/utils';
+type IdentifiedMessage = {
+    module: 'attestor-core';
+    /**
+     * Optionally, name of the channel to respond to
+     * Useful for specifying 'flutter_webview'
+     * channel
+     */
+    channel?: string;
+    id: string;
+};
+type CreateClaimRPCBaseOpts = {
+    /**
+     * Specify the mode for the ZK operator,
+     * 'default' -> will use the default ZK operator included in the SDK
+     * (presently that's SnarkJS supported by FFs running on WASM)
+     * 'rpc' -> if you've access to a native ZK operator, you can use this mode
+     * For eg. on React Native
+     */
+    zkOperatorMode?: 'default' | 'rpc';
+    context?: string;
+    zkEngine?: ZKEngine;
+    updateProviderParams?: boolean;
+};
+export type RPCCreateClaimOptions<N extends ProviderName = any> = Omit<CreateClaimOnAttestorOpts<N>, 'zkOperators' | 'context'> & CreateClaimRPCBaseOpts;
+export type RPCCreateClaimOnAvsOptions<N extends ProviderName = any> = Omit<CreateClaimOnAvsOpts<N>, 'zkOperators' | 'context' | 'payer'> & {
+    payer?: 'attestor';
+} & CreateClaimRPCBaseOpts;
+type ExtractHTMLElementOptions = {
+    html: string;
+    xpathExpression: string;
+    contentsOnly: boolean;
+};
+type ExtractJSONValueIndexOptions = {
+    json: string;
+    jsonPath: string;
+};
+type ZKProveOpts = {
+    algorithm: EncryptionAlgorithm;
+    input: {
+        /** Base64 encoded attestor */
+        witnessB64: string;
+    };
+};
+type UpdateProviderParamsOpts = {
+    request: Omit<HttpRequest, 'body'> & {
+        body: string | undefined;
+    };
+    response: Omit<HttpResponse, 'body'> & {
+        body: string | undefined;
+    };
+};
+type ZKVerifyOpts = {
+    algorithm: EncryptionAlgorithm;
+    publicSignals: number[];
+    proof: {
+        [key: string]: string;
+    } | string;
+};
+type LogLevelOptions = {
+    logLevel: LogLevel;
+    /**
+     * If true, log messages will be sent back to the app
+     * via postMessage
+     */
+    sendLogsToApp: boolean;
+};
+type AVSCreateResult = {
+    object: TaskCompletedEventObject;
+    txHash: string;
+};
+/**
+ * Legacy V1 create claim response
+ */
+export type CreateClaimResponse = {
+    identifier: string;
+    claimData: CompleteClaimData;
+    signatures: string[];
+    /**
+     * @deprecated no longer valid
+     */
+    witnesses: AttestorData[];
+};
+/**
+ * Fns the app calls on the attestor.
+ * These are things done inside the attestor
+ */
+export type WindowRPCClient = {
+    /**
+     * Create a claim on the attestor where the RPC SDK is hosted.
+     */
+    createClaim(options: RPCCreateClaimOptions): Promise<CreateClaimResponse>;
+    /**
+     * Create a claim on the AVS
+     */
+    createClaimOnAvs(opts: RPCCreateClaimOnAvsOptions): Promise<AVSCreateResult>;
+    /**
+     * Extract an HTML element from a string of HTML
+     */
+    extractHtmlElement(options: ExtractHTMLElementOptions): Promise<ReturnType<typeof extractHTMLElement>>;
+    extractJSONValueIndex(options: ExtractJSONValueIndexOptions): Promise<ReturnType<typeof extractJSONValueIndex>>;
+    getCurrentMemoryUsage(): Promise<{
+        available: boolean;
+        content: string;
+    }>;
+    /**
+     * Set the log level for the attestor,
+     * optionally set "sendLogsToApp" to true to send logs
+     * back to the app
+     */
+    setLogLevel(options: LogLevelOptions): Promise<void>;
+    benchmarkZK(): Promise<string>;
+};
+/**
+ * Fns the attestor calls on the app
+ */
+export type WindowRPCAppClient = {
+    zkProve(opts: ZKProveOpts): ReturnType<ZKOperator['groth16Prove']>;
+    zkVerify(opts: ZKVerifyOpts): ReturnType<ZKOperator['groth16Verify']>;
+    updateProviderParams(opts: UpdateProviderParamsOpts): Promise<{
+        params: Partial<ProviderParams<'http'>>;
+        secretParams: Partial<ProviderSecretParams<'http'>>;
+    }>;
+};
+type AnyRPCClient = {
+    [_: string]: (opts: any) => any;
+};
+export type WindowRPCRequest<T extends AnyRPCClient, K extends keyof T> = {
+    type: K;
+    request: Parameters<T[K]>[0];
+};
+export type WindowRPCResponse<T extends AnyRPCClient, K extends (keyof T) & string> = {
+    type: `${K}Done`;
+    response: Awaited<ReturnType<T[K]>>;
+};
+export type WindowRPCErrorResponse = {
+    type: 'error';
+    data: {
+        message: string;
+        stack: string;
+    };
+};
+type AsResponse<T> = T & {
+    isResponse: true;
+};
+/**
+ * Data sent to the attestor from the window/application
+ */
+export type WindowRPCIncomingMsg = (WindowRPCRequest<WindowRPCClient, 'createClaim'> | WindowRPCRequest<WindowRPCClient, 'createClaimOnAvs'> | WindowRPCRequest<WindowRPCClient, 'extractHtmlElement'> | WindowRPCRequest<WindowRPCClient, 'extractJSONValueIndex'> | WindowRPCRequest<WindowRPCClient, 'getCurrentMemoryUsage'> | WindowRPCRequest<WindowRPCClient, 'setLogLevel'> | WindowRPCRequest<WindowRPCClient, 'benchmarkZK'> | AsResponse<WindowRPCResponse<WindowRPCAppClient, 'zkProve'>> | AsResponse<WindowRPCResponse<WindowRPCAppClient, 'zkVerify'>> | AsResponse<WindowRPCResponse<WindowRPCAppClient, 'updateProviderParams'>> | AsResponse<WindowRPCErrorResponse>) & IdentifiedMessage;
+/**
+ * Data sent back from the attestor to
+ * the window/application containing the attestor
+ */
+export type WindowRPCOutgoingMsg = (AsResponse<WindowRPCResponse<WindowRPCClient, 'createClaim'>> | AsResponse<WindowRPCResponse<WindowRPCClient, 'createClaimOnAvs'>> | AsResponse<WindowRPCResponse<WindowRPCClient, 'extractHtmlElement'>> | AsResponse<WindowRPCResponse<WindowRPCClient, 'extractJSONValueIndex'>> | AsResponse<WindowRPCResponse<WindowRPCClient, 'getCurrentMemoryUsage'>> | AsResponse<WindowRPCResponse<WindowRPCClient, 'setLogLevel'>> | AsResponse<WindowRPCResponse<WindowRPCClient, 'benchmarkZK'>> | WindowRPCRequest<WindowRPCAppClient, 'zkProve'> | WindowRPCRequest<WindowRPCAppClient, 'zkVerify'> | WindowRPCRequest<WindowRPCAppClient, 'updateProviderParams'> | ({
+    type: 'createClaimStep';
+    step: {
+        name: 'attestor-progress' | 'witness-progress';
+        step: ProofGenerationStep;
+    };
+}) | ({
+    type: 'createClaimOnAvsStep';
+    step: CreateClaimOnAvsStep;
+}) | ({
+    type: 'log';
+    level: LogLevelOptions['logLevel'];
+    message: object;
+}) | AsResponse<WindowRPCErrorResponse>) & IdentifiedMessage;
+export type CommunicationBridge = {
+    send(msg: WindowRPCOutgoingMsg): void;
+    onMessage(cb: (msg: WindowRPCIncomingMsg) => void): (() => void);
+};
+declare global {
+    interface Performance {
+        measureUserAgentSpecificMemory(): {
+            bytes: number;
+        };
+    }
+}
+export {};

package/lib/window-rpc/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd2luZG93LXJwYy90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/lib/window-rpc/utils.d.ts

@@ -0,0 +1,13 @@
+import { ClaimTunnelResponse } from 'src/proto/api';
+import { CreateClaimResponse } from 'src/window-rpc/types';
+export declare function getCurrentMemoryUsage(): Promise<{
+    available: boolean;
+    content: string;
+}>;
+export declare function generateRpcRequestId(): string;
+/**
+ * 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 declare function getWsApiUrlFromLocation(): string;
+export declare function mapToCreateClaimResponse(res: ClaimTunnelResponse): CreateClaimResponse;

package/lib/window-rpc/utils.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentMemoryUsage = getCurrentMemoryUsage;
+exports.generateRpcRequestId = generateRpcRequestId;
+exports.getWsApiUrlFromLocation = getWsApiUrlFromLocation;
+exports.mapToCreateClaimResponse = mapToCreateClaimResponse;
+const ethers_1 = require("ethers");
+const config_1 = require("src/config");
+const utils_1 = require("src/utils");
+// track memory usage
+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 = await 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);
+}
+/**
+ * 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.
+ */
+function getWsApiUrlFromLocation() {
+    const { host, protocol } = location;
+    const wsProtocol = protocol === 'https:' ? 'wss:' : 'ws:';
+    return `${wsProtocol}//${host}${config_1.WS_PATHNAME}`;
+}
+function mapToCreateClaimResponse(res) {
+    if (!res.claim) {
+        throw utils_1.AttestorError.fromProto(res.error);
+    }
+    return {
+        identifier: (0, utils_1.getIdentifierFromClaimInfo)(res.claim),
+        claimData: res.claim,
+        witnesses: [
+            {
+                id: res.signatures.attestorAddress,
+                url: getWsApiUrlFromLocation()
+            }
+        ],
+        signatures: [
+            ethers_1.ethers.utils
+                .hexlify(res.signatures.claimSignature)
+                .toLowerCase()
+        ]
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/window-rpc/window-rpc-zk.d.ts

@@ -0,0 +1,11 @@
+import { EncryptionAlgorithm, ZKOperator } from '@reclaimprotocol/circom-symmetric-crypto';
+import { ZKEngine } from 'src/types';
+import { CommunicationBridge, WindowRPCAppClient } from 'src/window-rpc/types';
+export declare const ALL_ENC_ALGORITHMS: EncryptionAlgorithm[];
+/**
+ * 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 declare function makeWindowRpcZkOperator(algorithm: EncryptionAlgorithm, bridge: CommunicationBridge, zkEngine?: ZKEngine): ZKOperator;
+export declare function waitForResponse<T extends keyof WindowRPCAppClient>(type: T, requestId: string, bridge: CommunicationBridge): Promise<Awaited<ReturnType<WindowRPCAppClient[T]>>>;

package/lib/window-rpc/window-rpc-zk.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALL_ENC_ALGORITHMS = void 0;
+exports.makeWindowRpcZkOperator = makeWindowRpcZkOperator;
+exports.waitForResponse = waitForResponse;
+const utils_1 = require("ethers/lib/utils");
+const utils_2 = require("src/utils");
+const utils_3 = require("src/window-rpc/utils");
+exports.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
+ */
+function makeWindowRpcZkOperator(algorithm, bridge, zkEngine = 'snarkJS') {
+    return {
+        async generateWitness(input) {
+            const operator = await (0, utils_2.makeDefaultZkOperator)(algorithm, zkEngine, utils_2.logger);
+            return operator.generateWitness(input);
+        },
+        groth16Prove(input) {
+            const id = (0, utils_3.generateRpcRequestId)();
+            const waitForRes = waitForResponse('zkProve', id, bridge);
+            bridge.send({
+                type: 'zkProve',
+                id,
+                request: {
+                    algorithm,
+                    input: { witnessB64: utils_1.base64.encode(input) },
+                },
+                module: 'attestor-core'
+            });
+            return waitForRes;
+        },
+        groth16Verify(publicSignals, proof) {
+            const id = (0, utils_3.generateRpcRequestId)();
+            const waitForRes = waitForResponse('zkVerify', id, bridge);
+            bridge.send({
+                type: 'zkVerify',
+                id,
+                request: {
+                    algorithm,
+                    publicSignals,
+                    proof,
+                },
+                module: 'attestor-core'
+            });
+            return waitForRes;
+        },
+    };
+}
+function waitForResponse(type, requestId, bridge) {
+    const returnType = `${type}Done`;
+    return new Promise((resolve, reject) => {
+        const cancel = bridge.onMessage(msg => {
+            if (msg.id === requestId) {
+                if (msg.type === 'error') {
+                    reject(new Error(msg.data.message));
+                }
+                else if (msg.type === returnType) {
+                    resolve(msg.response);
+                }
+                cancel();
+            }
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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