@streamr/trackerless-network 100.2.5-beta.1 → 101.0.0-beta.0

package/src/NetworkStack.ts

@@ -11,15 +11,15 @@ 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 { ContentDeliveryManager, ContentDeliveryManagerOptions } from './logic/ContentDeliveryManager'
+import { ControlLayerNode } from './logic/ControlLayerNode'
 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?: ContentDeliveryManagerConfig
+    networkNode?: ContentDeliveryManagerOptions
     metricsContext?: MetricsContext
 }
 
@@ -54,7 +54,7 @@ export type NodeInfo = Required<NodeInfoResponse>
 
 export class NetworkStack {
 
-    private layer0Node?: Layer0Node
+    private controlLayerNode?: ControlLayerNode
     private contentDeliveryManager?: ContentDeliveryManager
     private stopped = false
     private readonly metricsContext: MetricsContext
@@ -65,7 +65,7 @@ export class NetworkStack {
     constructor(options: NetworkOptions) {
         this.options = options
         this.metricsContext = options.metricsContext ?? new MetricsContext()
-        this.layer0Node = new DhtNode({
+        this.controlLayerNode = new DhtNode({
             ...options.layer0,
             metricsContext: this.metricsContext
         })
@@ -106,24 +106,24 @@ export class NetworkStack {
 
     async start(doJoin = true): Promise<void> {
         logger.info('Starting a Streamr Network Node')
-        await this.layer0Node!.start()
-        logger.info(`Node id is ${getNodeIdFromPeerDescriptor(this.layer0Node!.getLocalPeerDescriptor())}`)
-        const connectionManager = this.layer0Node!.getTransport() as ConnectionManager
+        await this.controlLayerNode!.start()
+        logger.info(`Node id is ${getNodeIdFromPeerDescriptor(this.controlLayerNode!.getLocalPeerDescriptor())}`)
+        const connectionManager = this.controlLayerNode!.getTransport() as ConnectionManager
         if ((this.options.layer0?.entryPoints !== undefined) && (this.options.layer0.entryPoints.some((entryPoint) => 
-            areEqualPeerDescriptors(entryPoint, this.layer0Node!.getLocalPeerDescriptor())
+            areEqualPeerDescriptors(entryPoint, this.controlLayerNode!.getLocalPeerDescriptor())
         ))) {
-            await this.layer0Node?.joinDht(this.options.layer0.entryPoints)
+            await this.controlLayerNode?.joinDht(this.options.layer0.entryPoints)
         } else if (doJoin) {
             // in practice there aren't be existing connections and therefore this always connects
             await this.ensureConnectedToControlLayer()
         }
         // TODO: remove undefined checks here. Assume that start is approproately awaited before stop is called.
-        await this.contentDeliveryManager?.start(this.layer0Node!, connectionManager, connectionManager)
+        await this.contentDeliveryManager?.start(this.controlLayerNode!, 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(
-                this.layer0Node!.getLocalPeerDescriptor(),
+                this.controlLayerNode!.getLocalPeerDescriptor(),
                 infoRpcCommunicator
             )
         }
@@ -131,16 +131,16 @@ export class NetworkStack {
 
     private async ensureConnectedToControlLayer(): Promise<void> {
         // TODO we could wrap joinDht with pOnce and call it here (no else-if needed in that case)
-        if (!this.layer0Node!.hasJoined()) {
+        if (!this.controlLayerNode!.hasJoined()) {
             setImmediate(async () => {
                 if (this.options.layer0?.entryPoints !== undefined) {
                     // TODO should catch possible rejection?
                     // the question mark is there to avoid problems when stop() is called before start()
                     // -> TODO change to exlamation mark if we don't support that (and remove NetworkStackStoppedDuringStart.test)
-                    await this.layer0Node?.joinDht(this.options.layer0.entryPoints)
+                    await this.controlLayerNode?.joinDht(this.options.layer0.entryPoints)
                 }
             })
-            await this.layer0Node!.waitForNetworkConnectivity()
+            await this.controlLayerNode!.waitForNetworkConnectivity()
         }
     }
 
@@ -148,8 +148,8 @@ export class NetworkStack {
         return this.contentDeliveryManager!
     }
 
-    getLayer0Node(): Layer0Node {
-        return this.layer0Node!
+    getControlLayerNode(): ControlLayerNode {
+        return this.controlLayerNode!
     }
 
     getMetricsContext(): MetricsContext {
@@ -157,7 +157,7 @@ export class NetworkStack {
     }
 
     async fetchNodeInfo(node: PeerDescriptor): Promise<NodeInfo> {
-        if (!areEqualPeerDescriptors(node, this.getLayer0Node().getLocalPeerDescriptor())) {
+        if (!areEqualPeerDescriptors(node, this.getControlLayerNode().getLocalPeerDescriptor())) {
             return this.nodeInfoClient!.getInfo(node)
         } else {
             return this.createNodeInfo()
@@ -166,10 +166,10 @@ export class NetworkStack {
 
     createNodeInfo(): NodeInfo {
         return {
-            peerDescriptor: this.getLayer0Node().getLocalPeerDescriptor(),
+            peerDescriptor: this.getControlLayerNode().getLocalPeerDescriptor(),
             controlLayer: {
-                connections: this.getLayer0Node().getConnectionsView().getConnections(),
-                neighbors: this.getLayer0Node().getNeighbors()
+                connections: this.getControlLayerNode().getConnectionsView().getConnections(),
+                neighbors: this.getControlLayerNode().getNeighbors()
             },
             streamPartitions: this.getContentDeliveryManager().getNodeInfo(),
             version: applicationVersion
@@ -181,7 +181,7 @@ export class NetworkStack {
     }
 
     private getConnectionManager(): ConnectionManager {
-        return this.layer0Node!.getTransport() as ConnectionManager
+        return this.controlLayerNode!.getTransport() as ConnectionManager
     }
 
     async stop(): Promise<void> {
@@ -189,9 +189,9 @@ export class NetworkStack {
             this.stopped = true
             pull(instances, this)
             await this.contentDeliveryManager!.destroy()
-            await this.layer0Node!.stop()
+            await this.controlLayerNode!.stop()
             this.contentDeliveryManager = undefined
-            this.layer0Node = undefined
+            this.controlLayerNode = undefined
         }
     }
 

package/src/exports.ts

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

package/src/logic/ContentDeliveryLayerNode.ts

@@ -30,7 +30,7 @@ import { ProxyConnectionRpcLocal } from './proxy/ProxyConnectionRpcLocal'
 import { Inspector } from './inspect/Inspector'
 import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'
 import { markAndCheckDuplicate } from './utils'
-import { Layer1Node } from './Layer1Node'
+import { DiscoveryLayerNode } from './DiscoveryLayerNode'
 import { StreamPartID } from '@streamr/protocol'
 
 export interface Events {
@@ -39,9 +39,9 @@ export interface Events {
     entryPointLeaveDetected: () => void
 }
 
-export interface StrictContentDeliveryLayerNodeConfig {
+export interface StrictContentDeliveryLayerNodeOptions {
     streamPartId: StreamPartID
-    layer1Node: Layer1Node
+    discoveryLayerNode: DiscoveryLayerNode
     transport: ITransport
     connectionLocker: ConnectionLocker
     localPeerDescriptor: PeerDescriptor
@@ -73,44 +73,44 @@ export class ContentDeliveryLayerNode extends EventEmitter<Events> {
 
     private started = false
     private readonly duplicateDetectors: Map<string, DuplicateMessageDetector>
-    private config: StrictContentDeliveryLayerNodeConfig
+    private options: StrictContentDeliveryLayerNodeOptions
     private readonly contentDeliveryRpcLocal: ContentDeliveryRpcLocal
     private abortController: AbortController = new AbortController()
 
-    constructor(config: StrictContentDeliveryLayerNodeConfig) {
+    constructor(options: StrictContentDeliveryLayerNodeOptions) {
         super()
-        this.config = config
+        this.options = options
         this.duplicateDetectors = new Map()
         this.contentDeliveryRpcLocal = new ContentDeliveryRpcLocal({
-            localPeerDescriptor: this.config.localPeerDescriptor,
-            streamPartId: this.config.streamPartId,
-            rpcCommunicator: this.config.rpcCommunicator,
+            localPeerDescriptor: this.options.localPeerDescriptor,
+            streamPartId: this.options.streamPartId,
+            rpcCommunicator: this.options.rpcCommunicator,
             markAndCheckDuplicate: (msg: MessageID, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
             broadcast: (message: StreamMessage, previousNode?: DhtAddress) => this.broadcast(message, previousNode),
-            onLeaveNotice: (sourceId: DhtAddress, sourceIsStreamEntryPoint: boolean) => {
+            onLeaveNotice: (remoteNodeId: DhtAddress, sourceIsStreamEntryPoint: boolean) => {
                 if (this.abortController.signal.aborted) {
                     return
                 }
-                const contact = this.config.nearbyNodeView.get(sourceId)
-                || this.config.randomNodeView.get(sourceId)
-                || this.config.neighbors.get(sourceId)
-                || this.config.proxyConnectionRpcLocal?.getConnection(sourceId)?.remote
+                const contact = this.options.nearbyNodeView.get(remoteNodeId)
+                || this.options.randomNodeView.get(remoteNodeId)
+                || this.options.neighbors.get(remoteNodeId)
+                || this.options.proxyConnectionRpcLocal?.getConnection(remoteNodeId)?.remote
                 // TODO: check integrity of notifier?
                 if (contact) {
-                    this.config.layer1Node.removeContact(sourceId)
-                    this.config.neighbors.remove(sourceId)
-                    this.config.nearbyNodeView.remove(sourceId)
-                    this.config.randomNodeView.remove(sourceId)
-                    this.config.leftNodeView.remove(sourceId)
-                    this.config.rightNodeView.remove(sourceId)
-                    this.config.neighborFinder.start([sourceId])
-                    this.config.proxyConnectionRpcLocal?.removeConnection(sourceId)
+                    this.options.discoveryLayerNode.removeContact(remoteNodeId)
+                    this.options.neighbors.remove(remoteNodeId)
+                    this.options.nearbyNodeView.remove(remoteNodeId)
+                    this.options.randomNodeView.remove(remoteNodeId)
+                    this.options.leftNodeView.remove(remoteNodeId)
+                    this.options.rightNodeView.remove(remoteNodeId)
+                    this.options.neighborFinder.start([remoteNodeId])
+                    this.options.proxyConnectionRpcLocal?.removeConnection(remoteNodeId)
                 }
                 if (sourceIsStreamEntryPoint) {
                     this.emit('entryPointLeaveDetected')
                 }
             },
-            markForInspection: (senderId: DhtAddress, messageId: MessageID) => this.config.inspector.markMessage(senderId, messageId)
+            markForInspection: (remoteNodeId: DhtAddress, messageId: MessageID) => this.options.inspector.markMessage(remoteNodeId, messageId)
         })
     }
 
@@ -118,92 +118,92 @@ export class ContentDeliveryLayerNode extends EventEmitter<Events> {
         this.started = true
         this.registerDefaultServerMethods()
         addManagedEventListener<any, any>(
-            this.config.layer1Node as any,
+            this.options.discoveryLayerNode as any,
             'nearbyContactAdded', 
             () => this.onNearbyContactAdded(),
             this.abortController.signal
         )
         addManagedEventListener<any, any>(
-            this.config.layer1Node as any,
+            this.options.discoveryLayerNode as any,
             'nearbyContactRemoved',
             () => this.onNearbyContactRemoved(),
             this.abortController.signal
         )
         addManagedEventListener<any, any>(
-            this.config.layer1Node as any,
+            this.options.discoveryLayerNode as any,
             'randomContactAdded',
             () => this.onRandomContactAdded(),
             this.abortController.signal
         )
         addManagedEventListener<any, any>(
-            this.config.layer1Node as any,
+            this.options.discoveryLayerNode as any,
             'randomContactRemoved',
             () => this.onRandomContactRemoved(),
             this.abortController.signal
         )
         addManagedEventListener<any, any>(
-            this.config.layer1Node as any,
+            this.options.discoveryLayerNode as any,
             'ringContactAdded',
             () => this.onRingContactsUpdated(),
             this.abortController.signal
         )
         addManagedEventListener<any, any>(
-            this.config.layer1Node as any,
+            this.options.discoveryLayerNode as any,
             'ringContactRemoved',
             () => this.onRingContactsUpdated(),
             this.abortController.signal
         )
         addManagedEventListener<any, any>(
-            this.config.transport as any,
+            this.options.transport as any,
             'disconnected',
             (peerDescriptor: PeerDescriptor) => this.onNodeDisconnected(peerDescriptor),
             this.abortController.signal
         )
         addManagedEventListener(
-            this.config.neighbors,
+            this.options.neighbors,
             'nodeAdded',
             (id, remote) => {
-                this.config.propagation.onNeighborJoined(id)
-                this.config.connectionLocker.weakLockConnection(
+                this.options.propagation.onNeighborJoined(id)
+                this.options.connectionLocker.weakLockConnection(
                     getNodeIdFromPeerDescriptor(remote.getPeerDescriptor()),
-                    this.config.streamPartId
+                    this.options.streamPartId
                 )
                 this.emit('neighborConnected', id)
             },
             this.abortController.signal
         )
         addManagedEventListener(
-            this.config.neighbors,
+            this.options.neighbors,
             'nodeRemoved',
             (_id, remote) => {
-                this.config.connectionLocker.weakUnlockConnection(
+                this.options.connectionLocker.weakUnlockConnection(
                     getNodeIdFromPeerDescriptor(remote.getPeerDescriptor()),
-                    this.config.streamPartId
+                    this.options.streamPartId
                 )
             },
             this.abortController.signal
         )
-        if (this.config.proxyConnectionRpcLocal !== undefined) {
+        if (this.options.proxyConnectionRpcLocal !== undefined) {
             addManagedEventListener(
-                this.config.proxyConnectionRpcLocal,
+                this.options.proxyConnectionRpcLocal,
                 'newConnection',
-                (id: DhtAddress) => this.config.propagation.onNeighborJoined(id),
+                (id: DhtAddress) => this.options.propagation.onNeighborJoined(id),
                 this.abortController.signal
             )
         }
-        this.config.neighborFinder.start()
-        await this.config.neighborUpdateManager.start()
+        this.options.neighborFinder.start()
+        await this.options.neighborUpdateManager.start()
     }
 
     private registerDefaultServerMethods(): void {
-        this.config.rpcCommunicator.registerRpcNotification(StreamMessage, 'sendStreamMessage',
+        this.options.rpcCommunicator.registerRpcNotification(StreamMessage, 'sendStreamMessage',
             (msg: StreamMessage, context) => this.contentDeliveryRpcLocal.sendStreamMessage(msg, context))
-        this.config.rpcCommunicator.registerRpcNotification(LeaveStreamPartNotice, 'leaveStreamPartNotice',
+        this.options.rpcCommunicator.registerRpcNotification(LeaveStreamPartNotice, 'leaveStreamPartNotice',
             (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',
-            (req: TemporaryConnectionRequest, context) => this.config.temporaryConnectionRpcLocal.closeConnection(req, context))
+        this.options.rpcCommunicator.registerRpcMethod(TemporaryConnectionRequest, TemporaryConnectionResponse, 'openConnection',
+            (req: TemporaryConnectionRequest, context) => this.options.temporaryConnectionRpcLocal.openConnection(req, context))
+        this.options.rpcCommunicator.registerRpcNotification(CloseTemporaryConnection, 'closeConnection',
+            (req: TemporaryConnectionRequest, context) => this.options.temporaryConnectionRpcLocal.closeConnection(req, context))
     }
 
     private onRingContactsUpdated(): void {
@@ -211,23 +211,23 @@ export class ContentDeliveryLayerNode extends EventEmitter<Events> {
         if (this.isStopped()) {
             return
         }
-        const contacts = this.config.layer1Node.getRingContacts()
-        this.config.leftNodeView.replaceAll(contacts.left.map((peer) => 
+        const contacts = this.options.discoveryLayerNode.getRingContacts()
+        this.options.leftNodeView.replaceAll(contacts.left.map((peer) => 
             new ContentDeliveryRpcRemote(
-                this.config.localPeerDescriptor,
+                this.options.localPeerDescriptor,
                 peer,
-                this.config.rpcCommunicator,
+                this.options.rpcCommunicator,
                 ContentDeliveryRpcClient,
-                this.config.rpcRequestTimeout
+                this.options.rpcRequestTimeout
             )
         ))
-        this.config.rightNodeView.replaceAll(contacts.right.map((peer) =>
+        this.options.rightNodeView.replaceAll(contacts.right.map((peer) =>
             new ContentDeliveryRpcRemote(
-                this.config.localPeerDescriptor,
+                this.options.localPeerDescriptor,
                 peer,
-                this.config.rpcCommunicator,
+                this.options.rpcCommunicator,
                 ContentDeliveryRpcClient,
-                this.config.rpcRequestTimeout
+                this.options.rpcRequestTimeout
             )
         ))
     }
@@ -237,10 +237,10 @@ export class ContentDeliveryLayerNode extends EventEmitter<Events> {
         if (this.isStopped()) {
             return
         }
-        const closestContacts = this.config.layer1Node.getClosestContacts()
+        const closestContacts = this.options.discoveryLayerNode.getClosestContacts()
         this.updateNearbyNodeView(closestContacts)
-        if (this.config.neighbors.size() < this.config.neighborTargetCount) {
-            this.config.neighborFinder.start()
+        if (this.options.neighbors.size() < this.options.neighborTargetCount) {
+            this.options.neighborFinder.start()
         }
     }
 
@@ -249,31 +249,31 @@ export class ContentDeliveryLayerNode extends EventEmitter<Events> {
         if (this.isStopped()) {
             return
         }
-        const closestContacts = this.config.layer1Node.getClosestContacts()
+        const closestContacts = this.options.discoveryLayerNode.getClosestContacts()
         this.updateNearbyNodeView(closestContacts)
     }
 
     private updateNearbyNodeView(nodes: PeerDescriptor[]) {
-        this.config.nearbyNodeView.replaceAll(Array.from(nodes).map((descriptor) =>
+        this.options.nearbyNodeView.replaceAll(Array.from(nodes).map((descriptor) =>
             new ContentDeliveryRpcRemote(
-                this.config.localPeerDescriptor,
+                this.options.localPeerDescriptor,
                 descriptor,
-                this.config.rpcCommunicator,
+                this.options.rpcCommunicator,
                 ContentDeliveryRpcClient,
-                this.config.rpcRequestTimeout
+                this.options.rpcRequestTimeout
             )
         ))
-        for (const descriptor of this.config.layer1Node.getNeighbors()) {
-            if (this.config.nearbyNodeView.size() >= this.config.nodeViewSize) {
+        for (const descriptor of this.options.discoveryLayerNode.getNeighbors()) {
+            if (this.options.nearbyNodeView.size() >= this.options.nodeViewSize) {
                 break
             }
-            this.config.nearbyNodeView.add(
+            this.options.nearbyNodeView.add(
                 new ContentDeliveryRpcRemote(
-                    this.config.localPeerDescriptor,
+                    this.options.localPeerDescriptor,
                     descriptor,
-                    this.config.rpcCommunicator,
+                    this.options.rpcCommunicator,
                     ContentDeliveryRpcClient,
-                    this.config.rpcRequestTimeout
+                    this.options.rpcRequestTimeout
                 )
             )
         }
@@ -283,18 +283,18 @@ export class ContentDeliveryLayerNode extends EventEmitter<Events> {
         if (this.isStopped()) {
             return
         }
-        const randomContacts = this.config.layer1Node.getRandomContacts(RANDOM_NODE_VIEW_SIZE)
-        this.config.randomNodeView.replaceAll(randomContacts.map((descriptor) =>
+        const randomContacts = this.options.discoveryLayerNode.getRandomContacts(RANDOM_NODE_VIEW_SIZE)
+        this.options.randomNodeView.replaceAll(randomContacts.map((descriptor) =>
             new ContentDeliveryRpcRemote(
-                this.config.localPeerDescriptor,
+                this.options.localPeerDescriptor,
                 descriptor,
-                this.config.rpcCommunicator,
+                this.options.rpcCommunicator,
                 ContentDeliveryRpcClient,
-                this.config.rpcRequestTimeout
+                this.options.rpcRequestTimeout
             )
         ))
-        if (this.config.neighbors.size() < this.config.neighborTargetCount) {
-            this.config.neighborFinder.start()
+        if (this.options.neighbors.size() < this.options.neighborTargetCount) {
+            this.options.neighborFinder.start()
         }
     }
 
@@ -303,30 +303,30 @@ export class ContentDeliveryLayerNode extends EventEmitter<Events> {
         if (this.isStopped()) {
             return
         }
-        const randomContacts = this.config.layer1Node.getRandomContacts(RANDOM_NODE_VIEW_SIZE)
-        this.config.randomNodeView.replaceAll(randomContacts.map((descriptor) =>
+        const randomContacts = this.options.discoveryLayerNode.getRandomContacts(RANDOM_NODE_VIEW_SIZE)
+        this.options.randomNodeView.replaceAll(randomContacts.map((descriptor) =>
             new ContentDeliveryRpcRemote(
-                this.config.localPeerDescriptor,
+                this.options.localPeerDescriptor,
                 descriptor,
-                this.config.rpcCommunicator,
+                this.options.rpcCommunicator,
                 ContentDeliveryRpcClient,
-                this.config.rpcRequestTimeout
+                this.options.rpcRequestTimeout
             )
         ))
     }
 
     private onNodeDisconnected(peerDescriptor: PeerDescriptor): void {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
-        if (this.config.neighbors.has(nodeId)) {
-            this.config.neighbors.remove(nodeId)
-            this.config.neighborFinder.start([nodeId])
-            this.config.temporaryConnectionRpcLocal.removeNode(nodeId)
+        if (this.options.neighbors.has(nodeId)) {
+            this.options.neighbors.remove(nodeId)
+            this.options.neighborFinder.start([nodeId])
+            this.options.temporaryConnectionRpcLocal.removeNode(nodeId)
         }
     }
 
     hasProxyConnection(nodeId: DhtAddress): boolean {
-        if (this.config.proxyConnectionRpcLocal) {
-            return this.config.proxyConnectionRpcLocal.hasConnection(nodeId)
+        if (this.options.proxyConnectionRpcLocal) {
+            return this.options.proxyConnectionRpcLocal.hasConnection(nodeId)
         }
         return false
     }
@@ -336,22 +336,22 @@ export class ContentDeliveryLayerNode extends EventEmitter<Events> {
             return
         }
         this.abortController.abort()
-        this.config.proxyConnectionRpcLocal?.stop()
-        this.config.neighbors.getAll().map((remote) => {
-            remote.leaveStreamPartNotice(this.config.streamPartId, this.config.isLocalNodeEntryPoint())
-            this.config.connectionLocker.weakUnlockConnection(
+        this.options.proxyConnectionRpcLocal?.stop()
+        this.options.neighbors.getAll().map((remote) => {
+            remote.leaveStreamPartNotice(this.options.streamPartId, this.options.isLocalNodeEntryPoint())
+            this.options.connectionLocker.weakUnlockConnection(
                 getNodeIdFromPeerDescriptor(remote.getPeerDescriptor()),
-                this.config.streamPartId
+                this.options.streamPartId
             )
         })
-        this.config.rpcCommunicator.destroy()
+        this.options.rpcCommunicator.destroy()
         this.removeAllListeners()
-        this.config.nearbyNodeView.stop()
-        this.config.neighbors.stop()
-        this.config.randomNodeView.stop()
-        this.config.neighborFinder.stop()
-        this.config.neighborUpdateManager.stop()
-        this.config.inspector.stop()
+        this.options.nearbyNodeView.stop()
+        this.options.neighbors.stop()
+        this.options.randomNodeView.stop()
+        this.options.neighborFinder.stop()
+        this.options.neighborUpdateManager.stop()
+        this.options.inspector.stop()
     }
 
     broadcast(msg: StreamMessage, previousNode?: DhtAddress): void {
@@ -359,40 +359,40 @@ export class ContentDeliveryLayerNode extends EventEmitter<Events> {
             markAndCheckDuplicate(this.duplicateDetectors, msg.messageId!, msg.previousMessageRef)
         }
         this.emit('message', msg)
-        const skipBackPropagation = previousNode !== undefined && !this.config.temporaryConnectionRpcLocal.hasNode(previousNode)
-        this.config.propagation.feedUnseenMessage(msg, this.getPropagationTargets(msg), skipBackPropagation ? previousNode : null)
+        const skipBackPropagation = previousNode !== undefined && !this.options.temporaryConnectionRpcLocal.hasNode(previousNode)
+        this.options.propagation.feedUnseenMessage(msg, this.getPropagationTargets(msg), skipBackPropagation ? previousNode : null)
     }
 
     inspect(peerDescriptor: PeerDescriptor): Promise<boolean> {
-        return this.config.inspector.inspect(peerDescriptor)
+        return this.options.inspector.inspect(peerDescriptor)
     }
 
     private getPropagationTargets(msg: StreamMessage): DhtAddress[] {
-        let propagationTargets = this.config.neighbors.getIds()
-        if (this.config.proxyConnectionRpcLocal) {
-            propagationTargets = propagationTargets.concat(this.config.proxyConnectionRpcLocal.getPropagationTargets(msg))
+        let propagationTargets = this.options.neighbors.getIds()
+        if (this.options.proxyConnectionRpcLocal) {
+            propagationTargets = propagationTargets.concat(this.options.proxyConnectionRpcLocal.getPropagationTargets(msg))
         }
-        propagationTargets = propagationTargets.concat(this.config.temporaryConnectionRpcLocal.getNodes().getIds())
+        propagationTargets = propagationTargets.concat(this.options.temporaryConnectionRpcLocal.getNodes().getIds())
         return propagationTargets
     }
 
     getOwnNodeId(): DhtAddress {
-        return getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
+        return getNodeIdFromPeerDescriptor(this.options.localPeerDescriptor)
     }
 
     getOutgoingHandshakeCount(): number {
-        return this.config.handshaker.getOngoingHandshakes().size
+        return this.options.handshaker.getOngoingHandshakes().size
     }
 
     getNeighbors(): PeerDescriptor[] {
         if (!this.started && this.isStopped()) {
             return []
         }
-        return this.config.neighbors.getAll().map((n) => n.getPeerDescriptor())
+        return this.options.neighbors.getAll().map((n) => n.getPeerDescriptor())
     }
 
     getNearbyNodeView(): NodeList {
-        return this.config.nearbyNodeView
+        return this.options.nearbyNodeView
     }
 
     private isStopped() {