@totemsdk/core 1.2.4 → 1.2.6

package/README.md

@@ -2,7 +2,7 @@
 
 **The cryptographic engine — every other package depends on this.**
 
-Zero production dependencies (only `@noble/hashes` as a peer). Provides quantum-resistant WOTS signatures, hierarchical TreeKey address derivation, BIP39 seed phrases, Merkle Mountain Range proofs, and byte-exact Minima Java-compatible transaction serialization.
+Zero production dependencies (only `@noble/hashes` as a peer). Provides WOTS (Winternitz) signatures, hierarchical TreeKey address derivation, BIP39 seed phrases, Merkle Mountain Range proofs, and byte-exact Minima Java-compatible transaction serialization.
 
 ## Install
 

package/dist/MiniNumber.d.ts

@@ -0,0 +1,47 @@
+export declare class MiniNumber {
+    readonly unscaled: bigint;
+    readonly scale: number;
+    static readonly ZERO: MiniNumber;
+    static readonly ONE: MiniNumber;
+    static readonly TWO: MiniNumber;
+    static readonly THREE: MiniNumber;
+    static readonly FOUR: MiniNumber;
+    static readonly EIGHT: MiniNumber;
+    static readonly TWELVE: MiniNumber;
+    static readonly SIXTEEN: MiniNumber;
+    static readonly TWENTY: MiniNumber;
+    static readonly THIRTYTWO: MiniNumber;
+    static readonly FIFTY: MiniNumber;
+    static readonly SIXTYFOUR: MiniNumber;
+    static readonly TWOFIVESIX: MiniNumber;
+    static readonly FIVEONE12: MiniNumber;
+    static readonly THOUSAND24: MiniNumber;
+    static readonly MINUSONE: MiniNumber;
+    constructor(value: string | number | bigint | MiniNumber);
+    getAsBigDecimal(): string;
+    getAsBigInteger(): string;
+    toNumber(): number;
+    toString(): string;
+    private assertSameScale;
+    add(other: MiniNumber): MiniNumber;
+    sub(other: MiniNumber): MiniNumber;
+    mult(other: MiniNumber): MiniNumber;
+    div(other: MiniNumber): MiniNumber;
+    modulo(other: MiniNumber): MiniNumber;
+    pow(n: number): MiniNumber;
+    sqrt(): MiniNumber;
+    floor(): MiniNumber;
+    ceil(): MiniNumber;
+    abs(): MiniNumber;
+    negate(): MiniNumber;
+    increment(): MiniNumber;
+    decrement(): MiniNumber;
+    compareTo(other: MiniNumber): number;
+    isEqual(other: MiniNumber): boolean;
+    isLess(other: MiniNumber): boolean;
+    isLessEqual(other: MiniNumber): boolean;
+    isMore(other: MiniNumber): boolean;
+    isMoreEqual(other: MiniNumber): boolean;
+    setSignificantDigits(d: number): MiniNumber;
+    decimalPlaces(): number;
+}

package/dist/MiniNumber.js

