@joclaim/attestor-core 0.2.0 → 0.2.3

package/src/external-rpc/benchmark.ts

@@ -1,102 +0,0 @@
-import type {
-	CipherSuite } from '@joclaim/tls'
-import {
-	crypto,
-	encryptWrappedRecord,
-	SUPPORTED_CIPHER_SUITE_MAP
-} from '@joclaim/tls'
-import { strToUint8Array } from 'src/utils/generics.ts'
-
-import type { CompleteTLSPacket } from '#src/types/index.ts'
-import { logger } from '#src/utils/logger.ts'
-import { makeZkProofGenerator } from '#src/utils/zk.ts'
-
-const ZK_CIPHER_SUITES: CipherSuite[] = [
-	'TLS_CHACHA20_POLY1305_SHA256',
-	'TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384',
-	'TLS_AES_128_GCM_SHA256'
-]
-
-export async function benchmark() {
-
-	let benchmarkRes = ''
-	for(const cipherSuite of ZK_CIPHER_SUITES) {
-
-		const now = Date.now()
-
-		const alg = cipherSuite.includes('CHACHA20')
-			? 'CHACHA20-POLY1305'
-			: (
-				cipherSuite.includes('AES_256_GCM')
-					? 'AES-256-GCM'
-					: 'AES-128-GCM'
-			)
-		const keylength = alg === 'AES-128-GCM' ? 16 : 32
-		const key = Buffer.alloc(keylength, 0)
-		const {
-			ivLength: fixedIvLength,
-		} = SUPPORTED_CIPHER_SUITE_MAP[cipherSuite]
-		const fixedIv = Buffer.alloc(fixedIvLength, 0)
-
-		const encKey = await crypto.importKey(alg, key)
-		const vectors = [
-			{
-				plaintext: 'My cool API secret is "my name jeff". Please don\'t reveal it'
-			}
-		]
-
-		const proofGenerator = await makeZkProofGenerator({
-			logger,
-			cipherSuite,
-		})
-		for(const { plaintext } of vectors) {
-			const plaintextArr = strToUint8Array(plaintext)
-
-			const { ciphertext, iv } = await encryptWrappedRecord(
-				plaintextArr,
-				{
-					key: encKey,
-					iv: fixedIv,
-					recordNumber: 0,
-					recordHeaderOpts: {
-						type: 'WRAPPED_RECORD'
-					},
-					cipherSuite,
-					version: cipherSuite.includes('ECDHE_')
-						? 'TLS1_2'
-						: 'TLS1_3',
-				}
-			)
-
-			const packet: CompleteTLSPacket = {
-				type: 'ciphertext',
-				encKey,
-				iv,
-				recordNumber: 0,
-				plaintext: plaintextArr,
-				ciphertext,
-				fixedIv: new Uint8Array(0),
-				data: ciphertext
-			}
-
-			await proofGenerator.addPacketToProve(
-				packet,
-				{
-					type: 'zk',
-					redactedPlaintext:plaintextArr,
-				},
-				() => {},
-				() => {
-					throw new Error('should not be called in benchmark')
-				}
-			)
-			await proofGenerator.generateProofs()
-
-		}
-
-		benchmarkRes = benchmarkRes + `Benchmark ${alg} ok. Took ${Date.now() - now} ms \n`
-	}
-
-	logger.info(benchmarkRes)
-	return benchmarkRes
-}

package/src/external-rpc/event-bus.ts

@@ -1,19 +0,0 @@
-type EventHandlerFn<T> = (data: T) => void
-
-export class EventBus<T> {
-
-	#listeners: EventHandlerFn<T>[] = []
-
-	addListener(fn: EventHandlerFn<T>) {
-		this.#listeners.push(fn)
-		return () => {
-			this.#listeners = this.#listeners.filter(l => l !== fn)
-		}
-	}
-
-	dispatch(data: T) {
-		for(const listener of this.#listeners) {
-			listener(data)
-		}
-	}
-}

package/src/external-rpc/global.d.ts

