@streamr/dht 0.0.1-tatum.7 → 100.0.0-pretestnet.0

package/src/dht/routing/RoutingSession.ts

@@ -6,9 +6,9 @@ import { Logger } from '@streamr/utils'
 import EventEmitter from 'eventemitter3'
 import { v4 } from 'uuid'
 import { PeerDescriptor, RouteMessageWrapper } from '../../proto/packages/dht/protos/DhtRpc'
-import { RemoteRouter } from './RemoteRouter'
+import { RouterRpcRemote } from './RouterRpcRemote'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
-import { RoutingServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { RouterRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { Contact } from '../contact/Contact'
 
@@ -18,19 +18,19 @@ const MAX_FAILED_HOPS = 2
 
 class RemoteContact extends Contact {
 
-    private router: RemoteRouter
+    private router: RouterRpcRemote
 
     constructor(peer: RemoteDhtNode, ownPeerDescriptor: PeerDescriptor, rpcCommunicator: RoutingRpcCommunicator) {
         super(peer.getPeerDescriptor())
-        this.router = new RemoteRouter(
+        this.router = new RouterRpcRemote(
             ownPeerDescriptor,
             peer.getPeerDescriptor(),
             peer.getServiceId(),
-            toProtoRpcClient(new RoutingServiceClient(rpcCommunicator.getRpcClientTransport()))
+            toProtoRpcClient(new RouterRpcClient(rpcCommunicator.getRpcClientTransport()))
         )
     }
 
-    getRouter(): RemoteRouter {
+    getRouter(): RouterRpcRemote {
         return this.router
     }
 }

package/src/dht/store/{DataStore.ts → StoreRpcLocal.ts}

@@ -7,14 +7,14 @@ import { Any } from '../../proto/google/protobuf/any'
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { DhtCallContext } from '../../rpc-protocol/DhtCallContext'
 import { toProtoRpcClient } from '@streamr/proto-rpc'
-import { StoreServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { StoreRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { RoutingRpcCommunicator } from '../../transport/RoutingRpcCommunicator'
 import { IRecursiveFinder } from '../find/RecursiveFinder'
 import { areEqualPeerDescriptors, keyFromPeerDescriptor, peerIdFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 import { Logger } from '@streamr/utils'
 import { LocalDataStore } from './LocalDataStore'
-import { IStoreService } from '../../proto/packages/dht/protos/DhtRpc.server'
-import { RemoteStore } from './RemoteStore'
+import { IStoreRpc } from '../../proto/packages/dht/protos/DhtRpc.server'
+import { StoreRpcRemote } from './StoreRpcRemote'
 import { Timestamp } from '../../proto/google/protobuf/timestamp'
 import EventEmitter from 'eventemitter3'
 import { Events } from '../DhtNode'
@@ -30,14 +30,14 @@ interface DataStoreConfig {
     serviceId: string
     maxTtl: number
     highestTtl: number
-    numberOfCopies: number
+    redundancyFactor: number
     dhtNodeEmitter: EventEmitter<Events>
     getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => RemoteDhtNode[]
 }
 
 const logger = new Logger(module)
 
-export class DataStore implements IStoreService {
+export class StoreRpcLocal implements IStoreRpc {
 
     private readonly rpcCommunicator: RoutingRpcCommunicator
     private readonly recursiveFinder: IRecursiveFinder
@@ -46,7 +46,7 @@ export class DataStore implements IStoreService {
     private readonly serviceId: string
     private readonly maxTtl: number
     private readonly highestTtl: number
-    private readonly numberOfCopies: number
+    private readonly redundancyFactor: number
     private readonly dhtNodeEmitter: EventEmitter<Events>
     private readonly getNodesClosestToIdFromBucket: (id: Uint8Array, n?: number) => RemoteDhtNode[]
 
@@ -58,7 +58,7 @@ export class DataStore implements IStoreService {
         this.serviceId = config.serviceId
         this.maxTtl = config.maxTtl
         this.highestTtl = config.highestTtl
-        this.numberOfCopies = config.numberOfCopies
+        this.redundancyFactor = config.redundancyFactor
         this.dhtNodeEmitter = config.dhtNodeEmitter
         this.getNodesClosestToIdFromBucket = config.getNodesClosestToIdFromBucket
         this.rpcCommunicator.registerRpcMethod(StoreDataRequest, StoreDataResponse, 'storeData',
@@ -114,10 +114,10 @@ export class DataStore implements IStoreService {
             }
         }
 
-        // if new node is within the storeNumberOfCopies closest nodes to the data
+        // if new node is within the storageRedundancyFactor closest nodes to the data
         // do migrate data to it
 
-        if (index < this.numberOfCopies) {
+        if (index < this.redundancyFactor) {
             this.localDataStore.setStale(dataId, dataEntry.storer!, false)
             return true
         } else {
@@ -127,19 +127,19 @@ export class DataStore implements IStoreService {
     }
 
     private async migrateDataToContact(dataEntry: DataEntry, contact: PeerDescriptor, doNotConnect: boolean = false): Promise<void> {
-        const remoteStore = new RemoteStore(
+        const rpcRemote = new StoreRpcRemote(
             this.ownPeerDescriptor,
             contact,
             this.serviceId,
-            toProtoRpcClient(new StoreServiceClient(this.rpcCommunicator.getRpcClientTransport()))
+            toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport()))
         )
         try {
-            const response = await remoteStore.migrateData({ dataEntry }, doNotConnect)
+            const response = await rpcRemote.migrateData({ dataEntry }, doNotConnect)
             if (response.error) {
-                logger.trace('RemoteStore::migrateData() returned error: ' + response.error)
+                logger.trace('migrateData() returned error: ' + response.error)
             }
         } catch (e) {
-            logger.trace('RemoteStore::migrateData() threw an exception ' + e)
+            logger.trace('migrateData() threw an exception ' + e)
         }
     }
 
@@ -150,7 +150,7 @@ export class DataStore implements IStoreService {
         const successfulNodes: PeerDescriptor[] = []
         const ttl = this.highestTtl // ToDo: make TTL decrease according to some nice curve
         const storerTime = Timestamp.now()
-        for (let i = 0; i < closestNodes.length && successfulNodes.length < this.numberOfCopies; i++) {
+        for (let i = 0; i < closestNodes.length && successfulNodes.length < this.redundancyFactor; i++) {
             if (areEqualPeerDescriptors(this.ownPeerDescriptor, closestNodes[i])) {
                 this.localDataStore.storeEntry({
                     kademliaId: key, 
@@ -165,22 +165,22 @@ export class DataStore implements IStoreService {
                 successfulNodes.push(closestNodes[i])
                 continue
             }
-            const remoteStore = new RemoteStore(
+            const rpcRemote = new StoreRpcRemote(
                 this.ownPeerDescriptor,
                 closestNodes[i],
                 this.serviceId,
-                toProtoRpcClient(new StoreServiceClient(this.rpcCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport()))
             )
             try {
-                const response = await remoteStore.storeData({ kademliaId: key, data, ttl, storerTime })
+                const response = await rpcRemote.storeData({ kademliaId: key, data, ttl, storerTime })
                 if (!response.error) {
                     successfulNodes.push(closestNodes[i])
-                    logger.trace('remoteStore.storeData() returned success')
+                    logger.trace('remote.storeData() returned success')
                 } else {
-                    logger.trace('remoteStore.storeData() returned error: ' + response.error)
+                    logger.trace('remote.storeData() returned error: ' + response.error)
                 }
             } catch (e) {
-                logger.trace('remoteStore.storeData() threw an exception ' + e)
+                logger.trace('remote.storeData() threw an exception ' + e)
             }
         }
         return successfulNodes
@@ -188,8 +188,8 @@ export class DataStore implements IStoreService {
 
     private selfIsOneOfClosestPeers(dataId: Uint8Array): boolean {
         const ownPeerId = PeerID.fromValue(this.ownPeerDescriptor.kademliaId)
-        const closestPeers = this.getNodesClosestToIdFromBucket(dataId, this.numberOfCopies)
-        const sortedList = new SortedContactList<Contact>(ownPeerId, this.numberOfCopies, undefined, true)
+        const closestPeers = this.getNodesClosestToIdFromBucket(dataId, this.redundancyFactor)
+        const sortedList = new SortedContactList<Contact>(ownPeerId, this.redundancyFactor, undefined, true)
         sortedList.addContact(new Contact(this.ownPeerDescriptor))
         closestPeers.forEach((con) => sortedList.addContact(new Contact(con.getPeerDescriptor())))
         return sortedList.getClosestContacts().some((node) => node.getPeerId().equals(ownPeerId))
@@ -200,28 +200,28 @@ export class DataStore implements IStoreService {
         const result = await this.recursiveFinder.startRecursiveFind(key)
         const closestNodes = result.closestNodes
         const successfulNodes: PeerDescriptor[] = []
-        for (let i = 0; i < closestNodes.length && successfulNodes.length < this.numberOfCopies; i++) {
+        for (let i = 0; i < closestNodes.length && successfulNodes.length < this.redundancyFactor; i++) {
             if (areEqualPeerDescriptors(this.ownPeerDescriptor, closestNodes[i])) {
                 this.localDataStore.markAsDeleted(key, peerIdFromPeerDescriptor(this.ownPeerDescriptor))
                 successfulNodes.push(closestNodes[i])
                 continue
             }
-            const remoteStore = new RemoteStore(
+            const rpcRemote = new StoreRpcRemote(
                 this.ownPeerDescriptor,
                 closestNodes[i],
                 this.serviceId,
-                toProtoRpcClient(new StoreServiceClient(this.rpcCommunicator.getRpcClientTransport()))
+                toProtoRpcClient(new StoreRpcClient(this.rpcCommunicator.getRpcClientTransport()))
             )
             try {
-                const response = await remoteStore.deleteData({ kademliaId: key })
+                const response = await rpcRemote.deleteData({ kademliaId: key })
                 if (response.deleted) {
-                    logger.trace('remoteStore.deleteData() returned success')
+                    logger.trace('remote.deleteData() returned success')
                 } else {
                     logger.trace('could not delete data from ' + keyFromPeerDescriptor(closestNodes[i]))
                 }
                 successfulNodes.push(closestNodes[i])
             } catch (e) {
-                logger.trace('remoteStore.deleteData() threw an exception ' + e)
+                logger.trace('remote.deleteData() threw an exception ' + e)
             }
         }
     }
@@ -283,7 +283,7 @@ export class DataStore implements IStoreService {
         const incomingPeerId = PeerID.fromValue(incomingPeer.kademliaId)
         const closestToData = this.getNodesClosestToIdFromBucket(dataEntry.kademliaId, 10)
 
-        const sortedList = new SortedContactList<Contact>(dataId, this.numberOfCopies, undefined, true)
+        const sortedList = new SortedContactList<Contact>(dataId, this.redundancyFactor, undefined, true)
         sortedList.addContact(new Contact(this.ownPeerDescriptor))
 
         closestToData.forEach((con) => {
@@ -307,7 +307,7 @@ export class DataStore implements IStoreService {
                 })
             }
         } else {
-            // if we are the closest to the data, migrate to all storeNumberOfCopies nearest
+            // if we are the closest to the data, migrate to all storageRedundancyFactor nearest
             sortedList.getAllContacts().forEach((contact) => {
                 const contactPeerId = PeerID.fromValue(contact.getPeerDescriptor().kademliaId)
                 if (!incomingPeerId.equals(contactPeerId) && !ownPeerId.equals(contactPeerId)) {

package/src/dht/store/{RemoteStore.ts → StoreRpcRemote.ts}

@@ -1,5 +1,5 @@
 import { Remote } from '../contact/Remote'
-import { IStoreServiceClient } from '../../proto/packages/dht/protos/DhtRpc.client'
+import { IStoreRpcClient } from '../../proto/packages/dht/protos/DhtRpc.client'
 import { 
     DeleteDataRequest,
     DeleteDataResponse,
@@ -10,7 +10,7 @@ import {
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { keyFromPeerDescriptor } from '../../helpers/peerIdFromPeerDescriptor'
 
-export class RemoteStore extends Remote<IStoreServiceClient> {
+export class StoreRpcRemote extends Remote<IStoreRpcClient> {
 
     async storeData(request: StoreDataRequest): Promise<StoreDataResponse> {
         const options = this.formDhtRpcOptions({

package/src/exports.ts

@@ -9,5 +9,5 @@ export { ConnectionManager, ConnectionLocker, PortRange, TlsCertificate } from '
 export { DhtRpcOptions } from './rpc-protocol/DhtRpcOptions'
 export { Remote } from './dht/contact/Remote'
 export { areEqualPeerDescriptors } from './helpers/peerIdFromPeerDescriptor'
-export { IceServer } from './connection/WebRTC/WebRtcConnector'
+export { IceServer } from './connection/WebRTC/WebRtcConnectorRpcLocal'
 export { DhtCallContext } from './rpc-protocol/DhtCallContext'

package/src/helpers/protoClasses.ts

@@ -13,8 +13,8 @@ import {
     PeerDescriptor, 
     PingRequest, 
     PingResponse, 
-    RecursiveFindReport, 
-    RecursiveFindRequest, 
+    FindResponse, 
+    FindRequest, 
     RouteMessageAck, 
     RouteMessageWrapper,
     WebSocketConnectionRequest,
@@ -32,8 +32,8 @@ import {
 export const protoClasses: Array<IMessageType<any>> = [
     ClosestPeersRequest,
     ClosestPeersResponse,
-    RecursiveFindRequest,
-    RecursiveFindReport,
+    FindRequest,
+    FindResponse,
     PingRequest,
     PingResponse,
     LeaveNotice,

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

@@ -1,35 +1,35 @@
 // @generated by protobuf-ts 2.9.1 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 { ExternalApiService } from "./DhtRpc";
+import { ExternalApiRpc } from "./DhtRpc";
 import type { ExternalStoreDataResponse } from "./DhtRpc";
 import type { ExternalStoreDataRequest } from "./DhtRpc";
 import type { FindDataResponse } from "./DhtRpc";
 import type { FindDataRequest } from "./DhtRpc";
-import { ConnectionLocker } 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";
 import type { LockRequest } from "./DhtRpc";
-import { WebRtcConnectorService } from "./DhtRpc";
+import { WebRtcConnectorRpc } from "./DhtRpc";
 import type { IceCandidate } from "./DhtRpc";
 import type { RtcAnswer } from "./DhtRpc";
 import type { RtcOffer } from "./DhtRpc";
 import type { WebRtcConnectionRequest } from "./DhtRpc";
-import { WebSocketConnectorService } from "./DhtRpc";
+import { WebSocketConnectorRpc } from "./DhtRpc";
 import type { WebSocketConnectionResponse } from "./DhtRpc";
 import type { WebSocketConnectionRequest } from "./DhtRpc";
 import { RecursiveFindSessionService } from "./DhtRpc";
-import type { RecursiveFindReport } from "./DhtRpc";
-import { StoreService } from "./DhtRpc";
+import type { FindResponse } 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 { StoreDataResponse } from "./DhtRpc";
 import type { StoreDataRequest } from "./DhtRpc";
-import { RoutingService } from "./DhtRpc";
+import { RouterRpc } from "./DhtRpc";
 import type { RouteMessageAck } from "./DhtRpc";
 import type { RouteMessageWrapper } from "./DhtRpc";
 import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
@@ -93,9 +93,9 @@ export class DhtRpcServiceClient implements IDhtRpcServiceClient, ServiceInfo {
     }
 }
 /**
- * @generated from protobuf service dht.RoutingService
+ * @generated from protobuf service dht.RouterRpc
  */
-export interface IRoutingServiceClient {
+export interface IRouterRpcClient {
     /**
      * @generated from protobuf rpc: routeMessage(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
      */
@@ -110,12 +110,12 @@ export interface IRoutingServiceClient {
     findRecursively(input: RouteMessageWrapper, options?: RpcOptions): UnaryCall<RouteMessageWrapper, RouteMessageAck>;
 }
 /**
- * @generated from protobuf service dht.RoutingService
+ * @generated from protobuf service dht.RouterRpc
  */
-export class RoutingServiceClient implements IRoutingServiceClient, ServiceInfo {
-    typeName = RoutingService.typeName;
-    methods = RoutingService.methods;
-    options = RoutingService.options;
+export class RouterRpcClient implements IRouterRpcClient, ServiceInfo {
+    typeName = RouterRpc.typeName;
+    methods = RouterRpc.methods;
+    options = RouterRpc.options;
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
@@ -141,9 +141,9 @@ export class RoutingServiceClient implements IRoutingServiceClient, ServiceInfo
     }
 }
 /**
- * @generated from protobuf service dht.StoreService
+ * @generated from protobuf service dht.StoreRpc
  */
-export interface IStoreServiceClient {
+export interface IStoreRpcClient {
     /**
      * @generated from protobuf rpc: storeData(dht.StoreDataRequest) returns (dht.StoreDataResponse);
      */
@@ -158,12 +158,12 @@ export interface IStoreServiceClient {
     deleteData(input: DeleteDataRequest, options?: RpcOptions): UnaryCall<DeleteDataRequest, DeleteDataResponse>;
 }
 /**
- * @generated from protobuf service dht.StoreService
+ * @generated from protobuf service dht.StoreRpc
  */
-export class StoreServiceClient implements IStoreServiceClient, ServiceInfo {
-    typeName = StoreService.typeName;
-    methods = StoreService.methods;
-    options = StoreService.options;
+export class StoreRpcClient implements IStoreRpcClient, ServiceInfo {
+    typeName = StoreRpc.typeName;
+    methods = StoreRpc.methods;
+    options = StoreRpc.options;
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
@@ -193,9 +193,9 @@ export class StoreServiceClient implements IStoreServiceClient, ServiceInfo {
  */
 export interface IRecursiveFindSessionServiceClient {
     /**
-     * @generated from protobuf rpc: reportRecursiveFindResult(dht.RecursiveFindReport) returns (google.protobuf.Empty);
+     * @generated from protobuf rpc: sendFindResponse(dht.FindResponse) returns (google.protobuf.Empty);
      */
-    reportRecursiveFindResult(input: RecursiveFindReport, options?: RpcOptions): UnaryCall<RecursiveFindReport, Empty>;
+    sendFindResponse(input: FindResponse, options?: RpcOptions): UnaryCall<FindResponse, Empty>;
 }
 /**
  * @generated from protobuf service dht.RecursiveFindSessionService
@@ -207,29 +207,29 @@ export class RecursiveFindSessionServiceClient implements IRecursiveFindSessionS
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
-     * @generated from protobuf rpc: reportRecursiveFindResult(dht.RecursiveFindReport) returns (google.protobuf.Empty);
+     * @generated from protobuf rpc: sendFindResponse(dht.FindResponse) returns (google.protobuf.Empty);
      */
-    reportRecursiveFindResult(input: RecursiveFindReport, options?: RpcOptions): UnaryCall<RecursiveFindReport, Empty> {
+    sendFindResponse(input: FindResponse, options?: RpcOptions): UnaryCall<FindResponse, Empty> {
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
-        return stackIntercept<RecursiveFindReport, Empty>("unary", this._transport, method, opt, input);
+        return stackIntercept<FindResponse, Empty>("unary", this._transport, method, opt, input);
     }
 }
 /**
- * @generated from protobuf service dht.WebSocketConnectorService
+ * @generated from protobuf service dht.WebSocketConnectorRpc
  */
-export interface IWebSocketConnectorServiceClient {
+export interface IWebSocketConnectorRpcClient {
     /**
      * @generated from protobuf rpc: requestConnection(dht.WebSocketConnectionRequest) returns (dht.WebSocketConnectionResponse);
      */
     requestConnection(input: WebSocketConnectionRequest, options?: RpcOptions): UnaryCall<WebSocketConnectionRequest, WebSocketConnectionResponse>;
 }
 /**
- * @generated from protobuf service dht.WebSocketConnectorService
+ * @generated from protobuf service dht.WebSocketConnectorRpc
  */
-export class WebSocketConnectorServiceClient implements IWebSocketConnectorServiceClient, ServiceInfo {
-    typeName = WebSocketConnectorService.typeName;
-    methods = WebSocketConnectorService.methods;
-    options = WebSocketConnectorService.options;
+export class WebSocketConnectorRpcClient implements IWebSocketConnectorRpcClient, ServiceInfo {
+    typeName = WebSocketConnectorRpc.typeName;
+    methods = WebSocketConnectorRpc.methods;
+    options = WebSocketConnectorRpc.options;
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
@@ -241,9 +241,9 @@ export class WebSocketConnectorServiceClient implements IWebSocketConnectorServi
     }
 }
 /**
- * @generated from protobuf service dht.WebRtcConnectorService
+ * @generated from protobuf service dht.WebRtcConnectorRpc
  */
-export interface IWebRtcConnectorServiceClient {
+export interface IWebRtcConnectorRpcClient {
     /**
      * @generated from protobuf rpc: requestConnection(dht.WebRtcConnectionRequest) returns (google.protobuf.Empty);
      */
@@ -262,12 +262,12 @@ export interface IWebRtcConnectorServiceClient {
     iceCandidate(input: IceCandidate, options?: RpcOptions): UnaryCall<IceCandidate, Empty>;
 }
 /**
- * @generated from protobuf service dht.WebRtcConnectorService
+ * @generated from protobuf service dht.WebRtcConnectorRpc
  */
-export class WebRtcConnectorServiceClient implements IWebRtcConnectorServiceClient, ServiceInfo {
-    typeName = WebRtcConnectorService.typeName;
-    methods = WebRtcConnectorService.methods;
-    options = WebRtcConnectorService.options;
+export class WebRtcConnectorRpcClient implements IWebRtcConnectorRpcClient, ServiceInfo {
+    typeName = WebRtcConnectorRpc.typeName;
+    methods = WebRtcConnectorRpc.methods;
+    options = WebRtcConnectorRpc.options;
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
@@ -300,9 +300,9 @@ export class WebRtcConnectorServiceClient implements IWebRtcConnectorServiceClie
     }
 }
 /**
- * @generated from protobuf service dht.ConnectionLocker
+ * @generated from protobuf service dht.ConnectionLockRpc
  */
-export interface IConnectionLockerClient {
+export interface IConnectionLockRpcClient {
     /**
      * @generated from protobuf rpc: lockRequest(dht.LockRequest) returns (dht.LockResponse);
      */
@@ -317,12 +317,12 @@ export interface IConnectionLockerClient {
     gracefulDisconnect(input: DisconnectNotice, options?: RpcOptions): UnaryCall<DisconnectNotice, DisconnectNoticeResponse>;
 }
 /**
- * @generated from protobuf service dht.ConnectionLocker
+ * @generated from protobuf service dht.ConnectionLockRpc
  */
-export class ConnectionLockerClient implements IConnectionLockerClient, ServiceInfo {
-    typeName = ConnectionLocker.typeName;
-    methods = ConnectionLocker.methods;
-    options = ConnectionLocker.options;
+export class ConnectionLockRpcClient implements IConnectionLockRpcClient, ServiceInfo {
+    typeName = ConnectionLockRpc.typeName;
+    methods = ConnectionLockRpc.methods;
+    options = ConnectionLockRpc.options;
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
@@ -348,9 +348,9 @@ export class ConnectionLockerClient implements IConnectionLockerClient, ServiceI
     }
 }
 /**
- * @generated from protobuf service dht.ExternalApiService
+ * @generated from protobuf service dht.ExternalApiRpc
  */
-export interface IExternalApiServiceClient {
+export interface IExternalApiRpcClient {
     /**
      * @generated from protobuf rpc: findData(dht.FindDataRequest) returns (dht.FindDataResponse);
      */
@@ -361,12 +361,12 @@ export interface IExternalApiServiceClient {
     externalStoreData(input: ExternalStoreDataRequest, options?: RpcOptions): UnaryCall<ExternalStoreDataRequest, ExternalStoreDataResponse>;
 }
 /**
- * @generated from protobuf service dht.ExternalApiService
+ * @generated from protobuf service dht.ExternalApiRpc
  */
-export class ExternalApiServiceClient implements IExternalApiServiceClient, ServiceInfo {
-    typeName = ExternalApiService.typeName;
-    methods = ExternalApiService.methods;
-    options = ExternalApiService.options;
+export class ExternalApiRpcClient implements IExternalApiRpcClient, ServiceInfo {
+    typeName = ExternalApiRpc.typeName;
+    methods = ExternalApiRpc.methods;
+    options = ExternalApiRpc.options;
     constructor(private readonly _transport: RpcTransport) {
     }
     /**

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

@@ -16,7 +16,7 @@ import { RtcOffer } from "./DhtRpc";
 import { WebRtcConnectionRequest } from "./DhtRpc";
 import { WebSocketConnectionResponse } from "./DhtRpc";
 import { WebSocketConnectionRequest } from "./DhtRpc";
-import { RecursiveFindReport } from "./DhtRpc";
+import { FindResponse } from "./DhtRpc";
 import { DeleteDataResponse } from "./DhtRpc";
 import { DeleteDataRequest } from "./DhtRpc";
 import { MigrateDataResponse } from "./DhtRpc";
@@ -50,9 +50,9 @@ export interface IDhtRpcService<T = ServerCallContext> {
     leaveNotice(request: LeaveNotice, context: T): Promise<Empty>;
 }
 /**
- * @generated from protobuf service dht.RoutingService
+ * @generated from protobuf service dht.RouterRpc
  */
-export interface IRoutingService<T = ServerCallContext> {
+export interface IRouterRpc<T = ServerCallContext> {
     /**
      * @generated from protobuf rpc: routeMessage(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
      */
@@ -67,9 +67,9 @@ export interface IRoutingService<T = ServerCallContext> {
     findRecursively(request: RouteMessageWrapper, context: T): Promise<RouteMessageAck>;
 }
 /**
- * @generated from protobuf service dht.StoreService
+ * @generated from protobuf service dht.StoreRpc
  */
-export interface IStoreService<T = ServerCallContext> {
+export interface IStoreRpc<T = ServerCallContext> {
     /**
      * @generated from protobuf rpc: storeData(dht.StoreDataRequest) returns (dht.StoreDataResponse);
      */
@@ -88,23 +88,23 @@ export interface IStoreService<T = ServerCallContext> {
  */
 export interface IRecursiveFindSessionService<T = ServerCallContext> {
     /**
-     * @generated from protobuf rpc: reportRecursiveFindResult(dht.RecursiveFindReport) returns (google.protobuf.Empty);
+     * @generated from protobuf rpc: sendFindResponse(dht.FindResponse) returns (google.protobuf.Empty);
      */
-    reportRecursiveFindResult(request: RecursiveFindReport, context: T): Promise<Empty>;
+    sendFindResponse(request: FindResponse, context: T): Promise<Empty>;
 }
 /**
- * @generated from protobuf service dht.WebSocketConnectorService
+ * @generated from protobuf service dht.WebSocketConnectorRpc
  */
-export interface IWebSocketConnectorService<T = ServerCallContext> {
+export interface IWebSocketConnectorRpc<T = ServerCallContext> {
     /**
      * @generated from protobuf rpc: requestConnection(dht.WebSocketConnectionRequest) returns (dht.WebSocketConnectionResponse);
      */
     requestConnection(request: WebSocketConnectionRequest, context: T): Promise<WebSocketConnectionResponse>;
 }
 /**
- * @generated from protobuf service dht.WebRtcConnectorService
+ * @generated from protobuf service dht.WebRtcConnectorRpc
  */
-export interface IWebRtcConnectorService<T = ServerCallContext> {
+export interface IWebRtcConnectorRpc<T = ServerCallContext> {
     /**
      * @generated from protobuf rpc: requestConnection(dht.WebRtcConnectionRequest) returns (google.protobuf.Empty);
      */
@@ -123,9 +123,9 @@ export interface IWebRtcConnectorService<T = ServerCallContext> {
     iceCandidate(request: IceCandidate, context: T): Promise<Empty>;
 }
 /**
- * @generated from protobuf service dht.ConnectionLocker
+ * @generated from protobuf service dht.ConnectionLockRpc
  */
-export interface IConnectionLocker<T = ServerCallContext> {
+export interface IConnectionLockRpc<T = ServerCallContext> {
     /**
      * @generated from protobuf rpc: lockRequest(dht.LockRequest) returns (dht.LockResponse);
      */
@@ -140,9 +140,9 @@ export interface IConnectionLocker<T = ServerCallContext> {
     gracefulDisconnect(request: DisconnectNotice, context: T): Promise<DisconnectNoticeResponse>;
 }
 /**
- * @generated from protobuf service dht.ExternalApiService
+ * @generated from protobuf service dht.ExternalApiRpc
  */
-export interface IExternalApiService<T = ServerCallContext> {
+export interface IExternalApiRpc<T = ServerCallContext> {
     /**
      * @generated from protobuf rpc: findData(dht.FindDataRequest) returns (dht.FindDataResponse);
      */