@streamr/dht 100.0.0-testnet-one.4 → 100.0.0-testnet-two.0

package/src/dht/routing/Router.ts

@@ -1,30 +1,24 @@
 import { Message, PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import {
     areEqualPeerDescriptors,
-    getNodeIdFromPeerDescriptor,
-    keyFromPeerDescriptor,
-    peerIdFromPeerDescriptor
+    getNodeIdFromPeerDescriptor
 } 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 { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { v4 } from 'uuid'
 import { RouterRpcLocal, createRouteMessageAck } from './RouterRpcLocal'
-import { ServiceID } from '../../types/ServiceID'
+import { NodeID, getNodeIdFromBinary } from '../../helpers/nodeId'
 
 export interface RouterConfig {
     rpcCommunicator: RoutingRpcCommunicator
     localPeerDescriptor: PeerDescriptor
-    connections: Map<PeerIDKey, DhtNodeRpcRemote>
+    connections: Map<NodeID, DhtNodeRpcRemote>
     addContact: (contact: PeerDescriptor, setActive?: boolean) => void
-    serviceId: ServiceID
     connectionManager?: ConnectionManager
-    rpcRequestTimeout?: number
-
 }
 
 interface ForwardingTableEntry {
@@ -32,46 +26,32 @@ interface ForwardingTableEntry {
     peerDescriptors: PeerDescriptor[]
 }
 
-export interface IRouter {
-    doRouteMessage(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedPeer?: PeerDescriptor): RouteMessageAck
-    send(msg: Message, reachableThrough: PeerDescriptor[]): void
-    isMostLikelyDuplicate(requestId: string): boolean
-    addToDuplicateDetector(requestId: string): void
-    addRoutingSession(session: RoutingSession): void
-    removeRoutingSession(sessionId: string): void
-    stop(): void
-}
-
 const logger = new Logger(module)
 
-export class Router implements IRouter {
-    private readonly rpcCommunicator: RoutingRpcCommunicator
-    private readonly localPeerDescriptor: PeerDescriptor
-    private readonly connections: Map<PeerIDKey, DhtNodeRpcRemote>
-    private readonly serviceId: ServiceID
-    private readonly forwardingTable: Map<string, ForwardingTableEntry> = new Map()
+export class Router {
+
+    private readonly forwardingTable: Map<NodeID, 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 stopped = false
+    private readonly config: RouterConfig
 
     constructor(config: RouterConfig) {
-        this.rpcCommunicator = config.rpcCommunicator
-        this.localPeerDescriptor = config.localPeerDescriptor
-        this.connections = config.connections
-        this.serviceId = config.serviceId
-        this.registerLocalRpcMethods(config)
+        this.config = config
+        this.registerLocalRpcMethods()
     }
 
-    private registerLocalRpcMethods(config: RouterConfig) {
+    private registerLocalRpcMethods() {
         const rpcLocal = new RouterRpcLocal({
             doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => this.doRouteMessage(routedMessage, mode),
-            addContact: (contact: PeerDescriptor, setActive: boolean) => config.addContact(contact, setActive),
+            addContact: (contact: PeerDescriptor, setActive: boolean) => this.config.addContact(contact, setActive),
             setForwardingEntries: (routedMessage: RouteMessageWrapper) => this.setForwardingEntries(routedMessage),
             duplicateRequestDetector: this.duplicateRequestDetector,
-            localPeerDescriptor: this.localPeerDescriptor,
-            connectionManager: config.connectionManager
+            localPeerDescriptor: this.config.localPeerDescriptor,
+            connectionManager: this.config.connectionManager
         })
-        this.rpcCommunicator.registerRpcMethod(
+        this.config.rpcCommunicator.registerRpcMethod(
             RouteMessageWrapper,
             RouteMessageAck,
             'routeMessage',
@@ -82,7 +62,7 @@ export class Router implements IRouter {
                 return rpcLocal.routeMessage(routedMessage)
             }
         )
-        this.rpcCommunicator.registerRpcMethod(
+        this.config.rpcCommunicator.registerRpcMethod(
             RouteMessageWrapper,
             RouteMessageAck,
             'forwardMessage',
@@ -97,16 +77,15 @@ export class Router implements IRouter {
     }
 
     public send(msg: Message, reachableThrough: PeerDescriptor[]): void {
-        msg.sourceDescriptor = this.localPeerDescriptor
+        msg.sourceDescriptor = this.config.localPeerDescriptor
         const targetPeerDescriptor = msg.targetDescriptor!
-        const forwardingEntry = this.forwardingTable.get(keyFromPeerDescriptor(targetPeerDescriptor))
+        const forwardingEntry = this.forwardingTable.get(getNodeIdFromPeerDescriptor(targetPeerDescriptor))
         if (forwardingEntry && forwardingEntry.peerDescriptors.length > 0) {
-            const forwardingPeer = forwardingEntry.peerDescriptors[0]
             const forwardedMessage: RouteMessageWrapper = {
                 message: msg,
                 requestId: v4(),
-                destinationPeer: forwardingPeer,
-                sourcePeer: this.localPeerDescriptor,
+                target: forwardingEntry.peerDescriptors[0].nodeId,
+                sourcePeer: this.config.localPeerDescriptor,
                 reachableThrough,
                 routingPath: []
             }
@@ -120,8 +99,8 @@ export class Router implements IRouter {
             const routedMessage: RouteMessageWrapper = {
                 message: msg,
                 requestId: v4(),
-                destinationPeer: targetPeerDescriptor,
-                sourcePeer: this.localPeerDescriptor,
+                target: targetPeerDescriptor.nodeId,
+                sourcePeer: this.config.localPeerDescriptor,
                 reachableThrough,
                 routingPath: []
             }
@@ -139,7 +118,7 @@ export class Router implements IRouter {
             return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
         }
         logger.trace(`Routing message ${routedMessage.requestId} from ${getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!)} `
-            + `to ${getNodeIdFromPeerDescriptor(routedMessage.destinationPeer!)}`)
+            + `to ${getNodeIdFromBinary(routedMessage.target)}`)
         const session = this.createRoutingSession(routedMessage, mode, excludedPeer)
         const contacts = session.updateAndGetRoutablePeers()
         if (contacts.length > 0) {
@@ -157,6 +136,7 @@ export class Router implements IRouter {
             })
             setImmediate(async () => {
                 try {
+                    // TODO use config option or named constant?
                     await withTimeout(eventReceived, 10000)
                     logger.trace('raceEvents ended from routingSession: ' + session.sessionId)
                 } catch (e) {
@@ -173,21 +153,22 @@ export class Router implements IRouter {
         }
     }
 
-    private createRoutingSession(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedPeer?: PeerDescriptor): RoutingSession {
-        const excludedPeers = routedMessage.routingPath.map((descriptor) => peerIdFromPeerDescriptor(descriptor))
-        if (excludedPeer) {
-            excludedPeers.push(peerIdFromPeerDescriptor(excludedPeer))
+    private createRoutingSession(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedNode?: PeerDescriptor): RoutingSession {
+        const excludedNodeIds = new Set<NodeID>(routedMessage.routingPath.map((descriptor) => getNodeIdFromPeerDescriptor(descriptor)))
+        if (excludedNode) {
+            excludedNodeIds.add(getNodeIdFromPeerDescriptor(excludedNode))
         }
-        logger.trace('routing session created with connections: ' + this.connections.size)
-        return new RoutingSession(
-            this.rpcCommunicator,
-            this.localPeerDescriptor,
+        logger.trace('routing session created with connections: ' + this.config.connections.size)
+        return new RoutingSession({
+            rpcCommunicator: this.config.rpcCommunicator,
+            localPeerDescriptor: this.config.localPeerDescriptor,
             routedMessage,
-            this.connections,
-            areEqualPeerDescriptors(this.localPeerDescriptor, routedMessage.sourcePeer!) ? 2 : 1,
+            connections: this.config.connections,
+            // TODO use config option or named constant?
+            parallelism: areEqualPeerDescriptors(this.config.localPeerDescriptor, routedMessage.sourcePeer!) ? 2 : 1,
             mode,
-            excludedPeers
-        )
+            excludedNodeIds
+        })
     }
 
     public isMostLikelyDuplicate(requestId: string): boolean {
@@ -221,23 +202,23 @@ export class Router implements IRouter {
 
     private setForwardingEntries(routedMessage: RouteMessageWrapper): void {
         const reachableThroughWithoutSelf = routedMessage.reachableThrough.filter((peer) => {
-            return !areEqualPeerDescriptors(peer, this.localPeerDescriptor)
+            return !areEqualPeerDescriptors(peer, this.config.localPeerDescriptor)
         })
         
         if (reachableThroughWithoutSelf.length > 0) {
-            const sourceKey = keyFromPeerDescriptor(routedMessage.sourcePeer!)
-            if (this.forwardingTable.has(sourceKey)) {
-                const oldEntry = this.forwardingTable.get(sourceKey)
+            const sourceNodeId = getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!)
+            if (this.forwardingTable.has(sourceNodeId)) {
+                const oldEntry = this.forwardingTable.get(sourceNodeId)
                 clearTimeout(oldEntry!.timeout)
-                this.forwardingTable.delete(sourceKey)
+                this.forwardingTable.delete(sourceNodeId)
             }
             const forwardingEntry: ForwardingTableEntry = {
                 peerDescriptors: reachableThroughWithoutSelf,
                 timeout: setTimeout(() => {
-                    this.forwardingTable.delete(sourceKey)
-                }, 10000)
+                    this.forwardingTable.delete(sourceNodeId)
+                }, 10000)  // TODO use config option or named constant?
             }
-            this.forwardingTable.set(sourceKey, forwardingEntry)
+            this.forwardingTable.set(sourceNodeId, forwardingEntry)
         }
     }
 }

package/src/dht/routing/RouterRpcLocal.ts

@@ -1,10 +1,11 @@
-import { Logger } from '@streamr/utils'
+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 { getNodeIdFromBinary } from '../../helpers/nodeId'
 
 interface RouterRpcLocalConfig {
     doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => RouteMessageAck
@@ -36,13 +37,13 @@ export class RouterRpcLocal implements IRouterRpc {
     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`)
+                + `to ${getNodeIdFromBinary(routedMessage.target)} is likely a duplicate`)
             return createRouteMessageAck(routedMessage, RouteMessageError.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!)) {
+        if (areEqualBinaries(this.config.localPeerDescriptor.nodeId, routedMessage.target)) {
             logger.trace(`routing message targeted to self ${routedMessage.requestId}`)
             this.config.setForwardingEntries(routedMessage)
             this.config.connectionManager?.handleMessage(routedMessage.message!)
@@ -55,13 +56,13 @@ export class RouterRpcLocal implements IRouterRpc {
     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`)
+                + `to ${getNodeIdFromBinary(forwardMessage.target)} is likely a duplicate`)
             return createRouteMessageAck(forwardMessage, RouteMessageError.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!)) {
+        if (areEqualBinaries(this.config.localPeerDescriptor.nodeId, forwardMessage.target)) {
             return this.forwardToDestination(forwardMessage)
         } else {
             return this.config.doRouteMessage(forwardMessage, RoutingMode.FORWARD)
@@ -75,7 +76,7 @@ export class RouterRpcLocal implements IRouterRpc {
             this.config.connectionManager?.handleMessage(forwardedMessage)
             return createRouteMessageAck(routedMessage)
         }
-        return this.config.doRouteMessage({ ...routedMessage, destinationPeer: forwardedMessage.targetDescriptor })
+        return this.config.doRouteMessage({ ...routedMessage, target: forwardedMessage.targetDescriptor!.nodeId })
     }
 
 }

package/src/dht/routing/RouterRpcRemote.ts

@@ -1,21 +1,20 @@
-import { RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+import { Logger, areEqualBinaries } from '@streamr/utils'
 import { v4 } from 'uuid'
 import {
-    areEqualPeerDescriptors,
     getNodeIdFromPeerDescriptor
 } from '../../helpers/peerIdFromPeerDescriptor'
-import { IRouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+import { RouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { RpcRemote } from '../contact/RpcRemote'
-import { Logger } from '@streamr/utils'
 import { getPreviousPeer } from './getPreviousPeer'
 
 const logger = new Logger(module)
 
-export class RouterRpcRemote extends RpcRemote<IRouterRpcClient> {
+export class RouterRpcRemote extends RpcRemote<RouterRpcClient> {
 
     async routeMessage(params: RouteMessageWrapper): Promise<boolean> {
         const message: RouteMessageWrapper = {
-            destinationPeer: params.destinationPeer,
+            target: params.target,
             sourcePeer: params.sourcePeer,
             message: params.message,
             requestId: params.requestId ?? v4(),
@@ -23,13 +22,13 @@ export class RouterRpcRemote extends RpcRemote<IRouterRpcClient> {
             routingPath: params.routingPath
         }
         const options = this.formDhtRpcOptions({
-            doNotConnect: true
+            connect: false
         })
         try {
             const ack = await this.getClient().routeMessage(message, options)
             // Success signal if sent to destination and error includes duplicate
             if (ack.error === RouteMessageError.DUPLICATE
-                && areEqualPeerDescriptors(params.destinationPeer!, this.getPeerDescriptor())
+                && areEqualBinaries(params.target, this.getPeerDescriptor().nodeId)
             ) {
                 return true
             } else if (ack.error !== undefined) {
@@ -48,7 +47,7 @@ export class RouterRpcRemote extends RpcRemote<IRouterRpcClient> {
 
     async forwardMessage(params: RouteMessageWrapper): Promise<boolean> {
         const message: RouteMessageWrapper = {
-            destinationPeer: params.destinationPeer,
+            target: params.target,
             sourcePeer: params.sourcePeer,
             message: params.message,
             requestId: params.requestId ?? v4(),
@@ -56,7 +55,7 @@ export class RouterRpcRemote extends RpcRemote<IRouterRpcClient> {
             routingPath: params.routingPath
         }
         const options = this.formDhtRpcOptions({
-            doNotConnect: true
+            connect: false
         })
         try {
             const ack = await this.getClient().forwardMessage(message, options)

package/src/dht/routing/RoutingSession.ts

@@ -1,19 +1,18 @@
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { SortedContactList } from '../contact/SortedContactList'
-import { PeerID, PeerIDKey } from '../../helpers/PeerID'
-import { getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { v4 } from 'uuid'
 import { PeerDescriptor, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { RouterRpcRemote } from './RouterRpcRemote'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { FindRpcClient, RouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { RecursiveOperationRpcClient, RouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Contact } from '../contact/Contact'
-import { FindRpcRemote } from './FindRpcRemote'
+import { RecursiveOperationRpcRemote } from '../recursive-operation/RecursiveOperationRpcRemote'
 import { EXISTING_CONNECTION_TIMEOUT } from '../contact/RpcRemote'
 import { getPreviousPeer } from './getPreviousPeer'
+import { NodeID, getNodeIdFromBinary } from '../../helpers/nodeId'
 
 const logger = new Logger(module)
 
@@ -22,7 +21,7 @@ const MAX_FAILED_HOPS = 2
 class RemoteContact extends Contact {
 
     private routerRpcRemote: RouterRpcRemote
-    private findRpcRemote: FindRpcRemote
+    private recursiveOperationRpcRemote: RecursiveOperationRpcRemote
 
     constructor(peer: DhtNodeRpcRemote, localPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
         super(peer.getPeerDescriptor())
@@ -30,14 +29,16 @@ class RemoteContact extends Contact {
             localPeerDescriptor,
             peer.getPeerDescriptor(),
             peer.getServiceId(),
-            toProtoRpcClient(new RouterRpcClient(rpcCommunicator.getRpcClientTransport())),
+            rpcCommunicator,
+            RouterRpcClient,
             EXISTING_CONNECTION_TIMEOUT
         )
-        this.findRpcRemote = new FindRpcRemote(
+        this.recursiveOperationRpcRemote = new RecursiveOperationRpcRemote(
             localPeerDescriptor,
             peer.getPeerDescriptor(),
             peer.getServiceId(),
-            toProtoRpcClient(new FindRpcClient(rpcCommunicator.getRpcClientTransport())),
+            rpcCommunicator,
+            RecursiveOperationRpcClient,
             EXISTING_CONNECTION_TIMEOUT
         )
     }
@@ -46,75 +47,66 @@ class RemoteContact extends Contact {
         return this.routerRpcRemote
     }
 
-    getFindRpcRemote(): FindRpcRemote {
-        return this.findRpcRemote
+    getRecursiveOperationRpcRemote(): RecursiveOperationRpcRemote {
+        return this.recursiveOperationRpcRemote
     }
 }
 
 export interface RoutingSessionEvents {
     // This event is emitted when a peer responds with a success ack
     // to routeMessage call
-    routingSucceeded: (sessionId: string) => void
-    partialSuccess: (sessionId: string) => void
-
+    routingSucceeded: () => void
+    partialSuccess: () => void
     // This event is emitted when all the candidates have been gone
     // through, and none of them responds with a success ack
-    routingFailed: (sessionId: string) => void
-    stopped: (sessionId: string) => void
+    routingFailed: () => void
+    stopped: () => void
 }
 
-export enum RoutingMode { ROUTE, FORWARD, FIND }
+export enum RoutingMode { ROUTE, FORWARD, RECURSIVE }
+
+interface RoutingSessionConfig {
+    rpcCommunicator: RoutingRpcCommunicator
+    localPeerDescriptor: PeerDescriptor
+    routedMessage: RouteMessageWrapper
+    connections: Map<NodeID, DhtNodeRpcRemote>
+    parallelism: number
+    mode: RoutingMode
+    excludedNodeIds?: Set<NodeID>
+}
 
 export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
 
     public readonly sessionId = v4()
-    private readonly rpcCommunicator: RoutingRpcCommunicator
-    private ongoingRequests: Set<PeerIDKey> = new Set()
+    private ongoingRequests: Set<NodeID> = new Set()
     private contactList: SortedContactList<RemoteContact>
-    private readonly localPeerDescriptor: PeerDescriptor
-    private readonly messageToRoute: RouteMessageWrapper
-    private connections: Map<PeerIDKey, DhtNodeRpcRemote>
-    private readonly parallelism: number
     private failedHopCounter = 0
     private successfulHopCounter = 0
-    private readonly mode: RoutingMode = RoutingMode.ROUTE
     private stopped = false
+    private readonly config: RoutingSessionConfig
 
-    constructor(
-        rpcCommunicator: RoutingRpcCommunicator,
-        localPeerDescriptor: PeerDescriptor,
-        messageToRoute: RouteMessageWrapper,
-        connections: Map<PeerIDKey, DhtNodeRpcRemote>,
-        parallelism: number,
-        mode: RoutingMode = RoutingMode.ROUTE,
-        excludedPeerIDs?: PeerID[]
-    ) {
+    constructor(config: RoutingSessionConfig) {
         super()
-        this.rpcCommunicator = rpcCommunicator
-        this.localPeerDescriptor = localPeerDescriptor
-        this.messageToRoute = messageToRoute
-        this.connections = connections
-        this.parallelism = parallelism
-        this.mode = mode
-        const previousPeer = getPreviousPeer(messageToRoute)
-        const previousId = previousPeer ? PeerID.fromValue(previousPeer.nodeId) : undefined
+        this.config = config
+        const previousPeer = getPreviousPeer(config.routedMessage)
+        const previousId = previousPeer ? getNodeIdFromPeerDescriptor(previousPeer) : undefined
         this.contactList = new SortedContactList({
-            referenceId: PeerID.fromValue(this.messageToRoute.destinationPeer!.nodeId),
+            referenceId: getNodeIdFromBinary(config.routedMessage.target),
             maxSize: 10000,  // TODO use config option or named constant?
             allowToContainReferenceId: true,
-            peerIdDistanceLimit: previousId,
-            excludedPeerIDs: excludedPeerIDs,
+            nodeIdDistanceLimit: previousId,
+            excludedNodeIds: config.excludedNodeIds,
             emitEvents: false
         })
     }
 
-    private onRequestFailed(peerId: PeerID) {
+    private onRequestFailed(nodeId: NodeID) {
         logger.trace('onRequestFailed() sessionId: ' + this.sessionId)
         if (this.stopped) {
             return
         }
-        if (this.ongoingRequests.has(peerId.toKey())) {
-            this.ongoingRequests.delete(peerId.toKey())
+        if (this.ongoingRequests.has(nodeId)) {
+            this.ongoingRequests.delete(nodeId)
         }
         const contacts = this.updateAndGetRoutablePeers()
         if (contacts.length === 0 && this.ongoingRequests.size === 0) {
@@ -131,9 +123,9 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
 
     private emitFailure() {
         if (this.successfulHopCounter >= 1) {
-            this.emit('partialSuccess', this.sessionId)
+            this.emit('partialSuccess')
         } else {
-            this.emit('routingFailed', this.sessionId)
+            this.emit('routingFailed')
         }
     }
 
@@ -144,10 +136,10 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         }
         this.successfulHopCounter += 1
         const contacts = this.updateAndGetRoutablePeers()
-        if (this.successfulHopCounter >= this.parallelism || contacts.length === 0) {
+        if (this.successfulHopCounter >= this.config.parallelism || contacts.length === 0) {
             // TODO should call this.stop() so that we do cleanup? (after the routingSucceeded call)
             this.stopped = true
-            this.emit('routingSucceeded', this.sessionId)
+            this.emit('routingSucceeded')
         } else if (contacts.length > 0 && this.ongoingRequests.size === 0) {
             this.sendMoreRequests(contacts)
         }
@@ -158,13 +150,13 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             return false
         }
         const msg = {
-            ...this.messageToRoute,
-            routingPath: this.messageToRoute.routingPath.concat([this.localPeerDescriptor])
+            ...this.config.routedMessage,
+            routingPath: this.config.routedMessage.routingPath.concat([this.config.localPeerDescriptor])
         }
-        if (this.mode === RoutingMode.FORWARD) {
+        if (this.config.mode === RoutingMode.FORWARD) {
             return contact.getRouterRpcRemote().forwardMessage(msg)
-        } else if (this.mode === RoutingMode.FIND) {
-            return contact.getFindRpcRemote().routeFindRequest(msg)
+        } else if (this.config.mode === RoutingMode.RECURSIVE) {
+            return contact.getRecursiveOperationRpcRemote().routeRequest(msg)
         } else {
             return contact.getRouterRpcRemote().routeMessage(msg)
         }
@@ -173,16 +165,15 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
     updateAndGetRoutablePeers(): RemoteContact[] {
         logger.trace('getRoutablePeers() sessionId: ' + this.sessionId)
         // Remove stale contacts that may have been removed from connections
-        this.contactList.getAllContacts().forEach((contact) => {
-            const peerId = peerIdFromPeerDescriptor(contact.getPeerDescriptor())
-            if (this.connections.has(peerId.toKey()) === false) {
-                this.contactList.removeContact(peerId)
+        this.contactList.getContactIds().forEach((nodeId) => {
+            if (!this.config.connections.has(nodeId)) {
+                this.contactList.removeContact(nodeId)
             }
         })
-        const contacts = Array.from(this.connections.values())
-            .map((peer) => new RemoteContact(peer, this.localPeerDescriptor, this.rpcCommunicator))
+        const contacts = Array.from(this.config.connections.values())
+            .map((peer) => new RemoteContact(peer, this.config.localPeerDescriptor, this.config.rpcCommunicator))
         this.contactList.addContacts(contacts)
-        return this.contactList.getUncontactedContacts(this.parallelism)
+        return this.contactList.getUncontactedContacts(this.config.parallelism)
     }
 
     sendMoreRequests(uncontacted: RemoteContact[]): void {
@@ -199,19 +190,19 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             this.emitFailure()
             return
         }
-        while ((this.ongoingRequests.size < this.parallelism) && (uncontacted.length > 0) && !this.stopped) {
+        while ((this.ongoingRequests.size < this.config.parallelism) && (uncontacted.length > 0) && !this.stopped) {
             const nextPeer = uncontacted.shift()
             // eslint-disable-next-line max-len
             logger.trace(`Sending routeMessage request to contact: ${getNodeIdFromPeerDescriptor(nextPeer!.getPeerDescriptor())} (sessionId=${this.sessionId})`)
-            this.contactList.setContacted(nextPeer!.getPeerId())
-            this.ongoingRequests.add(nextPeer!.getPeerId().toKey())
+            this.contactList.setContacted(nextPeer!.getNodeId())
+            this.ongoingRequests.add(nextPeer!.getNodeId())
             setImmediate(async () => {
                 try {
                     const succeeded = await this.sendRouteMessageRequest(nextPeer!)
                     if (succeeded) {
                         this.onRequestSucceeded()
                     } else {
-                        this.onRequestFailed(nextPeer!.getPeerId())
+                        this.onRequestFailed(nextPeer!.getNodeId())
                     }
                 } catch (e) {
                     logger.debug('Unable to route message ', { error: e })
@@ -225,7 +216,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
     public stop(): void {
         this.stopped = true
         this.contactList.stop()
-        this.emit('stopped', this.sessionId)
+        this.emit('stopped')
         this.removeAllListeners()
     }
 }