@streamr/trackerless-network 100.0.0-testnet-one.4 → 100.0.0-testnet-two.1

package/src/logic/neighbor-discovery/NeighborUpdateManager.ts

@@ -1,9 +1,8 @@
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
-import { ProtoRpcClient, toProtoRpcClient } from '@streamr/proto-rpc'
 import { NeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { Logger, scheduleAtInterval } from '@streamr/utils'
-import { INeighborFinder } from './NeighborFinder'
+import { NeighborFinder } from './NeighborFinder'
 import { NodeList } from '../NodeList'
 import { NeighborUpdateRpcRemote } from './NeighborUpdateRpcRemote'
 import { NeighborUpdateRpcLocal } from './NeighborUpdateRpcLocal'
@@ -14,7 +13,7 @@ interface NeighborUpdateManagerConfig {
     localPeerDescriptor: PeerDescriptor
     targetNeighbors: NodeList
     nearbyNodeView: NodeList
-    neighborFinder: INeighborFinder
+    neighborFinder: NeighborFinder
     streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
     neighborUpdateInterval: number
@@ -22,21 +21,14 @@ interface NeighborUpdateManagerConfig {
 
 const logger = new Logger(module)
 
-export interface INeighborUpdateManager {
-    start(): Promise<void>
-    stop(): void
-}
-
-export class NeighborUpdateManager implements INeighborUpdateManager {
+export class NeighborUpdateManager {
 
     private readonly abortController: AbortController
     private readonly config: NeighborUpdateManagerConfig
-    private readonly client: ProtoRpcClient<NeighborUpdateRpcClient>
     private readonly rpcLocal: NeighborUpdateRpcLocal
 
     constructor(config: NeighborUpdateManagerConfig) {
         this.abortController = new AbortController()
-        this.client = toProtoRpcClient(new NeighborUpdateRpcClient(config.rpcCommunicator.getRpcClientTransport()))
         this.rpcLocal = new NeighborUpdateRpcLocal(config)
         this.config = config
         this.config.rpcCommunicator.registerRpcMethod(NeighborUpdate, NeighborUpdate, 'neighborUpdate',
@@ -64,6 +56,12 @@ export class NeighborUpdateManager implements INeighborUpdateManager {
     }
 
     private createRemote(targetPeerDescriptor: PeerDescriptor): NeighborUpdateRpcRemote {
-        return new NeighborUpdateRpcRemote(this.config.localPeerDescriptor, targetPeerDescriptor, this.config.streamPartId, this.client)
+        return new NeighborUpdateRpcRemote(
+            this.config.localPeerDescriptor,
+            targetPeerDescriptor,
+            this.config.streamPartId,
+            this.config.rpcCommunicator,
+            NeighborUpdateRpcClient
+        )
     }
 }

package/src/logic/neighbor-discovery/NeighborUpdateRpcLocal.ts

@@ -1,13 +1,12 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { DhtCallContext, ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { INeighborUpdateRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { NodeList } from '../NodeList'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
-import { INeighborFinder } from './NeighborFinder'
+import { NeighborFinder } from './NeighborFinder'
 import { StreamPartID } from '@streamr/protocol'
 
 interface NeighborUpdateRpcLocalConfig {
@@ -15,7 +14,7 @@ interface NeighborUpdateRpcLocalConfig {
     streamPartId: StreamPartID
     targetNeighbors: NodeList
     nearbyNodeView: NodeList
-    neighborFinder: INeighborFinder
+    neighborFinder: NeighborFinder
     rpcCommunicator: ListeningRpcCommunicator
 }
 
@@ -43,7 +42,8 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
                     this.config.localPeerDescriptor,
                     peerDescriptor,
                     this.config.streamPartId,
-                    toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+                    this.config.rpcCommunicator,
+                    DeliveryRpcClient
                 ))
             )
             this.config.neighborFinder.start()

package/src/logic/neighbor-discovery/NeighborUpdateRpcRemote.ts

@@ -2,7 +2,7 @@ import { PeerDescriptor, RpcRemote } from '@streamr/dht'
 import { Logger } from '@streamr/utils'
 import { getNodeIdFromPeerDescriptor } from '../../identifiers'
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { INeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { NeighborUpdateRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 
 const logger = new Logger(module)
 
@@ -11,7 +11,7 @@ interface UpdateNeighborsResponse {
     removeMe: boolean
 }
 
-export class NeighborUpdateRpcRemote extends RpcRemote<INeighborUpdateRpcClient> {
+export class NeighborUpdateRpcRemote extends RpcRemote<NeighborUpdateRpcClient> {
 
     async updateNeighbors(neighbors: PeerDescriptor[]): Promise<UpdateNeighborsResponse> {
         const request: NeighborUpdate = {

package/src/logic/proxy/ProxyClient.ts

@@ -4,7 +4,6 @@ import {
     ListeningRpcCommunicator,
     PeerDescriptor
 } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { StreamPartID } from '@streamr/protocol'
 import { EthereumAddress, Logger, addManagedEventListener, wait } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
@@ -27,6 +26,7 @@ import { markAndCheckDuplicate } from '../utils'
 import { ProxyConnectionRpcRemote } from './ProxyConnectionRpcRemote'
 import { formStreamPartDeliveryServiceId } from '../formStreamPartDeliveryServiceId'
 
+// TODO use config option or named constant?
 export const retry = async <T>(task: () => Promise<T>, description: string, abortSignal: AbortSignal, delay = 10000): Promise<T> => {
     // eslint-disable-next-line no-constant-condition
     while (true) {
@@ -57,11 +57,15 @@ interface ProxyDefinition {
     userId: EthereumAddress
 }
 
+interface Events {
+    message: (message: StreamMessage) => void
+}
+
 const logger = new Logger(module)
 
 const SERVICE_ID = 'system/proxy-client'
 
-export class ProxyClient extends EventEmitter {
+export class ProxyClient extends EventEmitter<Events> {
 
     private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly deliveryRpcLocal: DeliveryRpcLocal
@@ -77,6 +81,7 @@ export class ProxyClient extends EventEmitter {
         super()
         this.config = config
         this.rpcCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(config.streamPartId), config.transport)
+        // TODO use config option or named constant?
         this.targetNeighbors = new NodeList(getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor), 1000)
         this.deliveryRpcLocal = new DeliveryRpcLocal({
             localPeerDescriptor: this.config.localPeerDescriptor,
@@ -94,6 +99,7 @@ export class ProxyClient extends EventEmitter {
             markForInspection: () => {}
         })
         this.propagation = new Propagation({
+            // TODO use config option or named constant?
             minPropagationTargets: config.minPropagationTargets ?? 2,
             sendToNeighbor: async (neighborId: NodeID, msg: StreamMessage): Promise<void> => {
                 const remote = this.targetNeighbors.get(neighborId)
@@ -167,8 +173,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.localPeerDescriptor, peerDescriptor, this.config.streamPartId, client)
+        const rpcRemote = new ProxyConnectionRpcRemote(
+            this.config.localPeerDescriptor,
+            peerDescriptor,
+            this.config.streamPartId,
+            this.rpcCommunicator,
+            ProxyConnectionRpcClient
+        )
         const accepted = await rpcRemote.requestConnection(direction, userId)
         if (accepted) {
             this.config.connectionLocker.lockConnection(peerDescriptor, SERVICE_ID)
@@ -177,7 +188,8 @@ export class ProxyClient extends EventEmitter {
                 this.config.localPeerDescriptor,
                 peerDescriptor,
                 this.config.streamPartId,
-                toProtoRpcClient(new DeliveryRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+                this.rpcCommunicator,
+                DeliveryRpcClient
             )
             this.targetNeighbors.add(remote)
             this.propagation.onNeighborJoined(nodeId)
@@ -204,7 +216,7 @@ export class ProxyClient extends EventEmitter {
                 nodeId
             })
             const server = this.targetNeighbors.get(nodeId)
-            server?.leaveStreamPartNotice()
+            server?.leaveStreamPartNotice(false)
             this.removeConnection(nodeId)
         }
     }
@@ -253,7 +265,7 @@ export class ProxyClient extends EventEmitter {
     stop(): void {
         this.targetNeighbors.getAll().map((remote) => {
             this.config.connectionLocker.unlockConnection(remote.getPeerDescriptor(), SERVICE_ID)
-            remote.leaveStreamPartNotice()
+            remote.leaveStreamPartNotice(false)
         })
         this.targetNeighbors.stop()
         this.rpcCommunicator.destroy()

package/src/logic/proxy/ProxyConnectionRpcLocal.ts

@@ -10,7 +10,6 @@ import {
 import { IProxyConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
 import { DhtCallContext, ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { EventEmitter } from 'eventemitter3'
 import { EthereumAddress, Logger, binaryToHex, toEthereumAddress } from '@streamr/utils'
@@ -60,7 +59,7 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
     }
 
     stop(): void {
-        this.connections.forEach((connection) => connection.remote.leaveStreamPartNotice())
+        this.connections.forEach((connection) => connection.remote.leaveStreamPartNotice(false))
         this.connections.clear()
         this.removeAllListeners()
     }
@@ -98,7 +97,8 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
                 this.config.localPeerDescriptor,
                 senderPeerDescriptor,
                 this.config.streamPartId,
-                toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+                this.config.rpcCommunicator,
+                DeliveryRpcClient
             )
         })
         const response: ProxyConnectionResponse = {

package/src/logic/proxy/ProxyConnectionRpcRemote.ts

@@ -1,11 +1,11 @@
-import { RpcRemote, EXISTING_CONNECTION_TIMEOUT } from '@streamr/dht'
+import { EXISTING_CONNECTION_TIMEOUT, RpcRemote } 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'
+import { ProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 
 const logger = new Logger(module)
 
-export class ProxyConnectionRpcRemote extends RpcRemote<IProxyConnectionRpcClient> {
+export class ProxyConnectionRpcRemote extends RpcRemote<ProxyConnectionRpcClient> {
 
     async requestConnection(direction: ProxyDirection, userId: EthereumAddress): Promise<boolean> {
         const request: ProxyConnectionRequest = {

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

@@ -4,7 +4,6 @@ import { ITemporaryConnectionRpc } from '../../proto/packages/trackerless-networ
 import { DhtCallContext, ListeningRpcCommunicator } from '@streamr/dht'
 import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { NodeList } from '../NodeList'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { getNodeIdFromPeerDescriptor } from '../../identifiers'
@@ -23,6 +22,7 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
 
     constructor(config: TemporaryConnectionRpcLocalConfig) {
         this.config = config
+        // TODO use config option or named constant?
         this.temporaryNodes = new NodeList(getNodeIdFromPeerDescriptor(config.localPeerDescriptor), 10)
     }
 
@@ -43,7 +43,8 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
             this.config.localPeerDescriptor,
             sender,
             this.config.streamPartId,
-            toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+            this.config.rpcCommunicator,
+            DeliveryRpcClient
         )
         this.temporaryNodes.add(remote)
         return {

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

@@ -1,11 +1,11 @@
 import { RpcRemote } from '@streamr/dht'
 import { Logger } from '@streamr/utils'
 import { getNodeIdFromPeerDescriptor } from '../../identifiers'
-import { ITemporaryConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { TemporaryConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 
 const logger = new Logger(module)
 
-export class TemporaryConnectionRpcRemote extends RpcRemote<ITemporaryConnectionRpcClient> {
+export class TemporaryConnectionRpcRemote extends RpcRemote<TemporaryConnectionRpcClient> {
 
     async openConnection(): Promise<boolean> {
         try {

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

@@ -18,15 +18,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 { 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";
@@ -128,27 +127,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);
     }
@@ -191,29 +190,29 @@ export class StoreRpcClient implements IStoreRpcClient, ServiceInfo {
     }
 }
 /**
- * @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);
     }
 }
 /**
@@ -221,9 +220,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
@@ -235,11 +234,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);
     }
 }
 /**

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

@@ -14,9 +14,8 @@ 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 { FindResponse } from "./DhtRpc";
+import { RecursiveOperationResponse } from "./DhtRpc";
 import { ReplicateDataRequest } from "./DhtRpc";
 import { StoreDataResponse } from "./DhtRpc";
 import { StoreDataRequest } from "./DhtRpc";
@@ -60,13 +59,13 @@ export interface IRouterRpc<T = ServerCallContext> {
     forwardMessage(request: RouteMessageWrapper, context: T): Promise<RouteMessageAck>;
 }
 /**
- * @generated from protobuf service dht.FindRpc
+ * @generated from protobuf service dht.RecursiveOperationRpc
  */
-export interface IFindRpc<T = ServerCallContext> {
+export interface IRecursiveOperationRpc<T = ServerCallContext> {
     /**
-     * @generated from protobuf rpc: routeFindRequest(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
+     * @generated from protobuf rpc: routeRequest(dht.RouteMessageWrapper) returns (dht.RouteMessageAck);
      */
-    routeFindRequest(request: RouteMessageWrapper, context: T): Promise<RouteMessageAck>;
+    routeRequest(request: RouteMessageWrapper, context: T): Promise<RouteMessageAck>;
 }
 /**
  * @generated from protobuf service dht.StoreRpc
@@ -82,22 +81,22 @@ export interface IStoreRpc<T = ServerCallContext> {
     replicateData(request: ReplicateDataRequest, context: T): Promise<Empty>;
 }
 /**
- * @generated from protobuf service dht.FindSessionRpc
+ * @generated from protobuf service dht.RecursiveOperationSessionRpc
  */
-export interface IFindSessionRpc<T = ServerCallContext> {
+export interface IRecursiveOperationSessionRpc<T = ServerCallContext> {
     /**
-     * @generated from protobuf rpc: sendFindResponse(dht.FindResponse) returns (google.protobuf.Empty);
+     * @generated from protobuf rpc: sendResponse(dht.RecursiveOperationResponse) returns (google.protobuf.Empty);
      */
-    sendFindResponse(request: FindResponse, context: T): Promise<Empty>;
+    sendResponse(request: RecursiveOperationResponse, context: T): Promise<Empty>;
 }
 /**
  * @generated from protobuf service dht.WebsocketConnectorRpc
  */
 export interface IWebsocketConnectorRpc<T = ServerCallContext> {
     /**
-     * @generated from protobuf rpc: requestConnection(dht.WebsocketConnectionRequest) returns (dht.WebsocketConnectionResponse);
+     * @generated from protobuf rpc: requestConnection(dht.WebsocketConnectionRequest) returns (google.protobuf.Empty);
      */
-    requestConnection(request: WebsocketConnectionRequest, context: T): Promise<WebsocketConnectionResponse>;
+    requestConnection(request: WebsocketConnectionRequest, context: T): Promise<Empty>;
 }
 /**
  * @generated from protobuf service dht.WebrtcConnectorRpc