@joclaim/attestor-core 0.2.0 → 0.2.3

package/src/external-rpc/jsc-polyfills/ws.ts

@@ -1,105 +0,0 @@
-import type { ExternalRPCIncomingMsg } from '#src/external-rpc/types.ts'
-import { RPC_MSG_BRIDGE, rpcRequest } from '#src/external-rpc/utils.ts'
-
-export class RPCWebSocket extends EventTarget implements WebSocket {
-
-	readonly CONNECTING: 0 = 0
-	readonly OPEN: 1 = 1
-	readonly CLOSING: 2 = 2
-	readonly CLOSED: 3 = 3
-
-	readonly id = `ws_${Date.now()}`
-	readonly binaryType: BinaryType = 'arraybuffer'
-	readonly bufferedAmount: number = 0
-	readonly extensions: string = ''
-	readonly url: string
-	readonly protocol: string
-	readyState: number = this.CONNECTING
-
-	onopen: ((this: WebSocket, ev: Event) => any) | null
-	onerror: ((this: WebSocket, ev: Event) => any) | null
-	onclose: ((this: WebSocket, ev: CloseEvent) => any) | null
-	onmessage: ((this: WebSocket, ev: MessageEvent<any>) => any) | null
-
-	#cancelRpcBridge?: (() => void)
-
-	constructor(url: string) {
-		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: string | ArrayBufferLike | Blob | ArrayBufferView): void {
-		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?: number, reason?: string): void {
-		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: Event): void {
-		this.readyState = this.OPEN
-		this.onopen?.call(this, ev)
-		this.dispatchEvent(ev)
-
-		this.#cancelRpcBridge?.()
-		this.#cancelRpcBridge = RPC_MSG_BRIDGE.addListener(this.#onMessage)
-	}
-
-	#callError(ev: ErrorEvent): void {
-		this.readyState = this.CLOSED
-		this.onerror?.call(this, ev)
-		this.dispatchEvent(ev)
-	}
-
-	#callClose(ev: CloseEvent): void {
-		this.readyState = this.CLOSED
-		this.onclose?.call(this, ev)
-		this.dispatchEvent(ev)
-	}
-
-	#onMessage = (msg: ExternalRPCIncomingMsg) => {
-		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/src/external-rpc/setup-browser.ts

@@ -1,42 +0,0 @@
-import { setCryptoImplementation } from '@joclaim/tls'
-import { webcryptoCrypto } from '@joclaim/tls/webcrypto'
-
-import { handleIncomingMessage } from '#src/external-rpc/handle-incoming-msg.ts'
-import { getWsApiUrlFromBaseUrl } from '#src/external-rpc/utils.ts'
-import { logger, makeLogger } from '#src/utils/index.ts'
-
-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?: string, 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 '#src/index.ts'

package/src/external-rpc/setup-jsc.ts

@@ -1,48 +0,0 @@
-import '#src/external-rpc/jsc-polyfills/index.ts'
-1 // done to avoid eslint rule
-
-import { setCryptoImplementation } from '@joclaim/tls'
-import { pureJsCrypto } from '@joclaim/tls/purejs-crypto'
-
-import * as AttestorRPCImport from '#src/external-rpc/index.ts'
-import { makeLogger } from '#src/utils/logger.ts'
-
-declare global {
-	/**
-	 * `sendMessage` function should be provided by the host of the JS environment for sending messages to host
-	 */
-	function sendMessage(channelName: string, message: any): void | Promise<void>
-
-	var AttestorRPC: typeof AttestorRPCImport & {
-		/**
-		 * Sets up the library to run in JS environments like QuickJS or JavascriptCore.
-		 *
-		 * RPC will communicate with user by sending messages using `AttestorRPCChannel` by `<channel>.postMessage(message: string)`,
-		 * for example: `globalThis['attestor-core'].postMessage(message: string)`.
-		 *
-		 * @param baseUrl
-		 * @param channel The name of the channel for sending messages. Default channel is 'attestor-core'.
-		 */
-		setupJsRpc(baseUrl: string, channel?: string): void
-	}
-}
-
-setCryptoImplementation(pureJsCrypto)
-makeLogger(true)
-
-/**
- * Sets up the library to run in JS environments like QuickJS or JavascriptCore.
- */
-export function setupJsRpc(baseUrl: string, channel = 'attestor-core') {
-	globalThis.ATTESTOR_BASE_URL = baseUrl
-	globalThis.RPC_CHANNEL_NAME = channel
-	const rpcChannel: AttestorRPCChannel = {
-		postMessage(message) {
-			return globalThis.sendMessage(channel, message)
-		}
-	}
-
-	globalThis[channel] = rpcChannel
-}
-
-globalThis.AttestorRPC = { ...AttestorRPCImport, setupJsRpc }

