@streamr/trackerless-network 0.0.1-tatum.0

package/src/logic/createRandomGraphNode.ts

@@ -0,0 +1,114 @@
+import { ListeningRpcCommunicator, PeerIDKey, peerIdFromPeerDescriptor } from '@streamr/dht'
+import { Handshaker } from './neighbor-discovery/Handshaker'
+import { NeighborFinder } from './neighbor-discovery/NeighborFinder'
+import { NeighborUpdateManager } from './neighbor-discovery/NeighborUpdateManager'
+import { StrictRandomGraphNodeConfig, RandomGraphNode } from './RandomGraphNode'
+import { PeerList } from './PeerList'
+import { Propagation } from './propagation/Propagation'
+import { StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
+import { MarkOptional } from 'ts-essentials'
+import { ProxyStreamConnectionServer } from './proxy/ProxyStreamConnectionServer'
+import { Inspector } from './inspect/Inspector'
+import { TemporaryConnectionRpcServer } from './temporary-connection/TemporaryConnectionRpcServer'
+
+type RandomGraphNodeConfig = MarkOptional<StrictRandomGraphNodeConfig,
+    'nearbyContactPool' | 'randomContactPool' | 'targetNeighbors' | 'propagation'
+    | 'handshaker' | 'neighborFinder' | 'neighborUpdateManager' | 'name' | 'numOfTargetNeighbors'
+    | 'maxNumberOfContacts' | 'minPropagationTargets' | 'rpcCommunicator' | 'peerViewSize' | 'acceptProxyConnections'
+    | 'neighborUpdateInterval' | 'inspector' | 'temporaryConnectionServer'>
+
+const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGraphNodeConfig => {
+    const peerId = peerIdFromPeerDescriptor(config.ownPeerDescriptor)
+    const rpcCommunicator = config.rpcCommunicator ?? new ListeningRpcCommunicator(`layer2-${config.randomGraphId}`, config.P2PTransport)
+    const name = config.name ?? peerId.toKey()
+    const numOfTargetNeighbors = config.numOfTargetNeighbors ?? 4
+    const maxNumberOfContacts = config.maxNumberOfContacts ?? 20
+    const minPropagationTargets = config.minPropagationTargets ?? 2
+    const acceptProxyConnections = config.acceptProxyConnections ?? false
+    const neighborUpdateInterval = config.neighborUpdateInterval ?? 10000
+    const nearbyContactPool = config.nearbyContactPool ?? new PeerList(peerId, numOfTargetNeighbors + 1)
+    const randomContactPool = config.randomContactPool ?? new PeerList(peerId, maxNumberOfContacts)
+    const targetNeighbors = config.targetNeighbors ?? new PeerList(peerId, maxNumberOfContacts)
+
+    const temporaryConnectionServer = new TemporaryConnectionRpcServer({
+        randomGraphId: config.randomGraphId,
+        rpcCommunicator,
+        ownPeerId: peerId
+    })
+    const proxyConnectionServer = acceptProxyConnections ? new ProxyStreamConnectionServer({
+        ownPeerDescriptor: config.ownPeerDescriptor,
+        streamPartId: config.randomGraphId,
+        rpcCommunicator
+    }) : undefined
+    const propagation = config.propagation ?? new Propagation({
+        minPropagationTargets,
+        sendToNeighbor: async (neighborId: string, msg: StreamMessage): Promise<void> => {
+            const remote = targetNeighbors.getNeighborById(neighborId) ?? temporaryConnectionServer.getPeers().getNeighborById(neighborId)
+            const proxyConnection = proxyConnectionServer?.getConnection(neighborId as PeerIDKey)
+            if (remote) {
+                await remote.sendData(config.ownPeerDescriptor, msg)
+            } else if (proxyConnection) {
+                await proxyConnection.remote.sendData(config.ownPeerDescriptor, msg)
+            } else {
+                throw new Error('Propagation target not found')
+            }
+        }
+    })
+    const handshaker = config.handshaker ?? new Handshaker({
+        ownPeerDescriptor: config.ownPeerDescriptor,
+        randomGraphId: config.randomGraphId,
+        connectionLocker: config.connectionLocker,
+        rpcCommunicator,
+        nearbyContactPool,
+        randomContactPool,
+        targetNeighbors,
+        N: numOfTargetNeighbors
+    })
+    const neighborFinder = config.neighborFinder ?? new NeighborFinder({
+        targetNeighbors: targetNeighbors,
+        nearbyContactPool: nearbyContactPool,
+        doFindNeighbors: (excludedIds) => handshaker!.attemptHandshakesOnContacts(excludedIds),
+        N: numOfTargetNeighbors
+    })
+    const neighborUpdateManager = config.neighborUpdateManager ?? new NeighborUpdateManager({
+        targetNeighbors,
+        nearbyContactPool,
+        ownStringId: peerId.toKey(),
+        ownPeerDescriptor: config.ownPeerDescriptor,
+        neighborFinder,
+        randomGraphId: config.randomGraphId,
+        rpcCommunicator,
+        neighborUpdateInterval
+    })
+    const inspector = config.inspector ?? new Inspector({
+        ownPeerDescriptor: config.ownPeerDescriptor,
+        rpcCommunicator,
+        graphId: config.randomGraphId,
+        connectionLocker: config.connectionLocker
+    })
+    return {
+        ...config,
+        nearbyContactPool,
+        randomContactPool,
+        targetNeighbors,
+        rpcCommunicator,
+        handshaker,
+        neighborFinder,
+        neighborUpdateManager,
+        propagation,
+        numOfTargetNeighbors,
+        minPropagationTargets,
+        maxNumberOfContacts,
+        name,
+        peerViewSize: maxNumberOfContacts,
+        acceptProxyConnections,
+        proxyConnectionServer,
+        neighborUpdateInterval,
+        inspector,
+        temporaryConnectionServer
+    }
+}
+
+export const createRandomGraphNode = (config: RandomGraphNodeConfig): RandomGraphNode => {
+    return new RandomGraphNode(createConfigWithDefaults(config))
+}

package/src/logic/inspect/InspectSession.ts

@@ -0,0 +1,49 @@
+import { EventEmitter } from 'eventemitter3'
+import { MessageRef } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { PeerIDKey } from '@streamr/dht'
+
+export interface Events {
+    done: () => void
+}
+
+interface InspectSessionConfig {
+    inspectedPeer: PeerIDKey
+}
+
+const createMessageKey = (messageRef: MessageRef): string => {
+    return `${messageRef.publisherId}:${messageRef.messageChainId}:${messageRef.timestamp}:${messageRef.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 inspectedPeer: PeerIDKey
+
+    constructor(config: InspectSessionConfig) {
+        super()
+        this.inspectedPeer = config.inspectedPeer
+    }
+
+    markMessage(senderId: PeerIDKey, messageRef: MessageRef): void {
+        const messageKey = createMessageKey(messageRef)
+        if (!this.inspectionMessages.has(messageKey)) {
+            this.inspectionMessages.set(messageKey, senderId === this.inspectedPeer)
+        } else if (this.inspectionMessages.has(messageKey)
+            && this.inspectionMessages.get(messageKey) === false
+            && senderId === this.inspectedPeer
+        ) {
+            this.emit('done')
+        } else if (this.inspectionMessages.has(messageKey)
+            && this.inspectionMessages.get(messageKey) === true) {
+            this.emit('done')
+        }
+    }
+
+    getInspectedMessageCount(): number {
+        return this.inspectionMessages.size
+    }
+
+    stop(): void {
+        this.emit('done')
+    }
+}

package/src/logic/inspect/Inspector.ts

@@ -0,0 +1,89 @@
+import { PeerIDKey, PeerDescriptor, keyFromPeerDescriptor, ConnectionLocker } from '@streamr/dht'
+import { MessageRef } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { InspectSession, Events as InspectSessionEvents } from './InspectSession'
+import { TemporaryConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
+import { Logger, waitForEvent3 } from '@streamr/utils'
+import { RemoteTemporaryConnectionRpcServer } from '../temporary-connection/RemoteTemporaryConnectionRpcServer'
+
+interface InspectorConfig {
+    ownPeerDescriptor: PeerDescriptor
+    graphId: string
+    rpcCommunicator: RpcCommunicator
+    connectionLocker: ConnectionLocker
+    inspectionTimeout?: number
+    openInspectConnection?: (peerDescriptor: PeerDescriptor, lockId: string) => Promise<void>
+}
+
+export interface IInspector {
+    inspect(peerDescriptor: PeerDescriptor): Promise<boolean>
+    markMessage(sender: PeerIDKey, messageId: MessageRef): void
+    isInspected(nodeId: PeerIDKey): boolean
+    stop(): void
+}
+
+const logger = new Logger(module)
+const DEFAULT_TIMEOUT = 60 * 1000
+
+export class Inspector implements IInspector {
+
+    private readonly sessions: Map<PeerIDKey, InspectSession> = new Map()
+    private readonly graphId: string
+    private readonly client: ProtoRpcClient<TemporaryConnectionRpcClient>
+    private readonly ownPeerDescriptor: PeerDescriptor
+    private readonly connectionLocker: ConnectionLocker
+    private readonly inspectionTimeout: number
+    private readonly openInspectConnection: (peerDescriptor: PeerDescriptor, lockId: string) => Promise<void>
+
+    constructor(config: InspectorConfig) {
+        this.graphId = config.graphId
+        this.ownPeerDescriptor = config.ownPeerDescriptor
+        this.client = toProtoRpcClient(new TemporaryConnectionRpcClient(config.rpcCommunicator.getRpcClientTransport()))
+        this.connectionLocker = config.connectionLocker
+        this.inspectionTimeout = config.inspectionTimeout ?? DEFAULT_TIMEOUT
+        this.openInspectConnection = config.openInspectConnection ?? this.defaultOpenInspectConnection
+    }
+
+    async defaultOpenInspectConnection(peerDescriptor: PeerDescriptor, lockId: string): Promise<void> {
+        const remoteRandomGraphNode = new RemoteTemporaryConnectionRpcServer(peerDescriptor, this.graphId, this.client)
+        await remoteRandomGraphNode.openConnection(this.ownPeerDescriptor)
+        this.connectionLocker.lockConnection(peerDescriptor, lockId)
+    }
+
+    async inspect(peerDescriptor: PeerDescriptor): Promise<boolean> {
+        const nodeId = keyFromPeerDescriptor(peerDescriptor)
+        const session = new InspectSession({
+            inspectedPeer: nodeId
+        })
+        const lockId = `inspector-${this.graphId}`
+        this.sessions.set(nodeId, session)
+        await this.openInspectConnection(peerDescriptor, lockId)
+        let success = false
+        try {
+            await waitForEvent3<InspectSessionEvents>(session, 'done', this.inspectionTimeout)
+            success = true
+        } catch (err) {
+            logger.trace('Inspect session timed out, removing')
+        } finally {
+            this.sessions.delete(nodeId)
+            this.connectionLocker.unlockConnection(peerDescriptor, lockId)
+        }
+        return success || session.getInspectedMessageCount() < 1
+    }
+
+    markMessage(sender: PeerIDKey, messageId: MessageRef): void {
+        this.sessions.forEach((session) => session.markMessage(sender, messageId))
+    }
+
+    isInspected(nodeId: PeerIDKey): boolean {
+        return this.sessions.has(nodeId)
+    }
+
+    stop(): void {
+        this.sessions.forEach((session) => {
+            session.stop()
+        })
+        this.sessions.clear()
+    }
+
+}

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

@@ -0,0 +1,180 @@
+import { ConnectionLocker, keyFromPeerDescriptor, PeerDescriptor } from '@streamr/dht'
+import { PeerList } from '../PeerList'
+import { RemoteRandomGraphNode } from '../RemoteRandomGraphNode'
+import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
+import {
+    HandshakeRpcClient,
+    IHandshakeRpcClient, NetworkRpcClient
+} from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import {
+    InterleaveNotice,
+    StreamHandshakeRequest,
+    StreamHandshakeResponse
+} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { Logger } from '@streamr/utils'
+import { IHandshakeRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { RemoteHandshaker } from './RemoteHandshaker'
+import { HandshakerServer } from './HandshakerServer'
+
+interface HandshakerConfig {
+    ownPeerDescriptor: PeerDescriptor
+    randomGraphId: string
+    connectionLocker: ConnectionLocker
+    targetNeighbors: PeerList
+    nearbyContactPool: PeerList
+    randomContactPool: PeerList
+    rpcCommunicator: RpcCommunicator
+    N: number
+}
+
+const logger = new Logger(module)
+
+const PARALLEL_HANDSHAKE_COUNT = 2
+
+export interface IHandshaker {
+    attemptHandshakesOnContacts(excludedIds: string[]): Promise<string[]>
+    getOngoingHandshakes(): Set<string>
+}
+
+export class Handshaker implements IHandshaker {
+
+    private readonly ongoingHandshakes: Set<string> = new Set()
+    private config: HandshakerConfig
+    private readonly client: ProtoRpcClient<IHandshakeRpcClient>
+    private readonly server: IHandshakeRpc
+
+    constructor(config: HandshakerConfig) {
+        this.config = config
+        this.client = toProtoRpcClient(new HandshakeRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+        this.server = new HandshakerServer({
+            randomGraphId: this.config.randomGraphId,
+            ownPeerDescriptor: this.config.ownPeerDescriptor,
+            targetNeighbors: this.config.targetNeighbors,
+            connectionLocker: this.config.connectionLocker,
+            ongoingHandshakes: this.ongoingHandshakes,
+            N: this.config.N,
+            handshakeWithInterleaving: (target: PeerDescriptor, senderId: string) => this.handshakeWithInterleaving(target, senderId),
+            createRemoteHandshaker: (target: PeerDescriptor) => this.createRemoteHandshaker(target),
+            createRemoteNode: (target: PeerDescriptor) => this.createRemoteNode(target)
+        })
+        this.config.rpcCommunicator.registerRpcNotification(InterleaveNotice, 'interleaveNotice',
+            (req: InterleaveNotice, context) => this.server.interleaveNotice(req, context))
+        this.config.rpcCommunicator.registerRpcMethod(StreamHandshakeRequest, StreamHandshakeResponse, 'handshake',
+            (req: StreamHandshakeRequest, context) => this.server.handshake(req, context))
+    }
+
+    public async attemptHandshakesOnContacts(excludedIds: string[]): Promise<string[]> {
+        if (this.config.targetNeighbors!.size() + this.ongoingHandshakes.size < this.config.N - 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.N) {
+            logger.trace(`Attempting handshake with new target`)
+            return this.selectNewTargetAndHandshake(excludedIds)
+        }
+        return excludedIds
+    }
+
+    private async selectParallelTargetsAndHandshake(excludedIds: string[]): Promise<string[]> {
+        const exclude = excludedIds.concat(this.config.targetNeighbors.getStringIds())
+        const targetNeighbors = this.selectParallelTargets(exclude)
+        targetNeighbors.forEach((contact) => this.ongoingHandshakes.add(keyFromPeerDescriptor(contact.getPeerDescriptor())))
+        return this.doParallelHandshakes(targetNeighbors, exclude)
+    }
+
+    private selectParallelTargets(excludedIds: string[]): RemoteHandshaker[] {
+        const targetNeighbors = this.config.nearbyContactPool.getClosestAndFurthest(excludedIds)
+        while (targetNeighbors.length < PARALLEL_HANDSHAKE_COUNT && this.config.randomContactPool.size(excludedIds) > 0) {
+            const random = this.config.randomContactPool.getRandom(excludedIds)
+            if (random) {
+                targetNeighbors.push(random)
+            }
+        }
+        return targetNeighbors.map((neighbor) => this.createRemoteHandshaker(neighbor.getPeerDescriptor()))
+    }
+
+    private async doParallelHandshakes(targets: RemoteHandshaker[], excludedIds: string[]): Promise<string[]> {
+        const results = await Promise.allSettled(
+            Array.from(targets.values()).map(async (target: RemoteHandshaker, i) => {
+                const otherPeer = i === 0 ? targets[1] : targets[0]
+                const otherPeerStringId = otherPeer ? keyFromPeerDescriptor(otherPeer.getPeerDescriptor()) : undefined
+                return this.handshakeWithTarget(target, otherPeerStringId)
+            })
+        )
+        results.map((res, i) => {
+            if (res.status !== 'fulfilled' || !res.value) {
+                excludedIds.push(keyFromPeerDescriptor(targets[i].getPeerDescriptor()))
+            }
+        })
+        return excludedIds
+    }
+
+    private async selectNewTargetAndHandshake(excludedIds: string[]): Promise<string[]> {
+        const exclude = excludedIds.concat(this.config.targetNeighbors.getStringIds())
+        const targetNeighbor = this.config.nearbyContactPool.getClosest(exclude) ?? this.config.randomContactPool.getRandom(exclude)
+        if (targetNeighbor) {
+            const accepted = await this.handshakeWithTarget(this.createRemoteHandshaker(targetNeighbor.getPeerDescriptor()))
+            if (!accepted) {
+                excludedIds.push(keyFromPeerDescriptor(targetNeighbor.getPeerDescriptor()))
+            }
+        }
+        return excludedIds
+    }
+
+    private async handshakeWithTarget(targetNeighbor: RemoteHandshaker, concurrentStringId?: string): Promise<boolean> {
+        const targetStringId = keyFromPeerDescriptor(targetNeighbor.getPeerDescriptor())
+        this.ongoingHandshakes.add(targetStringId)
+        const result = await targetNeighbor.handshake(
+            this.config.ownPeerDescriptor,
+            this.config.targetNeighbors.getStringIds(),
+            concurrentStringId
+        )
+        if (result.accepted) {
+            this.config.targetNeighbors.add(this.createRemoteNode(targetNeighbor.getPeerDescriptor()))
+            this.config.connectionLocker.lockConnection(targetNeighbor.getPeerDescriptor(), this.config.randomGraphId)
+        }
+        if (result.interleaveTarget) {
+            await this.handshakeWithInterleaving(result.interleaveTarget, targetStringId)
+        }
+        this.ongoingHandshakes.delete(targetStringId)
+        return result.accepted
+    }
+
+    private async handshakeWithInterleaving(target: PeerDescriptor, interleavingFrom: string): Promise<boolean> {
+        const targetNeighbor = new RemoteHandshaker(
+            target,
+            this.config.randomGraphId,
+            this.client
+        )
+        const targetStringId = keyFromPeerDescriptor(targetNeighbor.getPeerDescriptor())
+        this.ongoingHandshakes.add(targetStringId)
+        const result = await targetNeighbor.handshake(
+            this.config.ownPeerDescriptor,
+            this.config.targetNeighbors.getStringIds(),
+            undefined,
+            interleavingFrom
+        )
+        if (result.accepted) {
+            this.config.targetNeighbors.add(this.createRemoteNode(targetNeighbor.getPeerDescriptor()))
+            this.config.connectionLocker.lockConnection(targetNeighbor.getPeerDescriptor(), this.config.randomGraphId)
+        }
+        this.ongoingHandshakes.delete(targetStringId)
+        return result.accepted
+    }
+
+    private createRemoteHandshaker(targetPeerDescriptor: PeerDescriptor): RemoteHandshaker {
+        return new RemoteHandshaker(targetPeerDescriptor, this.config.randomGraphId, this.client)
+    }
+
+    private createRemoteNode(targetPeerDescriptor: PeerDescriptor): RemoteRandomGraphNode {
+        return new RemoteRandomGraphNode(
+            targetPeerDescriptor,
+            this.config.randomGraphId,
+            toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator!.getRpcClientTransport()))
+        )
+    }
+
+    public getOngoingHandshakes(): Set<string> {
+        return this.ongoingHandshakes
+    }
+
+}

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

@@ -0,0 +1,99 @@
+import { Empty } from '../../proto/google/protobuf/empty'
+import { InterleaveNotice, StreamHandshakeRequest, StreamHandshakeResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { PeerList } from '../PeerList'
+import { ConnectionLocker, keyFromPeerDescriptor, PeerDescriptor } from '@streamr/dht'
+import { IHandshakeRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { RemoteHandshaker } from './RemoteHandshaker'
+import { RemoteRandomGraphNode } from '../RemoteRandomGraphNode'
+
+interface HandshakerServerConfig {
+    randomGraphId: string
+    ownPeerDescriptor: PeerDescriptor
+    targetNeighbors: PeerList
+    connectionLocker: ConnectionLocker
+    ongoingHandshakes: Set<string>
+    N: number
+    createRemoteHandshaker: (target: PeerDescriptor) => RemoteHandshaker
+    createRemoteNode: (peerDescriptor: PeerDescriptor) => RemoteRandomGraphNode
+    handshakeWithInterleaving: (target: PeerDescriptor, senderId: string) => Promise<boolean>
+}
+
+export class HandshakerServer implements IHandshakeRpc {
+
+    private readonly config: HandshakerServerConfig
+
+    constructor(config: HandshakerServerConfig) {
+        this.config = config
+    }
+
+    async handshake(request: StreamHandshakeRequest, _context: ServerCallContext): Promise<StreamHandshakeResponse> {
+        return this.handleRequest(request)
+    }
+
+    private handleRequest(request: StreamHandshakeRequest): StreamHandshakeResponse {
+        if (this.config.targetNeighbors!.hasPeer(request.senderDescriptor!)
+            || this.config.ongoingHandshakes.has(keyFromPeerDescriptor(request.senderDescriptor!))
+        ) {
+            return this.acceptHandshake(request, request.senderDescriptor!)
+        } else if (this.config.targetNeighbors!.size() + this.config.ongoingHandshakes.size < this.config.N) {
+            return this.acceptHandshake(request, request.senderDescriptor!)
+        } else if (this.config.targetNeighbors!.size([request.interleavingFrom!]) >= 2) {
+            return this.acceptHandshakeWithInterleaving(request, request.senderDescriptor!)
+        } else {
+            return this.rejectHandshake(request)
+        }
+    }
+
+    private acceptHandshake(request: StreamHandshakeRequest, requester: PeerDescriptor) {
+        const res: StreamHandshakeResponse = {
+            requestId: request.requestId,
+            accepted: true
+        }
+        this.config.targetNeighbors.add(this.config.createRemoteNode(requester))
+        this.config.connectionLocker.lockConnection(request.senderDescriptor!, this.config.randomGraphId)
+        return res
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    private rejectHandshake(request: StreamHandshakeRequest) {
+        const res: StreamHandshakeResponse = {
+            requestId: request.requestId,
+            accepted: false
+        }
+        return res
+    }
+
+    private acceptHandshakeWithInterleaving(request: StreamHandshakeRequest, requester: PeerDescriptor): StreamHandshakeResponse {
+        const exclude = request.neighbors
+        exclude.push(request.senderId)
+        exclude.push(request.interleavingFrom!)
+        const furthest = this.config.targetNeighbors.getFurthest(exclude)
+        const furthestPeerDescriptor = furthest ? furthest.getPeerDescriptor() : undefined
+        if (furthest) {
+            const remote = this.config.createRemoteHandshaker(furthest.getPeerDescriptor())
+            remote.interleaveNotice(this.config.ownPeerDescriptor, request.senderDescriptor!)
+            this.config.targetNeighbors.remove(furthest.getPeerDescriptor())
+            this.config.connectionLocker.unlockConnection(furthestPeerDescriptor!, this.config.randomGraphId)
+        }
+        this.config.targetNeighbors.add(this.config.createRemoteNode(requester))
+        this.config.connectionLocker.lockConnection(request.senderDescriptor!, this.config.randomGraphId)
+        return {
+            requestId: request.requestId,
+            accepted: true,
+            interleaveTarget: furthestPeerDescriptor
+        }
+    }
+
+    async interleaveNotice(message: InterleaveNotice, _context: ServerCallContext): Promise<Empty> {
+        if (message.randomGraphId === this.config.randomGraphId) {
+            if (this.config.targetNeighbors.hasPeerWithStringId(message.senderId)) {
+                const senderDescriptor = this.config.targetNeighbors.getNeighborById(message.senderId)!.getPeerDescriptor()
+                this.config.connectionLocker.unlockConnection(senderDescriptor, this.config.randomGraphId)
+                this.config.targetNeighbors.remove(senderDescriptor)
+            }
+            this.config.handshakeWithInterleaving(message.interleaveTarget!, message.senderId).catch((_e) => {})
+        }
+        return Empty
+    }
+}

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

@@ -0,0 +1,61 @@
+import { setAbortableTimeout } from '@streamr/utils'
+import { PeerList } from '../PeerList'
+
+interface FindNeighborsSessionConfig {
+    targetNeighbors: PeerList
+    nearbyContactPool: PeerList
+    doFindNeighbors: (excludedNodes: string[]) => Promise<string[]>
+    N: number
+}
+
+const INITIAL_TIMEOUT = 100
+const INTERVAL_TIMEOUT = 250
+
+export interface INeighborFinder {
+    start(excluded?: string[]): void
+    stop(): void
+    isRunning(): boolean
+}
+
+export class NeighborFinder implements INeighborFinder {
+    private readonly abortController: AbortController
+    private readonly config: FindNeighborsSessionConfig
+    private running = false
+
+    constructor(config: FindNeighborsSessionConfig) {
+        this.config = config
+        this.abortController = new AbortController()
+    }
+
+    private async findNeighbors(excluded: string[]): Promise<void> {
+        if (!this.running) {
+            return
+        }
+        const newExcludes = await this.config.doFindNeighbors(excluded)
+        if (this.config.targetNeighbors!.size() < this.config.N && newExcludes.length < this.config.nearbyContactPool!.size()) {
+            setAbortableTimeout(() => this.findNeighbors(newExcludes), INTERVAL_TIMEOUT, this.abortController.signal)
+        } else {
+            this.running = false
+        }
+    }
+
+    isRunning(): boolean {
+        return this.running
+    }
+
+    start(excluded: string[] = []): void {
+        if (this.running) {
+            return
+        }
+        this.running = true
+        setAbortableTimeout(() => this.findNeighbors(excluded), INITIAL_TIMEOUT, this.abortController.signal)
+    }
+
+    stop(): void {
+        if (!this.running) {
+            return
+        }
+        this.running = false
+        this.abortController.abort()
+    }
+}

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

@@ -0,0 +1,67 @@
+import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { keyFromPeerDescriptor, ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
+import { ProtoRpcClient, toProtoRpcClient } from '@streamr/proto-rpc'
+import { NeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { Logger, scheduleAtInterval } from '@streamr/utils'
+import { PeerIDKey } from '@streamr/dht/dist/src/helpers/PeerID'
+import { INeighborFinder } from './NeighborFinder'
+import { PeerList } from '../PeerList'
+import { RemoteNeighborUpdateManager } from './RemoteNeighborUpdateManager'
+import { NeighborUpdateManagerServer } from './NeighborUpdateManagerServer'
+
+interface NeighborUpdateManagerConfig {
+    ownStringId: PeerIDKey
+    ownPeerDescriptor: PeerDescriptor
+    targetNeighbors: PeerList
+    nearbyContactPool: PeerList
+    neighborFinder: INeighborFinder
+    randomGraphId: string
+    rpcCommunicator: ListeningRpcCommunicator
+    neighborUpdateInterval: number
+}
+
+const logger = new Logger(module)
+
+export interface INeighborUpdateManager {
+    start(): Promise<void>
+    stop(): void
+}
+
+export class NeighborUpdateManager implements INeighborUpdateManager {
+    private readonly abortController: AbortController
+    private readonly config: NeighborUpdateManagerConfig
+    private readonly client: ProtoRpcClient<NeighborUpdateRpcClient>
+    private readonly server: NeighborUpdateManagerServer
+    constructor(config: NeighborUpdateManagerConfig) {
+        this.abortController = new AbortController()
+        this.client = toProtoRpcClient(new NeighborUpdateRpcClient(config.rpcCommunicator.getRpcClientTransport()))
+        this.server = new NeighborUpdateManagerServer(config)
+        this.config = config
+        this.config.rpcCommunicator.registerRpcMethod(NeighborUpdate, NeighborUpdate, 'neighborUpdate',
+            (req: NeighborUpdate, context) => this.server.neighborUpdate(req, context))
+    }
+
+    public async start(): Promise<void> {
+        await scheduleAtInterval(() => this.updateNeighborInfo(), this.config.neighborUpdateInterval, false, this.abortController.signal)
+    }
+
+    public stop(): void {
+        this.abortController.abort()
+    }
+
+    private async updateNeighborInfo(): Promise<void> {
+        logger.trace(`Updating neighbor info to peers`)
+        const neighborDescriptors = this.config.targetNeighbors!.getPeers().map((neighbor) => neighbor.getPeerDescriptor())
+        await Promise.allSettled(this.config.targetNeighbors!.getPeers().map(async (neighbor) => {
+            const res = await this.createRemote(neighbor.getPeerDescriptor()).updateNeighbors(this.config.ownPeerDescriptor, neighborDescriptors)
+            if (res.removeMe) {
+                this.config.targetNeighbors!.remove(neighbor.getPeerDescriptor())
+                this.config.neighborFinder!.start([keyFromPeerDescriptor(neighbor.getPeerDescriptor())])
+            }
+        }))
+    }
+
+    private createRemote(targetPeerDescriptor: PeerDescriptor): RemoteNeighborUpdateManager {
+        return new RemoteNeighborUpdateManager(targetPeerDescriptor, this.config.randomGraphId, this.client)
+    }
+}