@totemsdk/wots-lease 0.1.5 → 1.0.0

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>;
-}

package/dist/stubs.js

@@ -6,12 +6,15 @@
  *   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.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OnchainWatermarkProvider = exports.P2PQuorumLeaseProvider = exports.PersonalLeaseNodeProvider = void 0;
-const errors_js_1 = require("./errors.js");
+exports.PersonalLeaseNodeProvider = exports.OnchainWatermarkProvider = exports.P2PQuorumLeaseProvider = void 0;
+var quorum_js_1 = require("./quorum.js");
+Object.defineProperty(exports, "P2PQuorumLeaseProvider", { enumerable: true, get: function () { return quorum_js_1.P2PQuorumLeaseProvider; } });
+var onchain_js_1 = require("./onchain.js");
+Object.defineProperty(exports, "OnchainWatermarkProvider", { enumerable: true, get: function () { return onchain_js_1.OnchainWatermarkProvider; } });
 /**
  * Layer 3 — personal lookup-node lease coordinator.
  *
@@ -104,53 +107,3 @@ class PersonalLeaseNodeProvider {
     }
 }
 exports.PersonalLeaseNodeProvider = PersonalLeaseNodeProvider;
-/** Layer 4 — p2p replicated lease witnesses. */
-class P2PQuorumLeaseProvider {
-    reserveKeyUse(_params) {
-        throw new errors_js_1.P2PQuorumNotImplementedError();
-    }
-    commitKeyUse(_reservationId, _txId) {
-        throw new errors_js_1.P2PQuorumNotImplementedError();
-    }
-    burnReservation(_reservationId, _reason) {
-        throw new errors_js_1.P2PQuorumNotImplementedError();
-    }
-    getLocalWatermark(_treeId) {
-        throw new errors_js_1.P2PQuorumNotImplementedError();
-    }
-    publishWatermark(_treeId) {
-        throw new errors_js_1.P2PQuorumNotImplementedError();
-    }
-    syncLeaseJournal() {
-        throw new errors_js_1.P2PQuorumNotImplementedError();
-    }
-    verifyLeaseCertificate(_cert) {
-        throw new errors_js_1.P2PQuorumNotImplementedError();
-    }
-}
-exports.P2PQuorumLeaseProvider = P2PQuorumLeaseProvider;
-/** Layer 5 — on-chain watermark coin. */
-class OnchainWatermarkProvider {
-    reserveKeyUse(_params) {
-        throw new errors_js_1.OnchainWatermarkNotImplementedError();
-    }
-    commitKeyUse(_reservationId, _txId) {
-        throw new errors_js_1.OnchainWatermarkNotImplementedError();
-    }
-    burnReservation(_reservationId, _reason) {
-        throw new errors_js_1.OnchainWatermarkNotImplementedError();
-    }
-    getLocalWatermark(_treeId) {
-        throw new errors_js_1.OnchainWatermarkNotImplementedError();
-    }
-    publishWatermark(_treeId) {
-        throw new errors_js_1.OnchainWatermarkNotImplementedError();
-    }
-    syncLeaseJournal() {
-        throw new errors_js_1.OnchainWatermarkNotImplementedError();
-    }
-    verifyLeaseCertificate(_cert) {
-        throw new errors_js_1.OnchainWatermarkNotImplementedError();
-    }
-}
-exports.OnchainWatermarkProvider = OnchainWatermarkProvider;

package/dist/types.d.ts

@@ -1,6 +1,7 @@
 /**
  * @totemsdk/wots-lease — canonical v3 watermark types and WotsLeaseProvider interface
  */