package/src/external-rpc/types.ts

@@ -1,289 +0,0 @@
-import type { OPRFOperator, ZKEngine, ZKOperator } from '@joclaim/zk-symmetric-crypto'
-import '#src/external-rpc/global.d.ts'
-
-import type { TaskCompletedEventObject } 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: TaskCompletedEventObject
-	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
- */
-// spread out each key because TS can't handle
-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

package/src/external-rpc/utils.ts

@@ -1,126 +0,0 @@
-import { WS_PATHNAME } from '#src/config/index.ts'
-import { EventBus } from '#src/external-rpc/event-bus.ts'
-import type { ExternalRPCAppClient, ExternalRPCIncomingMsg, ExternalRPCOutgoingMsg, ExternalRPCRequest, ExternalRPCResponse } from '#src/external-rpc/types.ts'
-import { B64_JSON_REPLACER } from '#src/utils/b64-json.ts'
-import { AttestorError } from '#src/utils/error.ts'
-
-export const RPC_MSG_BRIDGE = new EventBus<ExternalRPCIncomingMsg>()
-
-// 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<T extends keyof ExternalRPCAppClient>(
-	opts: ExternalRPCRequest<ExternalRPCAppClient, T>
-): Promise<ExternalRPCResponse<ExternalRPCAppClient, T>['response']> {
-	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<T extends keyof ExternalRPCAppClient>(
-	type: T,
-	requestId: string,
-	timeoutMs = 60_000
-) {
-	type R = Awaited<ReturnType<ExternalRPCAppClient[T]>>
-	const returnType = `${type}Done` as const
-	return new Promise<R>((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 as R)
-			} else {
-				return
-			}
-
-			clearTimeout(timeout)
-			cancel()
-		})
-	})
-}
-
-/**
- * Sends a message back to the host app
- * @param data
- */
-export function sendMessageToApp(data: ExternalRPCOutgoingMsg) {
-	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] as AttestorRPCChannel
-	if(!channel) {
-		throw new Error(`RPC channel ${RPC_CHANNEL_NAME} not set on globalThis`)
-	}
-
-	channel.postMessage(str)
-}

package/src/external-rpc/zk.ts

@@ -1,79 +0,0 @@
-import type { EncryptionAlgorithm, OPRFOperator, ZKEngine, ZKOperator } from '@joclaim/zk-symmetric-crypto'
-
-import type { ExecuteOPRFOpts, ExecuteZKOpts } from '#src/external-rpc/types.ts'
-import { rpcRequest } from '#src/external-rpc/utils.ts'
-import { logger, makeDefaultZkOperator } from '#src/utils/index.ts'
-
-export const ALL_ENC_ALGORITHMS: EncryptionAlgorithm[] = [
-	'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: EncryptionAlgorithm,
-	zkEngine: ZKEngine = 'snarkjs'
-): ZKOperator {
-	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: ExecuteZKOpts) {
-	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: EncryptionAlgorithm,
-	zkEngine: ZKEngine = 'snarkjs'
-): OPRFOperator {
-	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: ExecuteOPRFOpts) {
-	return rpcRequest({ type: 'executeOprfFunctionV3', request })
-}

package/src/index.ts

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