@streamr/dht 100.0.0-testnet-two.3 → 100.0.0-testnet-three.0

package/src/dht/PeerManager.ts

@@ -2,9 +2,6 @@ import {
     Logger
 } from '@streamr/utils'
 import KBucket from 'k-bucket'
-import {
-    getNodeIdFromPeerDescriptor
-} from '../helpers/peerIdFromPeerDescriptor'
 import {
     PeerDescriptor
 } from '../proto/packages/dht/protos/DhtRpc'
@@ -13,7 +10,7 @@ import { RandomContactList } from './contact/RandomContactList'
 import { SortedContactList } from './contact/SortedContactList'
 import { ConnectionManager } from '../connection/ConnectionManager'
 import EventEmitter from 'eventemitter3'
-import { DhtAddress, DhtAddressRaw, getRawFromDhtAddress } from '../identifiers'
+import { DhtAddress, DhtAddressRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../identifiers'
 
 const logger = new Logger(module)
 
@@ -66,7 +63,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             numberOfNodesToPing: this.config.numberOfNodesPerKBucket
         })
         this.bucket.on('ping', (oldContacts: DhtNodeRpcRemote[], newContact: DhtNodeRpcRemote) => this.onKBucketPing(oldContacts, newContact))
-        this.bucket.on('removed', (contact: DhtNodeRpcRemote) => this.onKBucketRemoved(contact))
+        this.bucket.on('removed', (contact: DhtNodeRpcRemote) => this.onKBucketRemoved(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())))
         this.bucket.on('added', (contact: DhtNodeRpcRemote) => this.onKBucketAdded(contact))
         this.bucket.on('updated', () => {
             // TODO: Update contact info to the connection manager and reconnect
@@ -114,11 +111,10 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         this.bucket.add(newContact)
     }
 
-    private onKBucketRemoved(contact: DhtNodeRpcRemote): void {
+    private onKBucketRemoved(nodeId: DhtAddress): void {
         if (this.stopped) {
             return
         }
-        const nodeId = getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())
         this.config.connectionManager?.weakUnlockConnection(nodeId)
         logger.trace(`Removed contact ${nodeId}`)
         if (this.bucket.count() === 0) {
@@ -145,13 +141,13 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
                     } else {
                         logger.trace('ping failed ' + nodeId)
                         this.config.connectionManager?.weakUnlockConnection(nodeId)
-                        this.removeContact(peerDescriptor)
+                        this.removeContact(nodeId)
                         this.addClosestContactToBucket()
                     }
                     return
                 }).catch((_e) => {
                     this.config.connectionManager?.weakUnlockConnection(nodeId)
-                    this.removeContact(peerDescriptor)
+                    this.removeContact(nodeId)
                     this.addClosestContactToBucket()
                 })
             }
@@ -192,30 +188,28 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         logger.trace('connected: ' + nodeId + ' ' + this.connections.size)
     }
 
