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

package/test/integration/StoreRpcRemote.test.ts

@@ -8,14 +8,14 @@ import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { StoreRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import { StoreRpcRemote } from '../../src/dht/store/StoreRpcRemote'
 import { createMockDataEntry } from '../utils/mock/mockDataEntry'
-import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
+import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
+import { createRandomDhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../src/identifiers'
 
 describe('StoreRpcRemote', () => {
 
     let rpcRemote: StoreRpcRemote
-    let clientRpcCommunicator: RpcCommunicator
-    let serverRpcCommunicator: RpcCommunicator
+    let clientRpcCommunicator: RpcCommunicator<DhtCallContext>
+    let serverRpcCommunicator: RpcCommunicator<DhtCallContext>
     const clientPeerDescriptor = createMockPeerDescriptor()
     const serverPeerDescriptor = createMockPeerDescriptor()
     const data = createMockDataEntry()

package/test/integration/WebrtcConnectionManagement.test.ts

@@ -9,6 +9,7 @@ import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTran
 import { DefaultConnectorFacade } from '../../src/connection/ConnectorFacade'
 import { MetricsContext } from '@streamr/utils'
 import { createMockPeerDescriptor } from '../utils/utils'
+import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport: ITransport) => {
     return new ConnectionManager({
@@ -68,8 +69,8 @@ describe('WebRTC Connection Management', () => {
 
         manager2.on('message', (message: Message) => {
             expect(message.messageId).toEqual('mockerer')
-            expect(manager1.getConnection(peerDescriptor2)!.connectionType).toEqual(ConnectionType.WEBRTC)
-            expect(manager2.getConnection(peerDescriptor1)!.connectionType).toEqual(ConnectionType.WEBRTC)
+            expect(manager1.getConnection(getNodeIdFromPeerDescriptor(peerDescriptor2))!.connectionType).toEqual(ConnectionType.WEBRTC)
+            expect(manager2.getConnection(getNodeIdFromPeerDescriptor(peerDescriptor1))!.connectionType).toEqual(ConnectionType.WEBRTC)
 
             done()
         })
@@ -91,8 +92,8 @@ describe('WebRTC Connection Management', () => {
         }
         manager1.on('message', (message: Message) => {
             expect(message.messageId).toEqual('mockerer')
-            expect(manager1.getConnection(peerDescriptor2)!.connectionType).toEqual(ConnectionType.WEBRTC)
-            expect(manager2.getConnection(peerDescriptor1)!.connectionType).toEqual(ConnectionType.WEBRTC)
+            expect(manager1.getConnection(getNodeIdFromPeerDescriptor(peerDescriptor2))!.connectionType).toEqual(ConnectionType.WEBRTC)
+            expect(manager2.getConnection(getNodeIdFromPeerDescriptor(peerDescriptor1))!.connectionType).toEqual(ConnectionType.WEBRTC)
 
             done()
         })
@@ -226,6 +227,6 @@ describe('WebRTC Connection Management', () => {
             manager1.send(msg),
             disconnectedPromise1
         ])
-        expect(manager1.getConnection(msg.targetDescriptor!)).toBeUndefined()
+        expect(manager1.getConnection(getNodeIdFromPeerDescriptor(msg.targetDescriptor))).toBeUndefined()
     }, 20000)
 })

package/test/integration/WebrtcConnectorRpc.test.ts

@@ -11,11 +11,12 @@ import { createMockPeerDescriptor } from '../utils/utils'
 import { IWebrtcConnectorRpc } from '../../src/proto/packages/dht/protos/DhtRpc.server'
 import { waitForCondition } from '@streamr/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
+import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 
 describe('WebRTC rpc messages', () => {
 
-    let rpcCommunicator1: RpcCommunicator
-    let rpcCommunicator2: RpcCommunicator
+    let rpcCommunicator1: RpcCommunicator<DhtCallContext>
+    let rpcCommunicator2: RpcCommunicator<DhtCallContext>
     let client: ProtoRpcClient<WebrtcConnectorRpcClient>
     let requestConnectionCounter: number
     let rtcOfferCounter: number

package/test/integration/WebsocketConnectionManagement.test.ts

@@ -5,12 +5,12 @@ import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../../src/connection/ConnectorFacade'
 import { ConnectionType } from '../../src/connection/IConnection'
 import { Simulator } from '../../src/connection/simulator/Simulator'
-import { SimulatorTransport } from '../../src/exports'
-import { PeerID } from '../../src/helpers/PeerID'
+import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 import * as Err from '../../src/helpers/errors'
 import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { TransportEvents } from '../../src/transport/ITransport'
+import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 const SERVICE_ID = 'test'
 
@@ -31,7 +31,7 @@ describe('Websocket Connection Management', () => {
     let biggerNoWsServerManager: ConnectionManager
     const simulator = new Simulator()
     const wsServerConnectorPeerDescriptor: PeerDescriptor = {
-        nodeId: PeerID.fromString('2').value,
+        nodeId: new Uint8Array([2]),
         type: NodeType.NODEJS,
         websocket: {
             host: '127.0.0.1',
@@ -40,11 +40,11 @@ describe('Websocket Connection Management', () => {
         }
     }
     const noWsServerConnectorPeerDescriptor: PeerDescriptor = {
-        nodeId: PeerID.fromString('1').value,
+        nodeId: new Uint8Array([1]),
         type: NodeType.NODEJS,
     }
     const biggerNoWsServerConnectorPeerDescriptor: PeerDescriptor = {
-        nodeId: PeerID.fromString('3').value,
+        nodeId: new Uint8Array([3]),
         type: NodeType.NODEJS,
     }
 
@@ -91,7 +91,7 @@ describe('Websocket Connection Management', () => {
         await connectorTransport3.stop()
     })
 
-    it('Can open connections to serverless peer with smaller peerId', (done) => {
+    it('Can open connections to serverless peer with smaller nodeId', (done) => {
         const dummyMessage: Message = {
             serviceId: SERVICE_ID,
             body: {
@@ -104,8 +104,12 @@ describe('Websocket Connection Management', () => {
         }
         noWsServerManager.on('message', (message: Message) => {
             expect(message.messageId).toEqual('mockerer')
-            expect(wsServerManager.getConnection(noWsServerConnectorPeerDescriptor)!.connectionType).toEqual(ConnectionType.WEBSOCKET_SERVER)
-            expect(noWsServerManager.getConnection(wsServerConnectorPeerDescriptor)!.connectionType).toEqual(ConnectionType.WEBSOCKET_CLIENT)
+            expect(wsServerManager.getConnection(getNodeIdFromPeerDescriptor(noWsServerConnectorPeerDescriptor))!.connectionType).toEqual(
+                ConnectionType.WEBSOCKET_SERVER
+            )
+            expect(noWsServerManager.getConnection(getNodeIdFromPeerDescriptor(wsServerConnectorPeerDescriptor))!.connectionType).toEqual(
+                ConnectionType.WEBSOCKET_CLIENT
+            )
 
             done()
         })
@@ -113,7 +117,7 @@ describe('Websocket Connection Management', () => {
         wsServerManager.send(dummyMessage)
     })
 
-    it('Can open connections to serverless peer with bigger peerId', (done) => {
+    it('Can open connections to serverless peer with bigger nodeId', (done) => {
         const dummyMessage: Message = {
             serviceId: SERVICE_ID,
             body: {
@@ -126,8 +130,12 @@ describe('Websocket Connection Management', () => {
         }
         biggerNoWsServerManager.on('message', (message: Message) => {
             expect(message.messageId).toEqual('mockerer')
-            expect(wsServerManager.getConnection(biggerNoWsServerConnectorPeerDescriptor)!.connectionType).toEqual(ConnectionType.WEBSOCKET_SERVER)
-            expect(biggerNoWsServerManager.getConnection(wsServerConnectorPeerDescriptor)!.connectionType).toEqual(ConnectionType.WEBSOCKET_CLIENT)
+            expect(wsServerManager.getConnection(getNodeIdFromPeerDescriptor(biggerNoWsServerConnectorPeerDescriptor))!.connectionType).toEqual(
+                ConnectionType.WEBSOCKET_SERVER
+            )
+            expect(biggerNoWsServerManager.getConnection(getNodeIdFromPeerDescriptor(wsServerConnectorPeerDescriptor))!.connectionType).toEqual(
+                ConnectionType.WEBSOCKET_CLIENT
+            )
 
             done()
         })
@@ -154,7 +162,7 @@ describe('Websocket Connection Management', () => {
             waitForEvent3<TransportEvents>(wsServerManager, 'disconnected', 15000),
             wsServerManager.send(dummyMessage)
         ])
-        expect(wsServerManager.getConnection(dummyMessage.targetDescriptor!)).toBeUndefined()
+        expect(wsServerManager.getConnection(getNodeIdFromPeerDescriptor(dummyMessage.targetDescriptor!))).toBeUndefined()
     }, 20000)
     
     it('Can open connections to peer with server', async () => {
@@ -171,12 +179,16 @@ describe('Websocket Connection Management', () => {
         await noWsServerManager.send(dummyMessage)
         await waitForCondition(
             () => {
-                return (!!wsServerManager.getConnection(noWsServerConnectorPeerDescriptor)
-                    && wsServerManager.getConnection(noWsServerConnectorPeerDescriptor)!.connectionType === ConnectionType.WEBSOCKET_SERVER)
+                const nodeId = getNodeIdFromPeerDescriptor(noWsServerConnectorPeerDescriptor)
+                return (!!wsServerManager.getConnection(nodeId)
+                    && wsServerManager.getConnection(nodeId)!.connectionType === ConnectionType.WEBSOCKET_SERVER)
             }
         )
         await waitForCondition(
-            () => noWsServerManager.getConnection(wsServerConnectorPeerDescriptor)!.connectionType === ConnectionType.WEBSOCKET_CLIENT
+            () => {
+                const connection = noWsServerManager.getConnection(getNodeIdFromPeerDescriptor(wsServerConnectorPeerDescriptor))!
+                return connection.connectionType === ConnectionType.WEBSOCKET_CLIENT
+            }
         )
     })
 

package/test/integration/WebsocketConnectorRpc.test.ts

@@ -7,11 +7,12 @@ import {
 import { mockWebsocketConnectorRpc } from '../utils/utils'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
 import { Empty } from '../../src/proto/google/protobuf/empty'
+import { DhtCallContext } from '../../src/rpc-protocol/DhtCallContext'
 
 describe('WebsocketConnectorRpc', () => {
 
-    let rpcCommunicator1: RpcCommunicator
-    let rpcCommunicator2: RpcCommunicator
+    let rpcCommunicator1: RpcCommunicator<DhtCallContext>
+    let rpcCommunicator2: RpcCommunicator<DhtCallContext>
     let client1: ProtoRpcClient<WebsocketConnectorRpcClient>
     let client2: ProtoRpcClient<WebsocketConnectorRpcClient>
     const peerDescriptor1 = createMockPeerDescriptor()

package/test/integration/{RpcErrors.test.ts → rpc-connections-over-webrpc.test.ts}

@@ -24,7 +24,7 @@ const createConnectionManager = (localPeerDescriptor: PeerDescriptor, transport:
     })
 }
 
-describe('RPC errors', () => {
+describe('RPC connections over WebRTC', () => {
 
     let manager1: ConnectionManager
     let manager2: ConnectionManager
@@ -58,10 +58,10 @@ describe('RPC errors', () => {
     })
 
     afterEach(async () => {
-        await connectorTransport1.stop()
-        await connectorTransport2.stop()
         await manager1.stop()
         await manager2.stop()
+        await connectorTransport1.stop()
+        await connectorTransport2.stop()
         simulator.stop()
     })
 
@@ -104,6 +104,9 @@ describe('RPC errors', () => {
     }, 60000)
 
     /*
+    
+    TODO enable these tests (NET-1177)
+
     it.only('Throws a client-side exception if WebRTC connection fails', async () => {
 
         const request: PingRequest = {

package/test/unit/DuplicateDetector.test.ts

@@ -7,7 +7,7 @@ describe('Duplicate Detector', () => {
     let detector: DuplicateDetector
 
     beforeEach(async () => {
-        detector = new DuplicateDetector(MAX_VALUE_COUNT, 100)
+        detector = new DuplicateDetector(MAX_VALUE_COUNT)
     })
 
     it('detects duplicates', async () => {
@@ -16,7 +16,7 @@ describe('Duplicate Detector', () => {
         expect(detector.isMostLikelyDuplicate('test')).toEqual(true)
     })
 
-    it('resets on resetLimit', () => {
+    it('removes from tail when full', () => {
         for (let i = 0; i < MAX_VALUE_COUNT; i++) {
             detector.add(`test${i}`)
         }

package/test/unit/LocalDataStore.test.ts

@@ -1,11 +1,8 @@
 import { wait } from '@streamr/utils'
 import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
-import {
-    getNodeIdFromPeerDescriptor,
-} from '../../src/helpers/peerIdFromPeerDescriptor'
 import { createMockPeerDescriptor } from '../utils/utils'
 import { createMockDataEntry } from '../utils/mock/mockDataEntry'
-import { createRandomDhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
+import { createRandomDhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 
 describe('LocalDataStore', () => {
 

package/test/unit/RandomContactList.test.ts

@@ -1,11 +1,9 @@
 import { RandomContactList } from '../../src/dht/contact/RandomContactList'
-import { PeerID } from '../../src/helpers/PeerID'
 import { DhtAddress, DhtAddressRaw, getDhtAddressFromRaw } from '../../src/identifiers'
 
-const createItem = (nodeId: DhtAddressRaw): { getNodeId: () => DhtAddress, getPeerId: () => PeerID } => {
+const createItem = (nodeId: DhtAddressRaw): { getNodeId: () => DhtAddress } => {
     return { 
-        getNodeId: () => getDhtAddressFromRaw(nodeId),
-        getPeerId: () => PeerID.fromValue(nodeId)
+        getNodeId: () => getDhtAddressFromRaw(nodeId)
     }
 }
 

package/test/unit/RecursiveOperationManager.test.ts

@@ -6,7 +6,6 @@ import {
     RouteMessageError,
     RouteMessageWrapper
 } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { PeerID } from '../../src/helpers/PeerID'
 import {
     createWrappedClosestPeersRequest,
     createFindRequest,
@@ -17,11 +16,10 @@ import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
 import { v4 } from 'uuid'
 import { MockRouter } from '../utils/mock/Router'
 import { MockTransport } from '../utils/mock/Transport'
-import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
 import { Router } from '../../src/dht/routing/Router'
-import { ITransport } from '../../src/exports'
-import { getDhtAddressFromRaw } from '../../src/identifiers'
+import { ITransport } from '../../src/transport/ITransport'
+import { areEqualPeerDescriptors, createRandomDhtAddress } from '../../src/identifiers'
 
 const createMockRouter = (error?: RouteMessageError): Partial<Router> => {
     return {
@@ -57,7 +55,8 @@ describe('RecursiveOperationManager', () => {
         routingPath: [],
         reachableThrough: [],
         sourcePeer: peerDescriptor1,
-        target: peerDescriptor2.nodeId
+        target: peerDescriptor2.nodeId,
+        parallelRootNodeIds: []
     }
     const rpcCommunicator = new FakeRpcCommunicator()
 
@@ -86,7 +85,7 @@ describe('RecursiveOperationManager', () => {
 
     it('startFind with mode Node returns self if no peers', async () => {
         const recursiveOperationManager = createRecursiveOperationManager()
-        const res = await recursiveOperationManager.execute(getDhtAddressFromRaw(PeerID.fromString('find').value), RecursiveOperation.FIND_NODE)
+        const res = await recursiveOperationManager.execute(createRandomDhtAddress(), RecursiveOperation.FIND_NODE)
         expect(areEqualPeerDescriptors(res.closestNodes[0], peerDescriptor1)).toEqual(true)
         recursiveOperationManager.stop()
     })

package/test/unit/RecursiveOperationSession.test.ts

@@ -2,7 +2,7 @@ import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { RecursiveOperationSession } from '../../src/dht/recursive-operation/RecursiveOperationSession'
 import { RecursiveOperationSessionRpcRemote } from '../../src/dht/recursive-operation/RecursiveOperationSessionRpcRemote'
-import { ServiceID } from '../../src/exports'
+import { ServiceID } from '../../src/types/ServiceID'
 import { createRandomDhtAddress } from '../../src/identifiers'
 import { Message, PeerDescriptor, RecursiveOperation } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RecursiveOperationSessionRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
@@ -16,10 +16,11 @@ describe('RecursiveOperationSession', () => {
     let localPeerDescriptor: PeerDescriptor
 
     const createRpcRemote = (serviceId: ServiceID) => {
-        const transport = environment.createTransport()
+        const mockPeerDescriptor = createMockPeerDescriptor()
+        const transport = environment.createTransport(mockPeerDescriptor)
         const send = (msg: Message) => transport.send(msg)
         return new RecursiveOperationSessionRpcRemote(
-            createMockPeerDescriptor(),
+            mockPeerDescriptor,
             localPeerDescriptor,
             new RoutingRpcCommunicator(serviceId, send),
             RecursiveOperationSessionRpcClient
@@ -34,7 +35,7 @@ describe('RecursiveOperationSession', () => {
     it('happy path', async () => {
         const doRouteRequest = jest.fn()
         const session = new RecursiveOperationSession({
-            transport: environment.createTransport(),
+            transport: environment.createTransport(localPeerDescriptor),
             targetId: createRandomDhtAddress(),
             localPeerDescriptor,
             waitedRoutingPathCompletions: 3,

package/test/unit/Router.test.ts

@@ -1,7 +1,6 @@
 import { v4 } from 'uuid'
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { Router } from '../../src/dht/routing/Router'
-import { PeerID } from '../../src/helpers/PeerID'
 import { 
     Message,
     MessageType,
@@ -12,7 +11,7 @@ import {
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockPeerDescriptor, createWrappedClosestPeersRequest } from '../utils/utils'
 import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
-import { DhtAddress } from '../../src/identifiers'
+import { DhtAddress, getNodeIdFromPeerDescriptor, createRandomDhtAddress } from '../../src/identifiers'
 import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 
 describe('Router', () => {
@@ -38,7 +37,8 @@ describe('Router', () => {
         routingPath: [],
         reachableThrough: [],
         target: peerDescriptor1.nodeId,
-        sourcePeer: peerDescriptor2
+        sourcePeer: peerDescriptor2,
+        parallelRootNodeIds: []
     }
     let connections: Map<DhtAddress, DhtNodeRpcRemote>
     const rpcCommunicator = new FakeRpcCommunicator()
@@ -68,31 +68,48 @@ describe('Router', () => {
             requestId: v4(),
             sourcePeer: peerDescriptor1,
             reachableThrough: [],
-            routingPath: []
+            routingPath: [],
+            parallelRootNodeIds: []
         }) as RouteMessageAck
         expect(ack.error).toEqual(RouteMessageError.NO_TARGETS)
     })
 
     it('doRouteMessage with connections', async () => {
-        connections.set(PeerID.fromString('test').toNodeId(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        connections.set(createRandomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
             message,
             target: peerDescriptor2.nodeId,
             requestId: v4(),
             sourcePeer: peerDescriptor1,
             reachableThrough: [],
-            routingPath: []
+            routingPath: [],
+            parallelRootNodeIds: []
         }) as RouteMessageAck
         expect(ack.error).toBeUndefined()
     })
 
+    it('doRouteMessage with parallelRootNodeIds', async () => {
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor2)
+        connections.set(nodeId, createMockDhtNodeRpcRemote(peerDescriptor2))
+        const ack = await rpcCommunicator.callRpcMethod('routeMessage', {
+            message,
+            target: peerDescriptor2.nodeId,
+            requestId: v4(),
+            sourcePeer: peerDescriptor1,
+            reachableThrough: [],
+            routingPath: [],
+            parallelRootNodeIds: [nodeId]
+        }) as RouteMessageAck
+        expect(ack.error).toEqual(RouteMessageError.NO_TARGETS)
+    })
+
     it('route server is destination without connections', async () => {
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
         expect(ack.error).toBeUndefined()
     })
 
     it('route server with connections', async () => {
-        connections.set(PeerID.fromString('test').toNodeId(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        connections.set(createRandomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('routeMessage', routedMessage) as RouteMessageAck
         expect(ack.error).toBeUndefined()
     })
@@ -109,7 +126,7 @@ describe('Router', () => {
     })
 
     it('forward server with connections', async () => {
-        connections.set(PeerID.fromString('test').toNodeId(), createMockDhtNodeRpcRemote(peerDescriptor2))
+        connections.set(createRandomDhtAddress(), createMockDhtNodeRpcRemote(peerDescriptor2))
         const ack = await rpcCommunicator.callRpcMethod('forwardMessage', routedMessage) as RouteMessageAck
         expect(ack.error).toBeUndefined()
     })

package/test/unit/RoutingSession.test.ts

@@ -4,8 +4,7 @@ import { Message, MessageType, PeerDescriptor, RouteMessageWrapper } from '../..
 import { createMockPeerDescriptor, createWrappedClosestPeersRequest } from '../utils/utils'
 import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { RoutingRpcCommunicator } from '../../src/transport/RoutingRpcCommunicator'
-import { getNodeIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
-import { DhtAddress } from '../../src/identifiers'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { MockRpcCommunicator } from '../utils/mock/MockRpcCommunicator'
 
 describe('RoutingSession', () => {
@@ -33,7 +32,8 @@ describe('RoutingSession', () => {
         routingPath: [],
         reachableThrough: [],
         target: mockPeerDescriptor1.nodeId,
-        sourcePeer: mockPeerDescriptor2
+        sourcePeer: mockPeerDescriptor2,
+        parallelRootNodeIds: []
     }
 
     const createMockDhtNodeRpcRemote = (destination: PeerDescriptor): DhtNodeRpcRemote => {

package/test/unit/SortedContactList.test.ts

@@ -1,11 +1,9 @@
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
-import { PeerID } from '../../src/helpers/PeerID'
 import { DhtAddress, DhtAddressRaw, createRandomDhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
 
-const createItem = (nodeId: DhtAddressRaw): { getNodeId: () => DhtAddress, getPeerId: () => PeerID } => {
+const createItem = (nodeId: DhtAddressRaw): { getNodeId: () => DhtAddress } => {
     return { 
-        getNodeId: () => getDhtAddressFromRaw(nodeId),
-        getPeerId: () => PeerID.fromValue(nodeId)
+        getNodeId: () => getDhtAddressFromRaw(nodeId)
     }
 }
 

package/test/unit/connectivityRequestHandler.test.ts

@@ -1,4 +1,4 @@
-import { waitForCondition } from '@streamr/utils'
+import { ipv4ToNumber, waitForCondition } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { once } from 'events'
 import { Server as HttpServer, createServer as createHttpServer } from 'http'
@@ -34,8 +34,9 @@ describe('connectivityRequestHandler', () => {
     it('happy path', async () => {
         const connection: any = new EventEmitter()
         connection.send = jest.fn()
-
-        attachConnectivityRequestHandler(connection as any)
+        connection.getRemoteIp = () => HOST
+        
+        attachConnectivityRequestHandler(connection)
         const request: Message = {
             serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
             messageType: MessageType.CONNECTIVITY_REQUEST,
@@ -60,6 +61,7 @@ describe('connectivityRequestHandler', () => {
                         port: PORT,
                         tls: false
                     },
+                    ipAddress: ipv4ToNumber(HOST)
                 },
                 oneofKind: 'connectivityResponse'
             },

package/test/unit/createPeerDescriptor.test.ts

@@ -0,0 +1,63 @@
+import { ipv4ToNumber } from '@streamr/utils'
+import { createPeerDescriptor } from '../../src/helpers/createPeerDescriptor'
+import { isBrowserEnvironment } from '../../src/helpers/browser/isBrowserEnvironment'
+import { NodeType } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { createRandomDhtAddress, getRawFromDhtAddress } from '../../src/identifiers'
+
+const IP_ADDRESS = '1.2.3.4'
+
+describe('createPeerDescriptor', () => {
+
+    it('without websocket', () => {
+        const connectivityResponse = {
+            ipAddress: ipv4ToNumber(IP_ADDRESS)
+        } as any
+        const peerDescriptor = createPeerDescriptor(connectivityResponse)
+        expect(peerDescriptor).toEqual({
+            nodeId: expect.any(Uint8Array),
+            type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
+            ipAddress: ipv4ToNumber(IP_ADDRESS),
+            publicKey: expect.any(Uint8Array),
+            signature: expect.any(Uint8Array)
+        })
+    })
+
+    it('with websocket', () => {
+        const connectivityResponse = {
+            ipAddress: ipv4ToNumber(IP_ADDRESS),
+            websocket: {
+                host: 'bar.com',
+                port: 123,
+                tls: true
+            }
+        } as any
+        const peerDescriptor = createPeerDescriptor(connectivityResponse)
+        expect(peerDescriptor).toEqual({
+            nodeId: expect.any(Uint8Array),
+            type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
+            ipAddress: ipv4ToNumber(IP_ADDRESS),
+            publicKey: expect.any(Uint8Array),
+            signature: expect.any(Uint8Array),
+            websocket: {
+                host: 'bar.com',
+                port: 123,
+                tls: true
+            }
+        })
+    })
+
+    it('explicit nodeId', () => {
+        const nodeId = createRandomDhtAddress()
+        const connectivityResponse = {
+            ipAddress: ipv4ToNumber(IP_ADDRESS)
+        } as any
+        const peerDescriptor = createPeerDescriptor(connectivityResponse, nodeId)
+        expect(peerDescriptor).toEqual({
+            nodeId: getRawFromDhtAddress(nodeId),
+            type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
+            ipAddress: ipv4ToNumber(IP_ADDRESS),
+            publicKey: expect.any(Uint8Array),
+            signature: expect.any(Uint8Array)
+        })
+    })
+})

package/test/utils/FakeTransport.ts

@@ -5,13 +5,16 @@ import { Message, PeerDescriptor } from '../../src/proto/packages/dht/protos/Dht
 class FakeTransport extends EventEmitter<TransportEvents> implements ITransport {
 
     private onSend: (msg: Message) => void
+    private readonly localPeerDescriptor: PeerDescriptor
 
-    constructor(onSend: (msg: Message) => void) {
+    constructor(peerDescriptor: PeerDescriptor, onSend: (msg: Message) => void) {
         super()
         this.onSend = onSend
+        this.localPeerDescriptor = peerDescriptor
     }
 
     async send(msg: Message): Promise<void> {
+        msg.sourceDescriptor = this.localPeerDescriptor
         this.onSend(msg)
     }
 
@@ -21,7 +24,7 @@ class FakeTransport extends EventEmitter<TransportEvents> implements ITransport
     }
 
     // eslint-disable-next-line class-methods-use-this
-    getAllConnectionPeerDescriptors(): PeerDescriptor[] {
+    getConnections(): PeerDescriptor[] {
         throw new Error('not implemented')
     }
 
@@ -34,8 +37,8 @@ export class FakeEnvironment {
 
     private transports: FakeTransport[] = []
 
-    createTransport(): ITransport {
-        const transport = new FakeTransport((msg) => {
+    createTransport(peerDescriptor: PeerDescriptor): ITransport {
+        const transport = new FakeTransport(peerDescriptor, (msg) => {
             this.transports.forEach((t) => t.emit('message', msg))
         })
         this.transports.push(transport)

package/test/utils/mock/Transport.ts

@@ -15,7 +15,7 @@ export class MockTransport extends EventEmitter<TransportEvents> implements ITra
     }
 
     // eslint-disable-next-line class-methods-use-this
-    getAllConnectionPeerDescriptors(): PeerDescriptor[] {
+    getConnections(): PeerDescriptor[] {
         return []
     }
 

package/test/utils/utils.ts

@@ -235,15 +235,15 @@ async function waitReadyForTesting(connectionManager: ConnectionManager, limit:
     connectionManager.garbageCollectConnections(limit, LAST_USED_LIMIT)
     try {
         await waitForCondition(() => {
-            return (connectionManager.getNumberOfLocalLockedConnections() === 0 &&
-                connectionManager.getNumberOfRemoteLockedConnections() === 0 &&
-                connectionManager.getAllConnectionPeerDescriptors().length <= limit)
+            return (connectionManager.getLocalLockedConnectionCount() === 0 &&
+                connectionManager.getRemoteLockedConnectionCount() === 0 &&
+                connectionManager.getConnections().length <= limit)
         }, 20000)
     } catch (err) {
-        if (connectionManager.getNumberOfLocalLockedConnections() > 0
-            && connectionManager.getNumberOfRemoteLockedConnections() > 0) {
+        if (connectionManager.getLocalLockedConnectionCount() > 0
+            && connectionManager.getRemoteLockedConnectionCount() > 0) {
             throw new Error('Connections are still locked')
-        } else if (connectionManager.getAllConnectionPeerDescriptors().length > limit) {
+        } else if (connectionManager.getConnections().length > limit) {
             throw new Error(`ConnectionManager has more than ${limit}`)
         }
     }