@streamr/trackerless-network 100.0.0-testnet-two.4 → 100.0.0-testnet-three.0

package/test/end-to-end/random-graph-with-real-connections.test.ts

@@ -124,32 +124,32 @@ describe('random graph with real connections', () => {
 
     it('can fully connected topologies ', async () => {
         await waitForCondition(() => {
-            return randomGraphNode1.getTargetNeighborIds().length >= 3
-                && randomGraphNode2.getTargetNeighborIds().length >= 3
-                && randomGraphNode3.getTargetNeighborIds().length >= 3
-                && randomGraphNode4.getTargetNeighborIds().length >= 3
-                && randomGraphNode5.getTargetNeighborIds().length >= 3
+            return randomGraphNode1.getNeighbors().length >= 3
+                && randomGraphNode2.getNeighbors().length >= 3
+                && randomGraphNode3.getNeighbors().length >= 3
+                && randomGraphNode4.getNeighbors().length >= 3
+                && randomGraphNode5.getNeighbors().length >= 3
         }, 10000)
-        expect(randomGraphNode1.getTargetNeighborIds().length).toBeGreaterThanOrEqual(3)
-        expect(randomGraphNode2.getTargetNeighborIds().length).toBeGreaterThanOrEqual(3)
-        expect(randomGraphNode3.getTargetNeighborIds().length).toBeGreaterThanOrEqual(3)
-        expect(randomGraphNode4.getTargetNeighborIds().length).toBeGreaterThanOrEqual(3)
-        expect(randomGraphNode5.getTargetNeighborIds().length).toBeGreaterThanOrEqual(3)
+        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)
     })
 
     it('can propagate messages', async () => {
-        let numOfMessagesReceived = 0
-        randomGraphNode2.on('message', () => numOfMessagesReceived += 1)
-        randomGraphNode3.on('message', () => numOfMessagesReceived += 1)
-        randomGraphNode4.on('message', () => numOfMessagesReceived += 1)
-        randomGraphNode5.on('message', () => numOfMessagesReceived += 1)
+        let receivedMessageCount = 0
+        randomGraphNode2.on('message', () => receivedMessageCount += 1)
+        randomGraphNode3.on('message', () => receivedMessageCount += 1)
+        randomGraphNode4.on('message', () => receivedMessageCount += 1)
+        randomGraphNode5.on('message', () => receivedMessageCount += 1)
 
         await waitForCondition(() => {
-            return randomGraphNode1.getTargetNeighborIds().length >= 3
-                && randomGraphNode2.getTargetNeighborIds().length >= 3
-                && randomGraphNode3.getTargetNeighborIds().length >= 3
-                && randomGraphNode4.getTargetNeighborIds().length >= 3
-                && randomGraphNode5.getTargetNeighborIds().length >= 3
+            return randomGraphNode1.getNeighbors().length >= 3
+                && randomGraphNode2.getNeighbors().length >= 3
+                && randomGraphNode3.getNeighbors().length >= 3
+                && randomGraphNode4.getNeighbors().length >= 3
+                && randomGraphNode5.getNeighbors().length >= 3
         }, 10000)
 
         const msg = createStreamMessage(
@@ -158,6 +158,6 @@ describe('random graph with real connections', () => {
             randomEthereumAddress()
         )
         randomGraphNode1.broadcast(msg)
-        await waitForCondition(() => numOfMessagesReceived >= 4)
+        await waitForCondition(() => receivedMessageCount >= 4)
     })
 })

package/test/end-to-end/webrtc-full-node-network.test.ts

@@ -66,12 +66,12 @@ describe('Full node network with WebRTC connections', () => {
             }
             , 30000)
         ))
