@streamr/dht 100.0.0-testnet-three.2 → 100.0.0-testnet-three.4

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,37 +40,33 @@ 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())
+                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(
-                        'newContact',
+                        'contactAdded',
                         contact,
                         this.getClosestContacts()
                     )
                 }
-            } else if (this.compareIds(this.contactIds[this.config.maxSize - 1], contact.getNodeId()) > 0) {
+            } 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(
@@ -79,7 +75,7 @@ export class SortedContactList<C extends { getNodeId: () => DhtAddress }> extend
                         closestContacts
                     )
                     this.emit(
-                        'newContact',
+                        'contactAdded',
                         contact,
                         closestContacts
                     )

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/test/end-to-end/Layer0Webrtc-Layer1.test.ts

@@ -28,22 +28,26 @@ describe('Layer 1 on Layer 0 with mocked connections', () => {
 
         const layer0Node1Id = createRandomDhtAddress()
         layer0Node1 = new DhtNode({
-            nodeId: layer0Node1Id
+            nodeId: layer0Node1Id,
+            entryPoints: [entrypointDescriptor]
         })
 
         const layer0Node2Id = createRandomDhtAddress()
         layer0Node2 = new DhtNode({
-            nodeId: layer0Node2Id
+            nodeId: layer0Node2Id,
+            entryPoints: [entrypointDescriptor]
         })
 
         const layer0Node3Id = createRandomDhtAddress()
         layer0Node3 = new DhtNode({
-            nodeId: layer0Node3Id
+            nodeId: layer0Node3Id,
+            entryPoints: [entrypointDescriptor]
         })
 
         const layer0Node4Id = createRandomDhtAddress()
         layer0Node4 = new DhtNode({
-            nodeId: layer0Node4Id
+            nodeId: layer0Node4Id,
+            entryPoints: [entrypointDescriptor]
         })
 
         layer1EntryPoint = new DhtNode({

package/test/end-to-end/Layer0Webrtc.test.ts

@@ -39,8 +39,6 @@ describe('Layer0 with WebRTC connections', () => {
             node3.start(),
             node4.start()
         ])
-
-        await epDhtNode.joinDht([epPeerDescriptor])
     })
 
     afterEach(async () => {

package/test/end-to-end/memory-leak.test.ts

@@ -30,8 +30,8 @@ describe('memory leak', () => {
         })
         await entryPoint.start()
         await entryPoint.joinDht([entryPointDescriptor])
-        let sender: DhtNode | undefined = new DhtNode({})
-        let receiver: DhtNode | undefined = new DhtNode({})
+        let sender: DhtNode | undefined = new DhtNode({ entryPoints: [entryPointDescriptor] })
+        let receiver: DhtNode | undefined = new DhtNode({ entryPoints: [entryPointDescriptor] })
         await Promise.all([
             (async () => {
                 await sender.start()
@@ -77,5 +77,5 @@ describe('memory leak', () => {
         const detector3 = new LeakDetector(receiver)
         receiver = undefined
         expect(await detector3.isLeaking()).toBe(false)
-    })
+    }, 10000)
 })

package/test/unit/PeerManager.test.ts

@@ -15,7 +15,7 @@ describe('PeerManager', () => {
                 return new DhtNodeRpcRemote(undefined as any, peerDescriptor, undefined as any, new MockRpcCommunicator())
             }
         } as any)
-        manager.handleNewPeers(nodeIds.map((n) => ({ nodeId: getRawFromDhtAddress(n), type: NodeType.NODEJS })))
+        manager.addContact(nodeIds.map((n) => ({ nodeId: getRawFromDhtAddress(n), type: NodeType.NODEJS })))
 
         const referenceId = createRandomDhtAddress()
         const excluded = new Set<DhtAddress>(sampleSize(nodeIds, 2)!)

package/test/unit/SortedContactList.test.ts

@@ -119,15 +119,15 @@ describe('SortedContactList', () => {
         expect(list.getActiveContacts()).toEqual([item2, item3, item4])
     })
 
-    it('does not emit newContact if contact did not fit the structure', () => {
+    it('does not emit contactAdded if contact did not fit the structure', () => {
         const list = new SortedContactList({ referenceId: item0.getNodeId(), maxSize: 2, allowToContainReferenceId: false, emitEvents: true })
-        const onNewContact = jest.fn()
-        list.on('newContact', onNewContact)
+        const onContactAdded = jest.fn()
+        list.on('contactAdded', onContactAdded)
         list.addContact(item1)
         list.addContact(item2)
-        expect(onNewContact).toBeCalledTimes(2)
+        expect(onContactAdded).toBeCalledTimes(2)
         list.addContact(item3)
-        expect(onNewContact).toBeCalledTimes(2)
+        expect(onContactAdded).toBeCalledTimes(2)
         expect(list.getAllContacts().length).toEqual(2)
     })
 

package/test/unit/StoreManager.test.ts

@@ -27,7 +27,7 @@ describe('StoreManager', () => {
             localNodeId: DhtAddress,
             closestNeighbors: DhtAddress[],
             replicateData: (request: ReplicateDataRequest) => unknown,
-            setStale: (key: DhtAddress, creator: DhtAddress, stale: boolean) => unknown
+            setAllEntriesAsStale: (key: DhtAddress) => unknown
         ): StoreManager => {
             const getClosestNeighborsTo = () => {
                 return closestNeighbors.map((nodeId) => ({ nodeId: getRawFromDhtAddress(nodeId), type: NodeType.NODEJS }))
@@ -39,7 +39,11 @@ describe('StoreManager', () => {
                 } as any,
                 recursiveOperationManager: undefined as any,
                 localPeerDescriptor: { nodeId: getRawFromDhtAddress(localNodeId), type: NodeType.NODEJS },
-                localDataStore: { values: () => [DATA_ENTRY], setStale } as any,
+                localDataStore: { 
+                    keys: () => [getDhtAddressFromRaw(DATA_ENTRY.key)],
+                    values: () => [DATA_ENTRY],
+                    setAllEntriesAsStale 
+                } as any,
                 serviceId: undefined as any,
                 highestTtl: undefined as any,
                 redundancyFactor: 3,
@@ -52,34 +56,34 @@ describe('StoreManager', () => {
 
             it('new node is within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[0],
                     [NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[3], NODES_CLOSEST_TO_DATA[4]],
                     replicateData,
-                    setStale
+                    setAllEntriesAsStale
                 )
-                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[2]), type: NodeType.NODEJS })
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[2]), type: NodeType.NODEJS })
                 await waitForCondition(() => replicateData.mock.calls.length === 1)
                 expect(replicateData).toHaveBeenCalledWith({
                     entry: DATA_ENTRY
                 })
-                expect(setStale).not.toHaveBeenCalled()
+                expect(setAllEntriesAsStale).not.toHaveBeenCalled()
             })
     
             it('new node is not within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[0],
                     [NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[2], NODES_CLOSEST_TO_DATA[3]],
                     replicateData,
-                    setStale
+                    setAllEntriesAsStale
                 )
-                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
-                expect(setStale).not.toHaveBeenCalled()
+                expect(setAllEntriesAsStale).not.toHaveBeenCalled()
             })
         })
 
