@totemsdk/core 1.2.5 → 1.2.7

package/dist/cjs/tx/types.d.ts

@@ -0,0 +1,115 @@
+/**
+ * @module Transaction Types
+ * Type definitions for transaction service
+ */
+export interface WotsIndices {
+    addressIndex: number;
+    l1: number;
+    l2: number;
+}
+export interface PrepareRequest {
+    to: string;
+    amount: string;
+    tokenId?: string;
+    burn?: string;
+    txId?: string;
+    addressIndex?: number;
+}
+export interface PrepareResponse {
+    addressIndex: number;
+    l1: number;
+    l2: number;
+    leaseToken: string;
+    digestTx: string;
+    digestL2: string | null;
+    digestL3: string | null;
+    txId: string;
+    rootPublicKey: string;
+    paramSet: string;
+    leaseId: string;
+    leaseTTL: number;
+    perAddressScript?: string | null;
+}
+export interface SignRequest {
+    addressIndex: number;
+    l1: number;
+    l2: number;
+    digestTx: string;
+}
+/**
+ * Per-proof entry in a hierarchical TreeKey signature chain.
+ * Each proof represents one parent→child signing step.
+ */
+export interface SignatureProofHex {
+    leafPubkey: string;
+    signature: string;
+    mmrProof: string;
+}
+/**
+ * Hierarchical witness bundle produced by per-address TreeKey signing.
+ *
+ * Index mapping:
+ *   addressIndex — which HD address (0-63)
+ *   l1           — L1 index within per-address TreeKey (0-63)
+ *   l2           — L2 index within per-address TreeKey (0-63)
+ *
+ * proofs contains 3 entries for depth-3 TreeKeys (Root→L1→L2→DATA),
+ * matching Minima's TreeKey.sign() exactly.
+ */
+export interface HierarchicalWitnessBundle {
+    addressIndex: number;
+    l1: number;
+    l2: number;
+    rootPublicKey: string;
+    proofs: SignatureProofHex[];
+}
+/**
+ * @deprecated Use HierarchicalWitnessBundle. Kept for backward compatibility.
+ */
+export interface WitnessBundle {
+    addressIndex: number;
+    l1: number;
+    l2: number;
+    signatures: {
+        l1Proof: string[];
+        l2Proof: string[];
+        l3Proof: string[];
+    };
+}
+export interface SignResult {
+    witnessBundle: HierarchicalWitnessBundle;
+    signedHex: string;
+}
+export interface FinalizeRequest {
+    leaseToken: string;
+    signedHex?: string;
+    signedBase64?: string;
+    transactionHex?: string;
+    importId?: string;
+}
+export interface FinalizeResponse {
+    ok: boolean;
+    leaseId: string;
+    txpowid: string;
+}
+export interface TransactionMetadata {
+    to: string;
+    amount: string;
+    tokenId: string;
+}
+export interface TransactionReceipt {
+    txpowid: string;
+    timestamp: number;
+    to: string;
+    amount: string;
+    tokenId: string;
+    indices: WotsIndices;
+    status: 'confirmed' | 'pending' | 'failed';
+    txId?: string;
+    leaseId?: string;
+}
+export interface TransactionError {
+    code: number;
+    message: string;
+    userMessage: string;
+}

package/dist/cjs/tx/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * @module Transaction Types
+ * Type definitions for transaction service
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/util.d.ts

@@ -0,0 +1 @@
+export declare const bytesToHex: (b: Uint8Array) => string;

package/dist/cjs/util.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bytesToHex = void 0;
+const bytesToHex = (b) => Array.from(b).map(x => x.toString(16).padStart(2, "0")).join("").toUpperCase();
+exports.bytesToHex = bytesToHex;

package/dist/cjs/utils.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Utility functions for byte array manipulation
+ */
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function hexToBytes(hex: string): Uint8Array;
+export declare function concatBytes(...arrays: Uint8Array[]): Uint8Array;
+export declare function utf8ToBytes(str: string): Uint8Array;
+export declare function bytesToUtf8(bytes: Uint8Array): string;

