@totemsdk/core 1.2.6 → 1.2.8

package/dist/cjs/legacy.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * Legacy JS implementations — backward compatibility.
+ *
+ * These are the original TypeScript implementations preserved for
+ * environments where WASM is not available. The main entry point
+ * (`@totemsdk/core`) now delegates to WASM by default.
+ *
+ * Import legacy implementations directly:
+ *   import { wotsSign } from '@totemsdk/core/legacy';
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyGenerateWordList = exports.legacyPhraseToSeed = exports.convertWordListToSeed = exports.convertStringToSeed = exports.legacyValidatePhrase = exports.legacyCleanSeedPhrase = exports.WORD_LIST = exports.serializeRealMMRProof = exports.serializeMMRProof = exports.deserializeMMRProof = exports.parseMMRProofFromHex = exports.legacyVerifyMMRProof = exports.calculateProofRoot = exports.createMMRDataParentNode = exports.createMMRDataLeafNode = exports.mmrRootFromSingleLeaf = exports.mmrLeafExact = exports.MMRTree = exports.createPerAddressTreeKeyAsync = exports.createPerAddressTreeKey = exports.legacyDeriveUnifiedAddressPublicKey = exports.legacyCreateUnifiedRootTreeKey = exports.createUnifiedChildTreeKeyAsync = exports.legacyCreateUnifiedChildTreeKey = exports.DEFAULT_LEVELS = exports.DEFAULT_KEYS_PER_LEVEL = exports.getRootPublicKey = exports.deserializeTreeSignature = exports.serializeTreeSignature = exports.legacyVerifyTreeSignature = exports.TreeKeyNode = exports.TreeKey = exports.legacyWotsPublicKeyFromSeed = exports.legacyWotsVerifyDigest = exports.legacyWotsVerify = exports.legacyWotsPkFromSig = exports.wotsSignLegacy = exports.legacyWotsSign = exports.legacyWotsKeypairFromSeed = exports.legacyDerivePKdigest = exports.baseWWithChecksum = exports.toWinternitzDigits = exports.prfChainSeed = exports.h = exports.assert32 = exports.u32be = exports.u16be = exports.fromHex = exports.hex = exports.F = void 0;
+exports.legacyPrecomputeTransactionCoinIDTx = exports.serializeMMREntry = exports.serializeMMRData = exports.serializeMMREntryNumber = exports.createMMREntryNumber = exports.deriveUnifiedChildSeed = exports.legacyDeriveRootPrivSeed = exports.legacyDerivePerAddressSeed = exports.indexToMiniDataBytes = exports.javaHashAllObjects = exports.serializeMiniNumberONE = exports.serializeMiniNumberZERO = exports.hashObject = exports.deriveChildTreeSeedJava = exports.legacyDeriveChainSeedJava = exports.hashAllObjects = exports.serializeMiniData = exports.serializeMiniNumber = exports.writeHashToStream = exports.legacyWriteMiniString = exports.bigIntToByteArray = exports.legacyBytesToHex = exports.legacyHexToBytes = exports.concat = exports.writeMMREntryNumber = exports.writeMiniByte = exports.legacyWriteMiniData = exports.legacyWriteMiniNumber = exports.convertMinimaAddress = exports.makeMinimaAddress = exports.decodeMx = exports.encodeMx = exports.mxToHex = exports.hexToMx = exports.legacyParseMxAddress = exports.legacyMakeMxAddress = exports.decodeMxRadix32Frame = exports.encodeMxRadix32Frame = exports.legacyWotsAddressFromKeypair = exports.scriptFromWotsPk = exports.addressToRoot = exports.scriptToAddress = exports.buildMinimaCoin = exports.createDefaultTransaction = exports.legacyPrecomputeTransactionCoinID = exports.legacyComputeTransactionDigest = exports.legacySerializeTransaction = exports.serializeCoin = exports.parseDecimalToMiniNumber = exports.generateSeedPhrase = void 0;
+exports.legacyValidateChallenge = exports.legacyCreateChallenge = exports.normalizeHex = exports.deriveAddressFromPublicKey = exports.verifyTreeSignatureDetailed = exports.verifySignatureDetailed = exports.verifySignature = exports.legacyConcatBytes = void 0;
+// WOTS — unique exports
+var wots_js_1 = require("./wots.js");
+Object.defineProperty(exports, "F", { enumerable: true, get: function () { return wots_js_1.F; } });
+Object.defineProperty(exports, "hex", { enumerable: true, get: function () { return wots_js_1.hex; } });
+Object.defineProperty(exports, "fromHex", { enumerable: true, get: function () { return wots_js_1.fromHex; } });
+Object.defineProperty(exports, "u16be", { enumerable: true, get: function () { return wots_js_1.u16be; } });
+Object.defineProperty(exports, "u32be", { enumerable: true, get: function () { return wots_js_1.u32be; } });
+Object.defineProperty(exports, "assert32", { enumerable: true, get: function () { return wots_js_1.assert32; } });
+Object.defineProperty(exports, "h", { enumerable: true, get: function () { return wots_js_1.h; } });
+Object.defineProperty(exports, "prfChainSeed", { enumerable: true, get: function () { return wots_js_1.prfChainSeed; } });
+Object.defineProperty(exports, "toWinternitzDigits", { enumerable: true, get: function () { return wots_js_1.toWinternitzDigits; } });
+Object.defineProperty(exports, "baseWWithChecksum", { enumerable: true, get: function () { return wots_js_1.baseWWithChecksum; } });
+Object.defineProperty(exports, "legacyDerivePKdigest", { enumerable: true, get: function () { return wots_js_1.derivePKdigest; } });
+Object.defineProperty(exports, "legacyWotsKeypairFromSeed", { enumerable: true, get: function () { return wots_js_1.wotsKeypairFromSeed; } });
+Object.defineProperty(exports, "legacyWotsSign", { enumerable: true, get: function () { return wots_js_1.wotsSign; } });
+Object.defineProperty(exports, "wotsSignLegacy", { enumerable: true, get: function () { return wots_js_1.wotsSignLegacy; } });
+Object.defineProperty(exports, "legacyWotsPkFromSig", { enumerable: true, get: function () { return wots_js_1.wotsPkFromSig; } });
+Object.defineProperty(exports, "legacyWotsVerify", { enumerable: true, get: function () { return wots_js_1.wotsVerify; } });
+Object.defineProperty(exports, "legacyWotsVerifyDigest", { enumerable: true, get: function () { return wots_js_1.wotsVerifyDigest; } });
+Object.defineProperty(exports, "legacyWotsPublicKeyFromSeed", { enumerable: true, get: function () { return wots_js_1.wotsPublicKeyFromSeed; } });
+// TreeKey — unique exports
+var treekey_js_1 = require("./treekey.js");
+Object.defineProperty(exports, "TreeKey", { enumerable: true, get: function () { return treekey_js_1.TreeKey; } });
+Object.defineProperty(exports, "TreeKeyNode", { enumerable: true, get: function () { return treekey_js_1.TreeKeyNode; } });
+Object.defineProperty(exports, "legacyVerifyTreeSignature", { enumerable: true, get: function () { return treekey_js_1.verifyTreeSignature; } });
+Object.defineProperty(exports, "serializeTreeSignature", { enumerable: true, get: function () { return treekey_js_1.serializeTreeSignature; } });
+Object.defineProperty(exports, "deserializeTreeSignature", { enumerable: true, get: function () { return treekey_js_1.deserializeTreeSignature; } });
+Object.defineProperty(exports, "getRootPublicKey", { enumerable: true, get: function () { return treekey_js_1.getRootPublicKey; } });
+Object.defineProperty(exports, "DEFAULT_KEYS_PER_LEVEL", { enumerable: true, get: function () { return treekey_js_1.DEFAULT_KEYS_PER_LEVEL; } });
+Object.defineProperty(exports, "DEFAULT_LEVELS", { enumerable: true, get: function () { return treekey_js_1.DEFAULT_LEVELS; } });
+Object.defineProperty(exports, "legacyCreateUnifiedChildTreeKey", { enumerable: true, get: function () { return treekey_js_1.createUnifiedChildTreeKey; } });
+Object.defineProperty(exports, "createUnifiedChildTreeKeyAsync", { enumerable: true, get: function () { return treekey_js_1.createUnifiedChildTreeKeyAsync; } });
+Object.defineProperty(exports, "legacyCreateUnifiedRootTreeKey", { enumerable: true, get: function () { return treekey_js_1.createUnifiedRootTreeKey; } });
+Object.defineProperty(exports, "legacyDeriveUnifiedAddressPublicKey", { enumerable: true, get: function () { return treekey_js_1.deriveUnifiedAddressPublicKey; } });
+Object.defineProperty(exports, "createPerAddressTreeKey", { enumerable: true, get: function () { return treekey_js_1.createPerAddressTreeKey; } });
+Object.defineProperty(exports, "createPerAddressTreeKeyAsync", { enumerable: true, get: function () { return treekey_js_1.createPerAddressTreeKeyAsync; } });
+// MMR — unique exports
+var mmr_js_1 = require("./mmr.js");
+Object.defineProperty(exports, "MMRTree", { enumerable: true, get: function () { return mmr_js_1.MMRTree; } });
+Object.defineProperty(exports, "mmrLeafExact", { enumerable: true, get: function () { return mmr_js_1.mmrLeafExact; } });
+Object.defineProperty(exports, "mmrRootFromSingleLeaf", { enumerable: true, get: function () { return mmr_js_1.mmrRootFromSingleLeaf; } });
+Object.defineProperty(exports, "createMMRDataLeafNode", { enumerable: true, get: function () { return mmr_js_1.createMMRDataLeafNode; } });
+Object.defineProperty(exports, "createMMRDataParentNode", { enumerable: true, get: function () { return mmr_js_1.createMMRDataParentNode; } });
+Object.defineProperty(exports, "calculateProofRoot", { enumerable: true, get: function () { return mmr_js_1.calculateProofRoot; } });
+Object.defineProperty(exports, "legacyVerifyMMRProof", { enumerable: true, get: function () { return mmr_js_1.verifyMMRProof; } });
+Object.defineProperty(exports, "parseMMRProofFromHex", { enumerable: true, get: function () { return mmr_js_1.parseMMRProofFromHex; } });
+Object.defineProperty(exports, "deserializeMMRProof", { enumerable: true, get: function () { return mmr_js_1.deserializeMMRProof; } });
+Object.defineProperty(exports, "serializeMMRProof", { enumerable: true, get: function () { return mmr_js_1.serializeMMRProof; } });
+Object.defineProperty(exports, "serializeRealMMRProof", { enumerable: true, get: function () { return mmr_js_1.serializeRealMMRProof; } });
+// BIP39
+var bip39_js_1 = require("./bip39.js");
+Object.defineProperty(exports, "WORD_LIST", { enumerable: true, get: function () { return bip39_js_1.WORD_LIST; } });
+Object.defineProperty(exports, "legacyCleanSeedPhrase", { enumerable: true, get: function () { return bip39_js_1.cleanSeedPhrase; } });
+Object.defineProperty(exports, "legacyValidatePhrase", { enumerable: true, get: function () { return bip39_js_1.validatePhrase; } });
+Object.defineProperty(exports, "convertStringToSeed", { enumerable: true, get: function () { return bip39_js_1.convertStringToSeed; } });
+Object.defineProperty(exports, "convertWordListToSeed", { enumerable: true, get: function () { return bip39_js_1.convertWordListToSeed; } });
+Object.defineProperty(exports, "legacyPhraseToSeed", { enumerable: true, get: function () { return bip39_js_1.phraseToSeed; } });
+Object.defineProperty(exports, "legacyGenerateWordList", { enumerable: true, get: function () { return bip39_js_1.generateWordList; } });
+Object.defineProperty(exports, "generateSeedPhrase", { enumerable: true, get: function () { return bip39_js_1.generateSeedPhrase; } });
+// Transaction
+var transaction_js_1 = require("./transaction.js");
+Object.defineProperty(exports, "parseDecimalToMiniNumber", { enumerable: true, get: function () { return transaction_js_1.parseDecimalToMiniNumber; } });
+Object.defineProperty(exports, "serializeCoin", { enumerable: true, get: function () { return transaction_js_1.serializeCoin; } });
+Object.defineProperty(exports, "legacySerializeTransaction", { enumerable: true, get: function () { return transaction_js_1.serializeTransaction; } });
+Object.defineProperty(exports, "legacyComputeTransactionDigest", { enumerable: true, get: function () { return transaction_js_1.computeTransactionDigest; } });
+Object.defineProperty(exports, "legacyPrecomputeTransactionCoinID", { enumerable: true, get: function () { return transaction_js_1.precomputeTransactionCoinID; } });
+Object.defineProperty(exports, "createDefaultTransaction", { enumerable: true, get: function () { return transaction_js_1.createDefaultTransaction; } });
+Object.defineProperty(exports, "buildMinimaCoin", { enumerable: true, get: function () { return transaction_js_1.buildMinimaCoin; } });
+// Derive
+var derive_js_1 = require("./derive.js");
+Object.defineProperty(exports, "scriptToAddress", { enumerable: true, get: function () { return derive_js_1.scriptToAddress; } });
+Object.defineProperty(exports, "addressToRoot", { enumerable: true, get: function () { return derive_js_1.addressToRoot; } });
+// Script
+var script_js_1 = require("./script.js");
+Object.defineProperty(exports, "scriptFromWotsPk", { enumerable: true, get: function () { return script_js_1.scriptFromWotsPk; } });
+Object.defineProperty(exports, "legacyWotsAddressFromKeypair", { enumerable: true, get: function () { return script_js_1.wotsAddressFromKeypair; } });
+// Minima32
+var minima32_js_1 = require("./minima32.js");
+Object.defineProperty(exports, "encodeMxRadix32Frame", { enumerable: true, get: function () { return minima32_js_1.encodeMxRadix32Frame; } });
+Object.defineProperty(exports, "decodeMxRadix32Frame", { enumerable: true, get: function () { return minima32_js_1.decodeMxRadix32Frame; } });
+Object.defineProperty(exports, "legacyMakeMxAddress", { enumerable: true, get: function () { return minima32_js_1.makeMxAddress; } });
+Object.defineProperty(exports, "legacyParseMxAddress", { enumerable: true, get: function () { return minima32_js_1.parseMxAddress; } });
+Object.defineProperty(exports, "hexToMx", { enumerable: true, get: function () { return minima32_js_1.hexToMx; } });
+Object.defineProperty(exports, "mxToHex", { enumerable: true, get: function () { return minima32_js_1.mxToHex; } });
+Object.defineProperty(exports, "encodeMx", { enumerable: true, get: function () { return minima32_js_1.encodeMx; } });
+Object.defineProperty(exports, "decodeMx", { enumerable: true, get: function () { return minima32_js_1.decodeMx; } });
+Object.defineProperty(exports, "makeMinimaAddress", { enumerable: true, get: function () { return minima32_js_1.makeMinimaAddress; } });
+Object.defineProperty(exports, "convertMinimaAddress", { enumerable: true, get: function () { return minima32_js_1.convertMinimaAddress; } });
+// Streamable
+var Streamable_js_1 = require("./Streamable.js");
+Object.defineProperty(exports, "legacyWriteMiniNumber", { enumerable: true, get: function () { return Streamable_js_1.writeMiniNumber; } });
+Object.defineProperty(exports, "legacyWriteMiniData", { enumerable: true, get: function () { return Streamable_js_1.writeMiniData; } });
+Object.defineProperty(exports, "writeMiniByte", { enumerable: true, get: function () { return Streamable_js_1.writeMiniByte; } });
+Object.defineProperty(exports, "writeMMREntryNumber", { enumerable: true, get: function () { return Streamable_js_1.writeMMREntryNumber; } });
+Object.defineProperty(exports, "concat", { enumerable: true, get: function () { return Streamable_js_1.concat; } });
+Object.defineProperty(exports, "legacyHexToBytes", { enumerable: true, get: function () { return Streamable_js_1.hexToBytes; } });
+Object.defineProperty(exports, "legacyBytesToHex", { enumerable: true, get: function () { return Streamable_js_1.bytesToHex; } });
+Object.defineProperty(exports, "bigIntToByteArray", { enumerable: true, get: function () { return Streamable_js_1.bigIntToByteArray; } });
+Object.defineProperty(exports, "legacyWriteMiniString", { enumerable: true, get: function () { return Streamable_js_1.writeMiniString; } });
+Object.defineProperty(exports, "writeHashToStream", { enumerable: true, get: function () { return Streamable_js_1.writeHashToStream; } });
+// JavaStreamables
+var javaStreamables_js_1 = require("./javaStreamables.js");
+Object.defineProperty(exports, "serializeMiniNumber", { enumerable: true, get: function () { return javaStreamables_js_1.serializeMiniNumber; } });
+Object.defineProperty(exports, "serializeMiniData", { enumerable: true, get: function () { return javaStreamables_js_1.serializeMiniData; } });
+Object.defineProperty(exports, "hashAllObjects", { enumerable: true, get: function () { return javaStreamables_js_1.hashAllObjects; } });
+Object.defineProperty(exports, "legacyDeriveChainSeedJava", { enumerable: true, get: function () { return javaStreamables_js_1.deriveChainSeedJava; } });
+Object.defineProperty(exports, "deriveChildTreeSeedJava", { enumerable: true, get: function () { return javaStreamables_js_1.deriveChildTreeSeedJava; } });
+Object.defineProperty(exports, "hashObject", { enumerable: true, get: function () { return javaStreamables_js_1.hashObject; } });
+Object.defineProperty(exports, "serializeMiniNumberZERO", { enumerable: true, get: function () { return javaStreamables_js_1.serializeMiniNumberZERO; } });
+Object.defineProperty(exports, "serializeMiniNumberONE", { enumerable: true, get: function () { return javaStreamables_js_1.serializeMiniNumberONE; } });
+Object.defineProperty(exports, "javaHashAllObjects", { enumerable: true, get: function () { return javaStreamables_js_1.javaHashAllObjects; } });
+Object.defineProperty(exports, "indexToMiniDataBytes", { enumerable: true, get: function () { return javaStreamables_js_1.indexToMiniDataBytes; } });
+Object.defineProperty(exports, "legacyDerivePerAddressSeed", { enumerable: true, get: function () { return javaStreamables_js_1.derivePerAddressSeed; } });
+Object.defineProperty(exports, "legacyDeriveRootPrivSeed", { enumerable: true, get: function () { return javaStreamables_js_1.deriveRootPrivSeed; } });
+Object.defineProperty(exports, "deriveUnifiedChildSeed", { enumerable: true, get: function () { return javaStreamables_js_1.deriveUnifiedChildSeed; } });
+Object.defineProperty(exports, "createMMREntryNumber", { enumerable: true, get: function () { return javaStreamables_js_1.createMMREntryNumber; } });
+Object.defineProperty(exports, "serializeMMREntryNumber", { enumerable: true, get: function () { return javaStreamables_js_1.serializeMMREntryNumber; } });
+Object.defineProperty(exports, "serializeMMRData", { enumerable: true, get: function () { return javaStreamables_js_1.serializeMMRData; } });
+Object.defineProperty(exports, "serializeMMREntry", { enumerable: true, get: function () { return javaStreamables_js_1.serializeMMREntry; } });
+Object.defineProperty(exports, "legacyPrecomputeTransactionCoinIDTx", { enumerable: true, get: function () { return javaStreamables_js_1.precomputeTransactionCoinID; } });
+// Utils
+var utils_js_1 = require("./utils.js");
+Object.defineProperty(exports, "legacyConcatBytes", { enumerable: true, get: function () { return utils_js_1.concatBytes; } });
+// Params
+__exportStar(require("./params.js"), exports);
+// Verify
+var verify_js_1 = require("./verify.js");
+Object.defineProperty(exports, "verifySignature", { enumerable: true, get: function () { return verify_js_1.verifySignature; } });
+Object.defineProperty(exports, "verifySignatureDetailed", { enumerable: true, get: function () { return verify_js_1.verifySignatureDetailed; } });
+Object.defineProperty(exports, "verifyTreeSignatureDetailed", { enumerable: true, get: function () { return verify_js_1.verifyTreeSignatureDetailed; } });
+Object.defineProperty(exports, "deriveAddressFromPublicKey", { enumerable: true, get: function () { return verify_js_1.deriveAddressFromPublicKey; } });
+Object.defineProperty(exports, "normalizeHex", { enumerable: true, get: function () { return verify_js_1.normalizeHex; } });
+Object.defineProperty(exports, "legacyCreateChallenge", { enumerable: true, get: function () { return verify_js_1.createChallenge; } });
+Object.defineProperty(exports, "legacyValidateChallenge", { enumerable: true, get: function () { return verify_js_1.validateChallenge; } });

