@arkade-os/boltz-swap 0.3.22 → 0.3.24

package/dist/index.cjs

@@ -2762,6 +2762,10 @@ function createForfeitTx(input, forfeitOutputScript, connector) {
 var import_legacy = require("@noble/hashes/legacy.js");
 var import_btc_signer4 = require("@scure/btc-signer");
 var import_payment3 = require("@scure/btc-signer/payment.js");
+var toBip68RelativeTimelock = (value) => ({
+  type: value < 512 ? "blocks" : "seconds",
+  value: BigInt(value)
+});
 var createVHTLCScript = (args) => {
   const {
     network,
@@ -2769,7 +2773,7 @@ var createVHTLCScript = (args) => {
     receiverPubkey,
     senderPubkey,
     serverPubkey,
-    timeoutBlockHeights
+    timeoutBlockHeights: vhtlcTimeouts
   } = args;
   const receiverXOnlyPublicKey = normalizeToXOnlyKey(
     import_base8.hex.decode(receiverPubkey),
@@ -2783,27 +2787,21 @@ var createVHTLCScript = (args) => {
     import_base8.hex.decode(serverPubkey),
     "server"
   );
-  const delayType = (num) => num < 512 ? "blocks" : "seconds";
   const vhtlcScript = new import_sdk7.VHTLC.Script({
     preimageHash: (0, import_legacy.ripemd160)(preimageHash),
     sender: senderXOnlyPublicKey,
     receiver: receiverXOnlyPublicKey,
     server: serverXOnlyPublicKey,
-    refundLocktime: BigInt(timeoutBlockHeights.refund),
-    unilateralClaimDelay: {
-      type: delayType(timeoutBlockHeights.unilateralClaim),
-      value: BigInt(timeoutBlockHeights.unilateralClaim)
-    },
-    unilateralRefundDelay: {
-      type: delayType(timeoutBlockHeights.unilateralRefund),
-      value: BigInt(timeoutBlockHeights.unilateralRefund)
-    },
-    unilateralRefundWithoutReceiverDelay: {
-      type: delayType(
-        timeoutBlockHeights.unilateralRefundWithoutReceiver
-      ),
-      value: BigInt(timeoutBlockHeights.unilateralRefundWithoutReceiver)
-    }
+    refundLocktime: BigInt(vhtlcTimeouts.refund),
+    unilateralClaimDelay: toBip68RelativeTimelock(
+      vhtlcTimeouts.unilateralClaim
+    ),
+    unilateralRefundDelay: toBip68RelativeTimelock(
+      vhtlcTimeouts.unilateralRefund
+    ),
+    unilateralRefundWithoutReceiverDelay: toBip68RelativeTimelock(
+      vhtlcTimeouts.unilateralRefundWithoutReceiver
+    )
   });
   if (!vhtlcScript.claimScript)
     throw new Error("Failed to create VHTLC script");
@@ -3042,6 +3040,20 @@ function scriptFromTapLeafScript(leaf) {
 }
 
 // src/arkade-swaps.ts
+var dedupeVtxos = (vtxos) => [
+  ...new Map(
+    vtxos.map((vtxo) => [`${vtxo.txid}:${vtxo.vout}`, vtxo])
+  ).values()
+];
+var hasNonEmptyString = (value) => typeof value === "string" && value.length > 0;
+var canRecoverViaBoltz3of3 = (refundableVtxos, swap) => {
+  const hasRequiredSwapMetadata = hasNonEmptyString(swap.id) && hasNonEmptyString(swap.request.refundPublicKey) && hasNonEmptyString(swap.response.address) && hasNonEmptyString(swap.response.claimPublicKey) && !!swap.response.timeoutBlockHeights;
+  if (!hasRequiredSwapMetadata) return false;
+  return refundableVtxos.some(
+    (vtxo) => !vtxo.isSpent && !(0, import_sdk8.isRecoverable)(vtxo)
+  );
+};
+var isSubmarineRefundLocktimeReached = (refundTimestamp) => Math.floor(Date.now() / 1e3) >= refundTimestamp;
 var CLAIM_VTXO_RETRY_ATTEMPTS = 3;
 var CLAIM_VTXO_RETRY_DELAY_MS = 500;
 var ArkadeSwaps = class _ArkadeSwaps {
@@ -3309,8 +3321,12 @@ var ArkadeSwaps = class _ArkadeSwaps {
       throw new Error(
         `Swap ${pendingSwap.id}: preimage is required to claim VHTLC`
       );
-    const { refundPublicKey, lockupAddress, timeoutBlockHeights } = pendingSwap.response;
-    if (!refundPublicKey || !lockupAddress || !timeoutBlockHeights)
+    const {
+      refundPublicKey,
+      lockupAddress,
+      timeoutBlockHeights: vhtlcTimeouts
+    } = pendingSwap.response;
+    if (!refundPublicKey || !lockupAddress || !vhtlcTimeouts)
       throw new Error(
         `Swap ${pendingSwap.id}: incomplete reverse swap response`
       );
@@ -3338,7 +3354,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       receiverPubkey: import_base9.hex.encode(receiverXOnly),
       senderPubkey: import_base9.hex.encode(senderXOnly),
       serverPubkey: import_base9.hex.encode(serverXOnly),
-      timeoutBlockHeights
+      timeoutBlockHeights: vhtlcTimeouts
     });
     if (!vhtlcScript.claimScript)
       throw new Error(
@@ -3566,84 +3582,184 @@ var ArkadeSwaps = class _ArkadeSwaps {
     return pendingSwap;
   }
   /**
-   * Refunds the VHTLC for a failed submarine swap, returning locked funds to the wallet.
-   * Uses multi-party signatures (user + Boltz + server) for non-recoverable VTXOs.
-   * @param pendingSwap - The submarine swap to refund.
-   * @throws {Error} If preimage hash is unavailable, VHTLC not found, or already spent.
+   * Reconstruct a submarine swap's VHTLC script from stored data. This does
+   * not query the indexer, so bulk scans can build every script first and
+   * then use batched VTXO lookups.
+   *
+   * @throws {Error} If preimage hash is unavailable, the swap response is
+   *   incomplete, the script can't be built, or the reconstructed address
+   *   doesn't match the one Boltz returned.
    */
-  async refundVHTLC(pendingSwap) {
-    const preimageHash = pendingSwap.request.invoice ? getInvoicePaymentHash(pendingSwap.request.invoice) : pendingSwap.preimageHash;
+  async buildSubmarineVHTLCContext(swap, arkInfo) {
+    const preimageHash = swap.request.invoice ? getInvoicePaymentHash(swap.request.invoice) : swap.preimageHash;
     if (!preimageHash)
       throw new Error(
-        `Swap ${pendingSwap.id}: preimage hash is required to refund VHTLC`
+        `Swap ${swap.id}: preimage hash is required to refund VHTLC`
       );
-    const arkInfo = await this.arkProvider.getInfo();
-    const address = await this.wallet.getAddress();
-    if (!address) throw new Error("Failed to get ark address from wallet");
+    const resolvedArkInfo = arkInfo ?? await this.arkProvider.getInfo();
     const ourXOnlyPublicKey = normalizeToXOnlyKey(
       await this.wallet.identity.xOnlyPublicKey(),
       "our",
-      pendingSwap.id
+      swap.id
     );
     const serverXOnlyPublicKey = normalizeToXOnlyKey(
-      import_base9.hex.decode(arkInfo.signerPubkey),
+      import_base9.hex.decode(resolvedArkInfo.signerPubkey),
       "server",
-      pendingSwap.id
+      swap.id
     );
-    const { claimPublicKey, timeoutBlockHeights } = pendingSwap.response;
-    if (!claimPublicKey || !timeoutBlockHeights)
+    const { claimPublicKey, timeoutBlockHeights: vhtlcTimeouts } = swap.response;
+    if (!claimPublicKey || !vhtlcTimeouts)
       throw new Error(
-        `Swap ${pendingSwap.id}: incomplete submarine swap response`
+        `Swap ${swap.id}: incomplete submarine swap response`
       );
     const boltzXOnlyPublicKey = normalizeToXOnlyKey(
       import_base9.hex.decode(claimPublicKey),
       "boltz",
-      pendingSwap.id
+      swap.id
     );
     const { vhtlcScript, vhtlcAddress } = this.createVHTLCScript({
-      network: arkInfo.network,
+      network: resolvedArkInfo.network,
       preimageHash: import_base9.hex.decode(preimageHash),
       receiverPubkey: import_base9.hex.encode(boltzXOnlyPublicKey),
       senderPubkey: import_base9.hex.encode(ourXOnlyPublicKey),
       serverPubkey: import_base9.hex.encode(serverXOnlyPublicKey),
-      timeoutBlockHeights
+      timeoutBlockHeights: vhtlcTimeouts
     });
     if (!vhtlcScript.claimScript)
       throw new Error(
-        `Swap ${pendingSwap.id}: failed to create VHTLC script for submarine swap`
+        `Swap ${swap.id}: failed to create VHTLC script for submarine swap`
       );
-    if (vhtlcAddress !== pendingSwap.response.address)
+    if (vhtlcAddress !== swap.response.address)
       throw new Error(
-        `VHTLC address mismatch for swap ${pendingSwap.id}: expected ${pendingSwap.response.address}, got ${vhtlcAddress}`
+        `VHTLC address mismatch for swap ${swap.id}: expected ${swap.response.address}, got ${vhtlcAddress}`
       );
     const vhtlcPkScriptHex = import_base9.hex.encode(vhtlcScript.pkScript);
+    return {
+      arkInfo: resolvedArkInfo,
+      vhtlcScript,
+      vhtlcAddress,
+      vhtlcPkScriptHex,
+      vhtlcTimeouts,
+      ourXOnlyPublicKey,
+      serverXOnlyPublicKey,
+      boltzXOnlyPublicKey
+    };
+  }
+  /**
+   * Reconstruct a submarine swap's VHTLC script from stored data and look
+   * up its VTXOs at the indexer. Side-effect free; shared by `refundVHTLC`
+   * (spending path) and `inspectSubmarineRecovery` (diagnostic path).
+   *
+   * `refundableVtxos` merges spendable + recoverable indexer queries
+   * (deduped by outpoint). When that set is empty, a third query
+   * populates `diagnostic` so callers can distinguish "never funded",
+   * "already spent", and "preconfirmed-only".
+   */
+  async lookupSubmarineVHTLC(swap, arkInfo) {
+    const context = await this.buildSubmarineVHTLCContext(swap, arkInfo);
     const [spendableResult, recoverableResult] = await Promise.all([
       this.indexerProvider.getVtxos({
-        scripts: [vhtlcPkScriptHex],
+        scripts: [context.vhtlcPkScriptHex],
         spendableOnly: true
       }),
       this.indexerProvider.getVtxos({
-        scripts: [vhtlcPkScriptHex],
+        scripts: [context.vhtlcPkScriptHex],
         recoverableOnly: true
       })
     ]);
-    const refundableVtxos = [
-      ...new Map(
-        [...spendableResult.vtxos, ...recoverableResult.vtxos].map(
-          (vtxo) => [`${vtxo.txid}:${vtxo.vout}`, vtxo]
-        )
-      ).values()
-    ];
+    const refundableVtxos = dedupeVtxos([
+      ...spendableResult.vtxos,
+      ...recoverableResult.vtxos
+    ]);
+    let diagnostic;
     if (refundableVtxos.length === 0) {
       const { vtxos: allVtxos } = await this.indexerProvider.getVtxos({
-        scripts: [vhtlcPkScriptHex]
+        scripts: [context.vhtlcPkScriptHex]
       });
-      if (allVtxos.length === 0) {
+      diagnostic = {
+        totalVtxoCount: allVtxos.length,
+        allSpent: allVtxos.length > 0 && allVtxos.every((vtxo) => vtxo.isSpent)
+      };
+    }
+    return {
+      ...context,
+      refundableVtxos,
+      diagnostic
+    };
+  }
+  submarineRecoveryInfoFromLookup(swap, lookup) {
+    const { refundableVtxos, diagnostic, vhtlcTimeouts } = lookup;
+    if (refundableVtxos.length > 0) {
+      const cltvSatisfied = isSubmarineRefundLocktimeReached(
+        vhtlcTimeouts.refund
+      );
+      const amountSats = refundableVtxos.reduce(
+        (sum, vtxo) => sum + Number(vtxo.value),
+        0
+      );
+      const isRecoverable2 = cltvSatisfied || canRecoverViaBoltz3of3(refundableVtxos, swap);
+      return {
+        swap,
+        status: isRecoverable2 ? "recoverable" : "pre_cltv",
+        vtxoCount: refundableVtxos.length,
+        amountSats,
+        refundLocktime: vhtlcTimeouts.refund
+      };
+    }
+    if (!diagnostic || diagnostic.totalVtxoCount === 0) {
+      return {
+        swap,
+        status: "none",
+        vtxoCount: 0,
+        amountSats: 0,
+        refundLocktime: vhtlcTimeouts.refund
+      };
+    }
+    if (diagnostic.allSpent) {
+      return {
+        swap,
+        status: "already_spent",
+        vtxoCount: 0,
+        amountSats: 0,
+        refundLocktime: vhtlcTimeouts.refund
+      };
+    }
+    return {
+      swap,
+      status: "none",
+      vtxoCount: 0,
+      amountSats: 0,
+      refundLocktime: vhtlcTimeouts.refund
+    };
+  }
+  /**
+   * Refunds the VHTLC for a failed submarine swap, returning locked funds to the wallet.
+   * Uses multi-party signatures (user + Boltz + server) for non-recoverable VTXOs.
+   * @param pendingSwap - The submarine swap to refund.
+   * @returns Counts of VTXOs swept vs. deferred. A return value of `{ swept: 0, skipped: N }`
+   *          means the call was a no-op — callers should not treat it as a successful refund.
+   * @throws {Error} If preimage hash is unavailable, VHTLC not found, or already spent.
+   */
+  async refundVHTLC(pendingSwap, cachedArkInfo) {
+    const address = await this.wallet.getAddress();
+    if (!address) throw new Error("Failed to get ark address from wallet");
+    const {
+      arkInfo,
+      vhtlcScript,
+      vhtlcTimeouts,
+      ourXOnlyPublicKey,
+      serverXOnlyPublicKey,
+      boltzXOnlyPublicKey,
+      refundableVtxos,
+      diagnostic
+    } = await this.lookupSubmarineVHTLC(pendingSwap, cachedArkInfo);
+    if (refundableVtxos.length === 0) {
+      if (!diagnostic || diagnostic.totalVtxoCount === 0) {
         throw new Error(
           `Swap ${pendingSwap.id}: VHTLC not found for address ${pendingSwap.response.address}`
         );
       }
-      if (allVtxos.every((vtxo) => vtxo.isSpent)) {
+      if (diagnostic.allSpent) {
         throw new Error(
           `Swap ${pendingSwap.id}: VHTLC is already spent`
         );
@@ -3654,10 +3770,11 @@ var ArkadeSwaps = class _ArkadeSwaps {
     }
     const outputScript = import_sdk8.ArkAddress.decode(address).pkScript;
     const refundWithoutReceiverLeaf = vhtlcScript.refundWithoutReceiver();
-    const refundLocktime = BigInt(timeoutBlockHeights.refund);
-    const currentBlockHeight = await this.swapProvider.getChainHeight();
-    const cltvSatisfied = BigInt(currentBlockHeight) >= refundLocktime;
+    const cltvSatisfied = isSubmarineRefundLocktimeReached(
+      vhtlcTimeouts.refund
+    );
     let boltzCallCount = 0;
+    let sweptCount = 0;
     let skippedCount = 0;
     for (const vtxo of refundableVtxos) {
       const isRecoverableVtxo = (0, import_sdk8.isRecoverable)(vtxo);
@@ -3678,11 +3795,12 @@ var ArkadeSwaps = class _ArkadeSwaps {
           arkInfo,
           isRecoverableVtxo
         );
+        sweptCount++;
         continue;
       }
       if (isRecoverableVtxo) {
         logger.error(
-          `Swap ${pendingSwap.id}: recoverable VTXO ${vtxo.txid}:${vtxo.vout} cannot be refunded yet \u2014 refundWithoutReceiver locktime has not passed (refundLocktime=${timeoutBlockHeights.refund}, currentBlockHeight=${currentBlockHeight}). Refund will be retried after locktime.`
+          `Swap ${pendingSwap.id}: recoverable VTXO ${vtxo.txid}:${vtxo.vout} cannot be refunded yet \u2014 refundWithoutReceiver locktime has not passed (refundLocktime=${vhtlcTimeouts.refund}, currentTimestamp=${Math.floor(Date.now() / 1e3)}). Refund will be retried after locktime.`
         );
         skippedCount++;
         continue;
@@ -3711,14 +3829,14 @@ var ArkadeSwaps = class _ArkadeSwaps {
           )
         );
         boltzCallCount++;
+        sweptCount++;
       } catch (error) {
         if (!(error instanceof BoltzRefundError)) {
           throw error;
         }
-        const tipNow = await this.swapProvider.getChainHeight();
-        if (BigInt(tipNow) < refundLocktime) {
+        if (!isSubmarineRefundLocktimeReached(vhtlcTimeouts.refund)) {
           logger.error(
-            `Swap ${pendingSwap.id}: Boltz rejected VTXO outpoint and refundWithoutReceiver locktime has not passed yet (currentBlockHeight=${tipNow}, locktime=${timeoutBlockHeights.refund}). Refund will be retried after locktime.`
+            `Swap ${pendingSwap.id}: Boltz rejected VTXO outpoint and refundWithoutReceiver locktime has not passed yet (currentTimestamp=${Math.floor(Date.now() / 1e3)}, locktime=${vhtlcTimeouts.refund}). Refund will be retried after locktime.`
           );
           skippedCount++;
           continue;
@@ -3738,16 +3856,218 @@ var ArkadeSwaps = class _ArkadeSwaps {
           arkInfo,
           false
         );
+        sweptCount++;
       }
     }
-    const fullyRefunded = skippedCount === 0;
-    await updateSubmarineSwapStatus(
-      pendingSwap,
-      pendingSwap.status,
-      // Keep current status
-      this.savePendingSubmarineSwap.bind(this),
-      { refundable: true, refunded: fullyRefunded }
+    if (!isSubmarineSuccessStatus(pendingSwap.status)) {
+      const fullyRefunded = skippedCount === 0;
+      await updateSubmarineSwapStatus(
+        pendingSwap,
+        pendingSwap.status,
+        // Keep current status
+        this.savePendingSubmarineSwap.bind(this),
+        { refundable: true, refunded: fullyRefunded }
+      );
+    }
+    return { swept: sweptCount, skipped: skippedCount };
+  }
+  /**
+   * Inspect a submarine swap's lockup address for recoverable funds.
+   *
+   * Side-effect free. Returns a structured snapshot the UI can use to
+   * decide whether to offer the user a recovery action — it will not
+   * trigger any signing or persistence.
+   *
+   * Only `transaction.claimed` (success with possible stranded extras)
+   * and refundable failure statuses are recovery candidates. Pending
+   * statuses (`invoice.set`, `transaction.mempool`, …) are returned as
+   * `invalid_swap`; this API is for recovery, not a generic VTXO probe.
+   *
+   * @param swap - The submarine swap to inspect.
+   */
+  async inspectSubmarineRecovery(swap) {
+    if (!isSubmarineSuccessStatus(swap.status) && !isSubmarineRefundableStatus(swap.status)) {
+      return {
+        swap,
+        status: "invalid_swap",
+        vtxoCount: 0,
+        amountSats: 0,
+        refundLocktime: swap.response.timeoutBlockHeights?.refund,
+        error: `Swap status ${swap.status} is not a recovery candidate`
+      };
+    }
+    let lookup;
+    try {
+      lookup = await this.lookupSubmarineVHTLC(swap);
+    } catch (err) {
+      return {
+        swap,
+        status: "invalid_swap",
+        vtxoCount: 0,
+        amountSats: 0,
+        refundLocktime: swap.response.timeoutBlockHeights?.refund,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+    return this.submarineRecoveryInfoFromLookup(swap, lookup);
+  }
+  /**
+   * Scan all locally-known submarine swaps for recoverable VHTLC funds.
+   *
+   * Loads submarine swaps from the repository, filters to recovery
+   * candidates (`transaction.claimed` plus refundable failure
+   * statuses), reconstructs their scripts, and performs one batched
+   * spendable query plus one batched recoverable query. Pending swaps are
+   * skipped entirely — they appear in the local repository but cannot
+   * be in a recovery state yet.
+   *
+   * Side-effect free: does not mutate the repository, does not sign,
+   * and does not query Boltz swap status.
+   */
+  async scanRecoverableSubmarineSwaps() {
+    const submarineSwaps = await this.swapRepository.getAllSwaps({
+      type: "submarine"
+    });
+    const candidates = submarineSwaps.filter(
+      (swap) => isSubmarineSuccessStatus(swap.status) || isSubmarineRefundableStatus(swap.status)
     );
+    let arkInfo;
+    let arkInfoError;
+    if (candidates.length > 0) {
+      try {
+        arkInfo = await this.arkProvider.getInfo();
+      } catch (err) {
+        arkInfoError = err instanceof Error ? err.message : String(err);
+      }
+    }
+    const prepared = await Promise.all(
+      candidates.map(async (swap) => {
+        if (arkInfoError) {
+          return {
+            swap,
+            error: arkInfoError
+          };
+        }
+        try {
+          return {
+            swap,
+            context: await this.buildSubmarineVHTLCContext(
+              swap,
+              arkInfo
+            )
+          };
+        } catch (err) {
+          return {
+            swap,
+            error: err instanceof Error ? err.message : String(err)
+          };
+        }
+      })
+    );
+    const valid = prepared.filter(
+      (item) => "context" in item
+    );
+    const scripts = [
+      ...new Set(valid.map(({ context }) => context.vhtlcPkScriptHex))
+    ];
+    const refundableByScript = /* @__PURE__ */ new Map();
+    if (scripts.length > 0) {
+      const [spendableResult, recoverableResult] = await Promise.all([
+        this.indexerProvider.getVtxos({
+          scripts,
+          spendableOnly: true
+        }),
+        this.indexerProvider.getVtxos({
+          scripts,
+          recoverableOnly: true
+        })
+      ]);
+      for (const vtxo of dedupeVtxos([
+        ...spendableResult.vtxos,
+        ...recoverableResult.vtxos
+      ])) {
+        const script = vtxo.script?.toLowerCase();
+        if (!script) continue;
+        const existing = refundableByScript.get(script) ?? [];
+        existing.push(vtxo);
+        refundableByScript.set(script, existing);
+      }
+    }
+    return prepared.map((item) => {
+      if ("error" in item) {
+        return {
+          swap: item.swap,
+          status: "invalid_swap",
+          vtxoCount: 0,
+          amountSats: 0,
+          refundLocktime: item.swap.response.timeoutBlockHeights?.refund,
+          error: item.error
+        };
+      }
+      const refundableVtxos = refundableByScript.get(
+        item.context.vhtlcPkScriptHex.toLowerCase()
+      ) ?? [];
+      return this.submarineRecoveryInfoFromLookup(item.swap, {
+        ...item.context,
+        refundableVtxos
+      });
+    });
+  }
+  /**
+   * Recover funds locked at a single submarine swap's VHTLC address.
+   *
+   * Thin wrapper around `refundVHTLC` for callers that have already
+   * confirmed (e.g. via `inspectSubmarineRecovery`) that funds are
+   * present. Centralises the spending logic in one place — flag-write
+   * behavior matches `refundVHTLC` (no-op for `transaction.claimed`,
+   * normal flag updates for failure statuses).
+   */
+  async recoverSubmarineFunds(swap, arkInfo) {
+    return this.refundVHTLC(swap, arkInfo);
+  }
+  /**
+   * Recover funds for a batch of submarine swaps.
+   *
+   * Each swap's recovery is independent — a failure on one swap does
+   * not abort the rest, and the caller receives a per-swap result so
+   * they can present partial outcomes in the UI. Recovery runs
+   * sequentially to avoid hammering Boltz / the indexer with parallel
+   * batch joins.
+   */
+  async recoverAllSubmarineFunds(swaps) {
+    const results = [];
+    let arkInfo;
+    try {
+      if (swaps.length > 0) {
+        arkInfo = await this.arkProvider.getInfo();
+      }
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      return swaps.map((swap) => ({
+        swapId: swap.id,
+        recovered: false,
+        skipped: false,
+        error
+      }));
+    }
+    for (const swap of swaps) {
+      try {
+        const outcome = await this.recoverSubmarineFunds(swap, arkInfo);
+        results.push({
+          swapId: swap.id,
+          recovered: outcome.swept > 0,
+          skipped: outcome.skipped > 0
+        });
+      } catch (err) {
+        results.push({
+          swapId: swap.id,
+          recovered: false,
+          skipped: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    return results;
   }
   /**
    * Waits for a submarine swap's Lightning payment to settle.
@@ -4529,14 +4849,14 @@ var ArkadeSwaps = class _ArkadeSwaps {
     const serverPubkey = import_base9.hex.encode(
       normalizeToXOnlyKey(arkInfo.signerPubkey, "server")
     );
-    const timeoutBlockHeights = to === "ARK" ? swap.response.claimDetails.timeouts : swap.response.lockupDetails.timeouts;
+    const vhtlcTimeouts = to === "ARK" ? swap.response.claimDetails.timeouts : swap.response.lockupDetails.timeouts;
     const { vhtlcAddress } = this.createVHTLCScript({
       network: arkInfo.network,
       preimageHash: import_base9.hex.decode(swap.request.preimageHash),
       receiverPubkey,
       senderPubkey,
       serverPubkey,
-      timeoutBlockHeights
+      timeoutBlockHeights: vhtlcTimeouts
     });
     if (lockupAddress !== vhtlcAddress) {
       throw new SwapError({
@@ -4880,6 +5200,25 @@ var ArkadeSwaps = class _ArkadeSwaps {
 // src/serviceWorker/arkade-swaps-message-handler.ts
 var import_sdk9 = require("@arkade-os/sdk");
 var DEFAULT_MESSAGE_TAG = "ARKADE_SWAPS_UPDATER";
+var LONG_RUNNING_ARKADE_SWAPS_REQUEST_TYPES = /* @__PURE__ */ new Set([
+  "SEND_LIGHTNING_PAYMENT",
+  "CLAIM_VHTLC",
+  "REFUND_VHTLC",
+  "INSPECT_SUBMARINE_RECOVERY",
+  "SCAN_RECOVERABLE_SUBMARINE_SWAPS",
+  "RECOVER_SUBMARINE_FUNDS",
+  "RECOVER_ALL_SUBMARINE_FUNDS",
+  "WAIT_AND_CLAIM",
+  "WAIT_FOR_SWAP_SETTLEMENT",
+  "RESTORE_SWAPS",
+  "WAIT_AND_CLAIM_CHAIN",
+  "WAIT_AND_CLAIM_ARK",
+  "WAIT_AND_CLAIM_BTC",
+  "CLAIM_ARK",
+  "CLAIM_BTC",
+  "REFUND_ARK",
+  "SM-WAIT_FOR_COMPLETION"
+]);
 var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
   constructor(swapRepository) {
     this.swapRepository = swapRepository;
@@ -4921,6 +5260,14 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
   async tick(_now) {
     return [];
   }
+  // Flows that surrender control to Boltz, the Ark server, or other
+  // participants in a batch round: quiet gaps between protocol events can
+  // easily exceed the bus-level messageTimeoutMs. Liveness is covered
+  // out-of-band by the page-side PING / MESSAGE_BUS_NOT_INITIALIZED path
+  // triggered by concurrent short requests (GET_FEES, GET_SWAP_STATUS, ...).
+  isLongRunning(message) {
+    return LONG_RUNNING_ARKADE_SWAPS_REQUEST_TYPES.has(message.type);
+  }
   tagged(res) {
     return {
       ...res,
@@ -5002,9 +5349,54 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
         case "CLAIM_VHTLC":
           await this.handler.claimVHTLC(message.payload);
           return this.tagged({ id, type: "VHTLC_CLAIMED" });
-        case "REFUND_VHTLC":
-          await this.handler.refundVHTLC(message.payload);
-          return this.tagged({ id, type: "VHTLC_REFUNDED" });
+        case "REFUND_VHTLC": {
+          const outcome = await this.handler.refundVHTLC(
+            message.payload
+          );
+          return this.tagged({
+            id,
+            type: "VHTLC_REFUNDED",
+            payload: outcome
+          });
+        }
+        case "INSPECT_SUBMARINE_RECOVERY": {
+          const info = await this.handler.inspectSubmarineRecovery(
+            message.payload
+          );
+          return this.tagged({
+            id,
+            type: "SUBMARINE_RECOVERY_INSPECTED",
+            payload: info
+          });
+        }
+        case "SCAN_RECOVERABLE_SUBMARINE_SWAPS": {
+          const infos = await this.handler.scanRecoverableSubmarineSwaps();
+          return this.tagged({
+            id,
+            type: "RECOVERABLE_SUBMARINE_SWAPS_SCANNED",
+            payload: infos
+          });
+        }
+        case "RECOVER_SUBMARINE_FUNDS": {
+          const outcome = await this.handler.recoverSubmarineFunds(
+            message.payload
+          );
+          return this.tagged({
+            id,
+            type: "SUBMARINE_FUNDS_RECOVERED",
+            payload: outcome
+          });
+        }
+        case "RECOVER_ALL_SUBMARINE_FUNDS": {
+          const results = await this.handler.recoverAllSubmarineFunds(
+            message.payload
+          );
+          return this.tagged({
+            id,
+            type: "ALL_SUBMARINE_FUNDS_RECOVERED",
+            payload: results
+          });
+        }
         case "WAIT_AND_CLAIM": {
           const res = await this.handler.waitAndClaim(
             message.payload
@@ -5352,6 +5744,8 @@ var import_sdk10 = require("@arkade-os/sdk");
 function isMessageBusNotInitializedError(error) {
   return error instanceof Error && error.message.includes(import_sdk10.MESSAGE_BUS_NOT_INITIALIZED);
 }
+var DEFAULT_MESSAGE_TIMEOUT_MS = 3e4;
+var NO_MESSAGE_TIMEOUT_MS = 0;
 var DEDUPABLE_REQUEST_TYPES = /* @__PURE__ */ new Set([
   "GET_FEES",
   "GET_LIMITS",
@@ -5627,12 +6021,48 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
     });
   }
   async refundVHTLC(pendingSwap) {
-    await this.sendMessage({
+    const res = await this.sendMessage({
       id: getRandomId(),
       tag: this.messageTag,
       type: "REFUND_VHTLC",
       payload: pendingSwap
     });
+    return res.payload;
+  }
+  async inspectSubmarineRecovery(swap) {
+    const res = await this.sendMessage({
+      id: getRandomId(),
+      tag: this.messageTag,
+      type: "INSPECT_SUBMARINE_RECOVERY",
+      payload: swap
+    });
+    return res.payload;
+  }
+  async scanRecoverableSubmarineSwaps() {
+    const res = await this.sendMessage({
+      id: getRandomId(),
+      tag: this.messageTag,
+      type: "SCAN_RECOVERABLE_SUBMARINE_SWAPS"
+    });
+    return res.payload;
+  }
+  async recoverSubmarineFunds(swap) {
+    const res = await this.sendMessage({
+      id: getRandomId(),
+      tag: this.messageTag,
+      type: "RECOVER_SUBMARINE_FUNDS",
+      payload: swap
+    });
+    return res.payload;
+  }
+  async recoverAllSubmarineFunds(swaps) {
+    const res = await this.sendMessage({
+      id: getRandomId(),
+      tag: this.messageTag,
+      type: "RECOVER_ALL_SUBMARINE_FUNDS",
+      payload: swaps
+    });
+    return res.payload;
   }
   async waitAndClaim(pendingSwap) {
     try {
@@ -5961,7 +6391,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async [Symbol.asyncDispose]() {
     return this.dispose();
   }
-  sendMessageDirect(request) {
+  sendMessageDirect(request, timeoutMs) {
     return new Promise((resolve, reject) => {
       const cleanup = () => {
         clearTimeout(timeoutId);
@@ -5970,14 +6400,14 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
           messageHandler
         );
       };
-      const timeoutId = setTimeout(() => {
+      const timeoutId = timeoutMs > 0 ? setTimeout(() => {
         cleanup();
         reject(
           new import_sdk10.ServiceWorkerTimeoutError(
             `Service worker message timed out (${request.type})`
           )
         );
-      }, 3e4);
+      }, timeoutMs) : void 0;
       const messageHandler = (event) => {
         const response = event.data;
         if (!response || response.tag !== this.messageTag || response.id !== request.id) {
@@ -6052,10 +6482,13 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
         await this.reinitialize();
       }
     }
+    const timeoutMs = LONG_RUNNING_ARKADE_SWAPS_REQUEST_TYPES.has(
+      request.type
+    ) ? NO_MESSAGE_TIMEOUT_MS : DEFAULT_MESSAGE_TIMEOUT_MS;
     const maxRetries = 2;
     for (let attempt = 0; ; attempt++) {
       try {
-        return await this.sendMessageDirect(request);
+        return await this.sendMessageDirect(request, timeoutMs);
       } catch (error) {
         if (!isMessageBusNotInitializedError(error) || attempt >= maxRetries) {
           throw error;
@@ -6076,7 +6509,10 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
         id: getRandomId(),
         payload: this.initPayload
       };
-      await this.sendMessageDirect(initMessage);
+      await this.sendMessageDirect(
+        initMessage,
+        DEFAULT_MESSAGE_TIMEOUT_MS
+      );
     })().finally(() => {
       this.reinitPromise = null;
     });