@streamr/dht 100.0.0-pretestnet.6 → 100.0.0-testnet-one.0

package/test/integration/StoreAndDelete.test.ts

@@ -1,10 +1,10 @@
 import { LatencyType, Simulator } from '../../src/connection/simulator/Simulator'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { createMockConnectionDhtNode, waitConnectionManagersReadyForTesting } from '../utils/utils'
-import { PeerID } from '../../src/helpers/PeerID'
+import { createMockConnectionDhtNode, createMockPeerDescriptor, waitConnectionManagersReadyForTesting } from '../utils/utils'
 import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { Any } from '../../src/proto/google/protobuf/any'
+import { createRandomNodeId } from '../../src/helpers/nodeId'
 
 describe('Storing data in DHT', () => {
     let entryPoint: DhtNode
@@ -46,45 +46,47 @@ describe('Storing data in DHT', () => {
 
     it('Data can be deleted', async () => {
         const storingNode = getRandomNode()
-        const dataKey = PeerID.fromString('3232323e12r31r3')
-        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
-        const successfulStorers = await storingNode.storeDataToDht(dataKey.value, data)
+        const dataKey = createRandomNodeId()
+        const storedData = createMockPeerDescriptor()
+        const data = Any.pack(storedData, PeerDescriptor)
+        const successfulStorers = await storingNode.storeDataToDht(dataKey, data)
         expect(successfulStorers.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(dataKey.value)
+        await storingNode.deleteDataFromDht(dataKey, true)
 
         const fetchingNode = getRandomNode()
-        const results = await fetchingNode.getDataFromDht(dataKey.value)
+        const results = await fetchingNode.getDataFromDht(dataKey)
         results.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
             expect(entry.deleted).toBeTrue()
-            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storedData)).toBeTrue()
         })
     }, 90000)
 
     it('Data can be deleted and re-stored', async () => {
         const storingNode = getRandomNode()
-        const dataKey = PeerID.fromString('3232323e12r31r3')
-        const data = Any.pack(entrypointDescriptor, PeerDescriptor)
-        const successfulStorers1 = await storingNode.storeDataToDht(dataKey.value, data)
+        const dataKey = createRandomNodeId()
+        const storedData = createMockPeerDescriptor()
+        const data = Any.pack(storedData, PeerDescriptor)
+        const successfulStorers1 = await storingNode.storeDataToDht(dataKey, data)
         expect(successfulStorers1.length).toBeGreaterThan(4)
-        await storingNode.deleteDataFromDht(dataKey.value)
+        await storingNode.deleteDataFromDht(dataKey, true)
 
         const fetchingNode = getRandomNode()
-        const results1 = await fetchingNode.getDataFromDht(dataKey.value)
+        const results1 = await fetchingNode.getDataFromDht(dataKey)
         results1.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
             expect(entry.deleted).toBeTrue()
-            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storedData)).toBeTrue()
         })
 
-        const successfulStorers2 = await storingNode.storeDataToDht(dataKey.value, data)
+        const successfulStorers2 = await storingNode.storeDataToDht(dataKey, data)
         expect(successfulStorers2.length).toBeGreaterThan(4)
 
-        const results2 = await fetchingNode.getDataFromDht(dataKey.value)
+        const results2 = await fetchingNode.getDataFromDht(dataKey)
         results2.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
             expect(entry.deleted).toBeFalse()
-            expect(areEqualPeerDescriptors(fetchedDescriptor, entrypointDescriptor)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, storedData)).toBeTrue()
         })
     }, 90000)
 })

package/test/integration/StoreOnDhtWithTwoNodes.test.ts

@@ -1,11 +1,11 @@
-import { createMockConnectionDhtNode } from '../utils/utils'
+import { createMockConnectionDhtNode, createMockPeerDescriptor } from '../utils/utils'
 import { DhtNode } from '../../src/dht/DhtNode'
 import { Simulator } from '../../src/connection/simulator/Simulator'
-import { PeerID } from '../../src/helpers/PeerID'
 import { Any } from '../../src/proto/google/protobuf/any'
 import { PeerDescriptor } from '../../src/proto/packages/dht/protos/DhtRpc'
 import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { waitForCondition } from '@streamr/utils'
