@totemsdk/wots-lease 0.1.3 → 0.1.5

package/dist/axia.js

@@ -47,6 +47,7 @@ class AxiaLeaseProvider {
         const lease = {
             leaseId: reservationId,
             leaseToken: resp.leaseToken,
+            treeId: params.treeId,
             indices,
             expiresAt,
             status: 'active',

package/dist/journal.d.ts

@@ -12,6 +12,7 @@ export declare class LeaseJournal {
     constructor(storage: StorageAdapter, logger?: LoggerAdapter);
     initialize(): Promise<void>;
     append(entry: JournalEntry): Promise<void>;
+    private _verifyChain;
     getAll(): JournalEntry[];
     getByTree(treeId: string): JournalEntry[];
     getByReservation(reservationId: string): JournalEntry | undefined;

package/dist/journal.js

@@ -5,8 +5,24 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LeaseJournal = void 0;
+const crypto_1 = require("crypto");
 const core_1 = require("@totemsdk/core");
 const STORAGE_KEY = 'totem_wots_journal';
+function hashEntry(entry) {
+    const encoder = new TextEncoder();
+    const data = {
+        t: entry.treeId,
+        b: entry.branchId,
+        i: entry.wotsIndex,
+        s: entry.status,
+        r: entry.reservationId,
+        p: entry.previousHash,
+        ts: entry.timestamp,
+        d: entry.deviceId,
+    };
+    const bytes = encoder.encode(JSON.stringify(data));
+    return (0, crypto_1.createHash)('sha256').update(bytes).digest('hex');
+}
 class LeaseJournal {
     constructor(storage, logger = new core_1.NoopLogger()) {
         this.storage = storage;
@@ -19,12 +35,40 @@ class LeaseJournal {
             return;
         const stored = await this.storage.get(STORAGE_KEY);
         this.entries = stored ?? [];
+        if (this.entries.length > 0) {
+            const ok = this._verifyChain();
+            if (!ok) {
+                this.logger.error('[LeaseJournal] hash chain integrity check FAILED — journal may be tampered');
+                throw new Error('Journal hash chain integrity check failed');
+            }
+        }
         this._initialized = true;
     }
     async append(entry) {
+        const prev = this.entries[this.entries.length - 1];
+        entry.previousHash = prev?.hash;
+        entry.hash = hashEntry(entry);
         this.entries.push(entry);
         await this.storage.set(STORAGE_KEY, this.entries);
-        this.logger.debug(`[LeaseJournal] ${entry.status} treeId=${entry.treeId} idx=${entry.wotsIndex} txId=${entry.txId ?? '-'}`);
+        this.logger.debug(`[LeaseJournal] ${entry.status} treeId=${entry.treeId} idx=${entry.wotsIndex} txId=${entry.txId ?? '-'} hash=${entry.hash.slice(0, 8)}`);
+    }
+    _verifyChain() {
+        for (let i = 0; i < this.entries.length; i++) {
+            const e = this.entries[i];
+            const expectedHash = hashEntry(e);
+            if (e.hash !== expectedHash) {
+                this.logger.error(`[LeaseJournal] hash mismatch at entry ${i}: expected ${expectedHash}, stored ${e.hash}`);
+                return false;
+            }
+            if (i > 0) {
+                const prevHash = this.entries[i - 1].hash;
+                if (e.previousHash !== prevHash) {
+                    this.logger.error(`[LeaseJournal] previousHash mismatch at entry ${i}: expected ${prevHash}, stored ${e.previousHash}`);
+                    return false;
+                }
+            }
+        }
+        return true;
     }
     getAll() {
         return [...this.entries];

package/dist/local.d.ts

@@ -13,10 +13,12 @@ export declare class LocalLeaseProvider implements WotsLeaseProvider {
     private readonly journal;
     private _initialized;
     private readonly deviceId;
-    /** In-memory map: reservationId → treeId (lost on restart; watermark survives). */
-    private readonly _treeIdByReservation;
     constructor(storage: StorageAdapter, logger?: LoggerAdapter, deviceId?: string);
     initialize(): Promise<void>;
+    /** Burn all active (non-expired) leases that have no matching treeId.
+     *  On restart, leases with missing treeId (from before the treeId field was added)
+     *  must be burned to prevent index reuse. */
+    private burnUnresolvedReservations;
     private recoverExpiredReservations;
     reserveKeyUse(params: ReserveParams): Promise<LeaseReservation>;
     commitKeyUse(reservationId: string, txId: string): Promise<void>;

package/dist/local.js

@@ -22,8 +22,6 @@ class LocalLeaseProvider {
     constructor(storage, logger = new core_1.NoopLogger(), deviceId = 'local') {
         this.logger = logger;
         this._initialized = false;
-        /** In-memory map: reservationId → treeId (lost on restart; watermark survives). */
-        this._treeIdByReservation = new Map();
         this.watermark = new watermark_js_1.WotsWatermarkStore(storage, logger);
         this.leaseStore = new core_2.LeaseStore(storage, logger);
         this.journal = new journal_js_1.LeaseJournal(storage, logger);
@@ -36,13 +34,37 @@ class LocalLeaseProvider {
         await this.leaseStore.initialize();
         await this.journal.initialize();
         await this.recoverExpiredReservations();
+        await this.burnUnresolvedReservations();
         this._initialized = true;
     }
+    /** Burn all active (non-expired) leases that have no matching treeId.
+     *  On restart, leases with missing treeId (from before the treeId field was added)
+     *  must be burned to prevent index reuse. */
+    async burnUnresolvedReservations() {
+        const now = Date.now();
+        for (const lease of this.leaseStore.getAll()) {
+            if (lease.status === 'active' && lease.expiresAt >= now && !lease.treeId) {
+                this.logger.warn(`[LocalLeaseProvider] Burning unresolved lease ${lease.leaseId} (no treeId)`);
+                await this.watermark.markUnavailable('default', lease.indices, 'burned');
+                await this.leaseStore.updateStatus(lease.leaseId, 'cancelled');
+                await this.journal.append({
+                    treeId: 'default',
+                    branchId: 'default',
+                    wotsIndex: (0, watermark_js_1.flatIndex)(lease.indices),
+                    indices: lease.indices,
+                    status: 'burned',
+                    reservationId: lease.leaseId,
+                    timestamp: now,
+                    deviceId: this.deviceId,
+                });
+            }
+        }
+    }
     async recoverExpiredReservations() {
         const now = Date.now();
         for (const lease of this.leaseStore.getAll()) {
             if (lease.status === 'active' && lease.expiresAt < now) {
-                const treeId = this._treeIdByReservation.get(lease.leaseId) ?? 'default';
+                const treeId = lease.treeId ?? 'default';
                 await this.watermark.markUnavailable(treeId, lease.indices, 'reserved-expired');
                 await this.leaseStore.updateStatus(lease.leaseId, 'expired');
                 await this.journal.append({
@@ -51,6 +73,7 @@ class LocalLeaseProvider {
                     wotsIndex: (0, watermark_js_1.flatIndex)(lease.indices),
                     indices: lease.indices,
                     status: 'reserved-expired',
+                    reservationId: lease.leaseId,
                     timestamp: now,
                     deviceId: this.deviceId,
                 });
@@ -62,18 +85,22 @@ class LocalLeaseProvider {
             await this.initialize();
         const treeId = params.treeId;
         const ttlMs = params.ttlMs ?? 120000;
+        // Atomically get the next available index AND mark it reserved in the watermark
         const indices = this.watermark.getNextIndices(treeId);
+        // Validate device range BEFORE marking unavailable — prevents permanent index loss
         if (params.deviceId) {
             const range = this.getDeviceRange(params.deviceId);
             if (range && (indices.addressIndex < range.start || indices.addressIndex > range.end)) {
                 throw new errors_js_1.DeviceRangeViolationError(indices.addressIndex, range.start, range.end);
             }
         }
+        await this.watermark.markUnavailable(treeId, indices, 'reserved');
         const reservationId = randomId();
         const expiresAt = Date.now() + ttlMs;
         const lease = {
             leaseId: reservationId,
             leaseToken: reservationId,
+            treeId,
             indices,
             expiresAt,
             status: 'active',
@@ -81,14 +108,13 @@ class LocalLeaseProvider {
             leaseTTL: ttlMs,
         };
         await this.leaseStore.save(lease);
-        // Track treeId in memory so commit/burn can reference the right watermark tree
-        this._treeIdByReservation.set(reservationId, treeId);
         await this.journal.append({
             treeId,
             branchId: params.branchId ?? 'default',
             wotsIndex: (0, watermark_js_1.flatIndex)(indices),
             indices,
             status: 'reserved',
+            reservationId,
             payloadHash: params.payloadHash,
             timestamp: Date.now(),
             deviceId: params.deviceId ?? this.deviceId,
@@ -101,17 +127,19 @@ class LocalLeaseProvider {
         const lease = this.leaseStore.get(reservationId);
         if (!lease)
             throw new errors_js_1.LeaseNotFoundError(reservationId);
-        const treeId = this._treeIdByReservation.get(reservationId) ?? 'default';
+        if (lease.status === 'finalized')
+            return;
+        const treeId = lease.treeId ?? 'default';
         const indices = lease.indices;
         await this.watermark.markUnavailable(treeId, indices, 'committed');
         await this.leaseStore.updateStatus(reservationId, 'finalized');
-        this._treeIdByReservation.delete(reservationId);
         await this.journal.append({
             treeId,
             branchId: 'default',
             wotsIndex: (0, watermark_js_1.flatIndex)(indices),
             indices,
             status: 'committed',
+            reservationId,
             txId,
             timestamp: Date.now(),
             deviceId: this.deviceId,
@@ -123,11 +151,10 @@ class LocalLeaseProvider {
         const lease = this.leaseStore.get(reservationId);
         if (!lease)
             throw new errors_js_1.LeaseNotFoundError(reservationId);
-        const treeId = this._treeIdByReservation.get(reservationId) ?? 'default';
+        const treeId = lease.treeId ?? 'default';
         const indices = lease.indices;
         await this.watermark.markUnavailable(treeId, indices, 'burned');
         await this.leaseStore.updateStatus(reservationId, 'cancelled');
-        this._treeIdByReservation.delete(reservationId);
         this.logger.warn(`[LocalLeaseProvider] Burning reservation ${reservationId}: ${reason}`);
         await this.journal.append({
             treeId,
@@ -135,6 +162,7 @@ class LocalLeaseProvider {
             wotsIndex: (0, watermark_js_1.flatIndex)(indices),
             indices,
             status: 'burned',
+            reservationId,
             timestamp: Date.now(),
             deviceId: this.deviceId,
         });

package/dist/stubs.d.ts

@@ -1,23 +1,46 @@
 /**
- * Stub implementations for Layers 3–5.
- * These throw descriptive errors until the full implementations land.
+ * Implementations for Layers 3–5 of the WotsLeaseProvider hierarchy.
+ *
+ * Layer 3 (PersonalLeaseNodeProvider) — HTTP client for a personal @totemsdk/lookup-node
+ *   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.
  */
 import type { WotsLeaseProvider, ReserveParams, LeaseReservation, LeaseCertificate, LocalWatermark, SyncResult, PersonalLeaseNodeConfig } from './types.js';
 /**
- * Layer 3 — personal p2p lease node.
+ * Layer 3 — personal lookup-node lease coordinator.
+ *
+ * Calls the HTTP REST API exposed by a running @totemsdk/lookup-node that has
+ * lease coordination enabled. All write operations are forwarded to the node's
+ * LeaseCoordinator so the node acts as the source-of-truth watermark journal
+ * for high-value transactions.
  *
- * Verifies ed25519 certs issued by a configured node public key.
- * Reserve/commit throws until the node is reachable — callers should
- * wrap with HybridLeaseProvider using a LocalLeaseProvider as the local layer.
+ * Wrap with HybridLeaseProvider so local reservations always succeed even when
+ * the personal node is temporarily unreachable:
+ *
+ * ```ts
+ * const provider = new HybridLeaseProvider({
+ *   local: new LocalLeaseProvider(storage),
+ *   node:  new PersonalLeaseNodeProvider({ nodeUrl, nodePubkey }),
+ *   threshold: 10, // escalate to node for txns >= 10 MIN
+ * });
+ * ```
  */
 export declare class PersonalLeaseNodeProvider implements WotsLeaseProvider {
-    private readonly config;
+    private readonly baseUrl;
+    private readonly nodePubkey;
+    private readonly authToken?;
     constructor(config: PersonalLeaseNodeConfig);
-    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>;
+    private headers;
+    private post;
+    private get;
+    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>;
 }

package/dist/stubs.js

@@ -1,44 +1,102 @@
 "use strict";
 /**
- * Stub implementations for Layers 3–5.
- * These throw descriptive errors until the full implementations land.
+ * Implementations for Layers 3–5 of the WotsLeaseProvider hierarchy.
+ *
+ * Layer 3 (PersonalLeaseNodeProvider) — HTTP client for a personal @totemsdk/lookup-node
+ *   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.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OnchainWatermarkProvider = exports.P2PQuorumLeaseProvider = exports.PersonalLeaseNodeProvider = void 0;
 const errors_js_1 = require("./errors.js");
 /**
- * Layer 3 — personal p2p lease node.
+ * Layer 3 — personal lookup-node lease coordinator.
+ *
+ * Calls the HTTP REST API exposed by a running @totemsdk/lookup-node that has
+ * lease coordination enabled. All write operations are forwarded to the node's
+ * LeaseCoordinator so the node acts as the source-of-truth watermark journal
+ * for high-value transactions.
+ *
+ * Wrap with HybridLeaseProvider so local reservations always succeed even when
+ * the personal node is temporarily unreachable:
  *
- * Verifies ed25519 certs issued by a configured node public key.
- * Reserve/commit throws until the node is reachable — callers should
- * wrap with HybridLeaseProvider using a LocalLeaseProvider as the local layer.
+ * ```ts
+ * const provider = new HybridLeaseProvider({
+ *   local: new LocalLeaseProvider(storage),
+ *   node:  new PersonalLeaseNodeProvider({ nodeUrl, nodePubkey }),
+ *   threshold: 10, // escalate to node for txns >= 10 MIN
+ * });
+ * ```
  */
 class PersonalLeaseNodeProvider {
     constructor(config) {
-        this.config = config;
-    }
-    reserveKeyUse(_params) {
-        throw new errors_js_1.PersonalLeaseNodeNotConfiguredError();
-    }
-    commitKeyUse(_reservationId, _txId) {
-        throw new errors_js_1.PersonalLeaseNodeNotConfiguredError();
-    }
-    burnReservation(_reservationId, _reason) {
-        throw new errors_js_1.PersonalLeaseNodeNotConfiguredError();
-    }
-    getLocalWatermark(_treeId) {
-        throw new errors_js_1.PersonalLeaseNodeNotConfiguredError();
-    }
-    publishWatermark(_treeId) {
-        throw new errors_js_1.PersonalLeaseNodeNotConfiguredError();
-    }
-    syncLeaseJournal() {
-        throw new errors_js_1.PersonalLeaseNodeNotConfiguredError();
+        this.baseUrl = config.nodeUrl.replace(/\/$/, '');
+        this.nodePubkey = config.nodePubkey;
+        this.authToken = config.authToken;
+    }
+    headers() {
+        const h = { 'Content-Type': 'application/json' };
+        if (this.authToken)
+            h['Authorization'] = `Bearer ${this.authToken}`;
+        return h;
+    }
+    async post(path, body) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: this.headers(),
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            throw new Error(`PersonalLeaseNodeProvider: ${path} HTTP ${res.status} — ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    async get(path) {
+        const res = await fetch(`${this.baseUrl}${path}`, { headers: this.headers() });
+        if (!res.ok) {
+            const text = await res.text().catch(() => '');
+            throw new Error(`PersonalLeaseNodeProvider: GET ${path} HTTP ${res.status} — ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    async reserveKeyUse(params) {
+        const data = await this.post('/v1/lease/reserve', {
+            treeId: params.treeId,
+            branchId: params.branchId,
+            deviceId: params.deviceId,
+            ttlMs: params.ttlMs,
+            payloadHash: params.payloadHash,
+            purpose: params.purpose,
+        });
+        return { ...data.reservation, certificate: data.certificate };
+    }
+    async commitKeyUse(reservationId, txId) {
+        const data = await this.post('/v1/lease/commit', { reservationId, txId });
+        if (!data.ok)
+            throw new Error(`PersonalLeaseNodeProvider: commit failed — ${data.error ?? 'unknown'}`);
+    }
+    async burnReservation(reservationId, reason) {
+        const data = await this.post('/v1/lease/burn', { reservationId, reason });
+        if (!data.ok)
+            throw new Error(`PersonalLeaseNodeProvider: burn failed — ${data.error ?? 'unknown'}`);
+    }
+    async getLocalWatermark(treeId) {
+        return this.get(`/v1/lease/watermark/${encodeURIComponent(treeId)}`);
+    }
+    async publishWatermark(treeId) {
+        await this.post(`/v1/lease/watermark/${encodeURIComponent(treeId)}/publish`, {});
+    }
+    async syncLeaseJournal() {
+        return this.get('/v1/lease/journal/sync');
     }
     async verifyLeaseCertificate(cert) {
         if (!cert)
             return false;
-        if (cert.issuedBy !== this.config.nodePubkey)
+        if (cert.issuedBy !== this.nodePubkey)
             return false;
         if (cert.expiresAt <= Date.now())
             return false;

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * @totemsdk/wots-lease — canonical v3 watermark types and WotsLeaseProvider interface
  */
-export type UnavailableReason = 'committed' | 'burned' | 'reserved-expired';
+export type UnavailableReason = 'reserved' | 'committed' | 'burned' | 'reserved-expired';
 export interface SigningIndices {
     addressIndex: number;
     l1: number;
@@ -86,10 +86,13 @@ export interface JournalEntry {
     wotsIndex: number;
     indices: SigningIndices;
     status: 'reserved' | 'committed' | 'burned' | 'reserved-expired';
+    reservationId?: string;
     payloadHash?: string;
     txId?: string;
     timestamp: number;
     deviceId: string;
+    previousHash?: string;
+    hash?: string;
 }
 export interface DeviceKeyRange {
     deviceId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/wots-lease",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "WOTS key-use coordination — canonical v3 watermark, provider-based lease safety layers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,22 +11,27 @@
       "import": "./dist/index.js"
     }
   },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc",
+    "clean": "rm -rf dist",
+    "test": "jest --passWithNoTests"
+  },
   "files": [
     "dist",
     "README.md",
     "LICENSE"
   ],
   "dependencies": {
-    "@totemsdk/lookup-protocol": "0.1.3",
-    "@totemsdk/core": "1.0.10"
+    "@totemsdk/core": "^1.1.0",
+    "@totemsdk/lookup-protocol": "^0.1.3"
   },
   "devDependencies": {
-    "@noble/hashes": "^2.2.0",
-    "@types/jest": "^29.0.0",
+    "@types/jest": "^30.0.0",
     "@types/node": "^20.0.0",
-    "jest": "^29.0.0",
+    "jest": "^30.4.2",
     "ts-jest": "^29.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^7.0.2"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -36,13 +41,13 @@
   },
   "license": "MIT",
   "author": "Totem SDK",
-  "homepage": "https://totemsdk.com",
+  "homepage": "https://totem.ing",
   "bugs": {
-    "url": "https://github.com/MrGheek/axia-totem/issues"
+    "url": "https://github.com/totem-sdk/totem-sdk/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/MrGheek/axia-totem.git",
+    "url": "git+https://github.com/totem-sdk/totem-sdk.git",
     "directory": "packages/totem-sdk/packages/wots-lease"
   },
   "keywords": [
@@ -54,10 +59,5 @@
     "wots",
     "kissvm",
     "utxo"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "clean": "rm -rf dist",
-    "test": "jest --passWithNoTests"
-  }
-}
+  ]
+}