@totemsdk/core 1.0.9 → 1.0.11

package/dist/verify.js

@@ -1,15 +1,26 @@
-import { sha3_256 } from '@noble/hashes/sha3.js';
-import { deserializeTreeSignature } from './treekey.js';
-import { scriptToAddress } from './derive.js';
-import { scriptFromWotsPk } from './script.js';
-import { getRootPublicKey } from './treekey.js';
-import { wotsVerifyDigest } from './wots.js';
-import { getParamSet } from './params.js';
-export function normalizeHex(hex) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeHex = normalizeHex;
+exports.hexToBytes = hexToBytes;
+exports.bytesToHex = bytesToHex;
+exports.deriveAddressFromPublicKey = deriveAddressFromPublicKey;
+exports.verifyTreeSignatureDetailed = verifyTreeSignatureDetailed;
+exports.verifySignature = verifySignature;
+exports.verifySignatureDetailed = verifySignatureDetailed;
+exports.createChallenge = createChallenge;
+exports.validateChallenge = validateChallenge;
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+const treekey_js_1 = require("./treekey.js");
+const derive_js_1 = require("./derive.js");
+const script_js_1 = require("./script.js");
+const treekey_js_2 = require("./treekey.js");
+const wots_js_1 = require("./wots.js");
+const params_js_1 = require("./params.js");
+function normalizeHex(hex) {
     const stripped = hex.startsWith('0x') ? hex.slice(2) : hex;
     return stripped.toLowerCase();
 }
