@totemsdk/core 1.2.5 → 1.2.7

package/dist/treekey.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * TreeKey/TreeKeyNode Implementation matching Minima's TreeKey.java and TreeKeyNode.java
  *
@@ -9,29 +8,14 @@
  *
  * Default structure: 3 levels x 64 keys = 64^3 = 262,144 one-time signatures
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TreeKey = exports.TreeKeyNode = exports.DEFAULT_LEVELS = exports.DEFAULT_KEYS_PER_LEVEL = void 0;
-exports.setTreeKeyLogger = setTreeKeyLogger;
-exports.disableTreeKeyLogger = disableTreeKeyLogger;
-exports.isTreeKeyDebugEnabled = isTreeKeyDebugEnabled;
-exports.getRootPublicKey = getRootPublicKey;
-exports.verifyTreeSignature = verifyTreeSignature;
-exports.serializeTreeSignature = serializeTreeSignature;
-exports.deserializeTreeSignature = deserializeTreeSignature;
-exports.createUnifiedChildTreeKey = createUnifiedChildTreeKey;
-exports.createUnifiedChildTreeKeyAsync = createUnifiedChildTreeKeyAsync;
-exports.createUnifiedRootTreeKey = createUnifiedRootTreeKey;
-exports.deriveUnifiedAddressPublicKey = deriveUnifiedAddressPublicKey;
-exports.createPerAddressTreeKey = createPerAddressTreeKey;
-exports.createPerAddressTreeKeyAsync = createPerAddressTreeKeyAsync;
-const javaStreamables_js_1 = require("./javaStreamables.js");
-const wots_js_1 = require("./wots.js");
-const params_js_1 = require("./params.js");
-const mmr_js_1 = require("./mmr.js");
-const Streamable_js_1 = require("./Streamable.js");
-const index_js_1 = require("./adapters/index.js");
+import { deriveChainSeedJava, hashObject, deriveRootPrivSeed, deriveUnifiedChildSeed, derivePerAddressSeed } from './javaStreamables.js';
+import { derivePKdigest, deriveFullPublicKey, wotsSign, wotsVerifyDigest, hex } from './wots.js';
+import { getParamSet } from './params.js';
+import { MMRTree, createMMRDataLeafNode, calculateProofRoot, parseMMRProofFromHex } from './mmr.js';
+import { writeSignature } from './Streamable.js';
+import { NoopLogger } from './adapters/index.js';
 // Module-level debug logger - can be set externally for parity testing
-let treeKeyLogger = new index_js_1.NoopLogger();
+let treeKeyLogger = new NoopLogger();
 let treeKeyDebugEnabled = false;
 /**
  * Enable TreeKey debug logging with a custom logger
@@ -41,32 +25,32 @@ let treeKeyDebugEnabled = false;
  * seeds and private key derivation. NEVER enable in production builds.
  * This is intended for development/testing parity verification only.
  */
