@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-testnet-one.1

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,46 +230,57 @@ 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),
-            limit,
-            undefined,
-            true,
-            undefined
-        )
+        const closestPeers = new SortedContactList<DhtNodeRpcRemote>({
+            referenceId: PeerID.fromValue(nodeId),
+            maxSize: limit,
+            allowToContainReferenceId: true,
+            emitEvents: false
+        })
         closestPeers.addContacts(connectedPeers)
         return closestPeers.getClosestContacts(limit).map((peer) => peer.getPeerDescriptor())
     }

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 {
+    public doRouteMessage(routedMessage: RouteMessageWrapper, mode = RoutingMode.ROUTE, excludedPeer?: PeerDescriptor): 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 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,
@@ -162,17 +168,16 @@ 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 {
+    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)
         return new RoutingSession(
             this.rpcCommunicator,
@@ -181,7 +186,7 @@ export class Router implements IRouter {
             this.connections,
             areEqualPeerDescriptors(this.localPeerDescriptor, routedMessage.sourcePeer!) ? 2 : 1,
             mode,
-            routedMessage.routingPath.map((descriptor) => peerIdFromPeerDescriptor(descriptor))
+            excludedPeers
         )
     }
 

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) {

package/src/dht/routing/RoutingSession.ts

@@ -1,7 +1,7 @@
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { SortedContactList } from '../contact/SortedContactList'
 import { PeerID, PeerIDKey } from '../../helpers/PeerID'
-import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { v4 } from 'uuid'
@@ -12,7 +12,7 @@ import { FindRpcClient, RouterRpcClient } from '../../proto/packages/dht/protos/
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { Contact } from '../contact/Contact'
 import { FindRpcRemote } from './FindRpcRemote'
-import { EXISTING_CONNECTION_TIMEOUT } from '../contact/Remote'
+import { EXISTING_CONNECTION_TIMEOUT } from '../contact/RpcRemote'
 import { getPreviousPeer } from './getPreviousPeer'
 
 const logger = new Logger(module)
@@ -97,15 +97,15 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         this.parallelism = parallelism
         this.mode = mode
         const previousPeer = getPreviousPeer(messageToRoute)
-        const previousId = previousPeer ? PeerID.fromValue(previousPeer.kademliaId) : undefined
-        this.contactList = new SortedContactList(
-            PeerID.fromValue(this.messageToRoute.destinationPeer!.kademliaId),
-            10000,
-            undefined,
-            true,
-            previousId,
-            excludedPeerIDs
-        )
+        const previousId = previousPeer ? PeerID.fromValue(previousPeer.nodeId) : undefined
+        this.contactList = new SortedContactList({
+            referenceId: PeerID.fromValue(this.messageToRoute.destinationPeer!.nodeId),
+            maxSize: 10000,  // TODO use config option or named constant?
+            allowToContainReferenceId: true,
+            peerIdDistanceLimit: previousId,
+            excludedPeerIDs: excludedPeerIDs,
+            emitEvents: false
+        })
     }
 
     private onRequestFailed(peerId: PeerID) {
@@ -116,7 +116,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         if (this.ongoingRequests.has(peerId.toKey())) {
             this.ongoingRequests.delete(peerId.toKey())
         }
-        const contacts = this.findMoreContacts()
+        const contacts = this.updateAndGetRoutablePeers()
         if (contacts.length === 0 && this.ongoingRequests.size === 0) {
             logger.trace('routing failed, emitting routingFailed sessionId: ' + this.sessionId)
             // TODO should call this.stop() so that we do cleanup? (after the emitFailure call)
@@ -143,7 +143,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             return
         }
         this.successfulHopCounter += 1
-        const contacts = this.findMoreContacts()
+        const contacts = this.updateAndGetRoutablePeers()
         if (this.successfulHopCounter >= this.parallelism || contacts.length === 0) {
             // TODO should call this.stop() so that we do cleanup? (after the routingSucceeded call)
             this.stopped = true
@@ -170,10 +170,15 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         }
     }
 
-    findMoreContacts(): RemoteContact[] {
-        logger.trace('findMoreContacts() sessionId: ' + this.sessionId)
-        // the contents of the connections might have changed between the rounds
-        // addContacts() will only add new contacts that were not there yet
+    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)
+            }
+        })
         const contacts = Array.from(this.connections.values())
             .map((peer) => new RemoteContact(peer, this.localPeerDescriptor, this.rpcCommunicator))
         this.contactList.addContacts(contacts)

package/src/dht/routing/getPreviousPeer.ts

@@ -2,5 +2,5 @@ import { last } from 'lodash'
 import { PeerDescriptor, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 
 export const getPreviousPeer = (routeMessage: RouteMessageWrapper): PeerDescriptor | undefined => {
-    return last(routeMessage.routingPath!)
+    return last(routeMessage.routingPath)
 }