@arkade-os/boltz-swap 0.2.13 → 0.2.15

package/dist/index.js

@@ -89,7 +89,7 @@ import {
   getSequence as getSequence2
 } from "@arkade-os/sdk";
 import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
-import { base64 as base643, hex as hex2 } from "@scure/base";
+import { base64 as base643, hex as hex3 } from "@scure/base";
 import { randomBytes } from "@noble/hashes/utils.js";
 
 // src/boltz-swap-provider.ts
@@ -131,7 +131,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"));
@@ -154,6 +154,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"
@@ -384,6 +404,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 {
@@ -451,6 +486,50 @@ var verifySignatures = (tx, inputIndex, requiredSigners) => {
   }
 };
 
+// src/utils/restoration.ts
+import { hex } from "@scure/base";
+import { Script } from "@scure/btc-signer";
+import bip68 from "bip68";
+function extractTimeLockFromLeafOutput(scriptHex) {
+  if (!scriptHex) return 0;
+  try {
+    const opcodes = Script.decode(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(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
+        } = bip68.decode(
+          parseInt(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) {
@@ -948,6 +1027,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);
@@ -956,6 +1041,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);
@@ -1175,13 +1266,13 @@ import {
   getSequence
 } from "@arkade-os/sdk";
 import { sha256 } from "@noble/hashes/sha2.js";
-import { base64 as base642, hex } from "@scure/base";
+import { base64 as base642, hex as hex2 } from "@scure/base";
 import { SigHash } from "@scure/btc-signer";
 import { tapLeafHash } from "@scure/btc-signer/payment.js";
 function createVHTLCBatchHandler(intentId, vhtlc, arkProvider, identity, session, sweepPublicKey, forfeitOutputScript, connectorIndex = 0) {
   const utf8IntentId = new TextEncoder().encode(intentId);
   const intentIdHash = sha256(utf8IntentId);
-  const intentIdHashStr = hex.encode(intentIdHash);
+  const intentIdHashStr = hex2.encode(intentIdHash);
   let sweepTapTreeRoot;
   return {
     onBatchStarted: async (event) => {
@@ -1220,7 +1311,7 @@ function createVHTLCBatchHandler(intentId, vhtlc, arkProvider, identity, session
       );
       const signerPublicKey = await session.getPublicKey();
       const xonlySignerPublicKey = signerPublicKey.subarray(1);
-      if (!xOnlyPublicKeys.includes(hex.encode(xonlySignerPublicKey))) {
+      if (!xOnlyPublicKeys.includes(hex2.encode(xonlySignerPublicKey))) {
         return { skip: true };
       }
       const commitmentTx = Transaction3.fromPSBT(
@@ -1232,7 +1323,7 @@ function createVHTLCBatchHandler(intentId, vhtlc, arkProvider, identity, session
         throw new Error("Shared output not found");
       }
       await session.init(vtxoTree, sweepTapTreeRoot, sharedOutput.amount);
-      const pubkey = hex.encode(await session.getPublicKey());
+      const pubkey = hex2.encode(await session.getPublicKey());
       const nonces = await session.getNonces();
       await arkProvider.submitTreeNonces(event.id, pubkey, nonces);
       return { skip: false };
@@ -1247,7 +1338,7 @@ function createVHTLCBatchHandler(intentId, vhtlc, arkProvider, identity, session
       );
       if (!hasAllNonces) return { fullySigned: false };
       const signatures = await session.sign();
-      const pubkey = hex.encode(await session.getPublicKey());
+      const pubkey = hex2.encode(await session.getPublicKey());
       await arkProvider.submitTreeSignatures(
         event.id,
         pubkey,
@@ -1500,7 +1591,7 @@ var ArkadeLightning = class {
    * @returns The created pending submarine swap.
    */
   async createSubmarineSwap(args) {
-    const refundPublicKey = hex2.encode(
+    const refundPublicKey = hex3.encode(
       await this.wallet.identity.compressedPublicKey()
     );
     if (!refundPublicKey)
@@ -1536,7 +1627,7 @@ var ArkadeLightning = class {
   async createReverseSwap(args) {
     if (args.amount <= 0)
       throw new SwapError({ message: "Amount must be greater than 0" });
-    const claimPublicKey = hex2.encode(
+    const claimPublicKey = hex3.encode(
       await this.wallet.identity.compressedPublicKey()
     );
     if (!claimPublicKey)
@@ -1544,7 +1635,7 @@ var ArkadeLightning = class {
         message: "Failed to get claim public key from wallet"
       });
     const preimage = randomBytes(32);
-    const preimageHash = hex2.encode(sha2562(preimage));
+    const preimageHash = hex3.encode(sha2562(preimage));
     if (!preimageHash)
       throw new SwapError({ message: "Failed to get preimage hash" });
     const swapRequest = {
@@ -1558,7 +1649,7 @@ var ArkadeLightning = class {
       id: swapResponse.id,
       type: "reverse",
       createdAt: Math.floor(Date.now() / 1e3),
-      preimage: hex2.encode(preimage),
+      preimage: hex3.encode(preimage),
       request: swapRequest,
       response: swapResponse,
       status: "swap.created"
@@ -1575,7 +1666,9 @@ var ArkadeLightning = class {
    * @param pendingSwap - The pending reverse swap to claim the VHTLC.
    */
   async claimVHTLC(pendingSwap) {
-    const preimage = hex2.decode(pendingSwap.preimage);
+    if (!pendingSwap.preimage)
+      throw new Error("Preimage is required to claim VHTLC");
+    const preimage = hex3.decode(pendingSwap.preimage);
     const aspInfo = await this.arkProvider.getInfo();
     const address = await this.wallet.getAddress();
     const ourXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
@@ -1584,21 +1677,21 @@ var ArkadeLightning = class {
       pendingSwap.id
     );
     const boltzXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      hex2.decode(pendingSwap.response.refundPublicKey),
+      hex3.decode(pendingSwap.response.refundPublicKey),
       "boltz",
       pendingSwap.id
     );
     const serverXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      hex2.decode(aspInfo.signerPubkey),
+      hex3.decode(aspInfo.signerPubkey),
       "server",
       pendingSwap.id
     );
     const { vhtlcScript, vhtlcAddress } = this.createVHTLCScript({
       network: aspInfo.network,
       preimageHash: sha2562(preimage),
-      receiverPubkey: hex2.encode(ourXOnlyPublicKey),
-      senderPubkey: hex2.encode(boltzXOnlyPublicKey),
-      serverPubkey: hex2.encode(serverXOnlyPublicKey),
+      receiverPubkey: hex3.encode(ourXOnlyPublicKey),
+      senderPubkey: hex3.encode(boltzXOnlyPublicKey),
+      serverPubkey: hex3.encode(serverXOnlyPublicKey),
       timeoutBlockHeights: pendingSwap.response.timeoutBlockHeights
     });
     if (!vhtlcScript)
@@ -1606,7 +1699,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: [hex2.encode(vhtlcScript.pkScript)]
+      scripts: [hex3.encode(vhtlcScript.pkScript)]
     });
     if (vtxos.length === 0)
       throw new Error("No spendable virtual coins found");
@@ -1654,11 +1747,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 = ArkAddress.decode(
       pendingSwap.response.address
     ).pkScript;
     const { vtxos } = await this.indexerProvider.getVtxos({
-      scripts: [hex2.encode(vhtlcPkScript)]
+      scripts: [hex3.encode(vhtlcPkScript)]
     });
     if (vtxos.length === 0) {
       throw new Error(
@@ -1678,23 +1774,21 @@ var ArkadeLightning = class {
       pendingSwap.id
     );
     const serverXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      hex2.decode(aspInfo.signerPubkey),
+      hex3.decode(aspInfo.signerPubkey),
       "server",
       pendingSwap.id
     );
     const boltzXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      hex2.decode(pendingSwap.response.claimPublicKey),
+      hex3.decode(pendingSwap.response.claimPublicKey),
       "boltz",
       pendingSwap.id
     );
     const { vhtlcScript } = this.createVHTLCScript({
       network: aspInfo.network,
-      preimageHash: hex2.decode(
-        getInvoicePaymentHash(pendingSwap.request.invoice)
-      ),
-      receiverPubkey: hex2.encode(boltzXOnlyPublicKey),
-      senderPubkey: hex2.encode(ourXOnlyPublicKey),
-      serverPubkey: hex2.encode(serverXOnlyPublicKey),
+      preimageHash: hex3.decode(preimageHash),
+      receiverPubkey: hex3.encode(boltzXOnlyPublicKey),
+      senderPubkey: hex3.encode(ourXOnlyPublicKey),
+      serverPubkey: hex3.encode(serverXOnlyPublicKey),
       timeoutBlockHeights: pendingSwap.response.timeoutBlockHeights
     });
     if (!vhtlcScript)
@@ -1750,14 +1844,14 @@ var ArkadeLightning = class {
       onchain_output_indexes: [],
       valid_at: 0,
       expire_at: 0,
-      cosigners_public_keys: [hex2.encode(signerPublicKey)]
+      cosigners_public_keys: [hex3.encode(signerPublicKey)]
     };
     const deleteMessage = {
       type: "delete",
       expire_at: 0
     };
     const intentInput = {
-      txid: hex2.decode(input.txid),
+      txid: hex3.decode(input.txid),
       index: input.vout,
       witnessUtxo: {
         amount: BigInt(input.value),
@@ -1792,11 +1886,11 @@ var ArkadeLightning = class {
         this.arkProvider,
         identity,
         signerSession,
-        hex2.decode(forfeitPubkey).slice(1),
+        hex3.decode(forfeitPubkey).slice(1),
         isRecoverable2 ? void 0 : OutScript.encode(decodedAddress)
       );
       const topics = [
-        hex2.encode(signerPublicKey),
+        hex3.encode(signerPublicKey),
         `${input.txid}:${input.vout}`
       ];
       const eventStream = this.arkProvider.getEventStream(
@@ -1969,8 +2063,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 = hex3.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 = hex3.encode(sha2562(hex3.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 = hex2.decode(arkInfos.checkpointTapscript);
+    const rawCheckpointTapscript = hex3.decode(arkInfos.checkpointTapscript);
     const serverUnrollScript = CSVMultisigTapscript2.decode(
       rawCheckpointTapscript
     );
@@ -2003,7 +2268,7 @@ var ArkadeLightning = class {
     await this.arkProvider.finalizeTx(arkTxid, finalCheckpoints);
   }
   async refundVHTLCwithOffchainTx(pendingSwap, boltzXOnlyPublicKey, ourXOnlyPublicKey, serverXOnlyPublicKey, input, output, arkInfos) {
-    const rawCheckpointTapscript = hex2.decode(arkInfos.checkpointTapscript);
+    const rawCheckpointTapscript = hex3.decode(arkInfos.checkpointTapscript);
     const serverUnrollScript = CSVMultisigTapscript2.decode(
       rawCheckpointTapscript
     );
@@ -2021,7 +2286,7 @@ var ArkadeLightning = class {
       unsignedRefundTx,
       unsignedCheckpointTx
     );
-    const boltzXOnlyPublicKeyHex = hex2.encode(boltzXOnlyPublicKey);
+    const boltzXOnlyPublicKeyHex = hex3.encode(boltzXOnlyPublicKey);
     if (!verifySignatures(boltzSignedRefundTx, 0, [boltzXOnlyPublicKeyHex])) {
       throw new Error("Invalid Boltz signature in refund transaction");
     }
@@ -2049,9 +2314,9 @@ var ArkadeLightning = class {
     const tx = Transaction4.fromPSBT(base643.decode(finalArkTx));
     const inputIndex = 0;
     const requiredSigners = [
-      hex2.encode(ourXOnlyPublicKey),
-      hex2.encode(boltzXOnlyPublicKey),
-      hex2.encode(serverXOnlyPublicKey)
+      hex3.encode(ourXOnlyPublicKey),
+      hex3.encode(boltzXOnlyPublicKey),
+      hex3.encode(serverXOnlyPublicKey)
     ];
     if (!verifySignatures(tx, inputIndex, requiredSigners)) {
       throw new Error("Invalid refund transaction");
@@ -2112,15 +2377,15 @@ var ArkadeLightning = class {
     timeoutBlockHeights
   }) {
     const receiverXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      hex2.decode(receiverPubkey),
+      hex3.decode(receiverPubkey),
       "receiver"
     );
     const senderXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      hex2.decode(senderPubkey),
+      hex3.decode(senderPubkey),
       "sender"
     );
     const serverXOnlyPublicKey = this.normalizeToXOnlyPublicKey(
-      hex2.decode(serverPubkey),
+      hex3.decode(serverPubkey),
       "server"
     );
     const delayType = (num) => num < 512 ? "blocks" : "seconds";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/boltz-swap",
-  "version": "0.2.13",
+  "version": "0.2.15",
   "type": "module",
   "description": "A production-ready TypeScript package that brings Boltz submarine-swaps to Arkade.",
   "main": "./dist/index.js",
@@ -34,6 +34,7 @@
     "@noble/hashes": "2.0.1",
     "@scure/base": "2.0.0",
     "@scure/btc-signer": "2.0.1",
+    "bip68": "^1.0.4",
     "light-bolt11-decoder": "3.2.0"
   },
   "devDependencies": {