@joclaim/attestor-core 0.2.0 → 0.2.3

package/src/client/tunnels/make-rpc-tcp-tunnel.ts

@@ -1,78 +0,0 @@
-import type { CreateTunnelRequest } from '#src/proto/api.ts'
-import type { IAttestorClient, MakeTunnelFn, RPCEvent } from '#src/types/index.ts'
-import { AttestorError } from '#src/utils/index.ts'
-
-export type TCPTunnelCreateOpts = {
-	/**
-	 * The tunnel ID to communicate with.
-	 */
-	tunnelId: CreateTunnelRequest['id']
-	client: IAttestorClient
-}
-
-/**
- * Makes a tunnel communication wrapper for a TCP tunnel.
- *
- * It listens for messages and disconnect events from the server,
- * and appropriately calls the `onMessage` and `onClose` callbacks.
- */
-export const makeRpcTcpTunnel: MakeTunnelFn<TCPTunnelCreateOpts> = ({
-	tunnelId,
-	client,
-	onClose,
-	onMessage,
-}) => {
-	let closed = false
-	client.addEventListener('tunnel-message', onMessageListener)
-	client.addEventListener('tunnel-disconnect-event', onDisconnectListener)
-	client.addEventListener('connection-terminated', onConnectionTerminatedListener)
-
-	return {
-		async write(message) {
-			await client.sendMessage({ tunnelMessage: { tunnelId, message } })
-		},
-		async close(err) {
-			if(closed) {
-				return
-			}
-
-			onErrorRecv(err)
-			await client.rpc('disconnectTunnel', { id: tunnelId })
-		}
-	}
-
-	function onMessageListener({ data }: RPCEvent<'tunnel-message'>) {
-		if(data.tunnelId !== tunnelId) {
-			return
-		}
-
-		onMessage?.(data.message)
-	}
-
-	function onDisconnectListener({ data }: RPCEvent<'tunnel-disconnect-event'>) {
-		if(data.tunnelId !== tunnelId) {
-			return
-		}
-
-		onErrorRecv(
-			data.error?.code
-				? AttestorError.fromProto(data.error)
-				: undefined
-		)
-	}
-
-	function onConnectionTerminatedListener({ data }: RPCEvent<'connection-terminated'>) {
-		onErrorRecv(data)
-	}
-
-	function onErrorRecv(err: Error | undefined) {
-		client.logger?.debug({ tunnelId, err }, 'TCP tunnel closed')
-
-		client.removeEventListener('tunnel-message', onMessageListener)
-		client.removeEventListener('tunnel-disconnect-event', onDisconnectListener)
-		client.removeEventListener('connection-terminated', onConnectionTerminatedListener)
-		onClose?.(err)
-		onClose = undefined
-		closed = true
-	}
-}

package/src/client/tunnels/make-rpc-tls-tunnel.ts

