@streamr/trackerless-network 102.0.0-beta.1 → 102.0.0-beta.2

package/src/logic/inspect/InspectSession.ts

@@ -1,55 +0,0 @@
-import { DhtAddress } from '@streamr/dht'
-import { toUserId } from '@streamr/utils'
-import { EventEmitter } from 'eventemitter3'
-import { MessageID } from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
-
-export interface Events {
-    done: () => void
-}
-
-interface InspectSessionOptions {
-    inspectedNode: DhtAddress
-}
-
-const createMessageKey = (messageId: MessageID): string => {
-    return `${toUserId(messageId.publisherId)}:${messageId.messageChainId}:${messageId.timestamp}:${messageId.sequenceNumber}`
-}
-
-export class InspectSession extends EventEmitter<Events> {
-    
-    // Boolean indicates if the message has been received by the inspected node
-    private readonly inspectionMessages: Map<string, boolean> = new Map()
-    private readonly inspectedNode: DhtAddress
-
-    constructor(options: InspectSessionOptions) {
-        super()
-        this.inspectedNode = options.inspectedNode
-    }
-
-    markMessage(remoteNodeId: DhtAddress, messageId: MessageID): void {
-        const messageKey = createMessageKey(messageId)
-        if (!this.inspectionMessages.has(messageKey)) {
-            this.inspectionMessages.set(messageKey, remoteNodeId === this.inspectedNode)
-        } else if (this.inspectionMessages.has(messageKey)
-            && this.inspectionMessages.get(messageKey) === false
-            && remoteNodeId === this.inspectedNode
-        ) {
-            this.emit('done')
-        } else if (this.inspectionMessages.has(messageKey)
-            && this.inspectionMessages.get(messageKey) === true) {
-            this.emit('done')
-        }
-    }
-
-    getInspectedMessageCount(): number {
-        return this.inspectionMessages.size
-    }
-
-    onlyMarkedByInspectedNode(): boolean {
-        return Array.from(this.inspectionMessages.values()).every((value) => value === true)
-    }
-
-    stop(): void {
-        this.emit('done')
-    }
-}

package/src/logic/inspect/Inspector.ts

@@ -1,100 +0,0 @@
-import { ConnectionLocker, DhtAddress, ListeningRpcCommunicator, LockID, PeerDescriptor, toNodeId } from '@streamr/dht'
-import { Logger, StreamPartID, waitForEvent3 } from '@streamr/utils'
-import { MessageID } from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { TemporaryConnectionRpcClient } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
-import { TemporaryConnectionRpcRemote } from '../temporary-connection/TemporaryConnectionRpcRemote'
-import { InspectSession, Events as InspectSessionEvents } from './InspectSession'
-
-interface InspectorOptions {
-    localPeerDescriptor: PeerDescriptor
-    streamPartId: StreamPartID
-    rpcCommunicator: ListeningRpcCommunicator
-    connectionLocker: ConnectionLocker
-    inspectionTimeout?: number
-    openInspectConnection?: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
-    closeInspectConnection?: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
-}
-
-const logger = new Logger(module)
-const DEFAULT_TIMEOUT = 60 * 1000
-
-export class Inspector {
-
-    private readonly sessions: Map<DhtAddress, InspectSession> = new Map()
-    private readonly streamPartId: StreamPartID
-    private readonly localPeerDescriptor: PeerDescriptor
-    private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly connectionLocker: ConnectionLocker
-    private readonly inspectionTimeout: number
-    private readonly openInspectConnection: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
-    private readonly closeInspectConnection: (peerDescriptor: PeerDescriptor, lockId: LockID) => Promise<void>
-
-    constructor(options: InspectorOptions) {
-        this.streamPartId = options.streamPartId
-        this.localPeerDescriptor = options.localPeerDescriptor
-        this.rpcCommunicator = options.rpcCommunicator
-        this.connectionLocker = options.connectionLocker
-        this.inspectionTimeout = options.inspectionTimeout ?? DEFAULT_TIMEOUT
-        this.openInspectConnection = options.openInspectConnection ?? this.defaultOpenInspectConnection
-        this.closeInspectConnection = options.closeInspectConnection ?? this.defaultCloseInspectConnection
-    }
-
-    async defaultOpenInspectConnection(peerDescriptor: PeerDescriptor, lockId: LockID): Promise<void> {
-        const rpcRemote = new TemporaryConnectionRpcRemote(
-            this.localPeerDescriptor,
-            peerDescriptor,
-            this.rpcCommunicator,
-            TemporaryConnectionRpcClient
-        )
-        await rpcRemote.openConnection()
-        this.connectionLocker.weakLockConnection(toNodeId(peerDescriptor), lockId)
-    }
-
-    async defaultCloseInspectConnection(peerDescriptor: PeerDescriptor, lockId: LockID): Promise<void> {
-        const rpcRemote = new TemporaryConnectionRpcRemote(
-            this.localPeerDescriptor,
-            peerDescriptor,
-            this.rpcCommunicator,
-            TemporaryConnectionRpcClient
-        )
-        await rpcRemote.closeConnection()
-        this.connectionLocker.weakUnlockConnection(toNodeId(peerDescriptor), lockId)
-    }
-
-    async inspect(peerDescriptor: PeerDescriptor): Promise<boolean> {
-        const nodeId = toNodeId(peerDescriptor)
-        const session = new InspectSession({
-            inspectedNode: nodeId
-        })
-        const lockId = `inspector-${this.streamPartId}`
-        this.sessions.set(nodeId, session)
-        await this.openInspectConnection(peerDescriptor, lockId)
-        let success = false
-        try {
-            await waitForEvent3<InspectSessionEvents>(session, 'done', this.inspectionTimeout)
-            success = true
-        } catch {
-            logger.trace('Inspect session timed out, removing')
-        } finally {
-            await this.closeInspectConnection(peerDescriptor, lockId)
-            this.sessions.delete(nodeId)
-        }
-        return success || session.getInspectedMessageCount() < 1 || session.onlyMarkedByInspectedNode()
-    }
-
-    markMessage(sender: DhtAddress, messageId: MessageID): void {
-        this.sessions.forEach((session) => session.markMessage(sender, messageId))
-    }
-
-    isInspected(nodeId: DhtAddress): boolean {
-        return this.sessions.has(nodeId)
-    }
-
-    stop(): void {
-        this.sessions.forEach((session) => {
-            session.stop()
-        })
-        this.sessions.clear()
-    }
-
-}

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