@@ -1,20 +0,0 @@
-declare module globalThis {
-	var ATTESTOR_BASE_URL: string
-	var RPC_CHANNEL_NAME: string
-
-	interface Performance {
-		measureUserAgentSpecificMemory(): { bytes: number }
-	}
-
-	interface AttestorRPCChannel {
-		postMessage(message: string): void
-	}
-
-	/**
-	 * https://github.com/sindresorhus/type-fest/blob/main/source/distributed-omit.d.ts
-	 */
-	type DistributedOmit<ObjectType, KeyType extends KeysOfUnion<ObjectType>> =
-		ObjectType extends unknown
-			? Omit<ObjectType, KeyType>
-			: never;
-}

package/src/external-rpc/handle-incoming-msg.ts

@@ -1,308 +0,0 @@
-
-import type { ZKEngine } from '@joclaim/zk-symmetric-crypto'
-import { utils } from 'ethers'
-
-import { createClaimOnAvs } from '#src/avs/client/create-claim-on-avs.ts'
-import { createClaimOnAttestor } from '#src/client/index.ts'
-import { benchmark } from '#src/external-rpc/benchmark.ts'
-import type { CreateClaimResponse, ExternalRPCClient, ExternalRPCErrorResponse, ExternalRPCIncomingMsg, ExternalRPCOutgoingMsg, ExternalRPCResponse, RPCCreateClaimOptions } from '#src/external-rpc/types.ts'
-import { generateRpcRequestId, getCurrentMemoryUsage, getWsApiUrlFromBaseUrl, RPC_MSG_BRIDGE, sendMessageToApp, waitForResponse } from '#src/external-rpc/utils.ts'
-import { ALL_ENC_ALGORITHMS, makeExternalRpcOprfOperator, makeExternalRpcZkOperator } from '#src/external-rpc/zk.ts'
-import { createClaimOnMechain } from '#src/mechain/client/create-claim-on-mechain.ts'
-import type { ClaimTunnelResponse } from '#src/proto/api.ts'
-import { extractHTMLElement, extractJSONValueIndex, generateRequstAndResponseFromTranscript } from '#src/providers/http/utils.ts'
-import type { OPRFOperators, ProviderParams, ProviderSecretParams, ZKOperators } from '#src/types/index.ts'
-import { B64_JSON_REVIVER } from '#src/utils/b64-json.ts'
-import { AttestorError, getIdentifierFromClaimInfo, logger, makeLogger, uint8ArrayToStr } from '#src/utils/index.ts'
-
-export async function handleIncomingMessage(data: string | ExternalRPCIncomingMsg) {
-	let id = ''
-	try {
-		const req: ExternalRPCIncomingMsg = (
-			typeof data === 'string'
-				? JSON.parse(data, B64_JSON_REVIVER)
-				: data
-		)
-
-		id = req.id || ''
-
-		const rslt = await _handleIncomingMessage(req)
-		if(!rslt) {
-			return
-		}
-
-		respond(rslt)
-	} catch(err) {
-		console.error('Error in RPC', { id, error: err })
-		respond({
-			type: 'error',
-			data: {
-				message: err.message,
-				stack: err.stack,
-			}
-		})
-	}
-
-	function respond(
-		data: ExternalRPCResponse<ExternalRPCClient, keyof ExternalRPCClient>
-			| ExternalRPCErrorResponse
-	) {
-		const res = {
-			...data,
-			id,
-			isResponse: true
-		} as ExternalRPCOutgoingMsg
-		return sendMessageToApp(res)
-	}
-}
-
-async function _handleIncomingMessage(req: ExternalRPCIncomingMsg): Promise<
-	ExternalRPCResponse<ExternalRPCClient, keyof ExternalRPCClient> | undefined
-> {
-	const { id: reqId, type: reqType } = req
-	// ignore any messages not for us
-	if(!reqId || !reqType) {
-		return
-	}
-
-	RPC_MSG_BRIDGE.dispatch(req)
-	// ignore response messages
-	if(('isResponse' in req && req.isResponse)) {
-		return
-	}
-
-	if(!reqId) {
-		logger.warn({ req }, 'Window RPC request missing ID')
-		return
-	}
-
-	logger.info({ req }, 'processing RPC request')
-
-	switch (req.type) {
-	case 'createClaim':
-		const claimTunnelRes = await createClaimOnAttestor({
-			...req.request,
-			context: req.request.context
-				? JSON.parse(req.request.context)
-				: undefined,
-			zkOperators: getZkOperators(
-				req.request.zkOperatorMode, req.request.zkEngine
-			),
-			oprfOperators: getOprfOperators(
-				req.request.zkOperatorMode, req.request.zkEngine
-			),
-			client: {
-				url: getWsApiUrlFromBaseUrl(),
-				authRequest: req.request.authRequest
-			},
-			logger,
-			onStep(step) {
-				sendMessageToApp({
-					type: 'createClaimStep',
-					step: { name: 'attestor-progress', step },
-					id: req.id,
-				})
-			},
-			updateProviderParams : req.request.updateProviderParams
-				? updateProviderParams
-				: undefined,
-		})
-		const response = mapToCreateClaimResponse(claimTunnelRes)
-		return { type: 'createClaimDone', response }
-	case 'createClaimOnAvs':
-		const avsRes = await createClaimOnAvs({
-			...req.request,
-			payer: req.request.payer === 'attestor'
-				? { attestor: getWsApiUrlFromBaseUrl() }
-				: undefined,
-			context: req.request.context
-				? JSON.parse(req.request.context)
-				: undefined,
-			zkOperators: getZkOperators(
-				req.request.zkOperatorMode, req.request.zkEngine
-			),
-			oprfOperators: getOprfOperators(
-				req.request.zkOperatorMode, req.request.zkEngine
-			),
-			logger,
-			onStep(step) {
-				sendMessageToApp({
-					type: 'createClaimOnAvsStep',
-					step,
-					id: req.id,
-				})
-			},
-		})
-		return {
-			type: 'createClaimOnAvsDone',
-			response: avsRes,
-		}
-	case 'createClaimOnMechain':
-		const mechainRes = await createClaimOnMechain({
-			...req.request,
-			context: req.request.context
-				? JSON.parse(req.request.context)
-				: undefined,
-			zkOperators: getZkOperators(
-				req.request.zkOperatorMode, req.request.zkEngine
-			),
-			oprfOperators: getOprfOperators(
-				req.request.zkOperatorMode, req.request.zkEngine
-			),
-			client: {	url: getWsApiUrlFromBaseUrl() },
-			logger,
-			onStep(step) {
-				sendMessageToApp({
-					type: 'createClaimOnMechainStep',
-					step,
-					id: req.id,
-				})
-			},
-		})
-		const claimResponses: CreateClaimResponse[] = []
-		for(let i = 0; i < mechainRes.responses.length; i++) {
-			claimResponses[i] = mapToCreateClaimResponse(mechainRes.responses[i])
-		}
-
-		return {
-			type: 'createClaimOnMechainDone',
-			response: { taskId: mechainRes.taskId, data: claimResponses },
-		}
-	case 'extractHtmlElement':
-		return {
-			type: 'extractHtmlElementDone',
-			response: extractHTMLElement(
-				req.request.html,
-				req.request.xpathExpression,
-				req.request.contentsOnly
-			),
-		}
-	case 'extractJSONValueIndex':
-		return {
-			type: 'extractJSONValueIndexDone',
-			response: extractJSONValueIndex(
-				req.request.json,
-				req.request.jsonPath
-			),
-		}
-	case 'getCurrentMemoryUsage':
-		return {
-			type: 'getCurrentMemoryUsageDone',
-			response: await getCurrentMemoryUsage(),
-		}
-	case 'setLogLevel':
-		makeLogger(
-			true,
-			req.request.logLevel,
-			req.request.sendLogsToApp
-				? (level, message) => (
-					sendMessageToApp({
-						type: 'log',
-						level,
-						message,
-						id: req.id,
-					})
-				)
-				: undefined
-		)
-		return { type: 'setLogLevelDone', response: undefined }
-	case 'benchmarkZK':
-		return { type: 'benchmarkZKDone', response: await benchmark() }
-	case 'ping':
-		return { type: 'pingDone', response: { pong: new Date().toJSON() } }
-	default:
-		break
-	}
-}
-
-
-function getZkOperators(
-	mode: RPCCreateClaimOptions['zkOperatorMode'] = 'default',
-	zkEngine: ZKEngine = 'snarkjs'
-) {
-// use default snarkJS ops
-	if(mode === 'default') {
-		return
-	}
-
-	// the native app/window calling implements
-	// a ZK operator & wants to use it
-	const operators: ZKOperators = {}
-	for(const alg of ALL_ENC_ALGORITHMS) {
-		operators[alg] = makeExternalRpcZkOperator(alg, zkEngine)
-	}
-
-	return operators
-}
-
-function getOprfOperators(
-	mode: RPCCreateClaimOptions['zkOperatorMode'] = 'default',
-	zkEngine: ZKEngine = 'snarkjs'
-) {
-// use default webview ops
-	if(mode === 'default') {
-		return
-	}
-
-	// the native app/window calling implements
-	// a ZK operator & wants to use it
-	const operators: OPRFOperators = {}
-	for(const alg of ALL_ENC_ALGORITHMS) {
-		operators[alg] = makeExternalRpcOprfOperator(alg, zkEngine)
-	}
-
-	return operators
-}
-
-async function updateProviderParams(
-	transcript,
-	tlsVersion,
-): Promise<{
-	params: Partial<ProviderParams<'http'>>
-	secretParams: Partial<ProviderSecretParams<'http'>>
-}> {
-	const { req, res } = generateRequstAndResponseFromTranscript(
-		transcript,
-		tlsVersion
-	)
-	const id = generateRpcRequestId()
-	const waitForRes = waitForResponse('updateProviderParams', id)
-	sendMessageToApp({
-		type: 'updateProviderParams',
-		id,
-		request: {
-			request: {
-				...req,
-				body: req.body
-					? uint8ArrayToStr(req.body)
-					: undefined
-			},
-			response: { ...res, body: uint8ArrayToStr(res.body) },
-		}
-	})
-	return waitForRes
-}
-
-function mapToCreateClaimResponse(
-	res: ClaimTunnelResponse
-): CreateClaimResponse {
-	if(!res.claim) {
-		throw AttestorError.fromProto(res.error)
-	}
-
-	return {
-		identifier: getIdentifierFromClaimInfo(res.claim),
-		claimData: res.claim,
-		witnesses: [
-			{
-				id: res.signatures!.attestorAddress,
-				url: getWsApiUrlFromBaseUrl()
-			}
-		],
-		signatures: [
-			utils
-				.hexlify(res.signatures!.claimSignature)
-				.toLowerCase()
-		]
-	}
-}

