@optimystic/db-p2p 0.2.3 → 0.3.0

package/src/dispute/dispute-service.ts

@@ -0,0 +1,453 @@
+import type { ClusterRecord, ITransactionValidator } from '@optimystic/db-core';
+import type { PeerId, PrivateKey } from '@libp2p/interface';
+import { sha256 } from 'multiformats/hashes/sha2';
+import { base58btc } from 'multiformats/bases/base58';
+import { toString as uint8ArrayToString, fromString as uint8ArrayFromString } from 'uint8arrays';
+import { publicKeyFromRaw } from '@libp2p/crypto/keys';
+import type {
+	ValidationEvidence,
+	DisputeChallenge,
+	ArbitrationVote,
+	DisputeResolution,
+	DisputeConfig,
+	DisputeMessage,
+	DisputeStatus,
+} from './types.js';
+import { DEFAULT_DISPUTE_CONFIG } from './types.js';
+import { EngineHealthMonitor } from './engine-health-monitor.js';
+import type { IPeerReputation } from '../reputation/types.js';
+import { PenaltyReason } from '../reputation/types.js';
+import { createLogger } from '../logger.js';
+import type { IPeerNetwork } from '@optimystic/db-core';
+import type { DisputeClient } from './client.js';
+
+const log = createLogger('dispute');
+
+/** Callback to create a DisputeClient for a given peer */
+export type CreateDisputeClient = (peerId: PeerId) => DisputeClient;
+
+/** Callback to re-execute a transaction and produce validation evidence */
+export type RevalidateTransaction = (record: ClusterRecord) => Promise<ValidationEvidence | undefined>;
+
+export interface DisputeServiceInit {
+	peerId: PeerId;
+	privateKey: PrivateKey;
+	peerNetwork: IPeerNetwork;
+	createDisputeClient: CreateDisputeClient;
+	reputation?: IPeerReputation;
+	validator?: ITransactionValidator;
+	revalidate?: RevalidateTransaction;
+	config?: Partial<DisputeConfig>;
+	/** Select arbitrators for a dispute (next K peers beyond the original cluster) */
+	selectArbitrators: (blockId: string, excludePeers: string[], count: number) => Promise<PeerId[]>;
+}
+
+/**
+ * Manages the dispute escalation protocol.
+ *
+ * When a transaction proceeds despite minority rejections, the overridden
+ * minority can escalate to independent arbitrators. The service coordinates
+ * challenge initiation, arbitration vote collection, and resolution.
+ */
+export class DisputeService {
+	private readonly peerId: PeerId;
+	private readonly privateKey: PrivateKey;
+	private readonly createDisputeClient: CreateDisputeClient;
+	private readonly reputation?: IPeerReputation;
+	private readonly revalidate?: RevalidateTransaction;
+	private readonly config: DisputeConfig;
+	private readonly engineHealth: EngineHealthMonitor;
+	private readonly selectArbitrators: DisputeServiceInit['selectArbitrators'];
+
+	/** Active disputes initiated by this node */
+	private activeDisputes: Map<string, DisputeChallenge> = new Map();
+	/** Resolved disputes (disputeId -> resolution) */
+	private resolvedDisputes: Map<string, DisputeResolution> = new Map();
+	/** Track which transactions we've already disputed (prevent spam) */
+	private disputedTransactions: Set<string> = new Set();
+
+	constructor(init: DisputeServiceInit) {
+		this.peerId = init.peerId;
+		this.privateKey = init.privateKey;
+		this.createDisputeClient = init.createDisputeClient;
+		this.reputation = init.reputation;
+		this.revalidate = init.revalidate;
+		this.config = { ...DEFAULT_DISPUTE_CONFIG, ...init.config };
+		this.engineHealth = new EngineHealthMonitor(this.config);
+		this.selectArbitrators = init.selectArbitrators;
+	}
+
+	/** Get the engine health monitor */
+	getEngineHealth(): EngineHealthMonitor {
+		return this.engineHealth;
+	}
+
+	/** Check if disputes are enabled */
+	isEnabled(): boolean {
+		return this.config.disputeEnabled;
+	}
+
+	/** Get the dispute status for a transaction, if any */
+	getDisputeStatus(messageHash: string): DisputeStatus | undefined {
+		// Check if there's an active dispute for this transaction
+		for (const [, challenge] of this.activeDisputes) {
+			if (challenge.originalMessageHash === messageHash) {
+				return 'committed-disputed';
+			}
+		}
+		// Check resolved disputes
+		for (const [, resolution] of this.resolvedDisputes) {
+			const challenge = this.findChallengeForDispute(resolution.disputeId);
+			if (challenge && challenge.originalMessageHash === messageHash) {
+				if (resolution.outcome === 'challenger-wins') return 'committed-invalidated';
+				if (resolution.outcome === 'majority-wins') return 'committed-validated';
+				return 'committed-disputed'; // inconclusive
+			}
+		}
+		return undefined;
+	}
+
+	/**
+	 * Initiate a dispute when this node's rejection was overridden.
+	 * Called by ClusterMember when it detects a disputed commit.
+	 */
+	async initiateDispute(record: ClusterRecord, evidence: ValidationEvidence): Promise<DisputeResolution | undefined> {
+		if (!this.config.disputeEnabled) {
+			log('dispute-disabled', { messageHash: record.messageHash });
+			return undefined;
+		}
+
+		// One dispute per transaction
+		if (this.disputedTransactions.has(record.messageHash)) {
+			log('dispute-already-initiated', { messageHash: record.messageHash });
+			return undefined;
+		}
+
+		// Don't dispute if our engine is unhealthy
+		if (this.engineHealth.isUnhealthy()) {
+			log('dispute-skipped-unhealthy', { messageHash: record.messageHash });
+			return undefined;
+		}
+
+		this.disputedTransactions.add(record.messageHash);
+
+		const timestamp = Date.now();
+		const disputeId = await this.computeDisputeId(record.messageHash, this.peerId.toString(), timestamp);
+		const signature = await this.signDispute(disputeId);
+
+		const defaultTtl = record.message.expiration
+			? (record.message.expiration - Date.now()) * 2
+			: this.config.disputeArbitrationTimeoutMs * 2;
+		const expiration = timestamp + Math.max(defaultTtl, this.config.disputeArbitrationTimeoutMs);
+
+		const challenge: DisputeChallenge = {
+			disputeId,
+			originalMessageHash: record.messageHash,
+			originalRecord: record,
+			challengerPeerId: this.peerId.toString(),
+			challengerEvidence: evidence,
+			signature,
+			timestamp,
+			expiration,
+		};
+
+		this.activeDisputes.set(disputeId, challenge);
+		log('dispute-initiated', { disputeId, messageHash: record.messageHash });
+
+		// Select arbitrators and collect votes
+		const blockIds = record.coordinatingBlockIds ?? [];
+		const blockId = blockIds[0] ?? record.messageHash;
+		const originalPeers = Object.keys(record.peers);
+		const arbitratorCount = this.config.arbitratorCount ?? originalPeers.length;
+
+		let arbitrators: PeerId[];
+		try {
+			arbitrators = await this.selectArbitrators(blockId, originalPeers, arbitratorCount);
+		} catch (err) {
+			log('dispute-arbitrator-selection-failed', { disputeId, error: err instanceof Error ? err.message : String(err) });
+			this.activeDisputes.delete(disputeId);
+			return undefined;
+		}
+
+		if (arbitrators.length === 0) {
+			log('dispute-no-arbitrators', { disputeId });
+			this.activeDisputes.delete(disputeId);
+			return undefined;
+		}
+
+		// Send challenge to all arbitrators and collect votes
+		const votes = await this.collectVotes(challenge, arbitrators);
+		const resolution = this.resolveDispute(challenge, votes);
+
+		this.activeDisputes.delete(disputeId);
+		this.resolvedDisputes.set(disputeId, resolution);
+
+		// Apply reputation effects
+		this.applyReputationEffects(resolution, record);
+
+		// Broadcast resolution
+		await this.broadcastResolution(resolution, arbitrators, originalPeers);
+
+		log('dispute-resolved', {
+			disputeId,
+			outcome: resolution.outcome,
+			votes: votes.length,
+			affectedPeers: resolution.affectedPeers.length,
+		});
+
+		return resolution;
+	}
+
+	/**
+	 * Handle an incoming dispute challenge (when this node is selected as arbitrator).
+	 * Re-executes the transaction and returns a vote.
+	 */
+	async handleChallenge(challenge: DisputeChallenge): Promise<ArbitrationVote> {
+		log('dispute-handle-challenge', { disputeId: challenge.disputeId });
+
+		// Verify the challenge signature
+		const validSignature = await this.verifyDisputeSignature(
+			challenge.disputeId,
+			challenge.signature,
+			challenge.originalRecord.peers[challenge.challengerPeerId]?.publicKey
+		);
+
+		if (!validSignature) {
+			log('dispute-invalid-challenge-signature', { disputeId: challenge.disputeId });
+			return this.makeVote(challenge.disputeId, 'inconclusive', {
+				computedHash: '',
+				engineId: 'unknown',
+				schemaHash: '',
+				blockStateHashes: {},
+			});
+		}
+
+		// Re-execute the transaction to produce our own evidence
+		let evidence: ValidationEvidence | undefined;
+		if (this.revalidate) {
+			try {
+				evidence = await this.revalidate(challenge.originalRecord);
+			} catch (err) {
+				log('dispute-revalidation-failed', {
+					disputeId: challenge.disputeId,
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
+		}
+
+		if (!evidence) {
+			// Can't re-execute — vote inconclusive
+			return this.makeVote(challenge.disputeId, 'inconclusive', {
+				computedHash: '',
+				engineId: 'unknown',
+				schemaHash: '',
+				blockStateHashes: {},
+			});
+		}
+
+		// Compare our evidence with the challenger's
+		let vote: ArbitrationVote['vote'];
+		if (evidence.computedHash === challenge.challengerEvidence.computedHash) {
+			// Our re-execution matches the challenger — the challenger is right
+			vote = 'agree-with-challenger';
+		} else {
+			// Our re-execution differs from the challenger — the majority is likely right
+			vote = 'agree-with-majority';
+		}
+
+		return this.makeVote(challenge.disputeId, vote, evidence);
+	}
+
+	/**
+	 * Handle an incoming dispute resolution (broadcast from the dispute initiator).
+	 */
+	handleResolution(resolution: DisputeResolution): void {
+		this.resolvedDisputes.set(resolution.disputeId, resolution);
+		log('dispute-resolution-received', {
+			disputeId: resolution.disputeId,
+			outcome: resolution.outcome,
+		});
+
+		// If we were penalized and the challenger won, check engine health
+		const ourId = this.peerId.toString();
+		const ourPenalty = resolution.affectedPeers.find(p => p.peerId === ourId);
+		if (ourPenalty && ourPenalty.reason === 'false-approval') {
+			this.engineHealth.recordDisputeLoss();
+		}
+	}
+
+	/** Collect votes from arbitrators with a timeout */
+	private async collectVotes(challenge: DisputeChallenge, arbitrators: PeerId[]): Promise<ArbitrationVote[]> {
+		const timeoutMs = this.config.disputeArbitrationTimeoutMs;
+		const votes: ArbitrationVote[] = [];
+
+		const votePromises = arbitrators.map(async (arbitratorPeerId) => {
+			try {
+				const client = this.createDisputeClient(arbitratorPeerId);
+				const vote = await client.sendChallenge(challenge, timeoutMs);
+				return vote;
+			} catch (err) {
+				log('dispute-vote-collection-failed', {
+					disputeId: challenge.disputeId,
+					arbitrator: arbitratorPeerId.toString(),
+					error: err instanceof Error ? err.message : String(err),
+				});
+				return undefined;
+			}
+		});
+
+		const results = await Promise.allSettled(votePromises);
+		for (const result of results) {
+			if (result.status === 'fulfilled' && result.value) {
+				votes.push(result.value);
+			}
+		}
+
+		return votes;
+	}
+
+	/** Determine dispute resolution from collected votes */
+	resolveDispute(challenge: DisputeChallenge, votes: ArbitrationVote[]): DisputeResolution {
+		const challengerVotes = votes.filter(v => v.vote === 'agree-with-challenger').length;
+		const majorityVotes = votes.filter(v => v.vote === 'agree-with-majority').length;
+		const totalDecisive = challengerVotes + majorityVotes;
+
+		// Need super-majority of decisive votes (>2/3)
+		const superMajorityThreshold = Math.ceil(totalDecisive * 2 / 3);
+
+		let outcome: DisputeResolution['outcome'];
+		const affectedPeers: DisputeResolution['affectedPeers'] = [];
+
+		if (totalDecisive === 0) {
+			outcome = 'inconclusive';
+		} else if (challengerVotes >= superMajorityThreshold) {
+			outcome = 'challenger-wins';
+			// Penalize majority peers who approved the transaction
+			const originalRecord = challenge.originalRecord;
+			for (const [peerId, signature] of Object.entries(originalRecord.promises)) {
+				if (signature.type === 'approve' && peerId !== challenge.challengerPeerId) {
+					affectedPeers.push({ peerId, reason: 'false-approval' });
+				}
+			}
+		} else if (majorityVotes >= superMajorityThreshold) {
+			outcome = 'majority-wins';
+			// Penalize the challenger
+			affectedPeers.push({ peerId: challenge.challengerPeerId, reason: 'dispute-lost' });
+		} else {
+			outcome = 'inconclusive';
+		}
+
+		return {
+			disputeId: challenge.disputeId,
+			outcome,
+			votes,
+			affectedPeers,
+			timestamp: Date.now(),
+		};
+	}
+
+	/** Apply reputation effects based on dispute resolution */
+	private applyReputationEffects(resolution: DisputeResolution, record: ClusterRecord): void {
+		if (!this.reputation) return;
+
+		for (const affected of resolution.affectedPeers) {
+			if (affected.reason === 'false-approval') {
+				// Weight: 40 as specified in ticket
+				this.reputation.reportPeer(affected.peerId, PenaltyReason.FalseApproval,
+					`dispute:false-approval:${resolution.disputeId}`);
+			} else if (affected.reason === 'dispute-lost') {
+				// Weight: 30 as specified in ticket
+				this.reputation.reportPeer(affected.peerId, PenaltyReason.DisputeLost,
+					`dispute:dispute-lost:${resolution.disputeId}`);
+			}
+		}
+
+		// If challenger wins, track engine health for majority peers
+		if (resolution.outcome === 'challenger-wins') {
+			const ourId = this.peerId.toString();
+			if (resolution.affectedPeers.some(p => p.peerId === ourId)) {
+				this.engineHealth.recordDisputeLoss();
+			}
+		}
+	}
+
+	/** Broadcast resolution to all interested parties */
+	private async broadcastResolution(
+		resolution: DisputeResolution,
+		arbitrators: PeerId[],
+		originalPeers: string[]
+	): Promise<void> {
+		const allTargets = new Set<string>();
+		for (const arb of arbitrators) allTargets.add(arb.toString());
+		for (const peer of originalPeers) allTargets.add(peer);
+		// Don't send to self
+		allTargets.delete(this.peerId.toString());
+
+		const promises = Array.from(allTargets).map(async (peerIdStr) => {
+			try {
+				const { peerIdFromString } = await import('@libp2p/peer-id');
+				const client = this.createDisputeClient(peerIdFromString(peerIdStr));
+				await client.sendResolution(resolution);
+			} catch (err) {
+				log('dispute-broadcast-failed', {
+					disputeId: resolution.disputeId,
+					peer: peerIdStr,
+					error: err instanceof Error ? err.message : String(err),
+				});
+			}
+		});
+
+		await Promise.allSettled(promises);
+	}
+
+	private async makeVote(
+		disputeId: string,
+		vote: ArbitrationVote['vote'],
+		evidence: ValidationEvidence
+	): Promise<ArbitrationVote> {
+		const payload = `${disputeId}:${vote}:${evidence.computedHash}`;
+		const payloadBytes = new TextEncoder().encode(payload);
+		const sigBytes = await this.privateKey.sign(payloadBytes);
+
+		return {
+			disputeId,
+			arbitratorPeerId: this.peerId.toString(),
+			vote,
+			evidence,
+			signature: uint8ArrayToString(sigBytes, 'base64url'),
+		};
+	}
+
+	private async computeDisputeId(messageHash: string, peerId: string, timestamp: number): Promise<string> {
+		const input = `${messageHash}+${peerId}+${timestamp}`;
+		const inputBytes = new TextEncoder().encode(input);
+		const hashBytes = await sha256.digest(inputBytes);
+		return base58btc.encode(hashBytes.digest);
+	}
+
+	private async signDispute(disputeId: string): Promise<string> {
+		const payload = new TextEncoder().encode(disputeId);
+		const sigBytes = await this.privateKey.sign(payload);
+		return uint8ArrayToString(sigBytes, 'base64url');
+	}
+
+	private async verifyDisputeSignature(
+		disputeId: string,
+		signature: string,
+		publicKey?: Uint8Array
+	): Promise<boolean> {
+		if (!publicKey?.length) return false;
+		try {
+			const pubKey = publicKeyFromRaw(publicKey);
+			const payload = new TextEncoder().encode(disputeId);
+			const sigBytes = uint8ArrayFromString(signature, 'base64url');
+			return pubKey.verify(payload, sigBytes);
+		} catch {
+			return false;
+		}
+	}
+
+	private findChallengeForDispute(disputeId: string): DisputeChallenge | undefined {
+		return this.activeDisputes.get(disputeId);
+	}
+}

package/src/dispute/engine-health-monitor.ts

@@ -0,0 +1,86 @@
+import type { EngineHealthState, DisputeConfig } from './types.js';
+import { DEFAULT_DISPUTE_CONFIG } from './types.js';
+import { createLogger } from '../logger.js';
+
+const log = createLogger('engine-health');
+
+/**
+ * Tracks local engine health based on dispute outcomes.
+ * When the node repeatedly loses disputes (its validations are wrong),
+ * it flags itself as unhealthy and stops participating in promise voting.
+ */
+export class EngineHealthMonitor {
+	private state: EngineHealthState = {
+		disputesLost: 0,
+		recentLosses: [],
+		unhealthy: false,
+	};
+
+	private readonly threshold: number;
+	private readonly windowMs: number;
+
+	constructor(config?: Partial<DisputeConfig>) {
+		this.threshold = config?.engineHealthDisputeThreshold ?? DEFAULT_DISPUTE_CONFIG.engineHealthDisputeThreshold;
+		this.windowMs = config?.engineHealthWindowMs ?? DEFAULT_DISPUTE_CONFIG.engineHealthWindowMs;
+	}
+
+	/** Record a dispute loss (our validation was wrong) */
+	recordDisputeLoss(): void {
+		const now = Date.now();
+		this.state.recentLosses.push(now);
+		this.pruneOldLosses(now);
+		this.state.disputesLost = this.state.recentLosses.length;
+
+		log('dispute-loss-recorded', {
+			recentLosses: this.state.recentLosses.length,
+			threshold: this.threshold,
+			wasUnhealthy: this.state.unhealthy,
+		});
+
+		if (this.state.recentLosses.length >= this.threshold && !this.state.unhealthy) {
+			this.state.unhealthy = true;
+			this.state.unhealthySince = now;
+			log('engine-marked-unhealthy', {
+				disputesLost: this.state.recentLosses.length,
+				threshold: this.threshold,
+				windowMs: this.windowMs,
+			});
+		}
+	}
+
+	/** Check if the engine is currently unhealthy */
+	isUnhealthy(): boolean {
+		this.pruneOldLosses(Date.now());
+		// Auto-recover if losses drop below threshold
+		if (this.state.unhealthy && this.state.recentLosses.length < this.threshold) {
+			this.state.unhealthy = false;
+			this.state.unhealthySince = undefined;
+			log('engine-auto-recovered', {
+				recentLosses: this.state.recentLosses.length,
+				threshold: this.threshold,
+			});
+		}
+		return this.state.unhealthy;
+	}
+
+	/** Get the current health state */
+	getState(): Readonly<EngineHealthState> {
+		this.pruneOldLosses(Date.now());
+		return { ...this.state };
+	}
+
+	/** Reset health state (for testing or admin recovery) */
+	reset(): void {
+		this.state = {
+			disputesLost: 0,
+			recentLosses: [],
+			unhealthy: false,
+		};
+	}
+
+	private pruneOldLosses(now: number): void {
+		const cutoff = now - this.windowMs;
+		this.state.recentLosses = this.state.recentLosses.filter(t => t > cutoff);
+		this.state.disputesLost = this.state.recentLosses.length;
+	}
+}

package/src/dispute/index.ts

@@ -0,0 +1,17 @@
+export { DisputeService, type CreateDisputeClient, type RevalidateTransaction, type DisputeServiceInit } from './dispute-service.js';
+export { DisputeClient } from './client.js';
+export { DisputeProtocolService, disputeProtocolService, type DisputeProtocolServiceComponents, type DisputeProtocolServiceInit } from './service.js';
+export { EngineHealthMonitor } from './engine-health-monitor.js';
+export {
+	type ValidationEvidence,
+	type DisputeChallenge,
+	type ArbitrationVote,
+	type DisputeResolution,
+	type DisputeMessage,
+	type DisputeStatus,
+	type DisputeConfig,
+	type DisputePenaltyReason,
+	type EngineHealthState,
+	DEFAULT_DISPUTE_CONFIG,
+} from './types.js';
+export { selectArbitrators } from './arbitrator-selection.js';

package/src/dispute/service.ts

@@ -0,0 +1,119 @@
+import { pipe } from 'it-pipe';
+import { decode as lpDecode, encode as lpEncode } from 'it-length-prefixed';
+import type { Startable, Logger, Stream, Connection, StreamHandler } from '@libp2p/interface';
+import type { Uint8ArrayList } from 'uint8arraylist';
+import type { DisputeMessage, ArbitrationVote, DisputeResolution } from './types.js';
+import type { DisputeService } from './dispute-service.js';
+
+interface BaseComponents {
+	logger: { forComponent: (name: string) => Logger };
+	registrar: {
+		handle: (protocol: string, handler: StreamHandler, options: any) => Promise<void>;
+		unhandle: (protocol: string) => Promise<void>;
+	};
+}
+
+export interface DisputeProtocolServiceComponents extends BaseComponents {
+	disputeService: DisputeService;
+}
+
+export interface DisputeProtocolServiceInit {
+	protocol?: string;
+	protocolPrefix?: string;
+	maxInboundStreams?: number;
+	maxOutboundStreams?: number;
+}
+
+export function disputeProtocolService(init: DisputeProtocolServiceInit = {}): (components: DisputeProtocolServiceComponents) => DisputeProtocolService {
+	return (components: DisputeProtocolServiceComponents) => new DisputeProtocolService(components, init);
+}
+
+/**
+ * Libp2p service that handles dispute protocol messages.
+ * Follows the same pattern as ClusterService.
+ */
+export class DisputeProtocolService implements Startable {
+	private readonly protocol: string;
+	private readonly maxInboundStreams: number;
+	private readonly maxOutboundStreams: number;
+	private readonly log: Logger;
+	private readonly disputeService: DisputeService;
+	private readonly components: DisputeProtocolServiceComponents;
+	private running: boolean;
+
+	constructor(components: DisputeProtocolServiceComponents, init: DisputeProtocolServiceInit = {}) {
+		this.components = components;
+		this.protocol = init.protocol ?? (init.protocolPrefix ?? '/db-p2p') + '/dispute/1.0.0';
+		this.maxInboundStreams = init.maxInboundStreams ?? 16;
+		this.maxOutboundStreams = init.maxOutboundStreams ?? 32;
+		this.log = components.logger.forComponent('db-p2p:dispute');
+		this.disputeService = components.disputeService;
+		this.running = false;
+	}
+
+	readonly [Symbol.toStringTag] = '@libp2p/dispute';
+
+	async start(): Promise<void> {
+		if (this.running) return;
+
+		await this.components.registrar.handle(this.protocol, this.handleIncomingStream.bind(this), {
+			maxInboundStreams: this.maxInboundStreams,
+			maxOutboundStreams: this.maxOutboundStreams,
+		});
+
+		this.running = true;
+	}
+
+	async stop(): Promise<void> {
+		if (!this.running) return;
+		await this.components.registrar.unhandle(this.protocol);
+		this.running = false;
+	}
+
+	private handleIncomingStream(stream: Stream, connection: Connection): void {
+		const peerId = connection.remotePeer;
+
+		const processStream = async function* (this: DisputeProtocolService, source: AsyncIterable<Uint8ArrayList>) {
+			for await (const msg of source) {
+				const decoded = new TextDecoder().decode(msg.subarray());
+				const message = JSON.parse(decoded) as DisputeMessage;
+
+				let response: any;
+				switch (message.type) {
+					case 'challenge': {
+						const vote = await this.disputeService.handleChallenge(message.challenge);
+						response = { type: 'vote', vote };
+						break;
+					}
+					case 'resolution': {
+						this.disputeService.handleResolution(message.resolution);
+						response = { type: 'ack' };
+						break;
+					}
+					default:
+						throw new Error(`Unknown dispute message type: ${(message as any).type}`);
+				}
+
+				yield new TextEncoder().encode(JSON.stringify(response));
+			}
+		};
+
+		void (async () => {
+			try {
+				const responses = pipe(
+					stream,
+					(source) => lpDecode(source),
+					processStream.bind(this),
+					(source) => lpEncode(source)
+				);
+				for await (const chunk of responses) {
+					stream.send(chunk);
+				}
+				await stream.close();
+			} catch (err) {
+				this.log.error('error handling dispute protocol message from %p - %e', peerId, err);
+				stream.abort(err instanceof Error ? err : new Error(String(err)));
+			}
+		})();
+	}
+}