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

package/src/helpers/AddressTools.ts

@@ -1,10 +1,12 @@
 import ipaddr from 'ipaddr.js'
 
 // IPv4 private address ranges as specified by RFC 1918
+// and private loopback addresses
 const IPv4PrivateRanges = [
     '10.0.0.0/8',
     '172.16.0.0/12',
     '192.168.0.0/16',
+    '127.0.0.0/8'
 ].map((a) => ipaddr.parseCIDR(a))
 
 export function isPrivateIPv4(address: string): boolean {

package/src/helpers/MapWithTtl.ts

@@ -0,0 +1,71 @@
+interface ValueWrapper<V> {
+    value: V
+    timeout: NodeJS.Timeout
+}
+
+export class MapWithTtl<K, V> {
+
+    private readonly delegate: Map<K, ValueWrapper<V>> = new Map()
+    private readonly getTtl: (value: V) => number
+
+    constructor(getTtl: (value: V) => number) {
+        this.getTtl = getTtl
+    }
+
+    set(key: K, value: V): void {
+        const existing = this.delegate.get(key)
+        if (existing !== undefined) {
+            clearTimeout(existing.timeout)
+        }
+        this.delegate.set(key, {
+            value,
+            timeout: this.createTimeout(key, value)
+        })
+    }
+
+    get(key: K): V | undefined {
+        const wrapper = this.delegate.get(key)
+        return wrapper?.value
+    }
+
+    has(key: K): boolean {
+        return this.delegate.has(key)
+    }
+
+    delete(key: K): void {
+        const existing = this.delegate.get(key)
+        if (existing !== undefined) {
+            clearTimeout(existing.timeout)
+            this.delegate.delete(key)
+        }
+    }
+
+    clear(): void {
+        this.delegate.forEach((value) => {
+            clearTimeout(value.timeout)
+        })
+        this.delegate.clear()
+    }
+
+    size(): number {
+        return this.delegate.size
+    }
+
+    *values(): IterableIterator<V> {
+        for (const v of this.delegate.values()) {
+            yield v.value
+        }
+    }
+
+    forEach(cb: (value: V, key: K) => void): void {
+        this.delegate.forEach((valueWrapper: ValueWrapper<V>, key: K) => {
+            cb(valueWrapper.value, key)
+        })
+    }
+
+    private createTimeout(key: K, value: V): NodeJS.Timeout {
+        return setTimeout(() => {
+            this.delete(key)
+        }, this.getTtl(value))
+    }
+}

package/src/helpers/createPeerDescriptor.ts

@@ -0,0 +1,57 @@
+import {
+    createSignature,
+    hash
+} from '@streamr/utils'
+import crypto from 'crypto'
+import { isBrowserEnvironment } from '../helpers/browser/isBrowserEnvironment'
+import { createPeerDescriptorSignaturePayload } from '../helpers/createPeerDescriptorSignaturePayload'
+import { DhtAddress, DhtAddressRaw, getRawFromDhtAddress } from '../identifiers'
+import {
+    ConnectivityResponse,
+    NodeType,
+    PeerDescriptor
+} from '../proto/packages/dht/protos/DhtRpc'
+
+const calculateNodeIdRaw = (ipAddress: number, privateKey: Uint8Array): DhtAddressRaw => {
+    // nodeId is calculated as 
+    // concatenate(
+    //   get104leastSignificatBits(hash(ipAddress)), 
+    //   get56leastSignificatBits(sign(ipAddress))
+    // )
+    const ipAsBuffer = Buffer.alloc(4)
+    ipAsBuffer.writeUInt32BE(ipAddress)
+    const ipHash = hash(ipAsBuffer)
+    const signature = createSignature(ipAsBuffer, privateKey)
+    const nodeIdRaw = Buffer.concat([
+        ipHash.subarray(ipHash.length - 13, ipHash.length),
+        signature.subarray(signature.length - 7, signature.length)
+    ])
+    return nodeIdRaw
+}
+
+export const createPeerDescriptor = (connectivityResponse: ConnectivityResponse, region: number, nodeId?: DhtAddress): PeerDescriptor => {
+    const privateKey = crypto.randomBytes(32)
+    const publicKey = crypto.randomBytes(20)  // TODO calculate publicKey from privateKey
+    let nodeIdRaw: DhtAddressRaw
+    if (nodeId !== undefined) {
+        nodeIdRaw = getRawFromDhtAddress(nodeId)
+    } else {
+        nodeIdRaw = calculateNodeIdRaw(connectivityResponse.ipAddress, privateKey)
+    }
+    const ret: PeerDescriptor = {
+        nodeId: nodeIdRaw,
+        type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
+        ipAddress: connectivityResponse.ipAddress,
+        region,
+        publicKey 
+    }
+    if (connectivityResponse.websocket) {
+        ret.websocket = {
+            host: connectivityResponse.websocket.host,
+            port: connectivityResponse.websocket.port,
+            tls: connectivityResponse.websocket.tls
+        }
+    }
+    ret.signature = createSignature(createPeerDescriptorSignaturePayload(ret), privateKey)
+    return ret
+}

package/src/helpers/createPeerDescriptorSignaturePayload.ts

@@ -0,0 +1,28 @@
+import { ConnectivityMethod, PeerDescriptor } from '../proto/packages/dht/protos/DhtRpc'
+
+function convertUnsignedIntegerToBuffer(number: number): Buffer {
+    const buffer = Buffer.alloc(4)
+    buffer.writeUInt32BE(number)
+    return buffer
+}
+
+export const createPeerDescriptorSignaturePayload = (peerDescriptor: PeerDescriptor): Uint8Array => {
+    const separator = Buffer.from(',')
+    const buffers = [
+        peerDescriptor.type !== undefined ? convertUnsignedIntegerToBuffer(peerDescriptor.type) : new Uint8Array(0),
+        separator,
+        peerDescriptor.udp !== undefined ? ConnectivityMethod.toBinary(peerDescriptor.udp) : new Uint8Array(0),
+        separator,
+        peerDescriptor.tcp !== undefined ? ConnectivityMethod.toBinary(peerDescriptor.tcp) : new Uint8Array(0),
+        separator,
+        peerDescriptor.websocket !== undefined ? ConnectivityMethod.toBinary(peerDescriptor.websocket) : new Uint8Array(0),
+        separator,
+        peerDescriptor.region !== undefined ? convertUnsignedIntegerToBuffer(peerDescriptor.region) : new Uint8Array(0),
+        separator,
+        peerDescriptor.ipAddress !== undefined ? convertUnsignedIntegerToBuffer(peerDescriptor.ipAddress) : new Uint8Array(0),
+        separator,
+        peerDescriptor.publicKey !== undefined ? Buffer.from(peerDescriptor.publicKey) : new Uint8Array(0)
+    ]
+    return Buffer.concat(buffers)
+}
+

package/src/helpers/offering.ts

@@ -0,0 +1,15 @@
+import crypto from 'crypto'
+import { DhtAddress } from '../identifiers'
+
+type Offerer = 'local' | 'remote'
+
+export const getOfferer = (localNodeId: DhtAddress, remoteNodeId: DhtAddress): Offerer => {
+    return getOfferingHash(localNodeId + ',' + remoteNodeId) < getOfferingHash(remoteNodeId + ',' + localNodeId)
+        ? 'local'
+        : 'remote'
+}
+
+const getOfferingHash = (idPair: string): number => {
+    const buffer = crypto.createHash('md5').update(idPair).digest()
+    return buffer.readInt32LE(0)
+}

package/src/helpers/protoClasses.ts

@@ -13,12 +13,11 @@ import {
     PeerDescriptor, 
     PingRequest, 
     PingResponse, 
-    FindResponse, 
-    FindRequest, 
+    RecursiveOperationResponse, 
+    RecursiveOperationRequest, 
     RouteMessageAck, 
     RouteMessageWrapper,
     WebsocketConnectionRequest,
-    WebsocketConnectionResponse,
     WebrtcConnectionRequest,
     RtcOffer,
     RtcAnswer,
@@ -32,8 +31,8 @@ import {
 export const protoClasses: Array<IMessageType<any>> = [
     ClosestPeersRequest,
     ClosestPeersResponse,
-    FindRequest,
-    FindResponse,
+    RecursiveOperationRequest,
+    RecursiveOperationResponse,
     PingRequest,
     PingResponse,
     LeaveNotice,
@@ -48,7 +47,6 @@ export const protoClasses: Array<IMessageType<any>> = [
     HandshakeResponse,
     Message,
     WebsocketConnectionRequest,
-    WebsocketConnectionResponse,
     WebrtcConnectionRequest,
     RtcOffer,
     RtcAnswer,

package/src/helpers/version.ts

@@ -0,0 +1,32 @@
+export const LOCAL_PROTOCOL_VERSION = '1.0'
+
+/*
+ * When two nodes negotiate whether they are compatible or not, it is up to the
+ * newer version to decide if it supports the old version or not.
+ * 
+ * The older version assumes optimistically that it may be supported by the newer
+ * version. It can't know for sure, but the other node will tell if it is not
+ * supported (e.g. rejecting the handshake with UNSUPPORTED_VERSION error).
+ */
+export const isMaybeSupportedVersion = (remoteVersion: string): boolean => {
+    const localMajor = parseVersion(LOCAL_PROTOCOL_VERSION)!.major
+    const remoteMajor = parseVersion(remoteVersion)?.major
+    if ((remoteMajor === undefined) || (remoteMajor < localMajor)) {
+        return false
+    } else {
+        // TODO implement proper checking when there are new protocol versions
+        return true
+    }
+}
+
+export const parseVersion = (version: string): { major: number, minor: number } | undefined => {
+    const parts = version.split('.')
+    if (parts.length === 2) {
+        const values = parts.map((p) => Number(p))
+        if (!values.some((v) => isNaN(v))) {
+            return { major: values[0], minor: values[1] }
+        }
+    } else {
+        return undefined
+    }
+}

package/src/identifiers.ts

@@ -0,0 +1,29 @@
+import { BrandedString, areEqualBinaries, binaryToHex, hexToBinary } from '@streamr/utils'
+import crypto from 'crypto'
+import { PeerDescriptor } from './proto/packages/dht/protos/DhtRpc'
+
+// https://www.scs.stanford.edu/~dm/home/papers/kpos.pdf
+export const KADEMLIA_ID_LENGTH_IN_BYTES = 20
+
+export type DhtAddress = BrandedString<'DhtAddress'>
+export type DhtAddressRaw = Uint8Array
+
+export const getDhtAddressFromRaw = (raw: DhtAddressRaw): DhtAddress => {
+    return binaryToHex(raw) as unknown as DhtAddress
+}
+
+export const getRawFromDhtAddress = (address: DhtAddress): DhtAddressRaw => {
+    return hexToBinary(address) as unknown as DhtAddressRaw
+}
+
+export const getNodeIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): DhtAddress => {
+    return getDhtAddressFromRaw(peerDescriptor.nodeId)
+}
+
+export const areEqualPeerDescriptors = (peerDescriptor1: PeerDescriptor, peerDescriptor2: PeerDescriptor): boolean => {
+    return areEqualBinaries(peerDescriptor1.nodeId, peerDescriptor2.nodeId)
+}
+
+export const createRandomDhtAddress = (): DhtAddress => {
+    return getDhtAddressFromRaw(crypto.randomBytes(KADEMLIA_ID_LENGTH_IN_BYTES))
+}

package/src/proto/google/protobuf/any.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/any.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //
@@ -39,7 +39,6 @@ import type { IBinaryReader } from "@protobuf-ts/runtime";
 import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { isJsonObject } from "@protobuf-ts/runtime";
 import { typeofJsonValue } from "@protobuf-ts/runtime";
 import type { JsonValue } from "@protobuf-ts/runtime";
@@ -272,8 +271,9 @@ class Any$Type extends MessageType<Any> {
         return name;
     }
     create(value?: PartialMessage<Any>): Any {
-        const message = { typeUrl: "", value: new Uint8Array(0) };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.typeUrl = "";
+        message.value = new Uint8Array(0);
         if (value !== undefined)
             reflectionMergePartial<Any>(this, message, value);
         return message;

package/src/proto/google/protobuf/empty.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/empty.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //
@@ -39,7 +39,6 @@ import type { BinaryReadOptions } from "@protobuf-ts/runtime";
 import type { IBinaryReader } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
 /**
  * A generic empty message that you can re-use to avoid defining duplicated
@@ -62,8 +61,7 @@ class Empty$Type extends MessageType<Empty> {
         super("google.protobuf.Empty", []);
     }
     create(value?: PartialMessage<Empty>): Empty {
-        const message = {};
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        const message = globalThis.Object.create((this.messagePrototype!));
         if (value !== undefined)
             reflectionMergePartial<Empty>(this, message, value);
         return message;

package/src/proto/google/protobuf/timestamp.ts

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/timestamp.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //
@@ -40,7 +40,6 @@ import type { IBinaryReader } from "@protobuf-ts/runtime";
 import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { typeofJsonValue } from "@protobuf-ts/runtime";
 import type { JsonValue } from "@protobuf-ts/runtime";
 import type { JsonReadOptions } from "@protobuf-ts/runtime";
@@ -234,8 +233,9 @@ class Timestamp$Type extends MessageType<Timestamp> {
         return target;
     }
     create(value?: PartialMessage<Timestamp>): Timestamp {
-        const message = { seconds: 0, nanos: 0 };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.seconds = 0;
+        message.nanos = 0;
         if (value !== undefined)
             reflectionMergePartial<Timestamp>(this, message, value);
         return message;

package/src/proto/packages/dht/protos/DhtRpc.client.ts

@@ -1,13 +1,12 @@
-// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "packages/dht/protos/DhtRpc.proto" (package "dht", syntax proto3)
 // tslint:disable
 import { ExternalApiRpc } from "./DhtRpc";
 import type { ExternalStoreDataResponse } from "./DhtRpc";
 import type { ExternalStoreDataRequest } from "./DhtRpc";
-import type { ExternalFindDataResponse } from "./DhtRpc";
-import type { ExternalFindDataRequest } from "./DhtRpc";
+import type { ExternalFetchDataResponse } from "./DhtRpc";
+import type { ExternalFetchDataRequest } from "./DhtRpc";
 import { ConnectionLockRpc } from "./DhtRpc";
-import type { DisconnectNoticeResponse } from "./DhtRpc";
 import type { DisconnectNotice } from "./DhtRpc";
 import type { UnlockRequest } from "./DhtRpc";
 import type { LockResponse } from "./DhtRpc";
@@ -18,18 +17,14 @@ import type { RtcAnswer } from "./DhtRpc";
 import type { RtcOffer } from "./DhtRpc";
 import type { WebrtcConnectionRequest } from "./DhtRpc";
 import { WebsocketConnectorRpc } from "./DhtRpc";
-import type { WebsocketConnectionResponse } from "./DhtRpc";
 import type { WebsocketConnectionRequest } from "./DhtRpc";
-import { FindSessionRpc } from "./DhtRpc";
-import type { FindResponse } from "./DhtRpc";
+import { RecursiveOperationSessionRpc } from "./DhtRpc";
+import type { RecursiveOperationResponse } from "./DhtRpc";
 import { StoreRpc } from "./DhtRpc";
-import type { DeleteDataResponse } from "./DhtRpc";
-import type { DeleteDataRequest } from "./DhtRpc";
-import type { MigrateDataResponse } from "./DhtRpc";
-import type { MigrateDataRequest } from "./DhtRpc";
+import type { ReplicateDataRequest } from "./DhtRpc";
 import type { StoreDataResponse } from "./DhtRpc";
 import type { StoreDataRequest } from "./DhtRpc";
-import { FindRpc } from "./DhtRpc";
+import { RecursiveOperationRpc } from "./DhtRpc";
 import { RouterRpc } from "./DhtRpc";
 import type { RouteMessageAck } from "./DhtRpc";
 import type { RouteMessageWrapper } from "./DhtRpc";
@@ -40,6 +35,8 @@ import type { Empty } from "../../../google/protobuf/empty";
 import type { LeaveNotice } from "./DhtRpc";
 import type { PingResponse } from "./DhtRpc";
 import type { PingRequest } from "./DhtRpc";
+import type { ClosestRingPeersResponse } from "./DhtRpc";
+import type { ClosestRingPeersRequest } from "./DhtRpc";
 import { stackIntercept } from "@protobuf-ts/runtime-rpc";
 import type { ClosestPeersResponse } from "./DhtRpc";
 import type { ClosestPeersRequest } from "./DhtRpc";
@@ -53,6 +50,10 @@ export interface IDhtNodeRpcClient {
      * @generated from protobuf rpc: getClosestPeers(dht.ClosestPeersRequest) returns (dht.ClosestPeersResponse);
      */
     getClosestPeers(input: ClosestPeersRequest, options?: RpcOptions): UnaryCall<ClosestPeersRequest, ClosestPeersResponse>;
+    /**
+     * @generated from protobuf rpc: getClosestRingPeers(dht.ClosestRingPeersRequest) returns (dht.ClosestRingPeersResponse);
+     */
+    getClosestRingPeers(input: ClosestRingPeersRequest, options?: RpcOptions): UnaryCall<ClosestRingPeersRequest, ClosestRingPeersResponse>;
     /**
      * @generated from protobuf rpc: ping(dht.PingRequest) returns (dht.PingResponse);
      */
@@ -78,18 +79,25 @@ export class DhtNodeRpcClient implements IDhtNodeRpcClient, ServiceInfo {
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
         return stackIntercept<ClosestPeersRequest, ClosestPeersResponse>("unary", this._transport, method, opt, input);
     }
+    /**
+     * @generated from protobuf rpc: getClosestRingPeers(dht.ClosestRingPeersRequest) returns (dht.ClosestRingPeersResponse);
+     */
+    getClosestRingPeers(input: ClosestRingPeersRequest, options?: RpcOptions): UnaryCall<ClosestRingPeersRequest, ClosestRingPeersResponse> {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ClosestRingPeersRequest, ClosestRingPeersResponse>("unary", this._transport, method, opt, input);
+    }
     /**
      * @generated from protobuf rpc: ping(dht.PingRequest) returns (dht.PingResponse);
      */
     ping(input: PingRequest, options?: RpcOptions): UnaryCall<PingRequest, PingResponse> {
-        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        const method = this.methods[2], opt = this._transport.mergeOptions(options);
         return stackIntercept<PingRequest, PingResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: leaveNotice(dht.LeaveNotice) returns (google.protobuf.Empty);
      */
     leaveNotice(input: LeaveNotice, options?: RpcOptions): UnaryCall<LeaveNotice, Empty> {
-        const method = this.methods[2], opt = this._transport.mergeOptions(options);
+        const method = this.methods[3], opt = this._transport.mergeOptions(options);
         return stackIntercept<LeaveNotice, Empty>("unary", this._transport, method, opt, input);
     }
 }
@@ -131,27 +139,27 @@ export class RouterRpcClient implements IRouterRpcClient, ServiceInfo {
     }
 }
 /**
- * @generated from protobuf service dht.FindRpc
+ * @generated from protobuf service dht.RecursiveOperationRpc
  */
-export interface IFindRpcClient {
+export interface IRecursiveOperationRpcClient {
     /**
-     * @generated from protobuf rpc: routeFindRequest(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
+     * @generated from protobuf rpc: routeRequest(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
      */
-    routeFindRequest(input: RouteMessageWrapper, options?: RpcOptions): UnaryCall<RouteMessageWrapper, RouteMessageAck>;
+    routeRequest(input: RouteMessageWrapper, options?: RpcOptions): UnaryCall<RouteMessageWrapper, RouteMessageAck>;
 }
 /**
- * @generated from protobuf service dht.FindRpc
+ * @generated from protobuf service dht.RecursiveOperationRpc
  */
-export class FindRpcClient implements IFindRpcClient, ServiceInfo {
-    typeName = FindRpc.typeName;
-    methods = FindRpc.methods;
-    options = FindRpc.options;
+export class RecursiveOperationRpcClient implements IRecursiveOperationRpcClient, ServiceInfo {
+    typeName = RecursiveOperationRpc.typeName;
+    methods = RecursiveOperationRpc.methods;
+    options = RecursiveOperationRpc.options;
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
-     * @generated from protobuf rpc: routeFindRequest(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
+     * @generated from protobuf rpc: routeRequest(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
      */
-    routeFindRequest(input: RouteMessageWrapper, options?: RpcOptions): UnaryCall<RouteMessageWrapper, RouteMessageAck> {
+    routeRequest(input: RouteMessageWrapper, options?: RpcOptions): UnaryCall<RouteMessageWrapper, RouteMessageAck> {
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
         return stackIntercept<RouteMessageWrapper, RouteMessageAck>("unary", this._transport, method, opt, input);
     }
@@ -165,13 +173,9 @@ export interface IStoreRpcClient {
      */
     storeData(input: StoreDataRequest, options?: RpcOptions): UnaryCall<StoreDataRequest, StoreDataResponse>;
     /**
-     * @generated from protobuf rpc: migrateData(dht.MigrateDataRequest) returns (dht.MigrateDataResponse);
-     */
-    migrateData(input: MigrateDataRequest, options?: RpcOptions): UnaryCall<MigrateDataRequest, MigrateDataResponse>;
-    /**
-     * @generated from protobuf rpc: deleteData(dht.DeleteDataRequest) returns (dht.DeleteDataResponse);
+     * @generated from protobuf rpc: replicateData(dht.ReplicateDataRequest) returns (google.protobuf.Empty);
      */
-    deleteData(input: DeleteDataRequest, options?: RpcOptions): UnaryCall<DeleteDataRequest, DeleteDataResponse>;
+    replicateData(input: ReplicateDataRequest, options?: RpcOptions): UnaryCall<ReplicateDataRequest, Empty>;
 }
 /**
  * @generated from protobuf service dht.StoreRpc
@@ -190,44 +194,37 @@ export class StoreRpcClient implements IStoreRpcClient, ServiceInfo {
         return stackIntercept<StoreDataRequest, StoreDataResponse>("unary", this._transport, method, opt, input);
     }
     /**
-     * @generated from protobuf rpc: migrateData(dht.MigrateDataRequest) returns (dht.MigrateDataResponse);
+     * @generated from protobuf rpc: replicateData(dht.ReplicateDataRequest) returns (google.protobuf.Empty);
      */
-    migrateData(input: MigrateDataRequest, options?: RpcOptions): UnaryCall<MigrateDataRequest, MigrateDataResponse> {
+    replicateData(input: ReplicateDataRequest, options?: RpcOptions): UnaryCall<ReplicateDataRequest, Empty> {
         const method = this.methods[1], opt = this._transport.mergeOptions(options);
-        return stackIntercept<MigrateDataRequest, MigrateDataResponse>("unary", this._transport, method, opt, input);
-    }
-    /**
-     * @generated from protobuf rpc: deleteData(dht.DeleteDataRequest) returns (dht.DeleteDataResponse);
-     */
-    deleteData(input: DeleteDataRequest, options?: RpcOptions): UnaryCall<DeleteDataRequest, DeleteDataResponse> {
-        const method = this.methods[2], opt = this._transport.mergeOptions(options);
-        return stackIntercept<DeleteDataRequest, DeleteDataResponse>("unary", this._transport, method, opt, input);
+        return stackIntercept<ReplicateDataRequest, Empty>("unary", this._transport, method, opt, input);
     }
 }
 /**
- * @generated from protobuf service dht.FindSessionRpc
+ * @generated from protobuf service dht.RecursiveOperationSessionRpc
  */
-export interface IFindSessionRpcClient {
+export interface IRecursiveOperationSessionRpcClient {
     /**
-     * @generated from protobuf rpc: sendFindResponse(dht.FindResponse) returns (google.protobuf.Empty);
+     * @generated from protobuf rpc: sendResponse(dht.RecursiveOperationResponse) returns (google.protobuf.Empty);
      */
-    sendFindResponse(input: FindResponse, options?: RpcOptions): UnaryCall<FindResponse, Empty>;
+    sendResponse(input: RecursiveOperationResponse, options?: RpcOptions): UnaryCall<RecursiveOperationResponse, Empty>;
 }
 /**
- * @generated from protobuf service dht.FindSessionRpc
+ * @generated from protobuf service dht.RecursiveOperationSessionRpc
  */
-export class FindSessionRpcClient implements IFindSessionRpcClient, ServiceInfo {
-    typeName = FindSessionRpc.typeName;
-    methods = FindSessionRpc.methods;
-    options = FindSessionRpc.options;
+export class RecursiveOperationSessionRpcClient implements IRecursiveOperationSessionRpcClient, ServiceInfo {
+    typeName = RecursiveOperationSessionRpc.typeName;
+    methods = RecursiveOperationSessionRpc.methods;
+    options = RecursiveOperationSessionRpc.options;
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
-     * @generated from protobuf rpc: sendFindResponse(dht.FindResponse) returns (google.protobuf.Empty);
+     * @generated from protobuf rpc: sendResponse(dht.RecursiveOperationResponse) returns (google.protobuf.Empty);
      */
-    sendFindResponse(input: FindResponse, options?: RpcOptions): UnaryCall<FindResponse, Empty> {
+    sendResponse(input: RecursiveOperationResponse, options?: RpcOptions): UnaryCall<RecursiveOperationResponse, Empty> {
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
-        return stackIntercept<FindResponse, Empty>("unary", this._transport, method, opt, input);
+        return stackIntercept<RecursiveOperationResponse, Empty>("unary", this._transport, method, opt, input);
     }
 }
 /**
@@ -235,9 +232,9 @@ export class FindSessionRpcClient implements IFindSessionRpcClient, ServiceInfo
  */
 export interface IWebsocketConnectorRpcClient {
     /**
-     * @generated from protobuf rpc: requestConnection(dht.WebsocketConnectionRequest) returns (dht.WebsocketConnectionResponse);
+     * @generated from protobuf rpc: requestConnection(dht.WebsocketConnectionRequest) returns (google.protobuf.Empty);
      */
-    requestConnection(input: WebsocketConnectionRequest, options?: RpcOptions): UnaryCall<WebsocketConnectionRequest, WebsocketConnectionResponse>;
+    requestConnection(input: WebsocketConnectionRequest, options?: RpcOptions): UnaryCall<WebsocketConnectionRequest, Empty>;
 }
 /**
  * @generated from protobuf service dht.WebsocketConnectorRpc
@@ -249,11 +246,11 @@ export class WebsocketConnectorRpcClient implements IWebsocketConnectorRpcClient
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
-     * @generated from protobuf rpc: requestConnection(dht.WebsocketConnectionRequest) returns (dht.WebsocketConnectionResponse);
+     * @generated from protobuf rpc: requestConnection(dht.WebsocketConnectionRequest) returns (google.protobuf.Empty);
      */
-    requestConnection(input: WebsocketConnectionRequest, options?: RpcOptions): UnaryCall<WebsocketConnectionRequest, WebsocketConnectionResponse> {
+    requestConnection(input: WebsocketConnectionRequest, options?: RpcOptions): UnaryCall<WebsocketConnectionRequest, Empty> {
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
-        return stackIntercept<WebsocketConnectionRequest, WebsocketConnectionResponse>("unary", this._transport, method, opt, input);
+        return stackIntercept<WebsocketConnectionRequest, Empty>("unary", this._transport, method, opt, input);
     }
 }
 /**
@@ -328,9 +325,9 @@ export interface IConnectionLockRpcClient {
      */
     unlockRequest(input: UnlockRequest, options?: RpcOptions): UnaryCall<UnlockRequest, Empty>;
     /**
-     * @generated from protobuf rpc: gracefulDisconnect(dht.DisconnectNotice) returns (dht.DisconnectNoticeResponse);
+     * @generated from protobuf rpc: gracefulDisconnect(dht.DisconnectNotice) returns (google.protobuf.Empty);
      */
-    gracefulDisconnect(input: DisconnectNotice, options?: RpcOptions): UnaryCall<DisconnectNotice, DisconnectNoticeResponse>;
+    gracefulDisconnect(input: DisconnectNotice, options?: RpcOptions): UnaryCall<DisconnectNotice, Empty>;
 }
 /**
  * @generated from protobuf service dht.ConnectionLockRpc
@@ -356,11 +353,11 @@ export class ConnectionLockRpcClient implements IConnectionLockRpcClient, Servic
         return stackIntercept<UnlockRequest, Empty>("unary", this._transport, method, opt, input);
     }
     /**
-     * @generated from protobuf rpc: gracefulDisconnect(dht.DisconnectNotice) returns (dht.DisconnectNoticeResponse);
+     * @generated from protobuf rpc: gracefulDisconnect(dht.DisconnectNotice) returns (google.protobuf.Empty);
      */
-    gracefulDisconnect(input: DisconnectNotice, options?: RpcOptions): UnaryCall<DisconnectNotice, DisconnectNoticeResponse> {
+    gracefulDisconnect(input: DisconnectNotice, options?: RpcOptions): UnaryCall<DisconnectNotice, Empty> {
         const method = this.methods[2], opt = this._transport.mergeOptions(options);
-        return stackIntercept<DisconnectNotice, DisconnectNoticeResponse>("unary", this._transport, method, opt, input);
+        return stackIntercept<DisconnectNotice, Empty>("unary", this._transport, method, opt, input);
     }
 }
 /**
@@ -368,9 +365,9 @@ export class ConnectionLockRpcClient implements IConnectionLockRpcClient, Servic
  */
 export interface IExternalApiRpcClient {
     /**
-     * @generated from protobuf rpc: externalFindData(dht.ExternalFindDataRequest) returns (dht.ExternalFindDataResponse);
+     * @generated from protobuf rpc: externalFetchData(dht.ExternalFetchDataRequest) returns (dht.ExternalFetchDataResponse);
      */
-    externalFindData(input: ExternalFindDataRequest, options?: RpcOptions): UnaryCall<ExternalFindDataRequest, ExternalFindDataResponse>;
+    externalFetchData(input: ExternalFetchDataRequest, options?: RpcOptions): UnaryCall<ExternalFetchDataRequest, ExternalFetchDataResponse>;
     /**
      * @generated from protobuf rpc: externalStoreData(dht.ExternalStoreDataRequest) returns (dht.ExternalStoreDataResponse);
      */
@@ -386,11 +383,11 @@ export class ExternalApiRpcClient implements IExternalApiRpcClient, ServiceInfo
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
-     * @generated from protobuf rpc: externalFindData(dht.ExternalFindDataRequest) returns (dht.ExternalFindDataResponse);
+     * @generated from protobuf rpc: externalFetchData(dht.ExternalFetchDataRequest) returns (dht.ExternalFetchDataResponse);
      */
-    externalFindData(input: ExternalFindDataRequest, options?: RpcOptions): UnaryCall<ExternalFindDataRequest, ExternalFindDataResponse> {
+    externalFetchData(input: ExternalFetchDataRequest, options?: RpcOptions): UnaryCall<ExternalFetchDataRequest, ExternalFetchDataResponse> {
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
-        return stackIntercept<ExternalFindDataRequest, ExternalFindDataResponse>("unary", this._transport, method, opt, input);
+        return stackIntercept<ExternalFetchDataRequest, ExternalFetchDataResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: externalStoreData(dht.ExternalStoreDataRequest) returns (dht.ExternalStoreDataResponse);