-export function hexToBytes(hex) {
+function hexToBytes(hex) {
     const h = normalizeHex(hex);
     if (h.length % 2 !== 0)
         throw new Error('Invalid hex string: odd length');
@@ -19,28 +30,28 @@ export function hexToBytes(hex) {
     }
     return bytes;
 }
-export function bytesToHex(bytes) {
+function bytesToHex(bytes) {
     return Array.from(bytes)
         .map(b => b.toString(16).padStart(2, '0'))
         .join('');
 }
-export function deriveAddressFromPublicKey(publicKeyHex) {
+function deriveAddressFromPublicKey(publicKeyHex) {
     const pkBytes = hexToBytes(publicKeyHex);
     if (pkBytes.length !== 32) {
         throw new Error(`Public key must be 32 bytes (64 hex chars), got ${pkBytes.length} bytes`);
     }
-    const script = scriptFromWotsPk(pkBytes);
-    return scriptToAddress(script);
+    const script = (0, script_js_1.scriptFromWotsPk)(pkBytes);
+    return (0, derive_js_1.scriptToAddress)(script);
 }
-export function verifyTreeSignatureDetailed(expectedPubkey, data, signature) {
+function verifyTreeSignatureDetailed(expectedPubkey, data, signature) {
     const { proofs } = signature;
     if (proofs.length === 0) {
         return { valid: false, error: 'Signature contains no proofs' };
     }
-    const paramSet = getParamSet();
+    const paramSet = (0, params_js_1.getParamSet)();
     for (let depth = 0; depth < proofs.length; depth++) {
         const proof = proofs[depth];
-        const rootPubkey = getRootPublicKey(proof);
+        const rootPubkey = (0, treekey_js_2.getRootPublicKey)(proof);
         if (depth === 0) {
             if (!timingSafeEqual(expectedPubkey, rootPubkey)) {
                 return {
@@ -54,9 +65,9 @@ export function verifyTreeSignatureDetailed(expectedPubkey, data, signature) {
             signedData = data;
         }
         else {
-            signedData = getRootPublicKey(proofs[depth + 1]);
+            signedData = (0, treekey_js_2.getRootPublicKey)(proofs[depth + 1]);
         }
-        if (!wotsVerifyDigest(proof.signature, signedData, proof.leafPubkey, paramSet)) {
+        if (!(0, wots_js_1.wotsVerifyDigest)(proof.signature, signedData, proof.leafPubkey, paramSet)) {
             return {
                 valid: false,
                 error: `WOTS signature verification failed at depth ${depth} (digest mismatch or corrupted signature)`,
@@ -65,11 +76,11 @@ export function verifyTreeSignatureDetailed(expectedPubkey, data, signature) {
     }
     return { valid: true };
 }
-export function verifySignature(address, message, signatureHex, publicKeyHex) {
+function verifySignature(address, message, signatureHex, publicKeyHex) {
     const result = verifySignatureDetailed(address, message, signatureHex, publicKeyHex);
     return result.valid;
 }
-export function verifySignatureDetailed(address, message, signatureHex, publicKeyHex) {
+function verifySignatureDetailed(address, message, signatureHex, publicKeyHex) {
     try {
         const pkBytes = hexToBytes(publicKeyHex);
         if (pkBytes.length !== 32) {
@@ -88,7 +99,7 @@ export function verifySignatureDetailed(address, message, signatureHex, publicKe
         const sigBytes = hexToBytes(signatureHex);
         let treeSignature;
         try {
-            treeSignature = deserializeTreeSignature(sigBytes);
+            treeSignature = (0, treekey_js_1.deserializeTreeSignature)(sigBytes);
         }
         catch (e) {
             return {
@@ -96,7 +107,7 @@ export function verifySignatureDetailed(address, message, signatureHex, publicKe
                 error: `Malformed signature: ${e.message}`,
             };
         }
-        const digest = sha3_256(new TextEncoder().encode(message));
+        const digest = (0, sha3_js_1.sha3_256)(new TextEncoder().encode(message));
         return verifyTreeSignatureDetailed(pkBytes, digest, treeSignature);
     }
     catch (e) {
@@ -132,12 +143,12 @@ function cryptoRandomBytes(length) {
     }
     return buf;
 }
-export function createChallenge(domain, nonce) {
+function createChallenge(domain, nonce) {
     const ts = Date.now();
-    const n = nonce || bytesToHex(sha3_256(new Uint8Array([...new TextEncoder().encode(`${domain}:${ts}:`), ...cryptoRandomBytes(16)]))).slice(0, 16);
+    const n = nonce || bytesToHex((0, sha3_js_1.sha3_256)(new Uint8Array([...new TextEncoder().encode(`${domain}:${ts}:`), ...cryptoRandomBytes(16)]))).slice(0, 16);
     return JSON.stringify({ domain, nonce: n, issuedAt: ts });
 }
-export function validateChallenge(challenge, options) {
+function validateChallenge(challenge, options) {
     try {
         const parsed = JSON.parse(challenge);
         const { domain, nonce, issuedAt } = parsed;

package/dist/version.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * SDK Core Version Information
  *
@@ -8,5 +9,7 @@
  * If you see different CORE_BUILD_IDs logged from wallet creation
  * vs signing modules, there's a bundling issue.
  */
-export const CORE_BUILD_ID = '2026.02.05-v1';
-export const CORE_VERSION = '1.0.0';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CORE_VERSION = exports.CORE_BUILD_ID = void 0;
+exports.CORE_BUILD_ID = '2026.02.05-v1';
+exports.CORE_VERSION = '1.0.0';

package/dist/wots.d.ts

@@ -31,14 +31,14 @@ export declare function disableWotsLogger(): void;
  * Check if WOTS debug logging is enabled
  */
 export declare function isWotsDebugEnabled(): boolean;
-export declare const F: (x: Uint8Array) => Uint8Array<ArrayBufferLike>;
+export declare const F: (x: Uint8Array) => Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>;
 export declare const hex: (u: Uint8Array) => string;
 export declare const fromHex: (h: string) => Uint8Array;
 export declare const concatBytes: (...arrs: Uint8Array[]) => Uint8Array<ArrayBuffer>;
 export declare const u16be: (n: number) => Uint8Array<ArrayBuffer>;
 export declare const u32be: (n: number) => Uint8Array<ArrayBuffer>;
 export declare function assert32(u: Uint8Array, label?: string): void;
-export declare const h: (x: Uint8Array) => Uint8Array<ArrayBufferLike>;
+export declare const h: (x: Uint8Array) => Uint8Array<ArrayBufferLike> & Uint8Array<ArrayBuffer>;
 /**
  * GMSSRandom - BouncyCastle's stateful PRNG for WOTS chain seed derivation
  *

package/dist/wots.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * WOTS Implementation - BouncyCastle Compatible
  *
@@ -12,12 +13,34 @@
  *
  * Source: org.bouncycastle.pqc.crypto.gmss.util.{WinternitzOTSignature, WinternitzOTSVerify, GMSSRandom}
  */
-import { sha3_256 } from '@noble/hashes/sha3.js';
-import { getParamSet } from "./params.js";
-import { deriveChainSeedJava } from "./javaStreamables.js";
-import { NoopLogger } from "./adapters/index.js";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GMSSRandom = exports.h = exports.u32be = exports.u16be = exports.concatBytes = exports.fromHex = exports.hex = exports.F = void 0;
+exports.setWotsLogger = setWotsLogger;
+exports.disableWotsLogger = disableWotsLogger;
+exports.isWotsDebugEnabled = isWotsDebugEnabled;
+exports.assert32 = assert32;
+exports.getLog = getLog;
+exports.expandPrivateKey = expandPrivateKey;
+exports.toWinternitzDigits = toWinternitzDigits;
+exports.baseWWithChecksum = baseWWithChecksum;
+exports.hashChain = hashChain;
+exports.deriveIndexedSeed = deriveIndexedSeed;
+exports.derivePKdigest = derivePKdigest;
+exports.deriveFullPublicKey = deriveFullPublicKey;
+exports.wotsKeypairFromSeed = wotsKeypairFromSeed;
+exports.wotsSign = wotsSign;
+exports.wotsSignLegacy = wotsSignLegacy;
+exports.wotsPkFromSig = wotsPkFromSig;
+exports.wotsVerify = wotsVerify;
+exports.wotsVerifyDigest = wotsVerifyDigest;
+exports.wotsPublicKeyFromSeed = wotsPublicKeyFromSeed;
+exports.prfChainSeed = prfChainSeed;
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+const params_js_1 = require("./params.js");
+const javaStreamables_js_1 = require("./javaStreamables.js");
+const index_js_1 = require("./adapters/index.js");
 // Module-level debug logger - can be set externally for parity testing
-let wotsLogger = new NoopLogger();
+let wotsLogger = new index_js_1.NoopLogger();
 let wotsDebugEnabled = false;
 /**
  * Enable WOTS debug logging with a custom logger
@@ -27,39 +50,42 @@ let wotsDebugEnabled = false;
  * private key chains and seeds. NEVER enable in production builds.
  * This is intended for development/testing parity verification only.
  */
-export function setWotsLogger(logger) {
+function setWotsLogger(logger) {
     wotsLogger = logger;
     wotsDebugEnabled = true;
 }
 /**
  * Disable WOTS debug logging
  */
-export function disableWotsLogger() {
-    wotsLogger = new NoopLogger();
+function disableWotsLogger() {
+    wotsLogger = new index_js_1.NoopLogger();
     wotsDebugEnabled = false;
 }
 /**
  * Check if WOTS debug logging is enabled
  */
-export function isWotsDebugEnabled() {
+function isWotsDebugEnabled() {
     return wotsDebugEnabled;
 }
 // === Canonical helpers ===
-export const F = (x) => sha3_256(x);
-export const hex = (u) => {
+const F = (x) => (0, sha3_js_1.sha3_256)(x);
+exports.F = F;
+const hex = (u) => {
     let s = '';
     for (let i = 0; i < u.length; i++)
         s += u[i].toString(16).padStart(2, '0');
     return s;
 };
-export const fromHex = (h) => {
+exports.hex = hex;
+const fromHex = (h) => {
     const s = h.replace(/^0x/, '');
     const out = new Uint8Array(s.length >> 1);
     for (let i = 0; i < out.length; i++)
         out[i] = parseInt(s.slice(i * 2, i * 2 + 2), 16);
     return out;
 };
-export const concatBytes = (...arrs) => {
+exports.fromHex = fromHex;
+const concatBytes = (...arrs) => {
     const len = arrs.reduce((n, a) => n + a.length, 0);
     const out = new Uint8Array(len);
     let o = 0;
@@ -69,9 +95,12 @@ export const concatBytes = (...arrs) => {
     }
     return out;
 };
-export const u16be = (n) => new Uint8Array([(n >>> 8) & 0xff, n & 0xff]);
-export const u32be = (n) => new Uint8Array([(n >>> 24) & 255, (n >>> 16) & 255, (n >>> 8) & 255, n & 255]);
-export function assert32(u, label = 'value') {
+exports.concatBytes = concatBytes;
+const u16be = (n) => new Uint8Array([(n >>> 8) & 0xff, n & 0xff]);
+exports.u16be = u16be;
+const u32be = (n) => new Uint8Array([(n >>> 24) & 255, (n >>> 16) & 255, (n >>> 8) & 255, n & 255]);
+exports.u32be = u32be;
+function assert32(u, label = 'value') {
     if (!(u instanceof Uint8Array))
         throw new Error(`${label} must be a Uint8Array`);
     if (u.length !== 32)
@@ -79,9 +108,9 @@ export function assert32(u, label = 'value') {
 }
 // Legacy aliases
 const u8 = (len) => new Uint8Array(len);
-export const h = F;
-const concat = concatBytes;
-const defaultParamSet = getParamSet();
+exports.h = exports.F;
+const concat = exports.concatBytes;
+const defaultParamSet = (0, params_js_1.getParamSet)();
 /**
  * GMSSRandom - BouncyCastle's stateful PRNG for WOTS chain seed derivation
  *
@@ -92,7 +121,7 @@ const defaultParamSet = getParamSet();
  *
  * The state is MUTATED in place after each call.
  */
-export class GMSSRandom {
+class GMSSRandom {
     /**
      * Generate next random value and update state
      *
@@ -102,7 +131,7 @@ export class GMSSRandom {
     static nextSeed(state) {
         assert32(state, 'state');
         // rand = H(state)
-        const rand = F(state);
+        const rand = (0, exports.F)(state);
         // state = state + rand (byte-wise addition with carry, little-endian)
         GMSSRandom.addByteArrays(state, rand);
         // state = state + 1
@@ -136,6 +165,7 @@ export class GMSSRandom {
         }
     }
 }
+exports.GMSSRandom = GMSSRandom;
 /**
  * getLog - Calculate ceil(log2(x))
  *
@@ -145,7 +175,7 @@ export class GMSSRandom {
  *   while (i < intValue) { i <<= 1; log++; }
  *   return log;
  */
-export function getLog(intValue) {
+function getLog(intValue) {
     let log = 1;
     let i = 2;
     while (i < intValue) {
@@ -164,13 +194,13 @@ export function getLog(intValue) {
  *     privateKeyOTS[i] = gmssRandom.nextSeed(dummy);
  *   }
  */
-export function expandPrivateKey(seed, ps = getParamSet()) {
+function expandPrivateKey(seed, ps = (0, params_js_1.getParamSet)()) {
     assert32(seed, 'seed');
     // Copy seed to mutable state
     const state = new Uint8Array(seed);
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[expandPrivateKey] Input seed: ${hex(seed).substring(0, 64)}...`);
-        wotsLogger.debug(`[expandPrivateKey] Initial state: ${hex(state).substring(0, 64)}...`);
+        wotsLogger.debug(`[expandPrivateKey] Input seed: ${(0, exports.hex)(seed).substring(0, 64)}...`);
+        wotsLogger.debug(`[expandPrivateKey] Initial state: ${(0, exports.hex)(state).substring(0, 64)}...`);
     }
     // Generate L chain seeds using stateful PRNG
     const privateKeys = [];
@@ -179,13 +209,13 @@ export function expandPrivateKey(seed, ps = getParamSet()) {
         privateKeys.push(pk);
         // Log first few private keys for debugging
         if (wotsDebugEnabled && i < 3) {
-            wotsLogger.debug(`[expandPrivateKey] pk[${i}]: ${hex(pk)}`);
-            wotsLogger.debug(`[expandPrivateKey] state after pk[${i}]: ${hex(state).substring(0, 32)}...`);
+            wotsLogger.debug(`[expandPrivateKey] pk[${i}]: ${(0, exports.hex)(pk)}`);
+            wotsLogger.debug(`[expandPrivateKey] state after pk[${i}]: ${(0, exports.hex)(state).substring(0, 32)}...`);
         }
     }
     if (wotsDebugEnabled) {
         wotsLogger.debug(`[expandPrivateKey] Generated ${privateKeys.length} private keys`);
-        wotsLogger.debug(`[expandPrivateKey] pk[33] (last): ${hex(privateKeys[33])}`);
+        wotsLogger.debug(`[expandPrivateKey] pk[33] (last): ${(0, exports.hex)(privateKeys[33])}`);
     }
     return privateKeys;
 }
@@ -200,7 +230,7 @@ export function expandPrivateKey(seed, ps = getParamSet()) {
  *
  * Matches WinternitzOTSignature.getSignature() for w=8 case
  */
-export function toWinternitzDigits(hash32, ps = getParamSet()) {
+function toWinternitzDigits(hash32, ps = (0, params_js_1.getParamSet)()) {
     assert32(hash32, 'hash');
     if (ps.w !== 8) {
         throw new Error(`Only w=8 is supported. Got w=${ps.w}`);
@@ -228,7 +258,7 @@ export function toWinternitzDigits(hash32, ps = getParamSet()) {
         c >>>= ps.w;
     }
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[toWinternitzDigits] Input hash: ${hex(hash32)}`);
+        wotsLogger.debug(`[toWinternitzDigits] Input hash: ${(0, exports.hex)(hash32)}`);
         wotsLogger.debug(`[toWinternitzDigits] First 5 message digits: [${digits.slice(0, 5).join(', ')}]`);
         wotsLogger.debug(`[toWinternitzDigits] Last 5 message digits: [${digits.slice(-5).join(', ')}]`);
         wotsLogger.debug(`[toWinternitzDigits] Digit sum: ${digitSum}`);
@@ -246,7 +276,7 @@ export function toWinternitzDigits(hash32, ps = getParamSet()) {
  * Decompose digest into base-w digits + checksum
  * Returns flat array of all L digits
  */
-export function baseWWithChecksum(msgHash, paramSet) {
+function baseWWithChecksum(msgHash, paramSet) {
     const ps = paramSet || defaultParamSet;
     const { digits, checksumDigits } = toWinternitzDigits(msgHash, ps);
     const result = digits.concat(checksumDigits);
@@ -262,13 +292,13 @@ export function baseWWithChecksum(msgHash, paramSet) {
  * - If rounds < 1: return input unchanged
  * - Otherwise: hash `rounds` times
  */
-export function hashChain(x, rounds) {
+function hashChain(x, rounds) {
     if (rounds < 1) {
         return new Uint8Array(x);
     }
-    let result = F(x);
+    let result = (0, exports.F)(x);
     for (let i = 1; i < rounds; i++) {
-        result = F(result);
+        result = (0, exports.F)(result);
     }
     return result;
 }
@@ -284,12 +314,12 @@ export function hashChain(x, rounds) {
  * This old implementation used H(seed || u32be(i)) which is NOT Java compatible.
  * @deprecated Use deriveChainSeedJava from javaStreamables.ts
  */
-export function deriveIndexedSeed(seed, keyIndex) {
+function deriveIndexedSeed(seed, keyIndex) {
     assert32(seed, 'seed');
     // Use Java-compatible derivation: hashAllObjects(MiniNumber(i), MiniData(seed))
-    const result = deriveChainSeedJava(seed, keyIndex);
+    const result = (0, javaStreamables_js_1.deriveChainSeedJava)(seed, keyIndex);
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[deriveIndexedSeed] seed=${hex(seed).substring(0, 32)}..., keyIndex=${keyIndex} => ${hex(result)}`);
+        wotsLogger.debug(`[deriveIndexedSeed] seed=${(0, exports.hex)(seed).substring(0, 32)}..., keyIndex=${keyIndex} => ${(0, exports.hex)(result)}`);
     }
     return result;
 }
@@ -306,7 +336,7 @@ export function deriveIndexedSeed(seed, keyIndex) {
  *   }
  *   return H(buf);
  */
-export function derivePKdigest(seed, i, ps = getParamSet()) {
+function derivePKdigest(seed, i, ps = (0, params_js_1.getParamSet)()) {
     assert32(seed, 'seed');
     // Derive unique seed for this key index
     const indexedSeed = deriveIndexedSeed(seed, i);
@@ -320,7 +350,7 @@ export function derivePKdigest(seed, i, ps = getParamSet()) {
         buf.set(top, j * 32);
     }
     // Return H(all chain tops)
-    return F(buf);
+    return (0, exports.F)(buf);
 }
 /**
  * Derive full WOTS public key (L × 32 bytes) without final hash
@@ -328,16 +358,16 @@ export function derivePKdigest(seed, i, ps = getParamSet()) {
  * Returns the concatenation of all chain tops BEFORE hashing.
  * Required by Minima's SignatureProof which expects the full public key.
  */
-export function deriveFullPublicKey(seed, i, ps = getParamSet()) {
+function deriveFullPublicKey(seed, i, ps = (0, params_js_1.getParamSet)()) {
     assert32(seed, 'seed');
     if (wotsDebugEnabled) {
         wotsLogger.debug(`[deriveFullPublicKey] ========== PK DERIVATION START ==========`);
-        wotsLogger.debug(`[deriveFullPublicKey] Master seed: ${hex(seed).substring(0, 32)}..., keyIndex: ${i}`);
+        wotsLogger.debug(`[deriveFullPublicKey] Master seed: ${(0, exports.hex)(seed).substring(0, 32)}..., keyIndex: ${i}`);
     }
     // Derive unique seed for this key index
     const indexedSeed = deriveIndexedSeed(seed, i);
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[deriveFullPublicKey] Indexed seed: ${hex(indexedSeed)}`);
+        wotsLogger.debug(`[deriveFullPublicKey] Indexed seed: ${(0, exports.hex)(indexedSeed)}`);
     }
     const privateKeys = expandPrivateKey(indexedSeed, ps);
     const rounds = ps.maxDigit; // 255
@@ -347,16 +377,16 @@ export function deriveFullPublicKey(seed, i, ps = getParamSet()) {
         buf.set(top, j * 32);
         // Log first few chain tops for debugging
         if (wotsDebugEnabled && j < 3) {
-            wotsLogger.debug(`[deriveFullPublicKey] chain[${j}]: pk=${hex(privateKeys[j]).substring(0, 16)}... rounds=${rounds} => top=${hex(top).substring(0, 16)}...`);
+            wotsLogger.debug(`[deriveFullPublicKey] chain[${j}]: pk=${(0, exports.hex)(privateKeys[j]).substring(0, 16)}... rounds=${rounds} => top=${(0, exports.hex)(top).substring(0, 16)}...`);
         }
     }
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[deriveFullPublicKey] Full public key (${buf.length}B): ${hex(buf).substring(0, 64)}...${hex(buf).substring(hex(buf).length - 32)}`);
+        wotsLogger.debug(`[deriveFullPublicKey] Full public key (${buf.length}B): ${(0, exports.hex)(buf).substring(0, 64)}...${(0, exports.hex)(buf).substring((0, exports.hex)(buf).length - 32)}`);
         wotsLogger.debug(`[deriveFullPublicKey] ========== PK DERIVATION END ==========`);
     }
     return buf; // L * 32 = 1088 bytes
 }
-export function wotsKeypairFromSeed(seed, index, paramSet) {
+function wotsKeypairFromSeed(seed, index, paramSet) {
     assert32(seed, 'seed');
     const ps = paramSet || defaultParamSet;
     const pkDigest = derivePKdigest(seed, index, ps);
@@ -378,25 +408,25 @@ export function wotsKeypairFromSeed(seed, index, paramSet) {
  * @param ps - WOTS parameter set (default: minima)
  * @returns Flat signature (L × 32 = 1088 bytes)
  */
-export function wotsSign(seed, i, message, ps = getParamSet()) {
+function wotsSign(seed, i, message, ps = (0, params_js_1.getParamSet)()) {
     assert32(seed, 'seed');
     assert32(message, 'message');
     if (wotsDebugEnabled) {
         wotsLogger.debug(`[wotsSign] ========== WOTS SIGN START ==========`);
-        wotsLogger.debug(`[wotsSign] Master seed: ${hex(seed)}`);
+        wotsLogger.debug(`[wotsSign] Master seed: ${(0, exports.hex)(seed)}`);
         wotsLogger.debug(`[wotsSign] Key index: ${i}`);
-        wotsLogger.debug(`[wotsSign] Message (raw): ${hex(message)}`);
+        wotsLogger.debug(`[wotsSign] Message (raw): ${(0, exports.hex)(message)}`);
     }
     // Derive unique seed for this key index
     const indexedSeed = deriveIndexedSeed(seed, i);
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[wotsSign] Indexed seed (after deriveIndexedSeed): ${hex(indexedSeed)}`);
+        wotsLogger.debug(`[wotsSign] Indexed seed (after deriveIndexedSeed): ${(0, exports.hex)(indexedSeed)}`);
     }
     const privateKeys = expandPrivateKey(indexedSeed, ps);
     // CRITICAL: Hash the message internally to match Java/BouncyCastle Winternitz behavior
     // Java's WinternitzOTSignature.getSignature() always hashes the message first
     // Callers pass RAW 32-byte data (tx digest, child root), NOT pre-hashed!
-    const hashedMsg = F(message);
+    const hashedMsg = (0, exports.F)(message);
     const { digits, checksumDigits } = toWinternitzDigits(hashedMsg, ps);
     const allDigits = digits.concat(checksumDigits);
     if (allDigits.length !== ps.L) {
@@ -412,11 +442,11 @@ export function wotsSign(seed, i, message, ps = getParamSet()) {
         out.set(sigPart, j * 32);
         // Log first few and last signature chains for debugging
         if (wotsDebugEnabled && (j < 3 || j >= ps.L - 2)) {
-            wotsLogger.debug(`[wotsSign] chain[${j}]: pk=${hex(privateKeys[j]).substring(0, 16)}... rounds=${rounds} => sig=${hex(sigPart).substring(0, 16)}...`);
+            wotsLogger.debug(`[wotsSign] chain[${j}]: pk=${(0, exports.hex)(privateKeys[j]).substring(0, 16)}... rounds=${rounds} => sig=${(0, exports.hex)(sigPart).substring(0, 16)}...`);
         }
     }
     if (wotsDebugEnabled) {
-        wotsLogger.debug(`[wotsSign] Signature output (${out.length} bytes): ${hex(out).substring(0, 64)}...${hex(out).substring(hex(out).length - 64)}`);
+        wotsLogger.debug(`[wotsSign] Signature output (${out.length} bytes): ${(0, exports.hex)(out).substring(0, 64)}...${(0, exports.hex)(out).substring((0, exports.hex)(out).length - 64)}`);
         wotsLogger.debug(`[wotsSign] ========== WOTS SIGN END ==========`);
     }
     return out;
@@ -424,8 +454,8 @@ export function wotsSign(seed, i, message, ps = getParamSet()) {
 /**
  * Legacy wrapper returning structured signature
  */
-export function wotsSignLegacy(msgHash, seed, index, paramSet) {
-    const ps = paramSet || getParamSet();
+function wotsSignLegacy(msgHash, seed, index, paramSet) {
+    const ps = paramSet || (0, params_js_1.getParamSet)();
     const sig = wotsSign(seed, index, msgHash, ps);
     const chunks = [];
     for (let i = 0; i < ps.L; i++) {
@@ -445,10 +475,10 @@ export function wotsSignLegacy(msgHash, seed, index, paramSet) {
  * CRITICAL: This function hashes the message internally to match Java/BouncyCastle
  * Winternitz behavior. Both wotsSign and wotsPkFromSig hash internally for parity.
  */
-export function wotsPkFromSig(message, signature, paramSet) {
+function wotsPkFromSig(message, signature, paramSet) {
     const ps = paramSet || defaultParamSet;
     // CRITICAL: Hash the message internally to match Java/BouncyCastle Winternitz behavior
-    const hashedMsg = F(message);
+    const hashedMsg = (0, exports.F)(message);
     const allDigits = baseWWithChecksum(hashedMsg, ps);
     if (signature.sig.length !== ps.L) {
         throw new Error(`Wrong signature length: expected ${ps.L}, got ${signature.sig.length}`);
@@ -459,7 +489,7 @@ export function wotsPkFromSig(message, signature, paramSet) {
         const top = hashChain(signature.sig[i], stepsUp);
         buf.set(top, i * 32);
     }
-    return F(buf);
+    return (0, exports.F)(buf);
 }
 /**
  * Verify WOTS signature against a FULL 1088-byte public key
@@ -480,7 +510,7 @@ export function wotsPkFromSig(message, signature, paramSet) {
  * @param pkFull - The FULL 1088-byte WOTS public key (L=34 × 32 bytes)
  * @param ps - WOTS parameter set (default: minima)
  */
-export function wotsVerify(sig, message, pkFull, ps = getParamSet()) {
+function wotsVerify(sig, message, pkFull, ps = (0, params_js_1.getParamSet)()) {
     // CRITICAL: Java verifies against FULL 1088-byte public key, not 32-byte digest
     const expectedLen = ps.L * 32;
     if (pkFull.length !== expectedLen) {
@@ -490,7 +520,7 @@ export function wotsVerify(sig, message, pkFull, ps = getParamSet()) {
         return false;
     }
     // CRITICAL: Hash the message internally to match Java/BouncyCastle Winternitz behavior
-    const hashedMsg = F(message);
+    const hashedMsg = (0, exports.F)(message);
     const allDigits = baseWWithChecksum(hashedMsg, ps);
     const buf = new Uint8Array(expectedLen);
     for (let j = 0; j < ps.L; j++) {
@@ -512,13 +542,13 @@ export function wotsVerify(sig, message, pkFull, ps = getParamSet()) {
  * Legacy verify function that accepts a 32-byte digest
  * @deprecated Use wotsVerify with full 1088-byte public key instead
  */
-export function wotsVerifyDigest(sig, message, pkDigest, ps = getParamSet()) {
+function wotsVerifyDigest(sig, message, pkDigest, ps = (0, params_js_1.getParamSet)()) {
     assert32(pkDigest, 'pkDigest');
     const expectedLen = ps.L * 32;
     if (sig.length !== expectedLen) {
         return false;
     }
-    const msgHash = F(message);
+    const msgHash = (0, exports.F)(message);
     const allDigits = baseWWithChecksum(msgHash, ps);
     const buf = new Uint8Array(expectedLen);
     for (let j = 0; j < ps.L; j++) {
@@ -527,7 +557,7 @@ export function wotsVerifyDigest(sig, message, pkDigest, ps = getParamSet()) {
         const top = hashChain(sigPart, stepsUp);
         buf.set(top, j * 32);
     }
-    const recomputed = F(buf);
+    const recomputed = (0, exports.F)(buf);
     if (recomputed.length !== pkDigest.length)
         return false;
     let diff = 0;
@@ -538,7 +568,7 @@ export function wotsVerifyDigest(sig, message, pkDigest, ps = getParamSet()) {
 /**
  * Generate WOTS public key from seed (convenience wrapper)
  */
-export function wotsPublicKeyFromSeed(seed, index = 0, paramSet) {
+function wotsPublicKeyFromSeed(seed, index = 0, paramSet) {
     assert32(seed, 'seed');
     const keypair = wotsKeypairFromSeed(seed, index, paramSet);
     return keypair.pk;
@@ -548,7 +578,7 @@ export function wotsPublicKeyFromSeed(seed, index = 0, paramSet) {
 /**
  * @deprecated Use expandPrivateKey instead
  */
-export function prfChainSeed(seed, i, j, _paramSet) {
+function prfChainSeed(seed, i, j, _paramSet) {
     // This function no longer makes sense with stateful PRNG
     // For compatibility, derive the j-th chain seed for key i
     const privateKeys = expandPrivateKey(seed, _paramSet);