@@ -1,138 +0,0 @@
-import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import {
-    DhtAddress,
-    DhtAddressRaw,
-    DhtCallContext,
-    PeerDescriptor,
-    toDhtAddress,
-    toNodeId
-} from '@streamr/dht'
-import { Logger, StreamPartID } from '@streamr/utils'
-import {
-    InterleaveRequest,
-    InterleaveResponse,
-    StreamPartHandshakeRequest,
-    StreamPartHandshakeResponse
-} from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { IHandshakeRpc } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.server'
-import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
-import { NodeList } from '../NodeList'
-import { HandshakeRpcRemote } from './HandshakeRpcRemote'
-
-interface HandshakeRpcLocalOptions {
-    streamPartId: StreamPartID
-    neighbors: NodeList
-    ongoingHandshakes: Set<DhtAddress>
-    ongoingInterleaves: Set<DhtAddress>
-    maxNeighborCount: number
-    createRpcRemote: (target: PeerDescriptor) => HandshakeRpcRemote
-    createContentDeliveryRpcRemote: (peerDescriptor: PeerDescriptor) => ContentDeliveryRpcRemote
-    handshakeWithInterleaving: (target: PeerDescriptor, remoteNodeId: DhtAddress) => Promise<boolean>
-}
-
-const logger = new Logger(module)
-
-export class HandshakeRpcLocal implements IHandshakeRpc {
-
-    private readonly options: HandshakeRpcLocalOptions
-
-    constructor(options: HandshakeRpcLocalOptions) {
-        this.options = options
-    }
-
-    async handshake(request: StreamPartHandshakeRequest, context: ServerCallContext): Promise<StreamPartHandshakeResponse> {
-        return this.handleRequest(request, context)
-    }
-
-    private handleRequest(request: StreamPartHandshakeRequest, context: ServerCallContext): StreamPartHandshakeResponse {
-        const senderDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const getInterleaveNodeIds = () => (request.interleaveNodeId !== undefined) ? [toDhtAddress(request.interleaveNodeId)] : []
-        const senderNodeId = toNodeId(senderDescriptor)
-        if (this.options.ongoingInterleaves.has(senderNodeId)) {
-            return this.rejectHandshake(request)
-        } else if (this.options.neighbors.has(senderNodeId)
-            || this.options.ongoingHandshakes.has(senderNodeId)
-        ) {
-            return this.acceptHandshake(request, senderDescriptor)
-        } else if (this.options.neighbors.size() + this.options.ongoingHandshakes.size < this.options.maxNeighborCount) {
-            return this.acceptHandshake(request, senderDescriptor)
-        } else if (
-            this.options.neighbors.size(getInterleaveNodeIds()) - this.options.ongoingInterleaves.size >= 2
-            && this.options.neighbors.size() <= this.options.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)
-        }
-    }
-
-    private acceptHandshake(request: StreamPartHandshakeRequest, requester: PeerDescriptor) {
-        const res: StreamPartHandshakeResponse = {
-            requestId: request.requestId,
-            accepted: true
-        }
-        this.options.neighbors.add(this.options.createContentDeliveryRpcRemote(requester))
-        return res
-    }
-
-    // eslint-disable-next-line class-methods-use-this
-    private rejectHandshake(request: StreamPartHandshakeRequest) {
-        const res: StreamPartHandshakeResponse = {
-            requestId: request.requestId,
-            accepted: false
-        }
-        return res
-    }
-
-    private acceptHandshakeWithInterleaving(request: StreamPartHandshakeRequest, requester: PeerDescriptor): StreamPartHandshakeResponse {
-        const exclude: DhtAddress[] = []
-        request.neighborNodeIds.forEach((id: DhtAddressRaw) => exclude.push(toDhtAddress(id)))
-        this.options.ongoingInterleaves.forEach((id) => exclude.push(id))
-        exclude.push(toNodeId(requester))
-        if (request.interleaveNodeId !== undefined) {
-            exclude.push(toDhtAddress(request.interleaveNodeId))
-        }
-        const last = this.options.neighbors.getLast(exclude)
-        const lastPeerDescriptor = last ? last.getPeerDescriptor() : undefined
-        if (last) {
-            const nodeId = toNodeId(last.getPeerDescriptor())
-            const remote = this.options.createRpcRemote(last.getPeerDescriptor())
-            this.options.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.options.neighbors.remove(toNodeId(lastPeerDescriptor!))
-                }
-            }).catch(() => {
-                // no-op: InterleaveRequest cannot reject
-            }).finally(() => {
-                this.options.ongoingInterleaves.delete(nodeId)
-            })
-        }
-        this.options.neighbors.add(this.options.createContentDeliveryRpcRemote(requester))
-        return {
-            requestId: request.requestId,
-            accepted: true,
-            interleaveTargetDescriptor: lastPeerDescriptor
-        }
-    }
-
-    async interleaveRequest(message: InterleaveRequest, context: ServerCallContext): Promise<InterleaveResponse> {
-        const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const remoteNodeId = toNodeId(senderPeerDescriptor)
-        try {
-            await this.options.handshakeWithInterleaving(message.interleaveTargetDescriptor!, remoteNodeId)
-            this.options.neighbors.remove(remoteNodeId)
-            return { accepted: true }
-        } catch (err) {
-            logger.debug(`interleaveRequest to ${toNodeId(message.interleaveTargetDescriptor!)} failed`, { err })
-            return { accepted: false }
-        }
-    }
-}

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

