@optimystic/db-p2p 0.0.1

package/src/cluster/partition-detector.ts

@@ -0,0 +1,158 @@
+export interface PeerStatus {
+	peerId: string;
+	lastSeen: number;
+	lastGoodbye?: number;
+	consecutiveFailures: number;
+}
+
+/**
+ * Detects potential network partitions by tracking peer health,
+ * goodbye messages, and sudden mass unreachability events.
+ */
+export class PartitionDetector {
+	private peerStatuses: Map<string, PeerStatus> = new Map();
+	private readonly unreachableThreshold = 3; // consecutive failures
+	private readonly rapidChurnThreshold = 5; // peers
+	private readonly rapidChurnWindow = 10000; // 10 seconds
+	private readonly peerTimeoutMs = 60000; // 1 minute
+
+	/**
+	 * Record successful communication with a peer
+	 */
+	recordSuccess(peerId: string): void {
+		const now = Date.now();
+		const status = this.peerStatuses.get(peerId);
+
+		if (status) {
+			status.lastSeen = now;
+			status.consecutiveFailures = 0;
+		} else {
+			this.peerStatuses.set(peerId, {
+				peerId,
+				lastSeen: now,
+				consecutiveFailures: 0
+			});
+		}
+
+		// Clean up old peer records
+		this.cleanupOldPeers();
+	}
+
+	/**
+	 * Record failed communication attempt with a peer
+	 */
+	recordFailure(peerId: string): void {
+		const now = Date.now();
+		const status = this.peerStatuses.get(peerId);
+
+		if (status) {
+			status.consecutiveFailures++;
+			status.lastSeen = now;
+		} else {
+			this.peerStatuses.set(peerId, {
+				peerId,
+				lastSeen: now,
+				consecutiveFailures: 1
+			});
+		}
+	}
+
+	/**
+	 * Record explicit goodbye message from a peer
+	 */
+	recordGoodbye(peerId: string): void {
+		const now = Date.now();
+		const status = this.peerStatuses.get(peerId);
+
+		if (status) {
+			status.lastGoodbye = now;
+			status.lastSeen = now;
+		} else {
+			this.peerStatuses.set(peerId, {
+				peerId,
+				lastSeen: now,
+				lastGoodbye: now,
+				consecutiveFailures: 0
+			});
+		}
+	}
+
+	/**
+	 * Detect if we're likely in a network partition
+	 * Returns true if sudden mass unreachability or rapid goodbye rate
+	 */
+	detectPartition(): boolean {
+		const now = Date.now();
+
+		// Count recent goodbyes
+		const recentGoodbyes = this.getRecentGoodbyes(this.rapidChurnWindow);
+
+		// Count unreachable peers
+		const unreachable = Array.from(this.peerStatuses.values()).filter(
+			s => s.consecutiveFailures >= this.unreachableThreshold
+				&& !s.lastGoodbye // Exclude peers that said goodbye
+		);
+
+		// Sudden mass unreachability suggests partition
+		const totalChurn = recentGoodbyes.length + unreachable.length;
+
+		return totalChurn >= this.rapidChurnThreshold;
+	}
+
+	/**
+	 * Get list of currently unreachable peers
+	 */
+	getUnreachablePeers(): string[] {
+		return Array.from(this.peerStatuses.values())
+			.filter(s => s.consecutiveFailures >= this.unreachableThreshold && !s.lastGoodbye)
+			.map(s => s.peerId);
+	}
+
+	/**
+	 * Get recent goodbye messages within the specified window
+	 */
+	private getRecentGoodbyes(windowMs: number): PeerStatus[] {
+		const cutoff = Date.now() - windowMs;
+		return Array.from(this.peerStatuses.values()).filter(
+			s => s.lastGoodbye && s.lastGoodbye > cutoff
+		);
+	}
+
+	/**
+	 * Clean up peer records that haven't been seen recently
+	 */
+	private cleanupOldPeers(): void {
+		const cutoff = Date.now() - this.peerTimeoutMs;
+		for (const [peerId, status] of this.peerStatuses.entries()) {
+			if (status.lastSeen < cutoff) {
+				this.peerStatuses.delete(peerId);
+			}
+		}
+	}
+
+	/**
+	 * Get statistics for monitoring
+	 */
+	getStatistics(): {
+		totalPeers: number;
+		unreachable: number;
+		recentGoodbyes: number;
+	} {
+		const unreachable = this.getUnreachablePeers().length;
+		const recentGoodbyes = this.getRecentGoodbyes(this.rapidChurnWindow).length;
+
+		return {
+			totalPeers: this.peerStatuses.size,
+			unreachable,
+			recentGoodbyes
+		};
+	}
+
+	/**
+	 * Reset all tracked peer states (useful for testing)
+	 */
+	reset(): void {
+		this.peerStatuses.clear();
+	}
+}
+