-        let numOfMessagesReceived = 0
+        let receivedMessageCount = 0
         const successIds: string[] = []
         nodes.forEach((node) => {
             node.getStreamrNode()!.on('newMessage', () => {
                 successIds.push(getNodeIdFromPeerDescriptor(node.getStreamrNode()!.getPeerDescriptor()))
-                numOfMessagesReceived += 1
+                receivedMessageCount += 1
             })
         })
         const msg = createStreamMessage(
@@ -80,7 +80,7 @@ describe('Full node network with WebRTC connections', () => {
             randomEthereumAddress()
         )
         entryPoint.getStreamrNode()!.broadcast(msg)
-        await waitForCondition(() => numOfMessagesReceived === NUM_OF_NODES)
+        await waitForCondition(() => receivedMessageCount === NUM_OF_NODES)
     }, 120000)
 
 })

package/test/end-to-end/websocket-full-node-network.test.ts

@@ -64,12 +64,12 @@ describe('Full node network with WebSocket connections only', () => {
             }
             , 30000)
         ))
-        let numOfMessagesReceived = 0
+        let receivedMessageCount = 0
         const successIds: string[] = []
         nodes.forEach((node) => {
             node.getStreamrNode()!.on('newMessage', () => {
                 successIds.push(getNodeIdFromPeerDescriptor(node.getStreamrNode()!.getPeerDescriptor()))
-                numOfMessagesReceived += 1
+                receivedMessageCount += 1
             })
         })
 
@@ -79,7 +79,7 @@ describe('Full node network with WebSocket connections only', () => {
             randomEthereumAddress()
         )
         entryPoint.getStreamrNode()!.broadcast(msg)
-        await waitForCondition(() => numOfMessagesReceived === NUM_OF_NODES)
+        await waitForCondition(() => receivedMessageCount === NUM_OF_NODES)
     }, 220000)
 
 })

package/test/integration/Handshakes.test.ts

@@ -34,7 +34,7 @@ describe('Handshakes', () => {
     let rpcCommunicator2: ListeningRpcCommunicator
     let rpcCommunicator3: ListeningRpcCommunicator
     let nodeView: NodeList
-    let targetNeighbors: NodeList
+    let neighbors: NodeList
     let handshaker: Handshaker
     const streamPartId = StreamPartIDUtils.parse('stream#0')
 
@@ -83,13 +83,13 @@ describe('Handshakes', () => {
 
         const handshakerNodeId = getNodeIdFromPeerDescriptor(peerDescriptor2)
         nodeView = new NodeList(handshakerNodeId, 10)
-        targetNeighbors = new NodeList(handshakerNodeId, 4)
+        neighbors = new NodeList(handshakerNodeId, 4)
         handshaker = new Handshaker({
             localPeerDescriptor: peerDescriptor2,
             streamPartId,
             nearbyNodeView: nodeView,
             randomNodeView: nodeView,
-            targetNeighbors,
+            neighbors,
             connectionLocker: mockConnectionLocker,
             rpcCommunicator: rpcCommunicator2,
             maxNeighborCount: 4
@@ -119,7 +119,7 @@ describe('Handshakes', () => {
             )
         )
         expect(res).toEqual(true)
-        expect(targetNeighbors.hasNode(peerDescriptor1)).toEqual(true)
+        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor1))).toEqual(true)
     })
 
     it('Handshake accepted', async () => {
@@ -134,7 +134,7 @@ describe('Handshakes', () => {
             )
         )
         expect(res).toEqual(true)
-        expect(targetNeighbors.hasNode(peerDescriptor1)).toEqual(true)
+        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor1))).toEqual(true)
     })
 
     it('Handshake rejected', async () => {
@@ -149,7 +149,7 @@ describe('Handshakes', () => {
             )
         )
         expect(res).toEqual(false)
-        expect(targetNeighbors.hasNode(peerDescriptor1)).toEqual(false)
+        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor1))).toEqual(false)
     })
 
     it('Handshake with Interleaving', async () => {
@@ -165,7 +165,7 @@ describe('Handshakes', () => {
             )
         )
         expect(res).toEqual(true)
-        expect(targetNeighbors.hasNode(peerDescriptor1)).toEqual(true)
-        expect(targetNeighbors.hasNode(peerDescriptor3)).toEqual(true)
+        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor1))).toEqual(true)
+        expect(neighbors.has(getNodeIdFromPeerDescriptor(peerDescriptor3))).toEqual(true)
     })
 })

