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

package/src/dht/DhtNodeRpcRemote.ts

@@ -41,7 +41,7 @@ export class DhtNodeRpcRemote extends RpcRemote<DhtNodeRpcClient> implements KBu
     }
 
     async getClosestPeers(nodeId: DhtAddress): Promise<PeerDescriptor[]> {
-        logger.trace(`Requesting getClosestPeers on ${this.serviceId} from ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Requesting getClosestPeers on ${this.serviceId} from ${this.getNodeId()}`)
         const request: ClosestPeersRequest = {
             nodeId: getRawFromDhtAddress(nodeId),
             requestId: v4()
@@ -56,7 +56,7 @@ export class DhtNodeRpcRemote extends RpcRemote<DhtNodeRpcClient> implements KBu
     }
 
     async ping(): Promise<boolean> {
-        logger.trace(`Requesting ping on ${this.serviceId} from ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Requesting ping on ${this.serviceId} from ${this.getNodeId()}`)
         const request: PingRequest = {
             requestId: v4()
         }
@@ -67,13 +67,13 @@ export class DhtNodeRpcRemote extends RpcRemote<DhtNodeRpcClient> implements KBu
                 return true
             }
         } catch (err) {
-            logger.trace(`ping failed on ${this.serviceId} 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.serviceId} from ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())}`)
+        logger.trace(`Sending leaveNotice on ${this.serviceId} from ${this.getNodeId()}`)
         const options = this.formDhtRpcOptions({
             notification: true
         })

package/src/dht/PeerManager.ts

@@ -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(getRawFromDhtAddress(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')
         }
@@ -129,25 +131,27 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
             return
         }
         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()
                 })
             }
@@ -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,8 +215,8 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
         if (this.stopped) {
             return
         }
-        logger.trace(`Removing contact ${getNodeIdFromPeerDescriptor(contact)}`)
         const nodeId = getNodeIdFromPeerDescriptor(contact)
+        logger.trace(`Removing contact ${nodeId}`)
         this.bucket.remove(getRawFromDhtAddress(nodeId))
         this.contacts.removeContact(nodeId)
         this.randomPeers.removeContact(nodeId)

package/src/dht/discovery/PeerDiscovery.ts

@@ -147,13 +147,14 @@ 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(getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor))
+                const contacts = await peer.getClosestPeers(localNodeId)
                 this.config.peerManager.handleNewPeers(contacts)
             })
         )

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

@@ -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)
             }
