@totemsdk/wots-lease 1.0.1 → 1.0.2

package/dist/cjs/watermark.js

@@ -0,0 +1,328 @@
+"use strict";
+/**
+ * WotsWatermarkStore — canonical v3 implementation
+ *
+ * - Reads v1 (flat usedIndices) and v2 (per-address usedIndices) automatically on load.
+ * - Writes only v3.
+ * - Enforces monotonicity: unavailable map can only grow, cursors can only advance.
+ * - Storage key unchanged ('totem_wots_watermark') to avoid storage churn.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WotsWatermarkStore = void 0;
+exports.flatIndex = flatIndex;
+exports.fromFlatIndex = fromFlatIndex;
+exports.assertValidSigningIndices = assertValidSigningIndices;
+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';
+function flatIndex(idx) {
+    assertValidSigningIndices(idx);
+    return idx.addressIndex * MAX_L * MAX_L + idx.l1 * MAX_L + idx.l2;
+}
+function fromFlatIndex(flat) {
+    if (!Number.isSafeInteger(flat) || flat < 0 || flat >= CAPACITY_PER_TREE) {
+        throw new RangeError(`WOTS flat index must be an integer in [0, ${CAPACITY_PER_TREE - 1}]`);
+    }
+    const addressIndex = Math.floor(flat / (MAX_L * MAX_L));
+    const rem = flat % (MAX_L * MAX_L);
+    const l1 = Math.floor(rem / MAX_L);
+    const l2 = rem % MAX_L;
+    return { addressIndex, l1, l2 };
+}
+function assertValidSigningIndices(indices) {
+    for (const name of ['addressIndex', 'l1', 'l2']) {
+        const value = indices[name];
+        if (!Number.isSafeInteger(value) || value < 0 || value >= MAX_L) {
+            throw new RangeError(`WOTS ${name} must be an integer in [0, ${MAX_L - 1}]`);
+        }
+    }
+}
+function emptyTree(treeId) {
+    return { treeId, addressCursor: 0, l1Cursor: 0, l2Cursor: 0, unavailable: {} };
+}
+function nextIndices(cur) {
+    let { addressIndex, l1, l2 } = cur;
+    l2++;
+    if (l2 >= MAX_L) {
+        l2 = 0;
+        l1++;
+    }
+    if (l1 >= MAX_L) {
+        l1 = 0;
+        addressIndex++;
+    }
+    if (addressIndex >= MAX_L)
+        return null;
+    return { addressIndex, l1, l2 };
+}
+/**
+ * Monotonic merge of two watermark states: the cursor is the further of the
+ * two and the unavailable maps are unioned, so merging never re-exposes a used
+ * index. Used to pick up writes made by another provider over the same storage
+ * (AUD-004).
+ */
+function mergeWatermarkState(a, b) {
+    if (!a)
+        return b;
+    const trees = { ...a.trees };
+    for (const [treeId, bt] of Object.entries(b.trees)) {
+        const at = trees[treeId];
+        if (!at) {
+            trees[treeId] = bt;
+            continue;
+        }
+        const aFlat = flatIndex({ addressIndex: at.addressCursor, l1: at.l1Cursor, l2: at.l2Cursor });
+        const bFlat = flatIndex({ addressIndex: bt.addressCursor, l1: bt.l1Cursor, l2: bt.l2Cursor });
+        const cursor = bFlat > aFlat ? bt : at;
+        const lastSync = Math.max(at.lastSyncTimestamp ?? 0, bt.lastSyncTimestamp ?? 0);
+        trees[treeId] = {
+            treeId,
+            addressCursor: cursor.addressCursor,
+            l1Cursor: cursor.l1Cursor,
+            l2Cursor: cursor.l2Cursor,
+            unavailable: { ...bt.unavailable, ...at.unavailable },
+            ...(lastSync > 0 ? { lastSyncTimestamp: lastSync } : {}),
+        };
+    }
+    return { version: 3, trees };
+}
+function migrateToV3(raw) {
+    if (!raw) {
+        return { version: 3, trees: {} };
+    }
+    if ('version' in raw && raw.version === 3) {
+        return raw;
+    }
+    if ('version' in raw && raw.version === 2) {
+        const v2 = raw;
+        const tree = emptyTree(DEFAULT_TREE);
+        let maxFlat = -1;
+        for (const [addrIdxStr, addrData] of Object.entries(v2.addresses)) {
+            const addressIndex = Number(addrIdxStr);
+            for (const [l1, l2] of addrData.usedIndices) {
+                const f = flatIndex({ addressIndex, l1, l2 });
+                tree.unavailable[f] = 'committed';
+                if (f > maxFlat)
+                    maxFlat = f;
+            }
+            const curFlat = flatIndex({ addressIndex, l1: addrData.next_l1, l2: addrData.next_l2 });
+            if (curFlat > maxFlat)
+                maxFlat = curFlat;
+        }
+        if (maxFlat >= 0) {
+            const cur = fromFlatIndex(maxFlat);
+            tree.addressCursor = cur.addressIndex;
+            tree.l1Cursor = cur.l1;
+            tree.l2Cursor = cur.l2;
+        }
+        return { version: 3, trees: { [DEFAULT_TREE]: tree } };
+    }
+    const v1 = raw;
+    const tree = emptyTree(DEFAULT_TREE);
+    for (const [ai, l1, l2] of v1.usedIndices ?? []) {
+        const f = flatIndex({ addressIndex: ai, l1, l2 });
+        tree.unavailable[f] = 'committed';
+    }
+    tree.addressCursor = v1.next_addressIndex ?? 0;
+    tree.l1Cursor = v1.next_l1 ?? 0;
+    tree.l2Cursor = v1.next_l2 ?? 0;
+    return { version: 3, trees: { [DEFAULT_TREE]: tree } };
+}
+class WotsWatermarkStore {
+    constructor(storage, logger = new core_1.NoopLogger()) {
+        this.storage = storage;
+        this.state = null;
+        this._initialized = false;
+        this.logger = logger;
+    }
+    async initialize() {
+        if (this._initialized)
+            return;
+        const raw = await this.storage.get(STORAGE_KEY);
+        this.state = migrateToV3(raw);
+        if (!('version' in (raw ?? {})) || raw.version !== 3) {
+            await this.persist();
+            this.logger.info('[WotsWatermarkStore] Migrated to v3');
+        }
+        this._initialized = true;
+    }
+    ensureInit() {
+        if (!this.state)
+            throw new Error('WotsWatermarkStore not initialized — call initialize() first');
+        return this.state;
+    }
+    async persist() {
+        await this.storage.set(STORAGE_KEY, this.state);
+    }
+    /**
+     * Reload the persisted watermark and merge it monotonically into the local
+     * state. A provider that shares its storage with another provider (AUD-004)
+     * must call this inside its mutation critical section before allocating or
+     * marking, so it observes writes it did not make and never re-issues a slot
+     * another instance already took.
+     */
+    async refresh() {
+        if (!this._initialized || !this.state)
+            return;
+        const raw = await this.storage.get(STORAGE_KEY);
+        this.state = mergeWatermarkState(this.state, migrateToV3(raw));
+    }
+    getOrCreateTree(treeId) {
+        const s = this.ensureInit();
+        if (!s.trees[treeId]) {
+            s.trees[treeId] = emptyTree(treeId);
+        }
+        return s.trees[treeId];
+    }
+    getNextIndices(treeId) {
+        const tree = this.getOrCreateTree(treeId);
+        let cur = {
+            addressIndex: tree.addressCursor,
+            l1: tree.l1Cursor,
+            l2: tree.l2Cursor,
+        };
+        let attempts = 0;
+        while (attempts < CAPACITY_PER_TREE) {
+            if (!tree.unavailable[flatIndex(cur)])
+                return cur;
+            const nxt = nextIndices(cur);
+            if (!nxt)
+                break;
+            cur = nxt;
+            attempts++;
+        }
+        throw new errors_js_1.WatermarkExhaustedError(treeId);
+    }
+    async markUnavailable(treeId, indices, reason) {
+        const tree = this.getOrCreateTree(treeId);
+        const f = flatIndex(indices);
+        tree.unavailable[f] = reason;
+        const nxt = nextIndices(indices);
+        if (nxt) {
+            const nxtFlat = flatIndex(nxt);
+            const curFlat = flatIndex({ addressIndex: tree.addressCursor, l1: tree.l1Cursor, l2: tree.l2Cursor });
+            if (nxtFlat > curFlat) {
+                tree.addressCursor = nxt.addressIndex;
+                tree.l1Cursor = nxt.l1;
+                tree.l2Cursor = nxt.l2;
+            }
+        }
+        await this.persist();
+    }
+    isUnavailable(treeId, indices) {
+        const s = this.ensureInit();
+        const tree = s.trees[treeId];
+        if (!tree)
+            return false;
+        const index = flatIndex(indices);
+        const cursor = flatIndex({
+            addressIndex: tree.addressCursor,
+            l1: tree.l1Cursor,
+            l2: tree.l2Cursor,
+        });
+        return index < cursor || index in tree.unavailable;
+    }
+    async save(treeId, patch) {
+        const s = this.ensureInit();
+        const existing = s.trees[treeId] ?? emptyTree(treeId);
+        const merged = { ...existing, ...patch, treeId };
+        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 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 errors_js_1.WatermarkMonotonicityError(`Cannot shrink unavailable map for ${treeId}: ${existingUnavailCount} → ${newUnavailCount}`);
+        }
+        s.trees[treeId] = merged;
+        await this.persist();
+    }
+    getLocalWatermark(treeId) {
+        const s = this.ensureInit();
+        const tree = s.trees[treeId] ?? emptyTree(treeId);
+        return {
+            treeId,
+            addressCursor: tree.addressCursor,
+            l1Cursor: tree.l1Cursor,
+            l2Cursor: tree.l2Cursor,
+            unavailableCount: Object.keys(tree.unavailable).length,
+            capacity: CAPACITY_PER_TREE,
+            lastSyncTimestamp: tree.lastSyncTimestamp,
+        };
+    }
+    /**
+     * Export a portable seed for a tree (RFC-013 §9). Includes the cursor and the
+     * flat indices already consumed, so it can rebuild the no-reuse state exactly.
+     */
+    exportSeed(treeId) {
+        const s = this.ensureInit();
+        const tree = s.trees[treeId] ?? emptyTree(treeId);
+        const unavailable = Object.keys(tree.unavailable)
+            .map((k) => Number(k))
+            .filter((f) => Number.isSafeInteger(f))
+            .sort((a, b) => a - b);
+        return {
+            version: 1,
+            treeId,
+            addressCursor: tree.addressCursor,
+            l1Cursor: tree.l1Cursor,
+            l2Cursor: tree.l2Cursor,
+            unavailable,
+        };
+    }
+    /**
+     * Seed the watermark from an exported/operator/on-chain snapshot. Forward-only
+     * by default: a seed behind the current cursor raises
+     * {@link WatermarkSeedRegressionError} so a restore can never re-expose used
+     * leaves. The unavailable set is unioned, never shrunk.
+     */
+    async seed(seed, options = {}) {
+        const s = this.ensureInit();
+        const existing = s.trees[seed.treeId] ?? emptyTree(seed.treeId);
+        const seedCursor = flatIndex({
+            addressIndex: seed.addressCursor,
+            l1: seed.l1Cursor,
+            l2: seed.l2Cursor,
+        });
+        const existingCursor = flatIndex({
+            addressIndex: existing.addressCursor,
+            l1: existing.l1Cursor,
+            l2: existing.l2Cursor,
+        });
+        if (!options.allowRegression && seedCursor < existingCursor) {
+            throw new errors_js_1.WatermarkSeedRegressionError(seed.treeId, existingCursor, seedCursor);
+        }
+        const unavailable = { ...existing.unavailable };
+        for (const flat of seed.unavailable ?? []) {
+            if (!Number.isSafeInteger(flat) || flat < 0 || flat >= CAPACITY_PER_TREE) {
+                throw new RangeError(`Seed unavailable index must be an integer in [0, ${CAPACITY_PER_TREE - 1}]`);
+            }
+            if (!(flat in unavailable))
+                unavailable[flat] = 'committed';
+        }
+        s.trees[seed.treeId] = {
+            ...existing,
+            treeId: seed.treeId,
+            addressCursor: seed.addressCursor,
+            l1Cursor: seed.l1Cursor,
+            l2Cursor: seed.l2Cursor,
+            unavailable,
+            lastSyncTimestamp: Date.now(),
+        };
+        await this.persist();
+    }
+    getRawState() {
+        return this.ensureInit();
+    }
+    async clear() {
+        this.state = { version: 3, trees: {} };
+        this._initialized = false;
+        await this.storage.remove(STORAGE_KEY);
+    }
+}
+exports.WotsWatermarkStore = WotsWatermarkStore;

