@arkade-os/boltz-swap 0.3.7 → 0.3.9

package/dist/{arkade-swaps-MmMjdK2G.d.ts → arkade-swaps--vc0H2oD.d.cts}

@@ -1,5 +1,5 @@
 import { IWallet, ArkProvider, IndexerProvider, ArkInfo, Identity, ArkTxInput, VHTLC } from '@arkade-os/sdk';
-import { l as BoltzSwapProvider, V as SwapManager, i as SwapRepository, X as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, j as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as PendingReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as PendingSubmarineSwap, h as ArkToBtcResponse, a as PendingChainSwap, B as BtcToArkResponse, d as Chain, F as FeesResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, P as PendingSwap } from './types-DCCYGYCD.js';
+import { l as BoltzSwapProvider, V as SwapManager, i as SwapRepository, X as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, j as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as PendingReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as PendingSubmarineSwap, h as ArkToBtcResponse, a as PendingChainSwap, B as BtcToArkResponse, d as Chain, F as FeesResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, P as PendingSwap } from './types-CEmBBA71.cjs';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
 
 /**
@@ -68,6 +68,13 @@ declare class ArkadeSwaps {
      * Dispose of resources (stops SwapManager and cleans up).
      * Can be called manually or automatically with `await using` syntax (TypeScript 5.2+).
      */
+    /**
+     * Reset all swap state: stops the SwapManager and clears the swap repository.
+     *
+     * **Destructive** — any swap in a non-terminal state will lose its
+     * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+     */
+    reset(): Promise<void>;
     dispose(): Promise<void>;
     /**
      * Symbol.asyncDispose for automatic cleanup with `await using` syntax.
@@ -426,6 +433,13 @@ interface IArkadeSwaps extends AsyncDisposable {
     getSwapStatus(swapId: string): Promise<GetSwapStatusResponse>;
     enrichReverseSwapPreimage(swap: PendingReverseSwap, preimage: string): PendingReverseSwap;
     enrichSubmarineSwapInvoice(swap: PendingSubmarineSwap, invoice: string): PendingSubmarineSwap;
+    /**
+     * Reset all swap state: stops the SwapManager and clears the swap repository.
+     *
+     * **Destructive** — any swap in a non-terminal state will lose its
+     * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+     */
+    reset(): Promise<void>;
     dispose(): Promise<void>;
 }
 

package/dist/{arkade-swaps-DnhnGtTb.d.cts → arkade-swaps-qQuX73sR.d.ts}

@@ -1,5 +1,5 @@
 import { IWallet, ArkProvider, IndexerProvider, ArkInfo, Identity, ArkTxInput, VHTLC } from '@arkade-os/sdk';
-import { l as BoltzSwapProvider, V as SwapManager, i as SwapRepository, X as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, j as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as PendingReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as PendingSubmarineSwap, h as ArkToBtcResponse, a as PendingChainSwap, B as BtcToArkResponse, d as Chain, F as FeesResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, P as PendingSwap } from './types-DCCYGYCD.cjs';
+import { l as BoltzSwapProvider, V as SwapManager, i as SwapRepository, X as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, j as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as PendingReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as PendingSubmarineSwap, h as ArkToBtcResponse, a as PendingChainSwap, B as BtcToArkResponse, d as Chain, F as FeesResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, P as PendingSwap } from './types-CEmBBA71.js';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
 
 /**
@@ -68,6 +68,13 @@ declare class ArkadeSwaps {
      * Dispose of resources (stops SwapManager and cleans up).
      * Can be called manually or automatically with `await using` syntax (TypeScript 5.2+).
      */
+    /**
+     * Reset all swap state: stops the SwapManager and clears the swap repository.
+     *
+     * **Destructive** — any swap in a non-terminal state will lose its
+     * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+     */
+    reset(): Promise<void>;
     dispose(): Promise<void>;
     /**
      * Symbol.asyncDispose for automatic cleanup with `await using` syntax.
@@ -426,6 +433,13 @@ interface IArkadeSwaps extends AsyncDisposable {
     getSwapStatus(swapId: string): Promise<GetSwapStatusResponse>;
     enrichReverseSwapPreimage(swap: PendingReverseSwap, preimage: string): PendingReverseSwap;
     enrichSubmarineSwapInvoice(swap: PendingSubmarineSwap, invoice: string): PendingSubmarineSwap;
+    /**
+     * Reset all swap state: stops the SwapManager and clears the swap repository.
+     *
+     * **Destructive** — any swap in a non-terminal state will lose its
+     * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+     */
+    reset(): Promise<void>;
     dispose(): Promise<void>;
 }
 

package/dist/{background-RLZLTWCI.js → background-VM6FN7TU.js}

@@ -2,8 +2,8 @@ import {
   defineExpoSwapBackgroundTask,
   registerExpoSwapBackgroundTask,
   unregisterExpoSwapBackgroundTask
-} from "./chunk-XUBVFCQZ.js";
-import "./chunk-ZJ2Q5QSA.js";
+} from "./chunk-3XJR3RIH.js";
+import "./chunk-NUR5GPRK.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   defineExpoSwapBackgroundTask,

package/dist/{chunk-XUBVFCQZ.js → chunk-3XJR3RIH.js}

@@ -8,7 +8,7 @@ import {
   isSubmarineFinalStatus,
   isSubmarineSwapRefundable,
   logger
-} from "./chunk-ZJ2Q5QSA.js";
+} from "./chunk-NUR5GPRK.js";
 import {
   __require
 } from "./chunk-3RG5ZIWI.js";

package/dist/{chunk-ZJ2Q5QSA.js → chunk-NUR5GPRK.js}

