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

package/src/dht/contact/RingContactList.ts

@@ -0,0 +1,151 @@
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+import { OrderedMap } from '@js-sdsl/ordered-map'
+import { RingDistance, RingId, RingIdRaw, getLeftDistance, getRightDistance, getRingIdFromPeerDescriptor, getRingIdFromRaw } from './ringIdentifiers'
+import { DhtAddress, getNodeIdFromPeerDescriptor } from '../../identifiers'
+import EventEmitter from 'eventemitter3'
+
+export interface RingContacts { 
+    left: PeerDescriptor[]
+    right: PeerDescriptor[]
+}
+export interface RingContactListEvents {  
+    ringContactAdded: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
+    ringContactRemoved: (peerDescriptor: PeerDescriptor, closestPeers: RingContacts) => void
+}
+export class RingContactList<C extends { getPeerDescriptor(): PeerDescriptor }> extends EventEmitter<RingContactListEvents> {
+
+    private readonly numNeighborsPerSide = 5
+    private readonly referenceId: RingId
+    private readonly excludedIds: Set<DhtAddress>
+    private readonly leftNeighbors: OrderedMap<RingDistance, C>
+    private readonly rightNeighbors: OrderedMap<RingDistance, C>
+    private readonly emitEvents: boolean
+
+    constructor(rawReferenceId: RingIdRaw, emitEvents: boolean, excludedIds?: Set<DhtAddress>) {
+        super()
+        this.referenceId = getRingIdFromRaw(rawReferenceId)
+        this.emitEvents = emitEvents
+        this.excludedIds = excludedIds ?? new Set()
+        this.leftNeighbors = new OrderedMap<RingDistance, C>()
+        this.rightNeighbors = new OrderedMap<RingDistance, C>()
+    }
+
+    addContact(contact: C): void {
+        const id = getRingIdFromPeerDescriptor(contact.getPeerDescriptor())
+        if (id === this.referenceId || this.excludedIds.has(getNodeIdFromPeerDescriptor(contact.getPeerDescriptor()))) {
+            return
+        }
+        let elementAdded = false
+        let elementRemoved = false
+
+        const leftDistance = getLeftDistance(this.referenceId, id)
+        const lastLeftNeighbor = this.leftNeighbors.back()
+        if (lastLeftNeighbor === undefined || leftDistance < lastLeftNeighbor[0]) {
+            this.leftNeighbors.setElement(leftDistance, contact)
+            elementAdded = true
+            if (this.leftNeighbors.size() > this.numNeighborsPerSide) {
+                this.leftNeighbors.eraseElementByIterator(this.leftNeighbors.rBegin())
+                elementRemoved = true
+            }
+        }
+
+        const rightDistance = getRightDistance(this.referenceId, id)
+        const lastRightNeighbor = this.rightNeighbors.back()
+        if (lastRightNeighbor === undefined || rightDistance < lastRightNeighbor[0]) {
+            this.rightNeighbors.setElement(rightDistance, contact)
+            elementAdded = true
+            if (this.rightNeighbors.size() > this.numNeighborsPerSide) {
+                this.rightNeighbors.eraseElementByIterator(this.rightNeighbors.rBegin())
+                elementRemoved = true
+            }
+        }
+
+        if (this.emitEvents && (elementAdded || elementRemoved)) {
+            const closestContacts = this.getClosestContacts()
+            const closestDescriptors = { 
+                left: closestContacts.left.map((c) => c.getPeerDescriptor()), 
+                right: closestContacts.right.map((c) => c.getPeerDescriptor())
+            }
+            if (elementAdded) {
+                this.emit('ringContactAdded', contact.getPeerDescriptor(), closestDescriptors)
+            }
+            if (elementRemoved) {
+                this.emit('ringContactRemoved', contact.getPeerDescriptor(), closestDescriptors)
+            }
+        }
+    }
+
+    removeContact(contact?: C): void {
+        if (contact === undefined) {
+            return
+        }
+
+        const id = getRingIdFromPeerDescriptor(contact.getPeerDescriptor())
+        const leftDistance = getLeftDistance(this.referenceId, id)
+        const rightDistance = getRightDistance(this.referenceId, id)
+
+        let elementRemoved = false
+        if (this.leftNeighbors.eraseElementByKey(leftDistance)) {
+            elementRemoved = true
+        }
+        if (this.rightNeighbors.eraseElementByKey(rightDistance)) {
+            elementRemoved = true
+        }
+
+        if (this.emitEvents && elementRemoved) {
+            const closestContacts = this.getClosestContacts()
+            const closestDescriptors = { left: closestContacts.left.map((c) => c.getPeerDescriptor()), 
+                right: closestContacts.right.map((c) => c.getPeerDescriptor()) }
+            this.emit('ringContactRemoved', contact.getPeerDescriptor(), closestDescriptors)
+        }
+    }
+
+    getContact(peerDescriptor: PeerDescriptor): C | undefined {
+        const id = getRingIdFromPeerDescriptor(peerDescriptor)
+        const leftDistance = getLeftDistance(this.referenceId, id)
+        const rightDistance = getRightDistance(this.referenceId, id)
+        if (this.leftNeighbors.getElementByKey(leftDistance)) {
+            return this.leftNeighbors.getElementByKey(leftDistance)
+        }
+        if (this.rightNeighbors.getElementByKey(rightDistance)) {
+            return this.rightNeighbors.getElementByKey(rightDistance)
+        }
+        return undefined
+    }
+
+    getClosestContacts(limitPerSide?: number): { left: C[], right: C[] } {
+        const leftContacts: C[] = []
+        const rightContacts: C[] = []
+
+        let leftCount = 0
+        for (const item of this.leftNeighbors) {
+            if (limitPerSide != undefined && leftCount >= limitPerSide) {
+                break
+            }
+            leftContacts.push(item[1])
+            leftCount++
+        } 
+
+        let rightCount = 0
+        for (const item of this.rightNeighbors) {
+            if (limitPerSide != undefined && rightCount >= limitPerSide) {
+                break
+            }
+            rightContacts.push(item[1])
+            rightCount++
+        }
+
+        return { left: leftContacts, right: rightContacts }
+    }
+
+    getAllContacts(): C[] {
+        const ret: C[] = []
+        for (const item of this.leftNeighbors) {
+            ret.push(item[1])
+        }
+        for (const item of this.rightNeighbors) {
+            ret.push(item[1])
+        }
+        return ret
+    }
+}

