@ghostlytools/cli 1.0.0

package/dist/assets/storage-Bya5b2Xt.js

@@ -0,0 +1,1648 @@
+//#region ../../node_modules/@breeztech/breez-sdk-spark/web/storage/index.js
+/**
+* ES6 module for Web IndexedDB Storage Implementation
+* This provides an ES6 interface to IndexedDB storage for web browsers
+*/
+var MigrationManager = class {
+	constructor(db, StorageError, logger = null) {
+		this.db = db;
+		this.StorageError = StorageError;
+		this.logger = logger;
+		this.migrations = this._getMigrations();
+	}
+	/**
+	* Handle IndexedDB upgrade event - called during database opening
+	*/
+	handleUpgrade(event, oldVersion, newVersion) {
+		const db = event.target.result;
+		const transaction = event.target.transaction;
+		this._log("info", `Upgrading IndexedDB from version ${oldVersion} to ${newVersion}`);
+		try {
+			for (let i = oldVersion; i < newVersion; i++) {
+				const migration = this.migrations[i];
+				if (migration) {
+					this._log("debug", `Running migration ${i + 1}: ${migration.name}`);
+					migration.upgrade(db, transaction);
+				}
+			}
+			this._log("info", `Database migration completed successfully`);
+		} catch (error) {
+			this._log("error", `Migration failed at version ${oldVersion}: ${error.message}`);
+			throw new this.StorageError(`Migration failed at version ${oldVersion}: ${error.message}`, error);
+		}
+	}
+	_log(level, message) {
+		if (this.logger && typeof this.logger.log === "function") this.logger.log({
+			line: message,
+			level
+		});
+		else if (level === "error") console.error(`[MigrationManager] ${message}`);
+	}
+	/**
+	* Define all database migrations for IndexedDB
+	*
+	* Each migration is an object with:
+	* - name: Description of the migration
+	* - upgrade: Function that takes (db, transaction) and creates/modifies object stores
+	*/
+	_getMigrations() {
+		return [
+			{
+				name: "Create initial object stores",
+				upgrade: (db) => {
+					if (!db.objectStoreNames.contains("settings")) db.createObjectStore("settings", { keyPath: "key" });
+					if (!db.objectStoreNames.contains("payments")) {
+						const paymentStore = db.createObjectStore("payments", { keyPath: "id" });
+						paymentStore.createIndex("timestamp", "timestamp", { unique: false });
+						paymentStore.createIndex("paymentType", "paymentType", { unique: false });
+						paymentStore.createIndex("status", "status", { unique: false });
+					}
+					if (!db.objectStoreNames.contains("payment_metadata")) db.createObjectStore("payment_metadata", { keyPath: "paymentId" });
+					if (!db.objectStoreNames.contains("unclaimed_deposits")) db.createObjectStore("unclaimed_deposits", { keyPath: ["txid", "vout"] }).createIndex("txid", "txid", { unique: false });
+				}
+			},
+			{
+				name: "Create invoice index",
+				upgrade: (db, transaction) => {
+					const paymentStore = transaction.objectStore("payments");
+					if (!paymentStore.indexNames.contains("invoice")) paymentStore.createIndex("invoice", "details.invoice", { unique: false });
+				}
+			},
+			{
+				name: "Convert amount and fees from Number to BigInt for u128 support",
+				upgrade: (db, transaction) => {
+					const store = transaction.objectStore("payments");
+					const getAllRequest = store.getAll();
+					getAllRequest.onsuccess = () => {
+						const payments = getAllRequest.result;
+						let updated = 0;
+						payments.forEach((payment) => {
+							let needsUpdate = false;
+							if (typeof payment.amount === "number") {
+								payment.amount = BigInt(Math.round(payment.amount));
+								needsUpdate = true;
+							}
+							if (typeof payment.fees === "number") {
+								payment.fees = BigInt(Math.round(payment.fees));
+								needsUpdate = true;
+							}
+							if (needsUpdate) {
+								store.put(payment);
+								updated++;
+							}
+						});
+						console.log(`Migrated ${updated} payment records to BigInt format`);
+					};
+				}
+			},
+			{
+				name: "Add sync tables",
+				upgrade: (db, transaction) => {
+					if (!db.objectStoreNames.contains("sync_revision")) {
+						db.createObjectStore("sync_revision", { keyPath: "id" });
+						transaction.objectStore("sync_revision").add({
+							id: 1,
+							revision: "0"
+						});
+					}
+					if (!db.objectStoreNames.contains("sync_outgoing")) {
+						db.createObjectStore("sync_outgoing", { keyPath: [
+							"type",
+							"dataId",
+							"revision"
+						] });
+						transaction.objectStore("sync_outgoing").createIndex("revision", "revision");
+					}
+					if (!db.objectStoreNames.contains("sync_incoming")) {
+						db.createObjectStore("sync_incoming", { keyPath: [
+							"type",
+							"dataId",
+							"revision"
+						] });
+						transaction.objectStore("sync_incoming").createIndex("revision", "revision");
+					}
+					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" });
+				}
+			},
+			{
+				name: "Clear unclaimed deposits for claim_error format change",
+				upgrade: (db, transaction) => {
+					if (db.objectStoreNames.contains("unclaimed_deposits")) transaction.objectStore("unclaimed_deposits").clear();
+				}
+			},
+			{
+				name: "Clear sync tables for BreezSigner backward compatibility",
+				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");
+				}
+			},
+			{
+				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) => {
+					if (db.objectStoreNames.contains("payments")) {
+						const paymentStore = transaction.objectStore("payments");
+						const getAllRequest = paymentStore.getAll();
+						getAllRequest.onsuccess = () => {
+							getAllRequest.result.forEach((payment) => {
+								let details = null;
+								if (payment.details && typeof payment.details === "string") try {
+									details = JSON.parse(payment.details);
+								} catch (e) {
+									return;
+								}
+								else details = payment.details;
+								if (details && details.type === "token" && !details.txType) {
+									details.txType = "transfer";
+									payment.details = JSON.stringify(details);
+									paymentStore.put(payment);
+								}
+							});
+						};
+					}
+					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.last_synced_final_token_payment_id = null;
+								settingsStore.put({
+									key: "sync_offset",
+									value: JSON.stringify(syncInfo)
+								});
+							} catch (e) {}
+						};
+					}
+				}
+			},
+			{
+				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");
+				}
+			},
+			{
+				name: "Add preimage to lnurl_receive_metadata for LUD-21 and NIP-57",
+				upgrade: (db, transaction) => {
+					if (db.objectStoreNames.contains("settings")) transaction.objectStore("settings").delete("lnurl_metadata_updated_after");
+				}
+			},
+			{
+				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 = () => {
+							getAllRequest.result.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);
+								}
+							});
+						};
+					}
+					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) {}
+						};
+					}
+				}
+			},
+			{
+				name: "Create contacts store",
+				upgrade: (db) => {
+					if (!db.objectStoreNames.contains("contacts")) {
+						const contactsStore = db.createObjectStore("contacts", { keyPath: "id" });
+						contactsStore.createIndex("name_identifier", ["name", "paymentIdentifier"], { unique: false });
+						contactsStore.createIndex("name", "name", { unique: false });
+					}
+				}
+			},
+			{
+				name: "Clear cached lightning address for LnurlInfo schema change",
+				upgrade: (db, transaction) => {
+					if (db.objectStoreNames.contains("settings")) transaction.objectStore("settings").delete("lightning_address");
+				}
+			},
+			{
+				name: "Drop preimage from lnurl_receive_metadata records",
+				upgrade: (db, transaction) => {
+					if (db.objectStoreNames.contains("lnurl_receive_metadata")) {
+						const request = transaction.objectStore("lnurl_receive_metadata").openCursor();
+						request.onsuccess = (event) => {
+							const cursor = event.target.result;
+							if (cursor) {
+								const record = cursor.value;
+								if ("preimage" in record) {
+									delete record.preimage;
+									cursor.update(record);
+								}
+								cursor.continue();
+							}
+						};
+					}
+				}
+			},
+			{
+				name: "Clear cached lightning address for CachedLightningAddress format change",
+				upgrade: (db, transaction) => {
+					if (db.objectStoreNames.contains("settings")) transaction.objectStore("settings").delete("lightning_address");
+				}
+			},
+			{
+				name: "Create contacts store (recovery for skipped migration)",
+				upgrade: (db) => {
+					if (!db.objectStoreNames.contains("contacts")) {
+						const contactsStore = db.createObjectStore("contacts", { keyPath: "id" });
+						contactsStore.createIndex("name_identifier", ["name", "paymentIdentifier"], { unique: false });
+						contactsStore.createIndex("name", "name", { unique: false });
+					}
+				}
+			},
+			{
+				name: "Clear legacy deposit details and reset sync offset for vout",
+				upgrade: (db, transaction) => {
+					if (db.objectStoreNames.contains("payments")) {
+						const cursorRequest = transaction.objectStore("payments").openCursor();
+						cursorRequest.onsuccess = (event) => {
+							const cursor = event.target.result;
+							if (!cursor) return;
+							const payment = cursor.value;
+							let details = null;
+							if (payment.details && typeof payment.details === "string") try {
+								details = JSON.parse(payment.details);
+							} catch (e) {
+								details = null;
+							}
+							else details = payment.details;
+							if (details && details.type === "deposit") {
+								payment.details = null;
+								cursor.update(payment);
+							}
+							cursor.continue();
+						};
+					}
+					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) {}
+						};
+					}
+				}
+			},
+			{
+				name: "Backfill conversion_info type discriminator for serde tagged enum",
+				upgrade: (db, transaction) => {
+					if (db.objectStoreNames.contains("payment_metadata")) {
+						const request = transaction.objectStore("payment_metadata").openCursor();
+						request.onsuccess = (event) => {
+							const cursor = event.target.result;
+							if (cursor) {
+								const record = cursor.value;
+								if (record.conversionInfo) try {
+									const ci = typeof record.conversionInfo === "string" ? JSON.parse(record.conversionInfo) : record.conversionInfo;
+									if (!ci.type) {
+										ci.type = "amm";
+										record.conversionInfo = JSON.stringify(ci);
+										cursor.update(record);
+									}
+								} catch (e) {}
+								cursor.continue();
+							}
+						};
+					}
+				}
+			},
+			{
+				name: "Create cross_chain_swaps store",
+				upgrade: (db) => {
+					if (!db.objectStoreNames.contains("cross_chain_swaps")) db.createObjectStore("cross_chain_swaps", { keyPath: ["provider", "id"] });
+				}
+			},
+			{
+				name: "Clear declined instant claim status after its shape changed",
+				upgrade: (db, transaction) => {
+					if (!db.objectStoreNames.contains("unclaimed_deposits")) return;
+					const cursorRequest = transaction.objectStore("unclaimed_deposits").openCursor();
+					cursorRequest.onsuccess = (event) => {
+						const cursor = event.target.result;
+						if (!cursor) return;
+						const deposit = cursor.value;
+						if (deposit.instantClaimStatus && String(deposit.instantClaimStatus).toLowerCase().includes("declined")) {
+							deposit.instantClaimStatus = null;
+							cursor.update(deposit);
+						}
+						cursor.continue();
+					};
+				}
+			},
+			{
+				name: "Create watched_deposit_addresses store",
+				upgrade: (db) => {
+					if (!db.objectStoreNames.contains("watched_deposit_addresses")) db.createObjectStore("watched_deposit_addresses", { keyPath: "address" });
+				}
+			}
+		];
+	}
+};
+var StorageError = class StorageError extends Error {
+	constructor(message, cause = null) {
+		super(message);
+		this.name = "StorageError";
+		this.cause = cause;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, StorageError);
+	}
+};
+var IndexedDBStorage = class {
+	constructor(dbName = "BreezSDK", logger = null) {
+		this.dbName = dbName;
+		this.db = null;
+		this.migrationManager = null;
+		this.logger = logger;
+		this.dbVersion = 22;
+	}
+	/**
+	* Initialize the storage - must be called before using other methods
+	*/
+	async initialize() {
+		if (this.db) return this;
+		if (typeof indexedDB === "undefined") throw new StorageError("IndexedDB is not available in this environment");
+		const migrationCount = new MigrationManager(null, StorageError).migrations.length;
+		if (this.dbVersion !== migrationCount) throw new StorageError(`dbVersion (${this.dbVersion}) must equal the migration count (${migrationCount}). Migrations are append-only: append a new migration and bump dbVersion to match.`);
+		return new Promise((resolve, reject) => {
+			const request = indexedDB.open(this.dbName, this.dbVersion);
+			request.onerror = () => {
+				reject(new StorageError(`Failed to open IndexedDB: ${request.error?.message || "Unknown error"}`, request.error));
+			};
+			request.onsuccess = () => {
+				this.db = request.result;
+				this.migrationManager = new MigrationManager(this.db, StorageError, this.logger);
+				this.db.onversionchange = () => {
+					this.db.close();
+					this.db = null;
+				};
+				resolve(this);
+			};
+			request.onupgradeneeded = (event) => {
+				this.db = event.target.result;
+				this.migrationManager = new MigrationManager(this.db, StorageError, this.logger);
+				try {
+					this.migrationManager.handleUpgrade(event, event.oldVersion, event.newVersion);
+				} catch (error) {
+					reject(error);
+				}
+			};
+		});
+	}
+	/**
+	* Close the database connection
+	*/
+	close() {
+		if (this.db) {
+			this.db.close();
+			this.db = null;
+		}
+	}
+	async getCachedItem(key) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const request = this.db.transaction("settings", "readonly").objectStore("settings").get(key);
+			request.onsuccess = () => {
+				const result = request.result;
+				resolve(result ? result.value : null);
+			};
+			request.onerror = () => {
+				reject(new StorageError(`Failed to get cached item '${key}': ${request.error?.message || "Unknown error"}`, request.error));
+			};
+		});
+	}
+	async setCachedItem(key, value) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const request = this.db.transaction("settings", "readwrite").objectStore("settings").put({
+				key,
+				value
+			});
+			request.onsuccess = () => resolve();
+			request.onerror = () => {
+				reject(new StorageError(`Failed to set cached item '${key}': ${request.error?.message || "Unknown error"}`, request.error));
+			};
+		});
+	}
+	async deleteCachedItem(key) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const request = this.db.transaction("settings", "readwrite").objectStore("settings").delete(key);
+			request.onsuccess = () => resolve();
+			request.onerror = () => {
+				reject(new StorageError(`Failed to delete cached item '${key}': ${request.error?.message || "Unknown error"}`, request.error));
+			};
+		});
+	}
+	/**
+	* 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 = /* @__PURE__ */ new Set();
+			if (!metadataStore.indexNames.contains("parentPaymentId")) {
+				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(/* @__PURE__ */ new Set());
+				return;
+			}
+			const cursorRequest = metadataStore.index("parentPaymentId").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(/* @__PURE__ */ new Set());
+			};
+		});
+	}
+	async listPayments(request) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		const actualOffset = request.offset !== null ? request.offset : 0;
+		const actualLimit = request.limit !== null ? request.limit : 4294967295;
+		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 relatedPaymentIds = await this._getRelatedPaymentIds(metadataStore);
+		return new Promise((resolve, reject) => {
+			const payments = [];
+			let count = 0;
+			let skipped = 0;
+			const cursorDirection = request.sortAscending ? "next" : "prev";
+			const cursorRequest = paymentStore.index("timestamp").openCursor(null, cursorDirection);
+			cursorRequest.onsuccess = (event) => {
+				const cursor = event.target.result;
+				if (!cursor || count >= actualLimit) {
+					resolve(payments);
+					return;
+				}
+				const payment = cursor.value;
+				if (relatedPaymentIds.has(payment.id)) {
+					cursor.continue();
+					return;
+				}
+				if (skipped < actualOffset) {
+					skipped++;
+					cursor.continue();
+					return;
+				}
+				const metadataRequest = metadataStore.get(payment.id);
+				metadataRequest.onsuccess = () => {
+					const metadata = metadataRequest.result;
+					const paymentWithMetadata = this._mergePaymentMetadata(payment, metadata);
+					this._fetchLnurlReceiveMetadata(paymentWithMetadata, lnurlReceiveMetadataStore).then((mergedPayment) => {
+						if (!this._matchesFilters(mergedPayment, request)) {
+							cursor.continue();
+							return;
+						}
+						payments.push(mergedPayment);
+						count++;
+						cursor.continue();
+					}).catch(() => {
+						if (!this._matchesFilters(paymentWithMetadata, request)) {
+							cursor.continue();
+							return;
+						}
+						payments.push(paymentWithMetadata);
+						count++;
+						cursor.continue();
+					});
+				};
+				metadataRequest.onerror = () => {
+					if (this._matchesFilters(payment, request)) {
+						payments.push(payment);
+						count++;
+					}
+					cursor.continue();
+				};
+			};
+			cursorRequest.onerror = () => {
+				reject(new StorageError(`Failed to list payments (request: ${JSON.stringify(request)}: ${cursorRequest.error?.message || "Unknown error"}`, cursorRequest.error));
+			};
+		});
+	}
+	async applyPaymentUpdate(payment) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			let shouldEmit = false;
+			let settled = false;
+			const transaction = this.db.transaction("payments", "readwrite");
+			const store = transaction.objectStore("payments");
+			const rejectOnce = (message, error) => {
+				if (settled) return;
+				settled = true;
+				reject(new StorageError(message, error));
+			};
+			transaction.oncomplete = () => {
+				if (settled) return;
+				settled = true;
+				resolve(shouldEmit);
+			};
+			transaction.onerror = () => {
+				rejectOnce(`Failed to apply payment update '${payment.id}': ${transaction.error?.message || "Unknown error"}`, transaction.error);
+			};
+			transaction.onabort = () => {
+				rejectOnce(`Payment update transaction aborted for '${payment.id}': ${transaction.error?.message || "Unknown error"}`, transaction.error);
+			};
+			const getRequest = store.get(payment.id);
+			getRequest.onsuccess = () => {
+				const storedPayment = getRequest.result;
+				const stored = storedPayment ? this._normalizePaymentStatus(storedPayment.status) : null;
+				const next = this._normalizePaymentStatus(payment.status);
+				let shouldPersist;
+				if (stored == null) {
+					shouldPersist = true;
+					shouldEmit = true;
+				} else if (stored === next) {
+					console.debug(`Skipping redundant payment event: id=${payment.id} status=${next}`);
+					shouldPersist = true;
+					shouldEmit = false;
+				} else if (this._isFinalPaymentStatus(stored)) {
+					console.warn(`Skipping payment update (would replace terminal status): id=${payment.id} stored=${stored} new=${next}`);
+					shouldPersist = false;
+					shouldEmit = false;
+				} else {
+					shouldPersist = true;
+					shouldEmit = true;
+				}
+				if (!shouldPersist) return;
+				const putRequest = store.put(this._paymentToStore(payment));
+				putRequest.onerror = () => {
+					rejectOnce(`Failed to persist payment update '${payment.id}': ${putRequest.error?.message || "Unknown error"}`, putRequest.error);
+				};
+			};
+			getRequest.onerror = () => {
+				rejectOnce(`Failed to read payment '${payment.id}' before update: ${getRequest.error?.message || "Unknown error"}`, getRequest.error);
+			};
+		});
+	}
+	async getPaymentById(id) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		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 paymentRequest = paymentStore.get(id);
+			paymentRequest.onsuccess = () => {
+				const payment = paymentRequest.result;
+				if (!payment) {
+					reject(new StorageError(`Payment with id '${id}' not found`));
+					return;
+				}
+				const metadataRequest = metadataStore.get(id);
+				metadataRequest.onsuccess = () => {
+					const metadata = metadataRequest.result;
+					const paymentWithMetadata = this._mergePaymentMetadata(payment, metadata);
+					this._fetchLnurlReceiveMetadata(paymentWithMetadata, lnurlReceiveMetadataStore).then(resolve).catch(() => {
+						resolve(paymentWithMetadata);
+					});
+				};
+				metadataRequest.onerror = () => {
+					resolve(payment);
+				};
+			};
+			paymentRequest.onerror = () => {
+				reject(new StorageError(`Failed to get payment by id '${id}': ${paymentRequest.error?.message || "Unknown error"}`, paymentRequest.error));
+			};
+		});
+	}
+	async getPaymentByInvoice(invoice) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const transaction = this.db.transaction([
+				"payments",
+				"payment_metadata",
+				"lnurl_receive_metadata"
+			], "readonly");
+			const invoiceIndex = transaction.objectStore("payments").index("invoice");
+			const metadataStore = transaction.objectStore("payment_metadata");
+			const lnurlReceiveMetadataStore = transaction.objectStore("lnurl_receive_metadata");
+			const paymentRequest = invoiceIndex.get(invoice);
+			paymentRequest.onsuccess = () => {
+				const payment = paymentRequest.result;
+				if (!payment) {
+					resolve(null);
+					return;
+				}
+				const metadataRequest = metadataStore.get(payment.id);
+				metadataRequest.onsuccess = () => {
+					const metadata = metadataRequest.result;
+					const paymentWithMetadata = this._mergePaymentMetadata(payment, metadata);
+					this._fetchLnurlReceiveMetadata(paymentWithMetadata, lnurlReceiveMetadataStore).then(resolve).catch(() => {
+						resolve(paymentWithMetadata);
+					});
+				};
+				metadataRequest.onerror = () => {
+					resolve(payment);
+				};
+			};
+			paymentRequest.onerror = () => {
+				reject(new StorageError(`Failed to get payment by invoice '${invoice}': ${paymentRequest.error?.message || "Unknown error"}`, paymentRequest.error));
+			};
+		});
+	}
+	/**
+	* 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) => {
+			if (!metadataStore.indexNames.contains("parentPaymentId")) {
+				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);
+				return;
+			}
+			const cursorRequest = metadataStore.index("parentPaymentId").openCursor();
+			cursorRequest.onsuccess = (event) => {
+				const cursor = event.target.result;
+				if (cursor && cursor.value.parentPaymentId) resolve(true);
+				else if (cursor) cursor.continue();
+				else resolve(false);
+			};
+			cursorRequest.onerror = () => {
+				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");
+		if (!await this._hasRelatedPayments(metadataStore)) 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 = [];
+			const cursorRequest = metadataStore.openCursor();
+			cursorRequest.onsuccess = (event) => {
+				const cursor = event.target.result;
+				if (!cursor) {
+					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] = [];
+								this._fetchLnurlReceiveMetadata(paymentWithMetadata, lnurlReceiveMetadataStore).then((mergedPayment) => {
+									result[parentId].push(mergedPayment);
+								}).catch(() => {
+									result[parentId].push(paymentWithMetadata);
+								}).finally(() => {
+									processed++;
+									if (processed === fetchedMetadata.length) {
+										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");
+		return new Promise((resolve, reject) => {
+			const store = this.db.transaction("payment_metadata", "readwrite").objectStore("payment_metadata");
+			const getRequest = store.get(paymentId);
+			getRequest.onsuccess = () => {
+				const existing = getRequest.result || {};
+				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,
+					conversionStatus: metadata.conversionStatus ?? existing.conversionStatus ?? null
+				};
+				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 get existing payment metadata for '${paymentId}': ${getRequest.error?.message || "Unknown error"}`, getRequest.error));
+			};
+		});
+	}
+	async addDeposit(txid, vout, amountSats, isMature) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const store = this.db.transaction("unclaimed_deposits", "readwrite").objectStore("unclaimed_deposits");
+			const getRequest = store.get([txid, vout]);
+			getRequest.onsuccess = () => {
+				const existing = getRequest.result;
+				const depositToStore = {
+					txid,
+					vout,
+					amountSats,
+					isMature: isMature ?? true,
+					claimError: existing?.claimError ?? null,
+					refundTx: existing?.refundTx ?? null,
+					refundTxId: existing?.refundTxId ?? null,
+					instantClaimStatus: existing?.instantClaimStatus ?? null,
+					refundState: existing?.refundState ?? null,
+					maxClaimFee: existing?.maxClaimFee ?? null
+				};
+				const putRequest = store.put(depositToStore);
+				putRequest.onsuccess = () => resolve();
+				putRequest.onerror = () => {
+					reject(new StorageError(`Failed to add deposit '${txid}:${vout}': ${putRequest.error?.message || "Unknown error"}`, putRequest.error));
+				};
+			};
+			getRequest.onerror = () => {
+				reject(new StorageError(`Failed to add deposit '${txid}:${vout}': ${getRequest.error?.message || "Unknown error"}`, getRequest.error));
+			};
+		});
+	}
+	async deleteDeposit(txid, vout) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const request = this.db.transaction("unclaimed_deposits", "readwrite").objectStore("unclaimed_deposits").delete([txid, vout]);
+			request.onsuccess = () => resolve();
+			request.onerror = () => {
+				reject(new StorageError(`Failed to delete deposit '${txid}:${vout}': ${request.error?.message || "Unknown error"}`, request.error));
+			};
+		});
+	}
+	async listDeposits() {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const request = this.db.transaction("unclaimed_deposits", "readonly").objectStore("unclaimed_deposits").getAll();
+			request.onsuccess = () => {
+				resolve(request.result.map((row) => ({
+					txid: row.txid,
+					vout: row.vout,
+					amountSats: row.amountSats,
+					isMature: row.isMature ?? true,
+					claimError: row.claimError ? JSON.parse(row.claimError) : null,
+					refundTx: row.refundTx,
+					refundTxId: row.refundTxId,
+					instantClaimStatus: row.instantClaimStatus ? JSON.parse(row.instantClaimStatus) : null,
+					refundState: row.refundState ? JSON.parse(row.refundState) : null,
+					maxClaimFee: row.maxClaimFee ? JSON.parse(row.maxClaimFee) : null
+				})));
+			};
+			request.onerror = () => {
+				reject(new StorageError(`Failed to list deposits: ${request.error?.message || "Unknown error"}`, request.error));
+			};
+		});
+	}
+	async updateDeposit(txid, vout, payload) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const store = this.db.transaction("unclaimed_deposits", "readwrite").objectStore("unclaimed_deposits");
+			const getRequest = store.get([txid, vout]);
+			getRequest.onsuccess = () => {
+				const existingDeposit = getRequest.result;
+				if (!existingDeposit) {
+					resolve();
+					return;
+				}
+				let updatedDeposit = { ...existingDeposit };
+				if (payload.type === "claimError") updatedDeposit.claimError = JSON.stringify(payload.error);
+				else if (payload.type === "refund") {
+					updatedDeposit.refundTx = payload.refundTx;
+					updatedDeposit.refundTxId = payload.refundTxid;
+					updatedDeposit.refundState = JSON.stringify(payload.state);
+					updatedDeposit.claimError = null;
+				} else if (payload.type === "instantClaim") updatedDeposit.instantClaimStatus = JSON.stringify(payload.status);
+				else if (payload.type === "refundBroadcastState") {
+					if (existingDeposit.refundTxId === payload.refundTxid) updatedDeposit.refundState = JSON.stringify(payload.state);
+				} else if (payload.type === "maxClaimFee") updatedDeposit.maxClaimFee = payload.maxFee ? JSON.stringify(payload.maxFee) : null;
+				else {
+					reject(new StorageError(`Unknown payload type: ${payload.type}`));
+					return;
+				}
+				const putRequest = store.put(updatedDeposit);
+				putRequest.onsuccess = () => resolve();
+				putRequest.onerror = () => {
+					reject(new StorageError(`Failed to update deposit '${txid}:${vout}': ${putRequest.error?.message || "Unknown error"}`, putRequest.error));
+				};
+			};
+			getRequest.onerror = () => {
+				reject(new StorageError(`Failed to get deposit '${txid}:${vout}' for update: ${getRequest.error?.message || "Unknown error"}`, getRequest.error));
+			};
+		});
+	}
+	async listWatchedDepositAddresses() {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const request = this.db.transaction("watched_deposit_addresses", "readonly").objectStore("watched_deposit_addresses").getAll();
+			request.onsuccess = () => {
+				const watched = (request.result || []).map((entry) => ({
+					address: entry.address,
+					issuedAt: entry.issuedAt,
+					seen: Boolean(entry.seen)
+				}));
+				watched.sort((a, b) => Number(b.issuedAt) - Number(a.issuedAt));
+				resolve(watched);
+			};
+			request.onerror = () => reject(new StorageError(`Failed to list watched deposit addresses: ${request.error}`));
+		});
+	}
+	async updateWatchedDepositAddress(address, payload) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const store = this.db.transaction("watched_deposit_addresses", "readwrite").objectStore("watched_deposit_addresses");
+			if (payload.type === "watch") {
+				const request = store.put({
+					address,
+					issuedAt: payload.issuedAt,
+					seen: false
+				});
+				request.onsuccess = () => resolve();
+				request.onerror = () => reject(new StorageError(`Failed to watch deposit address '${address}': ${request.error}`));
+				return;
+			}
+			if (payload.type === "unwatch") {
+				const getRequest = store.get(address);
+				getRequest.onsuccess = () => {
+					const existing = getRequest.result;
+					if (!existing || String(existing.issuedAt) !== String(payload.issuedAt)) {
+						resolve();
+						return;
+					}
+					const request = store.delete(address);
+					request.onsuccess = () => resolve();
+					request.onerror = () => reject(new StorageError(`Failed to unwatch deposit address '${address}': ${request.error}`));
+				};
+				getRequest.onerror = () => reject(new StorageError(`Failed to read watched deposit address '${address}': ${getRequest.error}`));
+				return;
+			}
+			if (payload.type === "seen") {
+				const getRequest = store.get(address);
+				getRequest.onsuccess = () => {
+					const existing = getRequest.result;
+					if (!existing) {
+						resolve();
+						return;
+					}
+					const request = store.put({
+						...existing,
+						seen: true
+					});
+					request.onsuccess = () => resolve();
+					request.onerror = () => reject(new StorageError(`Failed to mark deposit address '${address}' seen: ${request.error}`));
+				};
+				getRequest.onerror = () => reject(new StorageError(`Failed to read watched deposit address '${address}': ${getRequest.error}`));
+				return;
+			}
+			reject(new StorageError(`Unknown payload type: ${payload.type}`));
+		});
+	}
+	async setLnurlMetadata(metadata) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const store = this.db.transaction("lnurl_receive_metadata", "readwrite").objectStore("lnurl_receive_metadata");
+			let completed = 0;
+			const total = metadata.length;
+			if (total === 0) {
+				resolve();
+				return;
+			}
+			for (const item of metadata) {
+				const request = store.put({
+					paymentHash: item.paymentHash,
+					nostrZapRequest: item.nostrZapRequest || null,
+					nostrZapReceipt: item.nostrZapReceipt || null,
+					senderComment: item.senderComment || null
+				});
+				request.onsuccess = () => {
+					completed++;
+					if (completed === total) resolve();
+				};
+				request.onerror = () => {
+					reject(new StorageError(`Failed to add lnurl metadata for payment hash '${item.paymentHash}': ${request.error?.message || "Unknown error"}`, request.error));
+				};
+			}
+		});
+	}
+	async syncAddOutgoingChange(record) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const transaction = this.db.transaction(["sync_outgoing"], "readwrite");
+			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);
+				const storeRecord = {
+					type: record.id.type,
+					dataId: record.id.dataId,
+					revision: Number(nextRevision),
+					record: {
+						...record,
+						localRevision: nextRevision
+					}
+				};
+				const addRequest = outgoingStore.add(storeRecord);
+				addRequest.onsuccess = () => {
+					transaction.oncomplete = () => {
+						resolve(nextRevision);
+					};
+				};
+				addRequest.onerror = (event) => {
+					reject(new StorageError(`Failed to add outgoing change: ${event.target.error.message}`));
+				};
+			};
+			getAllOutgoingRequest.onerror = (event) => {
+				reject(new StorageError(`Failed to get outgoing records: ${event.target.error.message}`));
+			};
+			transaction.onerror = (event) => {
+				reject(new StorageError(`Transaction failed: ${event.target.error.message}`));
+			};
+		});
+	}
+	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_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(localRevision)
+			]);
+			deleteRequest.onsuccess = () => {
+				const stateRecord = {
+					type: record.id.type,
+					dataId: record.id.dataId,
+					record
+				};
+				stateStore.put(stateRecord);
+				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) => {
+				reject(new StorageError(`Failed to complete outgoing sync: ${event.target.error.message}`));
+			};
+		});
+	}
+	async syncGetPendingOutgoingChanges(limit) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const transaction = this.db.transaction(["sync_outgoing", "sync_state"], "readonly");
+			const outgoingStore = transaction.objectStore("sync_outgoing");
+			const stateStore = transaction.objectStore("sync_state");
+			const request = outgoingStore.index("revision").openCursor(null, "next");
+			const changes = [];
+			let count = 0;
+			request.onsuccess = (event) => {
+				const cursor = event.target.result;
+				if (cursor && count < limit) {
+					const storeRecord = cursor.value;
+					const change = {
+						...storeRecord.record,
+						localRevision: storeRecord.record.localRevision ?? storeRecord.record.revision
+					};
+					const stateRequest = stateStore.get([storeRecord.type, storeRecord.dataId]);
+					stateRequest.onsuccess = () => {
+						const stateRecord = stateRequest.result;
+						const parent = stateRecord ? stateRecord.record : null;
+						changes.push({
+							change,
+							parent
+						});
+						count++;
+						cursor.continue();
+					};
+					stateRequest.onerror = () => {
+						changes.push({
+							change,
+							parent: null
+						});
+						count++;
+						cursor.continue();
+					};
+				} else resolve(changes);
+			};
+			request.onerror = (event) => {
+				reject(new StorageError(`Failed to get pending outgoing changes: ${event.target.error.message}`));
+			};
+		});
+	}
+	async syncGetLastRevision() {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const request = this.db.transaction("sync_revision", "readonly").objectStore("sync_revision").get(1);
+			request.onsuccess = () => {
+				const result = request.result || {
+					id: 1,
+					revision: "0"
+				};
+				resolve(BigInt(result.revision));
+			};
+			request.onerror = (event) => {
+				reject(new StorageError(`Failed to get last revision: ${event.target.error.message}`));
+			};
+		});
+	}
+	async syncInsertIncomingRecords(records) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const store = this.db.transaction(["sync_incoming"], "readwrite").objectStore("sync_incoming");
+			let recordsProcessed = 0;
+			for (const record of records) {
+				const storeRecord = {
+					type: record.id.type,
+					dataId: record.id.dataId,
+					revision: Number(record.revision),
+					record
+				};
+				const request = store.put(storeRecord);
+				request.onsuccess = () => {
+					recordsProcessed++;
+					if (recordsProcessed === records.length) resolve();
+				};
+				request.onerror = (event) => {
+					reject(new StorageError(`Failed to insert incoming record: ${event.target.error.message}`));
+				};
+			}
+			if (records.length === 0) resolve();
+		});
+	}
+	async syncDeleteIncomingRecord(record) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const store = this.db.transaction(["sync_incoming"], "readwrite").objectStore("sync_incoming");
+			const key = [
+				record.id.type,
+				record.id.dataId,
+				Number(record.revision)
+			];
+			const request = store.delete(key);
+			request.onsuccess = () => {
+				resolve();
+			};
+			request.onerror = (event) => {
+				reject(new StorageError(`Failed to delete incoming record: ${event.target.error.message}`));
+			};
+		});
+	}
+	async syncGetIncomingRecords(limit) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const transaction = this.db.transaction(["sync_incoming", "sync_state"], "readonly");
+			const incomingStore = transaction.objectStore("sync_incoming");
+			const stateStore = transaction.objectStore("sync_state");
+			const request = incomingStore.index("revision").openCursor(null, "next");
+			const records = [];
+			let count = 0;
+			request.onsuccess = (event) => {
+				const cursor = event.target.result;
+				if (cursor && count < limit) {
+					const storeRecord = cursor.value;
+					const newState = storeRecord.record;
+					const stateRequest = stateStore.get([storeRecord.type, storeRecord.dataId]);
+					stateRequest.onsuccess = () => {
+						const stateRecord = stateRequest.result;
+						const oldState = stateRecord ? stateRecord.record : null;
+						records.push({
+							newState,
+							oldState
+						});
+						count++;
+						cursor.continue();
+					};
+					stateRequest.onerror = () => {
+						records.push({
+							newState,
+							oldState: null
+						});
+						count++;
+						cursor.continue();
+					};
+				} else resolve(records);
+			};
+			request.onerror = (event) => {
+				reject(new StorageError(`Failed to get incoming records: ${event.target.error.message}`));
+			};
+		});
+	}
+	async syncGetLatestOutgoingChange() {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const transaction = this.db.transaction(["sync_outgoing", "sync_state"], "readonly");
+			const outgoingStore = transaction.objectStore("sync_outgoing");
+			const stateStore = transaction.objectStore("sync_state");
+			const request = outgoingStore.index("revision").openCursor(null, "prev");
+			request.onsuccess = (event) => {
+				const cursor = event.target.result;
+				if (cursor) {
+					const storeRecord = cursor.value;
+					const change = {
+						...storeRecord.record,
+						localRevision: storeRecord.record.localRevision ?? storeRecord.record.revision
+					};
+					const stateRequest = stateStore.get([storeRecord.type, storeRecord.dataId]);
+					stateRequest.onsuccess = () => {
+						const stateRecord = stateRequest.result;
+						const parent = stateRecord ? stateRecord.record : null;
+						resolve({
+							change,
+							parent
+						});
+					};
+					stateRequest.onerror = () => {
+						resolve({
+							change,
+							parent: null
+						});
+					};
+				} else resolve(null);
+			};
+			request.onerror = (event) => {
+				reject(new StorageError(`Failed to get latest outgoing change: ${event.target.error.message}`));
+			};
+		});
+	}
+	async syncUpdateRecordFromIncoming(record) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			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,
+				dataId: record.id.dataId,
+				record
+			};
+			const request = stateStore.put(storeRecord);
+			request.onsuccess = () => {
+				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) => {
+				reject(new StorageError(`Failed to update record from incoming: ${event.target.error.message}`));
+			};
+		});
+	}
+	async listContacts(request) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		const actualOffset = request.offset !== null && request.offset !== void 0 ? request.offset : 0;
+		const actualLimit = request.limit !== null && request.limit !== void 0 ? request.limit : 4294967295;
+		return new Promise((resolve, reject) => {
+			const nameIndex = this.db.transaction("contacts", "readonly").objectStore("contacts").index("name");
+			const contacts = [];
+			let count = 0;
+			let skipped = 0;
+			const cursorRequest = nameIndex.openCursor();
+			cursorRequest.onsuccess = (event) => {
+				const cursor = event.target.result;
+				if (!cursor || count >= actualLimit) {
+					resolve(contacts);
+					return;
+				}
+				if (skipped < actualOffset) {
+					skipped++;
+					cursor.continue();
+					return;
+				}
+				contacts.push(cursor.value);
+				count++;
+				cursor.continue();
+			};
+			cursorRequest.onerror = () => {
+				reject(new StorageError(`Failed to list contacts: ${cursorRequest.error?.message || "Unknown error"}`, cursorRequest.error));
+			};
+		});
+	}
+	async getContact(id) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const request = this.db.transaction("contacts", "readonly").objectStore("contacts").get(id);
+			request.onsuccess = () => {
+				resolve(request.result || null);
+			};
+			request.onerror = () => {
+				reject(new StorageError(`Failed to get contact '${id}': ${request.error?.message || "Unknown error"}`, request.error));
+			};
+		});
+	}
+	async insertContact(contact) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const store = this.db.transaction("contacts", "readwrite").objectStore("contacts");
+			const getRequest = store.get(contact.id);
+			getRequest.onsuccess = () => {
+				const existingById = getRequest.result;
+				const toStore = existingById ? {
+					...contact,
+					createdAt: existingById.createdAt
+				} : contact;
+				const putRequest = store.put(toStore);
+				putRequest.onsuccess = () => resolve();
+				putRequest.onerror = () => {
+					reject(new StorageError(`Inserting contact failed: ${putRequest.error?.name || "Unknown error"} - ${putRequest.error?.message || ""}`, putRequest.error));
+				};
+			};
+			getRequest.onerror = () => {
+				reject(new StorageError(`Failed to check existing contact: ${getRequest.error?.message || "Unknown error"}`, getRequest.error));
+			};
+		});
+	}
+	async deleteContact(id) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const request = this.db.transaction("contacts", "readwrite").objectStore("contacts").delete(id);
+			request.onsuccess = () => resolve();
+			request.onerror = () => {
+				reject(new StorageError(`Failed to delete contact '${id}': ${request.error?.message || "Unknown error"}`, request.error));
+			};
+		});
+	}
+	async setCrossChainSwap(swap) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const request = this.db.transaction("cross_chain_swaps", "readwrite").objectStore("cross_chain_swaps").put(swap);
+			request.onsuccess = () => resolve();
+			request.onerror = () => {
+				reject(new StorageError(`Failed to set cross-chain swap '${swap.provider}:${swap.id}': ${request.error?.message || "Unknown error"}`, request.error));
+			};
+		});
+	}
+	async getCrossChainSwap(provider, id) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const request = this.db.transaction("cross_chain_swaps", "readonly").objectStore("cross_chain_swaps").get([provider, id]);
+			request.onsuccess = () => resolve(request.result || null);
+			request.onerror = () => {
+				reject(new StorageError(`Failed to get cross-chain swap '${provider}:${id}': ${request.error?.message || "Unknown error"}`, request.error));
+			};
+		});
+	}
+	async listActiveCrossChainSwaps(provider) {
+		if (!this.db) throw new StorageError("Database not initialized");
+		return new Promise((resolve, reject) => {
+			const request = this.db.transaction("cross_chain_swaps", "readonly").objectStore("cross_chain_swaps").getAll();
+			request.onsuccess = () => {
+				resolve((request.result || []).filter((swap) => swap.provider === provider && !swap.isTerminal));
+			};
+			request.onerror = () => {
+				reject(new StorageError(`Failed to list active cross-chain swaps for '${provider}': ${request.error?.message || "Unknown error"}`, request.error));
+			};
+		});
+	}
+	_paymentToStore(payment) {
+		return {
+			...payment,
+			details: payment.details ? JSON.stringify(payment.details) : null,
+			method: payment.method ? JSON.stringify(payment.method) : null
+		};
+	}
+	_normalizePaymentStatus(status) {
+		return typeof status === "string" ? status.toLowerCase() : status;
+	}
+	_isFinalPaymentStatus(status) {
+		const normalized = this._normalizePaymentStatus(status);
+		return normalized === "completed" || normalized === "failed";
+	}
+	_matchesFilters(payment, request) {
+		if (request.typeFilter && request.typeFilter.length > 0) {
+			if (!request.typeFilter.includes(payment.paymentType)) return false;
+		}
+		if (request.statusFilter && request.statusFilter.length > 0) {
+			if (!request.statusFilter.includes(payment.status)) return false;
+		}
+		if (request.fromTimestamp !== null && request.fromTimestamp !== void 0) {
+			if (payment.timestamp < request.fromTimestamp) return false;
+		}
+		if (request.toTimestamp !== null && request.toTimestamp !== void 0) {
+			if (payment.timestamp >= request.toTimestamp) return false;
+		}
+		if (request.paymentDetailsFilter && request.paymentDetailsFilter.length > 0) {
+			let details = null;
+			if (payment.details && typeof payment.details === "string") try {
+				details = JSON.parse(payment.details);
+			} catch (e) {
+				details = null;
+			}
+			else details = payment.details;
+			if (!details) return false;
+			let paymentDetailsFilterMatches = false;
+			for (const paymentDetailsFilter of request.paymentDetailsFilter) {
+				if (details.type !== paymentDetailsFilter.type) continue;
+				if ((paymentDetailsFilter.type === "spark" || paymentDetailsFilter.type === "lightning") && paymentDetailsFilter.htlcStatus != null && paymentDetailsFilter.htlcStatus.length > 0) {
+					if (details.type !== paymentDetailsFilter.type || !details.htlcDetails || !paymentDetailsFilter.htlcStatus.includes(details.htlcDetails.status)) continue;
+				}
+				if ((paymentDetailsFilter.type === "spark" || paymentDetailsFilter.type === "token" || paymentDetailsFilter.type === "lightning") && paymentDetailsFilter.conversionFilter != null) {
+					if (details.type !== paymentDetailsFilter.type || !details.conversionInfo) continue;
+					const ci = details.conversionInfo;
+					if (paymentDetailsFilter.conversionFilter === "ammRefundNeeded") {
+						if (ci.type !== "amm" || ci.status !== "refundNeeded") continue;
+					} else if (paymentDetailsFilter.conversionFilter === "orchestraPending") {
+						if (ci.type !== "orchestra" || [
+							"completed",
+							"failed",
+							"refunded"
+						].includes(ci.status)) continue;
+					} else if (paymentDetailsFilter.conversionFilter === "boltzPending") {
+						if (ci.type !== "boltz" || [
+							"completed",
+							"failed",
+							"refunded"
+						].includes(ci.status)) continue;
+					}
+				}
+				if (paymentDetailsFilter.type === "token" && paymentDetailsFilter.txHash != null) {
+					if (details.type !== "token" || details.txHash !== paymentDetailsFilter.txHash) continue;
+				}
+				if (paymentDetailsFilter.type === "token" && paymentDetailsFilter.txType != null) {
+					if (details.type !== "token" || details.txType !== paymentDetailsFilter.txType) continue;
+				}
+				paymentDetailsFilterMatches = true;
+				break;
+			}
+			if (!paymentDetailsFilterMatches) return false;
+		}
+		if (request.assetFilter) {
+			const assetFilter = request.assetFilter;
+			let details = null;
+			if (payment.details && typeof payment.details === "string") try {
+				details = JSON.parse(payment.details);
+			} catch (e) {
+				details = null;
+			}
+			else details = payment.details;
+			if (!details) return false;
+			if (assetFilter.type === "bitcoin" && details.type === "token") return false;
+			if (assetFilter.type === "token") {
+				if (details.type !== "token") return false;
+				if (assetFilter.tokenIdentifier) {
+					if (!details.metadata || details.metadata.identifier !== assetFilter.tokenIdentifier) return false;
+				}
+			}
+		}
+		return true;
+	}
+	_mergePaymentMetadata(payment, metadata) {
+		let details = null;
+		if (payment.details) try {
+			details = JSON.parse(payment.details);
+		} catch (e) {
+			throw new StorageError(`Failed to parse payment details JSON for payment ${payment.id}: ${e.message}`, e);
+		}
+		let method = null;
+		if (payment.method) try {
+			method = JSON.parse(payment.method);
+		} catch (e) {
+			throw new StorageError(`Failed to parse payment method JSON for payment ${payment.id}: ${e.message}`, e);
+		}
+		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) details.description = metadata.lnurlDescription;
+				if (metadata.lnurlPayInfo) try {
+					details.lnurlPayInfo = JSON.parse(metadata.lnurlPayInfo);
+				} catch (e) {
+					throw new StorageError(`Failed to parse lnurlPayInfo JSON for payment ${payment.id}: ${e.message}`, e);
+				}
+				if (metadata.lnurlWithdrawInfo) try {
+					details.lnurlWithdrawInfo = JSON.parse(metadata.lnurlWithdrawInfo);
+				} catch (e) {
+					throw new StorageError(`Failed to parse lnurlWithdrawInfo JSON for payment ${payment.id}: ${e.message}`, e);
+				}
+			}
+			if ((details.type == "lightning" || details.type == "spark" || details.type == "token") && metadata.conversionInfo) try {
+				details.conversionInfo = JSON.parse(metadata.conversionInfo);
+			} catch (e) {
+				throw new StorageError(`Failed to parse conversionInfo JSON for payment ${payment.id}: ${e.message}`, e);
+			}
+		}
+		return {
+			id: payment.id,
+			paymentType: payment.paymentType,
+			status: payment.status,
+			amount: payment.amount,
+			fees: payment.fees,
+			timestamp: payment.timestamp,
+			method,
+			details,
+			conversionDetails: metadata?.conversionStatus ? {
+				status: metadata.conversionStatus,
+				from: null,
+				to: null
+			} : null
+		};
+	}
+	_fetchLnurlReceiveMetadata(payment, lnurlReceiveMetadataStore) {
+		if (!payment.details || payment.details.type !== "lightning" || !payment.details.htlcDetails?.paymentHash) return Promise.resolve(payment);
+		if (!lnurlReceiveMetadataStore) return Promise.resolve(payment);
+		return new Promise((resolve, reject) => {
+			const lnurlReceiveRequest = lnurlReceiveMetadataStore.get(payment.details.htlcDetails.paymentHash);
+			lnurlReceiveRequest.onsuccess = () => {
+				const lnurlReceiveMetadata = lnurlReceiveRequest.result;
+				if (lnurlReceiveMetadata) payment.details.lnurlReceiveMetadata = {
+					nostrZapRequest: lnurlReceiveMetadata.nostrZapRequest || null,
+					nostrZapReceipt: lnurlReceiveMetadata.nostrZapReceipt || null,
+					senderComment: lnurlReceiveMetadata.senderComment || null
+				};
+				resolve(payment);
+			};
+			lnurlReceiveRequest.onerror = () => {
+				reject(/* @__PURE__ */ new Error("Failed to fetch lnurl receive metadata"));
+			};
+		});
+	}
+};
+async function createDefaultStorage(dbName = "BreezSdkSpark", logger = null) {
+	const storage = new IndexedDBStorage(dbName, logger);
+	await storage.initialize();
+	return storage;
+}
+//#endregion
+export { createDefaultStorage };
+
+//# sourceMappingURL=storage-Bya5b2Xt.js.map