@canton-network/core-tx-visualizer 0.1.0

package/dist/Tx.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Tx.test.d.ts.map

package/dist/Tx.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tx.test.d.ts","sourceRoot":"","sources":["../src/Tx.test.ts"],"names":[],"mappings":""}

package/dist/Tx.test.js

@@ -0,0 +1,16 @@
+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 camelcaseKeys from 'camelcase-keys';
+test('decode a base 64 encoded prepared tx', async () => {
+    const base64EncodedPreparedTx = 'Cp8GCgMyLjESATAa8AUKATDCPukFCuYFCgMyLjESQjAwNTUwODAyZGRiMTYzNzFmNWZjNmQzNjRlNmNkNGIzMjgzYTllYjVjMGNjYjEyMWFlMzY4Y2RlYmJhZDBmYmY1NhoOQWRtaW5Xb3JrZmxvd3MiXgpAMmEzOGI5NjNmNmFiZjQ1Yjc2YzcwMmY5NzAwYmZkOTA2MDU1NTg3MmFmOTE1ZWY3ZjhmNjg3OTVlMmM4MzFiZBIUQ2FudG9uLkludGVybmFsLlBpbmcaBFBpbmcqtgJyswIKXgpAMmEzOGI5NjNmNmFiZjQ1Yjc2YzcwMmY5NzAwYmZkOTA2MDU1NTg3MmFmOTE1ZWY3ZjhmNjg3OTVlMmM4MzFiZBIUQ2FudG9uLkludGVybmFsLlBpbmcaBFBpbmcSDwoCaWQSCUIHcGluZ19pZBJdCglpbml0aWF0b3ISUDpOb3BlcmF0b3I6OjEyMjBkNDRmYzFjM2JhMGI1YmRmN2I5NTZlZTcxYmM5NGViZTJkMjMyNThkYzI2OGZkZjA4MjRmYmFlZmYyYzYxNDI0EmEKCXJlc3BvbmRlchJUOlJwYXJ0aWNpcGFudDE6OjEyMjBkNDRmYzFjM2JhMGI1YmRmN2I5NTZlZTcxYmM5NGViZTJkMjMyNThkYzI2OGZkZjA4MjRmYmFlZmYyYzYxNDI0Mk5vcGVyYXRvcjo6MTIyMGQ0NGZjMWMzYmEwYjViZGY3Yjk1NmVlNzFiYzk0ZWJlMmQyMzI1OGRjMjY4ZmRmMDgyNGZiYWVmZjJjNjE0MjQ6Tm9wZXJhdG9yOjoxMjIwZDQ0ZmMxYzNiYTBiNWJkZjdiOTU2ZWU3MWJjOTRlYmUyZDIzMjU4ZGMyNjhmZGYwODI0ZmJhZWZmMmM2MTQyNDpScGFydGljaXBhbnQxOjoxMjIwZDQ0ZmMxYzNiYTBiNWJkZjdiOTU2ZWU3MWJjOTRlYmUyZDIzMjU4ZGMyNjhmZGYwODI0ZmJhZWZmMmM2MTQyNCIiEiBr2qJTURRRnXWp6y1EyXQiB69cfe50kJw0eYN1UF39nhL1ARJ2Ck5vcGVyYXRvcjo6MTIyMGQ0NGZjMWMzYmEwYjViZGY3Yjk1NmVlNzFiYzk0ZWJlMmQyMzI1OGRjMjY4ZmRmMDgyNGZiYWVmZjJjNjE0MjQSJGYyZWM0ZDhmLWNjYzEtNDAyYi1iMjc4LTc1NTZmZGQyYjQxMhpMd2FsbGV0OjoxMjIwZTdiMjNlYTUyZWI1YzY3MmZiMGIxY2RiYzkxNjkyMmZmZWQzZGQ3Njc2YzIyM2E2MDU2NjQzMTVlMmQ0M2VkZCokYTMyODE2MmUtNzI4ZS00ZTA1LWFjNzgtYjM0ZjA3MDk4M2JhMK7Y9/LU944D';
+    const preparedTx = decodePreparedTransaction(base64EncodedPreparedTx);
+    const __dirname = path.resolve();
+    const resolvedFilePath = path.join(__dirname, '../tx-visualizer/create_ping_prepared_response.json');
+    const preapredTXJson = JSON.parse(readFileSync(resolvedFilePath, 'utf-8'));
+    const camelCasePreparedTx = camelcaseKeys(preapredTXJson, { deep: true });
+    const message = PreparedTransaction.fromJson(camelCasePreparedTx);
+    expect(message === preparedTx);
+});

