@breeztech/breez-sdk-spark 0.8.0-dev1 → 0.8.3-dev1

package/bundler/breez_sdk_spark_wasm_bg.js

@@ -221,27 +221,6 @@ function debugString(val) {
     // TODO we could test for more things here, like `Set`s and `Map`s.
     return className;
 }
-/**
- * @param {Config} config
- * @param {ExternalSigner} signer
- * @param {string} storage_dir
- * @returns {Promise<BreezSdk>}
- */
-export function connectWithSigner(config, signer, storage_dir) {
-    const ptr0 = passStringToWasm0(storage_dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.connectWithSigner(config, signer, ptr0, len0);
-    return ret;
-}
-
-/**
- * @param {ConnectRequest} request
- * @returns {Promise<BreezSdk>}
- */
-export function connect(request) {
-    const ret = wasm.connect(request);
-    return ret;
-}
 
 function takeFromExternrefTable0(idx) {
     const value = wasm.__wbindgen_export_5.get(idx);
@@ -267,6 +246,15 @@ export function defaultExternalSigner(mnemonic, passphrase, network, key_set_con
     return DefaultSigner.__wrap(ret[0]);
 }
 
+/**
+ * @param {ConnectRequest} request
+ * @returns {Promise<BreezSdk>}
+ */
+export function connect(request) {
+    const ret = wasm.connect(request);
+    return ret;
+}
+
 /**
  * @param {Logger} logger
  * @param {string | null} [filter]
@@ -280,13 +268,15 @@ export function initLogging(logger, filter) {
 }
 
 /**
- * Creates a default external signer from a mnemonic phrase.
- *
- * This creates a signer that can be used with `connectWithSigner` or `SdkBuilder.newWithSigner`.
- * @returns {Promise<SparkStatus>}
+ * @param {Config} config
+ * @param {ExternalSigner} signer
+ * @param {string} storage_dir
+ * @returns {Promise<BreezSdk>}
  */
-export function getSparkStatus() {
-    const ret = wasm.getSparkStatus();
+export function connectWithSigner(config, signer, storage_dir) {
+    const ptr0 = passStringToWasm0(storage_dir, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.connectWithSigner(config, signer, ptr0, len0);
     return ret;
 }
 
@@ -299,6 +289,17 @@ export function defaultConfig(network) {
     return ret;
 }
 
+/**
+ * Creates a default external signer from a mnemonic phrase.
+ *
+ * This creates a signer that can be used with `connectWithSigner` or `SdkBuilder.newWithSigner`.
+ * @returns {Promise<SparkStatus>}
+ */
+export function getSparkStatus() {
+    const ret = wasm.getSparkStatus();
+    return ret;
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -317,15 +318,15 @@ export function task_worker_entry_point(ptr) {
 }
 
 function __wbg_adapter_64(arg0, arg1) {
-    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hf2ef52c8a8b47594(arg0, arg1);
+    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h127c718764a2a72f(arg0, arg1);
 }
 
 function __wbg_adapter_67(arg0, arg1, arg2) {
-    wasm.closure1078_externref_shim(arg0, arg1, arg2);
+    wasm.closure1090_externref_shim(arg0, arg1, arg2);
 }
 
-function __wbg_adapter_287(arg0, arg1, arg2, arg3) {
-    wasm.closure671_externref_shim(arg0, arg1, arg2, arg3);
+function __wbg_adapter_285(arg0, arg1, arg2, arg3) {
+    wasm.closure670_externref_shim(arg0, arg1, arg2, arg3);
 }
 
 const __wbindgen_enum_ReadableStreamType = ["bytes"];
@@ -1876,7 +1877,7 @@ export function __wbg_new_23a2665fac83c611(arg0, arg1) {
             const a = state0.a;
             state0.a = 0;
             try {
-                return __wbg_adapter_287(a, state0.b, arg0, arg1);
+                return __wbg_adapter_285(a, state0.b, arg0, arg1);
             } finally {
                 state0.a = a;
             }
@@ -2288,11 +2289,6 @@ export function __wbg_syncInsertIncomingRecords_dde4039dbc9cb38f() { return hand
     return ret;
 }, arguments) };
 
-export function __wbg_syncRebasePendingOutgoingRecords_b3441ced5dee0c8e() { return handleError(function (arg0, arg1) {
-    const ret = arg0.syncRebasePendingOutgoingRecords(BigInt.asUintN(64, arg1));
-    return ret;
-}, arguments) };
-
 export function __wbg_syncUpdateRecordFromIncoming_a76ad82592bfdcb3() { return handleError(function (arg0, arg1) {
     const ret = arg0.syncUpdateRecordFromIncoming(arg1);
     return ret;
@@ -2406,13 +2402,13 @@ export function __wbindgen_cb_drop(arg0) {
     return ret;
 };
 
-export function __wbindgen_closure_wrapper11759(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 848, __wbg_adapter_64);
+export function __wbindgen_closure_wrapper11879(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 851, __wbg_adapter_64);
     return ret;
 };
 
-export function __wbindgen_closure_wrapper13708(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 1079, __wbg_adapter_67);
+export function __wbindgen_closure_wrapper13824(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 1091, __wbg_adapter_67);
     return ret;
 };
 

package/bundler/breez_sdk_spark_wasm_bg.wasm.d.ts

@@ -113,7 +113,7 @@ export const __wbindgen_export_5: WebAssembly.Table;
 export const __externref_drop_slice: (a: number, b: number) => void;
 export const __wbindgen_export_7: WebAssembly.Table;
 export const __externref_table_dealloc: (a: number) => void;
-export const _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__hf2ef52c8a8b47594: (a: number, b: number) => void;
-export const closure1078_externref_shim: (a: number, b: number, c: any) => void;
-export const closure671_externref_shim: (a: number, b: number, c: any, d: any) => void;
+export const _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h127c718764a2a72f: (a: number, b: number) => void;
+export const closure1090_externref_shim: (a: number, b: number, c: any) => void;
+export const closure670_externref_shim: (a: number, b: number, c: any, d: any) => void;
 export const __wbindgen_start: () => void;

package/bundler/storage/index.js

@@ -331,6 +331,72 @@ class MigrationManager {
             transaction.objectStore("settings").delete("sync_initial_complete");
           }
         }
+      },
+      {
+        name: "Backfill htlc_details for existing Lightning payments",
+        upgrade: (db, transaction) => {
+          if (db.objectStoreNames.contains("payments")) {
+            const paymentStore = transaction.objectStore("payments");
+            const getAllRequest = paymentStore.getAll();
+
+            getAllRequest.onsuccess = () => {
+              const payments = getAllRequest.result;
+              payments.forEach((payment) => {
+                let details;
+                if (typeof payment.details === "string") {
+                  try {
+                    details = JSON.parse(payment.details);
+                  } catch (e) {
+                    return;
+                  }
+                } else {
+                  details = payment.details;
+                }
+
+                if (details && details.type === "lightning" && !details.htlcDetails) {
+                  let htlcStatus;
+                  if (payment.status === "completed") {
+                    htlcStatus = "preimageShared";
+                  } else if (payment.status === "pending") {
+                    htlcStatus = "waitingForPreimage";
+                  } else {
+                    htlcStatus = "returned";
+                  }
+                  details.htlcDetails = {
+                    paymentHash: details.paymentHash,
+                    preimage: details.preimage || null,
+                    expiryTime: 0,
+                    status: htlcStatus,
+                  };
+                  payment.details = JSON.stringify(details);
+                  paymentStore.put(payment);
+                }
+              });
+            };
+          }
+
+          // Reset sync offset to trigger resync
+          if (db.objectStoreNames.contains("settings")) {
+            const settingsStore = transaction.objectStore("settings");
+            const getRequest = settingsStore.get("sync_offset");
+
+            getRequest.onsuccess = () => {
+              const syncCache = getRequest.result;
+              if (syncCache && syncCache.value) {
+                try {
+                  const syncInfo = JSON.parse(syncCache.value);
+                  syncInfo.offset = 0;
+                  settingsStore.put({
+                    key: "sync_offset",
+                    value: JSON.stringify(syncInfo),
+                  });
+                } catch (e) {
+                  // If parsing fails, just continue
+                }
+              }
+            };
+          }
+        },
       }
     ];
   }
@@ -355,7 +421,7 @@ class IndexedDBStorage {
     this.db = null;
     this.migrationManager = null;
     this.logger = logger;
-    this.dbVersion = 10; // Current schema version
+    this.dbVersion = 11; // Current schema version
   }
 
   /**
@@ -1280,30 +1346,24 @@ class IndexedDBStorage {
     }
 
     return new Promise((resolve, reject) => {
-      const transaction = this.db.transaction(
-        ["sync_outgoing", "sync_revision"],
-        "readwrite"
-      );
+      const transaction = this.db.transaction(["sync_outgoing"], "readwrite");
 
-      // Compute next revision as max(committed, max outgoing) + 1, without updating sync_revision
-      const revisionStore = transaction.objectStore("sync_revision");
+      // This revision is a local queue id for pending rows, not a server revision.
       const outgoingStore = transaction.objectStore("sync_outgoing");
-
-      const getRevisionRequest = revisionStore.get(1);
       const getAllOutgoingRequest = outgoingStore.getAll();
 
-      let committedRevision = null;
-      let maxOutgoingRevision = null;
-      let resultsReady = 0;
-
-      const onBothReady = () => {
-        resultsReady++;
-        if (resultsReady < 2) return;
-
-        const base = committedRevision > maxOutgoingRevision
-          ? committedRevision
-          : maxOutgoingRevision;
-        const nextRevision = base + BigInt(1);
+      getAllOutgoingRequest.onsuccess = () => {
+        const records = getAllOutgoingRequest.result;
+        let maxOutgoingRevision = BigInt(0);
+        for (const storeRecord of records) {
+          const rev = BigInt(
+            storeRecord.record.localRevision ?? storeRecord.record.revision
+          );
+          if (rev > maxOutgoingRevision) {
+            maxOutgoingRevision = rev;
+          }
+        }
+        const nextRevision = maxOutgoingRevision + BigInt(1);
 
         const storeRecord = {
           type: record.id.type,
@@ -1311,7 +1371,7 @@ class IndexedDBStorage {
           revision: Number(nextRevision),
           record: {
             ...record,
-            revision: nextRevision,
+            localRevision: nextRevision,
           },
         };
 
@@ -1332,35 +1392,6 @@ class IndexedDBStorage {
         };
       };
 
-      getRevisionRequest.onsuccess = () => {
-        const revisionData = getRevisionRequest.result || {
-          id: 1,
-          revision: "0",
-        };
-        committedRevision = BigInt(revisionData.revision);
-        onBothReady();
-      };
-
-      getAllOutgoingRequest.onsuccess = () => {
-        const records = getAllOutgoingRequest.result;
-        maxOutgoingRevision = BigInt(0);
-        for (const storeRecord of records) {
-          const rev = BigInt(storeRecord.record.revision);
-          if (rev > maxOutgoingRevision) {
-            maxOutgoingRevision = rev;
-          }
-        }
-        onBothReady();
-      };
-
-      getRevisionRequest.onerror = (event) => {
-        reject(
-          new StorageError(
-            `Failed to get revision: ${event.target.error.message}`
-          )
-        );
-      };
-
       getAllOutgoingRequest.onerror = (event) => {
         reject(
           new StorageError(
@@ -1459,7 +1490,11 @@ class IndexedDBStorage {
         const cursor = event.target.result;
         if (cursor && count < limit) {
           const storeRecord = cursor.value;
-          const change = storeRecord.record;
+          const change = {
+            ...storeRecord.record,
+            localRevision:
+              storeRecord.record.localRevision ?? storeRecord.record.revision,
+          };
 
           // Look up parent record if it exists
           const stateRequest = stateStore.get([
@@ -1599,120 +1634,6 @@ class IndexedDBStorage {
     });
   }
 
-  async syncRebasePendingOutgoingRecords(revision) {
-    if (!this.db) {
-      throw new StorageError("Database not initialized");
-    }
-
-    return new Promise((resolve, reject) => {
-      const transaction = this.db.transaction(
-        ["sync_outgoing", "sync_revision"],
-        "readwrite"
-      );
-      const outgoingStore = transaction.objectStore("sync_outgoing");
-      const revisionStore = transaction.objectStore("sync_revision");
-
-      // Get the last committed revision from sync_revision
-      const getRevisionRequest = revisionStore.get(1);
-
-      getRevisionRequest.onsuccess = () => {
-        const revisionData = getRevisionRequest.result || {
-          id: 1,
-          revision: "0",
-        };
-        const lastRevision = BigInt(revisionData.revision);
-
-        // Calculate the difference
-        const diff = revision > lastRevision ? revision - lastRevision : BigInt(0);
-
-        // Helper to update sync_revision within the same transaction so retries are idempotent
-        const updateSyncRevision = () => {
-          if (revision > lastRevision) {
-            revisionStore.put({ id: 1, revision: revision.toString() });
-          }
-        };
-
-        if (diff <= BigInt(0)) {
-          updateSyncRevision();
-          resolve();
-          return;
-        }
-
-        // Get all records from sync_outgoing and update their revisions
-        const getAllRequest = outgoingStore.getAll();
-
-        getAllRequest.onsuccess = () => {
-          const records = getAllRequest.result;
-
-          if (records.length === 0) {
-            updateSyncRevision();
-            resolve();
-            return;
-          }
-
-          let updatesCompleted = 0;
-
-          for (const storeRecord of records) {
-            // Delete the old record
-            const oldKey = [
-              storeRecord.type,
-              storeRecord.dataId,
-              storeRecord.revision,
-            ];
-            outgoingStore.delete(oldKey);
-
-            // Update revision in both the key and the nested record
-            const newRevision = storeRecord.record.revision + diff;
-            const updatedRecord = {
-              type: storeRecord.type,
-              dataId: storeRecord.dataId,
-              revision: Number(newRevision),
-              record: {
-                ...storeRecord.record,
-                revision: newRevision,
-              },
-            };
-
-            // Add the updated record
-            const putRequest = outgoingStore.put(updatedRecord);
-
-            putRequest.onsuccess = () => {
-              updatesCompleted++;
-              if (updatesCompleted === records.length) {
-                updateSyncRevision();
-                resolve();
-              }
-            };
-
-            putRequest.onerror = (event) => {
-              reject(
-                new StorageError(
-                  `Failed to rebase outgoing record: ${event.target.error.message}`
-                )
-              );
-            };
-          }
-        };
-
-        getAllRequest.onerror = (event) => {
-          reject(
-            new StorageError(
-              `Failed to get outgoing records for rebase: ${event.target.error.message}`
-            )
-          );
-        };
-      };
-
-      getRevisionRequest.onerror = (event) => {
-        reject(
-          new StorageError(
-            `Failed to get last revision: ${event.target.error.message}`
-          )
-        );
-      };
-    });
-  }
-
   async syncGetIncomingRecords(limit) {
     if (!this.db) {
       throw new StorageError("Database not initialized");
@@ -1802,7 +1723,11 @@ class IndexedDBStorage {
         const cursor = event.target.result;
         if (cursor) {
           const storeRecord = cursor.value;
-          const change = storeRecord.record;
+          const change = {
+            ...storeRecord.record,
+            localRevision:
+              storeRecord.record.localRevision ?? storeRecord.record.revision,
+          };
 
           // Get the parent record
           const stateRequest = stateStore.get([
@@ -1947,14 +1872,15 @@ class IndexedDBStorage {
       // Filter by payment details. If any filter matches, we include the payment
       let paymentDetailsFilterMatches = false;
       for (const paymentDetailsFilter of request.paymentDetailsFilter) {
-        // Filter by Spark HTLC status
+        // Filter by HTLC status (Spark or Lightning)
         if (
-          paymentDetailsFilter.type === "spark" &&
+          (paymentDetailsFilter.type === "spark" ||
+            paymentDetailsFilter.type === "lightning") &&
           paymentDetailsFilter.htlcStatus != null &&
           paymentDetailsFilter.htlcStatus.length > 0
         ) {
           if (
-            details.type !== "spark" ||
+            details.type !== paymentDetailsFilter.type ||
             !details.htlcDetails ||
             !paymentDetailsFilter.htlcStatus.includes(
               details.htlcDetails.status
@@ -2008,6 +1934,7 @@ class IndexedDBStorage {
           }
         }
 
+
         paymentDetailsFilterMatches = true;
         break;
       }
@@ -2087,6 +2014,12 @@ class IndexedDBStorage {
       }
     }
 
+    if (details && details.type === "lightning" && !details.htlcDetails) {
+      throw new StorageError(
+        `htlc_details is required for Lightning payment ${payment.id}`
+      );
+    }
+
     if (metadata && details) {
       if (details.type == "lightning") {
         if (metadata.lnurlDescription && !details.description) {
@@ -2146,7 +2079,7 @@ class IndexedDBStorage {
     if (
       !payment.details ||
       payment.details.type !== "lightning" ||
-      !payment.details.paymentHash
+      !payment.details.htlcDetails?.paymentHash
     ) {
       return Promise.resolve(payment);
     }
@@ -2157,7 +2090,7 @@ class IndexedDBStorage {
 
     return new Promise((resolve, reject) => {
       const lnurlReceiveRequest = lnurlReceiveMetadataStore.get(
-        payment.details.paymentHash
+        payment.details.htlcDetails.paymentHash
       );
 
       lnurlReceiveRequest.onsuccess = () => {
@@ -2193,4 +2126,4 @@ export async function createDefaultStorage(
   return storage;
 }
 
-export { IndexedDBStorage, StorageError };
+export { IndexedDBStorage, MigrationManager, StorageError };