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

package/dist/index.cjs

@@ -0,0 +1,563 @@
+'use strict';
+
+var coreLedgerProto = require('@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;
+    }
+  });
+  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([coreLedgerProto.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 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 coreLedgerProto.PreparedTransaction.fromBinary(bytes);
+};
+var decodeTopologyTransaction = (topologyTx) => {
+  const bytes = fromBase64(topologyTx);
+  return coreLedgerProto.TopologyTransaction.fromBinary(bytes);
+};
+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,
+                `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;
+};
+
+exports.computeMultiHashForTopology = computeMultiHashForTopology;
+exports.computeSha256CantonHash = computeSha256CantonHash;
+exports.decodePreparedTransaction = decodePreparedTransaction;
+exports.decodeTopologyTransaction = decodeTopologyTransaction;
+exports.hashPreparedTransaction = hashPreparedTransaction;
+exports.validateAuthorizedPartyIds = validateAuthorizedPartyIds;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils.ts","../src/hashing_scheme_v2.ts","../src/index.ts"],"names":["HashingSchemeVersion","seed","PreparedTransaction","TopologyTransaction"],"mappings":";;;;;;;AAIO,SAAS,WAAW,GAAA,EAAyB;AAChD,EAAA,MAAM,YAAA,GAAe,KAAK,GAAG,CAAA;AAC7B,EAAA,MAAM,MAAM,YAAA,CAAa,MAAA;AACzB,EAAA,MAAM,KAAA,GAAQ,IAAI,UAAA,CAAW,GAAG,CAAA;AAChC,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,GAAA,EAAK,CAAA,EAAA,EAAK;AAC1B,IAAA,KAAA,CAAM,CAAC,CAAA,GAAI,YAAA,CAAa,UAAA,CAAW,CAAC,CAAA;AAAA,EACxC;AACA,EAAA,OAAO,KAAA;AACX;AAGO,SAAS,SAAS,IAAA,EAA0B;AAC/C,EAAA,IAAI,YAAA,GAAe,EAAA;AACnB,EAAA,MAAM,MAAM,IAAA,CAAK,UAAA;AACjB,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,GAAA,EAAK,CAAA,EAAA,EAAK;AAC1B,IAAA,YAAA,IAAgB,MAAA,CAAO,YAAA,CAAa,IAAA,CAAK,CAAC,CAAC,CAAA;AAAA,EAC/C;AACA,EAAA,OAAO,KAAK,YAAY,CAAA;AAC5B;AAGO,SAAS,MAAM,KAAA,EAA2B;AAC7C,EAAA,OAAO,MAAM,IAAA,CAAK,KAAK,CAAA,CAClB,GAAA,CAAI,CAAC,IAAA,KAAS,IAAA,CAAK,QAAA,CAAS,EAAE,EAAE,QAAA,CAAS,CAAA,EAAG,GAAG,CAAC,CAAA,CAChD,KAAK,EAAE,CAAA;AAChB;AAcA,eAAsB,OAClB,OAAA,EACmB;AACnB,EAAA,MAAM,GAAA,GACF,OAAO,OAAA,KAAY,QAAA,GACb,IAAI,WAAA,EAAY,CAAE,MAAA,CAAO,OAAO,CAAA,GAChC,OAAA;AAEV,EAAA,OAAO,MAAA,CAAO,MAAA,CACT,MAAA,CAAO,SAAA,EAAW,IAAI,UAAA,CAAW,GAAG,CAAC,CAAA,CACrC,KAAK,CAAC,IAAA,KAAS,IAAI,UAAA,CAAW,IAAI,CAAC,CAAA;AAC5C;AAGA,eAAsB,eACf,IAAA,EACgB;AACnB,EAAA,MAAM,cAAA,GAA+B,IAAA,CAAK,GAAA,CAAI,CAAC,GAAA,KAAQ;AACnD,IAAA,IAAI,OAAO,QAAQ,QAAA,EAAU;AACzB,MAAA,OAAO,IAAI,UAAA,CAAW,CAAC,GAAG,CAAC,CAAA;AAAA,IAC/B,CAAA,MAAO;AACH,MAAA,OAAO,GAAA;AAAA,IACX;AAAA,EACJ,CAAC,CAAA;AAED,EAAA,IAAI,WAAA,GAAc,CAAA;AAClB,EAAA,cAAA,CAAe,OAAA,CAAQ,CAAC,GAAA,KAAQ;AAC5B,IAAA,WAAA,IAAe,GAAA,CAAI,MAAA;AAAA,EACvB,CAAC,CAAA;AAED,EAAA,MAAM,WAAA,GAAc,IAAI,UAAA,CAAW,WAAW,CAAA;AAC9C,EAAA,IAAI,MAAA,GAAS,CAAA;AAEb,EAAA,cAAA,CAAe,OAAA,CAAQ,CAAC,GAAA,KAAQ;AAC5B,IAAA,WAAA,CAAY,GAAA,CAAI,KAAK,MAAM,CAAA;AAC3B,IAAA,MAAA,IAAU,GAAA,CAAI,MAAA;AAAA,EAClB,CAAC,CAAA;AAED,EAAA,OAAO,WAAA;AACX;;;ACtDA,IAAM,iCAAA,GAAoC,WAAW,IAAA,CAAK;AAAA,EACtD,CAAA;AAAA,EAAM,CAAA;AAAA,EAAM,CAAA;AAAA,EAAM;AACtB,CAAC,CAAA;AAED,IAAM,qBAAA,GAAwB,UAAA,CAAW,IAAA,CAAK,CAAC,CAAI,CAAC,CAAA;AAEpD,IAAM,yBAAyB,UAAA,CAAW,IAAA,CAAK,CAACA,oCAAA,CAAqB,EAAE,CAAC,CAAA;AAExE,eAAe,WAAW,KAAA,EAAqC;AAC3D,EAAA,OAAO,IAAI,UAAA,CAAW,CAAC,KAAA,GAAQ,CAAA,GAAI,CAAC,CAAC,CAAA;AACzC;AAEA,eAAe,YAAY,KAAA,EAAoC;AAC3D,EAAA,MAAM,MAAA,GAAS,IAAI,WAAA,CAAY,CAAC,CAAA;AAChC,EAAA,MAAM,IAAA,GAAO,IAAI,QAAA,CAAS,MAAM,CAAA;AAChC,EAAA,IAAA,CAAK,QAAA,CAAS,CAAA,EAAG,KAAA,EAAO,KAAK,CAAA;AAC7B,EAAA,OAAO,IAAI,WAAW,MAAM,CAAA;AAChC;AAEA,eAAe,YACX,KAAA,EACmB;AACnB,EAAA,MAAM,MAAM,OAAO,KAAA,KAAU,WAAW,KAAA,GAAQ,MAAA,CAAO,SAAS,CAAC,CAAA;AACjE,EAAA,MAAM,MAAA,GAAS,IAAI,WAAA,CAAY,CAAC,CAAA;AAChC,EAAA,MAAM,IAAA,GAAO,IAAI,QAAA,CAAS,MAAM,CAAA;AAChC,EAAA,IAAA,CAAK,WAAA,CAAY,CAAA,EAAG,GAAA,EAAK,KAAK,CAAA;AAC9B,EAAA,OAAO,IAAI,WAAW,MAAM,CAAA;AAChC;AAEA,eAAsB,YAAA,CAAa,QAAgB,EAAA,EAAyB;AACxE,EAAA,MAAM,SAAA,GAAY,IAAI,WAAA,EAAY,CAAE,OAAO,KAAK,CAAA;AAChD,EAAA,OAAO,YAAY,SAAS,CAAA;AAChC;AAEA,eAAe,YAAY,KAAA,EAAwC;AAC/D,EAAA,MAAM,MAAA,GAAS,MAAM,WAAA,CAAY,KAAA,CAAM,MAAM,CAAA;AAC7C,EAAA,OAAO,WAAA,CAAY,QAAQ,KAAK,CAAA;AACpC;AAEA,eAAe,WAAW,KAAA,EAAwC;AAC9D,EAAA,OAAO,KAAA;AACX;AAEA,SAAS,eAAA,CAAgB,QAAgB,EAAA,EAAyB;AAE9D,EAAA,MAAM,KAAA,GAAQ,IAAI,UAAA,CAAW,KAAA,CAAM,SAAS,CAAC,CAAA;AAC7C,EAAA,KAAA,IAAS,IAAI,CAAA,EAAG,CAAA,GAAI,KAAA,CAAM,MAAA,EAAQ,KAAK,CAAA,EAAG;AACtC,IAAA,KAAA,CAAM,CAAA,GAAI,CAAC,CAAA,GAAI,QAAA,CAAS,KAAA,CAAM,MAAM,CAAA,EAAG,CAAA,GAAI,CAAC,CAAA,EAAG,EAAE,CAAA;AAAA,EACrD;AACA,EAAA,OAAO,YAAY,KAAK,CAAA;AAC5B;AAGA,eAAe,cAAA,CACX,OACA,QAAA,EACmB;AACnB,EAAA,IAAI,KAAA,KAAU,MAAA,IAAa,KAAA,KAAU,IAAA,EAAM;AACvC,IAAA,OAAO,IAAI,UAAA,CAAW,CAAC,CAAC,CAAC,CAAA;AAAA,EAC7B,CAAA,MAAO;AACH,IAAA,OAAO,WAAA,CAAY,CAAA,EAAG,MAAM,QAAA,CAAS,KAAK,CAAC,CAAA;AAAA,EAC/C;AACJ;AAGA,eAAe,mBAAA,CACX,WAAA,EACA,SAAA,EACA,KAAA,EACA,QAAA,EACmB;AACnB,EAAA,IAAI,WAAA,IAAe,WAAA,CAAY,SAAS,CAAA,KAAM,MAAA,EAAW;AACrD,IAAA,OAAO,WAAA,CAAY,CAAA,EAAG,MAAM,QAAA,CAAS,KAAK,CAAC,CAAA;AAAA,EAC/C,CAAA,MAAO;AACH,IAAA,OAAO,IAAI,UAAA,CAAW,CAAC,CAAC,CAAC,CAAA;AAAA,EAC7B;AACJ;AAEA,eAAe,cAAA,CACX,MAAA,GAAc,EAAC,EACf,QAAA,EACmB;AACnB,EAAA,MAAM,MAAA,GAAS,MAAM,WAAA,CAAY,MAAA,CAAO,MAAM,CAAA;AAC9C,EAAA,MAAM,gBAAgB,MAAM,OAAA,CAAQ,IAAI,MAAA,CAAO,GAAA,CAAI,QAAQ,CAAC,CAAA;AAC5D,EAAA,OAAO,WAAA,CAAY,MAAA,EAAQ,GAAG,aAAa,CAAA;AAC/C;AAEA,SAAS,QAAA,CACL,QACA,SAAA,EACsB;AACtB,EAAA,MAAM,OAAO,SAAA,CAAU,IAAA;AAAA,IACnB,CAACC,KAAAA,KAASA,KAAAA,CAAK,MAAA,CAAO,UAAS,KAAM;AAAA,GACzC,EAAG,IAAA;AAEH,EAAA,OAAO,IAAA;AACX;AAEA,eAAe,iBAAiB,UAAA,EAA6C;AACzE,EAAA,OAAO,WAAA;AAAA,IACH,MAAM,YAAA,CAAa,UAAA,CAAW,SAAS,CAAA;AAAA,IACvC,MAAM,cAAA,CAAe,UAAA,CAAW,WAAW,KAAA,CAAM,GAAG,GAAG,YAAY,CAAA;AAAA,IACnE,MAAM,cAAA,CAAe,UAAA,CAAW,WAAW,KAAA,CAAM,GAAG,GAAG,YAAY;AAAA,GACvE;AACJ;AAEA,eAAe,eAAe,QAAA,EAAyC;AACnE,EAAA,OAAO,WAAA;AAAA,IACH,UAAA,CAAW,IAAA,CAAK,CAAC,CAAI,CAAC,CAAA;AAAA,IACtB,MAAM,cAAA,CAAe,QAAA,CAAS,aAAA,EAAe,OAAO,YAAY,CAAA;AAAA,IAChE,MAAM,YAAA,CAAa,QAAA,CAAS,aAAA,EAAe,SAAS,CAAA;AAAA,IACpD,MAAM,YAAA,CAAa,QAAA,CAAS,eAAe,CAAA;AAAA,IAC3C,MAAM,WAAA,CAAY,QAAA,CAAS,aAAa,CAAA;AAAA,IACxC,MAAM,YAAA,CAAa,QAAA,CAAS,cAAc,CAAA;AAAA,IAC1C,MAAM,mBAAA;AAAA,MACF,QAAA;AAAA,MACA,wBAAA;AAAA,MACA,QAAA,CAAS,sBAAA;AAAA,MACT;AAAA,KACJ;AAAA,IACA,MAAM,mBAAA;AAAA,MACF,QAAA;AAAA,MACA,wBAAA;AAAA,MACA,QAAA,CAAS,sBAAA;AAAA,MACT;AAAA,KACJ;AAAA,IACA,MAAM,WAAA,CAAY,QAAA,CAAS,eAAe,CAAA;AAAA,IAC1C,MAAM,cAAA,CAAe,QAAA,CAAS,cAAA,EAAgB,mBAAmB;AAAA,GACrE;AACJ;AAEA,eAAe,gBAAA,CACX,MAAA,EACA,MAAA,EACA,SAAA,EACmB;AACnB,EAAA,OAAO,MAAA,GACD,WAAA;AAAA,IACI,qBAAA;AAAA,IACA,MAAM,YAAA,CAAa,MAAA,CAAO,SAAS,CAAA;AAAA,IACnC,CAAA;AAAA,IACA,MAAM,cAAA,CAAe,QAAA,CAAS,MAAA,EAAQ,SAAS,GAAG,UAAU,CAAA;AAAA,IAC5D,MAAM,eAAA,CAAgB,MAAA,CAAO,UAAU,CAAA;AAAA,IACvC,MAAM,YAAA,CAAa,MAAA,CAAO,WAAW,CAAA;AAAA,IACrC,MAAM,gBAAA,CAAiB,MAAA,CAAO,UAAW,CAAA;AAAA,IACzC,MAAM,WAAA,CAAY,MAAA,CAAO,QAAS,CAAA;AAAA,IAClC,MAAM,cAAA,CAAe,MAAA,CAAO,WAAA,EAAa,YAAY,CAAA;AAAA,IACrD,MAAM,cAAA,CAAe,MAAA,CAAO,YAAA,EAAc,YAAY;AAAA,MAE1D,WAAA,EAAY;AACtB;AAEA,eAAe,kBAAA,CACX,QAAA,EACA,MAAA,EACA,SAAA,EACA,SAAA,EACmB;AACnB,EAAA,OAAO,WAAA;AAAA,IACH,qBAAA;AAAA,IACA,MAAM,YAAA,CAAa,QAAA,CAAS,SAAS,CAAA;AAAA,IACrC,CAAA;AAAA,IACA,MAAM,UAAA,CAAW,QAAA,CAAS,MAAA,EAAQ,SAAS,CAAE,CAAA;AAAA,IAC7C,MAAM,eAAA,CAAgB,QAAA,CAAS,UAAU,CAAA;AAAA,IACzC,MAAM,YAAA,CAAa,QAAA,CAAS,WAAW,CAAA;AAAA,IACvC,MAAM,gBAAA,CAAiB,QAAA,CAAS,UAAW,CAAA;AAAA,IAC3C,MAAM,cAAA,CAAe,QAAA,CAAS,WAAA,EAAa,YAAY,CAAA;AAAA,IACvD,MAAM,cAAA,CAAe,QAAA,CAAS,YAAA,EAAc,YAAY,CAAA;AAAA,IACxD,MAAM,cAAA,CAAe,QAAA,CAAS,aAAA,EAAe,YAAY,CAAA;AAAA,IACzD,MAAM,mBAAA;AAAA,MACF,QAAA;AAAA,MACA,aAAA;AAAA,MACA,QAAA,CAAS,WAAA;AAAA,MACT;AAAA,KACJ;AAAA,IACA,MAAM,YAAA,CAAa,QAAA,CAAS,QAAQ,CAAA;AAAA,IACpC,MAAM,WAAA,CAAY,QAAA,CAAS,WAAY,CAAA;AAAA,IACvC,MAAM,UAAA,CAAW,QAAA,CAAS,SAAS,CAAA;AAAA,IACnC,MAAM,mBAAA;AAAA,MACF,QAAA;AAAA,MACA,gBAAA;AAAA,MACA,QAAA,CAAS,cAAA;AAAA,MACT;AAAA,KACJ;AAAA,IACA,MAAM,cAAA,CAAe,QAAA,CAAS,eAAA,EAAiB,YAAY,CAAA;AAAA,IAC3D,MAAM,cAAA;AAAA,MACF,QAAA,CAAS,QAAA;AAAA,MACT,YAAA,CAAa,WAAW,SAAS;AAAA;AACrC,GACJ;AACJ;AAEA,eAAe,gBAAgB,KAAA,EAAmC;AAC9D,EAAA,OAAO,WAAA;AAAA,IACH,qBAAA;AAAA,IACA,MAAM,YAAA,CAAa,KAAA,CAAM,SAAS,CAAA;AAAA,IAClC,CAAA;AAAA,IACA,MAAM,eAAA,CAAgB,KAAA,CAAM,UAAU,CAAA;AAAA,IACtC,MAAM,YAAA,CAAa,KAAA,CAAM,WAAW,CAAA;AAAA,IACpC,MAAM,gBAAA,CAAiB,KAAA,CAAM,UAAW,CAAA;AAAA,IACxC,MAAM,cAAA,CAAe,KAAA,CAAM,WAAA,EAAa,YAAY,CAAA;AAAA,IACpD,MAAM,cAAA,CAAe,KAAA,CAAM,YAAA,EAAc,YAAY,CAAA;AAAA,IACrD,MAAM,mBAAA;AAAA,MACF,KAAA;AAAA,MACA,aAAA;AAAA,MACA,KAAA,CAAM,WAAA;AAAA,MACN;AAAA,KACJ;AAAA,IACA,MAAM,cAAA,CAAe,KAAA,CAAM,aAAA,EAAe,YAAY;AAAA,GAC1D;AACJ;AAEA,eAAe,kBAAA,CACX,QAAA,EACA,SAAA,EACA,SAAA,EACmB;AACnB,EAAA,OAAO,WAAA;AAAA,IACH,qBAAA;AAAA,IACA,CAAA;AAAA,IACA,MAAM,cAAA;AAAA,MACF,QAAA,CAAS,QAAA;AAAA,MACT,YAAA,CAAa,WAAW,SAAS;AAAA;AACrC,GACJ;AACJ;AAEA,eAAe,oBAAoB,QAAA,EAAkC;AACjE,EAAA,IAAI,QAAA,CAAS,SAAS,SAAA,KAAc,IAAA;AAChC,IAAA,OAAO,WAAA;AAAA,MACH,MAAM,WAAA,CAAY,QAAA,CAAS,SAAS,CAAA;AAAA,MACpC,MAAM,MAAA;AAAA,QACF,MAAM,gBAAA;AAAA,UACF,SAAS,QAAA,CAAS,EAAA;AAAA,UAClB,gBAAA;AAAA,UACA;AAAC;AACL;AACJ,KACJ;AAAA,OACC,MAAM,IAAI,KAAA,CAAM,8BAA8B,CAAA;AACvD;AAEA,eAAe,YAAY,KAAA,EAAmC;AAC1D,EAAA,IAAI,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,MAAA,EAAQ;AAChC,IAAA,OAAO,UAAA,CAAW,IAAA,CAAK,CAAC,CAAC,CAAC,CAAA;AAAA,EAC9B,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,MAAA,EAAQ;AACvC,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,CAAI,CAAC,CAAA;AAAA,MACtB,MAAM,UAAA,CAAW,KAAA,CAAM,GAAA,CAAI,IAAI;AAAA,KACnC;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,OAAA,EAAS;AACxC,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,CAAI,CAAC,CAAA;AAAA,MACtB,MAAM,WAAA,CAAY,QAAA,CAAS,KAAA,CAAM,GAAA,CAAI,KAAK,CAAC;AAAA,KAC/C;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,SAAA,EAAW;AAC1C,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,CAAI,CAAC,CAAA;AAAA,MACtB,MAAM,YAAA,CAAa,KAAA,CAAM,GAAA,CAAI,OAAO;AAAA,KACxC;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,WAAA,EAAa;AAC5C,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,CAAI,CAAC,CAAA;AAAA,MACtB,MAAM,WAAA,CAAY,MAAA,CAAO,KAAA,CAAM,GAAA,CAAI,SAAS,CAAC;AAAA,KACjD;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,MAAA,EAAQ;AACvC,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,CAAI,CAAC,CAAA;AAAA,MACtB,MAAM,WAAA,CAAY,KAAA,CAAM,GAAA,CAAI,IAAI;AAAA,KACpC;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,OAAA,EAAS;AACxC,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,CAAI,CAAC,CAAA;AAAA,MACtB,MAAM,YAAA,CAAa,KAAA,CAAM,GAAA,CAAI,KAAK;AAAA,KACtC;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,MAAA,EAAQ;AACvC,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,CAAI,CAAC,CAAA;AAAA,MACtB,MAAM,YAAA,CAAa,KAAA,CAAM,GAAA,CAAI,IAAI;AAAA,KACrC;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,YAAA,EAAc;AAC7C,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,CAAI,CAAC,CAAA;AAAA,MACtB,MAAM,eAAA,CAAgB,KAAA,CAAM,GAAA,CAAI,UAAU;AAAA,KAC9C;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,UAAA,EAAY;AAC3C,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,CAAI,CAAC,CAAA;AAAA,MACtB,MAAM,mBAAA;AAAA,QACF,MAAM,GAAA,CAAI,QAAA;AAAA,QACV,OAAA;AAAA,QACA,KAAA,CAAM,IAAI,QAAA,CAAS,KAAA;AAAA,QACnB;AAAA;AACJ,KACJ;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,MAAA,EAAQ;AACvC,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,EAAI,CAAC,CAAA;AAAA,MACtB,MAAM,cAAA,CAAe,KAAA,CAAM,GAAA,CAAI,IAAA,CAAK,UAAU,WAAW;AAAA,KAC7D;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,SAAA,EAAW;AAC1C,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,EAAI,CAAC,CAAA;AAAA,MACtB,MAAM,cAAA,CAAe,KAAA,CAAM,GAAA,CAAI,OAAA,EAAS,SAAS,kBAAkB;AAAA,KACvE;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,QAAA,EAAU;AACzC,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,EAAI,CAAC,CAAA;AAAA,MACtB,MAAM,mBAAA;AAAA,QACF,MAAM,GAAA,CAAI,MAAA;AAAA,QACV,UAAA;AAAA,QACA,KAAA,CAAM,IAAI,MAAA,CAAO,QAAA;AAAA,QACjB;AAAA,OACJ;AAAA,MACA,MAAM,cAAA,CAAe,KAAA,CAAM,GAAA,CAAI,MAAA,CAAO,QAAQ,iBAAiB;AAAA,KACnE;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,SAAA,EAAW;AAC1C,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,EAAI,CAAC,CAAA;AAAA,MACtB,MAAM,mBAAA;AAAA,QACF,MAAM,GAAA,CAAI,OAAA;AAAA,QACV,WAAA;AAAA,QACA,KAAA,CAAM,IAAI,OAAA,CAAQ,SAAA;AAAA,QAClB;AAAA,OACJ;AAAA,MACA,MAAM,YAAA,CAAa,KAAA,CAAM,GAAA,CAAI,QAAQ,WAAW,CAAA;AAAA,MAChD,MAAM,WAAA,CAAY,KAAA,CAAM,GAAA,CAAI,QAAQ,KAAM;AAAA,KAC9C;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,MAAA,EAAQ;AACvC,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,EAAI,CAAC,CAAA;AAAA,MACtB,MAAM,mBAAA;AAAA,QACF,MAAM,GAAA,CAAI,IAAA;AAAA,QACV,QAAA;AAAA,QACA,KAAA,CAAM,IAAI,IAAA,CAAK,MAAA;AAAA,QACf;AAAA,OACJ;AAAA,MACA,MAAM,YAAA,CAAa,KAAA,CAAM,GAAA,CAAI,KAAK,WAAW;AAAA,KACjD;AAAA,EACJ,CAAA,MAAA,IAAW,KAAA,CAAM,GAAA,CAAI,SAAA,KAAc,QAAA,EAAU;AACzC,IAAA,OAAO,WAAA;AAAA,MACH,UAAA,CAAW,IAAA,CAAK,CAAC,EAAI,CAAC,CAAA;AAAA,MACtB,MAAM,cAAA,CAAe,KAAA,CAAM,GAAA,CAAI,MAAA,EAAQ,SAAS,iBAAiB;AAAA,KACrE;AAAA,EACJ;AAEA,EAAA,MAAM,IAAI,KAAA,CAAM,0BAAA,GAA6B,IAAA,CAAK,SAAA,CAAU,KAAK,CAAC,CAAA;AACtE;AAEA,eAAe,mBAAmB,KAAA,EAA2C;AACzE,EAAA,OAAO,WAAA;AAAA,IACH,MAAM,YAAA,CAAa,KAAA,CAAM,GAAG,CAAA;AAAA,IAC5B,MAAM,WAAA,CAAY,KAAA,CAAM,KAAM;AAAA,GAClC;AACJ;AAEA,eAAe,kBAAkB,KAAA,EAAyC;AACtE,EAAA,OAAO,WAAA;AAAA,IACH,MAAM,cAAA,CAAe,KAAA,CAAM,KAAA,EAAO,YAAY,CAAA;AAAA,IAC9C,MAAM,WAAA,CAAY,KAAA,CAAM,KAAM;AAAA,GAClC;AACJ;AAEA,eAAe,kBAAkB,KAAA,EAA0C;AACvE,EAAA,OAAO,WAAA;AAAA,IACH,MAAM,WAAA,CAAY,KAAA,CAAM,GAAI,CAAA;AAAA,IAC5B,MAAM,WAAA,CAAY,KAAA,CAAM,KAAM;AAAA,GAClC;AACJ;AAEA,SAAS,YAAA,CACL,WACA,SAAA,EACuC;AACvC,EAAA,OAAO,OAAO,MAAA,KAAwC;AAClD,IAAA,MAAM,IAAA,GAAO,UAAU,MAAM,CAAA;AAC7B,IAAA,IAAI,CAAC,IAAA,EAAM;AACP,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,aAAA,EAAgB,MAAM,CAAA,yBAAA,CAA2B,CAAA;AAAA,IACrE;AAEA,IAAA,MAAM,WAAA,GAAc,MAAM,UAAA,CAAW,IAAA,EAAM,WAAW,SAAS,CAAA;AAC/D,IAAA,OAAO,OAAO,WAAW,CAAA;AAAA,EAC7B,CAAA;AACJ;AAEA,eAAe,UAAA,CACX,IAAA,EACA,SAAA,EACA,SAAA,EACmB;AACnB,EAAA,IAAI,IAAA,CAAK,aAAA,CAAc,SAAA,KAAc,IAAA,EAAM;AACvC,IAAA,IAAI,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,QAAA,CAAS,cAAc,QAAA,EAAU;AACvD,MAAA,OAAO,gBAAA;AAAA,QACH,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,QAAA,CAAS,MAAA;AAAA,QAC/B,IAAA,CAAK,MAAA;AAAA,QACL;AAAA,OACJ;AAAA,IACJ,WAAW,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,QAAA,CAAS,cAAc,UAAA,EAAY;AAChE,MAAA,OAAO,kBAAA;AAAA,QACH,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,QAAA,CAAS,QAAA;AAAA,QAC/B,IAAA,CAAK,MAAA;AAAA,QACL,SAAA;AAAA,QACA;AAAA,OACJ;AAAA,IACJ,WAAW,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,QAAA,CAAS,cAAc,OAAA,EAAS;AAC7D,MAAA,OAAO,eAAA,CAAgB,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,SAAS,KAAK,CAAA;AAAA,IAC/D,WAAW,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,QAAA,CAAS,cAAc,UAAA,EAAY;AAChE,MAAA,OAAO,kBAAA;AAAA,QACH,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,QAAA,CAAS,QAAA;AAAA,QAC/B,SAAA;AAAA,QACA;AAAA,OACJ;AAAA,IACJ;AAEA,IAAA,MAAM,IAAI,MAAM,uBAAuB,CAAA;AAAA,EAC3C,CAAA,MAAO;AACH,IAAA,MAAM,IAAI,MAAM,CAAA,wBAAA,CAA0B,CAAA;AAAA,EAC9C;AACJ;AAEA,SAAS,gBACL,mBAAA,EACoC;AACpC,EAAA,MAAM,YAAkD,EAAC;AACzD,EAAA,MAAM,KAAA,GAAQ,mBAAA,CAAoB,WAAA,EAAa,KAAA,IAAS,EAAC;AACzD,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACtB,IAAA,SAAA,CAAU,IAAA,CAAK,MAAM,CAAA,GAAI,IAAA;AAAA,EAC7B;AACA,EAAA,OAAO,SAAA;AACX;AAEA,eAAe,iBAAA,CACX,WAAA,EACA,SAAA,EACA,SAAA,EACmB;AACnB,EAAA,OAAO,WAAA;AAAA,IACH,MAAM,YAAA,CAAa,WAAA,CAAY,OAAO,CAAA;AAAA,IACtC,MAAM,cAAA;AAAA,MACF,WAAA,CAAY,KAAA;AAAA,MACZ,YAAA,CAAa,WAAW,SAAS;AAAA;AACrC,GACJ;AACJ;AAEA,eAAe,eAAA,CACX,aACA,SAAA,EACmB;AACnB,EAAA,MAAM,qBAAqB,MAAM,iBAAA;AAAA,IAC7B,WAAA;AAAA,IACA,SAAA;AAAA,IACA,WAAA,CAAY;AAAA,GAChB;AAEA,EAAA,MAAM,OAAO,MAAM,MAAA;AAAA,IACf,MAAM,WAAA,CAAY,iCAAA,EAAmC,kBAAkB;AAAA,GAC3E;AAEA,EAAA,OAAO,IAAA;AACX;AAEA,eAAe,aAAa,QAAA,EAAyC;AACjE,EAAA,MAAM,OAAO,MAAM,MAAA;AAAA,IACf,MAAM,WAAA;AAAA,MACF,iCAAA;AAAA,MACA,MAAM,eAAe,QAAQ;AAAA;AACjC,GACJ;AAEA,EAAA,OAAO,IAAA;AACX;AAEA,eAAe,0BACX,mBAAA,EACmB;AACnB,EAAA,MAAM,SAAA,GAAY,gBAAgB,mBAAmB,CAAA;AAErD,EAAA,MAAM,kBAAkB,MAAM,eAAA;AAAA,IAC1B,mBAAA,CAAoB,WAAA;AAAA,IACpB;AAAA,GACJ;AACA,EAAA,MAAM,YAAA,GAAe,MAAM,YAAA,CAAa,mBAAA,CAAoB,QAAS,CAAA;AAErE,EAAA,OAAO,WAAA;AAAA,IACH,iCAAA;AAAA,IACA,sBAAA;AAAA,IACA,eAAA;AAAA,IACA;AAAA,GACJ;AACJ;AAEA,eAAsB,2BAClB,mBAAA,EACmB;AACnB,EAAA,OAAO,MAAA,CAAO,MAAM,yBAAA,CAA0B,mBAAmB,CAAC,CAAA;AACtE;AAEA,eAAsB,uBAAA,CAClB,SACA,KAAA,EACF;AACE,EAAA,MAAM,cAAA,GAAiB,MAAM,WAAA,CAAY,OAAO,CAAA;AAEhD,EAAA,MAAM,SAAA,GAAY,MAAM,WAAA,CAAY,cAAA,EAAgB,KAAK,CAAA;AACzD,EAAA,MAAM,SAAA,GAAY,MAAM,MAAA,CAAO,SAAS,CAAA;AACxC,EAAA,MAAM,cAAc,IAAI,UAAA,CAAW,CAAC,EAAA,EAAM,EAAI,CAAC,CAAA;AAC/C,EAAA,OAAO,WAAA,CAAY,aAAa,SAAS,CAAA;AAC7C;AAEA,eAAsB,4BAA4B,MAAA,EAAsB;AACpE,EAAA,MAAM,YAAA,GAAe,MAAA,CAChB,KAAA,EAAM,CACN,KAAK,CAAC,CAAA,EAAG,CAAA,KAAM,KAAA,CAAM,CAAC,CAAA,CAAE,aAAA,CAAc,KAAA,CAAM,CAAC,CAAC,CAAC,CAAA;AAEpD,EAAA,MAAM,cAAA,GAAiB,MAAM,WAAA,CAAY,YAAA,CAAa,MAAM,CAAA;AAE5D,EAAA,MAAM,kBAAA,GAAqB,CAAC,cAAc,CAAA;AAE1C,EAAA,KAAA,MAAW,KAAK,YAAA,EAAc;AAC1B,IAAA,MAAM,WAAA,GAAc,MAAM,WAAA,CAAY,CAAA,CAAE,MAAM,CAAA;AAC9C,IAAA,kBAAA,CAAmB,IAAA,CAAK,aAAa,CAAC,CAAA;AAAA,EAC1C;AAEA,EAAA,OAAO,WAAA,CAAY,GAAG,kBAAkB,CAAA;AAC5C;;;ACrhBO,IAAM,yBAAA,GAA4B,CACrC,mBAAA,KACsB;AACtB,EAAA,MAAM,KAAA,GAAQ,WAAW,mBAAmB,CAAA;AAC5C,EAAA,OAAOC,mCAAAA,CAAoB,WAAW,KAAK,CAAA;AAC/C;AAEO,IAAM,yBAAA,GAA4B,CACrC,UAAA,KACsB;AACtB,EAAA,MAAM,KAAA,GAAQ,WAAW,UAAU,CAAA;AACnC,EAAA,OAAOC,mCAAA,CAAoB,WAAW,KAAK,CAAA;AAC/C;AASO,IAAM,uBAAA,GAA0B,OACnC,mBAAA,EACA,MAAA,GAA2B,QAAA,KACT;AAClB,EAAA,IAAI,UAAA;AAEJ,EAAA,IAAI,OAAO,wBAAwB,QAAA,EAAU;AACzC,IAAA,UAAA,GAAa,0BAA0B,mBAAmB,CAAA;AAAA,EAC9D,CAAA,MAAO;AACH,IAAA,UAAA,GAAa,mBAAA;AAAA,EACjB;AAEA,EAAA,MAAM,IAAA,GAAO,MAAM,0BAAA,CAA2B,UAAU,CAAA;AAExD,EAAA,QAAQ,MAAA;AAAQ,IACZ,KAAK,QAAA;AACD,MAAA,OAAO,SAAS,IAAI,CAAA;AAAA,IACxB,KAAK,KAAA;AACD,MAAA,OAAO,MAAM,IAAI,CAAA;AAAA;AAE7B;AAUO,IAAM,0BAAA,GAA6B,CACtC,mBAAA,EACA,kBAAA,KACmB;AACnB,EAAA,IAAI,UAAA;AAEJ,EAAA,IAAI,OAAO,wBAAwB,QAAA,EAAU;AACzC,IAAA,UAAA,GAAa,0BAA0B,mBAAmB,CAAA;AAAA,EAC9D,CAAA,MAAO;AACH,IAAA,UAAA,GAAa,mBAAA;AAAA,EACjB;AAEA,EAAA,MAAM,UAA4B,EAAC;AACnC,EAAA,UAAA,CAAW,QAAA,EAAU,aAAA,EAAe,KAAA,CAAM,OAAA,CAAQ,CAAC,KAAA,KAAU;AACzD,IAAA,OAAA,CAAQ,KAAK,CAAA,GAAI;AAAA,MACb,YAAA,EAAc,kBAAA,CAAmB,QAAA,CAAS,KAAK,CAAA;AAAA,MAC/C,SAAA,EAAW;AAAA,QACP,GAAG,OAAA,CAAQ,KAAK,CAAA,CAAE,SAAA;AAAA,QAClB;AAAA;AACJ,KACJ;AAAA,EACJ,CAAC,CAAA;AAGD,EAAA,UAAA,CAAW,WAAA,EAAa,KAAA,CAAM,OAAA,CAAQ,CAAC,IAAA,KAAS;AAC5C,IAAA,IAAI,IAAA,CAAK,aAAA,CAAc,SAAA,KAAc,IAAA,EAAM;AACvC,MAAA,IAAI,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,QAAA,CAAS,cAAc,QAAA,EAAU;AACvD,QAAA,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,QAAA,CAAS,MAAA,CAAO,WAAA,CAAY,OAAA;AAAA,UAC9C,CAAC,KAAA,KAAU;AACP,YAAA,OAAA,CAAQ,KAAK,CAAA,GAAI;AAAA,cACb,YAAA,EAAc,kBAAA,CAAmB,QAAA,CAAS,KAAK,CAAA;AAAA,cAC/C,SAAA,EAAW;AAAA,gBACP,GAAG,OAAA,CAAQ,KAAK,CAAA,CAAE,SAAA;AAAA,gBAClB,CAAA,kBAAA,EAAqB,KAAK,MAAM,CAAA,mBAAA;AAAA;AACpC,aACJ;AAAA,UACJ;AAAA,SACJ;AAEA,QAAA,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,QAAA,CAAS,MAAA,CAAO,YAAA,CAAa,OAAA;AAAA,UAC/C,CAAC,KAAA,KAAU;AACP,YAAA,OAAA,CAAQ,KAAK,CAAA,GAAI;AAAA,cACb,YAAA,EAAc,kBAAA,CAAmB,QAAA,CAAS,KAAK,CAAA;AAAA,cAC/C,SAAA,EAAW;AAAA,gBACP,GAAG,OAAA,CAAQ,KAAK,CAAA,CAAE,SAAA;AAAA,gBAClB,CAAA,kBAAA,EAAqB,KAAK,MAAM,CAAA,oBAAA;AAAA;AACpC,aACJ;AAAA,UACJ;AAAA,SACJ;AAAA,MACJ;AAEA,MAAA,IAAI,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,QAAA,CAAS,cAAc,UAAA,EAAY;AACzD,QAAA,MAAM,IAAI,MAAM,aAAa,CAAA;AAAA,MACjC;AAEA,MAAA,IAAI,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,QAAA,CAAS,cAAc,OAAA,EAAS;AACtD,QAAA,MAAM,IAAI,MAAM,aAAa,CAAA;AAAA,MACjC;AAEA,MAAA,IAAI,IAAA,CAAK,aAAA,CAAc,EAAA,CAAG,QAAA,CAAS,cAAc,UAAA,EAAY;AAE7D,IACJ;AAAA,EACJ,CAAC,CAAA;AAED,EAAA,OAAO,OAAA;AACX","file":"index.cjs","sourcesContent":["// Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.\n// SPDX-License-Identifier: Apache-2.0\n\n/** Take a base64 encoded string and return a Uint8Array of the decoded bytes */\nexport function fromBase64(b64: string): Uint8Array {\n    const binaryString = atob(b64)\n    const len = binaryString.length\n    const bytes = new Uint8Array(len)\n    for (let i = 0; i < len; i++) {\n        bytes[i] = binaryString.charCodeAt(i)\n    }\n    return bytes\n}\n\n/** Take a byte buffer (Uint8Array) and encode it into a base64 string */\nexport function toBase64(data: Uint8Array): string {\n    let binaryString = ''\n    const len = data.byteLength\n    for (let i = 0; i < len; i++) {\n        binaryString += String.fromCharCode(data[i])\n    }\n    return btoa(binaryString)\n}\n\n/** Take a byte buffer (Uint8Array) and encode it into a hex string */\nexport function toHex(bytes: Uint8Array): string {\n    return Array.from(bytes)\n        .map((byte) => byte.toString(16).padStart(2, '0'))\n        .join('')\n}\n\nexport function fromHex(hex: string): Uint8Array {\n    if (hex.length % 2 !== 0) {\n        throw new Error('Invalid hex string length')\n    }\n\n    const bytes = new Uint8Array(hex.length / 2)\n    for (let i = 0; i < hex.length; i += 2) {\n        bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16)\n    }\n    return bytes\n}\n\nexport async function sha256(\n    message: string | Uint8Array\n): Promise<Uint8Array> {\n    const msg =\n        typeof message === 'string'\n            ? new TextEncoder().encode(message)\n            : message\n\n    return crypto.subtle\n        .digest('SHA-256', new Uint8Array(msg))\n        .then((hash) => new Uint8Array(hash))\n}\n\n/** Utility to concatenate byte arrays or single bytes */\nexport async function mkByteArray(\n    ...args: (number | Uint8Array)[]\n): Promise<Uint8Array> {\n    const normalizedArgs: Uint8Array[] = args.map((arg) => {\n        if (typeof arg === 'number') {\n            return new Uint8Array([arg])\n        } else {\n            return arg\n        }\n    })\n\n    let totalLength = 0\n    normalizedArgs.forEach((arg) => {\n        totalLength += arg.length\n    })\n\n    const mergedArray = new Uint8Array(totalLength)\n    let offset = 0\n\n    normalizedArgs.forEach((arg) => {\n        mergedArray.set(arg, offset)\n        offset += arg.length\n    })\n\n    return mergedArray\n}\n","// Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n    DamlTransaction,\n    DamlTransaction_Node,\n    DamlTransaction_NodeSeed,\n    HashingSchemeVersion,\n    Metadata,\n    Metadata_InputContract,\n    PreparedTransaction,\n} from '@canton-network/core-ledger-proto'\nimport {\n    Create,\n    Exercise,\n    Fetch,\n    Rollback,\n} from '@canton-network/core-ledger-proto'\nimport {\n    GenMap_Entry,\n    Identifier,\n    RecordField,\n    TextMap_Entry,\n    Value,\n} from '@canton-network/core-ledger-proto'\nimport { mkByteArray, sha256, toHex } from './utils.js'\n\n// Hash purpose reserved for prepared transaction\nconst PREPARED_TRANSACTION_HASH_PURPOSE = Uint8Array.from([\n    0x00, 0x00, 0x00, 0x30,\n])\n\nconst NODE_ENCODING_VERSION = Uint8Array.from([0x01])\n\nconst HASHING_SCHEME_VERSION = Uint8Array.from([HashingSchemeVersion.V2])\n\nasync function encodeBool(value: boolean): Promise<Uint8Array> {\n    return new Uint8Array([value ? 1 : 0])\n}\n\nasync function encodeInt32(value: number): Promise<Uint8Array> {\n    const buffer = new ArrayBuffer(4)\n    const view = new DataView(buffer)\n    view.setInt32(0, value, false) // true for little-endian\n    return new Uint8Array(buffer)\n}\n\nasync function encodeInt64(\n    value: bigint | number | undefined\n): Promise<Uint8Array> {\n    const num = typeof value === 'bigint' ? value : BigInt(value || 0)\n    const buffer = new ArrayBuffer(8)\n    const view = new DataView(buffer)\n    view.setBigInt64(0, num, false) // true for little-endian\n    return new Uint8Array(buffer)\n}\n\nexport async function encodeString(value: string = ''): Promise<Uint8Array> {\n    const utf8Bytes = new TextEncoder().encode(value)\n    return encodeBytes(utf8Bytes)\n}\n\nasync function encodeBytes(value: Uint8Array): Promise<Uint8Array> {\n    const length = await encodeInt32(value.length)\n    return mkByteArray(length, value)\n}\n\nasync function encodeHash(value: Uint8Array): Promise<Uint8Array> {\n    return value\n}\n\nfunction encodeHexString(value: string = ''): Promise<Uint8Array> {\n    // Convert hex string to Uint8Array\n    const bytes = new Uint8Array(value.length / 2)\n    for (let i = 0; i < value.length; i += 2) {\n        bytes[i / 2] = parseInt(value.slice(i, i + 2), 16)\n    }\n    return encodeBytes(bytes)\n}\n\n// Maybe suspicious?\nasync function encodeOptional<T>(\n    value: T | undefined | null,\n    encodeFn: (arg: T) => Promise<Uint8Array>\n): Promise<Uint8Array> {\n    if (value === undefined || value === null) {\n        return new Uint8Array([0]) // Return empty array for undefined fields\n    } else {\n        return mkByteArray(1, await encodeFn(value))\n    }\n}\n\n// Maybe suspicious?\nasync function encodeProtoOptional<T, P extends object>(\n    parentValue: P,\n    fieldName: keyof P,\n    value: T,\n    encodeFn: (value: T) => Promise<Uint8Array>\n): Promise<Uint8Array> {\n    if (parentValue && parentValue[fieldName] !== undefined) {\n        return mkByteArray(1, await encodeFn(value))\n    } else {\n        return new Uint8Array([0]) // Return empty array for undefined fields\n    }\n}\n\nasync function encodeRepeated<T>(\n    values: T[] = [],\n    encodeFn: (value: T) => Promise<Uint8Array>\n): Promise<Uint8Array> {\n    const length = await encodeInt32(values.length)\n    const encodedValues = await Promise.all(values.map(encodeFn))\n    return mkByteArray(length, ...encodedValues)\n}\n\nfunction findSeed(\n    nodeId: string,\n    nodeSeeds: DamlTransaction_NodeSeed[]\n): Uint8Array | undefined {\n    const seed = nodeSeeds.find(\n        (seed) => seed.nodeId.toString() === nodeId\n    )?.seed\n\n    return seed\n}\n\nasync function encodeIdentifier(identifier: Identifier): Promise<Uint8Array> {\n    return mkByteArray(\n        await encodeString(identifier.packageId),\n        await encodeRepeated(identifier.moduleName.split('.'), encodeString),\n        await encodeRepeated(identifier.entityName.split('.'), encodeString)\n    )\n}\n\nasync function encodeMetadata(metadata: Metadata): Promise<Uint8Array> {\n    return mkByteArray(\n        Uint8Array.from([0x01]),\n        await encodeRepeated(metadata.submitterInfo?.actAs, encodeString),\n        await encodeString(metadata.submitterInfo?.commandId),\n        await encodeString(metadata.transactionUuid),\n        await encodeInt32(metadata.mediatorGroup),\n        await encodeString(metadata.synchronizerId),\n        await encodeProtoOptional(\n            metadata,\n            'minLedgerEffectiveTime',\n            metadata.minLedgerEffectiveTime,\n            encodeInt64\n        ),\n        await encodeProtoOptional(\n            metadata,\n            'maxLedgerEffectiveTime',\n            metadata.maxLedgerEffectiveTime,\n            encodeInt64\n        ),\n        await encodeInt64(metadata.preparationTime),\n        await encodeRepeated(metadata.inputContracts, encodeInputContract)\n    )\n}\n\nasync function encodeCreateNode(\n    create: Create | undefined,\n    nodeId: string,\n    nodeSeeds: DamlTransaction_NodeSeed[]\n): Promise<Uint8Array> {\n    return create\n        ? mkByteArray(\n              NODE_ENCODING_VERSION,\n              await encodeString(create.lfVersion),\n              0 /** Create node tag */,\n              await encodeOptional(findSeed(nodeId, nodeSeeds), encodeHash),\n              await encodeHexString(create.contractId),\n              await encodeString(create.packageName),\n              await encodeIdentifier(create.templateId!),\n              await encodeValue(create.argument!),\n              await encodeRepeated(create.signatories, encodeString),\n              await encodeRepeated(create.stakeholders, encodeString)\n          )\n        : mkByteArray()\n}\n\nasync function encodeExerciseNode(\n    exercise: Exercise,\n    nodeId: string,\n    nodesDict: Record<string, DamlTransaction_Node>,\n    nodeSeeds: DamlTransaction_NodeSeed[]\n): Promise<Uint8Array> {\n    return mkByteArray(\n        NODE_ENCODING_VERSION,\n        await encodeString(exercise.lfVersion),\n        1 /** Exercise node tag */,\n        await encodeHash(findSeed(nodeId, nodeSeeds)!),\n        await encodeHexString(exercise.contractId),\n        await encodeString(exercise.packageName),\n        await encodeIdentifier(exercise.templateId!),\n        await encodeRepeated(exercise.signatories, encodeString),\n        await encodeRepeated(exercise.stakeholders, encodeString),\n        await encodeRepeated(exercise.actingParties, encodeString),\n        await encodeProtoOptional(\n            exercise,\n            'interfaceId',\n            exercise.interfaceId!,\n            encodeIdentifier\n        ),\n        await encodeString(exercise.choiceId),\n        await encodeValue(exercise.chosenValue!),\n        await encodeBool(exercise.consuming),\n        await encodeProtoOptional(\n            exercise,\n            'exerciseResult',\n            exercise.exerciseResult!,\n            encodeValue\n        ),\n        await encodeRepeated(exercise.choiceObservers, encodeString),\n        await encodeRepeated(\n            exercise.children,\n            encodeNodeId(nodesDict, nodeSeeds)\n        )\n    )\n}\n\nasync function encodeFetchNode(fetch: Fetch): Promise<Uint8Array> {\n    return mkByteArray(\n        NODE_ENCODING_VERSION,\n        await encodeString(fetch.lfVersion),\n        2 /** Fetch node tag */,\n        await encodeHexString(fetch.contractId),\n        await encodeString(fetch.packageName),\n        await encodeIdentifier(fetch.templateId!),\n        await encodeRepeated(fetch.signatories, encodeString),\n        await encodeRepeated(fetch.stakeholders, encodeString),\n        await encodeProtoOptional(\n            fetch,\n            'interfaceId',\n            fetch.interfaceId!,\n            encodeIdentifier\n        ),\n        await encodeRepeated(fetch.actingParties, encodeString)\n    )\n}\n\nasync function encodeRollbackNode(\n    rollback: Rollback,\n    nodesDict: Record<string, DamlTransaction_Node>,\n    nodeSeeds: DamlTransaction_NodeSeed[]\n): Promise<Uint8Array> {\n    return mkByteArray(\n        NODE_ENCODING_VERSION,\n        3 /** Rollback node tag */,\n        await encodeRepeated(\n            rollback.children,\n            encodeNodeId(nodesDict, nodeSeeds)\n        )\n    )\n}\n\nasync function encodeInputContract(contract: Metadata_InputContract) {\n    if (contract.contract.oneofKind === 'v1')\n        return mkByteArray(\n            await encodeInt64(contract.createdAt),\n            await sha256(\n                await encodeCreateNode(\n                    contract.contract.v1,\n                    'unused_node_id',\n                    []\n                )\n            )\n        )\n    else throw new Error('Unsupported contract version')\n}\n\nasync function encodeValue(value: Value): Promise<Uint8Array> {\n    if (value.sum.oneofKind === 'unit') {\n        return Uint8Array.from([0]) // Unit value\n    } else if (value.sum.oneofKind === 'bool') {\n        return mkByteArray(\n            Uint8Array.from([0x01]),\n            await encodeBool(value.sum.bool)\n        )\n    } else if (value.sum.oneofKind === 'int64') {\n        return mkByteArray(\n            Uint8Array.from([0x02]),\n            await encodeInt64(parseInt(value.sum.int64))\n        )\n    } else if (value.sum.oneofKind === 'numeric') {\n        return mkByteArray(\n            Uint8Array.from([0x03]),\n            await encodeString(value.sum.numeric)\n        )\n    } else if (value.sum.oneofKind === 'timestamp') {\n        return mkByteArray(\n            Uint8Array.from([0x04]),\n            await encodeInt64(BigInt(value.sum.timestamp))\n        )\n    } else if (value.sum.oneofKind === 'date') {\n        return mkByteArray(\n            Uint8Array.from([0x05]),\n            await encodeInt32(value.sum.date)\n        )\n    } else if (value.sum.oneofKind === 'party') {\n        return mkByteArray(\n            Uint8Array.from([0x06]),\n            await encodeString(value.sum.party)\n        )\n    } else if (value.sum.oneofKind === 'text') {\n        return mkByteArray(\n            Uint8Array.from([0x07]),\n            await encodeString(value.sum.text)\n        )\n    } else if (value.sum.oneofKind === 'contractId') {\n        return mkByteArray(\n            Uint8Array.from([0x08]),\n            await encodeHexString(value.sum.contractId)\n        )\n    } else if (value.sum.oneofKind === 'optional') {\n        return mkByteArray(\n            Uint8Array.from([0x09]),\n            await encodeProtoOptional(\n                value.sum.optional,\n                'value',\n                value.sum.optional.value as Value,\n                encodeValue\n            )\n        )\n    } else if (value.sum.oneofKind === 'list') {\n        return mkByteArray(\n            Uint8Array.from([0x0a]),\n            await encodeRepeated(value.sum.list.elements, encodeValue)\n        )\n    } else if (value.sum.oneofKind === 'textMap') {\n        return mkByteArray(\n            Uint8Array.from([0x0b]),\n            await encodeRepeated(value.sum.textMap?.entries, encodeTextMapEntry)\n        )\n    } else if (value.sum.oneofKind === 'record') {\n        return mkByteArray(\n            Uint8Array.from([0x0c]),\n            await encodeProtoOptional(\n                value.sum.record,\n                'recordId',\n                value.sum.record.recordId!,\n                encodeIdentifier\n            ),\n            await encodeRepeated(value.sum.record.fields, encodeRecordField)\n        )\n    } else if (value.sum.oneofKind === 'variant') {\n        return mkByteArray(\n            Uint8Array.from([0x0d]),\n            await encodeProtoOptional(\n                value.sum.variant,\n                'variantId',\n                value.sum.variant.variantId!,\n                encodeIdentifier\n            ),\n            await encodeString(value.sum.variant.constructor),\n            await encodeValue(value.sum.variant.value!)\n        )\n    } else if (value.sum.oneofKind === 'enum') {\n        return mkByteArray(\n            Uint8Array.from([0x0e]),\n            await encodeProtoOptional(\n                value.sum.enum,\n                'enumId',\n                value.sum.enum.enumId!,\n                encodeIdentifier\n            ),\n            await encodeString(value.sum.enum.constructor)\n        )\n    } else if (value.sum.oneofKind === 'genMap') {\n        return mkByteArray(\n            Uint8Array.from([0x0f]),\n            await encodeRepeated(value.sum.genMap?.entries, encodeGenMapEntry)\n        )\n    }\n\n    throw new Error('Unsupported value type: ' + JSON.stringify(value))\n}\n\nasync function encodeTextMapEntry(entry: TextMap_Entry): Promise<Uint8Array> {\n    return mkByteArray(\n        await encodeString(entry.key),\n        await encodeValue(entry.value!)\n    )\n}\n\nasync function encodeRecordField(field: RecordField): Promise<Uint8Array> {\n    return mkByteArray(\n        await encodeOptional(field.label, encodeString),\n        await encodeValue(field.value!)\n    )\n}\n\nasync function encodeGenMapEntry(entry: GenMap_Entry): Promise<Uint8Array> {\n    return mkByteArray(\n        await encodeValue(entry.key!),\n        await encodeValue(entry.value!)\n    )\n}\n\nfunction encodeNodeId(\n    nodesDict: Record<string, DamlTransaction_Node>,\n    nodeSeeds: DamlTransaction_NodeSeed[]\n): (nodeId: string) => Promise<Uint8Array> {\n    return async (nodeId: string): Promise<Uint8Array> => {\n        const node = nodesDict[nodeId]\n        if (!node) {\n            throw new Error(`Node with ID ${nodeId} not found in transaction`)\n        }\n\n        const encodedNode = await encodeNode(node, nodesDict, nodeSeeds)\n        return sha256(encodedNode)\n    }\n}\n\nasync function encodeNode(\n    node: DamlTransaction_Node,\n    nodesDict: Record<string, DamlTransaction_Node>,\n    nodeSeeds: DamlTransaction_NodeSeed[]\n): Promise<Uint8Array> {\n    if (node.versionedNode.oneofKind === 'v1') {\n        if (node.versionedNode.v1.nodeType.oneofKind === 'create') {\n            return encodeCreateNode(\n                node.versionedNode.v1.nodeType.create,\n                node.nodeId,\n                nodeSeeds\n            )\n        } else if (node.versionedNode.v1.nodeType.oneofKind === 'exercise') {\n            return encodeExerciseNode(\n                node.versionedNode.v1.nodeType.exercise,\n                node.nodeId,\n                nodesDict,\n                nodeSeeds\n            )\n        } else if (node.versionedNode.v1.nodeType.oneofKind === 'fetch') {\n            return encodeFetchNode(node.versionedNode.v1.nodeType.fetch)\n        } else if (node.versionedNode.v1.nodeType.oneofKind === 'rollback') {\n            return encodeRollbackNode(\n                node.versionedNode.v1.nodeType.rollback,\n                nodesDict,\n                nodeSeeds\n            )\n        }\n\n        throw new Error('Unsupported node type')\n    } else {\n        throw new Error(`Unsupported node version`)\n    }\n}\n\nfunction createNodesDict(\n    preparedTransaction: PreparedTransaction\n): Record<string, DamlTransaction_Node> {\n    const nodesDict: Record<string, DamlTransaction_Node> = {}\n    const nodes = preparedTransaction.transaction?.nodes || []\n    for (const node of nodes) {\n        nodesDict[node.nodeId] = node\n    }\n    return nodesDict\n}\n\nasync function encodeTransaction(\n    transaction: DamlTransaction,\n    nodesDict: Record<string, DamlTransaction_Node>,\n    nodeSeeds: DamlTransaction_NodeSeed[]\n): Promise<Uint8Array> {\n    return mkByteArray(\n        await encodeString(transaction.version),\n        await encodeRepeated(\n            transaction.roots,\n            encodeNodeId(nodesDict, nodeSeeds)\n        )\n    )\n}\n\nasync function hashTransaction(\n    transaction: DamlTransaction,\n    nodesDict: Record<string, DamlTransaction_Node>\n): Promise<Uint8Array> {\n    const encodedTransaction = await encodeTransaction(\n        transaction,\n        nodesDict,\n        transaction.nodeSeeds\n    )\n\n    const hash = await sha256(\n        await mkByteArray(PREPARED_TRANSACTION_HASH_PURPOSE, encodedTransaction)\n    )\n\n    return hash\n}\n\nasync function hashMetadata(metadata: Metadata): Promise<Uint8Array> {\n    const hash = await sha256(\n        await mkByteArray(\n            PREPARED_TRANSACTION_HASH_PURPOSE,\n            await encodeMetadata(metadata)\n        )\n    )\n\n    return hash\n}\n\nasync function encodePreparedTransaction(\n    preparedTransaction: PreparedTransaction\n): Promise<Uint8Array> {\n    const nodesDict = createNodesDict(preparedTransaction)\n\n    const transactionHash = await hashTransaction(\n        preparedTransaction.transaction!,\n        nodesDict\n    )\n    const metadataHash = await hashMetadata(preparedTransaction.metadata!)\n\n    return mkByteArray(\n        PREPARED_TRANSACTION_HASH_PURPOSE,\n        HASHING_SCHEME_VERSION,\n        transactionHash,\n        metadataHash\n    )\n}\n\nexport async function computePreparedTransaction(\n    preparedTransaction: PreparedTransaction\n): Promise<Uint8Array> {\n    return sha256(await encodePreparedTransaction(preparedTransaction))\n}\n\nexport async function computeSha256CantonHash(\n    purpose: number,\n    bytes: Uint8Array\n) {\n    const encodedPurpose = await encodeInt32(purpose)\n\n    const hashInput = await mkByteArray(encodedPurpose, bytes)\n    const hashBytes = await sha256(hashInput)\n    const multiprefix = new Uint8Array([0x12, 0x20])\n    return mkByteArray(multiprefix, hashBytes)\n}\n\nexport async function computeMultiHashForTopology(hashes: Uint8Array[]) {\n    const sortedHashes = hashes\n        .slice()\n        .sort((a, b) => toHex(a).localeCompare(toHex(b)))\n\n    const numHashesBytes = await encodeInt32(sortedHashes.length)\n\n    const concatenatedHashes = [numHashesBytes]\n\n    for (const h of sortedHashes) {\n        const lengthBytes = await encodeInt32(h.length)\n        concatenatedHashes.push(lengthBytes, h)\n    }\n\n    return mkByteArray(...concatenatedHashes)\n}\n","// Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport {\n    PreparedTransaction,\n    TopologyTransaction,\n} from '@canton-network/core-ledger-proto'\nimport { computePreparedTransaction } from './hashing_scheme_v2.js'\nimport { fromBase64, toBase64, toHex } from './utils.js'\nexport {\n    computeSha256CantonHash,\n    computeMultiHashForTopology,\n} from './hashing_scheme_v2.js'\n\n/**\n * Decodes a base64 encoded prepared transaction into a well-typed data model, generated directly from Protobuf definitions.\n *\n * @param preparedTransaction - The prepared transaction in base64 format\n * @returns The decoded prepared transaction\n */\nexport const decodePreparedTransaction = (\n    preparedTransaction: string\n): PreparedTransaction => {\n    const bytes = fromBase64(preparedTransaction)\n    return PreparedTransaction.fromBinary(bytes)\n}\n\nexport const decodeTopologyTransaction = (\n    topologyTx: string\n): TopologyTransaction => {\n    const bytes = fromBase64(topologyTx)\n    return TopologyTransaction.fromBinary(bytes)\n}\n\n/**\n * Computes the hash of a prepared transaction.\n *\n * @param preparedTransaction - The prepared transaction to hash\n * @param format - The format of the output hash (base64 or hex)\n * @returns The computed hash in the specified format\n */\nexport const hashPreparedTransaction = async (\n    preparedTransaction: string | PreparedTransaction,\n    format: 'base64' | 'hex' = 'base64'\n): Promise<string> => {\n    let preparedTx: PreparedTransaction\n\n    if (typeof preparedTransaction === 'string') {\n        preparedTx = decodePreparedTransaction(preparedTransaction)\n    } else {\n        preparedTx = preparedTransaction\n    }\n\n    const hash = await computePreparedTransaction(preparedTx)\n\n    switch (format) {\n        case 'base64':\n            return toBase64(hash)\n        case 'hex':\n            return toHex(hash)\n    }\n}\n\ntype ValidationResult = Record<\n    string,\n    {\n        isAuthorized: boolean\n        locations: string[]\n    }\n>\n\nexport const validateAuthorizedPartyIds = (\n    preparedTransaction: string | PreparedTransaction,\n    authorizedPartyIds: string[]\n): ValidationResult => {\n    let preparedTx: PreparedTransaction\n\n    if (typeof preparedTransaction === 'string') {\n        preparedTx = decodePreparedTransaction(preparedTransaction)\n    } else {\n        preparedTx = preparedTransaction\n    }\n\n    const results: ValidationResult = {}\n    preparedTx.metadata?.submitterInfo?.actAs.forEach((party) => {\n        results[party] = {\n            isAuthorized: authorizedPartyIds.includes(party),\n            locations: [\n                ...results[party].locations,\n                'metadata.submitterInfo.actAs',\n            ],\n        }\n    })\n\n    // then check transaction nodes\n    preparedTx.transaction?.nodes.forEach((node) => {\n        if (node.versionedNode.oneofKind === 'v1') {\n            if (node.versionedNode.v1.nodeType.oneofKind === 'create') {\n                node.versionedNode.v1.nodeType.create.signatories.forEach(\n                    (party) => {\n                        results[party] = {\n                            isAuthorized: authorizedPartyIds.includes(party),\n                            locations: [\n                                ...results[party].locations,\n                                `transaction.nodes.${node.nodeId}.create.signatories`,\n                            ],\n                        }\n                    }\n                )\n\n                node.versionedNode.v1.nodeType.create.stakeholders.forEach(\n                    (party) => {\n                        results[party] = {\n                            isAuthorized: authorizedPartyIds.includes(party),\n                            locations: [\n                                ...results[party].locations,\n                                `transaction.nodes.${node.nodeId}.create.stakeholders`,\n                            ],\n                        }\n                    }\n                )\n            }\n\n            if (node.versionedNode.v1.nodeType.oneofKind === 'exercise') {\n                throw new Error('Unsupported')\n            }\n\n            if (node.versionedNode.v1.nodeType.oneofKind === 'fetch') {\n                throw new Error('Unsupported')\n            }\n\n            if (node.versionedNode.v1.nodeType.oneofKind === 'rollback') {\n                // do we need to check these nodes?\n            }\n        }\n    })\n\n    return results\n}\n"]}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { PreparedTransaction } from '@canton-network/core-ledger-proto';
+import { PreparedTransaction, TopologyTransaction } from '@canton-network/core-ledger-proto';
 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.
@@ -7,6 +7,7 @@ export { computeSha256CantonHash, computeMultiHashForTopology, } from './hashing
  * @returns The decoded prepared transaction
  */
 export declare const decodePreparedTransaction: (preparedTransaction: string) => PreparedTransaction;
+export declare const decodeTopologyTransaction: (topologyTx: string) => TopologyTransaction;
 /**
  * Computes the hash of a prepared transaction.
  *

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAA;AAGvE,OAAO,EACH,uBAAuB,EACvB,2BAA2B,GAC9B,MAAM,wBAAwB,CAAA;AAE/B;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,GAClC,qBAAqB,MAAM,KAC5B,mBAGF,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GAChC,qBAAqB,MAAM,GAAG,mBAAmB,EACjD,SAAQ,QAAQ,GAAG,KAAgB,KACpC,OAAO,CAAC,MAAM,CAiBhB,CAAA;AAED,KAAK,gBAAgB,GAAG,MAAM,CAC1B,MAAM,EACN;IACI,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,MAAM,EAAE,CAAA;CACtB,CACJ,CAAA;AAED,eAAO,MAAM,0BAA0B,GACnC,qBAAqB,MAAM,GAAG,mBAAmB,EACjD,oBAAoB,MAAM,EAAE,KAC7B,gBAgEF,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACH,mBAAmB,EACnB,mBAAmB,EACtB,MAAM,mCAAmC,CAAA;AAG1C,OAAO,EACH,uBAAuB,EACvB,2BAA2B,GAC9B,MAAM,wBAAwB,CAAA;AAE/B;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,GAClC,qBAAqB,MAAM,KAC5B,mBAGF,CAAA;AAED,eAAO,MAAM,yBAAyB,GAClC,YAAY,MAAM,KACnB,mBAGF,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,GAChC,qBAAqB,MAAM,GAAG,mBAAmB,EACjD,SAAQ,QAAQ,GAAG,KAAgB,KACpC,OAAO,CAAC,MAAM,CAiBhB,CAAA;AAED,KAAK,gBAAgB,GAAG,MAAM,CAC1B,MAAM,EACN;IACI,YAAY,EAAE,OAAO,CAAA;IACrB,SAAS,EAAE,MAAM,EAAE,CAAA;CACtB,CACJ,CAAA;AAED,eAAO,MAAM,0BAA0B,GACnC,qBAAqB,MAAM,GAAG,mBAAmB,EACjD,oBAAoB,MAAM,EAAE,KAC7B,gBAgEF,CAAA"}