@@ -1,172 +0,0 @@
-import type { TLSConnectionOptions } from '@joclaim/tls'
-import { concatenateUint8Arrays, makeTLSClient } from '@joclaim/tls'
-
-import { makeRpcTcpTunnel } from '#src/client/tunnels/make-rpc-tcp-tunnel.ts'
-import { DEFAULT_HTTPS_PORT } from '#src/config/index.ts'
-import type { CreateTunnelRequest, RPCMessage } from '#src/proto/api.ts'
-import type { CompleteTLSPacket, IAttestorClient, Logger, MakeTunnelFn, Transcript, Tunnel } from '#src/types/index.ts'
-import { generateRpcMessageId, generateTunnelId } from '#src/utils/index.ts'
-
-type ExtraTLSOptions = {
-	request: Partial<CreateTunnelRequest>
-	logger: Logger
-	/**
-	 * Either create a client with the given initMessages,
-	 * or simply send the messages to the server via an existing
-	 * client
-	 *
-	 * @returns the client that was used to send the messages
-	 */
-	connect(initMessages: Partial<RPCMessage>[]): IAttestorClient
-	tlsOpts?: TLSConnectionOptions
-}
-
-type TLSTunnelProperties = {
-	transcript: Transcript<CompleteTLSPacket>
-	tls: ReturnType<typeof makeTLSClient>
-}
-
-/**
- * Makes a TLS tunnel that connects to the server via RPC protocol
- */
-export const makeRpcTlsTunnel: MakeTunnelFn<ExtraTLSOptions, TLSTunnelProperties> = async({
-	onMessage, onClose,
-	tlsOpts, request,
-	connect, logger
-}) => {
-	const transcript: TLSTunnelProperties['transcript'] = []
-	const tunnelId = request.id || generateTunnelId()
-	let tunnel: Tunnel<{}>
-	let client: IAttestorClient | undefined
-
-	let handshakeResolve: ((value: void) => void) | undefined
-	let handshakeReject: ((reason: any) => void) | undefined
-	const waitForHandshake = new Promise<void>((resolve, reject) => {
-		handshakeResolve = resolve
-		handshakeReject = reject
-	})
-
-	const tls = makeTLSClient({
-		host: request.host!,
-		...tlsOpts,
-		logger,
-		onHandshake() {
-			handshakeResolve?.()
-		},
-		onApplicationData(plaintext) {
-			return onMessage?.(plaintext)
-		},
-		onTlsEnd: onConnectionClose,
-		async write(packet, ctx) {
-			const message = concatenateUint8Arrays([
-				packet.header,
-				packet.content
-			])
-			transcript.push({
-				sender: 'client',
-				message: { ...ctx, data: message }
-			})
-
-			if(!tunnel) {
-				// sends the packet as the initial message
-				// to the plaintext tunnel. Prevents another
-				// round trip to the server as we send the packet
-				// in the same message as the tunnel creation.
-				const createTunnelReqId = generateRpcMessageId()
-				client = connect([
-					{
-						id: createTunnelReqId,
-						createTunnelRequest: {
-							host: request.host || '',
-							port: request.port || DEFAULT_HTTPS_PORT,
-							geoLocation: request.geoLocation || '',
-							proxySessionId: request.proxySessionId || '',
-							id: tunnelId
-						},
-					},
-					{ tunnelMessage: { tunnelId, message } }
-				])
-
-				try {
-					await makeTunnel()
-					// wait for tunnel to be successfully created
-					await client.waitForResponse(createTunnelReqId)
-				} catch(err) {
-					onConnectionClose(err)
-				}
-
-				return
-			}
-
-			return tunnel.write(message)
-		},
-		onRead(packet, ctx) {
-			transcript.push({
-				sender: 'server',
-				message: {
-					...ctx,
-					data: concatenateUint8Arrays([
-						packet.header,
-						// the TLS package sends us the decrypted
-						// content, so we need to get the orginal
-						// ciphertext received from the server
-						// as that's part of the true transcript.
-						ctx.type === 'ciphertext'
-							? ctx.ciphertext
-							: packet.content
-					])
-				}
-			})
-		},
-	})
-
-	await tls.startHandshake()
-	// wait for handshake completion
-	await waitForHandshake
-
-	handshakeResolve = handshakeReject = undefined
-
-	return {
-		transcript,
-		tls,
-		write(data) {
-			return tls.write(data)
-		},
-		async close(err) {
-			onConnectionClose(err)
-			try {
-				await tunnel.close(err)
-			} catch(err) {
-				logger?.error({ err }, 'err in close tunnel')
-			}
-		},
-	}
-
-	function onConnectionClose(err: Error | undefined) {
-		onClose?.(err)
-		// once the TLS connection is closed, we no longer
-		// want to send `onClose` events back to the caller
-		// of this function.
-		onClose = undefined
-		handshakeReject?.(
-			err || new Error('TLS connection closed')
-		)
-	}
-
-	async function makeTunnel() {
-		tunnel = await makeRpcTcpTunnel({
-			tunnelId,
-			client: client!,
-			onMessage(data) {
-				tls.handleReceivedBytes(data)
-			},
-			onClose(err) {
-				tls.end(err)
-			},
-		})
-
-		logger?.debug('plaintext tunnel created')
-
-		return tunnel
-	}
-}

package/src/client/utils/attestor-pool.ts

