@streamr/trackerless-network 100.2.2 → 100.2.4-beta.0

package/src/logic/{createRandomGraphNode.ts → createContentDeliveryLayerNode.ts}

@@ -2,7 +2,7 @@ import { DhtAddress, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } fro
 import { Handshaker } from './neighbor-discovery/Handshaker'
 import { NeighborFinder } from './neighbor-discovery/NeighborFinder'
 import { NeighborUpdateManager } from './neighbor-discovery/NeighborUpdateManager'
-import { StrictRandomGraphNodeConfig, RandomGraphNode } from './RandomGraphNode'
+import { StrictContentDeliveryLayerNodeConfig, ContentDeliveryLayerNode } from './ContentDeliveryLayerNode'
 import { NodeList } from './NodeList'
 import { Propagation } from './propagation/Propagation'
 import { StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
@@ -12,7 +12,7 @@ import { Inspector } from './inspect/Inspector'
 import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'
 import { formStreamPartContentDeliveryServiceId } from './formStreamPartDeliveryServiceId'
 
-type RandomGraphNodeConfig = MarkOptional<StrictRandomGraphNodeConfig,
+type ContentDeliveryLayerNodeConfig = MarkOptional<StrictContentDeliveryLayerNodeConfig,
     'nearbyNodeView' | 'randomNodeView' | 'neighbors' | 'leftNodeView' | 'rightNodeView' | 'propagation'
     | 'handshaker' | 'neighborFinder' | 'neighborUpdateManager' | 'neighborTargetCount'
     | 'rpcCommunicator' | 'nodeViewSize'
@@ -23,7 +23,7 @@ type RandomGraphNodeConfig = MarkOptional<StrictRandomGraphNodeConfig,
         neighborUpdateInterval?: number
     }
 