-function setTreeKeyLogger(logger) {
+export function setTreeKeyLogger(logger) {
     treeKeyLogger = logger;
     treeKeyDebugEnabled = true;
 }
 /**
  * Disable TreeKey debug logging
  */
-function disableTreeKeyLogger() {
-    treeKeyLogger = new index_js_1.NoopLogger();
+export function disableTreeKeyLogger() {
+    treeKeyLogger = new NoopLogger();
     treeKeyDebugEnabled = false;
 }
 /**
  * Check if TreeKey debug logging is enabled
  */
-function isTreeKeyDebugEnabled() {
+export function isTreeKeyDebugEnabled() {
     return treeKeyDebugEnabled;
 }
-exports.DEFAULT_KEYS_PER_LEVEL = 64;
-exports.DEFAULT_LEVELS = 3;
+export const DEFAULT_KEYS_PER_LEVEL = 64;
+export const DEFAULT_LEVELS = 3;
 /**
  * Compute root public key from a Winternitz signature proof
  * Matches SignatureProof.getRootPublicKey() in Java
  */
-function getRootPublicKey(proof) {
-    const leafData = (0, mmr_js_1.createMMRDataLeafNode)(proof.leafPubkey, 0n);
-    return (0, mmr_js_1.calculateProofRoot)(leafData, proof.mmrProof);
+export function getRootPublicKey(proof) {
+    const leafData = createMMRDataLeafNode(proof.leafPubkey, 0n);
+    return calculateProofRoot(leafData, proof.mmrProof);
 }
 /**
  * TreeKeyNode - One node in the key tree containing 64 Winternitz keys
@@ -91,15 +75,21 @@ function getRootPublicKey(proof) {
  * IMPORTANT: Minima NEVER stores the 1088-byte full WOTS public key.
  * Only the 32-byte digest is stored and used for MMR construction.
  */
-class TreeKeyNode {
-    constructor(privateSeed, keysPerLevel = exports.DEFAULT_KEYS_PER_LEVEL) {
-        this.childCache = new Map();
+export class TreeKeyNode {
+    seed;
+    childSeed;
+    keysPerLevel;
+    publicKeyDigests; // 32-byte SHA3 digests - matches Java's Winternitz.getPublicKey() which returns SHA3-256(full_key)
+    mmrTree;
+    rootPubkey;
+    childCache = new Map();
+    constructor(privateSeed, keysPerLevel = DEFAULT_KEYS_PER_LEVEL) {
         if (privateSeed.length !== 32) {
             throw new Error('Private seed must be 32 bytes');
         }
         if (treeKeyDebugEnabled) {
             treeKeyLogger.debug(`[TreeKeyNode] ========== INIT START ==========`);
-            treeKeyLogger.debug(`[TreeKeyNode] Private seed: ${(0, wots_js_1.hex)(privateSeed)}`);
+            treeKeyLogger.debug(`[TreeKeyNode] Private seed: ${hex(privateSeed)}`);
             treeKeyLogger.debug(`[TreeKeyNode] Keys per level: ${keysPerLevel}`);
         }
         this.seed = privateSeed;
@@ -107,9 +97,9 @@ class TreeKeyNode {
         // Hash the seed to create child seed (for deriving child nodes)
         // From TreeKeyNode.java: mChildSeed = Crypto.getInstance().hashObject(zPrivateSeed);
         // hashObject serializes as MiniData (length-prefixed) then hashes
-        this.childSeed = (0, javaStreamables_js_1.hashObject)(privateSeed);
+        this.childSeed = hashObject(privateSeed);
         if (treeKeyDebugEnabled) {
-            treeKeyLogger.debug(`[TreeKeyNode] Child seed (hashObject): ${(0, wots_js_1.hex)(this.childSeed)}`);
+            treeKeyLogger.debug(`[TreeKeyNode] Child seed (hashObject): ${hex(this.childSeed)}`);
         }
         // Generate all Winternitz public key DIGESTS (32 bytes each)
         // Java's Winternitz.getPublicKey() returns SHA3-256(full_key) = 32 bytes
@@ -119,22 +109,22 @@ class TreeKeyNode {
         this.publicKeyDigests = [];
         for (let i = 0; i < keysPerLevel; i++) {
             // Digest (32 bytes) - used for MMR tree, SignatureProof.leafPubkey, and address derivation
-            const pkDigest = (0, wots_js_1.derivePKdigest)(privateSeed, i, (0, params_js_1.getParamSet)());
+            const pkDigest = derivePKdigest(privateSeed, i, getParamSet());
             this.publicKeyDigests.push(pkDigest);
             // Log first few keys for debugging
             if (treeKeyDebugEnabled && i < 3) {
-                treeKeyLogger.debug(`[TreeKeyNode] WOTS key[${i}] digest (32B): ${(0, wots_js_1.hex)(pkDigest)}`);
+                treeKeyLogger.debug(`[TreeKeyNode] WOTS key[${i}] digest (32B): ${hex(pkDigest)}`);
             }
         }
         if (treeKeyDebugEnabled) {
             treeKeyLogger.debug(`[TreeKeyNode] Generated ${this.publicKeyDigests.length} WOTS key digests`);
             const lastIdx = this.publicKeyDigests.length - 1;
-            treeKeyLogger.debug(`[TreeKeyNode] WOTS key[${lastIdx}] digest: ${(0, wots_js_1.hex)(this.publicKeyDigests[lastIdx])}`);
+            treeKeyLogger.debug(`[TreeKeyNode] WOTS key[${lastIdx}] digest: ${hex(this.publicKeyDigests[lastIdx])}`);
         }
         // Build MMR tree from 32-byte PUBLIC KEY DIGESTS (Java-compatible)
         // Java's TreeKeyNode: MMRData.CreateMMRDataLeafNode(wots.getPublicKey(), ZERO)
         // where getPublicKey() returns SHA3-256(full_key) = 32-byte DIGEST
-        this.mmrTree = mmr_js_1.MMRTree.fromPublicKeys(this.publicKeyDigests);
+        this.mmrTree = MMRTree.fromPublicKeys(this.publicKeyDigests);
         // Root public key = MMR root
         const root = this.mmrTree.getRoot();
         if (!root) {
@@ -142,7 +132,7 @@ class TreeKeyNode {
         }
         this.rootPubkey = root.data;
         if (treeKeyDebugEnabled) {
-            treeKeyLogger.debug(`[TreeKeyNode] MMR root (node public key): ${(0, wots_js_1.hex)(this.rootPubkey)}`);
+            treeKeyLogger.debug(`[TreeKeyNode] MMR root (node public key): ${hex(this.rootPubkey)}`);
             treeKeyLogger.debug(`[TreeKeyNode] ========== INIT END ==========`);
         }
     }
@@ -150,14 +140,14 @@ class TreeKeyNode {
      * Async factory method for TreeKeyNode with progress reporting
      * Yields to event loop every few keys to keep UI responsive
      */
-    static async createWithProgress(privateSeed, keysPerLevel = exports.DEFAULT_KEYS_PER_LEVEL, onProgress) {
+    static async createWithProgress(privateSeed, keysPerLevel = DEFAULT_KEYS_PER_LEVEL, onProgress) {
         if (privateSeed.length !== 32) {
             throw new Error('Private seed must be 32 bytes');
         }
         const node = Object.create(TreeKeyNode.prototype);
         node.seed = privateSeed;
         node.keysPerLevel = keysPerLevel;
-        node.childSeed = (0, javaStreamables_js_1.hashObject)(privateSeed);
+        node.childSeed = hashObject(privateSeed);
         node.publicKeyDigests = [];
         node.childCache = new Map();
         // Generate Winternitz public key DIGESTS with progress (32 bytes each)
@@ -165,7 +155,7 @@ class TreeKeyNode {
         // See WinternitzOTSignature.getPublicKey() lines 103-121: hashes full 1088B key, returns 32B digest
         for (let i = 0; i < keysPerLevel; i++) {
             // Digest (32 bytes) - used for MMR tree, SignatureProof.leafPubkey, and address derivation
-            const pkDigest = (0, wots_js_1.derivePKdigest)(privateSeed, i, (0, params_js_1.getParamSet)());
+            const pkDigest = derivePKdigest(privateSeed, i, getParamSet());
             node.publicKeyDigests.push(pkDigest);
             // Report progress every 4 keys and yield to event loop
             if (onProgress && (i + 1) % 4 === 0) {
@@ -191,7 +181,7 @@ class TreeKeyNode {
         // Build MMR tree from 32-byte PUBLIC KEY DIGESTS (Java-compatible)
         // Java's TreeKeyNode: MMRData.CreateMMRDataLeafNode(wots.getPublicKey(), ZERO)
         // where getPublicKey() returns SHA3-256(full_key) = 32-byte DIGEST
-        node.mmrTree = mmr_js_1.MMRTree.fromPublicKeys(node.publicKeyDigests);
+        node.mmrTree = MMRTree.fromPublicKeys(node.publicKeyDigests);
         const root = node.mmrTree.getRoot();
         if (!root) {
             throw new Error('Failed to compute MMR root');
@@ -228,7 +218,7 @@ class TreeKeyNode {
             throw new Error(`Key index ${index} out of range [0, ${this.keysPerLevel})`);
         }
         // Derive on-demand - expensive but only used for tests
-        return (0, wots_js_1.deriveFullPublicKey)(this.seed, index, (0, params_js_1.getParamSet)());
+        return deriveFullPublicKey(this.seed, index, getParamSet());
     }
     /**
      * Get the Winternitz public key digest at a specific index (0-63)
@@ -268,14 +258,14 @@ class TreeKeyNode {
         if (treeKeyDebugEnabled) {
             treeKeyLogger.debug(`[TreeKeyNode.sign] ========== SIGN START ==========`);
             treeKeyLogger.debug(`[TreeKeyNode.sign] keyIndex: ${keyIndex}`);
-            treeKeyLogger.debug(`[TreeKeyNode.sign] input data (${data.length}B): ${(0, wots_js_1.hex)(data).substring(0, 64)}${data.length > 32 ? '...' : ''}`);
+            treeKeyLogger.debug(`[TreeKeyNode.sign] input data (${data.length}B): ${hex(data).substring(0, 64)}${data.length > 32 ? '...' : ''}`);
         }
         // Get the 32-byte Winternitz public key DIGEST for SignatureProof
         // CRITICAL FIX: Java's Winternitz.getPublicKey() returns SHA3-256(full_key) = 32 bytes!
         // NOT the 1088-byte full key! This was the bug causing "allsignaturesvalid":false errors.
         const leafPubkey = this.publicKeyDigests[keyIndex];
         if (treeKeyDebugEnabled) {
-            treeKeyLogger.debug(`[TreeKeyNode.sign] leafPubkey (${leafPubkey.length}B DIGEST): ${(0, wots_js_1.hex)(leafPubkey)}`);
+            treeKeyLogger.debug(`[TreeKeyNode.sign] leafPubkey (${leafPubkey.length}B DIGEST): ${hex(leafPubkey)}`);
         }
         // CRITICAL: Do NOT pre-hash here! wotsSign() now handles internal hashing (matching Java/BouncyCastle).
         // Java's WinternitzOTSignature.getSignature() hashes internally, so wotsSign() does too.
@@ -284,12 +274,12 @@ class TreeKeyNode {
         //   - For parent→child: the 32-byte childRoot (MMR root of child proof)
         // WOTS hashes once internally - this is by design for Minima compatibility.
         if (treeKeyDebugEnabled) {
-            treeKeyLogger.debug(`[TreeKeyNode.sign] dataToSign (raw input, WOTS hashes internally): ${(0, wots_js_1.hex)(data)}`);
+            treeKeyLogger.debug(`[TreeKeyNode.sign] dataToSign (raw input, WOTS hashes internally): ${hex(data)}`);
         }
         // Sign data directly - wotsSign() handles internal hashing
-        const signature = (0, wots_js_1.wotsSign)(this.seed, keyIndex, data, (0, params_js_1.getParamSet)());
+        const signature = wotsSign(this.seed, keyIndex, data, getParamSet());
         if (treeKeyDebugEnabled) {
-            treeKeyLogger.debug(`[TreeKeyNode.sign] signature (${signature.length}B): ${(0, wots_js_1.hex)(signature).substring(0, 64)}...${(0, wots_js_1.hex)(signature).substring((0, wots_js_1.hex)(signature).length - 32)}`);
+            treeKeyLogger.debug(`[TreeKeyNode.sign] signature (${signature.length}B): ${hex(signature).substring(0, 64)}...${hex(signature).substring(hex(signature).length - 32)}`);
         }
         // Get the MMR proof for this key
         const mmrProof = this.getProof(keyIndex);
@@ -321,24 +311,23 @@ class TreeKeyNode {
         }
         if (treeKeyDebugEnabled) {
             treeKeyLogger.debug(`[TreeKeyNode.getChild] Creating child at index ${childIndex}`);
-            treeKeyLogger.debug(`[TreeKeyNode.getChild] Parent childSeed: ${(0, wots_js_1.hex)(this.childSeed)}`);
+            treeKeyLogger.debug(`[TreeKeyNode.getChild] Parent childSeed: ${hex(this.childSeed)}`);
         }
         // From TreeKeyNode.java:
         // MiniData seed = Crypto.getInstance().hashAllObjects(new MiniNumber(zChild), mChildSeed);
-        const childSeed = (0, javaStreamables_js_1.deriveChainSeedJava)(this.childSeed, childIndex);
+        const childSeed = deriveChainSeedJava(this.childSeed, childIndex);
         if (treeKeyDebugEnabled) {
-            treeKeyLogger.debug(`[TreeKeyNode.getChild] Derived childSeed: ${(0, wots_js_1.hex)(childSeed)}`);
+            treeKeyLogger.debug(`[TreeKeyNode.getChild] Derived childSeed: ${hex(childSeed)}`);
         }
         const child = new TreeKeyNode(childSeed, this.keysPerLevel);
         if (treeKeyDebugEnabled) {
-            treeKeyLogger.debug(`[TreeKeyNode.getChild] Child public key: ${(0, wots_js_1.hex)(child.getPublicKey())}`);
+            treeKeyLogger.debug(`[TreeKeyNode.getChild] Child public key: ${hex(child.getPublicKey())}`);
         }
         // Cache for future use
         this.childCache.set(childIndex, child);
         return child;
     }
 }
-exports.TreeKeyNode = TreeKeyNode;
 /**
  * TreeKey - Full hierarchical key tree with multiple levels
  *
@@ -347,21 +336,26 @@ exports.TreeKeyNode = TreeKeyNode;
  * - Tracks usage count to determine which key to use
  * - Produces multi-level signatures
  */
-class TreeKey {
-    constructor(privateSeed, keysPerLevel = exports.DEFAULT_KEYS_PER_LEVEL, levels = exports.DEFAULT_LEVELS) {
-        this.uses = 0;
-        /**
-         * Parent-child signature cache for efficiency
-         * Key format: "l1" for root->level1, "l1,l2" for level1->level2
-         * Value: SignatureProof for parent signing child's pubkey
-         */
-        this.parentChildSigCache = new Map();
+export class TreeKey {
+    privateSeed;
+    levels;
+    keysPerLevel;
+    root;
+    publicKey;
+    uses = 0;
+    /**
+     * Parent-child signature cache for efficiency
+     * Key format: "l1" for root->level1, "l1,l2" for level1->level2
+     * Value: SignatureProof for parent signing child's pubkey
+     */
+    parentChildSigCache = new Map();
+    constructor(privateSeed, keysPerLevel = DEFAULT_KEYS_PER_LEVEL, levels = DEFAULT_LEVELS) {
         if (privateSeed.length !== 32) {
             throw new Error('Private seed must be 32 bytes');
         }
         if (treeKeyDebugEnabled) {
             treeKeyLogger.debug(`[TreeKey] ========== WALLET INIT START ==========`);
-            treeKeyLogger.debug(`[TreeKey] Private seed: ${(0, wots_js_1.hex)(privateSeed)}`);
+            treeKeyLogger.debug(`[TreeKey] Private seed: ${hex(privateSeed)}`);
             treeKeyLogger.debug(`[TreeKey] Levels: ${levels}, Keys per level: ${keysPerLevel}`);
             treeKeyLogger.debug(`[TreeKey] Total capacity: ${Math.pow(keysPerLevel, levels)} signatures`);
         }
@@ -372,7 +366,7 @@ class TreeKey {
         this.root = new TreeKeyNode(privateSeed, keysPerLevel);
         this.publicKey = this.root.getPublicKey();
         if (treeKeyDebugEnabled) {
-            treeKeyLogger.debug(`[TreeKey] Root public key: ${(0, wots_js_1.hex)(this.publicKey)}`);
+            treeKeyLogger.debug(`[TreeKey] Root public key: ${hex(this.publicKey)}`);
             treeKeyLogger.debug(`[TreeKey] ========== WALLET INIT END ==========`);
         }
     }
@@ -380,7 +374,7 @@ class TreeKey {
      * Async factory method for TreeKey with progress reporting
      * Reports progress as the root TreeKeyNode generates its 64 signing keys
      */
-    static async createWithProgress(privateSeed, keysPerLevel = exports.DEFAULT_KEYS_PER_LEVEL, levels = exports.DEFAULT_LEVELS, onProgress) {
+    static async createWithProgress(privateSeed, keysPerLevel = DEFAULT_KEYS_PER_LEVEL, levels = DEFAULT_LEVELS, onProgress) {
         if (privateSeed.length !== 32) {
             throw new Error('Private seed must be 32 bytes');
         }
@@ -599,7 +593,6 @@ class TreeKey {
         return level2Node.getPublicKey();
     }
 }
-exports.TreeKey = TreeKey;
 /**
  * Verify a tree signature against expected public key and data
  *
@@ -608,14 +601,14 @@ exports.TreeKey = TreeKey;
  * - Each intermediate proof must sign the next level's root
  * - Final proof must verify against the actual data
  */
-function verifyTreeSignature(expectedPubkey, data, signature) {
+export function verifyTreeSignature(expectedPubkey, data, signature) {
     const { proofs } = signature;
     if (proofs.length === 0) {
         return false;
     }
     // Import wotsVerify for verification
     // wotsVerify already imported at top of file
-    const paramSet = (0, params_js_1.getParamSet)();
+    const paramSet = getParamSet();
     for (let depth = 0; depth < proofs.length; depth++) {
         const proof = proofs[depth];
         // Compute the root public key from this proof
@@ -640,7 +633,7 @@ function verifyTreeSignature(expectedPubkey, data, signature) {
         }
         // Verify the Winternitz signature
         // Use wotsVerifyDigest since leafPubkey is now a 32-byte digest (not 1088-byte full key)
-        if (!(0, wots_js_1.wotsVerifyDigest)(proof.signature, signedData, proof.leafPubkey, paramSet)) {
+        if (!wotsVerifyDigest(proof.signature, signedData, proof.leafPubkey, paramSet)) {
             return false;
         }
     }
@@ -652,7 +645,7 @@ function verifyTreeSignature(expectedPubkey, data, signature) {
  * Uses Streamable.writeSignature() for byte-exact compatibility
  * with Java's Signature.writeDataStream().
  */
-function serializeTreeSignature(sig) {
+export function serializeTreeSignature(sig) {
     // Convert to Streamable format (adds blockTime to MMRProof)
     const streamableSig = {
         proofs: sig.proofs.map(proof => ({
@@ -665,7 +658,7 @@ function serializeTreeSignature(sig) {
         }))
     };
     // Use canonical serializer for byte-exact Java compatibility
-    return (0, Streamable_js_1.writeSignature)(streamableSig);
+    return writeSignature(streamableSig);
 }
 /**
  * Deserialize a TreeSignature from bytes
@@ -674,33 +667,47 @@ function serializeTreeSignature(sig) {
  * - Number of proofs: MiniNumber format
  * - Each SignatureProof: MiniData(pubkey) + MiniData(signature) + MMRProof
  */
-function deserializeTreeSignature(data) {
+export function deserializeTreeSignature(data) {
     let offset = 0;
     // Read MiniNumber for proof count
     // Format: [scale: 1 byte] [length: 1 byte] [data: N bytes]
     const scale = data[offset];
     const numBytesLen = data[offset + 1];
     offset += 2;
+    if (!Number.isInteger(numBytesLen) || numBytesLen < 0 || numBytesLen > 4) {
+        throw new Error('Malformed signature: invalid proof-count length');
+    }
     // Read the number bytes (big-endian)
     let numProofs = 0;
     for (let i = 0; i < numBytesLen; i++) {
         numProofs = (numProofs << 8) | data[offset + i];
     }
     offset += numBytesLen;
+    if (!Number.isInteger(numProofs) || numProofs < 1 || numProofs > 8) {
+        throw new Error(`Malformed signature: impossible proof count (${numProofs})`);
+    }
     const proofs = [];
     for (let i = 0; i < numProofs; i++) {
         // Leaf pubkey - MiniData format (4-byte length prefix + data)
+        if (offset + 4 > data.length)
+            throw new Error('Malformed signature: truncated leaf pubkey length');
         const pubkeyLen = (data[offset] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3];
         offset += 4;
+        if (pubkeyLen < 0 || offset + pubkeyLen > data.length)
+            throw new Error('Malformed signature: leaf pubkey out of bounds');
         const leafPubkey = data.slice(offset, offset + pubkeyLen);
         offset += pubkeyLen;
         // Signature - MiniData format (4-byte length prefix + data)
+        if (offset + 4 > data.length)
+            throw new Error('Malformed signature: truncated signature length');
         const sigLen = (data[offset] << 24) | (data[offset + 1] << 16) | (data[offset + 2] << 8) | data[offset + 3];
         offset += 4;
+        if (sigLen < 0 || offset + sigLen > data.length)
+            throw new Error('Malformed signature: signature out of bounds');
         const signature = data.slice(offset, offset + sigLen);
         offset += sigLen;
         // MMR proof - returns { proof, blockTime, bytesRead }
-        const { proof: mmrProof, bytesRead: mmrProofLen } = (0, mmr_js_1.parseMMRProofFromHex)(data.slice(offset));
+        const { proof: mmrProof, bytesRead: mmrProofLen } = parseMMRProofFromHex(data.slice(offset));
         offset += mmrProofLen;
         proofs.push({ leafPubkey, signature, mmrProof });
     }
@@ -736,8 +743,8 @@ function deserializeTreeSignature(data) {
  * @param index - Address index (0-63)
  * @returns TreeKey for this spend address with size=64, depth=3
  */
-function createUnifiedChildTreeKey(baseSeed, index) {
-    const childSeed = (0, javaStreamables_js_1.deriveUnifiedChildSeed)(baseSeed, index);
+export function createUnifiedChildTreeKey(baseSeed, index) {
+    const childSeed = deriveUnifiedChildSeed(baseSeed, index);
     return new TreeKey(childSeed, 64, 3);
 }
 /**
@@ -748,8 +755,8 @@ function createUnifiedChildTreeKey(baseSeed, index) {
  * @param onProgress - Optional progress callback
  * @returns Promise resolving to the child TreeKey
  */
-async function createUnifiedChildTreeKeyAsync(baseSeed, index, onProgress) {
-    const childSeed = (0, javaStreamables_js_1.deriveUnifiedChildSeed)(baseSeed, index);
+export async function createUnifiedChildTreeKeyAsync(baseSeed, index, onProgress) {
+    const childSeed = deriveUnifiedChildSeed(baseSeed, index);
     return TreeKey.createWithProgress(childSeed, 64, 3, onProgress);
 }
 /**
@@ -761,8 +768,8 @@ async function createUnifiedChildTreeKeyAsync(baseSeed, index, onProgress) {
  * @param baseSeed - 32-byte wallet base seed (from mnemonic)
  * @returns Root identity TreeKey with size=64, depth=3
  */
-function createUnifiedRootTreeKey(baseSeed) {
-    const rootPrivSeed = (0, javaStreamables_js_1.deriveRootPrivSeed)(baseSeed);
+export function createUnifiedRootTreeKey(baseSeed) {
+    const rootPrivSeed = deriveRootPrivSeed(baseSeed);
     return new TreeKey(rootPrivSeed, 64, 3);
 }
 /**
@@ -773,7 +780,7 @@ function createUnifiedRootTreeKey(baseSeed) {
  * @param index - Address index (0-63)
  * @returns 32-byte address public key (MMR root of child TreeKey)
  */
-function deriveUnifiedAddressPublicKey(baseSeed, index) {
+export function deriveUnifiedAddressPublicKey(baseSeed, index) {
     return createUnifiedChildTreeKey(baseSeed, index).getPublicKey();
 }
 // ---------------------------------------------------------------------------
@@ -788,15 +795,15 @@ function deriveUnifiedAddressPublicKey(baseSeed, index) {
  * New code must use createUnifiedChildTreeKey which applies the unified
  * two-step derivation (root_priv_seed → child_seed_i).
  */
-function createPerAddressTreeKey(baseSeed, addressIndex) {
-    const perAddressSeed = (0, javaStreamables_js_1.derivePerAddressSeed)(baseSeed instanceof Uint8Array ? baseSeed : new Uint8Array(baseSeed), addressIndex);
+export function createPerAddressTreeKey(baseSeed, addressIndex) {
+    const perAddressSeed = derivePerAddressSeed(baseSeed instanceof Uint8Array ? baseSeed : new Uint8Array(baseSeed), addressIndex);
     return new TreeKey(perAddressSeed, 64, 3);
 }
 /**
  * @deprecated Use {@link createUnifiedChildTreeKeyAsync} instead.
  * Preserves legacy per-address seed derivation for backward compatibility.
  */
-async function createPerAddressTreeKeyAsync(baseSeed, addressIndex, onProgress) {
-    const perAddressSeed = (0, javaStreamables_js_1.derivePerAddressSeed)(baseSeed instanceof Uint8Array ? baseSeed : new Uint8Array(baseSeed), addressIndex);
+export async function createPerAddressTreeKeyAsync(baseSeed, addressIndex, onProgress) {
+    const perAddressSeed = derivePerAddressSeed(baseSeed instanceof Uint8Array ? baseSeed : new Uint8Array(baseSeed), addressIndex);
     return TreeKey.createWithProgress(perAddressSeed, 64, 3, onProgress);
 }

package/dist/tx/TransactionLifecycle.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @module TransactionLifecycle
  * Orchestrates the complete transaction flow with lease and watermark management
@@ -9,10 +8,10 @@
  * - WatermarkStore for index tracking
  * - TransactionReceiptStore for history
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionLifecycle = exports.WatermarkExhaustedError = exports.TransactionLifecycleError = void 0;
-const index_js_1 = require("../adapters/index.js");
-class TransactionLifecycleError extends Error {
+import { NoopLogger, NoopMetrics } from '../adapters/index.js';
+export class TransactionLifecycleError extends Error {
+    code;
+    userMessage;
     constructor(message, code, userMessage) {
         super(message);
         this.code = code;
@@ -20,16 +19,22 @@ class TransactionLifecycleError extends Error {
         this.name = 'TransactionLifecycleError';
     }
 }
-exports.TransactionLifecycleError = TransactionLifecycleError;
-class WatermarkExhaustedError extends Error {
+export class WatermarkExhaustedError extends Error {
     constructor() {
         super('All WOTS signatures have been used. Please create a new wallet.');
         this.name = 'WatermarkExhaustedError';
     }
 }
-exports.WatermarkExhaustedError = WatermarkExhaustedError;
-class TransactionLifecycle {
-    constructor(txService, leaseStore, watermarkStore, receiptStore, logger = new index_js_1.NoopLogger(), metrics = new index_js_1.NoopMetrics(), config = {}) {
+export class TransactionLifecycle {
+    txService;
+    leaseStore;
+    watermarkStore;
+    receiptStore;
+    logger;
+    metrics;
+    config;
+    syncWatermark;
+    constructor(txService, leaseStore, watermarkStore, receiptStore, logger = new NoopLogger(), metrics = new NoopMetrics(), config = {}) {
         this.txService = txService;
         this.leaseStore = leaseStore;
         this.watermarkStore = watermarkStore;
@@ -192,4 +197,3 @@ class TransactionLifecycle {
         };
     }
 }
-exports.TransactionLifecycle = TransactionLifecycle;

package/dist/tx/TransactionReceiptStore.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @module TransactionReceiptStore
  * Persistent storage for transaction receipts
@@ -9,15 +8,17 @@
  * - Sync getters read from memory cache (fast, no I/O)
  * - Mutators update memory cache AND persist to storage
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionReceiptStore = void 0;
-const index_js_1 = require("../adapters/index.js");
+import { NoopLogger } from '../adapters/index.js';
 const DEFAULT_STORAGE_KEY = 'totem_transaction_receipts';
 const DEFAULT_MAX_RECEIPTS = 1000;
-class TransactionReceiptStore {
-    constructor(storage, logger = new index_js_1.NoopLogger(), config = {}) {
-        this.receipts = [];
-        this._initialized = false;
+export class TransactionReceiptStore {
+    receipts = [];
+    _initialized = false;
+    storageKey;
+    maxReceipts;
+    storage;
+    logger;
+    constructor(storage, logger = new NoopLogger(), config = {}) {
         this.storage = storage;
         this.logger = logger;
         this.storageKey = config.storageKey ?? DEFAULT_STORAGE_KEY;
@@ -86,4 +87,3 @@ class TransactionReceiptStore {
         return this.receipts.length;
     }
 }
-exports.TransactionReceiptStore = TransactionReceiptStore;

package/dist/tx/TransactionService.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @module TransactionService
  * Handles WOTS signing flow: prepare → sign → finalize
@@ -9,14 +8,16 @@
  * matching Minima Wallet.java exactly. Each address has its own TreeKey derived
  * from the wallet seed. Signing produces 3 proofs (Root→L1→L2→DATA).
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionService = void 0;
-const index_js_1 = require("../adapters/index.js");
-const treekey_js_1 = require("../treekey.js");
-const mmr_js_1 = require("../mmr.js");
-const wots_js_1 = require("../wots.js");
-class TransactionService {
-    constructor(http, config, logger = new index_js_1.NoopLogger(), metrics = new index_js_1.NoopMetrics()) {
+import { NoopLogger, NoopMetrics } from '../adapters/index.js';
+import { createUnifiedChildTreeKey, serializeTreeSignature } from '../treekey.js';
+import { serializeMMRProof } from '../mmr.js';
+import { fromHex } from '../wots.js';
+export class TransactionService {
+    http;
+    logger;
+    metrics;
+    config;
+    constructor(http, config, logger = new NoopLogger(), metrics = new NoopMetrics()) {
         this.http = http;
         this.config = config;
         this.logger = logger;
@@ -100,13 +101,13 @@ class TransactionService {
         if (addressIndex < 0 || addressIndex >= 64) {
             throw new Error(`Invalid addressIndex: ${addressIndex}. Must be 0-63.`);
         }
-        const digestBytes = (0, wots_js_1.fromHex)(digestTx);
+        const digestBytes = fromHex(digestTx);
         if (digestBytes.length !== 32) {
             throw new Error(`Invalid digest length: ${digestBytes.length}, expected 32 bytes`);
         }
         // Derive unified child TreeKey for this address index
         this.logger.debug(`  Deriving unified child TreeKey for index ${addressIndex}...`);
-        const treeKey = (0, treekey_js_1.createUnifiedChildTreeKey)(seed, addressIndex);
+        const treeKey = createUnifiedChildTreeKey(seed, addressIndex);
         // Convert (l1, l2) to Java-compatible 'uses' counter
         // Java's TreeKey.sign() uses baseConversion(uses) to compute path
         const KEYS_PER_LEVEL = 64;
@@ -127,11 +128,11 @@ class TransactionService {
             proofs: treeSignature.proofs.map((proof) => ({
                 leafPubkey: `0x${this.bytesToHex(proof.leafPubkey)}`,
                 signature: `0x${this.bytesToHex(proof.signature)}`,
-                mmrProof: `0x${this.bytesToHex((0, mmr_js_1.serializeMMRProof)(proof.mmrProof))}`,
+                mmrProof: `0x${this.bytesToHex(serializeMMRProof(proof.mmrProof))}`,
             })),
         };
         // Serialize to byte-exact Java-compatible wire format
-        const serializedBytes = (0, treekey_js_1.serializeTreeSignature)(treeSignature);
+        const serializedBytes = serializeTreeSignature(treeSignature);
         const signedHex = `0x${this.bytesToHex(serializedBytes)}`;
         const elapsed = Date.now() - startTime;
         this.metrics.timing('tx_sign_duration_ms', elapsed);
@@ -179,4 +180,3 @@ class TransactionService {
             .join('');
     }
 }
-exports.TransactionService = TransactionService;

package/dist/tx/index.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @module @totemsdk/core/tx
  * Transaction service and lifecycle management
@@ -8,13 +7,6 @@
  * - TransactionLifecycle: Orchestrates flow with lease/watermark stores
  * - TransactionReceiptStore: Persistent transaction history
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionReceiptStore = exports.WatermarkExhaustedError = exports.TransactionLifecycleError = exports.TransactionLifecycle = exports.TransactionService = void 0;
-var TransactionService_js_1 = require("./TransactionService.js");
-Object.defineProperty(exports, "TransactionService", { enumerable: true, get: function () { return TransactionService_js_1.TransactionService; } });
-var TransactionLifecycle_js_1 = require("./TransactionLifecycle.js");
-Object.defineProperty(exports, "TransactionLifecycle", { enumerable: true, get: function () { return TransactionLifecycle_js_1.TransactionLifecycle; } });
-Object.defineProperty(exports, "TransactionLifecycleError", { enumerable: true, get: function () { return TransactionLifecycle_js_1.TransactionLifecycleError; } });
-Object.defineProperty(exports, "WatermarkExhaustedError", { enumerable: true, get: function () { return TransactionLifecycle_js_1.WatermarkExhaustedError; } });
-var TransactionReceiptStore_js_1 = require("./TransactionReceiptStore.js");
-Object.defineProperty(exports, "TransactionReceiptStore", { enumerable: true, get: function () { return TransactionReceiptStore_js_1.TransactionReceiptStore; } });
+export { TransactionService, } from './TransactionService.js';
+export { TransactionLifecycle, TransactionLifecycleError, WatermarkExhaustedError, } from './TransactionLifecycle.js';
+export { TransactionReceiptStore, } from './TransactionReceiptStore.js';