@@ -0,0 +1,298 @@
+// Matching Java's `org.minima.objects.base.MiniNumber` backed by `BigDecimal`
+// with MathContext(64, RoundingMode.DOWN).
+const MAX_DIGITS = 64;
+const MAX_DECIMAL_PLACES = MAX_DIGITS - 20;
+const MAX_VALUE_BIG = (1n << 64n) - 1n; // 2^64 - 1
+function checkLimits(unscaled, scale) {
+    if (scale > MAX_DECIMAL_PLACES) {
+        const diff = scale - MAX_DECIMAL_PLACES;
+        const divisor = 10n ** BigInt(diff);
+        unscaled = unscaled / divisor;
+        scale = MAX_DECIMAL_PLACES;
+    }
+    const abs = unscaled < 0n ? -unscaled : unscaled;
+    const factor = 10n ** BigInt(scale);
+    const intPart = abs / factor;
+    const rem = abs % factor;
+    if (intPart > MAX_VALUE_BIG || (intPart === MAX_VALUE_BIG && rem > 0n)) {
+        throw new RangeError(`MiniNumber too large: ${unscaled}E${-scale}`);
+    }
+}
+function digits(v) {
+    if (v === 0n)
+        return 0;
+    return v.toString().replace('-', '').length;
+}
+function roundToDigits(unscaled, scale, digits_target) {
+    let u = unscaled;
+    let s = scale;
+    const currentDigits = digits(u);
+    if (currentDigits > digits_target) {
+        const drop = currentDigits - digits_target;
+        const divisor = 10n ** BigInt(drop);
+        u = u / divisor;
+        s = s - drop;
+    }
+    if (s > MAX_DECIMAL_PLACES) {
+        const diff = s - MAX_DECIMAL_PLACES;
+        const divisor = 10n ** BigInt(diff);
+        u = u / divisor;
+        s = s - diff;
+    }
+    while (s > 0 && u % 10n === 0n) {
+        u = u / 10n;
+        s--;
+    }
+    return { unscaled: u, scale: s };
+}
+export class MiniNumber {
+    unscaled;
+    scale;
+    static ZERO = new MiniNumber(0);
+    static ONE = new MiniNumber(1);
+    static TWO = new MiniNumber(2);
+    static THREE = new MiniNumber(3);
+    static FOUR = new MiniNumber(4);
+    static EIGHT = new MiniNumber(8);
+    static TWELVE = new MiniNumber(12);
+    static SIXTEEN = new MiniNumber(16);
+    static TWENTY = new MiniNumber(20);
+    static THIRTYTWO = new MiniNumber(32);
+    static FIFTY = new MiniNumber(50);
+    static SIXTYFOUR = new MiniNumber(64);
+    static TWOFIVESIX = new MiniNumber(256);
+    static FIVEONE12 = new MiniNumber(512);
+    static THOUSAND24 = new MiniNumber(1024);
+    static MINUSONE = new MiniNumber(-1);
+    constructor(value) {
+        if (value instanceof MiniNumber) {
+            this.unscaled = value.unscaled;
+            this.scale = value.scale;
+            return;
+        }
+        if (typeof value === 'bigint') {
+            this.unscaled = value;
+            this.scale = 0;
+            if (value !== 0n) {
+                const r = roundToDigits(this.unscaled, this.scale, MAX_DIGITS);
+                this.unscaled = r.unscaled;
+                this.scale = r.scale;
+                checkLimits(this.unscaled, this.scale);
+            }
+            return;
+        }
+        if (typeof value === 'number') {
+            const s = Number.isInteger(value) ? value.toFixed(0) : value.toExponential(20);
+            const parsed = parseDecimal(s);
+            this.unscaled = parsed.unscaled;
+            this.scale = parsed.scale;
+            if (this.unscaled !== 0n) {
+                const r = roundToDigits(this.unscaled, this.scale, MAX_DIGITS);
+                this.unscaled = r.unscaled;
+                this.scale = r.scale;
+                checkLimits(this.unscaled, this.scale);
+            }
+            return;
+        }
+        const parsed = parseDecimal(value);
+        this.unscaled = parsed.unscaled;
+        this.scale = parsed.scale;
+        if (this.unscaled !== 0n) {
+            const r = roundToDigits(this.unscaled, this.scale, MAX_DIGITS);
+            this.unscaled = r.unscaled;
+            this.scale = r.scale;
+            checkLimits(this.unscaled, this.scale);
+        }
+    }
+    getAsBigDecimal() {
+        return this.toString();
+    }
+    getAsBigInteger() {
+        const s = this.toString();
+        const dot = s.indexOf('.');
+        return dot === -1 ? s : s.slice(0, dot);
+    }
+    toNumber() {
+        return Number(this.toString());
+    }
+    toString() {
+        if (this.unscaled === 0n)
+            return '0';
+        const neg = this.unscaled < 0n;
+        const abs = neg ? -this.unscaled : this.unscaled;
+        let s = abs.toString();
+        if (s.length <= this.scale) {
+            s = s.padStart(this.scale + 1, '0');
+            s = s.slice(0, s.length - this.scale) + '.' + s.slice(s.length - this.scale);
+        }
+        else {
+            s = s.slice(0, s.length - this.scale) + '.' + s.slice(s.length - this.scale);
+        }
+        s = s.replace(/(\.[0-9]*?)0+$/, '$1').replace(/\.$/, '');
+        return neg ? '-' + s : s;
+    }
+    assertSameScale(other) {
+        if (this.scale === other.scale)
+            return { a: this.unscaled, b: other.unscaled, outScale: this.scale };
+        if (this.scale > other.scale) {
+            const diff = this.scale - other.scale;
+            return { a: this.unscaled, b: other.unscaled * 10n ** BigInt(diff), outScale: this.scale };
+        }
+        const diff = other.scale - this.scale;
+        return { a: this.unscaled * 10n ** BigInt(diff), b: other.unscaled, outScale: other.scale };
+    }
+    add(other) {
+        const { a, b, outScale } = this.assertSameScale(other);
+        const result = a + b;
+        const r = roundToDigits(result, outScale, MAX_DIGITS);
+        return new MiniNumber(r.unscaled.toString() + 'e' + (-r.scale));
+    }
+    sub(other) {
+        const { a, b, outScale } = this.assertSameScale(other);
+        const result = a - b;
+        const r = roundToDigits(result, outScale, MAX_DIGITS);
+        return new MiniNumber(r.unscaled.toString() + 'e' + (-r.scale));
+    }
+    mult(other) {
+        const result = this.unscaled * other.unscaled;
+        const outScale = this.scale + other.scale;
+        const r = roundToDigits(result, outScale, MAX_DIGITS);
+        return new MiniNumber(r.unscaled.toString() + 'e' + (-r.scale));
+    }
+    div(other) {
+        if (other.unscaled === 0n)
+            throw new Error('Division by zero');
+        const extraScale = MAX_DIGITS;
+        const scaledThis = this.unscaled * 10n ** BigInt(extraScale);
+        const result = scaledThis / other.unscaled;
+        const outScale = this.scale + extraScale - other.scale;
+        const r = roundToDigits(result, outScale, MAX_DIGITS);
+        return new MiniNumber(r.unscaled.toString() + 'e' + (-r.scale));
+    }
+    modulo(other) {
+        if (other.unscaled === 0n)
+            throw new Error('Modulo by zero');
+        const { a, b, outScale } = this.assertSameScale(other);
+        const result = a % b;
+        return new MiniNumber(result.toString() + 'e' + (-outScale));
+    }
+    pow(n) {
+        if (n < 0)
+            throw new Error('Negative power not supported');
+        let result = MiniNumber.ONE;
+        for (let i = 0; i < n; i++)
+            result = result.mult(this);
+        return result;
+    }
+    sqrt() {
+        if (this.unscaled < 0n)
+            throw new Error('Square root of negative number');
+        if (this.unscaled === 0n)
+            return MiniNumber.ZERO;
+        const extra = MAX_DIGITS * 2;
+        const scaled = this.unscaled * 10n ** BigInt(extra);
+        const s = scaled / 10n ** BigInt(extra / 2);
+        let x = s;
+        const two = 2n;
+        for (let i = 0; i < 100; i++) {
+            const next = (x + scaled / x) / two;
+            if (next === x)
+                break;
+            x = next;
+        }
+        const outScale = (this.scale + extra) / 2;
+        const r = roundToDigits(x, outScale, MAX_DIGITS);
+        return new MiniNumber(r.unscaled.toString() + 'e' + (-r.scale));
+    }
+    floor() {
+        if (this.scale === 0)
+            return new MiniNumber(this);
+        const divisor = 10n ** BigInt(this.scale);
+        const q = this.unscaled / divisor;
+        const rem = this.unscaled % divisor;
+        if (this.unscaled < 0n && rem !== 0n) {
+            return new MiniNumber((q - 1n).toString());
+        }
+        return new MiniNumber(q.toString());
+    }
+    ceil() {
+        if (this.scale === 0)
+            return new MiniNumber(this);
+        const divisor = 10n ** BigInt(this.scale);
+        const q = this.unscaled / divisor;
+        const rem = this.unscaled % divisor;
+        if (this.unscaled > 0n && rem !== 0n) {
+            return new MiniNumber((q + 1n).toString());
+        }
+        return new MiniNumber(q.toString());
+    }
+    abs() {
+        if (this.unscaled >= 0n)
+            return new MiniNumber(this);
+        return new MiniNumber((-this.unscaled).toString() + 'e' + (-this.scale));
+    }
+    negate() {
+        return new MiniNumber((-this.unscaled).toString() + 'e' + (-this.scale));
+    }
+    increment() {
+        return this.add(MiniNumber.ONE);
+    }
+    decrement() {
+        return this.sub(MiniNumber.ONE);
+    }
+    compareTo(other) {
+        const { a, b } = this.assertSameScale(other);
+        if (a < b)
+            return -1;
+        if (a > b)
+            return 1;
+        return 0;
+    }
+    isEqual(other) { return this.compareTo(other) === 0; }
+    isLess(other) { return this.compareTo(other) < 0; }
+    isLessEqual(other) { return this.compareTo(other) <= 0; }
+    isMore(other) { return this.compareTo(other) > 0; }
+    isMoreEqual(other) { return this.compareTo(other) >= 0; }
+    setSignificantDigits(d) {
+        if (d > MAX_DIGITS)
+            throw new Error(`Cannot specify this many significant digits ${d}`);
+        if (d < 0)
+            throw new Error(`Cannot specify negative significant digits ${d}`);
+        const currentDigits = digits(this.unscaled);
+        if (currentDigits <= d)
+            return new MiniNumber(this);
+        const drop = currentDigits - d;
+        const divisor = 10n ** BigInt(drop);
+        const newUnscaled = this.unscaled / divisor;
+        return new MiniNumber(newUnscaled.toString() + 'e' + (-(this.scale - drop)));
+    }
+    decimalPlaces() {
+        return this.scale;
+    }
+}
+function parseDecimal(s) {
+    s = s.trim();
+    const ePos = s.toLowerCase().indexOf('e');
+    if (ePos !== -1) {
+        const mantissa = s.slice(0, ePos);
+        const exponent = parseInt(s.slice(ePos + 1), 10);
+        const { unscaled, scale } = parseDecimal(mantissa);
+        const newScale = scale - exponent;
+        if (newScale < 0) {
+            const factor = 10n ** BigInt(-newScale);
+            return { unscaled: unscaled * factor, scale: 0 };
+        }
+        return { unscaled, scale: newScale };
+    }
+    const neg = s.startsWith('-');
+    const abs = neg ? s.slice(1) : s;
+    const dot = abs.indexOf('.');
+    if (dot === -1) {
+        return { unscaled: BigInt(neg ? '-' + abs : abs), scale: 0 };
+    }
+    const intPart = abs.slice(0, dot) || '0';
+    const fracPart = abs.slice(dot + 1);
+    const full = intPart + fracPart;
+    const scale = fracPart.length;
+    return { unscaled: BigInt(neg ? '-' + full : full), scale };
+}

