@streamr/dht 100.0.0-pretestnet.4 → 100.0.0-rc.0

package/test/integration/StoreOnDhtWithThreeNodes.test.ts

@@ -0,0 +1,59 @@
+import { createMockConnectionDhtNode } from '../utils/utils'
+import { DhtNode } from '../../src/dht/DhtNode'
+import { Simulator } from '../../src/connection/simulator/Simulator'
+import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
+
+describe('Storing data in DHT with two peers', () => {
+
+    let entryPoint: DhtNode
+    let node1: DhtNode
+    let node2: DhtNode
+    let simulator: Simulator | undefined
+
+    beforeEach(async () => {
+        simulator = new Simulator()
+        entryPoint = await createMockConnectionDhtNode(simulator)
+        node1 = await createMockConnectionDhtNode(simulator)
+        node2 = await createMockConnectionDhtNode(simulator)
+
+        await entryPoint.start()
+        await node1.start()
+        await node2.start()
+
+        await entryPoint.joinDht([entryPoint.getLocalPeerDescriptor()])
+        node1.joinDht([entryPoint.getLocalPeerDescriptor()]).catch(() => {})
+        node2.joinDht([entryPoint.getLocalPeerDescriptor()]).catch(() => {})
+        await Promise.all([
+            node1.waitForNetworkConnectivity(),
+            node2.waitForNetworkConnectivity()
+        ])
+    })
+
+    afterEach(async () => {
+        await entryPoint.stop()
+        await node1.stop()
+        await node2.stop()
+        simulator?.stop()
+    })
+
+    it('Node can store on three peer DHT', async () => {
+        const storedData1 = createMockDataEntry()
+        const storedData2 = createMockDataEntry()
+        // Here we effectively test that fetching "null" data doesn't take too long. A test timeout here indicates an issue. 
+        await node1.fetchDataFromDht(getDhtAddressFromRaw(storedData1.key))
+        await node2.fetchDataFromDht(getDhtAddressFromRaw(storedData1.key))
+        
+        await node1.storeDataToDht(getDhtAddressFromRaw(storedData1.key), storedData1.data!)
+        await node2.storeDataToDht(getDhtAddressFromRaw(storedData1.key), storedData1.data!)
+        await entryPoint.storeDataToDht(getDhtAddressFromRaw(storedData2.key), storedData2.data!)
+        const foundData1 = await node1.fetchDataFromDht(getDhtAddressFromRaw(storedData1.key))
+        const foundData2 = await node2.fetchDataFromDht(getDhtAddressFromRaw(storedData1.key))
+        const foundData3 = await entryPoint.fetchDataFromDht(getDhtAddressFromRaw(storedData2.key))
+        expectEqualData(foundData1[0], storedData1)
+        expectEqualData(foundData1[1], storedData1)
+        expectEqualData(foundData2[0], storedData1)
+        expectEqualData(foundData2[1], storedData1)
+        expectEqualData(foundData3[0], storedData2)
+    }, 30000)
+})

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -1,31 +1,20 @@
 import { createMockConnectionDhtNode } from '../utils/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { Simulator } from '../../src/connection/simulator/Simulator'
