@streamr/trackerless-network 100.0.0-testnet-two.1 → 100.0.0-testnet-two.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamr/trackerless-network",
-  "version": "100.0.0-testnet-two.1",
+  "version": "100.0.0-testnet-two.3",
   "description": "Minimal and extendable implementation of the Streamr Network node.",
   "repository": {
     "type": "git",
@@ -30,11 +30,11 @@
   "dependencies": {
     "@protobuf-ts/runtime": "^2.8.2",
     "@protobuf-ts/runtime-rpc": "^2.8.2",
-    "@streamr/dht": "100.0.0-testnet-two.1",
-    "@streamr/proto-rpc": "100.0.0-testnet-two.1",
-    "@streamr/protocol": "100.0.0-testnet-two.1",
-    "@streamr/test-utils": "100.0.0-testnet-two.1",
-    "@streamr/utils": "100.0.0-testnet-two.1",
+    "@streamr/dht": "100.0.0-testnet-two.3",
+    "@streamr/proto-rpc": "100.0.0-testnet-two.3",
+    "@streamr/protocol": "100.0.0-testnet-two.3",
+    "@streamr/test-utils": "100.0.0-testnet-two.3",
+    "@streamr/utils": "100.0.0-testnet-two.3",
     "eventemitter3": "^5.0.0",
     "lodash": "^4.17.21",
     "uuid": "^9.0.1",

package/src/NetworkNode.ts

@@ -1,10 +1,9 @@
 import { StreamMessage, StreamPartID } from '@streamr/protocol'
-import { PeerDescriptor } from '@streamr/dht'
+import { DhtAddress, PeerDescriptor } from '@streamr/dht'
 import { StreamMessageTranslator } from './logic/protocol-integration/stream-message/StreamMessageTranslator'
 import { NetworkOptions, NetworkStack } from './NetworkStack'
 import { EthereumAddress, Logger, MetricsContext } from '@streamr/utils'
 import { ProxyDirection } from './proto/packages/trackerless-network/protos/NetworkRpc'
-import { NodeID } from './identifiers'
 import { pull } from 'lodash'
 
 export const createNetworkNode = (opts: NetworkOptions): NetworkNode => {
@@ -88,7 +87,7 @@ export class NetworkNode {
         await this.stack.getStreamrNode().leaveStreamPart(streamPartId)
     }
 
-    getNeighbors(streamPartId: StreamPartID): ReadonlyArray<NodeID> {
+    getNeighbors(streamPartId: StreamPartID): ReadonlyArray<DhtAddress> {
         return this.stack.getStreamrNode().getNeighbors(streamPartId)
     }
 
@@ -109,7 +108,7 @@ export class NetworkNode {
         return this.stack.getMetricsContext()
     }
 
-    getNodeId(): NodeID {
+    getNodeId(): DhtAddress {
         return this.stack.getStreamrNode().getNodeId()
     }
 

package/src/NetworkStack.ts

@@ -107,8 +107,8 @@ export class NetworkStack {
                     await this.layer0Node?.joinDht(this.options.layer0.entryPoints)
                 }
             })
+            await this.layer0Node!.waitForNetworkConnectivity()
         }
-        await this.layer0Node!.waitForNetworkConnectivity()
     }
 
     getStreamrNode(): StreamrNode {

package/src/exports.ts

@@ -1,5 +1,4 @@
 export { NetworkStack, NetworkOptions } from './NetworkStack'
 export { NetworkNode, createNetworkNode } from './NetworkNode'
 export { StreamrNodeConfig } from './logic/StreamrNode'
-export { NodeID } from './identifiers'
 export { ProxyDirection } from './proto/packages/trackerless-network/protos/NetworkRpc'

package/src/logic/DeliveryRpcLocal.ts

@@ -1,4 +1,4 @@
-import { ListeningRpcCommunicator, PeerDescriptor, DhtCallContext } from '@streamr/dht'
+import { ListeningRpcCommunicator, PeerDescriptor, DhtCallContext, DhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { Empty } from '../proto/google/protobuf/empty'
 import {
     LeaveStreamPartNotice,
@@ -8,16 +8,15 @@ import {
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
 import { IDeliveryRpc } from '../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../identifiers'
 import { StreamPartID } from '@streamr/protocol'
 
 export interface DeliveryRpcLocalConfig {
     localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     markAndCheckDuplicate: (messageId: MessageID, previousMessageRef?: MessageRef) => boolean
-    broadcast: (message: StreamMessage, previousNode?: NodeID) => void
-    onLeaveNotice(senderId: NodeID, isLocalNodeEntryPoint: boolean): void
-    markForInspection(senderId: NodeID, messageId: MessageID): void
+    broadcast: (message: StreamMessage, previousNode?: DhtAddress) => void
+    onLeaveNotice(senderId: DhtAddress, isLocalNodeEntryPoint: boolean): void
+    markForInspection(senderId: DhtAddress, messageId: MessageID): void
     rpcCommunicator: ListeningRpcCommunicator
 }
 

package/src/logic/DeliveryRpcRemote.ts

@@ -5,6 +5,7 @@ import {
     StreamMessage
 } from '../proto/packages/trackerless-network/protos/NetworkRpc'
 import { DeliveryRpcClient } from '../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { StreamPartID } from '@streamr/protocol'
 
 const logger = new Logger(module)
 
@@ -19,9 +20,9 @@ export class DeliveryRpcRemote extends RpcRemote<DeliveryRpcClient> {
         })
     }
 
-    leaveStreamPartNotice(isLocalNodeEntryPoint: boolean): void {
+    leaveStreamPartNotice(streamPartId: StreamPartID, isLocalNodeEntryPoint: boolean): void {
         const notification: LeaveStreamPartNotice = {
-            streamPartId: this.getServiceId(),
+            streamPartId,
             isEntryPoint: isLocalNodeEntryPoint
         }
         const options = this.formDhtRpcOptions({

package/src/logic/EntryPointDiscovery.ts

@@ -1,17 +1,19 @@
 import {
     DataEntry,
+    DhtAddress,
     PeerDescriptor,
-    areEqualPeerDescriptors
+    areEqualPeerDescriptors,
+    getDhtAddressFromRaw,
+    getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
 import { StreamPartID } from '@streamr/protocol'
 import { Logger, scheduleAtInterval, wait } from '@streamr/utils'
 import { createHash } from 'crypto'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../identifiers'
 import { Any } from '../proto/google/protobuf/any'
 import { Layer1Node } from './Layer1Node'
 
-export const streamPartIdToDataKey = (streamPartId: StreamPartID): Uint8Array => {
-    return new Uint8Array(createHash('md5').update(streamPartId).digest())
+export const streamPartIdToDataKey = (streamPartId: StreamPartID): DhtAddress => {
+    return getDhtAddressFromRaw(new Uint8Array(createHash('md5').update(streamPartId).digest()))
 }
 
 const parseEntryPointData = (dataEntries: DataEntry[]): PeerDescriptor[] => {
@@ -58,9 +60,9 @@ interface EntryPointDiscoveryConfig {
     streamPartId: StreamPartID
     localPeerDescriptor: PeerDescriptor
     layer1Node: Layer1Node
-    getEntryPointData: (key: Uint8Array) => Promise<DataEntry[]>
-    storeEntryPointData: (key: Uint8Array, data: Any) => Promise<PeerDescriptor[]>
-    deleteEntryPointData: (key: Uint8Array) => Promise<void>
+    getEntryPointData: (key: DhtAddress) => Promise<DataEntry[]>
+    storeEntryPointData: (key: DhtAddress, data: Any) => Promise<PeerDescriptor[]>
+    deleteEntryPointData: (key: DhtAddress) => Promise<void>
     storeInterval?: number
 }
 
@@ -68,7 +70,7 @@ export class EntryPointDiscovery {
     private readonly abortController: AbortController
     private readonly config: EntryPointDiscoveryConfig
     private readonly storeInterval: number
-    private readonly networkSplitAvoidedNodes: Set<NodeID> = new Set()
+    private readonly networkSplitAvoidedNodes: Set<DhtAddress> = new Set()
     private isLocalNodeStoredAsEntryPoint = false
     constructor(config: EntryPointDiscoveryConfig) {
         this.config = config
@@ -106,7 +108,7 @@ export class EntryPointDiscovery {
         }
     }
 
-    private async queryEntrypoints(key: Uint8Array): Promise<PeerDescriptor[]> {
+    private async queryEntrypoints(key: DhtAddress): Promise<PeerDescriptor[]> {
         logger.trace(`Finding data from dht node ${getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)}`)
         try {
             const result = await this.config.getEntryPointData(key)

package/src/logic/Layer0Node.ts

@@ -1,13 +1,13 @@
-import { DataEntry, ITransport, PeerDescriptor } from '@streamr/dht'
+import { DataEntry, DhtAddress, ITransport, PeerDescriptor } from '@streamr/dht'
 import { Any } from '../proto/google/protobuf/any'
 
 export interface Layer0Node extends ITransport {
     joinDht(entryPointDescriptors: PeerDescriptor[]): Promise<void>
     hasJoined(): boolean
     getLocalPeerDescriptor(): PeerDescriptor
-    getDataFromDht(key: Uint8Array): Promise<DataEntry[]>
-    storeDataToDht(key: Uint8Array, data: Any): Promise<PeerDescriptor[]>
-    deleteDataFromDht(key: Uint8Array, waitForCompletion: boolean): Promise<void>
+    getDataFromDht(key: DhtAddress): Promise<DataEntry[]>
+    storeDataToDht(key: DhtAddress, data: Any): Promise<PeerDescriptor[]>
+    deleteDataFromDht(key: DhtAddress, waitForCompletion: boolean): Promise<void>
     waitForNetworkConnectivity(): Promise<void>
     getTransport(): ITransport
     start(): Promise<void>

package/src/logic/NodeList.ts

@@ -1,25 +1,24 @@
-import { PeerDescriptor } from '@streamr/dht'
+import { DhtAddress, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { sample } from 'lodash'
 import { DeliveryRpcRemote } from './DeliveryRpcRemote'
 import { EventEmitter } from 'eventemitter3'
-import { getNodeIdFromPeerDescriptor, NodeID } from '../identifiers'
 
 export interface Events {
-    nodeAdded: (id: NodeID, remote: DeliveryRpcRemote) => any
+    nodeAdded: (id: DhtAddress, remote: DeliveryRpcRemote) => any
 }
 
-const getValuesOfIncludedKeys = (nodes: Map<NodeID, DeliveryRpcRemote>, exclude: NodeID[]): DeliveryRpcRemote[] => {
+const getValuesOfIncludedKeys = (nodes: Map<DhtAddress, DeliveryRpcRemote>, exclude: DhtAddress[]): DeliveryRpcRemote[] => {
     return Array.from(nodes.entries())
         .filter(([id, _node]) => !exclude.includes(id))
         .map(([_id, node]) => node)
 }
 
 export class NodeList extends EventEmitter<Events> {
-    private readonly nodes: Map<NodeID, DeliveryRpcRemote>
+    private readonly nodes: Map<DhtAddress, DeliveryRpcRemote>
     private readonly limit: number
-    private ownId: NodeID
+    private ownId: DhtAddress
 
-    constructor(ownId: NodeID, limit: number) {
+    constructor(ownId: DhtAddress, limit: number) {
         super()
         this.nodes = new Map()
         this.limit = limit
@@ -42,7 +41,7 @@ export class NodeList extends EventEmitter<Events> {
         this.nodes.delete(getNodeIdFromPeerDescriptor(peerDescriptor))
     }
 
-    removeById(nodeId: NodeID): void {
+    removeById(nodeId: DhtAddress): void {
         this.nodes.delete(nodeId)
     }
 
@@ -50,7 +49,7 @@ export class NodeList extends EventEmitter<Events> {
         return this.nodes.has(getNodeIdFromPeerDescriptor(peerDescriptor))
     }
 
-    hasNodeById(nodeId: NodeID): boolean {
+    hasNodeById(nodeId: DhtAddress): boolean {
         return this.nodes.has(nodeId)
     }
 
@@ -62,28 +61,28 @@ export class NodeList extends EventEmitter<Events> {
         })
     }
 
-    getIds(): NodeID[] {
+    getIds(): DhtAddress[] {
         return Array.from(this.nodes.keys())
     }
 
-    get(id: NodeID): DeliveryRpcRemote | undefined {
+    get(id: DhtAddress): DeliveryRpcRemote | undefined {
         return this.nodes.get(id)
     }
 
-    size(exclude: NodeID[] = []): number {
+    size(exclude: DhtAddress[] = []): number {
         return Array.from(this.nodes.keys()).filter((node) => !exclude.includes(node)).length
     }
 
-    getRandom(exclude: NodeID[]): DeliveryRpcRemote | undefined {
+    getRandom(exclude: DhtAddress[]): DeliveryRpcRemote | undefined {
         return sample(getValuesOfIncludedKeys(this.nodes, exclude))
     }
 
-    getClosest(exclude: NodeID[]): DeliveryRpcRemote | undefined {
+    getClosest(exclude: DhtAddress[]): DeliveryRpcRemote | undefined {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         return included[0]
     }
 
-    getClosestAndFurthest(exclude: NodeID[]): DeliveryRpcRemote[] {
+    getClosestAndFurthest(exclude: DhtAddress[]): DeliveryRpcRemote[] {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         if (included.length === 0) {
             return []
@@ -91,7 +90,7 @@ export class NodeList extends EventEmitter<Events> {
         return included.length > 1 ? [this.getClosest(exclude)!, this.getFurthest(exclude)!] : [this.getClosest(exclude)!]
     }
 
-    getFurthest(exclude: NodeID[]): DeliveryRpcRemote | undefined {
+    getFurthest(exclude: DhtAddress[]): DeliveryRpcRemote | undefined {
         const included = getValuesOfIncludedKeys(this.nodes, exclude)
         return included[included.length - 1]
     }

package/src/logic/RandomGraphNode.ts

@@ -3,7 +3,9 @@ import {
     PeerDescriptor,
     ListeningRpcCommunicator,
     ITransport,
-    ConnectionLocker
+    ConnectionLocker,
+    DhtAddress,
+    getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
 import {
     StreamMessage,
@@ -28,14 +30,13 @@ import { ProxyConnectionRpcLocal } from './proxy/ProxyConnectionRpcLocal'
 import { Inspector } from './inspect/Inspector'
 import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'
 import { markAndCheckDuplicate } from './utils'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../identifiers'
 import { Layer1Node } from './Layer1Node'
 import { StreamPartID } from '@streamr/protocol'
 import { uniqBy } from 'lodash'
 
 export interface Events {
     message: (message: StreamMessage) => void
-    targetNeighborConnected: (nodeId: NodeID) => void
+    targetNeighborConnected: (nodeId: DhtAddress) => void
     entryPointLeaveDetected: () => void
 }
 
@@ -82,8 +83,8 @@ export class RandomGraphNode extends EventEmitter<Events> {
             streamPartId: this.config.streamPartId,
             rpcCommunicator: this.config.rpcCommunicator,
             markAndCheckDuplicate: (msg: MessageID, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
-            broadcast: (message: StreamMessage, previousNode?: NodeID) => this.broadcast(message, previousNode),
-            onLeaveNotice: (sourceId: NodeID, sourceIsStreamEntryPoint: boolean) => {
+            broadcast: (message: StreamMessage, previousNode?: DhtAddress) => this.broadcast(message, previousNode),
+            onLeaveNotice: (sourceId: DhtAddress, sourceIsStreamEntryPoint: boolean) => {
                 if (this.abortController.signal.aborted) {
                     return
                 }
@@ -104,7 +105,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
                     this.emit('entryPointLeaveDetected')
                 }
             },
-            markForInspection: (senderId: NodeID, messageId: MessageID) => this.config.inspector.markMessage(senderId, messageId)
+            markForInspection: (senderId: DhtAddress, messageId: MessageID) => this.config.inspector.markMessage(senderId, messageId)
         })
     }
 
@@ -154,7 +155,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
             addManagedEventListener(
                 this.config.proxyConnectionRpcLocal,
                 'newConnection',
-                (id: NodeID) => this.config.propagation.onNeighborJoined(id),
+                (id: DhtAddress) => this.config.propagation.onNeighborJoined(id),
                 this.abortController.signal
             )
         }
@@ -199,7 +200,6 @@ export class RandomGraphNode extends EventEmitter<Events> {
             new DeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 descriptor,
-                this.config.streamPartId,
                 this.config.rpcCommunicator,
                 DeliveryRpcClient,
                 this.config.rpcRequestTimeout
@@ -213,7 +213,6 @@ export class RandomGraphNode extends EventEmitter<Events> {
                 new DeliveryRpcRemote(
                     this.config.localPeerDescriptor,
                     descriptor,
-                    this.config.streamPartId,
                     this.config.rpcCommunicator,
                     DeliveryRpcClient,
                     this.config.rpcRequestTimeout
@@ -231,7 +230,6 @@ export class RandomGraphNode extends EventEmitter<Events> {
             new DeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 descriptor,
-                this.config.streamPartId,
                 this.config.rpcCommunicator,
                 DeliveryRpcClient,
                 this.config.rpcRequestTimeout
@@ -251,7 +249,6 @@ export class RandomGraphNode extends EventEmitter<Events> {
             new DeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 descriptor,
-                this.config.streamPartId,
                 this.config.rpcCommunicator,
                 DeliveryRpcClient,
                 this.config.rpcRequestTimeout
@@ -279,7 +276,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
         return uniqBy(nodes, (p) => getNodeIdFromPeerDescriptor(p))
     }
 
-    hasProxyConnection(nodeId: NodeID): boolean {
+    hasProxyConnection(nodeId: DhtAddress): boolean {
         if (this.config.proxyConnectionRpcLocal) {
             return this.config.proxyConnectionRpcLocal.hasConnection(nodeId)
         }
@@ -292,7 +289,9 @@ export class RandomGraphNode extends EventEmitter<Events> {
         }
         this.abortController.abort()
         this.config.proxyConnectionRpcLocal?.stop()
-        this.config.targetNeighbors.getAll().map((remote) => remote.leaveStreamPartNotice(this.config.isLocalNodeEntryPoint()))
+        this.config.targetNeighbors.getAll().map(
+            (remote) => remote.leaveStreamPartNotice(this.config.streamPartId, this.config.isLocalNodeEntryPoint())
+        )
         this.config.rpcCommunicator.destroy()
         this.removeAllListeners()
         this.config.nearbyNodeView.stop()
@@ -303,7 +302,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
         this.config.inspector.stop()
     }
 
-    broadcast(msg: StreamMessage, previousNode?: NodeID): void {
+    broadcast(msg: StreamMessage, previousNode?: DhtAddress): void {
         if (!previousNode) {
             markAndCheckDuplicate(this.duplicateDetectors, msg.messageId!, msg.previousMessageRef)
         }
@@ -315,7 +314,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
         return this.config.inspector.inspect(peerDescriptor)
     }
 
-    private getPropagationTargets(msg: StreamMessage): NodeID[] {
+    private getPropagationTargets(msg: StreamMessage): DhtAddress[] {
         let propagationTargets = this.config.targetNeighbors.getIds()
         if (this.config.proxyConnectionRpcLocal) {
             propagationTargets = propagationTargets.concat(this.config.proxyConnectionRpcLocal.getPropagationTargets(msg))
@@ -325,7 +324,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
         return propagationTargets
     }
 
-    getOwnNodeId(): NodeID {
+    getOwnNodeId(): DhtAddress {
         return getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
     }
 
@@ -333,7 +332,7 @@ export class RandomGraphNode extends EventEmitter<Events> {
         return this.config.handshaker.getOngoingHandshakes().size
     }
 
-    getTargetNeighborIds(): NodeID[] {
+    getTargetNeighborIds(): DhtAddress[] {
         if (!this.started && this.isStopped()) {
             return []
         }

package/src/logic/StreamrNode.ts

@@ -3,7 +3,9 @@ import {
     DhtNode,
     ITransport,
     PeerDescriptor,
-    EXISTING_CONNECTION_TIMEOUT
+    EXISTING_CONNECTION_TIMEOUT,
+    DhtAddress,
+    getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
 import { StreamID, StreamPartID, StreamPartIDUtils, toStreamPartID } from '@streamr/protocol'
 import {
@@ -16,7 +18,6 @@ import {
 } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { sampleSize } from 'lodash'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../identifiers'
 import { ProxyDirection, StreamMessage } from '../proto/packages/trackerless-network/protos/NetworkRpc'
 import { Layer0Node } from './Layer0Node'
 import { Layer1Node } from './Layer1Node'
@@ -109,6 +110,7 @@ export class StreamrNode extends EventEmitter<Events> {
 
     broadcast(msg: StreamMessage): void {
         const streamPartId = toStreamPartID(msg.messageId!.streamId as StreamID, msg.messageId!.streamPartition)
+        logger.debug(`Broadcasting to stream part ${streamPartId}`)
         this.joinStreamPart(streamPartId)
         this.streamParts.get(streamPartId)!.broadcast(msg)
         this.metrics.broadcastMessagesPerSecond.record(1)
@@ -124,11 +126,11 @@ export class StreamrNode extends EventEmitter<Events> {
     }
 
     joinStreamPart(streamPartId: StreamPartID): void {
-        logger.debug(`Join stream part ${streamPartId}`)
         let streamPart = this.streamParts.get(streamPartId)
         if (streamPart !== undefined) {
             return
         }
+        logger.debug(`Join stream part ${streamPartId}`)
         const layer1Node = this.createLayer1Node(streamPartId, this.knownStreamPartEntryPoints.get(streamPartId) ?? [])
         const entryPointDiscovery = new EntryPointDiscovery({
             streamPartId,
@@ -136,7 +138,7 @@ export class StreamrNode extends EventEmitter<Events> {
             layer1Node,
             getEntryPointData: (key) => this.layer0Node!.getDataFromDht(key),
             storeEntryPointData: (key, data) => this.layer0Node!.storeDataToDht(key, data),
-            deleteEntryPointData: async (key: Uint8Array) => this.layer0Node!.deleteDataFromDht(key, false)
+            deleteEntryPointData: async (key) => this.layer0Node!.deleteDataFromDht(key, false)
         })
         const node = this.createRandomGraphNode(
             streamPartId,
@@ -305,11 +307,11 @@ export class StreamrNode extends EventEmitter<Events> {
         return this.layer0Node!.getLocalPeerDescriptor()
     }
 
-    getNodeId(): NodeID {
+    getNodeId(): DhtAddress {
         return getNodeIdFromPeerDescriptor(this.layer0Node!.getLocalPeerDescriptor())
     }
 
-    getNeighbors(streamPartId: StreamPartID): NodeID[] {
+    getNeighbors(streamPartId: StreamPartID): DhtAddress[] {
         const streamPart = this.streamParts.get(streamPartId)
         return (streamPart !== undefined) && (streamPart.proxied === false)
             ? streamPart.node.getTargetNeighborIds()

package/src/logic/createRandomGraphNode.ts

@@ -1,4 +1,4 @@
-import { ListeningRpcCommunicator } from '@streamr/dht'
+import { DhtAddress, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { Handshaker } from './neighbor-discovery/Handshaker'
 import { NeighborFinder } from './neighbor-discovery/NeighborFinder'
 import { NeighborUpdateManager } from './neighbor-discovery/NeighborUpdateManager'
@@ -10,7 +10,6 @@ import { MarkOptional } from 'ts-essentials'
 import { ProxyConnectionRpcLocal } from './proxy/ProxyConnectionRpcLocal'
 import { Inspector } from './inspect/Inspector'
 import { TemporaryConnectionRpcLocal } from './temporary-connection/TemporaryConnectionRpcLocal'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../identifiers'
 import { formStreamPartDeliveryServiceId } from './formStreamPartDeliveryServiceId'
 
 type RandomGraphNodeConfig = MarkOptional<StrictRandomGraphNodeConfig,
@@ -40,7 +39,6 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     const targetNeighbors = config.targetNeighbors ?? new NodeList(ownNodeId, maxNumberOfContacts)
 
     const temporaryConnectionRpcLocal = new TemporaryConnectionRpcLocal({
-        streamPartId: config.streamPartId,
         rpcCommunicator,
         localPeerDescriptor: config.localPeerDescriptor
     })
@@ -51,7 +49,7 @@ const createConfigWithDefaults = (config: RandomGraphNodeConfig): StrictRandomGr
     }) : undefined
     const propagation = config.propagation ?? new Propagation({
         minPropagationTargets,
-        sendToNeighbor: async (neighborId: NodeID, msg: StreamMessage): Promise<void> => {
+        sendToNeighbor: async (neighborId: DhtAddress, msg: StreamMessage): Promise<void> => {
             const remote = targetNeighbors.get(neighborId) ?? temporaryConnectionRpcLocal.getNodes().get(neighborId)
             const proxyConnection = proxyConnectionRpcLocal?.getConnection(neighborId)
             if (remote) {

package/src/logic/inspect/InspectSession.ts

@@ -1,14 +1,14 @@
 import { EventEmitter } from 'eventemitter3'
-import { NodeID } from '../../identifiers'
 import { MessageID } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { binaryToHex } from '@streamr/utils'
+import { DhtAddress } from '@streamr/dht'
 
 export interface Events {
     done: () => void
 }
 
 interface InspectSessionConfig {
-    inspectedNode: NodeID
+    inspectedNode: DhtAddress
 }
 
 const createMessageKey = (messageId: MessageID): string => {
@@ -18,14 +18,14 @@ export class InspectSession extends EventEmitter<Events> {
     
     // Boolean indicates if the message has been received by the inspected node
     private readonly inspectionMessages: Map<string, boolean> = new Map()
-    private readonly inspectedNode: NodeID
+    private readonly inspectedNode: DhtAddress
 
     constructor(config: InspectSessionConfig) {
         super()
         this.inspectedNode = config.inspectedNode
     }
 
-    markMessage(senderId: NodeID, messageId: MessageID): void {
+    markMessage(senderId: DhtAddress, messageId: MessageID): void {
         const messageKey = createMessageKey(messageId)
         if (!this.inspectionMessages.has(messageKey)) {
             this.inspectionMessages.set(messageKey, senderId === this.inspectedNode)

package/src/logic/inspect/Inspector.ts

@@ -1,11 +1,10 @@
-import { PeerDescriptor, ConnectionLocker, LockID } from '@streamr/dht'
+import { PeerDescriptor, ConnectionLocker, LockID, DhtAddress, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { MessageID } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { InspectSession, Events as InspectSessionEvents } from './InspectSession'
 import { TemporaryConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { RpcCommunicator } from '@streamr/proto-rpc'
 import { Logger, waitForEvent3 } from '@streamr/utils'
 import { TemporaryConnectionRpcRemote } from '../temporary-connection/TemporaryConnectionRpcRemote'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { StreamPartID } from '@streamr/protocol'
 
 interface InspectorConfig {
@@ -22,7 +21,7 @@ const DEFAULT_TIMEOUT = 60 * 1000
 
 export class Inspector {
 
-    private readonly sessions: Map<NodeID, InspectSession> = new Map()
+    private readonly sessions: Map<DhtAddress, InspectSession> = new Map()
     private readonly streamPartId: StreamPartID
     private readonly localPeerDescriptor: PeerDescriptor
     private readonly rpcCommunicator: RpcCommunicator
@@ -43,7 +42,6 @@ export class Inspector {
         const rpcRemote = new TemporaryConnectionRpcRemote(
             this.localPeerDescriptor,
             peerDescriptor,
-            this.streamPartId,
             this.rpcCommunicator,
             TemporaryConnectionRpcClient
         )
@@ -72,11 +70,11 @@ export class Inspector {
         return success || session.getInspectedMessageCount() < 1
     }
 
-    markMessage(sender: NodeID, messageId: MessageID): void {
+    markMessage(sender: DhtAddress, messageId: MessageID): void {
         this.sessions.forEach((session) => session.markMessage(sender, messageId))
     }
 
-    isInspected(nodeId: NodeID): boolean {
+    isInspected(nodeId: DhtAddress): boolean {
         return this.sessions.has(nodeId)
     }