@arkade-os/boltz-swap 0.3.50 → 0.3.52

package/dist/expo/background.cjs

@@ -235,6 +235,7 @@ var BoltzRefundError = class extends Error {
     this.cause = cause;
     this.name = "BoltzRefundError";
   }
+  cause;
 };
 
 // src/boltz-swap-provider.ts
@@ -1005,6 +1006,13 @@ var MusigKeyAgg = class _MusigKeyAgg {
     this.internalKey = internalKey;
     this._tweak = _tweak;
   }
+  privateKey;
+  myPublicKey;
+  publicKeys;
+  myIndex;
+  aggPubkey;
+  internalKey;
+  _tweak;
   xonlyTweakAdd(tweak) {
     if (this._tweak) throw new Error("musig key already tweaked");
     return new _MusigKeyAgg(
@@ -1039,6 +1047,13 @@ var MusigWithMessage = class {
     this.tweak = tweak;
     this.msg = msg;
   }
+  privateKey;
+  myPublicKey;
+  publicKeys;
+  myIndex;
+  aggPubkey;
+  tweak;
+  msg;
   generateNonce() {
     const nonce = (0, import_musig2.nonceGen)(this.myPublicKey, this.privateKey, this.aggPubkey, this.msg);
     return new MusigWithNonce(
@@ -1062,6 +1077,13 @@ var MusigWithNonce = class {
     this.msg = msg;
     this.nonce = nonce;
   }
+  privateKey;
+  myPublicKey;
+  publicKeys;
+  myIndex;
+  tweak;
+  msg;
+  nonce;
   get publicNonce() {
     return this.nonce.public;
   }
@@ -1110,6 +1132,14 @@ var MusigNoncesAggregated = class {
     this.pubNonces = pubNonces;
     this.aggregatedNonce = aggregatedNonce;
   }
+  privateKey;
+  publicKeys;
+  myIndex;
+  tweak;
+  msg;
+  nonce;
+  pubNonces;
+  aggregatedNonce;
   get publicNonce() {
     return this.nonce.public;
   }
@@ -1141,6 +1171,12 @@ var MusigSession = class {
     this.session = session;
     this.partialSignatures = Array(publicKeys.length).fill(null);
   }
+  privateKey;
+  publicKeys;
+  myIndex;
+  nonce;
+  pubNonces;
+  session;
   partialSignatures;
   get publicNonce() {
     return this.nonce.public;
@@ -1168,6 +1204,10 @@ var MusigSigned = class {
     this.ourPartialSignature = ourPartialSignature;
     this.publicNonce = publicNonce;
   }
+  session;
+  partialSignatures;
+  ourPartialSignature;
+  publicNonce;
   aggregatePartials() {
     if (this.partialSignatures.some((s) => s === null)) {
       throw new Error("not all partial signatures are set");
@@ -1435,12 +1475,20 @@ var SwapManager = class _SwapManager {
    */
   static NOT_FOUND_THRESHOLD = 10;
   /**
-   * Delay between re-attempts of a chain refund that left VTXOs deferred
-   * (e.g. pre-CLTV recoverable VTXO, or Boltz 3-of-3 rejected before CLTV
-   * has elapsed). Boltz won't send another status update once the swap
-   * is `swap.expired`, so the manager owns the local retry cadence.
+   * Floor on the delay between re-attempts of a refund that left VTXOs
+   * deferred, and the delay used when the outcome names no retry time. Boltz
+   * won't send another status update once the swap is refundable-and-final,
+   * so the manager owns the local retry cadence.
    */
   static REFUND_RETRY_DELAY_MS = 6e4;
+  /**
+   * Ceiling on that delay. A deferral can be hours out (a pre-CLTV VTXO waits
+   * out the whole refund locktime), and `setTimeout` fires *immediately* past
+   * its 32-bit millisecond range, so long waits are broken into re-armed
+   * hops. Re-attempting costs an indexer lookup and re-defers, which also lets
+   * the cadence recover from a suspended device or a clock jump.
+   */
+  static MAX_REFUND_RETRY_DELAY_MS = 60 * 6e4;
   swapProvider;
   config;
   // Event listeners storage (supports multiple listeners per event)
@@ -1459,10 +1507,9 @@ var SwapManager = class _SwapManager {
   reconnectTimer = null;
   initialPollTimer = null;
   pollRetryTimers = /* @__PURE__ */ new Map();
-  // Per-swap retry timers for chain refunds that left work undone
-  // (refundArk returned `skipped > 0`). The swap is held in
-  // `monitoredSwaps` past its terminal Boltz status until the local
-  // refund completes or the manager stops.
+  // Per-swap retry timers for deferred refunds that left local work undone.
+  // The swap is held in `monitoredSwaps` past its terminal Boltz status
+  // until the local refund completes or the manager stops.
   refundRetryTimers = /* @__PURE__ */ new Map();
   // Per-swap counter of consecutive `SwapNotFoundError` responses from
   // `getSwapStatus`. Reset on any successful poll. Once a swap reaches
@@ -1634,11 +1681,12 @@ var SwapManager = class _SwapManager {
       this.initialSwaps.set(swap.id, swap);
     }
     for (const swap of pendingSwaps) {
-      if (!this.isFinalStatus(swap)) {
+      if (this.shouldMonitorOnStart(swap)) {
         this.monitoredSwaps.set(swap.id, swap);
       }
     }
     await this.tryConnectWebSocket();
+    this.resumePersistedRefundRetries();
     await this.resumeActionableSwaps();
   }
   /**
@@ -1721,6 +1769,7 @@ var SwapManager = class _SwapManager {
    * Remove a swap from monitoring
    */
   async removeSwap(swapId) {
+    const swap = this.monitoredSwaps.get(swapId);
     this.monitoredSwaps.delete(swapId);
     this.swapSubscriptions.delete(swapId);
     this.chainClaimPromises.delete(swapId);
@@ -1734,6 +1783,9 @@ var SwapManager = class _SwapManager {
       clearTimeout(refundRetryTimer);
       this.refundRetryTimers.delete(swapId);
     }
+    if (swap) {
+      await this.clearRefundRetry(swap);
+    }
     this.notFoundCounts.delete(swapId);
     logger.log(`Removed swap ${swapId} from monitoring`);
   }
@@ -2072,12 +2124,69 @@ var SwapManager = class _SwapManager {
     }
     this.swapCompletedListeners.forEach((listener) => listener(swap));
   }
+  static isRefundRetryableSwap(swap) {
+    return isPendingSubmarineSwap(swap) || isPendingChainSwap(swap);
+  }
+  static hasPendingRefundRetry(swap) {
+    if (!_SwapManager.isRefundRetryableSwap(swap)) return false;
+    return swap.refundRetry?.pending === true && Number.isFinite(swap.refundRetry.nextRetryAt);
+  }
+  shouldMonitorOnStart(swap) {
+    if (!this.isFinalStatus(swap)) return true;
+    return this.config.enableAutoActions === true && _SwapManager.hasPendingRefundRetry(swap);
+  }
+  /**
+   * How long to wait before re-attempting a refund, given the `retryAt`
+   * (Unix seconds) the outcome reported. Clamped at both ends: see
+   * {@link SwapManager.REFUND_RETRY_DELAY_MS} and
+   * {@link SwapManager.MAX_REFUND_RETRY_DELAY_MS}.
+   */
+  static refundRetryDelayMs(retryAt) {
+    if (retryAt === void 0) return _SwapManager.REFUND_RETRY_DELAY_MS;
+    return Math.min(
+      Math.max(retryAt * 1e3 - Date.now(), _SwapManager.REFUND_RETRY_DELAY_MS),
+      _SwapManager.MAX_REFUND_RETRY_DELAY_MS
+    );
+  }
+  static persistedRefundRetryDelayMs(nextRetryAt) {
+    return Math.min(
+      Math.max(nextRetryAt * 1e3 - Date.now(), 0),
+      _SwapManager.MAX_REFUND_RETRY_DELAY_MS
+    );
+  }
+  static nextRefundRetryAt(delayMs) {
+    return Math.ceil((Date.now() + delayMs) / 1e3);
+  }
+  async clearRefundRetry(swap) {
+    if (!_SwapManager.isRefundRetryableSwap(swap) || swap.refundRetry === void 0) return;
+    delete swap.refundRetry;
+    await this.saveSwap(swap);
+  }
+  resumePersistedRefundRetries() {
+    if (!this.config.enableAutoActions) return;
+    for (const swap of this.monitoredSwaps.values()) {
+      if (!_SwapManager.hasPendingRefundRetry(swap)) continue;
+      const delayMs = _SwapManager.persistedRefundRetryDelayMs(swap.refundRetry.nextRetryAt);
+      logger.log(
+        `Swap ${swap.id}: resuming deferred refund retry in ${Math.round(delayMs / 1e3)}s`
+      );
+      this.armRefundRetryTimer(swap, delayMs);
+    }
+  }
   /**
-   * Schedule another `executeAutonomousAction` run for a chain swap whose
-   * refund left VTXOs deferred. After the retry completes, if no further
-   * deferral was reported, finalize monitoring cleanup.
+   * Schedule another `executeAutonomousAction` run for a swap whose refund
+   * left VTXOs deferred. The pending retry and its next attempt time are saved
+   * with the swap so stop/start and application restart can re-arm it.
    */
-  scheduleRefundRetry(swap, delayMs) {
+  async scheduleRefundRetry(swap, delayMs) {
+    swap.refundRetry = {
+      pending: true,
+      nextRetryAt: _SwapManager.nextRefundRetryAt(delayMs)
+    };
+    await this.saveSwap(swap);
+    this.armRefundRetryTimer(swap, delayMs);
+  }
+  armRefundRetryTimer(swap, delayMs) {
     const existing = this.refundRetryTimers.get(swap.id);
     if (existing) clearTimeout(existing);
     this.refundRetryTimers.set(
@@ -2085,12 +2194,14 @@ var SwapManager = class _SwapManager {
       setTimeout(async () => {
         this.refundRetryTimers.delete(swap.id);
         if (!this.isRunning) return;
-        if (!this.monitoredSwaps.has(swap.id)) return;
+        const current = this.monitoredSwaps.get(swap.id);
+        if (!current) return;
+        let ran = false;
         try {
-          await this.executeAutonomousAction(swap);
+          ran = await this.executeAutonomousAction(current);
         } finally {
-          if (!this.refundRetryTimers.has(swap.id) && this.isFinalStatus(swap)) {
-            this.finalizeMonitoredSwap(swap);
+          if (ran && !this.refundRetryTimers.has(current.id) && this.isFinalStatus(current)) {
+            this.finalizeMonitoredSwap(current);
           }
         }
       }, delayMs)
@@ -2099,11 +2210,16 @@ var SwapManager = class _SwapManager {
   /**
    * Execute autonomous action based on swap status
    * Uses locking to prevent race conditions with manual operations
+   *
+   * @returns `false` when another action for this swap already held the lock
+   * and this call did nothing, `true` when it ran. Callers that finalize on
+   * the result must not act on `false`: the in-flight action owns the swap's
+   * outcome and will re-arm or finalize from its own result.
    */
   async executeAutonomousAction(swap) {
     if (this.swapsInProgress.has(swap.id)) {
       logger.log(`Swap ${swap.id} is already being processed, skipping autonomous action`);
-      return;
+      return false;
     }
     try {
       this.swapsInProgress.add(swap.id);
@@ -2112,7 +2228,7 @@ var SwapManager = class _SwapManager {
           logger.log(
             `Skipping claim for swap ${swap.id}: missing preimage (restored swap)`
           );
-          return;
+          return true;
         }
         if (isReverseClaimableStatus(swap.status)) {
           logger.log(`Auto-claiming reverse swap ${swap.id}`);
@@ -2124,11 +2240,26 @@ var SwapManager = class _SwapManager {
           logger.log(
             `Skipping refund for swap ${swap.id}: missing invoice (restored swap)`
           );
-          return;
+          return true;
         }
         if (isSubmarineRefundableStatus(swap.status)) {
           logger.log(`Auto-refunding submarine swap ${swap.id}`);
-          await this.executeRefundAction(swap);
+          let outcome;
+          try {
+            outcome = await this.executeRefundAction(swap);
+          } catch (error) {
+            await this.clearRefundRetry(swap);
+            throw error;
+          }
+          if (outcome && outcome.skipped > 0) {
+            const delayMs = _SwapManager.refundRetryDelayMs(outcome.retryAt);
+            logger.log(
+              `Submarine swap ${swap.id}: ${outcome.skipped} VTXO(s) deferred \u2014 scheduling refund retry in ${Math.round(delayMs / 1e3)}s`
+            );
+            await this.scheduleRefundRetry(swap, delayMs);
+          } else if (outcome) {
+            await this.clearRefundRetry(swap);
+          }
           this.actionExecutedListeners.forEach((listener) => listener(swap, "refund"));
         }
       } else if (isPendingChainSwap(swap)) {
@@ -2152,10 +2283,13 @@ var SwapManager = class _SwapManager {
             try {
               const outcome = await this.executeRefundArkAction(swap);
               if (outcome && outcome.skipped > 0) {
+                const delayMs = _SwapManager.refundRetryDelayMs(outcome.retryAt);
                 logger.log(
-                  `Chain swap ${swap.id}: ${outcome.skipped} VTXO(s) deferred \u2014 scheduling refund retry`
+                  `Chain swap ${swap.id}: ${outcome.skipped} VTXO(s) deferred \u2014 scheduling refund retry in ${Math.round(delayMs / 1e3)}s`
                 );
-                this.scheduleRefundRetry(swap, _SwapManager.REFUND_RETRY_DELAY_MS);
+                await this.scheduleRefundRetry(swap, delayMs);
+              } else if (outcome) {
+                await this.clearRefundRetry(swap);
               }
               this.actionExecutedListeners.forEach(
                 (listener) => listener(swap, "refundArk")
@@ -2168,7 +2302,7 @@ var SwapManager = class _SwapManager {
               this.swapFailedListeners.forEach(
                 (listener) => listener(swap, error)
               );
-              this.scheduleRefundRetry(swap, _SwapManager.REFUND_RETRY_DELAY_MS);
+              await this.scheduleRefundRetry(swap, _SwapManager.REFUND_RETRY_DELAY_MS);
             }
           }
           if (swap.request.from === "BTC") {
@@ -2201,6 +2335,7 @@ var SwapManager = class _SwapManager {
     } finally {
       this.swapsInProgress.delete(swap.id);
     }
+    return true;
   }
   /**
    * Execute claim action for reverse swap
@@ -2214,13 +2349,15 @@ var SwapManager = class _SwapManager {
   }
   /**
    * Execute refund action for submarine swap
+   *
+   * @returns The refund outcome, or `undefined` if no callback is wired.
    */
   async executeRefundAction(swap) {
     if (!this.refundCallback) {
       logger.error("Refund callback not set");
       return;
     }
-    await this.refundCallback(swap);
+    return this.refundCallback(swap);
   }
   /**
    * Execute claim action for chain swap Btc to Ark
@@ -2302,6 +2439,7 @@ var SwapManager = class _SwapManager {
       return;
     }
     for (const swap of this.monitoredSwaps.values()) {
+      if (this.refundRetryTimers.has(swap.id)) continue;
       try {
         if (isPendingReverseSwap(swap) && isReverseClaimableStatus(swap.status)) {
           logger.log(`Resuming claim for swap ${swap.id}`);
@@ -2626,6 +2764,7 @@ var IndexedDbSwapRepository = class {
   constructor(dbName = DEFAULT_DB_NAME) {
     this.dbName = dbName;
   }
+  dbName;
   version = 1;
   db = null;
   async getDB() {
@@ -3176,6 +3315,7 @@ var canRecoverViaBoltz3of3 = (refundableVtxos, swap) => {
   return refundableVtxos.some((vtxo) => !vtxo.isSpent && !(0, import_sdk8.isRecoverable)(vtxo));
 };
 var isSubmarineRefundLocktimeReached = (refundTimestamp) => Math.floor(Date.now() / 1e3) >= refundTimestamp;
+var CLTV_IMMATURE_RETRY_SEC = 60;
 var CLAIM_VTXO_RETRY_ATTEMPTS = 3;
 var CLAIM_VTXO_RETRY_DELAY_MS = 500;
 var quoteOptionsForSwap = (swap) => {
@@ -3248,9 +3388,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
         claim: async (swap) => {
           await this.claimVHTLC(swap);
         },
-        refund: async (swap) => {
-          await this.refundVHTLC(swap);
-        },
+        refund: (swap) => this.refundVHTLC(swap),
         claimArk: (swap) => this.claimArk(swap),
         claimBtc: (swap) => this.claimBtc(swap),
         refundArk: async (swap) => {
@@ -3856,7 +3994,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       refundWithoutReceiverLeaf,
       outputScript
     };
-    const { swept: sweptCount, skipped: skippedCount } = await this.refundVtxos({
+    const outcome = await this.refundVtxos({
       swapId: pendingSwap.id,
       vtxos: refundableVtxos,
       refundLocktime: vhtlcTimeouts.refund,
@@ -3866,7 +4004,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
       refundViaBoltz: this.swapProvider.refundSubmarineSwap.bind(this.swapProvider)
     });
     if (!isSubmarineSuccessStatus(pendingSwap.status)) {
-      const fullyRefunded = skippedCount === 0;
+      const fullyRefunded = outcome.skipped === 0;
+      pendingSwap.refundable = true;
+      pendingSwap.refunded = fullyRefunded;
       await updateSubmarineSwapStatus(
         pendingSwap,
         pendingSwap.status,
@@ -3875,7 +4015,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
         { refundable: true, refunded: fullyRefunded }
       );
     }
-    return { swept: sweptCount, skipped: skippedCount };
+    return outcome;
   }
   /**
    * Inspect a submarine swap's lockup address for recoverable funds.
@@ -4492,7 +4632,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       refundWithoutReceiverLeaf,
       outputScript
     };
-    const { swept: sweptCount, skipped: skippedCount } = await this.refundVtxos({
+    const outcome = await this.refundVtxos({
       swapId: pendingSwap.id,
       vtxos: unspentVtxos,
       refundLocktime,
@@ -4502,11 +4642,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
       refundViaBoltz: this.swapProvider.refundChainSwap.bind(this.swapProvider)
     });
     const finalStatus = await this.getSwapStatus(pendingSwap.id);
-    await this.savePendingChainSwap({
-      ...pendingSwap,
-      status: finalStatus.status
-    });
-    return { swept: sweptCount, skipped: skippedCount };
+    pendingSwap.status = finalStatus.status;
+    await this.savePendingChainSwap(pendingSwap);
+    return outcome;
   }
   // =========================================================================
   // Chain swaps: BTC -> ARK
@@ -5110,18 +5248,44 @@ var ArkadeSwaps = class _ArkadeSwaps {
       );
     }
   }
+  /**
+   * {@link settleRefundWithoutReceiver}, deferring instead of failing when the server
+   * rejects the spend as CLTV-immature ({@link ArkErrorName.FORFEIT_CLOSURE_LOCKED}):
+   * we gate on the local wall clock, the server on the chain tip's, which lags. The
+   * server-authoritative sibling of the wall-clock deferral the pre-CLTV branches
+   * already implement. Anything else propagates.
+   *
+   * Only `submitTx` can raise it, so this is a pass-through for recoverable VTXOs,
+   * which settle via a batch round.
+   *
+   * @returns `true` if settled, `false` if the server deferred it.
+   */
+  async trySettleRefundWithoutReceiver(swapId, ctx, vtxo) {
+    try {
+      await this.settleRefundWithoutReceiver(ctx, vtxo);
+      return true;
+    } catch (error) {
+      if (!(0, import_sdk8.isArkError)(error, import_sdk8.ArkErrorName.FORFEIT_CLOSURE_LOCKED)) throw error;
+      logger.warn(
+        `Swap ${swapId}: server deferred refundWithoutReceiver for VTXO ${vtxo.txid}:${vtxo.vout} \u2014 refund locktime has not matured against the chain tip (locktime=${error.metadata?.locktime}, currentLocktime=${error.metadata?.current_locktime}, type=${error.metadata?.type}). Refund will be retried once a later block carries the locktime.`
+      );
+      return false;
+    }
+  }
   /**
    * Refund every VTXO at a swap's VHTLC address back to the wallet, shared by
    * {@link ArkadeSwaps.refundVHTLC} (submarine) and {@link ArkadeSwaps.refundArk}
    * (chain). Path selection per VTXO:
-   * - CLTV elapsed → `refundWithoutReceiver` (offchain for a live VTXO, via a
-   *   batch round for a swept one — see {@link settleRefundWithoutReceiver}).
+   * - CLTV elapsed by our wall clock → `refundWithoutReceiver` (offchain for a
+   *   live VTXO, via a batch round for a swept one — see
+   *   {@link settleRefundWithoutReceiver}), or skipped if the server defers it as
+   *   still immature (see {@link trySettleRefundWithoutReceiver}).
    * - Pre-CLTV recoverable → skipped (Boltz can't co-sign a swept-batch refund).
    * - Pre-CLTV non-recoverable → cooperative 3-of-3 refund via Boltz, falling
    *   back to `refundWithoutReceiver` offchain if Boltz rejects after the
    *   locktime has since elapsed.
    *
-   * @returns Counts of VTXOs swept vs. deferred.
+   * @returns Counts of VTXOs swept vs. deferred, and when to retry the latter.
    */
   async refundVtxos(params) {
     const {
@@ -5137,19 +5301,27 @@ var ArkadeSwaps = class _ArkadeSwaps {
     let boltzCallCount = 0;
     let sweptCount = 0;
     let skippedCount = 0;
+    let retryAt;
+    const defer = (candidate) => {
+      skippedCount++;
+      retryAt = retryAt === void 0 ? candidate : Math.min(retryAt, candidate);
+    };
     for (const vtxo of vtxos) {
       const isRecoverableVtxo = (0, import_sdk8.isRecoverable)(vtxo);
       const output = { amount: BigInt(vtxo.value), script: outputScript };
       if (isSubmarineRefundLocktimeReached(refundLocktime)) {
-        await this.settleRefundWithoutReceiver(refundContext, vtxo);
-        sweptCount++;
+        if (await this.trySettleRefundWithoutReceiver(swapId, refundContext, vtxo)) {
+          sweptCount++;
+        } else {
+          defer(Math.floor(Date.now() / 1e3) + CLTV_IMMATURE_RETRY_SEC);
+        }
         continue;
       }
       if (isRecoverableVtxo) {
         logger.error(
           `Swap ${swapId}: recoverable VTXO ${vtxo.txid}:${vtxo.vout} cannot be refunded yet \u2014 refundWithoutReceiver locktime has not passed (refundLocktime=${refundLocktime}, currentTimestamp=${Math.floor(Date.now() / 1e3)}). Refund will be retried after locktime.`
         );
-        skippedCount++;
+        defer(refundLocktime);
         continue;
       }
       const input = {
@@ -5183,17 +5355,20 @@ var ArkadeSwaps = class _ArkadeSwaps {
           logger.error(
             `Swap ${swapId}: Boltz rejected VTXO outpoint and refundWithoutReceiver locktime has not passed yet (currentTimestamp=${Math.floor(Date.now() / 1e3)}, locktime=${refundLocktime}). Refund will be retried after locktime.`
           );
-          skippedCount++;
+          defer(refundLocktime);
           continue;
         }
         logger.warn(
           `Swap ${swapId}: Boltz rejected VTXO outpoint, falling back to refundWithoutReceiver offchain`
         );
-        await this.settleRefundWithoutReceiver(refundContext, vtxo);
-        sweptCount++;
+        if (await this.trySettleRefundWithoutReceiver(swapId, refundContext, vtxo)) {
+          sweptCount++;
+        } else {
+          defer(Math.floor(Date.now() / 1e3) + CLTV_IMMATURE_RETRY_SEC);
+        }
       }
     }
-    return { swept: sweptCount, skipped: skippedCount };
+    return { swept: sweptCount, skipped: skippedCount, retryAt };
   }
   /**
    * Creates a VHTLC script for the swap.

package/dist/expo/background.d.cts

@@ -1,8 +1,8 @@
-import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor-CIqTFkV1.cjs';
-export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor-CIqTFkV1.cjs';
+import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor-DCtJYSbJ.cjs';
+export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor-DCtJYSbJ.cjs';
 import '@arkade-os/sdk/worker/expo';
 import '@arkade-os/sdk';
-import '../types-BKEkNZxK.cjs';
+import '../types-Db4JSdjk.cjs';
 
 /**
  * Define the Expo background task handler for swap polling.

package/dist/expo/background.d.ts

@@ -1,8 +1,8 @@
-import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor-C4HQHP9Z.js';
-export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor-C4HQHP9Z.js';
+import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor--BPV48QB.js';
+export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor--BPV48QB.js';
 import '@arkade-os/sdk/worker/expo';
 import '@arkade-os/sdk';
-import '../types-BKEkNZxK.js';
+import '../types-Db4JSdjk.js';
 
 /**
  * Define the Expo background task handler for swap polling.

package/dist/expo/background.js

@@ -1,10 +1,10 @@
 import {
   SWAP_POLL_TASK_TYPE,
   swapsPollProcessor
-} from "../chunk-HIG2OOAN.js";
+} from "../chunk-76V3TKDL.js";
 import {
   BoltzSwapProvider
-} from "../chunk-VKHFXGKL.js";
+} from "../chunk-CZTZTYZU.js";
 import "../chunk-SJQJQO7P.js";
 
 // src/expo/background.ts