@@ -1,35 +0,0 @@
-import { AttestorClient } from '#src/client/utils/client-socket.ts'
-import type { IAttestorClient, IAttestorClientCreateOpts } from '#src/types/index.ts'
-
-const POOL: { [url: string]: IAttestorClient | undefined } = {}
-
-/**
- * Get a attestor client from the pool,
- * if it doesn't exist, create one.
- * @param [getCreateOpts] - Function to get the options for creating a new client.
- *  called synchronously, in the same tick as this function.
- */
-export function getAttestorClientFromPool(
-	url: string | URL,
-	getCreateOpts: () => Omit<IAttestorClientCreateOpts, 'url'> = () => ({})
-) {
-	const key = url.toString()
-	let client = POOL[key]
-	let createReason: string | undefined
-	if(client?.isClosed) {
-		createReason = 'closed'
-	} else if(!client) {
-		createReason = 'non-existent'
-	}
-
-	if(createReason) {
-		const createOpts = getCreateOpts()
-		createOpts?.logger?.info(
-			{ key, createReason },
-			'creating new client'
-		)
-		client = (POOL[key] = new AttestorClient({ ...createOpts, url }))
-	}
-
-	return client!
-}

package/src/client/utils/client-socket.ts

@@ -1,160 +0,0 @@
-import { utils } from 'ethers'
-
-import { DEFAULT_METADATA, DEFAULT_RPC_TIMEOUT_MS } from '#src/config/index.ts'
-import type { InitResponse } from '#src/proto/api.ts'
-import { RPCMessages } from '#src/proto/api.ts'
-import type { IAttestorClient, IAttestorClientCreateOpts, RPCEvent, RPCRequestData, RPCResponseData, RPCType } from '#src/types/index.ts'
-import { AttestorError, generateRpcMessageId, getRpcRequestType, logger as LOGGER, packRpcMessages } from '#src/utils/index.ts'
-import { AttestorSocket } from '#src/utils/socket-base.ts'
-import { makeWebSocket as defaultMakeWebSocket } from '#src/utils/ws.ts'
-
-const { base64 } = utils
-
-export class AttestorClient extends AttestorSocket implements IAttestorClient {
-
-	private waitForInitPromise: Promise<void>
-
-	public initResponse?: InitResponse
-
-	constructor({
-		url,
-		initMessages = [],
-		signatureType = DEFAULT_METADATA.signatureType,
-		logger = LOGGER,
-		authRequest,
-		makeWebSocket = defaultMakeWebSocket
-	}: IAttestorClientCreateOpts) {
-		const initRequest = {
-			...DEFAULT_METADATA,
-			signatureType,
-			auth: authRequest
-		}
-		const msg = packRpcMessages({ initRequest }, ...initMessages)
-		const initRequestBytes = RPCMessages.encode(msg).finish()
-		const initRequestB64 = base64.encode(initRequestBytes)
-
-		url = new URL(url.toString())
-		url.searchParams.set('messages', initRequestB64)
-
-		super(
-			makeWebSocket(url) as WebSocket,
-			initRequest,
-			logger
-		)
-
-		const initReqId = msg.messages[0].id
-		this.waitForInitPromise = this
-			.waitForResponse<'init'>(initReqId, DEFAULT_RPC_TIMEOUT_MS)
-			.then(res => {
-				logger.info('client initialised')
-				this.isInitialised = true
-				this.initResponse = res
-			})
-		// swallow the error if anything bad happens, and we've no
-		// catch block to handle it
-		this.waitForInitPromise
-			.catch(() => { })
-
-		this.addEventListener('connection-terminated', ev => (
-			logger.info({ err: ev.data }, 'connection terminated')
-		))
-	}
-
-	async rpc<T extends RPCType>(
-		type: T,
-		request: Partial<RPCRequestData<T>>,
-		timeoutMs: number = DEFAULT_RPC_TIMEOUT_MS
-	) {
-		const msgId = generateRpcMessageId()
-		this.logger.debug({ type, id: msgId }, 'sending rpc request')
-		const now = Date.now()
-		try {
-			const rslt = this.waitForResponse<T>(msgId, timeoutMs)
-			await this.sendMessage({ id: msgId, [getRpcRequestType(type)]: request })
-
-			return await rslt
-		} finally {
-			const timeTakenMs = Date.now() - now
-			this.logger.debug({ type, timeTakenMs }, 'received rpc response')
-		}
-	}
-
-	waitForResponse<T extends RPCType>(
-		id: number,
-		timeoutMs: number = DEFAULT_RPC_TIMEOUT_MS
-	) {
-		if(this.isClosed) {
-			throw new AttestorError(
-				'ERROR_NETWORK_ERROR',
-				'Client connection already closed'
-			)
-		}
-
-		// setup a promise to wait for the response
-		return new Promise<RPCResponseData<T>>((resolve, reject) => {
-			const handler = (event: RPCEvent<'rpc-response'>) => {
-				if(event.data.id !== id) {
-					return
-				}
-
-				removeHandlers()
-				if('error' in event.data) {
-					reject(event.data.error)
-					return
-				}
-
-				// @ts-expect-error
-				resolve(event.data.data)
-			}
-
-			const terminateHandler = (event: RPCEvent<'connection-terminated'>) => {
-				removeHandlers()
-				// if the connection was terminated, reject the promise
-				// but update the error code to reflect the network error
-				if(event.data.code === 'ERROR_NO_ERROR') {
-					reject(
-						new AttestorError(
-							'ERROR_NETWORK_ERROR',
-							event.data.message,
-							event.data.data
-						)
-					)
-					return
-				}
-
-				reject(event.data)
-			}
-
-			const timeout = setTimeout(() => {
-				removeHandlers()
-				reject(
-					new AttestorError(
-						'ERROR_TIMEOUT',
-						`RPC request timed out after ${timeoutMs}ms`,
-						{ id }
-					)
-				)
-			}, timeoutMs)
-
-			const removeHandlers = () => {
-				clearTimeout(timeout)
-				this.removeEventListener('rpc-response', handler)
-				this.removeEventListener('connection-terminated', terminateHandler)
-			}
-
-			this.addEventListener('rpc-response', handler)
-			this.addEventListener('connection-terminated', terminateHandler)
-		})
-	}
-
-	waitForInit = () => {
-		if(this.isClosed) {
-			throw new AttestorError(
-				'ERROR_NETWORK_ERROR',
-				'Client connection already closed'
-			)
-		}
-
-		return this.waitForInitPromise
-	}
-}

