@streamr/dht 100.0.0-testnet-two.3 → 100.0.0-testnet-three.0

package/test/benchmark/SortedContactListBenchmark.test.ts

@@ -2,8 +2,7 @@
 
 import KBucket from 'k-bucket'
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
-import crypto from 'crypto'
-import { DhtAddress, DhtAddressRaw, getDhtAddressFromRaw } from '../../src/identifiers'
+import { DhtAddress, DhtAddressRaw, createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
 
 const NUM_ADDS = 1000
 
@@ -14,10 +13,11 @@ interface Item {
 }
 
 const createRandomItem = (index: number): Item => {
-    const rand = new Uint8Array(crypto.randomBytes(20))
+    const nodeId = createRandomDhtAddress()
+    const nodeIdRaw = getRawFromDhtAddress(nodeId)
     return {
-        getNodeId: () => getDhtAddressFromRaw(rand),
-        id: rand,
+        getNodeId: () => nodeId,
+        id: nodeIdRaw,
         vectorClock: index
     }
 }
@@ -32,13 +32,13 @@ function shuffleArray<T>(array: T[]): T[] {
 
 describe('SortedContactListBenchmark', () => {
 
-    it('adds ' + NUM_ADDS + ' random peerIDs', async () => {
+    it('adds ' + NUM_ADDS + ' random nodeIds', async () => {
         const randomIds = []
         for (let i = 0; i < NUM_ADDS; i++) {
             randomIds.push(createRandomItem(i))
         }
         const list = new SortedContactList({
-            referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
+            referenceId: createRandomDhtAddress(),
             allowToContainReferenceId: true,
             emitEvents: true
         })
@@ -50,7 +50,7 @@ describe('SortedContactListBenchmark', () => {
         console.timeEnd('SortedContactList.addContact() with emitEvents=true')
 
         const list2 = new SortedContactList({
-            referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
+            referenceId: createRandomDhtAddress(),
             allowToContainReferenceId: true,
             emitEvents: false
         })
@@ -61,7 +61,7 @@ describe('SortedContactListBenchmark', () => {
         }
         console.timeEnd('SortedContactList.addContact() with emitEvents=false')
 
-        const kBucket = new KBucket<Item>({ localNodeId: crypto.randomBytes(20) })
+        const kBucket = new KBucket<Item>({ localNodeId: getRawFromDhtAddress(createRandomDhtAddress()) })
         console.time('KBucket.add()')
         for (let i = 0; i < NUM_ADDS; i++) {
             kBucket.add(randomIds[i])
@@ -77,14 +77,14 @@ describe('SortedContactListBenchmark', () => {
 
         console.time('kBucket closest()')
         for (let i = 0; i < NUM_ADDS; i++) {
-            kBucket.closest(crypto.randomBytes(20), 20)
+            kBucket.closest(getRawFromDhtAddress(createRandomDhtAddress()), 20)
         }
         console.timeEnd('kBucket closest()')
 
         console.time('SortedContactList.getClosestContacts() with emitEvents=true')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
+                referenceId: createRandomDhtAddress(),
                 allowToContainReferenceId: true,
                 emitEvents: true
             })
@@ -98,7 +98,7 @@ describe('SortedContactListBenchmark', () => {
         console.time('SortedContactList.getClosestContacts() with emitEvents=false')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
+                referenceId: createRandomDhtAddress(),
                 allowToContainReferenceId: true,
                 emitEvents: false
             })
@@ -112,7 +112,7 @@ describe('SortedContactListBenchmark', () => {
         console.time('SortedContactList.getClosestContacts() with emitEvents=false and lodash')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
+                referenceId: createRandomDhtAddress(),
                 allowToContainReferenceId: true,
                 emitEvents: false
             })
@@ -126,7 +126,7 @@ describe('SortedContactListBenchmark', () => {
         console.time('SortedContactList.getClosestContacts() with emitEvents=false and addContacts()')
         for (let i = 0; i < NUM_ADDS; i++) {
             const closest = new SortedContactList<Item>({
-                referenceId: getDhtAddressFromRaw(crypto.randomBytes(20)),
+                referenceId: createRandomDhtAddress(),
                 allowToContainReferenceId: true,
                 emitEvents: false
             })
@@ -140,10 +140,10 @@ describe('SortedContactListBenchmark', () => {
         const shuffled = shuffleArray(kBucket.toArray())
         console.time('kbucket add and closest')
         for (let i = 0; i < NUM_ADDS; i++) {
-            const bucket2 = new KBucket<Item>({ localNodeId: crypto.randomBytes(20) })
+            const bucket2 = new KBucket<Item>({ localNodeId: getRawFromDhtAddress(createRandomDhtAddress()) })
 
             shuffled.forEach((contact) => bucket2.add(contact))
-            bucket2.closest(crypto.randomBytes(20), 20)
+            bucket2.closest(getRawFromDhtAddress(createRandomDhtAddress()), 20)
         }
         console.timeEnd('kbucket add and closest')
 

package/test/benchmark/WebsocketServerMemoryLeak.test.ts

@@ -2,7 +2,7 @@
 
 import { wait } from '@streamr/utils'
 import { WebsocketServer } from '../../src/connection/websocket/WebsocketServer'
-import { ClientWebsocket } from '../../src/exports'
+import { ClientWebsocket } from '../../src/connection/websocket/ClientWebsocket'
 
 // This 'test' is meant to be run manually using the following command:
 // node --inspect ../../../../node_modules/.bin/jest WebsocketServerMemoryLeak.test.ts

package/test/benchmark/kademlia-simulation/KademliaSimulation.ts

@@ -42,17 +42,17 @@ export class KademliaSimulation {
 
         for (let i = this.nodes.length - 1; i >= 0; i--) {
             
-            const numberOfOutgoingRpcCalls = this.nodes[i].getNumberOfOutgoingRpcCalls()
+            const outgoingRpcCallCount = this.nodes[i].getOutgoingRpcCallCount()
             console.log('-----------')
             console.log('Node: ' + i)
             console.log('Kbucket size: ' + this.nodes[i].getKBucketSize())
-            console.log('Num incoming RPC calls: ' + this.nodes[i].getNumberOfIncomingRpcCalls())
-            console.log('Num outgoing RPC calls: ' + numberOfOutgoingRpcCalls)
+            console.log('Num incoming RPC calls: ' + this.nodes[i].getIncomingRpcCallCount())
+            console.log('Num outgoing RPC calls: ' + outgoingRpcCallCount)
     
-            sumOutgoingRpcCalls += numberOfOutgoingRpcCalls
+            sumOutgoingRpcCalls += outgoingRpcCallCount
     
-            if (maxOutgoingRpcCalls < numberOfOutgoingRpcCalls) {
-                maxOutgoingRpcCalls = numberOfOutgoingRpcCalls
+            if (maxOutgoingRpcCalls < outgoingRpcCallCount) {
+                maxOutgoingRpcCalls = outgoingRpcCallCount
             }
 
             const kademliaNeighbors = this.nodes[i].getNeightborList().getContactIds()
@@ -79,13 +79,13 @@ export class KademliaSimulation {
 
         const avgCorrectNeighbors = sumCorrectNeighbors / (KademliaSimulation.NUM_NODES - 1)
         const avgKbucketSize = sumKbucketSize / (KademliaSimulation.NUM_NODES - 1)
-        const avgNumberOfOutgoingRpcCalls = sumOutgoingRpcCalls / (KademliaSimulation.NUM_NODES - 1)
+        const avgOutgoingRpcCallCount = sumOutgoingRpcCalls / (KademliaSimulation.NUM_NODES - 1)
 
         console.log('----------- Simulation results ------------------')
         console.log('Minimum correct neighbors: ' + minimumCorrectNeighbors)
         console.log('Average correct neighbors: ' + avgCorrectNeighbors)
         console.log('Average Kbucket size: ' + avgKbucketSize)
-        console.log('Average number of outgoing RPC calls: ' + avgNumberOfOutgoingRpcCalls)
+        console.log('Average number of outgoing RPC calls: ' + avgOutgoingRpcCallCount)
         console.log('MAX number of outgoing RPC calls: ' + maxOutgoingRpcCalls)
     }
 }

package/test/benchmark/kademlia-simulation/SimulationNode.ts

@@ -12,8 +12,8 @@ export class SimulationNode {
     private bucket: KBucket<Contact>
     private ownContact: Contact
 
-    private numberOfIncomingRpcCalls = 0
-    private numberOfOutgoingRpcCalls = 0
+    private incomingRpcCallCount = 0
+    private outgoingRpcCallCount = 0
 
     private neighborList: SortedContactList<Contact>
     private ownId: DhtAddress
@@ -47,18 +47,18 @@ export class SimulationNode {
         return this.bucket.count()
     }
 
-    public getNumberOfIncomingRpcCalls(): number {
-        return this.numberOfIncomingRpcCalls
+    public getIncomingRpcCallCount(): number {
+        return this.incomingRpcCallCount
     }
 
-    public getNumberOfOutgoingRpcCalls(): number {
-        return this.numberOfOutgoingRpcCalls
+    public getOutgoingRpcCallCount(): number {
+        return this.outgoingRpcCallCount
     }
 
     // RPC call
 
     public getClosestNodesTo(id: DhtAddress, caller: SimulationNode): Contact[] {
-        this.numberOfIncomingRpcCalls++
+        this.incomingRpcCallCount++
         const idValue = getRawFromDhtAddress(id)
         const ret = this.bucket.closest(idValue)
         if (!this.bucket.get(idValue)) {
@@ -73,7 +73,7 @@ export class SimulationNode {
         contactList.forEach((contact) => {
             shortlist.setContacted(contact.getNodeId())
             shortlist.setActive(contact.getNodeId())
-            this.numberOfOutgoingRpcCalls++
+            this.outgoingRpcCallCount++
             const returnedContacts = contact.dhtNode!.getClosestNodesTo(this.ownId, this)
             shortlist.addContacts(returnedContacts)
             returnedContacts.forEach((returnedContact: Contact) => {

package/test/end-to-end/Layer0-Layer1.test.ts

@@ -1,5 +1,5 @@
 import { DhtNode } from '../../src/dht/DhtNode'
-import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors } from '../../src/identifiers'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 const STREAM_ID1 = 'stream1'

package/test/end-to-end/Layer0.test.ts

@@ -68,9 +68,9 @@ describe('Layer0', () => {
             node4.joinDht([epDhtNode.getLocalPeerDescriptor()])
         ])
 
-        expect(node1.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(node2.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(node3.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(node4.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(node1.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node2.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node3.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node4.getNeighborCount()).toBeGreaterThanOrEqual(2)
     }, 10000)
 })

package/test/end-to-end/Layer0MixedConnectionTypes.test.ts

@@ -87,13 +87,13 @@ describe('Layer0MixedConnectionTypes', () => {
             node5.joinDht([epPeerDescriptor])
         ])
 
-        expect(node1.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(node2.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(node3.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(node4.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(node5.getNumberOfNeighbors()).toBeGreaterThanOrEqual(1)
+        expect(node1.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node2.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node3.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node4.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node5.getNeighborCount()).toBeGreaterThanOrEqual(1)
 
-    }, 15000)
+    }, 20000)
 
     it('Simultaneous joins', async () => {
         await Promise.all([
@@ -103,10 +103,10 @@ describe('Layer0MixedConnectionTypes', () => {
             node4.joinDht([epPeerDescriptor]),
             node5.joinDht([epPeerDescriptor])
         ])
-        expect(node1.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(node2.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(node3.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(node4.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(node5.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-    }, 30000)
+        expect(node1.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node2.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node3.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node4.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(node5.getNeighborCount()).toBeGreaterThanOrEqual(2)
+    }, 40000)
 })

package/test/end-to-end/Layer0Webrtc-Layer1.test.ts

@@ -1,6 +1,6 @@
 import { DhtNode } from '../../src/dht/DhtNode'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { getNodeIdFromPeerDescriptor } from '../../src/exports'
 
 describe('Layer 1 on Layer 0 with mocked connections', () => {
 
@@ -26,52 +26,52 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
         layer0EntryPoint = new DhtNode({ peerDescriptor: entrypointDescriptor, websocketServerEnableTls: false })
 
-        const layer0Node1Id = '11'
+        const layer0Node1Id = '11' as DhtAddress
         layer0Node1 = new DhtNode({
-            peerId: layer0Node1Id
+            nodeId: layer0Node1Id
         })
 
-        const layer0Node2Id = '22'
+        const layer0Node2Id = '22' as DhtAddress
         layer0Node2 = new DhtNode({
-            peerId: layer0Node2Id
+            nodeId: layer0Node2Id
         })
 
-        const layer0Node3Id = '33'
+        const layer0Node3Id = '33' as DhtAddress
         layer0Node3 = new DhtNode({
-            peerId: layer0Node3Id
+            nodeId: layer0Node3Id
         })
 
-        const layer0Node4Id = '44'
+        const layer0Node4Id = '44' as DhtAddress
         layer0Node4 = new DhtNode({
-            peerId: layer0Node4Id
+            nodeId: layer0Node4Id
         })
 
         layer1EntryPoint = new DhtNode({
-            peerId: getNodeIdFromPeerDescriptor(entrypointDescriptor),
+            nodeId: getNodeIdFromPeerDescriptor(entrypointDescriptor),
             transport: layer0EntryPoint,
             serviceId: 'layer1'
         })
 
         layer1Node1 = new DhtNode({
-            peerId: layer0Node1Id,
+            nodeId: layer0Node1Id,
             transport: layer0Node1,
             serviceId: 'layer1'
         })
 
         layer1Node2 = new DhtNode({
-            peerId: layer0Node2Id,
+            nodeId: layer0Node2Id,
             transport: layer0Node2,
             serviceId: 'layer1'
         })
 
         layer1Node3 = new DhtNode({
-            peerId: layer0Node3Id,
+            nodeId: layer0Node3Id,
             transport: layer0Node3,
             serviceId: 'layer1'
         })
 
         layer1Node4 = new DhtNode({
-            peerId: layer0Node4Id,
+            nodeId: layer0Node4Id,
             transport: layer0Node4,
             serviceId: 'layer1'
         })
@@ -119,9 +119,9 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
         await layer1Node3.joinDht([entrypointDescriptor])
         await layer1Node4.joinDht([entrypointDescriptor])
 
-        expect(layer1Node1.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node2.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node3.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
-        expect(layer1Node4.getNumberOfNeighbors()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node1.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node2.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node3.getNeighborCount()).toBeGreaterThanOrEqual(2)
+        expect(layer1Node4.getNeighborCount()).toBeGreaterThanOrEqual(2)
     }, 60000)
 })

package/test/end-to-end/Layer0Webrtc.test.ts

@@ -4,6 +4,7 @@ import { ConnectionType } from '../../src/connection/IConnection'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
+import { getNodeIdFromPeerDescriptor } from '../../src/exports'
 
 describe('Layer0 with WebRTC connections', () => {
 
@@ -66,12 +67,13 @@ describe('Layer0 with WebRTC connections', () => {
             node2.joinDht([epPeerDescriptor]),
             node1.joinDht([epPeerDescriptor])
         ])
-
-        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getLocalPeerDescriptor())).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getLocalPeerDescriptor())).toEqual(true)
-        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getLocalPeerDescriptor())!.connectionType)
+        const nodeId1 = getNodeIdFromPeerDescriptor(node1.getLocalPeerDescriptor())
+        const nodeId2 = getNodeIdFromPeerDescriptor(node2.getLocalPeerDescriptor())
+        expect((node1.getTransport() as ConnectionManager).hasConnection(nodeId2)).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(nodeId1)).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).getConnection(nodeId2)!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
-        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getLocalPeerDescriptor())!.connectionType)
+        expect((node2.getTransport() as ConnectionManager).getConnection(nodeId1)!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
 
     }, 60000)
@@ -83,12 +85,13 @@ describe('Layer0 with WebRTC connections', () => {
             node3.joinDht([epPeerDescriptor]),
             node4.joinDht([epPeerDescriptor])
         ])
-
-        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getLocalPeerDescriptor())).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getLocalPeerDescriptor())).toEqual(true)
-        expect((node1.getTransport() as ConnectionManager).getConnection(node2.getLocalPeerDescriptor())!.connectionType)
+        const nodeId1 = getNodeIdFromPeerDescriptor(node1.getLocalPeerDescriptor())
+        const nodeId2 = getNodeIdFromPeerDescriptor(node2.getLocalPeerDescriptor())
+        expect((node1.getTransport() as ConnectionManager).hasConnection(nodeId2)).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(nodeId1)).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).getConnection(nodeId2)!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
-        expect((node2.getTransport() as ConnectionManager).getConnection(node1.getLocalPeerDescriptor())!.connectionType)
+        expect((node2.getTransport() as ConnectionManager).getConnection(nodeId1)!.connectionType)
             .toEqual(ConnectionType.WEBRTC)
     })
 })

package/test/end-to-end/Layer1-Scale-WebSocket.test.ts

@@ -67,10 +67,10 @@ describe('Layer1 Scale', () => {
     // TODO: fix flaky test in NET-1021
     it('bucket sizes', async () => {
         layer0Nodes.forEach((node) => {
-            expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
+            expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
         })
         layer1Nodes.forEach((node ) => {
-            expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+            expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         })
     })
 })

package/test/end-to-end/Layer1-Scale-Webrtc.test.ts

@@ -58,10 +58,10 @@ describe('Layer1 Scale', () => {
 
     it('bucket sizes', async () => {
         layer0Nodes.forEach((node) => {
-            expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
+            expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET - 1)
         })
         layer1Nodes.forEach((node) => {
-            expect(node.getNumberOfNeighbors()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
+            expect(node.getNeighborCount()).toBeGreaterThanOrEqual(NUM_OF_NODES_PER_KBUCKET / 2)
         })
     })
 })

package/test/end-to-end/RecoveryFromFailedAutoCertification.test.ts

@@ -46,7 +46,7 @@ describe('Failed autocertification', () => {
         const failedAutocertificationPeerDescriptor = failedAutocertificationNode.getLocalPeerDescriptor()
         expect(failedAutocertificationPeerDescriptor.websocket!.tls).toBe(false)
         await failedAutocertificationNode.joinDht([entryPointPeerDescriptor])
-        expect(failedAutocertificationNode.getNumberOfNeighbors()).toEqual(2)
+        expect(failedAutocertificationNode.getNeighborCount()).toEqual(2)
     })
 
 })

package/test/end-to-end/WebsocketConnectionRequest.test.ts

@@ -2,8 +2,8 @@ import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { waitForCondition } from '@streamr/utils'
-import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { createMockPeerDescriptor } from '../utils/utils'
+import { areEqualPeerDescriptors } from '../../src/identifiers'
 
 describe('Websocket IConnection Requests', () => {
 
@@ -62,8 +62,8 @@ describe('Websocket IConnection Requests', () => {
 
         await waitForCondition(() => { return (connected1 && connected2) })
 
-        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getLocalPeerDescriptor())).toEqual(true)
-        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getLocalPeerDescriptor())).toEqual(true)
+        expect((node1.getTransport() as ConnectionManager).hasConnection(node2.getNodeId())).toEqual(true)
+        expect((node2.getTransport() as ConnectionManager).hasConnection(node1.getNodeId())).toEqual(true)
 
     }, 10000)
 })

package/test/end-to-end/memory-leak.test.ts

@@ -4,7 +4,7 @@ import { DhtNode } from '../../src/dht/DhtNode'
 import { Message, MessageType } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { getNodeIdFromPeerDescriptor } from '../../src/exports'
+import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 const MESSAGE_ID = 'mock-message-id'
 
@@ -19,7 +19,7 @@ describe('memory leak', () => {
             }
         })
         let entryPoint: DhtNode | undefined = new DhtNode({
-            peerId: getNodeIdFromPeerDescriptor(entryPointDescriptor),
+            nodeId: getNodeIdFromPeerDescriptor(entryPointDescriptor),
             websocketHost: entryPointDescriptor.websocket!.host,
             websocketPortRange: {
                 min: entryPointDescriptor.websocket!.port,