@bitgo-beta/sdk-coin-canton 1.0.1-beta.22 → 1.0.1-beta.221

package/dist/resources/hash/hash.d.ts

@@ -0,0 +1,5 @@
+import type { IPreparedTransaction } from '../../src/lib/iface';
+
+declare module '../../resources/hash/hash.js' {
+  export function computePreparedTransaction(preparedTransaction: IPreparedTransaction): Promise<Uint8Array>;
+}

package/dist/resources/hash/hash.js

@@ -0,0 +1,298 @@
+// This is the static helper file from canton SDK, replicating it here since we won't be using the canton wallet SDK
+// TODO: https://bitgoinc.atlassian.net/browse/COIN-6016
+const PREPARED_TRANSACTION_HASH_PURPOSE = Uint8Array.from([0x00, 0x00, 0x00, 0x30]);
+const NODE_ENCODING_VERSION = Uint8Array.from([0x01]);
+const HASHING_SCHEME_VERSION = Uint8Array.from([2]);
+async function sha256(message) {
+  const msg = typeof message === 'string' ? new TextEncoder().encode(message) : message;
+  return crypto.subtle.digest('SHA-256', new Uint8Array(msg)).then((hash) => new Uint8Array(hash));
+}
+async function mkByteArray(...args) {
+  const normalizedArgs = args.map((arg) => {
+    if (typeof arg === 'number') {
+      return new Uint8Array([arg]);
+    } else {
+      return arg;
+    }
+  });
+  let totalLength = 0;
+  normalizedArgs.forEach((arg) => {
+    totalLength += arg.length;
+  });
+  const mergedArray = new Uint8Array(totalLength);
+  let offset = 0;
+  normalizedArgs.forEach((arg) => {
+    mergedArray.set(arg, offset);
+    offset += arg.length;
+  });
+  return mergedArray;
+}
+async function encodeBool(value) {
+  return new Uint8Array([value ? 1 : 0]);
+}
+async function encodeInt32(value) {
+  const buffer = new ArrayBuffer(4);
+  const view = new DataView(buffer);
+  view.setInt32(0, value, false); // true for little-endian
+  return new Uint8Array(buffer);
+}
+async function encodeInt64(value) {
+  // eslint-disable-next-line no-undef
+  const num = typeof value === 'bigint' ? value : BigInt(value || 0);
+  const buffer = new ArrayBuffer(8);
+  const view = new DataView(buffer);
+  view.setBigInt64(0, num, false); // true for little-endian
+  return new Uint8Array(buffer);
+}
+async function encodeString(value = '') {
+  const utf8Bytes = new TextEncoder().encode(value);
+  return encodeBytes(utf8Bytes);
+}
+async function encodeBytes(value) {
+  const length = await encodeInt32(value.length);
+  return mkByteArray(length, value);
+}
+async function encodeHash(value) {
+  return value;
+}
+function encodeHexString(value = '') {
+  // Convert hex string to Uint8Array
+  const bytes = new Uint8Array(value.length / 2);
+  for (let i = 0; i < value.length; i += 2) {
+    bytes[i / 2] = parseInt(value.slice(i, i + 2), 16);
+  }
+  return encodeBytes(bytes);
+}
+// Maybe suspicious?
+async function encodeOptional(value, encodeFn) {
+  if (value === undefined || value === null) {
+    return new Uint8Array([0]); // Return empty array for undefined fields
+  } else {
+    return mkByteArray(1, await encodeFn(value));
+  }
+}
+// Maybe suspicious?
+async function encodeProtoOptional(parentValue, fieldName, value, encodeFn) {
+  if (parentValue && parentValue[fieldName] !== undefined) {
+    return mkByteArray(1, await encodeFn(value));
+  } else {
+    return new Uint8Array([0]); // Return empty array for undefined fields
+  }
+}
+async function encodeRepeated(values = [], encodeFn) {
+  const length = await encodeInt32(values.length);
+  const encodedValues = await Promise.all(values.map(encodeFn));
+  return mkByteArray(length, ...encodedValues);
+}
+function findSeed(nodeId, nodeSeeds) {
+  const seed = nodeSeeds.find((seed) => seed.nodeId.toString() === nodeId)?.seed;
+  return seed;
+}
+async function encodeIdentifier(identifier) {
+  return mkByteArray(
+    await encodeString(identifier.packageId),
+    await encodeRepeated(identifier.moduleName.split('.'), encodeString),
+    await encodeRepeated(identifier.entityName.split('.'), encodeString)
+  );
+}
+async function encodeMetadata(metadata) {
+  return mkByteArray(
+    Uint8Array.from([0x01]),
+    await encodeRepeated(metadata.submitterInfo?.actAs, encodeString),
+    await encodeString(metadata.submitterInfo?.commandId),
+    await encodeString(metadata.transactionUuid),
+    await encodeInt32(metadata.mediatorGroup),
+    await encodeString(metadata.synchronizerId),
+    await encodeProtoOptional(metadata, 'minLedgerEffectiveTime', metadata.minLedgerEffectiveTime, encodeInt64),
+    await encodeProtoOptional(metadata, 'maxLedgerEffectiveTime', metadata.maxLedgerEffectiveTime, encodeInt64),
+    await encodeInt64(metadata.preparationTime),
+    await encodeRepeated(metadata.inputContracts, encodeInputContract)
+  );
+}
+async function encodeCreateNode(create, nodeId, nodeSeeds) {
+  return create
+    ? mkByteArray(
+        NODE_ENCODING_VERSION,
+        await encodeString(create.lfVersion),
+        0 /** Create node tag */,
+        await encodeOptional(findSeed(nodeId, nodeSeeds), encodeHash),
+        await encodeHexString(create.contractId),
+        await encodeString(create.packageName),
+        await encodeIdentifier(create.templateId),
+        await encodeValue(create.argument),
+        await encodeRepeated(create.signatories, encodeString),
+        await encodeRepeated(create.stakeholders, encodeString)
+      )
+    : mkByteArray();
+}
+async function encodeExerciseNode(exercise, nodeId, nodesDict, nodeSeeds) {
+  return mkByteArray(
+    NODE_ENCODING_VERSION,
+    await encodeString(exercise.lfVersion),
+    1 /** Exercise node tag */,
+    await encodeHash(findSeed(nodeId, nodeSeeds)),
+    await encodeHexString(exercise.contractId),
+    await encodeString(exercise.packageName),
+    await encodeIdentifier(exercise.templateId),
+    await encodeRepeated(exercise.signatories, encodeString),
+    await encodeRepeated(exercise.stakeholders, encodeString),
+    await encodeRepeated(exercise.actingParties, encodeString),
+    await encodeProtoOptional(exercise, 'interfaceId', exercise.interfaceId, encodeIdentifier),
+    await encodeString(exercise.choiceId),
+    await encodeValue(exercise.chosenValue),
+    await encodeBool(exercise.consuming),
+    await encodeProtoOptional(exercise, 'exerciseResult', exercise.exerciseResult, encodeValue),
+    await encodeRepeated(exercise.choiceObservers, encodeString),
+    await encodeRepeated(exercise.children, encodeNodeId(nodesDict, nodeSeeds))
+  );
+}
+async function encodeFetchNode(fetch) {
+  return mkByteArray(
+    NODE_ENCODING_VERSION,
+    await encodeString(fetch.lfVersion),
+    2 /** Fetch node tag */,
+    await encodeHexString(fetch.contractId),
+    await encodeString(fetch.packageName),
+    await encodeIdentifier(fetch.templateId),
+    await encodeRepeated(fetch.signatories, encodeString),
+    await encodeRepeated(fetch.stakeholders, encodeString),
+    await encodeProtoOptional(fetch, 'interfaceId', fetch.interfaceId, encodeIdentifier),
+    await encodeRepeated(fetch.actingParties, encodeString)
+  );
+}
+async function encodeRollbackNode(rollback, nodesDict, nodeSeeds) {
+  return mkByteArray(
+    NODE_ENCODING_VERSION,
+    3 /** Rollback node tag */,
+    await encodeRepeated(rollback.children, encodeNodeId(nodesDict, nodeSeeds))
+  );
+}
+async function encodeInputContract(contract) {
+  if (contract.contract.oneofKind === 'v1')
+    return mkByteArray(
+      await encodeInt64(contract.createdAt),
+      await sha256(await encodeCreateNode(contract.contract.v1, 'unused_node_id', []))
+    );
+  else throw new Error('Unsupported contract version');
+}
+async function encodeValue(value) {
+  if (value.sum.oneofKind === 'unit') {
+    return Uint8Array.from([0]); // Unit value
+  } else if (value.sum.oneofKind === 'bool') {
+    return mkByteArray(Uint8Array.from([0x01]), await encodeBool(value.sum.bool));
+  } else if (value.sum.oneofKind === 'int64') {
+    return mkByteArray(Uint8Array.from([0x02]), await encodeInt64(parseInt(value.sum.int64, 10)));
+  } else if (value.sum.oneofKind === 'numeric') {
+    return mkByteArray(Uint8Array.from([0x03]), await encodeString(value.sum.numeric));
+  } else if (value.sum.oneofKind === 'timestamp') {
+    // eslint-disable-next-line no-undef
+    return mkByteArray(Uint8Array.from([0x04]), await encodeInt64(BigInt(value.sum.timestamp)));
+  } else if (value.sum.oneofKind === 'date') {
+    return mkByteArray(Uint8Array.from([0x05]), await encodeInt32(value.sum.date));
+  } else if (value.sum.oneofKind === 'party') {
+    return mkByteArray(Uint8Array.from([0x06]), await encodeString(value.sum.party));
+  } else if (value.sum.oneofKind === 'text') {
+    return mkByteArray(Uint8Array.from([0x07]), await encodeString(value.sum.text));
+  } else if (value.sum.oneofKind === 'contractId') {
+    return mkByteArray(Uint8Array.from([0x08]), await encodeHexString(value.sum.contractId));
+  } else if (value.sum.oneofKind === 'optional') {
+    return mkByteArray(
+      Uint8Array.from([0x09]),
+      await encodeProtoOptional(value.sum.optional, 'value', value.sum.optional.value, encodeValue)
+    );
+  } else if (value.sum.oneofKind === 'list') {
+    return mkByteArray(Uint8Array.from([0x0a]), await encodeRepeated(value.sum.list.elements, encodeValue));
+  } else if (value.sum.oneofKind === 'textMap') {
+    return mkByteArray(Uint8Array.from([0x0b]), await encodeRepeated(value.sum.textMap?.entries, encodeTextMapEntry));
+  } else if (value.sum.oneofKind === 'record') {
+    return mkByteArray(
+      Uint8Array.from([0x0c]),
+      await encodeProtoOptional(value.sum.record, 'recordId', value.sum.record.recordId, encodeIdentifier),
+      await encodeRepeated(value.sum.record.fields, encodeRecordField)
+    );
+  } else if (value.sum.oneofKind === 'variant') {
+    return mkByteArray(
+      Uint8Array.from([0x0d]),
+      await encodeProtoOptional(value.sum.variant, 'variantId', value.sum.variant.variantId, encodeIdentifier),
+      await encodeString(value.sum.variant.constructor),
+      await encodeValue(value.sum.variant.value)
+    );
+  } else if (value.sum.oneofKind === 'enum') {
+    return mkByteArray(
+      Uint8Array.from([0x0e]),
+      await encodeProtoOptional(value.sum.enum, 'enumId', value.sum.enum.enumId, encodeIdentifier),
+      await encodeString(value.sum.enum.constructor)
+    );
+  } else if (value.sum.oneofKind === 'genMap') {
+    return mkByteArray(Uint8Array.from([0x0f]), await encodeRepeated(value.sum.genMap?.entries, encodeGenMapEntry));
+  }
+  throw new Error('Unsupported value type: ' + JSON.stringify(value));
+}
+async function encodeTextMapEntry(entry) {
+  return mkByteArray(await encodeString(entry.key), await encodeValue(entry.value));
+}
+async function encodeRecordField(field) {
+  return mkByteArray(await encodeOptional(field.label, encodeString), await encodeValue(field.value));
+}
+async function encodeGenMapEntry(entry) {
+  return mkByteArray(await encodeValue(entry.key), await encodeValue(entry.value));
+}
+function encodeNodeId(nodesDict, nodeSeeds) {
+  return async (nodeId) => {
+    const node = nodesDict[nodeId];
+    if (!node) {
+      throw new Error(`Node with ID ${nodeId} not found in transaction`);
+    }
+    const encodedNode = await encodeNode(node, nodesDict, nodeSeeds);
+    return sha256(encodedNode);
+  };
+}
+async function encodeNode(node, nodesDict, nodeSeeds) {
+  if (node.versionedNode.oneofKind === 'v1') {
+    if (node.versionedNode.v1.nodeType.oneofKind === 'create') {
+      return encodeCreateNode(node.versionedNode.v1.nodeType.create, node.nodeId, nodeSeeds);
+    } else if (node.versionedNode.v1.nodeType.oneofKind === 'exercise') {
+      return encodeExerciseNode(node.versionedNode.v1.nodeType.exercise, node.nodeId, nodesDict, nodeSeeds);
+    } else if (node.versionedNode.v1.nodeType.oneofKind === 'fetch') {
+      return encodeFetchNode(node.versionedNode.v1.nodeType.fetch);
+    } else if (node.versionedNode.v1.nodeType.oneofKind === 'rollback') {
+      return encodeRollbackNode(node.versionedNode.v1.nodeType.rollback, nodesDict, nodeSeeds);
+    }
+    throw new Error('Unsupported node type');
+  } else {
+    throw new Error(`Unsupported node version`);
+  }
+}
+function createNodesDict(preparedTransaction) {
+  const nodesDict = {};
+  const nodes = preparedTransaction.transaction?.nodes || [];
+  for (const node of nodes) {
+    nodesDict[node.nodeId] = node;
+  }
+  return nodesDict;
+}
+async function encodeTransaction(transaction, nodesDict, nodeSeeds) {
+  return mkByteArray(
+    await encodeString(transaction.version),
+    await encodeRepeated(transaction.roots, encodeNodeId(nodesDict, nodeSeeds))
+  );
+}
+async function hashTransaction(transaction, nodesDict) {
+  const encodedTransaction = await encodeTransaction(transaction, nodesDict, transaction.nodeSeeds);
+  const hash = await sha256(await mkByteArray(PREPARED_TRANSACTION_HASH_PURPOSE, encodedTransaction));
+  return hash;
+}
+async function hashMetadata(metadata) {
+  const hash = await sha256(await mkByteArray(PREPARED_TRANSACTION_HASH_PURPOSE, await encodeMetadata(metadata)));
+  return hash;
+}
+async function encodePreparedTransaction(preparedTransaction) {
+  const nodesDict = createNodesDict(preparedTransaction);
+  const transactionHash = await hashTransaction(preparedTransaction.transaction, nodesDict);
+  const metadataHash = await hashMetadata(preparedTransaction.metadata);
+  return mkByteArray(PREPARED_TRANSACTION_HASH_PURPOSE, HASHING_SCHEME_VERSION, transactionHash, metadataHash);
+}
+async function computePreparedTransaction(preparedTransaction) {
+  return sha256(await encodePreparedTransaction(preparedTransaction));
+}
+module.exports.computePreparedTransaction = computePreparedTransaction;

