@canton-network/core-tx-visualizer 0.9.0 → 0.10.0

package/dist/index.js

@@ -1,93 +1,552 @@
-// Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
-// SPDX-License-Identifier: Apache-2.0
-import { PreparedTransaction } from '@canton-network/core-ledger-proto';
-import { computePreparedTransaction } from './hashing_scheme_v2.js';
-import { fromBase64, toBase64, toHex } from './utils.js';
-export { computeSha256CantonHash, computeMultiHashForTopology, } from './hashing_scheme_v2.js';
-/**
- * Decodes a base64 encoded prepared transaction into a well-typed data model, generated directly from Protobuf definitions.
- *
- * @param preparedTransaction - The prepared transaction in base64 format
- * @returns The decoded prepared transaction
- */
-export const decodePreparedTransaction = (preparedTransaction) => {
-    const bytes = fromBase64(preparedTransaction);
-    return PreparedTransaction.fromBinary(bytes);
-};
-/**
- * Computes the hash of a prepared transaction.
- *
- * @param preparedTransaction - The prepared transaction to hash
- * @param format - The format of the output hash (base64 or hex)
- * @returns The computed hash in the specified format
- */
-export const hashPreparedTransaction = async (preparedTransaction, format = 'base64') => {
-    let preparedTx;
-    if (typeof preparedTransaction === 'string') {
-        preparedTx = decodePreparedTransaction(preparedTransaction);
+import { HashingSchemeVersion, PreparedTransaction } from '@canton-network/core-ledger-proto';
+
+// src/index.ts
+
+// src/utils.ts
+function fromBase64(b64) {
+  const binaryString = atob(b64);
+  const len = binaryString.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+function toBase64(data) {
+  let binaryString = "";
+  const len = data.byteLength;
+  for (let i = 0; i < len; i++) {
+    binaryString += String.fromCharCode(data[i]);
+  }
+  return btoa(binaryString);
+}
+function toHex(bytes) {
+  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+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;
     }
-    else {
-        preparedTx = preparedTransaction;
+  });
+  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;
+}
+
+// src/hashing_scheme_v2.ts
+var PREPARED_TRANSACTION_HASH_PURPOSE = Uint8Array.from([
+  0,
+  0,
+  0,
+  48
+]);
+var NODE_ENCODING_VERSION = Uint8Array.from([1]);
+var HASHING_SCHEME_VERSION = Uint8Array.from([HashingSchemeVersion.V2]);
+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);
+  return new Uint8Array(buffer);
+}
+async function encodeInt64(value) {
+  const num = typeof value === "bigint" ? value : BigInt(value || 0);
+  const buffer = new ArrayBuffer(8);
+  const view = new DataView(buffer);
+  view.setBigInt64(0, num, false);
+  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 = "") {
+  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);
+}
+async function encodeOptional(value, encodeFn) {
+  if (value === void 0 || value === null) {
+    return new Uint8Array([0]);
+  } else {
+    return mkByteArray(1, await encodeFn(value));
+  }
+}
+async function encodeProtoOptional(parentValue, fieldName, value, encodeFn) {
+  if (parentValue && parentValue[fieldName] !== void 0) {
+    return mkByteArray(1, await encodeFn(value));
+  } else {
+    return new Uint8Array([0]);
+  }
+}
+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(
+    (seed2) => seed2.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([1]),
+    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,
+    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,
+    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,
+    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,
+    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]);
+  } else if (value.sum.oneofKind === "bool") {
+    return mkByteArray(
+      Uint8Array.from([1]),
+      await encodeBool(value.sum.bool)
+    );
+  } else if (value.sum.oneofKind === "int64") {
+    return mkByteArray(
+      Uint8Array.from([2]),
+      await encodeInt64(parseInt(value.sum.int64))
+    );
+  } else if (value.sum.oneofKind === "numeric") {
+    return mkByteArray(
+      Uint8Array.from([3]),
+      await encodeString(value.sum.numeric)
+    );
+  } else if (value.sum.oneofKind === "timestamp") {
+    return mkByteArray(
+      Uint8Array.from([4]),
+      await encodeInt64(BigInt(value.sum.timestamp))
+    );
+  } else if (value.sum.oneofKind === "date") {
+    return mkByteArray(
+      Uint8Array.from([5]),
+      await encodeInt32(value.sum.date)
+    );
+  } else if (value.sum.oneofKind === "party") {
+    return mkByteArray(
+      Uint8Array.from([6]),
+      await encodeString(value.sum.party)
+    );
+  } else if (value.sum.oneofKind === "text") {
+    return mkByteArray(
+      Uint8Array.from([7]),
+      await encodeString(value.sum.text)
+    );
+  } else if (value.sum.oneofKind === "contractId") {
+    return mkByteArray(
+      Uint8Array.from([8]),
+      await encodeHexString(value.sum.contractId)
+    );
+  } else if (value.sum.oneofKind === "optional") {
+    return mkByteArray(
+      Uint8Array.from([9]),
+      await encodeProtoOptional(
+        value.sum.optional,
+        "value",
+        value.sum.optional.value,
+        encodeValue
+      )
+    );
+  } else if (value.sum.oneofKind === "list") {
+    return mkByteArray(
+      Uint8Array.from([10]),
+      await encodeRepeated(value.sum.list.elements, encodeValue)
+    );
+  } else if (value.sum.oneofKind === "textMap") {
+    return mkByteArray(
+      Uint8Array.from([11]),
+      await encodeRepeated(value.sum.textMap?.entries, encodeTextMapEntry)
+    );
+  } else if (value.sum.oneofKind === "record") {
+    return mkByteArray(
+      Uint8Array.from([12]),
+      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([13]),
+      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([14]),
+      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([15]),
+      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 hash = await computePreparedTransaction(preparedTx);
-    switch (format) {
-        case 'base64':
-            return toBase64(hash);
-        case 'hex':
-            return toHex(hash);
+    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));
+}
+async function computeSha256CantonHash(purpose, bytes) {
+  const encodedPurpose = await encodeInt32(purpose);
+  const hashInput = await mkByteArray(encodedPurpose, bytes);
+  const hashBytes = await sha256(hashInput);
+  const multiprefix = new Uint8Array([18, 32]);
+  return mkByteArray(multiprefix, hashBytes);
+}
+async function computeMultiHashForTopology(hashes) {
+  const sortedHashes = hashes.slice().sort((a, b) => toHex(a).localeCompare(toHex(b)));
+  const numHashesBytes = await encodeInt32(sortedHashes.length);
+  const concatenatedHashes = [numHashesBytes];
+  for (const h of sortedHashes) {
+    const lengthBytes = await encodeInt32(h.length);
+    concatenatedHashes.push(lengthBytes, h);
+  }
+  return mkByteArray(...concatenatedHashes);
+}
+
+// src/index.ts
+var decodePreparedTransaction = (preparedTransaction) => {
+  const bytes = fromBase64(preparedTransaction);
+  return PreparedTransaction.fromBinary(bytes);
 };
