@arkade-os/boltz-swap 0.3.25 → 0.3.26

package/dist/{arkade-swaps-CZF9XoFR.d.cts → arkade-swaps-CS8FZSVL.d.cts}

@@ -1,5 +1,5 @@
 import { IWallet, ArkProvider, IndexerProvider, ArkInfo, Identity, ArkTxInput, VHTLC } from '@arkade-os/sdk';
-import { p as BoltzSwapProvider, Y as SwapManager, m as SwapRepository, _ as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, n as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, k as ArkToBtcResponse, a as BoltzChainSwap, l as BtcToArkResponse, d as Chain, F as FeesResponse, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-LCXS1AVA.cjs';
+import { p as BoltzSwapProvider, Y as SwapManager, m as SwapRepository, _ as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, n as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, k as ArkToBtcResponse, a as BoltzChainSwap, l as BtcToArkResponse, d as Chain, F as FeesResponse, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-BBI7-KJ0.cjs';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
 
 /**

package/dist/{arkade-swaps-pfAgQUMP.d.ts → arkade-swaps-WiKCanCL.d.ts}

@@ -1,5 +1,5 @@
 import { IWallet, ArkProvider, IndexerProvider, ArkInfo, Identity, ArkTxInput, VHTLC } from '@arkade-os/sdk';
-import { p as BoltzSwapProvider, Y as SwapManager, m as SwapRepository, _ as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, n as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, k as ArkToBtcResponse, a as BoltzChainSwap, l as BtcToArkResponse, d as Chain, F as FeesResponse, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-LCXS1AVA.js';
+import { p as BoltzSwapProvider, Y as SwapManager, m as SwapRepository, _ as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, n as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, k as ArkToBtcResponse, a as BoltzChainSwap, l as BtcToArkResponse, d as Chain, F as FeesResponse, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-BBI7-KJ0.js';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
 
 /**

package/dist/{background-GCBCKLGY.js → background-UQDFQCGM.js}

@@ -2,8 +2,8 @@ import {
   defineExpoSwapBackgroundTask,
   registerExpoSwapBackgroundTask,
   unregisterExpoSwapBackgroundTask
-} from "./chunk-FEXQELYZ.js";
-import "./chunk-XC2ARJZO.js";
+} from "./chunk-X3JNWDAR.js";
+import "./chunk-LWUXSE5N.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   defineExpoSwapBackgroundTask,

package/dist/{chunk-XC2ARJZO.js → chunk-LWUXSE5N.js}

@@ -47,6 +47,19 @@ var NetworkError = class extends Error {
     this.errorData = errorData;
   }
 };
+var SwapNotFoundError = class extends NetworkError {
+  /** The swap ID Boltz did not recognise. */
+  swapId;
+  constructor(swapId, errorData) {
+    super(
+      `Boltz returned 404 for swap '${swapId}': swap unknown to this Boltz instance`,
+      404,
+      errorData
+    );
+    this.name = "SwapNotFoundError";
+    this.swapId = swapId;
+  }
+};
 var SchemaError = class extends SwapError {
   constructor(options = {}) {
     super({ message: "Invalid API response", ...options });
@@ -302,10 +315,17 @@ var isCreateSwapsRestoreResponse = (data) => {
   );
 };
 var BASE_URLS = {
-  bitcoin: "https://api.ark.boltz.exchange",
+  bitcoin: "https://api.boltz.exchange",
   mutinynet: "https://api.boltz.mutinynet.arkade.sh",
   regtest: "http://localhost:9069"
 };
+var isSwapNotFoundBody = (error) => {
+  const needle = "could not find swap";
+  const fromJson = error.errorData?.error;
+  if (typeof fromJson === "string" && fromJson.toLowerCase().includes(needle))
+    return true;
+  return error.message.toLowerCase().includes(needle);
+};
 var BoltzSwapProvider = class {
   wsUrl;
   apiUrl;
@@ -397,12 +417,27 @@ var BoltzSwapProvider = class {
       });
     return res;
   }
-  /** Queries the current status of a swap by ID. */
+  /**
+   * Queries the current status of a swap by ID.
+   *
+   * @throws {SwapNotFoundError} when Boltz responds with HTTP 404 and a body
+   * matching the "could not find swap" pattern. Distinct from a generic 404
+   * so callers (e.g. SwapManager polling) can drive a per-swap unknown-to-
+   * provider counter without tripping on transient route or proxy errors.
+   */
   async getSwapStatus(id) {
-    const response = await this.request(
-      `/v2/swap/${id}`,
-      "GET"
-    );
+    let response;
+    try {
+      response = await this.request(
+        `/v2/swap/${id}`,
+        "GET"
+      );
+    } catch (error) {
+      if (error instanceof NetworkError && error.statusCode === 404 && isSwapNotFoundBody(error)) {
+        throw new SwapNotFoundError(id, error.errorData);
+      }
+      throw error;
+    }
     if (!isGetSwapStatusResponse(response))
       throw new SchemaError({
         message: `error fetching status for swap: ${id}`
@@ -881,7 +916,15 @@ function setLogger(customLogger) {
 }
 
 // src/swap-manager.ts
-var SwapManager = class {
+var SwapManager = class _SwapManager {
+  /**
+   * Number of consecutive Boltz 404s for a single swap ID before the
+   * polling loop gives up and transitions the swap to a terminal state.
+   * At the default 30s poll cadence this is roughly a 5-minute grace
+   * window — long enough to ride out a transient Boltz blip, short
+   * enough that a real "swap unknown to this provider" surfaces quickly.
+   */
+  static NOT_FOUND_THRESHOLD = 10;
   swapProvider;
   config;
   // Event listeners storage (supports multiple listeners per event)
@@ -900,6 +943,13 @@ var SwapManager = class {
   reconnectTimer = null;
   initialPollTimer = null;
   pollRetryTimers = /* @__PURE__ */ new Map();
+  // Per-swap counter of consecutive `SwapNotFoundError` responses from
+  // `getSwapStatus`. Reset on any successful poll. Once a swap reaches
+  // `NOT_FOUND_THRESHOLD` consecutive 404s the safety net trips and the
+  // swap is transitioned to `swap.expired` (terminal) and dropped from
+  // monitoring — typically the canonical failure mode after a Boltz
+  // endpoint switch, where old swap IDs are unknown to the new instance.
+  notFoundCounts = /* @__PURE__ */ new Map();
   isRunning = false;
   currentReconnectDelay;
   currentPollRetryDelay;
@@ -1091,6 +1141,7 @@ var SwapManager = class {
       clearTimeout(timer);
     }
     this.pollRetryTimers.clear();
+    this.notFoundCounts.clear();
   }
   /**
    * Set the polling interval (ms).
@@ -1151,6 +1202,7 @@ var SwapManager = class {
       clearTimeout(retryTimer);
       this.pollRetryTimers.delete(swapId);
     }
+    this.notFoundCounts.delete(swapId);
     logger.log(`Removed swap ${swapId} from monitoring`);
   }
   /**
@@ -1427,6 +1479,7 @@ var SwapManager = class {
    * This is the core logic that determines what actions to take
    */
   async handleSwapStatusUpdate(swap, newStatus) {
+    this.notFoundCounts.delete(swap.id);
     const oldStatus = swap.status;
     if (oldStatus === newStatus) return;
     swap.status = newStatus;
@@ -1712,51 +1765,135 @@ var SwapManager = class {
   async pollAllSwaps() {
     if (this.monitoredSwaps.size === 0) return;
     const pollPromises = Array.from(this.monitoredSwaps.values()).map(
-      async (swap) => {
+      (swap) => this.pollSingleSwap(swap)
+    );
+    await Promise.allSettled(pollPromises);
+  }
+  async pollSingleSwap(swap) {
+    try {
+      const statusResponse = await this.swapProvider.getSwapStatus(
+        swap.id
+      );
+      this.notFoundCounts.delete(swap.id);
+      if (statusResponse.status !== swap.status) {
+        await this.handleSwapStatusUpdate(swap, statusResponse.status);
+      }
+    } catch (error) {
+      if (error instanceof SwapNotFoundError) {
+        await this.handleSwapNotFound(swap);
+        return;
+      }
+      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
+              );
+              this.notFoundCounts.delete(swap.id);
+              if (retry.status !== swap.status) {
+                await this.handleSwapStatusUpdate(
+                  swap,
+                  retry.status
+                );
+              }
+            } catch (retryError) {
+              if (retryError instanceof SwapNotFoundError) {
+                await this.handleSwapNotFound(swap);
+                return;
+              }
+              logger.error(
+                `Retry poll for swap ${swap.id} also failed:`,
+                retryError
+              );
+            }
+          }, 2e3)
+        );
+      } else {
+        logger.error(`Failed to poll swap ${swap.id}:`, error);
+      }
+    }
+  }
+  /**
+   * Increment the consecutive-not-found counter and, once the threshold is
+   * reached, transition the swap to a terminal state and stop polling it.
+   * Driven from {@link pollSingleSwap} when `getSwapStatus` throws
+   * {@link SwapNotFoundError}. The threshold rides out a transient blip
+   * but ensures we stop hammering Boltz with requests for swap IDs the
+   * server has no record of (e.g. after switching the configured
+   * Boltz endpoint).
+   */
+  async handleSwapNotFound(swap) {
+    const count = (this.notFoundCounts.get(swap.id) ?? 0) + 1;
+    this.notFoundCounts.set(swap.id, count);
+    logger.warn(
+      `Swap ${swap.id}: unknown to Boltz (${count}/${_SwapManager.NOT_FOUND_THRESHOLD} consecutive)`
+    );
+    if (count >= _SwapManager.NOT_FOUND_THRESHOLD) {
+      await this.markSwapAsUnknownToProvider(swap);
+    }
+  }
+  /**
+   * Transition a swap to {@code swap.expired} (terminal for all swap types)
+   * after Boltz has consistently reported it unknown for
+   * {@link SwapManager.NOT_FOUND_THRESHOLD} consecutive polls. The swap is
+   * persisted, removed from monitoring, and reported via `onSwapFailed`.
+   * Bypasses {@link handleSwapStatusUpdate} on purpose: we don't want to
+   * trigger autonomous claim/refund actions against a Boltz instance that
+   * has no record of this swap — the requests would just generate more
+   * 404s without recovering anything.
+   */
+  async markSwapAsUnknownToProvider(swap) {
+    if (!this.monitoredSwaps.has(swap.id)) {
+      this.notFoundCounts.delete(swap.id);
+      return;
+    }
+    const oldStatus = swap.status;
+    swap.status = "swap.expired";
+    this.monitoredSwaps.delete(swap.id);
+    const retryTimer = this.pollRetryTimers.get(swap.id);
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+      this.pollRetryTimers.delete(swap.id);
+    }
+    this.notFoundCounts.delete(swap.id);
+    this.swapUpdateListeners.forEach(
+      (listener) => listener(swap, oldStatus)
+    );
+    const subscribers = this.swapSubscriptions.get(swap.id);
+    if (subscribers) {
+      subscribers.forEach((callback) => {
         try {
-          const statusResponse = await this.swapProvider.getSwapStatus(swap.id);
-          if (statusResponse.status !== swap.status) {
-            await this.handleSwapStatusUpdate(
-              swap,
-              statusResponse.status
-            );
-          }
-        } catch (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);
-          }
+          callback(swap, oldStatus);
+        } catch (subscriberError) {
+          logger.error(
+            `Error in swap subscription callback for ${swap.id}:`,
+            subscriberError
+          );
         }
-      }
+      });
+    }
+    try {
+      await this.saveSwap(swap);
+    } catch (saveError) {
+      logger.error(
+        `Failed to persist unknown-to-provider state for swap ${swap.id}:`,
+        saveError
+      );
+    }
+    logger.warn(
+      `Swap ${swap.id}: marked failed after ${_SwapManager.NOT_FOUND_THRESHOLD} consecutive Boltz 404s \u2014 swap is unknown to the configured Boltz instance`
     );