package/src/external-rpc/index.ts

@@ -1,3 +0,0 @@
-export * from './types.ts'
-export * from './handle-incoming-msg.ts'
-export * from './utils.ts'

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

@@ -1,117 +0,0 @@
-import { TextDecoder, TextEncoder } from '@kayahr/text-encoding'
-import { crypto, uint8ArrayToBinaryStr } from '@joclaim/tls'
-import { fromByteArray, toByteArray } from 'base64-js'
-import { EventTarget } from 'event-target-shim'
-
-import type { ExternalRPCIncomingMsg, ExternalRPCOutgoingMsg } from '#src/external-rpc/types.ts'
-
-declare global {
-	function readline(): string
-	function print(...args: any[]): void
-	// @ts-expect-error - JSC built-in, conflicts with @types/debug namespace
-	function debug(...args: any[]): void
-	function quit(): void
-
-	type JSCIncomingMsg = ExternalRPCIncomingMsg
-		| { type: 'quit' }
-		| {
-			type: 'init'
-			attestorBaseUrl: string
-		}
-
-	type JSCOutgoingMsg = ExternalRPCOutgoingMsg
-}
-
-if(typeof global === 'undefined') {
-	globalThis.global = globalThis
-}
-
-if(typeof console === 'undefined') {
-	// @ts-expect-error
-	globalThis.console = {
-		log: print,
-		error: print,
-		warn: print,
-		info: print,
-		debug: print,
-	}
-}
-
-if(typeof globalThis.crypto === 'undefined') {
-	globalThis.crypto = {
-		// @ts-expect-error
-		getRandomValues(arr: Uint8Array) {
-			const randVals = crypto.randomBytes(arr.length)
-			for(let i = 0; i < arr.length; i++) {
-				arr[i] = randVals[i]
-			}
-
-			return arr
-		},
-		randomBytes(length: number) {
-			return crypto.randomBytes(length)
-		}
-	}
-}
-
-if(typeof globalThis.TextEncoder === 'undefined') {
-	globalThis.TextEncoder = TextEncoder
-}
-
-if(typeof globalThis.TextDecoder === 'undefined') {
-	globalThis.TextDecoder = TextDecoder
-}
-
-if(typeof globalThis.EventTarget === 'undefined') {
-	globalThis.EventTarget = EventTarget
-}
-
-if(typeof globalThis.atob === 'undefined') {
-	globalThis.atob = a => uint8ArrayToBinaryStr(toByteArray(a))
-}
-
-if(typeof globalThis.btoa === 'undefined') {
-	function binaryStringToUint8Array(binaryString: string) {
-		const uint8Array = new Uint8Array(binaryString.length)
-		for(let i = 0; i < binaryString.length; i++) {
-			uint8Array[i] = binaryString.charCodeAt(i)
-		}
-
-		return uint8Array
-	}
-
-	globalThis.btoa = b => fromByteArray(binaryStringToUint8Array(b))
-}
-
-if(typeof globalThis.clearTimeout === 'undefined') {
-	const ogSettimeout = globalThis.setTimeout
-	if(!ogSettimeout) {
-		throw new Error('setTimeout is not defined, no polyfill yet')
-	}
-
-	// @ts-expect-error
-	globalThis.setTimeout = (fn, delayMs, ...args) => {
-		let aborted = false
-		const abortableFn = (...args) => {
-			if(aborted) {
-				return
-			}
-
-			return fn(...args)
-		}
-
-		const val = ogSettimeout(abortableFn, delayMs, ...args)
-		return {
-			original: val,
-			abort() {
-				aborted = true
-			}
-		}
-	}
-
-	globalThis.clearTimeout = (id) => {
-		if(typeof id === 'object' && !!id && 'abort' in id) {
-			id.abort()
-		}
-	}
-}

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

