@optimystic/db-p2p 0.2.3 → 0.3.0

package/src/dispute/types.ts

@@ -0,0 +1,114 @@
+import type { ClusterRecord } from '@optimystic/db-core';
+
+/** Evidence a validator collects during transaction re-execution */
+export type ValidationEvidence = {
+	/** Operations hash the validator computed */
+	computedHash: string;
+	/** Engine used for validation */
+	engineId: string;
+	/** Schema hash at time of validation */
+	schemaHash: string;
+	/** Snapshot of block states during validation */
+	blockStateHashes: {
+		[blockId: string]: { revision: number; contentHash: string };
+	};
+};
+
+/** A challenge initiated by an overridden minority peer */
+export type DisputeChallenge = {
+	/** Hash of (messageHash + challengerPeerId + timestamp) */
+	disputeId: string;
+	/** References the disputed ClusterRecord */
+	originalMessageHash: string;
+	/** Full record including all promises */
+	originalRecord: ClusterRecord;
+	/** Peer ID of the challenger */
+	challengerPeerId: string;
+	/** Challenger's validation evidence */
+	challengerEvidence: ValidationEvidence;
+	/** Challenger signs the dispute */
+	signature: string;
+	/** Timestamp of dispute creation */
+	timestamp: number;
+	/** TTL for arbitration (default: 2 × transaction TTL) */
+	expiration: number;
+};
+
+/** An arbitrator's independent assessment */
+export type ArbitrationVote = {
+	/** Dispute being voted on */
+	disputeId: string;
+	/** Peer ID of the arbitrator */
+	arbitratorPeerId: string;
+	/** The arbitrator's verdict */
+	vote: 'agree-with-challenger' | 'agree-with-majority' | 'inconclusive';
+	/** Arbitrator's own re-execution results */
+	evidence: ValidationEvidence;
+	/** Arbitrator signs the vote */
+	signature: string;
+};
+
+/** Final resolution of a dispute */
+export type DisputeResolution = {
+	/** Dispute being resolved */
+	disputeId: string;
+	/** Outcome of the dispute */
+	outcome: 'challenger-wins' | 'majority-wins' | 'inconclusive';
+	/** All votes collected */
+	votes: ArbitrationVote[];
+	/** Peers receiving reputation adjustments */
+	affectedPeers: {
+		peerId: string;
+		reason: DisputePenaltyReason;
+	}[];
+	/** Timestamp of resolution */
+	timestamp: number;
+};
+
+/** Dispute-specific penalty reasons (mapped to PenaltyReason for reputation) */
+export type DisputePenaltyReason = 'false-approval' | 'dispute-lost';
+
+/** Dispute protocol message types */
+export type DisputeMessage =
+	| { type: 'challenge'; challenge: DisputeChallenge }
+	| { type: 'vote'; vote: ArbitrationVote }
+	| { type: 'resolution'; resolution: DisputeResolution };
+
+/** Dispute status for transaction queries */
+export type DisputeStatus =
+	| 'committed-disputed'
+	| 'committed-validated'
+	| 'committed-invalidated';
+
+/** Engine health state */
+export type EngineHealthState = {
+	/** Number of disputes lost in the tracking window */
+	disputesLost: number;
+	/** Timestamps of recent dispute losses */
+	recentLosses: number[];
+	/** Whether the engine is flagged as unhealthy */
+	unhealthy: boolean;
+	/** When the unhealthy flag was set */
+	unhealthySince?: number;
+};
+
+/** Dispute configuration */
+export interface DisputeConfig {
+	/** Enable/disable dispute protocol */
+	disputeEnabled: boolean;
+	/** Timeout for arbitration in milliseconds (default: 60000) */
+	disputeArbitrationTimeoutMs: number;
+	/** Number of arbitrators to select (default: same as cluster size) */
+	arbitratorCount?: number;
+	/** Engine health: max disputes lost in window before marking unhealthy */
+	engineHealthDisputeThreshold: number;
+	/** Engine health: window in ms for counting disputes (default: 600000 = 10 min) */
+	engineHealthWindowMs: number;
+}
+
+export const DEFAULT_DISPUTE_CONFIG: DisputeConfig = {
+	disputeEnabled: false,
+	disputeArbitrationTimeoutMs: 60_000,
+	engineHealthDisputeThreshold: 3,
+	engineHealthWindowMs: 10 * 60 * 1000,
+};

package/src/index.ts

