@streamr/trackerless-network 100.0.0-testnet-three.6 → 100.1.0

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

@@ -1,33 +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,
-    serializeGroupKeyRequest as serializeOldGroupKeyRequest,
-    serializeGroupKeyResponse as serializeOldGroupKeyResponse,
-    deserializeGroupKeyRequest as deserializeOldGroupKeyRequest,
-    deserializeGroupKeyResponse as deserializeOldGroupKeyResponse
+    StreamID,
+    StreamMessage as OldStreamMessage,
+    StreamMessageType as OldStreamMessageType
 } from '@streamr/protocol'
 import {
     ContentType,
-    GroupKey,
     EncryptionType,
+    GroupKey,
     GroupKeyRequest,
     GroupKeyResponse,
+    MessageID,
     MessageRef,
     SignatureType,
-    StreamMessage,
-    StreamMessageType,
-    MessageID
+    StreamMessage
 } from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
-import { toEthereumAddress, binaryToHex, hexToBinary } from '@streamr/utils'
-import { GroupKeyRequestTranslator } from './GroupKeyRequestTranslator'
-import { GroupKeyResponseTranslator } from './GroupKeyResponseTranslator'
+import { binaryToHex, hexToBinary, toEthereumAddress } from '@streamr/utils'
 
 const oldToNewEncryptionType = (type: OldEncryptionType): EncryptionType => {
     if (type === OldEncryptionType.AES) {
@@ -61,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
 }
 
@@ -68,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
 
 }
