@streamr/dht 100.0.0-testnet-three.5 → 100.0.0

package/src/dht/contact/RingContactList.ts

@@ -0,0 +1,151 @@
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { OrderedMap } from '@js-sdsl/ordered-map'
+import { RingDistance, RingId, RingIdRaw, getLeftDistance, getRightDistance, getRingIdFromPeerDescriptor, getRingIdFromRaw } from './ringIdentifiers'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import EventEmitter from 'eventemitter3'
+
+export interface RingContacts { 
+    left: PeerDescriptor[]
+    right: PeerDescriptor[]
+}
+export interface RingContactListEvents {  
+    ringContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
+    ringContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
+}
+export class RingContactList<C extends { getPeerDescriptor(): PeerDescriptor }> extends EventEmitter<RingContactListEvents> {
+
+    private readonly numNeighborsPerSide = 5
+    private readonly referenceId: RingId
+    private readonly excludedIds: Set<DhtAddress>
+    private readonly leftNeighbors: OrderedMap<RingDistance, C>
+    private readonly rightNeighbors: OrderedMap<RingDistance, C>
+    private readonly emitEvents: boolean
+
+    constructor(rawReferenceId: RingIdRaw, emitEvents: boolean, excludedIds?: Set<DhtAddress>) {
+        super()
+        this.referenceId = getRingIdFromRaw(rawReferenceId)
+        this.emitEvents = emitEvents
+        this.excludedIds = excludedIds ?? new Set()
+        this.leftNeighbors = new OrderedMap<RingDistance, C>()
+        this.rightNeighbors = new OrderedMap<RingDistance, C>()
+    }
+
+    addContact(contact: C): void {
+        const id = getRingIdFromPeerDescriptor(contact.getPeerDescriptor())
+        if (id === this.referenceId || this.excludedIds.has(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))) {
+            return
+        }
+        let elementAdded = false
+        let elementRemoved = false
+
+        const leftDistance = getLeftDistance(this.referenceId, id)
+        const lastLeftNeighbor = this.leftNeighbors.back()
+        if (lastLeftNeighbor === undefined || leftDistance < lastLeftNeighbor[0]) {
+            this.leftNeighbors.setElement(leftDistance, contact)
+            elementAdded = true
+            if (this.leftNeighbors.size() > this.numNeighborsPerSide) {
+                this.leftNeighbors.eraseElementByIterator(this.leftNeighbors.rBegin())
+                elementRemoved = true
+            }
+        }
+
+        const rightDistance = getRightDistance(this.referenceId, id)
+        const lastRightNeighbor = this.rightNeighbors.back()
+        if (lastRightNeighbor === undefined || rightDistance < lastRightNeighbor[0]) {
+            this.rightNeighbors.setElement(rightDistance, contact)
+            elementAdded = true
+            if (this.rightNeighbors.size() > this.numNeighborsPerSide) {
+                this.rightNeighbors.eraseElementByIterator(this.rightNeighbors.rBegin())
+                elementRemoved = true
+            }
+        }
+
+        if (this.emitEvents && (elementAdded || elementRemoved)) {
+            const closestContacts = this.getClosestContacts()
+            const closestDescriptors = { 
+                left: closestContacts.left.map((c) => c.getPeerDescriptor()), 
+                right: closestContacts.right.map((c) => c.getPeerDescriptor())
+            }
+            if (elementAdded) {
+                this.emit('ringContactAdded', contact.getPeerDescriptor(), closestDescriptors)
+            }
+            if (elementRemoved) {
+                this.emit('ringContactRemoved', contact.getPeerDescriptor(), closestDescriptors)
+            }
+        }
+    }
+
+    removeContact(contact?: C): void {
+        if (contact === undefined) {
+            return
+        }
+
+        const id = getRingIdFromPeerDescriptor(contact.getPeerDescriptor())
+        const leftDistance = getLeftDistance(this.referenceId, id)
+        const rightDistance = getRightDistance(this.referenceId, id)
+
+        let elementRemoved = false
+        if (this.leftNeighbors.eraseElementByKey(leftDistance)) {
+            elementRemoved = true
+        }
+        if (this.rightNeighbors.eraseElementByKey(rightDistance)) {
+            elementRemoved = true
+        }
+
+        if (this.emitEvents && elementRemoved) {
+            const closestContacts = this.getClosestContacts()
+            const closestDescriptors = { left: closestContacts.left.map((c) => c.getPeerDescriptor()), 
+                right: closestContacts.right.map((c) => c.getPeerDescriptor()) }
+            this.emit('ringContactRemoved', contact.getPeerDescriptor(), closestDescriptors)
+        }
+    }
+
+    getContact(peerDescriptor: PeerDescriptor): C | undefined {
+        const id = getRingIdFromPeerDescriptor(peerDescriptor)
+        const leftDistance = getLeftDistance(this.referenceId, id)
+        const rightDistance = getRightDistance(this.referenceId, id)
+        if (this.leftNeighbors.getElementByKey(leftDistance)) {
+            return this.leftNeighbors.getElementByKey(leftDistance)
+        }
+        if (this.rightNeighbors.getElementByKey(rightDistance)) {
+            return this.rightNeighbors.getElementByKey(rightDistance)
+        }
+        return undefined
+    }
+
+    getClosestContacts(limitPerSide?: number): { left: C[], right: C[] } {
+        const leftContacts: C[] = []
+        const rightContacts: C[] = []
+
+        let leftCount = 0
+        for (const item of this.leftNeighbors) {
+            if (limitPerSide != undefined && leftCount >= limitPerSide) {
+                break
+            }
+            leftContacts.push(item[1])
+            leftCount++
+        } 
+
+        let rightCount = 0
+        for (const item of this.rightNeighbors) {
+            if (limitPerSide != undefined && rightCount >= limitPerSide) {
+                break
+            }
+            rightContacts.push(item[1])
+            rightCount++
+        }
+
+        return { left: leftContacts, right: rightContacts }
+    }
+
+    getAllContacts(): C[] {
+        const ret: C[] = []
+        for (const item of this.leftNeighbors) {
+            ret.push(item[1])
+        }
+        for (const item of this.rightNeighbors) {
+            ret.push(item[1])
+        }
+        return ret
+    }
+}

