@breeztech/breez-sdk-spark 0.12.2-dev1 → 0.12.2-dev2

package/nodejs/postgres-token-store/migrations.cjs

@@ -0,0 +1,163 @@
+/**
+ * Database Migration Manager for Breez SDK PostgreSQL Token Store
+ *
+ * Uses a token_schema_migrations table + pg_advisory_xact_lock to safely run
+ * migrations from concurrent processes.
+ */
+
+const { TokenStoreError } = require("./errors.cjs");
+
+/**
+ * Advisory lock ID for token store migrations.
+ * Uses a different lock ID from the storage/tree store migrations to avoid contention.
+ * Derived from ASCII bytes of "TOKN" (0x544F4B4E).
+ */
+const MIGRATION_LOCK_ID = "1414022990"; // 0x544F4B4E as decimal string
+
+class TokenStoreMigrationManager {
+  constructor(logger = null) {
+    this.logger = logger;
+  }
+
+  /**
+   * Run all pending migrations inside a single transaction with an advisory lock.
+   * @param {import('pg').Pool} pool
+   */
+  async migrate(pool) {
+    const client = await pool.connect();
+    try {
+      await client.query("BEGIN");
+
+      // Transaction-level advisory lock — automatically released on COMMIT/ROLLBACK
+      await client.query(`SELECT pg_advisory_xact_lock(${MIGRATION_LOCK_ID})`);
+
+      // Create the migrations tracking table if needed
+      await client.query(`
+        CREATE TABLE IF NOT EXISTS token_schema_migrations (
+          version INTEGER PRIMARY KEY,
+          applied_at TIMESTAMPTZ DEFAULT NOW()
+        )
+      `);
+
+      // Get current version
+      const versionResult = await client.query(
+        "SELECT COALESCE(MAX(version), 0) AS version FROM token_schema_migrations"
+      );
+      const currentVersion = versionResult.rows[0].version;
+
+      const migrations = this._getMigrations();
+
+      if (currentVersion >= migrations.length) {
+        this._log("info", `Token store database is up to date (version ${currentVersion})`);
+        await client.query("COMMIT");
+        return;
+      }
+
+      this._log(
+        "info",
+        `Migrating token store database from version ${currentVersion} to ${migrations.length}`
+      );
+
+      for (let i = currentVersion; i < migrations.length; i++) {
+        const migration = migrations[i];
+        const version = i + 1;
+        this._log("debug", `Running token store migration ${version}: ${migration.name}`);
+
+        for (const sql of migration.sql) {
+          await client.query(sql);
+        }
+
+        await client.query(
+          "INSERT INTO token_schema_migrations (version) VALUES ($1)",
+          [version]
+        );
+      }
+
+      await client.query("COMMIT");
+      this._log("info", "Token store database migration completed successfully");
+    } catch (error) {
+      await client.query("ROLLBACK").catch(() => {});
+      throw new TokenStoreError(
+        `Token store migration failed: ${error.message}`,
+        error
+      );
+    } finally {
+      client.release();
+    }
+  }
+
+  _log(level, message) {
+    if (this.logger && typeof this.logger.log === "function") {
+      this.logger.log({ line: message, level });
+    } else if (level === "error") {
+      console.error(`[TokenStoreMigrationManager] ${message}`);
+    }
+  }
+
+  /**
+   * Migrations matching the Rust PostgresTokenStore schema exactly.
+   */
+  _getMigrations() {
+    return [
+      {
+        name: "Create token store tables with race condition protection",
+        sql: [
+          `CREATE TABLE IF NOT EXISTS token_metadata (
+            identifier TEXT PRIMARY KEY,
+            issuer_public_key TEXT NOT NULL,
+            name TEXT NOT NULL,
+            ticker TEXT NOT NULL,
+            decimals INTEGER NOT NULL,
+            max_supply TEXT NOT NULL,
+            is_freezable BOOLEAN NOT NULL,
+            creation_entity_public_key TEXT
+          )`,
+
+          `CREATE INDEX IF NOT EXISTS idx_token_metadata_issuer_pk
+            ON token_metadata (issuer_public_key)`,
+
+          `CREATE TABLE IF NOT EXISTS token_reservations (
+            id TEXT PRIMARY KEY,
+            purpose TEXT NOT NULL,
+            created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+          )`,
+
+          `CREATE TABLE IF NOT EXISTS token_outputs (
+            id TEXT PRIMARY KEY,
+            token_identifier TEXT NOT NULL REFERENCES token_metadata(identifier),
+            owner_public_key TEXT NOT NULL,
+            revocation_commitment TEXT NOT NULL,
+            withdraw_bond_sats BIGINT NOT NULL,
+            withdraw_relative_block_locktime BIGINT NOT NULL,
+            token_public_key TEXT,
+            token_amount TEXT NOT NULL,
+            prev_tx_hash TEXT NOT NULL,
+            prev_tx_vout INTEGER NOT NULL,
+            reservation_id TEXT REFERENCES token_reservations(id) ON DELETE SET NULL,
+            added_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+          )`,
+
+          `CREATE INDEX IF NOT EXISTS idx_token_outputs_identifier
+            ON token_outputs (token_identifier)`,
+
+          `CREATE INDEX IF NOT EXISTS idx_token_outputs_reservation
+            ON token_outputs (reservation_id) WHERE reservation_id IS NOT NULL`,
+
+          `CREATE TABLE IF NOT EXISTS token_spent_outputs (
+            output_id TEXT PRIMARY KEY,
+            spent_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+          )`,
+
+          `CREATE TABLE IF NOT EXISTS token_swap_status (
+            id INTEGER PRIMARY KEY DEFAULT 1 CHECK (id = 1),
+            last_completed_at TIMESTAMPTZ
+          )`,
+
+          `INSERT INTO token_swap_status (id) VALUES (1) ON CONFLICT DO NOTHING`,
+        ],
+      },
+    ];
+  }
+}
+
+module.exports = { TokenStoreMigrationManager };