@@ -76,24 +75,6 @@ const newToOldSignatureType = (type: SignatureType): OldSignatureType => {
 export class StreamMessageTranslator {
 
     static toProtobuf(msg: OldStreamMessage): StreamMessage {
-        let content: Uint8Array
-        let messageType: StreamMessageType
-        if (msg.messageType === OldStreamMessageType.MESSAGE) {
-            content = msg.content
-            messageType = StreamMessageType.MESSAGE
-        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_REQUEST) {
-            content = GroupKeyRequest.toBinary(
-                GroupKeyRequestTranslator.toProtobuf(deserializeOldGroupKeyRequest(msg.content))
-            )
-            messageType = StreamMessageType.GROUP_KEY_REQUEST
-        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_RESPONSE) {
-            content = GroupKeyResponse.toBinary(
-                GroupKeyResponseTranslator.toProtobuf(deserializeOldGroupKeyResponse(msg.content))
-            )
-            messageType = StreamMessageType.GROUP_KEY_RESPONSE
-        } else {
-            throw new Error('invalid message type')
-        }
         const messageId: MessageID = {
             timestamp: msg.getTimestamp(),
             sequenceNumber: msg.getSequenceNumber(),
@@ -106,52 +87,81 @@ export class StreamMessageTranslator {
         if (msg.prevMsgRef) {
             previousMessageRef = {
                 timestamp: msg.prevMsgRef.timestamp,
-                sequenceNumber: msg.prevMsgRef.sequenceNumber,
+                sequenceNumber: msg.prevMsgRef.sequenceNumber
             }
         }
-        let newGroupKey: GroupKey | undefined = undefined
-        if (msg.newGroupKey) {
-            newGroupKey = {
-                id: msg.newGroupKey.id,
-                data: msg.newGroupKey.data
+        let body: StreamMessage['body']
+        if (msg.messageType === OldStreamMessageType.MESSAGE) {
+            let newGroupKey: GroupKey | undefined = undefined
+            if (msg.newGroupKey) {
+                newGroupKey = {
+                    id: msg.newGroupKey.id,
+                    data: msg.newGroupKey.data
+                }
+            }
+            body = {
+                oneofKind: 'contentMessage',
+                contentMessage: {
+                    content: msg.content,
+                    contentType: oldToNewContentType(msg.contentType),
+                    encryptionType: oldToNewEncryptionType(msg.encryptionType),
+                    groupKeyId: msg.groupKeyId ?? undefined,
+                    newGroupKey
+                }
+            }
+        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_REQUEST) {
+            body = {
+                oneofKind: 'groupKeyRequest',
+                groupKeyRequest: GroupKeyRequest.fromBinary(msg.content)
             }
+        } else if (msg.messageType === OldStreamMessageType.GROUP_KEY_RESPONSE) {
+            body = {
+                oneofKind: 'groupKeyResponse',
+                groupKeyResponse: GroupKeyResponse.fromBinary(msg.content)
+            }
+        } else {
+            throw new Error('invalid message type')
         }
         const translated: StreamMessage = {
             messageId,
             previousMessageRef,
-            content,
-            messageType,
-            contentType: oldToNewContentType(msg.contentType),
-            encryptionType: oldToNewEncryptionType(msg.encryptionType),
-            groupKeyId: msg.groupKeyId ?? undefined,
-            newGroupKey,
             signature: msg.signature,
             signatureType: oldToNewSignatureType(msg.signatureType),
+            body
         }
         return translated
     }
 
     static toClientProtocol(msg: StreamMessage): OldStreamMessage {
-        let content: Uint8Array
         let messageType: OldStreamMessageType
-        if (msg.messageType === StreamMessageType.MESSAGE) {
+        let content: Uint8Array
+        let contentType: OldContentType = OldContentType.BINARY
+        let encryptionType: OldEncryptionType = OldEncryptionType.NONE
+        let newGroupKey: OldEncryptedGroupKey | undefined = undefined
+        let groupKeyId: string | undefined = undefined
+        if (msg.body.oneofKind === 'contentMessage') {
             messageType = OldStreamMessageType.MESSAGE
-            content = msg.content
-        } else if (msg.messageType === StreamMessageType.GROUP_KEY_REQUEST) {
+            content = msg.body.contentMessage.content
+            contentType = newToOldContentType(msg.body.contentMessage.contentType)
+            encryptionType = newToOldEncryptionType(msg.body.contentMessage.encryptionType)
+            if (msg.body.contentMessage.newGroupKey) {
+                newGroupKey = new OldEncryptedGroupKey(
+                    msg.body.contentMessage.newGroupKey.id,
+                    msg.body.contentMessage.newGroupKey.data
+                )
+            }
+            groupKeyId = msg.body.contentMessage.groupKeyId
+        } else if (msg.body.oneofKind === 'groupKeyRequest') {
             messageType = OldStreamMessageType.GROUP_KEY_REQUEST
             try {
-                const parsedRequest = GroupKeyRequest.fromBinary(msg.content)
-                const oldGroupKeyRequest = GroupKeyRequestTranslator.toClientProtocol(parsedRequest)
-                content = serializeOldGroupKeyRequest(oldGroupKeyRequest)
+                content = GroupKeyRequest.toBinary(msg.body.groupKeyRequest)
             } catch (err) {
                 throw new Error(`invalid group key request: ${err}`)
             }
-        } else if (msg.messageType === StreamMessageType.GROUP_KEY_RESPONSE) {
+        } else if (msg.body.oneofKind === 'groupKeyResponse') {
             messageType = OldStreamMessageType.GROUP_KEY_RESPONSE
             try {
-                const parsedResponse = GroupKeyResponse.fromBinary(msg.content)
-                const oldGroupKeyResponse = GroupKeyResponseTranslator.toClientProtocol(parsedResponse)
-                content = serializeOldGroupKeyResponse(oldGroupKeyResponse)
+                content = GroupKeyResponse.toBinary(msg.body.groupKeyResponse)
             } catch (err) {
                 throw new Error(`invalid group key response: ${err}`)
             }
@@ -170,24 +180,17 @@ export class StreamMessageTranslator {
         if (msg.previousMessageRef) {
             prevMsgRef = new OldMessageRef(Number(msg.previousMessageRef.timestamp), msg.previousMessageRef.sequenceNumber)
         }
-        let newGroupKey: OldEncryptedGroupKey | undefined = undefined
-        if (msg.newGroupKey) {
-            newGroupKey = new OldEncryptedGroupKey(
-                msg.newGroupKey.id,
-                msg.newGroupKey.data,
-            )
-        }
         const translated = new OldStreamMessage({
             messageId,
             prevMsgRef,
-            content,
             messageType,
-            contentType: newToOldContentType(msg.contentType),
-            encryptionType: newToOldEncryptionType(msg.encryptionType),
-            groupKeyId: msg.groupKeyId,
-            newGroupKey,
+            content,
+            contentType,
             signature: msg.signature,
-            signatureType: newToOldSignatureType(msg.signatureType)
+            signatureType: newToOldSignatureType(msg.signatureType),
+            encryptionType,
+            groupKeyId,
+            newGroupKey
         })
         return translated
     }

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

@@ -1,6 +1,16 @@
-import { StreamMessage as OldStreamMessage } from '@streamr/protocol'
+import { 
+    StreamMessage as OldStreamMessage,
+    GroupKeyRequest as OldGroupKeyRequest,
+    GroupKeyResponse as OldGroupKeyResponse
+} from '@streamr/protocol'
 import { StreamMessageTranslator } from './StreamMessageTranslator'
-import { StreamMessage } from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
+import {
+    StreamMessage,
+    GroupKeyRequest,
+    GroupKeyResponse
+} from '../../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { GroupKeyResponseTranslator } from './GroupKeyResponseTranslator'
+import { GroupKeyRequestTranslator } from './GroupKeyRequestTranslator'
 
 export function convertStreamMessageToBytes(oldStreamMessage: OldStreamMessage): Uint8Array {
     return StreamMessage.toBinary(StreamMessageTranslator.toProtobuf(oldStreamMessage))
@@ -9,3 +19,19 @@ export function convertStreamMessageToBytes(oldStreamMessage: OldStreamMessage):
 export function convertBytesToStreamMessage(bytes: Uint8Array): OldStreamMessage {
     return StreamMessageTranslator.toClientProtocol(StreamMessage.fromBinary(bytes))
 }
+
+export const convertGroupKeyRequestToBytes = (oldGroupKeyRequest: OldGroupKeyRequest): Uint8Array => {
+    return GroupKeyRequest.toBinary(GroupKeyRequestTranslator.toProtobuf(oldGroupKeyRequest))
+}
+
+export const convertBytesToGroupKeyRequest = (bytes: Uint8Array): OldGroupKeyRequest => {
+    return GroupKeyRequestTranslator.toClientProtocol(GroupKeyRequest.fromBinary(bytes))
+}
+
+export const convertGroupKeyResponseToBytes = (oldGroupKeyResponse: OldGroupKeyResponse): Uint8Array => {
+    return GroupKeyResponse.toBinary(GroupKeyResponseTranslator.toProtobuf(oldGroupKeyResponse))
+}
+
+export const convertBytesToGroupKeyResponse = (bytes: Uint8Array): OldGroupKeyResponse => {
+    return GroupKeyResponseTranslator.toClientProtocol(GroupKeyResponse.fromBinary(bytes))
+}

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

@@ -1,16 +1,14 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
 import { 
-    GroupKeyRequest,
     ProxyConnectionRequest,
     ProxyConnectionResponse,
     ProxyDirection,
-    StreamMessage,
-    StreamMessageType
+    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'
@@ -20,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 {
@@ -64,12 +62,12 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
     }
 
     getPropagationTargets(msg: StreamMessage): DhtAddress[] {
-        if (msg.messageType === StreamMessageType.GROUP_KEY_REQUEST) {
+        if (msg.body.oneofKind === 'groupKeyRequest') {
             try {
-                const recipientId = GroupKeyRequest.fromBinary(msg.content).recipientId
+                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 {
@@ -92,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

@@ -5,27 +5,33 @@ import {
     TemporaryConnectionResponse
 } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ITemporaryConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
-import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { ConnectionLocker, DhtAddress, DhtCallContext, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
+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'
 
 interface TemporaryConnectionRpcLocalConfig {
     rpcCommunicator: ListeningRpcCommunicator
     localPeerDescriptor: PeerDescriptor
+    streamPartId: StreamPartID
+    connectionLocker: ConnectionLocker
 } 
 
+const LOCK_ID_BASE = 'system/content-delivery/temporary-connection/'
+
 export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
 
     private readonly config: TemporaryConnectionRpcLocalConfig
     private readonly temporaryNodes: NodeList
-
+    private readonly lockId: string
     constructor(config: TemporaryConnectionRpcLocalConfig) {
         this.config = config
         // TODO use config option or named constant?
         this.temporaryNodes = new NodeList(getNodeIdFromPeerDescriptor(config.localPeerDescriptor), 10)
+        this.lockId = LOCK_ID_BASE + config.streamPartId
     }
 
     getNodes(): NodeList {
@@ -38,6 +44,7 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
 
     removeNode(nodeId: DhtAddress): void {
         this.temporaryNodes.remove(nodeId)
+        this.config.connectionLocker.weakUnlockConnection(nodeId, this.lockId)
     }
 
     async openConnection(
@@ -45,13 +52,14 @@ 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)
         return {
             accepted: true
         }

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

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