@totemsdk/core 1.2.6 → 1.2.8

package/dist/cjs/lease/LeaseStore.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * @module LeaseStore
+ * WOTS lease lifecycle management with platform-agnostic storage
+ *
+ * Uses in-memory cache backed by persistent storage.
+ * Pattern:
+ * - initialize() loads from storage into memory cache
+ * - Sync getters read from memory cache (fast, no I/O)
+ * - Mutators update memory cache AND persist to storage
+ * - Caller MUST call initialize() before using sync getters
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeaseStore = void 0;
+const index_js_1 = require("../adapters/index.js");
+const DEFAULT_STORAGE_KEY = 'totem_wots_leases';
+class LeaseStore {
+    leases = new Map();
+    _initialized = false;
+    storageKey;
+    storage;
+    logger;
+    constructor(storage, logger = new index_js_1.NoopLogger(), config = {}) {
+        this.storage = storage;
+        this.logger = logger;
+        this.storageKey = config.storageKey ?? DEFAULT_STORAGE_KEY;
+    }
+    async initialize() {
+        if (this._initialized)
+            return;
+        await this.load();
+        await this.cleanupExpired();
+        this._initialized = true;
+    }
+    isInitialized() {
+        return this._initialized;
+    }
+    async load() {
+        try {
+            const leasesArray = await this.storage.get(this.storageKey);
+            if (leasesArray) {
+                this.leases = new Map(leasesArray.map(lease => [lease.leaseId, lease]));
+                this.logger.debug(`Loaded ${this.leases.size} leases from storage`);
+            }
+        }
+        catch (error) {
+            this.logger.error('Failed to load leases:', error);
+        }
+    }
+    async persist() {
+        try {
+            const leasesArray = Array.from(this.leases.values());
+            await this.storage.set(this.storageKey, leasesArray);
+        }
+        catch (error) {
+            this.logger.error('Failed to persist leases:', error);
+            throw error;
+        }
+    }
+    async save(lease) {
+        const flatIndex = this.flattenIndex(lease.indices);
+        this.logger.debug(`Storing lease: ${lease.leaseId}`);
+        this.logger.debug(`  indices: (addressIndex=${lease.indices.addressIndex}, l1=${lease.indices.l1}, l2=${lease.indices.l2}) [${flatIndex}/262,144]`);
+        this.logger.debug(`  status: ${lease.status}, TTL: ${lease.leaseTTL}ms`);
+        this.leases.set(lease.leaseId, lease);
+        await this.persist();
+    }
+    get(leaseId) {
+        return this.leases.get(leaseId);
+    }
+    getByToken(leaseToken) {
+        return Array.from(this.leases.values()).find(lease => lease.leaseToken === leaseToken);
+    }
+    getAll() {
+        return Array.from(this.leases.values());
+    }
+    getActive() {
+        const now = Date.now();
+        return this.getAll().filter(lease => lease.status === 'active' && lease.expiresAt > now);
+    }
+    getExpiringSoon(thresholdMs = 5000) {
+        const now = Date.now();
+        return this.getAll().filter(lease => lease.status === 'active' &&
+            lease.expiresAt > now &&
+            lease.expiresAt <= now + thresholdMs);
+    }
+    async delete(leaseId) {
+        const lease = this.leases.get(leaseId);
+        if (lease) {
+            this.logger.debug(`Deleting lease: ${leaseId}, final status: ${lease.status}`);
+        }
+        const existed = this.leases.delete(leaseId);
+        if (existed) {
+            await this.persist();
+        }
+        return existed;
+    }
+    async deleteByToken(leaseToken) {
+        const lease = this.getByToken(leaseToken);
+        if (lease) {
+            return this.delete(lease.leaseId);
+        }
+        return false;
+    }
+    async updateStatus(leaseId, status) {
+        const lease = this.leases.get(leaseId);
+        if (lease) {
+            const oldStatus = lease.status;
+            this.logger.debug(`Lease status change: ${leaseId} ${oldStatus} → ${status}`);
+            lease.status = status;
+            await this.persist();
+        }
+    }
+    async cleanupExpired() {
+        const now = Date.now();
+        const expiredLeaseIds = [];
+        for (const [leaseId, lease] of this.leases.entries()) {
+            if (lease.expiresAt <= now && lease.status !== 'finalized') {
+                lease.status = 'expired';
+                expiredLeaseIds.push(leaseId);
+            }
+        }
+        if (expiredLeaseIds.length > 0) {
+            this.logger.debug(`Marked ${expiredLeaseIds.length} leases as expired`);
+            await this.persist();
+        }
+        return expiredLeaseIds.length;
+    }
+    async clear() {
+        this.leases.clear();
+        await this.storage.remove(this.storageKey);
+        this.logger.debug('Cleared all leases');
+    }
+    getMinimumTTL() {
+        const activeLeases = this.getActive();
+        if (activeLeases.length === 0)
+            return null;
+        return Math.min(...activeLeases.map(lease => lease.leaseTTL));
+    }
+    calculateMonitoringInterval() {
+        const minTTL = this.getMinimumTTL();
+        if (minTTL === null)
+            return 5000;
+        const calculatedInterval = Math.min(minTTL / 4, 5000);
+        return Math.max(calculatedInterval, 1000);
+    }
+    flattenIndex(indices) {
+        return (indices.addressIndex * 64 * 64) + (indices.l1 * 64) + indices.l2;
+    }
+}
+exports.LeaseStore = LeaseStore;

