@streamr/dht 100.0.0-testnet-three.6 → 100.1.0

package/src/dht/discovery/RingDiscoverySession.ts

@@ -0,0 +1,162 @@
+import { Logger, runAndWaitForEvents3 } from '@streamr/utils'
+import EventEmitter from 'eventemitter3'
+import { v4 } from 'uuid'
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { PeerManager } from '../PeerManager'
+import { DhtNodeRpcRemote } from '../DhtNodeRpcRemote'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { RingId, RingIdRaw, getLeftDistance, getRingIdFromPeerDescriptor, getRingIdFromRaw } from '../contact/ringIdentifiers'
+import { RingContacts } from '../contact/RingContactList'
+
+const logger = new Logger(module)
+
+interface RingDiscoverySessionEvents {
+    discoveryCompleted: () => void
+}
+
+interface RingDiscoverySessionConfig {
+    targetId: RingIdRaw
+    parallelism: number
+    noProgressLimit: number
+    peerManager: PeerManager
+    // Note that contacted peers will be mutated by the DiscoverySession or other parallel sessions
+    contactedPeers: Set<DhtAddress>
+}
+
+export class RingDiscoverySession {
+
+    public readonly id = v4()
+    private stopped = false
+    private emitter = new EventEmitter<RingDiscoverySessionEvents>()
+    private noProgressCounter = 0
+    private ongoingClosestPeersRequests: Set<DhtAddress> = new Set()
+    private readonly config: RingDiscoverySessionConfig
+    private numContactedPeers = 0
+    private targetIdAsRingId: RingId
+
+    constructor(config: RingDiscoverySessionConfig) {
+        this.config = config
+        this.targetIdAsRingId = getRingIdFromRaw(this.config.targetId)
+    }
+
+    private addContacts(contacts: PeerDescriptor[]): void {
+        if (this.stopped) {
+            return
+        }
+        for (const contact of contacts) {
+            this.config.peerManager.addContact(contact)
+        }
+    }
+
+    private async getClosestPeersFromContact(contact: DhtNodeRpcRemote): Promise<RingContacts> {
+        if (this.stopped) {
+            return { left: [], right: [] }
+        }
+        logger.trace(`Getting closest ring peers from contact: ${getNodeIdFromPeerDescriptor(contact.getPeerDescriptor())}`)
+        this.numContactedPeers++
+        this.config.contactedPeers.add(contact.getNodeId())
+        const returnedContacts = await contact.getClosestRingPeers(this.config.targetId)
+        this.config.peerManager.setContactActive(contact.getNodeId())
+        return returnedContacts
+    }
+
+    private onClosestPeersRequestSucceeded(nodeId: DhtAddress, contacts: RingContacts) {
+        if (!this.ongoingClosestPeersRequests.has(nodeId)) {
+            return
+        }
+        this.ongoingClosestPeersRequests.delete(nodeId)
+        const oldClosestContacts = this.config.peerManager.getClosestRingContactsTo(this.config.targetId, 1)
+        const oldClosestLeftDistance = getLeftDistance(
+            this.targetIdAsRingId,
+            getRingIdFromPeerDescriptor(oldClosestContacts.left[0].getPeerDescriptor())
+        )
+        const oldClosestRightDistance = getLeftDistance(
+            this.targetIdAsRingId,
+            getRingIdFromPeerDescriptor(oldClosestContacts.right[0].getPeerDescriptor())
+        )
+        this.addContacts(contacts.left.concat(contacts.right))
+        const newClosestContacts = this.config.peerManager.getClosestRingContactsTo(this.config.targetId, 1)
+        const newClosestLeftDistance = getLeftDistance(this.targetIdAsRingId,
+            getRingIdFromPeerDescriptor(newClosestContacts.left[0].getPeerDescriptor()))
+        const newClosestRightDistance = getLeftDistance(this.targetIdAsRingId,
+            getRingIdFromPeerDescriptor(newClosestContacts.right[0].getPeerDescriptor()))
+        if (newClosestLeftDistance >= oldClosestLeftDistance && newClosestRightDistance >= oldClosestRightDistance) {
+            this.noProgressCounter++
+        }
+    }
+
+    private onClosestPeersRequestFailed(peer: DhtNodeRpcRemote) {
+        if (!this.ongoingClosestPeersRequests.has(peer.getNodeId())) {
+            return
+        }
+        this.ongoingClosestPeersRequests.delete(peer.getNodeId())
+        this.config.peerManager.removeContact(peer.getNodeId())
+    }
+
+    private findMoreContacts(): void {
+        if (this.stopped) {
+            return
+        }
+        const uncontacted = this.config.peerManager.getClosestRingContactsTo(
+            this.config.targetId,
+            this.config.parallelism,
+            this.config.contactedPeers
+        )
+        if ((uncontacted.left.length === 0 && uncontacted.right.length === 0)
+            || this.noProgressCounter >= this.config.noProgressLimit) {
+            this.emitter.emit('discoveryCompleted')
+            this.stopped = true
+            return
+        }
+        // ask from both sides equally
+        const merged = []
+        const alreadyInMerged: Set<DhtAddress> = new Set()
+        const length = Math.max(uncontacted.left.length, uncontacted.right.length)
+        for (let i = 0; i < length; i++) {
+            if (i < uncontacted.left.length) {
+                if (!alreadyInMerged.has(uncontacted.left[i].getNodeId())) {
+                    merged.push(uncontacted.left[i])
+                    alreadyInMerged.add(uncontacted.left[i].getNodeId())
+                }
+            }
+            if (i < uncontacted.right.length) {
+                if (!alreadyInMerged.has(uncontacted.right[i].getNodeId())) {
+                    merged.push(uncontacted.right[i])
+                    alreadyInMerged.add(uncontacted.right[i].getNodeId())
+                }
+            }
+        }
+
+        for (const nextPeer of merged) {
+            if (this.ongoingClosestPeersRequests.size >= this.config.parallelism) {
+                break
+            }
+            this.ongoingClosestPeersRequests.add(nextPeer.getNodeId())
+            // eslint-disable-next-line promise/catch-or-return
+            this.getClosestPeersFromContact(nextPeer)
+                .then((contacts) => this.onClosestPeersRequestSucceeded(nextPeer.getNodeId(), contacts))
+                .catch(() => this.onClosestPeersRequestFailed(nextPeer))
+                .finally(() => {
+                    this.findMoreContacts()
+                })
+        }
+    }
+
+    public async findClosestNodes(timeout: number): Promise<void> {
+        if (this.config.peerManager.getContactCount(this.config.contactedPeers) === 0) {
+            return
+        }
+        // TODO add abortController and signal it in stop()
+        await runAndWaitForEvents3<RingDiscoverySessionEvents>(
+            [this.findMoreContacts.bind(this)],
+            [[this.emitter, 'discoveryCompleted']],
+            timeout
+        )
+    }
+
+    public stop(): void {
+        this.stopped = true
+        this.emitter.emit('discoveryCompleted')
+        this.emitter.removeAllListeners()
+    }
+}

