@bitgo-beta/sdk-coin-canton 1.0.0-alpha.0

package/dist/resources/proto/damlTransactionNode.js

@@ -0,0 +1,71 @@
+import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
+import { Node } from './node/node.js';
+
+class DamlTransaction_Node$Type extends MessageType {
+  constructor() {
+    super('com.daml.ledger.api.v2.interactive.DamlTransaction.Node', [
+      {
+        no: 1,
+        name: 'node_id',
+        kind: 'scalar',
+        T: 9 /*ScalarType.STRING*/,
+      },
+      {
+        no: 1000,
+        name: 'v1',
+        kind: 'message',
+        oneof: 'versionedNode',
+        T: () => Node,
+      },
+    ]);
+  }
+  create(value) {
+    const message = Object.create(this.messagePrototype);
+    message.nodeId = '';
+    message.versionedNode = { oneofKind: undefined };
+    if (value !== undefined) reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    const message = target ?? this.create(),
+      end = reader.pos + length;
+    while (reader.pos < end) {
+      const [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* string node_id */ 1:
+          message.nodeId = reader.string();
+          break;
+        case /* com.daml.ledger.api.v2.interactive.transaction.v1.Node v1 */ 1000:
+          message.versionedNode = {
+            oneofKind: 'v1',
+            v1: Node.internalBinaryRead(reader, reader.uint32(), options, message.versionedNode.v1),
+          };
+          break;
+        default:
+          const u = options.readUnknownField;
+          if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          const d = reader.skip(wireType);
+          if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    /* string node_id = 1; */
+    if (message.nodeId !== '') writer.tag(1, WireType.LengthDelimited).string(message.nodeId);
+    /* com.daml.ledger.api.v2.interactive.transaction.v1.Node v1 = 1000; */
+    if (message.versionedNode.oneofKind === 'v1')
+      Node.internalBinaryWrite(
+        message.versionedNode.v1,
+        writer.tag(1000, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    const u = options.writeUnknownFields;
+    if (u !== false) (u === true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.DamlTransaction.Node
+ */
+export const DamlTransaction_Node = new DamlTransaction_Node$Type();

package/dist/resources/proto/damlTransactionNodeSeed.js

@@ -0,0 +1,56 @@
+import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
+
+class DamlTransaction_NodeSeed$Type extends MessageType {
+  constructor() {
+    super('com.daml.ledger.api.v2.interactive.DamlTransaction.NodeSeed', [
+      {
+        no: 1,
+        name: 'node_id',
+        kind: 'scalar',
+        T: 5 /*ScalarType.INT32*/,
+      },
+      { no: 2, name: 'seed', kind: 'scalar', T: 12 /*ScalarType.BYTES*/ },
+    ]);
+  }
+  create(value) {
+    const message = Object.create(this.messagePrototype);
+    message.nodeId = 0;
+    message.seed = new Uint8Array(0);
+    if (value !== undefined) reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    const message = target ?? this.create(),
+      end = reader.pos + length;
+    while (reader.pos < end) {
+      const [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* int32 node_id */ 1:
+          message.nodeId = reader.int32();
+          break;
+        case /* bytes seed */ 2:
+          message.seed = reader.bytes();
+          break;
+        default:
+          const u = options.readUnknownField;
+          if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          const d = reader.skip(wireType);
+          if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    /* int32 node_id = 1; */
+    if (message.nodeId !== 0) writer.tag(1, WireType.Varint).int32(message.nodeId);
+    /* bytes seed = 2; */
+    if (message.seed.length) writer.tag(2, WireType.LengthDelimited).bytes(message.seed);
+    const u = options.writeUnknownFields;
+    if (u !== false) (u === true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.DamlTransaction.NodeSeed
+ */
+export const DamlTransaction_NodeSeed = new DamlTransaction_NodeSeed$Type();

package/dist/resources/proto/metadata/metadataGlobalKeyMappingEntry.js

@@ -0,0 +1,53 @@
+import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
+import { Value } from '../node/value.js';
+import { GlobalKey } from '../node/globalKey.js';
+
+class Metadata_GlobalKeyMappingEntry$Type extends MessageType {
+  constructor() {
+    super('com.daml.ledger.api.v2.interactive.Metadata.GlobalKeyMappingEntry', [
+      { no: 1, name: 'key', kind: 'message', T: () => GlobalKey },
+      { no: 2, name: 'value', kind: 'message', T: () => Value },
+    ]);
+  }
+  create(value) {
+    const message = Object.create(this.messagePrototype);
+    if (value !== undefined) reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    const message = target ?? this.create(),
+      end = reader.pos + length;
+    while (reader.pos < end) {
+      const [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* com.daml.ledger.api.v2.interactive.GlobalKey key */ 1:
+          message.key = GlobalKey.internalBinaryRead(reader, reader.uint32(), options, message.key);
+          break;
+        case /* optional com.daml.ledger.api.v2.Value value */ 2:
+          message.value = Value.internalBinaryRead(reader, reader.uint32(), options, message.value);
+          break;
+        default:
+          const u = options.readUnknownField;
+          if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          const d = reader.skip(wireType);
+          if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    /* com.daml.ledger.api.v2.interactive.GlobalKey key = 1; */
+    if (message.key)
+      GlobalKey.internalBinaryWrite(message.key, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+    /* optional com.daml.ledger.api.v2.Value value = 2; */
+    if (message.value)
+      Value.internalBinaryWrite(message.value, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+    const u = options.writeUnknownFields;
+    if (u !== false) (u === true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.Metadata.GlobalKeyMappingEntry
+ */
+export const Metadata_GlobalKeyMappingEntry = new Metadata_GlobalKeyMappingEntry$Type();

package/dist/resources/proto/metadata/metadataInputContract.js

@@ -0,0 +1,80 @@
+import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
+import { Create } from '../node/node.js';
+
+class Metadata_InputContract$Type extends MessageType {
+  constructor() {
+    super('com.daml.ledger.api.v2.interactive.Metadata.InputContract', [
+      {
+        no: 1,
+        name: 'v1',
+        kind: 'message',
+        oneof: 'contract',
+        T: () => Create,
+      },
+      {
+        no: 1000,
+        name: 'created_at',
+        kind: 'scalar',
+        T: 4 /*ScalarType.UINT64*/,
+        L: 0 /*LongType.BIGINT*/,
+      },
+      {
+        no: 1002,
+        name: 'event_blob',
+        kind: 'scalar',
+        T: 12 /*ScalarType.BYTES*/,
+      },
+    ]);
+  }
+  create(value) {
+    const message = Object.create(this.messagePrototype);
+    message.contract = { oneofKind: undefined };
+    message.createdAt = 0n;
+    message.eventBlob = new Uint8Array(0);
+    if (value !== undefined) reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    const message = target ?? this.create(),
+      end = reader.pos + length;
+    while (reader.pos < end) {
+      const [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* com.daml.ledger.api.v2.interactive.transaction.v1.Create v1 */ 1:
+          message.contract = {
+            oneofKind: 'v1',
+            v1: Create.internalBinaryRead(reader, reader.uint32(), options, message.contract.v1),
+          };
+          break;
+        case /* uint64 created_at */ 1000:
+          message.createdAt = reader.uint64().toBigInt();
+          break;
+        case /* bytes event_blob */ 1002:
+          message.eventBlob = reader.bytes();
+          break;
+        default:
+          const u = options.readUnknownField;
+          if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          const d = reader.skip(wireType);
+          if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    /* com.daml.ledger.api.v2.interactive.transaction.v1.Create v1 = 1; */
+    if (message.contract.oneofKind === 'v1')
+      Create.internalBinaryWrite(message.contract.v1, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+    /* uint64 created_at = 1000; */
+    if (message.createdAt !== 0n) writer.tag(1000, WireType.Varint).uint64(message.createdAt);
+    /* bytes event_blob = 1002; */
+    if (message.eventBlob.length) writer.tag(1002, WireType.LengthDelimited).bytes(message.eventBlob);
+    const u = options.writeUnknownFields;
+    if (u !== false) (u === true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.Metadata.InputContract
+ */
+export const Metadata_InputContract = new Metadata_InputContract$Type();

package/dist/resources/proto/metadata/metadataSubmitterInfo.js

@@ -0,0 +1,62 @@
+import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
+
+class Metadata_SubmitterInfo$Type extends MessageType {
+  constructor() {
+    super('com.daml.ledger.api.v2.interactive.Metadata.SubmitterInfo', [
+      {
+        no: 1,
+        name: 'act_as',
+        kind: 'scalar',
+        repeat: 2 /*RepeatType.UNPACKED*/,
+        T: 9 /*ScalarType.STRING*/,
+      },
+      {
+        no: 2,
+        name: 'command_id',
+        kind: 'scalar',
+        T: 9 /*ScalarType.STRING*/,
+      },
+    ]);
+  }
+  create(value) {
+    const message = Object.create(this.messagePrototype);
+    message.actAs = [];
+    message.commandId = '';
+    if (value !== undefined) reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    const message = target ?? this.create(),
+      end = reader.pos + length;
+    while (reader.pos < end) {
+      const [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* repeated string act_as */ 1:
+          message.actAs.push(reader.string());
+          break;
+        case /* string command_id */ 2:
+          message.commandId = reader.string();
+          break;
+        default:
+          const u = options.readUnknownField;
+          if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          const d = reader.skip(wireType);
+          if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    /* repeated string act_as = 1; */
+    for (let i = 0; i < message.actAs.length; i++) writer.tag(1, WireType.LengthDelimited).string(message.actAs[i]);
+    /* string command_id = 2; */
+    if (message.commandId !== '') writer.tag(2, WireType.LengthDelimited).string(message.commandId);
+    const u = options.writeUnknownFields;
+    if (u !== false) (u === true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.Metadata.SubmitterInfo
+ */
+export const Metadata_SubmitterInfo = new Metadata_SubmitterInfo$Type();

package/dist/resources/proto/metadata.js

@@ -0,0 +1,189 @@
+import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
+import { Metadata_GlobalKeyMappingEntry } from './metadata/metadataGlobalKeyMappingEntry.js';
+import { Metadata_InputContract } from './metadata/metadataInputContract.js';
+import { Metadata_SubmitterInfo } from './metadata/metadataSubmitterInfo.js';
+
+class Metadata$Type extends MessageType {
+  constructor() {
+    super('com.daml.ledger.api.v2.interactive.Metadata', [
+      {
+        no: 2,
+        name: 'submitter_info',
+        kind: 'message',
+        T: () => Metadata_SubmitterInfo,
+      },
+      {
+        no: 3,
+        name: 'synchronizer_id',
+        kind: 'scalar',
+        T: 9 /*ScalarType.STRING*/,
+      },
+      {
+        no: 4,
+        name: 'mediator_group',
+        kind: 'scalar',
+        T: 13 /*ScalarType.UINT32*/,
+      },
+      {
+        no: 5,
+        name: 'transaction_uuid',
+        kind: 'scalar',
+        T: 9 /*ScalarType.STRING*/,
+      },
+      {
+        no: 6,
+        name: 'preparation_time',
+        kind: 'scalar',
+        T: 4 /*ScalarType.UINT64*/,
+        L: 0 /*LongType.BIGINT*/,
+      },
+      {
+        no: 7,
+        name: 'input_contracts',
+        kind: 'message',
+        repeat: 2 /*RepeatType.UNPACKED*/,
+        T: () => Metadata_InputContract,
+      },
+      {
+        no: 9,
+        name: 'min_ledger_effective_time',
+        kind: 'scalar',
+        opt: true,
+        T: 4 /*ScalarType.UINT64*/,
+        L: 0 /*LongType.BIGINT*/,
+      },
+      {
+        no: 10,
+        name: 'max_ledger_effective_time',
+        kind: 'scalar',
+        opt: true,
+        T: 4 /*ScalarType.UINT64*/,
+        L: 0 /*LongType.BIGINT*/,
+      },
+      {
+        no: 8,
+        name: 'global_key_mapping',
+        kind: 'message',
+        repeat: 2 /*RepeatType.UNPACKED*/,
+        T: () => Metadata_GlobalKeyMappingEntry,
+      },
+      {
+        no: 11,
+        name: 'max_record_time',
+        kind: 'scalar',
+        opt: true,
+        T: 4 /*ScalarType.UINT64*/,
+        L: 0 /*LongType.BIGINT*/,
+      },
+    ]);
+  }
+  create(value) {
+    const message = Object.create(this.messagePrototype);
+    message.synchronizerId = '';
+    message.mediatorGroup = 0;
+    message.transactionUuid = '';
+    message.preparationTime = 0n;
+    message.inputContracts = [];
+    message.globalKeyMapping = [];
+    if (value !== undefined) reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    const message = target ?? this.create(),
+      end = reader.pos + length;
+    while (reader.pos < end) {
+      const [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* com.daml.ledger.api.v2.interactive.Metadata.SubmitterInfo submitter_info */ 2:
+          message.submitterInfo = Metadata_SubmitterInfo.internalBinaryRead(
+            reader,
+            reader.uint32(),
+            options,
+            message.submitterInfo
+          );
+          break;
+        case /* string synchronizer_id */ 3:
+          message.synchronizerId = reader.string();
+          break;
+        case /* uint32 mediator_group */ 4:
+          message.mediatorGroup = reader.uint32();
+          break;
+        case /* string transaction_uuid */ 5:
+          message.transactionUuid = reader.string();
+          break;
+        case /* uint64 preparation_time */ 6:
+          message.preparationTime = reader.uint64().toBigInt();
+          break;
+        case /* repeated com.daml.ledger.api.v2.interactive.Metadata.InputContract input_contracts */ 7:
+          message.inputContracts.push(Metadata_InputContract.internalBinaryRead(reader, reader.uint32(), options));
+          break;
+        case /* optional uint64 min_ledger_effective_time */ 9:
+          message.minLedgerEffectiveTime = reader.uint64().toBigInt();
+          break;
+        case /* optional uint64 max_ledger_effective_time */ 10:
+          message.maxLedgerEffectiveTime = reader.uint64().toBigInt();
+          break;
+        case /* repeated com.daml.ledger.api.v2.interactive.Metadata.GlobalKeyMappingEntry global_key_mapping */ 8:
+          message.globalKeyMapping.push(
+            Metadata_GlobalKeyMappingEntry.internalBinaryRead(reader, reader.uint32(), options)
+          );
+          break;
+        case /* optional uint64 max_record_time */ 11:
+          message.maxRecordTime = reader.uint64().toBigInt();
+          break;
+        default:
+          const u = options.readUnknownField;
+          if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          const d = reader.skip(wireType);
+          if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    /* com.daml.ledger.api.v2.interactive.Metadata.SubmitterInfo submitter_info = 2; */
+    if (message.submitterInfo)
+      Metadata_SubmitterInfo.internalBinaryWrite(
+        message.submitterInfo,
+        writer.tag(2, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    /* string synchronizer_id = 3; */
+    if (message.synchronizerId !== '') writer.tag(3, WireType.LengthDelimited).string(message.synchronizerId);
+    /* uint32 mediator_group = 4; */
+    if (message.mediatorGroup !== 0) writer.tag(4, WireType.Varint).uint32(message.mediatorGroup);
+    /* string transaction_uuid = 5; */
+    if (message.transactionUuid !== '') writer.tag(5, WireType.LengthDelimited).string(message.transactionUuid);
+    /* uint64 preparation_time = 6; */
+    if (message.preparationTime !== 0n) writer.tag(6, WireType.Varint).uint64(message.preparationTime);
+    /* repeated com.daml.ledger.api.v2.interactive.Metadata.InputContract input_contracts = 7; */
+    for (let i = 0; i < message.inputContracts.length; i++)
+      Metadata_InputContract.internalBinaryWrite(
+        message.inputContracts[i],
+        writer.tag(7, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    /* repeated com.daml.ledger.api.v2.interactive.Metadata.GlobalKeyMappingEntry global_key_mapping = 8; */
+    for (let i = 0; i < message.globalKeyMapping.length; i++)
+      Metadata_GlobalKeyMappingEntry.internalBinaryWrite(
+        message.globalKeyMapping[i],
+        writer.tag(8, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    /* optional uint64 min_ledger_effective_time = 9; */
+    if (message.minLedgerEffectiveTime !== undefined)
+      writer.tag(9, WireType.Varint).uint64(message.minLedgerEffectiveTime);
+    /* optional uint64 max_ledger_effective_time = 10; */
+    if (message.maxLedgerEffectiveTime !== undefined)
+      writer.tag(10, WireType.Varint).uint64(message.maxLedgerEffectiveTime);
+    /* optional uint64 max_record_time = 11; */
+    if (message.maxRecordTime !== undefined) writer.tag(11, WireType.Varint).uint64(message.maxRecordTime);
+    const u = options.writeUnknownFields;
+    if (u !== false) (u === true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.Metadata
+ */
+export const Metadata = new Metadata$Type();

package/dist/resources/proto/node/empty.js

@@ -0,0 +1,36 @@
+import { MessageType, UnknownFieldHandler, reflectionMergePartial } from '@protobuf-ts/runtime';
+
+class Empty$Type extends MessageType {
+  constructor() {
+    super('google.protobuf.Empty', []);
+  }
+  create(value) {
+    const message = Object.create(this.messagePrototype);
+    if (value !== undefined) reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    const message = target ?? this.create(),
+      end = reader.pos + length;
+    while (reader.pos < end) {
+      const [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        default:
+          const u = options.readUnknownField;
+          if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          const d = reader.skip(wireType);
+          if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    const u = options.writeUnknownFields;
+    if (u !== false) (u === true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Empty
+ */
+export const Empty = new Empty$Type();

package/dist/resources/proto/node/globalKey.js

@@ -0,0 +1,81 @@
+import { MessageType, reflectionMergePartial, UnknownFieldHandler, WireType } from '@protobuf-ts/runtime';
+import { Value } from './value.js';
+import { Identifier } from './identifier.js';
+
+class GlobalKey$Type extends MessageType {
+  constructor() {
+    super('com.daml.ledger.api.v2.interactive.GlobalKey', [
+      {
+        no: 1,
+        name: 'template_id',
+        kind: 'message',
+        T: () => Identifier,
+      },
+      {
+        no: 2,
+        name: 'package_name',
+        kind: 'scalar',
+        T: 9 /*ScalarType.STRING*/,
+      },
+      { no: 3, name: 'key', kind: 'message', T: () => Value },
+      { no: 4, name: 'hash', kind: 'scalar', T: 12 /*ScalarType.BYTES*/ },
+    ]);
+  }
+  create(value) {
+    const message = Object.create(this.messagePrototype);
+    message.packageName = '';
+    message.hash = new Uint8Array(0);
+    if (value !== undefined) reflectionMergePartial(this, message, value);
+    return message;
+  }
+  internalBinaryRead(reader, length, options, target) {
+    const message = target ?? this.create(),
+      end = reader.pos + length;
+    while (reader.pos < end) {
+      const [fieldNo, wireType] = reader.tag();
+      switch (fieldNo) {
+        case /* com.daml.ledger.api.v2.Identifier template_id */ 1:
+          message.templateId = Identifier.internalBinaryRead(reader, reader.uint32(), options, message.templateId);
+          break;
+        case /* string package_name */ 2:
+          message.packageName = reader.string();
+          break;
+        case /* com.daml.ledger.api.v2.Value key */ 3:
+          message.key = Value.internalBinaryRead(reader, reader.uint32(), options, message.key);
+          break;
+        case /* bytes hash */ 4:
+          message.hash = reader.bytes();
+          break;
+        default:
+          const u = options.readUnknownField;
+          if (u === 'throw') throw new Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+          const d = reader.skip(wireType);
+          if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+      }
+    }
+    return message;
+  }
+  internalBinaryWrite(message, writer, options) {
+    /* com.daml.ledger.api.v2.Identifier template_id = 1; */
+    if (message.templateId)
+      Identifier.internalBinaryWrite(
+        message.templateId,
+        writer.tag(1, WireType.LengthDelimited).fork(),
+        options
+      ).join();
+    /* string package_name = 2; */
+    if (message.packageName !== '') writer.tag(2, WireType.LengthDelimited).string(message.packageName);
+    /* com.daml.ledger.api.v2.Value key = 3; */
+    if (message.key)
+      Value.internalBinaryWrite(message.key, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+    /* bytes hash = 4; */
+    if (message.hash.length) writer.tag(4, WireType.LengthDelimited).bytes(message.hash);
+    const u = options.writeUnknownFields;
+    if (u !== false) (u === true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+    return writer;
+  }
+}
+/**
+ * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.GlobalKey
+ */
+export const GlobalKey = new GlobalKey$Type();