@@ -87,48 +91,47 @@ describe('StoreManager', () => {
 
             it('this node is within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[1],
                     [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[2], NODES_CLOSEST_TO_DATA[3]],
                     replicateData,
-                    setStale
+                    setAllEntriesAsStale
                 )
-                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
-                expect(setStale).not.toHaveBeenCalled()
             })
 
             it('this node is not within redundancy factor', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[3],
                     [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[1], NODES_CLOSEST_TO_DATA[2]],
                     replicateData,
-                    setStale
+                    setAllEntriesAsStale
                 )
-                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
-                expect(setStale).toHaveBeenCalledTimes(1)
-                expect(setStale).toHaveBeenCalledWith(getDhtAddressFromRaw(DATA_ENTRY.key), getDhtAddressFromRaw(DATA_ENTRY.creator), true)
+                expect(setAllEntriesAsStale).toHaveBeenCalledTimes(1)
+                expect(setAllEntriesAsStale).toHaveBeenCalledWith(getDhtAddressFromRaw(DATA_ENTRY.key))
             })
 
             it('this node has less than redundancyFactor neighbors', async () => {
                 const replicateData = jest.fn<undefined, [ReplicateDataRequest]>()
-                const setStale = jest.fn<undefined, [DhtAddress, DhtAddress]>()
+                const setAllEntriesAsStale = jest.fn<undefined, [DhtAddress]>()
                 const manager = createStoreManager(
                     NODES_CLOSEST_TO_DATA[3],
                     [NODES_CLOSEST_TO_DATA[0], NODES_CLOSEST_TO_DATA[1]],
                     replicateData,
-                    setStale
+                    setAllEntriesAsStale
                 )
-                manager.onNewContact({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
+                manager.onContactAdded({ nodeId: getRawFromDhtAddress(NODES_CLOSEST_TO_DATA[4]), type: NodeType.NODEJS })
                 await wait(50)
                 expect(replicateData).not.toHaveBeenCalled()
-                expect(setStale).toHaveBeenCalledTimes(0)
+                expect(setAllEntriesAsStale).toHaveBeenCalledTimes(0)
             })
         })
     })