package/src/dht/contact/ringIdentifiers.ts

@@ -0,0 +1,62 @@
+import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
+
+// Notice: you cannot convert RingId to RingIdRaw, because 
+// RingId is only an approximation of the actual value.
+// That is why RingIdRaw is widely used in the codebase.
+
+export type RingIdRaw = Uint8Array & { __ringIdRaw: never }
+export type RingId = number & { __ringId: never }
+export type RingDistance = number & { __ringDistance: never }
+
+export const RING_SIZE = 2 ** 120 - 1   // 2^120 - 1
+
+const binaryToBigInt = (binary: Uint8Array): bigint => {
+    return binary.reduce((acc, val) => (acc << BigInt(8)) | BigInt(val), BigInt(0))
+}
+
+export const getRingIdFromRaw = (raw: RingIdRaw): RingId => Number(binaryToBigInt(raw)) as RingId
+
+export const getRingIdRawFromPeerDescriptor = (peerDescriptor: PeerDescriptor): RingIdRaw => {
+    const regionAsBuffer = Buffer.alloc(4)
+    regionAsBuffer.writeUInt32BE(peerDescriptor.region ?? 0, 0)
+    const ipAsbuffer = Buffer.alloc(4)
+    ipAsbuffer.writeUInt32BE(peerDescriptor.ipAddress ?? 0, 0)
+    
+    const uniquePartAsBuffer = Buffer.from(peerDescriptor.nodeId.subarray(peerDescriptor.nodeId.length - 7, peerDescriptor.nodeId.length))
+
+    const arr = [
+        regionAsBuffer,
+        ipAsbuffer,
+        uniquePartAsBuffer
+    ]
+
+    const buffer = Buffer.concat(arr)
+    return new Uint8Array(buffer) as RingIdRaw
+}
+
+export const getRingIdFromPeerDescriptor = (peerDescriptor: PeerDescriptor): RingId => {
+    const raw = getRingIdRawFromPeerDescriptor(peerDescriptor)
+    return Number(binaryToBigInt(raw)) as RingId    
+}
+
+export const getLeftDistance = (referenceId: RingId, id: RingId): RingDistance =>{
+    const diff = Math.abs(referenceId - id)
+    if (referenceId > id) {
+        // if id is smaller than referenceId, then the distance is the difference
+        return diff as RingDistance
+    } else {
+        // if id is bigger than referenceId, then the distance is the ringSize - difference
+        return RING_SIZE - diff as RingDistance
+    }
+}
+
+export const getRightDistance = (referenceId: RingId, id: RingId): RingDistance => {
+    const diff = Math.abs(referenceId - id)
+    if (referenceId > id) {
+        // if id is smaller than referenceId, then the distance is the ringSize - difference
+        return RING_SIZE - diff as RingDistance
+    } else {
+        // if id is bigger than referenceId, then the distance is the difference
+        return diff as RingDistance
+    }
+}

