@totemsdk/wots-lease 0.1.1 → 0.1.3

package/dist/watermark.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * WotsWatermarkStore — canonical v3 implementation
  *
@@ -6,16 +7,20 @@
  * - Enforces monotonicity: unavailable map can only grow, cursors can only advance.
  * - Storage key unchanged ('totem_wots_watermark') to avoid storage churn.
  */
-import { NoopLogger } from '@totemsdk/core';
-import { WatermarkMonotonicityError, WatermarkExhaustedError } from './errors.js';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WotsWatermarkStore = void 0;
+exports.flatIndex = flatIndex;
+exports.fromFlatIndex = fromFlatIndex;
+const core_1 = require("@totemsdk/core");
+const errors_js_1 = require("./errors.js");
 const STORAGE_KEY = 'totem_wots_watermark';
 const MAX_L = 64;
 const CAPACITY_PER_TREE = MAX_L * MAX_L * MAX_L;
 const DEFAULT_TREE = 'default';
-export function flatIndex(idx) {
+function flatIndex(idx) {
     return idx.addressIndex * MAX_L * MAX_L + idx.l1 * MAX_L + idx.l2;
 }
-export function fromFlatIndex(flat) {
+function fromFlatIndex(flat) {
     const addressIndex = Math.floor(flat / (MAX_L * MAX_L));
     const rem = flat % (MAX_L * MAX_L);
     const l1 = Math.floor(rem / MAX_L);
@@ -82,8 +87,8 @@ function migrateToV3(raw) {
     tree.l2Cursor = v1.next_l2 ?? 0;
     return { version: 3, trees: { [DEFAULT_TREE]: tree } };
 }
-export class WotsWatermarkStore {
-    constructor(storage, logger = new NoopLogger()) {
+class WotsWatermarkStore {
+    constructor(storage, logger = new core_1.NoopLogger()) {
         this.storage = storage;
         this.state = null;
         this._initialized = false;
@@ -132,7 +137,7 @@ export class WotsWatermarkStore {
             cur = nxt;
             attempts++;
         }
-        throw new WatermarkExhaustedError(treeId);
+        throw new errors_js_1.WatermarkExhaustedError(treeId);
     }
     async markUnavailable(treeId, indices, reason) {
         const tree = this.getOrCreateTree(treeId);
@@ -164,12 +169,12 @@ export class WotsWatermarkStore {
         const existingFlat = flatIndex({ addressIndex: existing.addressCursor, l1: existing.l1Cursor, l2: existing.l2Cursor });
         const newFlat = flatIndex({ addressIndex: merged.addressCursor, l1: merged.l1Cursor, l2: merged.l2Cursor });
         if (newFlat < existingFlat) {
-            throw new WatermarkMonotonicityError(`Cannot decrease watermark cursor for ${treeId}: ${existingFlat} → ${newFlat}`);
+            throw new errors_js_1.WatermarkMonotonicityError(`Cannot decrease watermark cursor for ${treeId}: ${existingFlat} → ${newFlat}`);
         }
         const existingUnavailCount = Object.keys(existing.unavailable).length;
         const newUnavailCount = Object.keys(merged.unavailable).length;
         if (newUnavailCount < existingUnavailCount) {
-            throw new WatermarkMonotonicityError(`Cannot shrink unavailable map for ${treeId}: ${existingUnavailCount} → ${newUnavailCount}`);
+            throw new errors_js_1.WatermarkMonotonicityError(`Cannot shrink unavailable map for ${treeId}: ${existingUnavailCount} → ${newUnavailCount}`);
         }
         s.trees[treeId] = merged;
         await this.persist();
@@ -196,3 +201,4 @@ export class WotsWatermarkStore {
         await this.storage.remove(STORAGE_KEY);
     }
 }
+exports.WotsWatermarkStore = WotsWatermarkStore;

package/package.json

@@ -1,26 +1,27 @@
 {
   "name": "@totemsdk/wots-lease",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "WOTS key-use coordination — canonical v3 watermark, provider-based lease safety layers",
-  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
       "import": "./dist/index.js"
     }
   },
   "files": [
     "dist",
-    "src"
+    "README.md",
+    "LICENSE"
   ],
   "dependencies": {
-    "@totemsdk/core": "1.0.6",
-    "@totemsdk/lookup-protocol": "0.1.1"
+    "@totemsdk/lookup-protocol": "0.1.3",
+    "@totemsdk/core": "1.0.10"
   },
   "devDependencies": {
-    "@noble/hashes": "^1.3.0",
+    "@noble/hashes": "^2.2.0",
     "@types/jest": "^29.0.0",
     "@types/node": "^20.0.0",
     "jest": "^29.0.0",
@@ -34,6 +35,26 @@
     "access": "public"
   },
   "license": "MIT",
+  "author": "Totem SDK",
+  "homepage": "https://totemsdk.com",
+  "bugs": {
+    "url": "https://github.com/MrGheek/axia-totem/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MrGheek/axia-totem.git",
+    "directory": "packages/totem-sdk/packages/wots-lease"
+  },
+  "keywords": [
+    "totem",
+    "totemsdk",
+    "minima",
+    "blockchain",
+    "quantum-resistant",
+    "wots",
+    "kissvm",
+    "utxo"
+  ],
   "scripts": {
     "build": "tsc",
     "clean": "rm -rf dist",

package/src/__tests__/watermark.test.ts

@@ -1,200 +0,0 @@
-import { WotsWatermarkStore, flatIndex, fromFlatIndex } from '../watermark';
-import { WatermarkMonotonicityError, WatermarkExhaustedError } from '../errors';
-import { LocalLeaseProvider } from '../local';
-import { allocateDeviceRange } from '../device';
-import type { StorageAdapter } from '@totemsdk/core';
-
-function makeMemStorage(): StorageAdapter {
-  const store = new Map<string, unknown>();
-  return {
-    get: async <T>(key: string) => (store.has(key) ? (store.get(key) as T) : null),
-    set: async <T>(key: string, value: T) => { store.set(key, value); },
-    remove: async (key: string) => { const had = store.has(key); store.delete(key); return had; },
-    clear: async () => { store.clear(); },
-    keys: async () => Array.from(store.keys()),
-    has: async (key: string) => store.has(key),
-  };
-}
-
-describe('flatIndex / fromFlatIndex', () => {
-  it('round-trips', () => {
-    const cases = [
-      { addressIndex: 0, l1: 0, l2: 0 },
-      { addressIndex: 0, l1: 0, l2: 63 },
-      { addressIndex: 0, l1: 63, l2: 63 },
-      { addressIndex: 63, l1: 63, l2: 63 },
-      { addressIndex: 5, l1: 12, l2: 37 },
-    ];
-    for (const idx of cases) {
-      expect(fromFlatIndex(flatIndex(idx))).toEqual(idx);
-    }
-  });
-
-  it('total capacity is 64^3 = 262144', () => {
-    expect(flatIndex({ addressIndex: 63, l1: 63, l2: 63 })).toBe(262143);
-  });
-});
-
-describe('WotsWatermarkStore', () => {
-  it('initializes empty on first use', async () => {
-    const store = new WotsWatermarkStore(makeMemStorage());
-    await store.initialize();
-    const wm = store.getLocalWatermark('tree1');
-    expect(wm.addressCursor).toBe(0);
-    expect(wm.l1Cursor).toBe(0);
-    expect(wm.l2Cursor).toBe(0);
-    expect(wm.unavailableCount).toBe(0);
-    expect(wm.capacity).toBe(262144);
-  });
-
-  it('getNextIndices returns cursor position', async () => {
-    const store = new WotsWatermarkStore(makeMemStorage());
-    await store.initialize();
-    const idx = store.getNextIndices('tree1');
-    expect(idx).toEqual({ addressIndex: 0, l1: 0, l2: 0 });
-  });
-
-  it('markUnavailable advances cursor and records reason', async () => {
-    const store = new WotsWatermarkStore(makeMemStorage());
-    await store.initialize();
-    await store.markUnavailable('tree1', { addressIndex: 0, l1: 0, l2: 0 }, 'committed');
-    const next = store.getNextIndices('tree1');
-    expect(next).toEqual({ addressIndex: 0, l1: 0, l2: 1 });
-    expect(store.isUnavailable('tree1', { addressIndex: 0, l1: 0, l2: 0 })).toBe(true);
-    expect(store.isUnavailable('tree1', { addressIndex: 0, l1: 0, l2: 1 })).toBe(false);
-  });
-
-  it('migrates v1 flat state automatically', async () => {
-    const storage = makeMemStorage();
-    await storage.set('totem_wots_watermark', {
-      next_addressIndex: 0,
-      next_l1: 0,
-      next_l2: 3,
-      usedIndices: [[0, 0, 0], [0, 0, 1], [0, 0, 2]],
-    });
-    const store = new WotsWatermarkStore(storage);
-    await store.initialize();
-    const wm = store.getLocalWatermark('default');
-    expect(wm.unavailableCount).toBe(3);
-  });
-
-  it('migrates v2 per-address state automatically', async () => {
-    const storage = makeMemStorage();
-    await storage.set('totem_wots_watermark', {
-      version: 2,
-      addresses: {
-        0: { next_l1: 0, next_l2: 2, usedIndices: [[0, 0], [0, 1]] },
-      },
-    });
-    const store = new WotsWatermarkStore(storage);
-    await store.initialize();
-    const wm = store.getLocalWatermark('default');
-    expect(wm.unavailableCount).toBe(2);
-  });
-
-  it('throws WatermarkMonotonicityError if cursor decreases', async () => {
-    const store = new WotsWatermarkStore(makeMemStorage());
-    await store.initialize();
-    await store.markUnavailable('t', { addressIndex: 0, l1: 0, l2: 5 }, 'committed');
-    await expect(
-      store.save('t', { addressCursor: 0, l1Cursor: 0, l2Cursor: 0, unavailable: {} }),
-    ).rejects.toThrow(WatermarkMonotonicityError);
-  });
-
-  it('throws WatermarkMonotonicityError if unavailable map shrinks', async () => {
-    const store = new WotsWatermarkStore(makeMemStorage());
-    await store.initialize();
-    await store.markUnavailable('t', { addressIndex: 0, l1: 0, l2: 0 }, 'committed');
-    await expect(
-      store.save('t', { addressCursor: 0, l1Cursor: 0, l2Cursor: 1, unavailable: {} }),
-    ).rejects.toThrow(WatermarkMonotonicityError);
-  });
-});
-
-describe('LocalLeaseProvider', () => {
-  it('reserves and commits successfully', async () => {
-    const provider = new LocalLeaseProvider(makeMemStorage());
-    await provider.initialize();
-
-    const reservation = await provider.reserveKeyUse({ treeId: 'wallet' });
-    expect(reservation.reservationId).toBeTruthy();
-    expect(reservation.indices).toEqual({ addressIndex: 0, l1: 0, l2: 0 });
-
-    await provider.commitKeyUse(reservation.reservationId, '0xTXID');
-
-    const wm = await provider.getLocalWatermark('wallet');
-    expect(wm.unavailableCount).toBe(1);
-  });
-
-  it('burns reservation — marks index permanently unavailable', async () => {
-    const storage = makeMemStorage();
-    const provider = new LocalLeaseProvider(storage);
-    await provider.initialize();
-
-    const reservation = await provider.reserveKeyUse({ treeId: 'wallet' });
-    await provider.burnReservation(reservation.reservationId, 'test burn');
-
-    const store = new WotsWatermarkStore(storage);
-    await store.initialize();
-    expect(store.isUnavailable('wallet', reservation.indices)).toBe(true);
-  });
-
-  it('two consecutive reserves yield different indices', async () => {
-    const provider = new LocalLeaseProvider(makeMemStorage());
-    await provider.initialize();
-
-    const r1 = await provider.reserveKeyUse({ treeId: 'wallet' });
-    await provider.commitKeyUse(r1.reservationId, '0xA');
-    const r2 = await provider.reserveKeyUse({ treeId: 'wallet' });
-
-    expect(flatIndex(r2.indices)).toBeGreaterThan(flatIndex(r1.indices));
-  });
-
-  it('syncLeaseJournal returns synced:true (local no-op)', async () => {
-    const provider = new LocalLeaseProvider(makeMemStorage());
-    await provider.initialize();
-    const result = await provider.syncLeaseJournal();
-    expect(result.synced).toBe(true);
-  });
-
-  it('verifyLeaseCertificate returns true when cert is undefined', async () => {
-    const provider = new LocalLeaseProvider(makeMemStorage());
-    await provider.initialize();
-    expect(await provider.verifyLeaseCertificate(undefined)).toBe(true);
-  });
-
-  it('verifyLeaseCertificate returns false for external cert', async () => {
-    const provider = new LocalLeaseProvider(makeMemStorage());
-    await provider.initialize();
-    const cert = {
-      reservationId: 'r1',
-      treeId: 'wallet',
-      indices: { addressIndex: 0, l1: 0, l2: 0 },
-      issuedBy: 'external-key',
-      issuedAt: Date.now(),
-      expiresAt: Date.now() + 120000,
-      signature: 'sig',
-    };
-    expect(await provider.verifyLeaseCertificate(cert)).toBe(false);
-  });
-});
-
-describe('allocateDeviceRange', () => {
-  it('slot 0 gets addressIndex 0–7', () => {
-    const range = allocateDeviceRange({ deviceSlot: 0, deviceId: 'phone' });
-    expect(range.startAddressIndex).toBe(0);
-    expect(range.endAddressIndex).toBe(7);
-    expect(range.addressCount).toBe(8);
-  });
-
-  it('slot 3 gets addressIndex 24–31', () => {
-    const range = allocateDeviceRange({ deviceSlot: 3, deviceId: 'pear' });
-    expect(range.startAddressIndex).toBe(24);
-    expect(range.endAddressIndex).toBe(31);
-  });
-
-  it('throws on out-of-range slot', () => {
-    expect(() => allocateDeviceRange({ deviceSlot: 8, deviceId: 'x' })).toThrow(RangeError);
-    expect(() => allocateDeviceRange({ deviceSlot: -1, deviceId: 'x' })).toThrow(RangeError);
-  });
-});

package/src/axia.ts

@@ -1,169 +0,0 @@
-/**
- * AxiaLeaseProvider — wraps the Axia API's /v1/wots-hardened endpoints.
- *
- * Callers do NOT need to call /finalize separately — commitKeyUse() does it.
- */
-
-import type { StorageAdapter, LoggerAdapter } from '@totemsdk/core';
-import { NoopLogger, LeaseStore, type StoredLease } from '@totemsdk/core';
-import { prepareLease, finalizeLease } from '@totemsdk/core';
-import type {
-  WotsLeaseProvider,
-  ReserveParams,
-  LeaseReservation,
-  LeaseCertificate,
-  LocalWatermark,
-  SyncResult,
-  SigningIndices,
-} from './types.js';
-import { WotsWatermarkStore, flatIndex } from './watermark.js';
-import { LeaseJournal } from './journal.js';
-import { LeaseNotFoundError } from './errors.js';
-
-export interface AxiaLeaseProviderConfig {
-  apiUrl: string;
-  apiKey: string;
-  rootPublicKey: string;
-  storage: StorageAdapter;
-  logger?: LoggerAdapter;
-}
-
-export class AxiaLeaseProvider implements WotsLeaseProvider {
-  private readonly watermark: WotsWatermarkStore;
-  private readonly leaseStore: LeaseStore;
-  private readonly journal: LeaseJournal;
-  private readonly apiUrl: string;
-  private readonly apiKey: string;
-  private readonly rootPublicKey: string;
-  private readonly logger: LoggerAdapter;
-  private _initialized = false;
-
-  constructor(config: AxiaLeaseProviderConfig) {
-    this.apiUrl = config.apiUrl;
-    this.apiKey = config.apiKey;
-    this.rootPublicKey = config.rootPublicKey;
-    this.logger = config.logger ?? new NoopLogger();
-    this.watermark = new WotsWatermarkStore(config.storage, this.logger);
-    this.leaseStore = new LeaseStore(config.storage, this.logger);
-    this.journal = new LeaseJournal(config.storage, this.logger);
-  }
-
-  async initialize(): Promise<void> {
-    if (this._initialized) return;
-    await this.watermark.initialize();
-    await this.leaseStore.initialize();
-    await this.journal.initialize();
-    this._initialized = true;
-  }
-
-  async reserveKeyUse(params: ReserveParams): Promise<LeaseReservation> {
-    if (!this._initialized) await this.initialize();
-
-    const txId = params.payloadHash ?? `tx-${Date.now()}`;
-    const resp = await prepareLease(this.apiUrl, this.apiKey, {
-      txId,
-      rootPublicKey: this.rootPublicKey,
-      to: params.treeId,
-      amount: params.valueHint ?? '0',
-      ttlMs: params.ttlMs ?? 120_000,
-    });
-
-    const indices: SigningIndices = resp.lease;
-    const expiresAt = Date.now() + (params.ttlMs ?? 120_000);
-    const reservationId = resp.txId;
-
-    const lease: StoredLease = {
-      leaseId: reservationId,
-      leaseToken: resp.leaseToken,
-      indices,
-      expiresAt,
-      status: 'active',
-      createdAt: Date.now(),
-      leaseTTL: params.ttlMs ?? 120_000,
-    };
-    await this.leaseStore.save(lease);
-
-    await this.journal.append({
-      treeId: params.treeId,
-      branchId: params.branchId ?? 'default',
-      wotsIndex: flatIndex(indices),
-      indices,
-      status: 'reserved',
-      payloadHash: params.payloadHash,
-      timestamp: Date.now(),
-      deviceId: params.deviceId ?? 'axia',
-    });
-
-    return { reservationId, indices, expiresAt, leaseToken: resp.leaseToken };
-  }
-
-  async commitKeyUse(reservationId: string, txId: string): Promise<void> {
-    if (!this._initialized) await this.initialize();
-    const lease = this.leaseStore.get(reservationId);
-    if (!lease) throw new LeaseNotFoundError(reservationId);
-
-    await finalizeLease(this.apiUrl, this.apiKey, lease.leaseToken, txId);
-
-    const indices: SigningIndices = lease.indices;
-    await this.watermark.markUnavailable(
-      lease.indices.addressIndex.toString(),
-      indices,
-      'committed',
-    );
-    await this.leaseStore.updateStatus(reservationId, 'finalized');
-
-    await this.journal.append({
-      treeId: reservationId,
-      branchId: 'default',
-      wotsIndex: flatIndex(indices),
-      indices,
-      status: 'committed',
-      txId,
-      timestamp: Date.now(),
-      deviceId: 'axia',
-    });
-  }
-
-  async burnReservation(reservationId: string, reason: string): Promise<void> {
-    if (!this._initialized) await this.initialize();
-    const lease = this.leaseStore.get(reservationId);
-    if (!lease) throw new LeaseNotFoundError(reservationId);
-
-    const indices: SigningIndices = lease.indices;
-    await this.watermark.markUnavailable(
-      lease.indices.addressIndex.toString(),
-      indices,
-      'burned',
-    );
-    await this.leaseStore.updateStatus(reservationId, 'cancelled');
-
-    this.logger.warn(`[AxiaLeaseProvider] Burning reservation ${reservationId}: ${reason}`);
-    await this.journal.append({
-      treeId: reservationId,
-      branchId: 'default',
-      wotsIndex: flatIndex(indices),
-      indices,
-      status: 'burned',
-      timestamp: Date.now(),
-      deviceId: 'axia',
-    });
-  }
-
-  async getLocalWatermark(treeId: string): Promise<LocalWatermark> {
-    if (!this._initialized) await this.initialize();
-    return this.watermark.getLocalWatermark(treeId);
-  }
-
-  async publishWatermark(_treeId: string): Promise<void> {
-    // Server maintains its own watermark via the lease API
-  }
-
-  async syncLeaseJournal(): Promise<SyncResult> {
-    return { synced: true, conflicts: [] };
-  }
-
-  async verifyLeaseCertificate(cert?: LeaseCertificate): Promise<boolean> {
-    if (cert === undefined) return true;
-    return false;
-  }
-}

package/src/device.ts

@@ -1,40 +0,0 @@
-/**
- * Device keyspace partitioning — Layer 2.
- *
- * Deterministic address-index range assignment per device slot.
- * Does NOT accept a raw seed; the caller derives the TreeKey in @totemsdk/core.
- *
- * Layout (8 device slots × 8 addresses each = 64 total):
- *   device 0 → addressIndex 0–7
- *   device 1 → addressIndex 8–15
- *   device 2 → addressIndex 16–23
- *   ...
- */
-
-import type { DeviceKeyRange } from './types.js';
-
-const ADDRESSES_PER_DEVICE = 8;
-const MAX_DEVICE_SLOTS = 8;
-
-export function allocateDeviceRange(params: {
-  deviceSlot: number;
-  deviceId: string;
-}): DeviceKeyRange {
-  if (params.deviceSlot < 0 || params.deviceSlot >= MAX_DEVICE_SLOTS) {
-    throw new RangeError(
-      `Device slot must be 0–${MAX_DEVICE_SLOTS - 1}, got ${params.deviceSlot}`,
-    );
-  }
-  const startAddressIndex = params.deviceSlot * ADDRESSES_PER_DEVICE;
-  const endAddressIndex = startAddressIndex + ADDRESSES_PER_DEVICE - 1;
-  return {
-    deviceId: params.deviceId,
-    startAddressIndex,
-    endAddressIndex,
-    addressCount: ADDRESSES_PER_DEVICE,
-  };
-}
-
-export function deviceSlotForAddressIndex(addressIndex: number): number {
-  return Math.floor(addressIndex / ADDRESSES_PER_DEVICE);
-}

package/src/errors.ts

@@ -1,57 +0,0 @@
-export class WatermarkMonotonicityError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'WatermarkMonotonicityError';
-  }
-}
-
-export class WatermarkExhaustedError extends Error {
-  constructor(public readonly treeId: string) {
-    super(`WOTS keyspace exhausted for tree: ${treeId}`);
-    this.name = 'WatermarkExhaustedError';
-  }
-}
-
-export class LeaseNotFoundError extends Error {
-  constructor(public readonly reservationId: string) {
-    super(`Lease reservation not found: ${reservationId}`);
-    this.name = 'LeaseNotFoundError';
-  }
-}
-
-export class PersonalLeaseNodeNotConfiguredError extends Error {
-  constructor() {
-    super(
-      'PersonalLeaseNodeProvider requires a running lookup node. ' +
-        'Deploy @totemsdk/lookup-node and configure { nodeUrl, nodePubkey }.',
-    );
-    this.name = 'PersonalLeaseNodeNotConfiguredError';
-  }
-}
-
-export class P2PQuorumNotImplementedError extends Error {
-  constructor() {
-    super('P2PQuorumLeaseProvider is not yet implemented.');
-    this.name = 'P2PQuorumNotImplementedError';
-  }
-}
-
-export class OnchainWatermarkNotImplementedError extends Error {
-  constructor() {
-    super('OnchainWatermarkProvider is not yet implemented.');
-    this.name = 'OnchainWatermarkNotImplementedError';
-  }
-}
-
-export class DeviceRangeViolationError extends Error {
-  constructor(
-    public readonly addressIndex: number,
-    public readonly allowedStart: number,
-    public readonly allowedEnd: number,
-  ) {
-    super(
-      `Address index ${addressIndex} is outside device range [${allowedStart}, ${allowedEnd}]`,
-    );
-    this.name = 'DeviceRangeViolationError';
-  }
-}

package/src/hybrid.ts

@@ -1,98 +0,0 @@
-/**
- * HybridLeaseProvider — recommended production default.
- *
- * Always uses local first, then gates on node cert and/or quorum attestation
- * for transactions above a configurable value threshold.
- */
-
-import type {
-  WotsLeaseProvider,
-  ReserveParams,
-  LeaseReservation,
-  LeaseCertificate,
-  LocalWatermark,
-  SyncResult,
-} from './types.js';
-import type { LocalLeaseProvider } from './local.js';
-import type { PersonalLeaseNodeProvider } from './stubs.js';
-import type { P2PQuorumLeaseProvider } from './stubs.js';
-import type { OnchainWatermarkProvider } from './stubs.js';
-
-export interface HybridLeaseProviderConfig {
-  local: LocalLeaseProvider;
-  node?: PersonalLeaseNodeProvider;
-  quorum?: P2PQuorumLeaseProvider;
-  onchain?: OnchainWatermarkProvider;
-  threshold?: number;
-}
-
-export class HybridLeaseProvider implements WotsLeaseProvider {
-  private readonly local: LocalLeaseProvider;
-  private readonly node?: PersonalLeaseNodeProvider;
-  private readonly quorum?: P2PQuorumLeaseProvider;
-  private readonly onchain?: OnchainWatermarkProvider;
-  private readonly threshold: number;
-
-  constructor(config: HybridLeaseProviderConfig) {
-    this.local = config.local;
-    this.node = config.node;
-    this.quorum = config.quorum;
-    this.onchain = config.onchain;
-    this.threshold = config.threshold ?? Infinity;
-  }
-
-  private isHighValue(params: ReserveParams): boolean {
-    if (!params.valueHint) return false;
-    const val = parseFloat(params.valueHint);
-    return !isNaN(val) && val >= this.threshold;
-  }
-
-  async reserveKeyUse(params: ReserveParams): Promise<LeaseReservation> {
-    const reservation = await this.local.reserveKeyUse(params);
-
-    if (this.isHighValue(params)) {
-      if (this.node) {
-        try {
-          const nodeReservation = await this.node.reserveKeyUse(params);
-          return { ...reservation, certificate: nodeReservation.certificate };
-        } catch {
-          // Node unavailable — continue with local only
-        }
-      }
-    }
-
-    return reservation;
-  }
-
-  commitKeyUse(reservationId: string, txId: string): Promise<void> {
-    return this.local.commitKeyUse(reservationId, txId);
-  }
-
-  burnReservation(reservationId: string, reason: string): Promise<void> {
-    return this.local.burnReservation(reservationId, reason);
-  }
-
-  getLocalWatermark(treeId: string): Promise<LocalWatermark> {
-    return this.local.getLocalWatermark(treeId);
-  }
-
-  publishWatermark(treeId: string): Promise<void> {
-    if (this.node) {
-      return this.node.publishWatermark(treeId).catch(() => this.local.publishWatermark(treeId));
-    }
-    return this.local.publishWatermark(treeId);
-  }
-
-  syncLeaseJournal(): Promise<SyncResult> {
-    if (this.node) {
-      return this.node.syncLeaseJournal().catch(() => this.local.syncLeaseJournal());
-    }
-    return this.local.syncLeaseJournal();
-  }
-
-  async verifyLeaseCertificate(cert?: LeaseCertificate): Promise<boolean> {
-    if (!cert) return this.local.verifyLeaseCertificate(cert);
-    if (this.node) return this.node.verifyLeaseCertificate(cert);
-    return false;
-  }
-}