@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-rc.0

package/src/dht/routing/Router.ts

@@ -1,35 +1,20 @@
-import { Message, PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
-import {
-    areEqualPeerDescriptors,
-    getNodeIdFromPeerDescriptor,
-    keyFromPeerDescriptor,
-    peerIdFromPeerDescriptor
-} from '../../helpers/peerIdFromPeerDescriptor'
-import { RoutingMode, RoutingSession, RoutingSessionEvents } from './RoutingSession'
+import { Message, PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+import { RoutingMode, RoutingRemoteContact, 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'
-
-export enum RoutingErrors {
-    NO_CANDIDATES_FOUND = 'No routing candidates found',
-    STOPPED = 'DhtNode Stopped'
-}
+import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { RoutingTablesCache } from './RoutingTablesCache'
 
 export interface RouterConfig {
     rpcCommunicator: RoutingRpcCommunicator
     localPeerDescriptor: PeerDescriptor
-    connections: Map<PeerIDKey, DhtNodeRpcRemote>
+    connections: Map<DhtAddress, DhtNodeRpcRemote>
     addContact: (contact: PeerDescriptor, setActive?: boolean) => void
-    serviceId: ServiceID
-    connectionManager?: ConnectionManager
-    rpcRequestTimeout?: number
-
+    handleMessage: (message: Message) => void
 }
 
 interface ForwardingTableEntry {
@@ -37,63 +22,50 @@ interface ForwardingTableEntry {
     peerDescriptors: PeerDescriptor[]
 }
 
-export interface IRouter {
-    doRouteMessage(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedPeer?: PeerDescriptor): RouteMessageAck
-    send(msg: Message, reachableThrough: PeerDescriptor[]): Promise<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<DhtAddress, ForwardingTableEntry> = new Map()
+    private readonly routingTablesCache = new RoutingTablesCache()
     private ongoingRoutingSessions: Map<string, RoutingSession> = new Map()
-    private readonly duplicateRequestDetector: DuplicateDetector = new DuplicateDetector(100000, 100)
+    // TODO use config option or named constant?
+    private readonly duplicateRequestDetector: DuplicateDetector = new DuplicateDetector(10000)
     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,
+            handleMessage: this.config.handleMessage
         })
-        this.rpcCommunicator.registerRpcMethod(
+        this.config.rpcCommunicator.registerRpcMethod(
             RouteMessageWrapper,
             RouteMessageAck,
             'routeMessage',
             async (routedMessage: RouteMessageWrapper) => {
                 if (this.stopped) {
-                    return createRouteMessageAck(routedMessage, 'routeMessage() service is not running')
+                    return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
                 }
                 return rpcLocal.routeMessage(routedMessage)
             }
         )
-        this.rpcCommunicator.registerRpcMethod(
+        this.config.rpcCommunicator.registerRpcMethod(
             RouteMessageWrapper,
             RouteMessageAck,
             'forwardMessage',
             async (forwardMessage: RouteMessageWrapper) => {
                 if (this.stopped) {
-                    return createRouteMessageAck(forwardMessage, 'forwardMessage() service is not running')
+                    return createRouteMessageAck(forwardMessage, RouteMessageError.STOPPED)
                 }
                 return rpcLocal.forwardMessage(forwardMessage)
             }
@@ -101,47 +73,59 @@ export class Router implements IRouter {
 
     }
 
-    public async send(msg: Message, reachableThrough: PeerDescriptor[]): Promise<void> {
-        msg.sourceDescriptor = this.localPeerDescriptor
+    public send(msg: Message, reachableThrough: PeerDescriptor[]): void {
+        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: []
+                routingPath: [],
+                parallelRootNodeIds: []
+            }
+            const ack = this.doRouteMessage(forwardedMessage, RoutingMode.FORWARD)
+            if (ack.error !== undefined) {
+                const error = 'Could not forward message with error ' + ack.error
+                logger.debug(error)
+                throw new Error(error)
             }
-            this.doRouteMessage(forwardedMessage, RoutingMode.FORWARD)
         } else {
             const routedMessage: RouteMessageWrapper = {
                 message: msg,
                 requestId: v4(),
-                destinationPeer: targetPeerDescriptor,
-                sourcePeer: this.localPeerDescriptor,
+                target: targetPeerDescriptor.nodeId,
+                sourcePeer: this.config.localPeerDescriptor,
                 reachableThrough,
-                routingPath: []
+                routingPath: [],
+                parallelRootNodeIds: []
+            }
+            const ack = this.doRouteMessage(routedMessage, RoutingMode.ROUTE)
+            if (ack.error !== undefined) {
+                const error = 'Could not route message with error ' + ack.error
+                logger.debug(error)
+                throw new Error(error)
             }
-            this.doRouteMessage(routedMessage, RoutingMode.ROUTE)
         }
     }
 
-    public doRouteMessage(routedMessage: RouteMessageWrapper, mode = RoutingMode.ROUTE): RouteMessageAck {
+    public doRouteMessage(routedMessage: RouteMessageWrapper, mode = RoutingMode.ROUTE, excludedPeer?: DhtAddress): RouteMessageAck {
         if (this.stopped) {
-            return createRouteMessageAck(routedMessage, RoutingErrors.STOPPED)
+            return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
         }
         logger.trace(`Routing message ${routedMessage.requestId} from ${getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!)} `
-            + `to ${getNodeIdFromPeerDescriptor(routedMessage.destinationPeer!)}`)
-        const session = this.createRoutingSession(routedMessage, mode)
-        const contacts = session.findMoreContacts()
+            + `to ${getDhtAddressFromRaw(routedMessage.target)}`)
+        const session = this.createRoutingSession(routedMessage, mode, excludedPeer)
+        const contacts = session.updateAndGetRoutablePeers()
         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>
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
             executeSafePromise(async () => {
                 eventReceived = raceEvents3<RoutingSessionEvents>(
                     session,
@@ -151,6 +135,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) {
@@ -162,27 +147,31 @@ export class Router implements IRouter {
             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)
+            logger.trace('no targets', { sessionId: session.sessionId })
+            return createRouteMessageAck(routedMessage, RouteMessageError.NO_TARGETS)
         }
     }
 
-    private createRoutingSession(routedMessage: RouteMessageWrapper, mode: RoutingMode): RoutingSession {
-        logger.trace('routing session created with connections: ' + this.connections.size)
-        return new RoutingSession(
-            this.rpcCommunicator,
-            this.localPeerDescriptor,
+    private createRoutingSession(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedNode?: DhtAddress): RoutingSession {
+        const excludedNodeIds = new Set<DhtAddress>(routedMessage.routingPath.map((descriptor) => getNodeIdFromPeerDescriptor(descriptor)))
+        if (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,
+            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,
-            routedMessage.routingPath.map((descriptor) => peerIdFromPeerDescriptor(descriptor))
-        )
+            excludedNodeIds,
+            routingTablesCache: this.routingTablesCache
+        })
     }
 
     public isMostLikelyDuplicate(requestId: string): boolean {
@@ -201,6 +190,19 @@ export class Router implements IRouter {
         this.ongoingRoutingSessions.delete(sessionId)
     }
 
+    onNodeConnected(peerDescriptor: PeerDescriptor): void {
+        const remote = new RoutingRemoteContact(peerDescriptor, this.config.localPeerDescriptor, this.config.rpcCommunicator)
+        this.routingTablesCache.onNodeConnected(remote)
+    }
+
+    onNodeDisconnected(peerDescriptor: PeerDescriptor): void {
+        this.routingTablesCache.onNodeDisconnected(getNodeIdFromPeerDescriptor(peerDescriptor))
+    }
+
+    public resetCache(): void {
+        this.routingTablesCache.reset()
+    }
+
     public stop(): void {
         this.stopped = true
         this.ongoingRoutingSessions.forEach((session, _id) => {
@@ -212,27 +214,28 @@ export class Router implements IRouter {
         })
         this.forwardingTable.clear()
         this.duplicateRequestDetector.clear()
+        this.routingTablesCache.reset()
     }
 
     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,26 +1,26 @@
-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 { Logger, areEqualBinaries } from '@streamr/utils'
+import { Message, 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 { areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { v4 } from 'uuid'
 
 interface RouterRpcLocalConfig {
     doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => RouteMessageAck
     addContact: (contact: PeerDescriptor, setActive: boolean) => void
     setForwardingEntries: (routedMessage: RouteMessageWrapper) => void
+    handleMessage: (message: Message) => void
     duplicateRequestDetector: DuplicateDetector
     localPeerDescriptor: PeerDescriptor
-    connectionManager?: ConnectionManager
 }
 
 const logger = new Logger(module)
 
-export const createRouteMessageAck = (routedMessage: RouteMessageWrapper, error?: string): RouteMessageAck => {
+export const createRouteMessageAck = (routedMessage: RouteMessageWrapper, error?: RouteMessageError): RouteMessageAck => {
     const ack: RouteMessageAck = {
         requestId: routedMessage.requestId,
-        error: error ? error : ''
+        error
     }
     return ack
 }
@@ -36,16 +36,15 @@ 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`)
-            return createRouteMessageAck(routedMessage, 'message given to routeMessage() service is likely a duplicate')
+                + `to ${getDhtAddressFromRaw(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!)
+            this.config.handleMessage(routedMessage.message!)
             return createRouteMessageAck(routedMessage)
         } else {
             return this.config.doRouteMessage(routedMessage)
@@ -55,13 +54,12 @@ 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`)
-            return createRouteMessageAck(forwardMessage, 'message given to forwardMessage() service is likely a duplicate')
+                + `to ${getDhtAddressFromRaw(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)
@@ -72,10 +70,10 @@ export class RouterRpcLocal implements IRouterRpc {
         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)
+            this.config.handleMessage(forwardedMessage)
             return createRouteMessageAck(routedMessage)
         }
-        return this.config.doRouteMessage({ ...routedMessage, destinationPeer: forwardedMessage.targetDescriptor })
+        return this.config.doRouteMessage({ ...routedMessage, requestId: v4(), target: forwardedMessage.targetDescriptor!.nodeId })
     }
 
 }

package/src/dht/routing/RouterRpcRemote.ts

@@ -1,37 +1,36 @@
-import { 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 { Remote } from '../contact/Remote'
-import { Logger } from '@streamr/utils'
+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)
 
-export class RouterRpcRemote extends Remote<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(),
             reachableThrough: params.reachableThrough ?? [],
-            routingPath: params.routingPath
+            routingPath: params.routingPath,
+            parallelRootNodeIds: params.parallelRootNodeIds
         }
-        const options = this.formDhtRpcOptions()
+        const options = this.formDhtRpcOptions({
+            connect: false
+        })
         try {
             const ack = await this.getClient().routeMessage(message, options)
             // Success signal if sent to destination and error includes duplicate
-            if (
-                areEqualPeerDescriptors(params.destinationPeer!, this.getPeerDescriptor())
-                && ack.error.includes('duplicate')
+            if (ack.error === RouteMessageError.DUPLICATE
+                && areEqualBinaries(params.target, this.getPeerDescriptor().nodeId)
             ) {
                 return true
-            } else if (ack.error.length > 0) {
+            } else if (ack.error !== undefined) {
                 return false
             }
         } catch (err) {
@@ -39,7 +38,8 @@ export class RouterRpcRemote extends Remote<IRouterRpcClient> {
             const fromNode = previousPeer
                 ? getNodeIdFromPeerDescriptor(previousPeer)
                 : getNodeIdFromPeerDescriptor(params.sourcePeer!)
-            logger.trace(`Failed to send routeMessage from ${fromNode} to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
+            const toNode = getNodeIdFromPeerDescriptor(this.getPeerDescriptor())
+            logger.trace(`Failed to send routeMessage from ${fromNode} to ${toNode} with: ${err}`)
             return false
         }
         return true
@@ -47,17 +47,20 @@ export class RouterRpcRemote extends Remote<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(),
             reachableThrough: params.reachableThrough ?? [],
-            routingPath: params.routingPath
+            routingPath: params.routingPath,
+            parallelRootNodeIds: params.parallelRootNodeIds
         }
-        const options = this.formDhtRpcOptions()
+        const options = this.formDhtRpcOptions({
+            connect: false
+        })
         try {
             const ack = await this.getClient().forwardMessage(message, options)
-            if (ack.error.length > 0) {
+            if (ack.error !== undefined) {
                 return false
             }
         } catch (err) {
@@ -65,9 +68,8 @@ export class RouterRpcRemote extends Remote<IRouterRpcClient> {
             const fromNode = previousPeer
                 ? getNodeIdFromPeerDescriptor(previousPeer)
                 : getNodeIdFromPeerDescriptor(params.sourcePeer!)
-            logger.trace(
-                `Failed to send forwardMessage from ${fromNode} to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`
-            )
+            const toNode = getNodeIdFromPeerDescriptor(this.getPeerDescriptor())
+            logger.trace(`Failed to send forwardMessage from ${fromNode} to ${toNode} with: ${err}`)
             return false
         }
         return true