@@ -1,6 +1,7 @@
 export * from "./cluster/client.js";
 export * from "./cluster/cluster-repo.js";
 export * from "./cluster/service.js";
+export * from "./cluster/rebalance-monitor.js";
 export * from "./protocol-client.js";
 export * from "./repo/client.js";
 export * from "./repo/cluster-coordinator.js";
@@ -26,3 +27,5 @@ 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";
+export * from "./reputation/index.js";
+export * from "./dispute/index.js";

package/src/libp2p-key-network.ts

@@ -3,12 +3,28 @@ import { toString as u8ToString } from 'uint8arrays/to-string'
 import type { ClusterPeers, FindCoordinatorOptions, IKeyNetwork, IPeerNetwork } from "@optimystic/db-core";
 import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
-import type { FretService } from 'p2p-fret'
+import type { FretService, SerializedTable } from 'p2p-fret'
 import { hashKey } from 'p2p-fret'
-import { createLogger } from './logger.js'
+import { createLogger, verbose } from './logger.js'
+import type { IPeerReputation } from './reputation/types.js'
 
 interface WithFretService { services?: { fret?: FretService } }
 
+export type NetworkMode = 'forming' | 'joining';
+
+export interface PersistedNetworkState {
+	version: 1;
+	networkHighWaterMark: number;
+	lastConnectedTimestamp: number;
+	consecutiveIsolatedSessions: number;
+	fretTable?: SerializedTable;
+}
+
+export interface NetworkStatePersistence {
+	load(): Promise<PersistedNetworkState | undefined>;
+	save(state: PersistedNetworkState): Promise<void>;
+}
+
 /**
  * Configuration options for self-coordination behavior
  */
@@ -26,7 +42,7 @@ export interface SelfCoordinationConfig {
  */
 export interface SelfCoordinationDecision {
 	allow: boolean;
-	reason: 'bootstrap-node' | 'partition-detected' | 'suspicious-shrinkage' | 'grace-period-not-elapsed' | 'extended-isolation' | 'disabled';
+	reason: 'bootstrap-node' | 'partition-detected' | 'suspicious-shrinkage' | 'grace-period-not-elapsed' | 'extended-isolation' | 'hwm-decay' | 'disabled';
 	warn?: boolean;
 }
 
@@ -34,17 +50,25 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 	private readonly selfCoordinationConfig: Required<SelfCoordinationConfig>;
 	private networkHighWaterMark = 1;
 	private lastConnectedTime = Date.now();
+	private consecutiveIsolatedSessions = 0;
+	private readonly networkMode: NetworkMode;
+	private readonly persistence?: NetworkStatePersistence;
 
 	constructor(
 		private readonly libp2p: Libp2p,
 		private readonly clusterSize: number = 16,
-		selfCoordinationConfig?: SelfCoordinationConfig
+		selfCoordinationConfig?: SelfCoordinationConfig,
+		networkMode?: NetworkMode,
+		persistence?: NetworkStatePersistence,
+		private readonly reputation?: IPeerReputation
 	) {
 		this.selfCoordinationConfig = {
 			gracePeriodMs: selfCoordinationConfig?.gracePeriodMs ?? 30_000,
 			shrinkageThreshold: selfCoordinationConfig?.shrinkageThreshold ?? 0.5,
 			allowSelfCoordination: selfCoordinationConfig?.allowSelfCoordination ?? true
 		};
+		this.networkMode = networkMode ?? 'forming';
+		this.persistence = persistence;
 		this.setupConnectionTracking();
 	}
 
@@ -72,6 +96,7 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 		const connections = this.libp2p.getConnections?.() ?? [];
 		if (connections.length > 0) {
 			this.lastConnectedTime = Date.now();
+			this.consecutiveIsolatedSessions = 0;
 		}
 
 		try {
@@ -90,6 +115,56 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 				this.log('network-hwm-updated mark=%d (from connections)', this.networkHighWaterMark);
 			}
 		}
