@streamr/trackerless-network 100.0.0 → 100.1.0

package/src/NetworkStack.ts

@@ -4,21 +4,22 @@ import {
     DhtNodeOptions,
     ListeningRpcCommunicator,
     PeerDescriptor,
-    areEqualPeerDescriptors
+    areEqualPeerDescriptors,
+    getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
 import { StreamID, StreamPartID, toStreamPartID } from '@streamr/protocol'
 import { Logger, MetricsContext, waitForCondition } from '@streamr/utils'
 import { pull } from 'lodash'
 import { version as applicationVersion } from '../package.json'
+import { ContentDeliveryManager, ContentDeliveryManagerConfig } from './logic/ContentDeliveryManager'
 import { Layer0Node } from './logic/Layer0Node'
-import { StreamrNode, StreamrNodeConfig } from './logic/StreamrNode'
 import { NodeInfoClient } from './logic/node-info/NodeInfoClient'
 import { NODE_INFO_RPC_SERVICE_ID, NodeInfoRpcLocal } from './logic/node-info/NodeInfoRpcLocal'
 import { NodeInfoResponse, ProxyDirection, StreamMessage } from './proto/packages/trackerless-network/protos/NetworkRpc'
 
 export interface NetworkOptions {
     layer0?: DhtNodeOptions
-    networkNode?: StreamrNodeConfig
+    networkNode?: ContentDeliveryManagerConfig
     metricsContext?: MetricsContext
 }
 
@@ -54,7 +55,7 @@ export type NodeInfo = Required<NodeInfoResponse>
 export class NetworkStack {
 
     private layer0Node?: Layer0Node
-    private streamrNode?: StreamrNode
+    private contentDeliveryManager?: ContentDeliveryManager
     private stopped = false
     private readonly metricsContext: MetricsContext
     private readonly options: NetworkOptions
@@ -68,7 +69,7 @@ export class NetworkStack {
             ...options.layer0,
             metricsContext: this.metricsContext
         })
-        this.streamrNode = new StreamrNode({
+        this.contentDeliveryManager = new ContentDeliveryManager({
             ...options.networkNode,
             metricsContext: this.metricsContext
         })
@@ -76,32 +77,36 @@ export class NetworkStack {
     }
 
     async joinStreamPart(streamPartId: StreamPartID, neighborRequirement?: { minCount: number, timeout: number }): Promise<void> {
-        if (this.getStreamrNode().isProxiedStreamPart(streamPartId)) {
+        if (this.getContentDeliveryManager().isProxiedStreamPart(streamPartId)) {
             throw new Error(`Cannot join to ${streamPartId} as proxy connections have been set`)
         }
         await this.ensureConnectedToControlLayer()
-        this.getStreamrNode().joinStreamPart(streamPartId)
+        this.getContentDeliveryManager().joinStreamPart(streamPartId)
         if (neighborRequirement !== undefined) {
             await waitForCondition(() => {
-                return this.getStreamrNode().getNeighbors(streamPartId).length >= neighborRequirement.minCount
+                return this.getContentDeliveryManager().getNeighbors(streamPartId).length >= neighborRequirement.minCount
             }, neighborRequirement.timeout)
         }
     }
 
     async broadcast(msg: StreamMessage): Promise<void> {
         const streamPartId = toStreamPartID(msg.messageId!.streamId as StreamID, msg.messageId!.streamPartition)
-        if (this.getStreamrNode().isProxiedStreamPart(streamPartId, ProxyDirection.SUBSCRIBE) && (msg.body.oneofKind === 'contentMessage')) {
+        if (
+            this.getContentDeliveryManager().isProxiedStreamPart(streamPartId, ProxyDirection.SUBSCRIBE) 
+            && (msg.body.oneofKind === 'contentMessage')
+        ) {
             throw new Error(`Cannot broadcast to ${streamPartId} as proxy subscribe connections have been set`)
         }
         // TODO could combine these two calls to isProxiedStreamPart?
-        if (!this.streamrNode!.isProxiedStreamPart(streamPartId)) {
+        if (!this.contentDeliveryManager!.isProxiedStreamPart(streamPartId)) {
             await this.ensureConnectedToControlLayer()
         }
-        this.getStreamrNode().broadcast(msg)
+        this.getContentDeliveryManager().broadcast(msg)
     }
 
     async start(doJoin = true): Promise<void> {
         await this.layer0Node!.start()
+        logger.info(`Starting node with id ${getNodeIdFromPeerDescriptor(this.layer0Node!.getLocalPeerDescriptor())}`)
         const connectionManager = this.layer0Node!.getTransport() as ConnectionManager
         if ((this.options.layer0?.entryPoints !== undefined) && (this.options.layer0.entryPoints.some((entryPoint) => 
             areEqualPeerDescriptors(entryPoint, this.layer0Node!.getLocalPeerDescriptor())
@@ -114,8 +119,8 @@ export class NetworkStack {
             }
         }
         // TODO: remove undefined checks here. Assume that start is approproately awaited before stop is called.
-        await this.streamrNode?.start(this.layer0Node!, connectionManager, connectionManager)
-        if (this.streamrNode) {
+        await this.contentDeliveryManager?.start(this.layer0Node!, connectionManager, connectionManager)
+        if (this.contentDeliveryManager) {
             const infoRpcCommunicator = new ListeningRpcCommunicator(NODE_INFO_RPC_SERVICE_ID, this.getConnectionManager())
             this.nodeInfoRpcLocal = new NodeInfoRpcLocal(this, infoRpcCommunicator)
             this.nodeInfoClient = new NodeInfoClient(
@@ -140,8 +145,8 @@ export class NetworkStack {
         }
     }
 
-    getStreamrNode(): StreamrNode {
-        return this.streamrNode!
+    getContentDeliveryManager(): ContentDeliveryManager {
+        return this.contentDeliveryManager!
     }
 
     getLayer0Node(): Layer0Node {
@@ -167,7 +172,7 @@ export class NetworkStack {
                 connections: this.getLayer0Node().getConnections(),
                 neighbors: this.getLayer0Node().getNeighbors()
             },
-            streamPartitions: this.getStreamrNode().getNodeInfo(),
+            streamPartitions: this.getContentDeliveryManager().getNodeInfo(),
             version: applicationVersion
         }
     }
@@ -184,9 +189,9 @@ export class NetworkStack {
         if (!this.stopped) {
             this.stopped = true
             pull(instances, this)
-            await this.streamrNode!.destroy()
+            await this.contentDeliveryManager!.destroy()
             await this.layer0Node!.stop()
-            this.streamrNode = undefined
+            this.contentDeliveryManager = undefined
             this.layer0Node = undefined
         }
     }

package/src/exports.ts

@@ -1,6 +1,6 @@
 export { NetworkStack, NetworkOptions, NodeInfo } from './NetworkStack'
 export { NetworkNode, createNetworkNode } from './NetworkNode'
-export { StreamrNodeConfig } from './logic/StreamrNode'
+export { ContentDeliveryManagerConfig } from './logic/ContentDeliveryManager'
 export { ProxyDirection, GroupKeyRequest, GroupKeyResponse } from './proto/packages/trackerless-network/protos/NetworkRpc'
 export { streamPartIdToDataKey } from './logic/EntryPointDiscovery'
 export {

package/src/logic/{StreamrNode.ts → ContentDeliveryManager.ts}

@@ -1,10 +1,10 @@
 import {
     ConnectionLocker,
+    DhtAddress,
     DhtNode,
+    EXISTING_CONNECTION_TIMEOUT,
     ITransport,
     PeerDescriptor,
-    EXISTING_CONNECTION_TIMEOUT,
-    DhtAddress,
     getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
 import { StreamID, StreamPartID, StreamPartIDUtils, toStreamPartID } from '@streamr/protocol'
@@ -18,11 +18,11 @@ import {
 } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { sampleSize } from 'lodash'
-import { ProxyDirection, StreamPartitionInfo, StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
+import { ProxyDirection, StreamMessage, StreamPartitionInfo } from '../proto/packages/trackerless-network/protos/NetworkRpc'
+import { EntryPointDiscovery, NETWORK_SPLIT_AVOIDANCE_LIMIT } from './EntryPointDiscovery'
 import { Layer0Node } from './Layer0Node'
 import { Layer1Node } from './Layer1Node'
 import { RandomGraphNode } from './RandomGraphNode'
-import { NETWORK_SPLIT_AVOIDANCE_LIMIT, EntryPointDiscovery } from './EntryPointDiscovery'
 import { createRandomGraphNode } from './createRandomGraphNode'
 import { ProxyClient } from './proxy/ProxyClient'
 
@@ -50,7 +50,7 @@ interface Metrics extends MetricsDefinition {
     broadcastBytesPerSecond: Metric
 }
 
-export interface StreamrNodeConfig {
+export interface ContentDeliveryManagerConfig {
     metricsContext?: MetricsContext
     streamPartitionNeighborTargetCount?: number
     streamPartitionMinPropagationTargets?: number
@@ -58,20 +58,20 @@ export interface StreamrNodeConfig {
     rpcRequestTimeout?: number
 }
 
-// TODO rename class?
-export class StreamrNode extends EventEmitter<Events> {
+export class ContentDeliveryManager extends EventEmitter<Events> {
+
     private transport?: ITransport
     private connectionLocker?: ConnectionLocker
     private layer0Node?: Layer0Node
     private readonly metricsContext: MetricsContext
     private readonly metrics: Metrics
-    private readonly config: StreamrNodeConfig
+    private readonly config: ContentDeliveryManagerConfig
     private readonly streamParts: Map<StreamPartID, StreamPartDelivery>
     private readonly knownStreamPartEntryPoints: Map<StreamPartID, PeerDescriptor[]> = new Map()
     private started = false
     private destroyed = false
 
-    constructor(config: StreamrNodeConfig) {
+    constructor(config: ContentDeliveryManagerConfig) {
         super()
         this.config = config
         this.streamParts = new Map()
@@ -87,7 +87,6 @@ export class StreamrNode extends EventEmitter<Events> {
         if (this.started || this.destroyed) {
             return
         }
-        logger.info(`Starting new StreamrNode with id ${getNodeIdFromPeerDescriptor(startedAndJoinedLayer0Node.getLocalPeerDescriptor())}`)
         this.started = true
         this.layer0Node = startedAndJoinedLayer0Node
         this.transport = transport
@@ -98,7 +97,7 @@ export class StreamrNode extends EventEmitter<Events> {
         if (!this.started || this.destroyed) {
             return
         }
-        logger.trace('Destroying StreamrNode...')
+        logger.trace('Destroying ContentDeliveryManager')
         this.destroyed = true
         await Promise.all(Array.from(this.streamParts.values()).map((streamPart) => streamPart.stop()))
         this.streamParts.clear()
@@ -175,7 +174,7 @@ export class StreamrNode extends EventEmitter<Events> {
             try {
                 await this.startLayersAndJoinDht(streamPartId, entryPointDiscovery)
             } catch (err) {
-                logger.warn(`Failed to join to stream part ${streamPartId} with error: ${err}`)
+                logger.warn(`Failed to join to stream part ${streamPartId}`, { err })
             }
         })
     }
@@ -297,7 +296,7 @@ export class StreamrNode extends EventEmitter<Events> {
             return {
                 id: streamPartId,
                 controlLayerNeighbors: stream.layer1Node.getNeighbors(),
-                deliveryLayerNeighbors: stream.node.getNeighbors()
+                contentDeliveryLayerNeighbors: stream.node.getNeighbors()
             }
         })
 

package/src/logic/{DeliveryRpcLocal.ts → ContentDeliveryRpcLocal.ts}

@@ -6,11 +6,11 @@ import {
     MessageRef,
     StreamMessage
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import { IDeliveryRpc } from '../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { IContentDeliveryRpc } from '../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { StreamPartID } from '@streamr/protocol'
 
-export interface DeliveryRpcLocalConfig {
+export interface ContentDeliveryRpcLocalConfig {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     markAndCheckDuplicate: (messageId: MessageID, previousMessageRef?: MessageRef) => boolean
@@ -20,11 +20,11 @@ export interface DeliveryRpcLocalConfig {
     rpcCommunicator: ListeningRpcCommunicator
 }
 
-export class DeliveryRpcLocal implements IDeliveryRpc {
+export class ContentDeliveryRpcLocal implements IContentDeliveryRpc {
     
-    private readonly config: DeliveryRpcLocalConfig
+    private readonly config: ContentDeliveryRpcLocalConfig
 
-    constructor(config: DeliveryRpcLocalConfig) {
+    constructor(config: ContentDeliveryRpcLocalConfig) {
         this.config = config
     }
 

package/src/logic/{DeliveryRpcRemote.ts → ContentDeliveryRpcRemote.ts}

@@ -4,12 +4,12 @@ import {
     LeaveStreamPartNotice,
     StreamMessage
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
-import { DeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { StreamPartID } from '@streamr/protocol'
 
 const logger = new Logger(module)
 
-export class DeliveryRpcRemote extends RpcRemote<DeliveryRpcClient> {
+export class ContentDeliveryRpcRemote extends RpcRemote<ContentDeliveryRpcClient> {
 
     async sendStreamMessage(msg: StreamMessage): Promise<void> {
         const options = this.formDhtRpcOptions({

package/src/logic/EntryPointDiscovery.ts

@@ -46,7 +46,7 @@ const exponentialRunOff = async (
         try { // Abort controller throws unexpected errors in destroy?
             await wait(delay, abortSignal)
         } catch (err) {
-            logger.trace(`${err}`)
+            logger.trace(`${err}`)  // TODO Do we need logging?
         }
     }
 }

package/src/logic/NodeList.ts

@@ -1,14 +1,14 @@
 import { DhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { sample } from 'lodash'
-import { DeliveryRpcRemote } from './DeliveryRpcRemote'
+import { ContentDeliveryRpcRemote } from './ContentDeliveryRpcRemote'
 import { EventEmitter } from 'eventemitter3'
 
 export interface Events {
-    nodeAdded: (id: DhtAddress, remote: DeliveryRpcRemote) => void
-    nodeRemoved: (id: DhtAddress, remote: DeliveryRpcRemote) => void
+    nodeAdded: (id: DhtAddress, remote: ContentDeliveryRpcRemote) => void
+    nodeRemoved: (id: DhtAddress, remote: ContentDeliveryRpcRemote) => void
 }
 
-const getValuesOfIncludedKeys = (nodes: Map<DhtAddress, DeliveryRpcRemote>, exclude: DhtAddress[]): DeliveryRpcRemote[] => {
+const getValuesOfIncludedKeys = (nodes: Map<DhtAddress, ContentDeliveryRpcRemote>, exclude: DhtAddress[]): ContentDeliveryRpcRemote[] => {
     return Array.from(nodes.entries())
         .filter(([id, _node]) => !exclude.includes(id))
         .map(([_id, node]) => node)
@@ -17,7 +17,7 @@ const getValuesOfIncludedKeys = (nodes: Map<DhtAddress, DeliveryRpcRemote>, excl
 // The items in the list are in the insertion order
 
 export class NodeList extends EventEmitter<Events> {
-    private readonly nodes: Map<DhtAddress, DeliveryRpcRemote>
+    private readonly nodes: Map<DhtAddress, ContentDeliveryRpcRemote>
     private readonly limit: number
     private ownId: DhtAddress
 
@@ -28,7 +28,7 @@ export class NodeList extends EventEmitter<Events> {
         this.ownId = ownId
     }
 
-    add(remote: DeliveryRpcRemote): void {
+    add(remote: ContentDeliveryRpcRemote): void {
         const nodeId = getNodeIdFromPeerDescriptor(remote.getPeerDescriptor())
         if ((this.ownId !== nodeId) && (this.nodes.size < this.limit)) {
             const isExistingNode = this.nodes.has(nodeId)
@@ -53,7 +53,7 @@ export class NodeList extends EventEmitter<Events> {
     }
 
     // Replace nodes does not emit nodeRemoved events, use with caution
-    replaceAll(neighbors: DeliveryRpcRemote[]): void {
+    replaceAll(neighbors: ContentDeliveryRpcRemote[]): void {
         this.nodes.clear()
         const limited = neighbors.splice(0, this.limit)
         limited.forEach((remote) => {
@@ -65,7 +65,7 @@ export class NodeList extends EventEmitter<Events> {
         return Array.from(this.nodes.keys())
     }
 
-    get(id: DhtAddress): DeliveryRpcRemote | undefined {
+    get(id: DhtAddress): ContentDeliveryRpcRemote | undefined {
         return this.nodes.get(id)
     }
 
@@ -73,16 +73,16 @@ export class NodeList extends EventEmitter<Events> {
         return Array.from(this.nodes.keys()).filter((node) => !exclude.includes(node)).length
     }
 
-    getRandom(exclude: DhtAddress[]): DeliveryRpcRemote | undefined {
+    getRandom(exclude: DhtAddress[]): ContentDeliveryRpcRemote | undefined {
         return sample(getValuesOfIncludedKeys(this.nodes, exclude))
     }
 
-    getFirst(exclude: DhtAddress[]): DeliveryRpcRemote | undefined {
+    getFirst(exclude: DhtAddress[]): ContentDeliveryRpcRemote | undefined {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         return included[0]
     }
 
-    getFirstAndLast(exclude: DhtAddress[]): DeliveryRpcRemote[] {
+    getFirstAndLast(exclude: DhtAddress[]): ContentDeliveryRpcRemote[] {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         if (included.length === 0) {
             return []
@@ -90,12 +90,12 @@ export class NodeList extends EventEmitter<Events> {
         return included.length > 1 ? [this.getFirst(exclude)!, this.getLast(exclude)!] : [this.getFirst(exclude)!]
     }
 
-    getLast(exclude: DhtAddress[]): DeliveryRpcRemote | undefined {
+    getLast(exclude: DhtAddress[]): ContentDeliveryRpcRemote | undefined {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         return included[included.length - 1]
     }
 
-    getAll(): DeliveryRpcRemote[] {
+    getAll(): ContentDeliveryRpcRemote[] {
         return Array.from(this.nodes.values())
     }
 

package/src/logic/RandomGraphNode.ts

@@ -18,16 +18,15 @@ import {
     CloseTemporaryConnection,
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
 import { NodeList } from './NodeList'
-import { DeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { DeliveryRpcRemote } from './DeliveryRpcRemote'
-import { IDeliveryRpc } from '../proto/packages/trackerless-network/protos/NetworkRpc.server'
+import { ContentDeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcRemote } from './ContentDeliveryRpcRemote'
 import { DuplicateMessageDetector } from './DuplicateMessageDetector'
 import { Logger, addManagedEventListener } from '@streamr/utils'
 import { Handshaker } from './neighbor-discovery/Handshaker'
 import { Propagation } from './propagation/Propagation'
 import { NeighborFinder } from './neighbor-discovery/NeighborFinder'
 import { NeighborUpdateManager } from './neighbor-discovery/NeighborUpdateManager'
-import { DeliveryRpcLocal } from './DeliveryRpcLocal'
+import { ContentDeliveryRpcLocal } from './ContentDeliveryRpcLocal'
 import { ProxyConnectionRpcLocal } from './proxy/ProxyConnectionRpcLocal'
 import { Inspector } from './inspect/Inspector'
 import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'
@@ -75,14 +74,14 @@ export class RandomGraphNode extends EventEmitter<Events> {
     private started = false
     private readonly duplicateDetectors: Map<string, DuplicateMessageDetector>
     private config: StrictRandomGraphNodeConfig
-    private readonly deliveryRpcLocal: IDeliveryRpc
+    private readonly contentDeliveryRpcLocal: ContentDeliveryRpcLocal
     private abortController: AbortController = new AbortController()
 
     constructor(config: StrictRandomGraphNodeConfig) {
         super()
         this.config = config
         this.duplicateDetectors = new Map()
-        this.deliveryRpcLocal = new DeliveryRpcLocal({
+        this.contentDeliveryRpcLocal = new ContentDeliveryRpcLocal({
             localPeerDescriptor: this.config.localPeerDescriptor,
             streamPartId: this.config.streamPartId,
             rpcCommunicator: this.config.rpcCommunicator,
@@ -206,9 +205,9 @@ export class RandomGraphNode extends EventEmitter<Events> {
 
     private registerDefaultServerMethods(): void {
         this.config.rpcCommunicator.registerRpcNotification(StreamMessage, 'sendStreamMessage',
-            (msg: StreamMessage, context) => this.deliveryRpcLocal.sendStreamMessage(msg, context))
+            (msg: StreamMessage, context) => this.contentDeliveryRpcLocal.sendStreamMessage(msg, context))
         this.config.rpcCommunicator.registerRpcNotification(LeaveStreamPartNotice, 'leaveStreamPartNotice',
-            (req: LeaveStreamPartNotice, context) => this.deliveryRpcLocal.leaveStreamPartNotice(req, context))
+            (req: LeaveStreamPartNotice, context) => this.contentDeliveryRpcLocal.leaveStreamPartNotice(req, context))
         this.config.rpcCommunicator.registerRpcMethod(TemporaryConnectionRequest, TemporaryConnectionResponse, 'openConnection',
             (req: TemporaryConnectionRequest, context) => this.config.temporaryConnectionRpcLocal.openConnection(req, context))
         this.config.rpcCommunicator.registerRpcNotification(CloseTemporaryConnection, 'closeConnection',
@@ -221,20 +220,20 @@ export class RandomGraphNode extends EventEmitter<Events> {
             return
         }
         this.config.leftNodeView.replaceAll(ringPeers.left.map((peer) => 
-            new DeliveryRpcRemote(
+            new ContentDeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 peer,
                 this.config.rpcCommunicator,
-                DeliveryRpcClient,
+                ContentDeliveryRpcClient,
                 this.config.rpcRequestTimeout
             )
         ))
         this.config.rightNodeView.replaceAll(ringPeers.right.map((peer) =>
-            new DeliveryRpcRemote(
+            new ContentDeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 peer,
                 this.config.rpcCommunicator,
-                DeliveryRpcClient,
+                ContentDeliveryRpcClient,
                 this.config.rpcRequestTimeout
             )
         ))
@@ -261,11 +260,11 @@ export class RandomGraphNode extends EventEmitter<Events> {
 
     private updateNearbyNodeView(nodes: PeerDescriptor[]) {
         this.config.nearbyNodeView.replaceAll(Array.from(nodes).map((descriptor) =>
-            new DeliveryRpcRemote(
+            new ContentDeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 descriptor,
                 this.config.rpcCommunicator,
-                DeliveryRpcClient,
+                ContentDeliveryRpcClient,
                 this.config.rpcRequestTimeout
             )
         ))
@@ -274,13 +273,12 @@ export class RandomGraphNode extends EventEmitter<Events> {
                 break
             }
             this.config.nearbyNodeView.add(
-                new DeliveryRpcRemote(
+                new ContentDeliveryRpcRemote(
                     this.config.localPeerDescriptor,
                     descriptor,
                     this.config.rpcCommunicator,
-                    DeliveryRpcClient,
+                    ContentDeliveryRpcClient,
                     this.config.rpcRequestTimeout
-
                 )
             )
         }
@@ -291,11 +289,11 @@ export class RandomGraphNode extends EventEmitter<Events> {
             return
         }
         this.config.randomNodeView.replaceAll(randomNodes.map((descriptor) =>
-            new DeliveryRpcRemote(
+            new ContentDeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 descriptor,
                 this.config.rpcCommunicator,
-                DeliveryRpcClient,
+                ContentDeliveryRpcClient,
                 this.config.rpcRequestTimeout
             )
         ))
@@ -310,11 +308,11 @@ export class RandomGraphNode extends EventEmitter<Events> {
             return
         }
         this.config.randomNodeView.replaceAll(randomNodes.map((descriptor) =>
-            new DeliveryRpcRemote(
+            new ContentDeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 descriptor,
                 this.config.rpcCommunicator,
-                DeliveryRpcClient,
+                ContentDeliveryRpcClient,
                 this.config.rpcRequestTimeout
             )
         ))

package/src/logic/createRandomGraphNode.ts

@@ -10,7 +10,7 @@ import { MarkOptional } from 'ts-essentials'
 import { ProxyConnectionRpcLocal } from './proxy/ProxyConnectionRpcLocal'
 import { Inspector } from './inspect/Inspector'
 import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'
-import { formStreamPartDeliveryServiceId } from './formStreamPartDeliveryServiceId'
+import { formStreamPartContentDeliveryServiceId } from './formStreamPartDeliveryServiceId'
 
 type RandomGraphNodeConfig = MarkOptional<StrictRandomGraphNodeConfig,
     'nearbyNodeView' | 'randomNodeView' | 'neighbors' | 'leftNodeView' | 'rightNodeView' | 'propagation'
@@ -26,7 +26,7 @@ type RandomGraphNodeConfig = MarkOptional<StrictRandomGraphNodeConfig,
 const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGraphNodeConfig => {
     const ownNodeId = getNodeIdFromPeerDescriptor(config.localPeerDescriptor)
     const rpcCommunicator = config.rpcCommunicator ?? new ListeningRpcCommunicator(
-        formStreamPartDeliveryServiceId(config.streamPartId),
+        formStreamPartContentDeliveryServiceId(config.streamPartId),
         config.transport
     )
     const neighborTargetCount = config.neighborTargetCount ?? 4

package/src/logic/formStreamPartDeliveryServiceId.ts

@@ -1,6 +1,7 @@
 import { ServiceID } from '@streamr/dht'
 import { StreamPartID } from '@streamr/protocol'
 
-export const formStreamPartDeliveryServiceId = (streamPartId: StreamPartID): ServiceID => {
+export const formStreamPartContentDeliveryServiceId = (streamPartId: StreamPartID): ServiceID => {
+    // could be "content-delivery" instead of "delivery", but that is a breaking change
     return `stream-part-delivery-${streamPartId}`
 }

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

@@ -16,7 +16,7 @@ import {
 } from '@streamr/dht'
 import { IHandshakeRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { HandshakeRpcRemote } from './HandshakeRpcRemote'
-import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
+import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 import { Logger } from '@streamr/utils'
 import { StreamPartID } from '@streamr/protocol'
 
@@ -27,7 +27,7 @@ interface HandshakeRpcLocalConfig {
     ongoingInterleaves: Set<DhtAddress>
     maxNeighborCount: number
     createRpcRemote: (target: PeerDescriptor) => HandshakeRpcRemote
-    createDeliveryRpcRemote: (peerDescriptor: PeerDescriptor) => DeliveryRpcRemote
+    createContentDeliveryRpcRemote: (peerDescriptor: PeerDescriptor) => ContentDeliveryRpcRemote
     handshakeWithInterleaving: (target: PeerDescriptor, senderId: DhtAddress) => Promise<boolean>
 }
 
@@ -74,7 +74,7 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
             requestId: request.requestId,
             accepted: true
         }
-        this.config.neighbors.add(this.config.createDeliveryRpcRemote(requester))
+        this.config.neighbors.add(this.config.createContentDeliveryRpcRemote(requester))
         return res
     }
 
@@ -117,7 +117,7 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
                 this.config.ongoingInterleaves.delete(nodeId)
             })
         }
-        this.config.neighbors.add(this.config.createDeliveryRpcRemote(requester))
+        this.config.neighbors.add(this.config.createContentDeliveryRpcRemote(requester))
         return {
             requestId: request.requestId,
             accepted: true,
@@ -133,7 +133,7 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
             this.config.neighbors.remove(senderId)
             return { accepted: true }
         } catch (err) {
-            logger.debug(`interleaveRequest to ${getNodeIdFromPeerDescriptor(message.interleaveTargetDescriptor!)} failed: ${err}`)
+            logger.debug(`interleaveRequest to ${getNodeIdFromPeerDescriptor(message.interleaveTargetDescriptor!)} failed`, { err })
             return { accepted: false }
         }
     }

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

@@ -36,7 +36,7 @@ export class HandshakeRpcRemote extends RpcRemote<HandshakeRpcClient> {
                 interleaveTargetDescriptor: response.interleaveTargetDescriptor
             }
         } catch (err: any) {
-            logger.debug(`handshake to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed: ${err}`)
+            logger.debug(`handshake to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed`, { err })
             return {
                 accepted: false
             }
@@ -57,7 +57,7 @@ export class HandshakeRpcRemote extends RpcRemote<HandshakeRpcClient> {
                 accepted: res.accepted
             }
         } catch (err) {
-            logger.debug(`interleaveRequest to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed: ${err}`)
+            logger.debug(`interleaveRequest to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed`, { err })
             return {
                 accepted: false
             }