-const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGraphNodeConfig => {
+const createConfigWithDefaults = (config: ContentDeliveryLayerNodeConfig): StrictContentDeliveryLayerNodeConfig => {
     const ownNodeId = getNodeIdFromPeerDescriptor(config.localPeerDescriptor)
     const rpcCommunicator = config.rpcCommunicator ?? new ListeningRpcCommunicator(
         formStreamPartContentDeliveryServiceId(config.streamPartId),
@@ -125,6 +125,6 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     }
 }
 
-export const createRandomGraphNode = (config: RandomGraphNodeConfig): RandomGraphNode => {
-    return new RandomGraphNode(createConfigWithDefaults(config))
+export const createContentDeliveryLayerNode = (config: ContentDeliveryLayerNodeConfig): ContentDeliveryLayerNode => {
+    return new ContentDeliveryLayerNode(createConfigWithDefaults(config))
 }

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

@@ -47,10 +47,14 @@ import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
  */
 export interface IDhtNodeRpcClient {
     /**
+     * TODO rename to getClosestNeighbors (breaking change)
+     *
      * @generated from protobuf rpc: getClosestPeers(dht.ClosestPeersRequest) returns (dht.ClosestPeersResponse);
      */
     getClosestPeers(input: ClosestPeersRequest, options?: RpcOptions): UnaryCall<ClosestPeersRequest, ClosestPeersResponse>;
     /**
+     * TODO rename to getClosestRingContacts (breaking change)
+     *
      * @generated from protobuf rpc: getClosestRingPeers(dht.ClosestRingPeersRequest) returns (dht.ClosestRingPeersResponse);
      */
     getClosestRingPeers(input: ClosestRingPeersRequest, options?: RpcOptions): UnaryCall<ClosestRingPeersRequest, ClosestRingPeersResponse>;
@@ -73,6 +77,8 @@ export class DhtNodeRpcClient implements IDhtNodeRpcClient, ServiceInfo {
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
+     * TODO rename to getClosestNeighbors (breaking change)
+     *
      * @generated from protobuf rpc: getClosestPeers(dht.ClosestPeersRequest) returns (dht.ClosestPeersResponse);
      */
     getClosestPeers(input: ClosestPeersRequest, options?: RpcOptions): UnaryCall<ClosestPeersRequest, ClosestPeersResponse> {
@@ -80,6 +86,8 @@ export class DhtNodeRpcClient implements IDhtNodeRpcClient, ServiceInfo {
         return stackIntercept<ClosestPeersRequest, ClosestPeersResponse>("unary", this._transport, method, opt, input);
     }
     /**
+     * TODO rename to getClosestRingContacts (breaking change)
+     *
      * @generated from protobuf rpc: getClosestRingPeers(dht.ClosestRingPeersRequest) returns (dht.ClosestRingPeersResponse);
      */
     getClosestRingPeers(input: ClosestRingPeersRequest, options?: RpcOptions): UnaryCall<ClosestRingPeersRequest, ClosestRingPeersResponse> {

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

@@ -34,10 +34,14 @@ import { ServerCallContext } from "@protobuf-ts/runtime-rpc";
  */
 export interface IDhtNodeRpc<T = ServerCallContext> {
     /**
+     * TODO rename to getClosestNeighbors (breaking change)
+     *
      * @generated from protobuf rpc: getClosestPeers(dht.ClosestPeersRequest) returns (dht.ClosestPeersResponse);
      */
     getClosestPeers(request: ClosestPeersRequest, context: T): Promise<ClosestPeersResponse>;
     /**
+     * TODO rename to getClosestRingContacts (breaking change)
+     *
      * @generated from protobuf rpc: getClosestRingPeers(dht.ClosestRingPeersRequest) returns (dht.ClosestRingPeersResponse);
      */
     getClosestRingPeers(request: ClosestRingPeersRequest, context: T): Promise<ClosestRingPeersResponse>;

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

@@ -108,6 +108,8 @@ export interface DataEntry {
     deleted: boolean;
 }
 /**
+ * TODO rename to ClosestNeighborsRequest
+ *
  * @generated from protobuf message dht.ClosestPeersRequest
  */
 export interface ClosestPeersRequest {
@@ -121,6 +123,8 @@ export interface ClosestPeersRequest {
     requestId: string;
 }
 /**
+ * TODO rename to ClosestPeersResponse
+ *
  * @generated from protobuf message dht.ClosestPeersResponse
  */
 export interface ClosestPeersResponse {
@@ -134,6 +138,8 @@ export interface ClosestPeersResponse {
     requestId: string;
 }
 /**
+ * TODO rename to ClosestRingContactsRequest
+ *
  * @generated from protobuf message dht.ClosestRingPeersRequest
  */
 export interface ClosestRingPeersRequest {
@@ -147,6 +153,8 @@ export interface ClosestRingPeersRequest {
     requestId: string;
 }
 /**
+ * TODO rename to ClosestRingContactsResponse
+ *
  * @generated from protobuf message dht.ClosestRingPeersResponse
  */
 export interface ClosestRingPeersResponse {
@@ -181,9 +189,9 @@ export interface RecursiveOperationRequest {
  */
 export interface RecursiveOperationResponse {
     /**
-     * @generated from protobuf field: repeated dht.PeerDescriptor closestConnectedPeers = 1;
+     * @generated from protobuf field: repeated dht.PeerDescriptor closestConnectedNodes = 1;
      */
-    closestConnectedPeers: PeerDescriptor[];
+    closestConnectedNodes: PeerDescriptor[];
     /**
      * @generated from protobuf field: repeated dht.DataEntry dataEntries = 2;
      */
@@ -837,7 +845,7 @@ export const RecursiveOperationRequest = new RecursiveOperationRequest$Type();
 class RecursiveOperationResponse$Type extends MessageType<RecursiveOperationResponse> {
     constructor() {
         super("dht.RecursiveOperationResponse", [
-            { no: 1, name: "closestConnectedPeers", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor },
+            { no: 1, name: "closestConnectedNodes", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor },
             { no: 2, name: "dataEntries", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => DataEntry },
             { no: 3, name: "noCloserNodesFound", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
             { no: 4, name: "routingPath", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor }

package/test/benchmark/first-message.ts

@@ -26,7 +26,7 @@ import { NetworkNode } from '../../src/NetworkNode'
 import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
 import { createMockPeerDescriptor, createNetworkNodeWithSimulator } from '../utils/utils'
 import { Layer1Node } from '../../src/logic/Layer1Node'
-import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
+import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
 
 const numNodes = 10000
 
@@ -160,7 +160,8 @@ run().then(() => {
     const layer0Node = currentNode.stack.getLayer0Node() as DhtNode
     console.log(layer0Node.getNeighbors().length)
     console.log(layer0Node.getConnectionCount())
-    const streamPartDelivery = contentDeliveryManager.getStreamPartDelivery(streamParts[0])! as { layer1Node: Layer1Node, node: RandomGraphNode }
+    const streamPartDelivery = contentDeliveryManager
+        .getStreamPartDelivery(streamParts[0])! as { layer1Node: Layer1Node, node: ContentDeliveryLayerNode }
     console.log(streamPartDelivery.layer1Node.getNeighbors())
     console.log(streamPartDelivery.node.getNeighbors())
     console.log(nodes[nodes.length - 1])

package/test/end-to-end/{random-graph-with-real-connections.test.ts → content-delivery-layer-node-with-real-connections.test.ts}

@@ -1,14 +1,14 @@
 import { ConnectionManager, DhtNode, PeerDescriptor } from '@streamr/dht'
-import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
+import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
 import { waitForCondition } from '@streamr/utils'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
-import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
+import { createContentDeliveryLayerNode } from '../../src/logic/createContentDeliveryLayerNode'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { Layer0Node } from '../../src/logic/Layer0Node'
 import { Layer1Node } from '../../src/logic/Layer1Node'
 
-describe('random graph with real connections', () => {
+describe('content delivery layer node with real connections', () => {
 
     const epPeerDescriptor: PeerDescriptor = createMockPeerDescriptor({
         websocket: { host: '127.0.0.1', port: 12221, tls: false }
@@ -23,11 +23,11 @@ describe('random graph with real connections', () => {
     let dhtNode2: Layer0Node & Layer1Node
     let dhtNode3: Layer0Node & Layer1Node
     let dhtNode4: Layer0Node & Layer1Node
-    let randomGraphNode1: RandomGraphNode
-    let randomGraphNode2: RandomGraphNode
-    let randomGraphNode3: RandomGraphNode
-    let randomGraphNode4: RandomGraphNode
-    let randomGraphNode5: RandomGraphNode
+    let contentDeliveryLayerNode1: ContentDeliveryLayerNode
+    let contentDeliveryLayerNode2: ContentDeliveryLayerNode
+    let contentDeliveryLayerNode3: ContentDeliveryLayerNode
+    let contentDeliveryLayerNode4: ContentDeliveryLayerNode
+    let contentDeliveryLayerNode5: ContentDeliveryLayerNode
     const websocketPortRange = { min: 12222, max: 12225 } 
 
     beforeEach(async () => {
@@ -42,7 +42,7 @@ describe('random graph with real connections', () => {
         await dhtNode3.start()
         await dhtNode4.start()
 
-        randomGraphNode1 = createRandomGraphNode(
+        contentDeliveryLayerNode1 = createContentDeliveryLayerNode(
             {
                 streamPartId,
                 layer1Node: epDhtNode,
@@ -52,7 +52,7 @@ describe('random graph with real connections', () => {
                 isLocalNodeEntryPoint: () => false
             }
         )
-        randomGraphNode2 = createRandomGraphNode({
+        contentDeliveryLayerNode2 = createContentDeliveryLayerNode({
             streamPartId,
             layer1Node: dhtNode1,
             transport: dhtNode1.getTransport(),
@@ -60,7 +60,7 @@ describe('random graph with real connections', () => {
             localPeerDescriptor: dhtNode1.getLocalPeerDescriptor(),
             isLocalNodeEntryPoint: () => false
         })
-        randomGraphNode3 = createRandomGraphNode({
+        contentDeliveryLayerNode3 = createContentDeliveryLayerNode({
             streamPartId,
             layer1Node: dhtNode2,
             transport: dhtNode2.getTransport(),
@@ -68,7 +68,7 @@ describe('random graph with real connections', () => {
             localPeerDescriptor: dhtNode2.getLocalPeerDescriptor(),
             isLocalNodeEntryPoint: () => false
         })
-        randomGraphNode4 = createRandomGraphNode({
+        contentDeliveryLayerNode4 = createContentDeliveryLayerNode({
             streamPartId,
             layer1Node: dhtNode3,
             transport: dhtNode3.getTransport(),
@@ -76,7 +76,7 @@ describe('random graph with real connections', () => {
             localPeerDescriptor: dhtNode3.getLocalPeerDescriptor(),
             isLocalNodeEntryPoint: () => false
         })
-        randomGraphNode5 = createRandomGraphNode({
+        contentDeliveryLayerNode5 = createContentDeliveryLayerNode({
             streamPartId,
             layer1Node: dhtNode4,
             transport: dhtNode4.getTransport(),
@@ -84,6 +84,13 @@ describe('random graph with real connections', () => {
             localPeerDescriptor: dhtNode4.getLocalPeerDescriptor(),
             isLocalNodeEntryPoint: () => false
         })
+        await Promise.all([
+            contentDeliveryLayerNode1.start(),
+            contentDeliveryLayerNode2.start(),
+            contentDeliveryLayerNode3.start(),
+            contentDeliveryLayerNode4.start(),
+            contentDeliveryLayerNode5.start()
+        ])
         await epDhtNode.joinDht([epPeerDescriptor])
         await Promise.all([
             dhtNode1.joinDht([epPeerDescriptor]),
@@ -91,13 +98,6 @@ describe('random graph with real connections', () => {
             dhtNode3.joinDht([epPeerDescriptor]),
             dhtNode4.joinDht([epPeerDescriptor])
         ])
-        await Promise.all([
-            randomGraphNode1.start(),
-            randomGraphNode2.start(),
-            randomGraphNode3.start(),
-            randomGraphNode4.start(),
-            randomGraphNode5.start()
-        ])
     })
 
     afterEach(async () => {
@@ -107,11 +107,11 @@ describe('random graph with real connections', () => {
             dhtNode2.stop(),
             dhtNode3.stop(),
             dhtNode4.stop(),
-            randomGraphNode1.stop(),
-            randomGraphNode2.stop(),
-            randomGraphNode3.stop(),
-            randomGraphNode4.stop(),
-            randomGraphNode5.stop(),
+            contentDeliveryLayerNode1.stop(),
+            contentDeliveryLayerNode2.stop(),
+            contentDeliveryLayerNode3.stop(),
+            contentDeliveryLayerNode4.stop(),
+            contentDeliveryLayerNode5.stop(),
             (epDhtNode.getTransport() as ConnectionManager).stop(),
             (dhtNode1.getTransport() as ConnectionManager).stop(),
             (dhtNode2.getTransport() as ConnectionManager).stop(),
@@ -122,32 +122,32 @@ describe('random graph with real connections', () => {
 
     it('can fully connected topologies ', async () => {
         await waitForCondition(() => {
-            return randomGraphNode1.getNeighbors().length >= 3
-                && randomGraphNode2.getNeighbors().length >= 3
-                && randomGraphNode3.getNeighbors().length >= 3
-                && randomGraphNode4.getNeighbors().length >= 3
-                && randomGraphNode5.getNeighbors().length >= 3
+            return contentDeliveryLayerNode1.getNeighbors().length >= 3
+                && contentDeliveryLayerNode2.getNeighbors().length >= 3
+                && contentDeliveryLayerNode3.getNeighbors().length >= 3
+                && contentDeliveryLayerNode4.getNeighbors().length >= 3
+                && contentDeliveryLayerNode5.getNeighbors().length >= 3
         }, 10000)
-        expect(randomGraphNode1.getNeighbors().length).toBeGreaterThanOrEqual(3)
-        expect(randomGraphNode2.getNeighbors().length).toBeGreaterThanOrEqual(3)
-        expect(randomGraphNode3.getNeighbors().length).toBeGreaterThanOrEqual(3)
-        expect(randomGraphNode4.getNeighbors().length).toBeGreaterThanOrEqual(3)
-        expect(randomGraphNode5.getNeighbors().length).toBeGreaterThanOrEqual(3)
+        expect(contentDeliveryLayerNode1.getNeighbors().length).toBeGreaterThanOrEqual(3)
+        expect(contentDeliveryLayerNode2.getNeighbors().length).toBeGreaterThanOrEqual(3)
+        expect(contentDeliveryLayerNode3.getNeighbors().length).toBeGreaterThanOrEqual(3)
+        expect(contentDeliveryLayerNode4.getNeighbors().length).toBeGreaterThanOrEqual(3)
+        expect(contentDeliveryLayerNode5.getNeighbors().length).toBeGreaterThanOrEqual(3)
     })
 
     it('can propagate messages', async () => {
         let receivedMessageCount = 0
-        randomGraphNode2.on('message', () => receivedMessageCount += 1)
-        randomGraphNode3.on('message', () => receivedMessageCount += 1)
-        randomGraphNode4.on('message', () => receivedMessageCount += 1)
-        randomGraphNode5.on('message', () => receivedMessageCount += 1)
+        contentDeliveryLayerNode2.on('message', () => receivedMessageCount += 1)
+        contentDeliveryLayerNode3.on('message', () => receivedMessageCount += 1)
+        contentDeliveryLayerNode4.on('message', () => receivedMessageCount += 1)
+        contentDeliveryLayerNode5.on('message', () => receivedMessageCount += 1)
 
         await waitForCondition(() => {
-            return randomGraphNode1.getNeighbors().length >= 3
-                && randomGraphNode2.getNeighbors().length >= 3
-                && randomGraphNode3.getNeighbors().length >= 3
-                && randomGraphNode4.getNeighbors().length >= 3
-                && randomGraphNode5.getNeighbors().length >= 3
+            return contentDeliveryLayerNode1.getNeighbors().length >= 3
+                && contentDeliveryLayerNode2.getNeighbors().length >= 3
+                && contentDeliveryLayerNode3.getNeighbors().length >= 3
+                && contentDeliveryLayerNode4.getNeighbors().length >= 3
+                && contentDeliveryLayerNode5.getNeighbors().length >= 3
         }, 10000)
 
         const msg = createStreamMessage(
@@ -155,7 +155,7 @@ describe('random graph with real connections', () => {
             streamPartId,
             randomEthereumAddress()
         )
-        randomGraphNode1.broadcast(msg)
+        contentDeliveryLayerNode1.broadcast(msg)
         await waitForCondition(() => receivedMessageCount >= 4)
     })
 })

package/test/end-to-end/proxy-connections.test.ts

@@ -11,7 +11,7 @@ import {
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary, utf8ToBinary, wait, waitForCondition, waitForEvent3 } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
+import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
 import { ProxyClient } from '../../src/logic/proxy/ProxyClient'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
@@ -48,7 +48,7 @@ describe('Proxy connections', () => {
     const hasConnectionFromProxy = (proxyNode: NetworkNode): boolean => {
         const delivery = proxyNode.stack.getContentDeliveryManager().getStreamPartDelivery(STREAM_PART_ID)
         return (delivery !== undefined)
-            ? ((delivery as { node: RandomGraphNode }).node).hasProxyConnection(proxiedNode.getNodeId())
+            ? ((delivery as { node: ContentDeliveryLayerNode }).node).hasProxyConnection(proxiedNode.getNodeId())
             : false
     }
     

package/test/integration/{RandomGraphNode-Layer1Node-Latencies.test.ts → ContentDeliveryLayerNode-Layer1Node-Latencies.test.ts}

@@ -1,97 +1,96 @@
 import { DhtNode, LatencyType, PeerDescriptor, Simulator, SimulatorTransport, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
-import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
-import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
+import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
+import { createContentDeliveryLayerNode } from '../../src/logic/createContentDeliveryLayerNode'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { Layer1Node } from '../../src/logic/Layer1Node'
 
-describe('RandomGraphNode-DhtNode-Latencies', () => {
-    const nodeCount = 64
-    let layer1Nodes: Layer1Node[]
-    let dhtEntryPoint: Layer1Node
-    let entryPointRandomGraphNode: RandomGraphNode
-    let graphNodes: RandomGraphNode[]
+describe('ContentDeliveryLayerNode-DhtNode-Latencies', () => {
+    const otherNodeCount = 64
+    let otherLayer1Nodes: Layer1Node[]
+    let entryPointLayer1Node: Layer1Node
+    let entryPointContentDeliveryLayerNode: ContentDeliveryLayerNode
+    let otherContentDeliveryLayerNodes: ContentDeliveryLayerNode[]
 
     const streamPartId = StreamPartIDUtils.parse('stream#0')
     const entrypointDescriptor = createMockPeerDescriptor()
 
-    const peerDescriptors: PeerDescriptor[] = range(nodeCount).map(() => createMockPeerDescriptor())
+    const peerDescriptors: PeerDescriptor[] = range(otherNodeCount).map(() => createMockPeerDescriptor())
     beforeEach(async () => {
         const simulator = new Simulator(LatencyType.FIXED, 50)
         const entrypointCm = new SimulatorTransport(entrypointDescriptor, simulator)
-        const cms: SimulatorTransport[] = range(nodeCount).map((i) =>
+        const cms: SimulatorTransport[] = range(otherNodeCount).map((i) =>
             new SimulatorTransport(peerDescriptors[i], simulator)
         )
         await entrypointCm.start()
         await Promise.all(cms.map((cm) => cm.start()))
 
-        dhtEntryPoint = new DhtNode({
+        entryPointLayer1Node = new DhtNode({
             transport: entrypointCm,
             peerDescriptor: entrypointDescriptor,
             serviceId: streamPartId
         })
-        layer1Nodes = range(nodeCount).map((i) => new DhtNode({
+        otherLayer1Nodes = range(otherNodeCount).map((i) => new DhtNode({
             transport: cms[i],
             peerDescriptor: peerDescriptors[i],
             serviceId: streamPartId
         }))
-        graphNodes = range(nodeCount).map((i) => createRandomGraphNode({
+        otherContentDeliveryLayerNodes = range(otherNodeCount).map((i) => createContentDeliveryLayerNode({
             streamPartId,
-            layer1Node: layer1Nodes[i],
+            layer1Node: otherLayer1Nodes[i],
             transport: cms[i],
             connectionLocker: cms[i],
             localPeerDescriptor: peerDescriptors[i],
             isLocalNodeEntryPoint: () => false
         }))
-        entryPointRandomGraphNode = createRandomGraphNode({
+        entryPointContentDeliveryLayerNode = createContentDeliveryLayerNode({
             streamPartId,
-            layer1Node: dhtEntryPoint,
+            layer1Node: entryPointLayer1Node,
             transport: entrypointCm,
             connectionLocker: entrypointCm,
             localPeerDescriptor: entrypointDescriptor,
             isLocalNodeEntryPoint: () => false
         })
 
-        await dhtEntryPoint.start()
-        await dhtEntryPoint.joinDht([entrypointDescriptor])
-        await Promise.all(layer1Nodes.map((node) => node.start()))
+        await entryPointLayer1Node.start()
+        entryPointContentDeliveryLayerNode.start()
+        await entryPointLayer1Node.joinDht([entrypointDescriptor])
+        await Promise.all(otherLayer1Nodes.map((node) => node.start()))
     })
 
     afterEach(async () => {
-        dhtEntryPoint.stop()
-        entryPointRandomGraphNode.stop()
-        await Promise.all(layer1Nodes.map((node) => node.stop()))
-        await Promise.all(graphNodes.map((node) => node.stop()))
+        entryPointLayer1Node.stop()
+        entryPointContentDeliveryLayerNode.stop()
+        await Promise.all(otherLayer1Nodes.map((node) => node.stop()))
+        await Promise.all(otherContentDeliveryLayerNodes.map((node) => node.stop()))
     })
 
     it('happy path single node', async () => {
-        await layer1Nodes[0].joinDht([entrypointDescriptor])
-        entryPointRandomGraphNode.start()
-        await graphNodes[0].start()
+        await otherContentDeliveryLayerNodes[0].start()
+        await otherLayer1Nodes[0].joinDht([entrypointDescriptor])
         await Promise.all([
-            waitForCondition(() => graphNodes[0].getNearbyNodeView().getIds().length === 1),
-            waitForCondition(() => graphNodes[0].getNeighbors().length === 1)
+            waitForCondition(() => otherContentDeliveryLayerNodes[0].getNearbyNodeView().getIds().length === 1),
+            waitForCondition(() => otherContentDeliveryLayerNodes[0].getNeighbors().length === 1)
         ])
-        expect(graphNodes[0].getNearbyNodeView().getIds().length).toEqual(1)
-        expect(graphNodes[0].getNeighbors().length).toEqual(1)
+        expect(otherContentDeliveryLayerNodes[0].getNearbyNodeView().getIds().length).toEqual(1)
+        expect(otherContentDeliveryLayerNodes[0].getNeighbors().length).toEqual(1)
     })
 
     it('happy path 5 nodes', async () => {
-        entryPointRandomGraphNode.start()
-        range(4).forEach((i) => graphNodes[i].start())
+        range(4).forEach((i) => otherContentDeliveryLayerNodes[i].start())
         await Promise.all(range(4).map(async (i) => {
-            await layer1Nodes[i].joinDht([entrypointDescriptor])
+            await otherLayer1Nodes[i].joinDht([entrypointDescriptor])
         }))
-        await waitForCondition(() => range(4).every((i) => graphNodes[i].getNeighbors().length >= 4), 15000, 1000)
+        await waitForCondition(() => range(4).every((i) => otherContentDeliveryLayerNodes[i].getNeighbors().length >= 4), 15000, 1000)
         range(4).forEach((i) => {
-            expect(graphNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
-            expect(graphNodes[i].getNeighbors().length).toBeGreaterThanOrEqual(4)
+            expect(otherContentDeliveryLayerNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
+            expect(otherContentDeliveryLayerNodes[i].getNeighbors().length).toBeGreaterThanOrEqual(4)
         })
         // Check bidirectionality
-        const allNodes = graphNodes
-        allNodes.push(entryPointRandomGraphNode)
+        const allNodes = otherContentDeliveryLayerNodes
+        allNodes.push(entryPointContentDeliveryLayerNode)
         range(5).forEach((i) => {
             const ownNodeId = allNodes[i].getOwnNodeId()
             allNodes[i].getNearbyNodeView().getIds().forEach((nodeId) => {
@@ -105,26 +104,26 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
     }, 60000)
 
     it('happy path 64 nodes', async () => {
-        await Promise.all(range(nodeCount).map((i) => graphNodes[i].start()))
-        await Promise.all(range(nodeCount).map((i) => {
-            layer1Nodes[i].joinDht([entrypointDescriptor])
+        await Promise.all(range(otherNodeCount).map((i) => otherContentDeliveryLayerNodes[i].start()))
+        await Promise.all(range(otherNodeCount).map((i) => {
+            otherLayer1Nodes[i].joinDht([entrypointDescriptor])
         }))
-        await Promise.all(graphNodes.map((node) =>
+        await Promise.all(otherContentDeliveryLayerNodes.map((node) =>
             waitForCondition(() => node.getNeighbors().length >= 4, 10000)
         ))
 
-        await Promise.all(graphNodes.map((node) =>
+        await Promise.all(otherContentDeliveryLayerNodes.map((node) =>
             waitForCondition(() => node.getOutgoingHandshakeCount() === 0)
         ))
 
         await waitForCondition(() => {
             let mismatchCounter = 0
-            graphNodes.forEach((node) => {
+            otherContentDeliveryLayerNodes.forEach((node) => {
                 const nodeId = node.getOwnNodeId()
                 node.getNeighbors().forEach((neighbor) => {
                     const neighborId = getNodeIdFromPeerDescriptor(neighbor)
-                    if (neighborId !== entryPointRandomGraphNode.getOwnNodeId()) {
-                        const neighbor = graphNodes.find((n) => n.getOwnNodeId() === neighborId)
+                    if (neighborId !== entryPointContentDeliveryLayerNode.getOwnNodeId()) {
+                        const neighbor = otherContentDeliveryLayerNodes.find((n) => n.getOwnNodeId() === neighborId)
                         const neighborIds = neighbor!.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
                         if (!neighborIds.includes(nodeId)) {
                             mismatchCounter += 1