@streamr/dht 100.0.0-testnet-two.1 → 100.0.0-testnet-two.3

package/src/dht/contact/SortedContactList.ts

@@ -2,26 +2,26 @@ import { ContactState, Events } from './ContactList'
 import { sortedIndexBy } from 'lodash'
 import EventEmitter from 'eventemitter3'
 import { getDistance } from '../PeerManager'
-import { NodeID, areEqualNodeIds } from '../../helpers/nodeId'
+import { DhtAddress, getRawFromDhtAddress } from '../../identifiers'
 
 export interface SortedContactListConfig {
-    referenceId: NodeID  // all contacts in this list are in sorted by the distance to this ID
+    referenceId: DhtAddress  // all contacts in this list are in sorted by the distance to this ID
     allowToContainReferenceId: boolean
     // TODO could maybe optimize this by removing the flag and then we'd check whether we have 
     // any listeners before we emit the event
     emitEvents: boolean
     maxSize?: number
     // if set, the list can't contain any contacts which are futher away than this limit
-    nodeIdDistanceLimit?: NodeID
+    nodeIdDistanceLimit?: DhtAddress
     // if set, the list can't contain contacts with these ids
-    excludedNodeIds?: Set<NodeID>
+    excludedNodeIds?: Set<DhtAddress>
 }
 
