@totemsdk/core 1.0.0

package/dist/lease/LeaseMonitor.js

@@ -0,0 +1,107 @@
+/**
+ * @module LeaseMonitor
+ * Monitors lease expiry and triggers renewal/cleanup actions
+ *
+ * Features:
+ * - Automatic expiry detection with configurable thresholds
+ * - Event-based notifications for expiring leases
+ * - Adaptive monitoring interval based on shortest TTL
+ */
+import { DefaultTimerAdapter, NoopLogger } from '../adapters/index.js';
+const DEFAULT_CONFIG = {
+    defaultIntervalMs: 5000,
+    expiryThresholdMs: 5000,
+    minIntervalMs: 1000,
+    maxIntervalMs: 30000,
+};
+export class LeaseMonitor {
+    constructor(leaseStore, timer = new DefaultTimerAdapter(), logger = new NoopLogger(), config = {}) {
+        this.timerHandle = null;
+        this.isRunning = false;
+        this.expiryCallbacks = new Set();
+        this.leaseStore = leaseStore;
+        this.timer = timer;
+        this.logger = logger;
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    start() {
+        if (this.isRunning) {
+            this.logger.debug('LeaseMonitor already running');
+            return;
+        }
+        this.isRunning = true;
+        this.scheduleNextCheck();
+        this.logger.debug('LeaseMonitor started');
+    }
+    stop() {
+        if (!this.isRunning)
+            return;
+        this.isRunning = false;
+        if (this.timerHandle !== null) {
+            this.timer.clearTimeout(this.timerHandle);
+            this.timerHandle = null;
+        }
+        this.logger.debug('LeaseMonitor stopped');
+    }
+    isActive() {
+        return this.isRunning;
+    }
+    onExpirySoon(callback) {
+        this.expiryCallbacks.add(callback);
+        return () => this.expiryCallbacks.delete(callback);
+    }
+    removeAllListeners() {
+        this.expiryCallbacks.clear();
+    }
+    async checkNow() {
+        const now = this.timer.now();
+        const expiringSoon = this.leaseStore.getExpiringSoon(this.config.expiryThresholdMs);
+        const events = expiringSoon.map(lease => ({
+            leaseId: lease.leaseId,
+            expiresAt: lease.expiresAt,
+            remainingMs: Math.max(0, lease.expiresAt - now),
+            lease,
+        }));
+        for (const event of events) {
+            this.notifyExpirySoon(event);
+        }
+        await this.leaseStore.cleanupExpired();
+        return events;
+    }
+    scheduleNextCheck() {
+        if (!this.isRunning)
+            return;
+        const interval = this.calculateInterval();
+        this.timerHandle = this.timer.setTimeout(() => {
+            this.runCheck();
+        }, interval);
+        this.logger.debug(`Next lease check scheduled in ${interval}ms`);
+    }
+    async runCheck() {
+        if (!this.isRunning)
+            return;
+        try {
+            await this.checkNow();
+        }
+        catch (error) {
+            this.logger.error('Error during lease check:', error);
+        }
+        this.scheduleNextCheck();
+    }
+    calculateInterval() {
+        const storeInterval = this.leaseStore.calculateMonitoringInterval();
+        const interval = Math.max(this.config.minIntervalMs, Math.min(storeInterval, this.config.maxIntervalMs));
+        return interval;
+    }
+    notifyExpirySoon(event) {
+        this.logger.debug(`Lease expiring soon: ${event.leaseId}, remaining: ${event.remainingMs}ms`);
+        this.expiryCallbacks.forEach(callback => {
+            try {
+                callback(event);
+            }
+            catch (error) {
+                this.logger.error('Error in expiry callback:', error);
+            }
+        });
+    }
+}

package/dist/lease/LeaseStore.d.ts

@@ -0,0 +1,57 @@
+/**
+ * @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
+ */
+import type { StorageAdapter, LoggerAdapter } from '../adapters/index.js';
+export interface WotsIndices {
+    addressIndex: number;
+    l1: number;
+    l2: number;
+}
+export type LeaseStatus = 'pending' | 'active' | 'expired' | 'finalized' | 'cancelled';
+export interface StoredLease {
+    leaseId: string;
+    leaseToken: string;
+    indices: WotsIndices;
+    expiresAt: number;
+    status: LeaseStatus;
+    createdAt: number;
+    txId?: string;
+    leaseTTL: number;
+}
+export interface LeaseStoreConfig {
+    storageKey?: string;
+}
+export declare class LeaseStore {
+    private leases;
+    private _initialized;
+    private readonly storageKey;
+    private readonly storage;
+    private readonly logger;
+    constructor(storage: StorageAdapter, logger?: LoggerAdapter, config?: LeaseStoreConfig);
+    initialize(): Promise<void>;
+    isInitialized(): boolean;
+    private load;
+    private persist;
+    save(lease: StoredLease): Promise<void>;
+    get(leaseId: string): StoredLease | undefined;
+    getByToken(leaseToken: string): StoredLease | undefined;
+    getAll(): StoredLease[];
+    getActive(): StoredLease[];
+    getExpiringSoon(thresholdMs?: number): StoredLease[];
+    delete(leaseId: string): Promise<boolean>;
+    deleteByToken(leaseToken: string): Promise<boolean>;
+    updateStatus(leaseId: string, status: LeaseStatus): Promise<void>;
+    cleanupExpired(): Promise<number>;
+    clear(): Promise<void>;
+    getMinimumTTL(): number | null;
+    calculateMonitoringInterval(): number;
+    private flattenIndex;
+}

package/dist/lease/LeaseStore.js

@@ -0,0 +1,144 @@
+/**
+ * @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
+ */
+import { NoopLogger } from '../adapters/index.js';
+const DEFAULT_STORAGE_KEY = 'totem_wots_leases';
+export class LeaseStore {
+    constructor(storage, logger = new NoopLogger(), config = {}) {
+        this.leases = new Map();
+        this._initialized = false;
+        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;
+    }
+}

package/dist/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/lease/WatermarkStore.js

@@ -0,0 +1,202 @@
+/**
+ * @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 { NoopLogger } from '../adapters/index.js';
+const DEFAULT_STORAGE_KEY = 'totem_wots_watermark';
+const MAX_INDEX_PER_LEVEL = 64;
+const TOTAL_INDICES = 64 * 64 * 64;
+export class WatermarkStore {
+    constructor(storage, logger = new NoopLogger(), config = {}) {
+        this.state = null;
+        this._initialized = false;
+        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;
+    }
+}

package/dist/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/lease/index.js

@@ -0,0 +1,13 @@
+/**
+ * @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, } from './LeaseStore.js';
+export { WatermarkStore, } from './WatermarkStore.js';
+export { LeaseMonitor, } from './LeaseMonitor.js';
+export { prepareLease, finalizeLease, flatIndexFromLanes } from '../lease-client.js';

package/dist/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/lease-client.js

@@ -0,0 +1,39 @@
+export 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
+    };
+}
+export 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) */
+export 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/minima32.d.ts

@@ -0,0 +1,18 @@
+export declare function encodeMxRadix32Frame(frame: Uint8Array): string;
+export declare function decodeMxRadix32Frame(mx: string): Uint8Array;
+/** Encode raw 32 bytes to Mx address with frame and checksum */
+export declare function makeMxAddress(root32: Uint8Array): string;
+/** Decode Mx address to raw 32 bytes, validating frame and checksum */
+export declare function parseMxAddress(mx: string): Uint8Array;
+/** Make an Mx address from a hex string (legacy API compatibility) */
+export declare function hexToMx(hex: string): string;
+/** Convert an Mx address back to uppercase hex (legacy API compatibility) */
+export declare function mxToHex(mx: string): string;
+/** @deprecated Use makeMxAddress */
+export declare const encodeMx: typeof makeMxAddress;
+/** @deprecated Use parseMxAddress */
+export declare const decodeMx: typeof parseMxAddress;
+/** @deprecated Use hexToMx */
+export declare const makeMinimaAddress: typeof hexToMx;
+/** @deprecated Use mxToHex */
+export declare const convertMinimaAddress: typeof mxToHex;