package/test/integration/NetworkNode.test.ts

@@ -1,7 +1,9 @@
 import { NodeType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
 import {
+    ContentType,
+    EncryptionType,
     MessageID,
-    MessageRef,
+    MessageRef, SignatureType,
     StreamMessage,
     StreamMessageType,
     StreamPartIDUtils
@@ -78,7 +80,10 @@ describe('NetworkNode', () => {
             content: utf8ToBinary(JSON.stringify({
                 hello: 'world'
             })),
+            contentType: ContentType.JSON,
             messageType: StreamMessageType.MESSAGE,
+            encryptionType: EncryptionType.NONE,
+            signatureType: SignatureType.SECP256K1,
             signature: hexToBinary('0x1234'),
         })
 
@@ -93,4 +98,17 @@ describe('NetworkNode', () => {
         await waitForCondition(() => msgCount === 1)
     })
 
+    it('fetchNodeInfo', async () => {
+        await node1.join(STREAM_PART_ID)
+        await node2.join(STREAM_PART_ID)
+        const result1 = await node1.fetchNodeInfo(pd2)
+        const result2 = await node2.fetchNodeInfo(pd1)
+        expect(result1.streamPartitions.length).toEqual(1)
+        expect(result2.streamPartitions.length).toEqual(1)
+        expect(result1.controlLayer!.connections.length).toEqual(1)
+        expect(result2.controlLayer!.connections.length).toEqual(1)
+        expect(result1.controlLayer!.neighbors.length).toEqual(1)
+        expect(result2.controlLayer!.neighbors.length).toEqual(1)
+    })
+
 })

package/test/integration/NetworkRpc.test.ts

