@streamr/trackerless-network 100.0.0-testnet-two.4 → 100.0.0-testnet-three.0

package/test/integration/stream-without-default-entrypoints.test.ts

@@ -1,7 +1,10 @@
 import { LatencyType, NodeType, PeerDescriptor, Simulator, SimulatorTransport, getRandomRegion } from '@streamr/dht'
 import {
+    ContentType,
+    EncryptionType,
     MessageID,
     MessageRef,
+    SignatureType,
     StreamMessage,
     StreamMessageType,
     StreamPartIDUtils
@@ -18,7 +21,7 @@ describe('stream without default entrypoints', () => {
 
     let entrypoint: NetworkNode
     let nodes: NetworkNode[]
-    let numOfReceivedMessages: number
+    let receivedMessageCount: number
     const entryPointPeerDescriptor: PeerDescriptor = {
         nodeId: new Uint8Array([1, 2, 3]),
         type: NodeType.NODEJS,
@@ -39,13 +42,16 @@ describe('stream without default entrypoints', () => {
             hello: 'world'
         })),
         messageType: StreamMessageType.MESSAGE,
+        contentType: ContentType.JSON,
+        encryptionType: EncryptionType.NONE,
+        signatureType: SignatureType.SECP256K1,
         signature: hexToBinary('0x1234'),
     })
 
     beforeEach(async () => {
         const simulator = new Simulator(LatencyType.REAL)
         nodes = []
-        numOfReceivedMessages = 0
+        receivedMessageCount = 0
         const entryPointTransport = new SimulatorTransport(entryPointPeerDescriptor, simulator)
         await entryPointTransport.start()
         entrypoint = createNetworkNode({
@@ -80,36 +86,36 @@ describe('stream without default entrypoints', () => {
     it('can join stream without configured entrypoints one by one', async () => {
         await nodes[0].join(STREAM_PART_ID)
         nodes[0].addMessageListener((_msg) => {
-            numOfReceivedMessages += 1
+            receivedMessageCount += 1
         })
         await Promise.all([
-            waitForCondition(() => numOfReceivedMessages === 1, 10000),
+            waitForCondition(() => receivedMessageCount === 1, 10000),
             nodes[1].broadcast(streamMessage)
         ])
     })
 
     it('can join without configured entrypoints simultaneously', async () => {
         nodes[0].addMessageListener((_msg) => {
-            numOfReceivedMessages += 1
+            receivedMessageCount += 1
         })
         await Promise.all([
-            waitForCondition(() => numOfReceivedMessages === 1, 15000),
+            waitForCondition(() => receivedMessageCount === 1, 15000),
             nodes[0].join(STREAM_PART_ID),
             nodes[1].broadcast(streamMessage),
         ])
     })
 
     it('multiple nodes can join without configured entrypoints simultaneously', async () => {
-        const numOfSubscribers = 8
-        await Promise.all(range(numOfSubscribers).map(async (i) => {
+        const subscriberCount = 8
+        await Promise.all(range(subscriberCount).map(async (i) => {
             await nodes[i].join(STREAM_PART_ID, { minCount: 4, timeout: 15000 })
             nodes[i].addMessageListener(() => {
-                numOfReceivedMessages += 1
+                receivedMessageCount += 1
             })
         }))
-        const nonjoinedNode = nodes[numOfSubscribers]
+        const nonjoinedNode = nodes[subscriberCount]
         await nonjoinedNode.broadcast(streamMessage)
-        await waitForCondition(() => numOfReceivedMessages === numOfSubscribers, 15000)
+        await waitForCondition(() => receivedMessageCount === subscriberCount, 15000)
     }, 45000)
 
     it('nodes store themselves as entrypoints on streamPart if number of entrypoints is low', async () => {

package/test/unit/HandshakeRpcLocal.test.ts

@@ -13,13 +13,13 @@ describe('HandshakeRpcLocal', () => {
 
     const localPeerDescriptor = createMockPeerDescriptor()
 
-    let targetNeighbors: NodeList
+    let neighbors: NodeList
     let ongoingHandshakes: Set<DhtAddress>
     let ongoingInterleaves: Set<DhtAddress>
     let handshakeWithInterleaving: jest.Mock
 
     beforeEach(() => {
-        targetNeighbors = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), 10)
+        neighbors = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), 10)
         ongoingHandshakes = new Set()
         ongoingInterleaves = new Set()
         handshakeWithInterleaving = jest.fn()
@@ -35,7 +35,7 @@ describe('HandshakeRpcLocal', () => {
                 handshakeWithInterleaving()
                 return true
             },
-            targetNeighbors,
+            neighbors,
             maxNeighborCount: 4
         })
     })
@@ -54,10 +54,10 @@ describe('HandshakeRpcLocal', () => {
     })
 
     it('handshake interleave', async () => {
-        targetNeighbors.add(createMockDeliveryRpcRemote())
-        targetNeighbors.add(createMockDeliveryRpcRemote())
-        targetNeighbors.add(createMockDeliveryRpcRemote())
-        targetNeighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
         const req = StreamPartHandshakeRequest.create({
             streamPartId: STREAM_PART_ID,
             requestId: 'requestId'
@@ -111,10 +111,10 @@ describe('HandshakeRpcLocal', () => {
     })
 
     it('rejects handshakes if interleaving to the requestor is ongoing', async () => {
-        targetNeighbors.add(createMockDeliveryRpcRemote())
-        targetNeighbors.add(createMockDeliveryRpcRemote())
-        targetNeighbors.add(createMockDeliveryRpcRemote())
-        targetNeighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote())
         const requestor = createMockPeerDescriptor()
         ongoingInterleaves.add(getNodeIdFromPeerDescriptor(requestor))
         const req = StreamPartHandshakeRequest.create({
@@ -131,10 +131,10 @@ describe('HandshakeRpcLocal', () => {
         const interleavingPeer1 = createMockPeerDescriptor()
         const interleavingPeer2 = createMockPeerDescriptor()
         const interleavingPeer3 = createMockPeerDescriptor()
-        targetNeighbors.add(createMockDeliveryRpcRemote(interleavingPeer1))
-        targetNeighbors.add(createMockDeliveryRpcRemote(interleavingPeer2))
-        targetNeighbors.add(createMockDeliveryRpcRemote(interleavingPeer3))
-        targetNeighbors.add(createMockDeliveryRpcRemote())
+        neighbors.add(createMockDeliveryRpcRemote(interleavingPeer1))
+        neighbors.add(createMockDeliveryRpcRemote(interleavingPeer2))
+        neighbors.add(createMockDeliveryRpcRemote(interleavingPeer3))
+        neighbors.add(createMockDeliveryRpcRemote())
         ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer1))
         ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer2))
         ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer3))

package/test/unit/Handshaker.test.ts

@@ -13,7 +13,7 @@ describe('Handshaker', () => {
     const maxNeighborCount = 4
     const streamPartId = StreamPartIDUtils.parse('stream#0')
 
-    let targetNeighbors: NodeList
+    let neighbors: NodeList
     let nearbyNodeView: NodeList
     let randomNodeView: NodeList
 
@@ -27,7 +27,7 @@ describe('Handshaker', () => {
         const rpcCommunicator = new ListeningRpcCommunicator(streamPartId, simulatorTransport)
 
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
-        targetNeighbors = new NodeList(nodeId, 10)
+        neighbors = new NodeList(nodeId, 10)
         nearbyNodeView = new NodeList(nodeId, 20)
         randomNodeView = new NodeList(nodeId, 20)
 
@@ -35,7 +35,7 @@ describe('Handshaker', () => {
             localPeerDescriptor: peerDescriptor,
             streamPartId,
             connectionLocker: mockConnectionLocker,
-            targetNeighbors,
+            neighbors,
             nearbyNodeView,
             randomNodeView,
             rpcCommunicator,

package/test/unit/NeighborFinder.test.ts

@@ -9,27 +9,27 @@ import { DhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 describe('NeighborFinder', () => {
 
     const nodeId = createRandomNodeId()
-    let targetNeighbors: NodeList
+    let neighbors: NodeList
     let nearbyNodeView: NodeList
     let neighborFinder: NeighborFinder
 
     const minCount = 4
 
     beforeEach(() => {
-        targetNeighbors = new NodeList(nodeId, 15)
+        neighbors = new NodeList(nodeId, 15)
         nearbyNodeView = new NodeList(nodeId, 30)
         range(30).forEach(() => nearbyNodeView.add(createMockDeliveryRpcRemote()))
         const mockDoFindNeighbors = async (excluded: DhtAddress[]) => {
             const target = nearbyNodeView.getRandom(excluded)
             if (Math.random() < 0.5) {
-                targetNeighbors.add(target!)
+                neighbors.add(target!)
             } else {
                 excluded.push(getNodeIdFromPeerDescriptor(target!.getPeerDescriptor()))
             }
             return excluded
         }
         neighborFinder = new NeighborFinder({
-            targetNeighbors,
+            neighbors,
             nearbyNodeView,
             doFindNeighbors: (excluded) => mockDoFindNeighbors(excluded),
             minCount
@@ -42,7 +42,7 @@ describe('NeighborFinder', () => {
 
     it('Finds target number of nodes', async () => {
         neighborFinder.start()
-        await waitForCondition(() => targetNeighbors.size() >= minCount, 10000)
+        await waitForCondition(() => neighbors.size() >= minCount, 10000)
         expect(neighborFinder.isRunning()).toEqual(false)
     })
 })

package/test/unit/NodeList.test.ts

@@ -2,8 +2,6 @@ import {
     ListeningRpcCommunicator,
     NodeType,
     PeerDescriptor,
-    Simulator,
-    SimulatorTransport,
     getDhtAddressFromRaw,
     getNodeIdFromPeerDescriptor,
 } from '@streamr/dht'
@@ -14,6 +12,7 @@ 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, createRandomNodeId } from '../utils/utils'
+import { MockTransport } from '../utils/mock/Transport'
 
 const streamPartId = StreamPartIDUtils.parse('stream#0')
 
@@ -28,14 +27,9 @@ describe('NodeList', () => {
     ]
     const ownId = createRandomNodeId()
     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)
-        mockTransports.push(mockTransport)
+
+    const createRemoteGraphNode = (peerDescriptor: PeerDescriptor) => {
+        const mockCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(streamPartId), new MockTransport())
         return new DeliveryRpcRemote(
             createMockPeerDescriptor(),
             peerDescriptor,
@@ -44,95 +38,79 @@ describe('NodeList', () => {
         )
     }
 
-    beforeEach(async () => {
-        simulator = new Simulator()
-        mockTransports = []
+    beforeEach(() => {
         nodeList = new NodeList(ownId, 6)
         for (const id of ids) {
             const peerDescriptor: PeerDescriptor = {
                 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 = {
             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 = {
             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(getDhtAddressFromRaw(new Uint8Array([1, 1, 1])))
     })
 
-    it('getClosest with exclude', () => {
-        const closest = nodeList.getClosest([getDhtAddressFromRaw(new Uint8Array([1, 1, 1]))])
+    it('getFirst with exclude', () => {
+        const closest = nodeList.getFirst([getDhtAddressFromRaw(new Uint8Array([1, 1, 1]))])
         expect(getNodeIdFromPeerDescriptor(closest!.getPeerDescriptor()))
             .toEqual(getDhtAddressFromRaw(new Uint8Array([1, 1, 2])))
     })
 
-    it('getFurthest', () => {
-        const closest = nodeList.getFurthest([])
+    it('getLast', () => {
+        const closest = nodeList.getLast([])
         expect(getNodeIdFromPeerDescriptor(closest!.getPeerDescriptor()))
             .toEqual(getDhtAddressFromRaw(new Uint8Array([1, 1, 5])))
     })
 
-    it('getFurthest with exclude', () => {
-        const closest = nodeList.getFurthest([getDhtAddressFromRaw(new Uint8Array([1, 1, 5]))])
+    it('getLast with exclude', () => {
+        const closest = nodeList.getLast([getDhtAddressFromRaw(new Uint8Array([1, 1, 5]))])
         expect(getNodeIdFromPeerDescriptor(closest!.getPeerDescriptor()))
             .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', () => {
@@ -140,19 +118,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([
+    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([getDhtAddressFromRaw(new Uint8Array([1, 1, 1]))]),
-            nodeList.getFurthest([getDhtAddressFromRaw(new Uint8Array([1, 1, 5]))])
+            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(createRandomNodeId(), 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,11 +2,12 @@ import {
     ContentType,
     EncryptionType,
     MessageID,
+    SignatureType,
     StreamMessage,
     StreamMessageType,
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { Propagation } from '../../src/logic/propagation/Propagation'
-import { toEthereumAddress, wait, utf8ToBinary, hexToBinary } from '@streamr/utils'
+import { hexToBinary, toEthereumAddress, utf8ToBinary, wait } from '@streamr/utils'
 import { DhtAddress } from '@streamr/dht'
 
 const PUBLISHER_ID = toEthereumAddress('0x1111111111111111111111111111111111111111')
@@ -26,7 +27,8 @@ function makeMsg(streamId: string, partition: number, ts: number, msgNo: number)
         contentType: ContentType.JSON,
         encryptionType: EncryptionType.NONE,
         signature: hexToBinary('0x1111'),
-        messageType: StreamMessageType.MESSAGE
+        messageType: StreamMessageType.MESSAGE,
+        signatureType: SignatureType.SECP256K1
     }
 }
 

package/test/unit/RandomGraphNode.test.ts

@@ -16,7 +16,7 @@ describe('RandomGraphNode', () => {
     let randomGraphNode: RandomGraphNode
     const peerDescriptor = createMockPeerDescriptor()
 
-    let targetNeighbors: NodeList
+    let neighbors: NodeList
     let nearbyNodeView: NodeList
     let randomNodeView: NodeList
 
@@ -25,13 +25,13 @@ 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(),
@@ -52,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', () => {

package/test/unit/StreamMessageTranslator.test.ts

@@ -3,7 +3,9 @@ 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'
@@ -31,10 +33,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,
     })
 
@@ -59,10 +62,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/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/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/MockLayer0Node.ts

@@ -45,7 +45,12 @@ export class MockLayer0Node extends EventEmitter implements Layer0Node {
     }
 
     // eslint-disable-next-line class-methods-use-this
-    getAllConnectionPeerDescriptors(): PeerDescriptor[] {
+    getConnections(): PeerDescriptor[] {
+        return []
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    getNeighbors(): PeerDescriptor[] {
         return []
     }
 

package/test/utils/mock/MockLayer1Node.ts

@@ -16,11 +16,11 @@ export class MockLayer1Node extends EventEmitter implements Layer1Node {
         return []
     }
 
-    getAllNeighborPeerDescriptors(): PeerDescriptor[] {
+    getNeighbors(): PeerDescriptor[] {
         return this.kbucketPeers
     }
 
-    getNumberOfNeighbors(): number {
+    getNeighborCount(): number {
         return this.kbucketPeers.length
     }
 

package/test/utils/mock/Transport.ts

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

package/test/utils/utils.ts

@@ -16,6 +16,7 @@ import {
     ContentType,
     EncryptionType,
     MessageID,
+    SignatureType,
     StreamMessage,
     StreamMessageType
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
@@ -84,7 +85,8 @@ export const createStreamMessage = (
         content: utf8ToBinary(content),
         contentType: ContentType.JSON,
         messageId,
-        signature: hexToBinary('0x1234')
+        signature: hexToBinary('0x1234'),
+        signatureType: SignatureType.SECP256K1,
     }
     return msg
 }

package/tsconfig.jest.json

@@ -8,9 +8,9 @@
         "src/**/*",
         "test/**/*"
     ],
-    "exclude": [
-    ],
     "references": [
-        { "path": "tsconfig.node.json" }
+        { "path": "../protocol/tsconfig.node.json" },
+        { "path": "../proto-rpc/tsconfig.node.json" },
+        { "path": "../dht/tsconfig.node.json" }
     ]
 }

package/tsconfig.node.json

@@ -6,7 +6,6 @@
     },
     "include": [
         "src/**/*",
-        "package.json",
         "test/benchmark/first-message.ts",
         "test/utils/utils.ts"
     ],