package/dist/cjs/lease/WatermarkStore.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @module WatermarkStore
+ * WOTS index tracking with server synchronization
+ *
+ * Uses in-memory cache backed by persistent storage.
+ * Pattern:
+ * - initialize() loads from storage into memory cache (or creates default)
+ * - Sync getters read from memory cache (fast, no I/O)
+ * - Mutators update memory cache AND persist to storage
+ * - Caller MUST call initialize() before using sync getters
+ */
+import type { StorageAdapter, LoggerAdapter } from '../adapters/index.js';
+export interface WotsIndices {
+    addressIndex: number;
+    l1: number;
+    l2: number;
+}
+export interface WatermarkState {
+    next_addressIndex: number;
+    next_l1: number;
+    next_l2: number;
+    usedIndices: Array<[number, number, number]>;
+    lastSyncTimestamp?: number;
+    serverWatermark?: WotsIndices;
+}
+export interface SyncResult {
+    updated: boolean;
+    drift: number;
+    hasConflict: boolean;
+}
+export interface WatermarkStoreConfig {
+    storageKey?: string;
+}
+export declare class WatermarkStore {
+    private state;
+    private _initialized;
+    private readonly storageKey;
+    private readonly storage;
+    private readonly logger;
+    constructor(storage: StorageAdapter, logger?: LoggerAdapter, config?: WatermarkStoreConfig);
+    initialize(): Promise<WatermarkState>;
+    isInitialized(): boolean;
+    load(): Promise<WatermarkState | null>;
+    save(watermark: WatermarkState): Promise<void>;
+    clear(): Promise<void>;
+    getCurrent(): WatermarkState | null;
+    getNextIndices(): WotsIndices | null;
+    isExhausted(): boolean;
+    hasAvailableIndices(): boolean;
+    markUsed(indices: WotsIndices): Promise<void>;
+    advanceWatermark(indices: WotsIndices): Promise<void>;
+    updateFromServer(serverWatermark: WotsIndices): Promise<SyncResult>;
+    getUsageStats(): {
+        used: number;
+        total: number;
+        percentage: number;
+    };
+    private calculateNextIndices;
+    private shouldUseServerWatermark;
+    private flattenIndex;
+}