package/dist/hashing_scheme_v2.d.ts

@@ -0,0 +1,4 @@
+import { PreparedTransaction } from '@canton-network/core-ledger-proto';
+export declare function encodeString(value?: string): Promise<Uint8Array>;
+export declare function computePreparedTransaction(preparedTransaction: PreparedTransaction): Promise<Uint8Array>;
+//# sourceMappingURL=hashing_scheme_v2.d.ts.map

package/dist/hashing_scheme_v2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashing_scheme_v2.d.ts","sourceRoot":"","sources":["../src/hashing_scheme_v2.ts"],"names":[],"mappings":"AAAA,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"}

package/dist/hashing_scheme_v2.js

@@ -0,0 +1,218 @@
+import { HashingSchemeVersion, } from '@canton-network/core-ledger-proto';
+import { mkByteArray, sha256 } from './utils.js';
+// Hash purpose reserved for prepared transaction
+const PREPARED_TRANSACTION_HASH_PURPOSE = Uint8Array.from([
+    0x00, 0x00, 0x00, 0x30,
+]);
+const NODE_ENCODING_VERSION = Uint8Array.from([0x01]);
+const 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); // true for little-endian
+    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); // true for little-endian
+    return new Uint8Array(buffer);
+}
+export async function encodeString(value = '') {
+    const utf8Bytes = new TextEncoder().encode(value);
+    return encodeBytes(utf8Bytes);
+}
+async function encodeBytes(value) {
+    const length = await encodeInt32(value.length);
+    return mkByteArray(length, value);
+}
+async function encodeHash(value) {
+    return value;
+}
+function encodeHexString(value = '') {
+    // Convert hex string to Uint8Array
+    const bytes = new Uint8Array(value.length / 2);
+    for (let i = 0; i < value.length; i += 2) {
+        bytes[i / 2] = parseInt(value.slice(i, i + 2), 16);
+    }
+    return encodeBytes(bytes);
+}
+// Maybe suspicious?
+async function encodeOptional(value, encodeFn) {
+    if (value === undefined || value === null) {
+        return new Uint8Array([0]); // Return empty array for undefined fields
+    }
+    else {
+        return mkByteArray(1, await encodeFn(value));
+    }
+}
+// Maybe suspicious?
+async function encodeProtoOptional(parentValue, fieldName, value, encodeFn) {
+    if (parentValue && parentValue[fieldName] !== undefined) {
+        return mkByteArray(1, await encodeFn(value));
+    }
+    else {
+        return new Uint8Array([0]); // Return empty array for undefined fields
+    }
+}
+async function encodeRepeated(values = [], encodeFn) {
+    const length = await encodeInt32(values.length);
+    const encodedValues = await Promise.all(values.map(encodeFn));
+    return mkByteArray(length, ...encodedValues);
+}
+function findSeed(nodeId, nodeSeeds) {
+    const seed = nodeSeeds.find((seed) => seed.nodeId.toString() === nodeId)?.seed;
+    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));
+}
+async function encodeCreateNode(create, nodeId, nodeSeeds) {
+    return create
+        ? mkByteArray(NODE_ENCODING_VERSION, await encodeString(create.lfVersion), 0 /** Create node tag */, await encodeOptional(findSeed(nodeId, nodeSeeds), encodeHash), await encodeHexString(create.contractId), await encodeString(create.packageName), await encodeIdentifier(create.templateId), await encodeValue(create.argument), await encodeRepeated(create.signatories, encodeString), await encodeRepeated(create.stakeholders, encodeString))
+        : mkByteArray();
+}
+async function encodeExerciseNode(exercise, nodeId, nodesDict, nodeSeeds) {
+    return mkByteArray(NODE_ENCODING_VERSION, await encodeString(exercise.lfVersion), 1 /** Exercise node tag */, await encodeHash(findSeed(nodeId, nodeSeeds)), await encodeHexString(exercise.contractId), await encodeString(exercise.packageName), await encodeIdentifier(exercise.templateId), await encodeRepeated(exercise.signatories, encodeString), await encodeRepeated(exercise.actingParties, encodeString), await encodeProtoOptional(exercise, 'interfaceId', exercise.interfaceId, encodeIdentifier), await encodeString(exercise.choiceId), await encodeValue(exercise.chosenValue), await encodeBool(exercise.consuming), await encodeProtoOptional(exercise, 'exerciseResult', exercise.exerciseResult, encodeValue), await encodeRepeated(exercise.choiceObservers, encodeString), await encodeRepeated(exercise.children, encodeNodeId(nodesDict, nodeSeeds)));
+}
+async function encodeFetchNode(fetch) {
+    return mkByteArray(NODE_ENCODING_VERSION, await encodeString(fetch.lfVersion), 2 /** Fetch node tag */, await encodeHexString(fetch.contractId), await encodeString(fetch.packageName), await encodeIdentifier(fetch.templateId), await encodeRepeated(fetch.signatories, encodeString), await encodeRepeated(fetch.stakeholders, encodeString), await encodeProtoOptional(fetch, 'interfaceId', fetch.interfaceId, encodeIdentifier), await encodeRepeated(fetch.actingParties, encodeString));
+}
+async function encodeRollbackNode(rollback, nodesDict, nodeSeeds) {
+    return mkByteArray(NODE_ENCODING_VERSION, 3 /** Rollback node tag */, await encodeRepeated(rollback.children, encodeNodeId(nodesDict, nodeSeeds)));
+}
+async function encodeInputContract(contract) {
+    if (contract.contract.oneofKind === 'v1')
+        return mkByteArray(await encodeInt64(contract.createdAt), await sha256(await encodeCreateNode(contract.contract.v1, 'unused_node_id', [])));
+    else
+        throw new Error('Unsupported contract version');
+}
+async function encodeValue(value) {
+    if (value.sum.oneofKind === 'unit') {
+        return Uint8Array.from([0]); // Unit value
+    }
+    else if (value.sum.oneofKind === 'bool') {
+        return mkByteArray(0x01, await encodeBool(value.sum.bool));
+    }
+    else if (value.sum.oneofKind === 'int64') {
+        return mkByteArray(0x02, await encodeInt64(parseInt(value.sum.int64)));
+    }
+    else if (value.sum.oneofKind === 'numeric') {
+        return mkByteArray(0x03, await encodeString(value.sum.numeric));
+    }
+    else if (value.sum.oneofKind === 'timestamp') {
+        return mkByteArray(0x04, await encodeString(value.sum.timestamp));
+    }
+    else if (value.sum.oneofKind === 'date') {
+        return mkByteArray(0x05, await encodeInt32(value.sum.date));
+    }
+    else if (value.sum.oneofKind === 'party') {
+        return mkByteArray(0x06, await encodeString(value.sum.party));
+    }
+    else if (value.sum.oneofKind === 'text') {
+        return mkByteArray(0x07, await encodeString(value.sum.text));
+    }
+    else if (value.sum.oneofKind === 'contractId') {
+        return mkByteArray(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));
+    }
+    else if (value.sum.oneofKind === 'list') {
+        return mkByteArray(0x0a, await encodeRepeated(value.sum.list.elements, encodeValue));
+    }
+    else if (value.sum.oneofKind === 'textMap') {
+        return mkByteArray(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));
+    }
+    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));
+    }
+    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));
+    }
+    else if (value.sum.oneofKind === 'genMap') {
+        return mkByteArray(0x0f, await encodeRepeated(value.sum.genMap?.entries, encodeGenMapEntry));
+    }
+    throw new Error('Unsupported value type: ' + JSON.stringify(value));
+}
+async function encodeTextMapEntry(entry) {
+    return mkByteArray(await encodeString(entry.key), await encodeValue(entry.value));
+}
+async function encodeRecordField(field) {
+    return mkByteArray(await encodeOptional(field.label, encodeString), await encodeValue(field.value));
+}
+async function encodeGenMapEntry(entry) {
+    return mkByteArray(await encodeValue(entry.key), await encodeValue(entry.value));
+}
+function encodeNodeId(nodesDict, nodeSeeds) {
+    return async (nodeId) => {
+        const node = nodesDict[nodeId];
+        if (!node) {
+            throw new Error(`Node with ID ${nodeId} not found in transaction`);
+        }
+        const encodedNode = await encodeNode(node, nodesDict, nodeSeeds);
+        return sha256(encodedNode);
+    };
+}
+async function encodeNode(node, nodesDict, nodeSeeds) {
+    if (node.versionedNode.oneofKind === 'v1') {
+        if (node.versionedNode.v1.nodeType.oneofKind === 'create') {
+            return encodeCreateNode(node.versionedNode.v1.nodeType.create, node.nodeId, nodeSeeds);
+        }
+        else if (node.versionedNode.v1.nodeType.oneofKind === 'exercise') {
+            return encodeExerciseNode(node.versionedNode.v1.nodeType.exercise, node.nodeId, nodesDict, nodeSeeds);
+        }
+        else if (node.versionedNode.v1.nodeType.oneofKind === 'fetch') {
+            return encodeFetchNode(node.versionedNode.v1.nodeType.fetch);
+        }
+        else if (node.versionedNode.v1.nodeType.oneofKind === 'rollback') {
+            return encodeRollbackNode(node.versionedNode.v1.nodeType.rollback, nodesDict, nodeSeeds);
+        }
+        throw new Error('Unsupported node type');
+    }
+    else {
+        throw new Error(`Unsupported node version`);
+    }
+}
+function createNodesDict(preparedTransaction) {
+    const nodesDict = {};
+    const nodes = preparedTransaction.transaction?.nodes || [];
+    for (const node of nodes) {
+        nodesDict[node.nodeId] = node;
+    }
+    return nodesDict;
+}
+async function encodeTransaction(transaction, nodesDict, nodeSeeds) {
+    return mkByteArray(await encodeString(transaction.version), await encodeRepeated(transaction.roots, encodeNodeId(nodesDict, nodeSeeds)));
+}
+async function hashTransaction(transaction, nodesDict) {
+    const encodedTransaction = await encodeTransaction(transaction, nodesDict, transaction.nodeSeeds);
+    const hash = await sha256(await mkByteArray(PREPARED_TRANSACTION_HASH_PURPOSE, encodedTransaction));
+    return hash;
+}
+async function hashMetadata(metadata) {
+    const hash = await sha256(await mkByteArray(PREPARED_TRANSACTION_HASH_PURPOSE, await encodeMetadata(metadata)));
+    return hash;
+}
+async function encodePreparedTransaction(preparedTransaction) {
+    const nodesDict = createNodesDict(preparedTransaction);
+    const transactionHash = await hashTransaction(preparedTransaction.transaction, nodesDict);
+    const metadataHash = await hashMetadata(preparedTransaction.metadata);
+    return mkByteArray(PREPARED_TRANSACTION_HASH_PURPOSE, HASHING_SCHEME_VERSION, transactionHash, metadataHash);
+}
+export async function computePreparedTransaction(preparedTransaction) {
+    return sha256(await encodePreparedTransaction(preparedTransaction));
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import { PreparedTransaction } from '@canton-network/core-ledger-proto';
+/**
+ * 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 declare const decodePreparedTransaction: (preparedTransaction: string) => PreparedTransaction;
+/**
+ * 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 declare const hashPreparedTransaction: (preparedTransaction: string | PreparedTransaction, format?: "base64" | "hex") => Promise<string>;
+type ValidationResult = Record<string, {
+    isAuthorized: boolean;
+    locations: string[];
+}>;
+export declare const validateAuthorizedPartyIds: (preparedTransaction: string | PreparedTransaction, authorizedPartyIds: string[]) => ValidationResult;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,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"}

package/dist/index.js

@@ -0,0 +1,90 @@
+import { PreparedTransaction } from '@canton-network/core-ledger-proto';
+import { computePreparedTransaction } from './hashing_scheme_v2.js';
+import { fromBase64, toBase64, toHex } from './utils.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);
+    }
+    else {
+        preparedTx = preparedTransaction;
+    }
+    const hash = await computePreparedTransaction(preparedTx);
+    switch (format) {
+        case 'base64':
+            return toBase64(hash);
+        case 'hex':
+            return toHex(hash);
+    }
+};
+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: [
+                ...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;
+};

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+/** Take a base64 encoded string and return a Uint8Array of the decoded bytes */
+export declare function fromBase64(b64: string): Uint8Array;
+/** Take a byte buffer (Uint8Array) and encode it into a base64 string */
+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 sha256(message: string | Uint8Array): Promise<Uint8Array>;
+/** Utility to concatenate byte arrays or single bytes */
+export declare function mkByteArray(...args: (number | Uint8Array)[]): Promise<Uint8Array>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,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"}

package/dist/utils.js

@@ -0,0 +1,55 @@
+/** Take a base64 encoded string and return a Uint8Array of the decoded bytes */
+export 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;
+}
+/** Take a byte buffer (Uint8Array) and encode it into a base64 string */
+export function toBase64(data) {
+    let binaryString = '';
+    const len = data.byteLength;
+    for (let i = 0; i < len; i++) {
+        binaryString += String.fromCharCode(data[i]);
+    }
+    return btoa(binaryString);
+}
+/** Take a byte buffer (Uint8Array) and encode it into a hex string */
+export function toHex(bytes) {
+    return Array.from(bytes)
+        .map((byte) => byte.toString(16).padStart(2, '0'))
+        .join('');
+}
+export 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));
+}
+/** Utility to concatenate byte arrays or single bytes */
+export 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;
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@canton-network/core-tx-visualizer",
+  "version": "0.1.0",
+  "license": "Apache-2.0",
+  "packageManager": "yarn@4.9.2",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "tsc -b --watch",
+    "test": "yarn node --experimental-vm-modules $(yarn bin jest)",
+    "clean": "tsc -b --clean; rm -rf dist"
+  },
+  "devDependencies": {
+    "@canton-network/core-ledger-proto": "^0.1.0",
+    "@jest/globals": "^29.0.0",
+    "@swc/jest": "^0.2.38",
+    "@types/jest": "^30.0.0",
+    "globals": "^16.0.0",
+    "jest": "^30.0.0",
+    "ts-jest": "^29.4.0",
+    "ts-jest-resolver": "^2.0.1",
+    "ts-proto": "^2.7.5",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@protobuf-ts/runtime": "^2.11.1",
+    "@protobuf-ts/runtime-rpc": "^2.11.1",
+    "@swc/core": "^1.13.3",
+    "@types/node": "^22.15.30",
+    "camelcase-keys": "^9.1.3",
+    "rxjs": "^7.8.2"
+  },
+  "files": [
+    "dist/*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}