@@ -173,7 +173,7 @@ export class RecursiveOperationManager {
         // TODO use config option or named constant?
         const closestPeersToDestination = this.getClosestConnections(targetId, 5)
         const dataEntries = (request.operation === RecursiveOperation.FETCH_DATA) 
-            ? Array.from(this.config.localDataStore.getEntries(targetId).values())
+            ? Array.from(this.config.localDataStore.values(targetId))
             : []
         if (request.operation === RecursiveOperation.DELETE_DATA) {
             this.config.localDataStore.markAsDeleted(targetId, getNodeIdFromPeerDescriptor(routedMessage.sourcePeer!))

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/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

package/src/dht/store/LocalDataStore.ts

@@ -44,20 +44,19 @@ export class LocalDataStore {
         return true
     }
 
-    public* values(): IterableIterator<DataEntry> {
-        for (const v of this.store.values()) {
-            yield* v.values()
+    public* values(key?: DhtAddress): IterableIterator<DataEntry> {
+        if (key !== undefined) {
+            const map = this.store.get(key)
+            if (map !== undefined) {
+                yield* map.values()
+            }
+        } else {
+            for (const v of this.store.values()) {
+                yield* v.values()
+            }
         }
     }
 
-    public getEntries(key: DhtAddress): Map<DhtAddress, DataEntry> {
-        const dataEntries = new Map<DhtAddress, DataEntry>
-        this.store.get(key)?.forEach((value, creator) => {
-            dataEntries.set(creator, value)
-        })
-        return dataEntries
-    }
-
     public setStale(key: DhtAddress, creator: DhtAddress, stale: boolean): void {
         const storedEntry = this.store.get(key)?.get(creator)
         if (storedEntry) {

package/src/dht/store/StoreManager.ts

@@ -62,10 +62,11 @@ export class StoreManager {
 
     private replicateAndUpdateStaleState(dataEntry: DataEntry, newNode: PeerDescriptor): void {
         const newNodeId = getNodeIdFromPeerDescriptor(newNode)
+        const key = getDhtAddressFromRaw(dataEntry.key)
         // TODO use config option or named constant?
-        const closestToData = this.config.getClosestNeighborsTo(getDhtAddressFromRaw(dataEntry.key), 10)
+        const closestToData = this.config.getClosestNeighborsTo(key, 10)
         const sortedList = new SortedContactList<Contact>({
-            referenceId: getDhtAddressFromRaw(dataEntry.key), 
+            referenceId: key, 
             maxSize: 20,  // TODO use config option or named constant?
             allowToContainReferenceId: true,
             emitEvents: false
@@ -89,8 +90,8 @@ export class StoreManager {
                     await this.replicateDataToContact(dataEntry, newNode)
                 })
             }
-        } else if (!this.selfIsWithinRedundancyFactor(getDhtAddressFromRaw(dataEntry.key))) {
-            this.config.localDataStore.setStale(getDhtAddressFromRaw(dataEntry.key), getDhtAddressFromRaw(dataEntry.creator), true)
+        } else if (!this.selfIsWithinRedundancyFactor(key)) {
+            this.config.localDataStore.setStale(key, getDhtAddressFromRaw(dataEntry.creator), true)
         }
     }
 
@@ -111,11 +112,13 @@ export class StoreManager {
         const ttl = this.config.highestTtl // ToDo: make TTL decrease according to some nice curve
         const createdAt = Timestamp.now()
         for (let i = 0; i < closestNodes.length && successfulNodes.length < this.config.redundancyFactor; i++) {
+            const keyRaw = getRawFromDhtAddress(key)
+            const creatorRaw = getRawFromDhtAddress(creator)
             if (areEqualPeerDescriptors(this.config.localPeerDescriptor, closestNodes[i])) {
                 this.config.localDataStore.storeEntry({
-                    key: getRawFromDhtAddress(key),
+                    key: keyRaw,
                     data,
-                    creator: getRawFromDhtAddress(creator),
+                    creator: creatorRaw,
                     createdAt,
                     storedAt: Timestamp.now(), 
                     ttl, 
@@ -128,9 +131,9 @@ export class StoreManager {
             const rpcRemote = this.config.createRpcRemote(closestNodes[i])
             try {
                 await rpcRemote.storeData({
-                    key: getRawFromDhtAddress(key),
+                    key: keyRaw,
                     data,
-                    creator: getRawFromDhtAddress(creator),
+                    creator: creatorRaw,
                     createdAt,
                     ttl
                 })
@@ -173,10 +176,11 @@ export class StoreManager {
         // sort own contact list according to data id
         const localNodeId = getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor)
         const incomingNodeId = getNodeIdFromPeerDescriptor(incomingPeer)
+        const key = getDhtAddressFromRaw(dataEntry.key)
         // TODO use config option or named constant?
-        const closestToData = this.config.getClosestNeighborsTo(getDhtAddressFromRaw(dataEntry.key), 10)
+        const closestToData = this.config.getClosestNeighborsTo(key, 10)
         const sortedList = new SortedContactList<Contact>({
-            referenceId: getDhtAddressFromRaw(dataEntry.key), 
+            referenceId: key, 
             maxSize: this.config.redundancyFactor, 
             allowToContainReferenceId: true, 
             emitEvents: false
@@ -192,13 +196,13 @@ export class StoreManager {
             // if we are not the closest node to the data, replicate only to the closest one to the data
             : [sortedList.getAllContacts()[0]]
         targets.forEach((contact) => {
-            const contactNodeId = getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())
+            const contactNodeId = contact.getNodeId()
             if ((incomingNodeId !== contactNodeId) && (localNodeId !== contactNodeId)) {
                 setImmediate(() => {
                     executeSafePromise(async () => {
                         await this.replicateDataToContact(dataEntry, contact.getPeerDescriptor())
                         logger.trace('replicateDataToContact() returned', { 
-                            node: getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()),
+                            node: contactNodeId,
                             replicateOnlyToClosest: !selfIsPrimaryStorer
                         })
                     })

package/src/helpers/peerIdFromPeerDescriptor.ts

@@ -7,8 +7,6 @@ export const peerIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerID
     return PeerID.fromValue(peerDescriptor.nodeId)
 }
 
-// TODO could use this in trackerless-network (instead of copy-pasted same implementation)
-// and move this to nodeId.ts
 export const getNodeIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): DhtAddress => {
     return getDhtAddressFromRaw(peerDescriptor.nodeId)
 }

package/test/integration/ReplicateData.test.ts

@@ -7,11 +7,12 @@ import { execSync } from 'child_process'
 import fs from 'fs'
 import { Logger } from '@streamr/utils'
 import { PeerID } from '../../src/helpers/PeerID'
-import { getNodeIdFromPeerDescriptor, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
+import { keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { SortedContactList } from '../../src/dht/contact/SortedContactList'
 import { Contact } from '../../src/dht/contact/Contact'
 import { DhtAddress, getDhtAddressFromRaw, getRawFromDhtAddress } from '../../src/identifiers'
 import { createMockDataEntry } from '../utils/mock/mockDataEntry'
+import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
 
 const logger = new Logger(module)
 
@@ -40,6 +41,11 @@ describe('Replicate data from node to node in DHT', () => {
         return nodes[Math.floor(Math.random() * nodes.length)]
     }
     */
+
+    const getEntries = (key: DhtAddress, localDataStore: LocalDataStore) => {
+        return Array.from(localDataStore.values(key))
+    }
+
     beforeEach(async () => {
         nodes = []
         entryPoint = await createMockConnectionDhtNode(simulator,
@@ -95,7 +101,7 @@ describe('Replicate data from node to node in DHT', () => {
 
         logger.info('Nodes sorted according to distance to data are: ')
         closest.forEach((contact) => {
-            logger.info(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))
+            logger.info(contact.getNodeId())
         })
 
         logger.info('node 0 joining to the DHT')
@@ -110,17 +116,17 @@ describe('Replicate data from node to node in DHT', () => {
         logger.info('Nodes sorted according to distance to data with storing nodes marked are: ')
 
         closest.forEach((contact) => {
-            const node = nodesById.get(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))!
+            const node = nodesById.get(contact.getNodeId())!
             let hasDataMarker = ''
             
             // @ts-expect-error private field
             const store = node.localDataStore
-            if (store.getEntries(dataKey)) {
+            if (getEntries(dataKey, store).length > 0) {
                 hasDataMarker = '<-'
             }
 
             // eslint-disable-next-line max-len
-            logger.info(peerIdFromPeerDescriptor(contact.getPeerDescriptor()) + ' ' + getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + hasDataMarker)
+            logger.info(peerIdFromPeerDescriptor(contact.getPeerDescriptor()) + ' ' + node.getNodeId() + hasDataMarker)
         })
 
         logger.info(NUM_NODES + ' nodes joining layer0 DHT')
@@ -139,23 +145,23 @@ describe('Replicate data from node to node in DHT', () => {
         logger.info('After join of 99 nodes: nodes sorted according to distance to data with storing nodes marked are: ')
 
         closest.forEach((contact) => {
-            const node = nodesById.get(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))!
+            const node = nodesById.get(contact.getNodeId())!
             let hasDataMarker = ''
 
             // @ts-expect-error private field
             const store = node.localDataStore
-            if (store.getEntries(dataKey)) {
+            if (getEntries(dataKey, store).length > 0) {
                 hasDataMarker = '<-'
             }
 
-            logger.info(getNodeIdFromPeerDescriptor(node.getLocalPeerDescriptor()) + hasDataMarker)
+            logger.info(node.getNodeId() + hasDataMarker)
         })
 
-        const closestNode = nodesById.get(getNodeIdFromPeerDescriptor(closest[0].getPeerDescriptor()))!
+        const closestNode = nodesById.get(closest[0].getNodeId())!
 
         // @ts-expect-error private field
         const store = closestNode.localDataStore
-        expect(store.getEntries(dataKey).size).toBeGreaterThanOrEqual(1)
+        expect(getEntries(dataKey, store).length).toBeGreaterThanOrEqual(1)
     }, 180000)
 
     it('Data replicates to the last remaining node if all other nodes leave gracefully', async () => {
@@ -193,7 +199,7 @@ describe('Replicate data from node to node in DHT', () => {
             // @ts-expect-error private field
             const store = nodes[nodeIndex].localDataStore
             logger.info('Stopping node ' + nodeIndex + ' ' +
-                (store.getEntries(dataKey) ? ', has data' : ' does not have data'))
+                ((getEntries(dataKey, store).length > 0) ? ', has data' : ' does not have data'))
 
             await nodes[nodeIndex].stop()
         }
@@ -202,8 +208,8 @@ describe('Replicate data from node to node in DHT', () => {
 
         // @ts-expect-error private field
         const firstStore = nodes[randomIndices[0]].localDataStore
-        logger.info('data of ' + randomIndices[0] + ' was ' + firstStore.getEntries(dataKey))
-        expect(firstStore.getEntries(dataKey).size).toBeGreaterThanOrEqual(1)
+        logger.info('data of ' + randomIndices[0] + ' was ' + getEntries(dataKey, firstStore))
+        expect(getEntries(dataKey, firstStore).length).toBeGreaterThanOrEqual(1)
 
     }, 180000)
 })

package/test/unit/LocalDataStore.test.ts

@@ -4,17 +4,13 @@ import {
     getNodeIdFromPeerDescriptor,
 } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { createMockPeerDescriptor } from '../utils/utils'
-import { createMockDataEntry, expectEqualData } from '../utils/mock/mockDataEntry'
-import { DhtAddress, createRandomDhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
+import { createMockDataEntry } from '../utils/mock/mockDataEntry'
+import { createRandomDhtAddress, getDhtAddressFromRaw } from '../../src/identifiers'
 
 describe('LocalDataStore', () => {
 
     let localDataStore: LocalDataStore
 
-    const getEntryArray = (key: DhtAddress) => {
-        return Array.from(localDataStore.getEntries(key).values())
-    }
-    
     beforeEach(() => {
         localDataStore = new LocalDataStore(30 * 1000)
     })
@@ -26,9 +22,8 @@ describe('LocalDataStore', () => {
     it('can store', () => {
         const storedEntry = createMockDataEntry()
         localDataStore.storeEntry(storedEntry)
-        const fetchedEntries = getEntryArray(getDhtAddressFromRaw(storedEntry.key))
-        expect(fetchedEntries).toHaveLength(1)
-        expectEqualData(fetchedEntries[0], storedEntry)
+        const fetchedEntries = Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))
+        expect(fetchedEntries).toIncludeSameMembers([storedEntry])
     })
 
     it('multiple storers behind one key', () => {
@@ -39,10 +34,8 @@ describe('LocalDataStore', () => {
         const storedEntry2 = createMockDataEntry({ key, creator: creator2 })
         localDataStore.storeEntry(storedEntry1)
         localDataStore.storeEntry(storedEntry2)
-        const fetchedEntries = localDataStore.getEntries(key)
-        expect(fetchedEntries.size).toBe(2)
-        expectEqualData(fetchedEntries.get(creator1)!, storedEntry1)
-        expectEqualData(fetchedEntries.get(creator2)!, storedEntry2)
+        const fetchedEntries = Array.from(localDataStore.values(key))
+        expect(fetchedEntries).toIncludeSameMembers([storedEntry1, storedEntry2])
     })
 
     it('can remove data entries', () => {
@@ -54,9 +47,8 @@ describe('LocalDataStore', () => {
         localDataStore.storeEntry(storedEntry1)
         localDataStore.storeEntry(storedEntry2)
         localDataStore.deleteEntry(key, creator1)
-        const fetchedEntries = getEntryArray(key)
-        expect(fetchedEntries).toHaveLength(1)
-        expectEqualData(fetchedEntries[0], storedEntry2)
+        const fetchedEntries = Array.from(localDataStore.values(key))
+        expect(fetchedEntries).toIncludeSameMembers([storedEntry2])
     })
 
     it('can remove all data entries', () => {
@@ -69,15 +61,15 @@ describe('LocalDataStore', () => {
         localDataStore.storeEntry(storedEntry2)
         localDataStore.deleteEntry(key, creator1)
         localDataStore.deleteEntry(key, creator2)
-        expect(getEntryArray(key)).toHaveLength(0)
+        expect(Array.from(localDataStore.values(key))).toHaveLength(0)
     })
 
     it('data is deleted after TTL', async () => {
         const storedEntry = createMockDataEntry({ ttl: 1000 })
         localDataStore.storeEntry(storedEntry)
-        expect(getEntryArray(getDhtAddressFromRaw(storedEntry.key))).toHaveLength(1)
+        expect(Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))).toHaveLength(1)
         await wait(1100)
-        expect(getEntryArray(getDhtAddressFromRaw(storedEntry.key))).toHaveLength(0)
+        expect(Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))).toHaveLength(0)
     })
 
     describe('mark data as deleted', () => {
@@ -86,15 +78,15 @@ describe('LocalDataStore', () => {
             const creator1 = createRandomDhtAddress()
             const storedEntry = createMockDataEntry({ creator: creator1 })
             localDataStore.storeEntry(storedEntry)
-            const notDeletedData = localDataStore.getEntries(getDhtAddressFromRaw(storedEntry.key))
-            expect(notDeletedData.get(creator1)!.deleted).toBeFalse()
+            const notDeletedData = Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))
+            expect(notDeletedData[0]!.deleted).toBeFalse()
             const returnValue = localDataStore.markAsDeleted(
                 getDhtAddressFromRaw(storedEntry.key),
                 creator1
             )
             expect(returnValue).toBe(true)
-            const deletedData = localDataStore.getEntries(getDhtAddressFromRaw(storedEntry.key))
-            expect(deletedData.get(creator1)!.deleted).toBeTrue()
+            const deletedData = Array.from(localDataStore.values(getDhtAddressFromRaw(storedEntry.key)))
+            expect(deletedData[0]!.deleted).toBeTrue()
         })
 
         it('data not stored', () => {