-import { PeerID } from '../../src/helpers/PeerID'
-import { Any } from '../../src/proto/google/protobuf/any'
-import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { waitForCondition } from '@streamr/utils'
+import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
+import { getDhtAddressFromRaw } from '../../src/identifiers'
 
 describe('Storing data in DHT with two peers', () => {
 
     let entryPoint: DhtNode
     let otherNode: DhtNode
-
     let simulator: Simulator | undefined
 
     beforeEach(async () => {
         simulator = new Simulator()
-        const entryPointId = 'node0'
-        const otherNodeId = 'other-node'
-        entryPoint = await createMockConnectionDhtNode(
-            entryPointId,
-            simulator,
-        )
-        otherNode = await createMockConnectionDhtNode(
-            otherNodeId,
-            simulator
-        )
+        entryPoint = await createMockConnectionDhtNode(simulator)
+        otherNode = await createMockConnectionDhtNode(simulator)
 
         await entryPoint.start()
         await otherNode.start()
@@ -41,31 +30,22 @@ describe('Storing data in DHT with two peers', () => {
     })
 
     it('Node can store on two peer DHT', async () => {
-        const dataKey1 = PeerID.fromString('node0-stored-data')
-        const data1 = Any.pack(otherNode.getLocalPeerDescriptor(), PeerDescriptor)
-        const dataKey2 = PeerID.fromString('other-node-stored-data')
-        const data2 = Any.pack(entryPoint.getLocalPeerDescriptor(), PeerDescriptor)
-
-        const successfulStorers1 = await otherNode.storeDataToDht(dataKey1.value, data1)
-        const successfulStorers2 = await entryPoint.storeDataToDht(dataKey2.value, data2)
-        expect(successfulStorers1[0].kademliaId).toStrictEqual(entryPoint.getLocalPeerDescriptor().kademliaId)
-        expect(successfulStorers2[0].kademliaId).toStrictEqual(otherNode.getLocalPeerDescriptor().kademliaId)
-
-        const foundData1 = await otherNode.getDataFromDht(dataKey1.value)
-        const foundData2 = await entryPoint.getDataFromDht(dataKey2.value)
-        expect(areEqualPeerDescriptors(otherNode.getLocalPeerDescriptor(), Any.unpack(foundData1[0]!.data!, PeerDescriptor))).toBeTrue()
-        expect(areEqualPeerDescriptors(entryPoint.getLocalPeerDescriptor(), Any.unpack(foundData2[0]!.data!, PeerDescriptor))).toBeTrue()
+        const storedData1 = createMockDataEntry()
+        const storedData2 = createMockDataEntry()
+        await otherNode.storeDataToDht(getDhtAddressFromRaw(storedData1.key), storedData1.data!)
+        await entryPoint.storeDataToDht(getDhtAddressFromRaw(storedData2.key), storedData2.data!)
+        const foundData1 = await otherNode.fetchDataFromDht(getDhtAddressFromRaw(storedData1.key))
+        const foundData2 = await entryPoint.fetchDataFromDht(getDhtAddressFromRaw(storedData2.key))
+        expectEqualData(foundData1[0], storedData1)
+        expectEqualData(foundData2[0], storedData2)
     })
 
     it('Can store on one peer DHT', async () => {
         await otherNode.stop()
-        await waitForCondition(() => entryPoint.getBucketSize() === 0)
-        const dataKey = PeerID.fromString('data-to-store')
-        const data = Any.pack(entryPoint.getLocalPeerDescriptor(), PeerDescriptor)
-        const successfulStorers = await entryPoint.storeDataToDht(dataKey.value, data)
-        expect(successfulStorers[0].kademliaId).toStrictEqual(entryPoint.getLocalPeerDescriptor().kademliaId)
-
-        const foundData = await entryPoint.getDataFromDht(dataKey.value)
-        expect(areEqualPeerDescriptors(entryPoint.getLocalPeerDescriptor(), Any.unpack(foundData[0]!.data!, PeerDescriptor))).toBeTrue()
+        await waitForCondition(() => entryPoint.getNeighborCount() === 0)
+        const storedData = createMockDataEntry()
+        await entryPoint.storeDataToDht(getDhtAddressFromRaw(storedData.key), storedData.data!)
+        const foundData = await entryPoint.fetchDataFromDht(getDhtAddressFromRaw(storedData.key))
+        expectEqualData(foundData[0], storedData)
     }, 60000)
 })

package/test/integration/StoreRpcRemote.test.ts

@@ -1,34 +1,28 @@
-import { RpcCommunicator, toProtoRpcClient } from '@streamr/proto-rpc'
+import { RpcCommunicator } from '@streamr/proto-rpc'
 import {
-    NodeType,
-    PeerDescriptor,
     StoreDataRequest,
     StoreDataResponse
 } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { generateId, mockStoreRpc } from '../utils/utils'
+import { createMockPeerDescriptor, mockStoreRpc } from '../utils/utils'
 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 { Any } from '../../src/proto/google/protobuf/any'
+import { createMockDataEntry } from '../utils/mock/mockDataEntry'
+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
-    const serviceId = 'test'
-    const clientPeerDescriptor: PeerDescriptor = {
-        kademliaId: generateId('client'),
-        type: NodeType.NODEJS
-    }
-    const serverPeerDescriptor: PeerDescriptor = {
-        kademliaId: generateId('server'),
-        type: NodeType.NODEJS
-    }
-    const data = Any.pack(clientPeerDescriptor, PeerDescriptor)
+    let clientRpcCommunicator: RpcCommunicator<DhtCallContext>
+    let serverRpcCommunicator: RpcCommunicator<DhtCallContext>
+    const clientPeerDescriptor = createMockPeerDescriptor()
+    const serverPeerDescriptor = createMockPeerDescriptor()
+    const data = createMockDataEntry()
     const request: StoreDataRequest = {
-        kademliaId: clientPeerDescriptor.kademliaId,
-        data,
+        key: data.key,
+        data: data.data,
+        creator: getRawFromDhtAddress(createRandomDhtAddress()),
         ttl: 10
     }
 
@@ -42,25 +36,19 @@ describe('StoreRpcRemote', () => {
         serverRpcCommunicator.on('outgoingMessage', (message: RpcMessage) => {
             clientRpcCommunicator.handleIncomingMessage(message)
         })
-        const client = toProtoRpcClient(new StoreRpcClient(clientRpcCommunicator.getRpcClientTransport()))
-        rpcRemote = new StoreRpcRemote(clientPeerDescriptor, serverPeerDescriptor, serviceId, client)
+        rpcRemote = new StoreRpcRemote(clientPeerDescriptor, serverPeerDescriptor, clientRpcCommunicator, StoreRpcClient)
     })
 
     it('storeData happy path', async () => {
-        const response = await rpcRemote.storeData(request)
-        expect(response.error).toBeEmpty()
+        await expect(rpcRemote.storeData(request)).toResolve()
     })
 
     it('storeData rejects', async () => {
         serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', mockStoreRpc.throwStoreDataError)
-        await expect(rpcRemote.storeData(request))
-            .rejects.toThrowError('Could not store data to 736572766572 from 636c69656e74 Error: Mock')
+        await expect(rpcRemote.storeData(request)).rejects.toThrowError(
+            'Could not store data to'
+            + ` ${getNodeIdFromPeerDescriptor(serverPeerDescriptor)} from ${getNodeIdFromPeerDescriptor(clientPeerDescriptor)}`
+            + ' Error: Mock'
+        )
     })
-
-    it('storeData response error', async () => {
-        serverRpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData', mockStoreRpc.storeDataErrorString)
-        const response = await rpcRemote.storeData(request)
-        expect(response.error).toEqual('Mock')
-    })
-
 })