package/dist/cjs/utils.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * Utility functions for byte array manipulation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bytesToHex = bytesToHex;
+exports.hexToBytes = hexToBytes;
+exports.concatBytes = concatBytes;
+exports.utf8ToBytes = utf8ToBytes;
+exports.bytesToUtf8 = bytesToUtf8;
+function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+function hexToBytes(hex) {
+    if (hex.startsWith('0x'))
+        hex = hex.slice(2);
+    if (hex.length % 2 !== 0)
+        throw new Error('Invalid hex string');
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}
+function concatBytes(...arrays) {
+    const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+        result.set(arr, offset);
+        offset += arr.length;
+    }
+    return result;
+}
+function utf8ToBytes(str) {
+    return new TextEncoder().encode(str);
+}
+function bytesToUtf8(bytes) {
+    return new TextDecoder().decode(bytes);
+}

package/dist/cjs/verify.d.ts

@@ -0,0 +1,18 @@
+import type { TreeSignature } from './treekey.js';
+import type { Bytes } from './mmr.js';
+export interface VerificationResult {
+    valid: boolean;
+    error?: string;
+}
+export declare function normalizeHex(hex: string): string;
+export declare function hexToBytes(hex: string): Uint8Array;
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function deriveAddressFromPublicKey(publicKeyHex: string): string;
+export declare function verifyTreeSignatureDetailed(expectedPubkey: Bytes, data: Bytes, signature: TreeSignature): VerificationResult;
+export declare function verifySignature(address: string, message: string, signatureHex: string, publicKeyHex: string): boolean;
+export declare function verifySignatureDetailed(address: string, message: string, signatureHex: string, publicKeyHex: string): VerificationResult;
+export declare function createChallenge(domain: string, nonce?: string): string;
+export declare function validateChallenge(challenge: string, options?: {
+    maxAgeMs?: number;
+    expectedDomain?: string;
+}): VerificationResult;

package/dist/cjs/verify.js