@@ -1,24 +0,0 @@
-import { URL as WHATWG_URL } from 'whatwg-url'
-
-import { CloseEventPolyfill, ErrorEventPolyfill, EventPolyfill, MessageEventPolyfill } from '#src/external-rpc/jsc-polyfills/event.ts'
-import { RPCWebSocket } from '#src/external-rpc/jsc-polyfills/ws.ts'
-
-if(typeof globalThis.URL === 'undefined') {
-	globalThis.URL = WHATWG_URL
-}
-
-if(typeof globalThis.Event === 'undefined') {
-	// @ts-expect-error
-	globalThis.Event = EventPolyfill
-	// @ts-expect-error
-	globalThis.ErrorEvent = ErrorEventPolyfill
-	// @ts-expect-error
-	globalThis.CloseEvent = CloseEventPolyfill
-	// @ts-expect-error
-	globalThis.MessageEvent = MessageEventPolyfill
-}
-
-if(typeof globalThis.WebSocket === 'undefined') {
-	// @ts-expect-error
-	globalThis.WebSocket = RPCWebSocket
-}

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

@@ -1,16 +0,0 @@
-// @ts-expect-error
-export class EventPolyfill implements Event {
-
-	type: string
-
-	constructor(type: string, eventInitDict?: EventInit) {
-		this.type = type
-		Object.assign(this, eventInitDict)
-	}
-}
-
-export class ErrorEventPolyfill extends EventPolyfill {}
-
-export class CloseEventPolyfill extends EventPolyfill {}
-
-export class MessageEventPolyfill extends EventPolyfill {}

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

@@ -1,2 +0,0 @@
-import '#src/external-rpc/jsc-polyfills/1.ts'
-import '#src/external-rpc/jsc-polyfills/2.ts'