package/nodejs/postgres-token-store/package.json

@@ -0,0 +1,9 @@
+{
+  "dependencies": {
+    "pg": "^8.18.0"
+  },
+  "description": "Node.js PostgreSQL token store implementation for Breez SDK WASM (CommonJS)",
+  "main": "index.cjs",
+  "name": "@breez-sdk/postgres-token-store",
+  "version": "1.0.0"
+}

package/nodejs/postgres-tree-store/index.cjs

@@ -28,7 +28,7 @@ const { TreeStoreMigrationManager } = require("./migrations.cjs");
  * Advisory lock key for serializing tree store write operations.
  * Matches the Rust constant TREE_STORE_WRITE_LOCK_KEY = 0x7472_6565_5354_4f52
  */
-const TREE_STORE_WRITE_LOCK_KEY = "8391086132283252818"; // 0x7472656553544f52 as decimal string
+const TREE_STORE_WRITE_LOCK_KEY = "8390880541608791890"; // 0x7472656553544f52 as decimal string
 
 /**
  * Timeout for reservations in seconds. Reservations older than this are stale.
@@ -789,10 +789,20 @@ async function createPostgresTreeStore(config, logger = null) {
     connectionTimeoutMillis: config.createTimeoutSecs * 1000,
     idleTimeoutMillis: config.recycleTimeoutSecs * 1000,
   });
+  return createPostgresTreeStoreWithPool(pool, logger);
+}
 
+/**
+ * Create a PostgresTreeStore instance from an existing pg.Pool.
+ *
+ * @param {pg.Pool} pool - An existing connection pool
+ * @param {object} [logger] - Optional logger
+ * @returns {Promise<PostgresTreeStore>}
+ */
+async function createPostgresTreeStoreWithPool(pool, logger = null) {
   const store = new PostgresTreeStore(pool, logger);
   await store.initialize();
   return store;
 }
 
-module.exports = { PostgresTreeStore, createPostgresTreeStore, TreeStoreError };
+module.exports = { PostgresTreeStore, createPostgresTreeStore, createPostgresTreeStoreWithPool, TreeStoreError };

package/nodejs/storage/index.cjs

@@ -53,6 +53,7 @@ const SELECT_PAYMENT_SQL = `
            pm.lnurl_pay_info,
            pm.lnurl_withdraw_info,
            pm.conversion_info,
+           pm.conversion_status,
            t.metadata AS token_metadata,
            t.tx_hash AS token_tx_hash,
            t.tx_type AS token_tx_type,
@@ -260,21 +261,6 @@ class SqliteStorage {
             paymentDetailsClauses.push("t.tx_type = ?");
             params.push(paymentDetailsFilter.txType);
           }
-          // Filter by LNURL preimage status
-          if (
-            paymentDetailsFilter.type === "lightning" &&
-            paymentDetailsFilter.hasLnurlPreimage !== undefined
-          ) {
-            if (paymentDetailsFilter.hasLnurlPreimage) {
-              paymentDetailsClauses.push("lrm.preimage IS NOT NULL");
-            } else {
-              paymentDetailsClauses.push(
-                "lrm.payment_hash IS NOT NULL AND l.preimage IS NOT NULL AND lrm.preimage IS NULL"
-              );
-            }
-          }
-
-
           if (paymentDetailsClauses.length > 0) {
             allPaymentDetailsClauses.push(`(${paymentDetailsClauses.join(" AND ")})`);
           }
@@ -560,14 +546,15 @@ class SqliteStorage {
   insertPaymentMetadata(paymentId, metadata) {
     try {
       const stmt = this.db.prepare(`
-                INSERT INTO payment_metadata (payment_id, parent_payment_id, lnurl_pay_info, lnurl_withdraw_info, lnurl_description, conversion_info)
-                VALUES (?, ?, ?, ?, ?, ?)
+                INSERT INTO payment_metadata (payment_id, parent_payment_id, lnurl_pay_info, lnurl_withdraw_info, lnurl_description, conversion_info, conversion_status)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
                 ON CONFLICT(payment_id) DO UPDATE SET
                     parent_payment_id = COALESCE(excluded.parent_payment_id, parent_payment_id),
                     lnurl_pay_info = COALESCE(excluded.lnurl_pay_info, lnurl_pay_info),
                     lnurl_withdraw_info = COALESCE(excluded.lnurl_withdraw_info, lnurl_withdraw_info),
                     lnurl_description = COALESCE(excluded.lnurl_description, lnurl_description),
