@streamr/trackerless-network 100.0.0-pretestnet.4 → 100.0.0-rc.0

package/src/logic/proxy/ProxyClient.ts

@@ -1,15 +1,15 @@
 import {
     ConnectionLocker,
+    DhtAddress,
     ITransport,
     ListeningRpcCommunicator,
-    PeerDescriptor
+    PeerDescriptor,
+    getNodeIdFromPeerDescriptor
 } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { StreamPartID } from '@streamr/protocol'
 import { EthereumAddress, Logger, addManagedEventListener, wait } from '@streamr/utils'
 import { EventEmitter } from 'eventemitter3'
 import { sampleSize } from 'lodash'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
 import {
     LeaveStreamPartNotice,
     MessageID,
@@ -27,6 +27,7 @@ import { markAndCheckDuplicate } from '../utils'
 import { ProxyConnectionRpcRemote } from './ProxyConnectionRpcRemote'
 import { formStreamPartDeliveryServiceId } from '../formStreamPartDeliveryServiceId'
 
+// TODO use config option or named constant?
 export const retry = async <T>(task: () => Promise<T>, description: string, abortSignal: AbortSignal, delay = 10000): Promise<T> => {
     // eslint-disable-next-line no-constant-condition
     while (true) {
@@ -51,41 +52,52 @@ interface ProxyClientConfig {
 }
 
 interface ProxyDefinition {
-    nodes: Map<NodeID, PeerDescriptor>
+    nodes: Map<DhtAddress, PeerDescriptor>
     connectionCount: number
     direction: ProxyDirection
     userId: EthereumAddress
 }
 
+interface ProxyConnection {
+    peerDescriptor: PeerDescriptor
+    direction: ProxyDirection
+}
+
+interface Events {
+    message: (message: StreamMessage) => void
+}
+
 const logger = new Logger(module)
 
 const SERVICE_ID = 'system/proxy-client'
 
-export class ProxyClient extends EventEmitter {
+export class ProxyClient extends EventEmitter<Events> {
 
     private readonly rpcCommunicator: ListeningRpcCommunicator
     private readonly deliveryRpcLocal: DeliveryRpcLocal
     private readonly config: ProxyClientConfig
     private readonly duplicateDetectors: Map<string, DuplicateMessageDetector> = new Map()
     private definition?: ProxyDefinition
-    private readonly connections: Map<NodeID, ProxyDirection> = new Map()
+    private readonly connections: Map<DhtAddress, ProxyConnection> = new Map()
     private readonly propagation: Propagation
-    private readonly targetNeighbors: NodeList
+    private readonly neighbors: NodeList
     private readonly abortController: AbortController
 
     constructor(config: ProxyClientConfig) {
         super()
         this.config = config
         this.rpcCommunicator = new ListeningRpcCommunicator(formStreamPartDeliveryServiceId(config.streamPartId), config.transport)
-        this.targetNeighbors = new NodeList(getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor), 1000)
+        // TODO use config option or named constant?
+        this.neighbors = new NodeList(getNodeIdFromPeerDescriptor(this.config.localPeerDescriptor), 1000)
         this.deliveryRpcLocal = new DeliveryRpcLocal({
             localPeerDescriptor: this.config.localPeerDescriptor,
             streamPartId: this.config.streamPartId,
             markAndCheckDuplicate: (msg: MessageID, prev?: MessageRef) => markAndCheckDuplicate(this.duplicateDetectors, msg, prev),
-            broadcast: (message: StreamMessage, previousNode?: NodeID) => this.broadcast(message, previousNode),
-            onLeaveNotice: (senderId: NodeID) => {
-                const contact = this.targetNeighbors.get(senderId)
+            broadcast: (message: StreamMessage, previousNode?: DhtAddress) => this.broadcast(message, previousNode),
+            onLeaveNotice: (senderId: DhtAddress) => {
+                const contact = this.neighbors.get(senderId)
                 if (contact) {
+                    // TODO should we catch possible promise rejection?
                     setImmediate(() => this.onNodeDisconnected(contact.getPeerDescriptor()))
                 }
             },
@@ -93,9 +105,10 @@ export class ProxyClient extends EventEmitter {
             markForInspection: () => {}
         })
         this.propagation = new Propagation({
+            // TODO use config option or named constant?
             minPropagationTargets: config.minPropagationTargets ?? 2,
-            sendToNeighbor: async (neighborId: NodeID, msg: StreamMessage): Promise<void> => {
-                const remote = this.targetNeighbors.get(neighborId)
+            sendToNeighbor: async (neighborId: DhtAddress, msg: StreamMessage): Promise<void> => {
+                const remote = this.neighbors.get(neighborId)
                 if (remote) {
                     await remote.sendStreamMessage(msg)
                 } else {
@@ -121,9 +134,9 @@ export class ProxyClient extends EventEmitter {
     ): Promise<void> {
         logger.trace('Setting proxies', { streamPartId: this.config.streamPartId, peerDescriptors: nodes, direction, userId, connectionCount })
         if (connectionCount !== undefined && connectionCount > nodes.length) {
-            throw Error('Cannot set connectionCount above the size of the configured array of nodes')
+            throw new Error('Cannot set connectionCount above the size of the configured array of nodes')
         }
-        const nodesIds = new Map()
+        const nodesIds = new Map<DhtAddress, PeerDescriptor>()
         nodes.forEach((peerDescriptor) => {
             nodesIds.set(getNodeIdFromPeerDescriptor(peerDescriptor), peerDescriptor)
         })
@@ -148,37 +161,41 @@ export class ProxyClient extends EventEmitter {
         }
     }
 
-    private getInvalidConnections(): NodeID[] {
+    private getInvalidConnections(): DhtAddress[] {
         return Array.from(this.connections.keys()).filter((id) => {
             return !this.definition!.nodes.has(id)
-                || this.definition!.direction !== this.connections.get(id)
+                || this.definition!.direction !== this.connections.get(id)!.direction
         })
     }
 
     private async openRandomConnections(connectionCount: number): Promise<void> {
         const proxiesToAttempt = sampleSize(Array.from(this.definition!.nodes.keys()).filter((id) =>
-            !this.connections.has(id as unknown as NodeID)
+            !this.connections.has(id)
         ), connectionCount)
         await Promise.all(proxiesToAttempt.map((id) =>
-            this.attemptConnection(id as unknown as NodeID, this.definition!.direction, this.definition!.userId)
+            this.attemptConnection(id, this.definition!.direction, this.definition!.userId)
         ))
     }
 
-    private async attemptConnection(nodeId: NodeID, direction: ProxyDirection, userId: EthereumAddress): Promise<void> {
+    private async attemptConnection(nodeId: DhtAddress, direction: ProxyDirection, userId: EthereumAddress): Promise<void> {
         const peerDescriptor = this.definition!.nodes.get(nodeId)!
-        const client = toProtoRpcClient(new ProxyConnectionRpcClient(this.rpcCommunicator.getRpcClientTransport()))
-        const rpcRemote = new ProxyConnectionRpcRemote(this.config.localPeerDescriptor, peerDescriptor, this.config.streamPartId, client)
+        const rpcRemote = new ProxyConnectionRpcRemote(
+            this.config.localPeerDescriptor,
+            peerDescriptor,
+            this.rpcCommunicator,
+            ProxyConnectionRpcClient
+        )
         const accepted = await rpcRemote.requestConnection(direction, userId)
         if (accepted) {
             this.config.connectionLocker.lockConnection(peerDescriptor, SERVICE_ID)
-            this.connections.set(nodeId, direction)
+            this.connections.set(nodeId, { peerDescriptor, direction })
             const remote = new DeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 peerDescriptor,
-                this.config.streamPartId,
-                toProtoRpcClient(new DeliveryRpcClient(this.rpcCommunicator.getRpcClientTransport()))
+                this.rpcCommunicator,
+                DeliveryRpcClient
             )
-            this.targetNeighbors.add(remote)
+            this.neighbors.add(remote)
             this.propagation.onNeighborJoined(nodeId)
             logger.info('Open proxy connection', {
                 nodeId,
@@ -197,32 +214,34 @@ export class ProxyClient extends EventEmitter {
         await Promise.allSettled(proxiesToDisconnect.map((node) => this.closeConnection(node)))
     }
 
-    private async closeConnection(nodeId: NodeID): Promise<void> {
+    private async closeConnection(nodeId: DhtAddress): Promise<void> {
         if (this.connections.has(nodeId)) {
             logger.info('Close proxy connection', {
                 nodeId
             })
-            const server = this.targetNeighbors.get(nodeId)
-            server?.leaveStreamPartNotice()
-            this.removeConnection(nodeId)
+            const server = this.neighbors.get(nodeId)
+            server?.leaveStreamPartNotice(this.config.streamPartId, false)
+            this.removeConnection(this.connections.get(nodeId)!.peerDescriptor)
         }
     }
 
-    private removeConnection(nodeId: NodeID): void {
+    private removeConnection(peerDescriptor: PeerDescriptor): void {
+        const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         this.connections.delete(nodeId)
-        this.targetNeighbors.removeById(nodeId)
+        this.neighbors.remove(nodeId)
+        this.config.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID)
     }
 
-    broadcast(msg: StreamMessage, previousNode?: NodeID): void {
+    broadcast(msg: StreamMessage, previousNode?: DhtAddress): void {
         if (!previousNode) {
             markAndCheckDuplicate(this.duplicateDetectors, msg.messageId!, msg.previousMessageRef)
         }
         this.emit('message', msg)
-        this.propagation.feedUnseenMessage(msg, this.targetNeighbors.getIds(), previousNode ?? null)
+        this.propagation.feedUnseenMessage(msg, this.neighbors.getIds(), previousNode ?? null)
     }
 
-    hasConnection(nodeId: NodeID, direction: ProxyDirection): boolean {
-        return this.connections.has(nodeId) && this.connections.get(nodeId) === direction
+    hasConnection(nodeId: DhtAddress, direction: ProxyDirection): boolean {
+        return this.connections.has(nodeId) && this.connections.get(nodeId)!.direction === direction
     }
 
     getDirection(): ProxyDirection {
@@ -233,7 +252,7 @@ export class ProxyClient extends EventEmitter {
         const nodeId = getNodeIdFromPeerDescriptor(peerDescriptor)
         if (this.connections.has(nodeId)) {
             this.config.connectionLocker.unlockConnection(peerDescriptor, SERVICE_ID)
-            this.removeConnection(nodeId)
+            this.removeConnection(peerDescriptor)
             await retry(() => this.updateConnections(), 'updating proxy connections', this.abortController.signal)
         }
     }
@@ -243,17 +262,18 @@ export class ProxyClient extends EventEmitter {
         addManagedEventListener<any, any>(
             this.config.transport as any,
             'disconnected',
+            // TODO should we catch possible promise rejection?
             (peerDescriptor: PeerDescriptor) => this.onNodeDisconnected(peerDescriptor),
             this.abortController.signal
         )
     }
 
     stop(): void {
-        this.targetNeighbors.getAll().map((remote) => {
+        this.neighbors.getAll().forEach((remote) => {
             this.config.connectionLocker.unlockConnection(remote.getPeerDescriptor(), SERVICE_ID)
-            remote.leaveStreamPartNotice()
+            remote.leaveStreamPartNotice(this.config.streamPartId, false)
         })
-        this.targetNeighbors.stop()
+        this.neighbors.stop()
         this.rpcCommunicator.destroy()
         this.connections.clear()
         this.abortController.abort()

package/src/logic/proxy/ProxyConnectionRpcLocal.ts

@@ -1,21 +1,17 @@
 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 { DhtCallContext, ListeningRpcCommunicator, PeerDescriptor } from '@streamr/dht'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
+import { DhtAddress, DhtCallContext, ListeningRpcCommunicator, PeerDescriptor, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { DeliveryRpcClient } 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'
-import { NodeID, getNodeIdFromPeerDescriptor } from '../../identifiers'
 
 const logger = new Logger(module)
 
@@ -32,13 +28,13 @@ interface ProxyConnectionRpcLocalConfig {
 }
 
 export interface Events {
-    newConnection: (nodeId: NodeID) => void
+    newConnection: (nodeId: DhtAddress) => void
 }
 
 export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IProxyConnectionRpc {
 
     private readonly config: ProxyConnectionRpcLocalConfig
-    private readonly connections: Map<NodeID, ProxyConnection> = new Map()
+    private readonly connections: Map<DhtAddress, ProxyConnection> = new Map()
 
     constructor(config: ProxyConnectionRpcLocalConfig) {
         super()
@@ -47,28 +43,28 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
             (msg: ProxyConnectionRequest, context) => this.requestConnection(msg, context))
     }
 
-    getConnection(nodeId: NodeID): ProxyConnection | undefined {
+    getConnection(nodeId: DhtAddress): ProxyConnection | undefined {
         return this.connections.get(nodeId)
     }
 
-    hasConnection(nodeId: NodeID): boolean {
+    hasConnection(nodeId: DhtAddress): boolean {
         return this.connections.has(nodeId)
     }
 
-    removeConnection(nodeId: NodeID): void {
+    removeConnection(nodeId: DhtAddress): void {
         this.connections.delete(nodeId)
     }
 
     stop(): void {
-        this.connections.forEach((connection) => connection.remote.leaveStreamPartNotice())
+        this.connections.forEach((connection) => connection.remote.leaveStreamPartNotice(this.config.streamPartId, false))
         this.connections.clear()
         this.removeAllListeners()
     }
 
-    getPropagationTargets(msg: StreamMessage): NodeID[] {
-        if (msg.messageType === StreamMessageType.GROUP_KEY_REQUEST) {
+    getPropagationTargets(msg: StreamMessage): DhtAddress[] {
+        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}`)
@@ -79,11 +75,11 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
         }
     }
 
-    private getNodeIdsForUserId(userId: EthereumAddress): NodeID[] {
+    private getNodeIdsForUserId(userId: EthereumAddress): DhtAddress[] {
         return Array.from(this.connections.keys()).filter((nodeId) => this.connections.get(nodeId)!.userId === userId)
     }
 
-    private getSubscribers(): NodeID[] {
+    private getSubscribers(): DhtAddress[] {
         return Array.from(this.connections.keys()).filter((key) => this.connections.get(key)!.direction === ProxyDirection.SUBSCRIBE)
     }
 
@@ -97,8 +93,8 @@ export class ProxyConnectionRpcLocal extends EventEmitter<Events> implements IPr
             remote: new DeliveryRpcRemote(
                 this.config.localPeerDescriptor,
                 senderPeerDescriptor,
-                this.config.streamPartId,
-                toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+                this.config.rpcCommunicator,
+                DeliveryRpcClient
             )
         })
         const response: ProxyConnectionResponse = {

package/src/logic/proxy/ProxyConnectionRpcRemote.ts

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

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

@@ -1,37 +1,50 @@
 import { ServerCallContext } from '@protobuf-ts/runtime-rpc'
-import { TemporaryConnectionRequest, TemporaryConnectionResponse } from '../../proto/packages/trackerless-network/protos/NetworkRpc'
+import { 
+    CloseTemporaryConnection,
+    TemporaryConnectionRequest,
+    TemporaryConnectionResponse
+} from '../../proto/packages/trackerless-network/protos/NetworkRpc'
 import { ITemporaryConnectionRpc } from '../../proto/packages/trackerless-network/protos/NetworkRpc.server'
-import { DhtCallContext, ListeningRpcCommunicator } from '@streamr/dht'
+import { ConnectionLocker, DhtAddress, DhtCallContext, ListeningRpcCommunicator, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { DeliveryRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 import { NodeList } from '../NodeList'
-import { toProtoRpcClient } from '@streamr/proto-rpc'
 import { DeliveryRpcRemote } from '../DeliveryRpcRemote'
 import { PeerDescriptor } from '../../proto/packages/dht/protos/DhtRpc'
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
+import { Empty } from '../../proto/google/protobuf/empty'
 import { StreamPartID } from '@streamr/protocol'
 
 interface TemporaryConnectionRpcLocalConfig {
-    streamPartId: StreamPartID
     rpcCommunicator: ListeningRpcCommunicator
     localPeerDescriptor: PeerDescriptor
+    streamPartId: StreamPartID
+    connectionLocker: ConnectionLocker
 } 
 
+const LOCK_ID_BASE = 'system/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 {
         return this.temporaryNodes
     }
 
-    removeNode(peerDescriptor: PeerDescriptor): void {
-        this.temporaryNodes.remove(peerDescriptor)
+    hasNode(node: DhtAddress): boolean {
+        return this.temporaryNodes.has(node)
+    }
+
+    removeNode(nodeId: DhtAddress): void {
+        this.temporaryNodes.remove(nodeId)
+        this.config.connectionLocker.weakUnlockConnection(nodeId, this.lockId)
     }
 
     async openConnection(
@@ -42,12 +55,19 @@ export class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
         const remote = new DeliveryRpcRemote(
             this.config.localPeerDescriptor,
             sender,
-            this.config.streamPartId,
-            toProtoRpcClient(new DeliveryRpcClient(this.config.rpcCommunicator.getRpcClientTransport()))
+            this.config.rpcCommunicator,
+            DeliveryRpcClient
         )
         this.temporaryNodes.add(remote)
+        this.config.connectionLocker.weakLockConnection(getNodeIdFromPeerDescriptor(sender), this.lockId)
         return {
             accepted: true
         }
     }
+
+    async closeConnection(_request: CloseTemporaryConnection, context: ServerCallContext): Promise<Empty> {
+        const senderId = getNodeIdFromPeerDescriptor((context as DhtCallContext).incomingSourceDescriptor!)
+        this.removeNode(senderId)
+        return {}
+    }
 }

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

@@ -1,11 +1,10 @@
-import { Remote } from '@streamr/dht'
+import { RpcRemote, getNodeIdFromPeerDescriptor } from '@streamr/dht'
 import { Logger } from '@streamr/utils'
-import { getNodeIdFromPeerDescriptor } from '../../identifiers'
-import { ITemporaryConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
+import { TemporaryConnectionRpcClient } from '../../proto/packages/trackerless-network/protos/NetworkRpc.client'
 
 const logger = new Logger(module)
 
-export class TemporaryConnectionRpcRemote extends Remote<ITemporaryConnectionRpcClient> {
+export class TemporaryConnectionRpcRemote extends RpcRemote<TemporaryConnectionRpcClient> {
 
     async openConnection(): Promise<boolean> {
         try {
@@ -16,4 +15,15 @@ export class TemporaryConnectionRpcRemote extends Remote<ITemporaryConnectionRpc
             return false
         }
     }
+
+    async closeConnection(): Promise<void> {
+        try {
+            await this.getClient().closeConnection({}, this.formDhtRpcOptions({
+                connect: false,
+                notification: true
+            }))
+        } catch (err) {
+            logger.trace(`closeConnection to ${getNodeIdFromPeerDescriptor(this.getPeerDescriptor())} failed: ${err}`)
+        }
+    }
 }

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

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/any.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //
@@ -39,7 +39,6 @@ import type { IBinaryReader } from "@protobuf-ts/runtime";
 import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { isJsonObject } from "@protobuf-ts/runtime";
 import { typeofJsonValue } from "@protobuf-ts/runtime";
 import type { JsonValue } from "@protobuf-ts/runtime";
@@ -272,8 +271,9 @@ class Any$Type extends MessageType<Any> {
         return name;
     }
     create(value?: PartialMessage<Any>): Any {
-        const message = { typeUrl: "", value: new Uint8Array(0) };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.typeUrl = "";
+        message.value = new Uint8Array(0);
         if (value !== undefined)
             reflectionMergePartial<Any>(this, message, value);
         return message;

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

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/empty.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //
@@ -39,7 +39,6 @@ import type { BinaryReadOptions } from "@protobuf-ts/runtime";
 import type { IBinaryReader } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
 /**
  * A generic empty message that you can re-use to avoid defining duplicated
@@ -62,8 +61,7 @@ class Empty$Type extends MessageType<Empty> {
         super("google.protobuf.Empty", []);
     }
     create(value?: PartialMessage<Empty>): Empty {
-        const message = {};
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        const message = globalThis.Object.create((this.messagePrototype!));
         if (value !== undefined)
             reflectionMergePartial<Empty>(this, message, value);
         return message;

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

@@ -1,4 +1,4 @@
-// @generated by protobuf-ts 2.9.1 with parameter server_generic,generate_dependencies,long_type_number
+// @generated by protobuf-ts 2.9.3 with parameter server_generic,generate_dependencies,long_type_number
 // @generated from protobuf file "google/protobuf/timestamp.proto" (package "google.protobuf", syntax proto3)
 // tslint:disable
 //
@@ -40,7 +40,6 @@ import type { IBinaryReader } from "@protobuf-ts/runtime";
 import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
-import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
 import { typeofJsonValue } from "@protobuf-ts/runtime";
 import type { JsonValue } from "@protobuf-ts/runtime";
 import type { JsonReadOptions } from "@protobuf-ts/runtime";
@@ -234,8 +233,9 @@ class Timestamp$Type extends MessageType<Timestamp> {
         return target;
     }
     create(value?: PartialMessage<Timestamp>): Timestamp {
-        const message = { seconds: 0, nanos: 0 };
-        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.seconds = 0;
+        message.nanos = 0;
         if (value !== undefined)
             reflectionMergePartial<Timestamp>(this, message, value);
         return message;