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

package/src/connection/connectivityRequestHandler.ts

@@ -34,10 +34,25 @@ export const attachConnectivityRequestHandler = (connectionToListenTo: ServerWeb
 }
 
 const handleIncomingConnectivityRequest = async (connection: ServerWebsocket, connectivityRequest: ConnectivityRequest): Promise<void> => {
-    let outgoingConnection: IConnection | undefined
-    let connectivityResponseMessage: ConnectivityResponse | undefined
     const host = connectivityRequest.host ?? connection.getRemoteAddress()
     const ipAddress = connection.getRemoteIp()
+    const connectivityResponse = await connectivityProbe(connectivityRequest, ipAddress, host)
+    const msg: Message = {
+        serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
+        messageType: MessageType.CONNECTIVITY_RESPONSE,
+        messageId: v4(),
+        body: {
+            oneofKind: 'connectivityResponse',
+            connectivityResponse
+        }
+    }
+    connection.send(Message.toBinary(msg))
+    logger.trace('ConnectivityResponse sent: ' + JSON.stringify(Message.toJson(msg)))
+}
+
+const connectivityProbe = async (connectivityRequest: ConnectivityRequest, ipAddress: string, host: string): Promise<ConnectivityResponse> => {
+    let outgoingConnection: IConnection | undefined
+    let connectivityResponseMessage: ConnectivityResponse
     try {
         const wsServerInfo = {
             host,
@@ -50,6 +65,14 @@ const handleIncomingConnectivityRequest = async (connection: ServerWebsocket, co
             url,
             selfSigned: connectivityRequest.selfSigned
         })
+        logger.trace('Connectivity test produced positive result, communicating reply to the requester ' + host + ':' + connectivityRequest.port)
+        connectivityResponseMessage = {
+            host,
+            natType: NatType.OPEN_INTERNET,
+            websocket: { host, port: connectivityRequest.port, tls: connectivityRequest.tls },
+            ipAddress: ipv4ToNumber(ipAddress),
+            version: localVersion
+        }
     } catch (err) {
         logger.debug('error', { err })
         connectivityResponseMessage = {
@@ -62,25 +85,6 @@ const handleIncomingConnectivityRequest = async (connection: ServerWebsocket, co
     if (outgoingConnection) {
         // TODO should we have some handling for this floating promise?
         outgoingConnection.close(false)
-        logger.trace('Connectivity test produced positive result, communicating reply to the requester ' + host + ':' + connectivityRequest.port)
-        
-        connectivityResponseMessage = {
-            host,
-            natType: NatType.OPEN_INTERNET,
-            websocket: { host, port: connectivityRequest.port, tls: connectivityRequest.tls },
-            ipAddress: ipv4ToNumber(ipAddress),
-            version: localVersion
-        }
     }
-    const msg: Message = {
-        serviceId: CONNECTIVITY_CHECKER_SERVICE_ID,
-        messageType: MessageType.CONNECTIVITY_RESPONSE,
-        messageId: v4(),
-        body: {
-            oneofKind: 'connectivityResponse',
-            connectivityResponse: connectivityResponseMessage!
-        }
-    }
-    connection.send(Message.toBinary(msg))
-    logger.trace('ConnectivityResponse sent: ' + JSON.stringify(Message.toJson(msg)))
+    return connectivityResponseMessage
 }

package/src/connection/websocket/WebsocketConnector.ts

@@ -153,7 +153,15 @@ export class WebsocketConnector {
                 } else if (action === 'connectivityProbe') {
                     // no-op
                 } else {
-                    this.attachHandshaker(connection)
+                    // The localPeerDescriptor can be undefined here as the WS server is used for connectivity checks
+                    // before the localPeerDescriptor is set during start.
+                    // Handshaked connections should be rejected before the localPeerDescriptor is set.
+                    if (this.localPeerDescriptor !== undefined) {
+                        this.attachHandshaker(connection)
+                    } else {
+                        logger.trace('incoming Websocket connection before localPeerDescriptor was set, closing connection')
+                        connection.close(false).catch(() => {})
+                    }
                 }
             })
             const port = await this.websocketServer.start()

package/src/dht/DhtNode.ts

@@ -12,7 +12,7 @@ import { ConnectionManager, PortRange, TlsCertificate } from '../connection/Conn
 import { DefaultConnectorFacade, DefaultConnectorFacadeConfig } from '../connection/ConnectorFacade'
 import { IceServer } from '../connection/webrtc/WebrtcConnector'
 import { isBrowserEnvironment } from '../helpers/browser/isBrowserEnvironment'
-import { DhtAddress, getNodeIdFromPeerDescriptor } from '../identifiers'
+import { DhtAddress, KADEMLIA_ID_LENGTH_IN_BYTES, getNodeIdFromPeerDescriptor } from '../identifiers'
 import { Any } from '../proto/google/protobuf/any'
 import {
     ClosestPeersRequest,
@@ -48,9 +48,9 @@ import { StoreRpcRemote } from './store/StoreRpcRemote'
 import { createPeerDescriptor } from '../helpers/createPeerDescriptor'
 
 export interface DhtNodeEvents {
-    newContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    contactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     contactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
-    newRandomContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    randomContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     randomContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
 }
 
@@ -143,10 +143,27 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             storageRedundancyFactor: 5,
             metricsContext: new MetricsContext()
         }, conf)
