@arkade-os/boltz-swap 0.2.13 → 0.2.15

package/dist/index.cjs

@@ -138,7 +138,7 @@ var TransactionRefundedError = class extends SwapError {
 // src/arkade-lightning.ts
 var import_sdk5 = require("@arkade-os/sdk");
 var import_sha22 = require("@noble/hashes/sha2.js");
-var import_base3 = require("@scure/base");
+var import_base4 = require("@scure/base");
 var import_utils = require("@noble/hashes/utils.js");
 
 // src/boltz-swap-provider.ts
@@ -180,7 +180,7 @@ var isSubmarineSwapRefundable = (swap) => {
   return isSubmarineRefundableStatus(swap.status) && isPendingSubmarineSwap(swap) && swap.refundable !== false && swap.refunded !== true;
 };
 var isGetReverseSwapTxIdResponse = (data) => {
-  return data && typeof data === "object" && typeof data.id === "string" && typeof data.timeoutBlockHeight === "number";
+  return data && typeof data === "object" && typeof data.id === "string" && typeof data.hex === "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"));
@@ -203,6 +203,26 @@ var isCreateReverseSwapResponse = (data) => {
 var isRefundSubmarineSwapResponse = (data) => {
   return data && typeof data === "object" && typeof data.transaction === "string" && typeof data.checkpoint === "string";
 };
+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);
+};
+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.preimageHash === void 0 || typeof data.preimageHash === "string");
+};
+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);
+};
+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);
+};
+var isCreateSwapsRestoreResponse = (data) => {
+  return Array.isArray(data) && data.every(
+    (item) => isRestoredReverseSwap(item) || isRestoredSubmarineSwap(item)
+  );
+};
 var BASE_URLS = {
   mutinynet: "https://api.boltz.mutinynet.arkade.sh",
   regtest: "http://localhost:9069"
@@ -433,6 +453,21 @@ var BoltzSwapProvider = class {
       };
     });
   }