@@ -1,66 +0,0 @@
-import { DhtAddress, PeerDescriptor, RpcRemote, toNodeId, toDhtAddressRaw } from '@streamr/dht'
-import { Logger, StreamPartID } from '@streamr/utils'
-import { v4 } from 'uuid'
-import { InterleaveRequest, InterleaveResponse, StreamPartHandshakeRequest } from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
-import { HandshakeRpcClient } from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
-
-const logger = new Logger(module)
-
-interface HandshakeResponse {
-    accepted: boolean
-    interleaveTargetDescriptor?: PeerDescriptor
-}
-
-export const INTERLEAVE_REQUEST_TIMEOUT = 10000
-
-export class HandshakeRpcRemote extends RpcRemote<HandshakeRpcClient> {
-
-    async handshake(
-        streamPartId: StreamPartID,
-        neighborNodeIds: DhtAddress[],
-        concurrentHandshakeNodeId?: DhtAddress,
-        interleaveNodeId?: DhtAddress
-    ): Promise<HandshakeResponse> {
-        const request: StreamPartHandshakeRequest = {
-            streamPartId,
-            requestId: v4(),
-            neighborNodeIds: neighborNodeIds.map((id) => toDhtAddressRaw(id)),
-            concurrentHandshakeNodeId: (concurrentHandshakeNodeId !== undefined) ? toDhtAddressRaw(concurrentHandshakeNodeId) : undefined,
-            interleaveNodeId: (interleaveNodeId !== undefined) ? toDhtAddressRaw(interleaveNodeId) : undefined
-        }
-        try {
-            const response = await this.getClient().handshake(request, this.formDhtRpcOptions())
-            return {
-                accepted: response.accepted,
-                interleaveTargetDescriptor: response.interleaveTargetDescriptor
-            }
-        } catch (err: any) {
-            logger.debug(`handshake to ${toNodeId(this.getPeerDescriptor())} failed`, { err })
-            return {
-                accepted: false
-            }
-        }
-    }
-
-    async interleaveRequest(originatorDescriptor: PeerDescriptor): Promise<InterleaveResponse> {
-        const request: InterleaveRequest = {
-            interleaveTargetDescriptor: originatorDescriptor
-        }
-        const options = this.formDhtRpcOptions({
-            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 ${toNodeId(this.getPeerDescriptor())} failed`, { err })
-            return {
-                accepted: false
-            }
-        }
-        
-    }
-}

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

@@ -1,215 +0,0 @@
-import { DhtAddress, ListeningRpcCommunicator, PeerDescriptor, toNodeId } from '@streamr/dht'
-import { Logger, StreamPartID } from '@streamr/utils'
-import {
-    InterleaveRequest,
-    InterleaveResponse,
-    StreamPartHandshakeRequest,
-    StreamPartHandshakeResponse
-} from '../../../generated/packages/trackerless-network/protos/NetworkRpc'
-import {
-    ContentDeliveryRpcClient, HandshakeRpcClient
-} from '../../../generated/packages/trackerless-network/protos/NetworkRpc.client'
-import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
-import { NodeList } from '../NodeList'
-import { HandshakeRpcLocal } from './HandshakeRpcLocal'
-import { HandshakeRpcRemote, INTERLEAVE_REQUEST_TIMEOUT } from './HandshakeRpcRemote'
-
-interface HandshakerOptions {
-    localPeerDescriptor: PeerDescriptor
-    streamPartId: StreamPartID
-    neighbors: NodeList
-    leftNodeView: NodeList
-    rightNodeView: NodeList
-    nearbyNodeView: NodeList
-    randomNodeView: NodeList
-    rpcCommunicator: ListeningRpcCommunicator
-    maxNeighborCount: number
-    ongoingHandshakes: Set<DhtAddress>
-    rpcRequestTimeout?: number
-}
-
-const logger = new Logger(module)
-
-const PARALLEL_HANDSHAKE_COUNT = 2
-
-export class Handshaker {
-
-    private options: HandshakerOptions
-    private readonly rpcLocal: HandshakeRpcLocal
-
-    constructor(options: HandshakerOptions) {
-        this.options = options
-        this.rpcLocal = new HandshakeRpcLocal({
-            streamPartId: this.options.streamPartId,
-            neighbors: this.options.neighbors,
-            ongoingHandshakes: this.options.ongoingHandshakes,
-            ongoingInterleaves: new Set(),
-            maxNeighborCount: this.options.maxNeighborCount,
-            handshakeWithInterleaving: (target: PeerDescriptor, remoteNodeId: DhtAddress) => this.handshakeWithInterleaving(target, remoteNodeId),
-            createRpcRemote: (target: PeerDescriptor) => this.createRpcRemote(target),
-            createContentDeliveryRpcRemote: (target: PeerDescriptor) => this.createContentDeliveryRpcRemote(target)
-        })
-        this.options.rpcCommunicator.registerRpcMethod(InterleaveRequest, InterleaveResponse, 'interleaveRequest',
-            (req: InterleaveRequest, context) => this.rpcLocal.interleaveRequest(req, context), { timeout: INTERLEAVE_REQUEST_TIMEOUT })
-        this.options.rpcCommunicator.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake',
-            (req: StreamPartHandshakeRequest, context) => this.rpcLocal.handshake(req, context))
-    }
-
-    async attemptHandshakesOnContacts(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
-        // TODO use options option or named constant? or why the value 2?
-        if (this.options.neighbors.size() + this.options.ongoingHandshakes.size < this.options.maxNeighborCount - 2) {
-            logger.trace(`Attempting parallel handshakes with ${PARALLEL_HANDSHAKE_COUNT} targets`)
-            return this.selectParallelTargetsAndHandshake(excludedIds)
-        } else if (this.options.neighbors.size() + this.options.ongoingHandshakes.size < this.options.maxNeighborCount) {
-            logger.trace(`Attempting handshake with new target`)
-            return this.selectNewTargetAndHandshake(excludedIds)
-        }
-        return excludedIds
-    }
-
-    private async selectParallelTargetsAndHandshake(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
-        const exclude = excludedIds.concat(this.options.neighbors.getIds())
-        const neighbors = this.selectParallelTargets(exclude)
-        neighbors.forEach((contact) => this.options.ongoingHandshakes.add(toNodeId(contact.getPeerDescriptor())))
-        return this.doParallelHandshakes(neighbors, exclude)
-    }
-
-    private selectParallelTargets(excludedIds: DhtAddress[]): HandshakeRpcRemote[] {
-        const neighbors: Map<DhtAddress, ContentDeliveryRpcRemote> = new Map()
-        // If the node has 0 neighbors find a node in the stream with a WS server to connect to for faster time to data.
-        if (this.options.neighbors.size() === 0) {
-            const wsNode = this.options.nearbyNodeView.getFirst(
-                [...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[],
-                true
-            )
-            if (wsNode) {
-                const wsNodeId = toNodeId(wsNode.getPeerDescriptor())
-                excludedIds.push(wsNodeId)
-                neighbors.set(wsNodeId, wsNode)
-            }   
-        }
-        // Add the closest left and then right contacts from the ring if possible.
-        const left = this.options.leftNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
-        const right = this.options.rightNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
-        if (left) {
-            neighbors.set(toNodeId(left.getPeerDescriptor()), left)
-        }
-        if (right) {
-            neighbors.set(toNodeId(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.options.nearbyNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
-            if (first) {
-                neighbors.set(toNodeId(first.getPeerDescriptor()), first)
-            }
-        }
-        const getExcludedFromRandomView = () => [
-            ...excludedIds,
-            ...Array.from(neighbors.values()).map((neighbor) => toNodeId(neighbor.getPeerDescriptor()))
-        ]
-        // If there is still room add a random contact until PARALLEL_HANDSHAKE_COUNT is reached
-        while (
-            neighbors.size < PARALLEL_HANDSHAKE_COUNT 
-            && this.options.randomNodeView.size(getExcludedFromRandomView()) > 0
-        ) {
-            const random = this.options.randomNodeView.getRandom([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
-            if (random) {
-                neighbors.set(toNodeId(random.getPeerDescriptor()), random)
-            }
-        }
-        return Array.from(neighbors.values()).map((neighbor) => this.createRpcRemote(neighbor.getPeerDescriptor()))
-    }
-
-    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 ? toNodeId(otherNode.getPeerDescriptor()) : undefined
-                return this.handshakeWithTarget(target, otherNodeId)
-            })
-        )
-        results.forEach((res, i) => {
-            if (res.status !== 'fulfilled' || !res.value) {
-                excludedIds.push(toNodeId(targets[i].getPeerDescriptor()))
-            }
-        })
-        return excludedIds
-    }
-
-    private async selectNewTargetAndHandshake(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
-        const exclude = excludedIds.concat(this.options.neighbors.getIds())
-        const neighbor = this.options.leftNodeView.getFirst(exclude) 
-            ?? this.options.rightNodeView.getFirst(exclude)
-            ?? this.options.nearbyNodeView.getFirst(exclude)
-            ?? this.options.randomNodeView.getRandom(exclude)
-        if (neighbor) {
-            const accepted = await this.handshakeWithTarget(this.createRpcRemote(neighbor.getPeerDescriptor()))
-            if (!accepted) {
-                excludedIds.push(toNodeId(neighbor.getPeerDescriptor()))
-            }
-        }
-        return excludedIds
-    }
-
-    private async handshakeWithTarget(neighbor: HandshakeRpcRemote, concurrentNodeId?: DhtAddress): Promise<boolean> {
-        const targetNodeId = toNodeId(neighbor.getPeerDescriptor())
-        this.options.ongoingHandshakes.add(targetNodeId)
-        const result = await neighbor.handshake(
-            this.options.streamPartId,
-            this.options.neighbors.getIds(),
-            concurrentNodeId
-        )
-        if (result.accepted) {
-            this.options.neighbors.add(this.createContentDeliveryRpcRemote(neighbor.getPeerDescriptor()))
-        }
-        if (result.interleaveTargetDescriptor) {
-            await this.handshakeWithInterleaving(result.interleaveTargetDescriptor, targetNodeId)
-        }
-        this.options.ongoingHandshakes.delete(targetNodeId)
-        return result.accepted
-    }
-
-    private async handshakeWithInterleaving(target: PeerDescriptor, remoteNodeId: DhtAddress): Promise<boolean> {
-        const neighbor = this.createRpcRemote(target)
-        const targetNodeId = toNodeId(neighbor.getPeerDescriptor())
-        this.options.ongoingHandshakes.add(targetNodeId)
-        const result = await neighbor.handshake(
-            this.options.streamPartId,
-            this.options.neighbors.getIds(),
-            undefined,
-            remoteNodeId
-        )
-        if (result.accepted) {
-            this.options.neighbors.add(this.createContentDeliveryRpcRemote(neighbor.getPeerDescriptor()))
-        }
-        this.options.ongoingHandshakes.delete(targetNodeId)
-        return result.accepted
-    }
-
-    private createRpcRemote(targetPeerDescriptor: PeerDescriptor): HandshakeRpcRemote {
-        return new HandshakeRpcRemote(
-            this.options.localPeerDescriptor,
-            targetPeerDescriptor,
-            this.options.rpcCommunicator,
-            HandshakeRpcClient,
-            this.options.rpcRequestTimeout
-        )
-    }
-
-    private createContentDeliveryRpcRemote(targetPeerDescriptor: PeerDescriptor): ContentDeliveryRpcRemote {
-        return new ContentDeliveryRpcRemote(
-            this.options.localPeerDescriptor,
-            targetPeerDescriptor,
-            this.options.rpcCommunicator,
-            ContentDeliveryRpcClient,
-            this.options.rpcRequestTimeout
-        )
-    }
-
-    getOngoingHandshakes(): Set<DhtAddress> {
-        return this.options.ongoingHandshakes
-    }
-
-}

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

@@ -1,77 +0,0 @@
-import { Logger, setAbortableTimeout } from '@streamr/utils'
-import { NodeList } from '../NodeList'
-import { DhtAddress } from '@streamr/dht'
-
-interface FindNeighborsSessionOptions {
-    neighbors: NodeList
-    nearbyNodeView: NodeList
-    leftNodeView: NodeList
-    rightNodeView: NodeList
-    randomNodeView: NodeList
-    doFindNeighbors: (excludedNodes: DhtAddress[]) => Promise<DhtAddress[]>
-    minCount: number
-}
-
-const INITIAL_WAIT = 100
-const INTERVAL = 250
-
-const logger = new Logger(module)
-
-export class NeighborFinder {
-    private readonly abortController: AbortController
-    private readonly options: FindNeighborsSessionOptions
-    private running = false
-
-    constructor(options: FindNeighborsSessionOptions) {
-        this.options = options
-        this.abortController = new AbortController()
-    }
-
-    private async findNeighbors(excluded: DhtAddress[]): Promise<void> {
-        if (!this.running) {
-            return
-        }
-        const newExcludes = await this.options.doFindNeighbors(excluded)
-        const uniqueContactCount = new Set([
-            ...this.options.nearbyNodeView.getIds(),
-            ...this.options.leftNodeView.getIds(),
-            ...this.options.rightNodeView.getIds(),
-            ...this.options.randomNodeView.getIds()
-        ]).size
-        if (this.options.neighbors.size() < this.options.minCount && newExcludes.length < uniqueContactCount) {
-            // TODO should we catch possible promise rejection?
-            setAbortableTimeout(() => this.findNeighbors(newExcludes), INTERVAL, this.abortController.signal)
-        } else if (this.options.neighbors.size() === 0 && uniqueContactCount > 0) {
-            logger.debug('No neighbors found yet contacts are available, restarting handshaking process')
-            setAbortableTimeout(() => this.findNeighbors([]), INTERVAL, this.abortController.signal)
-        } else {
-            this.running = false
-        }
-    }
-
-    isRunning(): boolean {
-        return this.running
-    }
-
-    start(excluded: DhtAddress[] = []): void {
-        if (this.running) {
-            return
-        }
-        this.running = true
-        // TODO should we catch possible promise rejection?
-        setAbortableTimeout(async () => { 
-            await Promise.all([
-                this.findNeighbors(excluded),
-                this.findNeighbors(excluded)
-            ])
-        }, INITIAL_WAIT, this.abortController.signal)
-    }
-
-    stop(): void {
-        if (!this.running) {
-            return
-        }
-        this.running = false
-        this.abortController.abort()
-    }
-}