@totemsdk/core 1.0.9 → 1.0.10

package/dist/minima32.js

@@ -1,5 +1,14 @@
+"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)
@@ -18,13 +27,13 @@ function bigIntToBytes(x) {
     }
     return out;
 }
-export function encodeMxRadix32Frame(frame) {
+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();
 }
-export function decodeMxRadix32Frame(mx) {
+function decodeMxRadix32Frame(mx) {
     let s = mx.trim().toLowerCase();
     if (s.startsWith('mx'))
         s = s.slice(2);
@@ -39,9 +48,9 @@ export function decodeMxRadix32Frame(mx) {
     }
     return bigIntToBytes(x);
 }
-import { sha3_256 as nobleSha3 } from '@noble/hashes/sha3.js';
+const sha3_js_1 = require("@noble/hashes/sha3.js");
 /** Encode raw 32 bytes to Mx address with frame and checksum */
-export function makeMxAddress(root32) {
+function makeMxAddress(root32) {
     if (root32.length !== 32) {
         throw new Error(`Expected 32 bytes, got ${root32.length}`);
     }
@@ -52,12 +61,12 @@ export function makeMxAddress(root32) {
     frame[2] = 32; // Length low byte
     frame.set(root32, 3);
     // Calculate checksum of the raw 32 bytes
-    const chk = nobleSha3(root32);
+    const chk = (0, sha3_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 */
-export function parseMxAddress(mx) {
+function parseMxAddress(mx) {
     const frame = decodeMxRadix32Frame(mx);
     // Validate frame structure
     if (frame[0] !== 0x01) {
@@ -70,7 +79,7 @@ export function parseMxAddress(mx) {
     const root32 = frame.slice(3, 35);
     const checksum = frame.slice(35, 39);
     // Validate checksum
-    const expectedChk = nobleSha3(root32);
+    const expectedChk = (0, sha3_js_1.sha3_256)(root32);
     const expected = expectedChk.slice(0, 4);
     for (let i = 0; i < 4; i++) {
         if (checksum[i] !== expected[i]) {
@@ -93,20 +102,20 @@ 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) */
-export function hexToMx(hex) {
+function hexToMx(hex) {
     const bytes = hexToBytes(hex);
     return makeMxAddress(bytes);
 }
 /** Convert an Mx address back to uppercase hex (legacy API compatibility) */
-export function mxToHex(mx) {
+function mxToHex(mx) {
     const bytes = parseMxAddress(mx);
     return bytesToHex(bytes);
 }
 /** @deprecated Use makeMxAddress */
-export const encodeMx = makeMxAddress;
+exports.encodeMx = makeMxAddress;
 /** @deprecated Use parseMxAddress */
-export const decodeMx = parseMxAddress;
+exports.decodeMx = parseMxAddress;
 /** @deprecated Use hexToMx */
-export const makeMinimaAddress = hexToMx;
+exports.makeMinimaAddress = hexToMx;
 /** @deprecated Use mxToHex */
-export const convertMinimaAddress = mxToHex;
+exports.convertMinimaAddress = mxToHex;

package/dist/minimaWireSerializer.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Minima Wire Format Serializer
  *
@@ -7,10 +8,15 @@
  * @deprecated (2026-01) - Most functions deprecated. Use Streamable.ts directly for
  * byte-level serialization. This file remains for HierarchicalWitnessBundle hex APIs.
  */
-import { concat, hexToBytes, bytesToHex, writeMiniNumber, writeMiniData, } from './Streamable.js';
-// Re-export primitives for backward compatibility
-export { writeMiniNumber as serializeMiniNumber, writeMiniData as serializeMiniData };
-export { hexToBytes as fromHex, bytesToHex as toHex };
+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
  *
@@ -21,7 +27,7 @@ export { hexToBytes as fromHex, bytesToHex as toHex };
  *   3. MMRProof bytes (pre-serialized)
  */
 function serializeSignatureProofFromBytes(publicKey, signature, mmrProofBytes) {
-    return concat(writeMiniData(publicKey), writeMiniData(signature), mmrProofBytes // Already serialized - pass through directly
+    return (0, Streamable_js_1.concat)((0, Streamable_js_1.writeMiniData)(publicKey), (0, Streamable_js_1.writeMiniData)(signature), mmrProofBytes // Already serialized - pass through directly
     );
 }
 /**
@@ -43,20 +49,20 @@ function serializeSignatureProofFromBytes(publicKey, signature, mmrProofBytes) {
  * IMPORTANT: Uses pre-serialized MMR proof bytes directly to avoid
  * double-serialization (deserialize then re-serialize).
  */
-export function serializeHierarchicalWitness(bundle) {
+function serializeHierarchicalWitness(bundle) {
     const parts = [];
     // Witness.signatureCount (MiniNumber) - 1 Signature object containing N proofs
-    parts.push(writeMiniNumber(1n));
+    parts.push((0, Streamable_js_1.writeMiniNumber)(1n));
     // Signature.proofCount (MiniNumber) - N SignatureProofs inside the Signature
-    parts.push(writeMiniNumber(BigInt(bundle.proofs.length)));
+    parts.push((0, Streamable_js_1.writeMiniNumber)(BigInt(bundle.proofs.length)));
     for (const proofHex of bundle.proofs) {
-        const publicKey = hexToBytes(proofHex.leafPubkey);
-        const signature = hexToBytes(proofHex.signature);
-        const mmrProofBytes = hexToBytes(proofHex.mmrProof); // Already serialized
+        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 concat(...parts);
+    return (0, Streamable_js_1.concat)(...parts);
 }
 /**
  * @deprecated (2026-01) This function's output is NOT used in the main Totem transaction flow.
@@ -65,7 +71,7 @@ export function serializeHierarchicalWitness(bundle) {
  *
  * Serialize hierarchical witness bundle to hex string for transport
  */
-export function serializeHierarchicalWitnessToHex(bundle) {
+function serializeHierarchicalWitnessToHex(bundle) {
     const bytes = serializeHierarchicalWitness(bundle);
-    return bytesToHex(bytes);
+    return (0, Streamable_js_1.bytesToHex)(bytes);
 }

package/dist/mmr.js

@@ -1,12 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeMMRProof = exports.MMRTree = exports.serializeRealMMRProof = void 0;
+exports.serializeMMRProof = serializeMMRProof;
+exports.mmrLeafExact = mmrLeafExact;
+exports.mmrRootFromSingleLeaf = mmrRootFromSingleLeaf;
+exports.createMMRDataLeafNode = createMMRDataLeafNode;
+exports.createMMRDataParentNode = createMMRDataParentNode;
+exports.calculateProofRoot = calculateProofRoot;
+exports.verifyMMRProof = verifyMMRProof;
+exports.parseMMRProofFromHex = parseMMRProofFromHex;
 // packages/totem-sdk/packages/core/src/mmr.ts
 // Full MMR implementation matching Minima's MMR.java, MMRData.java, and TreeKeyNode.java
-import { sha3_256 as nobleSha3 } from '@noble/hashes/sha3.js';
-import { serializeMiniNumber, serializeMiniData, javaHashAllObjects } from "./javaStreamables.js";
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+const javaStreamables_js_1 = require("./javaStreamables.js");
 // Import canonical wire serialization from Streamable.ts (single source of truth)
-import { writeMMRProof } from "./Streamable.js";
+const Streamable_js_1 = require("./Streamable.js");
 // Re-export for API compatibility (existing code imports from mmr.ts)
 // Using a wrapper function for better compatibility with dynamic imports
-export function serializeMMRProof(proof, blockTime = 0n) {
+function serializeMMRProof(proof, blockTime = 0n) {
     // Convert to Streamable format and serialize
     const streamableProof = {
         blockTime: blockTime,
@@ -15,12 +26,12 @@ export function serializeMMRProof(proof, blockTime = 0n) {
             mmrData: { data: c.mmrData.data, value: c.mmrData.value }
         }))
     };
-    return writeMMRProof(streamableProof);
+    return (0, Streamable_js_1.writeMMRProof)(streamableProof);
 }
-export const serializeRealMMRProof = serializeMMRProof;
+exports.serializeRealMMRProof = serializeMMRProof;
 /** SHA3-256 helper returning 32 bytes */
 function sha3(data) {
-    return nobleSha3(data);
+    return (0, sha3_js_1.sha3_256)(data);
 }
 /** concat utility */
 function concat(...parts) {
@@ -59,14 +70,14 @@ function encodeMiniStringUTF8(text) {
  * Byte-exact one-leaf MMR leaf used by Minima Address.java path:
  *   sha3( MiniNumber.ZERO || MiniString(script) || MiniNumber.ZERO )
  */
-export function mmrLeafExact(script) {
+function mmrLeafExact(script) {
     const zero = encodeMiniNumberZERO();
     const mstr = encodeMiniStringUTF8(script);
     const all = concat(zero, mstr, zero);
     return sha3(all); // 32-byte leaf hash
 }
 /** In a single-leaf MMR the root equals the leaf commitment. */
-export function mmrRootFromSingleLeaf(script) {
+function mmrRootFromSingleLeaf(script) {
     return mmrLeafExact(script);
 }
 /**
@@ -86,20 +97,20 @@ export function mmrRootFromSingleLeaf(script) {
  * 2. MiniData (pubkey): [4-byte length] + [bytes] (writeDataStream, NOT writeHashToStream)
  * 3. MiniNumber.ZERO: [0x00, 0x01, 0x00]
  */
-export function createMMRDataLeafNode(pubkey, sumValue = 0n) {
+function createMMRDataLeafNode(pubkey, sumValue = 0n) {
     // Use cached ZERO serialization for efficiency
     const zero = new Uint8Array([0x00, 0x01, 0x00]); // MiniNumber.ZERO
     // IMPORTANT: hashAllObjects uses writeDataStream which is 4-byte length prefixed
-    const pubkeySerialized = serializeMiniData(pubkey);
+    const pubkeySerialized = (0, javaStreamables_js_1.serializeMiniData)(pubkey);
     // For sumValue, serialize as MiniNumber
     let sumSerialized;
     if (sumValue === 0n) {
         sumSerialized = new Uint8Array([0x00, 0x01, 0x00]); // MiniNumber.ZERO
     }
     else {
-        sumSerialized = serializeMiniNumber(Number(sumValue));
+        sumSerialized = (0, javaStreamables_js_1.serializeMiniNumber)(Number(sumValue));
     }
-    const hash = javaHashAllObjects(zero, pubkeySerialized, sumSerialized);
+    const hash = (0, javaStreamables_js_1.javaHashAllObjects)(zero, pubkeySerialized, sumSerialized);
     return { data: hash, value: sumValue };
 }
 /**
@@ -119,22 +130,22 @@ export function createMMRDataLeafNode(pubkey, sumValue = 0n) {
  * 3. MiniData (right.data): [4-byte length] + [bytes]
  * 4. MiniNumber (sumvalue): serialized MiniNumber
  */
-export function createMMRDataParentNode(left, right) {
+function createMMRDataParentNode(left, right) {
     const sumValue = left.value + right.value;
     // MiniNumber.ONE: [0x00, 0x01, 0x01]
     const one = new Uint8Array([0x00, 0x01, 0x01]);
     // Serialize left and right data as MiniData (4-byte length-prefixed)
-    const leftDataSerialized = serializeMiniData(left.data);
-    const rightDataSerialized = serializeMiniData(right.data);
+    const leftDataSerialized = (0, javaStreamables_js_1.serializeMiniData)(left.data);
+    const rightDataSerialized = (0, javaStreamables_js_1.serializeMiniData)(right.data);
     // Serialize sum value
     let sumSerialized;
     if (sumValue === 0n) {
         sumSerialized = new Uint8Array([0x00, 0x01, 0x00]); // MiniNumber.ZERO
     }
     else {
-        sumSerialized = serializeMiniNumber(Number(sumValue));
+        sumSerialized = (0, javaStreamables_js_1.serializeMiniNumber)(Number(sumValue));
     }
-    const hash = javaHashAllObjects(one, leftDataSerialized, rightDataSerialized, sumSerialized);
+    const hash = (0, javaStreamables_js_1.javaHashAllObjects)(one, leftDataSerialized, rightDataSerialized, sumSerialized);
     return { data: hash, value: sumValue };
 }
 /**
@@ -143,7 +154,7 @@ export function createMMRDataParentNode(left, right) {
  *
  * This matches TreeKeyNode.java which always uses 64 leaves (2^6)
  */
-export class MMRTree {
+class MMRTree {
     constructor() {
         this.entries = new Map();
         this.leafCount = 0;
@@ -241,6 +252,7 @@ export class MMRTree {
         return entry?.mmrData || null;
     }
 }
+exports.MMRTree = MMRTree;
 /**
  * Calculate root from leaf data and proof
  * Matches SignatureProof.getRootPublicKey() in Java
@@ -249,7 +261,7 @@ export class MMRTree {
  *   MMRData pubentry = MMRData.CreateMMRDataLeafNode(mPublicKey, MiniNumber.ZERO);
  *   return mProof.calculateProof(pubentry).getData();
  */
-export function calculateProofRoot(leafData, proof) {
+function calculateProofRoot(leafData, proof) {
     let current = leafData;
     for (const chunk of proof.chunks) {
         if (chunk.isLeft) {
@@ -266,7 +278,7 @@ export function calculateProofRoot(leafData, proof) {
 /**
  * Verify a proof: check that leaf + proof computes to expected root
  */
-export function verifyMMRProof(leafPubkey, proof, expectedRoot) {
+function verifyMMRProof(leafPubkey, proof, expectedRoot) {
     const leafData = createMMRDataLeafNode(leafPubkey, 0n);
     const computedRoot = calculateProofRoot(leafData, proof);
     if (computedRoot.length !== expectedRoot.length)
@@ -292,7 +304,7 @@ export function verifyMMRProof(leafPubkey, proof, expectedRoot) {
  *
  * @returns { proof: MMRProof, blockTime: bigint }
  */
-export function parseMMRProofFromHex(data) {
+function parseMMRProofFromHex(data) {
     let offset = 0;
     // Read blockTime as MiniNumber
     const { value: blockTime, bytesRead: btRead } = readMiniNumber(data, offset);
@@ -339,4 +351,4 @@ function readMiniNumber(data, offset) {
     return { value, bytesRead: 2 + length };
 }
 /** @deprecated Use parseMMRProofFromHex */
-export const deserializeMMRProof = parseMMRProofFromHex;
+exports.deserializeMMRProof = parseMMRProofFromHex;

package/dist/mx.js

@@ -1 +1,10 @@
-export { hexToMx, mxToHex, makeMinimaAddress, convertMinimaAddress, encodeMx, decodeMx } from './minima32.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeMx = exports.encodeMx = exports.convertMinimaAddress = exports.makeMinimaAddress = exports.mxToHex = exports.hexToMx = void 0;
+var minima32_js_1 = require("./minima32.js");
+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, "makeMinimaAddress", { enumerable: true, get: function () { return minima32_js_1.makeMinimaAddress; } });
+Object.defineProperty(exports, "convertMinimaAddress", { enumerable: true, get: function () { return minima32_js_1.convertMinimaAddress; } });
+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; } });

package/dist/params.js

@@ -1,4 +1,8 @@
-export const WOTS_MINIMA = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WOTS_V2_SPEC = exports.WOTS_V1_DEV = exports.WOTS_MINIMA = void 0;
+exports.getParamSet = getParamSet;
+exports.WOTS_MINIMA = {
     name: 'minima',
     n: 256,
     w: 8,
@@ -9,8 +13,8 @@ export const WOTS_MINIMA = {
     maxDigit: 255,
 };
 // Legacy aliases for backwards compatibility during migration
-export const WOTS_V1_DEV = WOTS_MINIMA;
-export const WOTS_V2_SPEC = WOTS_MINIMA;
-export function getParamSet(_env) {
-    return WOTS_MINIMA;
+exports.WOTS_V1_DEV = exports.WOTS_MINIMA;
+exports.WOTS_V2_SPEC = exports.WOTS_MINIMA;
+function getParamSet(_env) {
+    return exports.WOTS_MINIMA;
 }

package/dist/script.js

@@ -1,17 +1,22 @@
-import { bytesToHex } from "./util.js";
-import { scriptToAddress } from "./derive.js";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scriptFromWotsPk = scriptFromWotsPk;
+exports.wotsAddressFromKeypair = wotsAddressFromKeypair;
+exports.hexToBytes = hexToBytes;
+const util_js_1 = require("./util.js");
+const derive_js_1 = require("./derive.js");
 /** Produce KISSVM script that authorizes with a WOTS PK digest (32 bytes). */
-export function scriptFromWotsPk(pkDigest32) {
+function scriptFromWotsPk(pkDigest32) {
     // Minima uses SHA3-256 in SIGNEDBY paths; here we embed the digest as hex.
-    return `RETURN SIGNEDBY(${bytesToHex(pkDigest32)})`;
+    return `RETURN SIGNEDBY(${(0, util_js_1.bytesToHex)(pkDigest32)})`;
 }
 /** Address from WOTS keypair (client-only): script -> MMR leaf -> Mx */
-export function wotsAddressFromKeypair(kp) {
+function wotsAddressFromKeypair(kp) {
     const script = scriptFromWotsPk(kp.pk);
-    return scriptToAddress(script);
+    return (0, derive_js_1.scriptToAddress)(script);
 }
 /** tiny utils */
-export function hexToBytes(hex) {
+function hexToBytes(hex) {
     let h = hex.startsWith("0x") ? hex.slice(2) : hex;
     if (h.length % 2)
         h = "0" + h;

package/dist/scripts/contract-helpers.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Contract Helpers
  *
@@ -13,10 +14,12 @@
  * Each helper validates inputs and builds the appropriate ScriptDescriptor
  * for use with the EnhancedTransactionBuilder.
  */
-import { sha3_256 } from '@noble/hashes/sha3.js';
-import { sha256 } from '@noble/hashes/sha2.js';
-import { randomBytes } from '@noble/hashes/utils.js';
-import { createTimelockDescriptor, createHTLCDescriptor, createMASTDescriptor, createExchangeDescriptor, createFlashCashDescriptor, createSlowCashDescriptor } from './types.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatefulGameHelper = exports.SlowCashHelper = exports.FlashCashHelper = exports.VaultHelper = exports.ExchangeHelper = exports.MASTHelper = exports.HTLCHelper = exports.TimelockHelper = void 0;
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const utils_js_1 = require("@noble/hashes/utils.js");
+const types_js_1 = require("./types.js");
 function kissHex(hex) {
     const raw = hex.startsWith('0x') || hex.startsWith('0X') ? hex.slice(2) : hex;
     return '0x' + raw.toUpperCase();
@@ -37,7 +40,7 @@ function bytesToHex(bytes) {
  *
  * Creates timelocked scripts that can only be spent after a certain block.
  */
-export class TimelockHelper {
+class TimelockHelper {
     /**
      * Create a timelock script that unlocks at a specific block.
      */
@@ -64,22 +67,23 @@ export class TimelockHelper {
      * Build ScriptDescriptor for a timelock spend.
      */
     static buildDescriptor(address, publicKey, unlockBlock) {
-        return createTimelockDescriptor(address, publicKey, unlockBlock);
+        return (0, types_js_1.createTimelockDescriptor)(address, publicKey, unlockBlock);
     }
 }
+exports.TimelockHelper = TimelockHelper;
 /**
  * HTLC Helper
  *
  * Creates Hashed Timelock Contracts for atomic swaps and lightning-style payments.
  */
-export class HTLCHelper {
+class HTLCHelper {
     /**
      * Generate a random preimage and its hash.
      */
     static generateSecret() {
-        const preimageBytes = randomBytes(32);
+        const preimageBytes = (0, utils_js_1.randomBytes)(32);
         const preimage = bytesToHex(preimageBytes);
-        const hashBytes = sha3_256(preimageBytes);
+        const hashBytes = (0, sha3_js_1.sha3_256)(preimageBytes);
         const hash = bytesToHex(hashBytes);
         return { preimage, hash };
     }
@@ -89,11 +93,11 @@ export class HTLCHelper {
     static hashPreimage(preimage, algorithm = 'sha3') {
         const preimageBytes = hexToBytes(preimage);
         if (algorithm === 'sha2') {
-            const hashBytes = sha256(preimageBytes);
+            const hashBytes = (0, sha2_js_1.sha256)(preimageBytes);
             return bytesToHex(hashBytes);
         }
         else {
-            const hashBytes = sha3_256(preimageBytes);
+            const hashBytes = (0, sha3_js_1.sha3_256)(preimageBytes);
             return bytesToHex(hashBytes);
         }
     }
@@ -121,27 +125,28 @@ export class HTLCHelper {
      * Build ScriptDescriptor to claim HTLC with preimage.
      */
     static buildClaimDescriptor(address, senderPublicKey, recipientPublicKey, hashLock, timeoutBlock, preimage) {
-        return createHTLCDescriptor(address, senderPublicKey, recipientPublicKey, hashLock, timeoutBlock, false, preimage);
+        return (0, types_js_1.createHTLCDescriptor)(address, senderPublicKey, recipientPublicKey, hashLock, timeoutBlock, false, preimage);
     }
     /**
      * Build ScriptDescriptor to refund HTLC after timeout.
      */
     static buildRefundDescriptor(address, senderPublicKey, recipientPublicKey, hashLock, timeoutBlock) {
-        return createHTLCDescriptor(address, senderPublicKey, recipientPublicKey, hashLock, timeoutBlock, true);
+        return (0, types_js_1.createHTLCDescriptor)(address, senderPublicKey, recipientPublicKey, hashLock, timeoutBlock, true);
     }
 }
+exports.HTLCHelper = HTLCHelper;
 /**
  * MAST Helper
  *
  * Creates Merkelized Abstract Syntax Tree contracts for privacy and scalability.
  */
-export class MASTHelper {
+class MASTHelper {
     /**
      * Compute hash of a script for MAST leaf.
      */
     static hashScript(script) {
         const scriptBytes = new TextEncoder().encode(script.trim().toUpperCase());
-        const hashBytes = sha3_256(scriptBytes);
+        const hashBytes = (0, sha3_js_1.sha3_256)(scriptBytes);
         return bytesToHex(hashBytes);
     }
     /**
@@ -172,7 +177,7 @@ export class MASTHelper {
             proofs.set(scripts[i], { proof: proofHex, index: i });
         }
         const combinedBytes = hexToBytes(hashes[0].slice(2) + hashes[1].slice(2));
-        const rootBytes = sha3_256(combinedBytes);
+        const rootBytes = (0, sha3_js_1.sha3_256)(combinedBytes);
         const root = bytesToHex(rootBytes);
         return { root, proofs };
     }
@@ -188,15 +193,16 @@ export class MASTHelper {
      * Build ScriptDescriptor for spending a MAST branch.
      */
     static buildDescriptor(address, rootHash, branchScript, branchProof, wotsPublicKey) {
-        return createMASTDescriptor(address, rootHash, branchScript, branchProof, wotsPublicKey);
+        return (0, types_js_1.createMASTDescriptor)(address, rootHash, branchScript, branchProof, wotsPublicKey);
     }
 }
+exports.MASTHelper = MASTHelper;
 /**
  * Exchange Contract Helper
  *
  * Creates DEX-style exchange contracts using VERIFYOUT.
  */
-export class ExchangeHelper {
+class ExchangeHelper {
     /**
      * Create an exchange offer script.
      *
@@ -223,7 +229,7 @@ export class ExchangeHelper {
      * Build ScriptDescriptor for taking an exchange offer.
      */
     static buildTakeOfferDescriptor(address, ownerPublicKey, desiredAddress, desiredAmount, desiredTokenId) {
-        return createExchangeDescriptor(address, ownerPublicKey, desiredAddress, desiredAmount, desiredTokenId);
+        return (0, types_js_1.createExchangeDescriptor)(address, ownerPublicKey, desiredAddress, desiredAmount, desiredTokenId);
     }
     /**
      * Validate VERIFYOUT for an exchange transaction.
@@ -245,12 +251,13 @@ export class ExchangeHelper {
         return { valid: true };
     }
 }
+exports.ExchangeHelper = ExchangeHelper;
 /**
  * Vault Helper
  *
  * Creates vault/covenant contracts with safe house enforcement.
  */
-export class VaultHelper {
+class VaultHelper {
     /**
      * Generate safe house script from vault parameters.
      */
@@ -282,12 +289,13 @@ export class VaultHelper {
         ];
     }
 }
+exports.VaultHelper = VaultHelper;
 /**
  * Flash Cash Helper
  *
  * Creates flash loan contracts for single-transaction borrowing.
  */
-export class FlashCashHelper {
+class FlashCashHelper {
     /**
      * Create a flash cash contract.
      */
@@ -307,15 +315,16 @@ export class FlashCashHelper {
      * Build ScriptDescriptor for borrowing flash cash.
      */
     static buildBorrowDescriptor(address, ownerPublicKey, interestMultiplier = '1.01') {
-        return createFlashCashDescriptor(address, ownerPublicKey, interestMultiplier);
+        return (0, types_js_1.createFlashCashDescriptor)(address, ownerPublicKey, interestMultiplier);
     }
 }
+exports.FlashCashHelper = FlashCashHelper;
 /**
  * Slow Cash Helper
  *
  * Creates rate-limited withdrawal contracts.
  */
-export class SlowCashHelper {
+class SlowCashHelper {
     /**
      * Create a slow cash contract.
      */
@@ -342,15 +351,16 @@ export class SlowCashHelper {
      * Build ScriptDescriptor for slow cash withdrawal.
      */
     static buildWithdrawalDescriptor(address, ownerPublicKey, withdrawalPercent = '0.9', cooldownBlocks = 10000n) {
-        return createSlowCashDescriptor(address, ownerPublicKey, withdrawalPercent, cooldownBlocks);
+        return (0, types_js_1.createSlowCashDescriptor)(address, ownerPublicKey, withdrawalPercent, cooldownBlocks);
     }
 }
+exports.SlowCashHelper = SlowCashHelper;
 /**
  * Stateful Game Helper
  *
  * Creates multi-round stateful contracts (like coin flip).
  */
-export class StatefulGameHelper {
+class StatefulGameHelper {
     /**
      * Create a round increment assertion.
      */
@@ -376,10 +386,11 @@ export class StatefulGameHelper {
         return currentRound === previousRound + 1;
     }
 }
+exports.StatefulGameHelper = StatefulGameHelper;
 function computeScriptAddress(script) {
     const cleanScript = script.trim().toUpperCase();
     const scriptBytes = new TextEncoder().encode(cleanScript);
-    const hashBytes = sha3_256(scriptBytes);
+    const hashBytes = (0, sha3_js_1.sha3_256)(scriptBytes);
     return bytesToHex(hashBytes);
 }
 function encodeSimpleProof(siblingHash, isLeft) {

package/dist/scripts/dapp-types.js

@@ -1,12 +1,17 @@
-export const TOTEM_SEND_TRANSACTION_VERSION = 1;
-export function validateSendTransactionRequest(request) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOTEM_SEND_TRANSACTION_VERSION = void 0;
+exports.validateSendTransactionRequest = validateSendTransactionRequest;
+exports.simpleTotemSendRequest = simpleTotemSendRequest;
+exports.TOTEM_SEND_TRANSACTION_VERSION = 1;
+function validateSendTransactionRequest(request) {
     const errors = [];
     if (!request || typeof request !== 'object') {
         return { valid: false, errors: ['Request must be an object'] };
     }
     const req = request;
-    if (req.version !== TOTEM_SEND_TRANSACTION_VERSION) {
-        errors.push(`Invalid version: expected ${TOTEM_SEND_TRANSACTION_VERSION}, got ${req.version}`);
+    if (req.version !== exports.TOTEM_SEND_TRANSACTION_VERSION) {
+        errors.push(`Invalid version: expected ${exports.TOTEM_SEND_TRANSACTION_VERSION}, got ${req.version}`);
     }
     const validIntents = [
         'send', 'token_send', 'swap', 'liquidity_add', 'liquidity_remove',
@@ -59,9 +64,9 @@ export function validateSendTransactionRequest(request) {
     }
     return { valid: errors.length === 0, errors };
 }
-export function simpleTotemSendRequest(to, amount, tokenId) {
+function simpleTotemSendRequest(to, amount, tokenId) {
     return {
-        version: TOTEM_SEND_TRANSACTION_VERSION,
+        version: exports.TOTEM_SEND_TRANSACTION_VERSION,
         intent: tokenId && tokenId !== '0x00' ? 'token_send' : 'send',
         outputs: [{
                 address: to,