+  async restoreSwaps(publicKey) {
+    const requestBody = {
+      publicKey
+    };
+    const response = await this.request(
+      "/v2/swap/restore",
+      "POST",
+      requestBody
+    );
+    if (!isCreateSwapsRestoreResponse(response))
+      throw new SchemaError({
+        message: "Invalid schema in response for swap restoration"
+      });
+    return response;
+  }
   async request(path, method, body) {
     const url = `${this.apiUrl}${path}`;
     try {
@@ -465,7 +500,7 @@ var BoltzSwapProvider = class {
 };
 
 // src/arkade-lightning.ts
-var import_btc_signer2 = require("@scure/btc-signer");
+var import_btc_signer3 = require("@scure/btc-signer");
 var import_legacy = require("@noble/hashes/legacy.js");
 
 // src/utils/decoding.ts
@@ -500,6 +535,50 @@ var verifySignatures = (tx, inputIndex, requiredSigners) => {
   }
 };
 
+// src/utils/restoration.ts
+var import_base2 = require("@scure/base");
+var import_btc_signer = require("@scure/btc-signer");
+var import_bip68 = __toESM(require("bip68"), 1);
+function extractTimeLockFromLeafOutput(scriptHex) {
+  if (!scriptHex) return 0;
+  try {
+    const opcodes = import_btc_signer.Script.decode(import_base2.hex.decode(scriptHex));
+    const hasCLTV = opcodes.findIndex((op) => op === "CHECKLOCKTIMEVERIFY");
+    if (hasCLTV > 0) {
+      const data = opcodes[hasCLTV - 1];
+      if (data instanceof Uint8Array) {
+        const dataBytes = new Uint8Array(data).reverse();
+        return parseInt(import_base2.hex.encode(dataBytes), 16);
+      }
+    }
+    const hasCSV = opcodes.findIndex((op) => op === "CHECKSEQUENCEVERIFY");
+    if (hasCSV > 0) {
+      const data = opcodes[hasCSV - 1];
+      if (data instanceof Uint8Array) {
+        const dataBytes = new Uint8Array(data).reverse();
+        const {
+          blocks,
+          seconds
+        } = import_bip68.default.decode(
+          parseInt(import_base2.hex.encode(dataBytes), 16)
+        );
+        return blocks ?? seconds ?? 0;
+      }
+    }
+  } catch (error) {
+    return 0;
+  }
+  return 0;
+}
+function extractInvoiceAmount(amountSats, fees) {
+  if (!amountSats) return 0;
+  const { percentage, minerFees } = fees.reverse;
+  const miner = minerFees.lockup + minerFees.claim;
+  if (percentage >= 100 || percentage < 0) return 0;
+  if (miner >= amountSats) return 0;
+  return Math.ceil((amountSats - miner) / (1 - percentage / 100));
+}
+
 // src/logger.ts
 var logger = console;
 function setLogger(customLogger) {
@@ -997,6 +1076,12 @@ var SwapManager = class {
     try {
       this.swapsInProgress.add(swap.id);
       if (isPendingReverseSwap(swap)) {
+        if (!swap.preimage || swap.preimage.length === 0) {
+          logger.log(
+            `Skipping claim for swap ${swap.id}: missing preimage (restored swap)`
+          );
+          return;
+        }
         if (isReverseClaimableStatus(swap.status)) {
           logger.log(`Auto-claiming reverse swap ${swap.id}`);
           await this.executeClaimAction(swap);
@@ -1005,6 +1090,12 @@ var SwapManager = class {
           );
         }
       } else if (isPendingSubmarineSwap(swap)) {
+        if (!swap.request?.invoice || swap.request.invoice.length === 0) {
+          logger.log(
+            `Skipping refund for swap ${swap.id}: missing invoice (restored swap)`
+          );
+          return;
+        }
         if (isSubmarineRefundableStatus(swap.status)) {
           logger.log(`Auto-refunding submarine swap ${swap.id}`);
           await this.executeRefundAction(swap);
@@ -1212,13 +1303,13 @@ function claimVHTLCIdentity(identity, preimage) {
 // src/batch.ts
 var import_sdk4 = require("@arkade-os/sdk");
 var import_sha2 = require("@noble/hashes/sha2.js");
-var import_base2 = require("@scure/base");
-var import_btc_signer = require("@scure/btc-signer");
+var import_base3 = require("@scure/base");
+var import_btc_signer2 = require("@scure/btc-signer");
 var import_payment = require("@scure/btc-signer/payment.js");
 function createVHTLCBatchHandler(intentId, vhtlc, arkProvider, identity, session, sweepPublicKey, forfeitOutputScript, connectorIndex = 0) {
   const utf8IntentId = new TextEncoder().encode(intentId);
   const intentIdHash = (0, import_sha2.sha256)(utf8IntentId);
-  const intentIdHashStr = import_base2.hex.encode(intentIdHash);
+  const intentIdHashStr = import_base3.hex.encode(intentIdHash);
   let sweepTapTreeRoot;
   return {
     onBatchStarted: async (event) => {
@@ -1257,11 +1348,11 @@ function createVHTLCBatchHandler(intentId, vhtlc, arkProvider, identity, session
       );
       const signerPublicKey = await session.getPublicKey();
       const xonlySignerPublicKey = signerPublicKey.subarray(1);
-      if (!xOnlyPublicKeys.includes(import_base2.hex.encode(xonlySignerPublicKey))) {
+      if (!xOnlyPublicKeys.includes(import_base3.hex.encode(xonlySignerPublicKey))) {
         return { skip: true };
       }
       const commitmentTx = import_sdk4.Transaction.fromPSBT(
-        import_base2.base64.decode(event.unsignedCommitmentTx)
+        import_base3.base64.decode(event.unsignedCommitmentTx)
       );
       (0, import_sdk4.validateVtxoTxGraph)(vtxoTree, commitmentTx, sweepTapTreeRoot);
       const sharedOutput = commitmentTx.getOutput(0);
@@ -1269,7 +1360,7 @@ function createVHTLCBatchHandler(intentId, vhtlc, arkProvider, identity, session
         throw new Error("Shared output not found");
       }
       await session.init(vtxoTree, sweepTapTreeRoot, sharedOutput.amount);
-      const pubkey = import_base2.hex.encode(await session.getPublicKey());
+      const pubkey = import_base3.hex.encode(await session.getPublicKey());
       const nonces = await session.getNonces();
       await arkProvider.submitTreeNonces(event.id, pubkey, nonces);
       return { skip: false };
@@ -1284,7 +1375,7 @@ function createVHTLCBatchHandler(intentId, vhtlc, arkProvider, identity, session
       );
       if (!hasAllNonces) return { fullySigned: false };
       const signatures = await session.sign();
-      const pubkey = import_base2.hex.encode(await session.getPublicKey());
+      const pubkey = import_base3.hex.encode(await session.getPublicKey());
       await arkProvider.submitTreeSignatures(
         event.id,
         pubkey,
@@ -1315,7 +1406,7 @@ function createVHTLCBatchHandler(intentId, vhtlc, arkProvider, identity, session
       );
       const signedForfeitTx = await identity.sign(forfeitTx);
       await arkProvider.submitSignedForfeitTxs([
-        import_base2.base64.encode(signedForfeitTx.toPSBT())
+        import_base3.base64.encode(signedForfeitTx.toPSBT())
       ]);
     }
   };
@@ -1341,7 +1432,7 @@ function createForfeitTx(input, forfeitOutputScript, connector) {
           amount: BigInt(input.value),
           script: import_sdk4.VtxoScript.decode(input.tapTree).pkScript
         },
-        sighashType: import_btc_signer.SigHash.DEFAULT,
+        sighashType: import_btc_signer2.SigHash.DEFAULT,
         tapLeafScript: [input.tapLeafScript],
         sequence
       },
@@ -1537,7 +1628,7 @@ var ArkadeLightning = class {
    * @returns The created pending submarine swap.
    */
   async createSubmarineSwap(args) {
-    const refundPublicKey = import_base3.hex.encode(
+    const refundPublicKey = import_base4.hex.encode(
       await this.wallet.identity.compressedPublicKey()
     );
     if (!refundPublicKey)
@@ -1573,7 +1664,7 @@ var ArkadeLightning = class {
   async createReverseSwap(args) {
     if (args.amount <= 0)
       throw new SwapError({ message: "Amount must be greater than 0" });
-    const claimPublicKey = import_base3.hex.encode(
+    const claimPublicKey = import_base4.hex.encode(
       await this.wallet.identity.compressedPublicKey()
     );
     if (!claimPublicKey)
@@ -1581,7 +1672,7 @@ var ArkadeLightning = class {
         message: "Failed to get claim public key from wallet"
       });
     const preimage = (0, import_utils.randomBytes)(32);
-    const preimageHash = import_base3.hex.encode((0, import_sha22.sha256)(preimage));
+    const preimageHash = import_base4.hex.encode((0, import_sha22.sha256)(preimage));
     if (!preimageHash)
       throw new SwapError({ message: "Failed to get preimage hash" });
     const swapRequest = {
@@ -1595,7 +1686,7 @@ var ArkadeLightning = class {
       id: swapResponse.id,
       type: "reverse",
       createdAt: Math.floor(Date.now() / 1e3),
-      preimage: import_base3.hex.encode(preimage),
+      preimage: import_base4.hex.encode(preimage),
       request: swapRequest,
       response: swapResponse,
       status: "swap.created"
@@ -1612,7 +1703,9 @@ var ArkadeLightning = class {
    * @param pendingSwap - The pending reverse swap to claim the VHTLC.
    */
   async claimVHTLC(pendingSwap) {
-    const preimage = import_base3.hex.decode(pendingSwap.preimage);
+    if (!pendingSwap.preimage)
+      throw new Error("Preimage is required to claim VHTLC");
+    const preimage = import_base4.hex.decode(pendingSwap.preimage);
     const aspInfo = await this.arkProvider.getInfo();
     const address = await this.wallet.getAddress();
     const ourXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
@@ -1621,21 +1714,21 @@ var ArkadeLightning = class {
       pendingSwap.id
     );
     const boltzXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      import_base3.hex.decode(pendingSwap.response.refundPublicKey),
+      import_base4.hex.decode(pendingSwap.response.refundPublicKey),
       "boltz",
       pendingSwap.id
     );
     const serverXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      import_base3.hex.decode(aspInfo.signerPubkey),
+      import_base4.hex.decode(aspInfo.signerPubkey),
       "server",
       pendingSwap.id
     );
     const { vhtlcScript, vhtlcAddress } = this.createVHTLCScript({
       network: aspInfo.network,
       preimageHash: (0, import_sha22.sha256)(preimage),
-      receiverPubkey: import_base3.hex.encode(ourXOnlyPublicKey),
-      senderPubkey: import_base3.hex.encode(boltzXOnlyPublicKey),
-      serverPubkey: import_base3.hex.encode(serverXOnlyPublicKey),
+      receiverPubkey: import_base4.hex.encode(ourXOnlyPublicKey),
+      senderPubkey: import_base4.hex.encode(boltzXOnlyPublicKey),
+      serverPubkey: import_base4.hex.encode(serverXOnlyPublicKey),
       timeoutBlockHeights: pendingSwap.response.timeoutBlockHeights
     });
     if (!vhtlcScript)
@@ -1643,7 +1736,7 @@ var ArkadeLightning = class {
     if (vhtlcAddress !== pendingSwap.response.lockupAddress)
       throw new Error("Boltz is trying to scam us");
     const { vtxos } = await this.indexerProvider.getVtxos({
-      scripts: [import_base3.hex.encode(vhtlcScript.pkScript)]
+      scripts: [import_base4.hex.encode(vhtlcScript.pkScript)]
     });
     if (vtxos.length === 0)
       throw new Error("No spendable virtual coins found");
@@ -1691,11 +1784,14 @@ var ArkadeLightning = class {
    * @param pendingSwap - The pending submarine swap to refund the VHTLC.
    */
   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");
     const vhtlcPkScript = import_sdk5.ArkAddress.decode(
       pendingSwap.response.address
     ).pkScript;
     const { vtxos } = await this.indexerProvider.getVtxos({
-      scripts: [import_base3.hex.encode(vhtlcPkScript)]
+      scripts: [import_base4.hex.encode(vhtlcPkScript)]
     });
     if (vtxos.length === 0) {
       throw new Error(
@@ -1715,23 +1811,21 @@ var ArkadeLightning = class {
       pendingSwap.id
     );
     const serverXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      import_base3.hex.decode(aspInfo.signerPubkey),
+      import_base4.hex.decode(aspInfo.signerPubkey),
       "server",
       pendingSwap.id
     );
     const boltzXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      import_base3.hex.decode(pendingSwap.response.claimPublicKey),
+      import_base4.hex.decode(pendingSwap.response.claimPublicKey),
       "boltz",
       pendingSwap.id
     );
     const { vhtlcScript } = this.createVHTLCScript({
       network: aspInfo.network,
-      preimageHash: import_base3.hex.decode(
-        getInvoicePaymentHash(pendingSwap.request.invoice)
-      ),
-      receiverPubkey: import_base3.hex.encode(boltzXOnlyPublicKey),
-      senderPubkey: import_base3.hex.encode(ourXOnlyPublicKey),
-      serverPubkey: import_base3.hex.encode(serverXOnlyPublicKey),
+      preimageHash: import_base4.hex.decode(preimageHash),
+      receiverPubkey: import_base4.hex.encode(boltzXOnlyPublicKey),
+      senderPubkey: import_base4.hex.encode(ourXOnlyPublicKey),
+      serverPubkey: import_base4.hex.encode(serverXOnlyPublicKey),
       timeoutBlockHeights: pendingSwap.response.timeoutBlockHeights
     });
     if (!vhtlcScript)
@@ -1787,14 +1881,14 @@ var ArkadeLightning = class {
       onchain_output_indexes: [],
       valid_at: 0,
       expire_at: 0,
-      cosigners_public_keys: [import_base3.hex.encode(signerPublicKey)]
+      cosigners_public_keys: [import_base4.hex.encode(signerPublicKey)]
     };
     const deleteMessage = {
       type: "delete",
       expire_at: 0
     };
     const intentInput = {
-      txid: import_base3.hex.decode(input.txid),
+      txid: import_base4.hex.decode(input.txid),
       index: input.vout,
       witnessUtxo: {
         amount: BigInt(input.value),
@@ -1817,9 +1911,9 @@ var ArkadeLightning = class {
     const abortController = new AbortController();
     const intentId = await this.arkProvider.registerIntent({
       message: intentMessage,
-      proof: import_base3.base64.encode(signedRegisterIntent.toPSBT())
+      proof: import_base4.base64.encode(signedRegisterIntent.toPSBT())
     });
-    const decodedAddress = (0, import_btc_signer2.Address)(
+    const decodedAddress = (0, import_btc_signer3.Address)(
       network in import_sdk5.networks ? import_sdk5.networks[network] : import_sdk5.networks.bitcoin
     ).decode(forfeitAddress);
     try {
@@ -1829,11 +1923,11 @@ var ArkadeLightning = class {
         this.arkProvider,
         identity,
         signerSession,
-        import_base3.hex.decode(forfeitPubkey).slice(1),
-        isRecoverable2 ? void 0 : import_btc_signer2.OutScript.encode(decodedAddress)
+        import_base4.hex.decode(forfeitPubkey).slice(1),
+        isRecoverable2 ? void 0 : import_btc_signer3.OutScript.encode(decodedAddress)
       );
       const topics = [
-        import_base3.hex.encode(signerPublicKey),
+        import_base4.hex.encode(signerPublicKey),
         `${input.txid}:${input.vout}`
       ];
       const eventStream = this.arkProvider.getEventStream(
@@ -1854,7 +1948,7 @@ var ArkadeLightning = class {
       try {
         await this.arkProvider.deleteIntent({
           message: deleteMessage,
-          proof: import_base3.base64.encode(signedDeleteIntent.toPSBT())
+          proof: import_base4.base64.encode(signedDeleteIntent.toPSBT())
         });
       } catch (error2) {
         logger.error("Failed to delete intent:", error2);
@@ -2006,8 +2100,179 @@ var ArkadeLightning = class {
       });
     });
   }
+  /**
+   * Restore swaps from Boltz API.
+   *
+   * Note: restored swaps may lack local-only data such as the original
+   * Lightning invoice or preimage. They are intended primarily for
+   * display/monitoring and are not automatically wired into the SwapManager.
+   * Do not call `claimVHTLC` / `refundVHTLC` on them unless you have
+   * enriched the objects with the missing fields.
+   *
+   * @param boltzFees - Optional fees response to use for restoration.
+   * @returns An object containing arrays of restored reverse and submarine swaps.
+   */
+  async restoreSwaps(boltzFees) {
+    const publicKey = import_base4.hex.encode(
+      await this.wallet.identity.compressedPublicKey()
+    );
+    if (!publicKey) throw new Error("Failed to get public key from wallet");
+    const fees = boltzFees ?? await this.swapProvider.getFees();
+    const reverseSwaps = [];
+    const submarineSwaps = [];
+    const restoredSwaps = await this.swapProvider.restoreSwaps(publicKey);
+    for (const swap of restoredSwaps) {
+      const { id, createdAt, status } = swap;
+      if (isRestoredReverseSwap(swap)) {
+        const {
+          amount,
+          lockupAddress,
+          preimageHash,
+          serverPublicKey,
+          tree
+        } = swap.claimDetails;
+        reverseSwaps.push({
+          id,
+          createdAt,
+          request: {
+            invoiceAmount: extractInvoiceAmount(amount, fees),
+            claimPublicKey: publicKey,
+            preimageHash
+          },
+          response: {
+            id,
+            invoice: "",
+            // TODO check if we can get the invoice from boltz
+            onchainAmount: amount,
+            lockupAddress,
+            refundPublicKey: serverPublicKey,
+            timeoutBlockHeights: {
+              refund: extractTimeLockFromLeafOutput(
+                tree.refundWithoutBoltzLeaf.output
+              ),
+              unilateralClaim: extractTimeLockFromLeafOutput(
+                tree.unilateralClaimLeaf.output
+              ),
+              unilateralRefund: extractTimeLockFromLeafOutput(
+                tree.unilateralRefundLeaf.output
+              ),
+              unilateralRefundWithoutReceiver: extractTimeLockFromLeafOutput(
+                tree.unilateralRefundWithoutBoltzLeaf.output
+              )
+            }
+          },
+          status,
+          type: "reverse",
+          preimage: ""
+        });
+      } else if (isRestoredSubmarineSwap(swap)) {
+        const { amount, lockupAddress, serverPublicKey, tree } = swap.refundDetails;
+        let preimage = "";
+        try {
+          const data = await this.swapProvider.getSwapPreimage(
+            swap.id
+          );
+          preimage = data.preimage;
+        } catch (error) {
+          logger.warn(
+            `Failed to restore preimage for submarine swap ${id}`,
+            error
+          );
+        }
+        submarineSwaps.push({
+          id,
+          type: "submarine",
+          createdAt,
+          preimage,
+          preimageHash: swap.preimageHash,
+          status,
+          request: {
+            invoice: "",
+            // TODO check if we can get the invoice from boltz
+            refundPublicKey: publicKey
+          },
+          response: {
+            id,
+            address: lockupAddress,
+            expectedAmount: amount,
+            claimPublicKey: serverPublicKey,
+            timeoutBlockHeights: {
+              refund: extractTimeLockFromLeafOutput(
+                tree.refundWithoutBoltzLeaf.output
+              ),
+              unilateralClaim: extractTimeLockFromLeafOutput(
+                tree.unilateralClaimLeaf.output
+              ),
+              unilateralRefund: extractTimeLockFromLeafOutput(
+                tree.unilateralRefundLeaf.output
+              ),
+              unilateralRefundWithoutReceiver: extractTimeLockFromLeafOutput(
+                tree.unilateralRefundWithoutBoltzLeaf.output
+              )
+            }
+          }
+        });
+      }
+    }
+    return { reverseSwaps, submarineSwaps };
+  }
+  // Swap enrichment and validation helpers
+  /**
+   * Enrich a restored reverse swap with its preimage.
+   * This makes the swap claimable via `claimVHTLC`.
+   * Validates that the preimage hash matches the swap's expected preimageHash.
+   *
+   * @param swap - The restored reverse swap to enrich.
+   * @param preimage - The preimage (hex-encoded) for the swap.
+   * @returns The enriched swap object (same reference, mutated).
+   * @throws Error if the preimage does not match the swap's preimageHash.
+   */
+  enrichReverseSwapPreimage(swap, preimage) {
+    const computedHash = import_base4.hex.encode((0, import_sha22.sha256)(import_base4.hex.decode(preimage)));
+    if (computedHash !== swap.request.preimageHash) {
+      throw new Error(
+        `Preimage does not match swap: expected hash ${swap.request.preimageHash}, got ${computedHash}`
+      );
+    }
+    swap.preimage = preimage;
+    return swap;
+  }
+  /**
+   * Enrich a restored submarine swap with its invoice.
+   * This makes the swap refundable via `refundVHTLC`.
+   * Validates that the invoice is well-formed and its payment hash can be extracted.
+   * If the swap has a preimageHash (from restoration), validates that the invoice's
+   * payment hash matches.
+   *
+   * @param swap - The restored submarine swap to enrich.
+   * @param invoice - The Lightning invoice for the swap.
+   * @returns The enriched swap object (same reference, mutated).
+   * @throws Error if the invoice is invalid, cannot be decoded, or payment hash doesn't match.
+   */
+  enrichSubmarineSwapInvoice(swap, invoice) {
+    let paymentHash;
+    try {
+      const decoded = decodeInvoice(invoice);
+      if (!decoded.paymentHash) {
+        throw new Error("Invoice missing payment hash");
+      }
+      paymentHash = decoded.paymentHash;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Invalid Lightning invoice: ${error.message}`);
+      }
+      throw new Error(`Invalid Lightning invoice format`);
+    }
+    if (swap.preimageHash && paymentHash !== swap.preimageHash) {
+      throw new Error(
+        `Invoice payment hash does not match swap: expected ${swap.preimageHash}, got ${paymentHash}`
+      );
+    }
+    swap.request.invoice = invoice;
+    return swap;
+  }
   async claimVHTLCwithOffchainTx(vhtlcIdentity, vhtlcScript, serverXOnlyPublicKey, input, output, arkInfos) {
-    const rawCheckpointTapscript = import_base3.hex.decode(arkInfos.checkpointTapscript);
+    const rawCheckpointTapscript = import_base4.hex.decode(arkInfos.checkpointTapscript);
     const serverUnrollScript = import_sdk5.CSVMultisigTapscript.decode(
       rawCheckpointTapscript
     );
@@ -2018,8 +2283,8 @@ var ArkadeLightning = class {
     );
     const signedArkTx = await vhtlcIdentity.sign(arkTx);
     const { arkTxid, finalArkTx, signedCheckpointTxs } = await this.arkProvider.submitTx(
-      import_base3.base64.encode(signedArkTx.toPSBT()),
-      checkpoints.map((c) => import_base3.base64.encode(c.toPSBT()))
+      import_base4.base64.encode(signedArkTx.toPSBT()),
+      checkpoints.map((c) => import_base4.base64.encode(c.toPSBT()))
     );
     if (!this.validFinalArkTx(
       finalArkTx,
@@ -2030,17 +2295,17 @@ var ArkadeLightning = class {
     }
     const finalCheckpoints = await Promise.all(
       signedCheckpointTxs.map(async (c) => {
-        const tx = import_btc_signer2.Transaction.fromPSBT(import_base3.base64.decode(c), {
+        const tx = import_btc_signer3.Transaction.fromPSBT(import_base4.base64.decode(c), {
           allowUnknown: true
         });
         const signedCheckpoint = await vhtlcIdentity.sign(tx, [0]);
-        return import_base3.base64.encode(signedCheckpoint.toPSBT());
+        return import_base4.base64.encode(signedCheckpoint.toPSBT());
       })
     );
     await this.arkProvider.finalizeTx(arkTxid, finalCheckpoints);
   }
   async refundVHTLCwithOffchainTx(pendingSwap, boltzXOnlyPublicKey, ourXOnlyPublicKey, serverXOnlyPublicKey, input, output, arkInfos) {
-    const rawCheckpointTapscript = import_base3.hex.decode(arkInfos.checkpointTapscript);
+    const rawCheckpointTapscript = import_base4.hex.decode(arkInfos.checkpointTapscript);
     const serverUnrollScript = import_sdk5.CSVMultisigTapscript.decode(
       rawCheckpointTapscript
     );
@@ -2058,7 +2323,7 @@ var ArkadeLightning = class {
       unsignedRefundTx,
       unsignedCheckpointTx
     );
-    const boltzXOnlyPublicKeyHex = import_base3.hex.encode(boltzXOnlyPublicKey);
+    const boltzXOnlyPublicKeyHex = import_base4.hex.encode(boltzXOnlyPublicKey);
     if (!verifySignatures(boltzSignedRefundTx, 0, [boltzXOnlyPublicKeyHex])) {
       throw new Error("Invalid Boltz signature in refund transaction");
     }
@@ -2080,15 +2345,15 @@ var ArkadeLightning = class {
       signedCheckpointTx
     );
     const { arkTxid, finalArkTx, signedCheckpointTxs } = await this.arkProvider.submitTx(
-      import_base3.base64.encode(combinedSignedRefundTx.toPSBT()),
-      [import_base3.base64.encode(unsignedCheckpointTx.toPSBT())]
+      import_base4.base64.encode(combinedSignedRefundTx.toPSBT()),
+      [import_base4.base64.encode(unsignedCheckpointTx.toPSBT())]
     );
-    const tx = import_btc_signer2.Transaction.fromPSBT(import_base3.base64.decode(finalArkTx));
+    const tx = import_btc_signer3.Transaction.fromPSBT(import_base4.base64.decode(finalArkTx));
     const inputIndex = 0;
     const requiredSigners = [
-      import_base3.hex.encode(ourXOnlyPublicKey),
-      import_base3.hex.encode(boltzXOnlyPublicKey),
-      import_base3.hex.encode(serverXOnlyPublicKey)
+      import_base4.hex.encode(ourXOnlyPublicKey),
+      import_base4.hex.encode(boltzXOnlyPublicKey),
+      import_base4.hex.encode(serverXOnlyPublicKey)
     ];
     if (!verifySignatures(tx, inputIndex, requiredSigners)) {
       throw new Error("Invalid refund transaction");
@@ -2098,15 +2363,15 @@ var ArkadeLightning = class {
         `Expected one signed checkpoint transaction, got ${signedCheckpointTxs.length}`
       );
     }
-    const serverSignedCheckpointTx = import_btc_signer2.Transaction.fromPSBT(
-      import_base3.base64.decode(signedCheckpointTxs[0])
+    const serverSignedCheckpointTx = import_btc_signer3.Transaction.fromPSBT(
+      import_base4.base64.decode(signedCheckpointTxs[0])
     );
     const finalCheckpointTx = (0, import_sdk5.combineTapscriptSigs)(
       combinedSignedCheckpointTx,
       serverSignedCheckpointTx
     );
     await this.arkProvider.finalizeTx(arkTxid, [
-      import_base3.base64.encode(finalCheckpointTx.toPSBT())
+      import_base4.base64.encode(finalCheckpointTx.toPSBT())
     ]);
   }
   // validators
@@ -2121,7 +2386,7 @@ var ArkadeLightning = class {
    * @returns True if the final Ark transaction is valid, false otherwise.
    */
   validFinalArkTx = (finalArkTx, _pubkey, _tapLeaves) => {
-    const tx = import_btc_signer2.Transaction.fromPSBT(import_base3.base64.decode(finalArkTx), {
+    const tx = import_btc_signer3.Transaction.fromPSBT(import_base4.base64.decode(finalArkTx), {
       allowUnknown: true
     });
     if (!tx) return false;
@@ -2149,15 +2414,15 @@ var ArkadeLightning = class {
     timeoutBlockHeights
   }) {
     const receiverXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      import_base3.hex.decode(receiverPubkey),
+      import_base4.hex.decode(receiverPubkey),
       "receiver"
     );
     const senderXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      import_base3.hex.decode(senderPubkey),
+      import_base4.hex.decode(senderPubkey),
       "sender"
     );
     const serverXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      import_base3.hex.decode(serverPubkey),
+      import_base4.hex.decode(serverPubkey),
       "server"
     );
     const delayType = (num) => num < 512 ? "blocks" : "seconds";