@@ -9,12 +9,13 @@ import { waitForCondition } from '@streamr/utils'
 import { Empty } from '../../src/proto/google/protobuf/empty'
 import { createStreamMessage } from '../utils/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { DhtCallContext } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 
 describe('Network RPC', () => {
-    let rpcCommunicator1: RpcCommunicator
-    let rpcCommunicator2: RpcCommunicator
+    let rpcCommunicator1: RpcCommunicator<DhtCallContext>
+    let rpcCommunicator2: RpcCommunicator<DhtCallContext>
     let client: ProtoRpcClient<DeliveryRpcClient>
     let recvCounter = 0
 

package/test/integration/NodeInfoRpc.test.ts

@@ -0,0 +1,103 @@
+import { Simulator, SimulatorTransport, ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
+import { NetworkStack } from '../../src/NetworkStack'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { NodeInfoClient } from '../../src/logic/node-info/NodeInfoClient'
+import { NODE_INFO_RPC_SERVICE_ID } from '../../src/logic/node-info/NodeInfoRpcLocal'
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { waitForCondition } from '@streamr/utils'
+
+// TODO add Jest utility so that the normalization is not needed (NET-1254)
+const normalizePeerDescriptor = (peerDescriptor: PeerDescriptor) => {
+    return {
+        ...peerDescriptor,
+        nodeId: new Uint8Array(peerDescriptor.nodeId)
+    }
+}
+
+describe('NetworkStack NodeInfoRpc', () => {
+
+    let requesteStack: NetworkStack
+    let otherStack: NetworkStack
+    let nodeInfoClient: NodeInfoClient
+    let requesteeTransport1: SimulatorTransport
+    let otherTransport: SimulatorTransport
+    let requestorTransport: SimulatorTransport
+
+    let simulator: Simulator
+
+    const requesteePeerDescriptor = createMockPeerDescriptor()
+    const otherPeerDescriptor = createMockPeerDescriptor()
+    const requestorPeerDescriptor = createMockPeerDescriptor()
+
+    beforeEach(async () => {
+        simulator = new Simulator()
+        requesteeTransport1 = new SimulatorTransport(requesteePeerDescriptor, simulator)
+        otherTransport = new SimulatorTransport(otherPeerDescriptor, simulator)
+        requestorTransport = new SimulatorTransport(requestorPeerDescriptor, simulator)
+        await requesteeTransport1.start()
+        await otherTransport.start()
+        await requestorTransport.start()
+        requesteStack = new NetworkStack({
+            layer0: {
+                transport: requesteeTransport1,
+                peerDescriptor: requesteePeerDescriptor,
+                entryPoints: [requesteePeerDescriptor]
+            }
+        })
+        otherStack = new NetworkStack({
+            layer0: {
+                transport: otherTransport,
+                peerDescriptor: otherPeerDescriptor,
+                entryPoints: [requesteePeerDescriptor]
+            }
+        })
+        await requesteStack.start()
+        await otherStack.start()
+        nodeInfoClient = new NodeInfoClient(requestorPeerDescriptor, new ListeningRpcCommunicator(NODE_INFO_RPC_SERVICE_ID, requestorTransport))
+    })
+
+    afterEach(async () => {
+        await requesteStack.stop()
+        await otherStack.stop()
+        await requesteeTransport1.stop()
+        await otherTransport.stop()
+        await requestorTransport.stop()
+    })
+
+    it('happy path', async () => {
+        const streamPartId1 = StreamPartIDUtils.parse('stream1#0')
+        const streamPartId2 = StreamPartIDUtils.parse('stream2#0')
+        requesteStack.getStreamrNode().joinStreamPart(streamPartId1)
+        otherStack.getStreamrNode().joinStreamPart(streamPartId1)
+        requesteStack.getStreamrNode().joinStreamPart(streamPartId2)
+        otherStack.getStreamrNode().joinStreamPart(streamPartId2)
+        await waitForCondition(() => 
+            requesteStack.getStreamrNode().getNeighbors(streamPartId1).length === 1 
+            && otherStack.getStreamrNode().getNeighbors(streamPartId1).length === 1
+            && requesteStack.getStreamrNode().getNeighbors(streamPartId2).length === 1
+            && otherStack.getStreamrNode().getNeighbors(streamPartId2).length === 1
+        )
+        const result = await nodeInfoClient.getInfo(requesteePeerDescriptor)
+        expect(result).toMatchObject({
+            peerDescriptor: normalizePeerDescriptor(requesteePeerDescriptor),
+            controlLayer: {
+                neighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
+                connections: [normalizePeerDescriptor(otherPeerDescriptor), normalizePeerDescriptor(requestorPeerDescriptor)]
+            },
+            streamPartitions: [
+                {
+                    id: streamPartId1,
+                    controlLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
+                    deliveryLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)]
+                },
+                {
+                    id: streamPartId2,
+                    controlLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)],
+                    deliveryLayerNeighbors: [normalizePeerDescriptor(otherPeerDescriptor)]
+                }
+            ]
+        })
+        expect(result.streamPartitions.length).toEqual(2)
+    })
+
+})

package/test/integration/Propagation.test.ts

