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

package/src/dht/find/FindRpcLocal.ts

@@ -1,5 +1,5 @@
 import { Logger } from '@streamr/utils'
-import { PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+import { PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { IFindRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { createRouteMessageAck } from '../routing/RouterRpcLocal'
@@ -24,7 +24,7 @@ export class FindRpcLocal implements IFindRpc {
 
     async routeFindRequest(routedMessage: RouteMessageWrapper): Promise<RouteMessageAck> {
         if (this.config.isMostLikelyDuplicate(routedMessage.requestId)) {
-            return createRouteMessageAck(routedMessage, 'message given to routeFindRequest() service is likely a duplicate')
+            return createRouteMessageAck(routedMessage, RouteMessageError.DUPLICATE)
         }
         const senderId = getNodeIdFromPeerDescriptor(getPreviousPeer(routedMessage) ?? routedMessage.sourcePeer!)
         logger.trace(`Received routeFindRequest call from ${senderId}`)

package/src/dht/find/FindSession.ts

@@ -1,6 +1,6 @@
 import EventEmitter from 'eventemitter3'
 import { PeerID, PeerIDKey } from '../../helpers/PeerID'
-import { DataEntry, PeerDescriptor, FindResponse } from '../../proto/packages/dht/protos/DhtRpc'
+import { DataEntry, PeerDescriptor, FindResponse, FindAction } from '../../proto/packages/dht/protos/DhtRpc'
 import { ITransport } from '../../transport/ITransport'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
 import { Contact } from '../contact/Contact'
@@ -17,20 +17,20 @@ export interface FindSessionEvents {
 export interface FindSessionConfig {
     serviceId: ServiceID
     transport: ITransport
-    kademliaIdToFind: Uint8Array
+    nodeIdToFind: Uint8Array
     localPeerId: PeerID
     waitedRoutingPathCompletions: number
-    fetchData: boolean
+    action: FindAction
 }
 
 export class FindSession extends EventEmitter<FindSessionEvents> {
     private readonly serviceId: ServiceID
     private readonly transport: ITransport
-    private readonly kademliaIdToFind: Uint8Array
+    private readonly nodeIdToFind: Uint8Array
     private readonly localPeerId: PeerID
     private readonly waitedRoutingPathCompletions: number
     private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly fetchData: boolean
+    private readonly action: FindAction
     private results: SortedContactList<Contact>
     private foundData: Map<string, DataEntry> = new Map()
     private allKnownHops: Set<PeerIDKey> = new Set()
@@ -43,11 +43,11 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
         super()
         this.serviceId = config.serviceId
         this.transport = config.transport
-        this.kademliaIdToFind = config.kademliaIdToFind
+        this.nodeIdToFind = config.nodeIdToFind
         this.localPeerId = config.localPeerId
         this.waitedRoutingPathCompletions = config.waitedRoutingPathCompletions
-        this.results = new SortedContactList(PeerID.fromValue(this.kademliaIdToFind), 10, undefined, true)
-        this.fetchData = config.fetchData
+        this.results = new SortedContactList(PeerID.fromValue(this.nodeIdToFind), 10, undefined, true)
+        this.action = config.action
         this.rpcCommunicator = new ListeningRpcCommunicator(this.serviceId, this.transport, {
             rpcRequestTimeout: 15000
         })
@@ -56,7 +56,7 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
 
     private registerLocalRpcMethods() {
         const rpcLocal = new FindSessionRpcLocal({
-            doSendFindResponse: (routingPath: PeerDescriptor[], nodes: PeerDescriptor[], dataEntries: DataEntry[], noCloserNodesFound?: boolean) => {
+            doSendFindResponse: (routingPath: PeerDescriptor[], nodes: PeerDescriptor[], dataEntries: DataEntry[], noCloserNodesFound: boolean) => {
                 this.doSendFindResponse(routingPath, nodes, dataEntries, noCloserNodesFound)
             }
         })
@@ -70,10 +70,10 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
             unreportedHops.delete(id)
         })
         if (this.noCloserNodesReceivedCounter >= 1 && unreportedHops.size === 0) {
-            if (this.fetchData
+            if (this.action === FindAction.FETCH_DATA
                 && (this.hasNonStaleData() || this.noCloserNodesReceivedCounter >= this.waitedRoutingPathCompletions)) {
                 return true
-            } else if (this.fetchData) {
+            } else if (this.action === FindAction.FETCH_DATA) {
                 return false
             }
             return true
@@ -89,7 +89,7 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
         routingPath: PeerDescriptor[],
         nodes: PeerDescriptor[],
         dataEntries: DataEntry[],
-        noCloserNodesFound?: boolean
+        noCloserNodesFound: boolean
     ): void {
         this.addKnownHops(routingPath)
         if (routingPath.length >= 1) {
@@ -106,7 +106,7 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
 
     private addKnownHops(routingPath: PeerDescriptor[]) {
         routingPath.forEach((desc) => {
-            const newPeerId = PeerID.fromValue(desc.kademliaId)
+            const newPeerId = PeerID.fromValue(desc.nodeId)
             if (!this.localPeerId.equals(newPeerId)) {
                 this.allKnownHops.add(newPeerId.toKey())
             }
@@ -114,7 +114,7 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
     }
 
     private setHopAsReported(desc: PeerDescriptor) {
-        const newPeerId = PeerID.fromValue(desc.kademliaId)
+        const newPeerId = PeerID.fromValue(desc.nodeId)
         if (!this.localPeerId.equals(newPeerId)) {
             this.reportedHops.add(newPeerId.toKey())
         }
@@ -132,11 +132,11 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
 
     private processFoundData(dataEntries: DataEntry[]): void {
         dataEntries.forEach((entry) => {
-            const storerKey = keyFromPeerDescriptor(entry.storer!)
-            const existingEntry = this.foundData.get(storerKey)
-            if (!existingEntry || existingEntry.storerTime! < entry.storerTime! 
-                || (existingEntry.storerTime! <= entry.storerTime! && entry.deleted)) {
-                this.foundData.set(storerKey, entry)
+            const creatorKey = keyFromPeerDescriptor(entry.creator!)
+            const existingEntry = this.foundData.get(creatorKey)
+            if (!existingEntry || existingEntry.createdAt! < entry.createdAt! 
+                || (existingEntry.createdAt! <= entry.createdAt! && entry.deleted)) {
+                this.foundData.set(creatorKey, entry)
             }
         })
     }
@@ -164,7 +164,7 @@ export class FindSession extends EventEmitter<FindSessionEvents> {
 
     public getResults = (): FindResult => ({
         closestNodes: this.results.getAllContacts().map((contact) => contact.getPeerDescriptor()),
-        dataEntries: (this.foundData && this.foundData.size > 0) ? Array.from(this.foundData.values()) : undefined
+        dataEntries: Array.from(this.foundData.values())
     })
 
     public stop(): void {

package/src/dht/find/FindSessionRpcLocal.ts

@@ -6,7 +6,7 @@ import { Logger } from '@streamr/utils'
 const logger = new Logger(module)
 
 interface FindSessionRpcLocalConfig {
-    doSendFindResponse: (routingPath: PeerDescriptor[], nodes: PeerDescriptor[], dataEntries: DataEntry[], noCloserNodesFound?: boolean) => void
+    doSendFindResponse: (routingPath: PeerDescriptor[], nodes: PeerDescriptor[], dataEntries: DataEntry[], noCloserNodesFound: boolean) => void
 }
 
 export class FindSessionRpcLocal implements IFindSessionRpc {

package/src/dht/find/FindSessionRpcRemote.ts

@@ -5,11 +5,11 @@ import {
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { IFindSessionRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Logger } from '@streamr/utils'
-import { Remote } from '../contact/Remote'
+import { RpcRemote } from '../contact/RpcRemote'
 
 const logger = new Logger(module)
 
-export class FindSessionRpcRemote extends Remote<IFindSessionRpcClient> {
+export class FindSessionRpcRemote extends RpcRemote<IFindSessionRpcClient> {
 
     sendFindResponse(
         routingPath: PeerDescriptor[],

package/src/dht/find/Finder.ts

@@ -6,13 +6,15 @@ import {
     PeerDescriptor,
     FindRequest,
     RouteMessageAck,
-    RouteMessageWrapper
+    RouteMessageWrapper,
+    RouteMessageError,
+    FindAction
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { PeerID, PeerIDKey } from '../../helpers/PeerID'
-import { RoutingErrors, IRouter } from '../routing/Router'
+import { IRouter } from '../routing/Router'
 import { RoutingMode } from '../routing/RoutingSession'
 import { areEqualPeerDescriptors, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { Logger, runAndWaitForEvents3 } from '@streamr/utils'
+import { Logger, runAndWaitForEvents3, wait } from '@streamr/utils'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { FindSessionRpcRemote } from './FindSessionRpcRemote'
 import { v4 } from 'uuid'
@@ -37,12 +39,12 @@ interface FinderConfig {
     localPeerDescriptor: PeerDescriptor
     serviceId: ServiceID
     localDataStore: LocalDataStore
-    addContact: (contact: PeerDescriptor, setActive?: boolean) => void
+    addContact: (contact: PeerDescriptor) => void
     isPeerCloserToIdThanSelf: (peer1: PeerDescriptor, compareToId: PeerID) => boolean
 }
 
 export interface IFinder {
-    startFind(idToFind: Uint8Array, fetchData?: boolean): Promise<FindResult>
+    startFind(idToFind: Uint8Array, action?: FindAction): Promise<FindResult>
 }
 
 export interface FindResult { closestNodes: Array<PeerDescriptor>, dataEntries?: Array<DataEntry> }
@@ -77,7 +79,7 @@ export class Finder implements IFinder {
     private registerLocalRpcMethods(config: FinderConfig) {
         const rpcLocal = new FindRpcLocal({
             doRouteFindRequest: (routedMessage: RouteMessageWrapper) => this.doRouteFindRequest(routedMessage),
-            addContact: (contact: PeerDescriptor, setActive?: boolean) => config.addContact(contact, setActive),
+            addContact: (contact: PeerDescriptor) => config.addContact(contact),
             isMostLikelyDuplicate: (requestId: string) => this.router.isMostLikelyDuplicate(requestId),
             addToDuplicateDetector: (requestId: string) => this.router.addToDuplicateDetector(requestId)
         })
@@ -87,7 +89,7 @@ export class Finder implements IFinder {
             'routeFindRequest',
             async (routedMessage: RouteMessageWrapper) => {
                 if (this.stopped) {
-                    return createRouteMessageAck(routedMessage, 'routeFindRequest() service is not running')
+                    return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
                 } else {
                     return rpcLocal.routeFindRequest(routedMessage)
                 }
@@ -97,8 +99,9 @@ export class Finder implements IFinder {
 
     public async startFind(
         idToFind: Uint8Array,
-        fetchData: boolean = false,
-        excludedPeer?: PeerDescriptor
+        action: FindAction = FindAction.NODE,
+        excludedPeer?: PeerDescriptor,
+        waitForCompletion = true
     ): Promise<FindResult> {
         if (this.stopped) {
             return { closestNodes: [] }
@@ -107,46 +110,57 @@ export class Finder implements IFinder {
         const session = new FindSession({
             serviceId: sessionId,
             transport: this.sessionTransport,
-            kademliaIdToFind: idToFind,
+            nodeIdToFind: idToFind,
             localPeerId: peerIdFromPeerDescriptor(this.localPeerDescriptor),
             waitedRoutingPathCompletions: this.connections.size > 1 ? 2 : 1,
-            fetchData
+            action
         })
         if (this.connections.size === 0) {
             const data = this.localDataStore.getEntry(PeerID.fromValue(idToFind))
             session.doSendFindResponse(
                 [this.localPeerDescriptor],
                 [this.localPeerDescriptor],
-                data ? Array.from(data.values()) : [],
+                Array.from(data.values()),
                 true
             )
             return session.getResults()
         }
-        const routeMessage = this.wrapFindRequest(idToFind, sessionId, fetchData)
+        const routeMessage = this.wrapFindRequest(idToFind, sessionId, action)
         this.ongoingSessions.set(sessionId, session)
-        try {
-            await runAndWaitForEvents3<FindSessionEvents>(
-                [() => this.doRouteFindRequest(routeMessage, excludedPeer)],
-                [[session, 'findCompleted']],
-                15000
-            )
-        } catch (err) {
-            logger.debug(`doRouteFindRequest failed with error ${err}`)
+        if (waitForCompletion === true) {
+            try {
+                await runAndWaitForEvents3<FindSessionEvents>(
+                    [() => this.doRouteFindRequest(routeMessage, excludedPeer)],
+                    [[session, 'findCompleted']],
+                    15000
+                )
+            } catch (err) {
+                logger.debug(`doRouteFindRequest failed with error ${err}`)
+            }
+        } else {
+            this.doRouteFindRequest(routeMessage, excludedPeer)
+            // Wait for delete operation to be sent out by the router
+            // TODO: Add a feature to wait for the router to pass the message?
+            await wait(50)
+        }
+        if (action === FindAction.FETCH_DATA) {
+            this.findAndReportLocalData(idToFind, [], this.localPeerDescriptor, sessionId)
+        } else if (action === FindAction.DELETE_DATA) {
+            this.localDataStore.markAsDeleted(idToFind, peerIdFromPeerDescriptor(this.localPeerDescriptor))
         }
-        this.findAndReportLocalData(idToFind, fetchData, [], this.localPeerDescriptor, sessionId)
         this.ongoingSessions.delete(sessionId)
         session.stop()
         return session.getResults()
     }
 
-    private wrapFindRequest(idToFind: Uint8Array, sessionId: string, fetchData: boolean): RouteMessageWrapper {
+    private wrapFindRequest(idToFind: Uint8Array, sessionId: string, action: FindAction): RouteMessageWrapper {
         const targetDescriptor: PeerDescriptor = {
-            kademliaId: idToFind,
+            nodeId: idToFind,
             type: NodeType.VIRTUAL
         }
         const request: FindRequest = {
             sessionId,
-            fetchData
+            action
         }
         const msg: Message = {
             messageType: MessageType.FIND_REQUEST,
@@ -170,19 +184,14 @@ export class Finder implements IFinder {
 
     private findAndReportLocalData(
         idToFind: Uint8Array,
-        fetchData: boolean,
         routingPath: PeerDescriptor[],
         sourcePeer: PeerDescriptor,
         sessionId: string
-    ): boolean {
-        if (fetchData) {
-            const data = this.localDataStore.getEntry(PeerID.fromValue(idToFind))
-            if (data.size > 0) {
-                this.sendFindResponse(routingPath, sourcePeer, sessionId, [], data, true)
-                return true
-            }
+    ): void {
+        const data = this.localDataStore.getEntry(PeerID.fromValue(idToFind))
+        if (data.size > 0) {
+            this.sendFindResponse(routingPath, sourcePeer, sessionId, [], data, true)
         }
-        return false
     }
 
     private findLocalData(idToFind: Uint8Array, fetchData: boolean): Map<PeerIDKey, DataEntry> | undefined {
@@ -221,41 +230,53 @@ export class Finder implements IFinder {
 
     private doRouteFindRequest(routedMessage: RouteMessageWrapper, excludedPeer?: PeerDescriptor): RouteMessageAck {
         if (this.stopped) {
-            return createRouteMessageAck(routedMessage, 'DhtNode Stopped')
+            return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
         }
         const idToFind = peerIdFromPeerDescriptor(routedMessage.destinationPeer!)
         const msg = routedMessage.message
         const findRequest = msg?.body.oneofKind === 'findRequest' ? msg.body.findRequest : undefined
-        const closestPeersToDestination = this.getClosestConnections(routedMessage.destinationPeer!.kademliaId, 5)
-        const data = this.findLocalData(idToFind.value, findRequest!.fetchData)
+        const closestPeersToDestination = this.getClosestConnections(routedMessage.destinationPeer!.nodeId, 5)
+        const data = this.findLocalData(idToFind.value, findRequest!.action === FindAction.FETCH_DATA)
+        if (findRequest!.action === FindAction.DELETE_DATA) {
+            this.localDataStore.markAsDeleted(idToFind.value, peerIdFromPeerDescriptor(routedMessage.sourcePeer!))
+        }
         if (areEqualPeerDescriptors(this.localPeerDescriptor, routedMessage.destinationPeer!)) {
-            this.sendFindResponse(routedMessage.routingPath, routedMessage.sourcePeer!, findRequest!.sessionId,
-                closestPeersToDestination, data, true)
+            // TODO this is also very similar case to what we do at line 255, could simplify the code paths?
+            this.sendFindResponse(
+                routedMessage.routingPath,
+                routedMessage.sourcePeer!,
+                findRequest!.sessionId,
+                closestPeersToDestination,
+                data,
+                true
+            )
             return createRouteMessageAck(routedMessage)
-        }
-        const ack = this.router.doRouteMessage(routedMessage, RoutingMode.FIND, excludedPeer)
-        if (ack.error === RoutingErrors.NO_CANDIDATES_FOUND) {
-            logger.trace(`routeFindRequest Node found no candidates`)
-            this.sendFindResponse(routedMessage.routingPath, routedMessage.sourcePeer!, findRequest!.sessionId,
-                closestPeersToDestination, data, true)
-        } else if (ack.error) {
-            return ack
         } else {
-            const noCloserContactsFound = (
-                closestPeersToDestination.length > 0
-                && getPreviousPeer(routedMessage)
-                && !this.isPeerCloserToIdThanSelf(closestPeersToDestination[0], idToFind)
-            )
-            this.sendFindResponse(routedMessage.routingPath, routedMessage.sourcePeer!, findRequest!.sessionId,
-                closestPeersToDestination, data, noCloserContactsFound)
-        }
-        return ack
+            const ack = this.router.doRouteMessage(routedMessage, RoutingMode.FIND, excludedPeer)
+            if ((ack.error === undefined) || (ack.error === RouteMessageError.NO_TARGETS)) {
+                const noCloserContactsFound = (ack.error === RouteMessageError.NO_TARGETS) ||
+                    (
+                        closestPeersToDestination.length > 0 
+                        && getPreviousPeer(routedMessage) 
+                        && !this.isPeerCloserToIdThanSelf(closestPeersToDestination[0], idToFind)
+                    )
+                this.sendFindResponse(
+                    routedMessage.routingPath,
+                    routedMessage.sourcePeer!,
+                    findRequest!.sessionId,
+                    closestPeersToDestination,
+                    data,
+                    noCloserContactsFound
+                )
+            }
+            return ack
+        }    
     }
 
-    private getClosestConnections(kademliaId: Uint8Array, limit: number): PeerDescriptor[] {
+    private getClosestConnections(nodeId: Uint8Array, limit: number): PeerDescriptor[] {
         const connectedPeers = Array.from(this.connections.values())
         const closestPeers = new SortedContactList<DhtNodeRpcRemote>(
-            PeerID.fromValue(kademliaId),
+            PeerID.fromValue(nodeId),
             limit,
             undefined,
             true,

package/src/dht/routing/FindRpcRemote.ts

@@ -1,14 +1,14 @@
 import { RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { v4 } from 'uuid'
 import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { Remote } from '../contact/Remote'
+import { RpcRemote } from '../contact/RpcRemote'
 import { Logger } from '@streamr/utils'
 import { IFindRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { getPreviousPeer } from './getPreviousPeer'
 
 const logger = new Logger(module)
 
-export class FindRpcRemote extends Remote<IFindRpcClient> {
+export class FindRpcRemote extends RpcRemote<IFindRpcClient> {
 
     async routeFindRequest(params: RouteMessageWrapper): Promise<boolean> {
         const message: RouteMessageWrapper = {
@@ -19,11 +19,13 @@ export class FindRpcRemote extends Remote<IFindRpcClient> {
             reachableThrough: params.reachableThrough ?? [],
             routingPath: params.routingPath
         }
-        const options = this.formDhtRpcOptions()
+        const options = this.formDhtRpcOptions({
+            doNotConnect: true
+        })
         try {
             const ack = await this.getClient().routeFindRequest(message, options)
-            if (ack.error.length > 0) {
-                logger.debug('Next hop responded with error ' + ack.error)
+            if (ack.error !== undefined) {
+                logger.trace('Next hop responded with error ' + ack.error)
                 return false
             }
         } catch (err) {

package/src/dht/routing/Router.ts

@@ -1,4 +1,4 @@
-import { Message, PeerDescriptor, RouteMessageAck, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+import { Message, PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import {
     areEqualPeerDescriptors,
     getNodeIdFromPeerDescriptor,
@@ -16,11 +16,6 @@ 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'
-}
-
 export interface RouterConfig {
     rpcCommunicator: RoutingRpcCommunicator
     localPeerDescriptor: PeerDescriptor
@@ -39,7 +34,7 @@ interface ForwardingTableEntry {
 
 export interface IRouter {
     doRouteMessage(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedPeer?: PeerDescriptor): RouteMessageAck
-    send(msg: Message, reachableThrough: PeerDescriptor[]): Promise<void>
+    send(msg: Message, reachableThrough: PeerDescriptor[]): void
     isMostLikelyDuplicate(requestId: string): boolean
     addToDuplicateDetector(requestId: string): void
     addRoutingSession(session: RoutingSession): void
@@ -82,7 +77,7 @@ export class Router implements IRouter {
             'routeMessage',
             async (routedMessage: RouteMessageWrapper) => {
                 if (this.stopped) {
-                    return createRouteMessageAck(routedMessage, 'routeMessage() service is not running')
+                    return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
                 }
                 return rpcLocal.routeMessage(routedMessage)
             }
@@ -93,7 +88,7 @@ export class Router implements IRouter {
             '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,7 +96,7 @@ export class Router implements IRouter {
 
     }
 
-    public async send(msg: Message, reachableThrough: PeerDescriptor[]): Promise<void> {
+    public send(msg: Message, reachableThrough: PeerDescriptor[]): void {
         msg.sourceDescriptor = this.localPeerDescriptor
         const targetPeerDescriptor = msg.targetDescriptor!
         const forwardingEntry = this.forwardingTable.get(keyFromPeerDescriptor(targetPeerDescriptor))
@@ -115,7 +110,12 @@ export class Router implements IRouter {
                 reachableThrough,
                 routingPath: []
             }
-            this.doRouteMessage(forwardedMessage, RoutingMode.FORWARD)
+            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)
+            }
         } else {
             const routedMessage: RouteMessageWrapper = {
                 message: msg,
@@ -125,23 +125,29 @@ export class Router implements IRouter {
                 reachableThrough,
                 routingPath: []
             }
-            this.doRouteMessage(routedMessage, RoutingMode.ROUTE)
+            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)
+            }
         }
     }
 
     public doRouteMessage(routedMessage: RouteMessageWrapper, mode = RoutingMode.ROUTE): 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()
+        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,
@@ -162,13 +168,8 @@ 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)
         }
     }
 

package/src/dht/routing/RouterRpcLocal.ts

@@ -1,7 +1,7 @@
 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 { 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'
@@ -17,10 +17,10 @@ interface RouterRpcLocalConfig {
 
 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
 }
@@ -37,7 +37,7 @@ export class RouterRpcLocal implements IRouterRpc {
         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')
+            return createRouteMessageAck(routedMessage, RouteMessageError.DUPLICATE)
         }
         logger.trace(`Processing received routeMessage ${routedMessage.requestId}`)
         this.config.addContact(routedMessage.sourcePeer!, true)
@@ -56,7 +56,7 @@ export class RouterRpcLocal implements IRouterRpc {
         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')
+            return createRouteMessageAck(forwardMessage, RouteMessageError.DUPLICATE)
         }
         logger.trace(`Processing received forward routeMessage ${forwardMessage.requestId}`)
         this.config.addContact(forwardMessage.sourcePeer!, true)

package/src/dht/routing/RouterRpcRemote.ts

@@ -1,17 +1,17 @@
-import { RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+import { RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 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 { RpcRemote } from '../contact/RpcRemote'
 import { Logger } from '@streamr/utils'
 import { getPreviousPeer } from './getPreviousPeer'
 
 const logger = new Logger(module)
 
-export class RouterRpcRemote extends Remote<IRouterRpcClient> {
+export class RouterRpcRemote extends RpcRemote<IRouterRpcClient> {
 
     async routeMessage(params: RouteMessageWrapper): Promise<boolean> {
         const message: RouteMessageWrapper = {
@@ -22,16 +22,17 @@ export class RouterRpcRemote extends Remote<IRouterRpcClient> {
             reachableThrough: params.reachableThrough ?? [],
             routingPath: params.routingPath
         }
-        const options = this.formDhtRpcOptions()
+        const options = this.formDhtRpcOptions({
+            doNotConnect: true
+        })
         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
+                && areEqualPeerDescriptors(params.destinationPeer!, this.getPeerDescriptor())
             ) {
                 return true
-            } else if (ack.error.length > 0) {
+            } else if (ack.error !== undefined) {
                 return false
             }
         } catch (err) {
@@ -54,10 +55,12 @@ export class RouterRpcRemote extends Remote<IRouterRpcClient> {
             reachableThrough: params.reachableThrough ?? [],
             routingPath: params.routingPath
         }
-        const options = this.formDhtRpcOptions()
+        const options = this.formDhtRpcOptions({
+            doNotConnect: true
+        })
         try {
             const ack = await this.getClient().forwardMessage(message, options)
-            if (ack.error.length > 0) {
+            if (ack.error !== undefined) {
                 return false
             }
         } catch (err) {