package/dist/cjs/lease/WatermarkStore.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * @module WatermarkStore
+ * WOTS index tracking with server synchronization
+ *
+ * Uses in-memory cache backed by persistent storage.
+ * Pattern:
+ * - initialize() loads from storage into memory cache (or creates default)
+ * - Sync getters read from memory cache (fast, no I/O)
+ * - Mutators update memory cache AND persist to storage
+ * - Caller MUST call initialize() before using sync getters
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatermarkStore = void 0;
+const index_js_1 = require("../adapters/index.js");
+const DEFAULT_STORAGE_KEY = 'totem_wots_watermark';
+const MAX_INDEX_PER_LEVEL = 64;
+const TOTAL_INDICES = 64 * 64 * 64;
+class WatermarkStore {
+    state = null;
+    _initialized = false;
+    storageKey;
+    storage;
+    logger;
+    constructor(storage, logger = new index_js_1.NoopLogger(), config = {}) {
+        this.storage = storage;
+        this.logger = logger;
+        this.storageKey = config.storageKey ?? DEFAULT_STORAGE_KEY;
+    }
+    async initialize() {
+        if (this._initialized && this.state) {
+            return this.state;
+        }
+        const existing = await this.load();
+        if (existing) {
+            this._initialized = true;
+            return existing;
+        }
+        const initialState = {
+            next_addressIndex: 0,
+            next_l1: 0,
+            next_l2: 0,
+            usedIndices: []
+        };
+        await this.save(initialState);
+        this._initialized = true;
+        return initialState;
+    }
+    isInitialized() {
+        return this._initialized;
+    }
+    async load() {
+        try {
+            const watermark = await this.storage.get(this.storageKey);
+            if (watermark) {
+                this.state = watermark;
+                this.logger.debug('Loaded watermark from storage');
+                return this.state;
+            }
+            return null;
+        }
+        catch (error) {
+            this.logger.error('Failed to load watermark:', error);
+            return null;
+        }
+    }
+    async save(watermark) {
+        try {
+            this.state = watermark;
+            await this.storage.set(this.storageKey, watermark);
+        }
+        catch (error) {
+            this.logger.error('Failed to save watermark:', error);
+            throw error;
+        }
+    }
+    async clear() {
+        try {
+            this.state = null;
+            this._initialized = false;
+            await this.storage.remove(this.storageKey);
+            this.logger.debug('Cleared watermark');
+        }
+        catch (error) {
+            this.logger.error('Failed to clear watermark:', error);
+            throw error;
+        }
+    }
+    getCurrent() {
+        return this.state;
+    }
+    getNextIndices() {
+        if (!this.state || this.isExhausted()) {
+            return null;
+        }
+        return {
+            addressIndex: this.state.next_addressIndex,
+            l1: this.state.next_l1,
+            l2: this.state.next_l2
+        };
+    }
+    isExhausted() {
+        if (!this.state)
+            return false;
+        return this.state.next_addressIndex >= MAX_INDEX_PER_LEVEL;
+    }
+    hasAvailableIndices() {
+        return !this.isExhausted();
+    }
+    async markUsed(indices) {
+        if (!this.state) {
+            await this.load();
+        }
+        if (!this.state) {
+            throw new Error('Watermark not initialized');
+        }
+        const indexTuple = [indices.addressIndex, indices.l1, indices.l2];
+        const flatIndex = this.flattenIndex(indices.addressIndex, indices.l1, indices.l2);
+        const alreadyUsed = this.state.usedIndices.some(([addressIndex, l1, l2]) => addressIndex === indices.addressIndex && l1 === indices.l1 && l2 === indices.l2);
+        if (!alreadyUsed) {
+            this.logger.debug(`Marking indices as USED: (addressIndex=${indices.addressIndex}, l1=${indices.l1}, l2=${indices.l2}) [${flatIndex}/${TOTAL_INDICES}]`);
+            this.logger.debug(`  total used: ${this.state.usedIndices.length + 1} / ${TOTAL_INDICES}`);
+            this.state.usedIndices.push(indexTuple);
+        }
+        else {
+            this.logger.warn(`Indices already marked as used: (addressIndex=${indices.addressIndex}, l1=${indices.l1}, l2=${indices.l2})`);
+        }
+        await this.save(this.state);
+    }
+    async advanceWatermark(indices) {
+        if (!this.state) {
+            await this.load();
+        }
+        if (!this.state) {
+            throw new Error('Watermark not initialized');
+        }
+        const currentFlat = this.flattenIndex(indices.addressIndex, indices.l1, indices.l2);
+        const nextIndices = this.calculateNextIndices(indices);
+        const nextFlat = this.flattenIndex(nextIndices.addressIndex, nextIndices.l1, nextIndices.l2);
+        this.logger.debug(`Advancing watermark...`);
+        this.logger.debug(`  current: (addressIndex=${indices.addressIndex}, l1=${indices.l1}, l2=${indices.l2}) [${currentFlat}/${TOTAL_INDICES}]`);
+        this.logger.debug(`  next:    (addressIndex=${nextIndices.addressIndex}, l1=${nextIndices.l1}, l2=${nextIndices.l2}) [${nextFlat}/${TOTAL_INDICES}]`);
+        this.state.next_addressIndex = nextIndices.addressIndex;
+        this.state.next_l1 = nextIndices.l1;
+        this.state.next_l2 = nextIndices.l2;
+        await this.save(this.state);
+        this.logger.debug('Watermark advanced and persisted');
+    }
+    async updateFromServer(serverWatermark) {
+        if (!this.state) {
+            await this.load();
+        }
+        if (!this.state) {
+            await this.initialize();
+        }
+        const localIndexFlat = this.flattenIndex(this.state.next_addressIndex, this.state.next_l1, this.state.next_l2);
+        const serverIndexFlat = this.flattenIndex(serverWatermark.addressIndex, serverWatermark.l1, serverWatermark.l2);
+        const drift = serverIndexFlat - localIndexFlat;
+        const hasConflict = drift > 1;
+        const needsUpdate = this.shouldUseServerWatermark(this.state, serverWatermark);
+        if (needsUpdate) {
+            this.logger.debug(`Updating watermark from server (drift: ${drift})`);
+            this.state.next_addressIndex = serverWatermark.addressIndex;
+            this.state.next_l1 = serverWatermark.l1;
+            this.state.next_l2 = serverWatermark.l2;
+            this.state.serverWatermark = serverWatermark;
+            this.state.lastSyncTimestamp = Date.now();
+            await this.save(this.state);
+            return { updated: true, drift, hasConflict };
+        }
+        this.state.lastSyncTimestamp = Date.now();
+        await this.save(this.state);
+        return { updated: false, drift, hasConflict };
+    }
+    getUsageStats() {
+        const used = this.state?.usedIndices.length ?? 0;
+        return {
+            used,
+            total: TOTAL_INDICES,
+            percentage: (used / TOTAL_INDICES) * 100
+        };
+    }
+    calculateNextIndices(current) {
+        let { addressIndex, l1, l2 } = current;
+        l2++;
+        if (l2 >= MAX_INDEX_PER_LEVEL) {
+            l2 = 0;
+            l1++;
+            if (l1 >= MAX_INDEX_PER_LEVEL) {
+                l1 = 0;
+                addressIndex++;
+            }
+        }
+        return { addressIndex, l1, l2 };
+    }
+    shouldUseServerWatermark(local, server) {
+        if (server.addressIndex > local.next_addressIndex)
+            return true;
+        if (server.addressIndex === local.next_addressIndex && server.l1 > local.next_l1)
+            return true;
+        if (server.addressIndex === local.next_addressIndex && server.l1 === local.next_l1 && server.l2 > local.next_l2)
+            return true;
+        return false;
+    }
+    flattenIndex(addressIndex, l1, l2) {
+        return (addressIndex * MAX_INDEX_PER_LEVEL * MAX_INDEX_PER_LEVEL) + (l1 * MAX_INDEX_PER_LEVEL) + l2;
+    }
+}
+exports.WatermarkStore = WatermarkStore;