@@ -865,6 +865,8 @@ var SwapManager = class {
   // All swaps passed to start(), including completed ones
   pollTimer = null;
   reconnectTimer = null;
+  initialPollTimer = null;
+  pollRetryTimers = /* @__PURE__ */ new Map();
   isRunning = false;
   currentReconnectDelay;
   currentPollRetryDelay;
@@ -1048,6 +1050,14 @@ var SwapManager = class {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
+    if (this.initialPollTimer) {
+      clearTimeout(this.initialPollTimer);
+      this.initialPollTimer = null;
+    }
+    for (const timer of this.pollRetryTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.pollRetryTimers.clear();
   }
   /**
    * Set the polling interval (ms).
@@ -1103,6 +1113,11 @@ var SwapManager = class {
   async removeSwap(swapId) {
     this.monitoredSwaps.delete(swapId);
     this.swapSubscriptions.delete(swapId);
+    const retryTimer = this.pollRetryTimers.get(swapId);
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+      this.pollRetryTimers.delete(swapId);
+    }
     logger.log(`Removed swap ${swapId} from monitoring`);
   }
   /**
@@ -1253,12 +1268,25 @@ var SwapManager = class {
         for (const swapId of this.monitoredSwaps.keys()) {
           this.subscribeToSwap(swapId);
         }
-        this.pollAllSwaps();
+        if (this.initialPollTimer) {
+          clearTimeout(this.initialPollTimer);
+          this.initialPollTimer = null;
+        }
+        this.initialPollTimer = setTimeout(() => {
+          this.initialPollTimer = null;
+          if (this.isRunning) {
+            this.pollAllSwaps();
+          }
+        }, 2e3);
         this.startPolling();
         this.wsConnectedListeners.forEach((listener) => listener());
       };
       this.websocket.onclose = () => {
         clearTimeout(connectionTimeout);
+        if (this.initialPollTimer) {
+          clearTimeout(this.initialPollTimer);
+          this.initialPollTimer = null;
+        }
         this.websocket = null;
         if (this.isRunning) {
           this.scheduleReconnect();
@@ -1287,6 +1315,10 @@ var SwapManager = class {
    */
   enterPollingFallback(error) {
     if (!this.isRunning) return;
+    if (this.initialPollTimer) {
+      clearTimeout(this.initialPollTimer);
+      this.initialPollTimer = null;
+    }
     this.isReconnecting = false;
     this.websocket = null;
     this.usePollingFallback = true;
@@ -1388,6 +1420,11 @@ var SwapManager = class {
     if (this.isFinalStatus(swap)) {
       this.monitoredSwaps.delete(swap.id);
       this.swapSubscriptions.delete(swap.id);
+      const retryTimer = this.pollRetryTimers.get(swap.id);
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+        this.pollRetryTimers.delete(swap.id);
+      }
       this.swapCompletedListeners.forEach((listener) => listener(swap));
     }
   }
@@ -1652,7 +1689,37 @@ var SwapManager = class {
             );
           }
         } catch (error) {
-          logger.error(`Failed to poll swap ${swap.id}:`, error);
+          if (error instanceof NetworkError && error.statusCode === 429) {
+            logger.warn(
+              `Rate-limited polling swap ${swap.id}, retrying in 2s`
+            );
+            const existing = this.pollRetryTimers.get(swap.id);
+            if (existing) clearTimeout(existing);
+            this.pollRetryTimers.set(
+              swap.id,
+              setTimeout(async () => {
+                this.pollRetryTimers.delete(swap.id);
+                try {
+                  const retry = await this.swapProvider.getSwapStatus(
+                    swap.id
+                  );
+                  if (retry.status !== swap.status) {
+                    await this.handleSwapStatusUpdate(
+                      swap,
+                      retry.status
+                    );
+                  }
+                } catch (retryError) {
+                  logger.error(
+                    `Retry poll for swap ${swap.id} also failed:`,
+                    retryError
+                  );
+                }
+              }, 2e3)
+            );
+          } else {
+            logger.error(`Failed to poll swap ${swap.id}:`, error);
+          }
         }
       }
     );
