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

package/src/logic/proxy/ProxyConnectionRpcLocal.ts

@@ -9,12 +9,11 @@ import {
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { IProxyConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
-import { DhtCallContext, ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
+import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { EventEmitter } from 'eventemitter3'
 import { EthereumAddress, Logger, binaryToHex, toEthereumAddress } from '@streamr/utils'
 import { StreamPartID } from '@streamr/protocol'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 
@@ -31,13 +30,13 @@ interface ProxyConnectionRpcLocalConfig {
 }
 
 export interface Events {
-    newConnection: (nodeId: NodeID) => void
+    newConnection: (nodeId: DhtAddress) => void
 }
 
 export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IProxyConnectionRpc {
 
     private readonly config: ProxyConnectionRpcLocalConfig
-    private readonly connections: Map<NodeID, ProxyConnection> = new Map()
+    private readonly connections: Map<DhtAddress, ProxyConnection> = new Map()
 
     constructor(config: ProxyConnectionRpcLocalConfig) {
         super()
@@ -46,25 +45,25 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
             (msg: ProxyConnectionRequest, context) => this.requestConnection(msg, context))
     }
 
-    getConnection(nodeId: NodeID): ProxyConnection | undefined {
+    getConnection(nodeId: DhtAddress): ProxyConnection | undefined {
         return this.connections.get(nodeId)
     }
 
-    hasConnection(nodeId: NodeID): boolean {
+    hasConnection(nodeId: DhtAddress): boolean {
         return this.connections.has(nodeId)
     }
 
-    removeConnection(nodeId: NodeID): void {
+    removeConnection(nodeId: DhtAddress): void {
         this.connections.delete(nodeId)
     }
 
     stop(): void {
-        this.connections.forEach((connection) => connection.remote.leaveStreamPartNotice(false))
+        this.connections.forEach((connection) => connection.remote.leaveStreamPartNotice(this.config.streamPartId, false))
         this.connections.clear()
         this.removeAllListeners()
     }
 
-    getPropagationTargets(msg: StreamMessage): NodeID[] {
+    getPropagationTargets(msg: StreamMessage): DhtAddress[] {
         if (msg.messageType === StreamMessageType.GROUP_KEY_REQUEST) {
             try {
                 const recipientId = GroupKeyRequest.fromBinary(msg.content).recipientId
@@ -78,11 +77,11 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
         }
     }
 
-    private getNodeIdsForUserId(userId: EthereumAddress): NodeID[] {
+    private getNodeIdsForUserId(userId: EthereumAddress): DhtAddress[] {
         return Array.from(this.connections.keys()).filter((nodeId) => this.connections.get(nodeId)!.userId === userId)
     }
 
-    private getSubscribers(): NodeID[] {
+    private getSubscribers(): DhtAddress[] {
         return Array.from(this.connections.keys()).filter((key) => this.connections.get(key)!.direction === ProxyDirection.SUBSCRIBE)
     }
 
@@ -96,7 +95,6 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
             remote: new DeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 senderPeerDescriptor,
-                this.config.streamPartId,
                 this.config.rpcCommunicator,
                 DeliveryRpcClient
             )

package/src/logic/temporary-connection/TemporaryConnectionRpcLocal.ts

@@ -1,16 +1,13 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { TemporaryConnectionRequest, TemporaryConnectionResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ITemporaryConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { DhtCallContext, ListeningRpcCommunicator } from '@streamr/dht'
+import { DhtCallContext, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { NodeList } from '../NodeList'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
-import { StreamPartID } from '@streamr/protocol'
 
 interface TemporaryConnectionRpcLocalConfig {
-    streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
     localPeerDescriptor: PeerDescriptor
 } 
@@ -42,7 +39,6 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
         const remote = new DeliveryRpcRemote(
             this.config.localPeerDescriptor,
             sender,
-            this.config.streamPartId,
             this.config.rpcCommunicator,
             DeliveryRpcClient
         )

package/src/logic/temporary-connection/TemporaryConnectionRpcRemote.ts

@@ -1,6 +1,5 @@
-import { RpcRemote } from '@streamr/dht'
+import { RpcRemote, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { Logger } from '@streamr/utils'
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { TemporaryConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 
 const logger = new Logger(module)

package/src/proto/packages/dht/protos/DhtRpc.ts

@@ -189,10 +189,6 @@ export interface PingResponse {
  * @generated from protobuf message dht.LeaveNotice
  */
 export interface LeaveNotice {
-    /**
-     * @generated from protobuf field: string serviceId = 1;
-     */
-    serviceId: string;
 }
 /**
  * @generated from protobuf message dht.PeerDescriptor
@@ -334,6 +330,10 @@ export interface HandshakeRequest {
      * @generated from protobuf field: optional dht.PeerDescriptor targetPeerDescriptor = 2;
      */
     targetPeerDescriptor?: PeerDescriptor;
+    /**
+     * @generated from protobuf field: string version = 3;
+     */
+    version: string;
 }
 /**
  * @generated from protobuf message dht.HandshakeResponse
@@ -347,6 +347,10 @@ export interface HandshakeResponse {
      * @generated from protobuf field: optional dht.HandshakeError error = 2;
      */
     error?: HandshakeError;
+    /**
+     * @generated from protobuf field: string version = 3;
+     */
+    version: string;
 }
 /**
  * @generated from protobuf message dht.Message
@@ -615,7 +619,11 @@ export enum HandshakeError {
     /**
      * @generated from protobuf enum value: INVALID_TARGET_PEER_DESCRIPTOR = 1;
      */
-    INVALID_TARGET_PEER_DESCRIPTOR = 1
+    INVALID_TARGET_PEER_DESCRIPTOR = 1,
+    /**
+     * @generated from protobuf enum value: UNSUPPORTED_VERSION = 2;
+     */
+    UNSUPPORTED_VERSION = 2
 }
 // Wraps all messages
 
@@ -824,9 +832,7 @@ export const PingResponse = new PingResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class LeaveNotice$Type extends MessageType$<LeaveNotice> {
     constructor() {
-        super("dht.LeaveNotice", [
-            { no: 1, name: "serviceId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
-        ]);
+        super("dht.LeaveNotice", []);
     }
 }
 /**
@@ -928,7 +934,8 @@ class HandshakeRequest$Type extends MessageType$<HandshakeRequest> {
     constructor() {
         super("dht.HandshakeRequest", [
             { no: 1, name: "sourcePeerDescriptor", kind: "message", T: () => PeerDescriptor },
-            { no: 2, name: "targetPeerDescriptor", kind: "message", T: () => PeerDescriptor }
+            { no: 2, name: "targetPeerDescriptor", kind: "message", T: () => PeerDescriptor },
+            { no: 3, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
 }
@@ -941,7 +948,8 @@ class HandshakeResponse$Type extends MessageType$<HandshakeResponse> {
     constructor() {
         super("dht.HandshakeResponse", [
             { no: 1, name: "sourcePeerDescriptor", kind: "message", T: () => PeerDescriptor },
-            { no: 2, name: "error", kind: "enum", opt: true, T: () => ["dht.HandshakeError", HandshakeError] }
+            { no: 2, name: "error", kind: "enum", opt: true, T: () => ["dht.HandshakeError", HandshakeError] },
+            { no: 3, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
 }

package/test/benchmark/first-message.ts

@@ -1,12 +1,11 @@
 /* eslint-disable no-console */
 
-import { DhtNode, LatencyType, Simulator, getRandomRegion } from '@streamr/dht'
+import { DhtNode, LatencyType, Simulator, getNodeIdFromPeerDescriptor, getRandomRegion } from '@streamr/dht'
 import { MessageID, StreamMessage, StreamMessageType, StreamPartID, StreamPartIDUtils, toStreamID, toStreamPartID } from '@streamr/protocol'
 import { hexToBinary, utf8ToBinary, waitForEvent3 } from '@streamr/utils'
 import fs from 'fs'
 import { PeerDescriptor } from '@streamr/dht'
 import { NetworkNode } from '../../src/NetworkNode'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { streamPartIdToDataKey } from '../../src/logic/EntryPointDiscovery'
 import { createMockPeerDescriptor, createNetworkNodeWithSimulator } from '../utils/utils'
 import { Layer1Node } from '../../src/logic/Layer1Node'
@@ -52,7 +51,7 @@ const prepareStream = async (streamId: string) => {
 }
 
 const shutdownNetwork = async () => {
-    publishIntervals.map((interval) => clearInterval(interval))
+    publishIntervals.forEach((interval) => clearInterval(interval))
     await Promise.all([
         ...nodes.map((node) => node.stop())
     ])

package/test/end-to-end/proxy-connections.test.ts

@@ -2,11 +2,11 @@ import { MessageID, MessageRef, StreamMessage, StreamMessageType, StreamPartIDUt
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary, utf8ToBinary, wait, waitForCondition, waitForEvent3 } from '@streamr/utils'
 import { NetworkNode, createNetworkNode } from '../../src/NetworkNode'
-import { NodeID } from '../../src/identifiers'
 import { RandomGraphNode } from '../../src/logic/RandomGraphNode'
 import { ProxyClient } from '../../src/logic/proxy/ProxyClient'
 import { ProxyDirection } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { createMockPeerDescriptor } from '../utils/utils'
+import { DhtAddress } from '@streamr/dht'
 
 const PROXIED_NODE_USER_ID = randomEthereumAddress()
 const STREAM_PART_ID = StreamPartIDUtils.parse('proxy-test#0')
@@ -40,7 +40,7 @@ describe('Proxy connections', () => {
             : false
     }
     
-    const hasConnectionToProxy = (proxyNodeId: NodeID, direction: ProxyDirection): boolean => {
+    const hasConnectionToProxy = (proxyNodeId: DhtAddress, direction: ProxyDirection): boolean => {
         const client = (proxiedNode.stack.getStreamrNode()!.getStreamPartDelivery(STREAM_PART_ID) as { client: ProxyClient }).client
         return client.hasConnection(proxyNodeId, direction)
     }

package/test/end-to-end/webrtc-full-node-network.test.ts

@@ -1,10 +1,9 @@
-import { getRandomRegion } from '@streamr/dht'
+import { getNodeIdFromPeerDescriptor, getRandomRegion } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkStack } from '../../src/NetworkStack'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
 
 describe('Full node network with WebRTC connections', () => {

package/test/end-to-end/websocket-full-node-network.test.ts

@@ -3,8 +3,8 @@ import { randomEthereumAddress } from '@streamr/test-utils'
 import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { NetworkStack } from '../../src/NetworkStack'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { createMockPeerDescriptor, createStreamMessage } from '../utils/utils'
+import { getNodeIdFromPeerDescriptor } from '@streamr/dht'
 
 describe('Full node network with WebSocket connections only', () => {
 

package/test/integration/DeliveryRpcRemote.test.ts

@@ -17,8 +17,6 @@ import { createStreamMessage } from '../utils/utils'
 import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 
-const STREAM_PART_ID = StreamPartIDUtils.parse('test-stream#0')
-
 describe('DeliveryRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator
     let clientRpc: ListeningRpcCommunicator
@@ -71,7 +69,6 @@ describe('DeliveryRpcRemote', () => {
         rpcRemote = new DeliveryRpcRemote(
             clientNode,
             serverNode,
-            STREAM_PART_ID,
             clientRpc,
             DeliveryRpcClient
         )
@@ -88,7 +85,7 @@ describe('DeliveryRpcRemote', () => {
     it('sendStreamMessage', async () => {
         const msg = createStreamMessage(
             JSON.stringify({ hello: 'WORLD' }),
-            STREAM_PART_ID,
+            StreamPartIDUtils.parse('test-stream#0'),
             randomEthereumAddress()
         )
 
@@ -97,7 +94,7 @@ describe('DeliveryRpcRemote', () => {
     })
 
     it('leaveNotice', async () => {
-        rpcRemote.leaveStreamPartNotice(false)
+        rpcRemote.leaveStreamPartNotice(StreamPartIDUtils.parse('test#0'), false)
         await waitForCondition(() => recvCounter === 1)
     })
 

package/test/integration/HandshakeRpcRemote.test.ts

@@ -13,6 +13,7 @@ import {
     HandshakeRpcClient,
 } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
+import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('HandshakeRpcRemote', () => {
     let mockServerRpc: ListeningRpcCommunicator
@@ -58,7 +59,6 @@ describe('HandshakeRpcRemote', () => {
         rpcRemote = new HandshakeRpcRemote(
             clientNode,
             serverNode,
-            'test-stream-part',
             clientRpc,
             HandshakeRpcClient
         )
@@ -73,7 +73,7 @@ describe('HandshakeRpcRemote', () => {
     })
 
     it('handshake', async () => {
-        const result = await rpcRemote.handshake([])
+        const result = await rpcRemote.handshake(StreamPartIDUtils.parse('test#0'), [])
         expect(result.accepted).toEqual(true)
     })
 })

package/test/integration/Handshakes.test.ts

@@ -4,7 +4,8 @@ import {
     PeerDescriptor,
     ListeningRpcCommunicator,
     Simulator,
-    SimulatorTransport
+    SimulatorTransport,
+    getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
 import {
     HandshakeRpcClient
@@ -13,7 +14,6 @@ import { NodeList } from '../../src/logic/NodeList'
 import { mockConnectionLocker } from '../utils/utils'
 import { StreamPartHandshakeRequest, StreamPartHandshakeResponse } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
 import { HandshakeRpcRemote } from '../../src/logic/neighbor-discovery/HandshakeRpcRemote'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { StreamPartIDUtils } from '@streamr/protocol'
 
 describe('Handshakes', () => {
@@ -114,7 +114,6 @@ describe('Handshakes', () => {
             new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                streamPartId,
                 rpcCommunicator2,
                 HandshakeRpcClient
             )
@@ -130,7 +129,6 @@ describe('Handshakes', () => {
             new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                streamPartId,
                 rpcCommunicator2,
                 HandshakeRpcClient
             )
@@ -146,7 +144,6 @@ describe('Handshakes', () => {
             new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                streamPartId,
                 rpcCommunicator2,
                 HandshakeRpcClient
             )
@@ -163,7 +160,6 @@ describe('Handshakes', () => {
             new HandshakeRpcRemote(
                 peerDescriptor2,
                 peerDescriptor1,
-                streamPartId,
                 rpcCommunicator2,
                 HandshakeRpcClient
             )

package/test/integration/NeighborUpdateRpcRemote.test.ts

@@ -62,7 +62,6 @@ describe('NeighborUpdateRpcRemote', () => {
         rpcRemote = new NeighborUpdateRpcRemote(
             clientNode,
             serverNode,
-            'test-stream-part',
             clientRpc,
             NeighborUpdateRpcClient
         )
@@ -77,7 +76,7 @@ describe('NeighborUpdateRpcRemote', () => {
     })
 
     it('updateNeighbors', async () => {
-        const res = await rpcRemote.updateNeighbors([])
+        const res = await rpcRemote.updateNeighbors(StreamPartIDUtils.parse('test#0'), [])
         expect(res.peerDescriptors.length).toEqual(1)
     })
 })

package/test/unit/HandshakeRpcLocal.test.ts

@@ -1,6 +1,4 @@
-import { NodeType } from '@streamr/dht'
-import { hexToBinary } from '@streamr/utils'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { DhtAddress, NodeType, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '@streamr/dht'
 import { NodeList } from '../../src/logic/NodeList'
 import { HandshakeRpcLocal } from '../../src/logic/neighbor-discovery/HandshakeRpcLocal'
 import { InterleaveRequest, StreamPartHandshakeRequest } from '../../src/proto/packages/trackerless-network/protos/NetworkRpc'
@@ -16,8 +14,8 @@ describe('HandshakeRpcLocal', () => {
     const localPeerDescriptor = createMockPeerDescriptor()
 
     let targetNeighbors: NodeList
-    let ongoingHandshakes: Set<NodeID>
-    let ongoingInterleaves: Set<NodeID>
+    let ongoingHandshakes: Set<DhtAddress>
+    let ongoingInterleaves: Set<DhtAddress>
     let handshakeWithInterleaving: jest.Mock
 
     beforeEach(() => {
@@ -72,10 +70,10 @@ describe('HandshakeRpcLocal', () => {
     })
 
     it('unaccepted handshake', async () => {
-        ongoingHandshakes.add('0x2222' as NodeID)
-        ongoingHandshakes.add('0x3333' as NodeID)
-        ongoingHandshakes.add('0x4444' as NodeID)
-        ongoingHandshakes.add('0x5555' as NodeID)
+        ongoingHandshakes.add('0x2222' as DhtAddress)
+        ongoingHandshakes.add('0x3333' as DhtAddress)
+        ongoingHandshakes.add('0x4444' as DhtAddress)
+        ongoingHandshakes.add('0x5555' as DhtAddress)
         const req = StreamPartHandshakeRequest.create({
             streamPartId: STREAM_PART_ID,
             requestId: 'requestId'
@@ -89,7 +87,7 @@ describe('HandshakeRpcLocal', () => {
     it('handshakeWithInterleaving success', async () => {
         const req: InterleaveRequest = {
             interleaveTargetDescriptor: {
-                nodeId: hexToBinary('0x2222'),
+                nodeId: getRawFromDhtAddress('0x2222' as DhtAddress),
                 type: NodeType.NODEJS
             }
         }
@@ -102,7 +100,7 @@ describe('HandshakeRpcLocal', () => {
     it('handshakeWithInterleaving success', async () => {
         const req: InterleaveRequest = {
             interleaveTargetDescriptor: {
-                nodeId: hexToBinary('0x2222'),
+                nodeId: getRawFromDhtAddress('0x2222' as DhtAddress),
                 type: NodeType.NODEJS
             }
         }

package/test/unit/Handshaker.test.ts

@@ -1,6 +1,5 @@
-import { ListeningRpcCommunicator, Simulator, SimulatorTransport } from '@streamr/dht'
+import { ListeningRpcCommunicator, Simulator, SimulatorTransport, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { range } from 'lodash'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { NodeList } from '../../src/logic/NodeList'
 import { Handshaker } from '../../src/logic/neighbor-discovery/Handshaker'
 import { createMockPeerDescriptor, createMockDeliveryRpcRemote, mockConnectionLocker } from '../utils/utils'

package/test/unit/InspectSession.test.ts

@@ -2,14 +2,14 @@ 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 { NodeID } from '../../src/identifiers'
 import { createRandomNodeId } from '../utils/utils'
+import { DhtAddress } from '@streamr/dht'
 
 describe('InspectSession', () => {
 
     let inspectSession: InspectSession
-    let inspectedNode: NodeID
-    let anotherNode: NodeID
+    let inspectedNode: DhtAddress
+    let anotherNode: DhtAddress
 
     const publisherId = utf8ToBinary('publisherId')
     const messageId1: MessageID = {

package/test/unit/Inspector.test.ts

@@ -1,6 +1,5 @@
-import { ListeningRpcCommunicator } from '@streamr/dht'
+import { ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { utf8ToBinary } from '@streamr/utils'
-import { getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { Inspector } from '../../src/logic/inspect/Inspector'
 import { MockTransport } from '../utils/mock/Transport'
 import { createMockPeerDescriptor, createRandomNodeId, mockConnectionLocker } from '../utils/utils'

package/test/unit/NeighborFinder.test.ts

@@ -4,7 +4,7 @@ import { waitForCondition } from '@streamr/utils'
 import { range } from 'lodash'
 import { expect } from 'expect'
 import { createMockDeliveryRpcRemote, createRandomNodeId } from '../utils/utils'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 
 describe('NeighborFinder', () => {
 
@@ -19,7 +19,7 @@ describe('NeighborFinder', () => {
         targetNeighbors = new NodeList(nodeId, 15)
         nearbyNodeView = new NodeList(nodeId, 30)
         range(30).forEach(() => nearbyNodeView.add(createMockDeliveryRpcRemote()))
-        const mockDoFindNeighbors = async (excluded: NodeID[]) => {
+        const mockDoFindNeighbors = async (excluded: DhtAddress[]) => {
             const target = nearbyNodeView.getRandom(excluded)
             if (Math.random() < 0.5) {
                 targetNeighbors.add(target!)

package/test/unit/NodeList.test.ts

@@ -4,11 +4,11 @@ import {
     PeerDescriptor,
     Simulator,
     SimulatorTransport,
+    getDhtAddressFromRaw,
+    getNodeIdFromPeerDescriptor,
 } from '@streamr/dht'
 import { StreamPartIDUtils } from '@streamr/protocol'
-import { binaryToHex } from '@streamr/utils'
 import { expect } from 'expect'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../src/identifiers'
 import { DeliveryRpcRemote } from '../../src/logic/DeliveryRpcRemote'
 import { NodeList } from '../../src/logic/NodeList'
 import { formStreamPartDeliveryServiceId } from '../../src/logic/formStreamPartDeliveryServiceId'
@@ -39,7 +39,6 @@ describe('NodeList', () => {
         return new DeliveryRpcRemote(
             createMockPeerDescriptor(),
             peerDescriptor,
-            streamPartId,
             mockCommunicator,
             DeliveryRpcClient
         )
@@ -100,25 +99,25 @@ describe('NodeList', () => {
     it('getClosest', () => {
         const closest = nodeList.getClosest([])
         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])
+        const closest = nodeList.getClosest([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([])
         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])
+        const closest = nodeList.getFurthest([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', () => {
@@ -148,12 +147,12 @@ describe('NodeList', () => {
 
     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
+            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.getClosest([getDhtAddressFromRaw(new Uint8Array([1, 1, 1]))]),
+            nodeList.getFurthest([getDhtAddressFromRaw(new Uint8Array([1, 1, 5]))])
         ])
     })
 })

package/test/unit/Propagation.test.ts

@@ -7,7 +7,7 @@ import {
 } 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 { DhtAddress } from '@streamr/dht'
 
 const PUBLISHER_ID = toEthereumAddress('0x1111111111111111111111111111111111111111')
 
@@ -32,15 +32,15 @@ function makeMsg(streamId: string, partition: number, ts: number, msgNo: number)
 
 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 +80,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,5 +1,4 @@
 import { RpcCommunicator } from '@streamr/proto-rpc'
-import { StreamPartIDUtils } from '@streamr/protocol'
 import { randomEthereumAddress } from '@streamr/test-utils'
 import { hexToBinary } from '@streamr/utils'
 import { ProxyConnectionRpcRemote } from '../../src/logic/proxy/ProxyConnectionRpcRemote'
@@ -18,7 +17,6 @@ describe('ProxyConnectionRpcRemote', () => {
         const rpcRemote = new ProxyConnectionRpcRemote(
             clientPeerDescriptor,
             serverPeerDescriptor,
-            StreamPartIDUtils.parse('stream#0'),
             rpcCommunicator,
             ProxyConnectionRpcClient
         )

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,6 +9,7 @@ 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', () => {