+
+		this.persistState();
+	}
+
+	async initFromPersistedState(): Promise<void> {
+		if (!this.persistence) return;
+		const state = await this.persistence.load();
+		if (!state) return;
+
+		this.networkHighWaterMark = state.networkHighWaterMark;
+		this.lastConnectedTime = state.lastConnectedTimestamp;
+		this.consecutiveIsolatedSessions = state.consecutiveIsolatedSessions;
+
+		if (state.fretTable) {
+			try {
+				this.getFret().importTable(state.fretTable);
+			} catch (err) { this.log('init:fret-import-skipped %o', err); }
+		}
+
+		// If HWM > 1 but FRET table is empty/self-only, increment isolated sessions
+		if (state.networkHighWaterMark > 1) {
+			const fretEntryCount = state.fretTable?.entries?.length ?? 0;
+			if (fretEntryCount <= 1) {
+				this.consecutiveIsolatedSessions++;
+				this.log('init:isolated-session count=%d hwm=%d', this.consecutiveIsolatedSessions, this.networkHighWaterMark);
+			}
+		}
+	}
+
+	private canRetryImprove(fretNeighborIds: string[]): boolean {
+		if (this.networkMode !== 'forming') return true;
+		if (this.networkHighWaterMark > 1) return true;
+		const onlySelf = fretNeighborIds.length <= 1
+			&& (fretNeighborIds.length === 0 || fretNeighborIds[0] === this.libp2p.peerId.toString());
+		return !onlySelf;
+	}
+
+	private persistState(): void {
+		if (!this.persistence) return;
+		const state: PersistedNetworkState = {
+			version: 1,
+			networkHighWaterMark: this.networkHighWaterMark,
+			lastConnectedTimestamp: this.lastConnectedTime,
+			consecutiveIsolatedSessions: this.consecutiveIsolatedSessions,
+		};
+		try {
+			const fret = this.getFret();
+			state.fretTable = fret.exportTable();
+		} catch { /* FRET not available */ }
+		void this.persistence.save(state).catch(err => this.log('persist-state-failed %o', err));
 	}
 
 	/**
@@ -109,6 +184,12 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 			return { allow: true, reason: 'bootstrap-node' };
 		}
 
+		// Case 1b: Repeated isolation across sessions — decay HWM to allow eventual self-coordination
+		if (this.consecutiveIsolatedSessions >= 3) {
+			this.log('self-coord-allowed: hwm-decayed sessions=%d', this.consecutiveIsolatedSessions);
+			return { allow: true, reason: 'hwm-decay', warn: true };
+		}
+
 		// Case 2: Check for partition via FRET
 		try {
 			const fret = this.getFret();
@@ -199,6 +280,7 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 	}
 
 	async findCoordinator(key: Uint8Array, _options?: Partial<FindCoordinatorOptions>): Promise<PeerId> {
+		const t0 = Date.now();
 		const excludedSet = new Set<string>((_options?.excludedPeers ?? []).map(p => p.toString()))
 		const keyStr = this.toCacheKey(key).substring(0, 12);
 
@@ -207,7 +289,7 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 		// honor cache if not excluded
 		const cached = this.getCachedCoordinator(key)
 		if (cached != null && !excludedSet.has(cached.toString())) {
-			this.log('findCoordinator:cached-hit key=%s coordinator=%s', keyStr, cached.toString().substring(0, 12))
+			this.log('findCoordinator:done key=%s ms=%d source=%s', keyStr, Date.now() - t0, 'cache')
 			return cached
 		}
 
@@ -222,35 +304,49 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 			this.log('findCoordinator:connected-peers key=%s count=%d peers=%o attempt=%d', keyStr, connected.length, connected.map(p => p.toString().substring(0, 12)), attempt)
 
 			// prefer FRET neighbors that are also connected, pick first non-excluded
+			let ids: string[] = [];
 			try {
-				const ids = await this.getNeighborIdsForKey(key, this.clusterSize)
-				this.log('findCoordinator:fret-neighbors key=%s candidates=%o', keyStr, ids.map(s => s.substring(0, 12)))
-
-				// Filter to only connected FRET neighbors
-				const connectedFretIds = ids.filter(id => connectedSet.has(id) || id === this.libp2p.peerId.toString())
+				ids = await this.getNeighborIdsForKey(key, this.clusterSize)
+				this.log('findCoordinator:fret-neighbors key=%s candidates=%d', keyStr, ids.length)
+				if (verbose) this.log('findCoordinator:fret-candidates key=%s ids=%o connected=%o', keyStr, ids, Array.from(connectedSet))
+
+				// Filter to only connected FRET neighbors, excluding banned peers
+				const connectedFretIds = ids
+					.filter(id => (connectedSet.has(id) || id === this.libp2p.peerId.toString())
+						&& !excludedSet.has(id)
+						&& !(this.reputation?.isBanned(id)))
+					.sort((a, b) => (this.reputation?.getScore(a) ?? 0) - (this.reputation?.getScore(b) ?? 0))
 				this.log('findCoordinator:fret-connected key=%s count=%d peers=%o', keyStr, connectedFretIds.length, connectedFretIds.map(s => s.substring(0, 12)))
 
-				const pick = connectedFretIds.find(id => !excludedSet.has(id))
+				const pick = connectedFretIds[0]
 				if (pick) {
 					const pid = peerIdFromString(pick)
 					this.recordCoordinator(key, pid)
-					this.log('findCoordinator:fret-selected key=%s coordinator=%s', keyStr, pick.substring(0, 12))
+					this.log('findCoordinator:done key=%s ms=%d source=%s', keyStr, Date.now() - t0, 'fret')
 					return pid
 				}
 			} catch (err) {
 				this.log('findCoordinator getNeighborIdsForKey failed - %o', err)
 			}
 
-			// fallback: prefer any existing connected peer that's not excluded
-			const connectedPick = connected.find(p => !excludedSet.has(p.toString()))
+			// fallback: prefer any existing connected peer that's not excluded or banned
+			const connectedPick = connected
+				.filter(p => !excludedSet.has(p.toString()) && !(this.reputation?.isBanned(p.toString())))
+				.sort((a, b) => (this.reputation?.getScore(a.toString()) ?? 0) - (this.reputation?.getScore(b.toString()) ?? 0))
+				[0]
 			if (connectedPick) {
 				this.recordCoordinator(key, connectedPick)
-				this.log('findCoordinator:connected-fallback key=%s coordinator=%s', keyStr, connectedPick.toString().substring(0, 12))
+				this.log('findCoordinator:done key=%s ms=%d source=%s', keyStr, Date.now() - t0, 'connected-fallback')
 				return connectedPick
 			}
 
 			// If no connections and not the last attempt, wait and retry
 			if (connected.length === 0 && attempt < maxRetries - 1) {
+				if (!this.canRetryImprove(ids)) {
+					this.log('findCoordinator:retry-futile key=%s mode=%s hwm=%d',
+						keyStr, this.networkMode, this.networkHighWaterMark);
+					break;
+				}
 				this.log('findCoordinator:no-connections-retry key=%s attempt=%d delay=%dms', keyStr, attempt, retryDelayMs)
 				await new Promise(resolve => setTimeout(resolve, retryDelayMs))
 				continue
@@ -272,6 +368,7 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 				this.log('findCoordinator:self-selected key=%s coordinator=%s reason=%s',
 					keyStr, self.toString().substring(0, 12), decision.reason);
 			}
+			this.log('findCoordinator:done key=%s ms=%d source=%s', keyStr, Date.now() - t0, 'self')
 			return self
 		}
 
@@ -299,10 +396,12 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 	}
 
 	async findCluster(key: Uint8Array): Promise<ClusterPeers> {
+		const t0 = Date.now();
 		const fret = this.getFret()
 		const coord = await hashKey(key)
 		const cohort = fret.assembleCohort(coord, this.clusterSize)
 		const keyStr = this.toCacheKey(key).substring(0, 12);
+		this.log('findCluster:start key=%s', keyStr);
 
 		// Include self in the cohort
 		const ids = Array.from(new Set([...cohort, this.libp2p.peerId.toString()]))
@@ -310,8 +409,8 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 		const connectedByPeer = this.getConnectedAddrsByPeer()
 		const connectedPeerIds = Object.keys(connectedByPeer)
 
-		this.log('findCluster key=%s fretCohort=%d connected=%d cohortPeers=%o',
-			keyStr, cohort.length, connectedPeerIds.length, ids.map(s => s.substring(0, 12)))
+		this.log('findCluster key=%s fretCohort=%d connected=%d', keyStr, cohort.length, connectedPeerIds.length)
+		if (verbose) this.log('findCluster:detail key=%s cohortPeers=%o connectedPeers=%o', keyStr, ids, connectedPeerIds)
 
 		const peers: ClusterPeers = {}
 
@@ -321,13 +420,12 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 				continue
 			}
 			const strings = connectedByPeer[idStr] ?? []
-			peers[idStr] = { multiaddrs: this.parseMultiaddrs(strings), publicKey: new Uint8Array() }
+			const remotePeerId = peerIdFromString(idStr)
+			peers[idStr] = { multiaddrs: this.parseMultiaddrs(strings), publicKey: remotePeerId.publicKey?.raw ?? new Uint8Array() }
 		}
 
-		this.log('findCluster:result key=%s clusterSize=%d withAddrs=%d connectedInCohort=%d',
-			keyStr, Object.keys(peers).length,
-			Object.values(peers).filter(p => p.multiaddrs.length > 0).length,
-			ids.filter(id => connectedPeerIds.includes(id) || id === this.libp2p.peerId.toString()).length)
+		this.log('findCluster:done key=%s ms=%d peers=%d',
+			keyStr, Date.now() - t0, Object.keys(peers).length)
 		return peers
 	}
 }

package/src/libp2p-node-base.ts

@@ -7,6 +7,7 @@ import { gossipsub } from '@chainsafe/libp2p-gossipsub';
 import { bootstrap } from '@libp2p/bootstrap';
 import { circuitRelayServer } from '@libp2p/circuit-relay-v2';
 import { peerIdFromString } from '@libp2p/peer-id';
+import { generateKeyPair } from '@libp2p/crypto/keys';
 import { clusterService } from './cluster/service.js';
 import { repoService } from './repo/service.js';
 import { StorageRepo } from './storage/storage-repo.js';
@@ -15,7 +16,7 @@ import { MemoryRawStorage } from './storage/memory-storage.js';
 import type { IRawStorage } from './storage/i-raw-storage.js';
 import { clusterMember } from './cluster/cluster-repo.js';
 import { coordinatorRepo } from './repo/coordinator-repo.js';
-import { Libp2pKeyPeerNetwork } from './libp2p-key-network.js';
+import { Libp2pKeyPeerNetwork, type NetworkMode, type NetworkStatePersistence } from './libp2p-key-network.js';
 import { ClusterClient } from './cluster/client.js';
 import type { IRepo, ICluster, ITransactionValidator } from '@optimystic/db-core';
 import { networkManagerService } from './network/network-manager-service.js';
@@ -31,6 +32,12 @@ import { ArachnodeFretAdapter } from './storage/arachnode-fret-adapter.js';
 import type { RestoreCallback } from './storage/struct.js';
 import type { FretService } from 'p2p-fret';
 import { PartitionDetector } from './cluster/partition-detector.js';
+import { PeerReputationService } from './reputation/peer-reputation.js';
+import { DisputeService } from './dispute/dispute-service.js';
+import { DisputeClient } from './dispute/client.js';
+import { disputeProtocolService } from './dispute/service.js';
+import { selectArbitrators } from './dispute/arbitrator-selection.js';
+import type { DisputeConfig } from './dispute/types.js';
 
 type Libp2pInit = NonNullable<Parameters<typeof createLibp2p>[0]>;
 export type Libp2pTransports = NonNullable<Libp2pInit['transports']>;
@@ -80,6 +87,12 @@ export type NodeOptions = {
 
 	/** Transaction validator for cluster consensus */
 	validator?: ITransactionValidator;
