@joclaim/attestor-core 0.2.0 → 0.2.3

package/src/utils/redactions.ts

@@ -1,203 +0,0 @@
-import { base64Encode } from '@bufbuild/protobuf/wire'
-import { concatenateUint8Arrays } from '@joclaim/tls'
-
-import type { ArraySlice, RedactedOrHashedArraySlice, TOPRFProofParams } from '#src/types/index.ts'
-
-export const REDACTION_CHAR = '*'
-export const REDACTION_CHAR_CODE = REDACTION_CHAR.charCodeAt(0)
-
-type SliceWithReveal<T> = {
-	block: T
-	redactedPlaintext: Uint8Array
-	/**
-	 * If the block has some TOPRF claims -- they'll be set here
-	 */
-	toprfs?: TOPRFProofParams[]
-	/**
-	 * If text was replaced in the previous block w TOPRF but
-	 * it overshot into this block. The "length" specifies how much
-	 * of it got overshot into this block
-	 */
-	overshotToprfFromPrevBlock?: { length: number }
-}
-
-export type RevealedSlices<T> = 'all' | SliceWithReveal<T>[]
-
-/**
- * Check if a redacted string is congruent with the original string.
- * @param redacted the redacted content, redacted content is replaced by '*'
- * @param original the original content
- */
-export function isRedactionCongruent<T extends string | Uint8Array>(
-	redacted: T,
-	original: T
-): boolean {
-	// eslint-disable-next-line unicorn/no-for-loop
-	for(let i = 0;i < redacted.length;i++) {
-		const element = redacted[i]
-		const areSame = element === original[i]
-			|| (typeof element === 'string' && element === REDACTION_CHAR)
-			|| (typeof element === 'number' && element === REDACTION_CHAR_CODE)
-		if(!areSame) {
-			return false
-		}
-	}
-
-	return true
-}
-
-/**
- * Is the string fully redacted?
- */
-export function isFullyRedacted<T extends string | Uint8Array>(
-	redacted: T
-): boolean {
-	for(const element of redacted) {
-		if(
-			element !== REDACTION_CHAR
-			&& element !== REDACTION_CHAR_CODE
-		) {
-			return false
-		}
-	}
-
-	return true
-}
-
-/**
- * Given some plaintext blocks and a redaction function, return the blocks that
- * need to be revealed to the other party
- *
- * Use case: we get the response for a request in several blocks, and want to redact
- * pieces that go through multiple blocks. We can use this function to get the
- * blocks that need to be revealed to the other party
- *
- * @example if we received ["secret is 12","345","678. Thanks"]. We'd want
- * to redact the "12345678" and reveal the rest. We'd pass in the blocks and
- * the redact function will return the redactions, namely [10,19].
- * The function will return the blocks ["secret is **","***. Thanks"].
- * The middle block is fully redacted, so it's not returned
- *
- * @param blocks blocks to reveal
- * @param redact function that returns the redactions
- * @returns blocks to reveal
- */
-export async function getBlocksToReveal<T extends { plaintext: Uint8Array }>(
-	blocks: T[],
-	redact: (total: Uint8Array) => RedactedOrHashedArraySlice[],
-	performOprf: (plaintext: Uint8Array) => Promise<TOPRFProofParams>
-) {
-	const slicesWithReveal: SliceWithReveal<T>[] = blocks.map(block => ({
-		block,
-		// copy the plaintext to avoid mutating the original
-		redactedPlaintext: new Uint8Array(block.plaintext)
-	}))
-	const total = concatenateUint8Arrays(blocks.map(b => b.plaintext))
-	const redactions = redact(total)
-
-	if(!redactions.length) {
-		return 'all'
-	}
-
-	let blockIdx = 0
-	let cursorInBlock = 0
-	let cursor = 0
-
-	for(const redaction of redactions) {
-		await redactBlocks(redaction)
-	}
-
-	// only reveal blocks that have some data to reveal,
-	// or are completely plaintext
-	return slicesWithReveal
-		.filter(s => !isFullyRedacted(s.redactedPlaintext))
-
-	async function redactBlocks(slice: RedactedOrHashedArraySlice) {
-		while(cursor < slice.fromIndex) {
-			advance()
-		}
-
-		if(slice.hash) {
-			const plaintext = total.slice(slice.fromIndex, slice.toIndex)
-			const { nullifier, responses, mask } = await performOprf(plaintext)
-
-			// set the TOPRF claim on the first blocks this
-			// redaction covers
-			const toprf: TOPRFProofParams = {
-				nullifier,
-				responses,
-				dataLocation: {
-					fromIndex: cursorInBlock,
-					length: slice.toIndex - slice.fromIndex
-				},
-				mask,
-				plaintext
-			}
-			const startBlockIdx = blockIdx
-			const block = slicesWithReveal[blockIdx]
-			block.toprfs ||= []
-			block.toprfs.push(toprf)
-
-			const nullifierStr
-				= binaryHashToStr(nullifier, toprf.dataLocation!.length)
-
-			let i = 0
-			let overshootLen = 0
-			while(cursor < slice.toIndex) {
-				if(blockIdx !== startBlockIdx) {
-					overshootLen += 1
-				}
-
-				slicesWithReveal[blockIdx].redactedPlaintext[cursorInBlock]
-					= nullifierStr.charCodeAt(i)
-				advance()
-
-				i += 1
-			}
-
-			if(overshootLen) {
-				slicesWithReveal[blockIdx]
-					.overshotToprfFromPrevBlock = { length: overshootLen }
-			}
-		}
-
-		while(cursor < slice.toIndex) {
-			slicesWithReveal[blockIdx]
-				.redactedPlaintext[cursorInBlock] = REDACTION_CHAR_CODE
-			advance()
-		}
-	}
-
-	function advance() {
-		cursor += 1
-		cursorInBlock += 1
-		if(cursorInBlock >= blocks[blockIdx].plaintext.length) {
-			blockIdx += 1
-			cursorInBlock = 0
-		}
-	}
-}
-
-/**
- * Redact the following slices from the total
- */
-export function redactSlices(total: Uint8Array, slices: ArraySlice[]) {
-	const redacted = new Uint8Array(total)
-
-	for(const slice of slices) {
-		for(let i = slice.fromIndex;i < slice.toIndex;i++) {
-			redacted[i] = REDACTION_CHAR_CODE
-		}
-	}
-
-	return redacted
-}
-
-/**
- * Converts the binary hash to an ASCII string of the expected length.
- * If the hash is shorter than the expected length, it will be padded with
- * '0' characters. If it's longer, it will be truncated.
- */
-export function binaryHashToStr(hash: Uint8Array, expLength: number) {
-	return base64Encode(hash).padEnd(expLength, '0').slice(0, expLength)
-}