+import type { LocalLeaseProvider } from './local.js';
 export type UnavailableReason = 'reserved' | 'committed' | 'burned' | 'reserved-expired';
 export interface SigningIndices {
     addressIndex: number;
@@ -22,6 +23,12 @@ export interface WotsWatermarkState {
     version: 3;
     trees: Record<string, TreeWatermark>;
 }
+export interface QuorumAttestation {
+    peerId: string;
+    indices: SigningIndices;
+    expiresAt: number;
+    signature?: string;
+}
 export interface LeaseCertificate {
     reservationId: string;
     treeId: string;
@@ -34,6 +41,10 @@ export interface LeaseCertificate {
     issuedAt: number;
     expiresAt: number;
     signature: string;
+    /** Layer 4 — quorum attestations collected from P2P peers. */
+    attestations?: QuorumAttestation[];
+    /** Layer 5 — content hash of the on-chain watermark TX (sha3-256 of TxPoW bytes). */
+    txpowid?: string;
 }
 export interface LeaseReservation {
     reservationId: string;
@@ -105,3 +116,84 @@ export interface PersonalLeaseNodeConfig {
     nodePubkey: string;
     authToken?: string;
 }
+/**
+ * Layer 4 — P2P quorum lease coordination.
+ *
+ * `peers` is the set of quorum members this device coordinates with. Each
+ * entry is a transport-agnostic RPC handle: the provider sends the same
+ * LEASE_RESERVE / LEASE_COMMIT / LEASE_BURN wire messages used by the
+ * lookup protocol, so any peer that speaks that protocol can participate
+ * (lookup nodes, other devices, or in-memory test peers).
+ */
+export interface QuorumPeer {
+    peerId: string;
+    request(message: {
+        type: 'LEASE_RESERVE' | 'LEASE_COMMIT' | 'LEASE_BURN' | 'LEASE_WATERMARK';
+        payload: Record<string, unknown>;
+    }, timeoutMs?: number): Promise<{
+        type: string;
+        payload: Record<string, unknown>;
+    }>;
+}
+export interface P2PQuorumLeaseProviderConfig {
+    /** Quorum members to coordinate with (excluding self). */
+    peers: QuorumPeer[];
+    /** Minimum attestations required for a reservation to be considered quorum-approved. Default: 1. */
+    minAttestations?: number;
+    /** Local provider used for the authoritative local watermark + journal. */
+    local: LocalLeaseProvider;
+    /** Timeout per peer request. Default: 5_000. */
+    requestTimeoutMs?: number;
+    /** Require quorum approval on commit as well as reserve. Default: false. */
+    requireQuorumOnCommit?: boolean;
+}
+/**
+ * Layer 5 — on-chain watermark anchoring.
+ *
+ * `chain` is any ChainStateProvider (hosted, Minima RPC, or lookup node).
+ * The provider spends a dedicated watermark coin whose STATE(0) holds the
+ * flat watermark cursor; every publish advances it on-chain so the watermark
+ * is verifiable by third parties without trusting this device.
+ */
+export interface OnchainWatermarkProviderConfig {
+    /** Chain access for coin queries, proofs, and broadcasting. */
+    chain: {
+        getCoin(coinId: string): Promise<{
+            coinid: string;
+            address: string;
+            amount: string;
+            tokenid: string;
+            state?: unknown[];
+        } | null>;
+        getProof(coinId: string): Promise<{
+            data: unknown;
+        }>;
+        broadcastTxPoW(txpowHex: string): Promise<{
+            success: boolean;
+            txpowid?: string;
+            message?: string;
+        }>;
+        getTip?(): Promise<{
+            block: number;
+        }>;
+    };
+    /** Coin ID of the dedicated watermark coin. */
+    watermarkCoinId: string;
+    /** Address the watermark coin currently sits at (spending address). */
+    watermarkAddress: string;
+    /** Token ID of the watermark coin. Default: '0x00'. */
+    tokenId?: string;
+    /** Amount of the watermark coin in MIN base units. Default: '1'. */
+    amount?: string;
+    /** Local provider used for the authoritative local watermark + journal. */
+    local: LocalLeaseProvider;
+    /** Signer for the watermark coin's script (SIGNEDBY digest). */
+    signer: {
+        publicKeyDigest: string;
+        sign(message: Uint8Array): Promise<Uint8Array>;
+    };
+    /** Port holding the flat watermark cursor in the coin state. Default: 0. */
+    statePort?: number;
+    /** Minimum blocks between on-chain publishes (rate limit). Default: 1. */
+    minBlocksBetweenPublishes?: number;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/wots-lease",
-  "version": "0.1.5",
+  "version": "1.0.0",
   "description": "WOTS key-use coordination — canonical v3 watermark, provider-based lease safety layers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,20 +11,17 @@
       "import": "./dist/index.js"
     }
   },
-  "scripts": {
-    "build": "tsc",
-    "prepare": "tsc",
-    "clean": "rm -rf dist",
-    "test": "jest --passWithNoTests"
-  },
   "files": [
     "dist",
+    "rust/pkg/",
+    "rust/pkg-node/",
     "README.md",
     "LICENSE"
   ],
   "dependencies": {
-    "@totemsdk/core": "^1.1.0",
-    "@totemsdk/lookup-protocol": "^0.1.3"
+    "@totemsdk/lookup-protocol": "^0.1.6",
+    "@totemsdk/core": "^1.2.9",
+    "@totemsdk/txpow": "^0.1.7"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
@@ -48,7 +45,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/totem-sdk/totem-sdk.git",
-    "directory": "packages/totem-sdk/packages/wots-lease"
+    "directory": "packages/wots-lease"
   },
   "keywords": [
     "totem",
@@ -57,7 +54,12 @@
     "blockchain",
     "quantum-resistant",
     "wots",
-    "kissvm",
     "utxo"
-  ]
-}
+  ],
+  "scripts": {
+    "build": "npm run build:wasm && tsc && node ../../scripts/clean-wasm-output-ignores.mjs",
+    "build:wasm": "cd rust && wasm-pack build --target bundler --out-dir pkg && wasm-pack build --target nodejs --out-dir pkg-node",
+    "clean": "rm -rf dist rust/pkg rust/pkg-node rust/target",
+    "test": "jest"
+  }
+}