package/src/client/utils/message-handler.ts

@@ -1,116 +0,0 @@
-import type { RPCMessage } from '#src/proto/api.ts'
-import { RPCMessages } from '#src/proto/api.ts'
-import type { IAttestorSocket } from '#src/types/index.ts'
-import { AttestorError, extractArrayBufferFromWsData, getRpcRequest, getRpcRequestType, getRpcResponseType } from '#src/utils/index.ts'
-
-export async function wsMessageHandler(this: IAttestorSocket, data: unknown) {
-	// extract array buffer from WS data & decode proto
-	const buff = await extractArrayBufferFromWsData(data)
-	const { messages } = RPCMessages.decode(buff)
-	for(const msg of messages) {
-		await handleMessage.call(this, msg)
-	}
-}
-
-export function handleMessage(this: IAttestorSocket, msg: RPCMessage) {
-	this.logger?.trace({ msg }, 'received message')
-	// handle connection termination alert
-	if(msg.connectionTerminationAlert) {
-		const err = AttestorError.fromProto(
-			msg.connectionTerminationAlert
-		)
-		this.logger?.warn(
-			{
-				err: err.code !== 'ERROR_NO_ERROR'
-					? err
-					: undefined
-			},
-			'received connection termination alert'
-		)
-		this.dispatchRPCEvent('connection-terminated', err)
-		return
-	}
-
-	const rpcRequest = getRpcRequest(msg)
-	if(rpcRequest) {
-		if(
-			rpcRequest.direction === 'response'
-			&& rpcRequest.type === 'error'
-		) {
-			this.dispatchRPCEvent('rpc-response', {
-				id: msg.id,
-				error: AttestorError.fromProto(msg.requestError)
-			})
-			return
-		}
-
-		const resType = getRpcResponseType(rpcRequest.type)
-		if(rpcRequest.direction === 'response') {
-			this.dispatchRPCEvent('rpc-response', {
-				id: msg.id,
-				type: rpcRequest.type,
-				data: msg[resType]!
-			})
-			return
-		}
-
-		if(!this.isInitialised && rpcRequest.type !== 'init') {
-			this.logger.warn(
-				{ type: rpcRequest.type },
-				'RPC request received before initialisation'
-			)
-			void this.sendMessage({
-				id: msg.id,
-				requestError: AttestorError
-					.badRequest('Initialise connection first')
-					.toProto()
-			})
-			return
-		}
-
-		return new Promise<void>((resolve, reject) => {
-			this.dispatchRPCEvent('rpc-request', {
-				requestId: msg.id,
-				type: rpcRequest.type,
-				data: msg[getRpcRequestType(rpcRequest.type)]!,
-				respond: (res) => {
-					if(!this.isOpen) {
-						this.logger?.debug(
-							{ type: rpcRequest.type, res },
-							'connection closed before responding'
-						)
-						reject(new Error('connection closed'))
-						return
-					}
-
-					if('code' in res) {
-						reject(res)
-						return this.sendMessage({
-							id: msg.id,
-							requestError: res.toProto()
-						})
-					}
-
-					resolve()
-					return this
-						.sendMessage({ id: msg.id, [resType]: res })
-				},
-			})
-		})
-	}
-
-	if(msg.tunnelMessage) {
-		this.dispatchRPCEvent('tunnel-message', msg.tunnelMessage)
-		return
-	}
-
-	if(msg.tunnelDisconnectEvent) {
-		this.dispatchRPCEvent(
-			'tunnel-disconnect-event',
-			msg.tunnelDisconnectEvent
-		)
-		return
-	}
-
-	this.logger.warn({ msg }, 'unhandled message')
-}