-    handleDisconnected(peerDescriptor: PeerDescriptor, gracefulLeave: boolean): void {
-        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+    handleDisconnected(nodeId: DhtAddress, gracefulLeave: boolean): void {
         logger.trace('disconnected: ' + nodeId)
         this.connections.delete(nodeId)
         if (this.config.isLayer0) {
-            this.bucket.remove(peerDescriptor.nodeId)
+            this.bucket.remove(getRawFromDhtAddress(nodeId))
             if (gracefulLeave === true) {
                 logger.trace(nodeId + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
-                this.removeContact(peerDescriptor)
+                this.removeContact(nodeId)
             } else {
                 logger.trace(nodeId + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
             }
         }
     }
 
-    handlePeerLeaving(peerDescriptor: PeerDescriptor): void {
-        this.removeContact(peerDescriptor)
+    handlePeerLeaving(nodeId: DhtAddress): void {
+        this.removeContact(nodeId)
     }
 
-    private removeContact(contact: PeerDescriptor): void {
+    private removeContact(nodeId: DhtAddress): void {
         if (this.stopped) {
             return
         }
-        const nodeId = getNodeIdFromPeerDescriptor(contact)
         logger.trace(`Removing contact ${nodeId}`)
         this.bucket.remove(getRawFromDhtAddress(nodeId))
         this.contacts.removeContact(nodeId)
@@ -258,7 +252,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         return closest.getClosestContacts(limit)
     }
 
-    getNumberOfContacts(excludedNodeIds?: Set<DhtAddress>): number {
+    getContactCount(excludedNodeIds?: Set<DhtAddress>): number {
         return this.contacts.getAllContacts().filter((contact) => {
             if (!excludedNodeIds) {
                 return true
@@ -268,11 +262,11 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         }).length
     }
 
-    getNumberOfConnections(): number {
+    getConnectionCount(): number {
         return this.connections.size
     }
 
-    getNumberOfNeighbors(): number {
+    getNeighborCount(): number {
         return this.bucket.count()
     }
 

package/src/dht/contact/Contact.ts

@@ -1,6 +1,5 @@
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { DhtAddress } from '../../identifiers'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 export class Contact {
 

package/src/dht/contact/RpcRemote.ts

@@ -4,6 +4,7 @@ import { ConnectionType } from '../../connection/IConnection'
 import { expectedConnectionType } from '../../helpers/Connectivity'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
+import { DhtCallContext } from '../../rpc-protocol/DhtCallContext' 
 
 // Should connect directly to the server, timeout can be low
 const WEBSOCKET_CLIENT_TIMEOUT = 5000
@@ -37,7 +38,7 @@ export abstract class RpcRemote<T extends ServiceInfo & ClassType> {
     constructor(
         localPeerDescriptor: PeerDescriptor,
         remotePeerDescriptor: PeerDescriptor,
-        rpcCommunicator: RpcCommunicator,
+        rpcCommunicator: RpcCommunicator<DhtCallContext>,
         // eslint-disable-next-line @typescript-eslint/prefer-function-type
         clientClass: { new (clientTransport: ClientTransport): T },
         timeout?: number

package/src/dht/discovery/DiscoverySession.ts

@@ -4,8 +4,7 @@ import { v4 } from 'uuid'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { PeerManager, getDistance } from '../PeerManager'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
-import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { DhtAddress, getRawFromDhtAddress } from '../../identifiers'
+import { DhtAddress, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../identifiers'
 
 const logger = new Logger(module)
 
@@ -107,7 +106,7 @@ export class DiscoverySession {
     }
 
     public async findClosestNodes(timeout: number): Promise<void> {
-        if (this.config.peerManager.getNumberOfContacts(this.config.contactedPeers) === 0) {
+        if (this.config.peerManager.getContactCount(this.config.contactedPeers) === 0) {
             return
         }
         // TODO add abortController and signal it in stop()

package/src/dht/discovery/PeerDiscovery.ts

@@ -1,11 +1,10 @@
 import { DiscoverySession } from './DiscoverySession'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
-import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger, scheduleAtInterval, setAbortableTimeout } from '@streamr/utils'
 import { ConnectionManager } from '../../connection/ConnectionManager'
 import { PeerManager } from '../PeerManager'
-import { DhtAddress, createRandomDhtAddress } from '../../identifiers'
+import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../identifiers'
 import { ServiceID } from '../../types/ServiceID'
 
 interface PeerDiscoveryConfig {
@@ -19,6 +18,12 @@ interface PeerDiscoveryConfig {
     peerManager: PeerManager
 }
 
+export const createDistantDhtAddress = (address: DhtAddress): DhtAddress => {
+    const raw = getRawFromDhtAddress(address)
+    const flipped = raw.map((val) => ~val)
+    return getDhtAddressFromRaw(flipped)
+}
+
 const logger = new Logger(module)
 
 export class PeerDiscovery {
@@ -37,14 +42,16 @@ export class PeerDiscovery {
 
     async joinDht(
         entryPoints: PeerDescriptor[],
-        doAdditionalRandomPeerDiscovery = true,
+        doAdditionalDistantPeerDiscovery = true,
         retry = true
     ): Promise<void> {
         const contactedPeers = new Set<DhtAddress>()
+        const distantJoinConfig = doAdditionalDistantPeerDiscovery 
+            ? { enabled: true, contactedPeers: new Set<DhtAddress>() } : { enabled: false } as const
         await Promise.all(entryPoints.map((entryPoint) => this.joinThroughEntryPoint(
             entryPoint,
             contactedPeers,
-            doAdditionalRandomPeerDiscovery,
+            distantJoinConfig,
             retry
         )))
     }
@@ -53,7 +60,7 @@ export class PeerDiscovery {
         entryPointDescriptor: PeerDescriptor,
         // Note that this set is mutated by DiscoverySession
         contactedPeers: Set<DhtAddress>,
-        doAdditionalRandomPeerDiscovery = true,
+        additionalDistantJoin: { enabled: true, contactedPeers: Set<DhtAddress> } | { enabled: false },
         retry = true
     ): Promise<void> {
         if (this.isStopped()) {
@@ -71,8 +78,8 @@ export class PeerDiscovery {
         this.config.peerManager.handleNewPeers([entryPointDescriptor])
         const targetId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
         const sessions = [this.createSession(targetId, contactedPeers)]
-        if (doAdditionalRandomPeerDiscovery) {
-            sessions.push(this.createSession(createRandomDhtAddress(), contactedPeers))
+        if (additionalDistantJoin.enabled) {
+            sessions.push(this.createSession(createDistantDhtAddress(targetId), additionalDistantJoin.contactedPeers))
         }
         await this.runSessions(sessions, entryPointDescriptor, retry)
         this.config.connectionManager?.unlockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
@@ -100,7 +107,7 @@ export class PeerDiscovery {
             logger.debug(`DHT join on ${this.config.serviceId} timed out`)
         } finally {
             if (!this.isStopped()) {
-                if (this.config.peerManager.getNumberOfNeighbors() === 0) {
+                if (this.config.peerManager.getNeighborCount() === 0) {
                     if (retry) {
                         // TODO should we catch possible promise rejection?
                         // TODO use config option or named constant?
@@ -121,7 +128,7 @@ export class PeerDiscovery {
         logger.debug(`Rejoining DHT ${this.config.serviceId}`)
         this.rejoinOngoing = true
         try {
-            await this.joinThroughEntryPoint(entryPoint, new Set())
+            await this.joinThroughEntryPoint(entryPoint, new Set(), { enabled: false })
             logger.debug(`Rejoined DHT successfully ${this.config.serviceId}!`)
         } catch (err) {
             logger.warn(`Rejoining DHT ${this.config.serviceId} failed`)

package/src/dht/recursive-operation/RecursiveOperationManager.ts

@@ -9,7 +9,6 @@ import {
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { Router } from '../routing/Router'
 import { RoutingMode } from '../routing/RoutingSession'
-import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger, areEqualBinaries, runAndWaitForEvents3, wait } from '@streamr/utils'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { RecursiveOperationSessionRpcRemote } from './RecursiveOperationSessionRpcRemote'
@@ -24,7 +23,7 @@ import { getPreviousPeer } from '../routing/getPreviousPeer'
 import { createRouteMessageAck } from '../routing/RouterRpcLocal'
 import { ServiceID } from '../../types/ServiceID'
 import { RecursiveOperationRpcLocal } from './RecursiveOperationRpcLocal'
-import { DhtAddress, getDhtAddressFromRaw, getRawFromDhtAddress } from '../../identifiers'
+import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../identifiers'
 import { getDistance } from '../PeerManager'
 
 interface RecursiveOperationManagerConfig {
@@ -77,7 +76,7 @@ export class RecursiveOperationManager {
     public async execute(
         targetId: DhtAddress,
         operation: RecursiveOperation,
-        excludedPeer?: PeerDescriptor,
+        excludedPeer?: DhtAddress,
         waitForCompletion = true
     ): Promise<RecursiveOperationResult> {
         if (this.stopped) {
@@ -98,6 +97,7 @@ export class RecursiveOperationManager {
         if (this.config.connections.size === 0) {
             const dataEntries = Array.from(this.config.localDataStore.values(targetId))
             session.onResponseReceived(
+                getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor),
                 [this.config.localPeerDescriptor],
                 [this.config.localPeerDescriptor],
                 dataEntries,
@@ -126,7 +126,7 @@ export class RecursiveOperationManager {
         if (operation === RecursiveOperation.FETCH_DATA) {
             const dataEntries = Array.from(this.config.localDataStore.values(targetId))
             if (dataEntries.length > 0) {
-                this.sendResponse([], this.config.localPeerDescriptor, session.getId(), [], dataEntries, true)
+                this.sendResponse([this.config.localPeerDescriptor], this.config.localPeerDescriptor, session.getId(), [], dataEntries, true)
             }
         } else if (operation === RecursiveOperation.DELETE_DATA) {
             this.config.localDataStore.markAsDeleted(targetId, getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor))
@@ -147,7 +147,13 @@ export class RecursiveOperationManager {
         const isOwnNode = areEqualPeerDescriptors(this.config.localPeerDescriptor, targetPeerDescriptor)
         if (isOwnNode && this.ongoingSessions.has(serviceId)) {
             this.ongoingSessions.get(serviceId)!
-                .onResponseReceived(routingPath, closestNodes, dataEntries, noCloserNodesFound)
+                .onResponseReceived(
+                    getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor),
+                    routingPath,
+                    closestNodes,
+                    dataEntries,
+                    noCloserNodesFound
+                )
         } else {
             // TODO use config option or named constant?
             const remoteCommunicator = new ListeningRpcCommunicator(serviceId, this.config.sessionTransport, { rpcRequestTimeout: 15000 })
@@ -164,7 +170,7 @@ export class RecursiveOperationManager {
         }
     }
 
-    private doRouteRequest(routedMessage: RouteMessageWrapper, excludedPeer?: PeerDescriptor): RouteMessageAck {
+    private doRouteRequest(routedMessage: RouteMessageWrapper, excludedPeer?: DhtAddress): RouteMessageAck {
         if (this.stopped) {
             return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
         }

package/src/dht/recursive-operation/RecursiveOperationRpcLocal.ts

@@ -1,9 +1,9 @@
 import { Logger } from '@streamr/utils'
 import { PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { IRecursiveOperationRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
-import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { createRouteMessageAck } from '../routing/RouterRpcLocal'
 import { getPreviousPeer } from '../routing/getPreviousPeer'
+import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 

package/src/dht/recursive-operation/RecursiveOperationRpcRemote.ts

@@ -1,10 +1,10 @@
 import { Logger } from '@streamr/utils'
 import { v4 } from 'uuid'
-import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { RecursiveOperationRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { RpcRemote } from '../contact/RpcRemote'
 import { getPreviousPeer } from '../routing/getPreviousPeer'
+import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 
@@ -17,7 +17,8 @@ export class RecursiveOperationRpcRemote extends RpcRemote<RecursiveOperationRpc
             message: params.message,
             requestId: params.requestId ?? v4(),
             reachableThrough: params.reachableThrough ?? [],
-            routingPath: params.routingPath
+            routingPath: params.routingPath,
+            parallelRootNodeIds: params.parallelRootNodeIds
         }
         const options = this.formDhtRpcOptions({
             connect: false

package/src/dht/recursive-operation/RecursiveOperationSession.ts

@@ -16,10 +16,10 @@ import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicat
 import { Contact } from '../contact/Contact'
 import { SortedContactList } from '../contact/SortedContactList'
 import { RecursiveOperationResult } from './RecursiveOperationManager'
-import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { ServiceID } from '../../types/ServiceID'
 import { RecursiveOperationSessionRpcLocal } from './RecursiveOperationSessionRpcLocal'
-import { DhtAddress, getDhtAddressFromRaw, getRawFromDhtAddress } from '../../identifiers'
+import { DhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../identifiers'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 
 export interface RecursiveOperationSessionEvents {
     completed: () => void
@@ -45,6 +45,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
     private timeoutTask?: NodeJS.Timeout 
     private completionEventEmitted = false
     private noCloserNodesReceivedCounter = 0
+    private readonly noCloserNodesReceivedFrom: Set<DhtAddress> = new Set()
     private readonly config: RecursiveOperationSessionConfig
 
     constructor(config: RecursiveOperationSessionConfig) {
@@ -64,12 +65,18 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
 
     private registerLocalRpcMethods() {
         const rpcLocal = new RecursiveOperationSessionRpcLocal({
-            onResponseReceived: (routingPath: PeerDescriptor[], nodes: PeerDescriptor[], dataEntries: DataEntry[], noCloserNodesFound: boolean) => {
-                this.onResponseReceived(routingPath, nodes, dataEntries, noCloserNodesFound)
+            onResponseReceived: (
+                sourceId: DhtAddress,
+                routingPath: PeerDescriptor[],
+                nodes: PeerDescriptor[],
+                dataEntries: DataEntry[],
+                noCloserNodesFound: boolean
+            ) => {
+                this.onResponseReceived(sourceId, routingPath, nodes, dataEntries, noCloserNodesFound)
             }
         })
         this.rpcCommunicator.registerRpcNotification(RecursiveOperationResponse, 'sendResponse',
-            (req: RecursiveOperationResponse) => rpcLocal.sendResponse(req))
+            (req: RecursiveOperationResponse, context: ServerCallContext) => rpcLocal.sendResponse(req, context))
     }
 
     public start(serviceId: ServiceID): void {
@@ -97,7 +104,8 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
             target: getRawFromDhtAddress(this.config.targetId),
             sourcePeer: this.config.localPeerDescriptor,
             reachableThrough: [],
-            routingPath: []
+            routingPath: [],
+            parallelRootNodeIds: []
         }
         return routeMessage
     }
@@ -124,6 +132,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
     }
 
     public onResponseReceived(
+        sourceId: DhtAddress,
         routingPath: PeerDescriptor[],
         nodes: PeerDescriptor[],
         dataEntries: DataEntry[],
@@ -137,8 +146,8 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
             this.results.addContact(new Contact(descriptor))
         })
         this.processFoundData(dataEntries)
-        if (noCloserNodesFound) {
-            this.onNoCloserPeersFound()
+        if (noCloserNodesFound || this.noCloserNodesReceivedFrom.has(sourceId)) {
+            this.onNoCloserPeersFound(sourceId)
         }
     }
 
@@ -181,8 +190,9 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
         })
     }
 
-    private onNoCloserPeersFound(): void {
+    private onNoCloserPeersFound(sourceId: DhtAddress): void {
         this.noCloserNodesReceivedCounter += 1
+        this.noCloserNodesReceivedFrom.add(sourceId)
         if (this.isCompleted()) {
             this.emit('completed')
             this.completionEventEmitted = true

package/src/dht/recursive-operation/RecursiveOperationSessionRpcLocal.ts

@@ -2,11 +2,20 @@ import { IRecursiveOperationSessionRpc } from '../../proto/packages/dht/protos/D
 import { Empty } from '../../proto/google/protobuf/empty'
 import { DataEntry, RecursiveOperationResponse, PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger } from '@streamr/utils'
+import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
+import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 
 interface RecursiveOperationSessionRpcLocalConfig {
-    onResponseReceived: (routingPath: PeerDescriptor[], nodes: PeerDescriptor[], dataEntries: DataEntry[], noCloserNodesFound: boolean) => void
+    onResponseReceived: (
+        sourceId: DhtAddress,
+        routingPath: PeerDescriptor[],
+        nodes: PeerDescriptor[],
+        dataEntries: DataEntry[],
+        noCloserNodesFound: boolean
+    ) => void
 }
 
 export class RecursiveOperationSessionRpcLocal implements IRecursiveOperationSessionRpc {
@@ -17,9 +26,10 @@ export class RecursiveOperationSessionRpcLocal implements IRecursiveOperationSes
         this.config = config
     }
     
-    async sendResponse(report: RecursiveOperationResponse): Promise<Empty> {
+    async sendResponse(report: RecursiveOperationResponse, context: ServerCallContext): Promise<Empty> {
+        const sourceId = getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!)
         logger.trace('RecursiveOperationResponse arrived: ' + JSON.stringify(report))
-        this.config.onResponseReceived(report.routingPath, report.closestConnectedPeers, report.dataEntries, report.noCloserNodesFound)
+        this.config.onResponseReceived(sourceId, report.routingPath, report.closestConnectedPeers, report.dataEntries, report.noCloserNodesFound)
         return {}
     }
 }

package/src/dht/routing/DuplicateDetector.ts

@@ -1,40 +1,28 @@
-type QueueEntry = [timestamp: number, value: string]
-
 export class DuplicateDetector {
 
     private values: Set<string> = new Set()
-    private queue: Array<QueueEntry> = []
-    private maxAge: number
-    private maxNumberOfValues: number
+    private queue: Array<string> = []
+    private maxItemCount: number
 
     constructor(
-        maxNumberOfValues: number,
-        maxAgeInSeconds: number
+        maxItemCount: number,
     ) {
-        this.maxNumberOfValues = maxNumberOfValues
-        this.maxAge = maxAgeInSeconds * 1000
+        this.maxItemCount = maxItemCount
     }
 
     public add(value: string): void {
         this.values.add(value)
-        this.queue.push([Date.now(), value])
-        this.cleanUp()
+        this.queue.push(value)
+        if (this.queue.length > this.maxItemCount) {
+            const removed = this.queue.shift()!
+            this.values.delete(removed)
+        }
     }
 
     public isMostLikelyDuplicate(value: string): boolean {
         return this.values.has(value)
     }
 
-    private cleanUp(): void {
-        const currentTime = Date.now()
-
-        while (this.queue.length > 0 && (this.queue.length > this.maxNumberOfValues ||
-            (currentTime - this.queue[0][0]) > this.maxAge)) {
-            const oldestEntry = this.queue.shift()
-            this.values.delete(oldestEntry![1])
-        }
-    }
-
     public size(): number {
         return this.values.size
     }

package/src/dht/routing/Router.ts

@@ -1,8 +1,4 @@
 import { Message, PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
-import {
-    areEqualPeerDescriptors,
-    getNodeIdFromPeerDescriptor
-} from '../../helpers/peerIdFromPeerDescriptor'
 import { RoutingMode, RoutingSession, RoutingSessionEvents } from './RoutingSession'
 import { Logger, executeSafePromise, raceEvents3, withTimeout } from '@streamr/utils'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
@@ -11,7 +7,7 @@ import { ConnectionManager } from '../../connection/ConnectionManager'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { v4 } from 'uuid'
 import { RouterRpcLocal, createRouteMessageAck } from './RouterRpcLocal'
-import { DhtAddress, getDhtAddressFromRaw } from '../../identifiers'
+import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 export interface RouterConfig {
     rpcCommunicator: RoutingRpcCommunicator
@@ -33,7 +29,7 @@ export class Router {
     private readonly forwardingTable: Map<DhtAddress, ForwardingTableEntry> = new Map()
     private ongoingRoutingSessions: Map<string, RoutingSession> = new Map()
     // TODO use config option or named constant?
-    private readonly duplicateRequestDetector: DuplicateDetector = new DuplicateDetector(100000, 100)
+    private readonly duplicateRequestDetector: DuplicateDetector = new DuplicateDetector(100000)
     private stopped = false
     private readonly config: RouterConfig
 
@@ -87,7 +83,8 @@ export class Router {
                 target: forwardingEntry.peerDescriptors[0].nodeId,
                 sourcePeer: this.config.localPeerDescriptor,
                 reachableThrough,
-                routingPath: []
+                routingPath: [],
+                parallelRootNodeIds: []
             }
             const ack = this.doRouteMessage(forwardedMessage, RoutingMode.FORWARD)
             if (ack.error !== undefined) {
@@ -102,7 +99,8 @@ export class Router {
                 target: targetPeerDescriptor.nodeId,
                 sourcePeer: this.config.localPeerDescriptor,
                 reachableThrough,
-                routingPath: []
+                routingPath: [],
+                parallelRootNodeIds: []
             }
             const ack = this.doRouteMessage(routedMessage, RoutingMode.ROUTE)
             if (ack.error !== undefined) {
@@ -113,7 +111,7 @@ export class Router {
         }
     }
 
-    public doRouteMessage(routedMessage: RouteMessageWrapper, mode = RoutingMode.ROUTE, excludedPeer?: PeerDescriptor): RouteMessageAck {
+    public doRouteMessage(routedMessage: RouteMessageWrapper, mode = RoutingMode.ROUTE, excludedPeer?: DhtAddress): RouteMessageAck {
         if (this.stopped) {
             return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
         }
@@ -153,11 +151,14 @@ export class Router {
         }
     }
 
-    private createRoutingSession(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedNode?: PeerDescriptor): RoutingSession {
+    private createRoutingSession(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedNode?: DhtAddress): RoutingSession {
         const excludedNodeIds = new Set<DhtAddress>(routedMessage.routingPath.map((descriptor) => getNodeIdFromPeerDescriptor(descriptor)))
         if (excludedNode) {
-            excludedNodeIds.add(getNodeIdFromPeerDescriptor(excludedNode))
+            excludedNodeIds.add(excludedNode)
         }
+        routedMessage.parallelRootNodeIds.forEach((nodeId) => {
+            excludedNodeIds.add(nodeId as DhtAddress)
+        })
         logger.trace('routing session created with connections: ' + this.config.connections.size)
         return new RoutingSession({
             rpcCommunicator: this.config.rpcCommunicator,

package/src/dht/routing/RouterRpcLocal.ts

@@ -1,11 +1,10 @@
 import { Logger, areEqualBinaries } from '@streamr/utils'
 import { ConnectionManager } from '../../connection/ConnectionManager'
-import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { IRouterRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { DuplicateDetector } from './DuplicateDetector'
 import { RoutingMode } from './RoutingSession'
-import { getDhtAddressFromRaw } from '../../identifiers'
+import { areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 interface RouterRpcLocalConfig {
     doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => RouteMessageAck

package/src/dht/routing/RouterRpcRemote.ts

@@ -1,12 +1,10 @@
 import { Logger, areEqualBinaries } from '@streamr/utils'
 import { v4 } from 'uuid'
-import {
-    getNodeIdFromPeerDescriptor
-} from '../../helpers/peerIdFromPeerDescriptor'
 import { RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { RouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { RpcRemote } from '../contact/RpcRemote'
 import { getPreviousPeer } from './getPreviousPeer'
+import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 
@@ -19,7 +17,8 @@ export class RouterRpcRemote extends RpcRemote<RouterRpcClient> {
             message: params.message,
             requestId: params.requestId ?? v4(),
             reachableThrough: params.reachableThrough ?? [],
-            routingPath: params.routingPath
+            routingPath: params.routingPath,
+            parallelRootNodeIds: params.parallelRootNodeIds
         }
         const options = this.formDhtRpcOptions({
             connect: false
@@ -53,7 +52,8 @@ export class RouterRpcRemote extends RpcRemote<RouterRpcClient> {
             message: params.message,
             requestId: params.requestId ?? v4(),
             reachableThrough: params.reachableThrough ?? [],
-            routingPath: params.routingPath
+            routingPath: params.routingPath,
+            parallelRootNodeIds: params.parallelRootNodeIds
         }
         const options = this.formDhtRpcOptions({
             connect: false