package/rust/pkg/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "wots-lease-wasm",
+  "type": "module",
+  "collaborators": [
+    "Totem SDK Contributors"
+  ],
+  "description": "WOTS key-use coordination — canonical v3 watermark, flat index computation, monotonicity enforcement, device keyspace partitioning (Rust/WASM)",
+  "version": "0.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/totem-sdk/totem-sdk"
+  },
+  "files": [
+    "wots_lease_wasm_bg.wasm",
+    "wots_lease_wasm.js",
+    "wots_lease_wasm_bg.js",
+    "wots_lease_wasm.d.ts"
+  ],
+  "main": "wots_lease_wasm.js",
+  "homepage": "https://totem.ing",
+  "types": "wots_lease_wasm.d.ts",
+  "sideEffects": [
+    "./wots_lease_wasm.js",
+    "./snippets/*"
+  ]
+}

package/rust/pkg/wots_lease_wasm.d.ts

@@ -0,0 +1,24 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export function allocate_device_range_wasm(device_slot: number, device_id: string): any;
+
+export function device_slot_for_address_index_wasm(address_index: number): number;
+
+export function flat_index_wasm(address_index: number, l1: number, l2: number): number;
+
+export function from_flat_index_wasm(flat: number): any;
+
+export function get_capacity_per_tree_wasm(): number;
+
+export function get_local_watermark_wasm(state_js: any, tree_id: string): any;
+
+export function get_next_indices_wasm(state_js: any, tree_id: string): any;
+
+export function init(): void;
+
+export function is_unavailable_wasm(state_js: any, tree_id: string, indices_js: any): boolean;
+
+export function mark_unavailable_wasm(state_js: any, tree_id: string, indices_js: any, reason: string): any;
+
+export function new_watermark_state_wasm(): any;

package/rust/pkg/wots_lease_wasm.js

@@ -0,0 +1,9 @@
+/* @ts-self-types="./wots_lease_wasm.d.ts" */
+import * as wasm from "./wots_lease_wasm_bg.wasm";
+import { __wbg_set_wasm } from "./wots_lease_wasm_bg.js";
+
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();
+export {
+    allocate_device_range_wasm, device_slot_for_address_index_wasm, flat_index_wasm, from_flat_index_wasm, get_capacity_per_tree_wasm, get_local_watermark_wasm, get_next_indices_wasm, init, is_unavailable_wasm, mark_unavailable_wasm, new_watermark_state_wasm
+} from "./wots_lease_wasm_bg.js";