@streamr/dht 100.0.0-pretestnet.4 → 100.0.0-rc.0

package/src/dht/routing/RoutingSession.ts

@@ -1,43 +1,44 @@
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { SortedContactList } from '../contact/SortedContactList'
-import { PeerID, PeerIDKey } from '../../helpers/PeerID'
-import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { v4 } from 'uuid'
 import { PeerDescriptor, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 import { RouterRpcRemote } from './RouterRpcRemote'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { FindRpcClient, RouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { RecursiveOperationRpcClient, RouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { Contact } from '../contact/Contact'
-import { FindRpcRemote } from './FindRpcRemote'
-import { EXISTING_CONNECTION_TIMEOUT } from '../contact/Remote'
+import { RecursiveOperationRpcRemote } from '../recursive-operation/RecursiveOperationRpcRemote'
+import { EXISTING_CONNECTION_TIMEOUT } from '../contact/RpcRemote'
 import { getPreviousPeer } from './getPreviousPeer'
+import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { pull } from 'lodash'
+import { RoutingTable, RoutingTablesCache } from './RoutingTablesCache'
 
 const logger = new Logger(module)
 
 const MAX_FAILED_HOPS = 2
+const ROUTING_TABLE_MAX_SIZE = 20
 
-class RemoteContact extends Contact {
+export class RoutingRemoteContact extends Contact {
 
     private routerRpcRemote: RouterRpcRemote
-    private findRpcRemote: FindRpcRemote
+    private recursiveOperationRpcRemote: RecursiveOperationRpcRemote
 
-    constructor(peer: DhtNodeRpcRemote, localPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
-        super(peer.getPeerDescriptor())
+    constructor(peer: PeerDescriptor, localPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
+        super(peer)
         this.routerRpcRemote = new RouterRpcRemote(
             localPeerDescriptor,
-            peer.getPeerDescriptor(),
-            peer.getServiceId(),
-            toProtoRpcClient(new RouterRpcClient(rpcCommunicator.getRpcClientTransport())),
+            peer,
+            rpcCommunicator,
+            RouterRpcClient,
             EXISTING_CONNECTION_TIMEOUT
         )
-        this.findRpcRemote = new FindRpcRemote(
+        this.recursiveOperationRpcRemote = new RecursiveOperationRpcRemote(
             localPeerDescriptor,
-            peer.getPeerDescriptor(),
-            peer.getServiceId(),
-            toProtoRpcClient(new FindRpcClient(rpcCommunicator.getRpcClientTransport())),
+            peer,
+            rpcCommunicator,
+            RecursiveOperationRpcClient,
             EXISTING_CONNECTION_TIMEOUT
         )
     }
@@ -46,84 +47,70 @@ class RemoteContact extends Contact {
         return this.routerRpcRemote
     }
 
-    getFindRpcRemote(): FindRpcRemote {
-        return this.findRpcRemote
+    getRecursiveOperationRpcRemote(): RecursiveOperationRpcRemote {
+        return this.recursiveOperationRpcRemote
     }
 }
 
 export interface RoutingSessionEvents {
     // This event is emitted when a peer responds with a success ack
     // to routeMessage call
-    routingSucceeded: (sessionId: string) => void
-    partialSuccess: (sessionId: string) => void
-
+    routingSucceeded: () => void
+    partialSuccess: () => void
     // This event is emitted when all the candidates have been gone
     // through, and none of them responds with a success ack
-    routingFailed: (sessionId: string) => void
-    stopped: (sessionId: string) => void
+    routingFailed: () => void
+    stopped: () => void
 }
 
-export enum RoutingMode { ROUTE, FORWARD, FIND }
+export enum RoutingMode { ROUTE, FORWARD, RECURSIVE }
+
+interface RoutingSessionConfig {
+    rpcCommunicator: RoutingRpcCommunicator
+    localPeerDescriptor: PeerDescriptor
+    routedMessage: RouteMessageWrapper
+    connections: Map<DhtAddress, DhtNodeRpcRemote>
+    parallelism: number
+    mode: RoutingMode
+    excludedNodeIds: Set<DhtAddress>
+    routingTablesCache: RoutingTablesCache
+}
 
 export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
 
     public readonly sessionId = v4()
-    private readonly rpcCommunicator: RoutingRpcCommunicator
-    private ongoingRequests: Set<PeerIDKey> = new Set()
-    private contactList: SortedContactList<RemoteContact>
-    private readonly localPeerDescriptor: PeerDescriptor
-    private readonly messageToRoute: RouteMessageWrapper
-    private connections: Map<PeerIDKey, DhtNodeRpcRemote>
-    private readonly parallelism: number
+    private ongoingRequests: Set<DhtAddress> = new Set()
+    private contactedPeers: Set<DhtAddress> = new Set()
     private failedHopCounter = 0
     private successfulHopCounter = 0
-    private readonly mode: RoutingMode = RoutingMode.ROUTE
     private stopped = false
+    private readonly config: RoutingSessionConfig
 
-    constructor(
-        rpcCommunicator: RoutingRpcCommunicator,
-        localPeerDescriptor: PeerDescriptor,
-        messageToRoute: RouteMessageWrapper,
-        connections: Map<PeerIDKey, DhtNodeRpcRemote>,
-        parallelism: number,
-        mode: RoutingMode = RoutingMode.ROUTE,
-        excludedPeerIDs?: PeerID[]
-    ) {
+    constructor(config: RoutingSessionConfig) {
         super()
-        this.rpcCommunicator = rpcCommunicator
-        this.localPeerDescriptor = localPeerDescriptor
-        this.messageToRoute = messageToRoute
-        this.connections = connections
-        this.parallelism = parallelism
-        this.mode = mode
-        const previousPeer = getPreviousPeer(messageToRoute)
-        const previousId = previousPeer ? PeerID.fromValue(previousPeer.kademliaId) : undefined
-        this.contactList = new SortedContactList(
-            PeerID.fromValue(this.messageToRoute.destinationPeer!.kademliaId),
-            10000,
-            undefined,
-            true,
-            previousId,
-            excludedPeerIDs
-        )
+        this.config = config
     }
 
-    private onRequestFailed(peerId: PeerID) {
+    private onRequestFailed(nodeId: DhtAddress) {
         logger.trace('onRequestFailed() sessionId: ' + this.sessionId)
         if (this.stopped) {
             return
         }
-        if (this.ongoingRequests.has(peerId.toKey())) {
-            this.ongoingRequests.delete(peerId.toKey())
+        if (this.ongoingRequests.has(nodeId)) {
+            this.ongoingRequests.delete(nodeId)
+        }
+        this.deleteParallelRootIfSource(nodeId)
+        this.failedHopCounter += 1
+        if (this.failedHopCounter >= MAX_FAILED_HOPS) {
+            logger.trace(`Stopping routing after ${MAX_FAILED_HOPS} failed attempts for sessionId: ${this.sessionId}`)
+            this.emitFailure()
+            return
         }
-        const contacts = this.findMoreContacts()
+        const contacts = this.updateAndGetRoutablePeers()
         if (contacts.length === 0 && this.ongoingRequests.size === 0) {
             logger.trace('routing failed, emitting routingFailed sessionId: ' + this.sessionId)
-            // TODO should call this.stop() so that we do cleanup? (after the emitFailure call)
-            this.stopped = true
             this.emitFailure()
         } else {
-            this.failedHopCounter += 1
             logger.trace('routing failed, retrying to route sessionId: ' + this.sessionId + ' failedHopCounter: ' + this.failedHopCounter)
             this.sendMoreRequests(contacts)
         }
@@ -131,9 +118,9 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
 
     private emitFailure() {
         if (this.successfulHopCounter >= 1) {
-            this.emit('partialSuccess', this.sessionId)
+            this.emit('partialSuccess')
         } else {
-            this.emit('routingFailed', this.sessionId)
+            this.emit('routingFailed')
         }
     }
 
@@ -143,44 +130,65 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             return
         }
         this.successfulHopCounter += 1
-        const contacts = this.findMoreContacts()
-        if (this.successfulHopCounter >= this.parallelism || contacts.length === 0) {
-            // TODO should call this.stop() so that we do cleanup? (after the routingSucceeded call)
-            this.stopped = true
-            this.emit('routingSucceeded', this.sessionId)
+        if (this.successfulHopCounter >= this.config.parallelism) {
+            this.emit('routingSucceeded')
+            return
+        }
+        const contacts = this.updateAndGetRoutablePeers()
+        if (contacts.length === 0) {
+            this.emit('routingSucceeded')
         } else if (contacts.length > 0 && this.ongoingRequests.size === 0) {
             this.sendMoreRequests(contacts)
         }
     }
 
-    private async sendRouteMessageRequest(contact: RemoteContact): Promise<boolean> {
+    private async sendRouteMessageRequest(contact: RoutingRemoteContact): Promise<boolean> {
         if (this.stopped) {
             return false
         }
         const msg = {
-            ...this.messageToRoute,
-            routingPath: this.messageToRoute.routingPath.concat([this.localPeerDescriptor])
+            ...this.config.routedMessage,
+            routingPath: this.config.routedMessage.routingPath.concat([this.config.localPeerDescriptor])
         }
-        if (this.mode === RoutingMode.FORWARD) {
+        if (this.config.mode === RoutingMode.FORWARD) {
             return contact.getRouterRpcRemote().forwardMessage(msg)
-        } else if (this.mode === RoutingMode.FIND) {
-            return contact.getFindRpcRemote().routeFindRequest(msg)
+        } else if (this.config.mode === RoutingMode.RECURSIVE) {
+            return contact.getRecursiveOperationRpcRemote().routeRequest(msg)
         } else {
             return contact.getRouterRpcRemote().routeMessage(msg)
         }
     }
 
-    findMoreContacts(): RemoteContact[] {
-        logger.trace('findMoreContacts() sessionId: ' + this.sessionId)
-        // the contents of the connections might have changed between the rounds
-        // addContacts() will only add new contacts that were not there yet
-        const contacts = Array.from(this.connections.values())
-            .map((peer) => new RemoteContact(peer, this.localPeerDescriptor, this.rpcCommunicator))
-        this.contactList.addContacts(contacts)
-        return this.contactList.getUncontactedContacts(this.parallelism)
+    updateAndGetRoutablePeers(): RoutingRemoteContact[] {
+        logger.trace('getRoutablePeers() sessionId: ' + this.sessionId)
+        const previousPeer = getPreviousPeer(this.config.routedMessage)
+        const previousId = previousPeer ? getNodeIdFromPeerDescriptor(previousPeer) : undefined
+        const targetId = getDhtAddressFromRaw(this.config.routedMessage.target)
+        let routingTable: RoutingTable
+        if (this.config.routingTablesCache.has(targetId, previousId)) {
+            routingTable = this.config.routingTablesCache.get(targetId, previousId)!
+        } else {
+            routingTable = new SortedContactList<RoutingRemoteContact>({
+                referenceId: getDhtAddressFromRaw(this.config.routedMessage.target),
+                maxSize: ROUTING_TABLE_MAX_SIZE,
+                allowToContainReferenceId: true,
+                nodeIdDistanceLimit: previousId,
+                emitEvents: false
+            })
+            const contacts = Array.from(this.config.connections.values())
+                .map((peer) => new RoutingRemoteContact(
+                    peer.getPeerDescriptor(),
+                    this.config.localPeerDescriptor,
+                    this.config.rpcCommunicator
+                ))
+            routingTable.addContacts(contacts)
+            this.config.routingTablesCache.set(targetId, routingTable, previousId)
+        }
+        return routingTable.getAllContacts()
+            .filter((contact) => !this.contactedPeers.has(contact.getNodeId()) && !this.config.excludedNodeIds.has(contact.getNodeId()))
     }
 
-    sendMoreRequests(uncontacted: RemoteContact[]): void {
+    sendMoreRequests(uncontacted: RoutingRemoteContact[]): void {
         logger.trace('sendMoreRequests() sessionId: ' + this.sessionId)
         if (this.stopped) {
             return
@@ -189,24 +197,20 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
             this.emitFailure()
             return
         }
-        if (this.failedHopCounter >= MAX_FAILED_HOPS) {
-            logger.trace(`Stopping routing after ${MAX_FAILED_HOPS} failed attempts for sessionId: ${this.sessionId}`)
-            this.emitFailure()
-            return
-        }
-        while ((this.ongoingRequests.size < this.parallelism) && (uncontacted.length > 0) && !this.stopped) {
+        while ((this.ongoingRequests.size < this.config.parallelism) && (uncontacted.length > 0) && !this.stopped) {
             const nextPeer = uncontacted.shift()
             // eslint-disable-next-line max-len
             logger.trace(`Sending routeMessage request to contact: ${getNodeIdFromPeerDescriptor(nextPeer!.getPeerDescriptor())} (sessionId=${this.sessionId})`)
-            this.contactList.setContacted(nextPeer!.getPeerId())
-            this.ongoingRequests.add(nextPeer!.getPeerId().toKey())
+            this.contactedPeers.add(nextPeer!.getNodeId())
+            this.ongoingRequests.add(nextPeer!.getNodeId())
+            this.addParallelRootIfSource(nextPeer!.getNodeId())
             setImmediate(async () => {
                 try {
                     const succeeded = await this.sendRouteMessageRequest(nextPeer!)
                     if (succeeded) {
                         this.onRequestSucceeded()
                     } else {
-                        this.onRequestFailed(nextPeer!.getPeerId())
+                        this.onRequestFailed(nextPeer!.getNodeId())
                     }
                 } catch (e) {
                     logger.debug('Unable to route message ', { error: e })
@@ -217,10 +221,27 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
         }
     }
 
+    private addParallelRootIfSource(nodeId: DhtAddress) {
+        if (
+            this.config.mode === RoutingMode.RECURSIVE
+            && areEqualPeerDescriptors(this.config.localPeerDescriptor, this.config.routedMessage.sourcePeer!)
+        ) {
+            this.config.routedMessage.parallelRootNodeIds.push(nodeId)
+        }
+    }
+
+    private deleteParallelRootIfSource(nodeId: DhtAddress) {
+        if (
+            this.config.mode === RoutingMode.RECURSIVE
+            && areEqualPeerDescriptors(this.config.localPeerDescriptor, this.config.routedMessage.sourcePeer!)
+        ) {
+            pull(this.config.routedMessage.parallelRootNodeIds, nodeId)
+        }
+    }
+
     public stop(): void {
         this.stopped = true
-        this.contactList.stop()
-        this.emit('stopped', this.sessionId)
+        this.emit('stopped')
         this.removeAllListeners()
     }
 }

package/src/dht/routing/RoutingTablesCache.ts

@@ -0,0 +1,58 @@
+import { DhtAddress } from '../../identifiers'
+import { SortedContactList } from '../contact/SortedContactList'
+import { RoutingRemoteContact } from './RoutingSession'
+import { LRUCache } from 'lru-cache'
+
+type RoutingTableID = string
+export type RoutingTable = Pick<SortedContactList<RoutingRemoteContact>, 'getAllContacts' | 'addContacts' | 'addContact' | 'removeContact' | 'stop'>
+
+const createRoutingTableId = (targetId: DhtAddress, previousId?: DhtAddress): RoutingTableID => {
+    return targetId + (previousId ? previousId : '')
+}
+
+const DEFAULT_LRU_OPTIONS = {
+    max: 1000,
+    maxAge: 15 * 1000
+}
+
+/**
+ * RoutingTablesCache is a cache for routing tables. 
+ * It is used to store the routing tables for a specific targetId and previousId.
+ * Storing the previousId is important as it is used as a minimum distance for the contacts in the table.
+ * Calculating a RoutingTable from scratch is an O(n log n) operation (n = number of connections of a node)
+ * However,
+ * - Adding a contact to a RoutingTable is an O(log n) operation.
+ * - Deleting a contact from a RoutingTable is an O(1) operation.
+ * Thus, holding the most frequently used routing tables in memory to be updated on 
+ * connections and disconnections is hugely beneficial in terms of performance.
+*/
+
+export class RoutingTablesCache {
+
+    private readonly tables: LRUCache<RoutingTableID, RoutingTable> = new LRUCache(DEFAULT_LRU_OPTIONS)
+
+    get(targetId: DhtAddress, previousId?: DhtAddress): RoutingTable | undefined {
+        return this.tables.get(createRoutingTableId(targetId, previousId))
+    }
+
+    set(targetId: DhtAddress, table: RoutingTable, previousId?: DhtAddress): void {
+        this.tables.set(createRoutingTableId(targetId, previousId), table)
+    }
+
+    has(targetId: DhtAddress, previousId?: DhtAddress): boolean {
+        return this.tables.has(createRoutingTableId(targetId, previousId))
+    }
+
+    onNodeDisconnected(nodeId: DhtAddress): void {
+        this.tables.forEach((table) => table.removeContact(nodeId))
+    }
+
+    onNodeConnected(remote: RoutingRemoteContact): void {
+        this.tables.forEach((table) => table.addContact(remote))
+    }
+
+    reset(): void {
+        this.tables.forEach((table) => table.stop())
+        this.tables.clear()
+    }
+}

package/src/dht/routing/getPreviousPeer.ts

@@ -2,5 +2,5 @@ import { last } from 'lodash'
 import { PeerDescriptor, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
 
 export const getPreviousPeer = (routeMessage: RouteMessageWrapper): PeerDescriptor | undefined => {
-    return last(routeMessage.routingPath!)
+    return last(routeMessage.routingPath)
 }

package/src/dht/store/LocalDataStore.ts

@@ -1,114 +1,84 @@
-import { PeerID, PeerIDKey } from '../../helpers/PeerID'
-import { DataEntry, PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { DataEntry } from '../../proto/packages/dht/protos/DhtRpc'
+import { MapWithTtl } from '../../helpers/MapWithTtl'
+import { DhtAddress, getDhtAddressFromRaw } from '../../identifiers'
 
-const MIN_TTL = 1 * 1000
-const MAX_TTL = 300 * 1000
+export class LocalDataStore {
 
-const createTtlValue = (ttl: number): number => {
-    if (ttl < MIN_TTL) {
-        return MIN_TTL
-    } else if (ttl > MAX_TTL) {
-        return MAX_TTL
-    } else {
-        return ttl
-    }
-}
+    private readonly maxTtl: number
 
-interface LocalDataEntry {
-    dataEntry: DataEntry
-    ttlTimeout: NodeJS.Timeout
-}
+    constructor(maxTtl: number) {
+        this.maxTtl = maxTtl
+    }
 
-export class LocalDataStore {
     // A map into which each node can store one value per data key
     // The first key is the key of the data, the second key is the
-    // PeerID of the storer of the data
-    private store: Map<PeerIDKey, Map<PeerIDKey, LocalDataEntry>> = new Map()
+    // DhtAddress of the creator of the data
+    private store: Map<DhtAddress, MapWithTtl<DhtAddress, DataEntry>> = new Map()
 
     public storeEntry(dataEntry: DataEntry): boolean {
-        const publisherKey = PeerID.fromValue(dataEntry.storer!.kademliaId).toKey()
-        const dataKey = PeerID.fromValue(dataEntry.kademliaId).toKey()
-        
-        if (!this.store.has(dataKey)) {
-            this.store.set(dataKey, new Map())
+        const key = getDhtAddressFromRaw(dataEntry.key)
+        const creatorNodeId = getDhtAddressFromRaw(dataEntry.creator)
+        if (!this.store.has(key)) {
+            this.store.set(key, new MapWithTtl((e) => Math.min(e.ttl, this.maxTtl)))
         }
-
-        if (this.store.get(dataKey)!.has(publisherKey)) {
-            const storedMillis = (dataEntry.storerTime!.seconds * 1000) + (dataEntry.storerTime!.nanos / 1000000)
-            const oldLocalEntry = this.store.get(dataKey)!.get(publisherKey)!
-            const oldStoredMillis = (oldLocalEntry.dataEntry.storerTime!.seconds * 1000) + (oldLocalEntry.dataEntry.storerTime!.nanos / 1000000)
-        
-            // do nothing if old entry is newer than the one being migrated
+        if (this.store.get(key)!.has(creatorNodeId)) {
+            const storedMillis = (dataEntry.createdAt!.seconds * 1000) + (dataEntry.createdAt!.nanos / 1000000)
+            const oldLocalEntry = this.store.get(key)!.get(creatorNodeId)!
+            const oldStoredMillis = (oldLocalEntry.createdAt!.seconds * 1000) + (oldLocalEntry.createdAt!.nanos / 1000000)
+            // do nothing if old entry is newer than the one being replicated
             if (oldStoredMillis >= storedMillis) {
                 return false
-            } else {
-                clearTimeout(oldLocalEntry.ttlTimeout)
             }
         }
-        this.store.get(dataKey)!.set(publisherKey, {
-            dataEntry,
-            ttlTimeout: setTimeout(() => {
-                this.deleteEntry(PeerID.fromValue(dataEntry.kademliaId), dataEntry.storer!)
-            }, createTtlValue(dataEntry.ttl))
-        })
+        this.store.get(key)!.set(creatorNodeId, dataEntry)
         return true
     }
 
-    public markAsDeleted(id: Uint8Array, storer: PeerID): boolean {
-        const dataKey = PeerID.fromValue(id).toKey()
-        if (!this.store.get(dataKey)?.has(storer.toKey())) {
+    public markAsDeleted(key: DhtAddress, creator: DhtAddress): boolean {
+        const item = this.store.get(key)
+        if ((item === undefined) || !item.has(creator)) {
             return false
         }
-        const storedEntry = this.store.get(dataKey)!.get(storer.toKey())
-        storedEntry!.dataEntry.deleted = true
+        const storedEntry = item.get(creator)
+        storedEntry!.deleted = true
         return true
     }
 
-    public getStore(): Map<PeerIDKey, Map<PeerIDKey, LocalDataEntry>> {
-        return this.store
-    }
-
-    public getEntry(key: PeerID): Map<PeerIDKey, DataEntry> {
-        const dataEntries = new Map<PeerIDKey, DataEntry>
-        this.store.get(key.toKey())?.forEach((value, key) => {
-            dataEntries.set(key, value.dataEntry)
-        })
-        return dataEntries
+    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 setStale(key: PeerID, storer: PeerDescriptor, stale: boolean): void {
-        const storerKey = keyFromPeerDescriptor(storer)
-        const storedEntry = this.store.get(key.toKey())?.get(storerKey)
-        if (storedEntry) {
-            storedEntry.dataEntry.stale = stale
-        }
+    public keys(): IterableIterator<DhtAddress> {
+        return this.store.keys()
     }
 
-    public setAllEntriesAsStale(key: PeerID): void {
-        this.store.get(key.toKey())?.forEach((value) => {
-            value.dataEntry.stale = true
+    public setAllEntriesAsStale(key: DhtAddress): void {
+        this.store.get(key)?.forEach((value) => {
+            value.stale = true
         })
     }
 
-    public deleteEntry(key: PeerID, storer: PeerDescriptor): void {
-        const storerKey = keyFromPeerDescriptor(storer)
-        const storedEntry = this.store.get(key.toKey())?.get(storerKey)
+    public deleteEntry(key: DhtAddress, creator: DhtAddress): void {
+        const storedEntry = this.store.get(key)?.get(creator)
         if (storedEntry) {
-            clearTimeout(storedEntry.ttlTimeout)
-            this.store.get(key.toKey())?.delete(storerKey)
-            if (this.store.get(key.toKey())?.size === 0) {
-                this.store.delete(key.toKey())
+            this.store.get(key)?.delete(creator)
+            if (this.store.get(key)?.size() === 0) {
+                this.store.delete(key)
             }
         }
     }
 
     public clear(): void {
-        this.store.forEach((value) => {
-            value.forEach((value) => {
-                clearTimeout(value.ttlTimeout)
-            })
-        })
+        this.store.forEach((value) => value.clear())
         this.store.clear()
     }
 }