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

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,11 +6,11 @@ interface FindNeighborsSessionConfig {
     targetNeighbors: NodeList
     nearbyNodeView: NodeList
     doFindNeighbors: (excludedNodes: NodeID[]) => Promise<NodeID[]>
-    N: number
+    minCount: number
 }
 
-const INITIAL_TIMEOUT = 100
-const INTERVAL_TIMEOUT = 250
+const INITIAL_WAIT = 100
+const INTERVAL = 250
 
 export interface INeighborFinder {
     start(excluded?: NodeID[]): void
@@ -33,8 +33,8 @@ 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()) {
-            setAbortableTimeout(() => this.findNeighbors(newExcludes), INTERVAL_TIMEOUT, this.abortController.signal)
+        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
         }
@@ -49,7 +49,7 @@ export class NeighborFinder implements INeighborFinder {
             return
         }
         this.running = true
-        setAbortableTimeout(() => this.findNeighbors(excluded), INITIAL_TIMEOUT, this.abortController.signal)
+        setAbortableTimeout(() => this.findNeighbors(excluded), INITIAL_WAIT, this.abortController.signal)
     }
 
     stop(): void {

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,31 +28,33 @@ 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()
     }
 
     private async updateNeighborInfo(): Promise<void> {
         logger.trace(`Updating neighbor info to nodes`)
-        const neighborDescriptors = this.config.targetNeighbors.getNodes().map((neighbor) => neighbor.getPeerDescriptor())
-        await Promise.allSettled(this.config.targetNeighbors.getNodes().map(async (neighbor) => {
+        const neighborDescriptors = this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor())
+        await Promise.allSettled(this.config.targetNeighbors.getAll().map(async (neighbor) => {
             const res = await this.createRemote(neighbor.getPeerDescriptor()).updateNeighbors(neighborDescriptors)
             if (res.removeMe) {
                 this.config.targetNeighbors.remove(neighbor.getPeerDescriptor())
@@ -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)
     }
 }

package/src/logic/neighbor-discovery/{NeighborUpdateManagerServer.ts → NeighborUpdateRpcLocal.ts}

@@ -1,33 +1,33 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext, ListeningRpcCommunicator } from '@streamr/dht'
-import { PeerDescriptor } from '@streamr/dht/src/exports'
+import { DhtCallContext, ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { NetworkRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { INeighborUpdateRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { NodeList } from '../NodeList'
-import { RemoteRandomGraphNode } from '../RemoteRandomGraphNode'
+import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
 import { INeighborFinder } from './NeighborFinder'
+import { StreamPartID } from '@streamr/protocol'
 
-interface NeighborUpdateManagerConfig {
+interface NeighborUpdateRpcLocalConfig {
     ownPeerDescriptor: PeerDescriptor
-    randomGraphId: string
+    streamPartId: StreamPartID
     targetNeighbors: NodeList
     nearbyNodeView: NodeList
     neighborFinder: INeighborFinder
     rpcCommunicator: ListeningRpcCommunicator
 }
 
-export class NeighborUpdateManagerServer implements INeighborUpdateRpc {
+export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
 
-    private readonly config: NeighborUpdateManagerConfig
+    private readonly config: NeighborUpdateRpcLocalConfig
 
-    constructor(config: NeighborUpdateManagerConfig) {
+    constructor(config: NeighborUpdateRpcLocalConfig) {
         this.config = config
     }
 
-    // INetworkRpc server method
+    // INeighborUpdateRpc server method
     async neighborUpdate(message: NeighborUpdate, context: ServerCallContext): Promise<NeighborUpdate> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
         const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
@@ -39,24 +39,24 @@ export class NeighborUpdateManagerServer implements INeighborUpdateRpc {
                     return nodeId !== ownNodeId && !this.config.targetNeighbors.getIds().includes(nodeId)
                 })
             newPeerDescriptors.forEach((peerDescriptor) => this.config.nearbyNodeView.add(
-                new RemoteRandomGraphNode(
+                new DeliveryRpcRemote(
                     this.config.ownPeerDescriptor,
                     peerDescriptor,
-                    this.config.randomGraphId,
-                    toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+                    this.config.streamPartId,
+                    toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
                 ))
             )
             this.config.neighborFinder.start()
             const response: NeighborUpdate = {
-                randomGraphId: this.config.randomGraphId,
-                neighborDescriptors: this.config.targetNeighbors.getNodes().map((neighbor) => neighbor.getPeerDescriptor()),
+                streamPartId: this.config.streamPartId,
+                neighborDescriptors: this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
                 removeMe: false
             }
             return response
         } else {
             const response: NeighborUpdate = {
-                randomGraphId: this.config.randomGraphId,
-                neighborDescriptors: this.config.targetNeighbors.getNodes().map((neighbor) => neighbor.getPeerDescriptor()),
+                streamPartId: this.config.streamPartId,
+                neighborDescriptors: this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
                 removeMe: true
             }
             return response

package/src/logic/neighbor-discovery/{RemoteNeighborUpdateManager.ts → NeighborUpdateRpcRemote.ts}

@@ -11,11 +11,11 @@ interface UpdateNeighborsResponse {
     removeMe: boolean
 }
 
-export class RemoteNeighborUpdateManager extends Remote<INeighborUpdateRpcClient> {
+export class NeighborUpdateRpcRemote extends Remote<INeighborUpdateRpcClient> {
 
     async updateNeighbors(neighbors: PeerDescriptor[]): Promise<UpdateNeighborsResponse> {
         const request: NeighborUpdate = {
-            randomGraphId: this.getServiceId(),
+            streamPartId: this.getServiceId(),
             neighborDescriptors: neighbors,
             removeMe: false
         }

package/src/logic/propagation/Propagation.ts

@@ -57,8 +57,8 @@ export class Propagation {
      * Node should invoke this when it learns about a new node stream assignment
      */
     onNeighborJoined(neighborId: NodeID): void {
-        const tasksOfStream = this.activeTaskStore.get()
-        for (const task of tasksOfStream) {
+        const tasks = this.activeTaskStore.get()
+        for (const task of tasks) {
             this.sendAndAwaitThenMark(task, neighborId)
         }
     }

package/src/logic/proxy/{ProxyStreamConnectionClient.ts → ProxyClient.ts}

@@ -1,9 +1,9 @@
 import {
+    ConnectionLocker,
     ITransport,
     ListeningRpcCommunicator,
     PeerDescriptor
 } from '@streamr/dht'
-import { ConnectionLocker } from '@streamr/dht/src/exports'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { StreamPartID } from '@streamr/protocol'
 import { EthereumAddress, Logger, addManagedEventListener, wait } from '@streamr/utils'
@@ -17,14 +17,15 @@ import {
     ProxyDirection,
     StreamMessage
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { NetworkRpcClient, ProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcClient, ProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { DuplicateMessageDetector } from '../DuplicateMessageDetector'
 import { NodeList } from '../NodeList'
-import { RemoteRandomGraphNode } from '../RemoteRandomGraphNode'
-import { StreamNodeServer } from '../StreamNodeServer'
+import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
+import { DeliveryRpcLocal } from '../DeliveryRpcLocal'
 import { Propagation } from '../propagation/Propagation'
 import { markAndCheckDuplicate } from '../utils'
-import { RemoteProxyServer } from './RemoteProxyServer'
+import { ProxyConnectionRpcRemote } from './ProxyConnectionRpcRemote'
+import { formStreamPartDeliveryServiceId } from '../formStreamPartDeliveryServiceId'
 
 export const retry = async <T>(task: () => Promise<T>, description: string, abortSignal: AbortSignal, delay = 10000): Promise<T> => {
     // eslint-disable-next-line no-constant-condition
@@ -41,13 +42,11 @@ export const retry = async <T>(task: () => Promise<T>, description: string, abor
     }
 }
 
-interface ProxyStreamConnectionClientConfig {
+interface ProxyClientConfig {
     P2PTransport: ITransport
     ownPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     connectionLocker: ConnectionLocker
-    userId: EthereumAddress
-    nodeName?: string
     minPropagationTargets?: number // TODO could be required option if we apply all defaults somewhere at higher level
 }
 
@@ -60,11 +59,13 @@ interface ProxyDefinition {
 
 const logger = new Logger(module)
 
-export class ProxyStreamConnectionClient extends EventEmitter {
+const SERVICE_ID = 'system/proxy-client'
+
+export class ProxyClient extends EventEmitter {
 
     private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly server: StreamNodeServer
-    private readonly config: ProxyStreamConnectionClientConfig
+    private readonly deliveryRpcLocal: DeliveryRpcLocal
+    private readonly config: ProxyClientConfig
     private readonly duplicateDetectors: Map<string, DuplicateMessageDetector> = new Map()
     private definition?: ProxyDefinition
     private readonly connections: Map<NodeID, ProxyDirection> = new Map()
@@ -72,29 +73,29 @@ export class ProxyStreamConnectionClient extends EventEmitter {
     private readonly targetNeighbors: NodeList
     private readonly abortController: AbortController
 
-    constructor(config: ProxyStreamConnectionClientConfig) {
+    constructor(config: ProxyClientConfig) {
         super()
         this.config = config
-        this.rpcCommunicator = new ListeningRpcCommunicator(`layer2-${config.streamPartId}`, config.P2PTransport)
+        this.rpcCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(config.streamPartId), config.P2PTransport)
         this.targetNeighbors = new NodeList(getNodeIdFromPeerDescriptor(this.config.ownPeerDescriptor), 1000)
-        this.server = new StreamNodeServer({
+        this.deliveryRpcLocal = new DeliveryRpcLocal({
             ownPeerDescriptor: this.config.ownPeerDescriptor,
-            randomGraphId: this.config.streamPartId,
+            streamPartId: this.config.streamPartId,
             markAndCheckDuplicate: (msg: MessageID, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
             broadcast: (message: StreamMessage, previousNode?: NodeID) => this.broadcast(message, previousNode),
             onLeaveNotice: (senderId: NodeID) => {
-                const contact = this.targetNeighbors.getNeighborById(senderId)
+                const contact = this.targetNeighbors.get(senderId)
                 if (contact) {
                     setImmediate(() => this.onNodeDisconnected(contact.getPeerDescriptor()))
                 }
             },
             rpcCommunicator: this.rpcCommunicator,
-            markForInspection: (_senderId: NodeID, _messageId: MessageID) => {}
+            markForInspection: () => {}
         })
         this.propagation = new Propagation({
             minPropagationTargets: config.minPropagationTargets ?? 2,
             sendToNeighbor: async (neighborId: NodeID, msg: StreamMessage): Promise<void> => {
-                const remote = this.targetNeighbors.getNeighborById(neighborId)
+                const remote = this.targetNeighbors.get(neighborId)
                 if (remote) {
                     await remote.sendStreamMessage(msg)
                 } else {
@@ -107,19 +108,18 @@ export class ProxyStreamConnectionClient extends EventEmitter {
 
     private registerDefaultServerMethods(): void {
         this.rpcCommunicator.registerRpcNotification(StreamMessage, 'sendStreamMessage',
-            (msg: StreamMessage, context) => this.server.sendStreamMessage(msg, context))
+            (msg: StreamMessage, context) => this.deliveryRpcLocal.sendStreamMessage(msg, context))
         this.rpcCommunicator.registerRpcNotification(LeaveStreamPartNotice, 'leaveStreamPartNotice',
-            (req: LeaveStreamPartNotice, context) => this.server.leaveStreamPartNotice(req, context))
+            (req: LeaveStreamPartNotice, context) => this.deliveryRpcLocal.leaveStreamPartNotice(req, context))
     }
 
     async setProxies(
-        streamPartId: StreamPartID,
         nodes: PeerDescriptor[],
         direction: ProxyDirection,
         userId: EthereumAddress,
         connectionCount?: number
     ): Promise<void> {
-        logger.trace('Setting proxies', { streamPartId, peerDescriptors: nodes, direction, userId, connectionCount })
+        logger.trace('Setting proxies', { streamPartId: this.config.streamPartId, peerDescriptors: nodes, direction, userId, connectionCount })
         if (connectionCount !== undefined && connectionCount > nodes.length) {
             throw Error('Cannot set connectionCount above the size of the configured array of nodes')
         }
@@ -167,16 +167,16 @@ export class ProxyStreamConnectionClient extends EventEmitter {
     private async attemptConnection(nodeId: NodeID, direction: ProxyDirection, userId: EthereumAddress): Promise<void> {
         const peerDescriptor = this.definition!.nodes.get(nodeId)!
         const client = toProtoRpcClient(new ProxyConnectionRpcClient(this.rpcCommunicator.getRpcClientTransport()))
-        const proxyNode = new RemoteProxyServer(this.config.ownPeerDescriptor, peerDescriptor, this.config.streamPartId, client)
-        const accepted = await proxyNode.requestConnection(direction, userId)
+        const rpcRemote = new ProxyConnectionRpcRemote(this.config.ownPeerDescriptor, peerDescriptor, this.config.streamPartId, client)
+        const accepted = await rpcRemote.requestConnection(direction, userId)
         if (accepted) {
-            this.config.connectionLocker.lockConnection(peerDescriptor, 'proxy-stream-connection-client')
+            this.config.connectionLocker.lockConnection(peerDescriptor, SERVICE_ID)
             this.connections.set(nodeId, direction)
-            const remote = new RemoteRandomGraphNode(
+            const remote = new DeliveryRpcRemote(
                 this.config.ownPeerDescriptor,
                 peerDescriptor,
                 this.config.streamPartId,
-                toProtoRpcClient(new NetworkRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new DeliveryRpcClient(this.rpcCommunicator.getRpcClientTransport()))
             )
             this.targetNeighbors.add(remote)
             this.propagation.onNeighborJoined(nodeId)
@@ -202,7 +202,7 @@ export class ProxyStreamConnectionClient extends EventEmitter {
             logger.info('Close proxy connection', {
                 nodeId
             })
-            const server = this.targetNeighbors.getNeighborById(nodeId)
+            const server = this.targetNeighbors.get(nodeId)
             server?.leaveStreamPartNotice()
             this.removeConnection(nodeId)
         }
@@ -221,11 +221,7 @@ export class ProxyStreamConnectionClient extends EventEmitter {
         this.propagation.feedUnseenMessage(msg, this.targetNeighbors.getIds(), previousNode ?? null)
     }
 
-    getTargetNeighborIds(): NodeID[] {
-        return this.targetNeighbors.getIds()
-    }
-
-    hasProxyConnection(nodeId: NodeID, direction: ProxyDirection): boolean {
+    hasConnection(nodeId: NodeID, direction: ProxyDirection): boolean {
         return this.connections.has(nodeId) && this.connections.get(nodeId) === direction
     }
 
@@ -233,10 +229,10 @@ export class ProxyStreamConnectionClient extends EventEmitter {
         return this.definition!.direction
     }
 
-    async onNodeDisconnected(peerDescriptor: PeerDescriptor): Promise<void> {
+    private async onNodeDisconnected(peerDescriptor: PeerDescriptor): Promise<void> {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         if (this.connections.has(nodeId)) {
-            this.config.connectionLocker.unlockConnection(peerDescriptor, 'proxy-stream-connection-client')
+            this.config.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID)
             this.removeConnection(nodeId)
             await retry(() => this.updateConnections(), 'updating proxy connections', this.abortController.signal)
         }
@@ -253,8 +249,8 @@ export class ProxyStreamConnectionClient extends EventEmitter {
     }
 
     stop(): void {
-        this.targetNeighbors.getNodes().map((remote) => {
-            this.config.connectionLocker.unlockConnection(remote.getPeerDescriptor(), 'proxy-stream-connection-client')
+        this.targetNeighbors.getAll().map((remote) => {
+            this.config.connectionLocker.unlockConnection(remote.getPeerDescriptor(), SERVICE_ID)
             remote.leaveStreamPartNotice()
         })
         this.targetNeighbors.stop()