@optimystic/db-p2p 0.3.0 → 0.7.0

package/src/cluster/block-transfer.ts

@@ -1,28 +1,13 @@
-import type { BlockId, IRepo } from '@optimystic/db-core';
-import type { PeerId, IPeerNetwork } from '@optimystic/db-core';
+import type { IRepo, IPeerNetwork } from '@optimystic/db-core';
 import { peerIdFromString } from '@libp2p/peer-id';
 import type { PartitionDetector } from './partition-detector.js';
 import type { RestorationCoordinator } from '../storage/restoration-coordinator-v2.js';
-import { BlockTransferClient, type BlockTransferRequest, type BlockTransferResponse } from './block-transfer-service.js';
+import { BlockTransferClient } from './block-transfer-service.js';
+import type { RebalanceEvent } from './rebalance-monitor.js';
 import { createLogger } from '../logger.js';
 
 const log = createLogger('block-transfer');
 
-/**
- * Rebalance event describing gained/lost block responsibilities.
- * Matches the RebalanceMonitor spec from the sibling ticket.
- */
-export interface RebalanceEvent {
-	/** Block IDs this node has gained responsibility for */
-	gained: string[];
-	/** Block IDs this node has lost responsibility for */
-	lost: string[];
-	/** Peers that are now closer for the lost blocks: blockId → peerId[] */
-	newOwners: Map<string, string[]>;
-	/** Timestamp of the topology change that triggered this */
-	triggeredAt: number;
-}
-
 export interface BlockTransferConfig {
 	/** Max concurrent transfers. Default: 4 */
 	maxConcurrency?: number;
@@ -34,11 +19,6 @@ export interface BlockTransferConfig {
 	enablePush?: boolean;
 }
 
-interface TransferTask {
-	blockId: string;
-	attempt: number;
-}
-
 /**
  * Coordinates block transfers in response to rebalance events.
  *
@@ -84,11 +64,9 @@ export class BlockTransferCoordinator {
 		const succeeded: string[] = [];
 		const failed: string[] = [];
 
-		const tasks = blockIds
-			.filter(id => !this.inFlight.has(`pull:${id}`))
-			.map(id => ({ blockId: id, attempt: 0 }));
+		const ids = blockIds.filter(id => !this.inFlight.has(`pull:${id}`));
 
-		await Promise.all(tasks.map(task => this.executePull(task, succeeded, failed)));
+		await Promise.all(ids.map(id => this.executePull(id, succeeded, failed)));
 
 		return { succeeded, failed };
 	}
@@ -111,11 +89,9 @@ export class BlockTransferCoordinator {
 		const succeeded: string[] = [];
 		const failed: string[] = [];
 
-		const tasks = blockIds
-			.filter(id => !this.inFlight.has(`push:${id}`) && newOwners.has(id))
-			.map(id => ({ blockId: id, attempt: 0 }));
+		const ids = blockIds.filter(id => !this.inFlight.has(`push:${id}`) && newOwners.has(id));
 
-		await Promise.all(tasks.map(task => this.executePush(task, newOwners, succeeded, failed)));
+		await Promise.all(ids.map(id => this.executePush(id, newOwners, succeeded, failed)));
 
 		return { succeeded, failed };
 	}
@@ -139,37 +115,40 @@ export class BlockTransferCoordinator {
 	}
 
 	private async executePull(
-		task: TransferTask,
+		blockId: string,
 		succeeded: string[],
 		failed: string[]
 	): Promise<void> {
-		const key = `pull:${task.blockId}`;
+		const key = `pull:${blockId}`;
 		if (this.inFlight.has(key)) return;
 		this.inFlight.add(key);
 
 		try {
-			await this.acquireSemaphore();
-			try {
-				const archive = await this.withTimeout(
-					this.restorationCoordinator.restore(task.blockId),
-					this.transferTimeoutMs
-				);
+			for (let attempt = 0; ; attempt++) {
+				await this.acquireSemaphore();
+				let archive: Awaited<ReturnType<RestorationCoordinator['restore']>>;
+				try {
+					archive = await this.withTimeout(
+						this.restorationCoordinator.restore(blockId),
+						this.transferTimeoutMs
+					);
+				} finally {
+					this.releaseSemaphore();
+				}
 
 				if (archive) {
-					log('pull:ok block=%s', task.blockId);
-					succeeded.push(task.blockId);
-				} else if (task.attempt < this.maxRetries) {
-					log('pull:retry block=%s attempt=%d', task.blockId, task.attempt + 1);
-					this.inFlight.delete(key);
-					await this.delay(this.backoffMs(task.attempt));
-					await this.executePull({ ...task, attempt: task.attempt + 1 }, succeeded, failed);
+					log('pull:ok block=%s', blockId);
+					succeeded.push(blockId);
 					return;
-				} else {
-					log('pull:failed block=%s', task.blockId);
-					failed.push(task.blockId);
 				}
-			} finally {
-				this.releaseSemaphore();
+				if (attempt < this.maxRetries) {
+					log('pull:retry block=%s attempt=%d', blockId, attempt + 1);
+					await this.delay(this.backoffMs(attempt));
+					continue;
+				}
+				log('pull:failed block=%s', blockId);
+				failed.push(blockId);
+				return;
 			}
 		} finally {
 			this.inFlight.delete(key);
@@ -177,71 +156,73 @@ export class BlockTransferCoordinator {
 	}
 
 	private async executePush(
-		task: TransferTask,
+		blockId: string,
 		newOwners: Map<string, string[]>,
 		succeeded: string[],
 		failed: string[]
 	): Promise<void> {
-		const key = `push:${task.blockId}`;
+		const key = `push:${blockId}`;
 		if (this.inFlight.has(key)) return;
 		this.inFlight.add(key);
 
 		try {
-			await this.acquireSemaphore();
-			try {
-				const owners = newOwners.get(task.blockId);
-				if (!owners || owners.length === 0) {
-					failed.push(task.blockId);
-					return;
-				}
-
-				// Read block data from local storage
-				const result = await this.repo.get({ blockIds: [task.blockId] });
-				const blockResult = result[task.blockId];
-				if (!blockResult?.block) {
-					log('push:no-local-data block=%s', task.blockId);
-					failed.push(task.blockId);
-					return;
-				}
+			for (let attempt = 0; ; attempt++) {
+				await this.acquireSemaphore();
+				let pushed = false;
+				try {
+					const owners = newOwners.get(blockId);
+					if (!owners || owners.length === 0) {
+						failed.push(blockId);
+						return;
+					}
 
-				const blockData = new TextEncoder().encode(JSON.stringify(blockResult.block));
+					// Read block data from local storage
+					const result = await this.repo.get({ blockIds: [blockId] });
+					const blockResult = result[blockId];
+					if (!blockResult?.block) {
+						log('push:no-local-data block=%s', blockId);
+						failed.push(blockId);
+						return;
+					}
 
-				// Push to at least one new owner
-				let pushed = false;
-				for (const ownerPeerIdStr of owners) {
-					try {
-						const peerId = peerIdFromString(ownerPeerIdStr);
-						const client = new BlockTransferClient(peerId, this.peerNetwork, this.protocolPrefix);
-						const response = await this.withTimeout(
-							client.pushBlocks([task.blockId], [blockData]),
-							this.transferTimeoutMs
-						);
-
-						if (response && !response.missing.includes(task.blockId)) {
-							pushed = true;
-							log('push:ok block=%s peer=%s', task.blockId, ownerPeerIdStr);
-							break;
+					const blockData = new TextEncoder().encode(JSON.stringify(blockResult.block));
+
+					// Push to at least one new owner
+					for (const ownerPeerIdStr of owners) {
+						try {
+							const peerId = peerIdFromString(ownerPeerIdStr);
+							const client = new BlockTransferClient(peerId, this.peerNetwork, this.protocolPrefix);
+							const response = await this.withTimeout(
+								client.pushBlocks([blockId], [blockData]),
+								this.transferTimeoutMs
+							);
+
+							if (response && !response.missing.includes(blockId)) {
+								pushed = true;
+								log('push:ok block=%s peer=%s', blockId, ownerPeerIdStr);
+								break;
+							}
+						} catch (err) {
+							log('push:peer-error block=%s peer=%s err=%s',
+								blockId, ownerPeerIdStr, (err as Error).message);
 						}
-					} catch (err) {
-						log('push:peer-error block=%s peer=%s err=%s',
-							task.blockId, ownerPeerIdStr, (err as Error).message);
 					}
+				} finally {
+					this.releaseSemaphore();
 				}
 
 				if (pushed) {
-					succeeded.push(task.blockId);
-				} else if (task.attempt < this.maxRetries) {
-					log('push:retry block=%s attempt=%d', task.blockId, task.attempt + 1);
-					this.inFlight.delete(key);
-					await this.delay(this.backoffMs(task.attempt));
-					await this.executePush({ ...task, attempt: task.attempt + 1 }, newOwners, succeeded, failed);
+					succeeded.push(blockId);
 					return;
-				} else {
-					log('push:failed block=%s', task.blockId);
-					failed.push(task.blockId);
 				}
-			} finally {
-				this.releaseSemaphore();
+				if (attempt < this.maxRetries) {
+					log('push:retry block=%s attempt=%d', blockId, attempt + 1);
+					await this.delay(this.backoffMs(attempt));
+					continue;
+				}
+				log('push:failed block=%s', blockId);
+				failed.push(blockId);
+				return;
 			}
 		} finally {
 			this.inFlight.delete(key);

package/src/cluster/cluster-repo.ts

@@ -306,7 +306,8 @@ export class ClusterMember implements ICluster {
 	}
 
 	/**
-	 * Merges two records, validating that non-signature fields match
+	 * Merges two records, validating that non-signature fields match.
+	 * Detects equivocation (same peer changing vote type) and applies penalties.
 	 */
 	private async mergeRecords(existing: ClusterRecord, incoming: ClusterRecord): Promise<ClusterRecord> {
 		log('cluster-member:merge-records', {
@@ -327,14 +328,64 @@ export class ClusterMember implements ICluster {
 			throw new Error('Peers mismatch');
 		}
 
-		// Merge signatures, keeping the most recent valid ones
+		// Merge signatures with equivocation detection
+		const mergedPromises = this.detectEquivocation(
+			existing.promises, incoming.promises, 'promise', existing.messageHash
+		);
+		const mergedCommits = this.detectEquivocation(
+			existing.commits, incoming.commits, 'commit', existing.messageHash
+		);
+
 		return {
 			...existing,
-			promises: { ...existing.promises, ...incoming.promises },
-			commits: { ...existing.commits, ...incoming.commits }
+			promises: mergedPromises,
+			commits: mergedCommits
 		};
 	}
 
+	/**
+	 * Compares existing vs incoming signatures for the same peers.
+	 * If a peer's vote type changed (approve↔reject), that's equivocation:
+	 * report a penalty and keep the first-seen signature.
+	 * New peers are accepted normally.
+	 */
+	private detectEquivocation(
+		existing: Record<string, Signature>,
+		incoming: Record<string, Signature>,
+		phase: 'promise' | 'commit',
+		messageHash: string
+	): Record<string, Signature> {
+		const merged = { ...existing };
+
+		for (const [peerId, incomingSig] of Object.entries(incoming)) {
+			const existingSig = existing[peerId];
+			if (existingSig) {
+				if (existingSig.type !== incomingSig.type) {
+					// Equivocation detected: peer changed their vote type
+					log('cluster-member:equivocation-detected', {
+						peerId,
+						phase,
+						messageHash,
+						existingType: existingSig.type,
+						incomingType: incomingSig.type
+					});
+					this.reputation?.reportPeer(
+						peerId,
+						PenaltyReason.Equivocation,
+						`${phase}:${messageHash}:${existingSig.type}->${incomingSig.type}`
+					);
+					// Keep first-seen signature — do not let the peer flip their vote
+				}
+				// Same type: keep existing (no-op, already in merged)
+			} else {
+				// New peer — accept normally
+				merged[peerId] = incomingSig;
+			}
+		}
+
+		return merged;
+	}
+
 	private async validateRecord(record: ClusterRecord): Promise<void> {
 		// Validate message hash matches the message content
 		const expectedHash = await this.computeMessageHash(record.message);

package/src/cluster/rebalance-monitor.ts

@@ -6,6 +6,7 @@ import type { ArachnodeFretAdapter, ArachnodeInfo } from '../storage/arachnode-f
 import { createLogger } from '../logger.js'
 
 const log = createLogger('rebalance-monitor')
+const textEncoder = new TextEncoder()
 
 export interface RebalanceEvent {
 	/** Block IDs this node has gained responsibility for */
@@ -164,7 +165,7 @@ export class RebalanceMonitor implements Startable {
 		const newOwners = new Map<string, string[]>()
 
 		for (const blockId of this.trackedBlocks) {
-			const key = new TextEncoder().encode(blockId)
+			const key = textEncoder.encode(blockId)
 			const coord = await hashKey(key)
 
 			// Get the current cohort — assembleCohort returns peer IDs sorted by distance
@@ -217,9 +218,6 @@ export class RebalanceMonitor implements Startable {
 	 * Update ArachnodeInfo status through the fret adapter.
 	 */
 	setStatus(status: ArachnodeInfo['status']): void {
-		const current = this.deps.fretAdapter.getMyArachnodeInfo()
-		if (current) {
-			this.deps.fretAdapter.setArachnodeInfo({ ...current, status })
-		}
+		this.deps.fretAdapter.setStatus(status)
 	}
 }

package/src/dispute/dispute-service.ts

@@ -63,6 +63,8 @@ export class DisputeService {
 	private activeDisputes: Map<string, DisputeChallenge> = new Map();
 	/** Resolved disputes (disputeId -> resolution) */
 	private resolvedDisputes: Map<string, DisputeResolution> = new Map();
+	/** Challenges retained after resolution for status lookups */
+	private resolvedChallenges: Map<string, DisputeChallenge> = new Map();
 	/** Track which transactions we've already disputed (prevent spam) */
 	private disputedTransactions: Set<string> = new Set();
 
@@ -179,6 +181,7 @@ export class DisputeService {
 		const votes = await this.collectVotes(challenge, arbitrators);
 		const resolution = this.resolveDispute(challenge, votes);
 
+		this.resolvedChallenges.set(disputeId, challenge);
 		this.activeDisputes.delete(disputeId);
 		this.resolvedDisputes.set(disputeId, resolution);
 
@@ -448,6 +451,6 @@ export class DisputeService {
 	}
 
 	private findChallengeForDispute(disputeId: string): DisputeChallenge | undefined {
-		return this.activeDisputes.get(disputeId);
+		return this.activeDisputes.get(disputeId) ?? this.resolvedChallenges.get(disputeId);
 	}
 }

package/src/index.ts

@@ -2,6 +2,8 @@ export * from "./cluster/client.js";
 export * from "./cluster/cluster-repo.js";
 export * from "./cluster/service.js";
 export * from "./cluster/rebalance-monitor.js";
+export * from "./cluster/block-transfer.js";
+export * from "./cluster/block-transfer-service.js";
 export * from "./protocol-client.js";
 export * from "./repo/client.js";
 export * from "./repo/cluster-coordinator.js";

package/src/libp2p-node-base.ts

@@ -315,7 +315,7 @@ export async function createLibp2pNodeBase(
 	);
 
 	// Create callback for querying cluster peers for their latest block revision
-	const clusterLatestCallback: ClusterLatestCallback = async (peerId, blockId) => {
+	const clusterLatestCallback: ClusterLatestCallback = async (peerId, blockId, _context?) => {
 		const syncClient = new SyncClient(peerId, keyNetwork, protocolPrefix);
 		try {
 			const response = await syncClient.requestBlock({ blockId, rev: undefined });

package/src/repo/coordinator-repo.ts

@@ -1,4 +1,4 @@
-import type { PendRequest, ActionBlocks, IRepo, MessageOptions, CommitResult, GetBlockResults, PendResult, BlockGets, CommitRequest, RepoMessage, IKeyNetwork, ICluster, ClusterConsensusConfig, BlockId, ActionRev } from "@optimystic/db-core";
+import type { PendRequest, ActionBlocks, IRepo, MessageOptions, CommitResult, GetBlockResults, PendResult, BlockGets, CommitRequest, RepoMessage, IKeyNetwork, ICluster, ClusterConsensusConfig, BlockId, ActionRev, ActionContext } from "@optimystic/db-core";
 import { LruMap } from "@optimystic/db-core";
 import { ClusterCoordinator } from "./cluster-coordinator.js";
 import type { ClusterClient } from "../cluster/client.js";
@@ -22,7 +22,7 @@ interface LocalClusterWithExecutionTracking extends ICluster {
  * Callback to query a cluster peer for their latest revision of a block.
  * Returns the peer's latest ActionRev if they have the block, undefined otherwise.
  */
-export type ClusterLatestCallback = (peerId: PeerId, blockId: BlockId) => Promise<ActionRev | undefined>;
+export type ClusterLatestCallback = (peerId: PeerId, blockId: BlockId, context?: ActionContext) => Promise<ActionRev | undefined>;
 
 interface CoordinatorRepoComponents {
 	storageRepo: IRepo;
@@ -159,7 +159,7 @@ export class CoordinatorRepo implements IRepo {
 				// If block not found locally (no state), try cluster peers
 				if (!localEntry?.state?.latest) {
 					try {
-						await this.fetchBlockFromCluster(blockId);
+						await this.fetchBlockFromCluster(blockId, blockGets.context);
 						// Re-fetch after sync
 						const refreshed = await this.storageRepo.get({ blockIds: [blockId], context: blockGets.context }, options);
 						if (refreshed[blockId]) {
@@ -175,11 +175,11 @@ export class CoordinatorRepo implements IRepo {
 		return localResult;
 	}
 
-	private async fetchBlockFromCluster(blockId: BlockId): Promise<void> {
+	private async fetchBlockFromCluster(blockId: BlockId, context?: ActionContext): Promise<void> {
 		if (!this.clusterLatestCallback) return;
 
 		// Query cluster for the block
-		const clusterLatest = await this.queryClusterForLatest(blockId);
+		const clusterLatest = await this.queryClusterForLatest(blockId, context);
 		if (clusterLatest) {
 			// Found on cluster - trigger restoration to sync the block
 			await this.storageRepo.get({ blockIds: [blockId], context: { committed: [clusterLatest], rev: clusterLatest.rev } });
@@ -190,7 +190,7 @@ export class CoordinatorRepo implements IRepo {
 	/**
 	 * Query cluster peers to find the maximum latest revision for a block.
 	 */
-	private async queryClusterForLatest(blockId: BlockId): Promise<ActionRev | undefined> {
+	private async queryClusterForLatest(blockId: BlockId, context?: ActionContext): Promise<ActionRev | undefined> {
 		const blockIdBytes = new TextEncoder().encode(blockId);
 		const peers = await this.keyNetwork.findCluster(blockIdBytes);
 		if (!peers || Object.keys(peers).length === 0) {
@@ -211,7 +211,7 @@ export class CoordinatorRepo implements IRepo {
 		const latestResults = await Promise.allSettled(
 			peerIds.map(peerIdStr => {
 				const peerId = peerIdFromString(peerIdStr);
-				return withTimeout(this.clusterLatestCallback!(peerId, blockId), 3000);
+				return withTimeout(this.clusterLatestCallback!(peerId, blockId, context), 3000);
 			})
 		);