package/src/utils/retries.ts

@@ -1,41 +0,0 @@
-import type { Logger } from '#src/types/index.ts'
-
-type RetryLoopOptions = {
-	maxRetries?: number
-	logger: Logger
-	shouldRetry: (error: Error) => boolean
-}
-
-/**
- * Execute a function, and upon failure -- retry
- * based on specified options.
- */
-export async function executeWithRetries<T>(
-	code: (attempt: number) => Promise<T>,
-	{
-		maxRetries = 3,
-		shouldRetry,
-		logger,
-	}: RetryLoopOptions
-) {
-	let retries = 0
-	while(retries < maxRetries) {
-		try {
-			const result = await code(retries)
-			return result
-		} catch(err) {
-			retries += 1
-			if(retries >= maxRetries) {
-				throw err
-			}
-
-			if(!shouldRetry(err)) {
-				throw err
-			}
-
-			logger.info({ err, retries }, 'retrying failed operation')
-		}
-	}
-
-	throw new Error('retries exhausted')
-}

package/src/utils/signatures/eth.ts

@@ -1,35 +0,0 @@
-import { utils, Wallet } from 'ethers'
-
-import type { ServiceSignatureProvider } from '#src/types/index.ts'
-
-const { computeAddress, computePublicKey } = utils
-
-export const ETH_SIGNATURE_PROVIDER: ServiceSignatureProvider = {
-	getPublicKey(privateKey) {
-		const pub = computePublicKey(privateKey, true)
-		return utils.arrayify(pub)
-	},
-	getAddress(publicKey) {
-		return computeAddress(publicKey).toLowerCase()
-	},
-	async sign(data, privateKey) {
-		const wallet = getEthWallet(privateKey)
-		const signature = await wallet.signMessage(data)
-		return utils.arrayify(signature)
-	},
-	async verify(data, signature, addressBytes) {
-		const address = typeof addressBytes === 'string'
-			? addressBytes
-			: utils.hexlify(addressBytes)
-		const signerAddress = utils.verifyMessage(data, signature)
-		return signerAddress.toLowerCase() === address.toLowerCase()
-	}
-}
-
-function getEthWallet(privateKey: string) {
-	if(!privateKey) {
-		throw new Error('Private key missing')
-	}
-
-	return new Wallet(privateKey)
-}

package/src/utils/signatures/index.ts

@@ -1,11 +0,0 @@
-import { ServiceSignatureType } from '#src/proto/api.ts'
-import type { ServiceSignatureProvider } from '#src/types/index.ts'
-import { ETH_SIGNATURE_PROVIDER } from '#src/utils/signatures/eth.ts'
-
-export const SIGNATURES = {
-	[ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH]: ETH_SIGNATURE_PROVIDER,
-} as { [key in ServiceSignatureType]: ServiceSignatureProvider }
-
-export const SelectedServiceSignatureType = ServiceSignatureType.SERVICE_SIGNATURE_TYPE_ETH
-
-export const SelectedServiceSignature = SIGNATURES[SelectedServiceSignatureType]

package/src/utils/socket-base.ts

