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

package/src/dht/store/LocalDataStore.ts

@@ -23,23 +23,23 @@ interface LocalDataEntry {
 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
+    // PeerID of the creator of the data
     private store: Map<PeerIDKey, Map<PeerIDKey, LocalDataEntry>> = new Map()
 
     public storeEntry(dataEntry: DataEntry): boolean {
-        const publisherKey = PeerID.fromValue(dataEntry.storer!.kademliaId).toKey()
-        const dataKey = PeerID.fromValue(dataEntry.kademliaId).toKey()
+        const publisherKey = PeerID.fromValue(dataEntry.creator!.nodeId).toKey()
+        const dataKey = PeerID.fromValue(dataEntry.key).toKey()
         
         if (!this.store.has(dataKey)) {
             this.store.set(dataKey, new Map())
         }
 
         if (this.store.get(dataKey)!.has(publisherKey)) {
-            const storedMillis = (dataEntry.storerTime!.seconds * 1000) + (dataEntry.storerTime!.nanos / 1000000)
+            const storedMillis = (dataEntry.createdAt!.seconds * 1000) + (dataEntry.createdAt!.nanos / 1000000)
             const oldLocalEntry = this.store.get(dataKey)!.get(publisherKey)!
-            const oldStoredMillis = (oldLocalEntry.dataEntry.storerTime!.seconds * 1000) + (oldLocalEntry.dataEntry.storerTime!.nanos / 1000000)
+            const oldStoredMillis = (oldLocalEntry.dataEntry.createdAt!.seconds * 1000) + (oldLocalEntry.dataEntry.createdAt!.nanos / 1000000)
         
-            // do nothing if old entry is newer than the one being migrated
+            // do nothing if old entry is newer than the one being replicated
             if (oldStoredMillis >= storedMillis) {
                 return false
             } else {
@@ -49,18 +49,19 @@ export class LocalDataStore {
         this.store.get(dataKey)!.set(publisherKey, {
             dataEntry,
             ttlTimeout: setTimeout(() => {
-                this.deleteEntry(PeerID.fromValue(dataEntry.kademliaId), dataEntry.storer!)
+                this.deleteEntry(PeerID.fromValue(dataEntry.key), dataEntry.creator!)
             }, createTtlValue(dataEntry.ttl))
         })
         return true
     }
 
-    public markAsDeleted(id: Uint8Array, storer: PeerID): boolean {
+    public markAsDeleted(id: Uint8Array, creator: PeerID): boolean {
         const dataKey = PeerID.fromValue(id).toKey()
-        if (!this.store.get(dataKey)?.has(storer.toKey())) {
+        const item = this.store.get(dataKey)
+        if ((item === undefined) || !item.has(creator.toKey())) {
             return false
         }
-        const storedEntry = this.store.get(dataKey)!.get(storer.toKey())
+        const storedEntry = item.get(creator.toKey())
         storedEntry!.dataEntry.deleted = true
         return true
     }
@@ -77,9 +78,9 @@ export class LocalDataStore {
         return dataEntries
     }
 
-    public setStale(key: PeerID, storer: PeerDescriptor, stale: boolean): void {
-        const storerKey = keyFromPeerDescriptor(storer)
-        const storedEntry = this.store.get(key.toKey())?.get(storerKey)
+    public setStale(key: PeerID, creator: PeerDescriptor, stale: boolean): void {
+        const creatorKey = keyFromPeerDescriptor(creator)
+        const storedEntry = this.store.get(key.toKey())?.get(creatorKey)
         if (storedEntry) {
             storedEntry.dataEntry.stale = stale
         }
@@ -91,12 +92,12 @@ export class LocalDataStore {
         })
     }
 
-    public deleteEntry(key: PeerID, storer: PeerDescriptor): void {
-        const storerKey = keyFromPeerDescriptor(storer)
-        const storedEntry = this.store.get(key.toKey())?.get(storerKey)
+    public deleteEntry(key: PeerID, creator: PeerDescriptor): void {
+        const creatorKey = keyFromPeerDescriptor(creator)
+        const storedEntry = this.store.get(key.toKey())?.get(creatorKey)
         if (storedEntry) {
             clearTimeout(storedEntry.ttlTimeout)
-            this.store.get(key.toKey())?.delete(storerKey)
+            this.store.get(key.toKey())?.delete(creatorKey)
             if (this.store.get(key.toKey())?.size === 0) {
                 this.store.delete(key.toKey())
             }

package/src/dht/store/StoreRpcLocal.ts

@@ -1,5 +1,5 @@
 import {
-    DataEntry, DeleteDataRequest, DeleteDataResponse, MigrateDataRequest, MigrateDataResponse, PeerDescriptor,
+    DataEntry, ReplicateDataRequest, PeerDescriptor,
     StoreDataRequest, StoreDataResponse
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { PeerID } from '../../helpers/PeerID'
@@ -10,7 +10,7 @@ import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { StoreRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { IFinder } from '../find/Finder'
-import { areEqualPeerDescriptors, getNodeIdFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
+import { areEqualPeerDescriptors } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import { LocalDataStore } from './LocalDataStore'
 import { IStoreRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
@@ -22,6 +22,7 @@ import { SortedContactList } from '../contact/SortedContactList'
 import { Contact } from '../contact/Contact'
 import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
 import { ServiceID } from '../../types/ServiceID'
+import { Empty } from '../../proto/google/protobuf/empty'
 
 interface DataStoreConfig {
     rpcCommunicator: RoutingRpcCommunicator
@@ -66,46 +67,53 @@ export class StoreRpcLocal implements IStoreRpc {
         this.rpcRequestTimeout = config.rpcRequestTimeout
         this.getNodesClosestToIdFromBucket = config.getNodesClosestToIdFromBucket
         this.rpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData',
-            (request: StoreDataRequest, context: ServerCallContext) => this.storeData(request, context))
-        this.rpcCommunicator.registerRpcMethod(MigrateDataRequest, MigrateDataResponse, 'migrateData',
-            (request: MigrateDataRequest, context: ServerCallContext) => this.migrateData(request, context))
-        this.rpcCommunicator.registerRpcMethod(DeleteDataRequest, DeleteDataResponse, 'deleteData',
-            (request: DeleteDataRequest, context: ServerCallContext) => this.deleteData(request, context))
+            (request: StoreDataRequest) => this.storeData(request))
+        this.rpcCommunicator.registerRpcNotification(ReplicateDataRequest, 'replicateData',
+            (request: ReplicateDataRequest, context: ServerCallContext) => this.replicateData(request, context))
 
         this.dhtNodeEmitter.on('newContact', (peerDescriptor: PeerDescriptor) => {
             this.localDataStore.getStore().forEach((dataMap, _dataKey) => {
-                dataMap.forEach((dataEntry) => {
-                    if (this.shouldMigrateDataToNewNode(dataEntry.dataEntry, peerDescriptor)) {
-                        this.migrateDataToContact(dataEntry.dataEntry, peerDescriptor)
+                dataMap.forEach(async (dataEntry) => {
+                    if (this.shouldReplicateDataToNewNode(dataEntry.dataEntry, peerDescriptor)) {
+                        try {
+                            await this.replicateDataToContact(dataEntry.dataEntry, peerDescriptor)
+                        } catch (e) {
+                            logger.trace('replicateDataToContact() failed', { error: e })
+                        }
                     }
                 })
             })
         })
     }
 
-    private shouldMigrateDataToNewNode(dataEntry: DataEntry, newNode: PeerDescriptor): boolean {
+    private shouldReplicateDataToNewNode(dataEntry: DataEntry, newNode: PeerDescriptor): boolean {
 
-        const dataId = PeerID.fromValue(dataEntry.kademliaId)
-        const newNodeId = PeerID.fromValue(newNode.kademliaId)
-        const localPeerId = PeerID.fromValue(this.localPeerDescriptor.kademliaId)
+        const dataId = PeerID.fromValue(dataEntry.key)
+        const newNodeId = PeerID.fromValue(newNode.nodeId)
+        const localPeerId = PeerID.fromValue(this.localPeerDescriptor.nodeId)
 
-        const closestToData = this.getNodesClosestToIdFromBucket(dataEntry.kademliaId, 10)
-
-        const sortedList = new SortedContactList<Contact>(dataId, 20, undefined, true)
+        const closestToData = this.getNodesClosestToIdFromBucket(dataEntry.key, 10)
+        const sortedList = new SortedContactList<Contact>({
+            referenceId: PeerID.fromValue(dataEntry.key), 
+            maxSize: 20,  // TODO use config option or named constant?
+            allowToContainReferenceId: true,
+            emitEvents: false
+        })
         sortedList.addContact(new Contact(this.localPeerDescriptor))
 
         closestToData.forEach((con) => {
-            if (!newNodeId.equals(PeerID.fromValue(con.getPeerDescriptor().kademliaId))) {
+            if (!newNodeId.equals(PeerID.fromValue(con.getPeerDescriptor().nodeId))) {
                 sortedList.addContact(new Contact(con.getPeerDescriptor()))
             }
         })
 
         if (!sortedList.getAllContacts()[0].getPeerId().equals(localPeerId)) {
-            // If we are not the closes node to the data, do not migrate
+            // If we are not the closes node to the data, do not replicate
             return false
         }
 
-        const newPeerId = PeerID.fromValue(newNode.kademliaId)
+        this.localDataStore.setStale(dataId, dataEntry.creator!, false)
+        const newPeerId = PeerID.fromValue(newNode.nodeId)
         sortedList.addContact(new Contact(newNode))
 
         const sorted = sortedList.getAllContacts()
@@ -119,18 +127,16 @@ export class StoreRpcLocal implements IStoreRpc {
         }
 
         // if new node is within the storageRedundancyFactor closest nodes to the data
-        // do migrate data to it
+        // do replicate data to it
 
         if (index < this.redundancyFactor) {
-            this.localDataStore.setStale(dataId, dataEntry.storer!, false)
             return true
         } else {
-            this.localDataStore.setStale(dataId, dataEntry.storer!, true)
             return false
         }
     }
 
-    private async migrateDataToContact(dataEntry: DataEntry, contact: PeerDescriptor, doNotConnect: boolean = false): Promise<void> {
+    private async replicateDataToContact(dataEntry: DataEntry, contact: PeerDescriptor, doNotConnect: boolean = false): Promise<void> {
         const rpcRemote = new StoreRpcRemote(
             this.localPeerDescriptor,
             contact,
@@ -139,33 +145,30 @@ export class StoreRpcLocal implements IStoreRpc {
             this.rpcRequestTimeout
         )
         try {
-            const response = await rpcRemote.migrateData({ dataEntry }, doNotConnect)
-            if (response.error) {
-                logger.trace('migrateData() returned error: ' + response.error)
-            }
+            await rpcRemote.replicateData({ entry: dataEntry }, doNotConnect)
         } catch (e) {
-            logger.trace('migrateData() threw an exception ' + e)
+            logger.trace('replicateData() threw an exception ' + e)
         }
     }
 
-    public async storeDataToDht(key: Uint8Array, data: Any): Promise<PeerDescriptor[]> {
+    public async storeDataToDht(key: Uint8Array, data: Any, creator: PeerDescriptor): Promise<PeerDescriptor[]> {
         logger.debug(`Storing data to DHT ${this.serviceId}`)
         const result = await this.finder.startFind(key)
         const closestNodes = result.closestNodes
         const successfulNodes: PeerDescriptor[] = []
         const ttl = this.highestTtl // ToDo: make TTL decrease according to some nice curve
-        const storerTime = Timestamp.now()
+        const createdAt = Timestamp.now()
         for (let i = 0; i < closestNodes.length && successfulNodes.length < this.redundancyFactor; i++) {
             if (areEqualPeerDescriptors(this.localPeerDescriptor, closestNodes[i])) {
                 this.localDataStore.storeEntry({
-                    kademliaId: key, 
-                    storer: this.localPeerDescriptor,
-                    ttl, 
-                    storedAt: Timestamp.now(), 
+                    key, 
                     data,
+                    creator,
+                    createdAt,
+                    storedAt: Timestamp.now(), 
+                    ttl, 
                     stale: false,
                     deleted: false,
-                    storerTime
                 })
                 successfulNodes.push(closestNodes[i])
                 continue
@@ -178,7 +181,13 @@ export class StoreRpcLocal implements IStoreRpc {
                 this.rpcRequestTimeout
             )
             try {
-                const response = await rpcRemote.storeData({ kademliaId: key, data, ttl, storerTime })
+                const response = await rpcRemote.storeData({
+                    key,
+                    data,
+                    creator,
+                    createdAt,
+                    ttl
+                })
                 if (!response.error) {
                     successfulNodes.push(closestNodes[i])
                     logger.trace('remote.storeData() returned success')
@@ -193,104 +202,100 @@ export class StoreRpcLocal implements IStoreRpc {
     }
 
     private selfIsOneOfClosestPeers(dataId: Uint8Array): boolean {
-        const localPeerId = PeerID.fromValue(this.localPeerDescriptor.kademliaId)
+        const localPeerId = PeerID.fromValue(this.localPeerDescriptor.nodeId)
         const closestPeers = this.getNodesClosestToIdFromBucket(dataId, this.redundancyFactor)
-        const sortedList = new SortedContactList<Contact>(localPeerId, this.redundancyFactor, undefined, true)
+        const sortedList = new SortedContactList<Contact>({
+            referenceId: localPeerId, 
+            maxSize: this.redundancyFactor, 
+            allowToContainReferenceId: true, 
+            emitEvents: false
+        })
         sortedList.addContact(new Contact(this.localPeerDescriptor))
         closestPeers.forEach((con) => sortedList.addContact(new Contact(con.getPeerDescriptor())))
         return sortedList.getClosestContacts().some((node) => node.getPeerId().equals(localPeerId))
     }
 
-    public async deleteDataFromDht(key: Uint8Array): Promise<void> {
-        logger.debug(`Deleting data from DHT ${this.serviceId}`)
-        const result = await this.finder.startFind(key)
-        const closestNodes = result.closestNodes
-        const successfulNodes: PeerDescriptor[] = []
-        for (let i = 0; i < closestNodes.length && successfulNodes.length < this.redundancyFactor; i++) {
-            if (areEqualPeerDescriptors(this.localPeerDescriptor, closestNodes[i])) {
-                this.localDataStore.markAsDeleted(key, peerIdFromPeerDescriptor(this.localPeerDescriptor))
-                successfulNodes.push(closestNodes[i])
-                continue
-            }
-            const rpcRemote = new StoreRpcRemote(
-                this.localPeerDescriptor,
-                closestNodes[i],
-                this.serviceId,
-                toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport())),
-                this.rpcRequestTimeout
-            )
-            try {
-                const response = await rpcRemote.deleteData({ kademliaId: key })
-                if (response.deleted) {
-                    logger.trace('remote.deleteData() returned success')
-                } else {
-                    logger.trace('could not delete data from ' + getNodeIdFromPeerDescriptor(closestNodes[i]))
-                }
-                successfulNodes.push(closestNodes[i])
-            } catch (e) {
-                logger.trace('remote.deleteData() threw an exception ' + e)
-            }
-        }
-    }
-
     // RPC service implementation
-    async storeData(request: StoreDataRequest, context: ServerCallContext): Promise<StoreDataResponse> {
+    async storeData(request: StoreDataRequest): Promise<StoreDataResponse> {
         const ttl = Math.min(request.ttl, this.maxTtl)
-        const { incomingSourceDescriptor } = context as DhtCallContext
-        const { kademliaId, data, storerTime } = request
+        const { key, data, createdAt, creator } = request
         this.localDataStore.storeEntry({ 
-            kademliaId, 
-            storer: incomingSourceDescriptor!, 
-            ttl,
-            storedAt: Timestamp.now(),
-            storerTime,
+            key, 
             data,
-            stale: !this.selfIsOneOfClosestPeers(kademliaId),
+            creator, 
+            createdAt,
+            storedAt: Timestamp.now(),
+            ttl,
+            stale: !this.selfIsOneOfClosestPeers(key),
             deleted: false
         })
         
-        if (!this.selfIsOneOfClosestPeers(kademliaId)) {
-            this.localDataStore.setAllEntriesAsStale(PeerID.fromValue(kademliaId))
+        if (!this.selfIsOneOfClosestPeers(key)) {
+            this.localDataStore.setAllEntriesAsStale(PeerID.fromValue(key))
         }
 
         logger.trace('storeData()')
         return StoreDataResponse.create()
     }
 
-    // RPC service implementation
-    async deleteData(request: DeleteDataRequest, context: ServerCallContext): Promise<DeleteDataResponse> {
-        const { incomingSourceDescriptor } = context as DhtCallContext
-        const { kademliaId } = request
-        const deleted = this.localDataStore.markAsDeleted(kademliaId, peerIdFromPeerDescriptor(incomingSourceDescriptor!))
-        return DeleteDataResponse.create({ deleted })
+    async destroy(): Promise<void> {
+        await this.replicateDataToClosestNodes()
+    }
+
+    private async replicateDataToClosestNodes(): Promise<void> {
+        const dataEntries = Array.from(this.localDataStore.getStore().values())
+            .flatMap((dataMap) => Array.from(dataMap.values()))
+            .map((localData) => localData.dataEntry)
+
+        await Promise.all(dataEntries.map(async (dataEntry) => {
+            const dhtNodeRemotes = this.getNodesClosestToIdFromBucket(dataEntry.key, this.redundancyFactor)
+            await Promise.all(dhtNodeRemotes.map(async (remoteDhtNode) => {
+                const rpcRemote = new StoreRpcRemote(
+                    this.localPeerDescriptor,
+                    remoteDhtNode.getPeerDescriptor(),
+                    this.serviceId,
+                    toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport())),
+                    this.rpcRequestTimeout
+                )
+                try {
+                    await rpcRemote.replicateData({ entry: dataEntry })
+                } catch (err) {
+                    logger.trace('Failed to replicate data in replicateDataToClosestNodes', { error: err })
+                }
+            }))
+        }))
     }
 
     // RPC service implementation
-    public async migrateData(request: MigrateDataRequest, context: ServerCallContext): Promise<MigrateDataResponse> {
-        logger.trace('server-side migrateData()')
-        const dataEntry = request.dataEntry!
+    public async replicateData(request: ReplicateDataRequest, context: ServerCallContext): Promise<Empty> {
+        logger.trace('server-side replicateData()')
+        const dataEntry = request.entry!
 
         const wasStored = this.localDataStore.storeEntry(dataEntry)
         
         if (wasStored) {
-            this.migrateDataToNeighborsIfNeeded((context as DhtCallContext).incomingSourceDescriptor!, request.dataEntry!)
+            this.replicateDataToNeighborsIfNeeded((context as DhtCallContext).incomingSourceDescriptor!, request.entry!)
         }
-        if (!this.selfIsOneOfClosestPeers(dataEntry.kademliaId)) {
-            this.localDataStore.setAllEntriesAsStale(PeerID.fromValue(dataEntry.kademliaId))
+        if (!this.selfIsOneOfClosestPeers(dataEntry.key)) {
+            this.localDataStore.setAllEntriesAsStale(PeerID.fromValue(dataEntry.key))
         }
-        logger.trace('server-side migrateData() at end')
-        return MigrateDataResponse.create()
+        logger.trace('server-side replicateData() at end')
+        return {}
     }
 
-    private migrateDataToNeighborsIfNeeded(incomingPeer: PeerDescriptor, dataEntry: DataEntry): void {
+    private replicateDataToNeighborsIfNeeded(incomingPeer: PeerDescriptor, dataEntry: DataEntry): void {
 
         // sort own contact list according to data id
-        const localPeerId = PeerID.fromValue(this.localPeerDescriptor.kademliaId)
-        const dataId = PeerID.fromValue(dataEntry.kademliaId)
-        const incomingPeerId = PeerID.fromValue(incomingPeer.kademliaId)
-        const closestToData = this.getNodesClosestToIdFromBucket(dataEntry.kademliaId, 10)
-
-        const sortedList = new SortedContactList<Contact>(dataId, this.redundancyFactor, undefined, true)
+        const localPeerId = PeerID.fromValue(this.localPeerDescriptor.nodeId)
+        const dataId = PeerID.fromValue(dataEntry.key)
+        const incomingPeerId = PeerID.fromValue(incomingPeer.nodeId)
+        const closestToData = this.getNodesClosestToIdFromBucket(dataEntry.key, 10)
+        const sortedList = new SortedContactList<Contact>({
+            referenceId: dataId, 
+            maxSize: this.redundancyFactor, 
+            allowToContainReferenceId: true, 
+            emitEvents: false
+        })
         sortedList.addContact(new Contact(this.localPeerDescriptor))
 
         closestToData.forEach((con) => {
@@ -298,33 +303,33 @@ export class StoreRpcLocal implements IStoreRpc {
         })
 
         if (!sortedList.getAllContacts()[0].getPeerId().equals(localPeerId)) {
-            // If we are not the closest node to the data, migrate only to the 
+            // If we are not the closest node to the data, replicate only to the 
             // closest one to the data
 
             const contact = sortedList.getAllContacts()[0]
-            const contactPeerId = PeerID.fromValue(contact.getPeerDescriptor().kademliaId)
+            const contactPeerId = PeerID.fromValue(contact.getPeerDescriptor().nodeId)
             if (!incomingPeerId.equals(contactPeerId) && !localPeerId.equals(contactPeerId)) {
                 setImmediate(async () => {
                     try {
-                        await this.migrateDataToContact(dataEntry, contact.getPeerDescriptor())
-                        logger.trace('migrateDataToContact() returned when migrating to only the closest contact')
+                        await this.replicateDataToContact(dataEntry, contact.getPeerDescriptor())
+                        logger.trace('replicateDataToContact() returned when migrating to only the closest contact')
                     } catch (e) {
-                        logger.error('migrating data to only the closest contact failed ' + e)
+                        logger.error('replicating data to only the closest contact failed ' + e)
                     }
                 })
             }
         } else {
-            // if we are the closest to the data, migrate to all storageRedundancyFactor nearest
+            // if we are the closest to the data, replicate to all storageRedundancyFactor nearest
             sortedList.getAllContacts().forEach((contact) => {
-                const contactPeerId = PeerID.fromValue(contact.getPeerDescriptor().kademliaId)
+                const contactPeerId = PeerID.fromValue(contact.getPeerDescriptor().nodeId)
                 if (!incomingPeerId.equals(contactPeerId) && !localPeerId.equals(contactPeerId)) {
                     if (!incomingPeerId.equals(contactPeerId) && !localPeerId.equals(contactPeerId)) {
                         setImmediate(async () => {
                             try {
-                                await this.migrateDataToContact(dataEntry, contact.getPeerDescriptor())
-                                logger.trace('migrateDataToContact() returned')
+                                await this.replicateDataToContact(dataEntry, contact.getPeerDescriptor())
+                                logger.trace('replicateDataToContact() returned')
                             } catch (e) {
-                                logger.error('migrating data to one of the closest contacts failed ' + e)
+                                logger.error('replicating data to one of the closest contacts failed ' + e)
                             }
                         })
                     }

package/src/dht/store/StoreRpcRemote.ts

@@ -1,16 +1,13 @@
-import { EXISTING_CONNECTION_TIMEOUT, Remote } from '../contact/Remote'
+import { EXISTING_CONNECTION_TIMEOUT, RpcRemote } from '../contact/RpcRemote'
 import { IStoreRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
-import { 
-    DeleteDataRequest,
-    DeleteDataResponse,
-    MigrateDataRequest,
-    MigrateDataResponse,
+import {
+    ReplicateDataRequest,
     StoreDataRequest,
     StoreDataResponse
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { getNodeIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
-export class StoreRpcRemote extends Remote<IStoreRpcClient> {
+export class StoreRpcRemote extends RpcRemote<IStoreRpcClient> {
 
     async storeData(request: StoreDataRequest): Promise<StoreDataResponse> {
         const options = this.formDhtRpcOptions()
@@ -19,29 +16,16 @@ export class StoreRpcRemote extends Remote<IStoreRpcClient> {
         } catch (err) {
             const to = getNodeIdFromPeerDescriptor(this.getPeerDescriptor())
             const from = getNodeIdFromPeerDescriptor(this.getLocalPeerDescriptor())
-            throw Error(
-                `Could not store data to ${to} from ${from} ${err}`
-            )
+            throw new Error(`Could not store data to ${to} from ${from} ${err}`)
         }
     }
 
-    async deleteData(request: DeleteDataRequest): Promise<DeleteDataResponse> {
-        const options = this.formDhtRpcOptions()
-        try {
-            return await this.getClient().deleteData(request, options)
-        } catch (err) {
-            throw Error(
-                `Could not call delete data to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} ${err}`
-            )
-        }
-    }
-
-    async migrateData(request: MigrateDataRequest, doNotConnect: boolean = false): Promise<MigrateDataResponse> {
+    async replicateData(request: ReplicateDataRequest, doNotConnect: boolean = false): Promise<void> {
         const options = this.formDhtRpcOptions({
             timeout: EXISTING_CONNECTION_TIMEOUT,
             doNotConnect
         })
-        return this.getClient().migrateData(request, options)
+        return this.getClient().replicateData(request, options)
     }
 
 }

package/src/exports.ts

@@ -9,7 +9,7 @@ export { ITransport } from './transport/ITransport'
 export { ConnectionManager, ConnectionLocker, PortRange, TlsCertificate } from './connection/ConnectionManager'
 export { DefaultConnectorFacade } from './connection/ConnectorFacade'
 export { DhtRpcOptions } from './rpc-protocol/DhtRpcOptions'
-export { Remote, EXISTING_CONNECTION_TIMEOUT } from './dht/contact/Remote'
+export { RpcRemote, EXISTING_CONNECTION_TIMEOUT } from './dht/contact/RpcRemote'
 export { areEqualPeerDescriptors } from './helpers/peerIdFromPeerDescriptor'
 export { IceServer } from './connection/webrtc/WebrtcConnector'
 export { DhtCallContext } from './rpc-protocol/DhtCallContext'

package/src/helpers/PeerID.ts

@@ -1,10 +1,14 @@
-import { BrandedString } from '@streamr/utils'
+import { BrandedString, binaryToHex } from '@streamr/utils'
 import { UUID } from './UUID'
 import { IllegalArguments } from './errors'
 import crypto from 'crypto'
 
 export type PeerIDKey = BrandedString<'PeerIDKey'>
 
+export const createPeerIDKey = (nodeId: Uint8Array): PeerIDKey => {
+    return binaryToHex(nodeId) as PeerIDKey
+}
+
 export class PeerID {
     // avoid creating a new instance for every operation
     private static readonly textEncoder = new TextEncoder() 
@@ -14,7 +18,7 @@ export class PeerID {
     private readonly key: PeerIDKey  // precompute often-used form of data
 
     protected constructor({ ip, value, stringValue }: { ip?: string, value?: Uint8Array, stringValue?: string } = {}) {
-        if (ip) {
+        if (ip !== undefined) {
             this.data = new Uint8Array(20)
             const ipNum = this.ip2Int(ip)
             const view = new DataView(this.data.buffer)
@@ -23,14 +27,14 @@ export class PeerID {
             this.data.set((new UUID()).value, 4)
         } else if (value) {
             this.data = new Uint8Array(value.slice(0))
-        } else if (stringValue) {
+        } else if (stringValue !== undefined) {
             const ab = PeerID.textEncoder.encode(stringValue) //toUTF8Array(stringValue)
             this.data = ab
         } else {
             throw new IllegalArguments('Constructor of PeerID must be given either ip, value or stringValue')
         }
 
-        this.key = Buffer.from(this.data).toString('hex') as PeerIDKey
+        this.key = createPeerIDKey(this.data)
     }
 
     static fromIp(ip: string): PeerID {

package/src/helpers/UUID.ts

@@ -5,7 +5,7 @@ export class UUID {
     private buf: Uint8Array
 
     constructor(other?: (UUID | Uint8Array | string)) {
-        if (!other) {
+        if (other === undefined) {
             this.buf = new Uint8Array(16)
             v4(null, this.buf)
         } else if (other.constructor === UUID) {

package/src/helpers/{kademliaId.ts → nodeId.ts}

@@ -3,6 +3,6 @@ import crypto from 'crypto'
 // https://www.scs.stanford.edu/~dm/home/papers/kpos.pdf
 const KADEMLIA_ID_LENGTH_IN_BYTES = 20
 
-export const createRandomKademliaId = (): Uint8Array => {
+export const createRandomNodeId = (): Uint8Array => {
     return crypto.randomBytes(KADEMLIA_ID_LENGTH_IN_BYTES)
 }

package/src/helpers/peerIdFromPeerDescriptor.ts

@@ -1,20 +1,20 @@
-import { binaryToHex } from '@streamr/utils'
+import { areEqualBinaries, binaryToHex } from '@streamr/utils'
 import { PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
-import { PeerID, PeerIDKey } from './PeerID'
+import { PeerID, PeerIDKey, createPeerIDKey } from './PeerID'
 
 export const peerIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerID => {
-    return PeerID.fromValue(peerDescriptor.kademliaId)
+    return PeerID.fromValue(peerDescriptor.nodeId)
 }
 
 // TODO could move getNodeIdFromPeerDescriptor (and NodeID) from trackerless-network
 export const getNodeIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): string => {
-    return binaryToHex(peerDescriptor.kademliaId)
+    return binaryToHex(peerDescriptor.nodeId)
 }
 
 export const keyFromPeerDescriptor = (peerDescriptor: PeerDescriptor): PeerIDKey => {
-    return PeerID.fromValue(peerDescriptor.kademliaId).toKey()
+    return createPeerIDKey(peerDescriptor.nodeId)
 }
 
 export const areEqualPeerDescriptors = (peerDescriptor1: PeerDescriptor, peerDescriptor2: PeerDescriptor): boolean => {
-    return peerIdFromPeerDescriptor(peerDescriptor1).equals(peerIdFromPeerDescriptor(peerDescriptor2))
+    return areEqualBinaries(peerDescriptor1.nodeId, peerDescriptor2.nodeId)
 }