+import { createRandomNodeId } from '../../src/helpers/nodeId'
 
 describe('Storing data in DHT with two peers', () => {
 
@@ -41,31 +41,31 @@ describe('Storing data in DHT with two peers', () => {
     })
 
     it('Node can store on two peer DHT', async () => {
-        const dataKey1 = PeerID.fromString('node0-stored-data')
-        const data1 = Any.pack(otherNode.getLocalPeerDescriptor(), PeerDescriptor)
-        const dataKey2 = PeerID.fromString('other-node-stored-data')
-        const data2 = Any.pack(entryPoint.getLocalPeerDescriptor(), PeerDescriptor)
+        const storedData1 = createMockPeerDescriptor()
+        const storedData2 = createMockPeerDescriptor()
+        const dataKey1 = createRandomNodeId()
+        const dataKey2 = createRandomNodeId()
+        const data1 = Any.pack(storedData1, PeerDescriptor)
+        const data2 = Any.pack(storedData2, PeerDescriptor)
 
-        const successfulStorers1 = await otherNode.storeDataToDht(dataKey1.value, data1)
-        const successfulStorers2 = await entryPoint.storeDataToDht(dataKey2.value, data2)
-        expect(successfulStorers1[0].kademliaId).toStrictEqual(entryPoint.getLocalPeerDescriptor().kademliaId)
-        expect(successfulStorers2[0].kademliaId).toStrictEqual(otherNode.getLocalPeerDescriptor().kademliaId)
+        await otherNode.storeDataToDht(dataKey1, data1)
+        await entryPoint.storeDataToDht(dataKey2, data2)
 
-        const foundData1 = await otherNode.getDataFromDht(dataKey1.value)
-        const foundData2 = await entryPoint.getDataFromDht(dataKey2.value)
-        expect(areEqualPeerDescriptors(otherNode.getLocalPeerDescriptor(), Any.unpack(foundData1[0]!.data!, PeerDescriptor))).toBeTrue()
-        expect(areEqualPeerDescriptors(entryPoint.getLocalPeerDescriptor(), Any.unpack(foundData2[0]!.data!, PeerDescriptor))).toBeTrue()
+        const foundData1 = await otherNode.getDataFromDht(dataKey1)
+        const foundData2 = await entryPoint.getDataFromDht(dataKey2)
+        expect(areEqualPeerDescriptors(storedData1, Any.unpack(foundData1[0]!.data!, PeerDescriptor))).toBeTrue()
+        expect(areEqualPeerDescriptors(storedData2, Any.unpack(foundData2[0]!.data!, PeerDescriptor))).toBeTrue()
     })
 
     it('Can store on one peer DHT', async () => {
         await otherNode.stop()
         await waitForCondition(() => entryPoint.getBucketSize() === 0)
-        const dataKey = PeerID.fromString('data-to-store')
-        const data = Any.pack(entryPoint.getLocalPeerDescriptor(), PeerDescriptor)
-        const successfulStorers = await entryPoint.storeDataToDht(dataKey.value, data)
-        expect(successfulStorers[0].kademliaId).toStrictEqual(entryPoint.getLocalPeerDescriptor().kademliaId)
+        const dataKey = createRandomNodeId()
+        const storedData = createMockPeerDescriptor()
+        const data = Any.pack(storedData, PeerDescriptor)
+        await entryPoint.storeDataToDht(dataKey, data)
 
-        const foundData = await entryPoint.getDataFromDht(dataKey.value)
-        expect(areEqualPeerDescriptors(entryPoint.getLocalPeerDescriptor(), Any.unpack(foundData[0]!.data!, PeerDescriptor))).toBeTrue()
+        const foundData = await entryPoint.getDataFromDht(dataKey)
+        expect(areEqualPeerDescriptors(storedData, Any.unpack(foundData[0]!.data!, PeerDescriptor))).toBeTrue()
     }, 60000)
 })

package/test/integration/StoreRpcRemote.test.ts

