@reclaimprotocol/attestor-core 4.0.3 → 5.0.1-beta.10

package/lib/{window-rpc → browser/external-rpc}/types.d.ts

@@ -1,19 +1,13 @@
+import '#src/external-rpc/global.d.ts';
 import type { OPRFOperator, ZKEngine, ZKOperator } from '@reclaimprotocol/zk-symmetric-crypto';
-import type { TaskCompletedEventObject } from '../avs/contracts/ReclaimServiceManager';
-import type { CreateClaimOnAvsOpts, CreateClaimOnAvsStep } from '../avs/types';
-import type { CreateClaimOnMechainStep } from '../mechain/types';
-import { AuthenticationRequest } from '../proto/api';
-import type { extractHTMLElement, extractJSONValueIndex } from '../providers/http/utils';
-import type { AttestorData, CompleteClaimData, CreateClaimOnAttestorOpts, LogLevel, ProofGenerationStep, ProviderName, ProviderParams, ProviderSecretParams } from '../types';
-import { HttpRequest, HttpResponse } from '../utils';
+import type { TaskCompletedEvent } from '#src/avs/contracts/ReclaimServiceManager.ts';
+import type { CreateClaimOnAvsOpts, CreateClaimOnAvsStep } from '#src/avs/types/index.ts';
+import type { CreateClaimOnMechainStep } from '#src/mechain/types/index.ts';
+import type { AuthenticationRequest } from '#src/proto/api.ts';
+import type { extractHTMLElement, extractJSONValueIndex } from '#src/providers/http/utils.ts';
+import type { AttestorData, CompleteClaimData, CreateClaimOnAttestorOpts, LogLevel, ProofGenerationStep, ProviderName, ProviderParams, ProviderSecretParams } from '#src/types/index.ts';
+import type { HttpRequest, HttpResponse } from '#src/utils/index.ts';
 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 = {
@@ -61,7 +55,7 @@ type LogLevelOptions = {
     sendLogsToApp: boolean;
 };
 type AVSCreateResult = {
-    object: TaskCompletedEventObject;
+    object: TaskCompletedEvent.OutputObject;
     txHash: string;
 };
 type MechainCreateResult = {
@@ -84,7 +78,7 @@ export type CreateClaimResponse = {
  * Fns the app calls on the attestor.
  * These are things done inside the attestor
  */
-export type WindowRPCClient = {
+export type ExternalRPCClient = {
     /**
      * Create a claim on the attestor where the RPC SDK is hosted.
      */
@@ -113,6 +107,9 @@ export type WindowRPCClient = {
      */
     setLogLevel(options: LogLevelOptions): Promise<void>;
     benchmarkZK(): Promise<string>;
+    ping(): Promise<{
+        pong: string;
+    }>;
 };
 type AsFunction<K> = K extends (...args: any[]) => any ? K : never;
 type FunctionalOperator<T, K extends keyof T> = {
@@ -124,26 +121,55 @@ export type ExecuteOPRFOpts<T extends keyof OPRFOperator = keyof OPRFOperator> =
 /**
  * Fns the attestor calls on the app
  */
-export type WindowRPCAppClient = {
+export type ExternalRPCAppClient = {
     executeZkFunctionV3(opts: ExecuteZKOpts): Promise<any>;
     executeOprfFunctionV3(opts: ExecuteOPRFOpts): Promise<any>;
     updateProviderParams(opts: UpdateProviderParamsOpts): Promise<{
         params: Partial<ProviderParams<'http'>>;
         secretParams: Partial<ProviderSecretParams<'http'>>;
     }>;
+    /**
+     * The runtime needs to open a WebSocket connection. Is required for
+     * runtimes that do not support WebSockets natively.
+     *
+     * The app should facilitate this by opening a WebSocket connection
+     * to the given URL.
+     * "id" is a unique identifier for the WebSocket connection.
+     */
+    connectWs(opts: {
+        id: string;
+        url: string;
+    }): Promise<{}>;
+    /**
+     * Runtime wants to disconnect a WebSocket connection.
+     * "code" is an optional close code,
+     * and "reason" is an optional reason for closing.
+     */
+    disconnectWs(opts: {
+        id: string;
+        code?: number;
+        reason?: any;
+    }): Promise<{}>;
+    /**
+     * Runtime wants to send a message over a WebSocket connection.
+     */
+    sendWsMessage(opts: {
+        id: string;
+        data: ArrayBufferView | string;
+    }): Promise<{}>;
 };
 type AnyRPCClient = {
     [_: string]: (opts: any) => any;
 };
-export type WindowRPCRequest<T extends AnyRPCClient, K extends keyof T> = {
+export type ExternalRPCRequest<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> = {
+export type ExternalRPCResponse<T extends AnyRPCClient, K extends (keyof T) & string> = {
     type: `${K}Done`;
     response: Awaited<ReturnType<T[K]>>;
 };
-export type WindowRPCErrorResponse = {
+export type ExternalRPCErrorResponse = {
     type: 'error';
     data: {
         message: string;
@@ -156,15 +182,21 @@ type AsResponse<T> = T & {
 /**
  * Data sent to the attestor from the window/application
  */
-export type WindowRPCIncomingMsg = (WindowRPCRequest<WindowRPCClient, 'createClaim'> | WindowRPCRequest<WindowRPCClient, 'createClaimOnAvs'> | WindowRPCRequest<WindowRPCClient, 'createClaimOnMechain'> | WindowRPCRequest<WindowRPCClient, 'extractHtmlElement'> | WindowRPCRequest<WindowRPCClient, 'extractJSONValueIndex'> | WindowRPCRequest<WindowRPCClient, 'getCurrentMemoryUsage'> | WindowRPCRequest<WindowRPCClient, 'setLogLevel'> | WindowRPCRequest<WindowRPCClient, 'benchmarkZK'> | AsResponse<WindowRPCResponse<WindowRPCAppClient, 'executeZkFunctionV3'>> | AsResponse<WindowRPCResponse<WindowRPCAppClient, 'executeOprfFunctionV3'>> | AsResponse<WindowRPCResponse<WindowRPCAppClient, 'updateProviderParams'>> | AsResponse<WindowRPCErrorResponse>) & IdentifiedMessage;
+export type ExternalRPCIncomingMsg = (ExternalRPCRequest<ExternalRPCClient, 'createClaim'> | ExternalRPCRequest<ExternalRPCClient, 'createClaimOnAvs'> | ExternalRPCRequest<ExternalRPCClient, 'createClaimOnMechain'> | ExternalRPCRequest<ExternalRPCClient, 'extractHtmlElement'> | ExternalRPCRequest<ExternalRPCClient, 'extractJSONValueIndex'> | ExternalRPCRequest<ExternalRPCClient, 'getCurrentMemoryUsage'> | ExternalRPCRequest<ExternalRPCClient, 'setLogLevel'> | ExternalRPCRequest<ExternalRPCClient, 'benchmarkZK'> | ExternalRPCRequest<ExternalRPCClient, 'ping'> | AsResponse<ExternalRPCResponse<ExternalRPCAppClient, 'executeZkFunctionV3'>> | AsResponse<ExternalRPCResponse<ExternalRPCAppClient, 'executeOprfFunctionV3'>> | AsResponse<ExternalRPCResponse<ExternalRPCAppClient, 'updateProviderParams'>> | AsResponse<ExternalRPCResponse<ExternalRPCAppClient, 'connectWs'>> | AsResponse<ExternalRPCResponse<ExternalRPCAppClient, 'disconnectWs'>> | AsResponse<ExternalRPCResponse<ExternalRPCAppClient, 'sendWsMessage'>> | AsResponse<ExternalRPCErrorResponse> | ExternalRPCRequest<ExternalRPCAppClient, 'sendWsMessage'> | {
+    type: 'disconnectWs';
+    request: {
+        id: string;
+        err?: string;
+    };
+}) & 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, 'executeZkFunctionV3'> | WindowRPCRequest<WindowRPCAppClient, 'executeOprfFunctionV3'> | WindowRPCRequest<WindowRPCAppClient, 'updateProviderParams'> | ({
+export type ExternalRPCOutgoingMsg = (AsResponse<ExternalRPCResponse<ExternalRPCClient, 'createClaim'>> | AsResponse<ExternalRPCResponse<ExternalRPCClient, 'createClaimOnAvs'>> | AsResponse<ExternalRPCResponse<ExternalRPCClient, 'extractHtmlElement'>> | AsResponse<ExternalRPCResponse<ExternalRPCClient, 'extractJSONValueIndex'>> | AsResponse<ExternalRPCResponse<ExternalRPCClient, 'getCurrentMemoryUsage'>> | AsResponse<ExternalRPCResponse<ExternalRPCClient, 'setLogLevel'>> | AsResponse<ExternalRPCResponse<ExternalRPCClient, 'benchmarkZK'>> | AsResponse<ExternalRPCResponse<ExternalRPCClient, 'ping'>> | ExternalRPCRequest<ExternalRPCAppClient, 'executeZkFunctionV3'> | ExternalRPCRequest<ExternalRPCAppClient, 'executeOprfFunctionV3'> | ExternalRPCRequest<ExternalRPCAppClient, 'updateProviderParams'> | ExternalRPCRequest<ExternalRPCAppClient, 'connectWs'> | ExternalRPCRequest<ExternalRPCAppClient, 'disconnectWs'> | ExternalRPCRequest<ExternalRPCAppClient, 'sendWsMessage'> | ({
     type: 'createClaimStep';
     step: {
-        name: 'attestor-progress' | 'witness-progress';
+        name: 'attestor-progress';
         step: ProofGenerationStep;
     };
 }) | ({
@@ -177,16 +209,5 @@ export type WindowRPCOutgoingMsg = (AsResponse<WindowRPCResponse<WindowRPCClient
     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;
-        };
-    }
-}
+}) | AsResponse<ExternalRPCErrorResponse>) & IdentifiedMessage;
 export {};

package/lib/browser/external-rpc/utils.d.ts

@@ -0,0 +1,20 @@
+import { EventBus } from '#src/external-rpc/event-bus.ts';
+import type { ExternalRPCAppClient, ExternalRPCIncomingMsg, ExternalRPCOutgoingMsg, ExternalRPCRequest, ExternalRPCResponse } from '#src/external-rpc/types.ts';
+export declare const RPC_MSG_BRIDGE: EventBus<ExternalRPCIncomingMsg>;
+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 getWsApiUrlFromBaseUrl(): string;
+export declare function rpcRequest<T extends keyof ExternalRPCAppClient>(opts: ExternalRPCRequest<ExternalRPCAppClient, T>): Promise<ExternalRPCResponse<ExternalRPCAppClient, T>['response']>;
+export declare function waitForResponse<T extends keyof ExternalRPCAppClient>(type: T, requestId: string, timeoutMs?: number): Promise<Awaited<ReturnType<ExternalRPCAppClient[T]>>>;
+/**
+ * Sends a message back to the host app
+ * @param data
+ */
+export declare function sendMessageToApp(data: ExternalRPCOutgoingMsg): void;

package/lib/browser/external-rpc/utils.js

@@ -0,0 +1,100 @@
+import { WS_PATHNAME } from "../config/index.js";
+import { EventBus } from "../external-rpc/event-bus.js";
+import { B64_JSON_REPLACER } from "../utils/b64-json.js";
+import { AttestorError } from "../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/browser/external-rpc/zk.d.ts

@@ -0,0 +1,14 @@
+import type { EncryptionAlgorithm, OPRFOperator, ZKEngine, ZKOperator } from '@reclaimprotocol/zk-symmetric-crypto';
+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 makeExternalRpcZkOperator(algorithm: EncryptionAlgorithm, zkEngine?: ZKEngine): ZKOperator;
+/**
+ * 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 declare function makeExternalRpcOprfOperator(algorithm: EncryptionAlgorithm, zkEngine?: ZKEngine): OPRFOperator;

package/lib/browser/external-rpc/zk.js

@@ -0,0 +1,58 @@
+import { rpcRequest } from "../external-rpc/utils.js";
+import { logger, makeDefaultZkOperator } from "../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
+};

package/lib/browser/index.browser.js

@@ -0,0 +1,13 @@
+import * as tls from "@reclaimprotocol/tls";
+export * from "./client/utils/client-socket.js";
+export * from "./config/index.js";
+export * from "./types/index.js";
+export * from "./utils/index.js";
+export * from "./providers/index.js";
+import * as proto from "./proto/api.js";
+export * from "./client/index.js";
+export * from "./mechain/index.js";
+export {
+  proto,
+  tls
+};

package/lib/browser/index.d.ts

@@ -0,0 +1,9 @@
+export * as tls from '@reclaimprotocol/tls';
+export * from './client/utils/client-socket.ts';
+export * from './config/index.ts';
+export * from './types/index.ts';
+export * from './utils/index.js';
+export * from './providers/index.ts';
+export * as proto from './proto/api.ts';
+export * from './client/index.ts';
+export * from './mechain/index.ts';

package/lib/browser/index.js

@@ -0,0 +1,13 @@
+import * as tls from "@reclaimprotocol/tls";
+export * from "./client/utils/client-socket.js";
+export * from "./config/index.js";
+export * from "./types/index.js";
+export * from "./utils/index.js";
+export * from "./providers/index.js";
+import * as proto from "./proto/api.js";
+export * from "./client/index.js";
+export * from "./mechain/index.js";
+export {
+  proto,
+  tls
+};

package/lib/browser/mechain/abis/governanceABI.d.ts

@@ -0,0 +1,50 @@
+export declare const governanceABI: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];