package/dist/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.encodeMiniString = exports.encodeMiniData = exports.encodeMiniNumber = 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,7 +403,7 @@ function writeHierarchicalWitness(bundle) {
 /**
  * Write hierarchical witness and return as hex string
  */
-function writeHierarchicalWitnessToHex(bundle) {
+export function writeHierarchicalWitnessToHex(bundle) {
     return bytesToHex(writeHierarchicalWitness(bundle));
 }
 // ============================================================
@@ -434,6 +411,6 @@ function writeHierarchicalWitnessToHex(bundle) {
 // ============================================================
 // The extension's WitnessSerializer uses encode* naming, while SDK uses write* naming.
 // These aliases provide compatibility with extension code.
-exports.encodeMiniNumber = writeMiniNumber;
-exports.encodeMiniData = writeMiniData;
-exports.encodeMiniString = writeMiniString;
+export const encodeMiniNumber = writeMiniNumber;
+export const encodeMiniData = writeMiniData;
+export const encodeMiniString = writeMiniString;

package/dist/adapters/index.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @module @totemsdk/core/adapters
  * Platform-agnostic adapter interfaces for SDK portability
@@ -10,17 +9,13 @@
  *
  * Each platform provides its own implementation of these adapters.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoopLifecycleAdapter = exports.DefaultTimerAdapter = exports.NoopMetrics = exports.ConsoleLogger = exports.NoopLogger = exports.WebSocketReadyState = void 0;
-exports.createCancellationToken = createCancellationToken;
-exports.createAdapterRegistry = createAdapterRegistry;
-exports.WebSocketReadyState = {
+export const WebSocketReadyState = {
     CONNECTING: 0,
     OPEN: 1,
     CLOSING: 2,
     CLOSED: 3,
 };
-function createCancellationToken() {
+export function createCancellationToken() {
     let cancelled = false;
     const callbacks = new Set();
     const token = {
@@ -45,7 +40,7 @@ function createCancellationToken() {
         }
     };
 }
-function createAdapterRegistry(adapters) {
+export function createAdapterRegistry(adapters) {
     const required = [
         'storage', 'auth', 'websocket', 'http', 'config', 'logger', 'timer', 'crypto'
     ];
@@ -56,14 +51,14 @@ function createAdapterRegistry(adapters) {
     }
     return adapters;
 }
-class NoopLogger {
+export class NoopLogger {
     debug(_message, ..._args) { }
     info(_message, ..._args) { }
     warn(_message, ..._args) { }
     error(_message, ..._args) { }
 }
-exports.NoopLogger = NoopLogger;
-class ConsoleLogger {
+export class ConsoleLogger {
+    prefix;
     constructor(prefix = '[SDK]') {
         this.prefix = prefix;
     }
@@ -80,15 +75,13 @@ class ConsoleLogger {
         console.error(`${this.prefix} ${message}`, ...args);
     }
 }
-exports.ConsoleLogger = ConsoleLogger;
-class NoopMetrics {
+export class NoopMetrics {
     increment(_name, _value, _tags) { }
     gauge(_name, _value, _tags) { }
     timing(_name, _durationMs, _tags) { }
     histogram(_name, _value, _tags) { }
 }
-exports.NoopMetrics = NoopMetrics;
-class DefaultTimerAdapter {
+export class DefaultTimerAdapter {
     setTimeout(callback, ms) {
         return setTimeout(callback, ms);
     }
@@ -105,8 +98,7 @@ class DefaultTimerAdapter {
         return Date.now();
     }
 }
-exports.DefaultTimerAdapter = DefaultTimerAdapter;
-class NoopLifecycleAdapter {
+export class NoopLifecycleAdapter {
     onSuspend(_callback) {
         return () => { };
     }
@@ -114,4 +106,3 @@ class NoopLifecycleAdapter {
         return () => { };
     }
 }
-exports.NoopLifecycleAdapter = NoopLifecycleAdapter;