@streamr/trackerless-network 101.1.2 → 102.0.0-beta.0

package/test/unit/ContentDeliveryLayerNode.test.ts

@@ -1,4 +1,4 @@
-import { getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { toNodeId } from '@streamr/dht'
 import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
 import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
 import { NodeList } from '../../src/logic/NodeList'
@@ -22,7 +22,7 @@ describe('ContentDeliveryLayerNode', () => {
     let discoveryLayerNode: MockDiscoveryLayerNode
 
     beforeEach(async () => {
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
 
         neighbors = new NodeList(nodeId, 10)
         randomNodeView = new NodeList(nodeId, 10)
@@ -54,14 +54,14 @@ describe('ContentDeliveryLayerNode', () => {
         const mockRemote = createMockContentDeliveryRpcRemote()
         neighbors.add(mockRemote)
         const result = contentDeliveryLayerNode.getNeighbors()
-        expect(getNodeIdFromPeerDescriptor(result[0])).toEqual(getNodeIdFromPeerDescriptor(mockRemote.getPeerDescriptor()))
+        expect(toNodeId(result[0])).toEqual(toNodeId(mockRemote.getPeerDescriptor()))
     })
 
     it('getNearbyNodeView', () => {
         const mockRemote = createMockContentDeliveryRpcRemote()
         nearbyNodeView.add(mockRemote)
         const ids = contentDeliveryLayerNode.getNearbyNodeView().getIds()
-        expect(ids[0]).toEqual(getNodeIdFromPeerDescriptor(mockRemote.getPeerDescriptor()))
+        expect(ids[0]).toEqual(toNodeId(mockRemote.getPeerDescriptor()))
     })
 
     it('Adds Closest Nodes from layer1 nearbyContactAdded event to nearbyNodeView', async () => {
@@ -70,8 +70,8 @@ describe('ContentDeliveryLayerNode', () => {
         discoveryLayerNode.setClosestContacts([peerDescriptor1, peerDescriptor2])
         discoveryLayerNode.emit('nearbyContactAdded', peerDescriptor1)
         await waitForCondition(() => nearbyNodeView.size() === 2)
-        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
-        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
+        expect(nearbyNodeView.get(toNodeId(peerDescriptor1))).toBeTruthy()
+        expect(nearbyNodeView.get(toNodeId(peerDescriptor2))).toBeTruthy()
     })
 
     it('Adds Random Nodes from layer1 randomContactAdded event to randomNodeView', async () => {
@@ -80,8 +80,8 @@ describe('ContentDeliveryLayerNode', () => {
         discoveryLayerNode.setRandomContacts([peerDescriptor1, peerDescriptor2])
         discoveryLayerNode.emit('randomContactAdded', peerDescriptor1)
         await waitForCondition(() => randomNodeView.size() === 2)
-        expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
-        expect(randomNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
+        expect(randomNodeView.get(toNodeId(peerDescriptor1))).toBeTruthy()
+        expect(randomNodeView.get(toNodeId(peerDescriptor2))).toBeTruthy()
     })
 
     it('Adds Nodes from layer1 neighbors to nearbyNodeView if its size is below nodeViewSize', async () => {
@@ -93,8 +93,20 @@ describe('ContentDeliveryLayerNode', () => {
         await waitForCondition(() => {
             return nearbyNodeView.size() === 3
         }, 20000)
-        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor1))).toBeTruthy()
-        expect(nearbyNodeView.get(getNodeIdFromPeerDescriptor(peerDescriptor2))).toBeTruthy()
+        expect(nearbyNodeView.get(toNodeId(peerDescriptor1))).toBeTruthy()
+        expect(nearbyNodeView.get(toNodeId(peerDescriptor2))).toBeTruthy()
     }, 25000)
 
+    it('getInfo', () => {
+        const nodeWithRtt = createMockContentDeliveryRpcRemote()
+        neighbors.add(nodeWithRtt)
+        const nodeWithoutRtt = createMockContentDeliveryRpcRemote()
+        neighbors.add(nodeWithoutRtt)
+        nodeWithRtt.setRtt(100)
+        const info = contentDeliveryLayerNode.getInfos()
+        expect(info[0].rtt).toEqual(100)
+        expect(info[0].peerDescriptor).toEqual(nodeWithRtt.getPeerDescriptor())
+        expect(info[1].rtt).toBeUndefined()
+        expect(info[1].peerDescriptor).toEqual(nodeWithoutRtt.getPeerDescriptor())
+    })
 })

package/test/unit/ContentDeliveryManager.test.ts

@@ -1,11 +1,11 @@
 import { areEqualPeerDescriptors } from '@streamr/dht'
-import { randomEthereumAddress } from '@streamr/test-utils'
 import { StreamPartIDUtils, waitForCondition } from '@streamr/utils'
 import { ContentDeliveryManager } from '../../src/logic/ContentDeliveryManager'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { MockControlLayerNode } from '../utils/mock/MockControlLayerNode'
 import { MockTransport } from '../utils/mock/MockTransport'
 import { createMockPeerDescriptor, createStreamMessage, mockConnectionLocker } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 describe('ContentDeliveryManager', () => {
 
@@ -32,7 +32,7 @@ describe('ContentDeliveryManager', () => {
         const message = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
             streamPartId,
-            randomEthereumAddress()
+            randomUserId()
         )
 
         beforeEach(async () => {
@@ -61,7 +61,7 @@ describe('ContentDeliveryManager', () => {
         it('happy path', async () => {
             const streamPartId = StreamPartIDUtils.parse('stream#0')
             const proxy = createMockPeerDescriptor()
-            const userId = randomEthereumAddress()
+            const userId = randomUserId()
             await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)
             expect(manager.isProxiedStreamPart(streamPartId)).toBe(true)
             await manager.setProxies(streamPartId, [], ProxyDirection.PUBLISH, userId)
@@ -71,7 +71,7 @@ describe('ContentDeliveryManager', () => {
         it('empty node list', async () => {
             const streamPartId = StreamPartIDUtils.parse('stream#0')
             const proxy = createMockPeerDescriptor()
-            const userId = randomEthereumAddress()
+            const userId = randomUserId()
             await manager.setProxies(streamPartId, [], ProxyDirection.PUBLISH, userId)
             expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
             await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)
@@ -83,7 +83,7 @@ describe('ContentDeliveryManager', () => {
         it('connection count to 0', async () => {
             const streamPartId = StreamPartIDUtils.parse('stream#0')
             const proxy = createMockPeerDescriptor()
-            const userId = randomEthereumAddress()
+            const userId = randomUserId()
             await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId, 0)
             expect(manager.isProxiedStreamPart(streamPartId)).toBe(false)
             await manager.setProxies(streamPartId, [proxy], ProxyDirection.PUBLISH, userId)

package/test/unit/ContentDeliveryRpcLocal.test.ts

@@ -1,10 +1,10 @@
 import { ListeningRpcCommunicator } from '@streamr/dht'
-import { randomEthereumAddress } from '@streamr/test-utils'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { ContentDeliveryRpcLocal } from '../../src/logic/ContentDeliveryRpcLocal'
 import { LeaveStreamPartNotice } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { MockTransport } from '../utils/mock/MockTransport'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 describe('ContentDeliveryRpcLocal', () => {
 
@@ -16,7 +16,7 @@ describe('ContentDeliveryRpcLocal', () => {
     const message = createStreamMessage(
         JSON.stringify({ hello: 'WORLD' }),
         StreamPartIDUtils.parse('random-graph#0'),
-        randomEthereumAddress()
+        randomUserId()
     )
 
     let mockBroadcast: jest.Mock

package/test/unit/HandshakeRpcLocal.test.ts

@@ -1,4 +1,4 @@
-import { DhtAddress, NodeType, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '@streamr/dht'
+import { DhtAddress, NodeType, toNodeId, toDhtAddressRaw } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { NodeList } from '../../src/logic/NodeList'
 import { HandshakeRpcLocal } from '../../src/logic/neighbor-discovery/HandshakeRpcLocal'
@@ -19,7 +19,7 @@ describe('HandshakeRpcLocal', () => {
     let handshakeWithInterleaving: jest.Mock
 
     beforeEach(() => {
-        neighbors = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), 10)
+        neighbors = new NodeList(toNodeId(localPeerDescriptor), 10)
         ongoingHandshakes = new Set()
         ongoingInterleaves = new Set()
         handshakeWithInterleaving = jest.fn()
@@ -86,7 +86,7 @@ describe('HandshakeRpcLocal', () => {
     it('handshakeWithInterleaving success', async () => {
         const req: InterleaveRequest = {
             interleaveTargetDescriptor: {
-                nodeId: getRawFromDhtAddress('0x2222' as DhtAddress),
+                nodeId: toDhtAddressRaw('0x2222' as DhtAddress),
                 type: NodeType.NODEJS
             }
         }
@@ -99,7 +99,7 @@ describe('HandshakeRpcLocal', () => {
     it('handshakeWithInterleaving success', async () => {
         const req: InterleaveRequest = {
             interleaveTargetDescriptor: {
-                nodeId: getRawFromDhtAddress('0x2222' as DhtAddress),
+                nodeId: toDhtAddressRaw('0x2222' as DhtAddress),
                 type: NodeType.NODEJS
             }
         }
@@ -115,7 +115,7 @@ describe('HandshakeRpcLocal', () => {
         neighbors.add(createMockContentDeliveryRpcRemote())
         neighbors.add(createMockContentDeliveryRpcRemote())
         const requestor = createMockPeerDescriptor()
-        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(requestor))
+        ongoingInterleaves.add(toNodeId(requestor))
         const req = StreamPartHandshakeRequest.create({
             streamPartId: STREAM_PART_ID,
             requestId: 'requestId'
@@ -134,9 +134,9 @@ describe('HandshakeRpcLocal', () => {
         neighbors.add(createMockContentDeliveryRpcRemote(interleavingPeer2))
         neighbors.add(createMockContentDeliveryRpcRemote(interleavingPeer3))
         neighbors.add(createMockContentDeliveryRpcRemote())
-        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer1))
-        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer2))
-        ongoingInterleaves.add(getNodeIdFromPeerDescriptor(interleavingPeer3))
+        ongoingInterleaves.add(toNodeId(interleavingPeer1))
+        ongoingInterleaves.add(toNodeId(interleavingPeer2))
+        ongoingInterleaves.add(toNodeId(interleavingPeer3))
         const req = StreamPartHandshakeRequest.create({
             streamPartId: STREAM_PART_ID,
             requestId: 'requestId'

package/test/unit/Handshaker.test.ts

@@ -1,4 +1,4 @@
-import { ListeningRpcCommunicator, Simulator, SimulatorTransport, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { ListeningRpcCommunicator, Simulator, SimulatorTransport, toNodeId } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { range } from 'lodash'
 import { NodeList } from '../../src/logic/NodeList'
@@ -28,7 +28,7 @@ describe('Handshaker', () => {
         await simulatorTransport.start()
         const rpcCommunicator = new ListeningRpcCommunicator(streamPartId, simulatorTransport)
 
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        const nodeId = toNodeId(peerDescriptor)
         neighbors = new NodeList(nodeId, 10)
         leftNodeView = new NodeList(nodeId, 20)
         rightNodeView = new NodeList(nodeId, 20)

package/test/unit/InspectSession.test.ts

@@ -2,7 +2,7 @@ import { InspectSession, Events } from '../../src/logic/inspect/InspectSession'
 import { MessageID } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { waitForEvent3 } from '../../../utils/dist/src/waitForEvent3'
 import { utf8ToBinary } from '@streamr/utils'
-import { DhtAddress, createRandomDhtAddress } from '@streamr/dht'
+import { DhtAddress, randomDhtAddress } from '@streamr/dht'
 
 describe('InspectSession', () => {
 
@@ -30,8 +30,8 @@ describe('InspectSession', () => {
     }
 
     beforeEach(() => {
-        inspectedNode = createRandomDhtAddress()
-        anotherNode = createRandomDhtAddress()
+        inspectedNode = randomDhtAddress()
+        anotherNode = randomDhtAddress()
         inspectSession = new InspectSession({
             inspectedNode
         })

package/test/unit/Inspector.test.ts

@@ -1,4 +1,4 @@
-import { ListeningRpcCommunicator, createRandomDhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { ListeningRpcCommunicator, randomDhtAddress, toNodeId } from '@streamr/dht'
 import { StreamPartIDUtils, utf8ToBinary } from '@streamr/utils'
 import { Inspector } from '../../src/logic/inspect/Inspector'
 import { MockTransport } from '../utils/mock/MockTransport'
@@ -11,7 +11,7 @@ describe('Inspector', () => {
 
     const inspectedDescriptor = createMockPeerDescriptor()
 
-    const nodeId = createRandomDhtAddress()
+    const nodeId = randomDhtAddress()
     let mockConnect: jest.Mock
 
     const messageRef = {
@@ -40,11 +40,11 @@ describe('Inspector', () => {
 
     it('Opens inspection connection and runs successfully', async () => {
         setTimeout(() => {
-            inspector.markMessage(getNodeIdFromPeerDescriptor(inspectedDescriptor), messageRef)
+            inspector.markMessage(toNodeId(inspectedDescriptor), messageRef)
             inspector.markMessage(nodeId, messageRef)
         }, 250)
         await inspector.inspect(inspectedDescriptor)
-        expect(inspector.isInspected(getNodeIdFromPeerDescriptor(inspectedDescriptor))).toBe(false)
+        expect(inspector.isInspected(toNodeId(inspectedDescriptor))).toBe(false)
         expect(mockConnect).toBeCalledTimes(1)
     })
 

package/test/unit/NeighborFinder.test.ts

@@ -4,11 +4,11 @@ import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { expect } from 'expect'
 import { createMockContentDeliveryRpcRemote } from '../utils/utils'
-import { DhtAddress, createRandomDhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { DhtAddress, randomDhtAddress, toNodeId } from '@streamr/dht'
 
 describe('NeighborFinder', () => {
 
-    const nodeId = createRandomDhtAddress()
+    const nodeId = randomDhtAddress()
     let neighbors: NodeList
     let nearbyNodeView: NodeList
     let neighborFinder: NeighborFinder
@@ -24,7 +24,7 @@ describe('NeighborFinder', () => {
             if (Math.random() < 0.5) {
                 neighbors.add(target!)
             } else {
-                excluded.push(getNodeIdFromPeerDescriptor(target!.getPeerDescriptor()))
+                excluded.push(toNodeId(target!.getPeerDescriptor()))
             }
             return excluded
         }

package/test/unit/NeighborUpdateRpcLocal.test.ts

@@ -1,4 +1,4 @@
-import { DhtAddress, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+import { DhtAddress, ListeningRpcCommunicator, toNodeId } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { range } from 'lodash'
 import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
@@ -35,8 +35,8 @@ describe('NeighborUpdateRpcLocal', () => {
 
     beforeEach(() => {
         rpcCommunicator = new ListeningRpcCommunicator('mock', new MockTransport())
-        neighbors = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), neighborTargetCount + 1)
-        nearbyNodeView = new NodeList(getNodeIdFromPeerDescriptor(localPeerDescriptor), neighborTargetCount)
+        neighbors = new NodeList(toNodeId(localPeerDescriptor), neighborTargetCount + 1)
+        nearbyNodeView = new NodeList(toNodeId(localPeerDescriptor), neighborTargetCount)
         neighborFinder = {
             start: jest.fn()
         } as any
@@ -122,12 +122,12 @@ describe('NeighborUpdateRpcLocal', () => {
             removeMe: false
         }, { incomingSourceDescriptor: caller } as any)
         expect(res.removeMe).toEqual(true)
-        expect(neighbors.has(getNodeIdFromPeerDescriptor(caller))).toEqual(false)
+        expect(neighbors.has(toNodeId(caller))).toEqual(false)
     })
 
     it('does not ask to be removed if there is an ongoing handshake to the caller', async () => {
         const caller = createMockPeerDescriptor()
-        ongoingHandshakes.add(getNodeIdFromPeerDescriptor(caller))
+        ongoingHandshakes.add(toNodeId(caller))
         const res = await rpcLocal.neighborUpdate({
             streamPartId,
             neighborDescriptors: [localPeerDescriptor],

package/test/unit/NetworkNode.test.ts

@@ -1,4 +1,3 @@
-import { randomEthereumAddress } from '@streamr/test-utils'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { NetworkNode } from '../../src/NetworkNode'
@@ -6,9 +5,10 @@ import { NetworkStack } from '../../src/NetworkStack'
 import { Events } from '../../src/logic/ContentDeliveryManager'
 import { StreamMessage } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createStreamMessage } from '../utils/utils'
+import { randomUserId } from '@streamr/test-utils'
 
 const STREAM_PART = StreamPartIDUtils.parse('stream#0')
-const PUBLISHER_ID = randomEthereumAddress()
+const PUBLISHER_ID = randomUserId()
 
 const createMessage = (id: number): StreamMessage => {
     return createStreamMessage(`${id}`, STREAM_PART, PUBLISHER_ID)

package/test/unit/NodeList.test.ts

@@ -2,9 +2,9 @@ import {
     ListeningRpcCommunicator,
     NodeType,
     PeerDescriptor,
-    createRandomDhtAddress,
-    getDhtAddressFromRaw,
-    getNodeIdFromPeerDescriptor,
+    randomDhtAddress,
+    toDhtAddress,
+    toNodeId,
 } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { expect } from 'expect'
@@ -26,7 +26,7 @@ describe('NodeList', () => {
         new Uint8Array([1, 1, 4]),
         new Uint8Array([1, 1, 5])
     ]
-    const ownId = createRandomDhtAddress()
+    const ownId = randomDhtAddress()
     let nodeList: NodeList
 
     const createRemoteGraphNode = (peerDescriptor: PeerDescriptor) => {
@@ -57,7 +57,7 @@ describe('NodeList', () => {
         }
         const newNode = createRemoteGraphNode(newDescriptor)
         nodeList.add(newNode)
-        expect(nodeList.has(getNodeIdFromPeerDescriptor(newDescriptor))).toEqual(true)
+        expect(nodeList.has(toNodeId(newDescriptor))).toEqual(true)
 
         const newDescriptor2 = {
             nodeId: new Uint8Array([1, 2, 4]),
@@ -65,26 +65,26 @@ describe('NodeList', () => {
         }
         const newNode2 = createRemoteGraphNode(newDescriptor2)
         nodeList.add(newNode2)
-        expect(nodeList.has(getNodeIdFromPeerDescriptor(newDescriptor2))).toEqual(false)
+        expect(nodeList.has(toNodeId(newDescriptor2))).toEqual(false)
     })
 
     it('remove', () => {
         const toRemove = nodeList.getFirst([])
-        const nodeId = getNodeIdFromPeerDescriptor(toRemove!.getPeerDescriptor())
+        const nodeId = toNodeId(toRemove!.getPeerDescriptor())
         nodeList.remove(nodeId)
         expect(nodeList.has(nodeId)).toEqual(false)
     })
 
     it('getFirst', () => {
         const closest = nodeList.getFirst([])
-        expect(getNodeIdFromPeerDescriptor(closest!.getPeerDescriptor()))
-            .toEqual(getDhtAddressFromRaw(new Uint8Array([1, 1, 1])))
+        expect(toNodeId(closest!.getPeerDescriptor()))
+            .toEqual(toDhtAddress(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])))
+        const closest = nodeList.getFirst([toDhtAddress(new Uint8Array([1, 1, 1]))])
+        expect(toNodeId(closest!.getPeerDescriptor()))
+            .toEqual(toDhtAddress(new Uint8Array([1, 1, 2])))
     })
 
     it('getFirst wsOnly', () => {
@@ -95,14 +95,14 @@ describe('NodeList', () => {
 
     it('getLast', () => {
         const closest = nodeList.getLast([])
-        expect(getNodeIdFromPeerDescriptor(closest!.getPeerDescriptor()))
-            .toEqual(getDhtAddressFromRaw(new Uint8Array([1, 1, 5])))
+        expect(toNodeId(closest!.getPeerDescriptor()))
+            .toEqual(toDhtAddress(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])))
+        const closest = nodeList.getLast([toDhtAddress(new Uint8Array([1, 1, 5]))])
+        expect(toNodeId(closest!.getPeerDescriptor()))
+            .toEqual(toDhtAddress(new Uint8Array([1, 1, 4])))
     })
 
     it('getFirstAndLast', () => {
@@ -132,17 +132,17 @@ describe('NodeList', () => {
 
     it('getFirstAndLast with exclude', () => {
         const results = nodeList.getFirstAndLast([
-            getDhtAddressFromRaw(new Uint8Array([1, 1, 1])),
-            getDhtAddressFromRaw(new Uint8Array([1, 1, 5]))
+            toDhtAddress(new Uint8Array([1, 1, 1])),
+            toDhtAddress(new Uint8Array([1, 1, 5]))
         ])
         expect(results).toEqual([
-            nodeList.getFirst([getDhtAddressFromRaw(new Uint8Array([1, 1, 1]))]),
-            nodeList.getLast([getDhtAddressFromRaw(new Uint8Array([1, 1, 5]))])
+            nodeList.getFirst([toDhtAddress(new Uint8Array([1, 1, 1]))]),
+            nodeList.getLast([toDhtAddress(new Uint8Array([1, 1, 5]))])
         ])
     })
 
     it('items are in insertion order', () => {
-        const list = new NodeList(createRandomDhtAddress(), 100)
+        const list = new NodeList(randomDhtAddress(), 100)
         const item1 = createRemoteGraphNode(createMockPeerDescriptor())
         const item2 = createRemoteGraphNode(createMockPeerDescriptor())
         const item3 = createRemoteGraphNode(createMockPeerDescriptor())

package/test/unit/PeerDescriptorStoreManager.test.ts

@@ -1,11 +1,11 @@
-import { PeerDescriptor, areEqualPeerDescriptors, createRandomDhtAddress } from '@streamr/dht'
+import { PeerDescriptor, areEqualPeerDescriptors, randomDhtAddress } from '@streamr/dht'
 import { wait } from '@streamr/utils'
 import { PeerDescriptorStoreManager } from '../../src/logic/PeerDescriptorStoreManager'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { DataEntry } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
 
-const KEY = createRandomDhtAddress()
+const KEY = randomDhtAddress()
 
 describe('PeerDescriptorStoreManager', () => {
 

package/test/unit/Propagation.test.ts

@@ -1,3 +1,6 @@
+import { DhtAddress } from '@streamr/dht'
+import { hexToBinary, wait } from '@streamr/utils'
+import { Propagation } from '../../src/logic/propagation/Propagation'
 import {
     ContentType,
     EncryptionType,
@@ -5,11 +8,9 @@ import {
     SignatureType,
     StreamMessage
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
-import { Propagation } from '../../src/logic/propagation/Propagation'
-import { hexToBinary, toEthereumAddress, utf8ToBinary, wait } from '@streamr/utils'
-import { DhtAddress } from '@streamr/dht'
+import { randomUserId } from '@streamr/test-utils'
 
-const PUBLISHER_ID = toEthereumAddress('0x1111111111111111111111111111111111111111')
+const PUBLISHER_ID = randomUserId()
 
 function makeMsg(streamId: string, partition: number, ts: number, msgNo: number): StreamMessage {
     const messageId: MessageID = {
@@ -18,7 +19,7 @@ function makeMsg(streamId: string, partition: number, ts: number, msgNo: number)
         timestamp: ts,
         sequenceNumber: msgNo,
         messageChainId: 'msgChain',
-        publisherId: utf8ToBinary(PUBLISHER_ID)
+        publisherId: hexToBinary(PUBLISHER_ID)
     }
     return {
         messageId,

package/test/unit/ProxyConnectionRpcRemote.test.ts

@@ -1,5 +1,5 @@
 import { RpcCommunicator } from '@streamr/proto-rpc'
-import { randomEthereumAddress } from '@streamr/test-utils'
+import { randomUserId } from '@streamr/test-utils'
 import { hexToBinary } from '@streamr/utils'
 import { ProxyConnectionRpcRemote } from '../../src/logic/proxy/ProxyConnectionRpcRemote'
 import { ProxyConnectionRequest, ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
@@ -21,14 +21,14 @@ describe('ProxyConnectionRpcRemote', () => {
             ProxyConnectionRpcClient
         )
 
-        const userId = randomEthereumAddress()
+        const userId = randomUserId()
         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: Uint8Array.from(hexToBinary(userId))
+            userId: expect.toEqualBinary(hexToBinary(userId))
         })
         expect(callContext).toMatchObject({
             sourceDescriptor: clientPeerDescriptor,

package/test/unit/TemporaryConnectionRpcLocal.test.ts

@@ -1,4 +1,4 @@
-import { ListeningRpcCommunicator, getDhtAddressFromRaw } from '@streamr/dht'
+import { ListeningRpcCommunicator, toDhtAddress } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/utils'
 import { TemporaryConnectionRpcLocal } from '../../src/logic/temporary-connection/TemporaryConnectionRpcLocal'
 import { MockTransport } from '../utils/mock/MockTransport'
@@ -30,9 +30,9 @@ describe('TemporaryConnectionRpcLocal', () => {
     it('Open and Close Connection', async () => {
         const caller = createMockPeerDescriptor()
         await rpcLocal.openConnection({}, { incomingSourceDescriptor: caller } as any)
-        expect(rpcLocal.getNodes().get(getDhtAddressFromRaw(caller.nodeId))).toBeDefined()
+        expect(rpcLocal.getNodes().get(toDhtAddress(caller.nodeId))).toBeDefined()
         await rpcLocal.closeConnection({}, { incomingSourceDescriptor: caller } as any)
-        expect(rpcLocal.getNodes().get(getDhtAddressFromRaw(caller.nodeId))).toBeUndefined()
+        expect(rpcLocal.getNodes().get(toDhtAddress(caller.nodeId))).toBeUndefined()
     })
 
 })

package/test/utils/mock/MockControlLayerNode.ts

@@ -70,4 +70,9 @@ export class MockControlLayerNode extends EventEmitter<TransportEvents> implemen
     // eslint-disable-next-line class-methods-use-this
     async stop(): Promise<void> {
     }
+
+    // eslint-disable-next-line class-methods-use-this
+    getDiagnosticInfo(): Record<string, unknown> {
+        return {}
+    }
 }

package/test/utils/mock/MockTransport.ts

@@ -16,4 +16,15 @@ export class MockTransport extends EventEmitter<TransportEvents> implements ITra
     // eslint-disable-next-line class-methods-use-this
     stop(): void {
     }
+
+    // eslint-disable-next-line class-methods-use-this
+    getDiagnosticInfo(): Record<string, unknown> {
+        return {}
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+    enablePrivateClientMode(): void {
+
+    }
+
 }

package/test/utils/utils.ts

@@ -5,12 +5,12 @@ import {
     PeerDescriptor,
     Simulator,
     SimulatorTransport,
-    createRandomDhtAddress,
+    randomDhtAddress,
     getRandomRegion,
-    getRawFromDhtAddress
+    toDhtAddressRaw
 } from '@streamr/dht'
 import { RpcCommunicator } from '@streamr/proto-rpc'
-import { EthereumAddress, StreamPartID, StreamPartIDUtils, hexToBinary, utf8ToBinary } from '@streamr/utils'
+import { StreamPartID, StreamPartIDUtils, UserID, hexToBinary, utf8ToBinary } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
 import { ContentDeliveryLayerNode } from '../../src/logic/ContentDeliveryLayerNode'
 import { ContentDeliveryRpcRemote } from '../../src/logic/ContentDeliveryRpcRemote'
@@ -67,7 +67,7 @@ export const createMockContentDeliveryLayerNodeAndDhtNode = async (
 export const createStreamMessage = (
     content: string,
     streamPartId: StreamPartID,
-    publisherId: EthereumAddress,
+    publisherId: UserID,
     timestamp?: number,
     sequenceNumber?: number
 ): StreamMessage => {
@@ -98,7 +98,7 @@ export const createStreamMessage = (
 export const createMockPeerDescriptor = (opts?: Omit<Partial<PeerDescriptor>, 'nodeId' | 'type'>): PeerDescriptor => {
     return {
         ...opts,
-        nodeId: getRawFromDhtAddress(createRandomDhtAddress()),
+        nodeId: toDhtAddressRaw(randomDhtAddress()),
         type: NodeType.NODEJS,
         region: getRandomRegion()
     }

package/tsconfig.jest.json

@@ -1,7 +1,7 @@
 {
     "extends": "../../tsconfig.jest.json",
     "compilerOptions": {
-        "outDir": "dist",
+        "noEmit": true,
         "noImplicitOverride": false
     },
     "include": [

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "./tsconfig.jest.json"
+}