@streamr/trackerless-network 100.0.0-pretestnet.4 → 100.0.0-rc.0

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

@@ -1,26 +1,38 @@
-import { Empty } from '../../proto/google/protobuf/empty'
-import { InterleaveNotice, StreamPartHandshakeRequest, StreamPartHandshakeResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { 
+    InterleaveRequest,
+    InterleaveResponse,
+    StreamPartHandshakeRequest,
+    StreamPartHandshakeResponse
+} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { NodeList } from '../NodeList'
-import { ConnectionLocker, DhtCallContext, PeerDescriptor } from '@streamr/dht'
+import {
+    DhtAddress,
+    DhtAddressRaw,
+    DhtCallContext,
+    PeerDescriptor,
+    getDhtAddressFromRaw,
+    getNodeIdFromPeerDescriptor
+} from '@streamr/dht'
 import { IHandshakeRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { HandshakeRpcRemote } from './HandshakeRpcRemote'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
-import { binaryToHex } from '@streamr/utils'
+import { Logger } from '@streamr/utils'
 import { StreamPartID } from '@streamr/protocol'
 
 interface HandshakeRpcLocalConfig {
     streamPartId: StreamPartID
-    targetNeighbors: NodeList
-    connectionLocker: ConnectionLocker
-    ongoingHandshakes: Set<NodeID>
+    neighbors: NodeList
+    ongoingHandshakes: Set<DhtAddress>
+    ongoingInterleaves: Set<DhtAddress>
     maxNeighborCount: number
     createRpcRemote: (target: PeerDescriptor) => HandshakeRpcRemote
     createDeliveryRpcRemote: (peerDescriptor: PeerDescriptor) => DeliveryRpcRemote
-    handshakeWithInterleaving: (target: PeerDescriptor, senderId: NodeID) => Promise<boolean>
+    handshakeWithInterleaving: (target: PeerDescriptor, senderId: DhtAddress) => Promise<boolean>
 }
 
+const logger = new Logger(module)
+
 export class HandshakeRpcLocal implements IHandshakeRpc {
 
     private readonly config: HandshakeRpcLocalConfig
@@ -35,14 +47,22 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
 
     private handleRequest(request: StreamPartHandshakeRequest, context: ServerCallContext): StreamPartHandshakeResponse {
         const senderDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const getInterleaveSourceIds = () => (request.interleaveSourceId !== undefined) ? [binaryToHex(request.interleaveSourceId) as NodeID] : []
-        if (this.config.targetNeighbors.hasNode(senderDescriptor)
-            || this.config.ongoingHandshakes.has(getNodeIdFromPeerDescriptor(senderDescriptor))
+        const getInterleaveSourceIds = () => (request.interleaveSourceId !== undefined) ? [getDhtAddressFromRaw(request.interleaveSourceId)] : []
+        const senderNodeId = getNodeIdFromPeerDescriptor(senderDescriptor)
+        if (this.config.ongoingInterleaves.has(senderNodeId)) {
+            return this.rejectHandshake(request)
+        } else if (this.config.neighbors.has(senderNodeId)
+            || this.config.ongoingHandshakes.has(senderNodeId)
         ) {
             return this.acceptHandshake(request, senderDescriptor)
-        } else if (this.config.targetNeighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount) {
+        } else if (this.config.neighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount) {
             return this.acceptHandshake(request, senderDescriptor)
-        } else if (this.config.targetNeighbors.size(getInterleaveSourceIds()) >= 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)
         } else {
             return this.rejectHandshake(request)
@@ -54,8 +74,7 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
             requestId: request.requestId,
             accepted: true
         }
-        this.config.targetNeighbors.add(this.config.createDeliveryRpcRemote(requester))
-        this.config.connectionLocker.lockConnection(requester, this.config.streamPartId)
+        this.config.neighbors.add(this.config.createDeliveryRpcRemote(requester))
         return res
     }
 
@@ -69,38 +88,53 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
     }
 
     private acceptHandshakeWithInterleaving(request: StreamPartHandshakeRequest, requester: PeerDescriptor): StreamPartHandshakeResponse {
-        const exclude = request.neighborIds.map((id: Uint8Array) => binaryToHex(id) as NodeID)
+        const exclude: DhtAddress[] = []
+        request.neighborIds.forEach((id: DhtAddressRaw) => exclude.push(getDhtAddressFromRaw(id)))
+        this.config.ongoingInterleaves.forEach((id) => exclude.push(id))
         exclude.push(getNodeIdFromPeerDescriptor(requester))
         if (request.interleaveSourceId !== undefined) {
-            exclude.push(binaryToHex(request.interleaveSourceId) as NodeID)
+            exclude.push(getDhtAddressFromRaw(request.interleaveSourceId))
         }
-        const furthest = this.config.targetNeighbors.getFurthest(exclude)
-        const furthestPeerDescriptor = furthest ? furthest.getPeerDescriptor() : undefined
-        if (furthest) {
-            const remote = this.config.createRpcRemote(furthest.getPeerDescriptor())
-            remote.interleaveNotice(requester)
-            this.config.targetNeighbors.remove(furthest.getPeerDescriptor())
-            this.config.connectionLocker.unlockConnection(furthestPeerDescriptor!, this.config.streamPartId)
+        const last = this.config.neighbors.getLast(exclude)
+        const lastPeerDescriptor = last ? last.getPeerDescriptor() : undefined
+        if (last) {
+            const nodeId = getNodeIdFromPeerDescriptor(last.getPeerDescriptor())
+            const remote = this.config.createRpcRemote(last.getPeerDescriptor())
+            this.config.ongoingInterleaves.add(nodeId)
+            // Run this with then catch instead of setImmediate to avoid changes in state
+            // eslint-disable-next-line promise/catch-or-return
+            remote.interleaveRequest(requester).then((response) => {
+                // If response is accepted, remove the last node from the target neighbors
+                // and unlock the connection
+                // If response is not accepted, keep the last node as a neighbor
+                if (response.accepted) {
+                    this.config.neighbors.remove(getNodeIdFromPeerDescriptor(lastPeerDescriptor!))
+                }
+                return
+            }).catch(() => {
+                // no-op: InterleaveRequest cannot reject
+            }).finally(() => {
+                this.config.ongoingInterleaves.delete(nodeId)
+            })
         }
-        this.config.targetNeighbors.add(this.config.createDeliveryRpcRemote(requester))
-        this.config.connectionLocker.lockConnection(requester, this.config.streamPartId)
+        this.config.neighbors.add(this.config.createDeliveryRpcRemote(requester))
         return {
             requestId: request.requestId,
             accepted: true,
-            interleaveTargetDescriptor: furthestPeerDescriptor
+            interleaveTargetDescriptor: lastPeerDescriptor
         }
     }
 
-    async interleaveNotice(message: InterleaveNotice, context: ServerCallContext): Promise<Empty> {
-        if (message.streamPartId === this.config.streamPartId) {
-            const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-            const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
-            if (this.config.targetNeighbors.hasNodeById(senderId)) {
-                this.config.connectionLocker.unlockConnection(senderPeerDescriptor, this.config.streamPartId)
-                this.config.targetNeighbors.remove(senderPeerDescriptor)
-            }
-            this.config.handshakeWithInterleaving(message.interleaveTargetDescriptor!, senderId).catch((_e) => {})
+    async interleaveRequest(message: InterleaveRequest, context: ServerCallContext): Promise<InterleaveResponse> {
+        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
+        const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
+        try {
+            await this.config.handshakeWithInterleaving(message.interleaveTargetDescriptor!, senderId)
+            this.config.neighbors.remove(senderId)
+            return { accepted: true }
+        } catch (err) {
+            logger.debug(`interleaveRequest to ${getNodeIdFromPeerDescriptor(message.interleaveTargetDescriptor!)} failed: ${err}`)
+            return { accepted: false }
         }
-        return Empty
     }
 }

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

@@ -1,9 +1,9 @@
-import { PeerDescriptor, Remote } from '@streamr/dht'
-import { Logger, hexToBinary } from '@streamr/utils'
+import { DhtAddress, PeerDescriptor, RpcRemote, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '@streamr/dht'
+import { Logger } from '@streamr/utils'
 import { v4 } from 'uuid'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
-import { InterleaveNotice, StreamPartHandshakeRequest } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { IHandshakeRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { InterleaveRequest, InterleaveResponse, StreamPartHandshakeRequest } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { HandshakeRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { StreamPartID } from '@streamr/protocol'
 
 const logger = new Logger(module)
 
@@ -12,19 +12,22 @@ interface HandshakeResponse {
     interleaveTargetDescriptor?: PeerDescriptor
 }
 
-export class HandshakeRpcRemote extends Remote<IHandshakeRpcClient> {
+export const INTERLEAVE_REQUEST_TIMEOUT = 15000
+
+export class HandshakeRpcRemote extends RpcRemote<HandshakeRpcClient> {
 
     async handshake(
-        neighborIds: NodeID[],
-        concurrentHandshakeTargetId?: NodeID,
-        interleaveSourceId?: NodeID
+        streamPartId: StreamPartID,
+        neighborIds: DhtAddress[],
+        concurrentHandshakeTargetId?: DhtAddress,
+        interleaveSourceId?: DhtAddress
     ): Promise<HandshakeResponse> {
         const request: StreamPartHandshakeRequest = {
-            streamPartId: this.getServiceId(),
+            streamPartId,
             requestId: v4(),
-            neighborIds: neighborIds.map((id) => hexToBinary(id)),
-            concurrentHandshakeTargetId: (concurrentHandshakeTargetId !== undefined) ? hexToBinary(concurrentHandshakeTargetId) : undefined,
-            interleaveSourceId: (interleaveSourceId !== undefined) ? hexToBinary(interleaveSourceId) : undefined
+            neighborIds: neighborIds.map((id) => getRawFromDhtAddress(id)),
+            concurrentHandshakeTargetId: (concurrentHandshakeTargetId !== undefined) ? getRawFromDhtAddress(concurrentHandshakeTargetId) : undefined,
+            interleaveSourceId: (interleaveSourceId !== undefined) ? getRawFromDhtAddress(interleaveSourceId) : undefined
         }
         try {
             const response = await this.getClient().handshake(request, this.formDhtRpcOptions())
@@ -40,16 +43,25 @@ export class HandshakeRpcRemote extends Remote<IHandshakeRpcClient> {
         }
     }
 
-    interleaveNotice(originatorDescriptor: PeerDescriptor): void {
-        const notification: InterleaveNotice = {
-            streamPartId: this.getServiceId(),
+    async interleaveRequest(originatorDescriptor: PeerDescriptor): Promise<InterleaveResponse> {
+        const request: InterleaveRequest = {
             interleaveTargetDescriptor: originatorDescriptor
         }
         const options = this.formDhtRpcOptions({
-            notification: true
-        })
-        this.getClient().interleaveNotice(notification, options).catch(() => {
-            logger.debug('Failed to send interleaveNotice')
+            connect: false,
+            timeout: INTERLEAVE_REQUEST_TIMEOUT
         })
+        try {
+            const res = await this.getClient().interleaveRequest(request, options)
+            return {
+                accepted: res.accepted
+            }
+        } catch (err) {
+            logger.debug(`interleaveRequest to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed: ${err}`)
+            return {
+                accepted: false
+            }
+        }
+        
     }
 }

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

@@ -1,32 +1,32 @@
-import { ConnectionLocker, PeerDescriptor } from '@streamr/dht'
+import { DhtAddress, PeerDescriptor, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { NodeList } from '../NodeList'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
-import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
 import {
-    HandshakeRpcClient,
-    IHandshakeRpcClient, DeliveryRpcClient
+    DeliveryRpcClient, HandshakeRpcClient
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import {
-    InterleaveNotice,
+    InterleaveRequest,
+    InterleaveResponse,
     StreamPartHandshakeRequest,
     StreamPartHandshakeResponse
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { Logger } from '@streamr/utils'
 import { IHandshakeRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { HandshakeRpcRemote } from './HandshakeRpcRemote'
+import { HandshakeRpcRemote, INTERLEAVE_REQUEST_TIMEOUT } from './HandshakeRpcRemote'
 import { HandshakeRpcLocal } from './HandshakeRpcLocal'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { StreamPartID } from '@streamr/protocol'
 
 interface HandshakerConfig {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
-    connectionLocker: ConnectionLocker
-    targetNeighbors: NodeList
+    neighbors: NodeList
+    leftNodeView: NodeList
+    rightNodeView: NodeList
     nearbyNodeView: NodeList
     randomNodeView: NodeList
-    rpcCommunicator: RpcCommunicator
+    rpcCommunicator: ListeningRpcCommunicator
     maxNeighborCount: number
+    ongoingHandshakes: Set<DhtAddress>
     rpcRequestTimeout?: number
 }
 
@@ -34,75 +34,93 @@ const logger = new Logger(module)
 
 const PARALLEL_HANDSHAKE_COUNT = 2
 
-export interface IHandshaker {
-    attemptHandshakesOnContacts(excludedIds: NodeID[]): Promise<NodeID[]>
-    getOngoingHandshakes(): Set<NodeID>
-}
-
-export class Handshaker implements IHandshaker {
+export class Handshaker {
 
-    private readonly ongoingHandshakes: Set<NodeID> = new Set()
     private config: HandshakerConfig
-    private readonly client: ProtoRpcClient<IHandshakeRpcClient>
     private readonly rpcLocal: IHandshakeRpc
 
     constructor(config: HandshakerConfig) {
         this.config = config
-        this.client = toProtoRpcClient(new HandshakeRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
         this.rpcLocal = new HandshakeRpcLocal({
             streamPartId: this.config.streamPartId,
-            targetNeighbors: this.config.targetNeighbors,
-            connectionLocker: this.config.connectionLocker,
-            ongoingHandshakes: this.ongoingHandshakes,
+            neighbors: this.config.neighbors,
+            ongoingHandshakes: this.config.ongoingHandshakes,
+            ongoingInterleaves: new Set(),
             maxNeighborCount: this.config.maxNeighborCount,
-            handshakeWithInterleaving: (target: PeerDescriptor, senderId: NodeID) => this.handshakeWithInterleaving(target, senderId),
+            handshakeWithInterleaving: (target: PeerDescriptor, senderId: DhtAddress) => this.handshakeWithInterleaving(target, senderId),
             createRpcRemote: (target: PeerDescriptor) => this.createRpcRemote(target),
             createDeliveryRpcRemote: (target: PeerDescriptor) => this.createDeliveryRpcRemote(target)
         })
-        this.config.rpcCommunicator.registerRpcNotification(InterleaveNotice, 'interleaveNotice',
-            (req: InterleaveNotice, context) => this.rpcLocal.interleaveNotice(req, context))
+        this.config.rpcCommunicator.registerRpcMethod(InterleaveRequest, InterleaveResponse, 'interleaveRequest',
+            (req: InterleaveRequest, context) => this.rpcLocal.interleaveRequest(req, context), { timeout: INTERLEAVE_REQUEST_TIMEOUT })
         this.config.rpcCommunicator.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake',
             (req: StreamPartHandshakeRequest, context) => this.rpcLocal.handshake(req, context))
     }
 
-    async attemptHandshakesOnContacts(excludedIds: NodeID[]): Promise<NodeID[]> {
-        if (this.config.targetNeighbors.size() + this.ongoingHandshakes.size < this.config.maxNeighborCount - 2) {
+    async attemptHandshakesOnContacts(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
+        // TODO use config option or named constant? or why the value 2?
+        if (this.config.neighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount - 2) {
             logger.trace(`Attempting parallel handshakes with ${PARALLEL_HANDSHAKE_COUNT} targets`)
             return this.selectParallelTargetsAndHandshake(excludedIds)
-        } else if (this.config.targetNeighbors.size() + this.ongoingHandshakes.size < this.config.maxNeighborCount) {
+        } else if (this.config.neighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount) {
             logger.trace(`Attempting handshake with new target`)
             return this.selectNewTargetAndHandshake(excludedIds)
         }
         return excludedIds
     }
 
-    private async selectParallelTargetsAndHandshake(excludedIds: NodeID[]): Promise<NodeID[]> {
-        const exclude = excludedIds.concat(this.config.targetNeighbors.getIds())
-        const targetNeighbors = this.selectParallelTargets(exclude)
-        targetNeighbors.forEach((contact) => this.ongoingHandshakes.add(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
-        return this.doParallelHandshakes(targetNeighbors, exclude)
+    private async selectParallelTargetsAndHandshake(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
+        const exclude = excludedIds.concat(this.config.neighbors.getIds())
+        const neighbors = this.selectParallelTargets(exclude)
+        neighbors.forEach((contact) => this.config.ongoingHandshakes.add(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
+        return this.doParallelHandshakes(neighbors, exclude)
     }
 
-    private selectParallelTargets(excludedIds: NodeID[]): HandshakeRpcRemote[] {
-        const targetNeighbors = this.config.nearbyNodeView.getClosestAndFurthest(excludedIds)
-        while (targetNeighbors.length < PARALLEL_HANDSHAKE_COUNT && this.config.randomNodeView.size(excludedIds) > 0) {
-            const random = this.config.randomNodeView.getRandom(excludedIds)
+    private selectParallelTargets(excludedIds: DhtAddress[]): HandshakeRpcRemote[] {
+        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,
+            ...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.size < PARALLEL_HANDSHAKE_COUNT 
+            && this.config.randomNodeView.size(getExcludedFromRandomView()) > 0
+        ) {
+            const random = this.config.randomNodeView.getRandom([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
             if (random) {
-                targetNeighbors.push(random)
+                neighbors.set(getNodeIdFromPeerDescriptor(random.getPeerDescriptor()), random)
             }
         }
-        return targetNeighbors.map((neighbor) => this.createRpcRemote(neighbor.getPeerDescriptor()))
+        return Array.from(neighbors.values()).map((neighbor) => this.createRpcRemote(neighbor.getPeerDescriptor()))
     }
 
-    private async doParallelHandshakes(targets: HandshakeRpcRemote[], excludedIds: NodeID[]): Promise<NodeID[]> {
+    private async doParallelHandshakes(targets: HandshakeRpcRemote[], excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
         const results = await Promise.allSettled(
             Array.from(targets.values()).map(async (target: HandshakeRpcRemote, i) => {
                 const otherNode = i === 0 ? targets[1] : targets[0]
+                // TODO better check (currently this condition is always true)
                 const otherNodeId = otherNode ? getNodeIdFromPeerDescriptor(otherNode.getPeerDescriptor()) : undefined
                 return this.handshakeWithTarget(target, otherNodeId)
             })
         )
-        results.map((res, i) => {
+        results.forEach((res, i) => {
             if (res.status !== 'fulfilled' || !res.value) {
                 excludedIds.push(getNodeIdFromPeerDescriptor(targets[i].getPeerDescriptor()))
             }
@@ -110,56 +128,53 @@ export class Handshaker implements IHandshaker {
         return excludedIds
     }
 
-    private async selectNewTargetAndHandshake(excludedIds: NodeID[]): Promise<NodeID[]> {
-        const exclude = excludedIds.concat(this.config.targetNeighbors.getIds())
-        const targetNeighbor = this.config.nearbyNodeView.getClosest(exclude) ?? this.config.randomNodeView.getRandom(exclude)
-        if (targetNeighbor) {
-            const accepted = await this.handshakeWithTarget(this.createRpcRemote(targetNeighbor.getPeerDescriptor()))
+    private async selectNewTargetAndHandshake(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
+        const exclude = excludedIds.concat(this.config.neighbors.getIds())
+        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) {
-                excludedIds.push(getNodeIdFromPeerDescriptor(targetNeighbor.getPeerDescriptor()))
+                excludedIds.push(getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor()))
             }
         }
         return excludedIds
     }
 
-    private async handshakeWithTarget(targetNeighbor: HandshakeRpcRemote, concurrentNodeId?: NodeID): Promise<boolean> {
-        const targetNodeId = getNodeIdFromPeerDescriptor(targetNeighbor.getPeerDescriptor())
-        this.ongoingHandshakes.add(targetNodeId)
-        const result = await targetNeighbor.handshake(
-            this.config.targetNeighbors.getIds(),
+    private async handshakeWithTarget(neighbor: HandshakeRpcRemote, concurrentNodeId?: DhtAddress): Promise<boolean> {
+        const targetNodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
+        this.config.ongoingHandshakes.add(targetNodeId)
+        const result = await neighbor.handshake(
+            this.config.streamPartId,
+            this.config.neighbors.getIds(),
             concurrentNodeId
         )
         if (result.accepted) {
-            this.config.targetNeighbors.add(this.createDeliveryRpcRemote(targetNeighbor.getPeerDescriptor()))
-            this.config.connectionLocker.lockConnection(targetNeighbor.getPeerDescriptor(), this.config.streamPartId)
+            this.config.neighbors.add(this.createDeliveryRpcRemote(neighbor.getPeerDescriptor()))
         }
         if (result.interleaveTargetDescriptor) {
             await this.handshakeWithInterleaving(result.interleaveTargetDescriptor, targetNodeId)
         }
-        this.ongoingHandshakes.delete(targetNodeId)
+        this.config.ongoingHandshakes.delete(targetNodeId)
         return result.accepted
     }
 
-    private async handshakeWithInterleaving(target: PeerDescriptor, interleaveSourceId: NodeID): Promise<boolean> {
-        const targetNeighbor = new HandshakeRpcRemote(
-            this.config.localPeerDescriptor,
-            target,
+    private async handshakeWithInterleaving(target: PeerDescriptor, interleaveSourceId: DhtAddress): Promise<boolean> {
+        const neighbor = this.createRpcRemote(target)
+        const targetNodeId = getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())
+        this.config.ongoingHandshakes.add(targetNodeId)
+        const result = await neighbor.handshake(
             this.config.streamPartId,
-            this.client,
-            this.config.rpcRequestTimeout
-        )
-        const targetNodeId = getNodeIdFromPeerDescriptor(targetNeighbor.getPeerDescriptor())
-        this.ongoingHandshakes.add(targetNodeId)
-        const result = await targetNeighbor.handshake(
-            this.config.targetNeighbors.getIds(),
+            this.config.neighbors.getIds(),
             undefined,
             interleaveSourceId
         )
         if (result.accepted) {
-            this.config.targetNeighbors.add(this.createDeliveryRpcRemote(targetNeighbor.getPeerDescriptor()))
-            this.config.connectionLocker.lockConnection(targetNeighbor.getPeerDescriptor(), this.config.streamPartId)
+            this.config.neighbors.add(this.createDeliveryRpcRemote(neighbor.getPeerDescriptor()))
         }
-        this.ongoingHandshakes.delete(targetNodeId)
+        this.config.ongoingHandshakes.delete(targetNodeId)
         return result.accepted
     }
 
@@ -167,8 +182,8 @@ export class Handshaker implements IHandshaker {
         return new HandshakeRpcRemote(
             this.config.localPeerDescriptor,
             targetPeerDescriptor,
-            this.config.streamPartId,
-            this.client,
+            this.config.rpcCommunicator,
+            HandshakeRpcClient,
             this.config.rpcRequestTimeout
         )
     }
@@ -177,14 +192,14 @@ export class Handshaker implements IHandshaker {
         return new DeliveryRpcRemote(
             this.config.localPeerDescriptor,
             targetPeerDescriptor,
-            this.config.streamPartId,
-            toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport())),
+            this.config.rpcCommunicator,
+            DeliveryRpcClient,
             this.config.rpcRequestTimeout
         )
     }
 
-    getOngoingHandshakes(): Set<NodeID> {
-        return this.ongoingHandshakes
+    getOngoingHandshakes(): Set<DhtAddress> {
+        return this.config.ongoingHandshakes
     }
 
 }

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

@@ -1,24 +1,21 @@
 import { setAbortableTimeout } from '@streamr/utils'
 import { NodeList } from '../NodeList'
-import { NodeID } from '../../identifiers'
+import { DhtAddress } from '@streamr/dht'
 
 interface FindNeighborsSessionConfig {
-    targetNeighbors: NodeList
+    neighbors: NodeList
     nearbyNodeView: NodeList
-    doFindNeighbors: (excludedNodes: NodeID[]) => Promise<NodeID[]>
+    leftNodeView: NodeList
+    rightNodeView: NodeList
+    randomNodeView: NodeList
+    doFindNeighbors: (excludedNodes: DhtAddress[]) => Promise<DhtAddress[]>
     minCount: number
 }
 
 const INITIAL_WAIT = 100
 const INTERVAL = 250
 
-export interface INeighborFinder {
-    start(excluded?: NodeID[]): void
-    stop(): void
-    isRunning(): boolean
-}
-
-export class NeighborFinder implements INeighborFinder {
+export class NeighborFinder {
     private readonly abortController: AbortController
     private readonly config: FindNeighborsSessionConfig
     private running = false
@@ -28,12 +25,19 @@ export class NeighborFinder implements INeighborFinder {
         this.abortController = new AbortController()
     }
 
-    private async findNeighbors(excluded: NodeID[]): Promise<void> {
+    private async findNeighbors(excluded: DhtAddress[]): Promise<void> {
         if (!this.running) {
             return
         }
         const newExcludes = await this.config.doFindNeighbors(excluded)
-        if (this.config.targetNeighbors.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 {
             this.running = false
@@ -44,11 +48,12 @@ export class NeighborFinder implements INeighborFinder {
         return this.running
     }
 
-    start(excluded: NodeID[] = []): void {
+    start(excluded: DhtAddress[] = []): void {
         if (this.running) {
             return
         }
         this.running = true
+        // TODO should we catch possible promise rejection?
         setAbortableTimeout(() => this.findNeighbors(excluded), INITIAL_WAIT, this.abortController.signal)
     }