package/src/dht/recursive-operation/RecursiveOperationManager.ts

@@ -115,7 +115,7 @@ export class RecursiveOperationManager {
                     15000
                 )
             } catch (err) {
-                logger.debug(`start failed with error ${err}`)
+                logger.debug('start failed', { err })
             }
         } else {
             session.start(this.config.serviceId)

package/src/dht/recursive-operation/RecursiveOperationRpcRemote.ts

@@ -35,7 +35,7 @@ export class RecursiveOperationRpcRemote extends RpcRemote<RecursiveOperationRpc
                 ? getNodeIdFromPeerDescriptor(previousPeer)
                 : getNodeIdFromPeerDescriptor(params.sourcePeer!)
             const toNode = getNodeIdFromPeerDescriptor(this.getPeerDescriptor())
-            logger.debug(`Failed to send routeRequest message from ${fromNode} to ${toNode} with: ${err}`)
+            logger.debug(`Failed to send routeRequest message from ${fromNode} to ${toNode}`, { err })
             return false
         }
         return true

package/src/dht/recursive-operation/RecursiveOperationSession.ts

@@ -8,8 +8,7 @@ import {
     RouteMessageWrapper,
     RouteMessageAck,
     RecursiveOperationRequest,
-    Message,
-    MessageType
+    Message
 } from '../../proto/packages/dht/protos/DhtRpc'
 import { ITransport } from '../../transport/ITransport'
 import { ListeningRpcCommunicator } from '../../transport/ListeningRpcCommunicator'
