@streamr/dht 100.0.0-pretestnet.2 → 100.0.0-pretestnet.4

package/src/dht/routing/Router.ts

@@ -1,22 +1,20 @@
 import { Message, PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
-import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import {
+    areEqualPeerDescriptors,
+    getNodeIdFromPeerDescriptor,
+    keyFromPeerDescriptor,
+    peerIdFromPeerDescriptor
+} from '../../helpers/peerIdFromPeerDescriptor'
 import { RoutingMode, RoutingSession, RoutingSessionEvents } from './RoutingSession'
 import { Logger, executeSafePromise, raceEvents3, withTimeout } from '@streamr/utils'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { PeerIDKey } from '../../helpers/PeerID'
 import { DuplicateDetector } from './DuplicateDetector'
 import { ConnectionManager } from '../../connection/ConnectionManager'
-import { RemoteDhtNode } from '../RemoteDhtNode'
+import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { v4 } from 'uuid'
-import { IRouterRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
-
-export const createRouteMessageAck = (routedMessage: RouteMessageWrapper, error?: string): RouteMessageAck => {
-    const ack: RouteMessageAck = {
-        requestId: routedMessage.requestId,
-        error: error ? error : ''
-    }
-    return ack
-}
+import { RouterRpcLocal, createRouteMessageAck } from './RouterRpcLocal'
+import { ServiceID } from '../../types/ServiceID'
 
 export enum RoutingErrors {
     NO_CANDIDATES_FOUND = 'No routing candidates found',
@@ -25,11 +23,13 @@ export enum RoutingErrors {
 
 export interface RouterConfig {
     rpcCommunicator: RoutingRpcCommunicator
-    ownPeerDescriptor: PeerDescriptor
-    connections: Map<PeerIDKey, RemoteDhtNode>
+    localPeerDescriptor: PeerDescriptor
+    connections: Map<PeerIDKey, DhtNodeRpcRemote>
     addContact: (contact: PeerDescriptor, setActive?: boolean) => void
-    serviceId: string
+    serviceId: ServiceID
     connectionManager?: ConnectionManager
+    rpcRequestTimeout?: number
+
 }
 
 interface ForwardingTableEntry {
@@ -37,7 +37,7 @@ interface ForwardingTableEntry {
     peerDescriptors: PeerDescriptor[]
 }
 
-interface IRouterFunc {
+export interface IRouter {
     doRouteMessage(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedPeer?: PeerDescriptor): RouteMessageAck
     send(msg: Message, reachableThrough: PeerDescriptor[]): Promise<void>
     isMostLikelyDuplicate(requestId: string): boolean
@@ -47,17 +47,13 @@ interface IRouterFunc {
     stop(): void
 }
 
-export interface IRouter extends Omit<IRouterRpc, 'findRecursively'>, IRouterFunc {}
-
 const logger = new Logger(module)
 
 export class Router implements IRouter {
     private readonly rpcCommunicator: RoutingRpcCommunicator
-    private readonly ownPeerDescriptor: PeerDescriptor
-    private readonly connections: Map<PeerIDKey, RemoteDhtNode>
-    private readonly addContact: (contact: PeerDescriptor, setActive?: boolean) => void
-    private readonly serviceId: string
-    private readonly connectionManager?: ConnectionManager
+    private readonly localPeerDescriptor: PeerDescriptor
+    private readonly connections: Map<PeerIDKey, DhtNodeRpcRemote>
+    private readonly serviceId: ServiceID
     private readonly forwardingTable: Map<string, ForwardingTableEntry> = new Map()
     private ongoingRoutingSessions: Map<string, RoutingSession> = new Map()
     private readonly duplicateRequestDetector: DuplicateDetector = new DuplicateDetector(100000, 100)
@@ -65,19 +61,48 @@ export class Router implements IRouter {
 
     constructor(config: RouterConfig) {
         this.rpcCommunicator = config.rpcCommunicator
-        this.ownPeerDescriptor = config.ownPeerDescriptor
+        this.localPeerDescriptor = config.localPeerDescriptor
         this.connections = config.connections
-        this.addContact = config.addContact
         this.serviceId = config.serviceId
-        this.connectionManager = config.connectionManager
-        this.rpcCommunicator.registerRpcMethod(RouteMessageWrapper, RouteMessageAck, 'forwardMessage',
-            (forwardMessage: RouteMessageWrapper) => this.forwardMessage(forwardMessage))
-        this.rpcCommunicator.registerRpcMethod(RouteMessageWrapper, RouteMessageAck, 'routeMessage',
-            (routedMessage: RouteMessageWrapper) => this.routeMessage(routedMessage))
+        this.registerLocalRpcMethods(config)
+    }
+
+    private registerLocalRpcMethods(config: RouterConfig) {
+        const rpcLocal = new RouterRpcLocal({
+            doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => this.doRouteMessage(routedMessage, mode),
+            addContact: (contact: PeerDescriptor, setActive: boolean) => config.addContact(contact, setActive),
+            setForwardingEntries: (routedMessage: RouteMessageWrapper) => this.setForwardingEntries(routedMessage),
+            duplicateRequestDetector: this.duplicateRequestDetector,
+            localPeerDescriptor: this.localPeerDescriptor,
+            connectionManager: config.connectionManager
+        })
+        this.rpcCommunicator.registerRpcMethod(
+            RouteMessageWrapper,
+            RouteMessageAck,
+            'routeMessage',
+            async (routedMessage: RouteMessageWrapper) => {
+                if (this.stopped) {
+                    return createRouteMessageAck(routedMessage, 'routeMessage() service is not running')
+                }
+                return rpcLocal.routeMessage(routedMessage)
+            }
+        )
+        this.rpcCommunicator.registerRpcMethod(
+            RouteMessageWrapper,
+            RouteMessageAck,
+            'forwardMessage',
+            async (forwardMessage: RouteMessageWrapper) => {
+                if (this.stopped) {
+                    return createRouteMessageAck(forwardMessage, 'forwardMessage() service is not running')
+                }
+                return rpcLocal.forwardMessage(forwardMessage)
+            }
+        )
+
     }
 
     public async send(msg: Message, reachableThrough: PeerDescriptor[]): Promise<void> {
-        msg.sourceDescriptor = this.ownPeerDescriptor
+        msg.sourceDescriptor = this.localPeerDescriptor
         const targetPeerDescriptor = msg.targetDescriptor!
         const forwardingEntry = this.forwardingTable.get(keyFromPeerDescriptor(targetPeerDescriptor))
         if (forwardingEntry && forwardingEntry.peerDescriptors.length > 0) {
@@ -86,7 +111,7 @@ export class Router implements IRouter {
                 message: msg,
                 requestId: v4(),
                 destinationPeer: forwardingPeer,
-                sourcePeer: this.ownPeerDescriptor,
+                sourcePeer: this.localPeerDescriptor,
                 reachableThrough,
                 routingPath: []
             }
@@ -96,7 +121,7 @@ export class Router implements IRouter {
                 message: msg,
                 requestId: v4(),
                 destinationPeer: targetPeerDescriptor,
-                sourcePeer: this.ownPeerDescriptor,
+                sourcePeer: this.localPeerDescriptor,
                 reachableThrough,
                 routingPath: []
             }
@@ -104,23 +129,23 @@ export class Router implements IRouter {
         }
     }
 
-    public doRouteMessage(routedMessage: RouteMessageWrapper, mode = RoutingMode.ROUTE, excludedPeer?: PeerDescriptor): RouteMessageAck {
+    public doRouteMessage(routedMessage: RouteMessageWrapper, mode = RoutingMode.ROUTE): RouteMessageAck {
         if (this.stopped) {
             return createRouteMessageAck(routedMessage, RoutingErrors.STOPPED)
         }
-        logger.trace(`Routing message ${routedMessage.requestId} from ${keyFromPeerDescriptor(routedMessage.sourcePeer!)} `
-            + `to ${keyFromPeerDescriptor(routedMessage.destinationPeer!)}`)
-        routedMessage.routingPath.push(this.ownPeerDescriptor)
-        const session = this.createRoutingSession(routedMessage, mode, excludedPeer)
-        this.addRoutingSession(session)
-        try {
+        logger.trace(`Routing message ${routedMessage.requestId} from ${getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!)} `
+            + `to ${getNodeIdFromPeerDescriptor(routedMessage.destinationPeer!)}`)
+        const session = this.createRoutingSession(routedMessage, mode)
+        const contacts = session.findMoreContacts()
+        if (contacts.length > 0) {
+            this.addRoutingSession(session)
             // eslint-disable-next-line promise/catch-or-return
             logger.trace('starting to raceEvents from routingSession: ' + session.sessionId)
             let eventReceived: Promise<unknown>
             executeSafePromise(async () => {
                 eventReceived = raceEvents3<RoutingSessionEvents>(
                     session,
-                    ['routingSucceeded', 'partialSuccess', 'routingFailed', 'stopped', 'noCandidatesFound'],
+                    ['routingSucceeded', 'partialSuccess', 'routingFailed', 'stopped'],
                     null
                 )
             })
@@ -134,33 +159,29 @@ export class Router implements IRouter {
                 session.stop()
                 this.removeRoutingSession(session.sessionId) 
             })
-            session.start()
-        } catch (e) {
-            if (areEqualPeerDescriptors(routedMessage.sourcePeer!, this.ownPeerDescriptor)) {
-                logger.warn(
-                    `Failed to send (routeMessage: ${this.serviceId}) to ${keyFromPeerDescriptor(routedMessage.destinationPeer!)}: ${e}`
+            session.sendMoreRequests(contacts)
+            return createRouteMessageAck(routedMessage)
+        } else {
+            if (areEqualPeerDescriptors(routedMessage.sourcePeer!, this.localPeerDescriptor)) {
+                logger.debug(
+                    `Failed to send (routeMessage: ${this.serviceId}) to ${getNodeIdFromPeerDescriptor(routedMessage.destinationPeer!)}`
                 )
             }
+            logger.trace('noCandidatesFound sessionId: ' + session.sessionId)
             return createRouteMessageAck(routedMessage, RoutingErrors.NO_CANDIDATES_FOUND)
         }
-        return createRouteMessageAck(routedMessage)
     }
 
-    private createRoutingSession(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedPeer?: PeerDescriptor): RoutingSession {
-        const excludedPeers = routedMessage.routingPath.map((descriptor) => peerIdFromPeerDescriptor(descriptor))
-        if (excludedPeer) {
-            excludedPeers.push(peerIdFromPeerDescriptor(excludedPeer))
-        }
-        logger.trace(' routing session created with connections: ' + this.connections.size )
+    private createRoutingSession(routedMessage: RouteMessageWrapper, mode: RoutingMode): RoutingSession {
+        logger.trace('routing session created with connections: ' + this.connections.size)
         return new RoutingSession(
             this.rpcCommunicator,
-            this.ownPeerDescriptor,
+            this.localPeerDescriptor,
             routedMessage,
             this.connections,
-            areEqualPeerDescriptors(this.ownPeerDescriptor, routedMessage.sourcePeer!) ? 2 : 1,
+            areEqualPeerDescriptors(this.localPeerDescriptor, routedMessage.sourcePeer!) ? 2 : 1,
             mode,
-            undefined,
-            excludedPeers
+            routedMessage.routingPath.map((descriptor) => peerIdFromPeerDescriptor(descriptor))
         )
     }
 
@@ -192,32 +213,10 @@ export class Router implements IRouter {
         this.forwardingTable.clear()
         this.duplicateRequestDetector.clear()
     }
-    
-    // IRouterRpc method
-    async routeMessage(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
-        if (this.stopped) {
-            return createRouteMessageAck(routedMessage, 'routeMessage() service is not running')
-        } else if (this.duplicateRequestDetector.isMostLikelyDuplicate(routedMessage.requestId)) {
-            logger.trace(`Routing message ${routedMessage.requestId} from ${keyFromPeerDescriptor(routedMessage.sourcePeer!)} `
-                + `to ${keyFromPeerDescriptor(routedMessage.destinationPeer!)} is likely a duplicate`)
-            return createRouteMessageAck(routedMessage, 'message given to routeMessage() service is likely a duplicate')
-        }
-        logger.trace(`Processing received routeMessage ${routedMessage.requestId}`)
-        this.addContact(routedMessage.sourcePeer!, true)
-        this.addToDuplicateDetector(routedMessage.requestId)
-        if (areEqualPeerDescriptors(this.ownPeerDescriptor, routedMessage.destinationPeer!)) {
-            logger.trace(`routing message targeted to self ${routedMessage.requestId}`)
-            this.setForwardingEntries(routedMessage)
-            this.connectionManager?.handleMessage(routedMessage.message!)
-            return createRouteMessageAck(routedMessage)
-        } else {
-            return this.doRouteMessage(routedMessage)
-        }
-    }
 
     private setForwardingEntries(routedMessage: RouteMessageWrapper): void {
         const reachableThroughWithoutSelf = routedMessage.reachableThrough.filter((peer) => {
-            return !areEqualPeerDescriptors(peer, this.ownPeerDescriptor)
+            return !areEqualPeerDescriptors(peer, this.localPeerDescriptor)
         })
         
         if (reachableThroughWithoutSelf.length > 0) {
@@ -236,34 +235,4 @@ export class Router implements IRouter {
             this.forwardingTable.set(sourceKey, forwardingEntry)
         }
     }
-
-    // IRouterRpc method
-    async forwardMessage(forwardMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
-        if (this.stopped) {
-            return createRouteMessageAck(forwardMessage, 'forwardMessage() service is not running')
-        } else if (this.duplicateRequestDetector.isMostLikelyDuplicate(forwardMessage.requestId)) {
-            logger.trace(`Forwarding message ${forwardMessage.requestId} from ${keyFromPeerDescriptor(forwardMessage.sourcePeer!)} `
-                + `to ${keyFromPeerDescriptor(forwardMessage.destinationPeer!)} is likely a duplicate`)
-            return createRouteMessageAck(forwardMessage, 'message given to forwardMessage() service is likely a duplicate')
-        }
-        logger.trace(`Processing received forward routeMessage ${forwardMessage.requestId}`)
-        this.addContact(forwardMessage.sourcePeer!, true)
-        this.addToDuplicateDetector(forwardMessage.requestId)
-        if (areEqualPeerDescriptors(this.ownPeerDescriptor, forwardMessage.destinationPeer!)) {
-            return this.forwardToDestination(forwardMessage)
-        } else {
-            return this.doRouteMessage(forwardMessage, RoutingMode.FORWARD)
-        }
-    }
-
-    private forwardToDestination(routedMessage: RouteMessageWrapper): RouteMessageAck {
-        logger.trace(`Forwarding found message targeted to self ${routedMessage.requestId}`)
-        const forwardedMessage = routedMessage.message!
-        if (areEqualPeerDescriptors(this.ownPeerDescriptor, forwardedMessage.targetDescriptor!)) {
-            this.connectionManager?.handleMessage(forwardedMessage)
-            return createRouteMessageAck(routedMessage)
-        }
-        return this.doRouteMessage({ ...routedMessage, destinationPeer: forwardedMessage.targetDescriptor })
-    }
-
 }

package/src/dht/routing/RouterRpcLocal.ts

@@ -0,0 +1,81 @@
+import { Logger } from '@streamr/utils'
+import { ConnectionManager } from '../../connection/ConnectionManager'
+import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+import { IRouterRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { DuplicateDetector } from './DuplicateDetector'
+import { RoutingMode } from './RoutingSession'
+
+interface RouterRpcLocalConfig {
+    doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => RouteMessageAck
+    addContact: (contact: PeerDescriptor, setActive: boolean) => void
+    setForwardingEntries: (routedMessage: RouteMessageWrapper) => void
+    duplicateRequestDetector: DuplicateDetector
+    localPeerDescriptor: PeerDescriptor
+    connectionManager?: ConnectionManager
+}
+
+const logger = new Logger(module)
+
+export const createRouteMessageAck = (routedMessage: RouteMessageWrapper, error?: string): RouteMessageAck => {
+    const ack: RouteMessageAck = {
+        requestId: routedMessage.requestId,
+        error: error ? error : ''
+    }
+    return ack
+}
+
+export class RouterRpcLocal implements IRouterRpc {
+
+    private readonly config: RouterRpcLocalConfig
+
+    constructor(config: RouterRpcLocalConfig) {
+        this.config = config
+    }
+
+    async routeMessage(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
+        if (this.config.duplicateRequestDetector.isMostLikelyDuplicate(routedMessage.requestId)) {
+            logger.trace(`Routing message ${routedMessage.requestId} from ${getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!)} `
+                + `to ${getNodeIdFromPeerDescriptor(routedMessage.destinationPeer!)} is likely a duplicate`)
+            return createRouteMessageAck(routedMessage, 'message given to routeMessage() service is likely a duplicate')
+        }
+        logger.trace(`Processing received routeMessage ${routedMessage.requestId}`)
+        this.config.addContact(routedMessage.sourcePeer!, true)
+        this.config.duplicateRequestDetector.add(routedMessage.requestId)
+        if (areEqualPeerDescriptors(this.config.localPeerDescriptor, routedMessage.destinationPeer!)) {
+            logger.trace(`routing message targeted to self ${routedMessage.requestId}`)
+            this.config.setForwardingEntries(routedMessage)
+            this.config.connectionManager?.handleMessage(routedMessage.message!)
+            return createRouteMessageAck(routedMessage)
+        } else {
+            return this.config.doRouteMessage(routedMessage)
+        }
+    }
+
+    async forwardMessage(forwardMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
+        if (this.config.duplicateRequestDetector.isMostLikelyDuplicate(forwardMessage.requestId)) {
+            logger.trace(`Forwarding message ${forwardMessage.requestId} from ${getNodeIdFromPeerDescriptor(forwardMessage.sourcePeer!)} `
+                + `to ${getNodeIdFromPeerDescriptor(forwardMessage.destinationPeer!)} is likely a duplicate`)
+            return createRouteMessageAck(forwardMessage, 'message given to forwardMessage() service is likely a duplicate')
+        }
+        logger.trace(`Processing received forward routeMessage ${forwardMessage.requestId}`)
+        this.config.addContact(forwardMessage.sourcePeer!, true)
+        this.config.duplicateRequestDetector.add(forwardMessage.requestId)
+        if (areEqualPeerDescriptors(this.config.localPeerDescriptor, forwardMessage.destinationPeer!)) {
+            return this.forwardToDestination(forwardMessage)
+        } else {
+            return this.config.doRouteMessage(forwardMessage, RoutingMode.FORWARD)
+        }
+    }
+
+    private forwardToDestination(routedMessage: RouteMessageWrapper): RouteMessageAck {
+        logger.trace(`Forwarding found message targeted to self ${routedMessage.requestId}`)
+        const forwardedMessage = routedMessage.message!
+        if (areEqualPeerDescriptors(this.config.localPeerDescriptor, forwardedMessage.targetDescriptor!)) {
+            this.config.connectionManager?.handleMessage(forwardedMessage)
+            return createRouteMessageAck(routedMessage)
+        }
+        return this.config.doRouteMessage({ ...routedMessage, destinationPeer: forwardedMessage.targetDescriptor })
+    }
+
+}

package/src/dht/routing/RouterRpcRemote.ts

@@ -2,12 +2,12 @@ import { RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { v4 } from 'uuid'
 import {
     areEqualPeerDescriptors,
-    keyFromPeerDescriptor,
-    peerIdFromPeerDescriptor
+    getNodeIdFromPeerDescriptor
 } from '../../helpers/peerIdFromPeerDescriptor'
 import { IRouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Remote } from '../contact/Remote'
 import { Logger } from '@streamr/utils'
+import { getPreviousPeer } from './getPreviousPeer'
 
 const logger = new Logger(module)
 
@@ -17,15 +17,12 @@ export class RouterRpcRemote extends Remote<IRouterRpcClient> {
         const message: RouteMessageWrapper = {
             destinationPeer: params.destinationPeer,
             sourcePeer: params.sourcePeer,
-            previousPeer: params.previousPeer,
             message: params.message,
-            requestId: params.requestId || v4(),
-            reachableThrough: params.reachableThrough || [],
+            requestId: params.requestId ?? v4(),
+            reachableThrough: params.reachableThrough ?? [],
             routingPath: params.routingPath
         }
-        const options = this.formDhtRpcOptions({
-            timeout: 10000
-        })
+        const options = this.formDhtRpcOptions()
         try {
             const ack = await this.getClient().routeMessage(message, options)
             // Success signal if sent to destination and error includes duplicate
@@ -38,9 +35,11 @@ export class RouterRpcRemote extends Remote<IRouterRpcClient> {
                 return false
             }
         } catch (err) {
-            const fromNode = params.previousPeer ?
-                peerIdFromPeerDescriptor(params.previousPeer) : keyFromPeerDescriptor(params.sourcePeer!)
-            logger.trace(`Failed to send routeMessage from ${fromNode} to ${keyFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
+            const previousPeer = getPreviousPeer(params)
+            const fromNode = previousPeer
+                ? getNodeIdFromPeerDescriptor(previousPeer)
+                : getNodeIdFromPeerDescriptor(params.sourcePeer!)
+            logger.trace(`Failed to send routeMessage from ${fromNode} to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
             return false
         }
         return true
@@ -50,57 +49,27 @@ export class RouterRpcRemote extends Remote<IRouterRpcClient> {
         const message: RouteMessageWrapper = {
             destinationPeer: params.destinationPeer,
             sourcePeer: params.sourcePeer,
-            previousPeer: params.previousPeer,
             message: params.message,
-            requestId: params.requestId || v4(),
-            reachableThrough: params.reachableThrough || [],
+            requestId: params.requestId ?? v4(),
+            reachableThrough: params.reachableThrough ?? [],
             routingPath: params.routingPath
         }
-        const options = this.formDhtRpcOptions({
-            timeout: 10000
-        })
+        const options = this.formDhtRpcOptions()
         try {
             const ack = await this.getClient().forwardMessage(message, options)
             if (ack.error.length > 0) {
                 return false
             }
         } catch (err) {
-            const fromNode = params.previousPeer ?
-                keyFromPeerDescriptor(params.previousPeer) : keyFromPeerDescriptor(params.sourcePeer!)
-
+            const previousPeer = getPreviousPeer(params)
+            const fromNode = previousPeer
+                ? getNodeIdFromPeerDescriptor(previousPeer)
+                : getNodeIdFromPeerDescriptor(params.sourcePeer!)
             logger.trace(
-                `Failed to send forwardMessage from ${fromNode} to ${keyFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`
+                `Failed to send forwardMessage from ${fromNode} to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`
             )
             return false
         }
         return true
     }
-
-    async findRecursively(params: RouteMessageWrapper): Promise<boolean> {
-        const message: RouteMessageWrapper = {
-            destinationPeer: params.destinationPeer,
-            sourcePeer: params.sourcePeer,
-            previousPeer: params.previousPeer,
-            message: params.message,
-            requestId: params.requestId || v4(),
-            reachableThrough: params.reachableThrough || [],
-            routingPath: params.routingPath
-        }
-        const options = this.formDhtRpcOptions({
-            timeout: 10000
-        })
-        try {
-            const ack = await this.getClient().findRecursively(message, options)
-            if (ack.error.length > 0) {
-                logger.debug('Next hop responded with error ' + ack.error)
-                return false
-            }
-        } catch (err) {
-            const fromNode = params.previousPeer ? keyFromPeerDescriptor(params.previousPeer) : keyFromPeerDescriptor(params.sourcePeer!)
-            logger.debug(`Failed to send recursiveFind message from ${fromNode} to ${keyFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
-            return false
-        }
-        return true
-    }
-
 }