@totemsdk/core 1.0.7 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/core",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Core cryptographic primitives for Totem SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -26,6 +26,10 @@
       "types": "./dist/tx/index.d.ts",
       "import": "./dist/tx/index.js"
     },
+    "./scripts": {
+      "types": "./dist/scripts/index.d.ts",
+      "import": "./dist/scripts/index.js"
+    },
     "./test-vectors.json": "./test-vectors.json"
   },
   "files": [

package/src/Streamable.d.ts

@@ -263,3 +263,6 @@ export declare function writeHierarchicalWitness(bundle: HierarchicalWitnessBund
  * Write hierarchical witness and return as hex string
  */
 export declare function writeHierarchicalWitnessToHex(bundle: HierarchicalWitnessBundle): string;
+export declare const encodeMiniNumber: typeof writeMiniNumber;
+export declare const encodeMiniData: typeof writeMiniData;
+export declare const encodeMiniString: typeof writeMiniString;

package/src/Streamable.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Streamable.ts - Canonical Java-Compatible Serialization Primitives
  *
@@ -21,29 +20,7 @@
  * Created: 2026-01-20
  * Purpose: Single source of truth for all Minima type serialization
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.STATETYPE_BOOL = exports.STATETYPE_STRING = exports.STATETYPE_NUMBER = exports.STATETYPE_HEX = void 0;
-exports.hexToBytes = hexToBytes;
-exports.bytesToHex = bytesToHex;
-exports.concat = concat;
-exports.writeMiniByte = writeMiniByte;
-exports.writeMiniData = writeMiniData;
-exports.writeMiniString = writeMiniString;
-exports.bigIntToByteArray = bigIntToByteArray;
-exports.writeMiniNumber = writeMiniNumber;
-exports.writeHashToStream = writeHashToStream;
-exports.writeMMREntryNumber = writeMMREntryNumber;
-exports.normalizeHexString = normalizeHexString;
-exports.writeStateVariable = writeStateVariable;
-exports.writeMMRData = writeMMRData;
-exports.writeMMRProofChunk = writeMMRProofChunk;
-exports.writeMMRProof = writeMMRProof;
-exports.writeSignatureProof = writeSignatureProof;
-exports.writeSignature = writeSignature;
-exports.writeWitness = writeWitness;
-exports.writeHierarchicalWitness = writeHierarchicalWitness;
-exports.writeHierarchicalWitnessToHex = writeHierarchicalWitnessToHex;
-function hexToBytes(hex) {
+export function hexToBytes(hex) {
     const cleanHex = hex.startsWith('0x') ? hex.slice(2) : hex;
     if (cleanHex.length === 0) {
         return new Uint8Array(0);
@@ -57,10 +34,10 @@ function hexToBytes(hex) {
     }
     return bytes;
 }
-function bytesToHex(bytes) {
+export function bytesToHex(bytes) {
     return '0x' + Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
 }
-function concat(...arrays) {
+export function concat(...arrays) {
     const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
     const result = new Uint8Array(totalLength);
     let offset = 0;
@@ -75,7 +52,7 @@ function concat(...arrays) {
  *
  * Format: single byte (0-255)
  */
-function writeMiniByte(value) {
+export function writeMiniByte(value) {
     if (typeof value === 'boolean') {
         return new Uint8Array([value ? 1 : 0]);
     }
@@ -89,7 +66,7 @@ function writeMiniByte(value) {
  *
  * Format: 4-byte big-endian int length + raw bytes
  */
-function writeMiniData(data) {
+export function writeMiniData(data) {
     const length = data.length;
     const lengthBytes = new Uint8Array([
         (length >> 24) & 0xff,
@@ -105,7 +82,7 @@ function writeMiniData(data) {
  * Format: MiniData encoding of UTF-8 bytes
  *         = 4-byte int length + UTF-8 bytes
  */
-function writeMiniString(str) {
+export function writeMiniString(str) {
     const utf8Bytes = new TextEncoder().encode(str);
     return writeMiniData(utf8Bytes);
 }
@@ -119,7 +96,7 @@ function writeMiniString(str) {
  * @param value - The BigInt value (must be non-negative)
  * @returns Uint8Array in two's complement format
  */
-function bigIntToByteArray(value) {
+export function bigIntToByteArray(value) {
     if (value < 0n) {
         throw new Error(`bigIntToByteArray does not support negative values: ${value}`);
     }
@@ -152,7 +129,7 @@ function bigIntToByteArray(value) {
  * @param value - The unscaled BigInt value
  * @param scale - The scale (decimal places), default 0
  */
-function writeMiniNumber(value, scale = 0) {
+export function writeMiniNumber(value, scale = 0) {
     if (typeof value !== 'bigint') {
         throw new Error(`writeMiniNumber requires bigint, got ${typeof value}`);
     }
@@ -176,7 +153,7 @@ function writeMiniNumber(value, scale = 0) {
  * Format: 4-byte big-endian int length + hash bytes
  *         (Same as MiniData)
  */
-function writeHashToStream(hash) {
+export function writeHashToStream(hash) {
     return writeMiniData(hash);
 }
 /**
@@ -194,7 +171,7 @@ function writeHashToStream(hash) {
  *   [00 01 00]        - MiniNumber: scale=0, len=1, data=0x00
  *   [00 00 00 LL ...] - MiniData: 4-byte len + BigInteger bytes
  */
-function writeMMREntryNumber(value, scale = 0) {
+export function writeMMREntryNumber(value, scale = 0) {
     if (value < 0n) {
         throw new Error(`writeMMREntryNumber does not support negative values: ${value}`);
     }
@@ -208,10 +185,10 @@ function writeMMREntryNumber(value, scale = 0) {
 /**
  * StateVariable type constants from Java StateVariable.java
  */
-exports.STATETYPE_HEX = 1;
-exports.STATETYPE_NUMBER = 2;
-exports.STATETYPE_STRING = 4;
-exports.STATETYPE_BOOL = 8;
+export const STATETYPE_HEX = 1;
+export const STATETYPE_NUMBER = 2;
+export const STATETYPE_STRING = 4;
+export const STATETYPE_BOOL = 8;
 /**
  * Normalize hex/address string to 0x format.
  * Handles both Mx (Minima Base32) and 0x formats.
@@ -220,7 +197,7 @@ exports.STATETYPE_BOOL = 8;
  * Note: For Mx conversion, caller should use mxToHex from minima-base32
  * This function handles 0x prefix normalization only.
  */
-function normalizeHexString(value) {
+export function normalizeHexString(value) {
     if (!value) {
         return '0x00';
     }
@@ -242,7 +219,7 @@ function normalizeHexString(value) {
  * @param sv - StateVariable with high-level value
  * @param mxToHex - Optional function to convert Mx addresses to 0x hex
  */
-function writeStateVariable(sv, mxToHex) {
+export function writeStateVariable(sv, mxToHex) {
     if (sv.port < 0 || sv.port > 255) {
         throw new Error(`StateVariable port must be 0-255, got ${sv.port}`);
     }
@@ -251,7 +228,7 @@ function writeStateVariable(sv, mxToHex) {
     let dataBytes;
     switch (sv.type) {
         case 'bool':
-            typeByte = writeMiniByte(exports.STATETYPE_BOOL);
+            typeByte = writeMiniByte(STATETYPE_BOOL);
             if (typeof sv.value === 'boolean') {
                 dataBytes = writeMiniByte(sv.value);
             }
@@ -263,7 +240,7 @@ function writeStateVariable(sv, mxToHex) {
             }
             break;
         case 'number':
-            typeByte = writeMiniByte(exports.STATETYPE_NUMBER);
+            typeByte = writeMiniByte(STATETYPE_NUMBER);
             if (typeof sv.value === 'bigint') {
                 dataBytes = writeMiniNumber(sv.value);
             }
@@ -275,7 +252,7 @@ function writeStateVariable(sv, mxToHex) {
             }
             break;
         case 'hex':
-            typeByte = writeMiniByte(exports.STATETYPE_HEX);
+            typeByte = writeMiniByte(STATETYPE_HEX);
             if (typeof sv.value === 'string') {
                 let normalizedHex = sv.value;
                 if (sv.value.toLowerCase().startsWith('mx') && mxToHex) {
@@ -294,7 +271,7 @@ function writeStateVariable(sv, mxToHex) {
             }
             break;
         case 'string':
-            typeByte = writeMiniByte(exports.STATETYPE_STRING);
+            typeByte = writeMiniByte(STATETYPE_STRING);
             if (typeof sv.value === 'string') {
                 let bracketedValue = sv.value;
                 if (!sv.value.startsWith('[') || !sv.value.endsWith(']')) {
@@ -318,7 +295,7 @@ function writeStateVariable(sv, mxToHex) {
  *   mData.writeHashToStream(zOut);  // 4-byte len + hash
  *   mValue.writeDataStream(zOut);   // MiniNumber
  */
-function writeMMRData(mmrData) {
+export function writeMMRData(mmrData) {
     const hashBytes = writeHashToStream(mmrData.data);
     const valueBytes = writeMiniNumber(mmrData.value, 0);
     return concat(hashBytes, valueBytes);
@@ -330,7 +307,7 @@ function writeMMRData(mmrData) {
  *   mLeft.writeDataStream(zOut);    // MiniByte (1 byte)
  *   mMMRData.writeDataStream(zOut); // MMRData
  */
-function writeMMRProofChunk(chunk) {
+export function writeMMRProofChunk(chunk) {
     const leftByte = writeMiniByte(chunk.isLeft);
     const dataBytes = writeMMRData(chunk.mmrData);
     return concat(leftByte, dataBytes);
@@ -343,7 +320,7 @@ function writeMMRProofChunk(chunk) {
  *   MiniNumber.WriteToStream(zOut, len);        // Array length as MiniNumber
  *   for each chunk: chunk.writeDataStream(zOut);
  */
-function writeMMRProof(proof) {
+export function writeMMRProof(proof) {
     const blockTimeBytes = writeMiniNumber(proof.blockTime, 0);
     const lengthBytes = writeMiniNumber(BigInt(proof.chunks.length), 0);
     const parts = [blockTimeBytes, lengthBytes];
@@ -360,7 +337,7 @@ function writeMMRProof(proof) {
  *   mSignature.writeDataStream(zOut);  // MiniData
  *   mProof.writeDataStream(zOut);      // MMRProof
  */
-function writeSignatureProof(sigProof) {
+export function writeSignatureProof(sigProof) {
     const pubKeyBytes = writeMiniData(sigProof.leafPubkey);
     const sigBytes = writeMiniData(sigProof.signature);
     const proofBytes = writeMMRProof(sigProof.mmrProof);
@@ -373,7 +350,7 @@ function writeSignatureProof(sigProof) {
  *   MiniNumber.WriteToStream(zOut, mSignatures.size());
  *   for each sig: sig.writeDataStream(zOut);
  */
-function writeSignature(sig) {
+export function writeSignature(sig) {
     const lengthBytes = writeMiniNumber(BigInt(sig.proofs.length), 0);
     const parts = [lengthBytes];
     for (const proof of sig.proofs) {
@@ -392,7 +369,7 @@ function writeSignature(sig) {
  *   MiniNumber.WriteToStream(zOut, mScriptProofs.size());
  *   for each sp: sp.writeDataStream(zOut);
  */
-function writeWitness(witness) {
+export function writeWitness(witness) {
     const parts = [];
     // Signatures
     parts.push(writeMiniNumber(BigInt(witness.signatures.length), 0));
@@ -415,7 +392,7 @@ function writeWitness(witness) {
  * Write a simplified hierarchical witness (signatures only)
  * Used for WOTS transaction signing flow
  */
-function writeHierarchicalWitness(bundle) {
+export function writeHierarchicalWitness(bundle) {
     const lengthBytes = writeMiniNumber(BigInt(bundle.signatures.length), 0);
     const parts = [lengthBytes];
     for (const sig of bundle.signatures) {
@@ -426,6 +403,14 @@ function writeHierarchicalWitness(bundle) {
 /**
  * Write hierarchical witness and return as hex string
  */
-function writeHierarchicalWitnessToHex(bundle) {
+export function writeHierarchicalWitnessToHex(bundle) {
     return bytesToHex(writeHierarchicalWitness(bundle));
 }
+// ============================================================
+// EXTENSION-MATCHING ALIASES
+// ============================================================
+// The extension's WitnessSerializer uses encode* naming, while SDK uses write* naming.
+// These aliases provide compatibility with extension code.
+export const encodeMiniNumber = writeMiniNumber;
+export const encodeMiniData = writeMiniData;
+export const encodeMiniString = writeMiniString;

package/src/javaStreamables.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Java-Compatible Serialization Helpers
  *
@@ -13,26 +12,8 @@
  * NOTE: This module provides number-based wrappers for backward compatibility.
  * The canonical implementations are in Streamable.ts which uses bigint for precision.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeMiniNumber = serializeMiniNumber;
-exports.serializeMiniData = serializeMiniData;
-exports.hashAllObjects = hashAllObjects;
-exports.deriveChainSeedJava = deriveChainSeedJava;
-exports.deriveChildTreeSeedJava = deriveChildTreeSeedJava;
-exports.hashObject = hashObject;
-exports.indexToMiniDataBytes = indexToMiniDataBytes;
-exports.derivePerAddressSeed = derivePerAddressSeed;
-exports.serializeMiniNumberZERO = serializeMiniNumberZERO;
-exports.serializeMiniNumberONE = serializeMiniNumberONE;
-exports.writeHashToStream = writeHashToStream;
-exports.javaHashAllObjects = javaHashAllObjects;
-exports.createMMREntryNumber = createMMREntryNumber;
-exports.serializeMMREntryNumber = serializeMMREntryNumber;
-exports.serializeMMRData = serializeMMRData;
-exports.serializeMMREntry = serializeMMREntry;
-exports.precomputeTransactionCoinID = precomputeTransactionCoinID;
-const sha3_1 = require("@noble/hashes/sha3");
-const Streamable_1 = require("./Streamable");
+import { sha3_256 } from '@noble/hashes/sha3.js';
+import { writeMiniNumber as streamableWriteMiniNumber, writeMiniData as streamableWriteMiniData, writeHashToStream as streamableWriteHashToStream, bigIntToByteArray } from './Streamable.js';
 /**
  * Serialize a number in MiniNumber format (Java compatible)
  *
@@ -41,10 +22,10 @@ const Streamable_1 = require("./Streamable");
  * @param n - Non-negative integer to serialize
  * @returns Serialized bytes matching Java MiniNumber format
  */
-function serializeMiniNumber(n) {
+export function serializeMiniNumber(n) {
     if (n < 0)
         throw new Error('MiniNumber must be non-negative');
-    return (0, Streamable_1.writeMiniNumber)(BigInt(n));
+    return streamableWriteMiniNumber(BigInt(n));
 }
 /**
  * Serialize bytes in MiniData format (Java compatible)
@@ -54,8 +35,8 @@ function serializeMiniNumber(n) {
  * @param data - Bytes to serialize
  * @returns Serialized bytes matching Java MiniData format
  */
-function serializeMiniData(data) {
-    return (0, Streamable_1.writeMiniData)(data);
+export function serializeMiniData(data) {
+    return streamableWriteMiniData(data);
 }
 /**
  * Hash multiple Streamable objects (Java compatible)
@@ -70,7 +51,7 @@ function serializeMiniData(data) {
  * @param items - Array of serialized objects (use serializeMiniNumber/serializeMiniData)
  * @returns 32-byte SHA3-256 hash
  */
-function hashAllObjects(...items) {
+export function hashAllObjects(...items) {
     // Concatenate all serialized items
     const totalLength = items.reduce((sum, item) => sum + item.length, 0);
     const combined = new Uint8Array(totalLength);
@@ -80,7 +61,7 @@ function hashAllObjects(...items) {
         offset += item.length;
     }
     // SHA3-256 hash
-    return (0, sha3_1.sha3_256)(combined);
+    return sha3_256(combined);
 }
 /**
  * Derive per-chain seed matching Java TreeKeyNode.java exactly
@@ -92,7 +73,7 @@ function hashAllObjects(...items) {
  * @param index - Chain index (0-63)
  * @returns 32-byte derived seed for this chain
  */
-function deriveChainSeedJava(privateSeed, index) {
+export function deriveChainSeedJava(privateSeed, index) {
     const indexSerialized = serializeMiniNumber(index);
     const seedSerialized = serializeMiniData(privateSeed);
     return hashAllObjects(indexSerialized, seedSerialized);
@@ -110,7 +91,7 @@ function deriveChainSeedJava(privateSeed, index) {
  * @param childIndex - Child index (0-63)
  * @returns 32-byte derived seed for child tree
  */
-function deriveChildTreeSeedJava(childSeed, childIndex) {
+export function deriveChildTreeSeedJava(childSeed, childIndex) {
     const indexSerialized = serializeMiniNumber(childIndex);
     const seedSerialized = serializeMiniData(childSeed);
     return hashAllObjects(indexSerialized, seedSerialized);
@@ -126,9 +107,9 @@ function deriveChildTreeSeedJava(childSeed, childIndex) {
  * @param data - Raw bytes (will be serialized as MiniData)
  * @returns 32-byte SHA3-256 hash
  */
-function hashObject(data) {
+export function hashObject(data) {
     const serialized = serializeMiniData(data);
-    return (0, sha3_1.sha3_256)(serialized);
+    return sha3_256(serialized);
 }
 /**
  * Convert index to MiniData bytes matching Java's:
@@ -140,7 +121,7 @@ function hashObject(data) {
  * @param index - Non-negative integer (0, 1, 2, ...)
  * @returns Minimal byte representation of the index
  */
-function indexToMiniDataBytes(index) {
+export function indexToMiniDataBytes(index) {
     if (index === 0) {
         return new Uint8Array([0x00]);
     }
@@ -168,7 +149,7 @@ function indexToMiniDataBytes(index) {
  * @param addressIndex - Address index (0, 1, 2, ... 63)
  * @returns 32-byte private seed for this address's TreeKey
  */
-function derivePerAddressSeed(baseSeed, addressIndex) {
+export function derivePerAddressSeed(baseSeed, addressIndex) {
     // Step 1: Create modifier bytes from BigInteger representation of index
     const modifierBytes = indexToMiniDataBytes(addressIndex);
     // Step 2: Serialize both as MiniData (4-byte length prefix each)
@@ -178,20 +159,27 @@ function derivePerAddressSeed(baseSeed, addressIndex) {
     const combined = new Uint8Array(baseSeedSerialized.length + modifierSerialized.length);
     combined.set(baseSeedSerialized, 0);
     combined.set(modifierSerialized, baseSeedSerialized.length);
-    return (0, sha3_1.sha3_256)(combined);
+    const result = sha3_256(combined);
+    // DIAGNOSTIC: Log first 8 bytes to detect bundle duplication or implementation differences
+    // Enable via: globalThis.TOTEM_SEED_DEBUG = true
+    if (typeof console !== 'undefined' && globalThis.TOTEM_SEED_DEBUG) {
+        const toHex = (b) => Array.from(b.slice(0, 8)).map(x => x.toString(16).padStart(2, '0')).join('');
+        console.log(`[derivePerAddressSeed] idx=${addressIndex} baseSeed[0:8]=${toHex(baseSeed)} -> result[0:8]=${toHex(result)}`);
+    }
+    return result;
 }
 /**
  * Serialize MiniNumber.ZERO - cached for performance
  * Returns: [0x00, 0x01, 0x00] = scale(0) + length(1) + value(0)
  */
-function serializeMiniNumberZERO() {
+export function serializeMiniNumberZERO() {
     return new Uint8Array([0x00, 0x01, 0x00]);
 }
 /**
  * Serialize MiniNumber.ONE
  * Returns: [0x00, 0x01, 0x01] = scale(0) + length(1) + value(1)
  */
-function serializeMiniNumberONE() {
+export function serializeMiniNumberONE() {
     return new Uint8Array([0x00, 0x01, 0x01]);
 }
 /**
@@ -202,8 +190,8 @@ function serializeMiniNumberONE() {
  * @param data - Hash bytes (max 64 bytes per MINIMA_MAX_HASH_LENGTH)
  * @returns Serialized bytes with 4-byte length prefix
  */
-function writeHashToStream(data) {
-    return (0, Streamable_1.writeHashToStream)(data);
+export function writeHashToStream(data) {
+    return streamableWriteHashToStream(data);
 }
 /**
  * Java hashAllObjects for MMRData hashing
@@ -223,7 +211,7 @@ function writeHashToStream(data) {
  * @param items - Pre-serialized items to concatenate and hash
  * @returns 32-byte SHA3-256 hash
  */
-function javaHashAllObjects(...items) {
+export function javaHashAllObjects(...items) {
     const totalLength = items.reduce((sum, item) => sum + item.length, 0);
     const combined = new Uint8Array(totalLength);
     let offset = 0;
@@ -231,12 +219,12 @@ function javaHashAllObjects(...items) {
         combined.set(item, offset);
         offset += item.length;
     }
-    return (0, sha3_1.sha3_256)(combined);
+    return sha3_256(combined);
 }
 /**
  * Create MMREntryNumber from bigint (common case for integer positions)
  */
-function createMMREntryNumber(value) {
+export function createMMREntryNumber(value) {
     return { scale: 0, unscaled: value };
 }
 /**
@@ -249,7 +237,7 @@ function createMMREntryNumber(value) {
  * @param entry - MMREntryNumber to serialize
  * @returns Serialized bytes: MiniNumber(scale) + MiniData(unscaled bytes)
  */
-function serializeMMREntryNumber(entry) {
+export function serializeMMREntryNumber(entry) {
     const scaleSerialized = serializeMiniNumber(entry.scale);
     const unscaledBytes = bigintToSignedBytes(entry.unscaled);
     const unscaledSerialized = serializeMiniData(unscaledBytes);
@@ -263,7 +251,7 @@ function serializeMMREntryNumber(entry) {
  * Uses the canonical implementation from Streamable.ts
  */
 function bigintToSignedBytes(n) {
-    return (0, Streamable_1.bigIntToByteArray)(n);
+    return bigIntToByteArray(n);
 }
 /**
  * Serialize MMRData matching Java MMRData.writeDataStream()
@@ -275,7 +263,7 @@ function bigintToSignedBytes(n) {
  * @param mmrData - MMRData to serialize
  * @returns Serialized bytes: writeHashToStream(hash) + MiniNumber(value)
  */
-function serializeMMRData(mmrData) {
+export function serializeMMRData(mmrData) {
     const hashSerialized = writeHashToStream(mmrData.data);
     const valueSerialized = serializeMiniNumber(Number(mmrData.value));
     const result = new Uint8Array(hashSerialized.length + valueSerialized.length);
@@ -295,7 +283,7 @@ function serializeMMRData(mmrData) {
  * @param entry - MMREntry to serialize
  * @returns Serialized bytes: MiniNumber(row) + MMREntryNumber + MMRData
  */
-function serializeMMREntry(entry) {
+export function serializeMMREntry(entry) {
     const rowSerialized = serializeMiniNumber(entry.row);
     const entryNumberSerialized = serializeMMREntryNumber(entry.entryNumber);
     const mmrDataSerialized = serializeMMRData(entry.mmrData);
@@ -309,7 +297,23 @@ function serializeMMREntry(entry) {
     result.set(mmrDataSerialized, offset);
     return result;
 }
-function precomputeTransactionCoinID(inputs, outputs) {
+/**
+ * Precompute output coin IDs before computing the transaction digest.
+ *
+ * CRITICAL: Java's txnsign command calls TxPoWGenerator.precomputeTransactionCoinID(txn)
+ * BEFORE calculateTransactionID(). This means the transaction digest that gets signed
+ * includes the PRECOMPUTED output coin IDs, not the placeholder 0x00.
+ *
+ * Formula: outputCoinID = SHA3-256( writeMiniData(input[0].coinID) || writeMiniNumber(outputIndex) )
+ * This matches Java's Crypto.hashObjects(baseCoinID, new MiniNumber(outputNum))
+ *
+ * Without this, the wallet signs a different digest than what the node verifies against,
+ * causing allsignaturesvalid=false on every transaction.
+ *
+ * @param inputs - Transaction inputs array, each must have a coinId (Uint8Array)
+ * @param outputs - Transaction outputs array, each will have its coinId mutated in-place
+ */
+export function precomputeTransactionCoinID(inputs, outputs) {
     if (inputs.length === 0)
         return;
     const baseCoinId = inputs[0].coinId;
@@ -318,11 +322,11 @@ function precomputeTransactionCoinID(inputs, outputs) {
             `(placeholder?). Real coinId from CoinProof required for signing.`);
     }
     for (let i = 0; i < outputs.length; i++) {
-        const baseCoinIdStream = (0, Streamable_1.writeMiniData)(baseCoinId);
-        const outputIndexStream = (0, Streamable_1.writeMiniNumber)(BigInt(i));
+        const baseCoinIdStream = streamableWriteMiniData(baseCoinId);
+        const outputIndexStream = streamableWriteMiniNumber(BigInt(i));
         const combined = new Uint8Array(baseCoinIdStream.length + outputIndexStream.length);
         combined.set(baseCoinIdStream, 0);
         combined.set(outputIndexStream, baseCoinIdStream.length);
-        outputs[i].coinId = (0, sha3_1.sha3_256)(combined);
+        outputs[i].coinId = sha3_256(combined);
     }
 }

package/src/mmr.d.ts

@@ -7,6 +7,7 @@ export declare function serializeMMRProof(proof: {
         };
     }>;
 }, 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:
@@ -147,13 +148,10 @@ export declare function verifyMMRProof(leafPubkey: Bytes, proof: MMRProof, expec
  *
  * @returns { proof: MMRProof, blockTime: bigint }
  */
-export declare function deserializeMMRProof(data: Bytes): {
-    proof: MMRProof;
-    blockTime: bigint;
-    bytesRead: number;
-};
 export declare function parseMMRProofFromHex(data: Bytes): {
     proof: MMRProof;
     blockTime: bigint;
     bytesRead: number;
 };
+/** @deprecated Use parseMMRProofFromHex */
+export declare const deserializeMMRProof: typeof parseMMRProofFromHex;

package/src/mmr.js

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

package/src/scripts/types.d.ts

@@ -0,0 +1,81 @@
+import type { MMRProofChunk, MMRProof } from '../mmr.js';
+export type { MMRProof };
+export type StateVariableType = 'STATE' | 'PREVSTATE' | 'SAMESTATE';
+export interface StateValue {
+    port: number;
+    value: string | bigint | Uint8Array | boolean;
+    type: 'bool' | 'number' | 'hex' | 'string';
+}
+export interface VerifyOutExpectation {
+    inputIndex: number | '@INPUT';
+    outputAddress: string;
+    amount: string | bigint;
+    tokenId: string;
+    keepState: boolean;
+}
+export type ScriptType = 'signedby' | 'multisig' | 'multisig_mofn' | 'timelock' | 'htlc' | 'mast' | 'exchange' | 'vault' | 'flashcash' | 'slowcash' | 'stateful' | 'custom';
+export interface ScriptDescriptor {
+    address: string;
+    scriptType: ScriptType;
+    script: string;
+    wotsRootPublicKey?: string;
+    mastProof?: MMRProof;
+    extraScripts?: Map<string, string>;
+    stateVariables?: StateValue[];
+    storeState?: boolean;
+    verifyOutExpectations?: VerifyOutExpectation[];
+    timelockBlock?: bigint;
+    htlcHash?: string;
+    htlcPreimage?: string;
+    multisigKeys?: string[];
+    multisigThreshold?: number;
+    externalSignatures?: ExternalSignature[];
+}
+export interface ExternalSignature {
+    publicKey: string;
+    signature: string;
+    proof?: MMRProof;
+    signatureType: 'wots' | 'standard';
+    validated?: boolean;
+}
+export interface ScriptCatalogEntry {
+    address: string;
+    script: string;
+    scriptType: ScriptType;
+    createdAt: number;
+    lastUsed: number;
+}
+export interface ScriptProofResult {
+    script: string;
+    proof: MMRProof;
+    serialized: Uint8Array;
+}
+export interface TransactionRoundState {
+    round: number;
+    previousRound: number;
+    preservedPorts: number[];
+    newStates: StateValue[];
+}
+export interface FlatMMRProofChunk {
+    isLeft: boolean;
+    data: Uint8Array;
+}
+export interface LegacyMMRProof {
+    blockTime: bigint;
+    proofChain: FlatMMRProofChunk[];
+}
+export declare function convertFlatChunkToSDK(chunk: FlatMMRProofChunk): MMRProofChunk;
+export declare function convertLegacyProofToSDK(legacy: LegacyMMRProof): {
+    proof: MMRProof;
+    blockTime: bigint;
+};
+export declare function createEmptyMMRProof(): MMRProof;
+export declare function createSignedByDescriptor(address: string, wotsRootPublicKey: string): ScriptDescriptor;
+export declare function createMultisigDescriptor(address: string, publicKey1: string, publicKey2: string, ownPublicKey: string): ScriptDescriptor;
+export declare function createMofNMultisigDescriptor(address: string, threshold: number, publicKeys: string[], ownPublicKey: string): ScriptDescriptor;
+export declare function createTimelockDescriptor(address: string, publicKey: string, unlockBlock: bigint): ScriptDescriptor;
+export declare function createHTLCDescriptor(address: string, ownerPublicKey: string, recipientPublicKey: string, hashLock: string, timeoutBlock: bigint, isOwner: boolean, preimage?: string): ScriptDescriptor;
+export declare function createMASTDescriptor(address: string, rootHash: string, branchScript: string, branchProof: string, wotsPublicKey?: string): ScriptDescriptor;
+export declare function createExchangeDescriptor(address: string, ownerPublicKey: string, desiredAddress: string, desiredAmount: string, desiredTokenId: string): ScriptDescriptor;
+export declare function createFlashCashDescriptor(address: string, ownerPublicKey: string, interestMultiplier?: string): ScriptDescriptor;
+export declare function createSlowCashDescriptor(address: string, ownerPublicKey: string, withdrawalPercent?: string, cooldownBlocks?: bigint): ScriptDescriptor;

package/src/scripts/types.js

@@ -0,0 +1,145 @@
+function kissHex(hex) {
+    const raw = hex.startsWith('0x') || hex.startsWith('0X') ? hex.slice(2) : hex;
+    return '0x' + raw.toUpperCase();
+}
+export function convertFlatChunkToSDK(chunk) {
+    return {
+        isLeft: chunk.isLeft,
+        mmrData: { data: chunk.data, value: 0n }
+    };
+}
+export function convertLegacyProofToSDK(legacy) {
+    return {
+        proof: {
+            chunks: legacy.proofChain.map(convertFlatChunkToSDK)
+        },
+        blockTime: legacy.blockTime
+    };
+}
+export function createEmptyMMRProof() {
+    return { chunks: [] };
+}
+export function createSignedByDescriptor(address, wotsRootPublicKey) {
+    return {
+        address,
+        scriptType: 'signedby',
+        script: `RETURN SIGNEDBY(${kissHex(wotsRootPublicKey)})`,
+        wotsRootPublicKey,
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+}
+export function createMultisigDescriptor(address, publicKey1, publicKey2, ownPublicKey) {
+    return {
+        address,
+        scriptType: 'multisig',
+        script: `RETURN SIGNEDBY(${kissHex(publicKey1)}) AND SIGNEDBY(${kissHex(publicKey2)})`,
+        wotsRootPublicKey: ownPublicKey,
+        multisigKeys: [publicKey1, publicKey2],
+        multisigThreshold: 2,
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+}
+export function createMofNMultisigDescriptor(address, threshold, publicKeys, ownPublicKey) {
+    const formattedKeys = publicKeys.map(pk => kissHex(pk)).join(' ');
+    return {
+        address,
+        scriptType: 'multisig_mofn',
+        script: `RETURN MULTISIG(${threshold} ${formattedKeys})`,
+        wotsRootPublicKey: ownPublicKey,
+        multisigKeys: publicKeys,
+        multisigThreshold: threshold,
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+}
+export function createTimelockDescriptor(address, publicKey, unlockBlock) {
+    return {
+        address,
+        scriptType: 'timelock',
+        script: `RETURN SIGNEDBY(${kissHex(publicKey)}) AND @BLOCK GT ${unlockBlock}`,
+        wotsRootPublicKey: publicKey,
+        timelockBlock: unlockBlock,
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+}
+export function createHTLCDescriptor(address, ownerPublicKey, recipientPublicKey, hashLock, timeoutBlock, isOwner, preimage) {
+    const script = `IF @BLOCK GT ${timeoutBlock} AND SIGNEDBY(${kissHex(ownerPublicKey)}) THEN RETURN TRUE ENDIF RETURN (SIGNEDBY(${kissHex(recipientPublicKey)}) AND SHA3(STATE(1)) EQ ${kissHex(hashLock)})`;
+    const descriptor = {
+        address,
+        scriptType: 'htlc',
+        script,
+        wotsRootPublicKey: isOwner ? ownerPublicKey : recipientPublicKey,
+        htlcHash: hashLock,
+        timelockBlock: timeoutBlock,
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+    if (preimage) {
+        descriptor.htlcPreimage = preimage;
+        descriptor.stateVariables = [{ port: 1, value: preimage, type: 'string' }];
+    }
+    return descriptor;
+}
+export function createMASTDescriptor(address, rootHash, branchScript, branchProof, wotsPublicKey) {
+    return {
+        address,
+        scriptType: 'mast',
+        script: `MAST ${kissHex(rootHash)}`,
+        wotsRootPublicKey: wotsPublicKey,
+        extraScripts: new Map([[branchScript, branchProof]]),
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+}
+export function createExchangeDescriptor(address, ownerPublicKey, desiredAddress, desiredAmount, desiredTokenId) {
+    const ownerPk = kissHex(ownerPublicKey);
+    const script = `IF SIGNEDBY(PREVSTATE(0)) THEN RETURN TRUE ENDIF ASSERT VERIFYOUT(@INPUT PREVSTATE(1) PREVSTATE(2) PREVSTATE(3) TRUE) RETURN TRUE`;
+    return {
+        address,
+        scriptType: 'exchange',
+        script,
+        wotsRootPublicKey: ownerPublicKey,
+        stateVariables: [
+            { port: 0, value: ownerPk, type: 'hex' },
+            { port: 1, value: desiredAddress, type: 'hex' },
+            { port: 2, value: desiredAmount, type: 'number' },
+            { port: 3, value: desiredTokenId, type: 'hex' }
+        ],
+        verifyOutExpectations: [{
+                inputIndex: '@INPUT',
+                outputAddress: desiredAddress,
+                amount: desiredAmount,
+                tokenId: desiredTokenId,
+                keepState: true
+            }],
+        mastProof: createEmptyMMRProof(),
+        storeState: true
+    };
+}
+export function createFlashCashDescriptor(address, ownerPublicKey, interestMultiplier = '1.01') {
+    const script = `IF SIGNEDBY(PREVSTATE(1)) THEN RETURN TRUE ENDIF ASSERT SAMESTATE(1 1) RETURN VERIFYOUT(@INPUT @ADDRESS @AMOUNT*${interestMultiplier} @TOKENID TRUE)`;
+    return {
+        address,
+        scriptType: 'flashcash',
+        script,
+        wotsRootPublicKey: ownerPublicKey,
+        stateVariables: [{ port: 1, value: ownerPublicKey, type: 'hex' }],
+        mastProof: createEmptyMMRProof(),
+        storeState: true
+    };
+}
+export function createSlowCashDescriptor(address, ownerPublicKey, withdrawalPercent = '0.9', cooldownBlocks = 10000n) {
+    const script = `IF @COINAGE LT ${cooldownBlocks} THEN RETURN FALSE ENDIF ASSERT SIGNEDBY(${kissHex(ownerPublicKey)}) AND VERIFYOUT(@INPUT @ADDRESS @AMOUNT*${withdrawalPercent} @TOKENID TRUE)`;
+    return {
+        address,
+        scriptType: 'slowcash',
+        script,
+        wotsRootPublicKey: ownerPublicKey,
+        timelockBlock: cooldownBlocks,
+        mastProof: createEmptyMMRProof(),
+        storeState: false
+    };
+}