@canton-network/core-tx-visualizer 0.3.2 → 0.5.0

package/dist/Tx.test.js

@@ -4,7 +4,7 @@ import { expect, test } from '@jest/globals';
 import { PreparedTransaction } from '@canton-network/core-ledger-proto';
 import * as path from 'path';
 import { readFileSync } from 'fs';
-import { decodePreparedTransaction } from '.';
+import { decodePreparedTransaction, hashPreparedTransaction } from '.';
 import camelcaseKeys from 'camelcase-keys';
 test('decode a base 64 encoded prepared tx', async () => {
     const base64EncodedPreparedTx = 'Cp8GCgMyLjESATAa8AUKATDCPukFCuYFCgMyLjESQjAwNTUwODAyZGRiMTYzNzFmNWZjNmQzNjRlNmNkNGIzMjgzYTllYjVjMGNjYjEyMWFlMzY4Y2RlYmJhZDBmYmY1NhoOQWRtaW5Xb3JrZmxvd3MiXgpAMmEzOGI5NjNmNmFiZjQ1Yjc2YzcwMmY5NzAwYmZkOTA2MDU1NTg3MmFmOTE1ZWY3ZjhmNjg3OTVlMmM4MzFiZBIUQ2FudG9uLkludGVybmFsLlBpbmcaBFBpbmcqtgJyswIKXgpAMmEzOGI5NjNmNmFiZjQ1Yjc2YzcwMmY5NzAwYmZkOTA2MDU1NTg3MmFmOTE1ZWY3ZjhmNjg3OTVlMmM4MzFiZBIUQ2FudG9uLkludGVybmFsLlBpbmcaBFBpbmcSDwoCaWQSCUIHcGluZ19pZBJdCglpbml0aWF0b3ISUDpOb3BlcmF0b3I6OjEyMjBkNDRmYzFjM2JhMGI1YmRmN2I5NTZlZTcxYmM5NGViZTJkMjMyNThkYzI2OGZkZjA4MjRmYmFlZmYyYzYxNDI0EmEKCXJlc3BvbmRlchJUOlJwYXJ0aWNpcGFudDE6OjEyMjBkNDRmYzFjM2JhMGI1YmRmN2I5NTZlZTcxYmM5NGViZTJkMjMyNThkYzI2OGZkZjA4MjRmYmFlZmYyYzYxNDI0Mk5vcGVyYXRvcjo6MTIyMGQ0NGZjMWMzYmEwYjViZGY3Yjk1NmVlNzFiYzk0ZWJlMmQyMzI1OGRjMjY4ZmRmMDgyNGZiYWVmZjJjNjE0MjQ6Tm9wZXJhdG9yOjoxMjIwZDQ0ZmMxYzNiYTBiNWJkZjdiOTU2ZWU3MWJjOTRlYmUyZDIzMjU4ZGMyNjhmZGYwODI0ZmJhZWZmMmM2MTQyNDpScGFydGljaXBhbnQxOjoxMjIwZDQ0ZmMxYzNiYTBiNWJkZjdiOTU2ZWU3MWJjOTRlYmUyZDIzMjU4ZGMyNjhmZGYwODI0ZmJhZWZmMmM2MTQyNCIiEiBr2qJTURRRnXWp6y1EyXQiB69cfe50kJw0eYN1UF39nhL1ARJ2Ck5vcGVyYXRvcjo6MTIyMGQ0NGZjMWMzYmEwYjViZGY3Yjk1NmVlNzFiYzk0ZWJlMmQyMzI1OGRjMjY4ZmRmMDgyNGZiYWVmZjJjNjE0MjQSJGYyZWM0ZDhmLWNjYzEtNDAyYi1iMjc4LTc1NTZmZGQyYjQxMhpMd2FsbGV0OjoxMjIwZTdiMjNlYTUyZWI1YzY3MmZiMGIxY2RiYzkxNjkyMmZmZWQzZGQ3Njc2YzIyM2E2MDU2NjQzMTVlMmQ0M2VkZCokYTMyODE2MmUtNzI4ZS00ZTA1LWFjNzgtYjM0ZjA3MDk4M2JhMK7Y9/LU944D';
@@ -16,3 +16,9 @@ test('decode a base 64 encoded prepared tx', async () => {
     const message = PreparedTransaction.fromJson(camelCasePreparedTx);
     expect(message === preparedTx);
 });
+test('hash from preparedTx ledger api call should match calculated hash', async () => {
+    const preparedTxFromLedgerAPi = 'f97Cv1BO7QS7jmSY03p56JGsPf60Vx/ABXmRub7iiQI=';
+    const preparedTx2 = 'CsoHCgMyLjESATAamwcKATDCPpQHCpEHCgMyLjESQjAwMTY4Nzc3ODEwNzU3MmJlZWVjYzQzODk3MmQxODQ4M2VhZDI1MGQxZDUwYmI2MzU3ZjdmYjhmNjdkY2U3ZDYzNRoNc3BsaWNlLXdhbGxldCKCAQpAZWI2ZTAxZWZhY2MzMzk3ZTIzYzZiZThiOWJlN2RiNGJmMzc2NzIyMTE5NzRkNjllMjRiNDg5ODBlMmY5OGI3ZRIhU3BsaWNlLldhbGxldC5UcmFuc2ZlclByZWFwcHJvdmFsGhtUcmFuc2ZlclByZWFwcHJvdmFsUHJvcG9zYWwqtQNysgMKggEKQGViNmUwMWVmYWNjMzM5N2UyM2M2YmU4YjliZTdkYjRiZjM3NjcyMjExOTc0ZDY5ZTI0YjQ4OTgwZTJmOThiN2USIVNwbGljZS5XYWxsZXQuVHJhbnNmZXJQcmVhcHByb3ZhbBobVHJhbnNmZXJQcmVhcHByb3ZhbFByb3Bvc2FsElcKCHJlY2VpdmVyEks6SWJvYjo6MTIyMDViZTNiOWQxNzc1NzNmZmZiNjhlYjI0NTk4NmY4OGI5ZGY1OGQ0NGNlNTc1ODE5MDc4OTcwNTgwZDg3ZDFkYzAScgoIcHJvdmlkZXISZjpkYXBwX3VzZXJfbG9jYWxuZXQtbG9jYWxwYXJ0eS0xOjoxMjIwM2E1MmZlNWFmM2I4N2UwNjk2MTgyYWM2NjhhNmNiMzE1ZGFiNGJkYzMwZGE5ZTViNmRkYTllYjcyODc4NDIxNhJeCgtleHBlY3RlZERzbxJPUk0KSzpJRFNPOjoxMjIwYmJkMDAwYjY5ODc1NzNiOGMwOWY0NDRlNGRmNTUwOWFmODk5N2I4MzkxMDlkN2UyYzIxMmQ1NDdmMGFmMDk1MDJJYm9iOjoxMjIwNWJlM2I5ZDE3NzU3M2ZmZmI2OGViMjQ1OTg2Zjg4YjlkZjU4ZDQ0Y2U1NzU4MTkwNzg5NzA1ODBkODdkMWRjMDpkYXBwX3VzZXJfbG9jYWxuZXQtbG9jYWxwYXJ0eS0xOjoxMjIwM2E1MmZlNWFmM2I4N2UwNjk2MTgyYWM2NjhhNmNiMzE1ZGFiNGJkYzMwZGE5ZTViNmRkYTllYjcyODc4NDIxNjpJYm9iOjoxMjIwNWJlM2I5ZDE3NzU3M2ZmZmI2OGViMjQ1OTg2Zjg4YjlkZjU4ZDQ0Y2U1NzU4MTkwNzg5NzA1ODBkODdkMWRjMCIiEiDBzeNcgqLvsssBxhNx7wP9pK71TsAprgz+a8jag/Lb3RL3ARJxCklib2I6OjEyMjA1YmUzYjlkMTc3NTczZmZmYjY4ZWIyNDU5ODZmODhiOWRmNThkNDRjZTU3NTgxOTA3ODk3MDU4MGQ4N2QxZGMwEiQ5NzU4ZTQ2ZS05ZmJlLTRmOTQtOTczZC04NWQ5ZTBmMTMyNzUaU2dsb2JhbC1kb21haW46OjEyMjBiYmQwMDBiNjk4NzU3M2I4YzA5ZjQ0NGU0ZGY1NTA5YWY4OTk3YjgzOTEwOWQ3ZTJjMjEyZDU0N2YwYWYwOTUwKiQ5NGJkYmFmNS0wYjJjLTQwYmMtOTZjZC1jM2M5YTlkODQ3ZDIw+eaGkdz0jwM=';
+    const hashResult = await hashPreparedTransaction(preparedTx2, 'base64');
+    expect(hashResult === preparedTxFromLedgerAPi);
+});

package/dist/hashing_scheme_v2.d.ts

@@ -1,4 +1,6 @@
 import { PreparedTransaction } from '@canton-network/core-ledger-proto';
 export declare function encodeString(value?: string): Promise<Uint8Array>;
 export declare function computePreparedTransaction(preparedTransaction: PreparedTransaction): Promise<Uint8Array>;
+export declare function computeSha256CantonHash(purpose: number, bytes: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
+export declare function computeMultiHashForTopology(hashes: Uint8Array[]): Promise<Uint8Array<ArrayBufferLike>>;
 //# sourceMappingURL=hashing_scheme_v2.d.ts.map

package/dist/hashing_scheme_v2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hashing_scheme_v2.d.ts","sourceRoot":"","sources":["../src/hashing_scheme_v2.ts"],"names":[],"mappings":"AAGA,OAAO,EAOH,mBAAmB,EACtB,MAAM,mCAAmC,CAAA;AA6C1C,wBAAsB,YAAY,CAAC,KAAK,GAAE,MAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAG1E;AAqbD,wBAAsB,0BAA0B,CAC5C,mBAAmB,EAAE,mBAAmB,GACzC,OAAO,CAAC,UAAU,CAAC,CAErB"}
+{"version":3,"file":"hashing_scheme_v2.d.ts","sourceRoot":"","sources":["../src/hashing_scheme_v2.ts"],"names":[],"mappings":"AAGA,OAAO,EAOH,mBAAmB,EACtB,MAAM,mCAAmC,CAAA;AA8C1C,wBAAsB,YAAY,CAAC,KAAK,GAAE,MAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAG1E;AA4cD,wBAAsB,0BAA0B,CAC5C,mBAAmB,EAAE,mBAAmB,GACzC,OAAO,CAAC,UAAU,CAAC,CAErB;AAED,wBAAsB,uBAAuB,CACzC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,UAAU,wCAQpB;AAED,wBAAsB,2BAA2B,CAAC,MAAM,EAAE,UAAU,EAAE,wCAerE"}

package/dist/hashing_scheme_v2.js

@@ -1,7 +1,7 @@
 // Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { HashingSchemeVersion, } from '@canton-network/core-ledger-proto';
-import { mkByteArray, sha256 } from './utils.js';
+import { mkByteArray, sha256, toHex } from './utils.js';
 // Hash purpose reserved for prepared transaction
 const PREPARED_TRANSACTION_HASH_PURPOSE = Uint8Array.from([
     0x00, 0x00, 0x00, 0x30,
@@ -68,16 +68,13 @@ async function encodeRepeated(values = [], encodeFn) {
 }
 function findSeed(nodeId, nodeSeeds) {
     const seed = nodeSeeds.find((seed) => seed.nodeId.toString() === nodeId)?.seed;
-    if (!seed) {
-        throw new Error(`Seed for node ID ${nodeId} not found`);
-    }
     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(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 encodeRepeated(metadata.inputContracts, encodeInputContract));
+    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
@@ -85,7 +82,7 @@ async function encodeCreateNode(create, nodeId, nodeSeeds) {
         : 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.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)));
+    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));
@@ -104,49 +101,49 @@ async function encodeValue(value) {
         return Uint8Array.from([0]); // Unit value
     }
     else if (value.sum.oneofKind === 'bool') {
-        return mkByteArray(0x01, await encodeBool(value.sum.bool));
+        return mkByteArray(Uint8Array.from([0x01]), await encodeBool(value.sum.bool));
     }
     else if (value.sum.oneofKind === 'int64') {
-        return mkByteArray(0x02, await encodeInt64(parseInt(value.sum.int64)));
+        return mkByteArray(Uint8Array.from([0x02]), await encodeInt64(parseInt(value.sum.int64)));
     }
     else if (value.sum.oneofKind === 'numeric') {
-        return mkByteArray(0x03, await encodeString(value.sum.numeric));
+        return mkByteArray(Uint8Array.from([0x03]), await encodeString(value.sum.numeric));
     }
     else if (value.sum.oneofKind === 'timestamp') {
-        return mkByteArray(0x04, await encodeString(value.sum.timestamp));
+        return mkByteArray(Uint8Array.from([0x04]), await encodeInt64(BigInt(value.sum.timestamp)));
     }
     else if (value.sum.oneofKind === 'date') {
-        return mkByteArray(0x05, await encodeInt32(value.sum.date));
+        return mkByteArray(Uint8Array.from([0x05]), await encodeInt32(value.sum.date));
     }
     else if (value.sum.oneofKind === 'party') {
-        return mkByteArray(0x06, await encodeString(value.sum.party));
+        return mkByteArray(Uint8Array.from([0x06]), await encodeString(value.sum.party));
     }
     else if (value.sum.oneofKind === 'text') {
-        return mkByteArray(0x07, await encodeString(value.sum.text));
+        return mkByteArray(Uint8Array.from([0x07]), await encodeString(value.sum.text));
     }
     else if (value.sum.oneofKind === 'contractId') {
-        return mkByteArray(0x08, await encodeHexString(value.sum.contractId));
+        return mkByteArray(Uint8Array.from([0x08]), await encodeHexString(value.sum.contractId));
     }
     else if (value.sum.oneofKind === 'optional') {
-        return mkByteArray(0x09, await encodeProtoOptional(value.sum.optional, 'value', value.sum.optional.value, encodeValue));
+        return mkByteArray(Uint8Array.from([0x09]), await encodeProtoOptional(value.sum.optional, 'value', value.sum.optional.value, encodeValue));
     }
     else if (value.sum.oneofKind === 'list') {
-        return mkByteArray(0x0a, await encodeRepeated(value.sum.list.elements, encodeValue));
+        return mkByteArray(Uint8Array.from([0x0a]), await encodeRepeated(value.sum.list.elements, encodeValue));
     }
     else if (value.sum.oneofKind === 'textMap') {
-        return mkByteArray(0x0b, await encodeRepeated(value.sum.textMap?.entries, encodeTextMapEntry));
+        return mkByteArray(Uint8Array.from([0x0b]), await encodeRepeated(value.sum.textMap?.entries, encodeTextMapEntry));
     }
     else if (value.sum.oneofKind === 'record') {
-        return mkByteArray(0x0c, await encodeProtoOptional(value.sum.record, 'recordId', value.sum.record.recordId, encodeIdentifier), await encodeRepeated(value.sum.record.fields, encodeRecordField));
+        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(0x0d, await encodeProtoOptional(value.sum.variant, 'variantId', value.sum.variant.variantId, encodeIdentifier), await encodeString(value.sum.variant.constructor), await encodeValue(value.sum.variant.value));
+        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(0x0e, await encodeProtoOptional(value.sum.enum, 'enumId', value.sum.enum.enumId, encodeIdentifier), await encodeString(value.sum.enum.constructor));
+        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(0x0f, await encodeRepeated(value.sum.genMap?.entries, encodeGenMapEntry));
+        return mkByteArray(Uint8Array.from([0x0f]), await encodeRepeated(value.sum.genMap?.entries, encodeGenMapEntry));
     }
     throw new Error('Unsupported value type: ' + JSON.stringify(value));
 }
@@ -218,3 +215,22 @@ async function encodePreparedTransaction(preparedTransaction) {
 export async function computePreparedTransaction(preparedTransaction) {
     return sha256(await encodePreparedTransaction(preparedTransaction));
 }
+export 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([0x12, 0x20]);
+    return mkByteArray(multiprefix, hashBytes);
+}
+export 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);
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { PreparedTransaction } 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.
  *