@@ -90,7 +89,6 @@ export class RecursiveOperationSession extends EventEmitter<RecursiveOperationSe
             operation: this.config.operation
         }
         const msg: Message = {
-            messageType: MessageType.RECURSIVE_OPERATION_REQUEST,
             messageId: v4(),
             serviceId,
             body: {

package/src/dht/routing/Router.ts

@@ -13,7 +13,6 @@ export interface RouterConfig {
     rpcCommunicator: RoutingRpcCommunicator
     localPeerDescriptor: PeerDescriptor
     connections: Map<DhtAddress, DhtNodeRpcRemote>
-    addContact: (contact: PeerDescriptor, setActive?: boolean) => void
     handleMessage: (message: Message) => void
 }
 
@@ -42,7 +41,6 @@ export class Router {
     private registerLocalRpcMethods() {
         const rpcLocal = new RouterRpcLocal({
             doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => this.doRouteMessage(routedMessage, mode),
-            addContact: (contact: PeerDescriptor, setActive: boolean) => this.config.addContact(contact, setActive),
             setForwardingEntries: (routedMessage: RouteMessageWrapper) => this.setForwardingEntries(routedMessage),
             duplicateRequestDetector: this.duplicateRequestDetector,
             localPeerDescriptor: this.config.localPeerDescriptor,

package/src/dht/routing/RouterRpcLocal.ts

@@ -8,7 +8,6 @@ import { v4 } from 'uuid'
 
 interface RouterRpcLocalConfig {
     doRouteMessage: (routedMessage: RouteMessageWrapper, mode?: RoutingMode) => RouteMessageAck
-    addContact: (contact: PeerDescriptor, setActive: boolean) => void
     setForwardingEntries: (routedMessage: RouteMessageWrapper) => void
     handleMessage: (message: Message) => void
     duplicateRequestDetector: DuplicateDetector

package/src/dht/routing/RouterRpcRemote.ts

@@ -39,7 +39,7 @@ export class RouterRpcRemote extends RpcRemote<RouterRpcClient> {
                 ? getNodeIdFromPeerDescriptor(previousPeer)
                 : getNodeIdFromPeerDescriptor(params.sourcePeer!)
             const toNode = getNodeIdFromPeerDescriptor(this.getPeerDescriptor())
-            logger.trace(`Failed to send routeMessage from ${fromNode} to ${toNode} with: ${err}`)
+            logger.trace(`Failed to send routeMessage from ${fromNode} to ${toNode}`, { err })
             return false
         }
         return true
@@ -69,7 +69,7 @@ export class RouterRpcRemote extends RpcRemote<RouterRpcClient> {
                 ? getNodeIdFromPeerDescriptor(previousPeer)
                 : getNodeIdFromPeerDescriptor(params.sourcePeer!)
             const toNode = getNodeIdFromPeerDescriptor(this.getPeerDescriptor())
-            logger.trace(`Failed to send forwardMessage from ${fromNode} to ${toNode} with: ${err}`)
+            logger.trace(`Failed to send forwardMessage from ${fromNode} to ${toNode}`, { err })
             return false
         }
         return true

package/src/dht/routing/RoutingSession.ts

@@ -212,8 +212,8 @@ export class RoutingSession extends EventEmitter<RoutingSessionEvents> {
                     } else {
                         this.onRequestFailed(nextPeer!.getNodeId())
                     }
-                } catch (e) {
-                    logger.debug('Unable to route message ', { error: e })
+                } catch (err) {
+                    logger.debug('Unable to route message ', { err })
                 } finally {
                     logger.trace('sendRouteMessageRequest returned')
                 }

package/src/dht/store/LocalDataStore.ts

@@ -1,6 +1,6 @@
 import { DataEntry } from '../../proto/packages/dht/protos/DhtRpc'
-import { MapWithTtl } from '../../helpers/MapWithTtl'
 import { DhtAddress, getDhtAddressFromRaw } from '../../identifiers'
+import { MapWithTtl } from '@streamr/utils'
 
 export class LocalDataStore {
 

package/src/dht/store/StoreManager.ts

@@ -98,7 +98,7 @@ export class StoreManager {
 
     public async storeDataToDht(key: DhtAddress, data: Any, creator: DhtAddress): Promise<PeerDescriptor[]> {
         logger.debug(`Storing data to DHT ${this.config.serviceId}`)
-        const result = await this.config.recursiveOperationManager.execute(key, RecursiveOperation.FIND_NODE)
+        const result = await this.config.recursiveOperationManager.execute(key, RecursiveOperation.FIND_CLOSEST_NODES)
         const closestNodes = result.closestNodes
         const successfulNodes: PeerDescriptor[] = []
         const ttl = this.config.highestTtl // ToDo: make TTL decrease according to some nice curve
@@ -158,7 +158,7 @@ export class StoreManager {
                 try {
                     await rpcRemote.replicateData({ entry: dataEntry })
                 } catch (err) {
-                    logger.trace('Failed to replicate data in replicateDataToClosestNodes', { error: err })
+                    logger.trace('Failed to replicate data in replicateDataToClosestNodes', { err })
                 }
             }))
         }))

package/src/exports.ts

@@ -7,16 +7,17 @@ export { getRandomRegion, getRegionDelayMatrix } from './connection/simulator/pi
 export { PeerDescriptor, Message, NodeType, DataEntry } from './proto/packages/dht/protos/DhtRpc'
 export { ITransport } from './transport/ITransport'
 export { ConnectionManager, ConnectionLocker, PortRange, TlsCertificate } from './connection/ConnectionManager'
-export { LockID } from './connection/ConnectionLockHandler'
+export { LockID } from './connection/ConnectionLockStates'
 export { DefaultConnectorFacade } from './connection/ConnectorFacade'
 export { DhtRpcOptions } from './rpc-protocol/DhtRpcOptions'
 export { RpcRemote, EXISTING_CONNECTION_TIMEOUT } from './dht/contact/RpcRemote'
 export { IceServer } from './connection/webrtc/WebrtcConnector'
 export { DhtCallContext } from './rpc-protocol/DhtCallContext'
-export { ClientWebsocket } from './connection/websocket/ClientWebsocket'
+export { WebsocketClientConnection } from './connection/websocket/NodeWebsocketClientConnection'
 export { ManagedConnection } from './connection/ManagedConnection'
 export { ConnectionType } from './connection/IConnection'
 export { ServiceID } from './types/ServiceID'
+export { RingContacts } from './dht/contact/RingContactList'
 export { 
     DhtAddress,
     DhtAddressRaw,

package/src/helpers/createPeerDescriptor.ts

@@ -29,7 +29,7 @@ const calculateNodeIdRaw = (ipAddress: number, privateKey: Uint8Array): DhtAddre
     return nodeIdRaw
 }
 
-export const createPeerDescriptor = (connectivityResponse: ConnectivityResponse, nodeId?: DhtAddress): PeerDescriptor => {
+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
@@ -42,6 +42,7 @@ export const createPeerDescriptor = (connectivityResponse: ConnectivityResponse,
         nodeId: nodeIdRaw,
         type: isBrowserEnvironment() ? NodeType.BROWSER : NodeType.NODEJS,
         ipAddress: connectivityResponse.ipAddress,
+        region,
         publicKey 
     }
     if (connectivityResponse.websocket) {

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/proto/packages/dht/protos/DhtRpc.client.ts

@@ -4,8 +4,8 @@
 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 { DisconnectNotice } from "./DhtRpc";
 import type { UnlockRequest } from "./DhtRpc";
@@ -35,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";
@@ -48,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);
      */
@@ -73,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);
     }
 }
@@ -352,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);
      */
@@ -370,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);

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