package/dist/device.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Device keyspace partitioning — Layer 2.
  *
@@ -11,12 +10,9 @@
  *   device 2 → addressIndex 16–23
  *   ...
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.allocateDeviceRange = allocateDeviceRange;
-exports.deviceSlotForAddressIndex = deviceSlotForAddressIndex;
 const ADDRESSES_PER_DEVICE = 8;
 const MAX_DEVICE_SLOTS = 8;
-function allocateDeviceRange(params) {
+export function allocateDeviceRange(params) {
     if (params.deviceSlot < 0 || params.deviceSlot >= MAX_DEVICE_SLOTS) {
         throw new RangeError(`Device slot must be 0–${MAX_DEVICE_SLOTS - 1}, got ${params.deviceSlot}`);
     }
@@ -29,6 +25,6 @@ function allocateDeviceRange(params) {
         addressCount: ADDRESSES_PER_DEVICE,
     };
 }
-function deviceSlotForAddressIndex(addressIndex) {
+export function deviceSlotForAddressIndex(addressIndex) {
     return Math.floor(addressIndex / ADDRESSES_PER_DEVICE);
 }

package/dist/errors.js

@@ -1,19 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceRangeViolationError = exports.OnchainWatermarkError = exports.QuorumConflictError = exports.QuorumUnavailableError = exports.OnchainWatermarkNotImplementedError = exports.P2PQuorumNotImplementedError = exports.PersonalLeaseNodeNotConfiguredError = exports.IndicesUnavailableError = exports.InvalidLeaseTransitionError = exports.LeaseNotFoundError = exports.WatermarkExhaustedError = exports.WatermarkSeedRequiredError = exports.WatermarkSeedRegressionError = exports.WatermarkMonotonicityError = void 0;
-class WatermarkMonotonicityError extends Error {
+export class WatermarkMonotonicityError extends Error {
     constructor(message) {
         super(message);
         this.name = 'WatermarkMonotonicityError';
     }
 }
-exports.WatermarkMonotonicityError = WatermarkMonotonicityError;
 /**
  * Raised when seeding would move the local watermark cursor backwards. This is
  * the fail-closed guard against restoring a wallet below its true high-water
  * mark and reusing a WOTS leaf (RFC-013 §9).
  */
-class WatermarkSeedRegressionError extends Error {
+export class WatermarkSeedRegressionError extends Error {
     constructor(treeId, currentCursor, seedCursor) {
         super(`Refusing to seed watermark for ${treeId} below the current cursor ` +
             `(${seedCursor} < ${currentCursor}); this would re-expose used WOTS leaves.`);
@@ -23,13 +19,12 @@ class WatermarkSeedRegressionError extends Error {
         this.name = 'WatermarkSeedRegressionError';
     }
 }
-exports.WatermarkSeedRegressionError = WatermarkSeedRegressionError;
 /**
  * Raised when a restore/import has no usable watermark source and the caller has
  * not declared the keyspace fresh. Failing closed is required: starting at 0
  * would reissue spent leaves (RFC-013 §9).
  */
-class WatermarkSeedRequiredError extends Error {
+export class WatermarkSeedRequiredError extends Error {
     constructor(treeId) {
         super(`No watermark source available for ${treeId}. Provide an on-chain cursor, an ` +
             'exported watermark, or an operator high-water mark — or declare the keyspace fresh. ' +
@@ -38,24 +33,21 @@ class WatermarkSeedRequiredError extends Error {
         this.name = 'WatermarkSeedRequiredError';
     }
 }
-exports.WatermarkSeedRequiredError = WatermarkSeedRequiredError;
-class WatermarkExhaustedError extends Error {
+export class WatermarkExhaustedError extends Error {
     constructor(treeId) {
         super(`WOTS keyspace exhausted for tree: ${treeId}`);
         this.treeId = treeId;
         this.name = 'WatermarkExhaustedError';
     }
 }
-exports.WatermarkExhaustedError = WatermarkExhaustedError;
-class LeaseNotFoundError extends Error {
+export class LeaseNotFoundError extends Error {
     constructor(reservationId) {
         super(`Lease reservation not found: ${reservationId}`);
         this.reservationId = reservationId;
         this.name = 'LeaseNotFoundError';
     }
 }
-exports.LeaseNotFoundError = LeaseNotFoundError;
-class InvalidLeaseTransitionError extends Error {
+export class InvalidLeaseTransitionError extends Error {
     constructor(reservationId, currentStatus, requestedStatus) {
         super(`Cannot transition lease ${reservationId} from ${currentStatus} to ${requestedStatus}`);
         this.reservationId = reservationId;
@@ -64,8 +56,7 @@ class InvalidLeaseTransitionError extends Error {
         this.name = 'InvalidLeaseTransitionError';
     }
 }
-exports.InvalidLeaseTransitionError = InvalidLeaseTransitionError;
-class IndicesUnavailableError extends Error {
+export class IndicesUnavailableError extends Error {
     constructor(treeId, indices) {
         super(`Indices (${indices.addressIndex}, ${indices.l1}, ${indices.l2}) are already unavailable for tree: ${treeId}`);
         this.treeId = treeId;
@@ -73,30 +64,26 @@ class IndicesUnavailableError extends Error {
         this.name = 'IndicesUnavailableError';
     }
 }
-exports.IndicesUnavailableError = IndicesUnavailableError;
-class PersonalLeaseNodeNotConfiguredError extends Error {
+export class PersonalLeaseNodeNotConfiguredError extends Error {
     constructor() {
         super('PersonalLeaseNodeProvider requires a running lookup node. ' +
             'Deploy @totemsdk/lookup-node and configure { nodeUrl, nodePubkey }.');
         this.name = 'PersonalLeaseNodeNotConfiguredError';
     }
 }
-exports.PersonalLeaseNodeNotConfiguredError = PersonalLeaseNodeNotConfiguredError;
-class P2PQuorumNotImplementedError extends Error {
+export class P2PQuorumNotImplementedError extends Error {
     constructor() {
         super('P2PQuorumLeaseProvider is not yet implemented.');
         this.name = 'P2PQuorumNotImplementedError';
     }
 }
-exports.P2PQuorumNotImplementedError = P2PQuorumNotImplementedError;
-class OnchainWatermarkNotImplementedError extends Error {
+export class OnchainWatermarkNotImplementedError extends Error {
     constructor() {
         super('OnchainWatermarkProvider is not yet implemented.');
         this.name = 'OnchainWatermarkNotImplementedError';
     }
 }
-exports.OnchainWatermarkNotImplementedError = OnchainWatermarkNotImplementedError;
-class QuorumUnavailableError extends Error {
+export class QuorumUnavailableError extends Error {
     constructor(required, available) {
         super(`Quorum not reached: ${available}/${required} peers attested. ` +
             'The reservation was burned locally — retry when more peers are reachable.');
@@ -105,8 +92,7 @@ class QuorumUnavailableError extends Error {
         this.name = 'QuorumUnavailableError';
     }
 }
-exports.QuorumUnavailableError = QuorumUnavailableError;
-class QuorumConflictError extends Error {
+export class QuorumConflictError extends Error {
     constructor(treeId, indices) {
         super(`Quorum conflict for tree ${treeId} at (${indices.addressIndex}, ${indices.l1}, ${indices.l2}): ` +
             'a peer already holds a reservation for these indices.');
@@ -115,15 +101,13 @@ class QuorumConflictError extends Error {
         this.name = 'QuorumConflictError';
     }
 }
-exports.QuorumConflictError = QuorumConflictError;
-class OnchainWatermarkError extends Error {
+export class OnchainWatermarkError extends Error {
     constructor(message) {
         super(message);
         this.name = 'OnchainWatermarkError';
     }
 }
-exports.OnchainWatermarkError = OnchainWatermarkError;
-class DeviceRangeViolationError extends Error {
+export class DeviceRangeViolationError extends Error {
     constructor(addressIndex, allowedStart, allowedEnd) {
         super(`Address index ${addressIndex} is outside device range [${allowedStart}, ${allowedEnd}]`);
         this.addressIndex = addressIndex;
@@ -132,4 +116,3 @@ class DeviceRangeViolationError extends Error {
         this.name = 'DeviceRangeViolationError';
     }
 }
-exports.DeviceRangeViolationError = DeviceRangeViolationError;

package/dist/hybrid.js

@@ -1,14 +1,11 @@
-"use strict";
 /**
  * HybridLeaseProvider — recommended production default.
  *
  * Always uses local first, then gates on node cert and/or quorum attestation
  * for transactions above a configurable value threshold.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HybridLeaseProvider = void 0;
-const certificate_js_1 = require("./certificate.js");
-class HybridLeaseProvider {
+import { signCertificate, certificateSignatureVerified } from './certificate.js';
+export class HybridLeaseProvider {
     constructor(config) {
         this.local = config.local;
         this.node = config.node;
@@ -56,7 +53,7 @@ class HybridLeaseProvider {
                         attestations,
                     };
                     certificate.signature = this.certificateSigner
-                        ? await (0, certificate_js_1.signCertificate)(this.certificateSigner, certificate)
+                        ? await signCertificate(this.certificateSigner, certificate)
                         : '';
                     return { ...reservation, certificate };
                 }
@@ -135,11 +132,10 @@ class HybridLeaseProvider {
             return this.local.verifyLeaseCertificate(cert);
         // Locally-assembled quorum certificates authenticate against our issuer.
         if (cert.issuedBy === (this.certificateSigner?.name ?? 'p2p-quorum')) {
-            return (0, certificate_js_1.certificateSignatureVerified)(cert, this.certificateSigner);
+            return certificateSignatureVerified(cert, this.certificateSigner);
         }
         if (this.node)
             return this.node.verifyLeaseCertificate(cert);
         return false;
     }
 }
-exports.HybridLeaseProvider = HybridLeaseProvider;

package/dist/index.d.ts

@@ -13,3 +13,5 @@ export { P2PQuorumLeaseProvider as QuorumLeaseProvider } from './quorum.js';
 export { OnchainWatermarkProvider as ChainWatermarkProvider } from './onchain.js';
 export { allocateDeviceRange, deviceSlotForAddressIndex } from './device.js';
 export { WatermarkMonotonicityError, WatermarkExhaustedError, WatermarkSeedRegressionError, WatermarkSeedRequiredError, LeaseNotFoundError, IndicesUnavailableError, PersonalLeaseNodeNotConfiguredError, P2PQuorumNotImplementedError, OnchainWatermarkNotImplementedError, QuorumUnavailableError, QuorumConflictError, OnchainWatermarkError, DeviceRangeViolationError, } from './errors.js';
+export { ReplicatedLeaseJournalBackup } from './replicated-backup.js';
+export type { LeaseJournalRestoreTarget } from './replicated-backup.js';

package/dist/index.js

@@ -1,43 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceRangeViolationError = exports.OnchainWatermarkError = exports.QuorumConflictError = exports.QuorumUnavailableError = exports.OnchainWatermarkNotImplementedError = exports.P2PQuorumNotImplementedError = exports.PersonalLeaseNodeNotConfiguredError = exports.IndicesUnavailableError = exports.LeaseNotFoundError = exports.WatermarkSeedRequiredError = exports.WatermarkSeedRegressionError = exports.WatermarkExhaustedError = exports.WatermarkMonotonicityError = exports.deviceSlotForAddressIndex = exports.allocateDeviceRange = exports.ChainWatermarkProvider = exports.QuorumLeaseProvider = exports.OnchainWatermarkProvider = exports.P2PQuorumLeaseProvider = exports.PersonalLeaseNodeProvider = exports.HybridLeaseProvider = exports.AxiaLeaseProvider = exports.exportLeaseWatermark = exports.seedLeaseWatermark = exports.LocalLeaseProvider = exports.LeaseJournal = exports.fromFlatIndex = exports.flatIndex = exports.WotsWatermarkStore = void 0;
-var watermark_js_1 = require("./watermark.js");
-Object.defineProperty(exports, "WotsWatermarkStore", { enumerable: true, get: function () { return watermark_js_1.WotsWatermarkStore; } });
-Object.defineProperty(exports, "flatIndex", { enumerable: true, get: function () { return watermark_js_1.flatIndex; } });
-Object.defineProperty(exports, "fromFlatIndex", { enumerable: true, get: function () { return watermark_js_1.fromFlatIndex; } });
-var journal_js_1 = require("./journal.js");
-Object.defineProperty(exports, "LeaseJournal", { enumerable: true, get: function () { return journal_js_1.LeaseJournal; } });
-var local_js_1 = require("./local.js");
-Object.defineProperty(exports, "LocalLeaseProvider", { enumerable: true, get: function () { return local_js_1.LocalLeaseProvider; } });
-var seed_js_1 = require("./seed.js");
-Object.defineProperty(exports, "seedLeaseWatermark", { enumerable: true, get: function () { return seed_js_1.seedLeaseWatermark; } });
-Object.defineProperty(exports, "exportLeaseWatermark", { enumerable: true, get: function () { return seed_js_1.exportLeaseWatermark; } });
-var axia_js_1 = require("./axia.js");
-Object.defineProperty(exports, "AxiaLeaseProvider", { enumerable: true, get: function () { return axia_js_1.AxiaLeaseProvider; } });
-var hybrid_js_1 = require("./hybrid.js");
-Object.defineProperty(exports, "HybridLeaseProvider", { enumerable: true, get: function () { return hybrid_js_1.HybridLeaseProvider; } });
-var stubs_js_1 = require("./stubs.js");
-Object.defineProperty(exports, "PersonalLeaseNodeProvider", { enumerable: true, get: function () { return stubs_js_1.PersonalLeaseNodeProvider; } });
-Object.defineProperty(exports, "P2PQuorumLeaseProvider", { enumerable: true, get: function () { return stubs_js_1.P2PQuorumLeaseProvider; } });
-Object.defineProperty(exports, "OnchainWatermarkProvider", { enumerable: true, get: function () { return stubs_js_1.OnchainWatermarkProvider; } });
-var quorum_js_1 = require("./quorum.js");
-Object.defineProperty(exports, "QuorumLeaseProvider", { enumerable: true, get: function () { return quorum_js_1.P2PQuorumLeaseProvider; } });
-var onchain_js_1 = require("./onchain.js");
-Object.defineProperty(exports, "ChainWatermarkProvider", { enumerable: true, get: function () { return onchain_js_1.OnchainWatermarkProvider; } });
-var device_js_1 = require("./device.js");
-Object.defineProperty(exports, "allocateDeviceRange", { enumerable: true, get: function () { return device_js_1.allocateDeviceRange; } });
-Object.defineProperty(exports, "deviceSlotForAddressIndex", { enumerable: true, get: function () { return device_js_1.deviceSlotForAddressIndex; } });
-var errors_js_1 = require("./errors.js");
-Object.defineProperty(exports, "WatermarkMonotonicityError", { enumerable: true, get: function () { return errors_js_1.WatermarkMonotonicityError; } });
-Object.defineProperty(exports, "WatermarkExhaustedError", { enumerable: true, get: function () { return errors_js_1.WatermarkExhaustedError; } });
-Object.defineProperty(exports, "WatermarkSeedRegressionError", { enumerable: true, get: function () { return errors_js_1.WatermarkSeedRegressionError; } });
-Object.defineProperty(exports, "WatermarkSeedRequiredError", { enumerable: true, get: function () { return errors_js_1.WatermarkSeedRequiredError; } });
-Object.defineProperty(exports, "LeaseNotFoundError", { enumerable: true, get: function () { return errors_js_1.LeaseNotFoundError; } });
-Object.defineProperty(exports, "IndicesUnavailableError", { enumerable: true, get: function () { return errors_js_1.IndicesUnavailableError; } });
-Object.defineProperty(exports, "PersonalLeaseNodeNotConfiguredError", { enumerable: true, get: function () { return errors_js_1.PersonalLeaseNodeNotConfiguredError; } });
-Object.defineProperty(exports, "P2PQuorumNotImplementedError", { enumerable: true, get: function () { return errors_js_1.P2PQuorumNotImplementedError; } });
-Object.defineProperty(exports, "OnchainWatermarkNotImplementedError", { enumerable: true, get: function () { return errors_js_1.OnchainWatermarkNotImplementedError; } });
-Object.defineProperty(exports, "QuorumUnavailableError", { enumerable: true, get: function () { return errors_js_1.QuorumUnavailableError; } });
-Object.defineProperty(exports, "QuorumConflictError", { enumerable: true, get: function () { return errors_js_1.QuorumConflictError; } });
-Object.defineProperty(exports, "OnchainWatermarkError", { enumerable: true, get: function () { return errors_js_1.OnchainWatermarkError; } });
-Object.defineProperty(exports, "DeviceRangeViolationError", { enumerable: true, get: function () { return errors_js_1.DeviceRangeViolationError; } });
+export { WotsWatermarkStore, flatIndex, fromFlatIndex, } from './watermark.js';
+export { LeaseJournal } from './journal.js';
+export { LocalLeaseProvider } from './local.js';
+export { seedLeaseWatermark, exportLeaseWatermark } from './seed.js';
+export { AxiaLeaseProvider } from './axia.js';
+export { HybridLeaseProvider } from './hybrid.js';
+export { PersonalLeaseNodeProvider, P2PQuorumLeaseProvider, OnchainWatermarkProvider, } from './stubs.js';
+export { P2PQuorumLeaseProvider as QuorumLeaseProvider } from './quorum.js';
+export { OnchainWatermarkProvider as ChainWatermarkProvider } from './onchain.js';
+export { allocateDeviceRange, deviceSlotForAddressIndex } from './device.js';
+export { WatermarkMonotonicityError, WatermarkExhaustedError, WatermarkSeedRegressionError, WatermarkSeedRequiredError, LeaseNotFoundError, IndicesUnavailableError, PersonalLeaseNodeNotConfiguredError, P2PQuorumNotImplementedError, OnchainWatermarkNotImplementedError, QuorumUnavailableError, QuorumConflictError, OnchainWatermarkError, DeviceRangeViolationError, } from './errors.js';
+export { ReplicatedLeaseJournalBackup } from './replicated-backup.js';