package/dist/cjs/lease/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @module @totemsdk/core/lease
+ * WOTS lease lifecycle management
+ *
+ * This module provides:
+ * - LeaseStore: Persistent storage for lease records with in-memory cache
+ * - WatermarkStore: WOTS index tracking with server sync
+ * - LeaseMonitor: Expiry monitoring and renewal
+ */
+export { LeaseStore, type StoredLease, type LeaseStatus, type LeaseStoreConfig, type WotsIndices as LeaseWotsIndices, } from './LeaseStore.js';
+export { WatermarkStore, type WatermarkState, type SyncResult, type WatermarkStoreConfig, } from './WatermarkStore.js';
+export type { WotsIndices } from './WatermarkStore.js';
+export { LeaseMonitor, type LeaseExpiryEvent, type LeaseExpiryCallback, type LeaseMonitorConfig, } from './LeaseMonitor.js';
+export { prepareLease, finalizeLease, flatIndexFromLanes, type PrepareArgs, type PrepareResp } from '../lease-client.js';

package/dist/cjs/lease/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * @module @totemsdk/core/lease
+ * WOTS lease lifecycle management
+ *
+ * This module provides:
+ * - LeaseStore: Persistent storage for lease records with in-memory cache
+ * - WatermarkStore: WOTS index tracking with server sync
+ * - LeaseMonitor: Expiry monitoring and renewal
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatIndexFromLanes = exports.finalizeLease = exports.prepareLease = exports.LeaseMonitor = exports.WatermarkStore = exports.LeaseStore = void 0;
+var LeaseStore_js_1 = require("./LeaseStore.js");
+Object.defineProperty(exports, "LeaseStore", { enumerable: true, get: function () { return LeaseStore_js_1.LeaseStore; } });
+var WatermarkStore_js_1 = require("./WatermarkStore.js");
+Object.defineProperty(exports, "WatermarkStore", { enumerable: true, get: function () { return WatermarkStore_js_1.WatermarkStore; } });
+var LeaseMonitor_js_1 = require("./LeaseMonitor.js");
+Object.defineProperty(exports, "LeaseMonitor", { enumerable: true, get: function () { return LeaseMonitor_js_1.LeaseMonitor; } });
+var lease_client_js_1 = require("../lease-client.js");
+Object.defineProperty(exports, "prepareLease", { enumerable: true, get: function () { return lease_client_js_1.prepareLease; } });
+Object.defineProperty(exports, "finalizeLease", { enumerable: true, get: function () { return lease_client_js_1.finalizeLease; } });
+Object.defineProperty(exports, "flatIndexFromLanes", { enumerable: true, get: function () { return lease_client_js_1.flatIndexFromLanes; } });