-export class SortedContactList<C extends { getNodeId: () => NodeID }> extends EventEmitter<Events<C>> {
+export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extends EventEmitter<Events<C>> {
 
     private config: SortedContactListConfig
-    private contactsById: Map<NodeID, ContactState<C>> = new Map()
-    private contactIds: NodeID[] = []
+    private contactsById: Map<DhtAddress, ContactState<C>> = new Map()
+    private contactIds: DhtAddress[] = []
 
     constructor(
         config: SortedContactListConfig
@@ -31,11 +31,11 @@ export class SortedContactList<C extends { getNodeId: () => NodeID }> extends Ev
         this.compareIds = this.compareIds.bind(this)
     }
 
-    public getClosestContactId(): NodeID {
+    public getClosestContactId(): DhtAddress {
         return this.contactIds[0]
     }
 
-    public getContactIds(): NodeID[] {
+    public getContactIds(): DhtAddress[] {
         return this.contactIds
     }
 
@@ -44,7 +44,7 @@ export class SortedContactList<C extends { getNodeId: () => NodeID }> extends Ev
             return
         }
 
-        if ((!this.config.allowToContainReferenceId && areEqualNodeIds(this.config.referenceId, contact.getNodeId())) ||
+        if ((!this.config.allowToContainReferenceId && (this.config.referenceId === contact.getNodeId())) ||
             (this.config.nodeIdDistanceLimit !== undefined && this.compareIds(this.config.nodeIdDistanceLimit, contact.getNodeId()) < 0)) {
             return
         }
@@ -53,7 +53,7 @@ export class SortedContactList<C extends { getNodeId: () => NodeID }> extends Ev
                 this.contactsById.set(contact.getNodeId(), new ContactState(contact))
 
                 // eslint-disable-next-line max-len
-                const index = sortedIndexBy(this.contactIds, contact.getNodeId(), (id: NodeID) => { return this.distanceToReferenceId(id) })
+                const index = sortedIndexBy(this.contactIds, contact.getNodeId(), (id: DhtAddress) => { return this.distanceToReferenceId(id) })
                 this.contactIds.splice(index, 0, contact.getNodeId())
             } else if (this.compareIds(this.contactIds[this.config.maxSize - 1], contact.getNodeId()) > 0) {
                 const removedId = this.contactIds.pop()
@@ -62,7 +62,7 @@ export class SortedContactList<C extends { getNodeId: () => NodeID }> extends Ev
                 this.contactsById.set(contact.getNodeId(), new ContactState(contact))
 
                 // eslint-disable-next-line max-len
-                const index = sortedIndexBy(this.contactIds, contact.getNodeId(), (id: NodeID) => { return this.distanceToReferenceId(id) })
+                const index = sortedIndexBy(this.contactIds, contact.getNodeId(), (id: DhtAddress) => { return this.distanceToReferenceId(id) })
                 this.contactIds.splice(index, 0, contact.getNodeId())
                 if (this.config.emitEvents) {
                     this.emit(
@@ -86,17 +86,17 @@ export class SortedContactList<C extends { getNodeId: () => NodeID }> extends Ev
         contacts.forEach((contact) => this.addContact(contact))
     }
 
-    public getContact(id: NodeID): ContactState<C> | undefined {
+    public getContact(id: DhtAddress): ContactState<C> | undefined {
         return this.contactsById.get(id)
     }
 
-    public setContacted(contactId: NodeID): void {
+    public setContacted(contactId: DhtAddress): void {
         if (this.contactsById.has(contactId)) {
             this.contactsById.get(contactId)!.contacted = true
         }
     }
 
-    public setActive(contactId: NodeID): void {
+    public setActive(contactId: DhtAddress): void {
         if (this.contactsById.has(contactId)) {
             this.contactsById.get(contactId)!.active = true
         }
@@ -146,23 +146,23 @@ export class SortedContactList<C extends { getNodeId: () => NodeID }> extends Ev
         }
     }
 
-    public compareIds(id1: NodeID, id2: NodeID): number {
+    public compareIds(id1: DhtAddress, id2: DhtAddress): number {
         const distance1 = this.distanceToReferenceId(id1)
         const distance2 = this.distanceToReferenceId(id2)
         return distance1 - distance2
     }
 
     // TODO inline this method?
-    private distanceToReferenceId(id: NodeID): number {
-        // TODO maybe this class should store the referenceId also as UInt8Array so that we don't need to convert it here?
-        return getDistance(this.config.referenceId, id)
+    private distanceToReferenceId(id: DhtAddress): number {
+        // TODO maybe this class should store the referenceId also as DhtAddressRaw so that we don't need to convert it here?
+        return getDistance(getRawFromDhtAddress(this.config.referenceId), getRawFromDhtAddress(id))
     }
 
-    public removeContact(id: NodeID): boolean {
+    public removeContact(id: DhtAddress): boolean {
         if (this.contactsById.has(id)) {
             const removed = this.contactsById.get(id)!.contact
             // TODO use sortedIndexBy?
-            const index = this.contactIds.findIndex((nodeId) => areEqualNodeIds(nodeId, id))
+            const index = this.contactIds.findIndex((nodeId) => (nodeId === id))
             this.contactIds.splice(index, 1)
             this.contactsById.delete(id)
             if (this.config.emitEvents) {
@@ -177,7 +177,7 @@ export class SortedContactList<C extends { getNodeId: () => NodeID }> extends Ev
         return false
     }
 
-    public isActive(id: NodeID): boolean {
+    public isActive(id: DhtAddress): boolean {
         return this.contactsById.has(id) ? this.contactsById.get(id)!.active : false
     }
 

package/src/dht/discovery/DiscoverySession.ts

@@ -5,7 +5,7 @@ import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { PeerManager, getDistance } from '../PeerManager'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { NodeID, getNodeIdFromBinary } from '../../helpers/nodeId'
+import { DhtAddress, getRawFromDhtAddress } from '../../identifiers'
 
 const logger = new Logger(module)
 
@@ -14,20 +14,21 @@ interface DiscoverySessionEvents {
 }
 
 interface DiscoverySessionConfig {
-    targetId: Uint8Array
+    targetId: DhtAddress
     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 DiscoverySession {
-    
+
     public readonly id = v4()
     private stopped = false
     private emitter = new EventEmitter<DiscoverySessionEvents>()
     private noProgressCounter = 0
-    private ongoingClosestPeersRequests: Set<NodeID> = new Set()
-    private contactedPeers: Set<NodeID> = new Set()
+    private ongoingClosestPeersRequests: Set<DhtAddress> = new Set()
     private readonly config: DiscoverySessionConfig
 
     constructor(config: DiscoverySessionConfig) {
@@ -46,22 +47,23 @@ export class DiscoverySession {
             return []
         }
         logger.trace(`Getting closest peers from contact: ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
-        this.contactedPeers.add(contact.getNodeId())
+        this.config.contactedPeers.add(contact.getNodeId())
         const returnedContacts = await contact.getClosestPeers(this.config.targetId)
         this.config.peerManager.handlePeerActive(contact.getNodeId())
         return returnedContacts
     }
 
-    private onClosestPeersRequestSucceeded(nodeId: NodeID, contacts: PeerDescriptor[]) {
+    private onClosestPeersRequestSucceeded(nodeId: DhtAddress, contacts: PeerDescriptor[]) {
         if (!this.ongoingClosestPeersRequests.has(nodeId)) {
             return
         }
         this.ongoingClosestPeersRequests.delete(nodeId)
-        const oldClosestNeighbor = this.config.peerManager.getClosestNeighborsTo(getNodeIdFromBinary(this.config.targetId), 1)[0]
-        const oldClosestDistance = getDistance(getNodeIdFromBinary(this.config.targetId), oldClosestNeighbor.getNodeId())
+        const targetId = getRawFromDhtAddress(this.config.targetId)
+        const oldClosestNeighbor = this.config.peerManager.getClosestNeighborsTo(this.config.targetId, 1)[0]
+        const oldClosestDistance = getDistance(targetId, getRawFromDhtAddress(oldClosestNeighbor.getNodeId()))
         this.addNewContacts(contacts)
-        const newClosestNeighbor = this.config.peerManager.getClosestNeighborsTo(getNodeIdFromBinary(this.config.targetId), 1)[0]
-        const newClosestDistance = getDistance(getNodeIdFromBinary(this.config.targetId), newClosestNeighbor.getNodeId())
+        const newClosestNeighbor = this.config.peerManager.getClosestNeighborsTo(this.config.targetId, 1)[0]
+        const newClosestDistance = getDistance(targetId, getRawFromDhtAddress(newClosestNeighbor.getNodeId()))
         if (newClosestDistance >= oldClosestDistance) {
             this.noProgressCounter++
         }
@@ -80,9 +82,9 @@ export class DiscoverySession {
             return
         }
         const uncontacted = this.config.peerManager.getClosestContactsTo(
-            getNodeIdFromBinary(this.config.targetId),
+            this.config.targetId,
             this.config.parallelism,
-            this.contactedPeers
+            this.config.contactedPeers
         )
         if (uncontacted.length === 0 || this.noProgressCounter >= this.config.noProgressLimit) {
             this.emitter.emit('discoveryCompleted')
@@ -105,7 +107,7 @@ export class DiscoverySession {
     }
 
     public async findClosestNodes(timeout: number): Promise<void> {
-        if (this.config.peerManager.getNumberOfContacts(this.contactedPeers) === 0) {
+        if (this.config.peerManager.getNumberOfContacts(this.config.contactedPeers) === 0) {
             return
         }
         // TODO add abortController and signal it in stop()

package/src/dht/discovery/PeerDiscovery.ts

@@ -1,11 +1,11 @@
 import { DiscoverySession } from './DiscoverySession'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
-import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Logger, scheduleAtInterval, setAbortableTimeout } from '@streamr/utils'
 import { ConnectionManager } from '../../connection/ConnectionManager'
 import { PeerManager } from '../PeerManager'
-import { createRandomNodeId } from '../../helpers/nodeId'
+import { DhtAddress, createRandomDhtAddress } from '../../identifiers'
 import { ServiceID } from '../../types/ServiceID'
 
 interface PeerDiscoveryConfig {
@@ -35,7 +35,27 @@ export class PeerDiscovery {
         this.abortController = new AbortController()
     }
 
-    async joinDht(entryPointDescriptor: PeerDescriptor, doAdditionalRandomPeerDiscovery = true, retry = true): Promise<void> {
+    async joinDht(
+        entryPoints: PeerDescriptor[],
+        doAdditionalRandomPeerDiscovery = true,
+        retry = true
+    ): Promise<void> {
+        const contactedPeers = new Set<DhtAddress>()
+        await Promise.all(entryPoints.map((entryPoint) => this.joinThroughEntryPoint(
+            entryPoint,
+            contactedPeers,
+            doAdditionalRandomPeerDiscovery,
+            retry
+        )))
+    }
+
+    async joinThroughEntryPoint(
+        entryPointDescriptor: PeerDescriptor,
+        // Note that this set is mutated by DiscoverySession
+        contactedPeers: Set<DhtAddress>,
+        doAdditionalRandomPeerDiscovery = true,
+        retry = true
+    ): Promise<void> {
         if (this.isStopped()) {
             return
         }
@@ -49,22 +69,23 @@ export class PeerDiscovery {
         }
         this.config.connectionManager?.lockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
         this.config.peerManager.handleNewPeers([entryPointDescriptor])
-        const targetId = peerIdFromPeerDescriptor(this.config.localPeerDescriptor).value
-        const sessions = [this.createSession(targetId)]
+        const targetId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
+        const sessions = [this.createSession(targetId, contactedPeers)]
         if (doAdditionalRandomPeerDiscovery) {
-            sessions.push(this.createSession(createRandomNodeId()))
+            sessions.push(this.createSession(createRandomDhtAddress(), contactedPeers))
         }
         await this.runSessions(sessions, entryPointDescriptor, retry)
         this.config.connectionManager?.unlockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
 
     }
 
-    private createSession(targetId: Uint8Array): DiscoverySession {
+    private createSession(targetId: DhtAddress, contactedPeers: Set<DhtAddress>): DiscoverySession {
         const sessionOptions = {
             targetId,
             parallelism: this.config.parallelism,
             noProgressLimit: this.config.joinNoProgressLimit,
-            peerManager: this.config.peerManager
+            peerManager: this.config.peerManager,
+            contactedPeers
         }
         return new DiscoverySession(sessionOptions)
     }
@@ -100,7 +121,7 @@ export class PeerDiscovery {
         logger.debug(`Rejoining DHT ${this.config.serviceId}`)
         this.rejoinOngoing = true
         try {
-            await this.joinDht(entryPoint)
+            await this.joinThroughEntryPoint(entryPoint, new Set())
             logger.debug(`Rejoined DHT successfully ${this.config.serviceId}!`)
         } catch (err) {
             logger.warn(`Rejoining DHT ${this.config.serviceId} failed`)
@@ -126,14 +147,15 @@ export class PeerDiscovery {
         if (this.isStopped()) {
             return
         }
+        const localNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
         const nodes = this.config.peerManager.getClosestNeighborsTo(
-            getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor),
+            localNodeId,
             this.config.parallelism
         )
         await Promise.allSettled(
             nodes.map(async (peer: DhtNodeRpcRemote) => {
-                const contacts = await peer.getClosestPeers(this.config.localPeerDescriptor.nodeId!)
-                this.config.peerManager.handleNewPeers(contacts)    
+                const contacts = await peer.getClosestPeers(localNodeId)
+                this.config.peerManager.handleNewPeers(contacts)
             })
         )
     }

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

@@ -10,7 +10,7 @@ import {
 import { Router } from '../routing/Router'
 import { RoutingMode } from '../routing/RoutingSession'
 import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { Logger, areEqualBinaries, hexToBinary, runAndWaitForEvents3, wait } from '@streamr/utils'
+import { Logger, areEqualBinaries, runAndWaitForEvents3, wait } from '@streamr/utils'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { RecursiveOperationSessionRpcRemote } from './RecursiveOperationSessionRpcRemote'
 import { RecursiveOperationSession, RecursiveOperationSessionEvents } from './RecursiveOperationSession'
@@ -24,13 +24,13 @@ import { getPreviousPeer } from '../routing/getPreviousPeer'
 import { createRouteMessageAck } from '../routing/RouterRpcLocal'
 import { ServiceID } from '../../types/ServiceID'
 import { RecursiveOperationRpcLocal } from './RecursiveOperationRpcLocal'
-import { NodeID, getNodeIdFromBinary } from '../../helpers/nodeId'
+import { DhtAddress, getDhtAddressFromRaw, getRawFromDhtAddress } from '../../identifiers'
 import { getDistance } from '../PeerManager'
 
 interface RecursiveOperationManagerConfig {
     rpcCommunicator: RoutingRpcCommunicator
     sessionTransport: ITransport
-    connections: Map<NodeID, DhtNodeRpcRemote>
+    connections: Map<DhtAddress, DhtNodeRpcRemote>
     router: Router
     localPeerDescriptor: PeerDescriptor
     serviceId: ServiceID
@@ -75,7 +75,7 @@ export class RecursiveOperationManager {
     }
 
     public async execute(
-        targetId: Uint8Array,
+        targetId: DhtAddress,
         operation: RecursiveOperation,
         excludedPeer?: PeerDescriptor,
         waitForCompletion = true
@@ -96,11 +96,11 @@ export class RecursiveOperationManager {
             }
         })
         if (this.config.connections.size === 0) {
-            const data = this.config.localDataStore.getEntries(targetId)
+            const dataEntries = Array.from(this.config.localDataStore.values(targetId))
             session.onResponseReceived(
                 [this.config.localPeerDescriptor],
                 [this.config.localPeerDescriptor],
-                Array.from(data.values()),
+                dataEntries,
                 true
             )
             return session.getResults()
@@ -124,7 +124,7 @@ export class RecursiveOperationManager {
             await wait(50)
         }
         if (operation === RecursiveOperation.FETCH_DATA) {
-            const dataEntries = Array.from(this.config.localDataStore.getEntries(targetId).values())
+            const dataEntries = Array.from(this.config.localDataStore.values(targetId))
             if (dataEntries.length > 0) {
                 this.sendResponse([], this.config.localPeerDescriptor, session.getId(), [], dataEntries, true)
             }
@@ -154,7 +154,6 @@ export class RecursiveOperationManager {
             const rpcRemote = new RecursiveOperationSessionRpcRemote(
                 this.config.localPeerDescriptor,
                 targetPeerDescriptor,
-                serviceId,
                 remoteCommunicator,
                 RecursiveOperationSessionRpcClient,
                 // TODO use config option or named constant?
@@ -169,15 +168,15 @@ export class RecursiveOperationManager {
         if (this.stopped) {
             return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
         }
-        const targetId = getNodeIdFromBinary(routedMessage.target)
+        const targetId = getDhtAddressFromRaw(routedMessage.target)
         const request = (routedMessage.message!.body as { recursiveOperationRequest: RecursiveOperationRequest }).recursiveOperationRequest
         // TODO use config option or named constant?
-        const closestPeersToDestination = this.getClosestConnections(routedMessage.target, 5)
+        const closestPeersToDestination = this.getClosestConnections(targetId, 5)
         const dataEntries = (request.operation === RecursiveOperation.FETCH_DATA) 
-            ? Array.from(this.config.localDataStore.getEntries(hexToBinary(targetId)).values())
+            ? Array.from(this.config.localDataStore.values(targetId))
             : []
         if (request.operation === RecursiveOperation.DELETE_DATA) {
-            this.config.localDataStore.markAsDeleted(hexToBinary(targetId), getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!))
+            this.config.localDataStore.markAsDeleted(targetId, getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!))
         }
         if (areEqualBinaries(this.config.localPeerDescriptor.nodeId, routedMessage.target)) {
             // TODO this is also very similar case to what we do at line 255, could simplify the code paths?
@@ -212,10 +211,10 @@ export class RecursiveOperationManager {
         }    
     }
 
-    private getClosestConnections(nodeId: Uint8Array, limit: number): PeerDescriptor[] {
+    private getClosestConnections(referenceId: DhtAddress, limit: number): PeerDescriptor[] {
         const connectedPeers = Array.from(this.config.connections.values())
         const closestPeers = new SortedContactList<DhtNodeRpcRemote>({
-            referenceId: getNodeIdFromBinary(nodeId),
+            referenceId,
             maxSize: limit,
             allowToContainReferenceId: true,
             emitEvents: false
@@ -224,9 +223,10 @@ export class RecursiveOperationManager {
         return closestPeers.getClosestContacts(limit).map((peer) => peer.getPeerDescriptor())
     }
 
-    private isPeerCloserToIdThanSelf(peer: PeerDescriptor, compareToId: NodeID): boolean {
-        const distance1 = getDistance(getNodeIdFromPeerDescriptor(peer), compareToId)
-        const distance2 = getDistance(getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor), compareToId)
+    private isPeerCloserToIdThanSelf(peer: PeerDescriptor, nodeIdOrDataKey: DhtAddress): boolean {
+        const nodeIdOrDataKeyRaw = getRawFromDhtAddress(nodeIdOrDataKey)
+        const distance1 = getDistance(peer.nodeId, nodeIdOrDataKeyRaw)
+        const distance2 = getDistance(this.config.localPeerDescriptor.nodeId, nodeIdOrDataKeyRaw)
         return distance1 < distance2
     }
 

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

@@ -33,8 +33,8 @@ export class RecursiveOperationRpcRemote extends RpcRemote<RecursiveOperationRpc
             const fromNode = previousPeer
                 ? getNodeIdFromPeerDescriptor(previousPeer)
                 : getNodeIdFromPeerDescriptor(params.sourcePeer!)
-            // eslint-disable-next-line max-len
-            logger.debug(`Failed to send routeRequest message from ${fromNode} to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} with: ${err}`)
+            const toNode = getNodeIdFromPeerDescriptor(this.getPeerDescriptor())
+            logger.debug(`Failed to send routeRequest message from ${fromNode} to ${toNode} with: ${err}`)
             return false
         }
         return true

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

@@ -19,7 +19,7 @@ import { RecursiveOperationResult } from './RecursiveOperationManager'
 import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { ServiceID } from '../../types/ServiceID'
 import { RecursiveOperationSessionRpcLocal } from './RecursiveOperationSessionRpcLocal'
-import { NodeID, areEqualNodeIds, getNodeIdFromBinary } from '../../helpers/nodeId'
+import { DhtAddress, getDhtAddressFromRaw, getRawFromDhtAddress } from '../../identifiers'
 
 export interface RecursiveOperationSessionEvents {
     completed: () => void
@@ -27,7 +27,7 @@ export interface RecursiveOperationSessionEvents {
 
 export interface RecursiveOperationSessionConfig {
     transport: ITransport
-    targetId: Uint8Array
+    targetId: DhtAddress
     localPeerDescriptor: PeerDescriptor
     waitedRoutingPathCompletions: number
     operation: RecursiveOperation
@@ -39,9 +39,9 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
     private readonly id = v4()
     private readonly rpcCommunicator: ListeningRpcCommunicator
     private results: SortedContactList<Contact>
-    private foundData: Map<NodeID, DataEntry> = new Map()
-    private allKnownHops: Set<NodeID> = new Set()
-    private reportedHops: Set<NodeID> = new Set()
+    private foundData: Map<DhtAddress, DataEntry> = new Map()
+    private allKnownHops: Set<DhtAddress> = new Set()
+    private reportedHops: Set<DhtAddress> = new Set()
     private timeoutTask?: NodeJS.Timeout 
     private completionEventEmitted = false
     private noCloserNodesReceivedCounter = 0
@@ -51,7 +51,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
         super()
         this.config = config
         this.results = new SortedContactList({
-            referenceId: getNodeIdFromBinary(config.targetId), 
+            referenceId: config.targetId, 
             maxSize: 10,  // TODO use config option or named constant?
             allowToContainReferenceId: true,
             emitEvents: false
@@ -94,7 +94,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
         const routeMessage: RouteMessageWrapper = {
             message: msg,
             requestId: v4(),
-            target: this.config.targetId,
+            target: getRawFromDhtAddress(this.config.targetId),
             sourcePeer: this.config.localPeerDescriptor,
             reachableThrough: [],
             routingPath: []
@@ -103,7 +103,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
     }
 
     private isCompleted(): boolean {
-        const unreportedHops: Set<NodeID> = new Set(this.allKnownHops)
+        const unreportedHops: Set<DhtAddress> = new Set(this.allKnownHops)
         this.reportedHops.forEach((id) => {
             unreportedHops.delete(id)
         })
@@ -146,7 +146,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
         const localNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
         routingPath.forEach((desc) => {
             const newNodeId = getNodeIdFromPeerDescriptor(desc)
-            if (!areEqualNodeIds(localNodeId, newNodeId)) {
+            if (localNodeId !== newNodeId) {
                 this.allKnownHops.add(newNodeId)
             }
         })
@@ -155,7 +155,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
     private setHopAsReported(desc: PeerDescriptor) {
         const localNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
         const newNodeId = getNodeIdFromPeerDescriptor(desc)
-        if (!areEqualNodeIds(localNodeId, newNodeId)) {
+        if (localNodeId !== newNodeId) {
             this.reportedHops.add(newNodeId)
         }
         if (this.isCompleted()) {
@@ -172,7 +172,7 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
 
     private processFoundData(dataEntries: DataEntry[]): void {
         dataEntries.forEach((entry) => {
-            const creatorNodeId = getNodeIdFromBinary(entry.creator)
+            const creatorNodeId = getDhtAddressFromRaw(entry.creator)
             const existingEntry = this.foundData.get(creatorNodeId)
             if (!existingEntry || existingEntry.createdAt! < entry.createdAt! 
                 || (existingEntry.createdAt! <= entry.createdAt! && entry.deleted)) {

package/src/dht/routing/Router.ts

@@ -11,12 +11,12 @@ import { ConnectionManager } from '../../connection/ConnectionManager'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { v4 } from 'uuid'
 import { RouterRpcLocal, createRouteMessageAck } from './RouterRpcLocal'
-import { NodeID, getNodeIdFromBinary } from '../../helpers/nodeId'
+import { DhtAddress, getDhtAddressFromRaw } from '../../identifiers'
 
 export interface RouterConfig {
     rpcCommunicator: RoutingRpcCommunicator
     localPeerDescriptor: PeerDescriptor
-    connections: Map<NodeID, DhtNodeRpcRemote>
+    connections: Map<DhtAddress, DhtNodeRpcRemote>
     addContact: (contact: PeerDescriptor, setActive?: boolean) => void
     connectionManager?: ConnectionManager
 }
@@ -30,7 +30,7 @@ const logger = new Logger(module)
 
 export class Router {
 
-    private readonly forwardingTable: Map<NodeID, ForwardingTableEntry> = new Map()
+    private readonly forwardingTable: Map<DhtAddress, ForwardingTableEntry> = new Map()
     private ongoingRoutingSessions: Map<string, RoutingSession> = new Map()
     // TODO use config option or named constant?
     private readonly duplicateRequestDetector: DuplicateDetector = new DuplicateDetector(100000, 100)
@@ -118,7 +118,7 @@ export class Router {
             return createRouteMessageAck(routedMessage, RouteMessageError.STOPPED)
         }
         logger.trace(`Routing message ${routedMessage.requestId} from ${getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!)} `
-            + `to ${getNodeIdFromBinary(routedMessage.target)}`)
+            + `to ${getDhtAddressFromRaw(routedMessage.target)}`)
         const session = this.createRoutingSession(routedMessage, mode, excludedPeer)
         const contacts = session.updateAndGetRoutablePeers()
         if (contacts.length > 0) {
@@ -154,7 +154,7 @@ export class Router {
     }
 
     private createRoutingSession(routedMessage: RouteMessageWrapper, mode: RoutingMode, excludedNode?: PeerDescriptor): RoutingSession {
-        const excludedNodeIds = new Set<NodeID>(routedMessage.routingPath.map((descriptor) => getNodeIdFromPeerDescriptor(descriptor)))
+        const excludedNodeIds = new Set<DhtAddress>(routedMessage.routingPath.map((descriptor) => getNodeIdFromPeerDescriptor(descriptor)))
         if (excludedNode) {
             excludedNodeIds.add(getNodeIdFromPeerDescriptor(excludedNode))
         }

package/src/dht/routing/RouterRpcLocal.ts

@@ -5,7 +5,7 @@ import { PeerDescriptor, RouteMessageAck, RouteMessageError, RouteMessageWrapper
 import { IRouterRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { DuplicateDetector } from './DuplicateDetector'
 import { RoutingMode } from './RoutingSession'
-import { getNodeIdFromBinary } from '../../helpers/nodeId'
+import { getDhtAddressFromRaw } from '../../identifiers'
 
 interface RouterRpcLocalConfig {
     doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => RouteMessageAck
@@ -37,7 +37,7 @@ 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 ${getNodeIdFromBinary(routedMessage.target)} is likely a duplicate`)
+                + `to ${getDhtAddressFromRaw(routedMessage.target)} is likely a duplicate`)
             return createRouteMessageAck(routedMessage, RouteMessageError.DUPLICATE)
         }
         logger.trace(`Processing received routeMessage ${routedMessage.requestId}`)
@@ -56,7 +56,7 @@ 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 ${getNodeIdFromBinary(forwardMessage.target)} 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}`)

package/src/dht/routing/RouterRpcRemote.ts

@@ -39,7 +39,8 @@ export class RouterRpcRemote extends RpcRemote<RouterRpcClient> {
             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
@@ -67,9 +68,8 @@ export class RouterRpcRemote extends RpcRemote<RouterRpcClient> {
             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