package/src/dht/discovery/PeerDiscovery.ts

@@ -6,6 +6,8 @@ import { ConnectionManager } from '../../connection/ConnectionManager'
 import { PeerManager } from '../PeerManager'
 import { DhtAddress, areEqualPeerDescriptors, getDhtAddressFromRaw, getNodeIdFromPeerDescriptor, getRawFromDhtAddress } from '../../identifiers'
 import { ServiceID } from '../../types/ServiceID'
+import { RingDiscoverySession } from './RingDiscoverySession'
+import { RingIdRaw, getRingIdRawFromPeerDescriptor } from '../contact/ringIdentifiers'
 
 interface PeerDiscoveryConfig {
     localPeerDescriptor: PeerDescriptor
@@ -29,6 +31,8 @@ const logger = new Logger(module)
 export class PeerDiscovery {
 
     private ongoingDiscoverySessions: Map<string, DiscoverySession> = new Map()
+    private ongoingRingDiscoverySessions: Map<string, RingDiscoverySession> = new Map()
+    
     private rejoinOngoing = false
     private joinCalled = false
     private readonly abortController: AbortController
@@ -86,6 +90,12 @@ export class PeerDiscovery {
 
     }
 
+    async joinRing(): Promise<void> {
+        const contactedPeers = new Set<DhtAddress>()
+        const sessions = [this.createRingSession(getRingIdRawFromPeerDescriptor(this.config.localPeerDescriptor), contactedPeers)]
+        await this.runRingSessions(sessions)
+    }
+
     private createSession(targetId: DhtAddress, contactedPeers: Set<DhtAddress>): DiscoverySession {
         const sessionOptions = {
             targetId,
@@ -97,6 +107,17 @@ export class PeerDiscovery {
         return new DiscoverySession(sessionOptions)
     }
 
+    private createRingSession(targetId: RingIdRaw, contactedPeers: Set<DhtAddress>): RingDiscoverySession {
+        const sessionOptions = {
+            targetId,
+            parallelism: this.config.parallelism,
+            noProgressLimit: this.config.joinNoProgressLimit,
+            peerManager: this.config.peerManager,
+            contactedPeers
+        }
+        return new RingDiscoverySession(sessionOptions)
+    }
+
     private async runSessions(sessions: DiscoverySession[], entryPointDescriptor: PeerDescriptor, retry: boolean): Promise<void> {
         try {
             for (const session of sessions) {
@@ -121,6 +142,19 @@ export class PeerDiscovery {
         }
     }
 
+    private async runRingSessions(sessions: RingDiscoverySession[]): Promise<void> {
+        try {
+            for (const session of sessions) {
+                this.ongoingRingDiscoverySessions.set(session.id, session)
+                await session.findClosestNodes(this.config.joinTimeout)
+            }
+        } catch (_e) {
+            logger.debug(`Ring join on ${this.config.serviceId} timed out`)
+        } finally {
+            sessions.forEach((session) => this.ongoingDiscoverySessions.delete(session.id))
+        }
+    }
+
     public async rejoinDht(entryPoint: PeerDescriptor): Promise<void> {
         if (this.isStopped() || this.rejoinOngoing) {
             return
@@ -184,5 +218,8 @@ export class PeerDiscovery {
         this.ongoingDiscoverySessions.forEach((session) => {
             session.stop()
         })
+        this.ongoingRingDiscoverySessions.forEach((session) => {
+            session.stop()
+        })
     }
 }

package/src/dht/discovery/RingDiscoverySession.ts

@@ -0,0 +1,160 @@
+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
+        }
+        this.config.peerManager.addContact(contacts)
+    }
+
+    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/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/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

package/src/exports.ts

@@ -17,6 +17,7 @@ export { ClientWebsocket } from './connection/websocket/ClientWebsocket'
 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);
      */