@arkade-os/boltz-swap 0.3.14 → 0.3.16

package/dist/expo/index.cjs

@@ -31,7 +31,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/errors.ts
-var SwapError, InvoiceExpiredError, InvoiceFailedToPayError, NetworkError, SchemaError, SwapExpiredError, TransactionFailedError, TransactionLockupFailedError, TransactionRefundedError;
+var SwapError, InvoiceExpiredError, InvoiceFailedToPayError, NetworkError, SchemaError, SwapExpiredError, TransactionFailedError, TransactionLockupFailedError, TransactionRefundedError, BoltzRefundError;
 var init_errors = __esm({
   "src/errors.ts"() {
     "use strict";
@@ -107,6 +107,13 @@ var init_errors = __esm({
         this.name = "TransactionRefundedError";
       }
     };
+    BoltzRefundError = class extends Error {
+      constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "BoltzRefundError";
+      }
+    };
   }
 });
 
@@ -185,7 +192,7 @@ var init_boltz_swap_provider = __esm({
       return data && typeof data === "object" && typeof data.id === "string" && typeof data.timeoutBlockHeight === "number";
     };
     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"));
     };
     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";
@@ -194,13 +201,13 @@ var init_boltz_swap_provider = __esm({
       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";
     };
     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));
     };
     isGetSwapPreimageResponse = (data) => {
       return data && typeof data === "object" && typeof data.preimage === "string";
     };
     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));
     };
     isRefundSubmarineSwapResponse = (data) => {
       return data && typeof data === "object" && typeof data.transaction === "string" && typeof data.checkpoint === "string";
@@ -239,19 +246,19 @@ var init_boltz_swap_provider = __esm({
       return data && typeof data === "object" && typeof data.version === "number" && typeof data.output === "string";
     };
     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));
     };
     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");
     };
     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));
     };
     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");
     };
     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");
     };
     isCreateSwapsRestoreResponse = (data) => {
       return Array.isArray(data) && data.every(
@@ -330,6 +337,18 @@ var init_boltz_swap_provider = __esm({
           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(
@@ -2659,6 +2678,7 @@ var init_vhtlc = __esm({
     "use strict";
     import_sdk7 = require("@arkade-os/sdk");
     init_logger();
+    init_errors();
     import_base8 = require("@scure/base");
     init_batch();
     import_legacy = require("@noble/hashes/legacy.js");
@@ -2851,10 +2871,22 @@ var init_vhtlc = __esm({
           `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)
@@ -3218,7 +3250,14 @@ var init_arkade_swaps = __esm({
        */
       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();
@@ -3228,7 +3267,7 @@ var init_arkade_swaps = __esm({
           pendingSwap.id
         );
         const senderXOnly = normalizeToXOnlyKey(
-          import_base9.hex.decode(pendingSwap.response.refundPublicKey),
+          import_base9.hex.decode(refundPublicKey),
           "boltz",
           pendingSwap.id
         );
@@ -3243,20 +3282,26 @@ var init_arkade_swaps = __esm({
           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,
@@ -3388,6 +3433,10 @@ var init_arkade_swaps = __esm({
        */
       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,
@@ -3457,7 +3506,9 @@ var init_arkade_swaps = __esm({
       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");
@@ -3471,8 +3522,13 @@ var init_arkade_swaps = __esm({
           "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
         );
@@ -3482,10 +3538,12 @@ var init_arkade_swaps = __esm({
           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}`
@@ -3500,30 +3558,50 @@ var init_arkade_swaps = __esm({
             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
             );
-          } else {
+            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.`
+            );
+            skippedCount++;
+            continue;
+          }
+          const input = {
+            ...vtxo,
+            tapLeafScript: vhtlcScript.refund(),
+            tapTree: vhtlcScript.encode()
+          };
+          try {
             if (boltzCallCount > 0) {
               await new Promise((r) => setTimeout(r, 2e3));
             }
@@ -3542,14 +3620,42 @@ var init_arkade_swaps = __esm({
               )
             );
             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 }
         );
       }
       /**
@@ -3752,14 +3858,22 @@ var init_arkade_swaps = __esm({
        */
       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)
         );
@@ -3814,7 +3928,9 @@ var init_arkade_swaps = __esm({
           }
         );
         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(
@@ -3839,9 +3955,13 @@ var init_arkade_swaps = __esm({
        */
       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(
@@ -3867,12 +3987,12 @@ var init_arkade_swaps = __esm({
         });
         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,
@@ -3883,7 +4003,9 @@ var init_arkade_swaps = __esm({
           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"
@@ -4057,11 +4179,17 @@ var init_arkade_swaps = __esm({
        */
       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();
@@ -4086,7 +4214,9 @@ var init_arkade_swaps = __esm({
           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"
@@ -4097,7 +4227,9 @@ var init_arkade_swaps = __esm({
           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,
@@ -4137,16 +4269,20 @@ var init_arkade_swaps = __esm({
        */
       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(
@@ -4266,15 +4402,23 @@ var init_arkade_swaps = __esm({
         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;
@@ -4484,7 +4628,8 @@ var init_arkade_swaps = __esm({
               lockupAddress,
               preimageHash,
               serverPublicKey,
-              tree
+              tree,
+              timeoutBlockHeights
             } = swap.claimDetails;
             reverseSwaps.push({
               id,
@@ -4500,18 +4645,18 @@ var init_arkade_swaps = __esm({
                 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 ?? ""
                   )
                 }
               },
@@ -4520,7 +4665,13 @@ var init_arkade_swaps = __esm({
               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 {
@@ -4551,29 +4702,31 @@ var init_arkade_swaps = __esm({
                 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",

package/dist/expo/index.d.cts

@@ -1,5 +1,5 @@
-import { I as IArkadeSwaps, A as ArkadeSwaps } from '../arkade-swaps-CwQbGdU9.cjs';
-import { A as ArkadeSwapsConfig, j as SwapRepository, m as BoltzSwapProvider, N as Network, k as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, b as BoltzReverseSwap, F as FeesResponse, a as BoltzChainSwap, h as ArkToBtcResponse, i as BtcToArkResponse, d as Chain, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from '../types-x542EUL6.cjs';
+import { I as IArkadeSwaps, A as ArkadeSwaps } from '../arkade-swaps-BlK0ASlg.cjs';
+import { A as ArkadeSwapsConfig, j as SwapRepository, m as BoltzSwapProvider, N as Network, k as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, b as BoltzReverseSwap, F as FeesResponse, a as BoltzChainSwap, h as ArkToBtcResponse, i as BtcToArkResponse, d as Chain, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from '../types-CKxFfdEH.cjs';
 import { Identity, ArkProvider, IndexerProvider, IWallet, ArkInfo, ArkTxInput, VHTLC } from '@arkade-os/sdk';
 import { AsyncStorageTaskQueue, TaskProcessor } from '@arkade-os/sdk/worker/expo';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';

package/dist/expo/index.d.ts

@@ -1,5 +1,5 @@
-import { I as IArkadeSwaps, A as ArkadeSwaps } from '../arkade-swaps-BfHIKMq0.js';
-import { A as ArkadeSwapsConfig, j as SwapRepository, m as BoltzSwapProvider, N as Network, k as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, b as BoltzReverseSwap, F as FeesResponse, a as BoltzChainSwap, h as ArkToBtcResponse, i as BtcToArkResponse, d as Chain, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from '../types-x542EUL6.js';
+import { I as IArkadeSwaps, A as ArkadeSwaps } from '../arkade-swaps-CM-UQ9-5.js';
+import { A as ArkadeSwapsConfig, j as SwapRepository, m as BoltzSwapProvider, N as Network, k as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, b as BoltzReverseSwap, F as FeesResponse, a as BoltzChainSwap, h as ArkToBtcResponse, i as BtcToArkResponse, d as Chain, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from '../types-CKxFfdEH.js';
 import { Identity, ArkProvider, IndexerProvider, IWallet, ArkInfo, ArkTxInput, VHTLC } from '@arkade-os/sdk';
 import { AsyncStorageTaskQueue, TaskProcessor } from '@arkade-os/sdk/worker/expo';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';