-                    conversion_info = COALESCE(excluded.conversion_info, conversion_info)
+                    conversion_info = COALESCE(excluded.conversion_info, conversion_info),
+                    conversion_status = COALESCE(excluded.conversion_status, conversion_status)
             `);
 
       stmt.run(
@@ -580,7 +567,8 @@ class SqliteStorage {
         metadata.lnurlDescription,
         metadata.conversionInfo
           ? JSON.stringify(metadata.conversionInfo)
-          : null
+          : null,
+        metadata.conversionStatus ?? null
       );
       return Promise.resolve();
     } catch (error) {
@@ -595,14 +583,15 @@ class SqliteStorage {
 
   // ===== Deposit Operations =====
 
-  addDeposit(txid, vout, amountSats) {
+  addDeposit(txid, vout, amountSats, isMature) {
     try {
       const stmt = this.db.prepare(`
-                 INSERT OR IGNORE INTO unclaimed_deposits (txid, vout, amount_sats) 
-                 VALUES (?, ?, ?)
+                 INSERT INTO unclaimed_deposits (txid, vout, amount_sats, is_mature)
+                 VALUES (?, ?, ?, ?)
+                 ON CONFLICT(txid, vout) DO UPDATE SET is_mature = excluded.is_mature, amount_sats = excluded.amount_sats
              `);
 
-      stmt.run(txid, vout, amountSats);
+      stmt.run(txid, vout, amountSats, isMature ? 1 : 0);
       return Promise.resolve();
     } catch (error) {
       return Promise.reject(
@@ -635,7 +624,7 @@ class SqliteStorage {
   listDeposits() {
     try {
       const stmt = this.db.prepare(`
-                SELECT txid, vout, amount_sats, claim_error, refund_tx, refund_tx_id 
+                SELECT txid, vout, amount_sats, is_mature, claim_error, refund_tx, refund_tx_id
                 FROM unclaimed_deposits
             `);
 
@@ -645,6 +634,7 @@ class SqliteStorage {
           txid: row.txid,
           vout: row.vout,
           amountSats: row.amount_sats,
+          isMature: Boolean(row.is_mature ?? 1),
           claimError: row.claim_error ? JSON.parse(row.claim_error) : null,
           refundTx: row.refund_tx,
           refundTxId: row.refund_tx_id,
@@ -695,7 +685,7 @@ class SqliteStorage {
   setLnurlMetadata(metadata) {
     try {
       const stmt = this.db.prepare(
-        "INSERT OR REPLACE INTO lnurl_receive_metadata (payment_hash, nostr_zap_request, nostr_zap_receipt, sender_comment, preimage) VALUES (?, ?, ?, ?, ?)"
+        "INSERT OR REPLACE INTO lnurl_receive_metadata (payment_hash, nostr_zap_request, nostr_zap_receipt, sender_comment) VALUES (?, ?, ?, ?)"
       );
 
       const transaction = this.db.transaction(() => {
@@ -704,8 +694,7 @@ class SqliteStorage {
             item.paymentHash,
             item.nostrZapRequest || null,
             item.nostrZapReceipt || null,
-            item.senderComment || null,
-            item.preimage || null
+            item.senderComment || null
           );
         }
       });
@@ -830,7 +819,9 @@ class SqliteStorage {
       timestamp: row.timestamp,
       method,
       details,
-      conversionDetails: null,
+      conversionDetails: row.conversion_status
+        ? { status: row.conversion_status, from: null, to: null }
+        : null,
     };
   }
 

package/nodejs/storage/migrations.cjs

@@ -392,6 +392,24 @@ class MigrationManager {
           updated_at INTEGER NOT NULL
         )`
       },
+      {
+        name: "Drop preimage column from lnurl_receive_metadata",
+        sql: `ALTER TABLE lnurl_receive_metadata DROP COLUMN preimage`
+      },
+      {
+        name: "Clear cached lightning address for CachedLightningAddress format change",
+        sql: `DELETE FROM settings WHERE key = 'lightning_address'`
+      },
+      {
+        name: "Add is_mature to unclaimed_deposits",
+        sql: [
+          `ALTER TABLE unclaimed_deposits ADD COLUMN is_mature INTEGER NOT NULL DEFAULT 1`,
+        ]
+      },
+      {
+        name: "Add conversion_status to payment_metadata",
+        sql: `ALTER TABLE payment_metadata ADD COLUMN conversion_status TEXT`,
+      },
     ];
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@breeztech/breez-sdk-spark",
-    "version": "0.12.2-dev1",
+    "version": "0.12.2-dev2",
     "description": "Breez Spark SDK",
     "repository": "https://github.com/breez/spark-sdk",
     "author": "Breez <contact@breez.technology> (https://github.com/breez)",