package/dist/cjs/lease-client.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Totem <-> Axia hardened WOTS helpers (no deps on server internals).
+ */
+export type PrepareArgs = {
+    txId: string;
+    rootPublicKey: string;
+    to: string;
+    amount: string;
+    tokenId?: string;
+    burn?: string | null;
+    digestL2?: string | null;
+    digestL3?: string | null;
+    ttlMs?: number;
+};
+export type PrepareResp = {
+    leaseToken: string;
+    lease: {
+        addressIndex: number;
+        l1: number;
+        l2: number;
+    };
+    txId: string;
+    digestTx?: string | null;
+};
+export declare function prepareLease(apiUrl: string, apiKey: string, args: PrepareArgs): Promise<PrepareResp>;
+export declare function finalizeLease(apiUrl: string, apiKey: string, leaseToken: string, signedHex: string): Promise<{
+    status: number;
+    body: string;
+}>;
+/** lane tuple -> flat WOTS index (64^3 space) */
+export declare function flatIndexFromLanes(addressIndex: number, l1: number, l2: number): number;

package/dist/cjs/lease-client.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareLease = prepareLease;
+exports.finalizeLease = finalizeLease;
+exports.flatIndexFromLanes = flatIndexFromLanes;
+async function prepareLease(apiUrl, apiKey, args) {
+    const res = await fetch(`${apiUrl}/v1/wots-hardened/prepare`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', 'x-api-key': apiKey },
+        body: JSON.stringify({
+            tokenId: "0x00",
+            burn: null,
+            digestL2: null,
+            digestL3: null,
+            ttlMs: 20000,
+            ...args
+        })
+    });
+    if (!res.ok)
+        throw new Error(`prepareLease ${res.status}`);
+    const raw = await res.json();
+    const lease = raw.lease ?? { addressIndex: raw.addressIndex ?? 0, l1: raw.l1 ?? 0, l2: raw.l2 ?? 0 };
+    return {
+        leaseToken: raw.leaseToken,
+        lease,
+        txId: raw.txId,
+        digestTx: raw.digestTx ?? null
+    };
+}
+async function finalizeLease(apiUrl, apiKey, leaseToken, signedHex) {
+    const res = await fetch(`${apiUrl}/v1/wots-hardened/finalize`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', 'x-api-key': apiKey },
+        body: JSON.stringify({ leaseToken, signedHex })
+    });
+    const text = await res.text();
+    return { status: res.status, body: text };
+}
+/** lane tuple -> flat WOTS index (64^3 space) */
+function flatIndexFromLanes(addressIndex, l1, l2) {
+    if (addressIndex | l1 | l2 & ~63)
+        throw new Error('lane out of range');
+    return (addressIndex * 64 * 64) + (l1 * 64) + l2;
+}

