@totemsdk/wots-lease 0.1.4 → 0.1.6

package/dist/onchain.js

@@ -0,0 +1,275 @@
+"use strict";
+/**
+ * OnchainWatermarkProvider — Layer 5: on-chain watermark anchoring.
+ *
+ * Safety model
+ * ────────────
+ * The local provider remains the authoritative watermark. This provider adds
+ * a verifiable public record: a dedicated watermark coin whose STATE(0) holds
+ * the flat watermark cursor. Every publish spends the coin back to itself
+ * with an advanced cursor, so any third party can read the on-chain state and
+ * prove that a given signing slot was consumed — without trusting this device.
+ *
+ * The watermark coin script is `RETURN SIGNEDBY(0x<digest>)` — the same
+ * single-sig pattern used by statechain reclaim addresses. The signer is the
+ * WOTS key owner; the digest is the 32-byte public key digest.
+ *
+ * Failure semantics
+ * ─────────────────
+ * - publishWatermark fails loudly (OnchainWatermarkError) when the chain
+ *   rejects the TX — the local watermark is never rolled back.
+ * - syncLeaseJournal merges the on-chain cursor into the local watermark
+ *   monotonically (remote ahead → advance; remote behind → conflict record).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnchainWatermarkProvider = void 0;
+const watermark_js_1 = require("./watermark.js");
+const errors_js_1 = require("./errors.js");
+const core_1 = require("@totemsdk/core");
+const txpow_1 = require("@totemsdk/txpow");
+const MAX_L = 64;
+function multiConcat(parts) {
+    if (parts.length === 0)
+        return new Uint8Array(0);
+    let result = parts[0];
+    for (let i = 1; i < parts.length; i++) {
+        result = concatBytes(result, parts[i]);
+    }
+    return result;
+}
+function concatBytes(a, b) {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+}
+function addressToHex(address) {
+    const upper = address.startsWith('0x') || address.startsWith('0X') ? address.slice(2) : address;
+    return upper.toUpperCase().startsWith('MX')
+        ? (0, core_1.bytesToHex)((0, core_1.parseMxAddress)(address))
+        : address.replace(/^0x/i, '');
+}
+function flatToHex(flat) {
+    let hex = BigInt(flat).toString(16);
+    if (hex.length % 2 !== 0)
+        hex = '0' + hex;
+    return hex || '00';
+}
+function hexToFlat(hex) {
+    const clean = (hex.startsWith('0x') ? hex.slice(2) : hex).replace(/^0+/, '') || '0';
+    return Number(BigInt('0x' + clean));
+}
+function readStateCursor(state, statePort) {
+    for (const raw of state) {
+        const entry = raw;
+        if (typeof entry !== 'object' || entry === null)
+            continue;
+        if (entry.port !== statePort)
+            continue;
+        if (typeof entry.data === 'string')
+            return hexToFlat(entry.data);
+        if (entry.value !== undefined)
+            return Number(entry.value);
+    }
+    return null;
+}
+function stateVarJson(port, hexValue) {
+    return { port, svtype: 'hex', data: hexValue };
+}
+function buildWitnessBytes(sigs) {
+    const parts = [(0, core_1.writeMiniNumber)(BigInt(sigs.length), 0)];
+    for (const sig of sigs)
+        parts.push(sig);
+    parts.push((0, core_1.writeMiniNumber)(0n, 0));
+    parts.push((0, core_1.writeMiniNumber)(0n, 0));
+    return multiConcat(parts);
+}
+class OnchainWatermarkProvider {
+    constructor(config) {
+        this._initialized = false;
+        this._lastPublishBlock = -1;
+        this.chain = config.chain;
+        this.watermarkCoinId = config.watermarkCoinId;
+        this.watermarkAddress = config.watermarkAddress;
+        this.tokenId = config.tokenId ?? '0x00';
+        this.amount = config.amount ?? '1';
+        this.local = config.local;
+        this.signer = config.signer;
+        this.statePort = config.statePort ?? 0;
+        this.minBlocksBetweenPublishes = config.minBlocksBetweenPublishes ?? 1;
+    }
+    async initialize() {
+        if (this._initialized)
+            return;
+        await this.local.initialize();
+        this._initialized = true;
+    }
+    async ensureInit() {
+        if (!this._initialized)
+            await this.initialize();
+    }
+    // -------------------------------------------------------------------------
+    // Reserve / commit / burn — local authoritative
+    // -------------------------------------------------------------------------
+    async reserveKeyUse(params) {
+        await this.ensureInit();
+        const reservation = await this.local.reserveKeyUse(params);
+        const certificate = {
+            reservationId: reservation.reservationId,
+            treeId: params.treeId,
+            branchId: params.branchId,
+            deviceId: params.deviceId,
+            indices: reservation.indices,
+            purpose: params.purpose,
+            payloadHash: params.payloadHash,
+            issuedBy: 'onchain-watermark',
+            issuedAt: Date.now(),
+            expiresAt: reservation.expiresAt,
+            signature: '',
+        };
+        return { ...reservation, certificate };
+    }
+    async commitKeyUse(reservationId, txId) {
+        await this.ensureInit();
+        await this.local.commitKeyUse(reservationId, txId);
+    }
+    async burnReservation(reservationId, reason) {
+        await this.ensureInit();
+        await this.local.burnReservation(reservationId, reason);
+    }
+    // -------------------------------------------------------------------------
+    // Watermark — local read, on-chain publish
+    // -------------------------------------------------------------------------
+    async getLocalWatermark(treeId) {
+        await this.ensureInit();
+        return this.local.getLocalWatermark(treeId);
+    }
+    /**
+     * Publish the local watermark cursor on-chain by spending the watermark
+     * coin back to itself with STATE(statePort) = flat cursor.
+     *
+     * Rate-limited by minBlocksBetweenPublishes using the chain tip.
+     */
+    async publishWatermark(treeId) {
+        await this.ensureInit();
+        const wm = await this.local.getLocalWatermark(treeId);
+        const newFlat = (0, watermark_js_1.flatIndex)({
+            addressIndex: wm.addressCursor,
+            l1: wm.l1Cursor,
+            l2: wm.l2Cursor,
+        });
+        // Rate limit: skip when the last publish was too recent.
+        try {
+            const tip = await this.chain.getTip?.();
+            if (tip && this._lastPublishBlock >= 0 && tip.block - this._lastPublishBlock < this.minBlocksBetweenPublishes) {
+                return;
+            }
+            if (tip)
+                this._lastPublishBlock = tip.block;
+        }
+        catch {
+            // Tip unavailable — proceed without rate limiting.
+        }
+        // Read the current on-chain cursor so the input state matches the coin.
+        const coin = await this.chain.getCoin(this.watermarkCoinId);
+        if (!coin) {
+            throw new errors_js_1.OnchainWatermarkError(`Watermark coin not found: ${this.watermarkCoinId}`);
+        }
+        const currentState = coin.state ?? [];
+        const currentFlat = readStateCursor(currentState, this.statePort);
+        if (currentFlat !== null && currentFlat >= newFlat) {
+            // On-chain cursor already at or ahead of local — nothing to publish.
+            return;
+        }
+        const inputCoin = {
+            coinid: this.watermarkCoinId,
+            address: addressToHex(this.watermarkAddress),
+            amount: this.amount,
+            tokenid: this.tokenId,
+            storestate: true,
+            state: currentState,
+        };
+        const outputCoin = {
+            address: addressToHex(this.watermarkAddress),
+            amount: this.amount,
+            tokenid: this.tokenId,
+            storestate: true,
+            state: [stateVarJson(this.statePort, flatToHex(newFlat))],
+        };
+        const tx = {
+            linkhash: '0x00',
+            inputs: [inputCoin],
+            outputs: [outputCoin],
+            state: [],
+        };
+        const txBytes = (0, core_1.serializeTransaction)(JSON.stringify(tx));
+        (0, core_1.precomputeTransactionCoinID)(txBytes, 0);
+        const digest = (0, core_1.computeTransactionDigest)(txBytes);
+        const sig = await this.signer.sign(digest);
+        const witnessBytes = buildWitnessBytes([sig]);
+        const prng = (0, core_1.sha3_256)(new TextEncoder().encode(`watermark:${treeId}:${this.watermarkCoinId}:${newFlat}`));
+        const txHex = Buffer.from((0, txpow_1.serializeTxPoW)(txBytes, witnessBytes, { prng })).toString('hex');
+        const result = await this.chain.broadcastTxPoW(txHex);
+        if (!result.success) {
+            throw new errors_js_1.OnchainWatermarkError(`Watermark publish rejected: ${result.message ?? 'unknown error'}`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Sync — merge on-chain cursor into local watermark
+    // -------------------------------------------------------------------------
+    async syncLeaseJournal() {
+        await this.ensureInit();
+        const conflicts = [];
+        let advancedTo;
+        for (const treeId of this.local.listTrees()) {
+            const localWm = await this.local.getLocalWatermark(treeId);
+            const localFlat = (0, watermark_js_1.flatIndex)({
+                addressIndex: localWm.addressCursor,
+                l1: localWm.l1Cursor,
+                l2: localWm.l2Cursor,
+            });
+            let onchainFlat = null;
+            try {
+                const coin = await this.chain.getCoin(this.watermarkCoinId);
+                if (coin)
+                    onchainFlat = readStateCursor(coin.state ?? [], this.statePort);
+            }
+            catch {
+                // Chain unreachable — skip.
+            }
+            if (onchainFlat === null)
+                continue;
+            if (onchainFlat > localFlat) {
+                const addressIndex = Math.floor(onchainFlat / (MAX_L * MAX_L));
+                const rem = onchainFlat % (MAX_L * MAX_L);
+                const l1 = Math.floor(rem / MAX_L);
+                const l2 = rem % MAX_L;
+                const advanced = await this.local.advanceToRemoteWatermark(treeId, {
+                    addressCursor: addressIndex,
+                    l1Cursor: l1,
+                    l2Cursor: l2,
+                });
+                if (advanced) {
+                    advancedTo = { addressIndex, l1, l2 };
+                }
+            }
+            else if (onchainFlat < localFlat) {
+                conflicts.push({
+                    treeId,
+                    localIndex: localFlat,
+                    remoteIndex: onchainFlat,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+        return { synced: conflicts.length === 0, conflicts, advancedTo };
+    }
+    async verifyLeaseCertificate(cert) {
+        if (!cert)
+            return false;
+        if (cert.expiresAt <= Date.now())
+            return false;
+        return cert.issuedBy === 'onchain-watermark';
+    }
+}
+exports.OnchainWatermarkProvider = OnchainWatermarkProvider;

package/dist/quorum.d.ts

@@ -0,0 +1,60 @@
+/**
+ * P2PQuorumLeaseProvider — Layer 4: multi-device quorum lease coordination.
+ *
+ * Safety model
+ * ────────────
+ * The local provider remains the authoritative watermark (it can only move
+ * forward). The quorum adds a second, independent check: before a reservation
+ * is handed to the caller, at least `minAttestations` peers must confirm that
+ * the same (treeId, indices) slot is free in *their* view of the world. This
+ * catches the failure mode where two devices share a seed and both believe
+ * they own the next slot — the peers see the double-reservation and refuse
+ * to attest.
+ *
+ * Wire protocol
+ * ─────────────
+ * Peers speak the same LEASE_RESERVE / LEASE_COMMIT / LEASE_BURN /
+ * LEASE_WATERMARK message shapes as the lookup protocol, so any peer that
+ * implements that protocol can participate: a personal lookup node, another
+ * device running this provider, or an in-memory test peer.
+ *
+ * Failure semantics
+ * ─────────────────
+ * - If quorum cannot be reached, the local reservation is burned and
+ *   QuorumUnavailableError is thrown. The slot is NOT reusable (burned),
+ *   which is the safe direction: a slot that might have been attested by
+ *   some peers must never be handed out again.
+ * - If a peer reports the slot as taken, the local reservation is burned
+ *   and QuorumConflictError is thrown.
+ */
+import type { WotsLeaseProvider, ReserveParams, LeaseReservation, LeaseCertificate, LocalWatermark, SyncResult, QuorumAttestation, P2PQuorumLeaseProviderConfig } from './types.js';
+export declare class P2PQuorumLeaseProvider implements WotsLeaseProvider {
+    private readonly peers;
+    private readonly minAttestations;
+    private readonly local;
+    private readonly requestTimeoutMs;
+    private readonly requireQuorumOnCommit;
+    private _initialized;
+    constructor(config: P2PQuorumLeaseProviderConfig);
+    initialize(): Promise<void>;
+    private ensureInit;
+    reserveKeyUse(params: ReserveParams): Promise<LeaseReservation>;
+    /**
+     * Collect quorum attestations for a reservation that was already made
+     * locally (used by HybridLeaseProvider so the local slot and the attested
+     * slot are the same). Throws QuorumUnavailableError / QuorumConflictError
+     * on failure — the caller owns the local reservation and must burn it.
+     */
+    attestKeyUse(params: ReserveParams, indices: {
+        addressIndex: number;
+        l1: number;
+        l2: number;
+    }): Promise<QuorumAttestation[]>;
+    commitKeyUse(reservationId: string, txId: string): Promise<void>;
+    burnReservation(reservationId: string, reason: string): Promise<void>;
+    private broadcastAck;
+    getLocalWatermark(treeId: string): Promise<LocalWatermark>;
+    publishWatermark(treeId: string): Promise<void>;
+    syncLeaseJournal(): Promise<SyncResult>;
+    verifyLeaseCertificate(cert?: LeaseCertificate): Promise<boolean>;
+}

package/dist/quorum.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * P2PQuorumLeaseProvider — Layer 4: multi-device quorum lease coordination.
+ *
+ * Safety model
+ * ────────────
+ * The local provider remains the authoritative watermark (it can only move
+ * forward). The quorum adds a second, independent check: before a reservation
+ * is handed to the caller, at least `minAttestations` peers must confirm that
+ * the same (treeId, indices) slot is free in *their* view of the world. This
+ * catches the failure mode where two devices share a seed and both believe
+ * they own the next slot — the peers see the double-reservation and refuse
+ * to attest.
+ *
+ * Wire protocol
+ * ─────────────
+ * Peers speak the same LEASE_RESERVE / LEASE_COMMIT / LEASE_BURN /
+ * LEASE_WATERMARK message shapes as the lookup protocol, so any peer that
+ * implements that protocol can participate: a personal lookup node, another
+ * device running this provider, or an in-memory test peer.
+ *
+ * Failure semantics
+ * ─────────────────
+ * - If quorum cannot be reached, the local reservation is burned and
+ *   QuorumUnavailableError is thrown. The slot is NOT reusable (burned),
+ *   which is the safe direction: a slot that might have been attested by
+ *   some peers must never be handed out again.
+ * - If a peer reports the slot as taken, the local reservation is burned
+ *   and QuorumConflictError is thrown.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.P2PQuorumLeaseProvider = void 0;
+const errors_js_1 = require("./errors.js");
+function sameIndices(a, b) {
+    return a.addressIndex === b.addressIndex && a.l1 === b.l1 && a.l2 === b.l2;
+}
+class P2PQuorumLeaseProvider {
+    constructor(config) {
+        this._initialized = false;
+        this.peers = config.peers;
+        this.minAttestations = config.minAttestations ?? 1;
+        this.local = config.local;
+        this.requestTimeoutMs = config.requestTimeoutMs ?? 5000;
+        this.requireQuorumOnCommit = config.requireQuorumOnCommit ?? false;
+    }
+    async initialize() {
+        if (this._initialized)
+            return;
+        await this.local.initialize();
+        this._initialized = true;
+    }
+    async ensureInit() {
+        if (!this._initialized)
+            await this.initialize();
+    }
+    // -------------------------------------------------------------------------
+    // Reserve — local first, then quorum attestation
+    // -------------------------------------------------------------------------
+    async reserveKeyUse(params) {
+        await this.ensureInit();
+        // 1. Local reservation (authoritative, monotonic watermark).
+        const reservation = await this.local.reserveKeyUse(params);
+        // 2. Collect attestations from peers for the SAME indices.
+        //    On failure the local reservation is burned — the slot is never reused.
+        let attestations;
+        try {
+            attestations = await this.attestKeyUse(params, reservation.indices);
+        }
+        catch (err) {
+            const reason = err instanceof errors_js_1.QuorumConflictError
+                ? `quorum conflict: ${err.message}`
+                : 'quorum not reached';
+            await this.local.burnReservation(reservation.reservationId, reason);
+            throw err;
+        }
+        const certificate = {
+            reservationId: reservation.reservationId,
+            treeId: params.treeId,
+            branchId: params.branchId,
+            deviceId: params.deviceId,
+            indices: reservation.indices,
+            purpose: params.purpose,
+            payloadHash: params.payloadHash,
+            issuedBy: 'p2p-quorum',
+            issuedAt: Date.now(),
+            expiresAt: reservation.expiresAt,
+            signature: '',
+            attestations,
+        };
+        return { ...reservation, certificate };
+    }
+    /**
+     * Collect quorum attestations for a reservation that was already made
+     * locally (used by HybridLeaseProvider so the local slot and the attested
+     * slot are the same). Throws QuorumUnavailableError / QuorumConflictError
+     * on failure — the caller owns the local reservation and must burn it.
+     */
+    async attestKeyUse(params, indices) {
+        await this.ensureInit();
+        const attestations = [];
+        const conflicts = [];
+        await Promise.all(this.peers.map(async (peer) => {
+            try {
+                const resp = await peer.request({
+                    type: 'LEASE_RESERVE',
+                    payload: {
+                        treeId: params.treeId,
+                        branchId: params.branchId,
+                        deviceId: params.deviceId,
+                        ttlMs: params.ttlMs,
+                        payloadHash: params.payloadHash,
+                        purpose: params.purpose,
+                        indices,
+                    },
+                }, this.requestTimeoutMs);
+                if (resp.type === 'ERROR') {
+                    conflicts.push(String(resp.payload.message ?? 'peer error'));
+                    return;
+                }
+                const body = resp.payload;
+                const peerIndices = body.reservation?.indices;
+                if (!peerIndices || !sameIndices(peerIndices, indices)) {
+                    conflicts.push('peer returned mismatched indices');
+                    return;
+                }
+                attestations.push({
+                    peerId: peer.peerId,
+                    indices,
+                    expiresAt: body.reservation?.expiresAt ?? Date.now() + (params.ttlMs ?? 120000),
+                });
+            }
+            catch {
+                // Peer unreachable — counted as no attestation.
+            }
+        }));
+        if (conflicts.length > 0) {
+            throw new errors_js_1.QuorumConflictError(params.treeId, indices);
+        }
+        if (attestations.length < this.minAttestations) {
+            throw new errors_js_1.QuorumUnavailableError(this.minAttestations, attestations.length);
+        }
+        return attestations;
+    }
+    // -------------------------------------------------------------------------
+    // Commit / burn — local authoritative, broadcast to peers
+    // -------------------------------------------------------------------------
+    async commitKeyUse(reservationId, txId) {
+        await this.ensureInit();
+        await this.local.commitKeyUse(reservationId, txId);
+        const acks = await this.broadcastAck('LEASE_COMMIT', { reservationId, txId });
+        if (this.requireQuorumOnCommit && acks < this.minAttestations) {
+            throw new errors_js_1.QuorumUnavailableError(this.minAttestations, acks);
+        }
+    }
+    async burnReservation(reservationId, reason) {
+        await this.ensureInit();
+        await this.local.burnReservation(reservationId, reason);
+        await this.broadcastAck('LEASE_BURN', { reservationId, reason });
+    }
+    async broadcastAck(type, payload) {
+        let acks = 0;
+        await Promise.all(this.peers.map(async (peer) => {
+            try {
+                const resp = await peer.request({ type, payload }, this.requestTimeoutMs);
+                if (resp.type !== 'ERROR')
+                    acks++;
+            }
+            catch {
+                // Peer unreachable — no ack.
+            }
+        }));
+        return acks;
+    }
+    // -------------------------------------------------------------------------
+    // Watermark / journal
+    // -------------------------------------------------------------------------
+    async getLocalWatermark(treeId) {
+        await this.ensureInit();
+        return this.local.getLocalWatermark(treeId);
+    }
+    async publishWatermark(treeId) {
+        await this.ensureInit();
+        const wm = await this.local.getLocalWatermark(treeId);
+        await Promise.all(this.peers.map(async (peer) => {
+            try {
+                await peer.request({
+                    type: 'LEASE_WATERMARK',
+                    payload: {
+                        treeId,
+                        addressCursor: wm.addressCursor,
+                        l1Cursor: wm.l1Cursor,
+                        l2Cursor: wm.l2Cursor,
+                        unavailableCount: wm.unavailableCount,
+                        lastSyncTimestamp: wm.lastSyncTimestamp ?? Date.now(),
+                    },
+                }, this.requestTimeoutMs);
+            }
+            catch {
+                // Peer unreachable — watermark publish is best-effort.
+            }
+        }));
+    }
+    async syncLeaseJournal() {
+        await this.ensureInit();
+        const conflicts = [];
+        let advancedTo;
+        for (const treeId of this.local.listTrees()) {
+            const localWm = await this.local.getLocalWatermark(treeId);
+            for (const peer of this.peers) {
+                try {
+                    const resp = await peer.request({
+                        type: 'LEASE_WATERMARK',
+                        payload: { treeId, query: true },
+                    }, this.requestTimeoutMs);
+                    if (resp.type === 'ERROR')
+                        continue;
+                    const p = resp.payload;
+                    if (typeof p.addressCursor !== 'number')
+                        continue;
+                    const remoteFlat = p.addressCursor * 64 * 64 + p.l1Cursor * 64 + p.l2Cursor;
+                    const localFlat = localWm.addressCursor * 64 * 64 + localWm.l1Cursor * 64 + localWm.l2Cursor;
+                    if (remoteFlat > localFlat) {
+                        const advanced = await this.local.advanceToRemoteWatermark(treeId, {
+                            addressCursor: p.addressCursor,
+                            l1Cursor: p.l1Cursor,
+                            l2Cursor: p.l2Cursor,
+                        });
+                        if (advanced) {
+                            advancedTo = {
+                                addressIndex: p.addressCursor,
+                                l1: p.l1Cursor,
+                                l2: p.l2Cursor,
+                            };
+                        }
+                    }
+                    else if (remoteFlat < localFlat) {
+                        conflicts.push({
+                            treeId,
+                            localIndex: localFlat,
+                            remoteIndex: remoteFlat,
+                            timestamp: Date.now(),
+                        });
+                    }
+                }
+                catch {
+                    // Peer unreachable — skip.
+                }
+            }
+        }
+        return { synced: conflicts.length === 0, conflicts, advancedTo };
+    }
+    async verifyLeaseCertificate(cert) {
+        if (!cert)
+            return false;
+        if (cert.expiresAt <= Date.now())
+            return false;
+        const attestations = cert.attestations ?? [];
+        if (attestations.length < this.minAttestations)
+            return false;
+        return attestations.every((a) => sameIndices(a.indices, cert.indices) &&
+            a.expiresAt > Date.now());
+    }
+}
+exports.P2PQuorumLeaseProvider = P2PQuorumLeaseProvider;

package/dist/stubs.d.ts

@@ -5,10 +5,12 @@
  *   that has lease coordination enabled ({ lease: { enabled: true } }).
  *   The node exposes REST endpoints under /v1/lease/*.
  *
- * Layers 4–5 (P2PQuorumLeaseProvider, OnchainWatermarkProvider) — require
- *   distributed infrastructure not yet available; they throw descriptive errors.
+ * Layers 4–5 (P2PQuorumLeaseProvider, OnchainWatermarkProvider) — implemented in
+ *   quorum.ts and onchain.ts; re-exported here for backward compatibility.
  */
 import type { WotsLeaseProvider, ReserveParams, LeaseReservation, LeaseCertificate, LocalWatermark, SyncResult, PersonalLeaseNodeConfig } from './types.js';
+export { P2PQuorumLeaseProvider } from './quorum.js';
+export { OnchainWatermarkProvider } from './onchain.js';
 /**
  * Layer 3 — personal lookup-node lease coordinator.
  *
@@ -44,23 +46,3 @@ export declare class PersonalLeaseNodeProvider implements WotsLeaseProvider {
     syncLeaseJournal(): Promise<SyncResult>;
     verifyLeaseCertificate(cert?: LeaseCertificate): Promise<boolean>;
 }
-/** Layer 4 — p2p replicated lease witnesses. */
-export declare class P2PQuorumLeaseProvider implements WotsLeaseProvider {
-    reserveKeyUse(_params: ReserveParams): Promise<LeaseReservation>;
-    commitKeyUse(_reservationId: string, _txId: string): Promise<void>;
-    burnReservation(_reservationId: string, _reason: string): Promise<void>;
-    getLocalWatermark(_treeId: string): Promise<LocalWatermark>;
-    publishWatermark(_treeId: string): Promise<void>;
-    syncLeaseJournal(): Promise<SyncResult>;
-    verifyLeaseCertificate(_cert?: LeaseCertificate): Promise<boolean>;
-}
-/** Layer 5 — on-chain watermark coin. */
-export declare class OnchainWatermarkProvider implements WotsLeaseProvider {
-    reserveKeyUse(_params: ReserveParams): Promise<LeaseReservation>;
-    commitKeyUse(_reservationId: string, _txId: string): Promise<void>;
-    burnReservation(_reservationId: string, _reason: string): Promise<void>;
-    getLocalWatermark(_treeId: string): Promise<LocalWatermark>;
-    publishWatermark(_treeId: string): Promise<void>;
-    syncLeaseJournal(): Promise<SyncResult>;
-    verifyLeaseCertificate(_cert?: LeaseCertificate): Promise<boolean>;
-}