+        this.validateConfig()
         this.localDataStore = new LocalDataStore(this.config.storeMaxTtl)
         this.send = this.send.bind(this)
     }
 
+    private validateConfig(): void {
+        const expectedNodeIdLength = KADEMLIA_ID_LENGTH_IN_BYTES * 2
+        if (this.config.nodeId !== undefined ) {
+            if (!/^[0-9a-fA-F]+$/.test(this.config.nodeId)) {
+                throw new Error('Invalid nodeId, the nodeId should be a hex string')
+            } else if (this.config.nodeId.length !== expectedNodeIdLength) {
+                throw new Error(`Invalid nodeId, the length of the nodeId should be ${expectedNodeIdLength}`)
+            }
+        }
+        if (this.config.peerDescriptor !== undefined) {
+            if (this.config.peerDescriptor.nodeId.length !== KADEMLIA_ID_LENGTH_IN_BYTES) {
+                throw new Error(`Invalid peerDescriptor, the length of the nodeId should be ${KADEMLIA_ID_LENGTH_IN_BYTES} bytes`)
+            }
+        }
+    }
+
     public async start(): Promise<void> {
         if (this.started || this.abortController.signal.aborted) {
             return
@@ -232,7 +249,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             rpcCommunicator: this.rpcCommunicator,
             connections: this.peerManager!.connections,
             localPeerDescriptor: this.localPeerDescriptor!,
-            addContact: (contact: PeerDescriptor, setActive?: boolean) => this.peerManager!.handleNewPeers([contact], setActive),
+            addContact: (contact: PeerDescriptor, setActive?: boolean) => this.peerManager!.addContact([contact], setActive),
             connectionManager: this.connectionManager
         })
         this.recursiveOperationManager = new RecursiveOperationManager({
@@ -242,7 +259,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             connections: this.peerManager!.connections,
             localPeerDescriptor: this.localPeerDescriptor!,
             serviceId: this.config.serviceId,
-            addContact: (contact: PeerDescriptor) => this.peerManager!.handleNewPeers([contact]),
+            addContact: (contact: PeerDescriptor) => this.peerManager!.addContact([contact]),
             localDataStore: this.localDataStore
         })
         this.storeManager = new StoreManager({
@@ -266,8 +283,8 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                 )
             }
         })
