@breeztech/breez-sdk-spark 0.25.0 → 0.26.0

package/bundler/breez_sdk_spark_wasm.d.ts

@@ -545,7 +545,7 @@ export interface BatchRecipient {
 
 export interface BatchTotal {
     tokenIdentifier?: string;
-    amount: bigint;
+    amount: string;
 }
 
 export interface Bip21Details {
@@ -705,7 +705,7 @@ export interface ClaimDepositRequest {
 }
 
 export interface ClaimDepositResponse {
-    payment?: Payment;
+    outcome: ClaimDepositOutcome;
 }
 
 export interface ClaimHtlcPaymentRequest {
@@ -832,12 +832,17 @@ export interface Credentials {
     password: string;
 }
 
+export interface CrossChainAcceptedAsset {
+    asset: SparkAsset;
+    limits?: CrossChainRouteLimits;
+}
+
 export interface CrossChainAddressDetails {
     address: string;
     addressFamily: CrossChainAddressFamily;
     contractAddress?: string;
     chainId?: number;
-    amount?: bigint;
+    amount?: string;
 }
 
 export interface CrossChainConfig {
@@ -853,9 +858,17 @@ export interface CrossChainReceiveInfo {
     tokenIdentifier?: string;
     serviceFeeAmount: string;
     serviceFeeAsset?: string;
+    serviceFeeAssetDecimals?: number;
     expiresAt: number;
 }
 
+export interface CrossChainRouteLimits {
+    minAmount?: string;
+    maxAmount?: string;
+    minUsdCents?: number;
+    maxUsdCents?: number;
+}
+
 export interface CrossChainRoutePair {
     provider: CrossChainProvider;
     chain: string;
@@ -864,7 +877,7 @@ export interface CrossChainRoutePair {
     contractAddress?: string;
     decimals: number;
     exactOutEligible: boolean;
-    acceptedAssets: SparkAsset[];
+    acceptedAssets: CrossChainAcceptedAsset[];
     deliveryMethods: DeliveryMethod[];
 }
 
@@ -888,6 +901,7 @@ export interface DepositInfo {
     claimError?: DepositClaimError;
     instantClaimStatus?: InstantClaimStatus;
     refundState?: RefundState;
+    maxClaimFee?: MaxFee;
 }
 
 export interface EcdsaSignatureBytes {
@@ -968,6 +982,10 @@ export interface ExternalInputParser {
     parserUrl: string;
 }
 
+export interface ExternalLeafSigningKey {
+    derivedFrom: ExternalTreeNodeId;
+}
+
 export interface ExternalNewLeafKey {
     nodeId: ExternalTreeNodeId;
     newSigningPublicKey: number[];
@@ -1114,6 +1132,7 @@ export interface ExternalStartedStaticDepositRefund {
 export interface ExternalTransferLeafInput {
     nodeId: ExternalTreeNodeId;
     newLeafId: ExternalTreeNodeId;
+    signingKey: ExternalLeafSigningKey;
 }
 
 export interface ExternalTreeNodeId {
@@ -1486,6 +1505,7 @@ export interface PreparePaymentLinkResponse {
     asset: string;
     serviceFeeAmount: bigint;
     serviceFeeAsset?: string;
+    serviceFeeAssetDecimals?: number;
     expiresAt: string;
 }
 
@@ -1831,6 +1851,8 @@ export interface Storage {
     deleteDeposit: (txid: string, vout: number) => Promise<void>;
     listDeposits: () => Promise<DepositInfo[]>;
     updateDeposit: (txid: string, vout: number, payload: UpdateDepositPayload) => Promise<void>;
+    listWatchedDepositAddresses: () => Promise<WatchedDepositAddress[]>;
+    updateWatchedDepositAddress: (address: string, payload: UpdateWatchedAddressPayload) => Promise<void>;
     setLnurlMetadata: (metadata: SetLnurlMetadataItem[]) => Promise<void>;
     getPaymentsByParentIds: (parentPaymentIds: string[]) => Promise<{ [parentId: string]: RelatedPayment[] }>;
     listContacts: (request: ListContactsRequest) => Promise<Contact[]>;
@@ -2025,6 +2047,12 @@ export interface Utxo {
     status: TxStatus;
 }
 
+export interface WatchedDepositAddress {
+    address: string;
+    issuedAt: number;
+    seen: boolean;
+}
+
 export interface Webhook {
     id: string;
     url: string;
@@ -2051,11 +2079,15 @@ export type BuyBitcoinRequest = { type: "moonpay"; lockedAmountSat?: number; red
 
 export type ChainApiType = "esplora" | "mempoolSpace";
 
+export type ClaimDeferredReason = { type: "maxFeeExceeded"; requiredFeeSats: number; maxFeeSats: number } | { type: "noEarlyClaimAvailable" } | { type: "providerDeclined"; message: string };
+
+export type ClaimDepositOutcome = { type: "settled"; payment: Payment } | { type: "submitted" } | { type: "deferred"; reason: ClaimDeferredReason };
+
 export type ConversionChain = { type: "spark" } | { type: "lightning" } | { type: "external"; name: string; chainId?: string };
 
 export type ConversionFilter = "ammRefundNeeded" | "orchestraPending" | "boltzPending";
 
-export type ConversionInfo = { type: "amm"; poolId: string; conversionId: string; status: ConversionStatus; fee?: string; purpose?: ConversionPurpose; amountAdjustment?: AmountAdjustmentReason; degradation?: SwapDegradation } | { type: "orchestra"; chain: string; chainId?: string; asset?: string; assetContract?: string; recipientAddress: string; assetAmountIn?: string; estimatedOut: string; deliveredAmount?: string; externalTxHash?: string; status: ConversionStatus; feeAmount?: string; serviceFeeAmount?: string; serviceFeeAsset?: string; assetDecimals: number; orderId: string; quoteId: string; readToken?: string } | { type: "boltz"; chain: string; chainId?: string; asset?: string; assetContract?: string; recipientAddress: string; assetAmountIn?: string; estimatedOut: string; deliveredAmount?: string; status: ConversionStatus; feeAmount?: string; serviceFeeAmount?: string; serviceFeeAsset?: string; assetDecimals: number; swapId: string; invoice: string; invoiceAmountSats: number; bridgeRef?: string; maxSlippageBps: number; quoteDegraded?: boolean };
+export type ConversionInfo = { type: "amm"; poolId: string; conversionId: string; status: ConversionStatus; fee?: string; purpose?: ConversionPurpose; amountAdjustment?: AmountAdjustmentReason; degradation?: SwapDegradation } | { type: "orchestra"; chain: string; chainId?: string; asset?: string; assetContract?: string; recipientAddress: string; assetAmountIn?: string; estimatedOut: string; deliveredAmount?: string; externalTxHash?: string; status: ConversionStatus; feeAmount?: string; serviceFeeAmount?: string; serviceFeeAsset?: string; serviceFeeAssetDecimals?: number; assetDecimals: number; orderId: string; quoteId: string; readToken?: string } | { type: "boltz"; chain: string; chainId?: string; asset?: string; assetContract?: string; recipientAddress: string; assetAmountIn?: string; estimatedOut: string; deliveredAmount?: string; status: ConversionStatus; feeAmount?: string; serviceFeeAmount?: string; serviceFeeAsset?: string; assetDecimals: number; swapId: string; invoice: string; invoiceAmountSats: number; bridgeRef?: string; maxSlippageBps: number; quoteDegraded?: boolean };
 
 export type ConversionProvider = "amm" | "orchestra" | "boltz";
 
@@ -2103,13 +2135,13 @@ export type FeePolicy = "feesExcluded" | "feesIncluded";
 
 export type InputType = ({ type: "bitcoinAddress" } & BitcoinAddressDetails) | ({ type: "bolt11Invoice" } & Bolt11InvoiceDetails) | ({ type: "bolt12Invoice" } & Bolt12InvoiceDetails) | ({ type: "bolt12Offer" } & Bolt12OfferDetails) | ({ type: "lightningAddress" } & LightningAddressDetails) | ({ type: "lnurlPay" } & LnurlPayRequestDetails) | ({ type: "silentPaymentAddress" } & SilentPaymentAddressDetails) | ({ type: "lnurlAuth" } & LnurlAuthRequestDetails) | ({ type: "url" } & string) | ({ type: "bip21" } & Bip21Details) | ({ type: "bolt12InvoiceRequest" } & Bolt12InvoiceRequestDetails) | ({ type: "lnurlWithdraw" } & LnurlWithdrawRequestDetails) | ({ type: "sparkAddress" } & SparkAddressDetails) | ({ type: "sparkInvoice" } & SparkInvoiceDetails) | ({ type: "crossChainAddress" } & CrossChainAddressDetails);
 
-export type InstantClaimStatus = { type: "declined"; maxFeeSats?: number; confirmations?: number } | { type: "submitted"; claimId: string };
+export type InstantClaimStatus = { type: "declined"; maxFeeSats?: number; confirmations?: number } | { type: "submitted"; claimId: string } | { type: "claimed" };
 
 export type LnurlCallbackStatus = { type: "ok" } | { type: "errorStatus"; errorDetails: LnurlErrorDetails };
 
 export type MaxFee = { type: "fixed"; amount: number } | { type: "rate"; satPerVbyte: number } | { type: "networkRecommended"; leewaySatPerVbyte: number };
 
-export type Network = "mainnet" | "regtest";
+export type Network = "mainnet" | "regtest" | "signet";
 
 export type OnchainConfirmationSpeed = "fast" | "medium" | "slow";
 
@@ -2141,11 +2173,11 @@ export type ReceivePaymentMethod = { type: "sparkAddress" } | { type: "sparkInvo
 
 export type RefundState = { type: "broadcastPending"; lastError?: string } | { type: "broadcast" };
 
-export type SdkEvent = { type: "synced" } | { type: "unclaimedDeposits"; unclaimedDeposits: DepositInfo[] } | { type: "claimedDeposits"; claimedDeposits: DepositInfo[] } | { type: "paymentSucceeded"; payment: Payment } | { type: "paymentPending"; payment: Payment } | { type: "paymentFailed"; payment: Payment } | { type: "autoOptimization"; optimizationEvent: AutoOptimizationEvent } | { type: "lightningAddressChanged"; lightningAddress?: LightningAddressInfo } | { type: "newDeposits"; newDeposits: DepositInfo[] } | { type: "unilateralExitStateChanged" };
+export type SdkEvent = { type: "synced" } | { type: "unclaimedDeposits"; unclaimedDeposits: DepositInfo[] } | { type: "claimedDeposits"; claimedDeposits: DepositInfo[] } | { type: "paymentSucceeded"; payment: Payment } | { type: "paymentPending"; payment: Payment } | { type: "paymentFailed"; payment: Payment } | { type: "paymentMetadataUpdated"; payment: Payment } | { type: "autoOptimization"; optimizationEvent: AutoOptimizationEvent } | { type: "lightningAddressChanged"; lightningAddress?: LightningAddressInfo } | { type: "newDeposits"; newDeposits: DepositInfo[] } | { type: "unilateralExitStateChanged" };
 
 export type Seed = { type: "mnemonic"; mnemonic: string; passphrase?: string } | ({ type: "entropy" } & number[]);
 
-export type SendPaymentMethod = { type: "bitcoinAddress"; address: BitcoinAddressDetails; feeQuote: SendOnchainFeeQuote } | { type: "bolt11Invoice"; invoiceDetails: Bolt11InvoiceDetails; sparkTransferFeeSats?: number; lightningFeeSats: number } | { type: "sparkAddress"; address: string; fee: string; tokenIdentifier?: string } | { type: "sparkInvoice"; sparkInvoiceDetails: SparkInvoiceDetails; fee: string; tokenIdentifier?: string } | { type: "crossChainAddress"; route: CrossChainRoutePair; recipientAddress: string; amountIn: string; assetAmountIn: string; estimatedOut: string; feeAmount: string; serviceFeeAmount: string; serviceFeeAsset?: string; sourceTransferFeeSats: number; feeMode: CrossChainFeeMode; expiresAt: string; providerContext: CrossChainProviderContext };
+export type SendPaymentMethod = { type: "bitcoinAddress"; address: BitcoinAddressDetails; feeQuote: SendOnchainFeeQuote } | { type: "bolt11Invoice"; invoiceDetails: Bolt11InvoiceDetails; sparkTransferFeeSats?: number; lightningFeeSats: number } | { type: "sparkAddress"; address: string; fee: string; tokenIdentifier?: string } | { type: "sparkInvoice"; sparkInvoiceDetails: SparkInvoiceDetails; fee: string; tokenIdentifier?: string } | { type: "crossChainAddress"; route: CrossChainRoutePair; recipientAddress: string; amountIn: string; assetAmountIn: string; estimatedOut: string; feeAmount: string; serviceFeeAmount: string; serviceFeeAsset?: string; serviceFeeAssetDecimals?: number; sourceTransferFeeSats: number; feeMode: CrossChainFeeMode; expiresAt: string; providerContext: CrossChainProviderContext };
 
 export type SendPaymentOptions = { type: "bitcoinAddress"; confirmationSpeed: OnchainConfirmationSpeed } | { type: "bolt11Invoice"; preferSpark: boolean; completionTimeoutSecs?: number } | { type: "sparkAddress"; htlcOptions?: SparkHtlcOptions };
 
@@ -2183,7 +2215,9 @@ export type UnilateralExitVerdict = { type: "valid" } | { type: "done" } | { typ
 
 export type UnsignedTransferPackage = { type: "swap"; prepareTransfer: ExternalPrepareTransferRequest; targetAmounts: number[]; amountSat: number; feeSat: number } | { type: "transfer"; prepareTransfer: ExternalPrepareTransferRequest; amountSat: number; feeSat: number; target: TransferTarget } | { type: "token"; prepareTokenTransaction: ExternalPrepareTokenTransactionRequest; tokenContext: number[]; tokenIdentifier: string; amount: string; fee: string; isSwap: boolean } | { type: "tokenBatch"; prepareTokenTransaction: ExternalPrepareTokenTransactionRequest; tokenContext: number[]; totals: BatchTotal[]; isSwap: boolean };
 
-export type UpdateDepositPayload = { type: "claimError"; error: DepositClaimError } | { type: "refund"; refundTxid: string; refundTx: string; state: RefundState } | { type: "instantClaim"; status: InstantClaimStatus } | { type: "refundBroadcastState"; refundTxid: string; state: RefundState };
+export type UpdateDepositPayload = { type: "claimError"; error: DepositClaimError } | { type: "refund"; refundTxid: string; refundTx: string; state: RefundState } | { type: "instantClaim"; status: InstantClaimStatus } | { type: "refundBroadcastState"; refundTxid: string; state: RefundState } | { type: "maxClaimFee"; maxFee?: MaxFee };
+
+export type UpdateWatchedAddressPayload = { type: "watch"; issuedAt: number } | { type: "seen" } | { type: "unwatch"; issuedAt: number };
 
 export type WebhookEventType = { type: "lightningReceiveFinished" } | { type: "lightningSendFinished" } | { type: "coopExitFinished" } | { type: "staticDepositFinished" } | ({ type: "unknown" } & string);
 

package/bundler/breez_sdk_spark_wasm_bg.js

@@ -2891,6 +2891,10 @@ export function __wbg_listTokensOutputs_3fecc3251ae7b71c() { return handleError(
     const ret = arg0.listTokensOutputs();
     return ret;
 }, arguments); }
+export function __wbg_listWatchedDepositAddresses_55fe8af0643e3ea9() { return handleError(function (arg0) {
+    const ret = arg0.listWatchedDepositAddresses();
+    return ret;
+}, arguments); }
 export function __wbg_log_cf86719f8acabfda(arg0, arg1) {
     arg0.log(arg1);
 }
@@ -3590,6 +3594,18 @@ export function __wbg_updateTokenOutputs_d978e01c817e8230() { return handleError
     const ret = arg0.updateTokenOutputs(arg1, arg2);
     return ret;
 }, arguments); }
+export function __wbg_updateWatchedDepositAddress_260322f77dee1443() { return handleError(function (arg0, arg1, arg2, arg3) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+        deferred0_0 = arg1;
+        deferred0_1 = arg2;
+        const ret = arg0.updateWatchedDepositAddress(getStringFromWasm0(arg1, arg2), arg3);
+        return ret;
+    } finally {
+        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+    }
+}, arguments); }
 export function __wbg_url_68fd9a221360e0db(arg0, arg1) {
     const ret = arg1.url;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -3625,47 +3641,47 @@ export function __wbg_wasmsdkcontext_new(arg0) {
     return ret;
 }
 export function __wbindgen_cast_0000000000000001(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 22, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 21, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a);
     return ret;
 }
 export function __wbindgen_cast_0000000000000002(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 397, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 405, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
     const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3b28fbbc8b451a25);
     return ret;
 }
 export function __wbindgen_cast_0000000000000003(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 397, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 405, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
     const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3b28fbbc8b451a25_2);
     return ret;
 }
 export function __wbindgen_cast_0000000000000004(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 397, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 405, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
     const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3b28fbbc8b451a25_3);
     return ret;
 }
 export function __wbindgen_cast_0000000000000005(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("SessionStore")], shim_idx: 22, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_4);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("SessionStore")], shim_idx: 21, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_4);
     return ret;
 }
 export function __wbindgen_cast_0000000000000006(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Storage")], shim_idx: 22, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_5);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Storage")], shim_idx: 21, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_5);
     return ret;
 }
 export function __wbindgen_cast_0000000000000007(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TokenStore")], shim_idx: 22, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_6);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TokenStore")], shim_idx: 21, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_6);
     return ret;
 }
 export function __wbindgen_cast_0000000000000008(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TreeStore")], shim_idx: 22, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_7);
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("TreeStore")], shim_idx: 21, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_7);
     return ret;
 }
 export function __wbindgen_cast_0000000000000009(arg0, arg1) {
-    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 402, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 409, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
     const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h484cd36e13f37bd7);
     return ret;
 }
