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

package/src/dht/DhtNodeRpcRemote.ts

@@ -1,7 +1,7 @@
 import { RpcCommunicator } from '@streamr/proto-rpc'
 import { Logger } from '@streamr/utils'
 import { v4 } from 'uuid'
-import { NodeID } from '../helpers/nodeId'
+import { DhtAddress, DhtAddressRaw, getRawFromDhtAddress } from '../identifiers'
 import { getNodeIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
 import {
     ClosestPeersRequest,
@@ -16,7 +16,7 @@ const logger = new Logger(module)
 
 // Fields required by objects stored in the k-bucket library
 export interface KBucketContact {
-    id: Uint8Array
+    id: DhtAddressRaw
     vectorClock: number
 }
 
@@ -24,7 +24,8 @@ export class DhtNodeRpcRemote extends RpcRemote<DhtNodeRpcClient> implements KBu
 
     private static counter = 0
     public vectorClock: number
-    public readonly id: Uint8Array
+    public readonly id: DhtAddressRaw
+    private readonly serviceId: ServiceID
 
     constructor(
         localPeerDescriptor: PeerDescriptor,
@@ -33,28 +34,29 @@ export class DhtNodeRpcRemote extends RpcRemote<DhtNodeRpcClient> implements KBu
         rpcCommunicator: RpcCommunicator,
         rpcRequestTimeout?: number
     ) {
-        super(localPeerDescriptor, peerDescriptor, serviceId, rpcCommunicator, DhtNodeRpcClient, rpcRequestTimeout)
+        super(localPeerDescriptor, peerDescriptor, rpcCommunicator, DhtNodeRpcClient, rpcRequestTimeout)
         this.id = this.getPeerDescriptor().nodeId
         this.vectorClock = DhtNodeRpcRemote.counter++
+        this.serviceId = serviceId
     }
 
-    async getClosestPeers(nodeId: Uint8Array): Promise<PeerDescriptor[]> {
-        logger.trace(`Requesting getClosestPeers on ${this.getServiceId()} from ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
+    async getClosestPeers(nodeId: DhtAddress): Promise<PeerDescriptor[]> {
+        logger.trace(`Requesting getClosestPeers on ${this.serviceId} from ${this.getNodeId()}`)
         const request: ClosestPeersRequest = {
-            nodeId,
+            nodeId: getRawFromDhtAddress(nodeId),
             requestId: v4()
         }
         try {
             const peers = await this.getClient().getClosestPeers(request, this.formDhtRpcOptions())
             return peers.peers
         } catch (err) {
-            logger.trace(`getClosestPeers error ${this.getServiceId()}`, { err })
+            logger.trace(`getClosestPeers error ${this.serviceId}`, { err })
             throw err
         }
     }
 
     async ping(): Promise<boolean> {
-        logger.trace(`Requesting ping on ${this.getServiceId()} from ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Requesting ping on ${this.serviceId} from ${this.getNodeId()}`)
         const request: PingRequest = {
             requestId: v4()
         }
@@ -65,13 +67,13 @@ export class DhtNodeRpcRemote extends RpcRemote<DhtNodeRpcClient> implements KBu
                 return true
             }
         } catch (err) {
-            logger.trace(`ping failed on ${this.getServiceId()} to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}: ${err}`)
+            logger.trace(`ping failed on ${this.serviceId} to ${this.getNodeId()}: ${err}`)
         }
         return false
     }
 
     leaveNotice(): void {
-        logger.trace(`Sending leaveNotice on ${this.getServiceId()} from ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Sending leaveNotice on ${this.serviceId} from ${this.getNodeId()}`)
         const options = this.formDhtRpcOptions({
             notification: true
         })
@@ -80,7 +82,7 @@ export class DhtNodeRpcRemote extends RpcRemote<DhtNodeRpcClient> implements KBu
         })
     }
 
-    getNodeId(): NodeID {
+    getNodeId(): DhtAddress {
         return getNodeIdFromPeerDescriptor(this.getPeerDescriptor())
     }
 }

package/src/dht/ExternalApiRpcLocal.ts

@@ -11,19 +11,20 @@ import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { DhtCallContext } from '../rpc-protocol/DhtCallContext'
 import { RecursiveOperationResult } from './recursive-operation/RecursiveOperationManager'
 import { Any } from '../proto/google/protobuf/any'
-import { NodeID } from '../helpers/nodeId'
+import { DhtAddress } from '../identifiers'
 import { getNodeIdFromPeerDescriptor } from '../helpers/peerIdFromPeerDescriptor'
+import { getDhtAddressFromRaw } from '../identifiers'
 
 interface ExternalApiRpcLocalConfig {
     executeRecursiveOperation: (
-        targetId: Uint8Array,
+        targetId: DhtAddress,
         operation: RecursiveOperation,
         excludedPeer: PeerDescriptor
     ) => Promise<RecursiveOperationResult>
     storeDataToDht: (
-        key: Uint8Array,
+        key: DhtAddress,
         data: Any,
-        creator: NodeID
+        creator: DhtAddress
     ) => Promise<PeerDescriptor[]>
 }
 
@@ -37,13 +38,21 @@ export class ExternalApiRpcLocal implements IExternalApiRpc {
 
     async externalFindData(findDataRequest: ExternalFindDataRequest, context: ServerCallContext): Promise<ExternalFindDataResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const result = await this.config.executeRecursiveOperation(findDataRequest.key, RecursiveOperation.FETCH_DATA, senderPeerDescriptor)
+        const result = await this.config.executeRecursiveOperation(
+            getDhtAddressFromRaw(findDataRequest.key),
+            RecursiveOperation.FETCH_DATA,
+            senderPeerDescriptor
+        )
         return ExternalFindDataResponse.create({ entries: result.dataEntries ?? [] })
     }
 
     async externalStoreData(request: ExternalStoreDataRequest, context: ServerCallContext): Promise<ExternalStoreDataResponse> {
         const senderPeerDescriptor = (context as DhtCallContext).incomingSourceDescriptor!
-        const result = await this.config.storeDataToDht(request.key, request.data!, getNodeIdFromPeerDescriptor(senderPeerDescriptor))
+        const result = await this.config.storeDataToDht(
+            getDhtAddressFromRaw(request.key),
+            request.data!,
+            getNodeIdFromPeerDescriptor(senderPeerDescriptor)
+        )
         return ExternalStoreDataResponse.create({
             storers: result
         })

package/src/dht/ExternalApiRpcRemote.ts

@@ -1,3 +1,4 @@
+import { DhtAddress, getRawFromDhtAddress } from '../identifiers'
 import { Any } from '../proto/google/protobuf/any'
 import { DataEntry, ExternalFindDataRequest, ExternalStoreDataRequest, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
 import { ExternalApiRpcClient } from '../proto/packages/dht/protos/DhtRpc.client'
@@ -5,9 +6,9 @@ import { RpcRemote } from './contact/RpcRemote'
 
 export class ExternalApiRpcRemote extends RpcRemote<ExternalApiRpcClient> {
 
-    async externalFindData(key: Uint8Array): Promise<DataEntry[]> {
+    async externalFindData(key: DhtAddress): Promise<DataEntry[]> {
         const request: ExternalFindDataRequest = {
-            key
+            key: getRawFromDhtAddress(key)
         }
         const options = this.formDhtRpcOptions({
             // TODO use config option or named constant?
@@ -21,9 +22,9 @@ export class ExternalApiRpcRemote extends RpcRemote<ExternalApiRpcClient> {
         }
     }
 
-    async storeData(key: Uint8Array, data: Any): Promise<PeerDescriptor[]> {
+    async storeData(key: DhtAddress, data: Any): Promise<PeerDescriptor[]> {
         const request: ExternalStoreDataRequest = {
-            key,
+            key: getRawFromDhtAddress(key),
             data
         }
         const options = this.formDhtRpcOptions({

package/src/dht/PeerManager.ts

@@ -1,5 +1,5 @@
 import {
-    Logger, hexToBinary
+    Logger
 } from '@streamr/utils'
 import KBucket from 'k-bucket'
 import {
@@ -13,7 +13,7 @@ import { RandomContactList } from './contact/RandomContactList'
 import { SortedContactList } from './contact/SortedContactList'
 import { ConnectionManager } from '../connection/ConnectionManager'
 import EventEmitter from 'eventemitter3'
-import { NodeID, areEqualNodeIds } from '../helpers/nodeId'
+import { DhtAddress, DhtAddressRaw, getRawFromDhtAddress } from '../identifiers'
 
 const logger = new Logger(module)
 
@@ -21,7 +21,7 @@ interface PeerManagerConfig {
     numberOfNodesPerKBucket: number
     maxContactListSize: number
     peerDiscoveryQueryBatchSize: number
-    localNodeId: NodeID
+    localNodeId: DhtAddress
     connectionManager: ConnectionManager
     isLayer0: boolean
     createDhtNodeRpcRemote: (peerDescriptor: PeerDescriptor) => DhtNodeRpcRemote
@@ -35,8 +35,8 @@ export interface PeerManagerEvents {
     kBucketEmpty: () => void
 }
 
-export const getDistance = (nodeId1: NodeID, nodeId2: NodeID): number => {
-    return KBucket.distance(hexToBinary(nodeId1), hexToBinary(nodeId2))
+export const getDistance = (nodeIdOrDataKeyRaw1: DhtAddressRaw, nodeIdOrDataKeyRaw2: DhtAddressRaw): number => {
+    return KBucket.distance(nodeIdOrDataKeyRaw1, nodeIdOrDataKeyRaw2)
 }
 
 export class PeerManager extends EventEmitter<PeerManagerEvents> {
@@ -50,7 +50,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     // The kademlia k-bucket
     private bucket: KBucket<DhtNodeRpcRemote>
     // Nodes that are connected to this node on Layer0
-    public readonly connections: Map<NodeID, DhtNodeRpcRemote> = new Map()
+    public readonly connections: Map<DhtAddress, DhtNodeRpcRemote> = new Map()
     // All nodes that we know about
     private contacts: SortedContactList<DhtNodeRpcRemote>
     private randomPeers: RandomContactList<DhtNodeRpcRemote>
@@ -61,7 +61,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         super()
         this.config = config
         this.bucket = new KBucket<DhtNodeRpcRemote>({
-            localNodeId: hexToBinary(this.config.localNodeId),
+            localNodeId: getRawFromDhtAddress(this.config.localNodeId),
             numberOfNodesPerKBucket: this.config.numberOfNodesPerKBucket,
             numberOfNodesToPing: this.config.numberOfNodesPerKBucket
         })
@@ -108,8 +108,9 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         })
         sortingList.addContacts(oldContacts)
         const sortedContacts = sortingList.getAllContacts()
-        this.config.connectionManager?.weakUnlockConnection(sortedContacts[sortedContacts.length - 1].getPeerDescriptor())
-        this.bucket.remove(hexToBinary(sortedContacts[sortedContacts.length - 1].getNodeId()))
+        const removableNodeId = sortedContacts[sortedContacts.length - 1].getNodeId()
+        this.config.connectionManager?.weakUnlockConnection(removableNodeId)
+        this.bucket.remove(getRawFromDhtAddress(removableNodeId))
         this.bucket.add(newContact)
     }
 
@@ -117,8 +118,9 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         if (this.stopped) {
             return
         }
-        this.config.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
-        logger.trace(`Removed contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
+        const nodeId = getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())
+        this.config.connectionManager?.weakUnlockConnection(nodeId)
+        logger.trace(`Removed contact ${nodeId}`)
         if (this.bucket.count() === 0) {
             this.emit('kBucketEmpty')
         }
@@ -128,26 +130,28 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         if (this.stopped) {
             return
         }
-        if (!areEqualNodeIds(contact.getNodeId(), this.config.localNodeId)) {
+        if (contact.getNodeId() !== this.config.localNodeId) {
+            const peerDescriptor = contact.getPeerDescriptor()
+            const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
             // Important to lock here, before the ping result is known
-            this.config.connectionManager?.weakLockConnection(contact.getPeerDescriptor())
+            this.config.connectionManager?.weakLockConnection(nodeId)
             if (this.connections.has(contact.getNodeId())) {
-                logger.trace(`Added new contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
+                logger.trace(`Added new contact ${nodeId}`)
             } else {    // open connection by pinging
-                logger.trace('starting ping ' + getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
+                logger.trace('starting ping ' + nodeId)
                 contact.ping().then((result) => {
                     if (result) {
-                        logger.trace(`Added new contact ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
+                        logger.trace(`Added new contact ${nodeId}`)
                     } else {
-                        logger.trace('ping failed ' + getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
-                        this.config.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
-                        this.removeContact(contact.getPeerDescriptor())
+                        logger.trace('ping failed ' + nodeId)
+                        this.config.connectionManager?.weakUnlockConnection(nodeId)
+                        this.removeContact(peerDescriptor)
                         this.addClosestContactToBucket()
                     }
                     return
                 }).catch((_e) => {
-                    this.config.connectionManager?.weakUnlockConnection(contact.getPeerDescriptor())
-                    this.removeContact(contact.getPeerDescriptor())
+                    this.config.connectionManager?.weakUnlockConnection(nodeId)
+                    this.removeContact(peerDescriptor)
                     this.addClosestContactToBucket()
                 })
             }
@@ -166,7 +170,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
 
     private getClosestActiveContactNotInBucket(): DhtNodeRpcRemote | undefined {
         for (const contactId of this.contacts.getContactIds()) {
-            if (!this.bucket.get(hexToBinary(contactId)) && this.contacts.isActive(contactId)) {
+            if (!this.bucket.get(getRawFromDhtAddress(contactId)) && this.contacts.isActive(contactId)) {
                 return this.contacts.getContact(contactId)!.contact
             }
         }
@@ -175,7 +179,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
 
     handleConnected(peerDescriptor: PeerDescriptor): void {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
-        if (areEqualNodeIds(nodeId, this.config.localNodeId)) {
+        if (nodeId === this.config.localNodeId) {
             logger.error('handleConnected() to self')
         }
         const rpcRemote = this.config.createDhtNodeRpcRemote(peerDescriptor)
@@ -185,19 +189,20 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         } else {
             logger.trace('new connection not set to connections, there is already a connection with the peer ID')
         }
-        logger.trace('connected: ' + getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + this.connections.size)
+        logger.trace('connected: ' + nodeId + ' ' + this.connections.size)
     }
 
     handleDisconnected(peerDescriptor: PeerDescriptor, gracefulLeave: boolean): void {
-        logger.trace('disconnected: ' + getNodeIdFromPeerDescriptor(peerDescriptor))
-        this.connections.delete(getNodeIdFromPeerDescriptor(peerDescriptor))
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
+        logger.trace('disconnected: ' + nodeId)
+        this.connections.delete(nodeId)
         if (this.config.isLayer0) {
             this.bucket.remove(peerDescriptor.nodeId)
             if (gracefulLeave === true) {
-                logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
+                logger.trace(nodeId + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
                 this.removeContact(peerDescriptor)
             } else {
-                logger.trace(getNodeIdFromPeerDescriptor(peerDescriptor) + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
+                logger.trace(nodeId + ' ' + 'onTransportDisconnected with gracefulLeave ' + gracefulLeave)
             }
         }
     }
@@ -210,9 +215,9 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         if (this.stopped) {
             return
         }
-        logger.trace(`Removing contact ${getNodeIdFromPeerDescriptor(contact)}`)
         const nodeId = getNodeIdFromPeerDescriptor(contact)
-        this.bucket.remove(hexToBinary(nodeId))
+        logger.trace(`Removing contact ${nodeId}`)
+        this.bucket.remove(getRawFromDhtAddress(nodeId))
         this.contacts.removeContact(nodeId)
         this.randomPeers.removeContact(nodeId)
     }
@@ -229,19 +234,19 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         this.connections.clear()
     }
 
-    getClosestNeighborsTo(referenceId: NodeID, limit?: number, excludedNodeIds?: Set<NodeID>): DhtNodeRpcRemote[] {
+    getClosestNeighborsTo(referenceId: DhtAddress, limit?: number, excludedNodeIds?: Set<DhtAddress>): DhtNodeRpcRemote[] {
         const closest = new SortedContactList<DhtNodeRpcRemote>({
             referenceId,
             allowToContainReferenceId: true,
             emitEvents: false,
             excludedNodeIds
         }) 
-        this.bucket.toArray().map((contact) => closest.addContact(contact))
+        this.bucket.toArray().forEach((contact) => closest.addContact(contact))
         return closest.getClosestContacts(limit)
     }
 
     // TODO reduce copy-paste?
-    getClosestContactsTo(referenceId: NodeID, limit?: number, excludedNodeIds?: Set<NodeID>): DhtNodeRpcRemote[] {
+    getClosestContactsTo(referenceId: DhtAddress, limit?: number, excludedNodeIds?: Set<DhtAddress>): DhtNodeRpcRemote[] {
         const closest = new SortedContactList<DhtNodeRpcRemote>({
             referenceId,
             allowToContainReferenceId: true,
@@ -253,7 +258,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         return closest.getClosestContacts(limit)
     }
 
-    getNumberOfContacts(excludedNodeIds?: Set<NodeID>): number {
+    getNumberOfContacts(excludedNodeIds?: Set<DhtAddress>): number {
         return this.contacts.getAllContacts().filter((contact) => {
             if (!excludedNodeIds) {
                 return true
@@ -275,12 +280,12 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         return this.bucket.toArray().map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
     }
 
-    handlePeerActive(nodeId: NodeID): void {
+    handlePeerActive(nodeId: DhtAddress): void {
         this.contacts.setActive(nodeId)
     }
 
-    handlePeerUnresponsive(nodeId: NodeID): void {
-        this.bucket.remove(hexToBinary(nodeId))
+    handlePeerUnresponsive(nodeId: DhtAddress): void {
+        this.bucket.remove(getRawFromDhtAddress(nodeId))
         this.contacts.removeContact(nodeId)
     }
 
@@ -290,7 +295,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         }
         peerDescriptors.forEach((contact) => {
             const nodeId = getNodeIdFromPeerDescriptor(contact)
-            if (!areEqualNodeIds(nodeId, this.config.localNodeId)) {
+            if (nodeId !== this.config.localNodeId) {
                 logger.trace(`Adding new contact ${nodeId}`)
                 const remote = this.config.createDhtNodeRpcRemote(contact)
                 const isInBucket = (this.bucket.get(contact.nodeId) !== null)

package/src/dht/contact/Contact.ts

@@ -1,6 +1,6 @@
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
-import { NodeID } from '../../helpers/nodeId'
+import { DhtAddress } from '../../identifiers'
 
 export class Contact {
 
@@ -14,7 +14,7 @@ export class Contact {
         return this.peerDescriptor
     }
 
-    public getNodeId(): NodeID {
+    public getNodeId(): DhtAddress {
         return getNodeIdFromPeerDescriptor(this.peerDescriptor)
     }
 }

package/src/dht/contact/ContactList.ts

@@ -1,5 +1,5 @@
 import EventEmitter from 'eventemitter3'
-import { NodeID } from '../../helpers/nodeId'
+import { DhtAddress } from '../../identifiers'
 
 export class ContactState<C> {
     public contacted = false
@@ -16,17 +16,17 @@ export interface Events<C> {
     newContact: (newContact: C, closestContacts: C[]) => void
 }
 
-export class ContactList<C extends { getNodeId: () => NodeID }> extends EventEmitter<Events<C>> {
+export class ContactList<C extends { getNodeId: () => DhtAddress }> extends EventEmitter<Events<C>> {
 
-    protected contactsById: Map<NodeID, ContactState<C>> = new Map()
+    protected contactsById: Map<DhtAddress, ContactState<C>> = new Map()
     // TODO move this to SortedContactList
-    protected contactIds: NodeID[] = []
-    protected localNodeId: NodeID
+    protected contactIds: DhtAddress[] = []
+    protected localNodeId: DhtAddress
     protected maxSize: number
     protected defaultContactQueryLimit
 
     constructor(
-        localNodeId: NodeID,
+        localNodeId: DhtAddress,
         maxSize: number,
         defaultContactQueryLimit = 20
     ) {
@@ -36,7 +36,7 @@ export class ContactList<C extends { getNodeId: () => NodeID }> extends EventEmi
         this.defaultContactQueryLimit = defaultContactQueryLimit
     }
 
-    public getContact(id: NodeID): ContactState<C> | undefined {
+    public getContact(id: DhtAddress): ContactState<C> | undefined {
         return this.contactsById.get(id)
     }
 

package/src/dht/contact/RandomContactList.ts

@@ -1,12 +1,12 @@
-import { NodeID, areEqualNodeIds } from '../../helpers/nodeId'
+import { DhtAddress } from '../../identifiers'
 import { ContactList, ContactState } from './ContactList'
 
-export class RandomContactList<C extends { getNodeId: () => NodeID }> extends ContactList<C> {
+export class RandomContactList<C extends { getNodeId: () => DhtAddress }> extends ContactList<C> {
 
     private randomness: number
 
     constructor(
-        localNodeId: NodeID,
+        localNodeId: DhtAddress,
         maxSize: number,
         randomness = 0.20,
         defaultContactQueryLimit?: number
@@ -16,7 +16,7 @@ export class RandomContactList<C extends { getNodeId: () => NodeID }> extends Co
     }
 
     addContact(contact: C): void {
-        if (areEqualNodeIds(this.localNodeId, contact.getNodeId())) {
+        if (this.localNodeId === contact.getNodeId()) {
             return
         }
         if (!this.contactsById.has(contact.getNodeId())) {
@@ -37,10 +37,10 @@ export class RandomContactList<C extends { getNodeId: () => NodeID }> extends Co
         }
     }
 
-    removeContact(id: NodeID): boolean {
+    removeContact(id: DhtAddress): boolean {
         if (this.contactsById.has(id)) {
             const removed = this.contactsById.get(id)!.contact
-            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)
             this.emit('contactRemoved', removed, this.getContacts())

package/src/dht/contact/RpcRemote.ts

@@ -4,7 +4,6 @@ import { ConnectionType } from '../../connection/IConnection'
 import { expectedConnectionType } from '../../helpers/Connectivity'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { DhtRpcOptions } from '../../rpc-protocol/DhtRpcOptions'
-import { ServiceID } from '../../types/ServiceID'
 
 // Should connect directly to the server, timeout can be low
 const WEBSOCKET_CLIENT_TIMEOUT = 5000
@@ -32,14 +31,12 @@ export abstract class RpcRemote<T extends ServiceInfo & ClassType> {
 
     private readonly localPeerDescriptor: PeerDescriptor
     private readonly remotePeerDescriptor: PeerDescriptor
-    private readonly serviceId: ServiceID
     private readonly client: ProtoRpcClient<T>
     private readonly timeout?: number
 
     constructor(
         localPeerDescriptor: PeerDescriptor,
         remotePeerDescriptor: PeerDescriptor,
-        serviceId: ServiceID,
         rpcCommunicator: RpcCommunicator,
         // eslint-disable-next-line @typescript-eslint/prefer-function-type
         clientClass: { new (clientTransport: ClientTransport): T },
@@ -48,7 +45,6 @@ export abstract class RpcRemote<T extends ServiceInfo & ClassType> {
         this.localPeerDescriptor = localPeerDescriptor
         this.remotePeerDescriptor = remotePeerDescriptor
         this.client = toProtoRpcClient(new clientClass(rpcCommunicator.getRpcClientTransport()))
-        this.serviceId = serviceId
         this.timeout = timeout
     }
 
@@ -60,10 +56,6 @@ export abstract class RpcRemote<T extends ServiceInfo & ClassType> {
         return this.localPeerDescriptor
     }
 
-    getServiceId(): ServiceID {
-        return this.serviceId
-    }
-
     getClient(): ProtoRpcClient<T> {
         return this.client
     }