@streamr/trackerless-network 100.0.0-testnet-three.6 → 100.0.0

package/src/NetworkStack.ts

@@ -1,4 +1,4 @@
-import { 
+import {
     ConnectionManager,
     DhtNode,
     DhtNodeOptions,
@@ -6,15 +6,15 @@ import {
     PeerDescriptor,
     areEqualPeerDescriptors
 } from '@streamr/dht'
-import { StreamrNode, StreamrNodeConfig } from './logic/StreamrNode'
-import { Logger, MetricsContext, waitForCondition } from '@streamr/utils'
 import { StreamID, StreamPartID, toStreamPartID } from '@streamr/protocol'
-import { NodeInfoResponse, ProxyDirection, StreamMessage, StreamMessageType } from './proto/packages/trackerless-network/protos/NetworkRpc'
-import { Layer0Node } from './logic/Layer0Node'
+import { Logger, MetricsContext, waitForCondition } from '@streamr/utils'
 import { pull } from 'lodash'
-import { NODE_INFO_RPC_SERVICE_ID, NodeInfoRpcLocal } from './logic/node-info/NodeInfoRpcLocal'
+import { version as applicationVersion } from '../package.json'
+import { Layer0Node } from './logic/Layer0Node'
+import { StreamrNode, StreamrNodeConfig } from './logic/StreamrNode'
 import { NodeInfoClient } from './logic/node-info/NodeInfoClient'
-import { version as localVersion } from '../package.json'
+import { NODE_INFO_RPC_SERVICE_ID, NodeInfoRpcLocal } from './logic/node-info/NodeInfoRpcLocal'
+import { NodeInfoResponse, ProxyDirection, StreamMessage } from './proto/packages/trackerless-network/protos/NetworkRpc'
 
 export interface NetworkOptions {
     layer0?: DhtNodeOptions
@@ -90,7 +90,7 @@ export class NetworkStack {
 
     async broadcast(msg: StreamMessage): Promise<void> {
         const streamPartId = toStreamPartID(msg.messageId!.streamId as StreamID, msg.messageId!.streamPartition)
-        if (this.getStreamrNode().isProxiedStreamPart(streamPartId, ProxyDirection.SUBSCRIBE) && (msg.messageType === StreamMessageType.MESSAGE)) {
+        if (this.getStreamrNode().isProxiedStreamPart(streamPartId, ProxyDirection.SUBSCRIBE) && (msg.body.oneofKind === 'contentMessage')) {
             throw new Error(`Cannot broadcast to ${streamPartId} as proxy subscribe connections have been set`)
         }
         // TODO could combine these two calls to isProxiedStreamPart?
@@ -168,7 +168,7 @@ export class NetworkStack {
                 neighbors: this.getLayer0Node().getNeighbors()
             },
             streamPartitions: this.getStreamrNode().getNodeInfo(),
-            version: localVersion
+            version: applicationVersion
         }
     }
 

package/src/exports.ts

@@ -1,9 +1,13 @@
 export { NetworkStack, NetworkOptions, NodeInfo } from './NetworkStack'
 export { NetworkNode, createNetworkNode } from './NetworkNode'
 export { StreamrNodeConfig } from './logic/StreamrNode'
-export { ProxyDirection } from './proto/packages/trackerless-network/protos/NetworkRpc'
+export { ProxyDirection, GroupKeyRequest, GroupKeyResponse } from './proto/packages/trackerless-network/protos/NetworkRpc'
 export { streamPartIdToDataKey } from './logic/EntryPointDiscovery'
 export {
     convertStreamMessageToBytes,
-    convertBytesToStreamMessage
+    convertBytesToStreamMessage,
+    convertGroupKeyRequestToBytes,
+    convertBytesToGroupKeyRequest,
+    convertGroupKeyResponseToBytes,
+    convertBytesToGroupKeyResponse
 } from './logic/protocol-integration/stream-message/oldStreamMessageBinaryUtils'

package/src/logic/EntryPointDiscovery.ts

@@ -13,7 +13,7 @@ import { Any } from '../proto/google/protobuf/any'
 import { Layer1Node } from './Layer1Node'
 
 export const streamPartIdToDataKey = (streamPartId: StreamPartID): DhtAddress => {
-    return getDhtAddressFromRaw(new Uint8Array(createHash('md5').update(streamPartId).digest()))
+    return getDhtAddressFromRaw(new Uint8Array((createHash('sha1').update(streamPartId).digest())))
 }
 
 const parseEntryPointData = (dataEntries: DataEntry[]): PeerDescriptor[] => {
@@ -60,7 +60,7 @@ interface EntryPointDiscoveryConfig {
     streamPartId: StreamPartID
     localPeerDescriptor: PeerDescriptor
     layer1Node: Layer1Node
-    getEntryPointData: (key: DhtAddress) => Promise<DataEntry[]>
+    fetchEntryPointData: (key: DhtAddress) => Promise<DataEntry[]>
     storeEntryPointData: (key: DhtAddress, data: Any) => Promise<PeerDescriptor[]>
     deleteEntryPointData: (key: DhtAddress) => Promise<void>
     storeInterval?: number
@@ -111,7 +111,7 @@ export class EntryPointDiscovery {
     private async queryEntrypoints(key: DhtAddress): Promise<PeerDescriptor[]> {
         logger.trace(`Finding data from dht node ${getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)}`)
         try {
-            const result = await this.config.getEntryPointData(key)
+            const result = await this.config.fetchEntryPointData(key)
             return parseEntryPointData(result)
         } catch (err) {
             return []

package/src/logic/Layer0Node.ts

@@ -5,7 +5,7 @@ export interface Layer0Node extends ITransport {
     joinDht(entryPointDescriptors: PeerDescriptor[]): Promise<void>
     hasJoined(): boolean
     getLocalPeerDescriptor(): PeerDescriptor
-    getDataFromDht(key: DhtAddress): Promise<DataEntry[]>
+    fetchDataFromDht(key: DhtAddress): Promise<DataEntry[]>
     storeDataToDht(key: DhtAddress, data: Any): Promise<PeerDescriptor[]>
     deleteDataFromDht(key: DhtAddress, waitForCompletion: boolean): Promise<void>
     waitForNetworkConnectivity(): Promise<void>

package/src/logic/Layer1Node.ts

@@ -1,21 +1,36 @@
-import { DhtAddress, PeerDescriptor } from '@streamr/dht'
+import { DhtAddress, PeerDescriptor, RingContacts } from '@streamr/dht'
 
 export interface Layer1NodeEvents {
     contactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     contactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     randomContactAdded: (peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => void
     randomContactRemoved: (peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => void
+    ringContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
+    ringContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
 }
 
 export interface Layer1Node {
     on<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
     once<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
     off<T extends keyof Layer1NodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, peers: PeerDescriptor[]) => void): void
+    on<T extends keyof Layer1NodeEvents>(
+        eventName: T,
+        listener: (peerDescriptor: PeerDescriptor, peers: RingContacts) => void
+    ): void
+    once<T extends keyof Layer1NodeEvents>(
+        eventName: T, 
+        listener: (peerDescriptor: PeerDescriptor, peers: RingContacts) => void
+    ): void
+    off<T extends keyof Layer1NodeEvents>(
+        eventName: T,
+        listener: (peerDescriptor: PeerDescriptor, peers: RingContacts
+    ) => void): void
     removeContact: (nodeId: DhtAddress) => void
     getClosestContacts: (maxCount?: number) => PeerDescriptor[]
     getNeighbors: () => PeerDescriptor[]
     getNeighborCount(): number
     joinDht: (entryPoints: PeerDescriptor[], doRandomJoin?: boolean, retry?: boolean) => Promise<void>
+    joinRing: () => Promise<void>
     start: () => Promise<void>
     stop: () => Promise<void>
 }

package/src/logic/NodeList.ts

@@ -4,7 +4,8 @@ import { DeliveryRpcRemote } from './DeliveryRpcRemote'
 import { EventEmitter } from 'eventemitter3'
 
 export interface Events {
-    nodeAdded: (id: DhtAddress, remote: DeliveryRpcRemote) => any
+    nodeAdded: (id: DhtAddress, remote: DeliveryRpcRemote) => void
+    nodeRemoved: (id: DhtAddress, remote: DeliveryRpcRemote) => void
 }
 
 const getValuesOfIncludedKeys = (nodes: Map<DhtAddress, DeliveryRpcRemote>, exclude: DhtAddress[]): DeliveryRpcRemote[] => {
@@ -40,13 +41,18 @@ export class NodeList extends EventEmitter<Events> {
     }
 
     remove(nodeId: DhtAddress): void {
-        this.nodes.delete(nodeId)
+        if (this.nodes.has(nodeId)) {
+            const remote = this.nodes.get(nodeId)!
+            this.nodes.delete(nodeId)
+            this.emit('nodeRemoved', nodeId, remote)
+        }   
     }
 
     has(nodeId: DhtAddress): boolean {
         return this.nodes.has(nodeId)
     }
 
+    // Replace nodes does not emit nodeRemoved events, use with caution
     replaceAll(neighbors: DeliveryRpcRemote[]): void {
         this.nodes.clear()
         const limited = neighbors.splice(0, this.limit)
@@ -94,7 +100,7 @@ export class NodeList extends EventEmitter<Events> {
     }
 
     stop(): void {
-        this.nodes.clear()
+        this.nodes.forEach((node) => this.remove(getNodeIdFromPeerDescriptor(node.getPeerDescriptor())))
         this.removeAllListeners()
     }
 }

package/src/logic/RandomGraphNode.ts

@@ -5,7 +5,8 @@ import {
     ITransport,
     ConnectionLocker,
     DhtAddress,
-    getNodeIdFromPeerDescriptor
+    getNodeIdFromPeerDescriptor,
+    RingContacts
 } from '@streamr/dht'
 import {
     StreamMessage,
@@ -50,6 +51,8 @@ export interface StrictRandomGraphNodeConfig {
     nodeViewSize: number
     nearbyNodeView: NodeList
     randomNodeView: NodeList
+    leftNodeView: NodeList
+    rightNodeView: NodeList
     neighbors: NodeList
     handshaker: Handshaker
     neighborFinder: NeighborFinder
@@ -92,13 +95,15 @@ export class RandomGraphNode extends EventEmitter<Events> {
                 const contact = this.config.nearbyNodeView.get(sourceId)
                 || this.config.randomNodeView.get(sourceId)
                 || this.config.neighbors.get(sourceId)
-                || this.config.proxyConnectionRpcLocal?.getConnection(sourceId )?.remote
+                || this.config.proxyConnectionRpcLocal?.getConnection(sourceId)?.remote
                 // TODO: check integrity of notifier?
                 if (contact) {
                     this.config.layer1Node.removeContact(sourceId)
                     this.config.neighbors.remove(sourceId)
                     this.config.nearbyNodeView.remove(sourceId)
-                    this.config.connectionLocker.unlockConnection(contact.getPeerDescriptor(), this.config.streamPartId)
+                    this.config.randomNodeView.remove(sourceId)
+                    this.config.leftNodeView.remove(sourceId)
+                    this.config.rightNodeView.remove(sourceId)
                     this.config.neighborFinder.start([sourceId])
                     this.config.proxyConnectionRpcLocal?.removeConnection(sourceId)
                 }
@@ -130,13 +135,29 @@ export class RandomGraphNode extends EventEmitter<Events> {
             'randomContactAdded',
             (_peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => this.onRandomContactAdded(randomPeers),
             this.abortController.signal
-        )   
+        )
         addManagedEventListener<any, any>(
             this.config.layer1Node as any,
             'randomContactRemoved',
             (_peerDescriptor: PeerDescriptor, randomPeers: PeerDescriptor[]) => this.onRandomContactRemoved(randomPeers),
             this.abortController.signal
-        )   
+        )
+        addManagedEventListener<any, any>(
+            this.config.layer1Node as any,
+            'ringContactAdded',
+            (_: PeerDescriptor, peers: RingContacts) => {
+                this.onRingContactEvent(peers)
+            },
+            this.abortController.signal
+        )
+        addManagedEventListener<any, any>(
+            this.config.layer1Node as any,
+            'ringContactRemoved',
+            (_: PeerDescriptor, peers: RingContacts) => {
+                this.onRingContactEvent(peers)
+            },
+            this.abortController.signal
+        )
         addManagedEventListener<any, any>(
             this.config.transport as any,
             'disconnected',
@@ -146,12 +167,27 @@ export class RandomGraphNode extends EventEmitter<Events> {
         addManagedEventListener(
             this.config.neighbors,
             'nodeAdded',
-            (id, _remote) => {
+            (id, remote) => {
                 this.config.propagation.onNeighborJoined(id)
+                this.config.connectionLocker.weakLockConnection(
+                    getNodeIdFromPeerDescriptor(remote.getPeerDescriptor()),
+                    this.config.streamPartId
+                )
                 this.emit('neighborConnected', id)
             },
             this.abortController.signal
         )
+        addManagedEventListener(
+            this.config.neighbors,
+            'nodeRemoved',
+            (_id, remote) => {
+                this.config.connectionLocker.weakUnlockConnection(
+                    getNodeIdFromPeerDescriptor(remote.getPeerDescriptor()),
+                    this.config.streamPartId
+                )
+            },
+            this.abortController.signal
+        )
         if (this.config.proxyConnectionRpcLocal !== undefined) {
             addManagedEventListener(
                 this.config.proxyConnectionRpcLocal,
@@ -179,6 +215,31 @@ export class RandomGraphNode extends EventEmitter<Events> {
             (req: TemporaryConnectionRequest, context) => this.config.temporaryConnectionRpcLocal.closeConnection(req, context))
     }
 
+    private onRingContactEvent(ringPeers: RingContacts): void {
+        logger.trace(`onRingContactAdded`)
+        if (this.isStopped()) {
+            return
+        }
+        this.config.leftNodeView.replaceAll(ringPeers.left.map((peer) => 
+            new DeliveryRpcRemote(
+                this.config.localPeerDescriptor,
+                peer,
+                this.config.rpcCommunicator,
+                DeliveryRpcClient,
+                this.config.rpcRequestTimeout
+            )
+        ))
+        this.config.rightNodeView.replaceAll(ringPeers.right.map((peer) =>
+            new DeliveryRpcRemote(
+                this.config.localPeerDescriptor,
+                peer,
+                this.config.rpcCommunicator,
+                DeliveryRpcClient,
+                this.config.rpcRequestTimeout
+            )
+        ))
+    }
+
     private onContactAdded(closestNodes: PeerDescriptor[]): void {
         logger.trace(`New nearby contact found`)
         if (this.isStopped()) {
@@ -263,7 +324,6 @@ export class RandomGraphNode extends EventEmitter<Events> {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         if (this.config.neighbors.has(nodeId)) {
             this.config.neighbors.remove(nodeId)
-            this.config.connectionLocker.unlockConnection(peerDescriptor, this.config.streamPartId)
             this.config.neighborFinder.start([nodeId])
             this.config.temporaryConnectionRpcLocal.removeNode(nodeId)
         }
@@ -293,9 +353,13 @@ export class RandomGraphNode extends EventEmitter<Events> {
         }
         this.abortController.abort()
         this.config.proxyConnectionRpcLocal?.stop()
-        this.config.neighbors.getAll().map(
-            (remote) => remote.leaveStreamPartNotice(this.config.streamPartId, this.config.isLocalNodeEntryPoint())
-        )
+        this.config.neighbors.getAll().map((remote) => {
+            remote.leaveStreamPartNotice(this.config.streamPartId, this.config.isLocalNodeEntryPoint())
+            this.config.connectionLocker.weakUnlockConnection(
+                getNodeIdFromPeerDescriptor(remote.getPeerDescriptor()),
+                this.config.streamPartId
+            )
+        })
         this.config.rpcCommunicator.destroy()
         this.removeAllListeners()
         this.config.nearbyNodeView.stop()

package/src/logic/StreamrNode.ts

@@ -113,8 +113,10 @@ export class StreamrNode extends EventEmitter<Events> {
         logger.debug(`Broadcasting to stream part ${streamPartId}`)
         this.joinStreamPart(streamPartId)
         this.streamParts.get(streamPartId)!.broadcast(msg)
-        this.metrics.broadcastMessagesPerSecond.record(1)
-        this.metrics.broadcastBytesPerSecond.record(msg.content.length)
+        if (msg.body.oneofKind === 'contentMessage') {
+            this.metrics.broadcastMessagesPerSecond.record(1)
+            this.metrics.broadcastBytesPerSecond.record(msg.body.contentMessage.content.length)
+        }
     }
 
     async leaveStreamPart(streamPartId: StreamPartID): Promise<void> {
@@ -136,7 +138,7 @@ export class StreamrNode extends EventEmitter<Events> {
             streamPartId,
             localPeerDescriptor: this.getPeerDescriptor(),
             layer1Node,
-            getEntryPointData: (key) => this.layer0Node!.getDataFromDht(key),
+            fetchEntryPointData: (key) => this.layer0Node!.fetchDataFromDht(key),
             storeEntryPointData: (key, data) => this.layer0Node!.storeDataToDht(key, data),
             deleteEntryPointData: async (key) => this.layer0Node!.deleteDataFromDht(key, false)
         })
@@ -192,7 +194,10 @@ export class StreamrNode extends EventEmitter<Events> {
             entryPoints.length
         )
         entryPoints = entryPoints.concat(discoveryResult.discoveredEntryPoints)
-        await streamPart.layer1Node.joinDht(sampleSize(entryPoints, NETWORK_SPLIT_AVOIDANCE_LIMIT))
+        await Promise.all([
+            streamPart.layer1Node.joinDht(sampleSize(entryPoints, NETWORK_SPLIT_AVOIDANCE_LIMIT)),
+            streamPart.layer1Node.joinRing()
+        ])
         if (discoveryResult.entryPointsFromDht) {
             await entryPointDiscovery.storeSelfAsEntryPointIfNecessary(entryPoints.length)
         }

package/src/logic/createRandomGraphNode.ts

@@ -13,7 +13,7 @@ import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryCon
 import { formStreamPartDeliveryServiceId } from './formStreamPartDeliveryServiceId'
 
 type RandomGraphNodeConfig = MarkOptional<StrictRandomGraphNodeConfig,
-    'nearbyNodeView' | 'randomNodeView' | 'neighbors' | 'propagation'
+    'nearbyNodeView' | 'randomNodeView' | 'neighbors' | 'leftNodeView' | 'rightNodeView' | 'propagation'
     | 'handshaker' | 'neighborFinder' | 'neighborUpdateManager' | 'neighborTargetCount'
     | 'rpcCommunicator' | 'nodeViewSize'
     | 'inspector' | 'temporaryConnectionRpcLocal'> & {
@@ -34,14 +34,18 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     const minPropagationTargets = config.minPropagationTargets ?? 2
     const acceptProxyConnections = config.acceptProxyConnections ?? false
     const neighborUpdateInterval = config.neighborUpdateInterval ?? 10000
+    const neighbors = config.neighbors ?? new NodeList(ownNodeId, maxContactCount)
+    const leftNodeView = config.leftNodeView ?? new NodeList(ownNodeId, maxContactCount)
+    const rightNodeView = config.rightNodeView ?? new NodeList(ownNodeId, maxContactCount)
     const nearbyNodeView = config.nearbyNodeView ?? new NodeList(ownNodeId, maxContactCount)
     const randomNodeView = config.randomNodeView ?? new NodeList(ownNodeId, maxContactCount)
-    const neighbors = config.neighbors ?? new NodeList(ownNodeId, maxContactCount)
     const ongoingHandshakes = new Set<DhtAddress>()
 
     const temporaryConnectionRpcLocal = new TemporaryConnectionRpcLocal({
         rpcCommunicator,
-        localPeerDescriptor: config.localPeerDescriptor
+        localPeerDescriptor: config.localPeerDescriptor,
+        streamPartId: config.streamPartId,
+        connectionLocker: config.connectionLocker
     })
     const proxyConnectionRpcLocal = acceptProxyConnections ? new ProxyConnectionRpcLocal({
         localPeerDescriptor: config.localPeerDescriptor,
@@ -65,18 +69,22 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     const handshaker = config.handshaker ?? new Handshaker({
         localPeerDescriptor: config.localPeerDescriptor,
         streamPartId: config.streamPartId,
-        connectionLocker: config.connectionLocker,
         rpcCommunicator,
+        neighbors,
+        leftNodeView,
+        rightNodeView,
         nearbyNodeView,
         randomNodeView,
-        neighbors,
         maxNeighborCount: neighborTargetCount,
         rpcRequestTimeout: config.rpcRequestTimeout,
         ongoingHandshakes
     })
     const neighborFinder = config.neighborFinder ?? new NeighborFinder({
         neighbors,
+        leftNodeView,
+        rightNodeView,
         nearbyNodeView,
+        randomNodeView,
         doFindNeighbors: (excludedIds) => handshaker.attemptHandshakesOnContacts(excludedIds),
         minCount: neighborTargetCount
     })
@@ -89,7 +97,6 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
         rpcCommunicator,
         neighborUpdateInterval,
         neighborTargetCount,
-        connectionLocker: config.connectionLocker,
         ongoingHandshakes
     })
     const inspector = config.inspector ?? new Inspector({
@@ -100,9 +107,11 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     })
     return {
         ...config,
+        neighbors,
+        leftNodeView,
+        rightNodeView,
         nearbyNodeView,
         randomNodeView,
-        neighbors,
         rpcCommunicator,
         handshaker,
         neighborFinder,

package/src/logic/inspect/Inspector.ts

@@ -48,7 +48,7 @@ export class Inspector {
             TemporaryConnectionRpcClient
         )
         await rpcRemote.openConnection()
-        this.connectionLocker.lockConnection(peerDescriptor, lockId)
+        this.connectionLocker.weakLockConnection(getNodeIdFromPeerDescriptor(peerDescriptor), lockId)
     }
 
     async defaultCloseInspectConnection(peerDescriptor: PeerDescriptor, lockId: LockID): Promise<void> {
@@ -59,7 +59,7 @@ export class Inspector {
             TemporaryConnectionRpcClient
         )
         await rpcRemote.closeConnection()
-        this.connectionLocker.unlockConnection(peerDescriptor, lockId)
+        this.connectionLocker.weakUnlockConnection(getNodeIdFromPeerDescriptor(peerDescriptor), lockId)
     }
 
     async inspect(peerDescriptor: PeerDescriptor): Promise<boolean> {

package/src/logic/neighbor-discovery/HandshakeRpcLocal.ts

@@ -7,7 +7,6 @@ import {
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { NodeList } from '../NodeList'
 import {
-    ConnectionLocker,
     DhtAddress,
     DhtAddressRaw,
     DhtCallContext,
@@ -24,7 +23,6 @@ import { StreamPartID } from '@streamr/protocol'
 interface HandshakeRpcLocalConfig {
     streamPartId: StreamPartID
     neighbors: NodeList
-    connectionLocker: ConnectionLocker
     ongoingHandshakes: Set<DhtAddress>
     ongoingInterleaves: Set<DhtAddress>
     maxNeighborCount: number
@@ -59,7 +57,10 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
             return this.acceptHandshake(request, senderDescriptor)
         } else if (this.config.neighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount) {
             return this.acceptHandshake(request, senderDescriptor)
-        } else if (this.config.neighbors.size(getInterleaveSourceIds()) - this.config.ongoingInterleaves.size >= 2) {
+        } else if (
+            this.config.neighbors.size(getInterleaveSourceIds()) - this.config.ongoingInterleaves.size >= 2
+            && this.config.neighbors.size() <= this.config.maxNeighborCount
+        ) {
             // Do not accept the handshakes requests if the target neighbor count can potentially drop below 2 
             // due to interleaving. This ensures that a stable number of connections is kept during high churn.
             return this.acceptHandshakeWithInterleaving(request, senderDescriptor)
@@ -74,7 +75,6 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
             accepted: true
         }
         this.config.neighbors.add(this.config.createDeliveryRpcRemote(requester))
-        this.config.connectionLocker.lockConnection(requester, this.config.streamPartId)
         return res
     }
 
@@ -109,7 +109,6 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
                 // If response is not accepted, keep the last node as a neighbor
                 if (response.accepted) {
                     this.config.neighbors.remove(getNodeIdFromPeerDescriptor(lastPeerDescriptor!))
-                    this.config.connectionLocker.unlockConnection(lastPeerDescriptor!, this.config.streamPartId)
                 }
                 return
             }).catch(() => {
@@ -119,7 +118,6 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
             })
         }
         this.config.neighbors.add(this.config.createDeliveryRpcRemote(requester))
-        this.config.connectionLocker.lockConnection(requester, this.config.streamPartId)
         return {
             requestId: request.requestId,
             accepted: true,
@@ -132,10 +130,7 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
         const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
         try {
             await this.config.handshakeWithInterleaving(message.interleaveTargetDescriptor!, senderId)
-            if (this.config.neighbors.has(senderId)) {
-                this.config.connectionLocker.unlockConnection(senderPeerDescriptor, this.config.streamPartId)
-                this.config.neighbors.remove(senderId)
-            }
+            this.config.neighbors.remove(senderId)
             return { accepted: true }
         } catch (err) {
             logger.debug(`interleaveRequest to ${getNodeIdFromPeerDescriptor(message.interleaveTargetDescriptor!)} failed: ${err}`)

package/src/logic/neighbor-discovery/Handshaker.ts

@@ -1,4 +1,4 @@
-import { ConnectionLocker, DhtAddress, PeerDescriptor, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { DhtAddress, PeerDescriptor, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { NodeList } from '../NodeList'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
 import {
@@ -19,8 +19,9 @@ import { StreamPartID } from '@streamr/protocol'
 interface HandshakerConfig {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
-    connectionLocker: ConnectionLocker
     neighbors: NodeList
+    leftNodeView: NodeList
+    rightNodeView: NodeList
     nearbyNodeView: NodeList
     randomNodeView: NodeList
     rpcCommunicator: ListeningRpcCommunicator
@@ -43,7 +44,6 @@ export class Handshaker {
         this.rpcLocal = new HandshakeRpcLocal({
             streamPartId: this.config.streamPartId,
             neighbors: this.config.neighbors,
-            connectionLocker: this.config.connectionLocker,
             ongoingHandshakes: this.config.ongoingHandshakes,
             ongoingInterleaves: new Set(),
             maxNeighborCount: this.config.maxNeighborCount,
@@ -77,19 +77,38 @@ export class Handshaker {
     }
 
     private selectParallelTargets(excludedIds: DhtAddress[]): HandshakeRpcRemote[] {
-        const neighbors = this.config.nearbyNodeView.getFirstAndLast(excludedIds)
+        const neighbors: Map<DhtAddress, DeliveryRpcRemote> = new Map()
+        // First add the closest left and then right contacts from the ring if possible.
+        const left = this.config.leftNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
+        const right = this.config.rightNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
+        if (left) {
+            neighbors.set(getNodeIdFromPeerDescriptor(left.getPeerDescriptor()), left)
+        }
+        if (right) {
+            neighbors.set(getNodeIdFromPeerDescriptor(right.getPeerDescriptor()), right)
+        }
+        // If there is still room add the closest contact based on the kademlia metric
+        if (neighbors.size < PARALLEL_HANDSHAKE_COUNT) {
+            const first = this.config.nearbyNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
+            if (first) {
+                neighbors.set(getNodeIdFromPeerDescriptor(first.getPeerDescriptor()), first)
+            }
+        }
         const getExcludedFromRandomView = () => [
             ...excludedIds,
-            ...neighbors.map((neighbor) => getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor()))
+            ...Array.from(neighbors.values()).map((neighbor) => getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor()))
         ]
+        // If there is still room add a random contact until PARALLEL_HANDSHAKE_COUNT is reached
         while (
-            neighbors.length < PARALLEL_HANDSHAKE_COUNT 
+            neighbors.size < PARALLEL_HANDSHAKE_COUNT 
             && this.config.randomNodeView.size(getExcludedFromRandomView()) > 0
         ) {
-            const random = this.config.randomNodeView.getRandom(getExcludedFromRandomView())!
-            neighbors.push(random)
+            const random = this.config.randomNodeView.getRandom([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
+            if (random) {
+                neighbors.set(getNodeIdFromPeerDescriptor(random.getPeerDescriptor()), random)
+            }
         }
-        return neighbors.map((neighbor) => this.createRpcRemote(neighbor.getPeerDescriptor()))
+        return Array.from(neighbors.values()).map((neighbor) => this.createRpcRemote(neighbor.getPeerDescriptor()))
     }
 
     private async doParallelHandshakes(targets: HandshakeRpcRemote[], excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
@@ -111,7 +130,10 @@ export class Handshaker {
 
     private async selectNewTargetAndHandshake(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
         const exclude = excludedIds.concat(this.config.neighbors.getIds())
-        const neighbor = this.config.nearbyNodeView.getFirst(exclude) ?? this.config.randomNodeView.getRandom(exclude)
+        const neighbor = this.config.leftNodeView.getFirst(exclude) 
+            ?? this.config.rightNodeView.getFirst(exclude)
+            ?? this.config.nearbyNodeView.getFirst(exclude)
+            ?? this.config.randomNodeView.getRandom(exclude)
         if (neighbor) {
             const accepted = await this.handshakeWithTarget(this.createRpcRemote(neighbor.getPeerDescriptor()))
             if (!accepted) {
@@ -131,7 +153,6 @@ export class Handshaker {
         )
         if (result.accepted) {
             this.config.neighbors.add(this.createDeliveryRpcRemote(neighbor.getPeerDescriptor()))
-            this.config.connectionLocker.lockConnection(neighbor.getPeerDescriptor(), this.config.streamPartId)
         }
         if (result.interleaveTargetDescriptor) {
             await this.handshakeWithInterleaving(result.interleaveTargetDescriptor, targetNodeId)
@@ -152,7 +173,6 @@ export class Handshaker {
         )
         if (result.accepted) {
             this.config.neighbors.add(this.createDeliveryRpcRemote(neighbor.getPeerDescriptor()))
-            this.config.connectionLocker.lockConnection(neighbor.getPeerDescriptor(), this.config.streamPartId)
         }
         this.config.ongoingHandshakes.delete(targetNodeId)
         return result.accepted

package/src/logic/neighbor-discovery/NeighborFinder.ts

@@ -5,6 +5,9 @@ import { DhtAddress } from '@streamr/dht'
 interface FindNeighborsSessionConfig {
     neighbors: NodeList
     nearbyNodeView: NodeList
+    leftNodeView: NodeList
+    rightNodeView: NodeList
+    randomNodeView: NodeList
     doFindNeighbors: (excludedNodes: DhtAddress[]) => Promise<DhtAddress[]>
     minCount: number
 }
@@ -27,7 +30,13 @@ export class NeighborFinder {
             return
         }
         const newExcludes = await this.config.doFindNeighbors(excluded)
-        if (this.config.neighbors.size() < this.config.minCount && newExcludes.length < this.config.nearbyNodeView.size()) {
+        const uniqueContactCount = new Set([
+            ...this.config.nearbyNodeView.getIds(),
+            ...this.config.leftNodeView.getIds(),
+            ...this.config.rightNodeView.getIds(),
+            ...this.config.randomNodeView.getIds()
+        ]).size
+        if (this.config.neighbors.size() < this.config.minCount && newExcludes.length < uniqueContactCount) {
             // TODO should we catch possible promise rejection?
             setAbortableTimeout(() => this.findNeighbors(newExcludes), INTERVAL, this.abortController.signal)
         } else {