package/src/dht/contact/ringIdentifiers.ts

@@ -0,0 +1,62 @@
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+
+// Notice: you cannot convert RingId to RingIdRaw, because 
+// RingId is only an approximation of the actual value.
+// That is why RingIdRaw is widely used in the codebase.
+
+export type RingIdRaw = Uint8Array & { __ringIdRaw: never }
+export type RingId = number & { __ringId: never }
+export type RingDistance = number & { __ringDistance: never }
+
+export const RING_SIZE = 2 ** 120 - 1   // 2^120 - 1
+
+const binaryToBigInt = (binary: Uint8Array): bigint => {
+    return binary.reduce((acc, val) => (acc << BigInt(8)) | BigInt(val), BigInt(0))
+}
+
+export const getRingIdFromRaw = (raw: RingIdRaw): RingId => Number(binaryToBigInt(raw)) as RingId
+
+export const getRingIdRawFromPeerDescriptor = (peerDescriptor: PeerDescriptor): RingIdRaw => {
+    const regionAsBuffer = Buffer.alloc(4)
+    regionAsBuffer.writeUInt32BE(peerDescriptor.region ?? 0, 0)
+    const ipAsbuffer = Buffer.alloc(4)
+    ipAsbuffer.writeUInt32BE(peerDescriptor.ipAddress ?? 0, 0)
+    
+    const uniquePartAsBuffer = Buffer.from(peerDescriptor.nodeId.subarray(peerDescriptor.nodeId.length - 7, peerDescriptor.nodeId.length))
+
+    const arr = [
+        regionAsBuffer,
+        ipAsbuffer,
+        uniquePartAsBuffer
+    ]
+
+    const buffer = Buffer.concat(arr)
+    return new Uint8Array(buffer) as RingIdRaw
+}
+
+export const getRingIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): RingId => {
+    const raw = getRingIdRawFromPeerDescriptor(peerDescriptor)
+    return Number(binaryToBigInt(raw)) as RingId    
+}
+
+export const getLeftDistance = (referenceId: RingId, id: RingId): RingDistance =>{
+    const diff = Math.abs(referenceId - id)
+    if (referenceId > id) {
+        // if id is smaller than referenceId, then the distance is the difference
+        return diff as RingDistance
+    } else {
+        // if id is bigger than referenceId, then the distance is the ringSize - difference
+        return RING_SIZE - diff as RingDistance
+    }
+}
+
+export const getRightDistance = (referenceId: RingId, id: RingId): RingDistance => {
+    const diff = Math.abs(referenceId - id)
+    if (referenceId > id) {
+        // if id is smaller than referenceId, then the distance is the ringSize - difference
+        return RING_SIZE - diff as RingDistance
+    } else {
+        // if id is bigger than referenceId, then the distance is the difference
+        return diff as RingDistance
+    }
+}

