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

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,23 +39,23 @@ 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,
+                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,
+                streamPartId: this.config.streamPartId,
                 neighborDescriptors: this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor()),
                 removeMe: true
             }

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,14 +73,14 @@ 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) => {
@@ -89,7 +90,7 @@ export class ProxyStreamConnectionClient extends EventEmitter {
                 }
             },
             rpcCommunicator: this.rpcCommunicator,
-            markForInspection: (_senderId: NodeID, _messageId: MessageID) => {}
+            markForInspection: () => {}
         })
         this.propagation = new Propagation({
             minPropagationTargets: config.minPropagationTargets ?? 2,
@@ -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)
@@ -232,7 +232,7 @@ export class ProxyStreamConnectionClient extends EventEmitter {
     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)
         }
@@ -250,7 +250,7 @@ export class ProxyStreamConnectionClient extends EventEmitter {
 
     stop(): void {
         this.targetNeighbors.getAll().map((remote) => {
-            this.config.connectionLocker.unlockConnection(remote.getPeerDescriptor(), 'proxy-stream-connection-client')
+            this.config.connectionLocker.unlockConnection(remote.getPeerDescriptor(), SERVICE_ID)
             remote.leaveStreamPartNotice()
         })
         this.targetNeighbors.stop()

package/src/logic/proxy/{ProxyStreamConnectionServer.ts → ProxyConnectionRpcLocal.ts}

@@ -8,25 +8,24 @@ import {
     StreamMessageType
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { IProxyConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { RemoteRandomGraphNode } from '../RemoteRandomGraphNode'
-import { ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
+import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
+import { DhtCallContext, ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
-import { NetworkRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { EventEmitter } from 'eventemitter3'
 import { EthereumAddress, Logger, binaryToHex, toEthereumAddress } from '@streamr/utils'
 import { StreamPartID } from '@streamr/protocol'
 import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
-import { DhtCallContext } from '@streamr/dht/src/exports'
 
 const logger = new Logger(module)
 
 interface ProxyConnection {
     direction: ProxyDirection // Direction is from the client's point of view
     userId: EthereumAddress
-    remote: RemoteRandomGraphNode
+    remote: DeliveryRpcRemote
 }
 
-interface ProxyStreamConnectionServerConfig {
+interface ProxyConnectionRpcLocalConfig {
     ownPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
@@ -36,12 +35,12 @@ export interface Events {
     newConnection: (nodeId: NodeID) => void
 }
 
-export class ProxyStreamConnectionServer extends EventEmitter<Events> implements IProxyConnectionRpc {
+export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IProxyConnectionRpc {
 
-    private readonly config: ProxyStreamConnectionServerConfig
+    private readonly config: ProxyConnectionRpcLocalConfig
     private readonly connections: Map<NodeID, ProxyConnection> = new Map()
 
-    constructor(config: ProxyStreamConnectionServerConfig) {
+    constructor(config: ProxyConnectionRpcLocalConfig) {
         super()
         this.config = config
         this.config.rpcCommunicator.registerRpcMethod(ProxyConnectionRequest, ProxyConnectionResponse, 'requestConnection',
@@ -95,11 +94,11 @@ export class ProxyStreamConnectionServer extends EventEmitter<Events> implements
         this.connections.set(senderId, {
             direction: request.direction,
             userId: toEthereumAddress(binaryToHex(request.userId, true)),
-            remote: new RemoteRandomGraphNode(
+            remote: new DeliveryRpcRemote(
                 this.config.ownPeerDescriptor,
                 senderPeerDescriptor,
                 this.config.streamPartId,
-                toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
             )
         })
         const response: ProxyConnectionResponse = {

package/src/logic/proxy/{RemoteProxyServer.ts → ProxyConnectionRpcRemote.ts}

@@ -5,7 +5,7 @@ import { IProxyConnectionRpcClient } from '../../proto/packages/trackerless-netw
 
 const logger = new Logger(module)
 
-export class RemoteProxyServer extends Remote<IProxyConnectionRpcClient> {
+export class ProxyConnectionRpcRemote extends Remote<IProxyConnectionRpcClient> {
 
     async requestConnection(direction: ProxyDirection, userId: EthereumAddress): Promise<boolean> {
         const request: ProxyConnectionRequest = {

package/src/logic/temporary-connection/{TemporaryConnectionRpcServer.ts → TemporaryConnectionRpcLocal.ts}

@@ -2,25 +2,26 @@ import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { TemporaryConnectionRequest, TemporaryConnectionResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ITemporaryConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { DhtCallContext, ListeningRpcCommunicator } from '@streamr/dht'
-import { NetworkRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { NodeList } from '../NodeList'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
-import { RemoteRandomGraphNode } from '../RemoteRandomGraphNode'
+import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { StreamPartID } from '@streamr/protocol'
 
-interface TemporaryConnectionRpcServerConfig {
-    randomGraphId: string
+interface TemporaryConnectionRpcLocalConfig {
+    streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
     ownPeerDescriptor: PeerDescriptor
 } 
 
-export class TemporaryConnectionRpcServer implements ITemporaryConnectionRpc {
+export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
 
-    private readonly config: TemporaryConnectionRpcServerConfig
+    private readonly config: TemporaryConnectionRpcLocalConfig
     private readonly temporaryNodes: NodeList
 
-    constructor(config: TemporaryConnectionRpcServerConfig) {
+    constructor(config: TemporaryConnectionRpcLocalConfig) {
         this.config = config
         this.temporaryNodes = new NodeList(getNodeIdFromPeerDescriptor(config.ownPeerDescriptor), 10)
     }
@@ -38,11 +39,11 @@ export class TemporaryConnectionRpcServer implements ITemporaryConnectionRpc {
         context: ServerCallContext
     ): Promise<TemporaryConnectionResponse> {
         const sender = (context as DhtCallContext).incomingSourceDescriptor!
-        const remote = new RemoteRandomGraphNode(
+        const remote = new DeliveryRpcRemote(
             this.config.ownPeerDescriptor,
             sender,
-            this.config.randomGraphId,
-            toProtoRpcClient(new NetworkRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+            this.config.streamPartId,
+            toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
         )
         this.temporaryNodes.add(remote)
         return {

package/src/logic/temporary-connection/{RemoteTemporaryConnectionRpcServer.ts → TemporaryConnectionRpcRemote.ts}

@@ -5,7 +5,7 @@ import { ITemporaryConnectionRpcClient } from '../../proto/packages/trackerless-
 
 const logger = new Logger(module)
 
-export class RemoteTemporaryConnectionRpcServer extends Remote<ITemporaryConnectionRpcClient> {
+export class TemporaryConnectionRpcRemote extends Remote<ITemporaryConnectionRpcClient> {
 
     async openConnection(): Promise<boolean> {
         try {

package/src/proto/packages/dht/protos/DhtRpc.ts

@@ -231,10 +231,6 @@ export interface PeerDescriptor {
      * @generated from protobuf field: optional uint32 region = 7;
      */
     region?: number;
-    /**
-     * @generated from protobuf field: optional string nodeName = 8;
-     */
-    nodeName?: string;
 }
 /**
  * @generated from protobuf message dht.ConnectivityMethod
@@ -972,8 +968,7 @@ class PeerDescriptor$Type extends MessageType$<PeerDescriptor> {
             { no: 4, name: "tcp", kind: "message", T: () => ConnectivityMethod },
             { no: 5, name: "websocket", kind: "message", T: () => ConnectivityMethod },
             { no: 6, name: "openInternet", kind: "scalar", opt: true, T: 8 /*ScalarType.BOOL*/ },
-            { no: 7, name: "region", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ },
-            { no: 8, name: "nodeName", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+            { no: 7, name: "region", kind: "scalar", opt: true, T: 13 /*ScalarType.UINT32*/ }
         ]);
     }
 }

package/src/proto/packages/trackerless-network/protos/NetworkRpc.client.ts

@@ -15,7 +15,7 @@ import type { ProxyConnectionResponse } from "./NetworkRpc";
 import type { ProxyConnectionRequest } from "./NetworkRpc";
 import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
 import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
-import { NetworkRpc } from "./NetworkRpc";
+import { DeliveryRpc } from "./NetworkRpc";
 import type { LeaveStreamPartNotice } from "./NetworkRpc";
 import { stackIntercept } from "@protobuf-ts/runtime-rpc";
 import type { Empty } from "../../../google/protobuf/empty";
@@ -23,9 +23,9 @@ import type { StreamMessage } from "./NetworkRpc";
 import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
 import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
 /**
- * @generated from protobuf service NetworkRpc
+ * @generated from protobuf service DeliveryRpc
  */
-export interface INetworkRpcClient {
+export interface IDeliveryRpcClient {
     /**
      * @generated from protobuf rpc: sendStreamMessage(StreamMessage) returns (google.protobuf.Empty);
      */
@@ -36,12 +36,12 @@ export interface INetworkRpcClient {
     leaveStreamPartNotice(input: LeaveStreamPartNotice, options?: RpcOptions): UnaryCall<LeaveStreamPartNotice, Empty>;
 }
 /**
- * @generated from protobuf service NetworkRpc
+ * @generated from protobuf service DeliveryRpc
  */
-export class NetworkRpcClient implements INetworkRpcClient, ServiceInfo {
-    typeName = NetworkRpc.typeName;
-    methods = NetworkRpc.methods;
-    options = NetworkRpc.options;
+export class DeliveryRpcClient implements IDeliveryRpcClient, ServiceInfo {
+    typeName = DeliveryRpc.typeName;
+    methods = DeliveryRpc.methods;
+    options = DeliveryRpc.options;
     constructor(private readonly _transport: RpcTransport) {
     }
     /**

package/src/proto/packages/trackerless-network/protos/NetworkRpc.server.ts

@@ -14,9 +14,9 @@ import { Empty } from "../../../google/protobuf/empty";
 import { StreamMessage } from "./NetworkRpc";
 import { ServerCallContext } from "@protobuf-ts/runtime-rpc";
 /**
- * @generated from protobuf service NetworkRpc
+ * @generated from protobuf service DeliveryRpc
  */
-export interface INetworkRpc<T = ServerCallContext> {
+export interface IDeliveryRpc<T = ServerCallContext> {
     /**
      * @generated from protobuf rpc: sendStreamMessage(StreamMessage) returns (google.protobuf.Empty);
      */

package/src/proto/packages/trackerless-network/protos/NetworkRpc.ts

@@ -146,9 +146,9 @@ export interface GroupKey {
  */
 export interface StreamPartHandshakeRequest {
     /**
-     * @generated from protobuf field: string randomGraphId = 1;
+     * @generated from protobuf field: string streamPartId = 1;
      */
-    randomGraphId: string;
+    streamPartId: string;
     /**
      * @generated from protobuf field: string requestId = 2;
      */
@@ -188,9 +188,9 @@ export interface StreamPartHandshakeResponse {
  */
 export interface InterleaveNotice {
     /**
-     * @generated from protobuf field: string randomGraphId = 1;
+     * @generated from protobuf field: string streamPartId = 1;
      */
-    randomGraphId: string;
+    streamPartId: string;
     /**
      * this is a required field but in generated NetworkRpc.ts it is incorrectly annotated as optional (NET-1082)
      *
@@ -203,18 +203,18 @@ export interface InterleaveNotice {
  */
 export interface LeaveStreamPartNotice {
     /**
-     * @generated from protobuf field: string randomGraphId = 1;
+     * @generated from protobuf field: string streamPartId = 1;
      */
-    randomGraphId: string;
+    streamPartId: string;
 }
 /**
  * @generated from protobuf message NeighborUpdate
  */
 export interface NeighborUpdate {
     /**
-     * @generated from protobuf field: string randomGraphId = 1;
+     * @generated from protobuf field: string streamPartId = 1;
      */
-    randomGraphId: string;
+    streamPartId: string;
     /**
      * @generated from protobuf field: bool removeMe = 2;
      */
@@ -412,7 +412,7 @@ export const GroupKey = new GroupKey$Type();
 class StreamPartHandshakeRequest$Type extends MessageType<StreamPartHandshakeRequest> {
     constructor() {
         super("StreamPartHandshakeRequest", [
-            { no: 1, name: "randomGraphId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 1, name: "streamPartId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 3, name: "concurrentHandshakeTargetId", kind: "scalar", opt: true, T: 12 /*ScalarType.BYTES*/ },
             { no: 4, name: "neighborIds", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 12 /*ScalarType.BYTES*/ },
@@ -442,7 +442,7 @@ export const StreamPartHandshakeResponse = new StreamPartHandshakeResponse$Type(
 class InterleaveNotice$Type extends MessageType<InterleaveNotice> {
     constructor() {
         super("InterleaveNotice", [
-            { no: 1, name: "randomGraphId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 1, name: "streamPartId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "interleaveTargetDescriptor", kind: "message", T: () => PeerDescriptor }
         ]);
     }
@@ -455,7 +455,7 @@ export const InterleaveNotice = new InterleaveNotice$Type();
 class LeaveStreamPartNotice$Type extends MessageType<LeaveStreamPartNotice> {
     constructor() {
         super("LeaveStreamPartNotice", [
-            { no: 1, name: "randomGraphId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+            { no: 1, name: "streamPartId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
 }
@@ -467,7 +467,7 @@ export const LeaveStreamPartNotice = new LeaveStreamPartNotice$Type();
 class NeighborUpdate$Type extends MessageType<NeighborUpdate> {
     constructor() {
         super("NeighborUpdate", [
-            { no: 1, name: "randomGraphId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 1, name: "streamPartId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 2, name: "removeMe", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
             { no: 3, name: "neighborDescriptors", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor }
         ]);
@@ -525,9 +525,9 @@ class TemporaryConnectionResponse$Type extends MessageType<TemporaryConnectionRe
  */
 export const TemporaryConnectionResponse = new TemporaryConnectionResponse$Type();
 /**
- * @generated ServiceType for protobuf service NetworkRpc
+ * @generated ServiceType for protobuf service DeliveryRpc
  */
-export const NetworkRpc = new ServiceType("NetworkRpc", [
+export const DeliveryRpc = new ServiceType("DeliveryRpc", [
     { name: "sendStreamMessage", options: {}, I: StreamMessage, O: Empty },
     { name: "leaveStreamPartNotice", options: {}, I: LeaveStreamPartNotice, O: Empty }
 ]);

package/test/benchmark/first-message.ts

@@ -4,10 +4,10 @@ import { LatencyType, Simulator, getRandomRegion } from '@streamr/dht'
 import { MessageID, StreamMessage, StreamMessageType, StreamPartID, StreamPartIDUtils, toStreamID, toStreamPartID } from '@streamr/protocol'
 import { hexToBinary, utf8ToBinary, waitForEvent3 } from '@streamr/utils'
 import fs from 'fs'
-import { PeerDescriptor } from '../../../dht/src/exports'
+import { PeerDescriptor } from '@streamr/dht'
 import { NetworkNode } from '../../src/NetworkNode'
 import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
-import { streamPartIdToDataKey } from '../../src/logic/StreamPartEntryPointDiscovery'
+import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
 import { createMockPeerDescriptor, createNetworkNodeWithSimulator } from '../utils/utils'
 import { ILayer1 } from '../../src/logic/ILayer1'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
@@ -28,8 +28,7 @@ const prepareLayer0 = async () => {
     nodes = []
     simulator = new Simulator(LatencyType.REAL)
     const peerDescriptor = createMockPeerDescriptor({
-        region: getRandomRegion(),
-        nodeName: 'entrypoint'
+        region: getRandomRegion()
     })
     layer0Ep = peerDescriptor
     const entryPoint = createNetworkNodeWithSimulator(peerDescriptor, simulator, [peerDescriptor])
@@ -42,8 +41,7 @@ const prepareLayer0 = async () => {
 const prepareStream = async (streamId: string) => {
     console.log('Preparing stream ')
     const peerDescriptor = createMockPeerDescriptor({
-        region: getRandomRegion(),
-        nodeName: streamId
+        region: getRandomRegion()
     })
     const streamPartId = toStreamPartID(toStreamID(streamId), 0)
     const streamPublisher = createNetworkNodeWithSimulator(peerDescriptor, simulator, [layer0Ep])
@@ -61,10 +59,9 @@ const shutdownNetwork = async () => {
     simulator.stop()
 }
 
-const measureJoiningTime = async (count: number) => {
+const measureJoiningTime = async () => {
     const peerDescriptor = createMockPeerDescriptor({
-        region: getRandomRegion(),
-        nodeName: `${count}`
+        region: getRandomRegion()
     })
     console.log('starting node with id ', getNodeIdFromPeerDescriptor(peerDescriptor))
 
@@ -121,7 +118,7 @@ const run = async () => {
     
     fs.writeSync(logFile, 'Network size' + '\t' + 'Time to receive first message time (ms)' + '\n')
     for (let i = 0; i < numNodes; i++) {
-        const time = await measureJoiningTime(i)
+        const time = await measureJoiningTime()
         console.log(`Time to receive first message for ${i + 1} nodes network: ${time}ms`)
         fs.writeSync(logFile, `${i + 1}` + '\t' + `${Math.round(time)}\n`)
     }
@@ -140,9 +137,9 @@ run().then(() => {
     console.log(foundData)
     console.log(currentNode.stack.getLayer0DhtNode().getKBucketPeers().length)
     console.log(currentNode.stack.getLayer0DhtNode().getNumberOfConnections())
-    const stream = currentNode.stack.getStreamrNode().getStream(streamParts[0])! as { layer1: ILayer1, node: RandomGraphNode }
-    console.log(stream.layer1.getKBucketPeers())
-    console.log(stream.node.getTargetNeighborIds())
+    const streamPartDelivery = currentNode.stack.getStreamrNode().getStreamPartDelivery(streamParts[0])! as { layer1: ILayer1, node: RandomGraphNode }
+    console.log(streamPartDelivery.layer1.getKBucketPeers())
+    console.log(streamPartDelivery.node.getTargetNeighborIds())
     console.log(nodes[nodes.length - 1])
     if (publishInterval) {
         clearInterval(publishInterval)