@streamr/trackerless-network 100.0.0-pretestnet.6 → 100.0.0-rc.0

package/test/unit/NodeList.test.ts

@@ -1,20 +1,19 @@
-import { NodeList } from '../../src/logic/NodeList'
-import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
 import {
-    PeerDescriptor,
     ListeningRpcCommunicator,
-    Simulator,
-    SimulatorTransport,
     NodeType,
+    PeerDescriptor,
+    createRandomDhtAddress,
+    getDhtAddressFromRaw,
+    getNodeIdFromPeerDescriptor,
 } from '@streamr/dht'
-import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
-import { expect } from 'expect'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
-import { createMockPeerDescriptor, createRandomNodeId } from '../utils/utils'
-import { binaryToHex } from '@streamr/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
+import { expect } from 'expect'
+import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
+import { NodeList } from '../../src/logic/NodeList'
 import { formStreamPartDeliveryServiceId } from '../../src/logic/formStreamPartDeliveryServiceId'
+import { DeliveryRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { MockTransport } from '../utils/mock/Transport'
 
 const streamPartId = StreamPartIDUtils.parse('stream#0')
 
@@ -27,115 +26,92 @@ describe('NodeList', () => {
         new Uint8Array([1, 1, 4]),
         new Uint8Array([1, 1, 5])
     ]
-    const ownId = createRandomNodeId()
+    const ownId = createRandomDhtAddress()
     let nodeList: NodeList
-    let simulator: Simulator
-    let mockTransports: SimulatorTransport[]
-
-    const createRemoteGraphNode = async (peerDescriptor: PeerDescriptor) => {
-        const mockTransport = new SimulatorTransport(peerDescriptor, simulator)
-        await mockTransport.start()
-        const mockCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(streamPartId), mockTransport)
-        const mockClient = mockCommunicator.getRpcClientTransport()
-        
-        mockTransports.push(mockTransport)
+
+    const createRemoteGraphNode = (peerDescriptor: PeerDescriptor) => {
+        const mockCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(streamPartId), new MockTransport())
         return new DeliveryRpcRemote(
             createMockPeerDescriptor(),
             peerDescriptor,
-            streamPartId,
-            toProtoRpcClient(new DeliveryRpcClient(mockClient))
+            mockCommunicator,
+            DeliveryRpcClient
         )
     }
 
-    beforeEach(async () => {
-        simulator = new Simulator()
-        mockTransports = []
+    beforeEach(() => {
         nodeList = new NodeList(ownId, 6)
         for (const id of ids) {
             const peerDescriptor: PeerDescriptor = {
-                kademliaId: id,
+                nodeId: id,
                 type: NodeType.NODEJS
             }
-            nodeList.add(await createRemoteGraphNode(peerDescriptor))
-        }
-    })
-
-    afterEach(async () => {
-        // eslint-disable-next-line @typescript-eslint/prefer-for-of
-        for (let i = 0; i < mockTransports.length; i++) {
-            await mockTransports[i].stop()
+            nodeList.add(createRemoteGraphNode(peerDescriptor))
         }
-        simulator.stop()
     })
 
-    it('add', async () => {
+    it('add', () => {
         const newDescriptor = {
-            kademliaId: new Uint8Array([1, 2, 3]),
+            nodeId: new Uint8Array([1, 2, 3]),
             type: NodeType.NODEJS
         }
-        const newNode = await createRemoteGraphNode(newDescriptor)
+        const newNode = createRemoteGraphNode(newDescriptor)
         nodeList.add(newNode)
-        expect(nodeList.hasNode(newDescriptor)).toEqual(true)
+        expect(nodeList.has(getNodeIdFromPeerDescriptor(newDescriptor))).toEqual(true)
 
         const newDescriptor2 = {
-            kademliaId: new Uint8Array([1, 2, 4]),
+            nodeId: new Uint8Array([1, 2, 4]),
             type: NodeType.NODEJS
         }
-        const newNode2 = await createRemoteGraphNode(newDescriptor2)
+        const newNode2 = createRemoteGraphNode(newDescriptor2)
         nodeList.add(newNode2)
-        expect(nodeList.hasNode(newDescriptor2)).toEqual(false)
+        expect(nodeList.has(getNodeIdFromPeerDescriptor(newDescriptor2))).toEqual(false)
     })
 
     it('remove', () => {
-        const toRemove = nodeList.getClosest([])
-        nodeList.remove(toRemove!.getPeerDescriptor())
-        expect(nodeList.hasNode(toRemove!.getPeerDescriptor())).toEqual(false)
-    })
-
-    it('removeById', () => {
-        const toRemove = nodeList.getClosest([])
+        const toRemove = nodeList.getFirst([])
         const nodeId = getNodeIdFromPeerDescriptor(toRemove!.getPeerDescriptor())
-        nodeList.removeById(nodeId)
-        expect(nodeList.hasNode(toRemove!.getPeerDescriptor())).toEqual(false)
+        nodeList.remove(nodeId)
+        expect(nodeList.has(nodeId)).toEqual(false)
     })
 
-    it('getClosest', () => {
-        const closest = nodeList.getClosest([])
+    it('getFirst', () => {
+        const closest = nodeList.getFirst([])
         expect(getNodeIdFromPeerDescriptor(closest!.getPeerDescriptor()))
-            .toEqual(binaryToHex(new Uint8Array([1, 1, 1])))
+            .toEqual(getDhtAddressFromRaw(new Uint8Array([1, 1, 1])))
     })
 
-    it('getClosest with exclude', () => {
-        const closest = nodeList.getClosest([binaryToHex(new Uint8Array([1, 1, 1])) as unknown as NodeID])
+    it('getFirst with exclude', () => {
+        const closest = nodeList.getFirst([getDhtAddressFromRaw(new Uint8Array([1, 1, 1]))])
         expect(getNodeIdFromPeerDescriptor(closest!.getPeerDescriptor()))
-            .toEqual(binaryToHex(new Uint8Array([1, 1, 2])))
+            .toEqual(getDhtAddressFromRaw(new Uint8Array([1, 1, 2])))
     })
 
-    it('getFurthest', () => {
-        const closest = nodeList.getFurthest([])
+    it('getLast', () => {
+        const closest = nodeList.getLast([])
         expect(getNodeIdFromPeerDescriptor(closest!.getPeerDescriptor()))
-            .toEqual(binaryToHex(new Uint8Array([1, 1, 5])))
+            .toEqual(getDhtAddressFromRaw(new Uint8Array([1, 1, 5])))
     })
 
-    it('getFurthest with exclude', () => {
-        const closest = nodeList.getFurthest([binaryToHex(new Uint8Array([1, 1, 5])) as unknown as NodeID])
+    it('getLast with exclude', () => {
+        const closest = nodeList.getLast([getDhtAddressFromRaw(new Uint8Array([1, 1, 5]))])
         expect(getNodeIdFromPeerDescriptor(closest!.getPeerDescriptor()))
-            .toEqual(binaryToHex(new Uint8Array([1, 1, 4])))
+            .toEqual(getDhtAddressFromRaw(new Uint8Array([1, 1, 4])))
     })
 
-    it('getClosestAndFurthest', () => {
-        const results = nodeList.getClosestAndFurthest([])
-        expect(results).toEqual([nodeList.getClosest([]), nodeList.getFurthest([])])
+    it('getFirstAndLast', () => {
+        const results = nodeList.getFirstAndLast([])
+        expect(results).toEqual([nodeList.getFirst([]), nodeList.getLast([])])
     })
 
-    it('getClosest empty', () => {
+    it('getFirst empty', () => {
         const emptyList = new NodeList(ownId, 2)
-        expect(emptyList.getClosest([])).toBeUndefined()
+        expect(emptyList.getFirst([])).toBeUndefined()
     })
 
-    it('getFurthest empty', () => {
+    it('getLast empty', () => {
         const emptyList = new NodeList(ownId, 2)
-        expect(emptyList.getFurthest([])).toBeUndefined()
+        expect(emptyList.getLast([])).toBeUndefined()
     })
 
     it('getRandom empty', () => {
@@ -143,19 +119,40 @@ describe('NodeList', () => {
         expect(emptyList.getRandom([])).toBeUndefined()
     })
 
-    it('getClosestAndFurthest empty', () => {
+    it('getFirstAndLast empty', () => {
         const emptyList = new NodeList(ownId, 2)
-        expect(emptyList.getClosestAndFurthest([])).toEqual([])
+        expect(emptyList.getFirstAndLast([])).toEqual([])
     })
 
-    it('getClosestAndFurthest with exclude', () => {
-        const results = nodeList.getClosestAndFurthest([
-            binaryToHex(new Uint8Array([1, 1, 1])) as unknown as NodeID,
-            binaryToHex(new Uint8Array([1, 1, 5])) as unknown as NodeID
+    it('getFirstAndLast with exclude', () => {
+        const results = nodeList.getFirstAndLast([
+            getDhtAddressFromRaw(new Uint8Array([1, 1, 1])),
+            getDhtAddressFromRaw(new Uint8Array([1, 1, 5]))
         ])
         expect(results).toEqual([
-            nodeList.getClosest([binaryToHex(new Uint8Array([1, 1, 1])) as unknown as NodeID]),
-            nodeList.getFurthest([binaryToHex(new Uint8Array([1, 1, 5])) as unknown as NodeID])
+            nodeList.getFirst([getDhtAddressFromRaw(new Uint8Array([1, 1, 1]))]),
+            nodeList.getLast([getDhtAddressFromRaw(new Uint8Array([1, 1, 5]))])
         ])
     })
+
+    it('items are in insertion order', () => {
+        const list = new NodeList(createRandomDhtAddress(), 100)
+        const item1 = createRemoteGraphNode(createMockPeerDescriptor())
+        const item2 = createRemoteGraphNode(createMockPeerDescriptor())
+        const item3 = createRemoteGraphNode(createMockPeerDescriptor())
+        const item4 = createRemoteGraphNode(createMockPeerDescriptor())
+        const item5 = createRemoteGraphNode(createMockPeerDescriptor())
+        const item6 = createRemoteGraphNode(createMockPeerDescriptor())
+        list.add(item2)
+        list.add(item3)
+        list.add(item1)
+        list.add(item6)
+        list.add(item4)
+        list.add(item5)
+        expect(list.getFirst([])!).toEqual(item2)
+        expect(list.getLast([])!).toEqual(item5)
+        // the order doesn't change if item re-added
+        list.add(item4)
+        expect(list.getLast([])!).toEqual(item5)
+    })
 })

package/test/unit/Propagation.test.ts

@@ -2,12 +2,12 @@ import {
     ContentType,
     EncryptionType,
     MessageID,
-    StreamMessage,
-    StreamMessageType,
+    SignatureType,
+    StreamMessage
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { Propagation } from '../../src/logic/propagation/Propagation'
-import { toEthereumAddress, wait, utf8ToBinary, hexToBinary } from '@streamr/utils'
-import { NodeID } from '../../src/identifiers'
+import { hexToBinary, toEthereumAddress, utf8ToBinary, wait } from '@streamr/utils'
+import { DhtAddress } from '@streamr/dht'
 
 const PUBLISHER_ID = toEthereumAddress('0x1111111111111111111111111111111111111111')
 
@@ -22,25 +22,30 @@ function makeMsg(streamId: string, partition: number, ts: number, msgNo: number)
     }
     return {
         messageId,
-        content: new Uint8Array([1]),
-        contentType: ContentType.JSON,
-        encryptionType: EncryptionType.NONE,
         signature: hexToBinary('0x1111'),
-        messageType: StreamMessageType.MESSAGE
+        signatureType: SignatureType.SECP256K1,
+        body: {
+            oneofKind: 'contentMessage',
+            contentMessage: {
+                content: new Uint8Array([1]),
+                contentType: ContentType.JSON,
+                encryptionType: EncryptionType.NONE
+            }
+        }
     }
 }
 
 const TTL = 100
 
-const N1 = 'n1' as NodeID
-const N2 = 'n2' as NodeID
-const N3 = 'n3' as NodeID
-const N4 = 'n4' as NodeID
-const N5 = 'n5' as NodeID
+const N1 = 'n1' as DhtAddress
+const N2 = 'n2' as DhtAddress
+const N3 = 'n3' as DhtAddress
+const N4 = 'n4' as DhtAddress
+const N5 = 'n5' as DhtAddress
 
 describe(Propagation, () => {
-    let getNeighbors: jest.Mock<ReadonlyArray<NodeID>, [string]>
-    let sendToNeighbor: jest.Mock<Promise<void>, [NodeID, StreamMessage]>
+    let getNeighbors: jest.Mock<ReadonlyArray<DhtAddress>, [string]>
+    let sendToNeighbor: jest.Mock<Promise<void>, [DhtAddress, StreamMessage]>
     let propagation: Propagation
 
     beforeEach(() => {
@@ -80,7 +85,7 @@ describe(Propagation, () => {
     describe('#onNeighborJoined', () => {
         let msg: StreamMessage
 
-        async function setUpAndFeed(neighbors: NodeID[]): Promise<void> {
+        async function setUpAndFeed(neighbors: DhtAddress[]): Promise<void> {
             getNeighbors.mockReturnValueOnce(neighbors)
             msg = makeMsg('s1', 0, 1000, 1)
             propagation.feedUnseenMessage(msg, [...getNeighbors('s1#0')], N2)

package/test/unit/ProxyConnectionRpcRemote.test.ts

@@ -1,30 +1,36 @@
-import { StreamPartIDUtils } from '@streamr/protocol'
+import { RpcCommunicator } from '@streamr/proto-rpc'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary } from '@streamr/utils'
 import { ProxyConnectionRpcRemote } from '../../src/logic/proxy/ProxyConnectionRpcRemote'
-import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ProxyConnectionRequest, ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
+import { ProxyConnectionRpcClient } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { createMockPeerDescriptor } from '../utils/utils'
 
 describe('ProxyConnectionRpcRemote', () => {
 
-    it('happy path', () => {
-        const client = {
-            requestConnection: jest.fn()
-        }
+    it('happy path', async () => {
+        const onOutgoingMessage = jest.fn()
+        const rpcCommunicator = new RpcCommunicator()
+        rpcCommunicator.setOutgoingMessageListener(onOutgoingMessage)
         const clientPeerDescriptor = createMockPeerDescriptor()
         const serverPeerDescriptor = createMockPeerDescriptor()
         const rpcRemote = new ProxyConnectionRpcRemote(
             clientPeerDescriptor,
             serverPeerDescriptor,
-            StreamPartIDUtils.parse('stream#0'),
-            client
+            rpcCommunicator,
+            ProxyConnectionRpcClient
         )
+
         const userId = randomEthereumAddress()
-        rpcRemote.requestConnection(ProxyDirection.PUBLISH, userId)
-        expect(client.requestConnection).toBeCalledWith({
+        await rpcRemote.requestConnection(ProxyDirection.PUBLISH, userId)
+
+        const [rpcMessage, _, callContext] = onOutgoingMessage.mock.calls[0]
+        const request = ProxyConnectionRequest.fromBinary(rpcMessage.body.value)
+        expect(request).toEqual({
             direction: ProxyDirection.PUBLISH,
-            userId: hexToBinary(userId)
-        }, {
+            userId: Uint8Array.from(hexToBinary(userId))
+        })
+        expect(callContext).toMatchObject({
             sourceDescriptor: clientPeerDescriptor,
             targetDescriptor: serverPeerDescriptor,
             timeout: 5000

package/test/unit/RandomGraphNode.test.ts

@@ -1,5 +1,4 @@
 import { waitForCondition } from '@streamr/utils'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { NodeList } from '../../src/logic/NodeList'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
 import { createRandomGraphNode } from '../../src/logic/createRandomGraphNode'
@@ -10,13 +9,14 @@ import { MockNeighborUpdateManager } from '../utils/mock/MockNeighborUpdateManag
 import { MockTransport } from '../utils/mock/Transport'
 import { createMockPeerDescriptor, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
+import { getNodeIdFromPeerDescriptor } from '@streamr/dht'
 
 describe('RandomGraphNode', () => {
 
     let randomGraphNode: RandomGraphNode
     const peerDescriptor = createMockPeerDescriptor()
 
-    let targetNeighbors: NodeList
+    let neighbors: NodeList
     let nearbyNodeView: NodeList
     let randomNodeView: NodeList
 
@@ -25,23 +25,25 @@ describe('RandomGraphNode', () => {
     beforeEach(async () => {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
 
-        targetNeighbors = new NodeList(nodeId, 10)
+        neighbors = new NodeList(nodeId, 10)
         randomNodeView = new NodeList(nodeId, 10)
         nearbyNodeView = new NodeList(nodeId, 10)
         layer1Node = new MockLayer1Node()
 
         randomGraphNode = createRandomGraphNode({
-            targetNeighbors,
+            neighbors,
             randomNodeView,
             nearbyNodeView,
             transport: new MockTransport(),
             localPeerDescriptor: peerDescriptor,
             layer1Node,
             connectionLocker: mockConnectionLocker,
-            handshaker: new MockHandshaker(),
-            neighborUpdateManager: new MockNeighborUpdateManager(),
-            neighborFinder: new MockNeighborFinder(),
-            streamPartId: StreamPartIDUtils.parse('stream#0')
+            handshaker: new MockHandshaker() as any,
+            neighborUpdateManager: new MockNeighborUpdateManager() as any,
+            neighborFinder: new MockNeighborFinder() as any,
+            streamPartId: StreamPartIDUtils.parse('stream#0'),
+            isLocalNodeEntryPoint: () => false
+
         })
         await randomGraphNode.start()
     })
@@ -50,12 +52,11 @@ describe('RandomGraphNode', () => {
         randomGraphNode.stop()
     })
 
-    it('getTargetNeighborIds', () => {
+    it('getNeighbors', () => {
         const mockRemote = createMockDeliveryRpcRemote()
-        targetNeighbors.add(mockRemote)
-        const ids = randomGraphNode.getTargetNeighborIds()
-        expect(ids[0]).toEqual(getNodeIdFromPeerDescriptor(mockRemote.getPeerDescriptor()))
-        targetNeighbors.remove(mockRemote.getPeerDescriptor())
+        neighbors.add(mockRemote)
+        const result = randomGraphNode.getNeighbors()
+        expect(getNodeIdFromPeerDescriptor(result[0])).toEqual(getNodeIdFromPeerDescriptor(mockRemote.getPeerDescriptor()))
     })
 
     it('getNearbyNodeView', () => {
@@ -65,19 +66,19 @@ describe('RandomGraphNode', () => {
         expect(ids[0]).toEqual(getNodeIdFromPeerDescriptor(mockRemote.getPeerDescriptor()))
     })
 
-    it('Adds Closest Nodes from layer1 newContact event to nearbyNodeView', async () => {
+    it('Adds Closest Nodes from layer1 contactAdded event to nearbyNodeView', async () => {
         const peerDescriptor1 = createMockPeerDescriptor()
         const peerDescriptor2 = createMockPeerDescriptor()
-        layer1Node.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
+        layer1Node.emit('contactAdded', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => nearbyNodeView.size() === 2)
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
     })
 
-    it('Adds Random Nodes from layer1 newRandomContact event to randomNodeView', async () => {
+    it('Adds Random Nodes from layer1 randomContactAdded event to randomNodeView', async () => {
         const peerDescriptor1 = createMockPeerDescriptor()
         const peerDescriptor2 = createMockPeerDescriptor()
-        layer1Node.emit('newRandomContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
+        layer1Node.emit('randomContactAdded', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
         await waitForCondition(() => randomNodeView.size() === 2)
         expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
         expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
@@ -87,10 +88,12 @@ describe('RandomGraphNode', () => {
         const peerDescriptor1 = createMockPeerDescriptor()
         const peerDescriptor2 = createMockPeerDescriptor()
         layer1Node.addNewRandomPeerToKBucket()
-        layer1Node.emit('newContact', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
-        await waitForCondition(() => nearbyNodeView.size() === 3)
+        layer1Node.emit('contactAdded', peerDescriptor1, [peerDescriptor1, peerDescriptor2])
+        await waitForCondition(() => {
+            return nearbyNodeView.size() === 3
+        }, 20000)
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
         expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
-    })
+    }, 25000)
 
 })

package/test/unit/StreamMessageTranslator.test.ts

@@ -3,11 +3,12 @@ import {
     MessageID,
     StreamMessage as OldStreamMessage,
     StreamMessageType as OldStreamMessageType,
-    StreamPartIDUtils
+    StreamPartIDUtils,
+    ContentType,
+    SignatureType
 } from '@streamr/protocol'
 import { binaryToHex, binaryToUtf8, hexToBinary, toEthereumAddress, utf8ToBinary } from '@streamr/utils'
 import { StreamMessageTranslator } from '../../src/logic/protocol-integration/stream-message/StreamMessageTranslator'
-import { StreamMessageType } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createStreamMessage } from '../utils/utils'
 
 const STREAM_PART_ID = StreamPartIDUtils.parse('TEST#0')
@@ -31,10 +32,11 @@ describe('StreamMessageTranslator', () => {
     )
     const oldProtocolMsg = new OldStreamMessage({
         messageId,
-        prevMsgRef: null,
         content: utf8ToBinary(JSON.stringify({ hello: 'WORLD' })),
+        contentType: ContentType.JSON,
         messageType: OldStreamMessageType.MESSAGE,
         encryptionType: EncryptionType.NONE,
+        signatureType: SignatureType.SECP256K1,
         signature,
     })
 
@@ -46,10 +48,10 @@ describe('StreamMessageTranslator', () => {
         expect(translated.messageId!.sequenceNumber).toEqual(0)
         expect(binaryToHex(translated.messageId!.publisherId, true)).toEqual('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
         expect(translated.previousMessageRef).toEqual(undefined)
-        expect(translated.messageType).toEqual(StreamMessageType.MESSAGE)
-        expect(translated.groupKeyId).toEqual(undefined)
+        expect(translated.body.oneofKind).toEqual('contentMessage')
+        expect((translated.body as any).contentMessage.groupKeyId).toEqual(undefined)
         expect(translated.signature).toStrictEqual(signature)
-        expect(JSON.parse(binaryToUtf8(translated.content))).toEqual({ hello: 'WORLD' })
+        expect(JSON.parse(binaryToUtf8((translated.body as any).contentMessage.content))).toEqual({ hello: 'WORLD' })
     })
 
     it('translates protobuf to old protocol', () => {
@@ -59,10 +61,10 @@ describe('StreamMessageTranslator', () => {
         expect(translated.messageId.timestamp).toBeGreaterThanOrEqual(0)
         expect(translated.messageId.sequenceNumber).toEqual(0)
         expect(translated.getPublisherId()).toEqual('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')
-        expect(translated.prevMsgRef).toEqual(null)
+        expect(translated.prevMsgRef).toEqual(undefined)
         expect(translated.messageType).toEqual(OldStreamMessageType.MESSAGE)
         expect(translated.contentType).toEqual(0)
-        expect(translated.groupKeyId).toEqual(null)
+        expect(translated.groupKeyId).toEqual(undefined)
         expect(translated.signature).toStrictEqual(signature)
         expect(translated.getParsedContent()).toEqual({ hello: 'WORLD' })
     })

package/test/unit/StreamPartIDDataKey.test.ts

@@ -0,0 +1,12 @@
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
+
+describe('StreamPartIDtoDataKey', () => {
+
+    it('generated key length is correct (160 bits)', () => {
+        const streamPartId = StreamPartIDUtils.parse('stream#0')
+        const dataKey = streamPartIdToDataKey(streamPartId)
+        expect(dataKey.length).toEqual(40)
+    })
+
+})

package/test/unit/StreamrNode.test.ts

@@ -56,6 +56,7 @@ describe('StreamrNode', () => {
             node.broadcast(message)
             await waitForCondition(() => node.hasStreamPart(streamPartId))
         })
+
     })
 
     describe('proxied stream', () => {
@@ -93,4 +94,5 @@ describe('StreamrNode', () => {
             expect(node.isProxiedStreamPart(streamPartId)).toBe(false)
         })
     })
+
 })

package/test/unit/TemporaryConnectionRpcLocal.test.ts

@@ -0,0 +1,38 @@
+import { StreamPartIDUtils } from '@streamr/protocol'
+import { TemporaryConnectionRpcLocal } from '../../src/logic/temporary-connection/TemporaryConnectionRpcLocal'
+import { MockTransport } from '../utils/mock/Transport'
+import { createMockPeerDescriptor } from '../utils/utils'
+import { ListeningRpcCommunicator, getDhtAddressFromRaw } from '@streamr/dht'
+
+describe('TemporaryConnectionRpcLocal', () => {
+
+    const peerDescriptor = createMockPeerDescriptor()
+    let rpcCommunicator: ListeningRpcCommunicator
+    let rpcLocal: TemporaryConnectionRpcLocal
+
+    beforeEach(() => {
+        rpcCommunicator = new ListeningRpcCommunicator('mock', new MockTransport())
+        rpcLocal = new TemporaryConnectionRpcLocal({
+            localPeerDescriptor: peerDescriptor,
+            rpcCommunicator,
+            streamPartId: StreamPartIDUtils.parse('mock#0'),
+            connectionLocker: {
+                weakLockConnection: jest.fn(),
+                weakUnlockConnection: jest.fn()
+            } as any
+        })
+    })
+
+    afterEach(() => {
+        rpcCommunicator.destroy()
+    })
+
+    it('Open and Close Connection', async () => {
+        const caller = createMockPeerDescriptor()
+        await rpcLocal.openConnection({}, { incomingSourceDescriptor: caller } as any)
+        expect(rpcLocal.getNodes().get(getDhtAddressFromRaw(caller.nodeId))).toBeDefined()
+        await rpcLocal.closeConnection({}, { incomingSourceDescriptor: caller } as any)
+        expect(rpcLocal.getNodes().get(getDhtAddressFromRaw(caller.nodeId))).toBeUndefined()
+    })
+
+})

package/test/unit/oldStreamMessageBinaryUtils.test.ts

@@ -0,0 +1,39 @@
+import {
+    ContentType,
+    EncryptionType,
+    MessageID,
+    MessageRef,
+    SignatureType,
+    StreamMessage,
+    toStreamID
+} from '@streamr/protocol'
+import { toEthereumAddress } from '@streamr/utils'
+import { convertBytesToStreamMessage, convertStreamMessageToBytes } from '../../src/exports'
+
+describe('oldStreamMessageBinaryUtils', () => {
+    it('convertStreamMessageToBytes and convertBytesToStreamMessage', () => {
+        const streamMessage = new StreamMessage({
+            messageId: new MessageID(
+                toStreamID('test.ens/foobar'),
+                0,
+                10001,
+                0,
+                toEthereumAddress('0x1234567890123456789012345678901234567890'),
+                'msgChainId'
+            ),
+            prevMsgRef: new MessageRef(10000, 1),
+            content: new Uint8Array([1, 2, 3]),
+            contentType: ContentType.BINARY,
+            encryptionType: EncryptionType.NONE,
+            groupKeyId: '0x1234567890123456789012345678901234567890',
+            signatureType: SignatureType.SECP256K1,
+            signature: new Uint8Array([7, 8, 9])
+        })
+
+        const bytes = convertStreamMessageToBytes(streamMessage)
+        expect(bytes).toBeInstanceOf(Uint8Array)
+        expect(bytes.length).toBeGreaterThan(100)
+        const convertedStreamMessage = convertBytesToStreamMessage(bytes)
+        expect(convertedStreamMessage).toEqual(streamMessage)
+    })
+})

package/test/utils/mock/MockHandshaker.ts

@@ -1,15 +1,16 @@
-import { NodeID } from '../../../src/identifiers'
-import { IHandshaker } from '../../../src/logic/neighbor-discovery/Handshaker'
+import { Methods } from '@streamr/test-utils'
+import { Handshaker } from '../../../src/logic/neighbor-discovery/Handshaker'
+import { DhtAddress } from '@streamr/dht'
 
-export class MockHandshaker implements IHandshaker {
+export class MockHandshaker implements Methods<Handshaker> {
 
     // eslint-disable-next-line class-methods-use-this
-    getOngoingHandshakes(): Set<NodeID> {
+    getOngoingHandshakes(): Set<DhtAddress> {
         return new Set()
     }
 
     // eslint-disable-next-line class-methods-use-this
-    async attemptHandshakesOnContacts(excludedIds: NodeID[]): Promise<NodeID[]> {
+    async attemptHandshakesOnContacts(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
         return excludedIds
     }