@streamr/trackerless-network 100.0.0 → 100.1.1

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

@@ -1,8 +1,8 @@
 import { DhtAddress, PeerDescriptor, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { NodeList } from '../NodeList'
-import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
+import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 import {
-    DeliveryRpcClient, HandshakeRpcClient
+    ContentDeliveryRpcClient, HandshakeRpcClient
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import {
     InterleaveRequest,
@@ -11,7 +11,6 @@ import {
     StreamPartHandshakeResponse
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { Logger } from '@streamr/utils'
-import { IHandshakeRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { HandshakeRpcRemote, INTERLEAVE_REQUEST_TIMEOUT } from './HandshakeRpcRemote'
 import { HandshakeRpcLocal } from './HandshakeRpcLocal'
 import { StreamPartID } from '@streamr/protocol'
@@ -37,7 +36,7 @@ const PARALLEL_HANDSHAKE_COUNT = 2
 export class Handshaker {
 
     private config: HandshakerConfig
-    private readonly rpcLocal: IHandshakeRpc
+    private readonly rpcLocal: HandshakeRpcLocal
 
     constructor(config: HandshakerConfig) {
         this.config = config
@@ -49,7 +48,7 @@ export class Handshaker {
             maxNeighborCount: this.config.maxNeighborCount,
             handshakeWithInterleaving: (target: PeerDescriptor, senderId: DhtAddress) => this.handshakeWithInterleaving(target, senderId),
             createRpcRemote: (target: PeerDescriptor) => this.createRpcRemote(target),
-            createDeliveryRpcRemote: (target: PeerDescriptor) => this.createDeliveryRpcRemote(target)
+            createContentDeliveryRpcRemote: (target: PeerDescriptor) => this.createContentDeliveryRpcRemote(target)
         })
         this.config.rpcCommunicator.registerRpcMethod(InterleaveRequest, InterleaveResponse, 'interleaveRequest',
             (req: InterleaveRequest, context) => this.rpcLocal.interleaveRequest(req, context), { timeout: INTERLEAVE_REQUEST_TIMEOUT })
@@ -77,7 +76,7 @@ export class Handshaker {
     }
 
     private selectParallelTargets(excludedIds: DhtAddress[]): HandshakeRpcRemote[] {
-        const neighbors: Map<DhtAddress, DeliveryRpcRemote> = new Map()
+        const neighbors: Map<DhtAddress, ContentDeliveryRpcRemote> = new Map()
         // First add the closest left and then right contacts from the ring if possible.
         const left = this.config.leftNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
         const right = this.config.rightNodeView.getFirst([...excludedIds, ...Array.from(neighbors.keys())] as DhtAddress[])
@@ -152,7 +151,7 @@ export class Handshaker {
             concurrentNodeId
         )
         if (result.accepted) {
-            this.config.neighbors.add(this.createDeliveryRpcRemote(neighbor.getPeerDescriptor()))
+            this.config.neighbors.add(this.createContentDeliveryRpcRemote(neighbor.getPeerDescriptor()))
         }
         if (result.interleaveTargetDescriptor) {
             await this.handshakeWithInterleaving(result.interleaveTargetDescriptor, targetNodeId)
@@ -172,7 +171,7 @@ export class Handshaker {
             interleaveSourceId
         )
         if (result.accepted) {
-            this.config.neighbors.add(this.createDeliveryRpcRemote(neighbor.getPeerDescriptor()))
+            this.config.neighbors.add(this.createContentDeliveryRpcRemote(neighbor.getPeerDescriptor()))
         }
         this.config.ongoingHandshakes.delete(targetNodeId)
         return result.accepted
@@ -188,12 +187,12 @@ export class Handshaker {
         )
     }
 
-    private createDeliveryRpcRemote(targetPeerDescriptor: PeerDescriptor): DeliveryRpcRemote {
-        return new DeliveryRpcRemote(
+    private createContentDeliveryRpcRemote(targetPeerDescriptor: PeerDescriptor): ContentDeliveryRpcRemote {
+        return new ContentDeliveryRpcRemote(
             this.config.localPeerDescriptor,
             targetPeerDescriptor,
             this.config.rpcCommunicator,
-            DeliveryRpcClient,
+            ContentDeliveryRpcClient,
             this.config.rpcRequestTimeout
         )
     }

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

@@ -1,10 +1,10 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { NeighborUpdate } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcClient } 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 { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 import { NeighborFinder } from './NeighborFinder'
 import { StreamPartID } from '@streamr/protocol'
 
@@ -34,11 +34,11 @@ export class NeighborUpdateRpcLocal implements INeighborUpdateRpc {
             return nodeId !== ownNodeId && !this.config.neighbors.getIds().includes(nodeId)
         })
         newPeerDescriptors.forEach((peerDescriptor) => this.config.nearbyNodeView.add(
-            new DeliveryRpcRemote(
+            new ContentDeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 peerDescriptor,
                 this.config.rpcCommunicator,
-                DeliveryRpcClient
+                ContentDeliveryRpcClient
             ))
         )
     }

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

@@ -26,7 +26,7 @@ export class NeighborUpdateRpcRemote extends RpcRemote<NeighborUpdateRpcClient>
                 removeMe: response.removeMe
             }
         } catch (err: any) {
-            logger.debug(`updateNeighbors to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed: ${err}`)
+            logger.debug(`updateNeighbors to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed`, { err })
             return {
                 peerDescriptors: [],
                 removeMe: true

package/src/logic/protocol-integration/stream-message/StreamMessageTranslator.ts

@@ -1,26 +1,26 @@
 import {
-    MessageID as OldMessageID,
-    StreamMessage as OldStreamMessage,
-    StreamMessageType as OldStreamMessageType,
-    MessageRef as OldMessageRef,
+    ContentType as OldContentType,
     EncryptedGroupKey as OldEncryptedGroupKey,
-    StreamID,
     EncryptionType as OldEncryptionType,
+    MessageID as OldMessageID,
+    MessageRef as OldMessageRef,
     SignatureType as OldSignatureType,
-    ContentType as OldContentType
+    StreamID,
+    StreamMessage as OldStreamMessage,
+    StreamMessageType as OldStreamMessageType
 } from '@streamr/protocol'
 import {
     ContentType,
-    GroupKey,
     EncryptionType,
+    GroupKey,
     GroupKeyRequest,
     GroupKeyResponse,
+    MessageID,
     MessageRef,
     SignatureType,
-    StreamMessage,
-    MessageID
+    StreamMessage
 } from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { toEthereumAddress, binaryToHex, hexToBinary } from '@streamr/utils'
+import { binaryToHex, hexToBinary, toEthereumAddress } from '@streamr/utils'
 
 const oldToNewEncryptionType = (type: OldEncryptionType): EncryptionType => {
     if (type === OldEncryptionType.AES) {
@@ -54,6 +54,9 @@ const oldToNewSignatureType = (type: OldSignatureType): SignatureType => {
     if (type === OldSignatureType.LEGACY_SECP256K1) {
         return SignatureType.LEGACY_SECP256K1
     }
+    if (type === OldSignatureType.ERC_1271) {
+        return SignatureType.ERC_1271
+    }
     return SignatureType.SECP256K1
 }
 
@@ -61,6 +64,9 @@ const newToOldSignatureType = (type: SignatureType): OldSignatureType => {
     if (type === SignatureType.LEGACY_SECP256K1) {
         return OldSignatureType.LEGACY_SECP256K1
     }
+    if (type === SignatureType.ERC_1271) {
+        return OldSignatureType.ERC_1271
+    }
     return OldSignatureType.SECP256K1
 
 }

package/src/logic/proxy/ProxyClient.ts

@@ -17,15 +17,15 @@ import {
     ProxyDirection,
     StreamMessage
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { DeliveryRpcClient, ProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcClient, ProxyConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { DuplicateMessageDetector } from '../DuplicateMessageDetector'
 import { NodeList } from '../NodeList'
-import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
-import { DeliveryRpcLocal } from '../DeliveryRpcLocal'
+import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
+import { ContentDeliveryRpcLocal } from '../ContentDeliveryRpcLocal'
 import { Propagation } from '../propagation/Propagation'
 import { markAndCheckDuplicate } from '../utils'
 import { ProxyConnectionRpcRemote } from './ProxyConnectionRpcRemote'
-import { formStreamPartDeliveryServiceId } from '../formStreamPartDeliveryServiceId'
+import { formStreamPartContentDeliveryServiceId } 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> => {
@@ -74,7 +74,7 @@ const SERVICE_ID = 'system/proxy-client'
 export class ProxyClient extends EventEmitter<Events> {
 
     private readonly rpcCommunicator: ListeningRpcCommunicator
-    private readonly deliveryRpcLocal: DeliveryRpcLocal
+    private readonly contentDeliveryRpcLocal: ContentDeliveryRpcLocal
     private readonly config: ProxyClientConfig
     private readonly duplicateDetectors: Map<string, DuplicateMessageDetector> = new Map()
     private definition?: ProxyDefinition
@@ -86,10 +86,10 @@ export class ProxyClient extends EventEmitter<Events> {
     constructor(config: ProxyClientConfig) {
         super()
         this.config = config
-        this.rpcCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(config.streamPartId), config.transport)
+        this.rpcCommunicator = new ListeningRpcCommunicator(formStreamPartContentDeliveryServiceId(config.streamPartId), config.transport)
         // TODO use config option or named constant?
         this.neighbors = new NodeList(getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor), 1000)
-        this.deliveryRpcLocal = new DeliveryRpcLocal({
+        this.contentDeliveryRpcLocal = new ContentDeliveryRpcLocal({
             localPeerDescriptor: this.config.localPeerDescriptor,
             streamPartId: this.config.streamPartId,
             markAndCheckDuplicate: (msg: MessageID, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
@@ -121,9 +121,9 @@ export class ProxyClient extends EventEmitter<Events> {
 
     private registerDefaultServerMethods(): void {
         this.rpcCommunicator.registerRpcNotification(StreamMessage, 'sendStreamMessage',
-            (msg: StreamMessage, context) => this.deliveryRpcLocal.sendStreamMessage(msg, context))
+            (msg: StreamMessage, context) => this.contentDeliveryRpcLocal.sendStreamMessage(msg, context))
         this.rpcCommunicator.registerRpcNotification(LeaveStreamPartNotice, 'leaveStreamPartNotice',
-            (req: LeaveStreamPartNotice, context) => this.deliveryRpcLocal.leaveStreamPartNotice(req, context))
+            (req: LeaveStreamPartNotice, context) => this.contentDeliveryRpcLocal.leaveStreamPartNotice(req, context))
     }
 
     async setProxies(
@@ -189,11 +189,11 @@ export class ProxyClient extends EventEmitter<Events> {
         if (accepted) {
             this.config.connectionLocker.lockConnection(peerDescriptor, SERVICE_ID)
             this.connections.set(nodeId, { peerDescriptor, direction })
-            const remote = new DeliveryRpcRemote(
+            const remote = new ContentDeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 peerDescriptor,
                 this.rpcCommunicator,
-                DeliveryRpcClient
+                ContentDeliveryRpcClient
             )
             this.neighbors.add(remote)
             this.propagation.onNeighborJoined(nodeId)

package/src/logic/proxy/ProxyConnectionRpcLocal.ts

@@ -6,9 +6,9 @@ import {
     StreamMessage
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { IProxyConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
+import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
-import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { EventEmitter } from 'eventemitter3'
 import { EthereumAddress, Logger, binaryToHex, toEthereumAddress } from '@streamr/utils'
 import { StreamPartID } from '@streamr/protocol'
@@ -18,7 +18,7 @@ const logger = new Logger(module)
 interface ProxyConnection {
     direction: ProxyDirection // Direction is from the client's point of view
     userId: EthereumAddress
-    remote: DeliveryRpcRemote
+    remote: ContentDeliveryRpcRemote
 }
 
 interface ProxyConnectionRpcLocalConfig {
@@ -67,7 +67,7 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
                 const recipientId = msg.body.groupKeyRequest.recipientId
                 return this.getNodeIdsForUserId(toEthereumAddress(binaryToHex(recipientId, true)))
             } catch (err) {
-                logger.trace(`Could not parse GroupKeyRequest: ${err}`)
+                logger.trace(`Could not parse GroupKeyRequest`, { err })
                 return []
             }
         } else {
@@ -90,11 +90,11 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
         this.connections.set(senderId, {
             direction: request.direction,
             userId: toEthereumAddress(binaryToHex(request.userId, true)),
-            remote: new DeliveryRpcRemote(
+            remote: new ContentDeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 senderPeerDescriptor,
                 this.config.rpcCommunicator,
-                DeliveryRpcClient
+                ContentDeliveryRpcClient
             )
         })
         const response: ProxyConnectionResponse = {

package/src/logic/proxy/ProxyConnectionRpcRemote.ts

@@ -19,7 +19,7 @@ export class ProxyConnectionRpcRemote extends RpcRemote<ProxyConnectionRpcClient
             const res = await this.getClient().requestConnection(request, options)
             return res.accepted
         } catch (err) {
-            logger.debug(`ProxyConnectionRequest failed with error: ${err}`)
+            logger.debug(`ProxyConnectionRequest failed with error`, { err })
             return false
         }
     }

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

@@ -6,9 +6,9 @@ import {
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ITemporaryConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
 import { ConnectionLocker, DhtAddress, DhtCallContext, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
-import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ContentDeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { NodeList } from '../NodeList'
-import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
+import { ContentDeliveryRpcRemote } from '../ContentDeliveryRpcRemote'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
 import { Empty } from '../../proto/google/protobuf/empty'
 import { StreamPartID } from '@streamr/protocol'
@@ -20,7 +20,7 @@ interface TemporaryConnectionRpcLocalConfig {
     connectionLocker: ConnectionLocker
 } 
 
-const LOCK_ID_BASE = 'system/delivery/temporary-connection/'
+const LOCK_ID_BASE = 'system/content-delivery/temporary-connection/'
 
 export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
 
@@ -52,11 +52,11 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
         context: ServerCallContext
     ): Promise<TemporaryConnectionResponse> {
         const sender = (context as DhtCallContext).incomingSourceDescriptor!
-        const remote = new DeliveryRpcRemote(
+        const remote = new ContentDeliveryRpcRemote(
             this.config.localPeerDescriptor,
             sender,
             this.config.rpcCommunicator,
-            DeliveryRpcClient
+            ContentDeliveryRpcClient
         )
         this.temporaryNodes.add(remote)
         this.config.connectionLocker.weakLockConnection(getNodeIdFromPeerDescriptor(sender), this.lockId)

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

@@ -11,7 +11,7 @@ export class TemporaryConnectionRpcRemote extends RpcRemote<TemporaryConnectionR
             const response = await this.getClient().openConnection({}, this.formDhtRpcOptions())
             return response.accepted
         } catch (err: any) {
-            logger.debug(`temporaryConnection to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed: ${err}`)
+            logger.debug(`temporaryConnection to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed`, { err })
             return false
         }
     }
@@ -23,7 +23,7 @@ export class TemporaryConnectionRpcRemote extends RpcRemote<TemporaryConnectionR
                 notification: true
             }))
         } catch (err) {
-            logger.trace(`closeConnection to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed: ${err}`)
+            logger.trace(`closeConnection to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed`, { err })
         }
     }
 }

package/src/proto/google/protobuf/any.ts

@@ -73,6 +73,10 @@ import { MessageType } from "@protobuf-ts/runtime";
  *     if (any.is(Foo.class)) {
  *       foo = any.unpack(Foo.class);
  *     }
+ *     // or ...
+ *     if (any.isSameTypeAs(Foo.getDefaultInstance())) {
+ *       foo = any.unpack(Foo.getDefaultInstance());
+ *     }
  *
  *  Example 3: Pack and unpack a message in Python.
  *
@@ -87,10 +91,13 @@ import { MessageType } from "@protobuf-ts/runtime";
  *  Example 4: Pack and unpack a message in Go
  *
  *      foo := &pb.Foo{...}
- *      any, err := ptypes.MarshalAny(foo)
+ *      any, err := anypb.New(foo)
+ *      if err != nil {
+ *        ...
+ *      }
  *      ...
  *      foo := &pb.Foo{}
- *      if err := ptypes.UnmarshalAny(any, foo); err != nil {
+ *      if err := any.UnmarshalTo(foo); err != nil {
  *        ...
  *      }
  *
@@ -100,7 +107,6 @@ import { MessageType } from "@protobuf-ts/runtime";
  * in the type URL, for example "foo.bar.com/x/y.z" will yield type
  * name "y.z".
  *
- *
  * JSON
  * ====
  * The JSON representation of an `Any` value uses the regular
@@ -157,7 +163,8 @@ export interface Any {
      *
      * Note: this functionality is not currently available in the official
      * protobuf release, and it is not used for type URLs beginning with
-     * type.googleapis.com.
+     * type.googleapis.com. As of May 2023, there are no widely used type server
+     * implementations and no plans to implement one.
      *
      * Schemes other than `http`, `https` (or the empty scheme) might be
      * used with implementation specific semantics.

package/src/proto/google/protobuf/empty.ts

@@ -49,7 +49,6 @@ import { MessageType } from "@protobuf-ts/runtime";
  *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
  *     }
  *
- * The JSON representation for `Empty` is empty JSON object `{}`.
  *
  * @generated from protobuf message google.protobuf.Empty
  */

package/src/proto/google/protobuf/timestamp.ts

@@ -97,8 +97,15 @@ import { MessageType } from "@protobuf-ts/runtime";
  *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
  *         .setNanos((int) ((millis % 1000) * 1000000)).build();
  *
+ * Example 5: Compute Timestamp from Java `Instant.now()`.
  *
- * Example 5: Compute Timestamp from current time in Python.
+ *     Instant now = Instant.now();
+ *
+ *     Timestamp timestamp =
+ *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+ *             .setNanos(now.getNano()).build();
+ *
+ * Example 6: Compute Timestamp from current time in Python.
  *
  *     timestamp = Timestamp()
  *     timestamp.GetCurrentTime()
@@ -127,11 +134,10 @@ import { MessageType } from "@protobuf-ts/runtime";
  * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
  * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
  * the Joda Time's [`ISODateTimeFormat.dateTime()`](
- * http://www.joda.org/joda-time/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime%2D%2D
+ * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
  * ) to obtain a formatter capable of generating timestamps in this format.
  *
  *
- *
  * @generated from protobuf message google.protobuf.Timestamp
  */
 export interface Timestamp {

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

@@ -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);
     }
 }

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

@@ -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);
      */

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

@@ -133,6 +133,36 @@ export interface ClosestPeersResponse {
      */
     requestId: string;
 }
+/**
+ * @generated from protobuf message dht.ClosestRingPeersRequest
+ */
+export interface ClosestRingPeersRequest {
+    /**
+     * @generated from protobuf field: bytes ringId = 1;
+     */
+    ringId: Uint8Array;
+    /**
+     * @generated from protobuf field: string requestId = 2;
+     */
+    requestId: string;
+}
+/**
+ * @generated from protobuf message dht.ClosestRingPeersResponse
+ */
+export interface ClosestRingPeersResponse {
+    /**
+     * @generated from protobuf field: repeated dht.PeerDescriptor leftPeers = 1;
+     */
+    leftPeers: PeerDescriptor[];
+    /**
+     * @generated from protobuf field: repeated dht.PeerDescriptor rightPeers = 2;
+     */
+    rightPeers: PeerDescriptor[];
+    /**
+     * @generated from protobuf field: string requestId = 3;
+     */
+    requestId: string;
+}
 /**
  * @generated from protobuf message dht.RecursiveOperationRequest
  */
@@ -764,6 +794,33 @@ class ClosestPeersResponse$Type extends MessageType<ClosestPeersResponse> {
  */
 export const ClosestPeersResponse = new ClosestPeersResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class ClosestRingPeersRequest$Type extends MessageType<ClosestRingPeersRequest> {
+    constructor() {
+        super("dht.ClosestRingPeersRequest", [
+            { no: 1, name: "ringId", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 2, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ClosestRingPeersRequest
+ */
+export const ClosestRingPeersRequest = new ClosestRingPeersRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ClosestRingPeersResponse$Type extends MessageType<ClosestRingPeersResponse> {
+    constructor() {
+        super("dht.ClosestRingPeersResponse", [
+            { no: 1, name: "leftPeers", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor },
+            { no: 2, name: "rightPeers", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => PeerDescriptor },
+            { no: 3, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message dht.ClosestRingPeersResponse
+ */
+export const ClosestRingPeersResponse = new ClosestRingPeersResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class RecursiveOperationRequest$Type extends MessageType<RecursiveOperationRequest> {
     constructor() {
         super("dht.RecursiveOperationRequest", [
@@ -1107,6 +1164,7 @@ export const ExternalFetchDataResponse = new ExternalFetchDataResponse$Type();
  */
 export const DhtNodeRpc = new ServiceType("dht.DhtNodeRpc", [
     { name: "getClosestPeers", options: {}, I: ClosestPeersRequest, O: ClosestPeersResponse },
+    { name: "getClosestRingPeers", options: {}, I: ClosestRingPeersRequest, O: ClosestRingPeersResponse },
     { name: "ping", options: {}, I: PingRequest, O: PingResponse },
     { name: "leaveNotice", options: {}, I: LeaveNotice, O: Empty }
 ]);

package/src/proto/packages/trackerless-network/protos/NetworkRpc.client.ts

@@ -20,7 +20,7 @@ import type { ProxyConnectionResponse } from "./NetworkRpc";
 import type { ProxyConnectionRequest } from "./NetworkRpc";
 import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
 import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
-import { DeliveryRpc } from "./NetworkRpc";
+import { ContentDeliveryRpc } from "./NetworkRpc";
 import type { LeaveStreamPartNotice } from "./NetworkRpc";
 import { stackIntercept } from "@protobuf-ts/runtime-rpc";
 import type { Empty } from "../../../google/protobuf/empty";
@@ -28,9 +28,9 @@ import type { StreamMessage } from "./NetworkRpc";
 import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
 import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
 /**
- * @generated from protobuf service DeliveryRpc
+ * @generated from protobuf service ContentDeliveryRpc
  */
-export interface IDeliveryRpcClient {
+export interface IContentDeliveryRpcClient {
     /**
      * @generated from protobuf rpc: sendStreamMessage(StreamMessage) returns (google.protobuf.Empty);
      */
@@ -41,12 +41,12 @@ export interface IDeliveryRpcClient {
     leaveStreamPartNotice(input: LeaveStreamPartNotice, options?: RpcOptions): UnaryCall<LeaveStreamPartNotice, Empty>;
 }
 /**
- * @generated from protobuf service DeliveryRpc
+ * @generated from protobuf service ContentDeliveryRpc
  */
-export class DeliveryRpcClient implements IDeliveryRpcClient, ServiceInfo {
-    typeName = DeliveryRpc.typeName;
-    methods = DeliveryRpc.methods;
-    options = DeliveryRpc.options;
+export class ContentDeliveryRpcClient implements IContentDeliveryRpcClient, ServiceInfo {
+    typeName = ContentDeliveryRpc.typeName;
+    methods = ContentDeliveryRpc.methods;
+    options = ContentDeliveryRpc.options;
     constructor(private readonly _transport: RpcTransport) {
     }
     /**

package/src/proto/packages/trackerless-network/protos/NetworkRpc.server.ts

@@ -18,9 +18,9 @@ import { Empty } from "../../../google/protobuf/empty";
 import { StreamMessage } from "./NetworkRpc";
 import { ServerCallContext } from "@protobuf-ts/runtime-rpc";
 /**
- * @generated from protobuf service DeliveryRpc
+ * @generated from protobuf service ContentDeliveryRpc
  */
-export interface IDeliveryRpc<T = ServerCallContext> {
+export interface IContentDeliveryRpc<T = ServerCallContext> {
     /**
      * @generated from protobuf rpc: sendStreamMessage(StreamMessage) returns (google.protobuf.Empty);
      */