@arkade-os/boltz-swap 0.3.43 → 0.3.45

package/dist/{arkade-swaps-LvsGHtre.d.ts → arkade-swaps-C8CmzknM.d.cts}

@@ -1,5 +1,5 @@
 import { IWallet, ArkProvider, IndexerProvider, ArkInfo, Identity, ArkTxInput, VHTLC } from '@arkade-os/sdk';
-import { r as BoltzSwapProvider, y as SwapManager, m as SwapRepository, q as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, n as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, o as SendLightningPaymentResponse, O as OptimisticSendLightningPaymentResponse, c as BoltzSubmarineSwap, f as SubmarineRefundOutcome, g as SubmarineRecoveryInfo, h as SubmarineRecoveryResult, j as ArkToBtcResponse, a as BoltzChainSwap, l as ChainArkRefundOutcome, k as BtcToArkResponse, d as Chain, F as FeesResponse, i as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-8NrCdOpS.js';
+import { r as BoltzSwapProvider, y as SwapManager, m as SwapRepository, q as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, n as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, o as SendLightningPaymentResponse, O as OptimisticSendLightningPaymentResponse, c as BoltzSubmarineSwap, f as SubmarineRefundOutcome, g as SubmarineRecoveryInfo, h as SubmarineRecoveryResult, j as ArkToBtcResponse, a as BoltzChainSwap, l as ChainArkRefundOutcome, k as BtcToArkResponse, d as Chain, F as FeesResponse, i as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-CS62-oEy.cjs';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
 
 /**
@@ -324,7 +324,10 @@ declare class ArkadeSwaps {
      * swap's ARK lockup address.
      *
      * Path selection per VTXO:
-     * - CLTV has elapsed → `refundWithoutReceiver` via `joinBatch` (no Boltz).
+     * - CLTV elapsed, live VTXO → `refundWithoutReceiver` offchain (sender +
+     *   server, no Boltz, no batch round).
+     * - CLTV elapsed, swept VTXO → `refundWithoutReceiver` via `joinBatch`
+     *   (a swept VTXO is no longer a live leaf).
      * - Pre-CLTV recoverable → skipped (Boltz can't co-sign swept-batch refund).
      * - Pre-CLTV non-recoverable → cooperative 3-of-3 refund via Boltz.
      *
@@ -463,6 +466,29 @@ declare class ArkadeSwaps {
      * @returns The commitment transaction ID.
      */
     joinBatch(identity: Identity, input: ArkTxInput, output: TransactionOutput, arkInfo: ArkInfo, isRecoverable?: boolean): Promise<string>;
+    /**
+     * Settle a `refundWithoutReceiver` (sender + server, no Boltz) refund for a
+     * single VTXO whose CLTV refund locktime has elapsed.
+     *
+     * A live VTXO settles the leaf with an offchain Ark tx — no batch round. A
+     * swept (recoverable) VTXO is no longer a live leaf, so it can only be
+     * reclaimed by re-registering it into a batch.
+     */
+    private settleRefundWithoutReceiver;
+    /**
+     * Refund every VTXO at a swap's VHTLC address back to the wallet, shared by
+     * {@link ArkadeSwaps.refundVHTLC} (submarine) and {@link ArkadeSwaps.refundArk}
+     * (chain). Path selection per VTXO:
+     * - CLTV elapsed → `refundWithoutReceiver` (offchain for a live VTXO, via a
+     *   batch round for a swept one — see {@link settleRefundWithoutReceiver}).
+     * - Pre-CLTV recoverable → skipped (Boltz can't co-sign a swept-batch refund).
+     * - Pre-CLTV non-recoverable → cooperative 3-of-3 refund via Boltz, falling
+     *   back to `refundWithoutReceiver` offchain if Boltz rejects after the
+     *   locktime has since elapsed.
+     *
+     * @returns Counts of VTXOs swept vs. deferred.
+     */
+    private refundVtxos;
     /**
      * Creates a VHTLC script for the swap.
      * Works for submarine, reverse, and chain swaps.

package/dist/{arkade-swaps-C3sUFr5f.d.cts → arkade-swaps-gXHRbR09.d.ts}

@@ -1,5 +1,5 @@
 import { IWallet, ArkProvider, IndexerProvider, ArkInfo, Identity, ArkTxInput, VHTLC } from '@arkade-os/sdk';
-import { r as BoltzSwapProvider, y as SwapManager, m as SwapRepository, q as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, n as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, o as SendLightningPaymentResponse, O as OptimisticSendLightningPaymentResponse, c as BoltzSubmarineSwap, f as SubmarineRefundOutcome, g as SubmarineRecoveryInfo, h as SubmarineRecoveryResult, j as ArkToBtcResponse, a as BoltzChainSwap, l as ChainArkRefundOutcome, k as BtcToArkResponse, d as Chain, F as FeesResponse, i as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-8NrCdOpS.cjs';
+import { r as BoltzSwapProvider, y as SwapManager, m as SwapRepository, q as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, n as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, o as SendLightningPaymentResponse, O as OptimisticSendLightningPaymentResponse, c as BoltzSubmarineSwap, f as SubmarineRefundOutcome, g as SubmarineRecoveryInfo, h as SubmarineRecoveryResult, j as ArkToBtcResponse, a as BoltzChainSwap, l as ChainArkRefundOutcome, k as BtcToArkResponse, d as Chain, F as FeesResponse, i as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-CS62-oEy.js';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
 
 /**
@@ -324,7 +324,10 @@ declare class ArkadeSwaps {
      * swap's ARK lockup address.
      *
      * Path selection per VTXO:
-     * - CLTV has elapsed → `refundWithoutReceiver` via `joinBatch` (no Boltz).
+     * - CLTV elapsed, live VTXO → `refundWithoutReceiver` offchain (sender +
+     *   server, no Boltz, no batch round).
+     * - CLTV elapsed, swept VTXO → `refundWithoutReceiver` via `joinBatch`
+     *   (a swept VTXO is no longer a live leaf).
      * - Pre-CLTV recoverable → skipped (Boltz can't co-sign swept-batch refund).
      * - Pre-CLTV non-recoverable → cooperative 3-of-3 refund via Boltz.
      *
@@ -463,6 +466,29 @@ declare class ArkadeSwaps {
      * @returns The commitment transaction ID.
      */
     joinBatch(identity: Identity, input: ArkTxInput, output: TransactionOutput, arkInfo: ArkInfo, isRecoverable?: boolean): Promise<string>;
+    /**
+     * Settle a `refundWithoutReceiver` (sender + server, no Boltz) refund for a
+     * single VTXO whose CLTV refund locktime has elapsed.
+     *
+     * A live VTXO settles the leaf with an offchain Ark tx — no batch round. A
+     * swept (recoverable) VTXO is no longer a live leaf, so it can only be
+     * reclaimed by re-registering it into a batch.
+     */
+    private settleRefundWithoutReceiver;
+    /**
+     * Refund every VTXO at a swap's VHTLC address back to the wallet, shared by
+     * {@link ArkadeSwaps.refundVHTLC} (submarine) and {@link ArkadeSwaps.refundArk}
+     * (chain). Path selection per VTXO:
+     * - CLTV elapsed → `refundWithoutReceiver` (offchain for a live VTXO, via a
+     *   batch round for a swept one — see {@link settleRefundWithoutReceiver}).
+     * - Pre-CLTV recoverable → skipped (Boltz can't co-sign a swept-batch refund).
+     * - Pre-CLTV non-recoverable → cooperative 3-of-3 refund via Boltz, falling
+     *   back to `refundWithoutReceiver` offchain if Boltz rejects after the
+     *   locktime has since elapsed.
+     *
+     * @returns Counts of VTXOs swept vs. deferred.
+     */
+    private refundVtxos;
     /**
      * Creates a VHTLC script for the swap.
      * Works for submarine, reverse, and chain swaps.

package/dist/{chunk-UXYHW7KV.js → chunk-5GBBRBFS.js}

@@ -571,20 +571,26 @@ var BoltzSwapProvider = class {
     invoiceAmount,
     claimPublicKey,
     preimageHash,
-    description
+    description,
+    descriptionHash
   }) {
     if (claimPublicKey.length != 66) {
       throw new SwapError({
         message: "claimPublicKey must be a compressed public key"
       });
     }
+    if (descriptionHash !== void 0 && !/^[0-9a-fA-F]{64}$/.test(descriptionHash)) {
+      throw new SwapError({
+        message: "descriptionHash must be a 32-byte SHA256 (64 hex chars)"
+      });
+    }
     const requestBody = {
       from: "BTC",
       to: "ARK",
       invoiceAmount,
       claimPublicKey,
       preimageHash,
-      description: description?.trim() || "Send to Arkade address",
+      ...descriptionHash ? { descriptionHash } : { description: description?.trim() || "Send to Arkade address" },
       ...this.referralId ? { referralId: this.referralId } : {}
     };
     const response = await this.request(
@@ -997,6 +1003,12 @@ var decodeInvoice = (invoice) => {
     expiry: decoded.expiry ?? 3600,
     amountSats: Number(millisats / 1000n),
     description: decoded.sections.find((s) => s.name === "description")?.value ?? "",
+    // description_hash (BOLT11 `h`) is missing from light-bolt11-decoder's
+    // Section union even though the decoder emits it. Widen just this lookup
+    // rather than patch the library's types (separate repo, out of scope).
+    descriptionHash: decoded.sections.find(
+      (s) => s.name === "description_hash"
+    )?.value ?? "",
     paymentHash: decoded.sections.find((s) => s.name === "payment_hash")?.value ?? ""
   };
 };
@@ -3100,6 +3112,40 @@ var claimVHTLCwithOffchainTx = async (identity, vhtlcScript, serverXOnlyPublicKe
   await arkProvider.finalizeTx(arkTxid, finalCheckpoints);
   return arkTxid;
 };
+var refundWithoutReceiverVHTLCwithOffchainTx = async (identity, vhtlcScript, serverXOnlyPublicKey, input, output, arkInfo, arkProvider) => {
+  const rawCheckpointTapscript = hex7.decode(arkInfo.checkpointTapscript);
+  const serverUnrollScript = CSVMultisigTapscript2.decode(rawCheckpointTapscript);
+  const { arkTx, checkpoints } = buildOffchainTx([input], [output], serverUnrollScript);
+  const signedArkTx = await identity.sign(arkTx);
+  const { arkTxid, finalArkTx, signedCheckpointTxs } = await arkProvider.submitTx(
+    base643.encode(signedArkTx.toPSBT()),
+    checkpoints.map((c) => base643.encode(c.toPSBT()))
+  );
+  const finalTx = Transaction5.fromPSBT(base643.decode(finalArkTx));
+  const serverPubkeyHex = hex7.encode(serverXOnlyPublicKey);
+  const refundLeafHash = tapLeafHash3(
+    scriptFromTapLeafScript(vhtlcScript.refundWithoutReceiver())
+  );
+  for (let i = 0; i < finalTx.inputsLength; i++) {
+    if (!verifySignatures(finalTx, i, [serverPubkeyHex], refundLeafHash)) {
+      throw new Error("Invalid final Ark transaction");
+    }
+  }
+  const finalCheckpoints = await Promise.all(
+    signedCheckpointTxs.map(async (c, idx) => {
+      const tx = Transaction5.fromPSBT(base643.decode(c));
+      const checkpointLeaf = checkpoints[idx].getInput(0).tapLeafScript[0];
+      const cpLeafHash = tapLeafHash3(scriptFromTapLeafScript(checkpointLeaf));
+      if (!verifySignatures(tx, 0, [serverPubkeyHex], cpLeafHash)) {
+        throw new Error("Invalid server signature in checkpoint transaction");
+      }
+      const signedCheckpoint = await identity.sign(tx, [0]);
+      return base643.encode(signedCheckpoint.toPSBT());
+    })
+  );
+  await arkProvider.finalizeTx(arkTxid, finalCheckpoints);
+  return arkTxid;
+};
 var refundVHTLCwithOffchainTx = async (swapId, identity, arkProvider, boltzXOnlyPublicKey, ourXOnlyPublicKey, serverXOnlyPublicKey, input, output, arkInfo, refundFunc) => {
   const rawCheckpointTapscript = hex7.decode(arkInfo.checkpointTapscript);
   const serverUnrollScript = CSVMultisigTapscript2.decode(rawCheckpointTapscript);
@@ -3406,7 +3452,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       invoiceAmount: args.amount,
       claimPublicKey,
       preimageHash,
-      ...args.description?.trim() ? { description: args.description.trim() } : {}
+      ...args.descriptionHash !== void 0 ? { descriptionHash: args.descriptionHash } : args.description?.trim() ? { description: args.description.trim() } : {}
     };
     const swapResponse = await this.swapProvider.createReverseSwap(swapRequest);
     const decodedInvoice = decodeInvoice(swapResponse.invoice);
@@ -3854,85 +3900,22 @@ var ArkadeSwaps = class _ArkadeSwaps {
     }
     const outputScript = ArkAddress2.decode(address).pkScript;
     const refundWithoutReceiverLeaf = vhtlcScript.refundWithoutReceiver();
-    const cltvSatisfied = isSubmarineRefundLocktimeReached(vhtlcTimeouts.refund);
-    let boltzCallCount = 0;
-    let sweptCount = 0;
-    let skippedCount = 0;
-    for (const vtxo of refundableVtxos) {
-      const isRecoverableVtxo = isRecoverable(vtxo);
-      const output = {
-        amount: BigInt(vtxo.value),
-        script: outputScript
-      };
-      if (cltvSatisfied) {
-        const input2 = {
-          ...vtxo,
-          tapLeafScript: refundWithoutReceiverLeaf,
-          tapTree: vhtlcScript.encode()
-        };
-        await this.joinBatch(
-          this.wallet.identity,
-          input2,
-          output,
-          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=${vhtlcTimeouts.refund}, currentTimestamp=${Math.floor(Date.now() / 1e3)}). Refund will be retried after locktime.`
-        );
-        skippedCount++;
-        continue;
-      }
-      const input = {
-        ...vtxo,
-        tapLeafScript: vhtlcScript.refund(),
-        tapTree: vhtlcScript.encode()
-      };
-      try {
-        if (boltzCallCount > 0) {
-          await new Promise((r) => setTimeout(r, 2e3));
-        }
-        boltzCallCount++;
-        await refundVHTLCwithOffchainTx(
-          pendingSwap.id,
-          this.wallet.identity,
-          this.arkProvider,
-          boltzXOnlyPublicKey,
-          ourXOnlyPublicKey,
-          serverXOnlyPublicKey,
-          input,
-          output,
-          arkInfo,
-          this.swapProvider.refundSubmarineSwap.bind(this.swapProvider)
-        );
-        sweptCount++;
-      } catch (error) {
-        if (!(error instanceof BoltzRefundError)) {
-          throw error;
-        }
-        if (!isSubmarineRefundLocktimeReached(vhtlcTimeouts.refund)) {
-          logger.error(
-            `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;
-        }
-        logger.warn(
-          `Swap ${pendingSwap.id}: Boltz rejected VTXO outpoint, falling back to refundWithoutReceiver via joinBatch`
-        );
-        const fallbackInput = {
-          ...vtxo,
-          tapLeafScript: refundWithoutReceiverLeaf,
-          tapTree: vhtlcScript.encode()
-        };
-        await this.joinBatch(this.wallet.identity, fallbackInput, output, arkInfo, false);
-        sweptCount++;
-      }
-    }
+    const refundContext = {
+      arkInfo,
+      vhtlcScript,
+      serverXOnlyPublicKey,
+      refundWithoutReceiverLeaf,
+      outputScript
+    };
+    const { swept: sweptCount, skipped: skippedCount } = await this.refundVtxos({
+      swapId: pendingSwap.id,
+      vtxos: refundableVtxos,
+      refundLocktime: vhtlcTimeouts.refund,
+      refundContext,
+      boltzXOnlyPublicKey,
+      ourXOnlyPublicKey,
+      refundViaBoltz: this.swapProvider.refundSubmarineSwap.bind(this.swapProvider)
+    });
     if (!isSubmarineSuccessStatus(pendingSwap.status)) {
       const fullyRefunded = skippedCount === 0;
       await updateSubmarineSwapStatus(
@@ -4490,7 +4473,10 @@ var ArkadeSwaps = class _ArkadeSwaps {
    * swap's ARK lockup address.
    *
    * Path selection per VTXO:
-   * - CLTV has elapsed → `refundWithoutReceiver` via `joinBatch` (no Boltz).
+   * - CLTV elapsed, live VTXO → `refundWithoutReceiver` offchain (sender +
+   *   server, no Boltz, no batch round).
+   * - CLTV elapsed, swept VTXO → `refundWithoutReceiver` via `joinBatch`
+   *   (a swept VTXO is no longer a live leaf).
    * - Pre-CLTV recoverable → skipped (Boltz can't co-sign swept-batch refund).
    * - Pre-CLTV non-recoverable → cooperative 3-of-3 refund via Boltz.
    *
@@ -4547,84 +4533,22 @@ var ArkadeSwaps = class _ArkadeSwaps {
     const outputScript = ArkAddress2.decode(address).pkScript;
     const refundWithoutReceiverLeaf = vhtlcScript.refundWithoutReceiver();
     const refundLocktime = pendingSwap.response.lockupDetails.timeouts.refund;
-    let boltzCallCount = 0;
-    let sweptCount = 0;
-    let skippedCount = 0;
-    for (const vtxo of unspentVtxos) {
-      const isRecoverableVtxo = isRecoverable(vtxo);
-      const output = {
-        amount: BigInt(vtxo.value),
-        script: outputScript
-      };
-      if (isSubmarineRefundLocktimeReached(refundLocktime)) {
-        const input2 = {
-          ...vtxo,
-          tapLeafScript: refundWithoutReceiverLeaf,
-          tapTree: vhtlcScript.encode()
-        };
-        await this.joinBatch(
-          this.wallet.identity,
-          input2,
-          output,
-          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=${refundLocktime}, currentTimestamp=${Math.floor(Date.now() / 1e3)}). Refund will be retried after locktime.`
-        );
-        skippedCount++;
-        continue;
-      }
-      const input = {
-        ...vtxo,
-        tapLeafScript: vhtlcScript.refund(),
-        tapTree: vhtlcScript.encode()
-      };
-      try {
-        if (boltzCallCount > 0) {
-          await new Promise((r) => setTimeout(r, 2e3));
-        }
-        boltzCallCount++;
-        await refundVHTLCwithOffchainTx(
-          pendingSwap.id,
-          this.wallet.identity,
-          this.arkProvider,
-          boltzXOnlyPublicKey,
-          ourXOnlyPublicKey,
-          serverXOnlyPublicKey,
-          input,
-          output,
-          arkInfo,
-          this.swapProvider.refundChainSwap.bind(this.swapProvider)
-        );
-        sweptCount++;
-      } catch (error) {
-        if (!(error instanceof BoltzRefundError)) {
-          throw error;
-        }
-        if (!isSubmarineRefundLocktimeReached(refundLocktime)) {
-          logger.error(
-            `Swap ${pendingSwap.id}: Boltz rejected VTXO outpoint and refundWithoutReceiver locktime has not passed yet (currentTimestamp=${Math.floor(Date.now() / 1e3)}, locktime=${refundLocktime}). Refund will be retried after locktime.`
-          );
-          skippedCount++;
-          continue;
-        }
-        logger.warn(
-          `Swap ${pendingSwap.id}: Boltz rejected VTXO outpoint, falling back to refundWithoutReceiver via joinBatch`
-        );
-        const fallbackInput = {
-          ...vtxo,
-          tapLeafScript: refundWithoutReceiverLeaf,
-          tapTree: vhtlcScript.encode()
-        };
-        await this.joinBatch(this.wallet.identity, fallbackInput, output, arkInfo, false);
-        sweptCount++;
-      }
-    }
+    const refundContext = {
+      arkInfo,
+      vhtlcScript,
+      serverXOnlyPublicKey,
+      refundWithoutReceiverLeaf,
+      outputScript
+    };
+    const { swept: sweptCount, skipped: skippedCount } = await this.refundVtxos({
+      swapId: pendingSwap.id,
+      vtxos: unspentVtxos,
+      refundLocktime,
+      refundContext,
+      boltzXOnlyPublicKey,
+      ourXOnlyPublicKey,
+      refundViaBoltz: this.swapProvider.refundChainSwap.bind(this.swapProvider)
+    });
     const finalStatus = await this.getSwapStatus(pendingSwap.id);
     await this.savePendingChainSwap({
       ...pendingSwap,
@@ -5157,6 +5081,120 @@ var ArkadeSwaps = class _ArkadeSwaps {
   async joinBatch(identity, input, output, arkInfo, isRecoverable2 = true) {
     return joinBatch(this.arkProvider, identity, input, output, arkInfo, isRecoverable2);
   }
+  /**
+   * Settle a `refundWithoutReceiver` (sender + server, no Boltz) refund for a
+   * single VTXO whose CLTV refund locktime has elapsed.
+   *
+   * A live VTXO settles the leaf with an offchain Ark tx — no batch round. A
+   * swept (recoverable) VTXO is no longer a live leaf, so it can only be
+   * reclaimed by re-registering it into a batch.
+   */
+  async settleRefundWithoutReceiver(ctx, vtxo) {
+    const input = {
+      ...vtxo,
+      tapLeafScript: ctx.refundWithoutReceiverLeaf,
+      tapTree: ctx.vhtlcScript.encode()
+    };
+    const output = { amount: BigInt(vtxo.value), script: ctx.outputScript };
+    if (isRecoverable(vtxo)) {
+      await this.joinBatch(this.wallet.identity, input, output, ctx.arkInfo, true);
+    } else {
+      await refundWithoutReceiverVHTLCwithOffchainTx(
+        this.wallet.identity,
+        ctx.vhtlcScript,
+        ctx.serverXOnlyPublicKey,
+        input,
+        output,
+        ctx.arkInfo,
+        this.arkProvider
+      );
+    }
+  }
+  /**
+   * Refund every VTXO at a swap's VHTLC address back to the wallet, shared by
+   * {@link ArkadeSwaps.refundVHTLC} (submarine) and {@link ArkadeSwaps.refundArk}
+   * (chain). Path selection per VTXO:
+   * - CLTV elapsed → `refundWithoutReceiver` (offchain for a live VTXO, via a
+   *   batch round for a swept one — see {@link settleRefundWithoutReceiver}).
+   * - Pre-CLTV recoverable → skipped (Boltz can't co-sign a swept-batch refund).
+   * - Pre-CLTV non-recoverable → cooperative 3-of-3 refund via Boltz, falling
+   *   back to `refundWithoutReceiver` offchain if Boltz rejects after the
+   *   locktime has since elapsed.
+   *
+   * @returns Counts of VTXOs swept vs. deferred.
+   */
+  async refundVtxos(params) {
+    const {
+      swapId,
+      vtxos,
+      refundLocktime,
+      refundContext,
+      boltzXOnlyPublicKey,
+      ourXOnlyPublicKey,
+      refundViaBoltz
+    } = params;
+    const { vhtlcScript, serverXOnlyPublicKey, arkInfo, outputScript } = refundContext;
+    let boltzCallCount = 0;
+    let sweptCount = 0;
+    let skippedCount = 0;
+    for (const vtxo of vtxos) {
+      const isRecoverableVtxo = isRecoverable(vtxo);
+      const output = { amount: BigInt(vtxo.value), script: outputScript };
+      if (isSubmarineRefundLocktimeReached(refundLocktime)) {
+        await this.settleRefundWithoutReceiver(refundContext, vtxo);
+        sweptCount++;
+        continue;
+      }
+      if (isRecoverableVtxo) {
+        logger.error(
+          `Swap ${swapId}: recoverable VTXO ${vtxo.txid}:${vtxo.vout} cannot be refunded yet \u2014 refundWithoutReceiver locktime has not passed (refundLocktime=${refundLocktime}, currentTimestamp=${Math.floor(Date.now() / 1e3)}). Refund will be retried after locktime.`
+        );
+        skippedCount++;
+        continue;
+      }
+      const input = {
+        ...vtxo,
+        tapLeafScript: vhtlcScript.refund(),
+        tapTree: vhtlcScript.encode()
+      };
+      try {
+        if (boltzCallCount > 0) {
+          await new Promise((r) => setTimeout(r, 2e3));
+        }
+        boltzCallCount++;
+        await refundVHTLCwithOffchainTx(
+          swapId,
+          this.wallet.identity,
+          this.arkProvider,
+          boltzXOnlyPublicKey,
+          ourXOnlyPublicKey,
+          serverXOnlyPublicKey,
+          input,
+          output,
+          arkInfo,
+          refundViaBoltz
+        );
+        sweptCount++;
+      } catch (error) {
+        if (!(error instanceof BoltzRefundError)) {
+          throw error;
+        }
+        if (!isSubmarineRefundLocktimeReached(refundLocktime)) {
+          logger.error(
+            `Swap ${swapId}: Boltz rejected VTXO outpoint and refundWithoutReceiver locktime has not passed yet (currentTimestamp=${Math.floor(Date.now() / 1e3)}, locktime=${refundLocktime}). Refund will be retried after locktime.`
+          );
+          skippedCount++;
+          continue;
+        }
+        logger.warn(
+          `Swap ${swapId}: Boltz rejected VTXO outpoint, falling back to refundWithoutReceiver offchain`
+        );
+        await this.settleRefundWithoutReceiver(refundContext, vtxo);
+        sweptCount++;
+      }
+    }
+    return { swept: sweptCount, skipped: skippedCount };
+  }
   /**
    * Creates a VHTLC script for the swap.
    * Works for submarine, reverse, and chain swaps.

package/dist/{chunk-CWY37W4B.js → chunk-WPAI2ECT.js}

@@ -7,7 +7,7 @@ import {
   isSubmarineFinalStatus,
   isSubmarineSwapRefundable,
   logger
-} from "./chunk-UXYHW7KV.js";
+} from "./chunk-5GBBRBFS.js";
 
 // src/expo/swapsPollProcessor.ts
 var SWAP_POLL_TASK_TYPE = "swap-poll";