@streamr/dht 100.0.0-pretestnet.3 → 100.0.0-pretestnet.4

package/src/dht/routing/Router.ts

@@ -1,5 +1,10 @@
 import { Message, PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import {
+    areEqualPeerDescriptors,
+    getNodeIdFromPeerDescriptor,
+    keyFromPeerDescriptor,
+    peerIdFromPeerDescriptor
+} from '../../helpers/peerIdFromPeerDescriptor'
 import { RoutingMode, RoutingSession, RoutingSessionEvents } from './RoutingSession'
 import { Logger, executeSafePromise, raceEvents3, withTimeout } from '@streamr/utils'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
@@ -128,8 +133,8 @@ export class Router implements IRouter {
         if (this.stopped) {
             return createRouteMessageAck(routedMessage, RoutingErrors.STOPPED)
         }
-        logger.trace(`Routing message ${routedMessage.requestId} from ${keyFromPeerDescriptor(routedMessage.sourcePeer!)} `
-            + `to ${keyFromPeerDescriptor(routedMessage.destinationPeer!)}`)
+        logger.trace(`Routing message ${routedMessage.requestId} from ${getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!)} `
+            + `to ${getNodeIdFromPeerDescriptor(routedMessage.destinationPeer!)}`)
         const session = this.createRoutingSession(routedMessage, mode)
         const contacts = session.findMoreContacts()
         if (contacts.length > 0) {
@@ -158,8 +163,8 @@ export class Router implements IRouter {
             return createRouteMessageAck(routedMessage)
         } else {
             if (areEqualPeerDescriptors(routedMessage.sourcePeer!, this.localPeerDescriptor)) {
-                logger.warn(
-                    `Failed to send (routeMessage: ${this.serviceId}) to ${keyFromPeerDescriptor(routedMessage.destinationPeer!)}`
+                logger.debug(
+                    `Failed to send (routeMessage: ${this.serviceId}) to ${getNodeIdFromPeerDescriptor(routedMessage.destinationPeer!)}`
                 )
             }
             logger.trace('noCandidatesFound sessionId: ' + session.sessionId)

package/src/dht/routing/RouterRpcLocal.ts

@@ -1,6 +1,6 @@
 import { Logger } from '@streamr/utils'
 import { ConnectionManager } from '../../connection/ConnectionManager'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { IRouterRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { DuplicateDetector } from './DuplicateDetector'
@@ -35,8 +35,8 @@ export class RouterRpcLocal implements IRouterRpc {
 
     async routeMessage(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
         if (this.config.duplicateRequestDetector.isMostLikelyDuplicate(routedMessage.requestId)) {
-            logger.trace(`Routing message ${routedMessage.requestId} from ${keyFromPeerDescriptor(routedMessage.sourcePeer!)} `
-                + `to ${keyFromPeerDescriptor(routedMessage.destinationPeer!)} is likely a duplicate`)
+            logger.trace(`Routing message ${routedMessage.requestId} from ${getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!)} `
+                + `to ${getNodeIdFromPeerDescriptor(routedMessage.destinationPeer!)} is likely a duplicate`)
             return createRouteMessageAck(routedMessage, 'message given to routeMessage() service is likely a duplicate')
         }
         logger.trace(`Processing received routeMessage ${routedMessage.requestId}`)
@@ -54,8 +54,8 @@ export class RouterRpcLocal implements IRouterRpc {
 
     async forwardMessage(forwardMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
         if (this.config.duplicateRequestDetector.isMostLikelyDuplicate(forwardMessage.requestId)) {
-            logger.trace(`Forwarding message ${forwardMessage.requestId} from ${keyFromPeerDescriptor(forwardMessage.sourcePeer!)} `
-                + `to ${keyFromPeerDescriptor(forwardMessage.destinationPeer!)} is likely a duplicate`)
+            logger.trace(`Forwarding message ${forwardMessage.requestId} from ${getNodeIdFromPeerDescriptor(forwardMessage.sourcePeer!)} `
+                + `to ${getNodeIdFromPeerDescriptor(forwardMessage.destinationPeer!)} is likely a duplicate`)
             return createRouteMessageAck(forwardMessage, 'message given to forwardMessage() service is likely a duplicate')
         }
         logger.trace(`Processing received forward routeMessage ${forwardMessage.requestId}`)

package/src/dht/routing/RouterRpcRemote.ts

@@ -2,8 +2,7 @@ import { RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { v4 } from 'uuid'
 import {
     areEqualPeerDescriptors,
-    keyFromPeerDescriptor,
-    peerIdFromPeerDescriptor
+    getNodeIdFromPeerDescriptor
 } from '../../helpers/peerIdFromPeerDescriptor'
 import { IRouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Remote } from '../contact/Remote'
@@ -38,9 +37,9 @@ export class RouterRpcRemote extends Remote<IRouterRpcClient> {
         } catch (err) {
             const previousPeer = getPreviousPeer(params)
             const fromNode = previousPeer
-                ? peerIdFromPeerDescriptor(previousPeer)
-                : keyFromPeerDescriptor(params.sourcePeer!)
-            logger.trace(`Failed to send routeMessage from ${fromNode} to ${keyFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
+                ? getNodeIdFromPeerDescriptor(previousPeer)
+                : getNodeIdFromPeerDescriptor(params.sourcePeer!)
+            logger.trace(`Failed to send routeMessage from ${fromNode} to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
             return false
         }
         return true
@@ -64,10 +63,10 @@ export class RouterRpcRemote extends Remote<IRouterRpcClient> {
         } catch (err) {
             const previousPeer = getPreviousPeer(params)
             const fromNode = previousPeer
-                ? keyFromPeerDescriptor(previousPeer)
-                : keyFromPeerDescriptor(params.sourcePeer!)
+                ? getNodeIdFromPeerDescriptor(previousPeer)
+                : getNodeIdFromPeerDescriptor(params.sourcePeer!)
             logger.trace(
-                `Failed to send forwardMessage from ${fromNode} to ${keyFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`
+                `Failed to send forwardMessage from ${fromNode} to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`
             )
             return false
         }

package/src/dht/routing/RoutingSession.ts

@@ -1,7 +1,7 @@
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { SortedContactList } from '../contact/SortedContactList'
 import { PeerID, PeerIDKey } from '../../helpers/PeerID'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { v4 } from 'uuid'
@@ -197,7 +197,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         while ((this.ongoingRequests.size < this.parallelism) && (uncontacted.length > 0) && !this.stopped) {
             const nextPeer = uncontacted.shift()
             // eslint-disable-next-line max-len
-            logger.trace(`Sending routeMessage request to contact: ${keyFromPeerDescriptor(nextPeer!.getPeerDescriptor())} (sessionId=${this.sessionId})`)
+            logger.trace(`Sending routeMessage request to contact: ${getNodeIdFromPeerDescriptor(nextPeer!.getPeerDescriptor())} (sessionId=${this.sessionId})`)
             this.contactList.setContacted(nextPeer!.getPeerId())
             this.ongoingRequests.add(nextPeer!.getPeerId().toKey())
             setImmediate(async () => {

package/src/dht/store/StoreRpcLocal.ts

@@ -10,7 +10,7 @@ import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { StoreRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { IFinder } from '../find/Finder'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import { LocalDataStore } from './LocalDataStore'
 import { IStoreRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
@@ -224,7 +224,7 @@ export class StoreRpcLocal implements IStoreRpc {
                 if (response.deleted) {
                     logger.trace('remote.deleteData() returned success')
                 } else {
-                    logger.trace('could not delete data from ' + keyFromPeerDescriptor(closestNodes[i]))
+                    logger.trace('could not delete data from ' + getNodeIdFromPeerDescriptor(closestNodes[i]))
                 }
                 successfulNodes.push(closestNodes[i])
             } catch (e) {

package/src/dht/store/StoreRpcRemote.ts

@@ -8,7 +8,7 @@ import {
     StoreDataRequest,
     StoreDataResponse
 } from '../../proto/packages/dht/protos/DhtRpc'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
 export class StoreRpcRemote extends Remote<IStoreRpcClient> {
 
@@ -17,8 +17,8 @@ export class StoreRpcRemote extends Remote<IStoreRpcClient> {
         try {
             return await this.getClient().storeData(request, options)
         } catch (err) {
-            const to = keyFromPeerDescriptor(this.getPeerDescriptor())
-            const from = keyFromPeerDescriptor(this.getLocalPeerDescriptor())
+            const to = getNodeIdFromPeerDescriptor(this.getPeerDescriptor())
+            const from = getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor())
             throw Error(
                 `Could not store data to ${to} from ${from} ${err}`
             )
@@ -31,7 +31,7 @@ export class StoreRpcRemote extends Remote<IStoreRpcClient> {
             return await this.getClient().deleteData(request, options)
         } catch (err) {
             throw Error(
-                `Could not call delete data to ${keyFromPeerDescriptor(this.getPeerDescriptor())} ${err}`
+                `Could not call delete data to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} ${err}`
             )
         }
     }

package/src/helpers/peerIdFromPeerDescriptor.ts

@@ -1,3 +1,4 @@
+import { binaryToHex } from '@streamr/utils'
 import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 import { PeerID, PeerIDKey } from './PeerID'
 
@@ -5,6 +6,11 @@ export const peerIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerID
     return PeerID.fromValue(peerDescriptor.kademliaId)
 }
 
+// TODO could move getNodeIdFromPeerDescriptor (and NodeID) from trackerless-network
+export const getNodeIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): string => {
+    return binaryToHex(peerDescriptor.kademliaId)
+}
+
 export const keyFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerIDKey => {
     return PeerID.fromValue(peerDescriptor.kademliaId).toKey()
 }

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

@@ -354,30 +354,26 @@ export interface ConnectivityResponse {
  */
 export interface HandshakeRequest {
     /**
-     * @generated from protobuf field: bytes sourceId = 1;
+     * @generated from protobuf field: dht.PeerDescriptor sourcePeerDescriptor = 1;
      */
-    sourceId: Uint8Array;
+    sourcePeerDescriptor?: PeerDescriptor;
     /**
-     * @generated from protobuf field: dht.PeerDescriptor peerDescriptor = 2;
+     * @generated from protobuf field: optional dht.PeerDescriptor targetPeerDescriptor = 2;
      */
-    peerDescriptor?: PeerDescriptor;
+    targetPeerDescriptor?: PeerDescriptor;
 }
 /**
  * @generated from protobuf message dht.HandshakeResponse
  */
 export interface HandshakeResponse {
     /**
-     * @generated from protobuf field: bytes sourceId = 1;
+     * @generated from protobuf field: dht.PeerDescriptor sourcePeerDescriptor = 1;
      */
-    sourceId: Uint8Array;
+    sourcePeerDescriptor?: PeerDescriptor;
     /**
-     * @generated from protobuf field: dht.PeerDescriptor peerDescriptor = 2;
+     * @generated from protobuf field: optional dht.HandshakeError error = 2;
      */
-    peerDescriptor?: PeerDescriptor;
-    /**
-     * @generated from protobuf field: optional string responseError = 3;
-     */
-    responseError?: string;
+    error?: HandshakeError;
 }
 /**
  * @generated from protobuf message dht.Message
@@ -619,6 +615,19 @@ export enum RpcResponseError {
      */
     UNKNOWN_RPC_METHOD = 3
 }
+/**
+ * @generated from protobuf enum dht.HandshakeError
+ */
+export enum HandshakeError {
+    /**
+     * @generated from protobuf enum value: DUPLICATE_CONNECTION = 0;
+     */
+    DUPLICATE_CONNECTION = 0,
+    /**
+     * @generated from protobuf enum value: INVALID_TARGET_PEER_DESCRIPTOR = 1;
+     */
+    INVALID_TARGET_PEER_DESCRIPTOR = 1
+}
 // Wraps all messages
 
 /**
@@ -966,8 +975,8 @@ export const ConnectivityResponse = new ConnectivityResponse$Type();
 class HandshakeRequest$Type extends MessageType$<HandshakeRequest> {
     constructor() {
         super("dht.HandshakeRequest", [
-            { no: 1, name: "sourceId", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
-            { no: 2, name: "peerDescriptor", kind: "message", T: () => PeerDescriptor }
+            { no: 1, name: "sourcePeerDescriptor", kind: "message", T: () => PeerDescriptor },
+            { no: 2, name: "targetPeerDescriptor", kind: "message", T: () => PeerDescriptor }
         ]);
     }
 }
@@ -979,9 +988,8 @@ export const HandshakeRequest = new HandshakeRequest$Type();
 class HandshakeResponse$Type extends MessageType$<HandshakeResponse> {
     constructor() {
         super("dht.HandshakeResponse", [
-            { no: 1, name: "sourceId", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
-            { no: 2, name: "peerDescriptor", kind: "message", T: () => PeerDescriptor },
-            { no: 3, name: "responseError", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+            { no: 1, name: "sourcePeerDescriptor", kind: "message", T: () => PeerDescriptor },
+            { no: 2, name: "error", kind: "enum", opt: true, T: () => ["dht.HandshakeError", HandshakeError] }
         ]);
     }
 }

package/test/benchmark/Find.test.ts

@@ -6,7 +6,7 @@ import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
 import fs from 'fs'
 import { PeerID } from '../../src/helpers/PeerID'
-import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Logger, wait } from '@streamr/utils'
 import { debugVars } from '../../src/helpers/debugHelpers'
 
@@ -70,7 +70,7 @@ describe('Find correctness', () => {
         debugVars['waiting'] = false
         logger.info('waiting over')
 
-        nodes.forEach((node) => logger.info(keyFromPeerDescriptor(node.getLocalPeerDescriptor()) + ': connections:' +
+        nodes.forEach((node) => logger.info(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + ': connections:' +
             node.getNumberOfConnections() + ', kbucket: ' + node.getBucketSize()
             + ', localLocked: ' + node.getNumberOfLocalLockedConnections()
             + ', remoteLocked: ' + node.getNumberOfRemoteLockedConnections()

package/test/benchmark/KademliaCorrectness.test.ts

@@ -2,7 +2,7 @@
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { PeerID } from '../../src/helpers/PeerID'
-import { keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { execSync } from 'child_process'
@@ -88,7 +88,7 @@ describe('Kademlia correctness', () => {
                     correctNeighbors++
                 }
             } catch (e) {
-                console.error('Node ' + keyFromPeerDescriptor(nodes[i].getLocalPeerDescriptor()) + ' had only ' 
+                console.error('Node ' + getNodeIdFromPeerDescriptor(nodes[i].getLocalPeerDescriptor()) + ' had only ' 
                     + kademliaNeighbors.length + ' kademlia neighbors')
             }
             if (correctNeighbors === 0) {

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

@@ -1,7 +1,8 @@
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { waitForEvent3 } from '@streamr/utils'
-import { ConnectionManager, Events as ConnectionManagerEvents } from '../../src/connection/ConnectionManager'
+import { ConnectionManager } from '../../src/connection/ConnectionManager'
+import { TransportEvents } from '../../src/transport/ITransport'
 
 describe('Layer0MixedConnectionTypes', () => {
 
@@ -74,8 +75,8 @@ describe('Layer0MixedConnectionTypes', () => {
     it('2 non-server peers join first', async () => {
 
         const promise = Promise.all([
-            waitForEvent3<ConnectionManagerEvents>((node3.getTransport() as ConnectionManager), 'newConnection'),
-            waitForEvent3<ConnectionManagerEvents>((node4.getTransport() as ConnectionManager), 'newConnection'),
+            waitForEvent3<TransportEvents>((node3.getTransport() as ConnectionManager), 'connected'),
+            waitForEvent3<TransportEvents>((node4.getTransport() as ConnectionManager), 'connected'),
         ])
 
         node3.joinDht([epPeerDescriptor])

package/test/integration/ConnectionLocking.test.ts

@@ -1,11 +1,12 @@
 import { MetricsContext, waitForCondition } from '@streamr/utils'
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
-import { Simulator } from '../../src/connection/simulator/Simulator'
+import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import { ITransport } from '../../src/exports'
 import { PeerID } from '../../src/helpers/PeerID'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { getRandomRegion } from '../../dist/src/connection/simulator/pings'
 
 const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
     return new ConnectionManager({
@@ -21,11 +22,13 @@ describe('Connection Locking', () => {
 
     const mockPeerDescriptor1: PeerDescriptor = {
         kademliaId: PeerID.fromString('mock1').value,
-        type: NodeType.NODEJS
+        type: NodeType.NODEJS,
+        region: getRandomRegion()
     }
     const mockPeerDescriptor2: PeerDescriptor = {
         kademliaId: PeerID.fromString('mock2').value,
-        type: NodeType.NODEJS
+        type: NodeType.NODEJS,
+        region: getRandomRegion()
     }
 
     let mockConnectorTransport1: ConnectionManager
@@ -37,7 +40,7 @@ describe('Connection Locking', () => {
     let simulator: Simulator
 
     beforeEach(async () => {
-        simulator = new Simulator()
+        simulator = new Simulator(LatencyType.REAL)
         mockConnectorTransport1 = new SimulatorTransport(mockPeerDescriptor1, simulator)
         await mockConnectorTransport1.start()
         mockConnectorTransport2 = new SimulatorTransport(mockPeerDescriptor2, simulator)

package/test/integration/ConnectionManager.test.ts

@@ -4,9 +4,12 @@ import { PeerID } from '../../src/helpers/PeerID'
 import { Simulator } from '../../src/connection/simulator/Simulator'
 import { createPeerDescriptor } from '../../src/dht/DhtNode'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { Logger, MetricsContext } from '@streamr/utils'
+import { Logger, MetricsContext, waitForEvent3 } from '@streamr/utils'
 import { SimulatorTransport } from '../../src/exports'
 import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
+import { MarkOptional } from 'ts-essentials'
+import { createRandomKademliaId } from '../../src/helpers/kademliaId'
+import { TransportEvents } from '../../src/transport/ITransport'
 
 const logger = new Logger(module)
 
@@ -39,7 +42,7 @@ describe('ConnectionManager', () => {
 
     let createLocalPeerDescriptor: jest.Mock<PeerDescriptor, [ConnectivityResponse]>
 
-    const createConnectionManager = (opts: Omit<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
+    const createConnectionManager = (opts: MarkOptional<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
         return new ConnectionManager({
             createConnectorFacade: () => new DefaultConnectorFacade({
                 createLocalPeerDescriptor,
@@ -183,7 +186,7 @@ describe('ConnectionManager', () => {
         const connectionManager1 = createConnectionManager({ 
             transport: mockConnectorTransport1,
             websocketHost: '127.0.0.1',
-            websocketPortRange: { min: 9997, max: 9997 }
+            websocketPortRange: { min: 9997, max: 9997 },
         })
 
         await connectionManager1.start()
@@ -332,13 +335,78 @@ describe('ConnectionManager', () => {
         await connectionManager1.stop()
     })
 
+    it('Cannot send to a WebSocketServer if kademliaIds do not match', async () => {
+
+        const peerDescriptor1 = {
+            kademliaId: createRandomKademliaId(),
+            type: NodeType.NODEJS,
+            websocket: {
+                host: '127.0.0.1',
+                port: 10002,
+                tls: false
+            }
+        }
+
+        const peerDescriptor2 = {
+            kademliaId: createRandomKademliaId(),
+            type: NodeType.NODEJS,
+            websocket: {
+                host: '127.0.0.1',
+                port: 10003,
+                tls: false
+            }
+        }
+        const connectionManager1 = createConnectionManager({
+            transport: mockTransport,
+            websocketHost: '127.0.0.1',
+            websocketPortRange: { min: 10002, max: 10002 },
+            createLocalPeerDescriptor: () => peerDescriptor1 
+        })
+
+        await connectionManager1.start()
+
+        const connectionManager2 = createConnectionManager({
+            transport: mockTransport,
+            websocketHost: '127.0.0.1',
+            websocketPortRange: { min: 10003, max: 10003 },
+            createLocalPeerDescriptor: () => peerDescriptor2
+        })
+
+        await connectionManager2.start()
+
+        const msg: Message = {
+            serviceId,
+            messageType: MessageType.RPC,
+            messageId: '1',
+            targetDescriptor: {
+                // This is not the correct kademliaId of peerDescriptor2
+                kademliaId: new Uint8Array([1, 2, 3, 4]),
+                type: NodeType.NODEJS,
+                websocket: peerDescriptor2.websocket
+            },
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            } 
+        }
+        await Promise.all([
+            waitForEvent3<TransportEvents>(connectionManager1, 'disconnected'),
+            expect(connectionManager1.send(msg))      
+                .rejects
+                .toThrow()
+        ])
+        
+        await connectionManager1.stop()
+        await connectionManager2.stop()
+    }, 10000)
+
     it('Failed autocertification', async () => {
         const connectionManager1 = createConnectionManager({
             transport: mockTransport,
             websocketHost: '127.0.0.1',
             autoCertifierUrl: 'https://localhost:12333',
             websocketServerEnableTls: true,
-            websocketPortRange: { min: 10003, max: 10003 }
+            websocketPortRange: { min: 10004, max: 10004 }
         })
 
         await connectionManager1.start()

package/test/integration/Find.test.ts

@@ -1,6 +1,6 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
 import { PeerID } from '../../src/helpers/PeerID'
 import { peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
@@ -10,7 +10,7 @@ describe('Find correctness', () => {
     let entryPoint: DhtNode
     let nodes: DhtNode[]
     let entrypointDescriptor: PeerDescriptor
-    const simulator = new Simulator(LatencyType.RANDOM)
+    const simulator = new Simulator(LatencyType.REAL)
     const NUM_NODES = 100
     const K = 2
 
@@ -19,10 +19,7 @@ describe('Find correctness', () => {
         const entryPointId = '0'
         entryPoint = await createMockConnectionDhtNode(entryPointId, simulator, undefined, K)
         nodes.push(entryPoint)
-        entrypointDescriptor = {
-            kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS
-        }
+        entrypointDescriptor = entryPoint.getLocalPeerDescriptor()
         for (let i = 1; i < NUM_NODES; i++) {
             const nodeId = `${i}`
             const node = await createMockConnectionDhtNode(nodeId, simulator, undefined, K, 20, 60000)

package/test/integration/MigrateData.test.ts

@@ -7,7 +7,7 @@ import { execSync } from 'child_process'
 import fs from 'fs'
 import { Logger } from '@streamr/utils'
 import { PeerID } from '../../src/helpers/PeerID'
-import { keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
 import { Contact } from '../../src/dht/contact/Contact'
@@ -91,7 +91,7 @@ describe('Migrating data from node to node in DHT', () => {
 
         logger.info('Nodes sorted according to distance to data are: ')
         closest.forEach((contact) => {
-            logger.info(keyFromPeerDescriptor(contact.getPeerDescriptor()))
+            logger.info(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
         })
 
         logger.info('node 0 joining to the DHT')
@@ -115,7 +115,7 @@ describe('Migrating data from node to node in DHT', () => {
             }
 
             // eslint-disable-next-line max-len
-            logger.info(keyFromPeerDescriptor(contact.getPeerDescriptor()) + ' ' + keyFromPeerDescriptor(node.getLocalPeerDescriptor()) + hasDataMarker)
+            logger.info(peerIdFromPeerDescriptor(contact.getPeerDescriptor()) + ' ' + getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + hasDataMarker)
         })
 
         logger.info(NUM_NODES + ' nodes joining layer0 DHT')
@@ -143,7 +143,7 @@ describe('Migrating data from node to node in DHT', () => {
                 hasDataMarker = '<-'
             }
 
-            logger.info(keyFromPeerDescriptor(node.getLocalPeerDescriptor()) + hasDataMarker)
+            logger.info(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + hasDataMarker)
         })
 
         const closestNode = nodesById.get(PeerID.fromValue(closest[0].getPeerDescriptor().kademliaId).toKey())!

package/test/integration/MultipleEntryPointJoining.test.ts

@@ -14,7 +14,7 @@ describe('multiple entry point joining', () => {
         let entryPoints: PeerDescriptor[]
         
         beforeEach(async () => {
-            simulator = new Simulator(LatencyType.RANDOM)
+            simulator = new Simulator(LatencyType.REAL)
 
             node1 = await createMockConnectionDhtNode('node1', simulator)
             node2 = await createMockConnectionDhtNode('node2', simulator)
@@ -67,7 +67,7 @@ describe('multiple entry point joining', () => {
         let entryPoints: PeerDescriptor[]
         
         beforeEach(async () => {
-            simulator = new Simulator(LatencyType.RANDOM)
+            simulator = new Simulator(LatencyType.REAL)
             
             entryPoint1 = await createMockConnectionDhtNode('entryPoint1', simulator)
             entryPoint2 = await createMockConnectionDhtNode('entryPoint2', simulator)

package/test/integration/ScaleDownDht.test.ts

@@ -2,7 +2,7 @@ import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator
 import { DhtNode } from '../../src/dht/DhtNode'
 import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode } from '../utils/utils'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 
 const logger = new Logger(module)
@@ -11,7 +11,7 @@ describe('Scaling down a Dht network', () => {
     let entryPoint: DhtNode
     let nodes: DhtNode[]
     let entrypointDescriptor: PeerDescriptor
-    const simulator = new Simulator(LatencyType.RANDOM)
+    const simulator = new Simulator(LatencyType.REAL)
     const NUM_NODES = 80
     const MAX_CONNECTIONS = 15
     const K = 2
@@ -54,8 +54,8 @@ describe('Scaling down a Dht network', () => {
             const nodeIsCleaned = nodes.every((node) =>
                 node.getAllConnectionPeerDescriptors().every((peer) => {
                     if (areEqualPeerDescriptors(peer, stoppingPeerDescriptor)) {
-                        logger.error(keyFromPeerDescriptor(node.getLocalPeerDescriptor()) + ', ' 
-                            + keyFromPeerDescriptor(stoppingPeerDescriptor) + ' cleaning up failed')
+                        logger.error(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + ', ' 
+                            + getNodeIdFromPeerDescriptor(stoppingPeerDescriptor) + ' cleaning up failed')
                     }
                     return !areEqualPeerDescriptors(peer, stoppingPeerDescriptor)
                 })

package/test/integration/Store.test.ts

@@ -1,6 +1,6 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
-import { NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
 import { PeerID } from '../../src/helpers/PeerID'
 import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
@@ -10,7 +10,7 @@ describe('Storing data in DHT', () => {
     let entryPoint: DhtNode
     let nodes: DhtNode[]
     let entrypointDescriptor: PeerDescriptor
-    const simulator = new Simulator(LatencyType.RANDOM)
+    const simulator = new Simulator(LatencyType.REAL)
     const NUM_NODES = 100
     const MAX_CONNECTIONS = 20
     const K = 4
@@ -27,10 +27,7 @@ describe('Storing data in DHT', () => {
             undefined, K, MAX_CONNECTIONS)
         nodes.push(entryPoint)
         nodeIndicesById[entryPoint.getNodeId().toKey()] = 0
-        entrypointDescriptor = {
-            kademliaId: entryPoint.getNodeId().value,
-            type: NodeType.NODEJS
-        }
+        entrypointDescriptor = entryPoint.getLocalPeerDescriptor()
         nodes.push(entryPoint)
         for (let i = 1; i < NUM_NODES; i++) {
             const nodeId = `${i}`