@@ -18,16 +18,16 @@ describe('StoreRpcRemote', () => {
     let serverRpcCommunicator: RpcCommunicator
     const serviceId = 'test'
     const clientPeerDescriptor: PeerDescriptor = {
-        kademliaId: generateId('client'),
+        nodeId: generateId('client'),
         type: NodeType.NODEJS
     }
     const serverPeerDescriptor: PeerDescriptor = {
-        kademliaId: generateId('server'),
+        nodeId: generateId('server'),
         type: NodeType.NODEJS
     }
     const data = Any.pack(clientPeerDescriptor, PeerDescriptor)
     const request: StoreDataRequest = {
-        kademliaId: clientPeerDescriptor.kademliaId,
+        key: clientPeerDescriptor.nodeId,
         data,
         ttl: 10
     }

package/test/integration/WebrtcConnectionManagement.test.ts

@@ -28,12 +28,12 @@ describe('WebRTC Connection Management', () => {
     let simulator: Simulator
 
     const peerDescriptor1: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peer1').value,
+        nodeId: PeerID.fromString('peer1').value,
         type: NodeType.NODEJS,
     }
 
     const peerDescriptor2: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peer2').value,
+        nodeId: PeerID.fromString('peer2').value,
         type: NodeType.NODEJS,
     }
 

package/test/integration/WebrtcConnectorRpc.test.ts

@@ -25,7 +25,7 @@ describe('WebRTC rpc messages', () => {
     let iceCandidateCounter: number
 
     const targetDescriptor: PeerDescriptor = {
-        kademliaId: generateId('peer'),
+        nodeId: generateId('peer'),
         type: NodeType.NODEJS
     }
 

package/test/integration/WebsocketConnectionManagement.test.ts

@@ -30,7 +30,7 @@ describe('Websocket Connection Management', () => {
     const simulator = new Simulator()
 
     const wsServerConnectorPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peerWithServer').value,
+        nodeId: PeerID.fromString('peerWithServer').value,
         type: NodeType.NODEJS,
         websocket: {
             host: '127.0.0.1',
@@ -40,7 +40,7 @@ describe('Websocket Connection Management', () => {
     }
 
     const noWsServerConnectorPeerDescriptor: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peerWithoutServer').value,
+        nodeId: PeerID.fromString('peerWithoutServer').value,
         type: NodeType.NODEJS,
     }
 

package/test/integration/WebsocketConnectorRpc.test.ts

@@ -17,12 +17,12 @@ describe('WebsocketConnectorRpc', () => {
     let client2: ProtoRpcClient<WebsocketConnectorRpcClient>
 
     const peerDescriptor1: PeerDescriptor = {
-        kademliaId: generateId('peer1'),
+        nodeId: generateId('peer1'),
         type: NodeType.NODEJS
     }
 
     const peerDescriptor2: PeerDescriptor = {
-        kademliaId: generateId('peer2'),
+        nodeId: generateId('peer2'),
         type: NodeType.NODEJS
     }
 

package/test/unit/ConnectivityHelpers.test.ts

@@ -5,7 +5,7 @@ import { ConnectionType } from '../../src/connection/IConnection'
 describe('Connectivity helpers', () => {
 
     const tlsServerPeerDescriptor = {
-        kademliaId: new Uint8Array(1),
+        nodeId: new Uint8Array(1),
         type: NodeType.NODEJS,
         websocket: {
             host: 'mock',
@@ -15,7 +15,7 @@ describe('Connectivity helpers', () => {
     }
 
     const noTlsServerPeerDescriptor = {
-        kademliaId: new Uint8Array(1),
+        nodeId: new Uint8Array(1),
         type: NodeType.NODEJS,
         websocket: {
             host: 'mock',
@@ -25,12 +25,12 @@ describe('Connectivity helpers', () => {
     }
 
     const browserPeerDescriptor = {
-        kademliaId: new Uint8Array(2),
+        nodeId: new Uint8Array(2),
         type: NodeType.BROWSER
     }
 
     const noServerPeerDescriptor = {
-        kademliaId: new Uint8Array(3),
+        nodeId: new Uint8Array(3),
         type: NodeType.NODEJS
     }
 

package/test/unit/Finder.test.ts

@@ -1,39 +1,51 @@
 import {
+    FindAction,
     Message,
     MessageType,
     NodeType,
     PeerDescriptor,
     RouteMessageAck,
+    RouteMessageError,
     RouteMessageWrapper
 } from '../../src/proto/packages/dht/protos/DhtRpc'
-import { PeerID, PeerIDKey } from '../../src/helpers/PeerID'
+import { PeerID } from '../../src/helpers/PeerID'
 import {
     createWrappedClosestPeersRequest,
     createFindRequest
 } from '../utils/utils'
 import { Finder } from '../../src/dht/find/Finder'
-import { DhtNodeRpcRemote } from '../../src/dht/DhtNodeRpcRemote'
 import { LocalDataStore } from '../../src/dht/store/LocalDataStore'
 import { v4 } from 'uuid'
 import { MockRouter } from '../utils/mock/Router'
 import { MockTransport } from '../utils/mock/Transport'
 import { areEqualPeerDescriptors } from '../../src/helpers/peerIdFromPeerDescriptor'
 import { FakeRpcCommunicator } from '../utils/FakeRpcCommunicator'
+import { IRouter } from '../../src/dht/routing/Router'
+import { ITransport } from '../../src/exports'
 
+const createMockRouter = (error?: RouteMessageError): Partial<IRouter> => {
+    return {
+        doRouteMessage: (routedMessage: RouteMessageWrapper) => {
+            return {
+                requestId: routedMessage.requestId,
+                error
+            }
+        },
+        isMostLikelyDuplicate: () => false,
+        addToDuplicateDetector: () => {}
+    }
+}
 describe('Finder', () => {
 
-    let finder: Finder
-    let connections: Map<PeerIDKey, DhtNodeRpcRemote>
-
     const peerDescriptor1: PeerDescriptor = {
-        kademliaId: PeerID.fromString('peerid').value,
+        nodeId: PeerID.fromString('peerid').value,
         type: NodeType.NODEJS
     }
     const peerDescriptor2: PeerDescriptor = {
-        kademliaId: PeerID.fromString('destination').value,
+        nodeId: PeerID.fromString('destination').value,
         type: NodeType.NODEJS
     }
-    const findRequest = createFindRequest(false)
+    const findRequest = createFindRequest(FindAction.NODE)
     const message: Message = {
         serviceId: 'unknown',
         messageId: v4(),
@@ -50,41 +62,41 @@ describe('Finder', () => {
         requestId: 'REQ',
         routingPath: [],
         reachableThrough: [],
-        destinationPeer: peerDescriptor1,
-        sourcePeer: peerDescriptor2
+        sourcePeer: peerDescriptor1,
+        destinationPeer: peerDescriptor2
     }
     const rpcCommunicator = new FakeRpcCommunicator()
 
-    beforeEach(() => {
-        connections = new Map()
-        finder = new Finder({
+    const createFinder = (router: IRouter = new MockRouter(), transport: ITransport = new MockTransport()): Finder => {
+        return new Finder({
             localPeerDescriptor: peerDescriptor1,
-            router: new MockRouter(),
-            connections,
+            router,
+            connections: new Map(),
             serviceId: 'Finder',
             localDataStore: new LocalDataStore(),
-            sessionTransport: new MockTransport(),
-            addContact: (_contact, _setActive) => {},
+            sessionTransport: transport,
+            addContact: () => {},
             isPeerCloserToIdThanSelf: (_peer1, _compareToId) => true,
             rpcCommunicator: rpcCommunicator as any
         })
-    })
-
-    afterEach(() => {
-        finder.stop()
-    })
+    }
 
     it('Finder server', async () => {
+        const finder = createFinder()
         const res = await rpcCommunicator.callRpcMethod('routeFindRequest', routedMessage) as RouteMessageAck
-        expect(res.error).toEqual('')
+        expect(res.error).toBeUndefined()
+        finder.stop()
     })
 
     it('startFind with mode Node returns self if no peers', async () => {
+        const finder = createFinder()
         const res = await finder.startFind(PeerID.fromString('find').value)
         expect(areEqualPeerDescriptors(res.closestNodes[0], peerDescriptor1)).toEqual(true)
+        finder.stop()
     })
 
     it('Finder server throws if payload is not FindRequest', async () => {
+        const finder = createFinder(new MockRouter())
         const rpcWrapper = createWrappedClosestPeersRequest(peerDescriptor1)
         const badMessage: Message = {
             serviceId: 'unknown',
@@ -105,6 +117,40 @@ describe('Finder', () => {
             destinationPeer: peerDescriptor1,
             sourcePeer: peerDescriptor2
         })).rejects.toThrow()
+        finder.stop()
+    })
+
+    it('no targets', async () => {
+        const router = createMockRouter(RouteMessageError.NO_TARGETS)
+        const send = jest.fn()
+        const transport = { 
+            send,
+            on: () => {},
+            off: () => {}
+        }
+        const finder = createFinder(router as any, transport as any)
+        const ack = await rpcCommunicator.callRpcMethod('routeFindRequest', routedMessage)
+        expect(ack).toEqual({
+            requestId: routedMessage.requestId,
+            error: RouteMessageError.NO_TARGETS
+        })
+        expect(send).toHaveBeenCalledTimes(1)
+        finder.stop()
     })
 
+    it('error', async () => {
+        const router = createMockRouter(RouteMessageError.DUPLICATE)
+        const send = jest.fn()
+        const transport = { 
+            send
+        }
+        const finder = createFinder(router as any, transport as any)
+        const ack = await rpcCommunicator.callRpcMethod('routeFindRequest', routedMessage)
+        expect(ack).toEqual({
+            requestId: routedMessage.requestId,
+            error: RouteMessageError.DUPLICATE
+        })
+        expect(send).not.toHaveBeenCalled()
+        finder.stop()
+    })
 })

package/test/unit/LocalDataStore.test.ts

@@ -11,16 +11,16 @@ import { Timestamp } from '../../src/proto/google/protobuf/timestamp'
 
 describe('LocalDataStore', () => {
     let localDataStore: LocalDataStore
-    const storer1: PeerDescriptor = {
-        kademliaId: new Uint8Array([1, 2, 3]),
+    const creator1: PeerDescriptor = {
+        nodeId: new Uint8Array([1, 2, 3]),
         type: NodeType.NODEJS
     }
-    const storer2: PeerDescriptor = {
-        kademliaId: new Uint8Array([3, 2, 1]),
+    const creator2: PeerDescriptor = {
+        nodeId: new Uint8Array([3, 2, 1]),
         type: NodeType.NODEJS
     }
-    const data1 = Any.pack(storer1, PeerDescriptor)
-    const data2 = Any.pack(storer2, PeerDescriptor)
+    const data1 = Any.pack(creator1, PeerDescriptor)
+    const data2 = Any.pack(creator2, PeerDescriptor)
 
     beforeEach(() => {
         localDataStore = new LocalDataStore()
@@ -31,59 +31,59 @@ describe('LocalDataStore', () => {
     })
 
     it('can store', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1, 
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        const dataKey = peerIdFromPeerDescriptor(creator1)
+        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1, 
+            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, storer1)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, creator1)).toBeTrue()
         })
     })
 
     it('multiple storers behind one key', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.storeEntry({ storer: storer2, kademliaId: dataKey.value, 
-            data: data1, ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        const dataKey = peerIdFromPeerDescriptor(creator1)
+        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
+            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+        localDataStore.storeEntry({ creator: creator2, key: dataKey.value, 
+            data: data1, ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, storer1)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, creator1)).toBeTrue()
         })
     })
 
     it('can remove data entries', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.storeEntry({ storer: storer2, kademliaId: dataKey.value, data: data2,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.deleteEntry(dataKey, storer1)
+        const dataKey = peerIdFromPeerDescriptor(creator1)
+        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
+            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+        localDataStore.storeEntry({ creator: creator2, key: dataKey.value, data: data2,
+            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+        localDataStore.deleteEntry(dataKey, creator1)
         const fetchedData = localDataStore.getEntry(dataKey)
         fetchedData.forEach((entry) => {
             const fetchedDescriptor = Any.unpack(entry.data!, PeerDescriptor)
-            expect(areEqualPeerDescriptors(fetchedDescriptor, storer2)).toBeTrue()
+            expect(areEqualPeerDescriptors(fetchedDescriptor, creator2)).toBeTrue()
         })
     })
 
     it('can remove all data entries', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.storeEntry({ storer: storer2, kademliaId: dataKey.value, data: data2,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        localDataStore.deleteEntry(dataKey, storer1)
-        localDataStore.deleteEntry(dataKey, storer2)
+        const dataKey = peerIdFromPeerDescriptor(creator1)
+        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
+            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+        localDataStore.storeEntry({ creator: creator2, key: dataKey.value, data: data2,
+            ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+        localDataStore.deleteEntry(dataKey, creator1)
+        localDataStore.deleteEntry(dataKey, creator2)
         const fetchedData = localDataStore.getEntry(dataKey)
         expect(fetchedData.size).toBe(0)
     })
 
     it('data is deleted after TTL', async () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 1000, stale: false, deleted: false, storerTime: Timestamp.now() })
+        const dataKey = peerIdFromPeerDescriptor(creator1)
+        localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
+            ttl: 1000, stale: false, deleted: false, createdAt: Timestamp.now() })
         const intitialStore = localDataStore.getEntry(dataKey)
         expect(intitialStore.size).toBe(1)
         await wait(1100)
@@ -91,15 +91,32 @@ describe('LocalDataStore', () => {
         expect(fetchedData.size).toBe(0)
     })
 
-    it('can mark data as deleted', () => {
-        const dataKey = peerIdFromPeerDescriptor(storer1)
-        localDataStore.storeEntry({ storer: storer1, kademliaId: dataKey.value, data: data1,
-            ttl: 10000, stale: false, deleted: false, storerTime: Timestamp.now() })
-        const notDeletedData = localDataStore.getEntry(dataKey)
-        expect(notDeletedData.get(keyFromPeerDescriptor(storer1))!.deleted).toBeFalse()
-        localDataStore.markAsDeleted(dataKey.value, peerIdFromPeerDescriptor(storer1))
-        const deletedData = localDataStore.getEntry(dataKey)
-        expect(deletedData.get(keyFromPeerDescriptor(storer1))!.deleted).toBeTrue()
-    })
+    describe('mark data as deleted', () => {
+
+        it('happy path', () => {
+            const dataKey = peerIdFromPeerDescriptor(creator1)
+            localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
+                ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+            const notDeletedData = localDataStore.getEntry(dataKey)
+            expect(notDeletedData.get(keyFromPeerDescriptor(creator1))!.deleted).toBeFalse()
+            const returnValue = localDataStore.markAsDeleted(dataKey.value, peerIdFromPeerDescriptor(creator1))
+            expect(returnValue).toBe(true)
+            const deletedData = localDataStore.getEntry(dataKey)
+            expect(deletedData.get(keyFromPeerDescriptor(creator1))!.deleted).toBeTrue()
+        })
 
+        it('data not stored', () => {
+            const dataKey = peerIdFromPeerDescriptor(creator1)
+            const returnValue = localDataStore.markAsDeleted(dataKey.value, peerIdFromPeerDescriptor(creator2))
+            expect(returnValue).toBe(false)
+        })
+
+        it('data not stored by the given creator', () => {
+            const dataKey = peerIdFromPeerDescriptor(creator1)
+            localDataStore.storeEntry({ creator: creator1, key: dataKey.value, data: data1,
+                ttl: 10000, stale: false, deleted: false, createdAt: Timestamp.now() })
+            const returnValue = localDataStore.markAsDeleted(dataKey.value, peerIdFromPeerDescriptor(creator2))
+            expect(returnValue).toBe(false)
+        })
+    })
 })

package/test/unit/RandomContactList.test.ts

@@ -1,8 +1,8 @@
 import { RandomContactList } from '../../src/dht/contact/RandomContactList'
 import { PeerID } from '../../src/helpers/PeerID'
 
-const createItem = (kademliaId: Uint8Array): { getPeerId: () => PeerID } => {
-    return { getPeerId: () => PeerID.fromValue(kademliaId) }
+const createItem = (nodeId: Uint8Array): { getPeerId: () => PeerID } => {
+    return { getPeerId: () => PeerID.fromValue(nodeId) }
 }
 
 describe('RandomContactList', () => {