@streamr/trackerless-network 100.0.0-pretestnet.2 → 100.0.0-pretestnet.3

package/src/logic/proxy/ProxyClient.ts

@@ -44,7 +44,7 @@ export const retry = async <T>(task: () => Promise<T>, description: string, abor
 
 interface ProxyClientConfig {
     transport: ITransport
-    ownPeerDescriptor: PeerDescriptor
+    localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     connectionLocker: ConnectionLocker
     minPropagationTargets?: number // TODO could be required option if we apply all defaults somewhere at higher level
@@ -77,9 +77,9 @@ export class ProxyClient extends EventEmitter {
         super()
         this.config = config
         this.rpcCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(config.streamPartId), config.transport)
-        this.targetNeighbors = new NodeList(getNodeIdFromPeerDescriptor(this.config.ownPeerDescriptor), 1000)
+        this.targetNeighbors = new NodeList(getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor), 1000)
         this.deliveryRpcLocal = new DeliveryRpcLocal({
-            ownPeerDescriptor: this.config.ownPeerDescriptor,
+            localPeerDescriptor: this.config.localPeerDescriptor,
             streamPartId: this.config.streamPartId,
             markAndCheckDuplicate: (msg: MessageID, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
             broadcast: (message: StreamMessage, previousNode?: NodeID) => this.broadcast(message, previousNode),
@@ -150,7 +150,7 @@ export class ProxyClient extends EventEmitter {
 
     private getInvalidConnections(): NodeID[] {
         return Array.from(this.connections.keys()).filter((id) => {
-            return !this.definition!.nodes.has(id )
+            return !this.definition!.nodes.has(id)
                 || this.definition!.direction !== this.connections.get(id)
         })
     }
@@ -167,13 +167,13 @@ export class ProxyClient extends EventEmitter {
     private async attemptConnection(nodeId: NodeID, direction: ProxyDirection, userId: EthereumAddress): Promise<void> {
         const peerDescriptor = this.definition!.nodes.get(nodeId)!
         const client = toProtoRpcClient(new ProxyConnectionRpcClient(this.rpcCommunicator.getRpcClientTransport()))
-        const rpcRemote = new ProxyConnectionRpcRemote(this.config.ownPeerDescriptor, peerDescriptor, this.config.streamPartId, client)
+        const rpcRemote = new ProxyConnectionRpcRemote(this.config.localPeerDescriptor, peerDescriptor, this.config.streamPartId, client)
         const accepted = await rpcRemote.requestConnection(direction, userId)
         if (accepted) {
             this.config.connectionLocker.lockConnection(peerDescriptor, SERVICE_ID)
             this.connections.set(nodeId, direction)
             const remote = new DeliveryRpcRemote(
-                this.config.ownPeerDescriptor,
+                this.config.localPeerDescriptor,
                 peerDescriptor,
                 this.config.streamPartId,
                 toProtoRpcClient(new DeliveryRpcClient(this.rpcCommunicator.getRpcClientTransport()))

package/src/logic/proxy/ProxyConnectionRpcLocal.ts

@@ -26,7 +26,7 @@ interface ProxyConnection {
 }
 
 interface ProxyConnectionRpcLocalConfig {
-    ownPeerDescriptor: PeerDescriptor
+    localPeerDescriptor: PeerDescriptor
     streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
 }
@@ -95,7 +95,7 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
             direction: request.direction,
             userId: toEthereumAddress(binaryToHex(request.userId, true)),
             remote: new DeliveryRpcRemote(
-                this.config.ownPeerDescriptor,
+                this.config.localPeerDescriptor,
                 senderPeerDescriptor,
                 this.config.streamPartId,
                 toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))

package/src/logic/proxy/ProxyConnectionRpcRemote.ts

@@ -1,4 +1,4 @@
-import { Remote } from '@streamr/dht'
+import { Remote, EXISTING_CONNECTION_TIMEOUT } from '@streamr/dht'
 import { EthereumAddress, Logger, hexToBinary } from '@streamr/utils'
 import { ProxyConnectionRequest, ProxyDirection } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { IProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
@@ -13,7 +13,7 @@ export class ProxyConnectionRpcRemote extends Remote<IProxyConnectionRpcClient>
             userId: hexToBinary(userId)
         }
         const options = this.formDhtRpcOptions({
-            timeout: 5000
+            timeout: EXISTING_CONNECTION_TIMEOUT
         })
         try {
             const res = await this.getClient().requestConnection(request, options)

package/src/logic/temporary-connection/TemporaryConnectionRpcLocal.ts

@@ -13,7 +13,7 @@ import { StreamPartID } from '@streamr/protocol'
 interface TemporaryConnectionRpcLocalConfig {
     streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
-    ownPeerDescriptor: PeerDescriptor
+    localPeerDescriptor: PeerDescriptor
 } 
 
 export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
@@ -23,7 +23,7 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
 
     constructor(config: TemporaryConnectionRpcLocalConfig) {
         this.config = config
-        this.temporaryNodes = new NodeList(getNodeIdFromPeerDescriptor(config.ownPeerDescriptor), 10)
+        this.temporaryNodes = new NodeList(getNodeIdFromPeerDescriptor(config.localPeerDescriptor), 10)
     }
 
     getNodes(): NodeList {
@@ -40,7 +40,7 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
     ): Promise<TemporaryConnectionResponse> {
         const sender = (context as DhtCallContext).incomingSourceDescriptor!
         const remote = new DeliveryRpcRemote(
-            this.config.ownPeerDescriptor,
+            this.config.localPeerDescriptor,
             sender,
             this.config.streamPartId,
             toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))

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

@@ -1,40 +1,41 @@
 // @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 type { ExternalFindDataResponse } from "./DhtRpc";
+import type { ExternalFindDataRequest } 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 type { WebSocketConnectionResponse } from "./DhtRpc";
-import type { WebSocketConnectionRequest } from "./DhtRpc";
-import { RecursiveFindSessionService } from "./DhtRpc";
-import type { RecursiveFindReport } from "./DhtRpc";
-import { StoreService } 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 { 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 { FindRpc } from "./DhtRpc";
+import { RouterRpc } from "./DhtRpc";
 import type { RouteMessageAck } from "./DhtRpc";
 import type { RouteMessageWrapper } from "./DhtRpc";
 import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
 import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
-import { DhtRpcService } from "./DhtRpc";
+import { DhtNodeRpc } from "./DhtRpc";
 import type { Empty } from "../../../google/protobuf/empty";
 import type { LeaveNotice } from "./DhtRpc";
 import type { PingResponse } from "./DhtRpc";
@@ -45,9 +46,9 @@ import type { ClosestPeersRequest } from "./DhtRpc";
 import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
 import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
 /**
- * @generated from protobuf service dht.DhtRpcService
+ * @generated from protobuf service dht.DhtNodeRpc
  */
-export interface IDhtRpcServiceClient {
+export interface IDhtNodeRpcClient {
     /**
      * @generated from protobuf rpc: getClosestPeers(dht.ClosestPeersRequest) returns (dht.ClosestPeersResponse);
      */
@@ -62,12 +63,12 @@ export interface IDhtRpcServiceClient {
     leaveNotice(input: LeaveNotice, options?: RpcOptions): UnaryCall<LeaveNotice, Empty>;
 }
 /**
- * @generated from protobuf service dht.DhtRpcService
+ * @generated from protobuf service dht.DhtNodeRpc
  */
-export class DhtRpcServiceClient implements IDhtRpcServiceClient, ServiceInfo {
-    typeName = DhtRpcService.typeName;
-    methods = DhtRpcService.methods;
-    options = DhtRpcService.options;
+export class DhtNodeRpcClient implements IDhtNodeRpcClient, ServiceInfo {
+    typeName = DhtNodeRpc.typeName;
+    methods = DhtNodeRpc.methods;
+    options = DhtNodeRpc.options;
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
@@ -93,9 +94,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);
      */
@@ -104,18 +105,14 @@ export interface IRoutingServiceClient {
      * @generated from protobuf rpc: forwardMessage(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
      */
     forwardMessage(input: RouteMessageWrapper, options?: RpcOptions): UnaryCall<RouteMessageWrapper, RouteMessageAck>;
-    /**
-     * @generated from protobuf rpc: findRecursively(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
-     */
-    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) {
     }
     /**
@@ -132,18 +129,37 @@ export class RoutingServiceClient implements IRoutingServiceClient, ServiceInfo
         const method = this.methods[1], opt = this._transport.mergeOptions(options);
         return stackIntercept<RouteMessageWrapper, RouteMessageAck>("unary", this._transport, method, opt, input);
     }
+}
+/**
+ * @generated from protobuf service dht.FindRpc
+ */
+export interface IFindRpcClient {
     /**
-     * @generated from protobuf rpc: findRecursively(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
+     * @generated from protobuf rpc: routeFindRequest(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
      */
-    findRecursively(input: RouteMessageWrapper, options?: RpcOptions): UnaryCall<RouteMessageWrapper, RouteMessageAck> {
-        const method = this.methods[2], opt = this._transport.mergeOptions(options);
+    routeFindRequest(input: RouteMessageWrapper, options?: RpcOptions): UnaryCall<RouteMessageWrapper, RouteMessageAck>;
+}
+/**
+ * @generated from protobuf service dht.FindRpc
+ */
+export class FindRpcClient implements IFindRpcClient, ServiceInfo {
+    typeName = FindRpc.typeName;
+    methods = FindRpc.methods;
+    options = FindRpc.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: routeFindRequest(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
+     */
+    routeFindRequest(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);
     }
 }
 /**
- * @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 +174,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) {
     }
     /**
@@ -189,65 +205,65 @@ export class StoreServiceClient implements IStoreServiceClient, ServiceInfo {
     }
 }
 /**
- * @generated from protobuf service dht.RecursiveFindSessionService
+ * @generated from protobuf service dht.FindSessionRpc
  */
-export interface IRecursiveFindSessionServiceClient {
+export interface IFindSessionRpcClient {
     /**
-     * @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
+ * @generated from protobuf service dht.FindSessionRpc
  */
-export class RecursiveFindSessionServiceClient implements IRecursiveFindSessionServiceClient, ServiceInfo {
-    typeName = RecursiveFindSessionService.typeName;
-    methods = RecursiveFindSessionService.methods;
-    options = RecursiveFindSessionService.options;
+export class FindSessionRpcClient implements IFindSessionRpcClient, ServiceInfo {
+    typeName = FindSessionRpc.typeName;
+    methods = FindSessionRpc.methods;
+    options = FindSessionRpc.options;
     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);
+     * @generated from protobuf rpc: requestConnection(dht.WebsocketConnectionRequest) returns (dht.WebsocketConnectionResponse);
      */
-    requestConnection(input: WebSocketConnectionRequest, options?: RpcOptions): UnaryCall<WebSocketConnectionRequest, 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) {
     }
     /**
-     * @generated from protobuf rpc: requestConnection(dht.WebSocketConnectionRequest) returns (dht.WebSocketConnectionResponse);
+     * @generated from protobuf rpc: requestConnection(dht.WebsocketConnectionRequest) returns (dht.WebsocketConnectionResponse);
      */
-    requestConnection(input: WebSocketConnectionRequest, options?: RpcOptions): UnaryCall<WebSocketConnectionRequest, WebSocketConnectionResponse> {
+    requestConnection(input: WebsocketConnectionRequest, options?: RpcOptions): UnaryCall<WebsocketConnectionRequest, WebsocketConnectionResponse> {
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
-        return stackIntercept<WebSocketConnectionRequest, WebSocketConnectionResponse>("unary", this._transport, method, opt, input);
+        return stackIntercept<WebsocketConnectionRequest, WebsocketConnectionResponse>("unary", this._transport, method, opt, input);
     }
 }
 /**
- * @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);
+     * @generated from protobuf rpc: requestConnection(dht.WebrtcConnectionRequest) returns (google.protobuf.Empty);
      */
-    requestConnection(input: WebRtcConnectionRequest, options?: RpcOptions): UnaryCall<WebRtcConnectionRequest, Empty>;
+    requestConnection(input: WebrtcConnectionRequest, options?: RpcOptions): UnaryCall<WebrtcConnectionRequest, Empty>;
     /**
      * @generated from protobuf rpc: rtcOffer(dht.RtcOffer) returns (google.protobuf.Empty);
      */
@@ -262,20 +278,20 @@ 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) {
     }
     /**
-     * @generated from protobuf rpc: requestConnection(dht.WebRtcConnectionRequest) returns (google.protobuf.Empty);
+     * @generated from protobuf rpc: requestConnection(dht.WebrtcConnectionRequest) returns (google.protobuf.Empty);
      */
-    requestConnection(input: WebRtcConnectionRequest, options?: RpcOptions): UnaryCall<WebRtcConnectionRequest, Empty> {
+    requestConnection(input: WebrtcConnectionRequest, options?: RpcOptions): UnaryCall<WebrtcConnectionRequest, Empty> {
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
-        return stackIntercept<WebRtcConnectionRequest, Empty>("unary", this._transport, method, opt, input);
+        return stackIntercept<WebrtcConnectionRequest, Empty>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: rtcOffer(dht.RtcOffer) returns (google.protobuf.Empty);
@@ -300,9 +316,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 +333,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,33 +364,33 @@ 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);
+     * @generated from protobuf rpc: externalFindData(dht.ExternalFindDataRequest) returns (dht.ExternalFindDataResponse);
      */
-    findData(input: FindDataRequest, options?: RpcOptions): UnaryCall<FindDataRequest, FindDataResponse>;
+    externalFindData(input: ExternalFindDataRequest, options?: RpcOptions): UnaryCall<ExternalFindDataRequest, ExternalFindDataResponse>;
     /**
      * @generated from protobuf rpc: externalStoreData(dht.ExternalStoreDataRequest) returns (dht.ExternalStoreDataResponse);
      */
     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) {
     }
     /**
-     * @generated from protobuf rpc: findData(dht.FindDataRequest) returns (dht.FindDataResponse);
+     * @generated from protobuf rpc: externalFindData(dht.ExternalFindDataRequest) returns (dht.ExternalFindDataResponse);
      */
-    findData(input: FindDataRequest, options?: RpcOptions): UnaryCall<FindDataRequest, FindDataResponse> {
+    externalFindData(input: ExternalFindDataRequest, options?: RpcOptions): UnaryCall<ExternalFindDataRequest, ExternalFindDataResponse> {
         const method = this.methods[0], opt = this._transport.mergeOptions(options);
-        return stackIntercept<FindDataRequest, FindDataResponse>("unary", this._transport, method, opt, input);
+        return stackIntercept<ExternalFindDataRequest, ExternalFindDataResponse>("unary", this._transport, method, opt, input);
     }
     /**
      * @generated from protobuf rpc: externalStoreData(dht.ExternalStoreDataRequest) returns (dht.ExternalStoreDataResponse);

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

@@ -3,8 +3,8 @@
 // tslint:disable
 import { ExternalStoreDataResponse } from "./DhtRpc";
 import { ExternalStoreDataRequest } from "./DhtRpc";
-import { FindDataResponse } from "./DhtRpc";
-import { FindDataRequest } from "./DhtRpc";
+import { ExternalFindDataResponse } from "./DhtRpc";
+import { ExternalFindDataRequest } from "./DhtRpc";
 import { DisconnectNoticeResponse } from "./DhtRpc";
 import { DisconnectNotice } from "./DhtRpc";
 import { UnlockRequest } from "./DhtRpc";
@@ -13,10 +13,10 @@ import { LockRequest } from "./DhtRpc";
 import { IceCandidate } from "./DhtRpc";
 import { RtcAnswer } from "./DhtRpc";
 import { RtcOffer } from "./DhtRpc";
-import { WebRtcConnectionRequest } from "./DhtRpc";
-import { WebSocketConnectionResponse } from "./DhtRpc";
-import { WebSocketConnectionRequest } from "./DhtRpc";
-import { RecursiveFindReport } from "./DhtRpc";
+import { WebrtcConnectionRequest } from "./DhtRpc";
+import { WebsocketConnectionResponse } from "./DhtRpc";
+import { WebsocketConnectionRequest } from "./DhtRpc";
+import { FindResponse } from "./DhtRpc";
 import { DeleteDataResponse } from "./DhtRpc";
 import { DeleteDataRequest } from "./DhtRpc";
 import { MigrateDataResponse } from "./DhtRpc";
@@ -33,9 +33,9 @@ import { ClosestPeersResponse } from "./DhtRpc";
 import { ClosestPeersRequest } from "./DhtRpc";
 import { ServerCallContext } from "@protobuf-ts/runtime-rpc";
 /**
- * @generated from protobuf service dht.DhtRpcService
+ * @generated from protobuf service dht.DhtNodeRpc
  */
-export interface IDhtRpcService<T = ServerCallContext> {
+export interface IDhtNodeRpc<T = ServerCallContext> {
     /**
      * @generated from protobuf rpc: getClosestPeers(dht.ClosestPeersRequest) returns (dht.ClosestPeersResponse);
      */
@@ -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);
      */
@@ -61,15 +61,20 @@ export interface IRoutingService<T = ServerCallContext> {
      * @generated from protobuf rpc: forwardMessage(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
      */
     forwardMessage(request: RouteMessageWrapper, context: T): Promise<RouteMessageAck>;
+}
+/**
+ * @generated from protobuf service dht.FindRpc
+ */
+export interface IFindRpc<T = ServerCallContext> {
     /**
-     * @generated from protobuf rpc: findRecursively(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
+     * @generated from protobuf rpc: routeFindRequest(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
      */
-    findRecursively(request: RouteMessageWrapper, context: T): Promise<RouteMessageAck>;
+    routeFindRequest(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);
      */
@@ -84,31 +89,31 @@ export interface IStoreService<T = ServerCallContext> {
     deleteData(request: DeleteDataRequest, context: T): Promise<DeleteDataResponse>;
 }
 /**
- * @generated from protobuf service dht.RecursiveFindSessionService
+ * @generated from protobuf service dht.FindSessionRpc
  */
-export interface IRecursiveFindSessionService<T = ServerCallContext> {
+export interface IFindSessionRpc<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);
+     * @generated from protobuf rpc: requestConnection(dht.WebsocketConnectionRequest) returns (dht.WebsocketConnectionResponse);
      */
-    requestConnection(request: WebSocketConnectionRequest, context: T): Promise<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);
+     * @generated from protobuf rpc: requestConnection(dht.WebrtcConnectionRequest) returns (google.protobuf.Empty);
      */
-    requestConnection(request: WebRtcConnectionRequest, context: T): Promise<Empty>;
+    requestConnection(request: WebrtcConnectionRequest, context: T): Promise<Empty>;
     /**
      * @generated from protobuf rpc: rtcOffer(dht.RtcOffer) returns (google.protobuf.Empty);
      */
@@ -123,9 +128,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,13 +145,13 @@ 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);
+     * @generated from protobuf rpc: externalFindData(dht.ExternalFindDataRequest) returns (dht.ExternalFindDataResponse);
      */
-    findData(request: FindDataRequest, context: T): Promise<FindDataResponse>;
+    externalFindData(request: ExternalFindDataRequest, context: T): Promise<ExternalFindDataResponse>;
     /**
      * @generated from protobuf rpc: externalStoreData(dht.ExternalStoreDataRequest) returns (dht.ExternalStoreDataResponse);
      */