@@ -19,5 +20,4 @@ type ValidationResult = Record<string, {
     locations: string[];
 }>;
 export declare const validateAuthorizedPartyIds: (preparedTransaction: string | PreparedTransaction, authorizedPartyIds: string[]) => ValidationResult;
-export {};
 //# sourceMappingURL=index.d.ts.map

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;AAIvE;;;;;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,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"}

package/dist/index.js

@@ -3,6 +3,7 @@
 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.
  *

package/dist/utils.d.ts

@@ -4,6 +4,7 @@ export declare function fromBase64(b64: string): Uint8Array;
 export declare function toBase64(data: Uint8Array): string;
 /** Take a byte buffer (Uint8Array) and encode it into a hex string */
 export declare function toHex(bytes: Uint8Array): string;
+export declare function fromHex(hex: string): Uint8Array;
 export declare function sha256(message: string | Uint8Array): Promise<Uint8Array>;
 /** Utility to concatenate byte arrays or single bytes */
 export declare function mkByteArray(...args: (number | Uint8Array)[]): Promise<Uint8Array>;

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAGA,gFAAgF;AAChF,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAQlD;AAED,yEAAyE;AACzE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAOjD;AAED,sEAAsE;AACtE,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAI/C;AAED,wBAAsB,MAAM,CACxB,OAAO,EAAE,MAAM,GAAG,UAAU,GAC7B,OAAO,CAAC,UAAU,CAAC,CASrB;AAED,yDAAyD;AACzD,wBAAsB,WAAW,CAC7B,GAAG,IAAI,EAAE,CAAC,MAAM,GAAG,UAAU,CAAC,EAAE,GACjC,OAAO,CAAC,UAAU,CAAC,CAuBrB"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAGA,gFAAgF;AAChF,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAQlD;AAED,yEAAyE;AACzE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAOjD;AAED,sEAAsE;AACtE,wBAAgB,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAI/C;AAED,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAU/C;AAED,wBAAsB,MAAM,CACxB,OAAO,EAAE,MAAM,GAAG,UAAU,GAC7B,OAAO,CAAC,UAAU,CAAC,CASrB;AAED,yDAAyD;AACzD,wBAAsB,WAAW,CAC7B,GAAG,IAAI,EAAE,CAAC,MAAM,GAAG,UAAU,CAAC,EAAE,GACjC,OAAO,CAAC,UAAU,CAAC,CAuBrB"}

package/dist/utils.js

@@ -25,6 +25,16 @@ export function toHex(bytes) {
         .map((byte) => byte.toString(16).padStart(2, '0'))
         .join('');
 }
+export function fromHex(hex) {
+    if (hex.length % 2 !== 0) {
+        throw new Error('Invalid hex string length');
+    }
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < hex.length; i += 2) {
+        bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+    }
+    return bytes;
+}
 export async function sha256(message) {
     const msg = typeof message === 'string'
         ? new TextEncoder().encode(message)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canton-network/core-tx-visualizer",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "type": "module",
   "description": "Decode and visualize prepared transactions from Canton",
   "repository": "github:hyperledger-labs/splice-wallet-kernel",
@@ -25,7 +25,7 @@
     "typescript": "^5.8.3"
   },
   "dependencies": {
-    "@canton-network/core-ledger-proto": "^0.4.0",
+    "@canton-network/core-ledger-proto": "^0.6.0",
     "@protobuf-ts/runtime": "^2.11.1",
     "@protobuf-ts/runtime-rpc": "^2.11.1",
     "@swc/core": "^1.13.3",