@@ -3,8 +3,8 @@
 // tslint:disable
 import { ExternalStoreDataResponse } from "./DhtRpc";
 import { ExternalStoreDataRequest } from "./DhtRpc";
-import { ExternalFindDataResponse } from "./DhtRpc";
-import { ExternalFindDataRequest } from "./DhtRpc";
+import { ExternalFetchDataResponse } from "./DhtRpc";
+import { ExternalFetchDataRequest } from "./DhtRpc";
 import { DisconnectNotice } from "./DhtRpc";
 import { UnlockRequest } from "./DhtRpc";
 import { LockResponse } from "./DhtRpc";
@@ -24,6 +24,8 @@ import { Empty } from "../../../google/protobuf/empty";
 import { LeaveNotice } from "./DhtRpc";
 import { PingResponse } from "./DhtRpc";
 import { PingRequest } from "./DhtRpc";
+import { ClosestRingPeersResponse } from "./DhtRpc";
+import { ClosestRingPeersRequest } from "./DhtRpc";
 import { ClosestPeersResponse } from "./DhtRpc";
 import { ClosestPeersRequest } from "./DhtRpc";
 import { ServerCallContext } from "@protobuf-ts/runtime-rpc";
@@ -35,6 +37,10 @@ export interface IDhtNodeRpc<T = ServerCallContext> {
      * @generated from protobuf rpc: getClosestPeers(dht.ClosestPeersRequest) returns (dht.ClosestPeersResponse);
      */
     getClosestPeers(request: ClosestPeersRequest, context: T): Promise<ClosestPeersResponse>;
+    /**
+     * @generated from protobuf rpc: getClosestRingPeers(dht.ClosestRingPeersRequest) returns (dht.ClosestRingPeersResponse);
+     */
+    getClosestRingPeers(request: ClosestRingPeersRequest, context: T): Promise<ClosestRingPeersResponse>;
     /**
      * @generated from protobuf rpc: ping(dht.PingRequest) returns (dht.PingResponse);
      */
@@ -140,9 +146,9 @@ export interface IConnectionLockRpc<T = ServerCallContext> {
  */
 export interface IExternalApiRpc<T = ServerCallContext> {
     /**
-     * @generated from protobuf rpc: externalFindData(dht.ExternalFindDataRequest) returns (dht.ExternalFindDataResponse);
+     * @generated from protobuf rpc: externalFetchData(dht.ExternalFetchDataRequest) returns (dht.ExternalFetchDataResponse);
      */
-    externalFindData(request: ExternalFindDataRequest, context: T): Promise<ExternalFindDataResponse>;
+    externalFetchData(request: ExternalFetchDataRequest, context: T): Promise<ExternalFetchDataResponse>;
     /**
      * @generated from protobuf rpc: externalStoreData(dht.ExternalStoreDataRequest) returns (dht.ExternalStoreDataResponse);
      */