package/src/dht/discovery/PeerDiscovery.ts

@@ -6,6 +6,8 @@ import { ConnectionManager } from '../../connection/ConnectionManager'
 import { PeerManager } from '../PeerManager'
 import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../identifiers'
 import { ServiceID } from '../../types/ServiceID'
+import { RingDiscoverySession } from './RingDiscoverySession'
+import { RingIdRaw, getRingIdRawFromPeerDescriptor } from '../contact/ringIdentifiers'
 
 interface PeerDiscoveryConfig {
     localPeerDescriptor: PeerDescriptor
@@ -29,6 +31,8 @@ const logger = new Logger(module)
 export class PeerDiscovery {
 
     private ongoingDiscoverySessions: Map<string, DiscoverySession> = new Map()
+    private ongoingRingDiscoverySessions: Map<string, RingDiscoverySession> = new Map()
+    
     private rejoinOngoing = false
     private joinCalled = false
     private readonly abortController: AbortController
@@ -86,6 +90,12 @@ export class PeerDiscovery {
 
     }
 
+    async joinRing(): Promise<void> {
+        const contactedPeers = new Set<DhtAddress>()
+        const sessions = [this.createRingSession(getRingIdRawFromPeerDescriptor(this.config.localPeerDescriptor), contactedPeers)]
+        await this.runRingSessions(sessions)
+    }
+
     private createSession(targetId: DhtAddress, contactedPeers: Set<DhtAddress>): DiscoverySession {
         const sessionOptions = {
             targetId,
@@ -97,6 +107,17 @@ export class PeerDiscovery {
         return new DiscoverySession(sessionOptions)
     }
 
+    private createRingSession(targetId: RingIdRaw, contactedPeers: Set<DhtAddress>): RingDiscoverySession {
+        const sessionOptions = {
+            targetId,
+            parallelism: this.config.parallelism,
+            noProgressLimit: this.config.joinNoProgressLimit,
+            peerManager: this.config.peerManager,
+            contactedPeers
+        }
+        return new RingDiscoverySession(sessionOptions)
+    }
+
     private async runSessions(sessions: DiscoverySession[], entryPointDescriptor: PeerDescriptor, retry: boolean): Promise<void> {
         try {
             for (const session of sessions) {
@@ -121,6 +142,19 @@ export class PeerDiscovery {
         }
     }
 
+    private async runRingSessions(sessions: RingDiscoverySession[]): Promise<void> {
+        try {
+            for (const session of sessions) {
+                this.ongoingRingDiscoverySessions.set(session.id, session)
+                await session.findClosestNodes(this.config.joinTimeout)
+            }
+        } catch (_e) {
+            logger.debug(`Ring join on ${this.config.serviceId} timed out`)
+        } finally {
+            sessions.forEach((session) => this.ongoingDiscoverySessions.delete(session.id))
+        }
+    }
+
     public async rejoinDht(entryPoint: PeerDescriptor): Promise<void> {
         if (this.isStopped() || this.rejoinOngoing) {
             return
@@ -184,5 +218,8 @@ export class PeerDiscovery {
         this.ongoingDiscoverySessions.forEach((session) => {
             session.stop()
         })
+        this.ongoingRingDiscoverySessions.forEach((session) => {
+            session.stop()
+        })
     }
 }

package/src/dht/discovery/RingDiscoverySession.ts

@@ -0,0 +1,160 @@
+import { Logger, runAndWaitForEvents3 } from '@streamr/utils'
+import EventEmitter from 'eventemitter3'
+import { v4 } from 'uuid'
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { PeerManager } from '../PeerManager'
+import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { RingId, RingIdRaw, getLeftDistance, getRingIdFromPeerDescriptor, getRingIdFromRaw } from '../contact/ringIdentifiers'
+import { RingContacts } from '../contact/RingContactList'
+
+const logger = new Logger(module)
+
+interface RingDiscoverySessionEvents {
+    discoveryCompleted: () => void
+}
+
+interface RingDiscoverySessionConfig {
+    targetId: RingIdRaw
+    parallelism: number
+    noProgressLimit: number
+    peerManager: PeerManager
+    // Note that contacted peers will be mutated by the DiscoverySession or other parallel sessions
+    contactedPeers: Set<DhtAddress>
+}
+
+export class RingDiscoverySession {
+
+    public readonly id = v4()
+    private stopped = false
+    private emitter = new EventEmitter<RingDiscoverySessionEvents>()
+    private noProgressCounter = 0
+    private ongoingClosestPeersRequests: Set<DhtAddress> = new Set()
+    private readonly config: RingDiscoverySessionConfig
+    private numContactedPeers = 0
+    private targetIdAsRingId: RingId
+
+    constructor(config: RingDiscoverySessionConfig) {
+        this.config = config
+        this.targetIdAsRingId = getRingIdFromRaw(this.config.targetId)
+    }
+
+    private addContacts(contacts: PeerDescriptor[]): void {
+        if (this.stopped) {
+            return
+        }
+        this.config.peerManager.addContact(contacts)
+    }
+
+    private async getClosestPeersFromContact(contact: DhtNodeRpcRemote): Promise<RingContacts> {
+        if (this.stopped) {
+            return { left: [], right: [] }
+        }
+        logger.trace(`Getting closest ring peers from contact: ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
+        this.numContactedPeers++
+        this.config.contactedPeers.add(contact.getNodeId())
+        const returnedContacts = await contact.getClosestRingPeers(this.config.targetId)
+        this.config.peerManager.setContactActive(contact.getNodeId())
+        return returnedContacts
+    }
+
+    private onClosestPeersRequestSucceeded(nodeId: DhtAddress, contacts: RingContacts) {
+        if (!this.ongoingClosestPeersRequests.has(nodeId)) {
+            return
+        }
+        this.ongoingClosestPeersRequests.delete(nodeId)
+        const oldClosestContacts = this.config.peerManager.getClosestRingContactsTo(this.config.targetId, 1)
+        const oldClosestLeftDistance = getLeftDistance(
+            this.targetIdAsRingId,
+            getRingIdFromPeerDescriptor(oldClosestContacts.left[0].getPeerDescriptor())
+        )
+        const oldClosestRightDistance = getLeftDistance(
+            this.targetIdAsRingId,
+            getRingIdFromPeerDescriptor(oldClosestContacts.right[0].getPeerDescriptor())
+        )
+        this.addContacts(contacts.left.concat(contacts.right))
+        const newClosestContacts = this.config.peerManager.getClosestRingContactsTo(this.config.targetId, 1)
+        const newClosestLeftDistance = getLeftDistance(this.targetIdAsRingId,
+            getRingIdFromPeerDescriptor(newClosestContacts.left[0].getPeerDescriptor()))
+        const newClosestRightDistance = getLeftDistance(this.targetIdAsRingId,
+            getRingIdFromPeerDescriptor(newClosestContacts.right[0].getPeerDescriptor()))
+        if (newClosestLeftDistance >= oldClosestLeftDistance && newClosestRightDistance >= oldClosestRightDistance) {
+            this.noProgressCounter++
+        }
+    }
+
+    private onClosestPeersRequestFailed(peer: DhtNodeRpcRemote) {
+        if (!this.ongoingClosestPeersRequests.has(peer.getNodeId())) {
+            return
+        }
+        this.ongoingClosestPeersRequests.delete(peer.getNodeId())
+        this.config.peerManager.removeContact(peer.getNodeId())
+    }
+
+    private findMoreContacts(): void {
+        if (this.stopped) {
+            return
+        }
+        const uncontacted = this.config.peerManager.getClosestRingContactsTo(
+            this.config.targetId,
+            this.config.parallelism,
+            this.config.contactedPeers
+        )
+        if ((uncontacted.left.length === 0 && uncontacted.right.length === 0)
+            || this.noProgressCounter >= this.config.noProgressLimit) {
+            this.emitter.emit('discoveryCompleted')
+            this.stopped = true
+            return
+        }
+        // ask from both sides equally
+        const merged = []
+        const alreadyInMerged: Set<DhtAddress> = new Set()
+        const length = Math.max(uncontacted.left.length, uncontacted.right.length)
+        for (let i = 0; i < length; i++) {
+            if (i < uncontacted.left.length) {
+                if (!alreadyInMerged.has(uncontacted.left[i].getNodeId())) {
+                    merged.push(uncontacted.left[i])
+                    alreadyInMerged.add(uncontacted.left[i].getNodeId())
+                }
+            }
+            if (i < uncontacted.right.length) {
+                if (!alreadyInMerged.has(uncontacted.right[i].getNodeId())) {
+                    merged.push(uncontacted.right[i])
+                    alreadyInMerged.add(uncontacted.right[i].getNodeId())
+                }
+            }
+        }
+
+        for (const nextPeer of merged) {
+            if (this.ongoingClosestPeersRequests.size >= this.config.parallelism) {
+                break
+            }
+            this.ongoingClosestPeersRequests.add(nextPeer.getNodeId())
+            // eslint-disable-next-line promise/catch-or-return
+            this.getClosestPeersFromContact(nextPeer)
+                .then((contacts) => this.onClosestPeersRequestSucceeded(nextPeer.getNodeId(), contacts))
+                .catch(() => this.onClosestPeersRequestFailed(nextPeer))
+                .finally(() => {
+                    this.findMoreContacts()
+                })
+        }
+    }
+
+    public async findClosestNodes(timeout: number): Promise<void> {
+        if (this.config.peerManager.getContactCount(this.config.contactedPeers) === 0) {
+            return
+        }
+        // TODO add abortController and signal it in stop()
+        await runAndWaitForEvents3<RingDiscoverySessionEvents>(
+            [this.findMoreContacts.bind(this)],
+            [[this.emitter, 'discoveryCompleted']],
+            timeout
+        )
+    }
+
+    public stop(): void {
+        this.stopped = true
+        this.emitter.emit('discoveryCompleted')
+        this.emitter.removeAllListeners()
+    }
+}

package/src/dht/recursive-operation/RecursiveOperationSession.ts

@@ -8,8 +8,7 @@ import {
     RouteMessageWrapper,
     RouteMessageAck,
     RecursiveOperationRequest,
-    Message,
-    MessageType
+    Message
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { ITransport } from '../../transport/ITransport'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
@@ -90,7 +89,6 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
             operation: this.config.operation
         }
         const msg: Message = {
-            messageType: MessageType.RECURSIVE_OPERATION_REQUEST,
             messageId: v4(),
             serviceId,
             body: {

package/src/dht/routing/Router.ts

@@ -1,20 +1,20 @@
 import { Message, PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
-import { RoutingMode, RoutingSession, RoutingSessionEvents } from './RoutingSession'
+import { RoutingMode, RoutingRemoteContact, RoutingSession, RoutingSessionEvents } from './RoutingSession'
 import { Logger, executeSafePromise, raceEvents3, withTimeout } from '@streamr/utils'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { DuplicateDetector } from './DuplicateDetector'
-import { ConnectionManager } from '../../connection/ConnectionManager'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { v4 } from 'uuid'
 import { RouterRpcLocal, createRouteMessageAck } from './RouterRpcLocal'
 import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { RoutingTablesCache } from './RoutingTablesCache'
 
 export interface RouterConfig {
     rpcCommunicator: RoutingRpcCommunicator
     localPeerDescriptor: PeerDescriptor
     connections: Map<DhtAddress, DhtNodeRpcRemote>
     addContact: (contact: PeerDescriptor, setActive?: boolean) => void
-    connectionManager?: ConnectionManager
+    handleMessage: (message: Message) => void
 }
 
 interface ForwardingTableEntry {
@@ -27,9 +27,10 @@ const logger = new Logger(module)
 export class Router {
 
     private readonly forwardingTable: Map<DhtAddress, ForwardingTableEntry> = new Map()
+    private readonly routingTablesCache = new RoutingTablesCache()
     private ongoingRoutingSessions: Map<string, RoutingSession> = new Map()
     // TODO use config option or named constant?
-    private readonly duplicateRequestDetector: DuplicateDetector = new DuplicateDetector(100000)
+    private readonly duplicateRequestDetector: DuplicateDetector = new DuplicateDetector(10000)
     private stopped = false
     private readonly config: RouterConfig
 
@@ -45,7 +46,7 @@ export class Router {
             setForwardingEntries: (routedMessage: RouteMessageWrapper) => this.setForwardingEntries(routedMessage),
             duplicateRequestDetector: this.duplicateRequestDetector,
             localPeerDescriptor: this.config.localPeerDescriptor,
-            connectionManager: this.config.connectionManager
+            handleMessage: this.config.handleMessage
         })
         this.config.rpcCommunicator.registerRpcMethod(
             RouteMessageWrapper,
@@ -168,7 +169,8 @@ export class Router {
             // TODO use config option or named constant?
             parallelism: areEqualPeerDescriptors(this.config.localPeerDescriptor, routedMessage.sourcePeer!) ? 2 : 1,
             mode,
-            excludedNodeIds
+            excludedNodeIds,
+            routingTablesCache: this.routingTablesCache
         })
     }
 
@@ -188,6 +190,19 @@ export class Router {
         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) => {
@@ -199,6 +214,7 @@ export class Router {
         })
         this.forwardingTable.clear()
         this.duplicateRequestDetector.clear()
+        this.routingTablesCache.reset()
     }
 
     private setForwardingEntries(routedMessage: RouteMessageWrapper): void {

package/src/dht/routing/RouterRpcLocal.ts

@@ -1,6 +1,5 @@
 import { Logger, areEqualBinaries } from '@streamr/utils'
-import { ConnectionManager } from '../../connection/ConnectionManager'
-import { PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
+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'
@@ -11,9 +10,9 @@ 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)
@@ -45,7 +44,7 @@ export class RouterRpcLocal implements IRouterRpc {
         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)
@@ -71,7 +70,7 @@ 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, requestId: v4(), target: forwardedMessage.targetDescriptor!.nodeId })