@@ -3039,6 +3106,16 @@ var ArkadeSwaps = class _ArkadeSwaps {
    * Dispose of resources (stops SwapManager and cleans up).
    * Can be called manually or automatically with `await using` syntax (TypeScript 5.2+).
    */
+  /**
+   * Reset all swap state: stops the SwapManager and clears the swap repository.
+   *
+   * **Destructive** — any swap in a non-terminal state will lose its
+   * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+   */
+  async reset() {
+    await this.dispose();
+    await this.swapRepository.clear();
+  }
   async dispose() {
     if (this.swapManager) {
       await this.stopSwapManager();
@@ -4409,16 +4486,18 @@ var ArkadeSwaps = class _ArkadeSwaps {
       } else if (isRestoredSubmarineSwap(swap)) {
         const { amount, lockupAddress, serverPublicKey, tree } = swap.refundDetails;
         let preimage = "";
-        try {
-          const data = await this.swapProvider.getSwapPreimage(
-            swap.id
-          );
-          preimage = data.preimage;
-        } catch (error) {
-          logger.warn(
-            `Failed to restore preimage for submarine swap ${id}`,
-            error
-          );
+        if (!isSubmarineFinalStatus(status)) {
+          try {
+            const data = await this.swapProvider.getSwapPreimage(
+              swap.id
+            );
+            preimage = data.preimage;
+          } catch (error) {
+            logger.warn(
+              `Failed to restore preimage for submarine swap ${id}`,
+              error
+            );
+          }
         }
         submarineSwaps.push({
           id,

package/dist/expo/index.cjs

@@ -1277,6 +1277,8 @@ var init_swap_manager = __esm({
       // All swaps passed to start(), including completed ones
       pollTimer = null;
       reconnectTimer = null;
+      initialPollTimer = null;
+      pollRetryTimers = /* @__PURE__ */ new Map();
       isRunning = false;
       currentReconnectDelay;
       currentPollRetryDelay;
@@ -1460,6 +1462,14 @@ var init_swap_manager = __esm({
           clearTimeout(this.reconnectTimer);
           this.reconnectTimer = null;
         }
+        if (this.initialPollTimer) {
+          clearTimeout(this.initialPollTimer);
+          this.initialPollTimer = null;
+        }
+        for (const timer of this.pollRetryTimers.values()) {
+          clearTimeout(timer);
+        }
+        this.pollRetryTimers.clear();
       }
       /**
        * Set the polling interval (ms).
@@ -1515,6 +1525,11 @@ var init_swap_manager = __esm({
       async removeSwap(swapId) {
         this.monitoredSwaps.delete(swapId);
         this.swapSubscriptions.delete(swapId);
+        const retryTimer = this.pollRetryTimers.get(swapId);
+        if (retryTimer) {
+          clearTimeout(retryTimer);
+          this.pollRetryTimers.delete(swapId);
+        }
         logger.log(`Removed swap ${swapId} from monitoring`);
       }
       /**
@@ -1665,12 +1680,25 @@ var init_swap_manager = __esm({
             for (const swapId of this.monitoredSwaps.keys()) {
               this.subscribeToSwap(swapId);
             }
-            this.pollAllSwaps();
+            if (this.initialPollTimer) {
+              clearTimeout(this.initialPollTimer);
+              this.initialPollTimer = null;
+            }
+            this.initialPollTimer = setTimeout(() => {
+              this.initialPollTimer = null;
+              if (this.isRunning) {
+                this.pollAllSwaps();
+              }
+            }, 2e3);
             this.startPolling();
             this.wsConnectedListeners.forEach((listener) => listener());
           };
           this.websocket.onclose = () => {
             clearTimeout(connectionTimeout);
+            if (this.initialPollTimer) {
+              clearTimeout(this.initialPollTimer);
+              this.initialPollTimer = null;
+            }
             this.websocket = null;
             if (this.isRunning) {
               this.scheduleReconnect();
@@ -1699,6 +1727,10 @@ var init_swap_manager = __esm({
        */
       enterPollingFallback(error) {
         if (!this.isRunning) return;
+        if (this.initialPollTimer) {
+          clearTimeout(this.initialPollTimer);
+          this.initialPollTimer = null;
+        }
         this.isReconnecting = false;
         this.websocket = null;
         this.usePollingFallback = true;
@@ -1800,6 +1832,11 @@ var init_swap_manager = __esm({
         if (this.isFinalStatus(swap)) {
           this.monitoredSwaps.delete(swap.id);
           this.swapSubscriptions.delete(swap.id);
+          const retryTimer = this.pollRetryTimers.get(swap.id);
+          if (retryTimer) {
+            clearTimeout(retryTimer);
+            this.pollRetryTimers.delete(swap.id);
+          }
           this.swapCompletedListeners.forEach((listener) => listener(swap));
         }
       }
@@ -2064,7 +2101,37 @@ var init_swap_manager = __esm({
                 );
               }
             } catch (error) {
-              logger.error(`Failed to poll swap ${swap.id}:`, error);
+              if (error instanceof NetworkError && error.statusCode === 429) {
+                logger.warn(
+                  `Rate-limited polling swap ${swap.id}, retrying in 2s`
+                );
+                const existing = this.pollRetryTimers.get(swap.id);
+                if (existing) clearTimeout(existing);
+                this.pollRetryTimers.set(
+                  swap.id,
+                  setTimeout(async () => {
+                    this.pollRetryTimers.delete(swap.id);
+                    try {
+                      const retry = await this.swapProvider.getSwapStatus(
+                        swap.id
+                      );
+                      if (retry.status !== swap.status) {
+                        await this.handleSwapStatusUpdate(
+                          swap,
+                          retry.status
+                        );
+                      }
+                    } catch (retryError) {
+                      logger.error(
+                        `Retry poll for swap ${swap.id} also failed:`,
+                        retryError
+                      );
+                    }
+                  }, 2e3)
+                );
+              } else {
+                logger.error(`Failed to poll swap ${swap.id}:`, error);
+              }
             }
           }
         );
@@ -3044,6 +3111,16 @@ var init_arkade_swaps = __esm({
        * Dispose of resources (stops SwapManager and cleans up).
        * Can be called manually or automatically with `await using` syntax (TypeScript 5.2+).
        */
+      /**
+       * Reset all swap state: stops the SwapManager and clears the swap repository.
+       *
+       * **Destructive** — any swap in a non-terminal state will lose its
+       * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+       */
+      async reset() {
+        await this.dispose();
+        await this.swapRepository.clear();
+      }
       async dispose() {
         if (this.swapManager) {
           await this.stopSwapManager();
@@ -4414,16 +4491,18 @@ var init_arkade_swaps = __esm({
           } else if (isRestoredSubmarineSwap(swap)) {
             const { amount, lockupAddress, serverPublicKey, tree } = swap.refundDetails;
             let preimage = "";
-            try {
-              const data = await this.swapProvider.getSwapPreimage(
-                swap.id
-              );
-              preimage = data.preimage;
-            } catch (error) {
-              logger.warn(
-                `Failed to restore preimage for submarine swap ${id}`,
-                error
-              );
+            if (!isSubmarineFinalStatus(status)) {
+              try {
+                const data = await this.swapProvider.getSwapPreimage(
+                  swap.id
+                );
+                preimage = data.preimage;
+              } catch (error) {
+                logger.warn(
+                  `Failed to restore preimage for submarine swap ${id}`,
+                  error
+                );
+              }
             }
             submarineSwaps.push({
               id,
@@ -4887,6 +4966,16 @@ var ExpoArkadeSwaps = class _ExpoArkadeSwaps {
     await taskQueue.addTask(task);
   }
   // ── Lifecycle ────────────────────────────────────────────────────
+  /**
+   * Reset all swap state: stops polling and clears the swap repository.
+   *
+   * **Destructive** — any swap in a non-terminal state will lose its
+   * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+   */
+  async reset() {
+    await this.dispose();
+    await this.inner.swapRepository.clear();
+  }
   async dispose() {
     if (this.foregroundIntervalId) {
       clearInterval(this.foregroundIntervalId);

package/dist/expo/index.d.cts

@@ -1,5 +1,5 @@
-import { I as IArkadeSwaps, A as ArkadeSwaps } from '../arkade-swaps-DnhnGtTb.cjs';
-import { A as ArkadeSwapsConfig, i as SwapRepository, l as BoltzSwapProvider, N as Network, j as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as PendingSubmarineSwap, b as PendingReverseSwap, F as FeesResponse, a as PendingChainSwap, h as ArkToBtcResponse, B as BtcToArkResponse, d as Chain, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, P as PendingSwap } from '../types-DCCYGYCD.cjs';
+import { I as IArkadeSwaps, A as ArkadeSwaps } from '../arkade-swaps--vc0H2oD.cjs';
+import { A as ArkadeSwapsConfig, i as SwapRepository, l as BoltzSwapProvider, N as Network, j as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as PendingSubmarineSwap, b as PendingReverseSwap, F as FeesResponse, a as PendingChainSwap, h as ArkToBtcResponse, B as BtcToArkResponse, d as Chain, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, P as PendingSwap } from '../types-CEmBBA71.cjs';
 import { Identity, ArkProvider, IndexerProvider, IWallet, ArkInfo, ArkTxInput, VHTLC } from '@arkade-os/sdk';
 import { AsyncStorageTaskQueue, TaskProcessor } from '@arkade-os/sdk/worker/expo';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
@@ -124,6 +124,13 @@ declare class ExpoArkadeSwaps implements IArkadeSwaps {
     private startForegroundPolling;
     private runForegroundPoll;
     private seedSwapPollTask;
+    /**
+     * Reset all swap state: stops polling and clears the swap repository.
+     *
+     * **Destructive** — any swap in a non-terminal state will lose its
+     * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+     */
+    reset(): Promise<void>;
     dispose(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
     startSwapManager(): Promise<void>;

package/dist/expo/index.d.ts

@@ -1,5 +1,5 @@
-import { I as IArkadeSwaps, A as ArkadeSwaps } from '../arkade-swaps-MmMjdK2G.js';
-import { A as ArkadeSwapsConfig, i as SwapRepository, l as BoltzSwapProvider, N as Network, j as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as PendingSubmarineSwap, b as PendingReverseSwap, F as FeesResponse, a as PendingChainSwap, h as ArkToBtcResponse, B as BtcToArkResponse, d as Chain, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, P as PendingSwap } from '../types-DCCYGYCD.js';
+import { I as IArkadeSwaps, A as ArkadeSwaps } from '../arkade-swaps-qQuX73sR.js';
+import { A as ArkadeSwapsConfig, i as SwapRepository, l as BoltzSwapProvider, N as Network, j as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as PendingSubmarineSwap, b as PendingReverseSwap, F as FeesResponse, a as PendingChainSwap, h as ArkToBtcResponse, B as BtcToArkResponse, d as Chain, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, P as PendingSwap } from '../types-CEmBBA71.js';
 import { Identity, ArkProvider, IndexerProvider, IWallet, ArkInfo, ArkTxInput, VHTLC } from '@arkade-os/sdk';
 import { AsyncStorageTaskQueue, TaskProcessor } from '@arkade-os/sdk/worker/expo';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
@@ -124,6 +124,13 @@ declare class ExpoArkadeSwaps implements IArkadeSwaps {
     private startForegroundPolling;
     private runForegroundPoll;
     private seedSwapPollTask;
+    /**
+     * Reset all swap state: stops polling and clears the swap repository.
+     *
+     * **Destructive** — any swap in a non-terminal state will lose its
+     * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+     */
+    reset(): Promise<void>;
     dispose(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
     startSwapManager(): Promise<void>;

package/dist/expo/index.js

@@ -4,10 +4,10 @@ import {
   registerExpoSwapBackgroundTask,
   swapsPollProcessor,
   unregisterExpoSwapBackgroundTask
-} from "../chunk-XUBVFCQZ.js";
+} from "../chunk-3XJR3RIH.js";
 import {
   ArkadeSwaps
-} from "../chunk-ZJ2Q5QSA.js";
+} from "../chunk-NUR5GPRK.js";
 import "../chunk-3RG5ZIWI.js";
 
 // src/expo/arkade-lightning.ts
@@ -56,7 +56,7 @@ var ExpoArkadeSwaps = class _ExpoArkadeSwaps {
     await instance.seedSwapPollTask();
     if (config.background.minimumBackgroundInterval) {
       try {
-        const { registerExpoSwapBackgroundTask: registerExpoSwapBackgroundTask2 } = await import("../background-RLZLTWCI.js");
+        const { registerExpoSwapBackgroundTask: registerExpoSwapBackgroundTask2 } = await import("../background-VM6FN7TU.js");
         await registerExpoSwapBackgroundTask2(
           config.background.taskName,
           {
@@ -112,6 +112,16 @@ var ExpoArkadeSwaps = class _ExpoArkadeSwaps {
     await taskQueue.addTask(task);
   }
   // ── Lifecycle ────────────────────────────────────────────────────
+  /**
+   * Reset all swap state: stops polling and clears the swap repository.
+   *
+   * **Destructive** — any swap in a non-terminal state will lose its
+   * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+   */
+  async reset() {
+    await this.dispose();
+    await this.inner.swapRepository.clear();
+  }
   async dispose() {
     if (this.foregroundIntervalId) {
       clearInterval(this.foregroundIntervalId);
@@ -119,7 +129,7 @@ var ExpoArkadeSwaps = class _ExpoArkadeSwaps {
     }
     await this.inner.dispose();
     try {
-      const { unregisterExpoSwapBackgroundTask: unregisterExpoSwapBackgroundTask2 } = await import("../background-RLZLTWCI.js");
+      const { unregisterExpoSwapBackgroundTask: unregisterExpoSwapBackgroundTask2 } = await import("../background-VM6FN7TU.js");
       await unregisterExpoSwapBackgroundTask2(this.taskName);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);

package/dist/index.cjs

@@ -1383,6 +1383,8 @@ var SwapManager = class {
   // All swaps passed to start(), including completed ones
   pollTimer = null;
   reconnectTimer = null;
+  initialPollTimer = null;
+  pollRetryTimers = /* @__PURE__ */ new Map();
   isRunning = false;
   currentReconnectDelay;
   currentPollRetryDelay;
@@ -1566,6 +1568,14 @@ var SwapManager = class {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
+    if (this.initialPollTimer) {
+      clearTimeout(this.initialPollTimer);
+      this.initialPollTimer = null;
+    }
+    for (const timer of this.pollRetryTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.pollRetryTimers.clear();
   }
   /**
    * Set the polling interval (ms).
@@ -1621,6 +1631,11 @@ var SwapManager = class {
   async removeSwap(swapId) {
     this.monitoredSwaps.delete(swapId);
     this.swapSubscriptions.delete(swapId);
+    const retryTimer = this.pollRetryTimers.get(swapId);
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+      this.pollRetryTimers.delete(swapId);
+    }
     logger.log(`Removed swap ${swapId} from monitoring`);
   }
   /**
@@ -1771,12 +1786,25 @@ var SwapManager = class {
         for (const swapId of this.monitoredSwaps.keys()) {
           this.subscribeToSwap(swapId);
         }
-        this.pollAllSwaps();
+        if (this.initialPollTimer) {
+          clearTimeout(this.initialPollTimer);
+          this.initialPollTimer = null;
+        }
+        this.initialPollTimer = setTimeout(() => {
+          this.initialPollTimer = null;
+          if (this.isRunning) {
+            this.pollAllSwaps();
+          }
+        }, 2e3);
         this.startPolling();
         this.wsConnectedListeners.forEach((listener) => listener());
       };
       this.websocket.onclose = () => {
         clearTimeout(connectionTimeout);
+        if (this.initialPollTimer) {
+          clearTimeout(this.initialPollTimer);
+          this.initialPollTimer = null;
+        }
         this.websocket = null;
         if (this.isRunning) {
           this.scheduleReconnect();
@@ -1805,6 +1833,10 @@ var SwapManager = class {
    */
   enterPollingFallback(error) {
     if (!this.isRunning) return;
+    if (this.initialPollTimer) {
+      clearTimeout(this.initialPollTimer);
+      this.initialPollTimer = null;
+    }
     this.isReconnecting = false;
     this.websocket = null;
     this.usePollingFallback = true;
@@ -1906,6 +1938,11 @@ var SwapManager = class {
     if (this.isFinalStatus(swap)) {
       this.monitoredSwaps.delete(swap.id);
       this.swapSubscriptions.delete(swap.id);
+      const retryTimer = this.pollRetryTimers.get(swap.id);
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+        this.pollRetryTimers.delete(swap.id);
+      }
       this.swapCompletedListeners.forEach((listener) => listener(swap));
     }
   }
@@ -2170,7 +2207,37 @@ var SwapManager = class {
             );
           }
         } catch (error) {
-          logger.error(`Failed to poll swap ${swap.id}:`, error);
+          if (error instanceof NetworkError && error.statusCode === 429) {
+            logger.warn(
+              `Rate-limited polling swap ${swap.id}, retrying in 2s`
+            );
+            const existing = this.pollRetryTimers.get(swap.id);
+            if (existing) clearTimeout(existing);
+            this.pollRetryTimers.set(
+              swap.id,
+              setTimeout(async () => {
+                this.pollRetryTimers.delete(swap.id);
+                try {
+                  const retry = await this.swapProvider.getSwapStatus(
+                    swap.id
+                  );
+                  if (retry.status !== swap.status) {
+                    await this.handleSwapStatusUpdate(
+                      swap,
+                      retry.status
+                    );
+                  }
+                } catch (retryError) {
+                  logger.error(
+                    `Retry poll for swap ${swap.id} also failed:`,
+                    retryError
+                  );
+                }
+              }, 2e3)
+            );
+          } else {
+            logger.error(`Failed to poll swap ${swap.id}:`, error);
+          }
         }
       }
     );
@@ -3098,6 +3165,16 @@ var ArkadeSwaps = class _ArkadeSwaps {
    * Dispose of resources (stops SwapManager and cleans up).
    * Can be called manually or automatically with `await using` syntax (TypeScript 5.2+).
    */
+  /**
+   * Reset all swap state: stops the SwapManager and clears the swap repository.
+   *
+   * **Destructive** — any swap in a non-terminal state will lose its
+   * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+   */
+  async reset() {
+    await this.dispose();
+    await this.swapRepository.clear();
+  }
   async dispose() {
     if (this.swapManager) {
       await this.stopSwapManager();
@@ -4468,16 +4545,18 @@ var ArkadeSwaps = class _ArkadeSwaps {
       } else if (isRestoredSubmarineSwap(swap)) {
         const { amount, lockupAddress, serverPublicKey, tree } = swap.refundDetails;
         let preimage = "";
-        try {
-          const data = await this.swapProvider.getSwapPreimage(
-            swap.id
-          );
-          preimage = data.preimage;
-        } catch (error) {
-          logger.warn(
-            `Failed to restore preimage for submarine swap ${id}`,
-            error
-          );
+        if (!isSubmarineFinalStatus(status)) {
+          try {
+            const data = await this.swapProvider.getSwapPreimage(
+              swap.id
+            );
+            preimage = data.preimage;
+          } catch (error) {
+            logger.warn(
+              `Failed to restore preimage for submarine swap ${id}`,
+              error
+            );
+          }
         }
         submarineSwaps.push({
           id,
@@ -5036,6 +5115,28 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
 };
 
 // src/serviceWorker/arkade-swaps-runtime.ts
+var import_sdk10 = require("@arkade-os/sdk");
+function isMessageBusNotInitializedError(error) {
+  return error instanceof Error && error.message.includes(import_sdk10.MESSAGE_BUS_NOT_INITIALIZED);
+}
+var DEDUPABLE_REQUEST_TYPES = /* @__PURE__ */ new Set([
+  "GET_FEES",
+  "GET_LIMITS",
+  "GET_SWAP_STATUS",
+  "GET_PENDING_SUBMARINE_SWAPS",
+  "GET_PENDING_REVERSE_SWAPS",
+  "GET_PENDING_CHAIN_SWAPS",
+  "GET_SWAP_HISTORY",
+  "QUOTE_SWAP",
+  "SM-GET_PENDING_SWAPS",
+  "SM-HAS_SWAP",
+  "SM-IS_PROCESSING",
+  "SM-GET_STATS"
+]);
+function getRequestDedupKey(request) {
+  const { id, tag, ...rest } = request;
+  return JSON.stringify(rest);
+}
 var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   constructor(messageTag, serviceWorker, swapRepository, withSwapManager) {
     this.messageTag = messageTag;
@@ -5050,6 +5151,10 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   actionExecutedListeners = /* @__PURE__ */ new Set();
   wsConnectedListeners = /* @__PURE__ */ new Set();
   wsDisconnectedListeners = /* @__PURE__ */ new Set();
+  initPayload = null;
+  reinitPromise = null;
+  pingPromise = null;
+  inflightRequests = /* @__PURE__ */ new Map();
   static async create(config) {
     const messageTag = config.messageTag ?? DEFAULT_MESSAGE_TAG;
     const swapRepository = config.swapRepository ?? new IndexedDbSwapRepository();
@@ -5059,18 +5164,20 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       swapRepository,
       Boolean(config.swapManager)
     );
+    const initPayload = {
+      network: config.network,
+      arkServerUrl: config.arkServerUrl,
+      swapProvider: { baseUrl: config.swapProvider.getApiUrl() },
+      swapManager: config.swapManager
+    };
     const initMessage = {
       tag: messageTag,
       id: getRandomId(),
       type: "INIT_ARKADE_SWAPS",
-      payload: {
-        network: config.network,
-        arkServerUrl: config.arkServerUrl,
-        swapProvider: { baseUrl: config.swapProvider.getApiUrl() },
-        swapManager: config.swapManager
-      }
+      payload: initPayload
     };
     await svcArkadeSwaps.sendMessage(initMessage);
+    svcArkadeSwaps.initPayload = initPayload;
     return svcArkadeSwaps;
   }
   async startSwapManager() {
@@ -5602,6 +5709,16 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       type: "REFRESH_SWAPS_STATUS"
     });
   }
+  /**
+   * Reset all swap state: stops the SwapManager and clears the swap repository.
+   *
+   * **Destructive** — any swap in a non-terminal state will lose its
+   * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+   */
+  async reset() {
+    await this.dispose();
+    await this.swapRepository.clear();
+  }
   async dispose() {
     if (this.withSwapManager) {
       await this.stopSwapManager().catch(() => {
@@ -5611,17 +5728,23 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async [Symbol.asyncDispose]() {
     return this.dispose();
   }
-  async sendMessage(request) {
+  sendMessageDirect(request) {
     return new Promise((resolve, reject) => {
-      const timeoutMs = 3e4;
-      let timeout;
       const cleanup = () => {
-        if (timeout) clearTimeout(timeout);
+        clearTimeout(timeoutId);
         navigator.serviceWorker.removeEventListener(
           "message",
           messageHandler
         );
       };
+      const timeoutId = setTimeout(() => {
+        cleanup();
+        reject(
+          new import_sdk10.ServiceWorkerTimeoutError(
+            `Service worker message timed out (${request.type})`
+          )
+        );
+      }, 3e4);
       const messageHandler = (event) => {
         const response = event.data;
         if (!response || response.tag !== this.messageTag || response.id !== request.id) {
@@ -5634,17 +5757,97 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
           resolve(response);
         }
       };
-      timeout = setTimeout(() => {
+      navigator.serviceWorker.addEventListener("message", messageHandler);
+      this.serviceWorker.postMessage(request);
+    });
+  }
+  async sendMessage(request) {
+    if (!DEDUPABLE_REQUEST_TYPES.has(request.type)) {
+      return this.sendMessageWithRetry(request);
+    }
+    const key = getRequestDedupKey(request);
+    const existing = this.inflightRequests.get(key);
+    if (existing) return existing;
+    const promise = this.sendMessageWithRetry(request).finally(() => {
+      this.inflightRequests.delete(key);
+    });
+    this.inflightRequests.set(key, promise);
+    return promise;
+  }
+  pingServiceWorker() {
+    if (this.pingPromise) return this.pingPromise;
+    this.pingPromise = new Promise((resolve, reject) => {
+      const pingId = getRandomId();
+      const cleanup = () => {
+        clearTimeout(timeoutId);
+        navigator.serviceWorker.removeEventListener(
+          "message",
+          onMessage
+        );
+      };
+      const timeoutId = setTimeout(() => {
         cleanup();
         reject(
-          new Error(
-            `Timed out waiting for service worker response: ${request.type}`
+          new import_sdk10.ServiceWorkerTimeoutError(
+            "Service worker ping timed out"
           )
         );
-      }, timeoutMs);
-      navigator.serviceWorker.addEventListener("message", messageHandler);
-      this.serviceWorker.postMessage(request);
+      }, 2e3);
+      const onMessage = (event) => {
+        if (event.data?.id === pingId && event.data?.tag === "PONG") {
+          cleanup();
+          resolve();
+        }
+      };
+      navigator.serviceWorker.addEventListener("message", onMessage);
+      this.serviceWorker.postMessage({
+        id: pingId,
+        tag: "PING"
+      });
+    }).finally(() => {
+      this.pingPromise = null;
+    });
+    return this.pingPromise;
+  }
+  // Send a message, retrying up to 2 times if the service worker was
+  // killed and restarted by the OS (mobile browsers do this aggressively).
+  async sendMessageWithRetry(request) {
+    if (this.initPayload) {
+      try {
+        await this.pingServiceWorker();
+      } catch {
+        await this.reinitialize();
+      }
+    }
+    const maxRetries = 2;
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await this.sendMessageDirect(request);
+      } catch (error) {
+        if (!isMessageBusNotInitializedError(error) || attempt >= maxRetries) {
+          throw error;
+        }
+        await this.reinitialize();
+      }
+    }
+  }
+  async reinitialize() {
+    if (this.reinitPromise) return this.reinitPromise;
+    this.reinitPromise = (async () => {
+      if (!this.initPayload) {
+        throw new Error("Cannot re-initialize: missing configuration");
+      }
+      const initMessage = {
+        tag: this.messageTag,
+        type: "INIT_ARKADE_SWAPS",
+        id: getRandomId(),
+        payload: this.initPayload
+      };
+      await this.sendMessageDirect(initMessage);
+    })().finally(() => {
+      this.reinitPromise = null;
     });
+    return this.reinitPromise;
   }
   initEventStream() {
     if (this.eventListenerInitialized) return;

package/dist/index.d.cts

@@ -1,7 +1,7 @@
-import { I as IArkadeSwaps } from './arkade-swaps-DnhnGtTb.cjs';
-export { A as ArkadeSwaps } from './arkade-swaps-DnhnGtTb.cjs';
-import { P as PendingSwap, D as DecodedInvoice, a as PendingChainSwap, b as PendingReverseSwap, c as PendingSubmarineSwap, A as ArkadeSwapsConfig, N as Network, C as CreateLightningInvoiceRequest, S as SendLightningPaymentRequest, F as FeesResponse, d as Chain, e as CreateLightningInvoiceResponse, f as SendLightningPaymentResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, h as ArkToBtcResponse, B as BtcToArkResponse, i as SwapRepository, j as SwapManagerClient, k as GetSwapsFilter } from './types-DCCYGYCD.cjs';
-export { X as ArkadeSwapsCreateConfig, l as BoltzSwapProvider, m as BoltzSwapStatus, W as IncomingPaymentSubscription, V as SwapManager, $ as SwapManagerCallbacks, Z as SwapManagerConfig, _ as SwapManagerEvents, Y as Vtxo, n as isChainClaimableStatus, o as isChainFailedStatus, p as isChainFinalStatus, q as isChainPendingStatus, r as isChainRefundableStatus, s as isChainSignableStatus, t as isChainSuccessStatus, u as isChainSwapClaimable, v as isChainSwapRefundable, w as isPendingChainSwap, x as isPendingReverseSwap, y as isPendingSubmarineSwap, z as isReverseClaimableStatus, E as isReverseFailedStatus, H as isReverseFinalStatus, I as isReversePendingStatus, J as isReverseSuccessStatus, K as isReverseSwapClaimable, M as isSubmarineFailedStatus, O as isSubmarineFinalStatus, Q as isSubmarinePendingStatus, T as isSubmarineRefundableStatus, R as isSubmarineSuccessStatus, U as isSubmarineSwapRefundable } from './types-DCCYGYCD.cjs';
+import { I as IArkadeSwaps } from './arkade-swaps--vc0H2oD.cjs';
+export { A as ArkadeSwaps } from './arkade-swaps--vc0H2oD.cjs';
+import { P as PendingSwap, D as DecodedInvoice, a as PendingChainSwap, b as PendingReverseSwap, c as PendingSubmarineSwap, A as ArkadeSwapsConfig, N as Network, C as CreateLightningInvoiceRequest, S as SendLightningPaymentRequest, F as FeesResponse, d as Chain, e as CreateLightningInvoiceResponse, f as SendLightningPaymentResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, h as ArkToBtcResponse, B as BtcToArkResponse, i as SwapRepository, j as SwapManagerClient, k as GetSwapsFilter } from './types-CEmBBA71.cjs';
+export { X as ArkadeSwapsCreateConfig, l as BoltzSwapProvider, m as BoltzSwapStatus, W as IncomingPaymentSubscription, V as SwapManager, $ as SwapManagerCallbacks, Z as SwapManagerConfig, _ as SwapManagerEvents, Y as Vtxo, n as isChainClaimableStatus, o as isChainFailedStatus, p as isChainFinalStatus, q as isChainPendingStatus, r as isChainRefundableStatus, s as isChainSignableStatus, t as isChainSuccessStatus, u as isChainSwapClaimable, v as isChainSwapRefundable, w as isPendingChainSwap, x as isPendingReverseSwap, y as isPendingSubmarineSwap, z as isReverseClaimableStatus, E as isReverseFailedStatus, H as isReverseFinalStatus, I as isReversePendingStatus, J as isReverseSuccessStatus, K as isReverseSwapClaimable, M as isSubmarineFailedStatus, O as isSubmarineFinalStatus, Q as isSubmarinePendingStatus, T as isSubmarineRefundableStatus, R as isSubmarineSuccessStatus, U as isSubmarineSwapRefundable } from './types-CEmBBA71.cjs';
 import { Transaction } from '@scure/btc-signer';
 import { MessageHandler, RequestEnvelope, ArkInfo, ResponseEnvelope, IWallet, IReadonlyWallet, VHTLC, Identity, ArkTxInput } from '@arkade-os/sdk';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
@@ -562,6 +562,10 @@ declare class ServiceWorkerArkadeSwaps implements IArkadeSwaps {
     private actionExecutedListeners;
     private wsConnectedListeners;
     private wsDisconnectedListeners;
+    private initPayload;
+    private reinitPromise;
+    private pingPromise;
+    private inflightRequests;
     private constructor();
     static create(config: SvcWrkArkadeSwapsConfig): Promise<ServiceWorkerArkadeSwaps>;
     startSwapManager(): Promise<void>;
@@ -652,9 +656,20 @@ declare class ServiceWorkerArkadeSwaps implements IArkadeSwaps {
     getPendingChainSwaps(): Promise<PendingChainSwap[]>;
     getSwapHistory(): Promise<(PendingReverseSwap | PendingSubmarineSwap | PendingChainSwap)[]>;
     refreshSwapsStatus(): Promise<void>;
+    /**
+     * Reset all swap state: stops the SwapManager and clears the swap repository.
+     *
+     * **Destructive** — any swap in a non-terminal state will lose its
+     * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+     */
+    reset(): Promise<void>;
     dispose(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
+    private sendMessageDirect;
     private sendMessage;
+    private pingServiceWorker;
+    private sendMessageWithRetry;
+    private reinitialize;
     private initEventStream;
     private handleEventMessage;
 }

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { I as IArkadeSwaps } from './arkade-swaps-MmMjdK2G.js';
-export { A as ArkadeSwaps } from './arkade-swaps-MmMjdK2G.js';
-import { P as PendingSwap, D as DecodedInvoice, a as PendingChainSwap, b as PendingReverseSwap, c as PendingSubmarineSwap, A as ArkadeSwapsConfig, N as Network, C as CreateLightningInvoiceRequest, S as SendLightningPaymentRequest, F as FeesResponse, d as Chain, e as CreateLightningInvoiceResponse, f as SendLightningPaymentResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, h as ArkToBtcResponse, B as BtcToArkResponse, i as SwapRepository, j as SwapManagerClient, k as GetSwapsFilter } from './types-DCCYGYCD.js';
-export { X as ArkadeSwapsCreateConfig, l as BoltzSwapProvider, m as BoltzSwapStatus, W as IncomingPaymentSubscription, V as SwapManager, $ as SwapManagerCallbacks, Z as SwapManagerConfig, _ as SwapManagerEvents, Y as Vtxo, n as isChainClaimableStatus, o as isChainFailedStatus, p as isChainFinalStatus, q as isChainPendingStatus, r as isChainRefundableStatus, s as isChainSignableStatus, t as isChainSuccessStatus, u as isChainSwapClaimable, v as isChainSwapRefundable, w as isPendingChainSwap, x as isPendingReverseSwap, y as isPendingSubmarineSwap, z as isReverseClaimableStatus, E as isReverseFailedStatus, H as isReverseFinalStatus, I as isReversePendingStatus, J as isReverseSuccessStatus, K as isReverseSwapClaimable, M as isSubmarineFailedStatus, O as isSubmarineFinalStatus, Q as isSubmarinePendingStatus, T as isSubmarineRefundableStatus, R as isSubmarineSuccessStatus, U as isSubmarineSwapRefundable } from './types-DCCYGYCD.js';
+import { I as IArkadeSwaps } from './arkade-swaps-qQuX73sR.js';
+export { A as ArkadeSwaps } from './arkade-swaps-qQuX73sR.js';
+import { P as PendingSwap, D as DecodedInvoice, a as PendingChainSwap, b as PendingReverseSwap, c as PendingSubmarineSwap, A as ArkadeSwapsConfig, N as Network, C as CreateLightningInvoiceRequest, S as SendLightningPaymentRequest, F as FeesResponse, d as Chain, e as CreateLightningInvoiceResponse, f as SendLightningPaymentResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, h as ArkToBtcResponse, B as BtcToArkResponse, i as SwapRepository, j as SwapManagerClient, k as GetSwapsFilter } from './types-CEmBBA71.js';
+export { X as ArkadeSwapsCreateConfig, l as BoltzSwapProvider, m as BoltzSwapStatus, W as IncomingPaymentSubscription, V as SwapManager, $ as SwapManagerCallbacks, Z as SwapManagerConfig, _ as SwapManagerEvents, Y as Vtxo, n as isChainClaimableStatus, o as isChainFailedStatus, p as isChainFinalStatus, q as isChainPendingStatus, r as isChainRefundableStatus, s as isChainSignableStatus, t as isChainSuccessStatus, u as isChainSwapClaimable, v as isChainSwapRefundable, w as isPendingChainSwap, x as isPendingReverseSwap, y as isPendingSubmarineSwap, z as isReverseClaimableStatus, E as isReverseFailedStatus, H as isReverseFinalStatus, I as isReversePendingStatus, J as isReverseSuccessStatus, K as isReverseSwapClaimable, M as isSubmarineFailedStatus, O as isSubmarineFinalStatus, Q as isSubmarinePendingStatus, T as isSubmarineRefundableStatus, R as isSubmarineSuccessStatus, U as isSubmarineSwapRefundable } from './types-CEmBBA71.js';
 import { Transaction } from '@scure/btc-signer';
 import { MessageHandler, RequestEnvelope, ArkInfo, ResponseEnvelope, IWallet, IReadonlyWallet, VHTLC, Identity, ArkTxInput } from '@arkade-os/sdk';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
@@ -562,6 +562,10 @@ declare class ServiceWorkerArkadeSwaps implements IArkadeSwaps {
     private actionExecutedListeners;
     private wsConnectedListeners;
     private wsDisconnectedListeners;
+    private initPayload;
+    private reinitPromise;
+    private pingPromise;
+    private inflightRequests;
     private constructor();
     static create(config: SvcWrkArkadeSwapsConfig): Promise<ServiceWorkerArkadeSwaps>;
     startSwapManager(): Promise<void>;
@@ -652,9 +656,20 @@ declare class ServiceWorkerArkadeSwaps implements IArkadeSwaps {
     getPendingChainSwaps(): Promise<PendingChainSwap[]>;
     getSwapHistory(): Promise<(PendingReverseSwap | PendingSubmarineSwap | PendingChainSwap)[]>;
     refreshSwapsStatus(): Promise<void>;
+    /**
+     * Reset all swap state: stops the SwapManager and clears the swap repository.
+     *
+     * **Destructive** — any swap in a non-terminal state will lose its
+     * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+     */
+    reset(): Promise<void>;
     dispose(): Promise<void>;
     [Symbol.asyncDispose](): Promise<void>;
+    private sendMessageDirect;
     private sendMessage;
+    private pingServiceWorker;
+    private sendMessageWithRetry;
+    private reinitialize;
     private initEventStream;
     private handleEventMessage;
 }

package/dist/index.js

@@ -49,7 +49,7 @@ import {
   updateReverseSwapStatus,
   updateSubmarineSwapStatus,
   verifySignatures
-} from "./chunk-ZJ2Q5QSA.js";
+} from "./chunk-NUR5GPRK.js";
 import "./chunk-3RG5ZIWI.js";
 
 // src/serviceWorker/arkade-swaps-message-handler.ts
@@ -526,6 +526,31 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
 };
 
 // src/serviceWorker/arkade-swaps-runtime.ts
+import {
+  MESSAGE_BUS_NOT_INITIALIZED,
+  ServiceWorkerTimeoutError
+} from "@arkade-os/sdk";
+function isMessageBusNotInitializedError(error) {
+  return error instanceof Error && error.message.includes(MESSAGE_BUS_NOT_INITIALIZED);
+}
+var DEDUPABLE_REQUEST_TYPES = /* @__PURE__ */ new Set([
+  "GET_FEES",
+  "GET_LIMITS",
+  "GET_SWAP_STATUS",
+  "GET_PENDING_SUBMARINE_SWAPS",
+  "GET_PENDING_REVERSE_SWAPS",
+  "GET_PENDING_CHAIN_SWAPS",
+  "GET_SWAP_HISTORY",
+  "QUOTE_SWAP",
+  "SM-GET_PENDING_SWAPS",
+  "SM-HAS_SWAP",
+  "SM-IS_PROCESSING",
+  "SM-GET_STATS"
+]);
+function getRequestDedupKey(request) {
+  const { id, tag, ...rest } = request;
+  return JSON.stringify(rest);
+}
 var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   constructor(messageTag, serviceWorker, swapRepository, withSwapManager) {
     this.messageTag = messageTag;
@@ -540,6 +565,10 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   actionExecutedListeners = /* @__PURE__ */ new Set();
   wsConnectedListeners = /* @__PURE__ */ new Set();
   wsDisconnectedListeners = /* @__PURE__ */ new Set();
+  initPayload = null;
+  reinitPromise = null;
+  pingPromise = null;
+  inflightRequests = /* @__PURE__ */ new Map();
   static async create(config) {
     const messageTag = config.messageTag ?? DEFAULT_MESSAGE_TAG;
     const swapRepository = config.swapRepository ?? new IndexedDbSwapRepository();
@@ -549,18 +578,20 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       swapRepository,
       Boolean(config.swapManager)
     );
+    const initPayload = {
+      network: config.network,
+      arkServerUrl: config.arkServerUrl,
+      swapProvider: { baseUrl: config.swapProvider.getApiUrl() },
+      swapManager: config.swapManager
+    };
     const initMessage = {
       tag: messageTag,
       id: getRandomId(),
       type: "INIT_ARKADE_SWAPS",
-      payload: {
-        network: config.network,
-        arkServerUrl: config.arkServerUrl,
-        swapProvider: { baseUrl: config.swapProvider.getApiUrl() },
-        swapManager: config.swapManager
-      }
+      payload: initPayload
     };
     await svcArkadeSwaps.sendMessage(initMessage);
+    svcArkadeSwaps.initPayload = initPayload;
     return svcArkadeSwaps;
   }
   async startSwapManager() {
@@ -1092,6 +1123,16 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       type: "REFRESH_SWAPS_STATUS"
     });
   }
+  /**
+   * Reset all swap state: stops the SwapManager and clears the swap repository.
+   *
+   * **Destructive** — any swap in a non-terminal state will lose its
+   * refund/claim path. Intended for wallet-reset / dev / test scenarios only.
+   */
+  async reset() {
+    await this.dispose();
+    await this.swapRepository.clear();
+  }
   async dispose() {
     if (this.withSwapManager) {
       await this.stopSwapManager().catch(() => {
@@ -1101,17 +1142,23 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async [Symbol.asyncDispose]() {
     return this.dispose();
   }
-  async sendMessage(request) {
+  sendMessageDirect(request) {
     return new Promise((resolve, reject) => {
-      const timeoutMs = 3e4;
-      let timeout;
       const cleanup = () => {
-        if (timeout) clearTimeout(timeout);
+        clearTimeout(timeoutId);
         navigator.serviceWorker.removeEventListener(
           "message",
           messageHandler
         );
       };
+      const timeoutId = setTimeout(() => {
+        cleanup();
+        reject(
+          new ServiceWorkerTimeoutError(
+            `Service worker message timed out (${request.type})`
+          )
+        );
+      }, 3e4);
       const messageHandler = (event) => {
         const response = event.data;
         if (!response || response.tag !== this.messageTag || response.id !== request.id) {
@@ -1124,17 +1171,97 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
           resolve(response);
         }
       };
-      timeout = setTimeout(() => {
+      navigator.serviceWorker.addEventListener("message", messageHandler);
+      this.serviceWorker.postMessage(request);
+    });
+  }
+  async sendMessage(request) {
+    if (!DEDUPABLE_REQUEST_TYPES.has(request.type)) {
+      return this.sendMessageWithRetry(request);
+    }
+    const key = getRequestDedupKey(request);
+    const existing = this.inflightRequests.get(key);
+    if (existing) return existing;
+    const promise = this.sendMessageWithRetry(request).finally(() => {
+      this.inflightRequests.delete(key);
+    });
+    this.inflightRequests.set(key, promise);
+    return promise;
+  }
+  pingServiceWorker() {
+    if (this.pingPromise) return this.pingPromise;
+    this.pingPromise = new Promise((resolve, reject) => {
+      const pingId = getRandomId();
+      const cleanup = () => {
+        clearTimeout(timeoutId);
+        navigator.serviceWorker.removeEventListener(
+          "message",
+          onMessage
+        );
+      };
+      const timeoutId = setTimeout(() => {
         cleanup();
         reject(
-          new Error(
-            `Timed out waiting for service worker response: ${request.type}`
+          new ServiceWorkerTimeoutError(
+            "Service worker ping timed out"
           )
         );
-      }, timeoutMs);
-      navigator.serviceWorker.addEventListener("message", messageHandler);
-      this.serviceWorker.postMessage(request);
+      }, 2e3);
+      const onMessage = (event) => {
+        if (event.data?.id === pingId && event.data?.tag === "PONG") {
+          cleanup();
+          resolve();
+        }
+      };
+      navigator.serviceWorker.addEventListener("message", onMessage);
+      this.serviceWorker.postMessage({
+        id: pingId,
+        tag: "PING"
+      });
+    }).finally(() => {
+      this.pingPromise = null;
+    });
+    return this.pingPromise;
+  }
+  // Send a message, retrying up to 2 times if the service worker was
+  // killed and restarted by the OS (mobile browsers do this aggressively).
+  async sendMessageWithRetry(request) {
+    if (this.initPayload) {
+      try {
+        await this.pingServiceWorker();
+      } catch {
+        await this.reinitialize();
+      }
+    }
+    const maxRetries = 2;
+    for (let attempt = 0; ; attempt++) {
+      try {
+        return await this.sendMessageDirect(request);
+      } catch (error) {
+        if (!isMessageBusNotInitializedError(error) || attempt >= maxRetries) {
+          throw error;
+        }
+        await this.reinitialize();
+      }
+    }
+  }
+  async reinitialize() {
+    if (this.reinitPromise) return this.reinitPromise;
+    this.reinitPromise = (async () => {
+      if (!this.initPayload) {
+        throw new Error("Cannot re-initialize: missing configuration");
+      }
+      const initMessage = {
+        tag: this.messageTag,
+        type: "INIT_ARKADE_SWAPS",
+        id: getRandomId(),
+        payload: this.initPayload
+      };
+      await this.sendMessageDirect(initMessage);
+    })().finally(() => {
+      this.reinitPromise = null;
     });
+    return this.reinitPromise;
   }
   initEventStream() {
     if (this.eventListenerInitialized) return;

package/dist/repositories/realm/index.d.cts

@@ -1,4 +1,4 @@
-import { i as SwapRepository, P as PendingSwap, k as GetSwapsFilter } from '../../types-DCCYGYCD.cjs';
+import { i as SwapRepository, P as PendingSwap, k as GetSwapsFilter } from '../../types-CEmBBA71.cjs';
 import '@arkade-os/sdk';
 
 /**

package/dist/repositories/realm/index.d.ts

@@ -1,4 +1,4 @@
-import { i as SwapRepository, P as PendingSwap, k as GetSwapsFilter } from '../../types-DCCYGYCD.js';
+import { i as SwapRepository, P as PendingSwap, k as GetSwapsFilter } from '../../types-CEmBBA71.js';
 import '@arkade-os/sdk';
 
 /**

package/dist/repositories/sqlite/index.d.cts

@@ -1,5 +1,5 @@
 import { SQLExecutor } from '@arkade-os/sdk/repositories/sqlite';
-import { i as SwapRepository, P as PendingSwap, k as GetSwapsFilter } from '../../types-DCCYGYCD.cjs';
+import { i as SwapRepository, P as PendingSwap, k as GetSwapsFilter } from '../../types-CEmBBA71.cjs';
 import '@arkade-os/sdk';
 
 /**

package/dist/repositories/sqlite/index.d.ts

@@ -1,5 +1,5 @@
 import { SQLExecutor } from '@arkade-os/sdk/repositories/sqlite';
-import { i as SwapRepository, P as PendingSwap, k as GetSwapsFilter } from '../../types-DCCYGYCD.js';
+import { i as SwapRepository, P as PendingSwap, k as GetSwapsFilter } from '../../types-CEmBBA71.js';
 import '@arkade-os/sdk';
 
 /**

package/dist/{types-DCCYGYCD.d.cts → types-CEmBBA71.d.cts}

@@ -489,6 +489,8 @@ declare class SwapManager implements SwapManagerClient {
     private initialSwaps;
     private pollTimer;
     private reconnectTimer;
+    private initialPollTimer;
+    private pollRetryTimers;
     private isRunning;
     private currentReconnectDelay;
     private currentPollRetryDelay;

package/dist/{types-DCCYGYCD.d.ts → types-CEmBBA71.d.ts}

@@ -489,6 +489,8 @@ declare class SwapManager implements SwapManagerClient {
     private initialSwaps;
     private pollTimer;
     private reconnectTimer;
+    private initialPollTimer;
+    private pollRetryTimers;
     private isRunning;
     private currentReconnectDelay;
     private currentPollRetryDelay;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/boltz-swap",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "type": "module",
   "description": "A production-ready TypeScript package that brings Boltz submarine-swaps to Arkade.",
   "main": "./dist/index.js",
@@ -60,7 +60,7 @@
   "author": "Arkade-OS",
   "license": "MIT",
   "dependencies": {
-    "@arkade-os/sdk": "0.4.9",
+    "@arkade-os/sdk": "0.4.10",
     "@noble/hashes": "2.0.1",
     "@scure/base": "2.0.0",
     "@scure/btc-signer": "2.0.1",