@reclaimprotocol/attestor-core 5.0.2 → 5.0.4

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

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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,22 @@
+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

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

package/lib/external-rpc/utils.js

@@ -0,0 +1,100 @@
+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

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