@@ -1,132 +0,0 @@
-import type { WebSocket as WSWebSocket } from 'ws'
-
-import { wsMessageHandler } from '#src/client/utils/message-handler.ts'
-import type { InitRequest, RPCMessage } from '#src/proto/api.ts'
-import { RPCMessages } from '#src/proto/api.ts'
-import type { IAttestorSocket, Logger, RPCEvent, RPCEventMap } from '#src/types/index.ts'
-import { AttestorError, makeRpcEvent, packRpcMessages } from '#src/utils/index.ts'
-
-/**
- * Common AttestorSocket class used on the client & server side as the
- * base for their respective socket implementations.
- */
-export class AttestorSocket implements IAttestorSocket {
-
-	private eventTarget = new EventTarget()
-	protected socket: WebSocket | WSWebSocket
-	readonly logger: Logger
-	readonly metadata: InitRequest
-
-	isInitialised = false
-
-	constructor(
-		socket: WebSocket | WSWebSocket,
-		metadata: InitRequest,
-		logger: Logger
-	) {
-		this.socket = socket
-		this.metadata = metadata
-		this.logger = logger
-
-		socket.addEventListener('error', (event) => {
-			const witErr = AttestorError.fromError(
-				event.error || new Error(event.message),
-				'ERROR_NETWORK_ERROR'
-			)
-
-			this.dispatchRPCEvent('connection-terminated', witErr)
-		})
-
-		socket.addEventListener('close', () => (
-			this.dispatchRPCEvent(
-				'connection-terminated',
-				new AttestorError(
-					'ERROR_NO_ERROR',
-					'connection closed'
-				)
-			)
-		))
-
-		socket.addEventListener('message', async({ data }) => {
-			try {
-				await wsMessageHandler.call(this, data)
-			} catch(err) {
-				this.logger.error({ err }, 'error processing message')
-			}
-		})
-	}
-
-	get isOpen() {
-		return this.socket.readyState === this.socket.OPEN
-	}
-
-	get isClosed() {
-		return this.socket.readyState === this.socket.CLOSED
-			|| this.socket.readyState === this.socket.CLOSING
-	}
-
-	async sendMessage(...msgs: Partial<RPCMessage>[]) {
-		if(this.isClosed) {
-			throw new AttestorError(
-				'ERROR_NETWORK_ERROR',
-				'Connection closed, cannot send message'
-			)
-		}
-
-		if(!this.isOpen) {
-			throw new AttestorError(
-				'ERROR_NETWORK_ERROR',
-				'Wait for connection to open before sending message'
-			)
-		}
-
-		const msg = packRpcMessages(...msgs)
-		const bytes = RPCMessages.encode(msg).finish()
-
-		this.logger.trace({ msg }, 'sending messages')
-
-		if('sendPromise' in this.socket && this.socket.sendPromise) {
-			await this.socket.sendPromise(bytes)
-		} else {
-			this.socket.send(bytes)
-		}
-
-		return msg
-	}
-
-	dispatchRPCEvent<K extends keyof RPCEventMap>(type: K, data: RPCEventMap[K]) {
-		const event = makeRpcEvent(type, data)
-		this.eventTarget.dispatchEvent(event)
-	}
-
-	addEventListener<K extends keyof RPCEventMap>(type: K, listener: (data: RPCEvent<K>) => void): void {
-		this.eventTarget.addEventListener(type, listener)
-	}
-
-	removeEventListener<K extends keyof RPCEventMap>(type: K, listener: (data: RPCEvent<K>) => void): void {
-		this.eventTarget.removeEventListener(type, listener)
-	}
-
-	async terminateConnection(err?: Error) {
-		// connection already closed
-		if(this.isClosed) {
-			return
-		}
-
-		try {
-			const witErr = err
-				? AttestorError.fromError(err)
-				: new AttestorError('ERROR_NO_ERROR', '')
-			this.dispatchRPCEvent('connection-terminated', witErr)
-			if(this.isOpen) {
-				await this.sendMessage({
-					connectionTerminationAlert: witErr.toProto()
-				})
-			}
-		} catch(err) {
-			this.logger?.error({ err }, 'error terminating connection')
-		} finally {
-			this.socket.close()
-		}
-	}
-}

package/src/utils/ws.ts

@@ -1,30 +0,0 @@
-import type { WebSocket as WSWebSocket } from 'ws'
-
-export function makeWebSocket(url: string) {
-	return new WebSocket(url)
-}
-
-/**
- * Adds the "sendPromise" fn to the given WebSocket instance,
- * if not already present.
- */
-export function promisifySend(ws: WSWebSocket) {
-	if(ws.sendPromise) {
-		return ws
-	}
-
-	ws.sendPromise = (data) => (
-		new Promise((resolve, reject) => {
-			ws.send(data, err => {
-				if(err) {
-					reject(err)
-					return
-				}
-
-				resolve()
-			})
-		})
-	)
-
-	return ws
-}