@breeztech/breez-sdk-spark 0.7.21 → 0.8.2

package/bundler/storage/index.js

@@ -148,6 +148,8 @@ class MigrationManager {
       {
         name: "Add sync tables",
         upgrade: (db, transaction) => {
+          // sync_revision: tracks the last committed revision (from server-acknowledged
+          // or server-received records). Does NOT include pending outgoing revisions.
           if (!db.objectStoreNames.contains("sync_revision")) {
             const syncRevisionStore = db.createObjectStore("sync_revision", {
               keyPath: "id",
@@ -178,15 +180,17 @@ class MigrationManager {
           if (!db.objectStoreNames.contains("sync_state")) {
             db.createObjectStore("sync_state", { keyPath: ["type", "dataId"] });
           }
-        }
+        },
       },
       {
         name: "Create lnurl_receive_metadata store",
         upgrade: (db) => {
           if (!db.objectStoreNames.contains("lnurl_receive_metadata")) {
-            db.createObjectStore("lnurl_receive_metadata", { keyPath: "paymentHash" });
+            db.createObjectStore("lnurl_receive_metadata", {
+              keyPath: "paymentHash",
+            });
           }
-        }
+        },
       },
       {
         // Delete all unclaimed deposits to clear old claim_error JSON format.
@@ -197,7 +201,7 @@ class MigrationManager {
             const store = transaction.objectStore("unclaimed_deposits");
             store.clear();
           }
-        }
+        },
       },
       {
         name: "Clear sync tables for BreezSigner backward compatibility",
@@ -236,6 +240,97 @@ class MigrationManager {
             settings.delete("sync_initial_complete");
           }
         }
+      },
+      {
+        name: "Create parentPaymentId index for related payments lookup",
+        upgrade: (db, transaction) => {
+          if (db.objectStoreNames.contains("payment_metadata")) {
+            const metadataStore = transaction.objectStore("payment_metadata");
+            if (!metadataStore.indexNames.contains("parentPaymentId")) {
+              metadataStore.createIndex("parentPaymentId", "parentPaymentId", { unique: false });
+            }
+          }
+        }
+      },
+      {
+        name: "Add tx_type to token payments and trigger token re-sync",
+        upgrade: (db, transaction) => {
+          // Update all existing token payments to have a default txType
+          if (db.objectStoreNames.contains("payments")) {
+            const paymentStore = transaction.objectStore("payments");
+            const getAllRequest = paymentStore.getAll();
+
+            getAllRequest.onsuccess = () => {
+              const payments = getAllRequest.result;
+
+              payments.forEach((payment) => {
+                // Parse details if it's a string
+                let details = null;
+                if (payment.details && typeof payment.details === "string") {
+                  try {
+                    details = JSON.parse(payment.details);
+                  } catch (e) {
+                    return; // Skip this payment if parsing fails
+                  }
+                } else {
+                  details = payment.details;
+                }
+
+                // Add default txType to token payments
+                if (details && details.type === "token" && !details.txType) {
+                  details.txType = "transfer";
+                  payment.details = JSON.stringify(details);
+                  paymentStore.put(payment);
+                }
+              });
+            };
+          }
+
+          // Reset sync cache to trigger token re-sync
+          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);
+                  // Reset only the token sync position, keep the bitcoin offset
+                  syncInfo.last_synced_final_token_payment_id = null;
+                  settingsStore.put({
+                    key: "sync_offset",
+                    value: JSON.stringify(syncInfo),
+                  });
+                } catch (e) {
+                  // If parsing fails, just continue
+                }
+              }
+            };
+          }
+        },
+      },
+      {
+        name: "Clear sync tables to force re-sync",
+        upgrade: (db, transaction) => {
+          if (db.objectStoreNames.contains("sync_outgoing")) {
+            transaction.objectStore("sync_outgoing").clear();
+          }
+          if (db.objectStoreNames.contains("sync_incoming")) {
+            transaction.objectStore("sync_incoming").clear();
+          }
+          if (db.objectStoreNames.contains("sync_state")) {
+            transaction.objectStore("sync_state").clear();
+          }
+          if (db.objectStoreNames.contains("sync_revision")) {
+            const syncRevision = transaction.objectStore("sync_revision");
+            syncRevision.clear();
+            syncRevision.put({ id: 1, revision: "0" });
+          }
+          if (db.objectStoreNames.contains("settings")) {
+            transaction.objectStore("settings").delete("sync_initial_complete");
+          }
+        }
       }
     ];
   }
