@optimystic/db-p2p 0.13.4 → 0.14.0

package/src/libp2p-key-network.ts

@@ -291,12 +291,27 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 		return undefined
 	}
 
-	connect(peerId: PeerId, protocol: string, _options?: AbortOptions): Promise<Stream> {
-		const conns = (this.libp2p as any).getConnections?.(peerId) ?? []
-		if (Array.isArray(conns) && conns.length > 0 && typeof conns[0]?.newStream === 'function') {
-			return conns[0].newStream([protocol]) as Promise<Stream>
+	connect(peerId: PeerId, protocol: string, options?: AbortOptions): Promise<Stream> {
+		const conns = this.libp2p.getConnections?.(peerId) ?? []
+		// Filter to only-open connections so a closing/closed entry that libp2p
+		// hasn't yet evicted from its index doesn't get picked up here.
+		const open = conns.find(c => c?.status === 'open' && typeof c?.newStream === 'function')
+		if (open) {
+			// runOnLimitedConnection: true is required to open a stream over a
+			// circuit-relay (limited) connection — the steady-state path for
+			// browsers and NATed peers. Without it, the warm relay connection
+			// from a prior dialProtocol cannot be reused on subsequent RPCs.
+			return open.newStream([protocol], {
+				signal: options?.signal,
+				runOnLimitedConnection: true,
+				negotiateFully: false
+			})
 		}
-		const dialOptions = { runOnLimitedConnection: true, negotiateFully: false } as const
+		// Forward the caller's AbortSignal so a per-peer dial deadline (enforced
+		// upstream by ProtocolClient.processMessage) can actually cancel a stuck
+		// dial — without this, libp2p falls back to its built-in dial timeout
+		// (default ~30s) and the caller's tighter deadline is decorative.
+		const dialOptions = { runOnLimitedConnection: true, negotiateFully: false, signal: options?.signal } as const
 		return this.libp2p.dialProtocol(peerId, [protocol], dialOptions)
 	}
 
@@ -457,30 +472,73 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 		this.log('findCluster:start key=%s', keyStr);
 
 		// Include self in the cohort
-		const ids = Array.from(new Set([...cohort, this.libp2p.peerId.toString()]))
+		const selfId = this.libp2p.peerId.toString()
+		const ids = Array.from(new Set([...cohort, selfId]))
 
 		const connectedByPeer = this.getConnectedAddrsByPeer()
 		const connectedPeerIds = Object.keys(connectedByPeer)
 
+		// Backfill addresses from the peerStore for cohort members we don't have
+		// a live connection to. The cohort is keyspace-determined and can include
+		// peers we know-of but haven't dialed yet; without this backfill those
+		// would be silently dropped.
+		const peerStoreAddrs = await this.getPeerStoreAddrsByPeer(ids.filter(id => id !== selfId))
+
 		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 = {}
 
 		for (const idStr of ids) {
-			if (idStr === this.libp2p.peerId.toString()) {
+			if (idStr === selfId) {
 				const raw = this.libp2p.peerId.publicKey?.raw ?? new Uint8Array()
 				peers[idStr] = { multiaddrs: this.libp2p.getMultiaddrs().map(ma => ma.toString()), publicKey: u8ToString(raw, 'base64url') }
 				continue
 			}
-			const strings = connectedByPeer[idStr] ?? []
+			const connectedStrings = connectedByPeer[idStr] ?? []
+			const peerStoreStrings = peerStoreAddrs[idStr] ?? []
+			// De-duplicate while preserving connected-first ordering. The
+			// connected multiaddr is the one libp2p just used to reach this peer
+			// and is the most reliable; peerStore addrs are the fallback for
+			// cohort members we know-of but aren't currently connected to.
+			const merged = Array.from(new Set([...connectedStrings, ...peerStoreStrings]))
+			const parsed = this.parseMultiaddrs(merged)
 			const remotePeerId = peerIdFromString(idStr)
 			const raw = remotePeerId.publicKey?.raw ?? new Uint8Array()
-			peers[idStr] = { multiaddrs: this.parseMultiaddrs(strings), publicKey: u8ToString(raw, 'base64url') }
+			// Note: parsed may be empty for a cohort member we have neither a
+			// live connection to nor a peerStore entry for. The dial will then
+			// surface as `code=none msg="no valid addresses"` and the caller's
+			// retry/exclude logic takes over — we intentionally do NOT drop
+			// addressless members here, because shrinking the cohort below
+			// `clusterSize` puts consensus supermajority out of reach.
+			peers[idStr] = { multiaddrs: parsed, publicKey: u8ToString(raw, 'base64url') }
 		}
 
 		this.log('findCluster:done key=%s ms=%d peers=%d',
 			keyStr, Date.now() - t0, Object.keys(peers).length)
 		return peers
 	}
+
+	/**
+	 * Look up the libp2p peerStore for known multiaddrs of the given peer ids.
+	 * Returns a map from peer-id string to multiaddr strings — empty/missing
+	 * when the peerStore has no entry. Errors are swallowed; we'd rather fail
+	 * back to the defense-in-depth drop than throw out of findCluster.
+	 */
+	private async getPeerStoreAddrsByPeer(ids: string[]): Promise<Record<string, string[]>> {
+		const out: Record<string, string[]> = {}
+		const store = (this.libp2p as { peerStore?: { get?: (id: PeerId) => Promise<{ addresses?: Array<{ multiaddr: { toString(): string } }> }> } }).peerStore
+		if (!store?.get) return out
+		await Promise.all(ids.map(async (idStr) => {
+			try {
+				const pid = peerIdFromString(idStr)
+				const peer = await store.get!(pid)
+				const addrs = (peer?.addresses ?? []).map(a => a.multiaddr.toString())
+				if (addrs.length > 0) out[idStr] = addrs
+			} catch {
+				// Unknown peer or peerStore failure — leave out of the map.
+			}
+		}))
+		return out
+	}
 }