package/dist/cjs/legacy.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Legacy JS implementations — backward compatibility.
+ *
+ * These are the original TypeScript implementations preserved for
+ * environments where WASM is not available. The main entry point
+ * (`@totemsdk/core`) now delegates to WASM by default.
+ *
+ * Import legacy implementations directly:
+ *   import { wotsSign } from '@totemsdk/core/legacy';
+ */
+export { F, hex, fromHex, u16be, u32be, assert32, h, prfChainSeed, toWinternitzDigits, baseWWithChecksum, derivePKdigest as legacyDerivePKdigest, wotsKeypairFromSeed as legacyWotsKeypairFromSeed, wotsSign as legacyWotsSign, wotsSignLegacy, wotsPkFromSig as legacyWotsPkFromSig, wotsVerify as legacyWotsVerify, wotsVerifyDigest as legacyWotsVerifyDigest, wotsPublicKeyFromSeed as legacyWotsPublicKeyFromSeed, type WotsKeypair, type WotsSignature, } from './wots.js';
+export { TreeKey, TreeKeyNode, verifyTreeSignature as legacyVerifyTreeSignature, serializeTreeSignature, deserializeTreeSignature, getRootPublicKey, DEFAULT_KEYS_PER_LEVEL, DEFAULT_LEVELS, createUnifiedChildTreeKey as legacyCreateUnifiedChildTreeKey, createUnifiedChildTreeKeyAsync, createUnifiedRootTreeKey as legacyCreateUnifiedRootTreeKey, deriveUnifiedAddressPublicKey as legacyDeriveUnifiedAddressPublicKey, createPerAddressTreeKey, createPerAddressTreeKeyAsync, type KeyGenProgress, type ProgressCallback, type SignatureProof, type TreeSignature, } from './treekey.js';
+export { MMRTree, mmrLeafExact, mmrRootFromSingleLeaf, createMMRDataLeafNode, createMMRDataParentNode, calculateProofRoot, verifyMMRProof as legacyVerifyMMRProof, parseMMRProofFromHex, deserializeMMRProof, serializeMMRProof, serializeRealMMRProof, type MMRData, type MMREntry, type MMRProof, type MMRProofChunk, type Bytes, } from './mmr.js';
+export { WORD_LIST, cleanSeedPhrase as legacyCleanSeedPhrase, validatePhrase as legacyValidatePhrase, convertStringToSeed, convertWordListToSeed, phraseToSeed as legacyPhraseToSeed, generateWordList as legacyGenerateWordList, generateSeedPhrase, } from './bip39.js';
+export { type MinimaTransaction, type MinimaCoin, type ParsedMiniNumber, type MinimaToken, type StateVariable, type RawStateVariable, type CoinProofData, type SpendableCoinInput, type TransactionBuildResult, parseDecimalToMiniNumber, serializeCoin, serializeTransaction as legacySerializeTransaction, computeTransactionDigest as legacyComputeTransactionDigest, precomputeTransactionCoinID as legacyPrecomputeTransactionCoinID, createDefaultTransaction, buildMinimaCoin, } from './transaction.js';
+export { scriptToAddress, addressToRoot } from './derive.js';
+export { scriptFromWotsPk, wotsAddressFromKeypair as legacyWotsAddressFromKeypair } from './script.js';
+export { encodeMxRadix32Frame, decodeMxRadix32Frame, makeMxAddress as legacyMakeMxAddress, parseMxAddress as legacyParseMxAddress, hexToMx, mxToHex, encodeMx, decodeMx, makeMinimaAddress, convertMinimaAddress, } from './minima32.js';
+export { writeMiniNumber as legacyWriteMiniNumber, writeMiniData as legacyWriteMiniData, writeMiniByte, writeMMREntryNumber, concat, hexToBytes as legacyHexToBytes, bytesToHex as legacyBytesToHex, bigIntToByteArray, writeMiniString as legacyWriteMiniString, writeHashToStream, } from './Streamable.js';
+export { serializeMiniNumber, serializeMiniData, hashAllObjects, deriveChainSeedJava as legacyDeriveChainSeedJava, deriveChildTreeSeedJava, hashObject, serializeMiniNumberZERO, serializeMiniNumberONE, javaHashAllObjects, indexToMiniDataBytes, derivePerAddressSeed as legacyDerivePerAddressSeed, deriveRootPrivSeed as legacyDeriveRootPrivSeed, deriveUnifiedChildSeed, createMMREntryNumber, serializeMMREntryNumber, serializeMMRData, serializeMMREntry, precomputeTransactionCoinID as legacyPrecomputeTransactionCoinIDTx, type MMREntryNumber as JavaMMREntryNumber, type MMRData as JavaMMRData, type MMREntry as JavaMMREntry, } from './javaStreamables.js';
+export { concatBytes as legacyConcatBytes } from './utils.js';
+export * from './params.js';
+export { verifySignature, verifySignatureDetailed, verifyTreeSignatureDetailed, deriveAddressFromPublicKey, normalizeHex, createChallenge as legacyCreateChallenge, validateChallenge as legacyValidateChallenge, type VerificationResult, } from './verify.js';