@arkade-os/boltz-swap 0.3.43 → 0.3.44

package/dist/expo/background.cjs

@@ -3043,6 +3043,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 = import_base8.hex.decode(arkInfo.checkpointTapscript);
+  const serverUnrollScript = import_sdk7.CSVMultisigTapscript.decode(rawCheckpointTapscript);
+  const { arkTx, checkpoints } = (0, import_sdk7.buildOffchainTx)([input], [output], serverUnrollScript);
+  const signedArkTx = await identity.sign(arkTx);
+  const { arkTxid, finalArkTx, signedCheckpointTxs } = await arkProvider.submitTx(
+    import_base8.base64.encode(signedArkTx.toPSBT()),
+    checkpoints.map((c) => import_base8.base64.encode(c.toPSBT()))
+  );
+  const finalTx = import_sdk7.Transaction.fromPSBT(import_base8.base64.decode(finalArkTx));
+  const serverPubkeyHex = import_base8.hex.encode(serverXOnlyPublicKey);
+  const refundLeafHash = (0, import_payment3.tapLeafHash)(
+    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 = import_sdk7.Transaction.fromPSBT(import_base8.base64.decode(c));
+      const checkpointLeaf = checkpoints[idx].getInput(0).tapLeafScript[0];
+      const cpLeafHash = (0, import_payment3.tapLeafHash)(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 import_base8.base64.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 = import_base8.hex.decode(arkInfo.checkpointTapscript);
   const serverUnrollScript = import_sdk7.CSVMultisigTapscript.decode(rawCheckpointTapscript);
@@ -3797,85 +3831,22 @@ var ArkadeSwaps = class _ArkadeSwaps {
     }
     const outputScript = import_sdk8.ArkAddress.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 = (0, import_sdk8.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(
@@ -4433,7 +4404,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.
    *
@@ -4490,84 +4464,22 @@ var ArkadeSwaps = class _ArkadeSwaps {
     const outputScript = import_sdk8.ArkAddress.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 = (0, import_sdk8.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,
@@ -5100,6 +5012,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 ((0, import_sdk8.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 = (0, import_sdk8.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/expo/background.js

@@ -1,10 +1,10 @@
 import {
   SWAP_POLL_TASK_TYPE,
   swapsPollProcessor
-} from "../chunk-CWY37W4B.js";
+} from "../chunk-PHF6C2NE.js";
 import {
   BoltzSwapProvider
-} from "../chunk-UXYHW7KV.js";
+} from "../chunk-QVXFEX5F.js";
 import "../chunk-SJQJQO7P.js";
 
 // src/expo/background.ts