package/dist/resources/proto/damlTransaction.js

@@ -1,6 +1,6 @@
-import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
-import { DamlTransaction_Node } from './damlTransactionNode.js';
-import { DamlTransaction_NodeSeed } from './damlTransactionNodeSeed.js';
+const { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } = require('@protobuf-ts/runtime');
+const { DamlTransaction_Node } = require('./damlTransactionNode.js');
+const { DamlTransaction_NodeSeed } = require('./damlTransactionNodeSeed.js');
 
 class DamlTransaction$Type extends MessageType {
   constructor() {
@@ -97,4 +97,4 @@ class DamlTransaction$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.DamlTransaction
  */
-export const DamlTransaction = new DamlTransaction$Type();
+module.exports.DamlTransaction = new DamlTransaction$Type();

package/dist/resources/proto/damlTransactionNode.js

@@ -1,5 +1,5 @@
-import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
-import { Node } from './node/node.js';
+const { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } = require('@protobuf-ts/runtime');
+const { Node } = require('./node/node.js');
 
 class DamlTransaction_Node$Type extends MessageType {
   constructor() {
@@ -68,4 +68,4 @@ class DamlTransaction_Node$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.DamlTransaction.Node
  */
-export const DamlTransaction_Node = new DamlTransaction_Node$Type();
+module.exports.DamlTransaction_Node = new DamlTransaction_Node$Type();

package/dist/resources/proto/damlTransactionNodeSeed.js

@@ -1,4 +1,4 @@
-import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
+const { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } = require('@protobuf-ts/runtime');
 
 class DamlTransaction_NodeSeed$Type extends MessageType {
   constructor() {
@@ -53,4 +53,4 @@ class DamlTransaction_NodeSeed$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.DamlTransaction.NodeSeed
  */
-export const DamlTransaction_NodeSeed = new DamlTransaction_NodeSeed$Type();
+module.exports.DamlTransaction_NodeSeed = new DamlTransaction_NodeSeed$Type();

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

@@ -1,6 +1,6 @@
-import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
-import { Value } from '../node/value.js';
-import { GlobalKey } from '../node/globalKey.js';
+const { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } = require('@protobuf-ts/runtime');
+const { Value } = require('../node/value.js');
+const { GlobalKey } = require('../node/globalKey.js');
 
 class Metadata_GlobalKeyMappingEntry$Type extends MessageType {
   constructor() {
@@ -50,4 +50,4 @@ class Metadata_GlobalKeyMappingEntry$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.Metadata.GlobalKeyMappingEntry
  */
-export const Metadata_GlobalKeyMappingEntry = new Metadata_GlobalKeyMappingEntry$Type();
+module.exports.Metadata_GlobalKeyMappingEntry = new Metadata_GlobalKeyMappingEntry$Type();

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

@@ -1,5 +1,5 @@
-import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
-import { Create } from '../node/node.js';
+const { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } = require('@protobuf-ts/runtime');
+const { Create } = require('../node/node.js');
 
 class Metadata_InputContract$Type extends MessageType {
   constructor() {
@@ -77,4 +77,4 @@ class Metadata_InputContract$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.Metadata.InputContract
  */
-export const Metadata_InputContract = new Metadata_InputContract$Type();
+module.exports.Metadata_InputContract = new Metadata_InputContract$Type();

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

@@ -1,4 +1,4 @@
-import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
+const { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } = require('@protobuf-ts/runtime');
 
 class Metadata_SubmitterInfo$Type extends MessageType {
   constructor() {
@@ -59,4 +59,4 @@ class Metadata_SubmitterInfo$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.Metadata.SubmitterInfo
  */
-export const Metadata_SubmitterInfo = new Metadata_SubmitterInfo$Type();
+module.exports.Metadata_SubmitterInfo = new Metadata_SubmitterInfo$Type();

package/dist/resources/proto/metadata.js

@@ -1,7 +1,7 @@
-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';
+const { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } = require('@protobuf-ts/runtime');
+const { Metadata_GlobalKeyMappingEntry } = require('./metadata/metadataGlobalKeyMappingEntry.js');
+const { Metadata_InputContract } = require('./metadata/metadataInputContract.js');
+const { Metadata_SubmitterInfo } = require('./metadata/metadataSubmitterInfo.js');
 
 class Metadata$Type extends MessageType {
   constructor() {
@@ -186,4 +186,4 @@ class Metadata$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.Metadata
  */
-export const Metadata = new Metadata$Type();
+module.exports.Metadata = new Metadata$Type();

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

@@ -1,4 +1,4 @@
-import { MessageType, UnknownFieldHandler, reflectionMergePartial } from '@protobuf-ts/runtime';
+const { MessageType, UnknownFieldHandler, reflectionMergePartial } = require('@protobuf-ts/runtime');
 
 class Empty$Type extends MessageType {
   constructor() {
@@ -33,4 +33,4 @@ class Empty$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message google.protobuf.Empty
  */
-export const Empty = new Empty$Type();
+module.exports.Empty = new Empty$Type();

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

@@ -1,6 +1,6 @@
-import { MessageType, reflectionMergePartial, UnknownFieldHandler, WireType } from '@protobuf-ts/runtime';
-import { Value } from './value.js';
-import { Identifier } from './identifier.js';
+const { MessageType, reflectionMergePartial, UnknownFieldHandler, WireType } = require('@protobuf-ts/runtime');
+const { Value } = require('./value.js');
+const { Identifier } = require('./identifier.js');
 
 class GlobalKey$Type extends MessageType {
   constructor() {
@@ -78,4 +78,4 @@ class GlobalKey$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.GlobalKey
  */
-export const GlobalKey = new GlobalKey$Type();
+module.exports.GlobalKey = new GlobalKey$Type();

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

@@ -1,4 +1,4 @@
-import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
+const { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } = require('@protobuf-ts/runtime');
 
 class Identifier$Type extends MessageType {
   constructor() {
@@ -70,4 +70,4 @@ class Identifier$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.Identifier
  */
-export const Identifier = new Identifier$Type();
+module.exports.Identifier = new Identifier$Type();

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

@@ -1,6 +1,6 @@
-import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
-import { Value } from './value.js';
-import { Identifier } from './identifier.js';
+const { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } = require('@protobuf-ts/runtime');
+const { Value } = require('./value.js');
+const { Identifier } = require('./identifier.js');
 
 class Fetch$Type extends MessageType {
   constructor() {
@@ -146,7 +146,7 @@ class Fetch$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.transaction.v1.Fetch
  */
-export const Fetch = new Fetch$Type();
+const Fetch = new Fetch$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class Exercise$Type extends MessageType {
   constructor() {
@@ -367,7 +367,7 @@ class Exercise$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.transaction.v1.Exercise
  */
-export const Exercise = new Exercise$Type();
+const Exercise = new Exercise$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class Create$Type extends MessageType {
   constructor() {
@@ -490,7 +490,7 @@ class Create$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.transaction.v1.Create
  */
-export const Create = new Create$Type();
+const Create = new Create$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class Rollback$Type extends MessageType {
   constructor() {
@@ -540,7 +540,7 @@ class Rollback$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.transaction.v1.Rollback
  */
-export const Rollback = new Rollback$Type();
+const Rollback = new Rollback$Type();
 // @generated message type with reflection information, may provide speed optimized methods
 class Node$Type extends MessageType {
   constructor() {
@@ -653,4 +653,12 @@ class Node$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.interactive.transaction.v1.Node
  */
-export const Node = new Node$Type();
+const Node = new Node$Type();
+
+module.exports = {
+  Fetch,
+  Exercise,
+  Create,
+  Rollback,
+  Node,
+};

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

@@ -1,11 +1,11 @@
-import {
+const {
   MessageType,
   UnknownFieldHandler,
   reflectionMergePartial,
   WireType,
   PbLong,
   typeofJsonValue,
-} from '@protobuf-ts/runtime';
+} = require('@protobuf-ts/runtime');
 
 class Timestamp$Type extends MessageType {
   constructor() {
@@ -142,4 +142,4 @@ class Timestamp$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message google.protobuf.Timestamp
  */
-export const Timestamp = new Timestamp$Type();
+module.exports.Timestamp = new Timestamp$Type();

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

@@ -1,6 +1,6 @@
-import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
-import { Empty } from './empty.js';
-import { Identifier } from './identifier.js';
+const { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } = require('@protobuf-ts/runtime');
+const { Empty } = require('./empty.js');
+const { Identifier } = require('./identifier.js');
 
 class Value$Type extends MessageType {
   constructor() {
@@ -289,7 +289,7 @@ class Value$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.Value
  */
-export const Value = new Value$Type();
+const Value = new Value$Type();
 
 class Optional$Type extends MessageType {
   constructor() {
@@ -330,7 +330,7 @@ class Optional$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.Optional
  */
-export const Optional = new Optional$Type();
+const Optional = new Optional$Type();
 
 class List$Type extends MessageType {
   constructor() {
@@ -380,7 +380,7 @@ class List$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.List
  */
-export const List = new List$Type();
+const List = new List$Type();
 
 class TextMap$Type extends MessageType {
   constructor() {
@@ -434,7 +434,7 @@ class TextMap$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.TextMap
  */
-export const TextMap = new TextMap$Type();
+const TextMap = new TextMap$Type();
 
 class TextMap_Entry$Type extends MessageType {
   constructor() {
@@ -484,7 +484,7 @@ class TextMap_Entry$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.TextMap.Entry
  */
-export const TextMap_Entry = new TextMap_Entry$Type();
+const TextMap_Entry = new TextMap_Entry$Type();
 
 class GenMap$Type extends MessageType {
   constructor() {
@@ -538,7 +538,7 @@ class GenMap$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.GenMap
  */
-export const GenMap = new GenMap$Type();
+const GenMap = new GenMap$Type();
 
 class GenMap_Entry$Type extends MessageType {
   constructor() {
@@ -588,7 +588,7 @@ class GenMap_Entry$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.GenMap.Entry
  */
-export const GenMap_Entry = new GenMap_Entry$Type();
+const GenMap_Entry = new GenMap_Entry$Type();
 
 class Record$Type extends MessageType {
   constructor() {
@@ -649,7 +649,7 @@ class Record$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.Record
  */
-export const Record = new Record$Type();
+const Record = new Record$Type();
 
 class RecordField$Type extends MessageType {
   constructor() {
@@ -704,7 +704,7 @@ class RecordField$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.RecordField
  */
-export const RecordField = new RecordField$Type();
+const RecordField = new RecordField$Type();
 
 class Variant$Type extends MessageType {
   constructor() {
@@ -766,7 +766,7 @@ class Variant$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.Variant
  */
-export const Variant = new Variant$Type();
+const Variant = new Variant$Type();
 
 class Enum$Type extends MessageType {
   constructor() {
@@ -821,4 +821,18 @@ class Enum$Type extends MessageType {
 /**
  * @generated MessageType for protobuf message com.daml.ledger.api.v2.Enum
  */
-export const Enum = new Enum$Type();
+const Enum = new Enum$Type();
+
+module.exports = {
+  Value,
+  Optional,
+  List,
+  TextMap,
+  TextMap_Entry,
+  GenMap,
+  GenMap_Entry,
+  Record,
+  RecordField,
+  Variant,
+  Enum,
+};

package/dist/resources/proto/preparedTransaction.js

@@ -1,6 +1,6 @@
-import { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } from '@protobuf-ts/runtime';
-import { DamlTransaction } from './damlTransaction.js';
-import { Metadata } from './metadata.js';
+const { MessageType, UnknownFieldHandler, reflectionMergePartial, WireType } = require('@protobuf-ts/runtime');
+const { DamlTransaction } = require('./damlTransaction.js');
+const { Metadata } = require('./metadata.js');
 
 class PreparedTransaction$Type extends MessageType {
   constructor() {
@@ -63,4 +63,4 @@ class PreparedTransaction$Type extends MessageType {
   }
 }
 
-export const PreparedTransaction = new PreparedTransaction$Type();
+module.exports.PreparedTransaction = new PreparedTransaction$Type();