@@ -3766,36 +3782,36 @@ function wasm_bindgen__convert__closures_____invoke__h3b28fbbc8b451a25_3(arg0, a
     wasm.wasm_bindgen__convert__closures_____invoke__h3b28fbbc8b451a25_3(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_4(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_4(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_4(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_4(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_5(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_5(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_5(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_5(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_6(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_6(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_6(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_6(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_7(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_7(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_7(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_7(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }

package/bundler/breez_sdk_spark_wasm_bg.wasm.d.ts

@@ -189,11 +189,11 @@ export const __wbg_externalsparksignerhandle_free: (a: number, b: number) => voi
 export const __wbg_signingonlyexternalsigners_free: (a: number, b: number) => void;
 export const signingonlyexternalsigners_breezSigner: (a: number) => number;
 export const signingonlyexternalsigners_sparkSigner: (a: number) => number;
-export const wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_4: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_5: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_6: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen__convert__closures_____invoke__h62bc116e0c266522_7: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_4: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_5: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_6: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen__convert__closures_____invoke__h2f6500191cedbf1a_7: (a: number, b: number, c: any) => [number, number];
 export const wasm_bindgen__convert__closures_____invoke__h41057d61edf43a32: (a: number, b: number, c: any, d: any) => void;
 export const wasm_bindgen__convert__closures_____invoke__h3b28fbbc8b451a25: (a: number, b: number, c: any) => void;
 export const wasm_bindgen__convert__closures_____invoke__h3b28fbbc8b451a25_2: (a: number, b: number, c: any) => void;

package/bundler/storage/index.js

@@ -611,6 +611,19 @@ class MigrationManager {
           };
         },
       },
+      {
+        // Deposit addresses polled on-chain for deposits still in the mempool.
+        // Entries are removed once watching them can no longer lead to an early
+        // claim, so the store holds only the live watch set.
+        name: "Create watched_deposit_addresses store",
+        upgrade: (db) => {
+          if (!db.objectStoreNames.contains("watched_deposit_addresses")) {
+            db.createObjectStore("watched_deposit_addresses", {
+              keyPath: "address",
+            });
+          }
+        },
+      },
     ];
   }
 }
@@ -639,7 +652,7 @@ class IndexedDBStorage {
     // so existing databases depend on indices never shifting. Never insert,
     // reorder, or delete a migration — only append. dbVersion MUST equal the
     // number of migrations (enforced by the guard in initialize()).
-    this.dbVersion = 21; // Current schema version (= migration count)
+    this.dbVersion = 22; // Current schema version (= migration count)
   }
 
   /**
@@ -1445,6 +1458,7 @@ class IndexedDBStorage {
           refundTxId: existing?.refundTxId ?? null,
           instantClaimStatus: existing?.instantClaimStatus ?? null,
           refundState: existing?.refundState ?? null,
+          maxClaimFee: existing?.maxClaimFee ?? null,
         };
 
         const putRequest = store.put(depositToStore);
@@ -1521,6 +1535,7 @@ class IndexedDBStorage {
             ? JSON.parse(row.instantClaimStatus)
             : null,
           refundState: row.refundState ? JSON.parse(row.refundState) : null,
+          maxClaimFee: row.maxClaimFee ? JSON.parse(row.maxClaimFee) : null,
         }));
         resolve(deposits);
       };
@@ -1576,6 +1591,10 @@ class IndexedDBStorage {
           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;
@@ -1606,6 +1625,131 @@ class IndexedDBStorage {
     });
   }
 
+  async listWatchedDepositAddresses() {
+    if (!this.db) {
+      throw new StorageError("Database not initialized");
+    }
+
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction(
+        "watched_deposit_addresses",
+        "readonly"
+      );
+      const store = transaction.objectStore("watched_deposit_addresses");
+      const request = store.getAll();
+
+      request.onsuccess = () => {
+        const watched = (request.result || []).map((entry) => ({
+          address: entry.address,
+          issuedAt: entry.issuedAt,
+          seen: Boolean(entry.seen),
+        }));
+        // The store is keyed by address, so ordering is applied here rather
+        // than by an index.
+        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 transaction = this.db.transaction(
+        "watched_deposit_addresses",
+        "readwrite"
+      );
+      const store = transaction.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") {
+        // Conditional on issuedAt, so an address handed out again since the
+        // caller read it is not retired by a decision taken before that. The
+        // get and the delete share one readwrite transaction, so nothing can
+        // interleave between them.
+        const getRequest = store.get(address);
+        getRequest.onsuccess = () => {
+          const existing = getRequest.result;
+          const stale =
+            !existing || String(existing.issuedAt) !== String(payload.issuedAt);
+          if (stale) {
+            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) {
+            // Not watched, so there is nothing to mark (matches the SQL stores,
+            // whose UPDATE affects no rows).
+            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");