package/dist/cjs/minima32.d.ts

@@ -0,0 +1,18 @@
+export declare function encodeMxRadix32Frame(frame: Uint8Array): string;
+export declare function decodeMxRadix32Frame(mx: string): Uint8Array;
+/** Encode raw 32 bytes to Mx address with frame and checksum */
+export declare function makeMxAddress(root32: Uint8Array): string;
+/** Decode Mx address to raw 32 bytes, validating frame and checksum */
+export declare function parseMxAddress(mx: string): Uint8Array;
+/** Make an Mx address from a hex string (legacy API compatibility) */
+export declare function hexToMx(hex: string): string;
+/** Convert an Mx address back to uppercase hex (legacy API compatibility) */
+export declare function mxToHex(mx: string): string;
+/** @deprecated Use makeMxAddress */
+export declare const encodeMx: typeof makeMxAddress;
+/** @deprecated Use parseMxAddress */
+export declare const decodeMx: typeof parseMxAddress;
+/** @deprecated Use hexToMx */
+export declare const makeMinimaAddress: typeof hexToMx;
+/** @deprecated Use mxToHex */
+export declare const convertMinimaAddress: typeof mxToHex;

package/dist/cjs/minima32.js

@@ -0,0 +1,121 @@
+"use strict";
+// Minima "Mx" Base32 — matches org.minima.utils.BaseConverter.encode32/decode32
+// Source behavior: BigInteger radix-32, then i→w, l→y, o→z, uppercased, prefixed with "Mx".
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertMinimaAddress = exports.makeMinimaAddress = exports.decodeMx = exports.encodeMx = void 0;
+exports.encodeMxRadix32Frame = encodeMxRadix32Frame;
+exports.decodeMxRadix32Frame = decodeMxRadix32Frame;
+exports.makeMxAddress = makeMxAddress;
+exports.parseMxAddress = parseMxAddress;
+exports.hexToMx = hexToMx;
+exports.mxToHex = mxToHex;
+function bytesToBigInt(bytes) {
+    let x = 0n;
+    for (const b of bytes)
+        x = (x << 8n) | BigInt(b);
+    return x;
+}
+function bigIntToBytes(x) {
+    if (x === 0n)
+        return new Uint8Array([0]); // not normally hit for framed addresses
+    let hex = x.toString(16);
+    if (hex.length % 2)
+        hex = '0' + hex;
+    const out = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < out.length; i++) {
+        out[i] = parseInt(hex.slice(2 * i, 2 * i + 2), 16);
+    }
+    return out;
+}
+function encodeMxRadix32Frame(frame) {
+    let s = bytesToBigInt(frame).toString(32).toLowerCase();
+    // JAR swaps (avoid ambiguous letters) then uppercase and add prefix
+    s = s.replace(/i/g, 'w').replace(/l/g, 'y').replace(/o/g, 'z');
+    return 'Mx' + s.toUpperCase();
+}
+function decodeMxRadix32Frame(mx) {
+    let s = mx.trim().toLowerCase();
+    if (s.startsWith('mx'))
+        s = s.slice(2);
+    s = s.replace(/w/g, 'i').replace(/y/g, 'l').replace(/z/g, 'o'); // reverse swaps
+    // parse base-32 by hand (radix 32)
+    let x = 0n;
+    for (const ch of s) {
+        const v = parseInt(ch, 32);
+        if (Number.isNaN(v))
+            throw new Error(`Invalid base32 character: ${ch}`);
+        x = x * 32n + BigInt(v);
+    }
+    return bigIntToBytes(x);
+}
+const wasm_sync_js_1 = require("./wasm-sync.js");
+/** Encode raw 32 bytes to Mx address with frame and checksum */
+function makeMxAddress(root32) {
+    if (root32.length !== 32) {
+        throw new Error(`Expected 32 bytes, got ${root32.length}`);
+    }
+    // Build frame: [sentinel(1), length(2), data(32), checksum(4)]
+    const frame = new Uint8Array(1 + 2 + 32 + 4);
+    frame[0] = 0x01; // Sentinel byte
+    frame[1] = 0; // Length high byte
+    frame[2] = 32; // Length low byte
+    frame.set(root32, 3);
+    // Calculate checksum of the raw 32 bytes
+    const chk = (0, wasm_sync_js_1.sha3_256)(root32);
+    frame.set(chk.slice(0, 4), 35);
+    return encodeMxRadix32Frame(frame);
+}
+/** Decode Mx address to raw 32 bytes, validating frame and checksum */
+function parseMxAddress(mx) {
+    const frame = decodeMxRadix32Frame(mx);
+    // Validate frame structure
+    if (frame[0] !== 0x01) {
+        throw new Error(`Invalid sentinel byte: ${frame[0]}`);
+    }
+    const len = (frame[1] << 8) | frame[2];
+    if (len !== 32) {
+        throw new Error(`Invalid length: ${len}, expected 32`);
+    }
+    const root32 = frame.slice(3, 35);
+    const checksum = frame.slice(35, 39);
+    // Validate checksum
+    const expectedChk = (0, wasm_sync_js_1.sha3_256)(root32);
+    const expected = expectedChk.slice(0, 4);
+    for (let i = 0; i < 4; i++) {
+        if (checksum[i] !== expected[i]) {
+            throw new Error('Invalid checksum');
+        }
+    }
+    return root32;
+}
+// Aliases for backward compatibility
+function hexToBytes(hex) {
+    let h = hex.startsWith("0x") ? hex.slice(2) : hex;
+    if (h.length % 2)
+        h = "0" + h;
+    const out = new Uint8Array(h.length / 2);
+    for (let i = 0; i < out.length; i++)
+        out[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
+    return out;
+}
+function bytesToHex(bytes) {
+    return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('').toUpperCase();
+}
+/** Make an Mx address from a hex string (legacy API compatibility) */
+function hexToMx(hex) {
+    const bytes = hexToBytes(hex);
+    return makeMxAddress(bytes);
+}
+/** Convert an Mx address back to uppercase hex (legacy API compatibility) */
+function mxToHex(mx) {
+    const bytes = parseMxAddress(mx);
+    return bytesToHex(bytes);
+}
+/** @deprecated Use makeMxAddress */
+exports.encodeMx = makeMxAddress;
+/** @deprecated Use parseMxAddress */
+exports.decodeMx = parseMxAddress;
+/** @deprecated Use hexToMx */
+exports.makeMinimaAddress = hexToMx;
+/** @deprecated Use mxToHex */
+exports.convertMinimaAddress = mxToHex;

package/dist/cjs/minimaWireSerializer.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Minima Wire Format Serializer
+ *
+ * High-level serialization for hex-string bundles (used in service.ts).
+ * Primitive serialization functions are imported from Streamable.ts.
+ *
+ * @deprecated (2026-01) - Most functions deprecated. Use Streamable.ts directly for
+ * byte-level serialization. This file remains for HierarchicalWitnessBundle hex APIs.
+ */
+import { hexToBytes, bytesToHex, writeMiniNumber, writeMiniData, type Bytes } from './Streamable.js';
+export { writeMiniNumber as serializeMiniNumber, writeMiniData as serializeMiniData };
+export { hexToBytes as fromHex, bytesToHex as toHex };
+export type { Bytes };
+/**
+ * SignatureProof with hex strings (for bundle transport)
+ */
+export interface SignatureProofHex {
+    leafPubkey: string;
+    signature: string;
+    mmrProof: string;
+}
+/**
+ * HierarchicalWitnessBundle - used by service.ts for transaction signing
+ * All fields are hex strings for JSON transport
+ */
+export interface HierarchicalWitnessBundle {
+    addressIndex: number;
+    l1: number;
+    l2: number;
+    rootPublicKey: string;
+    proofs: SignatureProofHex[];
+}
+/**
+ * Serialize hierarchical witness bundle to Minima wire format
+ *
+ * This converts the HierarchicalWitnessBundle (with hex strings) to
+ * the proper Witness signature format matching Witness.java → Signature.java hierarchy.
+ *
+ * CRITICAL FIX (2026-01): Must use double-nesting to match Java format:
+ *   - Witness.writeDataStream writes: [signatureCount][Signature[0].writeDataStream()]...
+ *   - Signature.writeDataStream writes: [proofCount][SignatureProof[0]]...
+ *
+ * So the final format is:
+ *   [1] = signatureCount (we have 1 Signature object in Witness)
+ *   [N] = proofCount inside that Signature (2 for address-based TreeKey)
+ *   [SignatureProof[0]]
+ *   [SignatureProof[1]]
+ *
+ * IMPORTANT: Uses pre-serialized MMR proof bytes directly to avoid
+ * double-serialization (deserialize then re-serialize).
+ */
+export declare function serializeHierarchicalWitness(bundle: HierarchicalWitnessBundle): Bytes;
+/**
+ * @deprecated (2026-01) This function's output is NOT used in the main Totem transaction flow.
+ * MinimaTransactionBuilder.serializeWitness in the extension handles actual witness serialization.
+ * Kept for API compatibility and potential future direct SDK usage.
+ *
+ * Serialize hierarchical witness bundle to hex string for transport
+ */
+export declare function serializeHierarchicalWitnessToHex(bundle: HierarchicalWitnessBundle): string;

package/dist/cjs/minimaWireSerializer.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Minima Wire Format Serializer
+ *
+ * High-level serialization for hex-string bundles (used in service.ts).
+ * Primitive serialization functions are imported from Streamable.ts.
+ *
+ * @deprecated (2026-01) - Most functions deprecated. Use Streamable.ts directly for
+ * byte-level serialization. This file remains for HierarchicalWitnessBundle hex APIs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHex = exports.fromHex = exports.serializeMiniData = exports.serializeMiniNumber = void 0;
+exports.serializeHierarchicalWitness = serializeHierarchicalWitness;
+exports.serializeHierarchicalWitnessToHex = serializeHierarchicalWitnessToHex;
+const Streamable_js_1 = require("./Streamable.js");
+Object.defineProperty(exports, "fromHex", { enumerable: true, get: function () { return Streamable_js_1.hexToBytes; } });
+Object.defineProperty(exports, "toHex", { enumerable: true, get: function () { return Streamable_js_1.bytesToHex; } });
+Object.defineProperty(exports, "serializeMiniNumber", { enumerable: true, get: function () { return Streamable_js_1.writeMiniNumber; } });
+Object.defineProperty(exports, "serializeMiniData", { enumerable: true, get: function () { return Streamable_js_1.writeMiniData; } });
+/**
+ * Serialize a SignatureProof from pre-serialized byte arrays
+ *
+ * This avoids double-serialization by passing MMR proof bytes through directly.
+ * Format matches SignatureProof.writeDataStream():
+ *   1. MiniData (publicKey) - 4-byte length + bytes
+ *   2. MiniData (signature) - 4-byte length + bytes
+ *   3. MMRProof bytes (pre-serialized)
+ */
+function serializeSignatureProofFromBytes(publicKey, signature, mmrProofBytes) {
+    return (0, Streamable_js_1.concat)((0, Streamable_js_1.writeMiniData)(publicKey), (0, Streamable_js_1.writeMiniData)(signature), mmrProofBytes // Already serialized - pass through directly
+    );
+}
+/**
+ * Serialize hierarchical witness bundle to Minima wire format
+ *
+ * This converts the HierarchicalWitnessBundle (with hex strings) to
+ * the proper Witness signature format matching Witness.java → Signature.java hierarchy.
+ *
+ * CRITICAL FIX (2026-01): Must use double-nesting to match Java format:
+ *   - Witness.writeDataStream writes: [signatureCount][Signature[0].writeDataStream()]...
+ *   - Signature.writeDataStream writes: [proofCount][SignatureProof[0]]...
+ *
+ * So the final format is:
+ *   [1] = signatureCount (we have 1 Signature object in Witness)
+ *   [N] = proofCount inside that Signature (2 for address-based TreeKey)
+ *   [SignatureProof[0]]
+ *   [SignatureProof[1]]
+ *
+ * IMPORTANT: Uses pre-serialized MMR proof bytes directly to avoid
+ * double-serialization (deserialize then re-serialize).
+ */
+function serializeHierarchicalWitness(bundle) {
+    const parts = [];
+    // Witness.signatureCount (MiniNumber) - 1 Signature object containing N proofs
+    parts.push((0, Streamable_js_1.writeMiniNumber)(1n, 0));
+    // Signature.proofCount (MiniNumber) - N SignatureProofs inside the Signature
+    parts.push((0, Streamable_js_1.writeMiniNumber)(BigInt(bundle.proofs.length), 0));
+    for (const proofHex of bundle.proofs) {
+        const publicKey = (0, Streamable_js_1.hexToBytes)(proofHex.leafPubkey);
+        const signature = (0, Streamable_js_1.hexToBytes)(proofHex.signature);
+        const mmrProofBytes = (0, Streamable_js_1.hexToBytes)(proofHex.mmrProof); // Already serialized
+        // Serialize SignatureProof with pre-serialized MMR bytes
+        parts.push(serializeSignatureProofFromBytes(publicKey, signature, mmrProofBytes));
+    }
+    return (0, Streamable_js_1.concat)(...parts);
+}
+/**
+ * @deprecated (2026-01) This function's output is NOT used in the main Totem transaction flow.
+ * MinimaTransactionBuilder.serializeWitness in the extension handles actual witness serialization.
+ * Kept for API compatibility and potential future direct SDK usage.
+ *
+ * Serialize hierarchical witness bundle to hex string for transport
+ */
+function serializeHierarchicalWitnessToHex(bundle) {
+    const bytes = serializeHierarchicalWitness(bundle);
+    return (0, Streamable_js_1.bytesToHex)(bytes);
+}

package/dist/cjs/mmr.d.ts

@@ -0,0 +1,157 @@
+export declare function serializeMMRProof(proof: {
+    chunks: Array<{
+        isLeft: boolean;
+        mmrData: {
+            data: Bytes;
+            value: bigint;
+        };
+    }>;
+}, blockTime?: bigint): Bytes;
+export declare const serializeRealMMRProof: typeof serializeMMRProof;
+export type Bytes = Uint8Array;
+/**
+ * Byte-exact one-leaf MMR leaf used by Minima Address.java path:
+ *   sha3( MiniNumber.ZERO || MiniString(script) || MiniNumber.ZERO )
+ */
+export declare function mmrLeafExact(script: string): Bytes;
+/** In a single-leaf MMR the root equals the leaf commitment. */
+export declare function mmrRootFromSingleLeaf(script: string): Bytes;
+/**
+ * MMRData structure matching Minima's MMRData.java
+ * Contains hash and value (for sum tree functionality)
+ */
+export interface MMRData {
+    data: Bytes;
+    value: bigint;
+}
+/**
+ * MMREntry structure matching Minima's MMREntry.java
+ * Represents a node in the MMR at a specific row and position
+ */
+export interface MMREntry {
+    row: number;
+    entryNumber: bigint;
+    mmrData: MMRData;
+}
+/**
+ * MMRProofChunk - one step in the proof path
+ * Matches Minima's MMRProof structure
+ */
+export interface MMRProofChunk {
+    isLeft: boolean;
+    mmrData: MMRData;
+}
+/**
+ * MMRProof structure matching Minima's MMRProof.java
+ * Contains proof chunks to verify leaf membership in the tree
+ */
+export interface MMRProof {
+    chunks: MMRProofChunk[];
+}
+/**
+ * Create MMRData leaf node matching Minima's MMRData.CreateMMRDataLeafNode
+ *
+ * From MMRData.java:
+ *   MiniData hash = Crypto.getInstance().hashAllObjects(MiniNumber.ZERO, zData, zSumValue);
+ *
+ * CRITICAL: Crypto.hashAllObjects uses writeDataStream for Streamables:
+ * - MiniNumber: scale + len + data (see serializeMiniNumber)
+ * - MiniData: 4-byte length + data (see serializeMiniData)
+ *
+ * For TreeKeyNode, zData is the Winternitz public key (MiniData) and zSumValue is ZERO
+ *
+ * Serialization order:
+ * 1. MiniNumber.ZERO: [0x00, 0x01, 0x00]
+ * 2. MiniData (pubkey): [4-byte length] + [bytes] (writeDataStream, NOT writeHashToStream)
+ * 3. MiniNumber.ZERO: [0x00, 0x01, 0x00]
+ */
+export declare function createMMRDataLeafNode(pubkey: Bytes, sumValue?: bigint): MMRData;
+/**
+ * Create MMRData parent node matching Minima's MMRData.CreateMMRDataParentNode
+ *
+ * From MMRData.java:
+ *   MiniNumber sumvalue = zLeft.getValue().add(zRight.getValue());
+ *   MiniData combinedhash = Crypto.getInstance().hashAllObjects(
+ *     MiniNumber.ONE, zLeft.getData(), zRight.getData(), sumvalue);
+ *
+ * CRITICAL: The getData() returns MiniData (the hash), which is serialized
+ * with writeDataStream (4-byte length) in hashAllObjects.
+ *
+ * Serialization order:
+ * 1. MiniNumber.ONE: [0x00, 0x01, 0x01]
+ * 2. MiniData (left.data): [4-byte length] + [bytes]
+ * 3. MiniData (right.data): [4-byte length] + [bytes]
+ * 4. MiniNumber (sumvalue): serialized MiniNumber
+ */
+export declare function createMMRDataParentNode(left: MMRData, right: MMRData): MMRData;
+/**
+ * Simple MMR Tree for TreeKeyNode
+ * Builds a perfect binary tree from N entries (N must be power of 2 for simplicity)
+ *
+ * This matches TreeKeyNode.java which always uses 64 leaves (2^6)
+ */
+export declare class MMRTree {
+    private entries;
+    private leafCount;
+    private maxRow;
+    private getKey;
+    private setEntry;
+    private getEntry;
+    /**
+     * Add a leaf entry to the MMR
+     * Matches MMR.java addEntry() but simplified for power-of-2 trees
+     */
+    addLeaf(data: MMRData): MMREntry;
+    /**
+     * Build tree from array of Winternitz public keys
+     * Used by TreeKeyNode to compute wallet public key
+     */
+    static fromPublicKeys(pubkeys: Bytes[]): MMRTree;
+    /**
+     * Get the root of the tree
+     * For a perfect binary tree with N leaves, root is at row log2(N), entry 0
+     */
+    getRoot(): MMRData | null;
+    /**
+     * Get proof for a leaf at given index
+     * Matches MMR.java getProofToPeak()
+     */
+    getProof(leafIndex: number): MMRProof;
+    /**
+     * Get the leaf MMRData at a specific index
+     */
+    getLeaf(index: number): MMRData | null;
+}
+/**
+ * Calculate root from leaf data and proof
+ * Matches SignatureProof.getRootPublicKey() in Java
+ *
+ * From SignatureProof.java:
+ *   MMRData pubentry = MMRData.CreateMMRDataLeafNode(mPublicKey, MiniNumber.ZERO);
+ *   return mProof.calculateProof(pubentry).getData();
+ */
+export declare function calculateProofRoot(leafData: MMRData, proof: MMRProof): Bytes;
+/**
+ * Verify a proof: check that leaf + proof computes to expected root
+ */
+export declare function verifyMMRProof(leafPubkey: Bytes, proof: MMRProof, expectedRoot: Bytes): boolean;
+/**
+ * Deserialize MMRProof from bytes matching Minima's MMRProof.readDataStream()
+ *
+ * Format:
+ *   1. blockTime (MiniNumber)
+ *   2. chain length (MiniNumber)
+ *   3. Each chunk: isLeft (1 byte) + MMRData (hash with 4-byte length prefix + value MiniNumber)
+ *
+ * CRITICAL: Java MMRData.readDataStream uses mData.readHashFromStream() which reads
+ * a 4-byte big-endian length prefix followed by the hash bytes.
+ *
+ * @returns { proof: MMRProof, blockTime: bigint }
+ */
+export declare function parseMMRProofFromHex(data: Bytes): {
+    proof: MMRProof;
+    blockTime: bigint;
+    bytesRead: number;
+};
+/** @deprecated Use parseMMRProofFromHex */
+export declare const deserializeMMRProof: typeof parseMMRProofFromHex;