-        this.on('newContact', (peerDescriptor: PeerDescriptor) => {
-            this.storeManager!.onNewContact(peerDescriptor)
+        this.on('contactAdded', (peerDescriptor: PeerDescriptor) => {
+            this.storeManager!.onContactAdded(peerDescriptor)
         })
         this.bindRpcLocalMethods()
     }
@@ -285,14 +302,14 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         this.peerManager.on('contactRemoved', (peerDescriptor: PeerDescriptor, activeContacts: PeerDescriptor[]) => {
             this.emit('contactRemoved', peerDescriptor, activeContacts)
         })
-        this.peerManager.on('newContact', (peerDescriptor: PeerDescriptor, activeContacts: PeerDescriptor[]) =>
-            this.emit('newContact', peerDescriptor, activeContacts)
+        this.peerManager.on('contactAdded', (peerDescriptor: PeerDescriptor, activeContacts: PeerDescriptor[]) =>
+            this.emit('contactAdded', peerDescriptor, activeContacts)
         )
         this.peerManager.on('randomContactRemoved', (peerDescriptor: PeerDescriptor, activeContacts: PeerDescriptor[]) =>
             this.emit('randomContactRemoved', peerDescriptor, activeContacts)
         )
-        this.peerManager.on('newRandomContact', (peerDescriptor: PeerDescriptor, activeContacts: PeerDescriptor[]) =>
-            this.emit('newRandomContact', peerDescriptor, activeContacts)
+        this.peerManager.on('randomContactAdded', (peerDescriptor: PeerDescriptor, activeContacts: PeerDescriptor[]) =>
+            this.emit('randomContactAdded', peerDescriptor, activeContacts)
         )
         this.peerManager.on('kBucketEmpty', () => {
             if (!this.peerDiscovery!.isJoinOngoing()
@@ -308,15 +325,15 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
             }
         })
         this.transport!.on('connected', (peerDescriptor: PeerDescriptor) => {
-            this.peerManager!.handleConnected(peerDescriptor)
+            this.peerManager!.onContactConnected(peerDescriptor)
             this.emit('connected', peerDescriptor)
         })
         this.transport!.on('disconnected', (peerDescriptor: PeerDescriptor, gracefulLeave: boolean) => {
-            this.peerManager!.handleDisconnected(getNodeIdFromPeerDescriptor(peerDescriptor), gracefulLeave)
+            this.peerManager!.onContactDisconnected(getNodeIdFromPeerDescriptor(peerDescriptor), gracefulLeave)
             this.emit('disconnected', peerDescriptor, gracefulLeave)
         })
         this.transport!.getConnections().forEach((peer) => {
-            this.peerManager!.handleConnected(peer)
+            this.peerManager!.onContactConnected(peer)
         })
     }
 
@@ -330,7 +347,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
                 return this.peerManager!.getClosestNeighborsTo(nodeId, limit)
                     .map((dhtPeer: DhtNodeRpcRemote) => dhtPeer.getPeerDescriptor())
             },
-            addNewContact: (contact: PeerDescriptor) => this.peerManager!.handleNewPeers([contact]),
+            addContact: (contact: PeerDescriptor) => this.peerManager!.addContact([contact]),
             removeContact: (nodeId: DhtAddress) => this.removeContact(nodeId)
         })
         this.rpcCommunicator!.registerRpcMethod(ClosestPeersRequest, ClosestPeersResponse, 'getClosestPeers',
@@ -400,7 +417,7 @@ export class DhtNode extends EventEmitter<Events> implements ITransport {
         if (!this.started) {  // the stopped state is checked in PeerManager
             return
         }
-        this.peerManager!.handlePeerLeaving(nodeId)
+        this.peerManager!.removeContact(nodeId)
     }
 
     public async send(msg: Message): Promise<void> {

package/src/dht/DhtNodeRpcLocal.ts

@@ -15,7 +15,7 @@ import { DhtAddress, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '.
 interface DhtNodeRpcLocalConfig {
     peerDiscoveryQueryBatchSize: number
     getClosestPeersTo: (nodeId: DhtAddress, limit: number) => PeerDescriptor[]
-    addNewContact: (contact: PeerDescriptor) => void
+    addContact: (contact: PeerDescriptor) => void
     removeContact: (nodeId: DhtAddress) => void
 }
 
@@ -30,7 +30,7 @@ export class DhtNodeRpcLocal implements IDhtNodeRpc {
     }
 
     async getClosestPeers(request: ClosestPeersRequest, context: ServerCallContext): Promise<ClosestPeersResponse> {
-        this.config.addNewContact((context as DhtCallContext).incomingSourceDescriptor!)
+        this.config.addContact((context as DhtCallContext).incomingSourceDescriptor!)
         const response = {
             peers: this.config.getClosestPeersTo(getDhtAddressFromRaw(request.nodeId), this.config.peerDiscoveryQueryBatchSize),
             requestId: request.requestId
@@ -41,7 +41,7 @@ export class DhtNodeRpcLocal implements IDhtNodeRpc {
     async ping(request: PingRequest, context: ServerCallContext): Promise<PingResponse> {
         logger.trace('received ping request: ' + getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!))
         setImmediate(() => {
-            this.config.addNewContact((context as DhtCallContext).incomingSourceDescriptor!)
+            this.config.addContact((context as DhtCallContext).incomingSourceDescriptor!)
         })
         const response: PingResponse = {
             requestId: request.requestId

package/src/dht/PeerManager.ts

@@ -25,9 +25,9 @@ interface PeerManagerConfig {
 }
 
 export interface PeerManagerEvents {
-    newContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    contactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     contactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
-    newRandomContact: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
+    randomContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     randomContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: PeerDescriptor[]) => void
     kBucketEmpty: () => void
 }
@@ -81,15 +81,15 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             this.emit('contactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
             this.randomPeers.addContact(this.config.createDhtNodeRpcRemote(removedContact.getPeerDescriptor()))
         })
-        this.contacts.on('newContact', (newContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
-            this.emit('newContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+        this.contacts.on('contactAdded', (contactAdded: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
+            this.emit('contactAdded', contactAdded.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
         this.randomPeers = new RandomContactList(this.config.localNodeId, this.config.maxContactListSize)
         this.randomPeers.on('contactRemoved', (removedContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
             this.emit('randomContactRemoved', removedContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
-        this.randomPeers.on('newContact', (newContact: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
-            this.emit('newRandomContact', newContact.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
+        this.randomPeers.on('contactAdded', (contactAdded: DhtNodeRpcRemote, activeContacts: DhtNodeRpcRemote[]) =>
+            this.emit('randomContactAdded', contactAdded.getPeerDescriptor(), activeContacts.map((c) => c.getPeerDescriptor()))
         )
     }
 
@@ -160,7 +160,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         }
         const closest = this.getClosestActiveContactNotInBucket()
         if (closest) {
-            this.handleNewPeers([closest.getPeerDescriptor()])
+            this.addContact([closest.getPeerDescriptor()])
         }
     }
 
@@ -173,7 +173,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         return undefined
     }
 
-    handleConnected(peerDescriptor: PeerDescriptor): void {
+    onContactConnected(peerDescriptor: PeerDescriptor): void {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         if (nodeId === this.config.localNodeId) {
             logger.error('handleConnected() to self')
@@ -188,7 +188,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         logger.trace('connected: ' + nodeId + ' ' + this.connections.size)
     }
 
-    handleDisconnected(nodeId: DhtAddress, gracefulLeave: boolean): void {
+    onContactDisconnected(nodeId: DhtAddress, gracefulLeave: boolean): void {
         logger.trace('disconnected: ' + nodeId)
         this.connections.delete(nodeId)
         if (this.config.isLayer0) {
@@ -202,11 +202,7 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         }
     }
 
-    handlePeerLeaving(nodeId: DhtAddress): void {
-        this.removeContact(nodeId)
-    }
-
-    private removeContact(nodeId: DhtAddress): void {
+    removeContact(nodeId: DhtAddress): void {
         if (this.stopped) {
             return
         }
@@ -274,16 +270,11 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         return this.bucket.toArray().map((rpcRemote: DhtNodeRpcRemote) => rpcRemote.getPeerDescriptor())
     }
 
-    handlePeerActive(nodeId: DhtAddress): void {
+    setContactActive(nodeId: DhtAddress): void {
         this.contacts.setActive(nodeId)
     }
 
-    handlePeerUnresponsive(nodeId: DhtAddress): void {
-        this.bucket.remove(getRawFromDhtAddress(nodeId))
-        this.contacts.removeContact(nodeId)
-    }
-
-    handleNewPeers(peerDescriptors: PeerDescriptor[], setActive?: boolean): void { 
+    addContact(peerDescriptors: PeerDescriptor[], setActive?: boolean): void { 
         if (this.stopped) {
             return
         }

package/src/dht/contact/ContactList.ts

@@ -13,7 +13,7 @@ export class ContactState<C> {
 
 export interface Events<C> {
     contactRemoved: (removedContact: C, closestContacts: C[]) => void
-    newContact: (newContact: C, closestContacts: C[]) => void
+    contactAdded: (contactAdded: C, closestContacts: C[]) => void
 }
 
 export class ContactList<C extends { getNodeId: () => DhtAddress }> extends EventEmitter<Events<C>> {

package/src/dht/contact/RandomContactList.ts

@@ -29,7 +29,7 @@ export class RandomContactList<C extends { getNodeId: () => DhtAddress }> extend
                 this.contactIds.push(contact.getNodeId())
                 this.contactsById.set(contact.getNodeId(), new ContactState(contact))
                 this.emit(
-                    'newContact',
+                    'contactAdded',
                     contact,
                     this.getContacts()
                 )

package/src/dht/contact/SortedContactList.ts

@@ -40,45 +40,47 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
     }
 
     public addContact(contact: C): void {
-        if (this.config.excludedNodeIds !== undefined && this.config.excludedNodeIds.has(contact.getNodeId())) {
+        const contactId = contact.getNodeId()
+        if (this.config.excludedNodeIds !== undefined && this.config.excludedNodeIds.has(contactId)) {
             return
         }
-
-        if ((!this.config.allowToContainReferenceId && (this.config.referenceId === contact.getNodeId())) ||
-            (this.config.nodeIdDistanceLimit !== undefined && this.compareIds(this.config.nodeIdDistanceLimit, contact.getNodeId()) < 0)) {
+        if ((!this.config.allowToContainReferenceId && (this.config.referenceId === contactId)) ||
+            (this.config.nodeIdDistanceLimit !== undefined && this.compareIds(this.config.nodeIdDistanceLimit, contactId) < 0)) {
             return
         }
-        if (!this.contactsById.has(contact.getNodeId())) {
+        if (!this.contactsById.has(contactId)) {
             if ((this.config.maxSize === undefined) || (this.contactIds.length < this.config.maxSize)) {
-                this.contactsById.set(contact.getNodeId(), new ContactState(contact))
-
-                // eslint-disable-next-line max-len
-                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) {
+                this.contactsById.set(contactId, new ContactState(contact))
+                const index = sortedIndexBy(this.contactIds, contactId, (id: DhtAddress) => { return this.distanceToReferenceId(id) })
+                this.contactIds.splice(index, 0, contactId)
+                if (this.config.emitEvents) {
+                    this.emit(
+                        'contactAdded',
+                        contact,
+                        this.getClosestContacts()
+                    )
+                }
+            } else if (this.compareIds(this.contactIds[this.config.maxSize - 1], contactId) > 0) {
                 const removedId = this.contactIds.pop()
                 const removedContact = this.contactsById.get(removedId!)!.contact
                 this.contactsById.delete(removedId!)
-                this.contactsById.set(contact.getNodeId(), new ContactState(contact))
-
-                // eslint-disable-next-line max-len
-                const index = sortedIndexBy(this.contactIds, contact.getNodeId(), (id: DhtAddress) => { return this.distanceToReferenceId(id) })
-                this.contactIds.splice(index, 0, contact.getNodeId())
+                this.contactsById.set(contactId, new ContactState(contact))
+                const index = sortedIndexBy(this.contactIds, contactId, (id: DhtAddress) => { return this.distanceToReferenceId(id) })
+                this.contactIds.splice(index, 0, contactId)
                 if (this.config.emitEvents) {
+                    const closestContacts = this.getClosestContacts()
                     this.emit(
                         'contactRemoved',
                         removedContact,
-                        this.getClosestContacts()
+                        closestContacts
+                    )
+                    this.emit(
+                        'contactAdded',
+                        contact,
+                        closestContacts
                     )
                 }
             }
-            if (this.config.emitEvents) {
-                this.emit(
-                    'newContact',
-                    contact,
-                    this.getClosestContacts()
-                )
-            }
         }
     }
 

package/src/dht/discovery/DiscoverySession.ts

@@ -34,11 +34,11 @@ export class DiscoverySession {
         this.config = config
     }
 
-    private addNewContacts(contacts: PeerDescriptor[]): void {
+    private addContacts(contacts: PeerDescriptor[]): void {
         if (this.stopped) {
             return
         }
-        this.config.peerManager.handleNewPeers(contacts)
+        this.config.peerManager.addContact(contacts)
     }
 
     private async getClosestPeersFromContact(contact: DhtNodeRpcRemote): Promise<PeerDescriptor[]> {
@@ -48,7 +48,7 @@ export class DiscoverySession {
         logger.trace(`Getting closest peers from contact: ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
         this.config.contactedPeers.add(contact.getNodeId())
         const returnedContacts = await contact.getClosestPeers(this.config.targetId)
-        this.config.peerManager.handlePeerActive(contact.getNodeId())
+        this.config.peerManager.setContactActive(contact.getNodeId())
         return returnedContacts
     }
 
@@ -60,7 +60,7 @@ export class DiscoverySession {
         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)
+        this.addContacts(contacts)
         const newClosestNeighbor = this.config.peerManager.getClosestNeighborsTo(this.config.targetId, 1)[0]
         const newClosestDistance = getDistance(targetId, getRawFromDhtAddress(newClosestNeighbor.getNodeId()))
         if (newClosestDistance >= oldClosestDistance) {
@@ -73,7 +73,7 @@ export class DiscoverySession {
             return
         }
         this.ongoingClosestPeersRequests.delete(peer.getNodeId())
-        this.config.peerManager.handlePeerUnresponsive(peer.getNodeId())
+        this.config.peerManager.removeContact(peer.getNodeId())
     }
 
     private findMoreContacts(): void {

package/src/dht/discovery/PeerDiscovery.ts

@@ -75,7 +75,7 @@ export class PeerDiscovery {
             return
         }
         this.config.connectionManager?.lockConnection(entryPointDescriptor, `${this.config.serviceId}::joinDht`)
-        this.config.peerManager.handleNewPeers([entryPointDescriptor])
+        this.config.peerManager.addContact([entryPointDescriptor])
         const targetId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
         const sessions = [this.createSession(targetId, contactedPeers)]
         if (additionalDistantJoin.enabled) {
@@ -162,7 +162,7 @@ export class PeerDiscovery {
         await Promise.allSettled(
             nodes.map(async (peer: DhtNodeRpcRemote) => {
                 const contacts = await peer.getClosestPeers(localNodeId)
-                this.config.peerManager.handleNewPeers(contacts)
+                this.config.peerManager.addContact(contacts)
             })
         )
     }

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

@@ -28,7 +28,6 @@ export class RecursiveOperationRpcLocal implements IRecursiveOperationRpc {
         }
         const senderId = getNodeIdFromPeerDescriptor(getPreviousPeer(routedMessage) ?? routedMessage.sourcePeer!)
         logger.trace(`Received routeRequest call from ${senderId}`)
-        this.config.addContact(routedMessage.sourcePeer!, true)
         this.config.addToDuplicateDetector(routedMessage.requestId)
         return this.config.doRouteRequest(routedMessage)
     }

package/src/dht/routing/RouterRpcLocal.ts

@@ -5,6 +5,7 @@ import { IRouterRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
 import { DuplicateDetector } from './DuplicateDetector'
 import { RoutingMode } from './RoutingSession'
 import { areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { v4 } from 'uuid'
 
 interface RouterRpcLocalConfig {
     doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => RouteMessageAck
@@ -40,7 +41,6 @@ export class RouterRpcLocal implements IRouterRpc {
             return createRouteMessageAck(routedMessage, RouteMessageError.DUPLICATE)
         }
         logger.trace(`Processing received routeMessage ${routedMessage.requestId}`)
-        this.config.addContact(routedMessage.sourcePeer!, true)
         this.config.duplicateRequestDetector.add(routedMessage.requestId)
         if (areEqualBinaries(this.config.localPeerDescriptor.nodeId, routedMessage.target)) {
             logger.trace(`routing message targeted to self ${routedMessage.requestId}`)
@@ -59,7 +59,6 @@ export class RouterRpcLocal implements IRouterRpc {
             return createRouteMessageAck(forwardMessage, RouteMessageError.DUPLICATE)
         }
         logger.trace(`Processing received forward routeMessage ${forwardMessage.requestId}`)
-        this.config.addContact(forwardMessage.sourcePeer!, true)
         this.config.duplicateRequestDetector.add(forwardMessage.requestId)
         if (areEqualBinaries(this.config.localPeerDescriptor.nodeId, forwardMessage.target)) {
             return this.forwardToDestination(forwardMessage)
@@ -75,7 +74,7 @@ export class RouterRpcLocal implements IRouterRpc {
             this.config.connectionManager?.handleMessage(forwardedMessage)
             return createRouteMessageAck(routedMessage)
         }
-        return this.config.doRouteMessage({ ...routedMessage, target: forwardedMessage.targetDescriptor!.nodeId })
+        return this.config.doRouteMessage({ ...routedMessage, requestId: v4(), target: forwardedMessage.targetDescriptor!.nodeId })
     }
 
 }

package/src/dht/routing/RoutingSession.ts

@@ -17,6 +17,7 @@ import { pull } from 'lodash'
 const logger = new Logger(module)
 
 const MAX_FAILED_HOPS = 2
+const CONTACT_LIST_MAX_SIZE = 10
 
 class RemoteContact extends Contact {
 
@@ -90,7 +91,7 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         const previousId = previousPeer ? getNodeIdFromPeerDescriptor(previousPeer) : undefined
         this.contactList = new SortedContactList({
             referenceId: getDhtAddressFromRaw(config.routedMessage.target),
-            maxSize: 10000,  // TODO use config option or named constant?
+            maxSize: CONTACT_LIST_MAX_SIZE,
             allowToContainReferenceId: true,
             nodeIdDistanceLimit: previousId,
             excludedNodeIds: config.excludedNodeIds,

package/src/dht/store/LocalDataStore.ts

@@ -57,11 +57,8 @@ export class LocalDataStore {
         }
     }
 
-    public setStale(key: DhtAddress, creator: DhtAddress, stale: boolean): void {
-        const storedEntry = this.store.get(key)?.get(creator)
-        if (storedEntry) {
-            storedEntry.stale = stale
-        }
+    public keys(): IterableIterator<DhtAddress> {
+        return this.store.keys()
     }
 
     public setAllEntriesAsStale(key: DhtAddress): void {

package/src/dht/store/StoreManager.ts

@@ -13,7 +13,6 @@ import { Timestamp } from '../../proto/google/protobuf/timestamp'
 import { SortedContactList } from '../contact/SortedContactList'
 import { Contact } from '../contact/Contact'
 import { ServiceID } from '../../types/ServiceID'
-import { findIndex } from 'lodash'
 import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../identifiers'
 import { StoreRpcLocal } from './StoreRpcLocal'
 import { getDistance } from '../PeerManager'
@@ -53,20 +52,18 @@ export class StoreManager {
             (request: ReplicateDataRequest, context: ServerCallContext) => rpcLocal.replicateData(request, context))
     }
 
-    onNewContact(peerDescriptor: PeerDescriptor): void {
-        for (const dataEntry of this.config.localDataStore.values()) {
-            this.replicateAndUpdateStaleState(dataEntry, peerDescriptor)
+    onContactAdded(peerDescriptor: PeerDescriptor): void {
+        for (const key of this.config.localDataStore.keys()) {
+            this.replicateAndUpdateStaleState(key, peerDescriptor)
         }
     }
 
-    private replicateAndUpdateStaleState(dataEntry: DataEntry, newNode: PeerDescriptor): void {
+    private replicateAndUpdateStaleState(key: DhtAddress, newNode: PeerDescriptor): void {
         const newNodeId = getNodeIdFromPeerDescriptor(newNode)
-        const key = getDhtAddressFromRaw(dataEntry.key)
-        // TODO use config option or named constant?
-        const closestToData = this.config.getClosestNeighborsTo(key, 10)
+        const closestToData = this.config.getClosestNeighborsTo(key, this.config.redundancyFactor)
         const sortedList = new SortedContactList<Contact>({
             referenceId: key, 
-            maxSize: 20,  // TODO use config option or named constant?
+            maxSize: this.config.redundancyFactor,
             allowToContainReferenceId: true,
             emitEvents: false
         })
@@ -79,18 +76,14 @@ export class StoreManager {
         const selfIsPrimaryStorer = (sortedList.getClosestContactId() === getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor))
         if (selfIsPrimaryStorer) {
             sortedList.addContact(new Contact(newNode))
-            const sorted = sortedList.getContactIds()
-            // findIndex should never return -1 here because we just added the new node to the list
-            const index = findIndex(sorted, (nodeId) => (nodeId === newNodeId))
-            // if new node is within the storageRedundancyFactor closest nodes to the data
-            // do replicate data to it
-            if (index < this.config.redundancyFactor) {
+            if (sortedList.getContact(newNodeId) !== undefined) {
                 setImmediate(async () => {
-                    await this.replicateDataToContact(dataEntry, newNode)
+                    const dataEntries = Array.from(this.config.localDataStore.values(key))
+                    await Promise.all(dataEntries.map(async (dataEntry) => this.replicateDataToContact(dataEntry, newNode)))
                 })
             }
         } else if (!this.selfIsWithinRedundancyFactor(key)) {
-            this.config.localDataStore.setStale(key, getDhtAddressFromRaw(dataEntry.creator), true)
+            this.config.localDataStore.setAllEntriesAsStale(key)
         }
     }
 

package/src/identifiers.ts

@@ -3,7 +3,7 @@ import crypto from 'crypto'
 import { PeerDescriptor } from './proto/packages/dht/protos/DhtRpc'
 
 // https://www.scs.stanford.edu/~dm/home/papers/kpos.pdf
-const KADEMLIA_ID_LENGTH_IN_BYTES = 20
+export const KADEMLIA_ID_LENGTH_IN_BYTES = 20
 
 export type DhtAddress = BrandedString<'DhtAddress'>
 export type DhtAddressRaw = Uint8Array