@@ -260,7 +355,7 @@ class IndexedDBStorage {
     this.db = null;
     this.migrationManager = null;
     this.logger = logger;
-    this.dbVersion = 7; // Current schema version
+    this.dbVersion = 10; // Current schema version
   }
 
   /**
@@ -418,6 +513,59 @@ class IndexedDBStorage {
 
   // ===== Payment Operations =====
 
+  /**
+   * Gets the set of payment IDs that are related payments (have a parentPaymentId).
+   * Uses the parentPaymentId index for efficient lookup.
+   * @param {IDBObjectStore} metadataStore - The payment_metadata object store
+   * @returns {Promise<Set<string>>} Set of payment IDs that are related payments
+   */
+  _getRelatedPaymentIds(metadataStore) {
+    return new Promise((resolve) => {
+      const relatedPaymentIds = new Set();
+
+      // Check if the parentPaymentId index exists (added in migration)
+      if (!metadataStore.indexNames.contains("parentPaymentId")) {
+        // Index doesn't exist yet, fall back to scanning all metadata
+        const cursorRequest = metadataStore.openCursor();
+        cursorRequest.onsuccess = (event) => {
+          const cursor = event.target.result;
+          if (cursor) {
+            if (cursor.value.parentPaymentId) {
+              relatedPaymentIds.add(cursor.value.paymentId);
+            }
+            cursor.continue();
+          } else {
+            resolve(relatedPaymentIds);
+          }
+        };
+        cursorRequest.onerror = () => resolve(new Set());
+        return;
+      }
+
+      // Use the parentPaymentId index to find all metadata entries with a parent
+      const index = metadataStore.index("parentPaymentId");
+      const cursorRequest = index.openCursor();
+
+      cursorRequest.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          // Only add if parentPaymentId is truthy (not null/undefined)
+          if (cursor.value.parentPaymentId) {
+            relatedPaymentIds.add(cursor.value.paymentId);
+          }
+          cursor.continue();
+        } else {
+          resolve(relatedPaymentIds);
+        }
+      };
+
+      cursorRequest.onerror = () => {
+        // If index lookup fails, return empty set and fall back to per-payment lookup
+        resolve(new Set());
+      };
+    });
+  }
+
   async listPayments(request) {
     if (!this.db) {
       throw new StorageError("Database not initialized");
@@ -427,15 +575,18 @@ class IndexedDBStorage {
     const actualOffset = request.offset !== null ? request.offset : 0;
     const actualLimit = request.limit !== null ? request.limit : 4294967295; // u32::MAX
 
-    return new Promise((resolve, reject) => {
-      const transaction = this.db.transaction(
-        ["payments", "payment_metadata", "lnurl_receive_metadata"],
-        "readonly"
-      );
-      const paymentStore = transaction.objectStore("payments");
-      const metadataStore = transaction.objectStore("payment_metadata");
-      const lnurlReceiveMetadataStore = transaction.objectStore("lnurl_receive_metadata");
+    const transaction = this.db.transaction(
+      ["payments", "payment_metadata", "lnurl_receive_metadata"],
+      "readonly"
+    );
+    const paymentStore = transaction.objectStore("payments");
+    const metadataStore = transaction.objectStore("payment_metadata");
+    const lnurlReceiveMetadataStore = transaction.objectStore("lnurl_receive_metadata");
 
+    // Build set of related payment IDs upfront for O(1) filtering
+    const relatedPaymentIds = await this._getRelatedPaymentIds(metadataStore);
+
+    return new Promise((resolve, reject) => {
       const payments = [];
       let count = 0;
       let skipped = 0;
@@ -458,16 +609,23 @@ class IndexedDBStorage {
 
         const payment = cursor.value;
 
+        // Skip related payments (those with a parentPaymentId)
+        if (relatedPaymentIds.has(payment.id)) {
+          cursor.continue();
+          return;
+        }
+
         if (skipped < actualOffset) {
           skipped++;
           cursor.continue();
           return;
         }
 
-        // Get metadata for this payment
+        // Get metadata for this payment (now only for non-related payments)
         const metadataRequest = metadataStore.get(payment.id);
         metadataRequest.onsuccess = () => {
           const metadata = metadataRequest.result;
+
           const paymentWithMetadata = this._mergePaymentMetadata(
             payment,
             metadata
@@ -478,9 +636,12 @@ class IndexedDBStorage {
             cursor.continue();
             return;
           }
-          
+
           // Fetch lnurl receive metadata if it's a lightning payment
-          this._fetchLnurlReceiveMetadata(paymentWithMetadata, lnurlReceiveMetadataStore)
+          this._fetchLnurlReceiveMetadata(
+            paymentWithMetadata,
+            lnurlReceiveMetadataStore
+          )
             .then((mergedPayment) => {
               payments.push(mergedPayment);
               count++;
@@ -560,7 +721,9 @@ class IndexedDBStorage {
       );
       const paymentStore = transaction.objectStore("payments");
       const metadataStore = transaction.objectStore("payment_metadata");
-      const lnurlReceiveMetadataStore = transaction.objectStore("lnurl_receive_metadata");
+      const lnurlReceiveMetadataStore = transaction.objectStore(
+        "lnurl_receive_metadata"
+      );
 
       const paymentRequest = paymentStore.get(id);
 
@@ -579,9 +742,12 @@ class IndexedDBStorage {
             payment,
             metadata
           );
-          
+
           // Fetch lnurl receive metadata if it's a lightning payment
-          this._fetchLnurlReceiveMetadata(paymentWithMetadata, lnurlReceiveMetadataStore)
+          this._fetchLnurlReceiveMetadata(
+            paymentWithMetadata,
+            lnurlReceiveMetadataStore
+          )
             .then(resolve)
             .catch(() => {
               // Continue without lnurl receive metadata if fetch fails
@@ -620,7 +786,9 @@ class IndexedDBStorage {
       const paymentStore = transaction.objectStore("payments");
       const invoiceIndex = paymentStore.index("invoice");
       const metadataStore = transaction.objectStore("payment_metadata");
-      const lnurlReceiveMetadataStore = transaction.objectStore("lnurl_receive_metadata");
+      const lnurlReceiveMetadataStore = transaction.objectStore(
+        "lnurl_receive_metadata"
+      );
 
       const paymentRequest = invoiceIndex.get(invoice);
 
@@ -639,9 +807,12 @@ class IndexedDBStorage {
             payment,
             metadata
           );
-          
+
           // Fetch lnurl receive metadata if it's a lightning payment
-          this._fetchLnurlReceiveMetadata(paymentWithMetadata, lnurlReceiveMetadataStore)
+          this._fetchLnurlReceiveMetadata(
+            paymentWithMetadata,
+            lnurlReceiveMetadataStore
+          )
             .then(resolve)
             .catch(() => {
               // Continue without lnurl receive metadata if fetch fails
@@ -667,7 +838,173 @@ class IndexedDBStorage {
     });
   }
 
-  async setPaymentMetadata(paymentId, metadata) {
+  /**
+   * Checks if any related payments exist (payments with a parentPaymentId).
+   * Uses the parentPaymentId index for efficient lookup.
+   * @param {IDBObjectStore} metadataStore - The payment_metadata object store
+   * @returns {Promise<boolean>} True if any related payments exist
+   */
+  _hasRelatedPayments(metadataStore) {
+    return new Promise((resolve) => {
+      // Check if the parentPaymentId index exists (added in migration)
+      if (!metadataStore.indexNames.contains("parentPaymentId")) {
+        // Index doesn't exist yet, fall back to scanning all metadata
+        const cursorRequest = metadataStore.openCursor();
+        cursorRequest.onsuccess = (event) => {
+          const cursor = event.target.result;
+          if (cursor) {
+            if (cursor.value.parentPaymentId) {
+              resolve(true);
+              return;
+            }
+            cursor.continue();
+          } else {
+            resolve(false);
+          }
+        };
+        cursorRequest.onerror = () => resolve(true); // Assume there might be related payments on error
+        return;
+      }
+
+      const index = metadataStore.index("parentPaymentId");
+      const cursorRequest = index.openCursor();
+
+      cursorRequest.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor && cursor.value.parentPaymentId) {
+          // Found at least one related payment
+          resolve(true);
+        } else if (cursor) {
+          // Entry with null parentPaymentId, continue searching
+          cursor.continue();
+        } else {
+          // No more entries
+          resolve(false);
+        }
+      };
+
+      cursorRequest.onerror = () => {
+        // If index lookup fails, assume there might be related payments
+        resolve(true);
+      };
+    });
+  }
+
+  /**
+   * Gets payments that have any of the specified parent payment IDs.
+   * @param {string[]} parentPaymentIds - Array of parent payment IDs
+   * @returns {Promise<Object>} Map of parentPaymentId -> array of RelatedPayment objects
+   */
+  async getPaymentsByParentIds(parentPaymentIds) {
+    if (!this.db) {
+      throw new StorageError("Database not initialized");
+    }
+
+    if (!parentPaymentIds || parentPaymentIds.length === 0) {
+      return {};
+    }
+
+    const transaction = this.db.transaction(
+      ["payments", "payment_metadata", "lnurl_receive_metadata"],
+      "readonly"
+    );
+    const metadataStore = transaction.objectStore("payment_metadata");
+
+    // Early exit if no related payments exist
+    const hasRelated = await this._hasRelatedPayments(metadataStore);
+    if (!hasRelated) {
+      return {};
+    }
+
+    const parentIdSet = new Set(parentPaymentIds);
+    const paymentStore = transaction.objectStore("payments");
+    const lnurlReceiveMetadataStore = transaction.objectStore("lnurl_receive_metadata");
+
+    return new Promise((resolve, reject) => {
+      const result = {};
+      const fetchedMetadata = [];
+
+      // Query all metadata records and filter by parentPaymentId
+      const cursorRequest = metadataStore.openCursor();
+
+      cursorRequest.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (!cursor) {
+          // All metadata processed, now fetch payment details
+          if (fetchedMetadata.length === 0) {
+            resolve(result);
+            return;
+          }
+
+          let processed = 0;
+          for (const metadata of fetchedMetadata) {
+            const parentId = metadata.parentPaymentId;
+            const paymentRequest = paymentStore.get(metadata.paymentId);
+            paymentRequest.onsuccess = () => {
+              const payment = paymentRequest.result;
+              if (payment) {
+                const paymentWithMetadata = this._mergePaymentMetadata(payment, metadata);
+
+                if (!result[parentId]) {
+                  result[parentId] = [];
+                }
+
+                // Fetch lnurl receive metadata if applicable
+                this._fetchLnurlReceiveMetadata(paymentWithMetadata, lnurlReceiveMetadataStore)
+                  .then((mergedPayment) => {
+                    result[parentId].push(mergedPayment);
+                  })
+                  .catch(() => {
+                    result[parentId].push(paymentWithMetadata);
+                  })
+                  .finally(() => {
+                    processed++;
+                    if (processed === fetchedMetadata.length) {
+                      // Sort each parent's children by timestamp
+                      for (const parentId of Object.keys(result)) {
+                        result[parentId].sort((a, b) => a.timestamp - b.timestamp);
+                      }
+                      resolve(result);
+                    }
+                  });
+              } else {
+                processed++;
+                if (processed === fetchedMetadata.length) {
+                  resolve(result);
+                }
+              }
+            };
+            paymentRequest.onerror = () => {
+              processed++;
+              if (processed === fetchedMetadata.length) {
+                resolve(result);
+              }
+            };
+          }
+          return;
+        }
+
+        const metadata = cursor.value;
+        if (metadata.parentPaymentId && parentIdSet.has(metadata.parentPaymentId)) {
+          fetchedMetadata.push(metadata);
+        }
+        cursor.continue();
+      };
+
+      cursorRequest.onerror = () => {
+        reject(
+          new StorageError(
+            `Failed to get payments by parent ids: ${
+              cursorRequest.error?.message || "Unknown error"
+            }`,
+            cursorRequest.error
+          )
+        );
+      };
+    });
+  }
+
+  async insertPaymentMetadata(paymentId, metadata) {
     if (!this.db) {
       throw new StorageError("Database not initialized");
     }
@@ -676,30 +1013,47 @@ class IndexedDBStorage {
       const transaction = this.db.transaction("payment_metadata", "readwrite");
       const store = transaction.objectStore("payment_metadata");
 
-      const metadataToStore = {
-        paymentId,
-        parentPaymentId: metadata.parentPaymentId,
-        lnurlPayInfo: metadata.lnurlPayInfo
-          ? JSON.stringify(metadata.lnurlPayInfo)
-          : null,
-        lnurlWithdrawInfo: metadata.lnurlWithdrawInfo
-          ? JSON.stringify(metadata.lnurlWithdrawInfo)
-          : null,
-        lnurlDescription: metadata.lnurlDescription,
-        conversionInfo: metadata.conversionInfo
-          ? JSON.stringify(metadata.conversionInfo)
-          : null,
-      };
+      // First get existing record to merge with
+      const getRequest = store.get(paymentId);
+      getRequest.onsuccess = () => {
+        const existing = getRequest.result || {};
+
+        // Use COALESCE-like behavior: new value if non-null, otherwise keep existing
+        const metadataToStore = {
+          paymentId,
+          parentPaymentId: metadata.parentPaymentId ?? existing.parentPaymentId ?? null,
+          lnurlPayInfo: metadata.lnurlPayInfo
+            ? JSON.stringify(metadata.lnurlPayInfo)
+            : existing.lnurlPayInfo ?? null,
+          lnurlWithdrawInfo: metadata.lnurlWithdrawInfo
+            ? JSON.stringify(metadata.lnurlWithdrawInfo)
+            : existing.lnurlWithdrawInfo ?? null,
+          lnurlDescription: metadata.lnurlDescription ?? existing.lnurlDescription ?? null,
+          conversionInfo: metadata.conversionInfo
+            ? JSON.stringify(metadata.conversionInfo)
+            : existing.conversionInfo ?? null,
+        };
 
-      const request = store.put(metadataToStore);
-      request.onsuccess = () => resolve();
-      request.onerror = () => {
+        const putRequest = store.put(metadataToStore);
+        putRequest.onsuccess = () => resolve();
+        putRequest.onerror = () => {
+          reject(
+            new StorageError(
+              `Failed to set payment metadata for '${paymentId}': ${
+                putRequest.error?.message || "Unknown error"
+              }`,
+              putRequest.error
+            )
+          );
+        };
+      };
+      getRequest.onerror = () => {
         reject(
           new StorageError(
-            `Failed to set payment metadata for '${paymentId}': ${
-              request.error?.message || "Unknown error"
+            `Failed to get existing payment metadata for '${paymentId}': ${
+              getRequest.error?.message || "Unknown error"
             }`,
-            request.error
+            getRequest.error
           )
         );
       };
@@ -909,9 +1263,9 @@ class IndexedDBStorage {
         request.onerror = () => {
           reject(
             new StorageError(
-              `Failed to add lnurl metadata for payment hash '${item.paymentHash}': ${
-                request.error?.message || "Unknown error"
-              }`,
+              `Failed to add lnurl metadata for payment hash '${
+                item.paymentHash
+              }': ${request.error?.message || "Unknown error"}`,
               request.error
             )
           );
@@ -926,72 +1280,56 @@ 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");
 
-      // Get the next revision
-      const revisionStore = transaction.objectStore("sync_revision");
-      const getRevisionRequest = revisionStore.get(1);
+      // This revision is a local queue id for pending rows, not a server revision.
+      const outgoingStore = transaction.objectStore("sync_outgoing");
+      const getAllOutgoingRequest = outgoingStore.getAll();
+
+      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);
 
-      getRevisionRequest.onsuccess = () => {
-        const revisionData = getRevisionRequest.result || {
-          id: 1,
-          revision: "0",
+        const storeRecord = {
+          type: record.id.type,
+          dataId: record.id.dataId,
+          revision: Number(nextRevision),
+          record: {
+            ...record,
+            localRevision: nextRevision,
+          },
         };
-        const nextRevision = BigInt(revisionData.revision) + BigInt(1);
-
-        // Update the revision
-        const updateRequest = revisionStore.put({
-          id: 1,
-          revision: nextRevision.toString(),
-        });
 
-        updateRequest.onsuccess = () => {
-          const outgoingStore = transaction.objectStore("sync_outgoing");
-
-          const storeRecord = {
-            type: record.id.type,
-            dataId: record.id.dataId,
-            revision: Number(nextRevision),
-            record: {
-              ...record,
-              revision: nextRevision,
-            },
-          };
-
-          const addRequest = outgoingStore.add(storeRecord);
+        const addRequest = outgoingStore.add(storeRecord);
 
-          addRequest.onsuccess = () => {
-            // Wait for transaction to complete before resolving
-            transaction.oncomplete = () => {
-              resolve(nextRevision);
-            };
-          };
-
-          addRequest.onerror = (event) => {
-            reject(
-              new StorageError(
-                `Failed to add outgoing change: ${event.target.error.message}`
-              )
-            );
+        addRequest.onsuccess = () => {
+          transaction.oncomplete = () => {
+            resolve(nextRevision);
           };
         };
 
-        updateRequest.onerror = (event) => {
+        addRequest.onerror = (event) => {
           reject(
             new StorageError(
-              `Failed to update revision: ${event.target.error.message}`
+              `Failed to add outgoing change: ${event.target.error.message}`
             )
           );
         };
       };
 
-      getRevisionRequest.onerror = (event) => {
+      getAllOutgoingRequest.onerror = (event) => {
         reject(
           new StorageError(
-            `Failed to get revision: ${event.target.error.message}`
+            `Failed to get outgoing records: ${event.target.error.message}`
           )
         );
       };
@@ -1004,23 +1342,24 @@ class IndexedDBStorage {
     });
   }
 
-  async syncCompleteOutgoingSync(record) {
+  async syncCompleteOutgoingSync(record, localRevision) {
     if (!this.db) {
       throw new StorageError("Database not initialized");
     }
 
     return new Promise((resolve, reject) => {
       const transaction = this.db.transaction(
-        ["sync_outgoing", "sync_state"],
+        ["sync_outgoing", "sync_state", "sync_revision"],
         "readwrite"
       );
       const outgoingStore = transaction.objectStore("sync_outgoing");
       const stateStore = transaction.objectStore("sync_state");
+      const revisionStore = transaction.objectStore("sync_revision");
 
       const deleteRequest = outgoingStore.delete([
         record.id.type,
         record.id.dataId,
-        Number(record.revision),
+        Number(localRevision),
       ]);
 
       deleteRequest.onsuccess = () => {
@@ -1030,7 +1369,25 @@ class IndexedDBStorage {
           record: record,
         };
         stateStore.put(stateRecord);
-        resolve();
+
+        // Update sync_revision to track the highest known revision
+        const getRevisionRequest = revisionStore.get(1);
+        getRevisionRequest.onsuccess = () => {
+          const current = getRevisionRequest.result || { id: 1, revision: "0" };
+          const currentRevision = BigInt(current.revision);
+          const recordRevision = BigInt(record.revision);
+          if (recordRevision > currentRevision) {
+            revisionStore.put({ id: 1, revision: recordRevision.toString() });
+          }
+          resolve();
+        };
+        getRevisionRequest.onerror = (event) => {
+          reject(
+            new StorageError(
+              `Failed to update sync revision: ${event.target.error.message}`
+            )
+          );
+        };
       };
 
       deleteRequest.onerror = (event) => {
@@ -1067,7 +1424,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([
@@ -1207,110 +1568,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 revision from sync_revision table
-      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;
-
-        if (diff <= BigInt(0)) {
-          // No rebase needed
-          resolve();
-          return;
-        }
-
-        // Get all records from sync_outgoing and update their revisions
-        const getAllRequest = outgoingStore.getAll();
-
-        getAllRequest.onsuccess = () => {
-          const records = getAllRequest.result;
-          let updatesCompleted = 0;
-
-          if (records.length === 0) {
-            resolve();
-            return;
-          }
-
-          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) {
-                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");
@@ -1400,7 +1657,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([
@@ -1446,8 +1707,9 @@ class IndexedDBStorage {
     }
 
     return new Promise((resolve, reject) => {
-      const transaction = this.db.transaction(["sync_state"], "readwrite");
+      const transaction = this.db.transaction(["sync_state", "sync_revision"], "readwrite");
       const stateStore = transaction.objectStore("sync_state");
+      const revisionStore = transaction.objectStore("sync_revision");
 
       const storeRecord = {
         type: record.id.type,
@@ -1458,7 +1720,24 @@ class IndexedDBStorage {
       const request = stateStore.put(storeRecord);
 
       request.onsuccess = () => {
-        resolve();
+        // Update sync_revision to track the highest known revision
+        const getRevisionRequest = revisionStore.get(1);
+        getRevisionRequest.onsuccess = () => {
+          const current = getRevisionRequest.result || { id: 1, revision: "0" };
+          const currentRevision = BigInt(current.revision);
+          const incomingRevision = BigInt(record.revision);
+          if (incomingRevision > currentRevision) {
+            revisionStore.put({ id: 1, revision: incomingRevision.toString() });
+          }
+          resolve();
+        };
+        getRevisionRequest.onerror = (event) => {
+          reject(
+            new StorageError(
+              `Failed to update sync revision: ${event.target.error.message}`
+            )
+          );
+        };
       };
 
       request.onerror = (event) => {
@@ -1502,7 +1781,10 @@ class IndexedDBStorage {
     }
 
     // Filter by payment details
-    if (request.paymentDetailsFilter && request.paymentDetailsFilter.length > 0) {
+    if (
+      request.paymentDetailsFilter &&
+      request.paymentDetailsFilter.length > 0
+    ) {
       let details = null;
 
       // Parse details if it's a string (stored in IndexedDB)
@@ -1533,7 +1815,9 @@ class IndexedDBStorage {
           if (
             details.type !== "spark" ||
             !details.htlcDetails ||
-            !paymentDetailsFilter.htlcStatus.includes(details.htlcDetails.status)
+            !paymentDetailsFilter.htlcStatus.includes(
+              details.htlcDetails.status
+            )
           ) {
             continue;
           }
@@ -1570,11 +1854,23 @@ class IndexedDBStorage {
             continue;
           }
         }
+        // Filter by token transaction type
+        if (
+          paymentDetailsFilter.type === "token" &&
+          paymentDetailsFilter.txType != null
+        ) {
+          if (
+            details.type !== "token" ||
+            details.txType !== paymentDetailsFilter.txType
+          ) {
+            continue;
+          }
+        }
 
         paymentDetailsFilterMatches = true;
         break;
       }
-      
+
       if (!paymentDetailsFilterMatches) {
         return false;
       }
@@ -1706,7 +2002,11 @@ class IndexedDBStorage {
 
   _fetchLnurlReceiveMetadata(payment, lnurlReceiveMetadataStore) {
     // Only fetch for lightning payments with a payment hash
-    if (!payment.details || payment.details.type !== "lightning" || !payment.details.paymentHash) {
+    if (
+      !payment.details ||
+      payment.details.type !== "lightning" ||
+      !payment.details.paymentHash
+    ) {
       return Promise.resolve(payment);
     }
 
@@ -1715,11 +2015,17 @@ class IndexedDBStorage {
     }
 
     return new Promise((resolve, reject) => {
-      const lnurlReceiveRequest = lnurlReceiveMetadataStore.get(payment.details.paymentHash);
-      
+      const lnurlReceiveRequest = lnurlReceiveMetadataStore.get(
+        payment.details.paymentHash
+      );
+
       lnurlReceiveRequest.onsuccess = () => {
         const lnurlReceiveMetadata = lnurlReceiveRequest.result;
-        if (lnurlReceiveMetadata && (lnurlReceiveMetadata.nostrZapRequest || lnurlReceiveMetadata.senderComment)) {
+        if (
+          lnurlReceiveMetadata &&
+          (lnurlReceiveMetadata.nostrZapRequest ||
+            lnurlReceiveMetadata.senderComment)
+        ) {
           payment.details.lnurlReceiveMetadata = {
             nostrZapRequest: lnurlReceiveMetadata.nostrZapRequest || null,
             nostrZapReceipt: lnurlReceiveMetadata.nostrZapReceipt || null,
@@ -1728,7 +2034,7 @@ class IndexedDBStorage {
         }
         resolve(payment);
       };
-      
+
       lnurlReceiveRequest.onerror = () => {
         // Continue without lnurlReceiveMetadata if fetch fails
         reject(new Error("Failed to fetch lnurl receive metadata"));