package/src/config/index.ts

@@ -1,65 +0,0 @@
-import type { InitRequest } from '#src/proto/api.ts'
-import { AttestorVersion, ServiceSignatureType } from '#src/proto/api.ts'
-
-export const DEFAULT_ZK_CONCURRENCY = 10
-
-export const JOCLAIM_USER_AGENT = 'joclaim/0.0.1'
-
-export const DEFAULT_HTTPS_PORT = 443
-
-export const WS_PATHNAME = '/ws'
-
-export const BROWSER_RPC_PATHNAME = '/browser-rpc'
-
-export const DEFAULT_REMOTE_FILE_FETCH_BASE_URL = `${BROWSER_RPC_PATHNAME}/resources`
-
-export const API_SERVER_PORT = 8001
-
-// 10s
-export const CONNECTION_TIMEOUT_MS = 10_000
-
-export const DNS_SERVERS = [
-	'8.8.8.8',
-	'8.8.4.4'
-]
-
-// 10m
-export const MAX_CLAIM_TIMESTAMP_DIFF_S = 10 * 60
-
-export const CURRENT_ATTESTOR_VERSION = AttestorVersion.ATTESTOR_VERSION_3_0_0
-
-export const DEFAULT_METADATA: InitRequest = {
-	signatureType: ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH,
-	clientVersion: CURRENT_ATTESTOR_VERSION,
-	auth: undefined
-}
-
-export const PROVIDER_CTX = { version: CURRENT_ATTESTOR_VERSION }
-
-export const PING_INTERVAL_MS = 10_000
-/**
- * Maximum interval in seconds to wait for before assuming
- * the connection is dead
- * @default 30s
- */
-export const MAX_NO_DATA_INTERVAL_MS = 30_000
-
-export const MAX_PAYLOAD_SIZE = 512 * 1024 * 1024 // 512MB
-
-export const DEFAULT_AUTH_EXPIRY_S = 15 * 60 // 15m
-
-export const DEFAULT_RPC_TIMEOUT_MS = 90_000
-
-export const TOPRF_DOMAIN_SEPARATOR = 'joclaim-toprf'
-
-export const MAX_CERT_SIZE_BYTES = 10 * 1024 * 1024 * 1024 // 10MB
-
-export const CERT_ALLOWED_MIMETYPES = [
-	'application/x-x509-ca-cert',
-	'application/x-x509-user-cert',
-	'application/pkix-cert',
-	'application/pkcs7-mime',
-	'application/octet-stream'
-]
-
-export const BGP_WS_URL = 'wss://ris-live.ripe.net/v1/ws/?client=joclaim-hijack-detector'