package/test/integration/WebrtcConnectionManagement.test.ts

@@ -1,14 +1,15 @@
 import { ConnectionManager } from '../../src/connection/ConnectionManager'
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
-import { Message, MessageType, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
+import { Message, NodeType, PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { RpcMessage } from '../../src/proto/packages/proto-rpc/protos/ProtoRpc'
-import { PeerID } from '../../src/helpers/PeerID'
 import { ConnectionType } from '../../src/connection/IConnection'
 import { ITransport } from '../../src/transport/ITransport'
 import * as Err from '../../src/helpers/errors'
 import { SimulatorTransport } from '../../src/connection/simulator/SimulatorTransport'
 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({
@@ -24,19 +25,9 @@ describe('WebRTC Connection Management', () => {
 
     let manager1: ConnectionManager
     let manager2: ConnectionManager
-
     let simulator: Simulator
-
-    const peerDescriptor1: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peer1').value,
-        type: NodeType.NODEJS,
-    }
-
-    const peerDescriptor2: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peer2').value,
-        type: NodeType.NODEJS,
-    }
-
+    const peerDescriptor1 = createMockPeerDescriptor()
+    const peerDescriptor2 = createMockPeerDescriptor()
     let connectorTransport1: SimulatorTransport
     let connectorTransport2: SimulatorTransport
 
@@ -72,14 +63,13 @@ describe('WebRTC Connection Management', () => {
                 oneofKind: 'rpcMessage',
                 rpcMessage: RpcMessage.create()
             },
-            messageType: MessageType.RPC,
             messageId: 'mockerer'
         }
 
         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()
         })
@@ -96,13 +86,12 @@ describe('WebRTC Connection Management', () => {
                 oneofKind: 'rpcMessage',
                 rpcMessage: RpcMessage.create()
             }, 
-            messageType: MessageType.RPC,
             messageId: 'mockerer'
         }
         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()
         })
@@ -117,7 +106,6 @@ describe('WebRTC Connection Management', () => {
                 oneofKind: 'rpcMessage',
                 rpcMessage: RpcMessage.create()
             },
-            messageType: MessageType.RPC,
             messageId: 'mockerer'
         }
         dummyMessage.targetDescriptor = peerDescriptor1