+
+	/** Optional persistence for network state (HWM, FRET table) across restarts */
+	persistence?: NetworkStatePersistence;
+
+	/** Dispute protocol configuration */
+	dispute?: Partial<DisputeConfig>;
 };
 
 function resolveStorage(provider: RawStorageProvider | undefined): IRawStorage {
@@ -139,15 +152,15 @@ export async function createLibp2pNodeBase(
 		}
 	};
 
-	// Parse peer ID if provided
-	const peerId = options.id ? await peerIdFromString(options.id) : undefined;
+	// Generate or derive the private key for this node
+	const nodePrivateKey = await generateKeyPair('Ed25519');
 
 	const listenAddrs = options.listenAddrs ?? defaults.listenAddrs;
 	const transports = options.transports ?? defaults.transports;
 
 	const libp2pOptions: unknown = {
 		start: false,
-		...(peerId ? { peerId } : {}),
+		privateKey: nodePrivateKey,
 		addresses: {
 			listen: listenAddrs
 		},
@@ -251,23 +264,43 @@ export async function createLibp2pNodeBase(
 
 	await node.start();
 
+	// Initialize peer reputation service
+	const reputation = new PeerReputationService();
+
 	// Initialize cluster coordination components
-	const keyNetwork = new Libp2pKeyPeerNetwork(node);
+	const networkMode: NetworkMode = (options.bootstrapNodes?.length ?? 0) > 0 ? 'joining' : 'forming';
+	const keyNetwork = new Libp2pKeyPeerNetwork(node, options.clusterSize, undefined, networkMode, options.persistence, reputation);
+	await keyNetwork.initFromPersistedState();
 	const protocolPrefix = `/optimystic/${options.networkName}`;
 	const createClusterClient = (peerId: any) => ClusterClient.create(peerId, keyNetwork, protocolPrefix);
 
+	// Inject reputation into NetworkManagerService
+	try { ((node as any).services?.networkManager as any)?.setReputation?.(reputation); } catch { }
+
 	// Create partition detector and get FRET service
 	const partitionDetector = new PartitionDetector();
 	const fretSvc = (node as any).services?.fret as FretService | undefined;
 
+	const consensusConfig = {
+		superMajorityThreshold: options.clusterPolicy?.superMajorityThreshold ?? 0.67,
+		simpleMajorityThreshold: 0.51,
+		minAbsoluteClusterSize: 2,
+		allowClusterDownsize: options.clusterPolicy?.allowDownsize ?? true,
+		clusterSizeTolerance: options.clusterPolicy?.sizeTolerance ?? 0.5,
+		partitionDetectionWindow: 60000
+	};
+
 	clusterImpl = clusterMember({
 		storageRepo,
 		peerNetwork: keyNetwork,
 		peerId: node.peerId,
+		privateKey: nodePrivateKey,
 		protocolPrefix,
 		partitionDetector,
 		fretService: fretSvc,
-		validator: options.validator
+		validator: options.validator,
+		reputation,
+		consensusConfig
 	});
 
 	const coordinatorRepoFactory = coordinatorRepo(
@@ -275,14 +308,10 @@ export async function createLibp2pNodeBase(
 		createClusterClient,
 		{
 			clusterSize: options.clusterSize ?? 10,
-			superMajorityThreshold: options.clusterPolicy?.superMajorityThreshold ?? 0.67,
-			simpleMajorityThreshold: 0.51,
-			minAbsoluteClusterSize: 2,
-			allowClusterDownsize: options.clusterPolicy?.allowDownsize ?? true,
-			clusterSizeTolerance: options.clusterPolicy?.sizeTolerance ?? 0.5,
-			partitionDetectionWindow: 60000
+			...consensusConfig
 		},
-		fretSvc
+		fretSvc,
+		reputation
 	);
 
 	// Create callback for querying cluster peers for their latest block revision
@@ -377,10 +406,45 @@ export async function createLibp2pNodeBase(
 		}
 	}
 
+	// Initialize dispute service if enabled
+	let disputeServiceInstance: DisputeService | undefined;
+	if (options.dispute?.disputeEnabled) {
+		const createDisputeClient = (peerId: any) => DisputeClient.create(peerId, keyNetwork, protocolPrefix);
+		disputeServiceInstance = new DisputeService({
+			peerId: node.peerId,
+			privateKey: nodePrivateKey,
+			peerNetwork: keyNetwork,
+			createDisputeClient,
+			reputation,
+			validator: options.validator,
+			config: options.dispute,
+			selectArbitrators: async (blockId: string, excludePeers: string[], count: number) => {
+				const { hashKey: fretHashKey } = await import('p2p-fret');
+				const blockIdBytes = new TextEncoder().encode(blockId);
+				const fret = (node as any).services?.fret as FretService | undefined;
+				if (!fret) return [];
+				// Get a larger cohort and exclude the original cluster peers
+				const cohortSize = count + excludePeers.length + 1;
+				const hashedCoord = await fretHashKey(blockIdBytes);
+				const allPeerIdStrs = fret.assembleCohort(hashedCoord, cohortSize) as string[];
+				// Filter out original cluster peers and self, convert to PeerId
+				const excludeSet = new Set(excludePeers);
+				excludeSet.add(node.peerId.toString());
+				const arbitratorPeerIds = allPeerIdStrs
+					.filter(pid => !excludeSet.has(pid))
+					.slice(0, count)
+					.map(pid => peerIdFromString(pid));
+				return arbitratorPeerIds;
+			},
+		});
+	}
+
 	// Expose coordinated repo and storage for external use
 	(node as any).coordinatedRepo = coordinatedRepo;
 	(node as any).storageRepo = storageRepo;
 	(node as any).keyNetwork = keyNetwork;
+	(node as any).reputation = reputation;
+	(node as any).disputeService = disputeServiceInstance;
 
 	return node;
 }

package/src/logger.ts

@@ -6,4 +6,5 @@ export function createLogger(subNamespace: string): debug.Debugger {
 	return debug(`${BASE_NAMESPACE}:${subNamespace}`)
 }
 
-
+export const verbose = typeof process !== 'undefined'
+	&& (process.env.OPTIMYSTIC_VERBOSE === '1' || process.env.OPTIMYSTIC_VERBOSE === 'true');