@reclaimprotocol/attestor-core 5.0.1-beta.7 → 5.0.1

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

@@ -1,213 +0,0 @@
-import '#src/external-rpc/global.d.ts';
-import type { OPRFOperator, ZKEngine, ZKOperator } from '@reclaimprotocol/zk-symmetric-crypto';
-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 = {
-    id: string;
-};
-type CreateClaimRPCBaseOpts = {
-    /**
-     * Specify the mode for the ZK & OPRF 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;
-    authRequest?: AuthenticationRequest;
-};
-export type RPCCreateClaimOptions<N extends ProviderName = any> = Omit<CreateClaimOnAttestorOpts<N>, 'zkOperators' | 'context' | 'client'> & CreateClaimRPCBaseOpts;
-export type RPCCreateClaimOnAvsOptions<N extends ProviderName = any> = Omit<CreateClaimOnAvsOpts<N>, 'zkOperators' | 'context' | 'payer'> & {
-    payer?: 'attestor';
-} & CreateClaimRPCBaseOpts;
-export type RPCCreateClaimOnMechainOptions<N extends ProviderName = any> = Omit<CreateClaimOnAvsOpts<N>, 'zkOperators' | 'context'> & CreateClaimRPCBaseOpts;
-type ExtractHTMLElementOptions = {
-    html: string;
-    xpathExpression: string;
-    contentsOnly: boolean;
-};
-type ExtractJSONValueIndexOptions = {
-    json: string;
-    jsonPath: string;
-};
-type UpdateProviderParamsOpts = {
-    request: Omit<HttpRequest, 'body'> & {
-        body: string | undefined;
-    };
-    response: Omit<HttpResponse, 'body'> & {
-        body: string | undefined;
-    };
-};
-type LogLevelOptions = {
-    logLevel: LogLevel;
-    /**
-     * If true, log messages will be sent back to the app
-     * via postMessage
-     */
-    sendLogsToApp: boolean;
-};
-type AVSCreateResult = {
-    object: TaskCompletedEvent.OutputObject;
-    txHash: string;
-};
-type MechainCreateResult = {
-    taskId: number;
-    data: CreateClaimResponse[];
-};
-/**
- * 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 ExternalRPCClient = {
-    /**
-     * 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>;
-    /**
-     * Create a claim on Mechain
-     */
-    createClaimOnMechain(opts: RPCCreateClaimOnMechainOptions): Promise<MechainCreateResult>;
-    /**
-     * 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>;
-    ping(): Promise<{
-        pong: string;
-    }>;
-};
-type AsFunction<K> = K extends (...args: any[]) => any ? K : never;
-type FunctionalOperator<T, K extends keyof T> = {
-    fn: K;
-    args: Parameters<AsFunction<T[K]>>;
-};
-export type ExecuteZKOpts<T extends keyof ZKOperator = keyof ZKOperator> = FunctionalOperator<ZKOperator, T>;
-export type ExecuteOPRFOpts<T extends keyof OPRFOperator = keyof OPRFOperator> = FunctionalOperator<OPRFOperator, T>;
-/**
- * Fns the attestor calls on the app
- */
-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 ExternalRPCRequest<T extends AnyRPCClient, K extends keyof T> = {
-    type: K;
-    request: Parameters<T[K]>[0];
-};
-export type ExternalRPCResponse<T extends AnyRPCClient, K extends (keyof T) & string> = {
-    type: `${K}Done`;
-    response: Awaited<ReturnType<T[K]>>;
-};
-export type ExternalRPCErrorResponse = {
-    type: 'error';
-    data: {
-        message: string;
-        stack: string;
-    };
-};
-type AsResponse<T> = T & {
-    isResponse: true;
-};
-/**
- * Data sent to the attestor from the window/application
- */
-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 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';
-        step: ProofGenerationStep;
-    };
-}) | ({
-    type: 'createClaimOnAvsStep';
-    step: CreateClaimOnAvsStep;
-}) | ({
-    type: 'createClaimOnMechainStep';
-    step: CreateClaimOnMechainStep;
-}) | ({
-    type: 'log';
-    level: LogLevelOptions['logLevel'];
-    message: object;
-}) | AsResponse<ExternalRPCErrorResponse>) & IdentifiedMessage;
-export {};

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

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

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

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

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

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

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

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

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