@streamr/trackerless-network 0.0.1-tatum.6 → 0.0.1-tatum.7

package/src/logic/createRandomGraphNode.ts

@@ -7,22 +7,29 @@ import { NodeList } from './NodeList'
 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 { ProxyConnectionRpcLocal } from './proxy/ProxyConnectionRpcLocal'
 import { Inspector } from './inspect/Inspector'
-import { TemporaryConnectionRpcServer } from './temporary-connection/TemporaryConnectionRpcServer'
-import { StreamPartIDUtils } from '@streamr/protocol'
+import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../identifiers'
+import { formStreamPartDeliveryServiceId } from './formStreamPartDeliveryServiceId'
 
 type RandomGraphNodeConfig = MarkOptional<StrictRandomGraphNodeConfig,
     'nearbyNodeView' | 'randomNodeView' | 'targetNeighbors' | 'propagation'
-    | 'handshaker' | 'neighborFinder' | 'neighborUpdateManager' | 'name' | 'numOfTargetNeighbors'
-    | 'maxNumberOfContacts' | 'minPropagationTargets' | 'rpcCommunicator' | 'nodeViewSize' | 'acceptProxyConnections'
-    | 'neighborUpdateInterval' | 'inspector' | 'temporaryConnectionServer'>
+    | 'handshaker' | 'neighborFinder' | 'neighborUpdateManager' | 'numOfTargetNeighbors'
+    | 'rpcCommunicator' | 'nodeViewSize'
+    | 'inspector' | 'temporaryConnectionRpcLocal'> & {
+        maxNumberOfContacts?: number
+        minPropagationTargets?: number
+        acceptProxyConnections?: boolean
+        neighborUpdateInterval?: number
+    }
 
 const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGraphNodeConfig => {
     const ownNodeId = getNodeIdFromPeerDescriptor(config.ownPeerDescriptor)
-    const rpcCommunicator = config.rpcCommunicator ?? new ListeningRpcCommunicator(`layer2-${config.randomGraphId}`, config.P2PTransport)
-    const name = config.name ?? ownNodeId
+    const rpcCommunicator = config.rpcCommunicator ?? new ListeningRpcCommunicator(
+        formStreamPartDeliveryServiceId(config.streamPartId),
+        config.P2PTransport
+    )
     const numOfTargetNeighbors = config.numOfTargetNeighbors ?? 4
     const maxNumberOfContacts = config.maxNumberOfContacts ?? 20
     const minPropagationTargets = config.minPropagationTargets ?? 2
@@ -32,21 +39,21 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     const randomNodeView = config.randomNodeView ?? new NodeList(ownNodeId, maxNumberOfContacts)
     const targetNeighbors = config.targetNeighbors ?? new NodeList(ownNodeId, maxNumberOfContacts)
 
-    const temporaryConnectionServer = new TemporaryConnectionRpcServer({
-        randomGraphId: config.randomGraphId,
+    const temporaryConnectionRpcLocal = new TemporaryConnectionRpcLocal({
+        streamPartId: config.streamPartId,
         rpcCommunicator,
         ownPeerDescriptor: config.ownPeerDescriptor
     })
-    const proxyConnectionServer = acceptProxyConnections ? new ProxyStreamConnectionServer({
+    const proxyConnectionRpcLocal = acceptProxyConnections ? new ProxyConnectionRpcLocal({
         ownPeerDescriptor: config.ownPeerDescriptor,
-        streamPartId: StreamPartIDUtils.parse(config.randomGraphId),
+        streamPartId: config.streamPartId,
         rpcCommunicator
     }) : undefined
     const propagation = config.propagation ?? new Propagation({
         minPropagationTargets,
         sendToNeighbor: async (neighborId: NodeID, msg: StreamMessage): Promise<void> => {
-            const remote = targetNeighbors.get(neighborId) ?? temporaryConnectionServer.getNodes().get(neighborId)
-            const proxyConnection = proxyConnectionServer?.getConnection(neighborId)
+            const remote = targetNeighbors.get(neighborId) ?? temporaryConnectionRpcLocal.getNodes().get(neighborId)
+            const proxyConnection = proxyConnectionRpcLocal?.getConnection(neighborId)
             if (remote) {
                 await remote.sendStreamMessage(msg)
             } else if (proxyConnection) {
@@ -58,33 +65,33 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     })
     const handshaker = config.handshaker ?? new Handshaker({
         ownPeerDescriptor: config.ownPeerDescriptor,
-        randomGraphId: config.randomGraphId,
+        streamPartId: config.streamPartId,
         connectionLocker: config.connectionLocker,
         rpcCommunicator,
         nearbyNodeView,
         randomNodeView,
         targetNeighbors,
-        N: numOfTargetNeighbors
+        maxNeighborCount: numOfTargetNeighbors
     })
     const neighborFinder = config.neighborFinder ?? new NeighborFinder({
         targetNeighbors,
         nearbyNodeView,
         doFindNeighbors: (excludedIds) => handshaker.attemptHandshakesOnContacts(excludedIds),
-        N: numOfTargetNeighbors
+        minCount: numOfTargetNeighbors
     })
     const neighborUpdateManager = config.neighborUpdateManager ?? new NeighborUpdateManager({
         targetNeighbors,
         nearbyNodeView,
         ownPeerDescriptor: config.ownPeerDescriptor,
         neighborFinder,
-        randomGraphId: config.randomGraphId,
+        streamPartId: config.streamPartId,
         rpcCommunicator,
         neighborUpdateInterval
     })
     const inspector = config.inspector ?? new Inspector({
         ownPeerDescriptor: config.ownPeerDescriptor,
         rpcCommunicator,
-        graphId: config.randomGraphId,
+        streamPartId: config.streamPartId,
         connectionLocker: config.connectionLocker
     })
     return {
@@ -98,15 +105,10 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
         neighborUpdateManager,
         propagation,
         numOfTargetNeighbors,
-        minPropagationTargets,
-        maxNumberOfContacts,
-        name,
         nodeViewSize: maxNumberOfContacts,
-        acceptProxyConnections,
-        proxyConnectionServer,
-        neighborUpdateInterval,
+        proxyConnectionRpcLocal,
         inspector,
-        temporaryConnectionServer
+        temporaryConnectionRpcLocal
     }
 }
 

package/src/logic/formStreamPartDeliveryServiceId.ts

@@ -0,0 +1,5 @@
+import { StreamPartID } from '@streamr/protocol'
+
+export const formStreamPartDeliveryServiceId = (streamPartId: StreamPartID): string => {
+    return `stream-part-delivery-${streamPartId}`
+}

package/src/logic/inspect/Inspector.ts

@@ -4,12 +4,13 @@ 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'
+import { TemporaryConnectionRpcRemote } from '../temporary-connection/TemporaryConnectionRpcRemote'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { StreamPartID } from '@streamr/protocol'
 
 interface InspectorConfig {
     ownPeerDescriptor: PeerDescriptor
-    graphId: string
+    streamPartId: StreamPartID
     rpcCommunicator: RpcCommunicator
     connectionLocker: ConnectionLocker
     inspectionTimeout?: number
@@ -29,7 +30,7 @@ const DEFAULT_TIMEOUT = 60 * 1000
 export class Inspector implements IInspector {
 
     private readonly sessions: Map<NodeID, InspectSession> = new Map()
-    private readonly graphId: string
+    private readonly streamPartId: StreamPartID
     private readonly client: ProtoRpcClient<TemporaryConnectionRpcClient>
     private readonly ownPeerDescriptor: PeerDescriptor
     private readonly connectionLocker: ConnectionLocker
@@ -37,7 +38,7 @@ export class Inspector implements IInspector {
     private readonly openInspectConnection: (peerDescriptor: PeerDescriptor, lockId: string) => Promise<void>
 
     constructor(config: InspectorConfig) {
-        this.graphId = config.graphId
+        this.streamPartId = config.streamPartId
         this.ownPeerDescriptor = config.ownPeerDescriptor
         this.client = toProtoRpcClient(new TemporaryConnectionRpcClient(config.rpcCommunicator.getRpcClientTransport()))
         this.connectionLocker = config.connectionLocker
@@ -46,8 +47,8 @@ export class Inspector implements IInspector {
     }
 
     async defaultOpenInspectConnection(peerDescriptor: PeerDescriptor, lockId: string): Promise<void> {
-        const remoteRandomGraphNode = new RemoteTemporaryConnectionRpcServer(this.ownPeerDescriptor, peerDescriptor, this.graphId, this.client)
-        await remoteRandomGraphNode.openConnection()
+        const rpcRemote = new TemporaryConnectionRpcRemote(this.ownPeerDescriptor, peerDescriptor, this.streamPartId, this.client)
+        await rpcRemote.openConnection()
         this.connectionLocker.lockConnection(peerDescriptor, lockId)
     }
 
@@ -56,7 +57,7 @@ export class Inspector implements IInspector {
         const session = new InspectSession({
             inspectedNode: nodeId
         })
-        const lockId = `inspector-${this.graphId}`
+        const lockId = `inspector-${this.streamPartId}`
         this.sessions.set(nodeId, session)
         await this.openInspectConnection(peerDescriptor, lockId)
         let success = false

package/src/logic/neighbor-discovery/{HandshakerServer.ts → HandshakeRpcLocal.ts}

@@ -4,28 +4,28 @@ import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { NodeList } from '../NodeList'
 import { ConnectionLocker, DhtCallContext, PeerDescriptor } from '@streamr/dht'
 import { IHandshakeRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { RemoteHandshaker } from './RemoteHandshaker'
-import { RemoteRandomGraphNode } from '../RemoteRandomGraphNode'
+import { HandshakeRpcRemote } from './HandshakeRpcRemote'
+import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { binaryToHex } from '@streamr/utils'
+import { StreamPartID } from '@streamr/protocol'
 
-interface HandshakerServerConfig {
-    randomGraphId: string
-    ownPeerDescriptor: PeerDescriptor
+interface HandshakeRpcLocalConfig {
+    streamPartId: StreamPartID
     targetNeighbors: NodeList
     connectionLocker: ConnectionLocker
     ongoingHandshakes: Set<NodeID>
-    N: number
-    createRemoteHandshaker: (target: PeerDescriptor) => RemoteHandshaker
-    createRemoteNode: (peerDescriptor: PeerDescriptor) => RemoteRandomGraphNode
+    maxNeighborCount: number
+    createRpcRemote: (target: PeerDescriptor) => HandshakeRpcRemote
+    createDeliveryRpcRemote: (peerDescriptor: PeerDescriptor) => DeliveryRpcRemote
     handshakeWithInterleaving: (target: PeerDescriptor, senderId: NodeID) => Promise<boolean>
 }
 
-export class HandshakerServer implements IHandshakeRpc {
+export class HandshakeRpcLocal implements IHandshakeRpc {
 
-    private readonly config: HandshakerServerConfig
+    private readonly config: HandshakeRpcLocalConfig
 
-    constructor(config: HandshakerServerConfig) {
+    constructor(config: HandshakeRpcLocalConfig) {
         this.config = config
     }
 
@@ -40,7 +40,7 @@ export class HandshakerServer implements IHandshakeRpc {
             || this.config.ongoingHandshakes.has(getNodeIdFromPeerDescriptor(senderDescriptor))
         ) {
             return this.acceptHandshake(request, senderDescriptor)
-        } else if (this.config.targetNeighbors.size() + this.config.ongoingHandshakes.size < this.config.N) {
+        } else if (this.config.targetNeighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount) {
             return this.acceptHandshake(request, senderDescriptor)
         } else if (this.config.targetNeighbors.size(getInterleaveSourceIds()) >= 2) {
             return this.acceptHandshakeWithInterleaving(request, senderDescriptor)
@@ -54,8 +54,8 @@ export class HandshakerServer implements IHandshakeRpc {
             requestId: request.requestId,
             accepted: true
         }
-        this.config.targetNeighbors.add(this.config.createRemoteNode(requester))
-        this.config.connectionLocker.lockConnection(requester, this.config.randomGraphId)
+        this.config.targetNeighbors.add(this.config.createDeliveryRpcRemote(requester))
+        this.config.connectionLocker.lockConnection(requester, this.config.streamPartId)
         return res
     }
 
@@ -77,13 +77,13 @@ export class HandshakerServer implements IHandshakeRpc {
         const furthest = this.config.targetNeighbors.getFurthest(exclude)
         const furthestPeerDescriptor = furthest ? furthest.getPeerDescriptor() : undefined
         if (furthest) {
-            const remote = this.config.createRemoteHandshaker(furthest.getPeerDescriptor())
+            const remote = this.config.createRpcRemote(furthest.getPeerDescriptor())
             remote.interleaveNotice(requester)
             this.config.targetNeighbors.remove(furthest.getPeerDescriptor())
-            this.config.connectionLocker.unlockConnection(furthestPeerDescriptor!, this.config.randomGraphId)
+            this.config.connectionLocker.unlockConnection(furthestPeerDescriptor!, this.config.streamPartId)
         }
-        this.config.targetNeighbors.add(this.config.createRemoteNode(requester))
-        this.config.connectionLocker.lockConnection(requester, this.config.randomGraphId)
+        this.config.targetNeighbors.add(this.config.createDeliveryRpcRemote(requester))
+        this.config.connectionLocker.lockConnection(requester, this.config.streamPartId)
         return {
             requestId: request.requestId,
             accepted: true,
@@ -92,11 +92,11 @@ export class HandshakerServer implements IHandshakeRpc {
     }
 
     async interleaveNotice(message: InterleaveNotice, context: ServerCallContext): Promise<Empty> {
-        if (message.randomGraphId === this.config.randomGraphId) {
+        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.randomGraphId)
+                this.config.connectionLocker.unlockConnection(senderPeerDescriptor, this.config.streamPartId)
                 this.config.targetNeighbors.remove(senderPeerDescriptor)
             }
             this.config.handshakeWithInterleaving(message.interleaveTargetDescriptor!, senderId).catch((_e) => {})

package/src/logic/neighbor-discovery/{RemoteHandshaker.ts → HandshakeRpcRemote.ts}

@@ -1,5 +1,6 @@
-import { PeerDescriptor, Remote, UUID } from '@streamr/dht'
+import { PeerDescriptor, Remote } from '@streamr/dht'
 import { Logger, hexToBinary } 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'
@@ -11,7 +12,7 @@ interface HandshakeResponse {
     interleaveTargetDescriptor?: PeerDescriptor
 }
 
-export class RemoteHandshaker extends Remote<IHandshakeRpcClient> {
+export class HandshakeRpcRemote extends Remote<IHandshakeRpcClient> {
 
     async handshake(
         neighborIds: NodeID[],
@@ -19,8 +20,8 @@ export class RemoteHandshaker extends Remote<IHandshakeRpcClient> {
         interleaveSourceId?: NodeID
     ): Promise<HandshakeResponse> {
         const request: StreamPartHandshakeRequest = {
-            randomGraphId: this.getServiceId(),
-            requestId: new UUID().toString(),
+            streamPartId: this.getServiceId(),
+            requestId: v4(),
             neighborIds: neighborIds.map((id) => hexToBinary(id)),
             concurrentHandshakeTargetId: (concurrentHandshakeTargetId !== undefined) ? hexToBinary(concurrentHandshakeTargetId) : undefined,
             interleaveSourceId: (interleaveSourceId !== undefined) ? hexToBinary(interleaveSourceId) : undefined
@@ -41,7 +42,7 @@ export class RemoteHandshaker extends Remote<IHandshakeRpcClient> {
 
     interleaveNotice(originatorDescriptor: PeerDescriptor): void {
         const notification: InterleaveNotice = {
-            randomGraphId: this.getServiceId(),
+            streamPartId: this.getServiceId(),
             interleaveTargetDescriptor: originatorDescriptor
         }
         const options = this.formDhtRpcOptions({

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

@@ -1,10 +1,10 @@
 import { ConnectionLocker, PeerDescriptor } from '@streamr/dht'
 import { NodeList } from '../NodeList'
-import { RemoteRandomGraphNode } from '../RemoteRandomGraphNode'
+import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
 import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
 import {
     HandshakeRpcClient,
-    IHandshakeRpcClient, NetworkRpcClient
+    IHandshakeRpcClient, DeliveryRpcClient
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import {
     InterleaveNotice,
@@ -13,19 +13,20 @@ import {
 } 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'
+import { HandshakeRpcRemote } from './HandshakeRpcRemote'
+import { HandshakeRpcLocal } from './HandshakeRpcLocal'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { StreamPartID } from '@streamr/protocol'
 
 interface HandshakerConfig {
     ownPeerDescriptor: PeerDescriptor
-    randomGraphId: string
+    streamPartId: StreamPartID
     connectionLocker: ConnectionLocker
     targetNeighbors: NodeList
     nearbyNodeView: NodeList
     randomNodeView: NodeList
     rpcCommunicator: RpcCommunicator
-    N: number
+    maxNeighborCount: number
 }
 
 const logger = new Logger(module)
@@ -34,7 +35,7 @@ const PARALLEL_HANDSHAKE_COUNT = 2
 
 export interface IHandshaker {
     attemptHandshakesOnContacts(excludedIds: NodeID[]): Promise<NodeID[]>
-    getOngoingHandshakes(): Set<string>
+    getOngoingHandshakes(): Set<NodeID>
 }
 
 export class Handshaker implements IHandshaker {
@@ -42,33 +43,32 @@ export class Handshaker implements IHandshaker {
     private readonly ongoingHandshakes: Set<NodeID> = new Set()
     private config: HandshakerConfig
     private readonly client: ProtoRpcClient<IHandshakeRpcClient>
-    private readonly server: IHandshakeRpc
+    private readonly rpcLocal: 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,
+        this.rpcLocal = new HandshakeRpcLocal({
+            streamPartId: this.config.streamPartId,
             targetNeighbors: this.config.targetNeighbors,
             connectionLocker: this.config.connectionLocker,
             ongoingHandshakes: this.ongoingHandshakes,
-            N: this.config.N,
+            maxNeighborCount: this.config.maxNeighborCount,
             handshakeWithInterleaving: (target: PeerDescriptor, senderId: NodeID) => this.handshakeWithInterleaving(target, senderId),
-            createRemoteHandshaker: (target: PeerDescriptor) => this.createRemoteHandshaker(target),
-            createRemoteNode: (target: PeerDescriptor) => this.createRemoteNode(target)
+            createRpcRemote: (target: PeerDescriptor) => this.createRpcRemote(target),
+            createDeliveryRpcRemote: (target: PeerDescriptor) => this.createDeliveryRpcRemote(target)
         })
         this.config.rpcCommunicator.registerRpcNotification(InterleaveNotice, 'interleaveNotice',
-            (req: InterleaveNotice, context) => this.server.interleaveNotice(req, context))
+            (req: InterleaveNotice, context) => this.rpcLocal.interleaveNotice(req, context))
         this.config.rpcCommunicator.registerRpcMethod(StreamPartHandshakeRequest, StreamPartHandshakeResponse, 'handshake',
-            (req: StreamPartHandshakeRequest, context) => this.server.handshake(req, context))
+            (req: StreamPartHandshakeRequest, context) => this.rpcLocal.handshake(req, context))
     }
 
-    public async attemptHandshakesOnContacts(excludedIds: NodeID[]): Promise<NodeID[]> {
-        if (this.config.targetNeighbors.size() + this.ongoingHandshakes.size < this.config.N - 2) {
+    async attemptHandshakesOnContacts(excludedIds: NodeID[]): Promise<NodeID[]> {
+        if (this.config.targetNeighbors.size() + this.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.N) {
+        } else if (this.config.targetNeighbors.size() + this.ongoingHandshakes.size < this.config.maxNeighborCount) {
             logger.trace(`Attempting handshake with new target`)
             return this.selectNewTargetAndHandshake(excludedIds)
         }
@@ -82,7 +82,7 @@ export class Handshaker implements IHandshaker {
         return this.doParallelHandshakes(targetNeighbors, exclude)
     }
 
-    private selectParallelTargets(excludedIds: NodeID[]): RemoteHandshaker[] {
+    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)
@@ -90,12 +90,12 @@ export class Handshaker implements IHandshaker {
                 targetNeighbors.push(random)
             }
         }
-        return targetNeighbors.map((neighbor) => this.createRemoteHandshaker(neighbor.getPeerDescriptor()))
+        return targetNeighbors.map((neighbor) => this.createRpcRemote(neighbor.getPeerDescriptor()))
     }
 
-    private async doParallelHandshakes(targets: RemoteHandshaker[], excludedIds: NodeID[]): Promise<NodeID[]> {
+    private async doParallelHandshakes(targets: HandshakeRpcRemote[], excludedIds: NodeID[]): Promise<NodeID[]> {
         const results = await Promise.allSettled(
-            Array.from(targets.values()).map(async (target: RemoteHandshaker, i) => {
+            Array.from(targets.values()).map(async (target: HandshakeRpcRemote, i) => {
                 const otherNode = i === 0 ? targets[1] : targets[0]
                 const otherNodeId = otherNode ? getNodeIdFromPeerDescriptor(otherNode.getPeerDescriptor()) : undefined
                 return this.handshakeWithTarget(target, otherNodeId)
@@ -113,7 +113,7 @@ export class Handshaker implements IHandshaker {
         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.createRemoteHandshaker(targetNeighbor.getPeerDescriptor()))
+            const accepted = await this.handshakeWithTarget(this.createRpcRemote(targetNeighbor.getPeerDescriptor()))
             if (!accepted) {
                 excludedIds.push(getNodeIdFromPeerDescriptor(targetNeighbor.getPeerDescriptor()))
             }
@@ -121,7 +121,7 @@ export class Handshaker implements IHandshaker {
         return excludedIds
     }
 
-    private async handshakeWithTarget(targetNeighbor: RemoteHandshaker, concurrentNodeId?: NodeID): Promise<boolean> {
+    private async handshakeWithTarget(targetNeighbor: HandshakeRpcRemote, concurrentNodeId?: NodeID): Promise<boolean> {
         const targetNodeId = getNodeIdFromPeerDescriptor(targetNeighbor.getPeerDescriptor())
         this.ongoingHandshakes.add(targetNodeId)
         const result = await targetNeighbor.handshake(
@@ -129,8 +129,8 @@ export class Handshaker implements IHandshaker {
             concurrentNodeId
         )
         if (result.accepted) {
-            this.config.targetNeighbors.add(this.createRemoteNode(targetNeighbor.getPeerDescriptor()))
-            this.config.connectionLocker.lockConnection(targetNeighbor.getPeerDescriptor(), this.config.randomGraphId)
+            this.config.targetNeighbors.add(this.createDeliveryRpcRemote(targetNeighbor.getPeerDescriptor()))
+            this.config.connectionLocker.lockConnection(targetNeighbor.getPeerDescriptor(), this.config.streamPartId)
         }
         if (result.interleaveTargetDescriptor) {
             await this.handshakeWithInterleaving(result.interleaveTargetDescriptor, targetNodeId)
@@ -140,10 +140,10 @@ export class Handshaker implements IHandshaker {
     }
 
     private async handshakeWithInterleaving(target: PeerDescriptor, interleaveSourceId: NodeID): Promise<boolean> {
-        const targetNeighbor = new RemoteHandshaker(
+        const targetNeighbor = new HandshakeRpcRemote(
             this.config.ownPeerDescriptor,
             target,
-            this.config.randomGraphId,
+            this.config.streamPartId,
             this.client
         )
         const targetNodeId = getNodeIdFromPeerDescriptor(targetNeighbor.getPeerDescriptor())
@@ -154,27 +154,27 @@ export class Handshaker implements IHandshaker {
             interleaveSourceId
         )
         if (result.accepted) {
-            this.config.targetNeighbors.add(this.createRemoteNode(targetNeighbor.getPeerDescriptor()))
-            this.config.connectionLocker.lockConnection(targetNeighbor.getPeerDescriptor(), this.config.randomGraphId)
+            this.config.targetNeighbors.add(this.createDeliveryRpcRemote(targetNeighbor.getPeerDescriptor()))
+            this.config.connectionLocker.lockConnection(targetNeighbor.getPeerDescriptor(), this.config.streamPartId)
         }
         this.ongoingHandshakes.delete(targetNodeId)
         return result.accepted
     }
 
-    private createRemoteHandshaker(targetPeerDescriptor: PeerDescriptor): RemoteHandshaker {
-        return new RemoteHandshaker(this.config.ownPeerDescriptor, targetPeerDescriptor, this.config.randomGraphId, this.client)
+    private createRpcRemote(targetPeerDescriptor: PeerDescriptor): HandshakeRpcRemote {
+        return new HandshakeRpcRemote(this.config.ownPeerDescriptor, targetPeerDescriptor, this.config.streamPartId, this.client)
     }
 
-    private createRemoteNode(targetPeerDescriptor: PeerDescriptor): RemoteRandomGraphNode {
-        return new RemoteRandomGraphNode(
+    private createDeliveryRpcRemote(targetPeerDescriptor: PeerDescriptor): DeliveryRpcRemote {
+        return new DeliveryRpcRemote(
             this.config.ownPeerDescriptor,
             targetPeerDescriptor,
-            this.config.randomGraphId,
-            toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+            this.config.streamPartId,
+            toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
         )
     }
 
-    public getOngoingHandshakes(): Set<string> {
+    getOngoingHandshakes(): Set<NodeID> {
         return this.ongoingHandshakes
     }
 

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

@@ -6,7 +6,7 @@ interface FindNeighborsSessionConfig {
     targetNeighbors: NodeList
     nearbyNodeView: NodeList
     doFindNeighbors: (excludedNodes: NodeID[]) => Promise<NodeID[]>
-    N: number
+    minCount: number
 }
 
 const INITIAL_WAIT = 100
@@ -33,7 +33,7 @@ export class NeighborFinder implements INeighborFinder {
             return
         }
         const newExcludes = await this.config.doFindNeighbors(excluded)
-        if (this.config.targetNeighbors.size() < this.config.N && newExcludes.length < this.config.nearbyNodeView.size()) {
+        if (this.config.targetNeighbors.size() < this.config.minCount && newExcludes.length < this.config.nearbyNodeView.size()) {
             setAbortableTimeout(() => this.findNeighbors(newExcludes), INTERVAL, this.abortController.signal)
         } else {
             this.running = false

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

@@ -5,16 +5,17 @@ import { NeighborUpdateRpcClient } from '../../proto/packages/trackerless-networ
 import { Logger, scheduleAtInterval } from '@streamr/utils'
 import { INeighborFinder } from './NeighborFinder'
 import { NodeList } from '../NodeList'
-import { RemoteNeighborUpdateManager } from './RemoteNeighborUpdateManager'
-import { NeighborUpdateManagerServer } from './NeighborUpdateManagerServer'
+import { NeighborUpdateRpcRemote } from './NeighborUpdateRpcRemote'
+import { NeighborUpdateRpcLocal } from './NeighborUpdateRpcLocal'
 import { getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { StreamPartID } from '@streamr/protocol'
 
 interface NeighborUpdateManagerConfig {
     ownPeerDescriptor: PeerDescriptor
     targetNeighbors: NodeList
     nearbyNodeView: NodeList
     neighborFinder: INeighborFinder
-    randomGraphId: string
+    streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
     neighborUpdateInterval: number
 }
@@ -27,24 +28,26 @@ export interface INeighborUpdateManager {
 }
 
 export class NeighborUpdateManager implements INeighborUpdateManager {
+
     private readonly abortController: AbortController
     private readonly config: NeighborUpdateManagerConfig
     private readonly client: ProtoRpcClient<NeighborUpdateRpcClient>
-    private readonly server: NeighborUpdateManagerServer
+    private readonly rpcLocal: NeighborUpdateRpcLocal
+
     constructor(config: NeighborUpdateManagerConfig) {
         this.abortController = new AbortController()
         this.client = toProtoRpcClient(new NeighborUpdateRpcClient(config.rpcCommunicator.getRpcClientTransport()))
-        this.server = new NeighborUpdateManagerServer(config)
+        this.rpcLocal = new NeighborUpdateRpcLocal(config)
         this.config = config
         this.config.rpcCommunicator.registerRpcMethod(NeighborUpdate, NeighborUpdate, 'neighborUpdate',
-            (req: NeighborUpdate, context) => this.server.neighborUpdate(req, context))
+            (req: NeighborUpdate, context) => this.rpcLocal.neighborUpdate(req, context))
     }
 
-    public async start(): Promise<void> {
+    async start(): Promise<void> {
         await scheduleAtInterval(() => this.updateNeighborInfo(), this.config.neighborUpdateInterval, false, this.abortController.signal)
     }
 
-    public stop(): void {
+    stop(): void {
         this.abortController.abort()
     }
 
@@ -60,7 +63,7 @@ export class NeighborUpdateManager implements INeighborUpdateManager {
         }))
     }
 
-    private createRemote(targetPeerDescriptor: PeerDescriptor): RemoteNeighborUpdateManager {
-        return new RemoteNeighborUpdateManager(this.config.ownPeerDescriptor, targetPeerDescriptor, this.config.randomGraphId, this.client)
+    private createRemote(targetPeerDescriptor: PeerDescriptor): NeighborUpdateRpcRemote {
+        return new NeighborUpdateRpcRemote(this.config.ownPeerDescriptor, targetPeerDescriptor, this.config.streamPartId, this.client)
     }
 }