-export const validateAuthorizedPartyIds = (preparedTransaction, authorizedPartyIds) => {
-    let preparedTx;
-    if (typeof preparedTransaction === 'string') {
-        preparedTx = decodePreparedTransaction(preparedTransaction);
-    }
-    else {
-        preparedTx = preparedTransaction;
-    }
-    const results = {};
-    preparedTx.metadata?.submitterInfo?.actAs.forEach((party) => {
-        results[party] = {
-            isAuthorized: authorizedPartyIds.includes(party),
-            locations: [
+var hashPreparedTransaction = async (preparedTransaction, format = "base64") => {
+  let preparedTx;
+  if (typeof preparedTransaction === "string") {
+    preparedTx = decodePreparedTransaction(preparedTransaction);
+  } else {
+    preparedTx = preparedTransaction;
+  }
+  const hash = await computePreparedTransaction(preparedTx);
+  switch (format) {
+    case "base64":
+      return toBase64(hash);
+    case "hex":
+      return toHex(hash);
+  }
+};
+var validateAuthorizedPartyIds = (preparedTransaction, authorizedPartyIds) => {
+  let preparedTx;
+  if (typeof preparedTransaction === "string") {
+    preparedTx = decodePreparedTransaction(preparedTransaction);
+  } else {
+    preparedTx = preparedTransaction;
+  }
+  const results = {};
+  preparedTx.metadata?.submitterInfo?.actAs.forEach((party) => {
+    results[party] = {
+      isAuthorized: authorizedPartyIds.includes(party),
+      locations: [
+        ...results[party].locations,
+        "metadata.submitterInfo.actAs"
+      ]
+    };
+  });
+  preparedTx.transaction?.nodes.forEach((node) => {
+    if (node.versionedNode.oneofKind === "v1") {
+      if (node.versionedNode.v1.nodeType.oneofKind === "create") {
+        node.versionedNode.v1.nodeType.create.signatories.forEach(
+          (party) => {
+            results[party] = {
+              isAuthorized: authorizedPartyIds.includes(party),
+              locations: [
+                ...results[party].locations,
+                `transaction.nodes.${node.nodeId}.create.signatories`
+              ]
+            };
+          }
+        );
+        node.versionedNode.v1.nodeType.create.stakeholders.forEach(
+          (party) => {
+            results[party] = {
+              isAuthorized: authorizedPartyIds.includes(party),
+              locations: [
                 ...results[party].locations,
-                'metadata.submitterInfo.actAs',
-            ],
-        };
-    });
-    // then check transaction nodes
-    preparedTx.transaction?.nodes.forEach((node) => {
-        if (node.versionedNode.oneofKind === 'v1') {
-            if (node.versionedNode.v1.nodeType.oneofKind === 'create') {
-                node.versionedNode.v1.nodeType.create.signatories.forEach((party) => {
-                    results[party] = {
-                        isAuthorized: authorizedPartyIds.includes(party),
-                        locations: [
-                            ...results[party].locations,
-                            `transaction.nodes.${node.nodeId}.create.signatories`,
-                        ],
-                    };
-                });
-                node.versionedNode.v1.nodeType.create.stakeholders.forEach((party) => {
-                    results[party] = {
-                        isAuthorized: authorizedPartyIds.includes(party),
-                        locations: [
-                            ...results[party].locations,
-                            `transaction.nodes.${node.nodeId}.create.stakeholders`,
-                        ],
-                    };
-                });
-            }
-            if (node.versionedNode.v1.nodeType.oneofKind === 'exercise') {
-                throw new Error('Unsupported');
-            }
-            if (node.versionedNode.v1.nodeType.oneofKind === 'fetch') {
-                throw new Error('Unsupported');
-            }
-            if (node.versionedNode.v1.nodeType.oneofKind === 'rollback') {
-                // do we need to check these nodes?
-            }
-        }
-    });
-    return results;
+                `transaction.nodes.${node.nodeId}.create.stakeholders`
+              ]
+            };
+          }
+        );
+      }
+      if (node.versionedNode.v1.nodeType.oneofKind === "exercise") {
+        throw new Error("Unsupported");
+      }
+      if (node.versionedNode.v1.nodeType.oneofKind === "fetch") {
+        throw new Error("Unsupported");
+      }
+      if (node.versionedNode.v1.nodeType.oneofKind === "rollback") ;
+    }
+  });
+  return results;
 };
+
+export { computeMultiHashForTopology, computeSha256CantonHash, decodePreparedTransaction, hashPreparedTransaction, validateAuthorizedPartyIds };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map