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

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'
@@ -136,7 +137,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 +306,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)
     }
 

package/src/logic/neighbor-discovery/HandshakeRpcLocal.ts

@@ -6,24 +6,31 @@ import {
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { NodeList } from '../NodeList'
-import { ConnectionLocker, DhtCallContext, PeerDescriptor } from '@streamr/dht'
+import {
+    ConnectionLocker,
+    DhtAddress,
+    DhtAddressRaw,
+    DhtCallContext,
+    PeerDescriptor,
+    getDhtAddressFromRaw,
+    getNodeIdFromPeerDescriptor
+} from '@streamr/dht'
 import { IHandshakeRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { HandshakeRpcRemote } from './HandshakeRpcRemote'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
-import { Logger, binaryToHex } from '@streamr/utils'
+import { Logger } from '@streamr/utils'
 import { StreamPartID } from '@streamr/protocol'
 
 interface HandshakeRpcLocalConfig {
     streamPartId: StreamPartID
     targetNeighbors: NodeList
     connectionLocker: ConnectionLocker
-    ongoingHandshakes: Set<NodeID>
-    ongoingInterleaves: Set<NodeID>
+    ongoingHandshakes: Set<DhtAddress>
+    ongoingInterleaves: Set<DhtAddress>
     maxNeighborCount: number
     createRpcRemote: (target: PeerDescriptor) => HandshakeRpcRemote
     createDeliveryRpcRemote: (peerDescriptor: PeerDescriptor) => DeliveryRpcRemote
-    handshakeWithInterleaving: (target: PeerDescriptor, senderId: NodeID) => Promise<boolean>
+    handshakeWithInterleaving: (target: PeerDescriptor, senderId: DhtAddress) => Promise<boolean>
 }
 
 const logger = new Logger(module)
@@ -42,7 +49,7 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
 
     private handleRequest(request: StreamPartHandshakeRequest, context: ServerCallContext): StreamPartHandshakeResponse {
         const senderDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const getInterleaveSourceIds = () => (request.interleaveSourceId !== undefined) ? [binaryToHex(request.interleaveSourceId) as NodeID] : []
+        const getInterleaveSourceIds = () => (request.interleaveSourceId !== undefined) ? [getDhtAddressFromRaw(request.interleaveSourceId)] : []
         if (this.config.ongoingInterleaves.has(getNodeIdFromPeerDescriptor(senderDescriptor))) {
             return this.rejectHandshake(request)
         } else if (this.config.targetNeighbors.hasNode(senderDescriptor)
@@ -80,12 +87,12 @@ export class HandshakeRpcLocal implements IHandshakeRpc {
     }
 
     private acceptHandshakeWithInterleaving(request: StreamPartHandshakeRequest, requester: PeerDescriptor): StreamPartHandshakeResponse {
-        const exclude: NodeID[] = []
-        request.neighborIds.forEach((id: Uint8Array) => exclude.push(binaryToHex(id) as NodeID))
+        const exclude: DhtAddress[] = []
+        request.neighborIds.forEach((id: DhtAddressRaw) => exclude.push(getDhtAddressFromRaw(id)))
         this.config.ongoingInterleaves.forEach((id) => exclude.push(id))
         exclude.push(getNodeIdFromPeerDescriptor(requester))
         if (request.interleaveSourceId !== undefined) {
-            exclude.push(binaryToHex(request.interleaveSourceId) as NodeID)
+            exclude.push(getDhtAddressFromRaw(request.interleaveSourceId))
         }
         const furthest = this.config.targetNeighbors.getFurthest(exclude)
         const furthestPeerDescriptor = furthest ? furthest.getPeerDescriptor() : undefined

package/src/logic/neighbor-discovery/HandshakeRpcRemote.ts

@@ -1,9 +1,9 @@
-import { PeerDescriptor, RpcRemote } from '@streamr/dht'
-import { Logger, hexToBinary } from '@streamr/utils'
+import { DhtAddress, PeerDescriptor, RpcRemote, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '@streamr/dht'
+import { Logger } from '@streamr/utils'
 import { v4 } from 'uuid'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { InterleaveRequest, InterleaveResponse, StreamPartHandshakeRequest } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { HandshakeRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { StreamPartID } from '@streamr/protocol'
 
 const logger = new Logger(module)
 
@@ -17,16 +17,17 @@ export const INTERLEAVE_REQUEST_TIMEOUT = 15000
 export class HandshakeRpcRemote extends RpcRemote<HandshakeRpcClient> {
 
     async handshake(
-        neighborIds: NodeID[],
-        concurrentHandshakeTargetId?: NodeID,
-        interleaveSourceId?: NodeID
+        streamPartId: StreamPartID,
+        neighborIds: DhtAddress[],
+        concurrentHandshakeTargetId?: DhtAddress,
+        interleaveSourceId?: DhtAddress
     ): Promise<HandshakeResponse> {
         const request: StreamPartHandshakeRequest = {
-            streamPartId: this.getServiceId(),
+            streamPartId,
             requestId: v4(),
-            neighborIds: neighborIds.map((id) => hexToBinary(id)),
-            concurrentHandshakeTargetId: (concurrentHandshakeTargetId !== undefined) ? hexToBinary(concurrentHandshakeTargetId) : undefined,
-            interleaveSourceId: (interleaveSourceId !== undefined) ? hexToBinary(interleaveSourceId) : undefined
+            neighborIds: neighborIds.map((id) => getRawFromDhtAddress(id)),
+            concurrentHandshakeTargetId: (concurrentHandshakeTargetId !== undefined) ? getRawFromDhtAddress(concurrentHandshakeTargetId) : undefined,
+            interleaveSourceId: (interleaveSourceId !== undefined) ? getRawFromDhtAddress(interleaveSourceId) : undefined
         }
         try {
             const response = await this.getClient().handshake(request, this.formDhtRpcOptions())