package/src/cluster/service.ts

@@ -0,0 +1,156 @@
+import { pipe } from 'it-pipe';
+import { decode as lpDecode, encode as lpEncode } from 'it-length-prefixed';
+import type { Startable, Logger, IncomingStreamData } from '@libp2p/interface';
+import type { ICluster, ClusterRecord } from '@optimystic/db-core';
+import { computeResponsibility } from '../routing/responsibility.js'
+import { peersEqual } from '../peer-utils.js'
+import { buildKnownPeers } from '../routing/libp2p-known-peers.js'
+import { encodePeers } from '../repo/redirect.js'
+import type { Uint8ArrayList } from 'uint8arraylist';
+
+interface BaseComponents {
+	logger: { forComponent: (name: string) => Logger },
+	registrar: {
+		handle: (protocol: string, handler: (data: IncomingStreamData) => void, options: any) => Promise<void>,
+		unhandle: (protocol: string) => Promise<void>
+	}
+}
+
+export interface ClusterServiceComponents extends BaseComponents {
+	cluster: ICluster
+}
+
+export interface ClusterServiceInit {
+	protocol?: string,
+	protocolPrefix?: string,
+	maxInboundStreams?: number,
+	maxOutboundStreams?: number,
+	logPrefix?: string,
+  kBucketSize?: number,
+  configuredClusterSize?: number,
+  allowClusterDownsize?: boolean,
+  clusterSizeTolerance?: number,
+}
+
+export function clusterService(init: ClusterServiceInit = {}): (components: ClusterServiceComponents) => ClusterService {
+	return (components: ClusterServiceComponents) => new ClusterService(components, init);
+}
+
+/**
+ * A libp2p service that handles cluster protocol messages
+ */
+export class ClusterService implements Startable {
+	private readonly protocol: string;
+	private readonly maxInboundStreams: number;
+	private readonly maxOutboundStreams: number;
+	private readonly log: Logger;
+	private readonly cluster: ICluster;
+	private readonly components: ClusterServiceComponents;
+	private running: boolean;
+  private readonly k: number;
+  private readonly configuredClusterSize: number;
+  private readonly allowDownsize: boolean;
+  private readonly sizeTolerance: number;
+
+	constructor(components: ClusterServiceComponents, init: ClusterServiceInit = {}) {
+		this.components = components;
+		this.protocol = init.protocol ?? (init.protocolPrefix ?? '/db-p2p') + '/cluster/1.0.0';
+		this.maxInboundStreams = init.maxInboundStreams ?? 32;
+		this.maxOutboundStreams = init.maxOutboundStreams ?? 64;
+		this.log = components.logger.forComponent(init.logPrefix ?? 'db-p2p:cluster');
+		this.cluster = components.cluster;
+		this.running = false;
+    this.k = init.kBucketSize ?? 10;
+    this.configuredClusterSize = init.configuredClusterSize ?? 10;
+    this.allowDownsize = init.allowClusterDownsize ?? true;
+    this.sizeTolerance = init.clusterSizeTolerance ?? 0.5;
+	}
+
+	readonly [Symbol.toStringTag] = '@libp2p/cluster';
+
+	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(data: IncomingStreamData): void {
+		const { stream, connection } = data;
+		const peerId = connection.remotePeer;
+
+		const processStream = async function* (this: ClusterService, source: AsyncIterable<Uint8ArrayList>) {
+			for await (const msg of source) {
+				// Decode the message
+				const decoded = new TextDecoder().decode(msg.subarray());
+				const message = JSON.parse(decoded) as { operation: string; record: ClusterRecord };
+
+				// Process the operation
+				let response: any;
+					if (message.operation === 'update') {
+          // Use message.record.message as key source; this is RepoMessage carrying block IDs
+          const tailId = (message.record?.message as any)?.commit?.tailId ?? (message.record?.message as any)?.pend ? Object.keys((message.record as any).message.pend.transforms)[0] : undefined
+          // TEMPORARY: Disable cluster membership check to fix empty promises issue
+          // The membership check was causing peers to return redirect responses
+          // instead of processing cluster updates, leading to empty promise arrays.
+          // TODO: Re-enable and fix cluster membership logic for proper DHT routing
+          response = await this.cluster.update(message.record)
+				} else {
+					throw new Error(`Unknown operation: ${message.operation}`);
+				}
+
+				// Encode and yield the response
+				if (message.operation === 'update') {
+					const rec = response as any;
+					this.log('cluster-service:pre-serialize', {
+						messageHash: rec?.messageHash,
+						responseType: typeof response,
+						hasPromises: 'promises' in (rec ?? {}),
+						hasCommits: 'commits' in (rec ?? {}),
+						promiseKeys: Object.keys(rec?.promises ?? {}),
+						commitKeys: Object.keys(rec?.commits ?? {}),
+						promiseValues: rec?.promises,
+						commitValues: rec?.commits
+					});
+				}
+				const serialized = JSON.stringify(response);
+				if (message.operation === 'update') {
+					const deserialized = JSON.parse(serialized);
+					this.log('cluster-service:post-serialize', {
+						messageHash: (deserialized as any)?.messageHash,
+						promiseKeys: Object.keys((deserialized as any)?.promises ?? {}),
+						commitKeys: Object.keys((deserialized as any)?.commits ?? {})
+					});
+				}
+				yield new TextEncoder().encode(serialized);
+			}
+		};
+
+		Promise.resolve().then(async () => {
+			await pipe(
+				stream,
+				(source) => lpDecode(source),
+				processStream.bind(this),
+				(source) => lpEncode(source),
+				stream
+			);
+		}).catch((err: Error) => {
+			this.log.error('error handling cluster protocol message from %p - %e', peerId, err);
+		});
+	}
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+export * from "./cluster/client.js";
+export * from "./cluster/cluster-repo.js";
+export * from "./cluster/service.js";
+export * from "./protocol-client.js";
+export * from "./repo/client.js";
+export * from "./repo/cluster-coordinator.js";
+export * from "./repo/coordinator-repo.js";
+export * from "./repo/service.js";
+export * from "./storage/block-storage.js";
+export * from "./storage/file-storage.js";
+export * from "./storage/memory-storage.js";
+export * from "./storage/i-block-storage.js";
+export * from "./storage/i-raw-storage.js";
+export * from "./storage/storage-repo.js";
+export * from "./storage/restoration-coordinator-v2.js";
+export * from "./storage/ring-selector.js";
+export * from "./storage/storage-monitor.js";
+export * from "./storage/arachnode-fret-adapter.js";
+export * from "./sync/protocol.js";
+export * from "./sync/client.js";
+export * from "./sync/service.js";
+export * from "./it-utility.js";
+export * from "./libp2p-key-network.js";
+export * from "./libp2p-node.js";
+export * from "./routing/responsibility.js";
+export * from "./routing/libp2p-known-peers.js";
+export * from "./network/network-manager-service.js";
+export * from "./network/get-network-manager.js";
+
+

package/src/it-utility.ts

@@ -0,0 +1,36 @@
+export async function first<T>(
+	createIterable: (signal: AbortSignal) => AsyncIterable<T>,
+	onEmpty: () => T = () => { throw new Error('No items found') },
+	timeoutMs?: number
+): Promise<T> {
+	const controller = new AbortController();
+	const timer = typeof timeoutMs === 'number' ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+	try {
+		for await (const item of createIterable(controller.signal)) {
+			return item;
+		}
+		return onEmpty();
+	} finally {
+		if (timer !== undefined) clearTimeout(timer);
+		controller.abort();
+	}
+}
+
+export async function asyncIteratorToArray<T>(iterator: AsyncIterable<T>): Promise<T[]> {
+	const result: T[] = [];
+	for await (const item of iterator) {
+		result.push(item);
+	}
+	return result;
+}
+
+export function reduce<TP, TC>(iter: IterableIterator<TC>, each: (prior: TP, current: TC, index: number) => TP, start: TP) {
+	let prior = start;
+	let i = 0;
+	for (let current of iter) {
+		prior = each(prior, current, i);
+		++i;
+	}
+	return prior;
+}
+