@@ -54,11 +54,11 @@ describe('Propagation', () => {
 
     it('All nodes receive messages', async () => {
         await waitForCondition(
-            () => randomGraphNodes.every((node) => node.getTargetNeighborIds().length >= 3), 30000
+            () => randomGraphNodes.every((node) => node.getNeighbors().length >= 3), 30000
         )
         await waitForCondition(() => {
             const avg = randomGraphNodes.reduce((acc, curr) => {
-                return acc + curr.getTargetNeighborIds().length
+                return acc + curr.getNeighbors().length
             }, 0) / randomGraphNodes.length
             return avg >= 4
         }, 20000)

package/test/integration/RandomGraphNode-Layer1Node-Latencies.test.ts

@@ -1,4 +1,4 @@
-import { DhtNode, LatencyType, PeerDescriptor, Simulator, SimulatorTransport } from '@streamr/dht'
+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'
@@ -8,7 +8,7 @@ import { StreamPartIDUtils } from '@streamr/protocol'
 import { Layer1Node } from '../../src/logic/Layer1Node'
 
 describe('RandomGraphNode-DhtNode-Latencies', () => {
-    const numOfNodes = 64
+    const nodeCount = 64
     let layer1Nodes: Layer1Node[]
     let dhtEntryPoint: Layer1Node
     let entryPointRandomGraphNode: RandomGraphNode
@@ -17,11 +17,11 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
     const streamPartId = StreamPartIDUtils.parse('stream#0')
     const entrypointDescriptor = createMockPeerDescriptor()
 
-    const peerDescriptors: PeerDescriptor[] = range(numOfNodes).map(() => createMockPeerDescriptor())
+    const peerDescriptors: PeerDescriptor[] = range(nodeCount).map(() => createMockPeerDescriptor())
     beforeEach(async () => {
         const simulator = new Simulator(LatencyType.FIXED, 50)
         const entrypointCm = new SimulatorTransport(entrypointDescriptor, simulator)
-        const cms: SimulatorTransport[] = range(numOfNodes).map((i) =>
+        const cms: SimulatorTransport[] = range(nodeCount).map((i) =>
             new SimulatorTransport(peerDescriptors[i], simulator)
         )
         await entrypointCm.start()
@@ -32,12 +32,12 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
             peerDescriptor: entrypointDescriptor,
             serviceId: streamPartId
         })
-        layer1Nodes = range(numOfNodes).map((i) => new DhtNode({
+        layer1Nodes = range(nodeCount).map((i) => new DhtNode({
             transport: cms[i],
             peerDescriptor: peerDescriptors[i],
             serviceId: streamPartId
         }))
-        graphNodes = range(numOfNodes).map((i) => createRandomGraphNode({
+        graphNodes = range(nodeCount).map((i) => createRandomGraphNode({
             streamPartId,
             layer1Node: layer1Nodes[i],
             transport: cms[i],
@@ -72,10 +72,10 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
         await graphNodes[0].start()
         await Promise.all([
             waitForCondition(() => graphNodes[0].getNearbyNodeView().getIds().length === 1),
-            waitForCondition(() => graphNodes[0].getTargetNeighborIds().length === 1)
+            waitForCondition(() => graphNodes[0].getNeighbors().length === 1)
         ])
         expect(graphNodes[0].getNearbyNodeView().getIds().length).toEqual(1)
-        expect(graphNodes[0].getTargetNeighborIds().length).toEqual(1)
+        expect(graphNodes[0].getNeighbors().length).toEqual(1)
     })
 
     it('happy path 5 nodes', async () => {
@@ -84,14 +84,10 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
         await Promise.all(range(4).map(async (i) => {
             await layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
-        await Promise.all(range(4).map((i) => {
-            return waitForCondition(() => {
-                return graphNodes[i].getTargetNeighborIds().length >= 4
-            }, 15000, 2000)
-        }))
+        await waitForCondition(() => range(4).every((i) => graphNodes[i].getNeighbors().length >= 4), 15000, 1000)
         range(4).forEach((i) => {
             expect(graphNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
-            expect(graphNodes[i].getTargetNeighborIds().length).toBeGreaterThanOrEqual(4)
+            expect(graphNodes[i].getNeighbors().length).toBeGreaterThanOrEqual(4)
         })
         // Check bidirectionality
         const allNodes = graphNodes
@@ -102,32 +98,35 @@ describe('RandomGraphNode-DhtNode-Latencies', () => {
                 const neighbor = allNodes.find((node) => {
                     return node.getOwnNodeId() === ownNodeId
                 })
-                expect(neighbor!.getTargetNeighborIds()).toContain(nodeId)
+                const neighborIds = neighbor!.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
+                expect(neighborIds).toContain(nodeId)
             })
         })
     }, 60000)
 
     it('happy path 64 nodes', async () => {
-        await Promise.all(range(numOfNodes).map((i) => graphNodes[i].start()))
-        await Promise.all(range(numOfNodes).map((i) => {
+        await Promise.all(range(nodeCount).map((i) => graphNodes[i].start()))
+        await Promise.all(range(nodeCount).map((i) => {
             layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
         await Promise.all(graphNodes.map((node) =>
-            waitForCondition(() => node.getTargetNeighborIds().length >= 4, 10000)
+            waitForCondition(() => node.getNeighbors().length >= 4, 10000)
         ))
 
         await Promise.all(graphNodes.map((node) =>
-            waitForCondition(() => node.getNumberOfOutgoingHandshakes() === 0)
+            waitForCondition(() => node.getOutgoingHandshakeCount() === 0)
         ))
 
         await waitForCondition(() => {
             let mismatchCounter = 0
             graphNodes.forEach((node) => {
                 const nodeId = node.getOwnNodeId()
-                node.getTargetNeighborIds().forEach((neighborId) => {
+                node.getNeighbors().forEach((neighbor) => {
+                    const neighborId = getNodeIdFromPeerDescriptor(neighbor)
                     if (neighborId !== entryPointRandomGraphNode.getOwnNodeId()) {
                         const neighbor = graphNodes.find((n) => n.getOwnNodeId() === neighborId)
-                        if (!neighbor!.getTargetNeighborIds().includes(nodeId)) {
+                        const neighborIds = neighbor!.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
+                        if (!neighborIds.includes(nodeId)) {
                             mismatchCounter += 1
                         }
                     }

package/test/integration/RandomGraphNode-Layer1Node.test.ts

@@ -1,4 +1,4 @@
-import { ConnectionManager, DhtNode, PeerDescriptor, Simulator, SimulatorTransport, getRandomRegion } from '@streamr/dht'
+import { ConnectionManager, DhtNode, PeerDescriptor, Simulator, SimulatorTransport, getNodeIdFromPeerDescriptor, getRandomRegion } from '@streamr/dht'
 import { Logger, waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
@@ -10,7 +10,7 @@ import { Layer1Node } from '../../src/logic/Layer1Node'
 const logger = new Logger(module)
 
 describe('RandomGraphNode-DhtNode', () => {
-    const numOfNodes = 64
+    const nodeCount = 64
     let layer1Nodes: Layer1Node[]
     let dhtEntryPoint: Layer1Node
     let entryPointRandomGraphNode: RandomGraphNode
@@ -21,7 +21,7 @@ describe('RandomGraphNode-DhtNode', () => {
         region: getRandomRegion()
     })
 
-    const peerDescriptors: PeerDescriptor[] = range(numOfNodes).map(() => {
+    const peerDescriptors: PeerDescriptor[] = range(nodeCount).map(() => {
         return createMockPeerDescriptor({
             region: getRandomRegion()
         })
@@ -34,7 +34,7 @@ describe('RandomGraphNode-DhtNode', () => {
         )
         await entrypointCm.start()
 
-        const cms: ConnectionManager[] = range(numOfNodes).map((i) =>
+        const cms: ConnectionManager[] = range(nodeCount).map((i) =>
             new SimulatorTransport(
                 peerDescriptors[i],
                 simulator
@@ -48,13 +48,13 @@ describe('RandomGraphNode-DhtNode', () => {
             serviceId: streamPartId
         })
 
-        layer1Nodes = range(numOfNodes).map((i) => new DhtNode({
+        layer1Nodes = range(nodeCount).map((i) => new DhtNode({
             transport: cms[i],
             peerDescriptor: peerDescriptors[i],
             serviceId: streamPartId
         }))
 
-        graphNodes = range(numOfNodes).map((i) => createRandomGraphNode({
+        graphNodes = range(nodeCount).map((i) => createRandomGraphNode({
             streamPartId,
             layer1Node: layer1Nodes[i],
             transport: cms[i],
@@ -92,9 +92,9 @@ describe('RandomGraphNode-DhtNode', () => {
 
         await graphNodes[0].start()
 
-        await waitForCondition(() => graphNodes[0].getTargetNeighborIds().length === 1)
+        await waitForCondition(() => graphNodes[0].getNeighbors().length === 1)
         expect(graphNodes[0].getNearbyNodeView().getIds().length).toEqual(1)
-        expect(graphNodes[0].getTargetNeighborIds().length).toEqual(1)
+        expect(graphNodes[0].getNeighbors().length).toEqual(1)
     })
 
     it('happy path 4 nodes', async () => {
@@ -104,10 +104,10 @@ describe('RandomGraphNode-DhtNode', () => {
             await layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
 
-        await waitForCondition(() => range(4).every((i) => graphNodes[i].getTargetNeighborIds().length === 4))
+        await waitForCondition(() => range(4).every((i) => graphNodes[i].getNeighbors().length === 4))
         range(4).forEach((i) => {
             expect(graphNodes[i].getNearbyNodeView().getIds().length).toBeGreaterThanOrEqual(4)
-            expect(graphNodes[i].getTargetNeighborIds().length).toBeGreaterThanOrEqual(4)
+            expect(graphNodes[i].getNeighbors().length).toBeGreaterThanOrEqual(4)
         })
 
         // Check bidirectionality
@@ -118,36 +118,39 @@ describe('RandomGraphNode-DhtNode', () => {
                 const neighbor = allNodes.find((node) => {
                     return node.getOwnNodeId() === nodeId
                 })
-                expect(neighbor!.getTargetNeighborIds().includes(allNodes[i].getOwnNodeId())).toEqual(true)
+                const neighborIds = neighbor!.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
+                expect(neighborIds.includes(allNodes[i].getOwnNodeId())).toEqual(true)
             })
         })
     }, 10000)
 
     it('happy path 64 nodes', async () => {
-        await Promise.all(range(numOfNodes).map((i) => graphNodes[i].start()))
-        await Promise.all(range(numOfNodes).map((i) => {
+        await Promise.all(range(nodeCount).map((i) => graphNodes[i].start()))
+        await Promise.all(range(nodeCount).map((i) => {
             layer1Nodes[i].joinDht([entrypointDescriptor])
         }))
         await Promise.all(graphNodes.map((node) =>
-            waitForCondition(() => node.getTargetNeighborIds().length >= 4, 10000)
+            waitForCondition(() => node.getNeighbors().length >= 4, 10000)
         ))
 
         const avg = graphNodes.reduce((acc, curr) => {
-            return acc + curr.getTargetNeighborIds().length
-        }, 0) / numOfNodes
+            return acc + curr.getNeighbors().length
+        }, 0) / nodeCount
 
         logger.info(`AVG Number of neighbors: ${avg}`)
         await Promise.all(graphNodes.map((node) =>
-            waitForCondition(() => node.getNumberOfOutgoingHandshakes() === 0)
+            waitForCondition(() => node.getOutgoingHandshakeCount() === 0)
         ))
         await waitForCondition(() => {
             let mismatchCounter = 0
             graphNodes.forEach((node) => {
                 const nodeId = node.getOwnNodeId()
-                node.getTargetNeighborIds().forEach((neighborId) => {
+                node.getNeighbors().forEach((neighbor) => {
+                    const neighborId = getNodeIdFromPeerDescriptor(neighbor)
                     if (neighborId !== entryPointRandomGraphNode.getOwnNodeId()) {
                         const neighbor = graphNodes.find((n) => n.getOwnNodeId() === neighborId)
-                        if (!neighbor!.getTargetNeighborIds().includes(nodeId)) {
+                        const neighborIds = neighbor!.getNeighbors().map((n) => getNodeIdFromPeerDescriptor(n))
+                        if (!neighborIds.includes(nodeId)) {
                             mismatchCounter += 1
                         }
                     }