-    await Promise.allSettled(pollPromises);
+    const error = new SwapNotFoundError(swap.id);
+    this.swapFailedListeners.forEach((listener) => listener(swap, error));
+    this.swapSubscriptions.delete(swap.id);
   }
   /**
    * Check if a status is final (no more updates expected)
@@ -5143,6 +5280,7 @@ export {
   InvoiceFailedToPayError,
   InsufficientFundsError,
   NetworkError,
+  SwapNotFoundError,
   SchemaError,
   SwapExpiredError,
   TransactionFailedError,

package/dist/{chunk-FEXQELYZ.js → chunk-X3JNWDAR.js}

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

package/dist/expo/index.cjs

@@ -31,7 +31,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/errors.ts
-var SwapError, InvoiceExpiredError, InvoiceFailedToPayError, NetworkError, SchemaError, SwapExpiredError, TransactionFailedError, TransactionLockupFailedError, TransactionRefundedError, BoltzRefundError;
+var SwapError, InvoiceExpiredError, InvoiceFailedToPayError, NetworkError, SwapNotFoundError, SchemaError, SwapExpiredError, TransactionFailedError, TransactionLockupFailedError, TransactionRefundedError, BoltzRefundError;
 var init_errors = __esm({
   "src/errors.ts"() {
     "use strict";
@@ -77,6 +77,19 @@ var init_errors = __esm({
         this.errorData = errorData;
       }
     };
+    SwapNotFoundError = class extends NetworkError {
+      /** The swap ID Boltz did not recognise. */
+      swapId;
+      constructor(swapId, errorData) {
+        super(
+          `Boltz returned 404 for swap '${swapId}': swap unknown to this Boltz instance`,
+          404,
+          errorData
+        );
+        this.name = "SwapNotFoundError";
+        this.swapId = swapId;
+      }
+    };
     SchemaError = class extends SwapError {
       constructor(options = {}) {
         super({ message: "Invalid API response", ...options });
@@ -118,7 +131,7 @@ var init_errors = __esm({
 });
 
 // src/boltz-swap-provider.ts
-var import_sdk, import_base, isSubmarineFinalStatus, isSubmarineRefundableStatus, isSubmarineSuccessStatus, isReverseFinalStatus, isReverseClaimableStatus, isChainClaimableStatus, isChainFinalStatus, isChainRefundableStatus, isChainSignableStatus, isPendingReverseSwap, isPendingSubmarineSwap, isPendingChainSwap, isSubmarineSwapRefundable, isTimeoutBlockHeights, isGetReverseSwapTxIdResponse, isGetSwapStatusResponse, isGetSubmarinePairsResponse, isGetReversePairsResponse, isCreateSubmarineSwapResponse, isGetSwapPreimageResponse, isCreateReverseSwapResponse, isRefundSubmarineSwapResponse, isRefundChainSwapResponse, isGetChainPairsResponse, isSwapTree, isChainSwapDetailsResponse, isCreateChainSwapResponse, isGetChainClaimDetailsResponse, isPostChainClaimDetailsResponse, isGetChainQuoteResponse, isPostChainQuoteResponse, isPostBtcTransactionResponse, isLeaf, isTree, isDetails, isRestoredChainSwap, isRestoredSubmarineSwap, isRestoredReverseSwap, isCreateSwapsRestoreResponse, BASE_URLS, BoltzSwapProvider;
+var import_sdk, import_base, isSubmarineFinalStatus, isSubmarineRefundableStatus, isSubmarineSuccessStatus, isReverseFinalStatus, isReverseClaimableStatus, isChainClaimableStatus, isChainFinalStatus, isChainRefundableStatus, isChainSignableStatus, isPendingReverseSwap, isPendingSubmarineSwap, isPendingChainSwap, isSubmarineSwapRefundable, isTimeoutBlockHeights, isGetReverseSwapTxIdResponse, isGetSwapStatusResponse, isGetSubmarinePairsResponse, isGetReversePairsResponse, isCreateSubmarineSwapResponse, isGetSwapPreimageResponse, isCreateReverseSwapResponse, isRefundSubmarineSwapResponse, isRefundChainSwapResponse, isGetChainPairsResponse, isSwapTree, isChainSwapDetailsResponse, isCreateChainSwapResponse, isGetChainClaimDetailsResponse, isPostChainClaimDetailsResponse, isGetChainQuoteResponse, isPostChainQuoteResponse, isPostBtcTransactionResponse, isLeaf, isTree, isDetails, isRestoredChainSwap, isRestoredSubmarineSwap, isRestoredReverseSwap, isCreateSwapsRestoreResponse, BASE_URLS, isSwapNotFoundBody, BoltzSwapProvider;
 var init_boltz_swap_provider = __esm({
   "src/boltz-swap-provider.ts"() {
     "use strict";
@@ -269,10 +282,17 @@ var init_boltz_swap_provider = __esm({
       );
     };
     BASE_URLS = {
-      bitcoin: "https://api.ark.boltz.exchange",
+      bitcoin: "https://api.boltz.exchange",
       mutinynet: "https://api.boltz.mutinynet.arkade.sh",
       regtest: "http://localhost:9069"
     };
+    isSwapNotFoundBody = (error) => {
+      const needle = "could not find swap";
+      const fromJson = error.errorData?.error;
+      if (typeof fromJson === "string" && fromJson.toLowerCase().includes(needle))
+        return true;
+      return error.message.toLowerCase().includes(needle);
+    };
     BoltzSwapProvider = class {
       wsUrl;
       apiUrl;
@@ -364,12 +384,27 @@ var init_boltz_swap_provider = __esm({
           });
         return res;
       }
-      /** Queries the current status of a swap by ID. */
+      /**
+       * Queries the current status of a swap by ID.
+       *
+       * @throws {SwapNotFoundError} when Boltz responds with HTTP 404 and a body
+       * matching the "could not find swap" pattern. Distinct from a generic 404
+       * so callers (e.g. SwapManager polling) can drive a per-swap unknown-to-
+       * provider counter without tripping on transient route or proxy errors.
+       */
       async getSwapStatus(id) {
-        const response = await this.request(
-          `/v2/swap/${id}`,
-          "GET"
-        );
+        let response;
+        try {
+          response = await this.request(
+            `/v2/swap/${id}`,
+            "GET"
+          );
+        } catch (error) {
+          if (error instanceof NetworkError && error.statusCode === 404 && isSwapNotFoundBody(error)) {
+            throw new SwapNotFoundError(id, error.errorData);
+          }
+          throw error;
+        }
         if (!isGetSwapStatusResponse(response))
           throw new SchemaError({
             message: `error fetching status for swap: ${id}`
@@ -1296,7 +1331,15 @@ var init_swap_manager = __esm({
     init_boltz_swap_provider();
     init_errors();
     init_logger();
-    SwapManager = class {
+    SwapManager = class _SwapManager {
+      /**
+       * Number of consecutive Boltz 404s for a single swap ID before the
+       * polling loop gives up and transitions the swap to a terminal state.
+       * At the default 30s poll cadence this is roughly a 5-minute grace
+       * window — long enough to ride out a transient Boltz blip, short
+       * enough that a real "swap unknown to this provider" surfaces quickly.
+       */
+      static NOT_FOUND_THRESHOLD = 10;
       swapProvider;
       config;
       // Event listeners storage (supports multiple listeners per event)
@@ -1315,6 +1358,13 @@ var init_swap_manager = __esm({
       reconnectTimer = null;
       initialPollTimer = null;
       pollRetryTimers = /* @__PURE__ */ new Map();
+      // Per-swap counter of consecutive `SwapNotFoundError` responses from
+      // `getSwapStatus`. Reset on any successful poll. Once a swap reaches
+      // `NOT_FOUND_THRESHOLD` consecutive 404s the safety net trips and the
+      // swap is transitioned to `swap.expired` (terminal) and dropped from
+      // monitoring — typically the canonical failure mode after a Boltz
+      // endpoint switch, where old swap IDs are unknown to the new instance.
+      notFoundCounts = /* @__PURE__ */ new Map();
       isRunning = false;
       currentReconnectDelay;
       currentPollRetryDelay;
@@ -1506,6 +1556,7 @@ var init_swap_manager = __esm({
           clearTimeout(timer);
         }
         this.pollRetryTimers.clear();
+        this.notFoundCounts.clear();
       }
       /**
        * Set the polling interval (ms).
@@ -1566,6 +1617,7 @@ var init_swap_manager = __esm({
           clearTimeout(retryTimer);
           this.pollRetryTimers.delete(swapId);
         }
+        this.notFoundCounts.delete(swapId);
         logger.log(`Removed swap ${swapId} from monitoring`);
       }
       /**
@@ -1842,6 +1894,7 @@ var init_swap_manager = __esm({
        * This is the core logic that determines what actions to take
        */
       async handleSwapStatusUpdate(swap, newStatus) {
+        this.notFoundCounts.delete(swap.id);
         const oldStatus = swap.status;
         if (oldStatus === newStatus) return;
         swap.status = newStatus;
@@ -2127,51 +2180,135 @@ var init_swap_manager = __esm({
       async pollAllSwaps() {
         if (this.monitoredSwaps.size === 0) return;
         const pollPromises = Array.from(this.monitoredSwaps.values()).map(
-          async (swap) => {
+          (swap) => this.pollSingleSwap(swap)
+        );
+        await Promise.allSettled(pollPromises);
+      }
+      async pollSingleSwap(swap) {
+        try {
+          const statusResponse = await this.swapProvider.getSwapStatus(
+            swap.id
+          );
+          this.notFoundCounts.delete(swap.id);
+          if (statusResponse.status !== swap.status) {
+            await this.handleSwapStatusUpdate(swap, statusResponse.status);
+          }
+        } catch (error) {
+          if (error instanceof SwapNotFoundError) {
+            await this.handleSwapNotFound(swap);
+            return;
+          }
+          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
+                  );
+                  this.notFoundCounts.delete(swap.id);
+                  if (retry.status !== swap.status) {
+                    await this.handleSwapStatusUpdate(
+                      swap,
+                      retry.status
+                    );
+                  }
+                } catch (retryError) {
+                  if (retryError instanceof SwapNotFoundError) {
+                    await this.handleSwapNotFound(swap);
+                    return;
+                  }
+                  logger.error(
+                    `Retry poll for swap ${swap.id} also failed:`,
+                    retryError
+                  );
+                }
+              }, 2e3)
+            );
+          } else {
+            logger.error(`Failed to poll swap ${swap.id}:`, error);
+          }
+        }
+      }
+      /**
+       * Increment the consecutive-not-found counter and, once the threshold is
+       * reached, transition the swap to a terminal state and stop polling it.
+       * Driven from {@link pollSingleSwap} when `getSwapStatus` throws
+       * {@link SwapNotFoundError}. The threshold rides out a transient blip
+       * but ensures we stop hammering Boltz with requests for swap IDs the
+       * server has no record of (e.g. after switching the configured
+       * Boltz endpoint).
+       */
+      async handleSwapNotFound(swap) {
+        const count = (this.notFoundCounts.get(swap.id) ?? 0) + 1;
+        this.notFoundCounts.set(swap.id, count);
+        logger.warn(
+          `Swap ${swap.id}: unknown to Boltz (${count}/${_SwapManager.NOT_FOUND_THRESHOLD} consecutive)`
+        );
+        if (count >= _SwapManager.NOT_FOUND_THRESHOLD) {
+          await this.markSwapAsUnknownToProvider(swap);
+        }
+      }
+      /**
+       * Transition a swap to {@code swap.expired} (terminal for all swap types)
+       * after Boltz has consistently reported it unknown for
+       * {@link SwapManager.NOT_FOUND_THRESHOLD} consecutive polls. The swap is
+       * persisted, removed from monitoring, and reported via `onSwapFailed`.
+       * Bypasses {@link handleSwapStatusUpdate} on purpose: we don't want to
+       * trigger autonomous claim/refund actions against a Boltz instance that
+       * has no record of this swap — the requests would just generate more
+       * 404s without recovering anything.
+       */
+      async markSwapAsUnknownToProvider(swap) {
+        if (!this.monitoredSwaps.has(swap.id)) {
+          this.notFoundCounts.delete(swap.id);
+          return;
+        }
+        const oldStatus = swap.status;
+        swap.status = "swap.expired";
+        this.monitoredSwaps.delete(swap.id);
+        const retryTimer = this.pollRetryTimers.get(swap.id);
+        if (retryTimer) {
+          clearTimeout(retryTimer);
+          this.pollRetryTimers.delete(swap.id);
+        }
+        this.notFoundCounts.delete(swap.id);
+        this.swapUpdateListeners.forEach(
+          (listener) => listener(swap, oldStatus)
+        );
+        const subscribers = this.swapSubscriptions.get(swap.id);
+        if (subscribers) {
+          subscribers.forEach((callback) => {
             try {
-              const statusResponse = await this.swapProvider.getSwapStatus(swap.id);
-              if (statusResponse.status !== swap.status) {
-                await this.handleSwapStatusUpdate(
-                  swap,
-                  statusResponse.status
-                );
-              }
-            } catch (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);
-              }
+              callback(swap, oldStatus);
+            } catch (subscriberError) {
+              logger.error(
+                `Error in swap subscription callback for ${swap.id}:`,
+                subscriberError
+              );
             }
-          }
+          });
+        }
+        try {
+          await this.saveSwap(swap);
+        } catch (saveError) {
+          logger.error(
+            `Failed to persist unknown-to-provider state for swap ${swap.id}:`,
+            saveError
+          );
+        }
+        logger.warn(
+          `Swap ${swap.id}: marked failed after ${_SwapManager.NOT_FOUND_THRESHOLD} consecutive Boltz 404s \u2014 swap is unknown to the configured Boltz instance`
         );
-        await Promise.allSettled(pollPromises);
+        const error = new SwapNotFoundError(swap.id);
+        this.swapFailedListeners.forEach((listener) => listener(swap, error));
+        this.swapSubscriptions.delete(swap.id);
       }
       /**
        * Check if a status is final (no more updates expected)

package/dist/expo/index.d.cts

@@ -1,5 +1,5 @@
-import { I as IArkadeSwaps, A as ArkadeSwaps, V as VhtlcTimeouts } from '../arkade-swaps-CZF9XoFR.cjs';
-import { A as ArkadeSwapsConfig, m as SwapRepository, p as BoltzSwapProvider, N as Network, n as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, b as BoltzReverseSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, F as FeesResponse, a as BoltzChainSwap, k as ArkToBtcResponse, l as BtcToArkResponse, d as Chain, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from '../types-LCXS1AVA.cjs';
+import { I as IArkadeSwaps, A as ArkadeSwaps, V as VhtlcTimeouts } from '../arkade-swaps-CS8FZSVL.cjs';
+import { A as ArkadeSwapsConfig, m as SwapRepository, p as BoltzSwapProvider, N as Network, n as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, b as BoltzReverseSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, F as FeesResponse, a as BoltzChainSwap, k as ArkToBtcResponse, l as BtcToArkResponse, d as Chain, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from '../types-BBI7-KJ0.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';