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

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,11 +49,12 @@ 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] : []
-        if (this.config.ongoingInterleaves.has(getNodeIdFromPeerDescriptor(senderDescriptor))) {
+        const getInterleaveSourceIds = () => (request.interleaveSourceId !== undefined) ? [getDhtAddressFromRaw(request.interleaveSourceId)] : []
+        const senderNodeId = getNodeIdFromPeerDescriptor(senderDescriptor)
+        if (this.config.ongoingInterleaves.has(senderNodeId)) {
             return this.rejectHandshake(request)
         } else if (this.config.targetNeighbors.hasNode(senderDescriptor)
-            || this.config.ongoingHandshakes.has(getNodeIdFromPeerDescriptor(senderDescriptor))
+            || this.config.ongoingHandshakes.has(senderNodeId)
         ) {
             return this.acceptHandshake(request, senderDescriptor)
         } else if (this.config.targetNeighbors.size() + this.config.ongoingHandshakes.size < this.config.maxNeighborCount) {
@@ -80,12 +88,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())

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

@@ -1,4 +1,4 @@
-import { ConnectionLocker, PeerDescriptor } from '@streamr/dht'
+import { ConnectionLocker, DhtAddress, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { NodeList } from '../NodeList'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
 import { RpcCommunicator } from '@streamr/proto-rpc'
@@ -15,7 +15,6 @@ import { Logger } from '@streamr/utils'
 import { IHandshakeRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { HandshakeRpcRemote, INTERLEAVE_REQUEST_TIMEOUT } from './HandshakeRpcRemote'
 import { HandshakeRpcLocal } from './HandshakeRpcLocal'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { StreamPartID } from '@streamr/protocol'
 
 interface HandshakerConfig {
@@ -36,7 +35,7 @@ const PARALLEL_HANDSHAKE_COUNT = 2
 
 export class Handshaker {
 
-    private readonly ongoingHandshakes: Set<NodeID> = new Set()
+    private readonly ongoingHandshakes: Set<DhtAddress> = new Set()
     private config: HandshakerConfig
     private readonly rpcLocal: IHandshakeRpc
 
@@ -49,7 +48,7 @@ export class Handshaker {
             ongoingHandshakes: this.ongoingHandshakes,
             ongoingInterleaves: new Set(),
             maxNeighborCount: this.config.maxNeighborCount,
-            handshakeWithInterleaving: (target: PeerDescriptor, senderId: NodeID) => this.handshakeWithInterleaving(target, senderId),
+            handshakeWithInterleaving: (target: PeerDescriptor, senderId: DhtAddress) => this.handshakeWithInterleaving(target, senderId),
             createRpcRemote: (target: PeerDescriptor) => this.createRpcRemote(target),
             createDeliveryRpcRemote: (target: PeerDescriptor) => this.createDeliveryRpcRemote(target)
         })
@@ -59,7 +58,7 @@ export class Handshaker {
             (req: StreamPartHandshakeRequest, context) => this.rpcLocal.handshake(req, context))
     }
 
-    async attemptHandshakesOnContacts(excludedIds: NodeID[]): Promise<NodeID[]> {
+    async attemptHandshakesOnContacts(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
         // TODO use config option or named constant? or why the value 2?
         if (this.config.targetNeighbors.size() + this.ongoingHandshakes.size < this.config.maxNeighborCount - 2) {
             logger.trace(`Attempting parallel handshakes with ${PARALLEL_HANDSHAKE_COUNT} targets`)
@@ -71,14 +70,14 @@ export class Handshaker {
         return excludedIds
     }
 
-    private async selectParallelTargetsAndHandshake(excludedIds: NodeID[]): Promise<NodeID[]> {
+    private async selectParallelTargetsAndHandshake(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
         const exclude = excludedIds.concat(this.config.targetNeighbors.getIds())
         const targetNeighbors = this.selectParallelTargets(exclude)
         targetNeighbors.forEach((contact) => this.ongoingHandshakes.add(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
         return this.doParallelHandshakes(targetNeighbors, exclude)
     }
 
-    private selectParallelTargets(excludedIds: NodeID[]): HandshakeRpcRemote[] {
+    private selectParallelTargets(excludedIds: DhtAddress[]): HandshakeRpcRemote[] {
         const targetNeighbors = this.config.nearbyNodeView.getClosestAndFurthest(excludedIds)
         while (targetNeighbors.length < PARALLEL_HANDSHAKE_COUNT && this.config.randomNodeView.size(excludedIds) > 0) {
             const random = this.config.randomNodeView.getRandom(excludedIds)
@@ -89,7 +88,7 @@ export class Handshaker {
         return targetNeighbors.map((neighbor) => this.createRpcRemote(neighbor.getPeerDescriptor()))
     }
 
-    private async doParallelHandshakes(targets: HandshakeRpcRemote[], excludedIds: NodeID[]): Promise<NodeID[]> {
+    private async doParallelHandshakes(targets: HandshakeRpcRemote[], excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
         const results = await Promise.allSettled(
             Array.from(targets.values()).map(async (target: HandshakeRpcRemote, i) => {
                 const otherNode = i === 0 ? targets[1] : targets[0]
@@ -98,7 +97,7 @@ export class Handshaker {
                 return this.handshakeWithTarget(target, otherNodeId)
             })
         )
-        results.map((res, i) => {
+        results.forEach((res, i) => {
             if (res.status !== 'fulfilled' || !res.value) {
                 excludedIds.push(getNodeIdFromPeerDescriptor(targets[i].getPeerDescriptor()))
             }
@@ -106,7 +105,7 @@ export class Handshaker {
         return excludedIds
     }
 
-    private async selectNewTargetAndHandshake(excludedIds: NodeID[]): Promise<NodeID[]> {
+    private async selectNewTargetAndHandshake(excludedIds: DhtAddress[]): Promise<DhtAddress[]> {
         const exclude = excludedIds.concat(this.config.targetNeighbors.getIds())
         const targetNeighbor = this.config.nearbyNodeView.getClosest(exclude) ?? this.config.randomNodeView.getRandom(exclude)
         if (targetNeighbor) {
@@ -118,10 +117,11 @@ export class Handshaker {
         return excludedIds
     }
 
-    private async handshakeWithTarget(targetNeighbor: HandshakeRpcRemote, concurrentNodeId?: NodeID): Promise<boolean> {
+    private async handshakeWithTarget(targetNeighbor: HandshakeRpcRemote, concurrentNodeId?: DhtAddress): Promise<boolean> {
         const targetNodeId = getNodeIdFromPeerDescriptor(targetNeighbor.getPeerDescriptor())
         this.ongoingHandshakes.add(targetNodeId)
         const result = await targetNeighbor.handshake(
+            this.config.streamPartId,
             this.config.targetNeighbors.getIds(),
             concurrentNodeId
         )
@@ -136,11 +136,12 @@ export class Handshaker {
         return result.accepted
     }
 
-    private async handshakeWithInterleaving(target: PeerDescriptor, interleaveSourceId: NodeID): Promise<boolean> {
+    private async handshakeWithInterleaving(target: PeerDescriptor, interleaveSourceId: DhtAddress): Promise<boolean> {
         const targetNeighbor = this.createRpcRemote(target)
         const targetNodeId = getNodeIdFromPeerDescriptor(targetNeighbor.getPeerDescriptor())
         this.ongoingHandshakes.add(targetNodeId)
         const result = await targetNeighbor.handshake(
+            this.config.streamPartId,
             this.config.targetNeighbors.getIds(),
             undefined,
             interleaveSourceId
@@ -157,7 +158,6 @@ export class Handshaker {
         return new HandshakeRpcRemote(
             this.config.localPeerDescriptor,
             targetPeerDescriptor,
-            this.config.streamPartId,
             this.config.rpcCommunicator,
             HandshakeRpcClient,
             this.config.rpcRequestTimeout
@@ -168,14 +168,13 @@ export class Handshaker {
         return new DeliveryRpcRemote(
             this.config.localPeerDescriptor,
             targetPeerDescriptor,
-            this.config.streamPartId,
             this.config.rpcCommunicator,
             DeliveryRpcClient,
             this.config.rpcRequestTimeout
         )
     }
 
-    getOngoingHandshakes(): Set<NodeID> {
+    getOngoingHandshakes(): Set<DhtAddress> {
         return this.ongoingHandshakes
     }
 

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

@@ -1,11 +1,11 @@
 import { setAbortableTimeout } from '@streamr/utils'
 import { NodeList } from '../NodeList'
-import { NodeID } from '../../identifiers'
+import { DhtAddress } from '@streamr/dht'
 
 interface FindNeighborsSessionConfig {
     targetNeighbors: NodeList
     nearbyNodeView: NodeList
-    doFindNeighbors: (excludedNodes: NodeID[]) => Promise<NodeID[]>
+    doFindNeighbors: (excludedNodes: DhtAddress[]) => Promise<DhtAddress[]>
     minCount: number
 }
 
@@ -22,7 +22,7 @@ export class NeighborFinder {
         this.abortController = new AbortController()
     }
 
-    private async findNeighbors(excluded: NodeID[]): Promise<void> {
+    private async findNeighbors(excluded: DhtAddress[]): Promise<void> {
         if (!this.running) {
             return
         }
@@ -39,7 +39,7 @@ export class NeighborFinder {
         return this.running
     }
 
-    start(excluded: NodeID[] = []): void {
+    start(excluded: DhtAddress[] = []): void {
         if (this.running) {
             return
         }

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

@@ -1,12 +1,11 @@
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
+import { ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { NeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { Logger, scheduleAtInterval } from '@streamr/utils'
 import { NeighborFinder } from './NeighborFinder'
 import { NodeList } from '../NodeList'
 import { NeighborUpdateRpcRemote } from './NeighborUpdateRpcRemote'
 import { NeighborUpdateRpcLocal } from './NeighborUpdateRpcLocal'
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { StreamPartID } from '@streamr/protocol'
 
 interface NeighborUpdateManagerConfig {
@@ -47,7 +46,7 @@ export class NeighborUpdateManager {
         logger.trace(`Updating neighbor info to nodes`)
         const neighborDescriptors = this.config.targetNeighbors.getAll().map((neighbor) => neighbor.getPeerDescriptor())
         await Promise.allSettled(this.config.targetNeighbors.getAll().map(async (neighbor) => {
-            const res = await this.createRemote(neighbor.getPeerDescriptor()).updateNeighbors(neighborDescriptors)
+            const res = await this.createRemote(neighbor.getPeerDescriptor()).updateNeighbors(this.config.streamPartId, neighborDescriptors)
             if (res.removeMe) {
                 this.config.targetNeighbors.remove(neighbor.getPeerDescriptor())
                 this.config.neighborFinder.start([getNodeIdFromPeerDescriptor(neighbor.getPeerDescriptor())])
@@ -59,7 +58,6 @@ export class NeighborUpdateManager {
         return new NeighborUpdateRpcRemote(
             this.config.localPeerDescriptor,
             targetPeerDescriptor,
-            this.config.streamPartId,
             this.config.rpcCommunicator,
             NeighborUpdateRpcClient
         )

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

@@ -1,6 +1,5 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { DhtCallContext, ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { INeighborUpdateRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
@@ -31,17 +30,15 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
         const senderId = getNodeIdFromPeerDescriptor(senderPeerDescriptor)
         if (this.config.targetNeighbors.hasNodeById(senderId)) {
-            const newPeerDescriptors = message.neighborDescriptors
-                .filter((peerDescriptor) => {
-                    const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
-                    const ownNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
-                    return nodeId !== ownNodeId && !this.config.targetNeighbors.getIds().includes(nodeId)
-                })
+            const ownNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
+            const newPeerDescriptors = message.neighborDescriptors.filter((peerDescriptor) => {
+                const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+                return nodeId !== ownNodeId && !this.config.targetNeighbors.getIds().includes(nodeId)
+            })
             newPeerDescriptors.forEach((peerDescriptor) => this.config.nearbyNodeView.add(
                 new DeliveryRpcRemote(
                     this.config.localPeerDescriptor,
                     peerDescriptor,
-                    this.config.streamPartId,
                     this.config.rpcCommunicator,
                     DeliveryRpcClient
                 ))

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

@@ -1,8 +1,8 @@
-import { PeerDescriptor, RpcRemote } from '@streamr/dht'
+import { PeerDescriptor, RpcRemote, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { Logger } from '@streamr/utils'
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { NeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { StreamPartID } from '@streamr/protocol'
 
 const logger = new Logger(module)
 
@@ -13,9 +13,9 @@ interface UpdateNeighborsResponse {
 
 export class NeighborUpdateRpcRemote extends RpcRemote<NeighborUpdateRpcClient> {
 
-    async updateNeighbors(neighbors: PeerDescriptor[]): Promise<UpdateNeighborsResponse> {
+    async updateNeighbors(streamPartId: StreamPartID, neighbors: PeerDescriptor[]): Promise<UpdateNeighborsResponse> {
         const request: NeighborUpdate = {
-            streamPartId: this.getServiceId(),
+            streamPartId,
             neighborDescriptors: neighbors,
             removeMe: false
         }

package/src/logic/propagation/Propagation.ts

@@ -1,8 +1,8 @@
-import { NodeID } from '../../identifiers'
+import { DhtAddress } from '@streamr/dht'
 import { StreamMessage } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { PropagationTask, PropagationTaskStore } from './PropagationTaskStore'
 
-type SendToNeighborFn = (neighborId: NodeID, msg: StreamMessage) => Promise<void>
+type SendToNeighborFn = (neighborId: DhtAddress, msg: StreamMessage) => Promise<void>
 
 interface ConstructorOptions {
     sendToNeighbor: SendToNeighborFn
@@ -41,11 +41,11 @@ export class Propagation {
     /**
      * Node should invoke this when it learns about a new message
      */
-    feedUnseenMessage(message: StreamMessage, targets: NodeID[], source: NodeID | null): void {
+    feedUnseenMessage(message: StreamMessage, targets: DhtAddress[], source: DhtAddress | null): void {
         const task = {
             message,
             source,
-            handledNeighbors: new Set<NodeID>()
+            handledNeighbors: new Set<DhtAddress>()
         }
         this.activeTaskStore.add(task)
         for (const target of targets) {
@@ -56,14 +56,14 @@ export class Propagation {
     /**
      * Node should invoke this when it learns about a new node stream assignment
      */
-    onNeighborJoined(neighborId: NodeID): void {
+    onNeighborJoined(neighborId: DhtAddress): void {
         const tasks = this.activeTaskStore.get()
         for (const task of tasks) {
             this.sendAndAwaitThenMark(task, neighborId)
         }
     }
 
-    private sendAndAwaitThenMark({ message, source, handledNeighbors }: PropagationTask, neighborId: NodeID): void {
+    private sendAndAwaitThenMark({ message, source, handledNeighbors }: PropagationTask, neighborId: DhtAddress): void {
         if (!handledNeighbors.has(neighborId) && neighborId !== source) {
             // eslint-disable-next-line @typescript-eslint/no-floating-promises
             (async () => {

package/src/logic/propagation/PropagationTaskStore.ts

@@ -1,11 +1,11 @@
-import { NodeID } from '../../identifiers'
+import { DhtAddress } from '@streamr/dht'
 import { MessageRef, StreamMessage } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { FifoMapWithTTL } from './FifoMapWithTTL'
 
 export interface PropagationTask {
     message: StreamMessage
     source: string | null
-    handledNeighbors: Set<NodeID>
+    handledNeighbors: Set<DhtAddress>
 }
 
 /**

package/src/logic/proxy/ProxyClient.ts

@@ -1,14 +1,15 @@
 import {
     ConnectionLocker,
+    DhtAddress,
     ITransport,
     ListeningRpcCommunicator,
-    PeerDescriptor
+    PeerDescriptor,
+    getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
 import { StreamPartID } from '@streamr/protocol'
 import { EthereumAddress, Logger, addManagedEventListener, wait } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { sampleSize } from 'lodash'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import {
     LeaveStreamPartNotice,
     MessageID,
@@ -51,7 +52,7 @@ interface ProxyClientConfig {
 }
 
 interface ProxyDefinition {
-    nodes: Map<NodeID, PeerDescriptor>
+    nodes: Map<DhtAddress, PeerDescriptor>
     connectionCount: number
     direction: ProxyDirection
     userId: EthereumAddress
@@ -72,7 +73,7 @@ export class ProxyClient extends EventEmitter<Events> {
     private readonly config: ProxyClientConfig
     private readonly duplicateDetectors: Map<string, DuplicateMessageDetector> = new Map()
     private definition?: ProxyDefinition
-    private readonly connections: Map<NodeID, ProxyDirection> = new Map()
+    private readonly connections: Map<DhtAddress, ProxyDirection> = new Map()
     private readonly propagation: Propagation
     private readonly targetNeighbors: NodeList
     private readonly abortController: AbortController
@@ -87,8 +88,8 @@ export class ProxyClient extends EventEmitter<Events> {
             localPeerDescriptor: this.config.localPeerDescriptor,
             streamPartId: this.config.streamPartId,
             markAndCheckDuplicate: (msg: MessageID, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
-            broadcast: (message: StreamMessage, previousNode?: NodeID) => this.broadcast(message, previousNode),
-            onLeaveNotice: (senderId: NodeID) => {
+            broadcast: (message: StreamMessage, previousNode?: DhtAddress) => this.broadcast(message, previousNode),
+            onLeaveNotice: (senderId: DhtAddress) => {
                 const contact = this.targetNeighbors.get(senderId)
                 if (contact) {
                     // TODO should we catch possible promise rejection?
@@ -101,7 +102,7 @@ export class ProxyClient extends EventEmitter<Events> {
         this.propagation = new Propagation({
             // TODO use config option or named constant?
             minPropagationTargets: config.minPropagationTargets ?? 2,
-            sendToNeighbor: async (neighborId: NodeID, msg: StreamMessage): Promise<void> => {
+            sendToNeighbor: async (neighborId: DhtAddress, msg: StreamMessage): Promise<void> => {
                 const remote = this.targetNeighbors.get(neighborId)
                 if (remote) {
                     await remote.sendStreamMessage(msg)
@@ -130,7 +131,7 @@ export class ProxyClient extends EventEmitter<Events> {
         if (connectionCount !== undefined && connectionCount > nodes.length) {
             throw new Error('Cannot set connectionCount above the size of the configured array of nodes')
         }
-        const nodesIds = new Map<NodeID, PeerDescriptor>()
+        const nodesIds = new Map<DhtAddress, PeerDescriptor>()
         nodes.forEach((peerDescriptor) => {
             nodesIds.set(getNodeIdFromPeerDescriptor(peerDescriptor), peerDescriptor)
         })
@@ -155,7 +156,7 @@ export class ProxyClient extends EventEmitter<Events> {
         }
     }
 
-    private getInvalidConnections(): NodeID[] {
+    private getInvalidConnections(): DhtAddress[] {
         return Array.from(this.connections.keys()).filter((id) => {
             return !this.definition!.nodes.has(id)
                 || this.definition!.direction !== this.connections.get(id)
@@ -164,19 +165,18 @@ export class ProxyClient extends EventEmitter<Events> {
 
     private async openRandomConnections(connectionCount: number): Promise<void> {
         const proxiesToAttempt = sampleSize(Array.from(this.definition!.nodes.keys()).filter((id) =>
-            !this.connections.has(id as unknown as NodeID)
+            !this.connections.has(id)
         ), connectionCount)
         await Promise.all(proxiesToAttempt.map((id) =>
-            this.attemptConnection(id as unknown as NodeID, this.definition!.direction, this.definition!.userId)
+            this.attemptConnection(id, this.definition!.direction, this.definition!.userId)
         ))
     }
 
-    private async attemptConnection(nodeId: NodeID, direction: ProxyDirection, userId: EthereumAddress): Promise<void> {
+    private async attemptConnection(nodeId: DhtAddress, direction: ProxyDirection, userId: EthereumAddress): Promise<void> {
         const peerDescriptor = this.definition!.nodes.get(nodeId)!
         const rpcRemote = new ProxyConnectionRpcRemote(
             this.config.localPeerDescriptor,
             peerDescriptor,
-            this.config.streamPartId,
             this.rpcCommunicator,
             ProxyConnectionRpcClient
         )
@@ -187,7 +187,6 @@ export class ProxyClient extends EventEmitter<Events> {
             const remote = new DeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 peerDescriptor,
-                this.config.streamPartId,
                 this.rpcCommunicator,
                 DeliveryRpcClient
             )
@@ -210,23 +209,23 @@ export class ProxyClient extends EventEmitter<Events> {
         await Promise.allSettled(proxiesToDisconnect.map((node) => this.closeConnection(node)))
     }
 
-    private async closeConnection(nodeId: NodeID): Promise<void> {
+    private async closeConnection(nodeId: DhtAddress): Promise<void> {
         if (this.connections.has(nodeId)) {
             logger.info('Close proxy connection', {
                 nodeId
             })
             const server = this.targetNeighbors.get(nodeId)
-            server?.leaveStreamPartNotice(false)
+            server?.leaveStreamPartNotice(this.config.streamPartId, false)
             this.removeConnection(nodeId)
         }
     }
 
-    private removeConnection(nodeId: NodeID): void {
+    private removeConnection(nodeId: DhtAddress): void {
         this.connections.delete(nodeId)
         this.targetNeighbors.removeById(nodeId)
     }
 
-    broadcast(msg: StreamMessage, previousNode?: NodeID): void {
+    broadcast(msg: StreamMessage, previousNode?: DhtAddress): void {
         if (!previousNode) {
             markAndCheckDuplicate(this.duplicateDetectors, msg.messageId!, msg.previousMessageRef)
         }
@@ -234,7 +233,7 @@ export class ProxyClient extends EventEmitter<Events> {
         this.propagation.feedUnseenMessage(msg, this.targetNeighbors.getIds(), previousNode ?? null)
     }
 
-    hasConnection(nodeId: NodeID, direction: ProxyDirection): boolean {
+    hasConnection(nodeId: DhtAddress, direction: ProxyDirection): boolean {
         return this.connections.has(nodeId) && this.connections.get(nodeId) === direction
     }
 
@@ -263,9 +262,9 @@ export class ProxyClient extends EventEmitter<Events> {
     }
 
     stop(): void {
-        this.targetNeighbors.getAll().map((remote) => {
+        this.targetNeighbors.getAll().forEach((remote) => {
             this.config.connectionLocker.unlockConnection(remote.getPeerDescriptor(), SERVICE_ID)
-            remote.leaveStreamPartNotice(false)
+            remote.leaveStreamPartNotice(this.config.streamPartId, false)
         })
         this.targetNeighbors.stop()
         this.rpcCommunicator.destroy()

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
             )