@arkade-os/boltz-swap 0.3.14 → 0.3.16

package/dist/expo/index.js

@@ -4,10 +4,10 @@ import {
   registerExpoSwapBackgroundTask,
   swapsPollProcessor,
   unregisterExpoSwapBackgroundTask
-} from "../chunk-2TWYSAFO.js";
+} from "../chunk-CNH5DDKV.js";
 import {
   ArkadeSwaps
-} from "../chunk-AIVWXKNG.js";
+} from "../chunk-RL4PDED5.js";
 import "../chunk-3RG5ZIWI.js";
 
 // src/expo/arkade-lightning.ts
@@ -56,7 +56,7 @@ var ExpoArkadeSwaps = class _ExpoArkadeSwaps {
     await instance.seedSwapPollTask();
     if (config.background.minimumBackgroundInterval) {
       try {
-        const { registerExpoSwapBackgroundTask: registerExpoSwapBackgroundTask2 } = await import("../background-5XMCGVMS.js");
+        const { registerExpoSwapBackgroundTask: registerExpoSwapBackgroundTask2 } = await import("../background-DX6SZGGJ.js");
         await registerExpoSwapBackgroundTask2(
           config.background.taskName,
           {
@@ -129,7 +129,7 @@ var ExpoArkadeSwaps = class _ExpoArkadeSwaps {
     }
     await this.inner.dispose();
     try {
-      const { unregisterExpoSwapBackgroundTask: unregisterExpoSwapBackgroundTask2 } = await import("../background-5XMCGVMS.js");
+      const { unregisterExpoSwapBackgroundTask: unregisterExpoSwapBackgroundTask2 } = await import("../background-DX6SZGGJ.js");
       await unregisterExpoSwapBackgroundTask2(this.taskName);
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);

package/dist/index.cjs

@@ -33,6 +33,7 @@ __export(index_exports, {
   ArkadeLightningMessageHandler: () => ArkadeSwapsMessageHandler,
   ArkadeSwaps: () => ArkadeSwaps,
   ArkadeSwapsMessageHandler: () => ArkadeSwapsMessageHandler,
+  BoltzRefundError: () => BoltzRefundError,
   BoltzSwapProvider: () => BoltzSwapProvider,
   IndexedDbSwapRepository: () => IndexedDbSwapRepository,
   InsufficientFundsError: () => InsufficientFundsError,
@@ -176,6 +177,13 @@ var TransactionRefundedError = class extends SwapError {
     this.name = "TransactionRefundedError";
   }
 };
+var BoltzRefundError = class extends Error {
+  constructor(message, cause) {
+    super(message);
+    this.cause = cause;
+    this.name = "BoltzRefundError";
+  }
+};
 
 // src/arkade-swaps.ts
 var import_sdk8 = require("@arkade-os/sdk");
@@ -314,7 +322,7 @@ var isGetReverseSwapTxIdResponse = (data) => {
   return data && typeof data === "object" && typeof data.id === "string" && typeof data.timeoutBlockHeight === "number";
 };
 var isGetSwapStatusResponse = (data) => {
-  return data && typeof data === "object" && typeof data.status === "string" && (data.zeroConfRejected === void 0 || typeof data.zeroConfRejected === "boolean") && (data.transaction === void 0 || data.transaction && typeof data.transaction === "object" && typeof data.transaction.id === "string" && (data.transaction.eta === void 0 || typeof data.transaction.eta === "number") && (data.transaction.hex === void 0 || typeof data.transaction.hex === "string") && (data.transaction.preimage === void 0 || typeof data.transaction.preimage === "string"));
+  return data && typeof data === "object" && typeof data.status === "string" && (data.zeroConfRejected === void 0 || typeof data.zeroConfRejected === "boolean") && (data.transaction === void 0 || data.transaction && typeof data.transaction === "object" && typeof data.transaction.id === "string" && (data.transaction.confirmed === void 0 || typeof data.transaction.confirmed === "boolean") && (data.transaction.eta === void 0 || typeof data.transaction.eta === "number") && (data.transaction.hex === void 0 || typeof data.transaction.hex === "string") && (data.transaction.preimage === void 0 || typeof data.transaction.preimage === "string"));
 };
 var isGetSubmarinePairsResponse = (data) => {
   return data && typeof data === "object" && data.ARK && typeof data.ARK === "object" && data.ARK.BTC && typeof data.ARK.BTC === "object" && typeof data.ARK.BTC.hash === "string" && typeof data.ARK.BTC.rate === "number" && data.ARK.BTC.limits && typeof data.ARK.BTC.limits === "object" && typeof data.ARK.BTC.limits.maximal === "number" && typeof data.ARK.BTC.limits.minimal === "number" && typeof data.ARK.BTC.limits.maximalZeroConf === "number" && data.ARK.BTC.fees && typeof data.ARK.BTC.fees === "object" && typeof data.ARK.BTC.fees.percentage === "number" && typeof data.ARK.BTC.fees.minerFees === "number";
@@ -323,13 +331,13 @@ var isGetReversePairsResponse = (data) => {
   return data && typeof data === "object" && data.BTC && typeof data.BTC === "object" && data.BTC.ARK && typeof data.BTC.ARK === "object" && data.BTC.ARK.hash && typeof data.BTC.ARK.hash === "string" && typeof data.BTC.ARK.rate === "number" && data.BTC.ARK.limits && typeof data.BTC.ARK.limits === "object" && typeof data.BTC.ARK.limits.maximal === "number" && typeof data.BTC.ARK.limits.minimal === "number" && data.BTC.ARK.fees && typeof data.BTC.ARK.fees === "object" && typeof data.BTC.ARK.fees.percentage === "number" && typeof data.BTC.ARK.fees.minerFees === "object" && typeof data.BTC.ARK.fees.minerFees.claim === "number" && typeof data.BTC.ARK.fees.minerFees.lockup === "number";
 };
 var isCreateSubmarineSwapResponse = (data) => {
-  return data && typeof data === "object" && typeof data.id === "string" && typeof data.address === "string" && typeof data.expectedAmount === "number" && typeof data.claimPublicKey === "string" && typeof data.acceptZeroConf === "boolean" && isTimeoutBlockHeights(data.timeoutBlockHeights);
+  return data && typeof data === "object" && typeof data.id === "string" && typeof data.expectedAmount === "number" && (data.address === void 0 || typeof data.address === "string") && (data.claimPublicKey === void 0 || typeof data.claimPublicKey === "string") && (data.acceptZeroConf === void 0 || typeof data.acceptZeroConf === "boolean") && (data.timeoutBlockHeight === void 0 || typeof data.timeoutBlockHeight === "number") && (data.timeoutBlockHeights === void 0 || isTimeoutBlockHeights(data.timeoutBlockHeights));
 };
 var isGetSwapPreimageResponse = (data) => {
   return data && typeof data === "object" && typeof data.preimage === "string";
 };
 var isCreateReverseSwapResponse = (data) => {
-  return data && typeof data === "object" && typeof data.id === "string" && typeof data.invoice === "string" && typeof data.onchainAmount === "number" && typeof data.lockupAddress === "string" && typeof data.refundPublicKey === "string" && isTimeoutBlockHeights(data.timeoutBlockHeights);
+  return data && typeof data === "object" && typeof data.id === "string" && typeof data.invoice === "string" && (data.onchainAmount === void 0 || typeof data.onchainAmount === "number") && (data.lockupAddress === void 0 || typeof data.lockupAddress === "string") && (data.refundPublicKey === void 0 || typeof data.refundPublicKey === "string") && (data.timeoutBlockHeight === void 0 || typeof data.timeoutBlockHeight === "number") && (data.timeoutBlockHeights === void 0 || isTimeoutBlockHeights(data.timeoutBlockHeights));
 };
 var isRefundSubmarineSwapResponse = (data) => {
   return data && typeof data === "object" && typeof data.transaction === "string" && typeof data.checkpoint === "string";
@@ -368,19 +376,19 @@ var isLeaf = (data) => {
   return data && typeof data === "object" && typeof data.version === "number" && typeof data.output === "string";
 };
 var isTree = (data) => {
-  return data && typeof data === "object" && isLeaf(data.claimLeaf) && isLeaf(data.refundLeaf) && isLeaf(data.refundWithoutBoltzLeaf) && isLeaf(data.unilateralClaimLeaf) && isLeaf(data.unilateralRefundLeaf) && isLeaf(data.unilateralRefundWithoutBoltzLeaf);
+  return data && typeof data === "object" && isLeaf(data.claimLeaf) && isLeaf(data.refundLeaf) && (data.covenantClaimLeaf === void 0 || isLeaf(data.covenantClaimLeaf)) && (data.refundWithoutBoltzLeaf === void 0 || isLeaf(data.refundWithoutBoltzLeaf)) && (data.unilateralClaimLeaf === void 0 || isLeaf(data.unilateralClaimLeaf)) && (data.unilateralRefundLeaf === void 0 || isLeaf(data.unilateralRefundLeaf)) && (data.unilateralRefundWithoutBoltzLeaf === void 0 || isLeaf(data.unilateralRefundWithoutBoltzLeaf));
 };
 var isDetails = (data) => {
-  return data && typeof data === "object" && isTree(data.tree) && (data.amount === void 0 || typeof data.amount === "number") && typeof data.keyIndex === "number" && (data.transaction === void 0 || data.transaction && typeof data.transaction === "object" && typeof data.transaction.id === "string" && typeof data.transaction.vout === "number") && typeof data.lockupAddress === "string" && typeof data.serverPublicKey === "string" && typeof data.timeoutBlockHeight === "number" && (data.timeoutBlockHeights === void 0 || isTimeoutBlockHeights(data.timeoutBlockHeights)) && (data.preimageHash === void 0 || typeof data.preimageHash === "string");
+  return data && typeof data === "object" && isTree(data.tree) && (data.amount === void 0 || typeof data.amount === "number") && typeof data.keyIndex === "number" && (data.transaction === void 0 || data.transaction && typeof data.transaction === "object" && typeof data.transaction.id === "string" && typeof data.transaction.vout === "number") && typeof data.lockupAddress === "string" && typeof data.serverPublicKey === "string" && (data.timeoutBlockHeight === void 0 || typeof data.timeoutBlockHeight === "number") && (data.timeoutBlockHeights === void 0 || isTimeoutBlockHeights(data.timeoutBlockHeights)) && (data.preimageHash === void 0 || typeof data.preimageHash === "string");
 };
 var isRestoredChainSwap = (data) => {
-  return data && typeof data === "object" && typeof data.id === "string" && data.type === "chain" && typeof data.status === "string" && typeof data.createdAt === "number" && (data.from === "ARK" || data.from === "BTC") && (data.to === "ARK" || data.to === "BTC") && typeof data.preimageHash === "string" && data.refundDetails && typeof data.refundDetails === "object" && isTree(data.refundDetails.tree) && typeof data.refundDetails.amount === "number" && typeof data.refundDetails.keyIndex === "number" && (data.refundDetails.transaction === void 0 || data.refundDetails.transaction && typeof data.refundDetails.transaction === "object" && typeof data.refundDetails.transaction.id === "string" && typeof data.refundDetails.transaction.vout === "number") && typeof data.refundDetails.lockupAddress === "string" && typeof data.refundDetails.serverPublicKey === "string" && typeof data.refundDetails.timeoutBlockHeight === "number";
+  return data && typeof data === "object" && typeof data.id === "string" && data.type === "chain" && typeof data.status === "string" && typeof data.createdAt === "number" && (data.from === "ARK" || data.from === "BTC") && (data.to === "ARK" || data.to === "BTC") && (data.preimageHash === void 0 || typeof data.preimageHash === "string") && (data.invoice === void 0 || typeof data.invoice === "string") && (data.refundDetails === void 0 || isDetails(data.refundDetails)) && (data.claimDetails === void 0 || isDetails(data.claimDetails));
 };
 var isRestoredSubmarineSwap = (data) => {
-  return data && typeof data === "object" && data.to === "BTC" && typeof data.id === "string" && data.from === "ARK" && data.type === "submarine" && typeof data.createdAt === "number" && typeof data.preimageHash === "string" && typeof data.status === "string" && isDetails(data.refundDetails) && (data.invoice === void 0 || typeof data.invoice === "string");
+  return data && typeof data === "object" && data.to === "BTC" && typeof data.id === "string" && data.from === "ARK" && data.type === "submarine" && typeof data.createdAt === "number" && (data.preimageHash === void 0 || typeof data.preimageHash === "string") && typeof data.status === "string" && isDetails(data.refundDetails) && (data.invoice === void 0 || typeof data.invoice === "string");
 };
 var isRestoredReverseSwap = (data) => {
-  return data && typeof data === "object" && data.to === "ARK" && typeof data.id === "string" && data.from === "BTC" && data.type === "reverse" && typeof data.createdAt === "number" && typeof data.preimageHash === "string" && typeof data.status === "string" && isDetails(data.claimDetails) && (data.invoice === void 0 || typeof data.invoice === "string");
+  return data && typeof data === "object" && data.to === "ARK" && typeof data.id === "string" && data.from === "BTC" && data.type === "reverse" && typeof data.createdAt === "number" && (data.preimageHash === void 0 || typeof data.preimageHash === "string") && typeof data.status === "string" && isDetails(data.claimDetails) && (data.invoice === void 0 || typeof data.invoice === "string");
 };
 var isCreateSwapsRestoreResponse = (data) => {
   return Array.isArray(data) && data.every(
@@ -459,6 +467,18 @@ var BoltzSwapProvider = class {
       max: response.ARK.BTC.limits.maximal
     };
   }
+  /** Returns the current BTC chain tip height from Boltz. */
+  async getChainHeight() {
+    const response = await this.request(
+      "/v2/chain/heights",
+      "GET"
+    );
+    if (typeof response?.BTC !== "number")
+      throw new SchemaError({
+        message: "error fetching chain heights"
+      });
+    return response.BTC;
+  }
   /** Gets the lockup transaction ID for a reverse swap. */
   async getReverseSwapTxId(id) {
     const res = await this.request(
@@ -2928,10 +2948,22 @@ var refundVHTLCwithOffchainTx = async (swapId, identity, arkProvider, boltzXOnly
       `Expected one checkpoint transaction, got ${checkpointPtxs.length}`
     );
   const unsignedCheckpointTx = checkpointPtxs[0];
-  const {
-    transaction: boltzSignedRefundTx,
-    checkpoint: boltzSignedCheckpointTx
-  } = await refundFunc(swapId, unsignedRefundTx, unsignedCheckpointTx);
+  let boltzSignedRefundTx;
+  let boltzSignedCheckpointTx;
+  try {
+    const result = await refundFunc(
+      swapId,
+      unsignedRefundTx,
+      unsignedCheckpointTx
+    );
+    boltzSignedRefundTx = result.transaction;
+    boltzSignedCheckpointTx = result.checkpoint;
+  } catch (error) {
+    throw new BoltzRefundError(
+      `Boltz rejected refund for swap ${swapId}`,
+      error
+    );
+  }
   const boltzXOnlyPublicKeyHex = import_base8.hex.encode(boltzXOnlyPublicKey);
   const refundLeafHash = (0, import_payment3.tapLeafHash)(
     scriptFromTapLeafScript(input.tapLeafScript)
@@ -3272,7 +3304,14 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async claimVHTLC(pendingSwap) {
     if (!pendingSwap.preimage)
-      throw new Error("Preimage is required to claim VHTLC");
+      throw new Error(
+        `Swap ${pendingSwap.id}: preimage is required to claim VHTLC`
+      );
+    const { refundPublicKey, lockupAddress, timeoutBlockHeights } = pendingSwap.response;
+    if (!refundPublicKey || !lockupAddress || !timeoutBlockHeights)
+      throw new Error(
+        `Swap ${pendingSwap.id}: incomplete reverse swap response`
+      );
     const preimage = import_base9.hex.decode(pendingSwap.preimage);
     const arkInfo = await this.arkProvider.getInfo();
     const address = await this.wallet.getAddress();
@@ -3282,7 +3321,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       pendingSwap.id
     );
     const senderXOnly = normalizeToXOnlyKey(
-      import_base9.hex.decode(pendingSwap.response.refundPublicKey),
+      import_base9.hex.decode(refundPublicKey),
       "boltz",
       pendingSwap.id
     );
@@ -3297,20 +3336,26 @@ var ArkadeSwaps = class _ArkadeSwaps {
       receiverPubkey: import_base9.hex.encode(receiverXOnly),
       senderPubkey: import_base9.hex.encode(senderXOnly),
       serverPubkey: import_base9.hex.encode(serverXOnly),
-      timeoutBlockHeights: pendingSwap.response.timeoutBlockHeights
+      timeoutBlockHeights
     });
     if (!vhtlcScript.claimScript)
-      throw new Error("Failed to create VHTLC script for reverse swap");
-    if (vhtlcAddress !== pendingSwap.response.lockupAddress)
-      throw new Error("Boltz is trying to scam us");
+      throw new Error(
+        `Swap ${pendingSwap.id}: failed to create VHTLC script for reverse swap`
+      );
+    if (vhtlcAddress !== lockupAddress)
+      throw new Error(
+        `Swap ${pendingSwap.id}: VHTLC address mismatch. Expected ${lockupAddress}, got ${vhtlcAddress}`
+      );
     const { vtxos } = await this.indexerProvider.getVtxos({
       scripts: [import_base9.hex.encode(vhtlcScript.pkScript)]
     });
     if (vtxos.length === 0)
-      throw new Error("No spendable virtual coins found");
+      throw new Error(
+        `Swap ${pendingSwap.id}: no spendable virtual coins found`
+      );
     const vtxo = vtxos[0];
     if (vtxo.isSpent) {
-      throw new Error("VHTLC is already spent");
+      throw new Error(`Swap ${pendingSwap.id}: VHTLC is already spent`);
     }
     const input = {
       ...vtxo,
@@ -3442,6 +3487,10 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async sendLightningPayment(args) {
     const pendingSwap = await this.createSubmarineSwap(args);
+    if (!pendingSwap.response.address)
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing address in submarine swap response`
+      );
     await this.savePendingSubmarineSwap(pendingSwap);
     const txid = await this.wallet.send({
       address: pendingSwap.response.address,
@@ -3511,7 +3560,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
   async refundVHTLC(pendingSwap) {
     const preimageHash = pendingSwap.request.invoice ? getInvoicePaymentHash(pendingSwap.request.invoice) : pendingSwap.preimageHash;
     if (!preimageHash)
-      throw new Error("Preimage hash is required to refund VHTLC");
+      throw new Error(
+        `Swap ${pendingSwap.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");
@@ -3525,8 +3576,13 @@ var ArkadeSwaps = class _ArkadeSwaps {
       "server",
       pendingSwap.id
     );
+    const { claimPublicKey, timeoutBlockHeights } = pendingSwap.response;
+    if (!claimPublicKey || !timeoutBlockHeights)
+      throw new Error(
+        `Swap ${pendingSwap.id}: incomplete submarine swap response`
+      );
     const boltzXOnlyPublicKey = normalizeToXOnlyKey(
-      import_base9.hex.decode(pendingSwap.response.claimPublicKey),
+      import_base9.hex.decode(claimPublicKey),
       "boltz",
       pendingSwap.id
     );
@@ -3536,10 +3592,12 @@ var ArkadeSwaps = class _ArkadeSwaps {
       receiverPubkey: import_base9.hex.encode(boltzXOnlyPublicKey),
       senderPubkey: import_base9.hex.encode(ourXOnlyPublicKey),
       serverPubkey: import_base9.hex.encode(serverXOnlyPublicKey),
-      timeoutBlockHeights: pendingSwap.response.timeoutBlockHeights
+      timeoutBlockHeights
     });
     if (!vhtlcScript.claimScript)
-      throw new Error("Failed to create VHTLC script for submarine swap");
+      throw new Error(
+        `Swap ${pendingSwap.id}: failed to create VHTLC script for submarine swap`
+      );
     if (vhtlcAddress !== pendingSwap.response.address)
       throw new Error(
         `VHTLC address mismatch for swap ${pendingSwap.id}: expected ${pendingSwap.response.address}, got ${vhtlcAddress}`
@@ -3554,30 +3612,50 @@ var ArkadeSwaps = class _ArkadeSwaps {
         scripts: [vhtlcPkScriptHex]
       });
       throw new Error(
-        allVtxos.length > 0 ? "VHTLC is already spent" : `VHTLC not found for address ${pendingSwap.response.address}`
+        allVtxos.length > 0 ? `Swap ${pendingSwap.id}: VHTLC is already spent` : `Swap ${pendingSwap.id}: VHTLC not found for address ${pendingSwap.response.address}`
       );
     }
     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;
     let boltzCallCount = 0;
+    let skippedCount = 0;
     for (const vtxo of spendableVtxos) {
       const isRecoverableVtxo = (0, import_sdk8.isRecoverable)(vtxo);
-      const input = {
-        ...vtxo,
-        tapLeafScript: isRecoverableVtxo ? vhtlcScript.refundWithoutReceiver() : vhtlcScript.refund(),
-        tapTree: vhtlcScript.encode()
-      };
       const output = {
         amount: BigInt(vtxo.value),
         script: outputScript
       };
-      if (isRecoverableVtxo) {
+      if (cltvSatisfied) {
+        const input2 = {
+          ...vtxo,
+          tapLeafScript: refundWithoutReceiverLeaf,
+          tapTree: vhtlcScript.encode()
+        };
         await this.joinBatch(
           this.wallet.identity,
-          input,
+          input2,
           output,
-          arkInfo
+          arkInfo,
+          isRecoverableVtxo
+        );
+        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.`
         );
-      } else {
+        skippedCount++;
+        continue;
+      }
+      const input = {
+        ...vtxo,
+        tapLeafScript: vhtlcScript.refund(),
+        tapTree: vhtlcScript.encode()
+      };
+      try {
         if (boltzCallCount > 0) {
           await new Promise((r) => setTimeout(r, 2e3));
         }
@@ -3596,14 +3674,42 @@ var ArkadeSwaps = class _ArkadeSwaps {
           )
         );
         boltzCallCount++;
+      } catch (error) {
+        if (!(error instanceof BoltzRefundError)) {
+          throw error;
+        }
+        const tipNow = await this.swapProvider.getChainHeight();
+        if (BigInt(tipNow) < refundLocktime) {
+          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.`
+          );
+          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
+        );
       }
     }
+    const fullyRefunded = skippedCount === 0;
     await updateSubmarineSwapStatus(
       pendingSwap,
       pendingSwap.status,
       // Keep current status
       this.savePendingSubmarineSwap.bind(this),
-      { refundable: true, refunded: true }
+      { refundable: true, refunded: fullyRefunded }
     );
   }
   /**
@@ -3806,14 +3912,22 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async claimBtc(pendingSwap) {
     if (!pendingSwap.toAddress)
-      throw new Error("Destination address is required");
+      throw new Error(
+        `Swap ${pendingSwap.id}: destination address is required`
+      );
     if (!pendingSwap.response.claimDetails.swapTree)
-      throw new Error("Missing swap tree in claim details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing swap tree in claim details`
+      );
     if (!pendingSwap.response.claimDetails.serverPublicKey)
-      throw new Error("Missing server public key in claim details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing server public key in claim details`
+      );
     const swapStatus = await this.getSwapStatus(pendingSwap.id);
     if (!swapStatus.transaction?.hex)
-      throw new Error("BTC transaction hex is required");
+      throw new Error(
+        `Swap ${pendingSwap.id}: BTC transaction hex is required`
+      );
     const lockupTx = import_btc_signer5.Transaction.fromRaw(
       import_base9.hex.decode(swapStatus.transaction.hex)
     );
@@ -3868,7 +3982,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
       }
     );
     if (!signedTxData.pubNonce || !signedTxData.partialSignature)
-      throw new Error("Invalid signature data from server");
+      throw new Error(
+        `Swap ${pendingSwap.id}: invalid signature data from server`
+      );
     const musigSession = musigMessage.aggregateNonces([
       [
         import_base9.hex.decode(
@@ -3893,9 +4009,13 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async refundArk(pendingSwap) {
     if (!pendingSwap.response.lockupDetails.serverPublicKey)
-      throw new Error("Missing server public key in lockup details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing server public key in lockup details`
+      );
     if (!pendingSwap.response.lockupDetails.timeouts)
-      throw new Error("Missing timeouts in lockup details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing timeouts in lockup details`
+      );
     const arkInfo = await this.arkProvider.getInfo();
     const address = await this.wallet.getAddress();
     const ourXOnlyPublicKey = normalizeToXOnlyKey(
@@ -3921,12 +4041,12 @@ var ArkadeSwaps = class _ArkadeSwaps {
     });
     if (vtxos.length === 0) {
       throw new Error(
-        `VHTLC not found for address ${pendingSwap.response.lockupDetails.lockupAddress}`
+        `Swap ${pendingSwap.id}: VHTLC not found for address ${pendingSwap.response.lockupDetails.lockupAddress}`
       );
     }
     const vtxo = vtxos[0];
     if (vtxo.isSpent) {
-      throw new Error("VHTLC is already spent");
+      throw new Error(`Swap ${pendingSwap.id}: VHTLC is already spent`);
     }
     const { vhtlcAddress, vhtlcScript } = this.createVHTLCScript({
       network: arkInfo.network,
@@ -3937,7 +4057,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
       timeoutBlockHeights: pendingSwap.response.lockupDetails.timeouts
     });
     if (!vhtlcScript.refundScript)
-      throw new Error("Failed to create VHTLC script for chain swap");
+      throw new Error(
+        `Swap ${pendingSwap.id}: failed to create VHTLC script for chain swap`
+      );
     if (pendingSwap.response.lockupDetails.lockupAddress !== vhtlcAddress) {
       throw new SwapError({
         message: "Unable to claim: invalid VHTLC address"
@@ -4111,11 +4233,17 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async claimArk(pendingSwap) {
     if (!pendingSwap.toAddress)
-      throw new Error("Destination address is required");
+      throw new Error(
+        `Swap ${pendingSwap.id}: destination address is required`
+      );
     if (!pendingSwap.response.claimDetails.serverPublicKey)
-      throw new Error("Missing server public key in claim details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing server public key in claim details`
+      );
     if (!pendingSwap.response.claimDetails.timeouts)
-      throw new Error("Missing timeouts in claim details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing timeouts in claim details`
+      );
     const arkInfo = await this.arkProvider.getInfo();
     const preimage = import_base9.hex.decode(pendingSwap.preimage);
     const address = await this.wallet.getAddress();
@@ -4140,7 +4268,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
       timeoutBlockHeights: pendingSwap.response.claimDetails.timeouts
     });
     if (!vhtlcScript.claimScript)
-      throw new Error("Failed to create VHTLC script for chain swap");
+      throw new Error(
+        `Swap ${pendingSwap.id}: failed to create VHTLC script for chain swap`
+      );
     if (pendingSwap.response.claimDetails.lockupAddress !== vhtlcAddress) {
       throw new SwapError({
         message: "Unable to claim: invalid VHTLC address"
@@ -4151,7 +4281,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
       spendableOnly: true
     });
     if (spendableVtxos.vtxos.length === 0)
-      throw new Error("No spendable virtual coins found");
+      throw new Error(
+        `Swap ${pendingSwap.id}: no spendable virtual coins found`
+      );
     const vtxo = spendableVtxos.vtxos[0];
     const input = {
       ...vtxo,
@@ -4191,16 +4323,20 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async signCooperativeClaimForServer(pendingSwap) {
     if (!pendingSwap.response.lockupDetails.swapTree)
-      throw new Error("Missing swap tree in lockup details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing swap tree in lockup details`
+      );
     if (!pendingSwap.response.lockupDetails.serverPublicKey)
-      throw new Error("Missing server public key in lockup details");
+      throw new Error(
+        `Swap ${pendingSwap.id}: missing server public key in lockup details`
+      );
     const claimDetails = await this.swapProvider.getChainClaimDetails(
       pendingSwap.id
     );
     const serverPubKey = pendingSwap.response.lockupDetails.serverPublicKey;
     if (claimDetails.publicKey !== serverPubKey) {
       throw new Error(
-        `Server public key mismatch: claim response has ${claimDetails.publicKey}, expected ${serverPubKey}`
+        `Swap ${pendingSwap.id}: server public key mismatch \u2014 claim response has ${claimDetails.publicKey}, expected ${serverPubKey}`
       );
     }
     const musig = tweakMusig(
@@ -4320,15 +4456,23 @@ var ArkadeSwaps = class _ArkadeSwaps {
     const { to, from, swap, arkInfo } = args;
     if (from === "ARK") {
       if (!swap.response.lockupDetails.serverPublicKey)
-        throw new Error("Missing serverPublicKey in lockup details");
+        throw new Error(
+          `Swap ${swap.id}: missing serverPublicKey in lockup details`
+        );
       if (!swap.response.lockupDetails.timeouts)
-        throw new Error("Missing timeouts in lockup details");
+        throw new Error(
+          `Swap ${swap.id}: missing timeouts in lockup details`
+        );
     }
     if (to === "ARK") {
       if (!swap.response.claimDetails.serverPublicKey)
-        throw new Error("Missing serverPublicKey in claim details");
+        throw new Error(
+          `Swap ${swap.id}: missing serverPublicKey in claim details`
+        );
       if (!swap.response.claimDetails.timeouts)
-        throw new Error("Missing timeouts in claim details");
+        throw new Error(
+          `Swap ${swap.id}: missing timeouts in claim details`
+        );
     }
     const lockupAddress = to === "ARK" ? swap.response.claimDetails.lockupAddress : swap.response.lockupDetails.lockupAddress;
     const receiverPubkey = to === "ARK" ? swap.request.claimPublicKey : swap.response.lockupDetails.serverPublicKey;
@@ -4538,7 +4682,8 @@ var ArkadeSwaps = class _ArkadeSwaps {
           lockupAddress,
           preimageHash,
           serverPublicKey,
-          tree
+          tree,
+          timeoutBlockHeights
         } = swap.claimDetails;
         reverseSwaps.push({
           id,
@@ -4554,18 +4699,18 @@ var ArkadeSwaps = class _ArkadeSwaps {
             onchainAmount: amount,
             lockupAddress,
             refundPublicKey: serverPublicKey,
-            timeoutBlockHeights: {
+            timeoutBlockHeights: timeoutBlockHeights ?? {
               refund: extractTimeLockFromLeafOutput(
-                tree.refundWithoutBoltzLeaf.output
+                tree.refundWithoutBoltzLeaf?.output ?? ""
               ),
               unilateralClaim: extractTimeLockFromLeafOutput(
-                tree.unilateralClaimLeaf.output
+                tree.unilateralClaimLeaf?.output ?? ""
               ),
               unilateralRefund: extractTimeLockFromLeafOutput(
-                tree.unilateralRefundLeaf.output
+                tree.unilateralRefundLeaf?.output ?? ""
               ),
               unilateralRefundWithoutReceiver: extractTimeLockFromLeafOutput(
-                tree.unilateralRefundWithoutBoltzLeaf.output
+                tree.unilateralRefundWithoutBoltzLeaf?.output ?? ""
               )
             }
           },
@@ -4574,7 +4719,13 @@ var ArkadeSwaps = class _ArkadeSwaps {
           preimage: ""
         });
       } else if (isRestoredSubmarineSwap(swap)) {
-        const { amount, lockupAddress, serverPublicKey, tree } = swap.refundDetails;
+        const {
+          amount,
+          lockupAddress,
+          serverPublicKey,
+          tree,
+          timeoutBlockHeights
+        } = swap.refundDetails;
         let preimage = "";
         if (!isSubmarineFinalStatus(status)) {
           try {
@@ -4605,29 +4756,31 @@ var ArkadeSwaps = class _ArkadeSwaps {
             address: lockupAddress,
             expectedAmount: amount,
             claimPublicKey: serverPublicKey,
-            timeoutBlockHeights: {
+            timeoutBlockHeights: timeoutBlockHeights ?? {
               refund: extractTimeLockFromLeafOutput(
-                tree.refundWithoutBoltzLeaf.output
+                tree.refundWithoutBoltzLeaf?.output ?? ""
               ),
               unilateralClaim: extractTimeLockFromLeafOutput(
-                tree.unilateralClaimLeaf.output
+                tree.unilateralClaimLeaf?.output ?? ""
               ),
               unilateralRefund: extractTimeLockFromLeafOutput(
-                tree.unilateralRefundLeaf.output
+                tree.unilateralRefundLeaf?.output ?? ""
               ),
               unilateralRefundWithoutReceiver: extractTimeLockFromLeafOutput(
-                tree.unilateralRefundWithoutBoltzLeaf.output
+                tree.unilateralRefundWithoutBoltzLeaf?.output ?? ""
               )
             }
           }
         });
       } else if (isRestoredChainSwap(swap)) {
+        const refundDetails = swap.refundDetails;
+        if (!refundDetails) continue;
         const {
           amount,
           lockupAddress,
           serverPublicKey,
           timeoutBlockHeight
-        } = swap.refundDetails;
+        } = refundDetails;
         chainSwaps.push({
           id,
           type: "chain",
@@ -5981,6 +6134,7 @@ async function getContractCollection(storage, contractType) {
   ArkadeLightningMessageHandler,
   ArkadeSwaps,
   ArkadeSwapsMessageHandler,
+  BoltzRefundError,
   BoltzSwapProvider,
   IndexedDbSwapRepository,
   InsufficientFundsError,