@arkade-os/boltz-swap 0.3.43 → 0.3.45

package/dist/expo/background.cjs

@@ -544,20 +544,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(
@@ -1312,6 +1318,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 ?? ""
   };
 };
@@ -3043,6 +3055,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);
@@ -3349,7 +3395,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);
@@ -3797,85 +3843,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 +4416,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 +4476,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 +5024,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.d.cts

@@ -1,8 +1,8 @@
-import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor-CGMXUKPe.cjs';
-export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor-CGMXUKPe.cjs';
+import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor-B98F6MQF.cjs';
+export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor-B98F6MQF.cjs';
 import '@arkade-os/sdk/worker/expo';
 import '@arkade-os/sdk';
-import '../types-8NrCdOpS.cjs';
+import '../types-CS62-oEy.cjs';
 
 /**
  * Define the Expo background task handler for swap polling.

package/dist/expo/background.d.ts

@@ -1,8 +1,8 @@
-import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor-CuDM6sxV.js';
-export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor-CuDM6sxV.js';
+import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor-Ov-wp17v.js';
+export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor-Ov-wp17v.js';
 import '@arkade-os/sdk/worker/expo';
 import '@arkade-os/sdk';
-import '../types-8NrCdOpS.js';
+import '../types-CS62-oEy.js';
 
 /**
  * Define the Expo background task handler for swap polling.

package/dist/expo/background.js

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