@@ -129,7 +117,6 @@ describe('WebRTC Connection Management', () => {
     it('Connects and disconnects webrtc connections', async () => {
         const msg: Message = {
             serviceId,
-            messageType: MessageType.RPC,
             messageId: '1',
             body: {
                 oneofKind: 'rpcMessage',
@@ -139,14 +126,14 @@ describe('WebRTC Connection Management', () => {
 
         const dataPromise = new Promise<void>((resolve, _reject) => {
             manager2.on('message', async (message: Message) => {
-                expect(message.messageType).toBe(MessageType.RPC)
+                expect(message.body.oneofKind).toBe('rpcMessage')
                 resolve()
             })
         })
 
         const connectedPromise1 = new Promise<void>((resolve, _reject) => {
             manager1.on('connected', () => {
-                //expect(message.messageType).toBe(MessageType.RPC)
+                //expect(message.body.oneofKind).toBe('rpcMessage')
                 resolve()
             })
         })
@@ -184,7 +171,6 @@ describe('WebRTC Connection Management', () => {
     it('Disconnects webrtcconnection while being connected', async () => {
         const msg: Message = {
             serviceId,
-            messageType: MessageType.RPC,
             messageId: '1',
             body: {
                 oneofKind: 'rpcMessage',
@@ -209,4 +195,32 @@ describe('WebRTC Connection Management', () => {
         await disconnectedPromise1
 
     }, 20000)
+
+    it('failed connections are cleaned up', async () => {
+        const msg: Message = {
+            serviceId,
+            messageId: '1',
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            },
+        }
+
+        const disconnectedPromise1 = new Promise<void>((resolve, _reject) => {
+            manager1.on('disconnected', () => {
+                resolve()
+            })
+        })
+
+        msg.targetDescriptor = {
+            nodeId: new Uint8Array([0, 0, 0, 0, 0]),
+            type: NodeType.NODEJS,
+        }
+        
+        await Promise.allSettled([
+            manager1.send(msg),
+            disconnectedPromise1
+        ])
+        expect(manager1.getConnection(getNodeIdFromPeerDescriptor(msg.targetDescriptor))).toBeUndefined()
+    }, 20000)
 })

package/test/integration/WebrtcConnectorRpc.test.ts

@@ -2,32 +2,27 @@ import { ProtoRpcClient, RpcCommunicator, toProtoRpcClient } from '@streamr/prot
 import { WebrtcConnectorRpcClient } from '../../src/proto/packages/dht/protos/DhtRpc.client'
 import {
     IceCandidate,
-    NodeType,
-    PeerDescriptor,
     RtcAnswer,
     RtcOffer,
     WebrtcConnectionRequest
 } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { Empty } from '../../src/proto/google/protobuf/empty'
-import { generateId } from '../utils/utils'
+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 client: ProtoRpcClient<WebrtcConnectorRpcClient>
 
+    let rpcCommunicator1: RpcCommunicator<DhtCallContext>
+    let rpcCommunicator2: RpcCommunicator<DhtCallContext>
+    let client: ProtoRpcClient<WebrtcConnectorRpcClient>
     let requestConnectionCounter: number
     let rtcOfferCounter: number
     let rtcAnswerCounter: number
     let iceCandidateCounter: number
-
-    const targetDescriptor: PeerDescriptor = {
-        kademliaId: generateId('peer'),
-        type: NodeType.NODEJS
-    }
+    const targetDescriptor = createMockPeerDescriptor()
 
     beforeEach(() => {
         requestConnectionCounter = 0

package/test/integration/WebsocketConnectionManagement.test.ts

@@ -1,15 +1,18 @@
 /* eslint-disable promise/no-nesting */
 
-import { MetricsContext, waitForCondition } from '@streamr/utils'
+import { MetricsContext, waitForCondition, waitForEvent3 } from '@streamr/utils'
 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 { Message, 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'
 
 const createConfig = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultConnectorFacadeConfig, 'createLocalPeerDescriptor'>) => {
     return {
@@ -23,14 +26,12 @@ const createConfig = (localPeerDescriptor: PeerDescriptor, opts: Omit<DefaultCon
 
 describe('Websocket Connection Management', () => {
 
-    const serviceId = 'test'
     let wsServerManager: ConnectionManager
     let noWsServerManager: ConnectionManager
-
+    let biggerNoWsServerManager: ConnectionManager
     const simulator = new Simulator()
-
     const wsServerConnectorPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peerWithServer').value,
+        nodeId: new Uint8Array([2]),
         type: NodeType.NODEJS,
         websocket: {
             host: '127.0.0.1',
@@ -38,14 +39,18 @@ describe('Websocket Connection Management', () => {
             tls: false
         }
     }
-
     const noWsServerConnectorPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peerWithoutServer').value,
+        nodeId: new Uint8Array([1]),
+        type: NodeType.NODEJS,
+    }
+    const biggerNoWsServerConnectorPeerDescriptor: PeerDescriptor = {
+        nodeId: new Uint8Array([3]),
         type: NodeType.NODEJS,
     }
 
     let connectorTransport1: SimulatorTransport
     let connectorTransport2: SimulatorTransport
+    let connectorTransport3: SimulatorTransport
 
     beforeEach(async () => {
 
@@ -53,6 +58,8 @@ describe('Websocket Connection Management', () => {
         await connectorTransport1.start()
         connectorTransport2 = new SimulatorTransport(noWsServerConnectorPeerDescriptor, simulator)
         await connectorTransport2.start()
+        connectorTransport3 = new SimulatorTransport(biggerNoWsServerConnectorPeerDescriptor, simulator)
+        await connectorTransport3.start()
 
         const config1 = createConfig(wsServerConnectorPeerDescriptor, {
             transport: connectorTransport1,
@@ -62,36 +69,46 @@ describe('Websocket Connection Management', () => {
         const config2 = createConfig(noWsServerConnectorPeerDescriptor, {
             transport: connectorTransport2
         })
+        const config3 = createConfig(biggerNoWsServerConnectorPeerDescriptor, {
+            transport: connectorTransport3
+        })
 
         wsServerManager = new ConnectionManager(config1)
         noWsServerManager = new ConnectionManager(config2)
+        biggerNoWsServerManager = new ConnectionManager(config3)
 
         await wsServerManager.start()
         await noWsServerManager.start()
+        await biggerNoWsServerManager.start()
     })
 
     afterEach(async () => {
         await wsServerManager.stop()
         await noWsServerManager.stop()
+        await biggerNoWsServerManager.stop()
         await connectorTransport1.stop()
         await connectorTransport2.stop()
+        await connectorTransport3.stop()
     })
 
-    it('Can open connections to serverless peer', (done) => {
+    it('Can open connections to serverless peer with smaller nodeId', (done) => {
         const dummyMessage: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: RpcMessage.create()
             },
-            messageType: MessageType.RPC,
             messageId: 'mockerer',
             targetDescriptor: noWsServerConnectorPeerDescriptor
         }
         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()
         })
@@ -99,37 +116,85 @@ describe('Websocket Connection Management', () => {
         wsServerManager.send(dummyMessage)
     })
 
+    it('Can open connections to serverless peer with bigger nodeId', (done) => {
+        const dummyMessage: Message = {
+            serviceId: SERVICE_ID,
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            },
+            messageId: 'mockerer',
+            targetDescriptor: biggerNoWsServerConnectorPeerDescriptor
+        }
+        biggerNoWsServerManager.on('message', (message: Message) => {
+            expect(message.messageId).toEqual('mockerer')
+            expect(wsServerManager.getConnection(getNodeIdFromPeerDescriptor(biggerNoWsServerConnectorPeerDescriptor))!.connectionType).toEqual(
+                ConnectionType.WEBSOCKET_SERVER
+            )
+            expect(biggerNoWsServerManager.getConnection(getNodeIdFromPeerDescriptor(wsServerConnectorPeerDescriptor))!.connectionType).toEqual(
+                ConnectionType.WEBSOCKET_CLIENT
+            )
+
+            done()
+        })
+
+        wsServerManager.send(dummyMessage)
+    })
+
+    it('Failed connection requests are cleaned up', async () => {
+        const dummyMessage: Message = {
+            serviceId: SERVICE_ID,
+            body: {
+                oneofKind: 'rpcMessage',
+                rpcMessage: RpcMessage.create()
+            },
+            messageId: 'mockerer',
+            targetDescriptor: {
+                nodeId: new Uint8Array([1, 2, 4]),
+                type: NodeType.NODEJS
+            }
+        }
+
+        await Promise.allSettled([
+            waitForEvent3<TransportEvents>(wsServerManager, 'disconnected', 15000),
+            wsServerManager.send(dummyMessage)
+        ])
+        expect(wsServerManager.getConnection(getNodeIdFromPeerDescriptor(dummyMessage.targetDescriptor!))).toBeUndefined()
+    }, 20000)
+    
     it('Can open connections to peer with server', async () => {
         const dummyMessage: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: RpcMessage.create()
             },
-            messageType: MessageType.RPC,
             messageId: 'mockerer',
             targetDescriptor: wsServerConnectorPeerDescriptor
         }
         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
+            }
         )
     })
 
     it('Connecting to self throws', async () => {
         const dummyMessage: Message = {
-            serviceId,
+            serviceId: SERVICE_ID,
             body: {
                 oneofKind: 'rpcMessage',
                 rpcMessage: RpcMessage.create()
             },
-            messageType: MessageType.RPC,
             messageId: 'mockerer',
             targetDescriptor: noWsServerConnectorPeerDescriptor
         }