@@ -0,0 +1,174 @@
+"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 wasm_sync_js_1 = require("./wasm-sync.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();
+}
+function hexToBytes(hex) {
+    const h = normalizeHex(hex);
+    if (h.length % 2 !== 0)
+        throw new Error('Invalid hex string: odd length');
+    const bytes = new Uint8Array(h.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}
+function bytesToHex(bytes) {
+    return Array.from(bytes)
+        .map(b => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+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 = (0, script_js_1.scriptFromWotsPk)(pkBytes);
+    return (0, derive_js_1.scriptToAddress)(script);
+}
+function verifyTreeSignatureDetailed(expectedPubkey, data, signature) {
+    const { proofs } = signature;
+    if (proofs.length === 0) {
+        return { valid: false, error: 'Signature contains no proofs' };
+    }
+    const paramSet = (0, params_js_1.getParamSet)();
+    for (let depth = 0; depth < proofs.length; depth++) {
+        const proof = proofs[depth];
+        const rootPubkey = (0, treekey_js_2.getRootPublicKey)(proof);
+        if (depth === 0) {
+            if (!timingSafeEqual(expectedPubkey, rootPubkey)) {
+                return {
+                    valid: false,
+                    error: 'Root public key does not match expected public key (wrong key or address)',
+                };
+            }
+        }
+        let signedData;
+        if (depth === proofs.length - 1) {
+            signedData = data;
+        }
+        else {
+            signedData = (0, treekey_js_2.getRootPublicKey)(proofs[depth + 1]);
+        }
+        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)`,
+            };
+        }
+    }
+    return { valid: true };
+}
+function verifySignature(address, message, signatureHex, publicKeyHex) {
+    const result = verifySignatureDetailed(address, message, signatureHex, publicKeyHex);
+    return result.valid;
+}
+function verifySignatureDetailed(address, message, signatureHex, publicKeyHex) {
+    try {
+        const pkBytes = hexToBytes(publicKeyHex);
+        if (pkBytes.length !== 32) {
+            return {
+                valid: false,
+                error: `Public key must be 32 bytes (64 hex chars), got ${pkBytes.length} bytes`,
+            };
+        }
+        const derivedAddress = deriveAddressFromPublicKey(publicKeyHex);
+        if (derivedAddress.toLowerCase() !== address.toLowerCase()) {
+            return {
+                valid: false,
+                error: `Public key does not match claimed address. Expected ${address}, derived ${derivedAddress}`,
+            };
+        }
+        const sigBytes = hexToBytes(signatureHex);
+        let treeSignature;
+        try {
+            treeSignature = (0, treekey_js_1.deserializeTreeSignature)(sigBytes);
+        }
+        catch (e) {
+            return {
+                valid: false,
+                error: `Malformed signature: ${e.message}`,
+            };
+        }
+        const digest = (0, wasm_sync_js_1.sha3_256)(new TextEncoder().encode(message));
+        return verifyTreeSignatureDetailed(pkBytes, digest, treeSignature);
+    }
+    catch (e) {
+        return {
+            valid: false,
+            error: `Verification error: ${e.message}`,
+        };
+    }
+}
+function timingSafeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+        result |= a[i] ^ b[i];
+    }
+    return result === 0;
+}
+function cryptoRandomBytes(length) {
+    const buf = new Uint8Array(length);
+    if (typeof globalThis.crypto !== 'undefined' && globalThis.crypto.getRandomValues) {
+        // Web Crypto API — available in browsers, Bare/Pear, and Node.js ≥ 19
+        globalThis.crypto.getRandomValues(buf);
+    }
+    else if (typeof process !== 'undefined' && process.versions?.node) {
+        // Node.js < 19 fallback — dynamic import avoids static resolution in Bare/bundlers
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const nodeCrypto = Function('return require')()('crypto');
+        nodeCrypto.randomFillSync(buf);
+    }
+    else {
+        throw new Error('No cryptographically secure RNG available in this runtime');
+    }
+    return buf;
+}
+function createChallenge(domain, nonce) {
+    const ts = Date.now();
+    const n = nonce || bytesToHex((0, wasm_sync_js_1.sha3_256)(new Uint8Array([...new TextEncoder().encode(`${domain}:${ts}:`), ...cryptoRandomBytes(16)]))).slice(0, 16);
+    return JSON.stringify({ domain, nonce: n, issuedAt: ts });
+}
+function validateChallenge(challenge, options) {
+    try {
+        const parsed = JSON.parse(challenge);
+        const { domain, nonce, issuedAt } = parsed;
+        if (!domain || !nonce || !issuedAt) {
+            return { valid: false, error: 'Challenge missing required fields (domain, nonce, issuedAt)' };
+        }
+        if (options?.expectedDomain && domain !== options.expectedDomain) {
+            return { valid: false, error: `Domain mismatch: expected ${options.expectedDomain}, got ${domain}` };
+        }
+        const maxAge = options?.maxAgeMs ?? 5 * 60 * 1000;
+        const age = Date.now() - issuedAt;
+        if (age > maxAge) {
+            return { valid: false, error: `Challenge expired: ${Math.round(age / 1000)}s old (max ${Math.round(maxAge / 1000)}s)` };
+        }
+        if (age < 0) {
+            return { valid: false, error: 'Challenge issued in the future' };
+        }
+        return { valid: true };
+    }
+    catch {
+        return { valid: false, error: 'Invalid challenge format (not valid JSON)' };
+    }
+}

package/dist/cjs/version.d.ts

@@ -0,0 +1,12 @@
+/**
+ * SDK Core Version Information
+ *
+ * CORE_BUILD_ID is used to detect bundle duplication issues where
+ * the extension might bundle two different copies of sdk-core,
+ * computing addresses with one copy and signing with another.
+ *
+ * If you see different CORE_BUILD_IDs logged from wallet creation
+ * vs signing modules, there's a bundling issue.
+ */
+export declare const CORE_BUILD_ID = "2026.02.05-v1";
+export declare const CORE_VERSION = "1.0.0";

package/dist/cjs/version.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * SDK Core Version Information
+ *
+ * CORE_BUILD_ID is used to detect bundle duplication issues where
+ * the extension might bundle two different copies of sdk-core,
+ * computing addresses with one copy and signing with another.
+ *
+ * If you see different CORE_BUILD_IDs logged from wallet creation
+ * vs signing modules, there's a bundling issue.
+ */
+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/cjs/wasm-sync.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Synchronous WASM bridge — thin wrappers around @totemsdk/core-wasm.
+ *
+ * All functions are synchronous. The WASM module is initialized at import time.
+ * This replaces the async bridge in wasm-bridge.ts with zero-overhead calls.
+ *
+ * Usage:
+ *   import { wotsSign, sha3_256 } from '@totemsdk/core/wasm';
+ *   const sig = wotsSign(seed, 0, message); // synchronous!
+ */
+import { bytes_to_hex_wasm, clean_seed_phrase_wasm, compute_transaction_digest_wasm, concat_bytes_wasm, create_challenge_wasm, create_unified_child_tree_key_wasm, create_unified_root_tree_key_wasm, derive_chain_seed_wasm, derive_full_public_key_batch_wasm, derive_full_public_key_wasm, derive_per_address_seed_wasm, derive_pk_digest_batch_wasm, derive_pk_digest_wasm, derive_root_priv_seed_wasm, derive_unified_address_public_key_wasm, expand_private_key_wasm, generate_mnemonic_wasm, get_params, hash_chain_wasm, hex_to_bytes_wasm, make_mx_address_wasm, mine_txpow_chunk_wasm, mine_txpow_wasm, mmr_root_from_public_keys_wasm, parse_mx_address_wasm, phrase_to_seed_wasm, precompute_transaction_coin_id_wasm, serialize_transaction_wasm, sha3_256_wasm, timing_safe_equal_wasm, validate_challenge_wasm, validate_phrase_wasm, verify_mmr_proof_wasm, verify_tree_signature_wasm, wasm_tree_key_free, wasm_tree_key_get_max_uses, wasm_tree_key_get_public_key, wasm_tree_key_get_uses, wasm_tree_key_new, wasm_tree_key_set_uses, wasm_tree_key_sign, wots_pk_from_sig_wasm, wots_sign_batch_wasm, wots_sign_wasm, wots_verify_digest_wasm, wots_verify_wasm, write_mini_data_wasm, write_mini_string_wasm } from '@totemsdk/core-wasm';
+export declare const bytesToHex: typeof bytes_to_hex_wasm;
+export declare const hexToBytes: typeof hex_to_bytes_wasm;
+export declare const concatBytes: typeof concat_bytes_wasm;
+export declare const sha3_256: typeof sha3_256_wasm;
+export declare const expandPrivateKey: typeof expand_private_key_wasm;
+export declare const hashChain: typeof hash_chain_wasm;
+export declare const derivePKdigest: typeof derive_pk_digest_wasm;
+export declare const deriveFullPublicKey: typeof derive_full_public_key_wasm;
+export declare const wotsSign: typeof wots_sign_wasm;
+export declare const wotsVerify: typeof wots_verify_wasm;
+export declare const wotsVerifyDigest: typeof wots_verify_digest_wasm;
+export declare const wotsPkFromSig: typeof wots_pk_from_sig_wasm;
+export declare const wotsPublicKeyFromSeed: typeof derive_pk_digest_wasm;
+export declare const deriveChainSeedJava: typeof derive_chain_seed_wasm;
+export declare const derivePerAddressSeed: typeof derive_per_address_seed_wasm;
+export declare const deriveRootPrivSeed: typeof derive_root_priv_seed_wasm;
+export declare const phraseToSeed: typeof phrase_to_seed_wasm;
+export declare const generateWordList: typeof generate_mnemonic_wasm;
+export declare const validatePhrase: typeof validate_phrase_wasm;
+export declare const cleanSeedPhrase: typeof clean_seed_phrase_wasm;
+export declare const makeMxAddress: typeof make_mx_address_wasm;
+export declare const parseMxAddress: typeof parse_mx_address_wasm;
+export declare function wotsAddressFromKeypair(seed: Uint8Array, index: number): string;
+export declare function wotsAddressFromKeypair(kp: {
+    seed: Uint8Array;
+    index: number;
+}): string;
+export declare const serializeTransaction: typeof serialize_transaction_wasm;
+export declare const computeTransactionDigest: typeof compute_transaction_digest_wasm;
+export declare const precomputeTransactionCoinID: typeof precompute_transaction_coin_id_wasm;
+export declare const verifyTreeSignature: typeof verify_tree_signature_wasm;
+export declare const timingSafeEqual: typeof timing_safe_equal_wasm;
+export declare const createChallenge: typeof create_challenge_wasm;
+export declare const validateChallenge: typeof validate_challenge_wasm;
+export declare function writeMiniNumber(value: bigint, scale?: number): Uint8Array;
+export declare const writeMiniData: typeof write_mini_data_wasm;
+export declare const writeMiniString: typeof write_mini_string_wasm;
+export declare const createUnifiedChildTreeKey: typeof create_unified_child_tree_key_wasm;
+export declare const createUnifiedRootTreeKey: typeof create_unified_root_tree_key_wasm;
+export declare const deriveUnifiedAddressPublicKey: typeof derive_unified_address_public_key_wasm;
+export declare const mmrRootFromPublicKeys: typeof mmr_root_from_public_keys_wasm;
+export declare const verifyMMRProof: typeof verify_mmr_proof_wasm;
+export { get_params as getParams };
+export declare const wotsSignBatch: typeof wots_sign_batch_wasm;
+export declare const derivePKdigestBatch: typeof derive_pk_digest_batch_wasm;
+export declare const deriveFullPublicKeyBatch: typeof derive_full_public_key_batch_wasm;
+export declare const mineTxPoW: typeof mine_txpow_wasm;
+export declare const mineTxPoWChunk: typeof mine_txpow_chunk_wasm;
+export declare const wasmTreeKeyNew: typeof wasm_tree_key_new;
+export declare const wasmTreeKeySign: typeof wasm_tree_key_sign;
+export declare const wasmTreeKeyGetPublicKey: typeof wasm_tree_key_get_public_key;
+export declare const wasmTreeKeyGetUses: typeof wasm_tree_key_get_uses;
+export declare const wasmTreeKeySetUses: typeof wasm_tree_key_set_uses;
+export declare const wasmTreeKeyGetMaxUses: typeof wasm_tree_key_get_max_uses;
+export declare const wasmTreeKeyFree: typeof wasm_tree_key_free;
+export declare function wotsKeypairFromSeed(seed: Uint8Array, index: number): {
+    seed: Uint8Array;
+    index: number;
+    pk: Uint8Array;
+};

package/dist/cjs/wasm-sync.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Synchronous WASM bridge — thin wrappers around @totemsdk/core-wasm.
+ *
+ * All functions are synchronous. The WASM module is initialized at import time.
+ * This replaces the async bridge in wasm-bridge.ts with zero-overhead calls.
+ *
+ * Usage:
+ *   import { wotsSign, sha3_256 } from '@totemsdk/core/wasm';
+ *   const sig = wotsSign(seed, 0, message); // synchronous!
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wasmTreeKeyFree = exports.wasmTreeKeyGetMaxUses = exports.wasmTreeKeySetUses = exports.wasmTreeKeyGetUses = exports.wasmTreeKeyGetPublicKey = exports.wasmTreeKeySign = exports.wasmTreeKeyNew = exports.mineTxPoWChunk = exports.mineTxPoW = exports.deriveFullPublicKeyBatch = exports.derivePKdigestBatch = exports.wotsSignBatch = exports.getParams = exports.verifyMMRProof = exports.mmrRootFromPublicKeys = exports.deriveUnifiedAddressPublicKey = exports.createUnifiedRootTreeKey = exports.createUnifiedChildTreeKey = exports.writeMiniString = exports.writeMiniData = exports.validateChallenge = exports.createChallenge = exports.timingSafeEqual = exports.verifyTreeSignature = exports.precomputeTransactionCoinID = exports.computeTransactionDigest = exports.serializeTransaction = exports.parseMxAddress = exports.makeMxAddress = exports.cleanSeedPhrase = exports.validatePhrase = exports.generateWordList = exports.phraseToSeed = exports.deriveRootPrivSeed = exports.derivePerAddressSeed = exports.deriveChainSeedJava = exports.wotsPublicKeyFromSeed = exports.wotsPkFromSig = exports.wotsVerifyDigest = exports.wotsVerify = exports.wotsSign = exports.deriveFullPublicKey = exports.derivePKdigest = exports.hashChain = exports.expandPrivateKey = exports.sha3_256 = exports.concatBytes = exports.hexToBytes = exports.bytesToHex = void 0;
+exports.wotsAddressFromKeypair = wotsAddressFromKeypair;
+exports.writeMiniNumber = writeMiniNumber;
+exports.wotsKeypairFromSeed = wotsKeypairFromSeed;
+// The bundler target initializes WASM synchronously at import time.
+// The nodejs target uses require() which is also synchronous.
+// Both targets export functions that are ready to call immediately.
+const core_wasm_1 = require("@totemsdk/core-wasm");
+Object.defineProperty(exports, "getParams", { enumerable: true, get: function () { return core_wasm_1.get_params; } });
+// ---------------------------------------------------------------------------
+// Re-export with clean names matching the original @totemsdk/core API
+// ---------------------------------------------------------------------------
+exports.bytesToHex = core_wasm_1.bytes_to_hex_wasm;
+exports.hexToBytes = core_wasm_1.hex_to_bytes_wasm;
+exports.concatBytes = core_wasm_1.concat_bytes_wasm;
+exports.sha3_256 = core_wasm_1.sha3_256_wasm;
+exports.expandPrivateKey = core_wasm_1.expand_private_key_wasm;
+exports.hashChain = core_wasm_1.hash_chain_wasm;
+exports.derivePKdigest = core_wasm_1.derive_pk_digest_wasm;
+exports.deriveFullPublicKey = core_wasm_1.derive_full_public_key_wasm;
+exports.wotsSign = core_wasm_1.wots_sign_wasm;
+exports.wotsVerify = core_wasm_1.wots_verify_wasm;
+exports.wotsVerifyDigest = core_wasm_1.wots_verify_digest_wasm;
+exports.wotsPkFromSig = core_wasm_1.wots_pk_from_sig_wasm;
+exports.wotsPublicKeyFromSeed = core_wasm_1.derive_pk_digest_wasm;
+exports.deriveChainSeedJava = core_wasm_1.derive_chain_seed_wasm;
+exports.derivePerAddressSeed = core_wasm_1.derive_per_address_seed_wasm;
+exports.deriveRootPrivSeed = core_wasm_1.derive_root_priv_seed_wasm;
+exports.phraseToSeed = core_wasm_1.phrase_to_seed_wasm;
+exports.generateWordList = core_wasm_1.generate_mnemonic_wasm;
+exports.validatePhrase = core_wasm_1.validate_phrase_wasm;
+exports.cleanSeedPhrase = core_wasm_1.clean_seed_phrase_wasm;
+exports.makeMxAddress = core_wasm_1.make_mx_address_wasm;
+exports.parseMxAddress = core_wasm_1.parse_mx_address_wasm;
+function wotsAddressFromKeypair(seedOrKp, index) {
+    if (seedOrKp instanceof Uint8Array) {
+        return (0, core_wasm_1.wots_address_from_keypair_wasm)(seedOrKp, index);
+    }
+    return (0, core_wasm_1.wots_address_from_keypair_wasm)(seedOrKp.seed, seedOrKp.index);
+}
+exports.serializeTransaction = core_wasm_1.serialize_transaction_wasm;
+exports.computeTransactionDigest = core_wasm_1.compute_transaction_digest_wasm;
+exports.precomputeTransactionCoinID = core_wasm_1.precompute_transaction_coin_id_wasm;
+exports.verifyTreeSignature = core_wasm_1.verify_tree_signature_wasm;
+exports.timingSafeEqual = core_wasm_1.timing_safe_equal_wasm;
+exports.createChallenge = core_wasm_1.create_challenge_wasm;
+exports.validateChallenge = core_wasm_1.validate_challenge_wasm;
+function writeMiniNumber(value, scale = 0) {
+    return (0, core_wasm_1.write_mini_number_wasm)(value.toString(), scale);
+}
+exports.writeMiniData = core_wasm_1.write_mini_data_wasm;
+exports.writeMiniString = core_wasm_1.write_mini_string_wasm;
+exports.createUnifiedChildTreeKey = core_wasm_1.create_unified_child_tree_key_wasm;
+exports.createUnifiedRootTreeKey = core_wasm_1.create_unified_root_tree_key_wasm;
+exports.deriveUnifiedAddressPublicKey = core_wasm_1.derive_unified_address_public_key_wasm;
+exports.mmrRootFromPublicKeys = core_wasm_1.mmr_root_from_public_keys_wasm;
+exports.verifyMMRProof = core_wasm_1.verify_mmr_proof_wasm;
+// ---------------------------------------------------------------------------
+// Batch WOTS APIs
+// ---------------------------------------------------------------------------
+exports.wotsSignBatch = core_wasm_1.wots_sign_batch_wasm;
+exports.derivePKdigestBatch = core_wasm_1.derive_pk_digest_batch_wasm;
+exports.deriveFullPublicKeyBatch = core_wasm_1.derive_full_public_key_batch_wasm;
+// ---------------------------------------------------------------------------
+// TxPoW Mining
+// ---------------------------------------------------------------------------
+exports.mineTxPoW = core_wasm_1.mine_txpow_wasm;
+exports.mineTxPoWChunk = core_wasm_1.mine_txpow_chunk_wasm;
+// ---------------------------------------------------------------------------
+// Stateful WasmTreeKey
+// ---------------------------------------------------------------------------
+exports.wasmTreeKeyNew = core_wasm_1.wasm_tree_key_new;
+exports.wasmTreeKeySign = core_wasm_1.wasm_tree_key_sign;
+exports.wasmTreeKeyGetPublicKey = core_wasm_1.wasm_tree_key_get_public_key;
+exports.wasmTreeKeyGetUses = core_wasm_1.wasm_tree_key_get_uses;
+exports.wasmTreeKeySetUses = core_wasm_1.wasm_tree_key_set_uses;
+exports.wasmTreeKeyGetMaxUses = core_wasm_1.wasm_tree_key_get_max_uses;
+exports.wasmTreeKeyFree = core_wasm_1.wasm_tree_key_free;
+// ---------------------------------------------------------------------------
+// Convenience: wotsKeypairFromSeed
+// ---------------------------------------------------------------------------
+function wotsKeypairFromSeed(seed, index) {
+    const pk = (0, core_wasm_1.derive_pk_digest_wasm)(seed, index);
+    return { seed, index, pk };
+}