@arkade-os/boltz-swap 0.3.39 → 0.3.41

package/dist/{chunk-CFB2NNGT.js → chunk-UXYHW7KV.js}

@@ -233,6 +233,22 @@ var isSubmarinePendingStatus = (status) => {
 var isSubmarineRefundableStatus = (status) => {
   return ["invoice.failedToPay", "transaction.lockupFailed", "swap.expired"].includes(status);
 };
+var SUBMARINE_STATUS_PROGRESSION = [
+  "swap.created",
+  "invoice.set",
+  "transaction.mempool",
+  "transaction.confirmed",
+  "invoice.pending",
+  "invoice.paid",
+  "transaction.claim.pending",
+  "transaction.claimed"
+];
+var hasSubmarineStatusReached = (status, target) => {
+  const progression = SUBMARINE_STATUS_PROGRESSION;
+  const statusIndex = progression.indexOf(status);
+  const targetIndex = progression.indexOf(target);
+  return statusIndex >= 0 && targetIndex >= 0 && statusIndex >= targetIndex;
+};
 var isSubmarineSuccessStatus = (status) => {
   return status === "transaction.claimed";
 };
@@ -976,10 +992,10 @@ import bolt11 from "light-bolt11-decoder";
 import { ArkAddress } from "@arkade-os/sdk";
 var decodeInvoice = (invoice) => {
   const decoded = bolt11.decode(invoice);
-  const millisats = Number(decoded.sections.find((s) => s.name === "amount")?.value ?? "0");
+  const millisats = BigInt(decoded.sections.find((s) => s.name === "amount")?.value ?? "0");
   return {
     expiry: decoded.expiry ?? 3600,
-    amountSats: Math.floor(millisats / 1e3),
+    amountSats: Number(millisats / 1000n),
     description: decoded.sections.find((s) => s.name === "description")?.value ?? "",
     paymentHash: decoded.sections.find((s) => s.name === "payment_hash")?.value ?? ""
   };
@@ -2966,6 +2982,19 @@ var createVHTLCScript = (args) => {
   const vhtlcAddress = vhtlcScript.address(hrp, serverXOnlyPublicKey).encode();
   return { vhtlcScript, vhtlcAddress };
 };
+var candidateServerPubkeys = (arkInfo) => {
+  const current = hex7.encode(normalizeToXOnlyKey(hex7.decode(arkInfo.signerPubkey), "server"));
+  const seen = /* @__PURE__ */ new Set([current]);
+  const candidates = [current];
+  for (const deprecated of arkInfo.deprecatedSigners ?? []) {
+    if (!deprecated.pubkey) continue;
+    const key = hex7.encode(normalizeToXOnlyKey(hex7.decode(deprecated.pubkey), "server"));
+    if (seen.has(key)) continue;
+    seen.add(key);
+    candidates.push(key);
+  }
+  return candidates;
+};
 var joinBatch = async (arkProvider, identity, input, output, {
   forfeitPubkey,
   forfeitAddress,
@@ -3380,6 +3409,10 @@ var ArkadeSwaps = class _ArkadeSwaps {
       ...args.description?.trim() ? { description: args.description.trim() } : {}
     };
     const swapResponse = await this.swapProvider.createReverseSwap(swapRequest);
+    const decodedInvoice = decodeInvoice(swapResponse.invoice);
+    if (decodedInvoice.paymentHash !== preimageHash) {
+      throw new SwapError({ message: "Preimage hash does not match invoice payment hash" });
+    }
     const pendingSwap = {
       id: swapResponse.id,
       type: "reverse",
@@ -3423,27 +3456,15 @@ var ArkadeSwaps = class _ArkadeSwaps {
       "boltz",
       pendingSwap.id
     );
-    const serverXOnly = normalizeToXOnlyKey(
-      hex8.decode(arkInfo.signerPubkey),
-      "server",
-      pendingSwap.id
-    );
-    const { vhtlcScript, vhtlcAddress } = this.createVHTLCScript({
-      network: arkInfo.network,
+    const { vhtlcScript, serverXOnlyPublicKey: serverXOnly } = this.resolveVHTLCForLockup({
+      arkInfo,
       preimageHash: sha2563(preimage),
       receiverPubkey: hex8.encode(receiverXOnly),
       senderPubkey: hex8.encode(senderXOnly),
-      serverPubkey: hex8.encode(serverXOnly),
-      timeoutBlockHeights: vhtlcTimeouts
+      timeoutBlockHeights: vhtlcTimeouts,
+      lockupAddress,
+      swapId: pendingSwap.id
     });
-    if (!vhtlcScript.claimScript)
-      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}`
-      );
     let unspentVtxos = [];
     let rawVtxos = [];
     for (let attempt = 1; attempt <= CLAIM_VTXO_RETRY_ATTEMPTS; attempt++) {
@@ -3594,16 +3615,6 @@ var ArkadeSwaps = class _ArkadeSwaps {
       this.swapProvider.monitorSwap(pendingSwap.id, onStatusUpdate).catch(reject);
     });
   }
-  // =========================================================================
-  // Lightning: Submarine swaps (send Arkade -> Lightning)
-  // =========================================================================
-  /**
-   * Sends a Lightning payment via a submarine swap (Arkade → Lightning).
-   * Creates the swap, sends funds, and waits for settlement. Auto-refunds on failure.
-   * @param args.invoice - BOLT11 Lightning invoice to pay.
-   * @returns The amount paid, preimage (proof of payment), and transaction ID.
-   * @throws {TransactionFailedError} If the payment fails (auto-refunds if possible).
-   */
   async sendLightningPayment(args) {
     const pendingSwap = await this.createSubmarineSwap(args);
     if (!pendingSwap.response.address)
@@ -3614,6 +3625,18 @@ var ArkadeSwaps = class _ArkadeSwaps {
       amount: pendingSwap.response.expectedAmount
     });
     try {
+      if (args.waitFor === "funded") {
+        if (!this.swapManager) {
+          logger.warn(
+            `Swap ${pendingSwap.id}: sendLightningPayment with waitFor "funded" but SwapManager is disabled \u2014 a failure after this promise resolves is only persisted as refundable, not auto-refunded; recover via restoreSwaps/recoverSubmarineFunds`
+          );
+        }
+        await this.waitForSwapFunded(pendingSwap);
+        return {
+          amount: pendingSwap.response.expectedAmount,
+          txid
+        };
+      }
       const { preimage } = await this.waitForSwapSettlement(pendingSwap);
       return {
         amount: pendingSwap.response.expectedAmount,
@@ -3685,11 +3708,6 @@ var ArkadeSwaps = class _ArkadeSwaps {
       "our",
       swap.id
     );
-    const serverXOnlyPublicKey = normalizeToXOnlyKey(
-      hex8.decode(resolvedArkInfo.signerPubkey),
-      "server",
-      swap.id
-    );
     const { claimPublicKey, timeoutBlockHeights: vhtlcTimeouts } = swap.response;
     if (!claimPublicKey || !vhtlcTimeouts)
       throw new Error(`Swap ${swap.id}: incomplete submarine swap response`);
@@ -3698,20 +3716,19 @@ var ArkadeSwaps = class _ArkadeSwaps {
       "boltz",
       swap.id
     );
-    const { vhtlcScript, vhtlcAddress } = this.createVHTLCScript({
-      network: resolvedArkInfo.network,
+    const lockupAddress = swap.response.address;
+    if (!lockupAddress)
+      throw new Error(`Swap ${swap.id}: missing lockup address in submarine swap response`);
+    const { vhtlcScript, serverXOnlyPublicKey } = this.resolveVHTLCForLockup({
+      arkInfo: resolvedArkInfo,
       preimageHash: hex8.decode(preimageHash),
       receiverPubkey: hex8.encode(boltzXOnlyPublicKey),
       senderPubkey: hex8.encode(ourXOnlyPublicKey),
-      serverPubkey: hex8.encode(serverXOnlyPublicKey),
-      timeoutBlockHeights: vhtlcTimeouts
+      timeoutBlockHeights: vhtlcTimeouts,
+      lockupAddress,
+      swapId: swap.id
     });
-    if (!vhtlcScript.claimScript)
-      throw new Error(`Swap ${swap.id}: failed to create VHTLC script for submarine swap`);
-    if (vhtlcAddress !== swap.response.address)
-      throw new Error(
-        `VHTLC address mismatch for swap ${swap.id}: expected ${swap.response.address}, got ${vhtlcAddress}`
-      );
+    const vhtlcAddress = lockupAddress;
     const vhtlcPkScriptHex = hex8.encode(vhtlcScript.pkScript);
     return {
       arkInfo: resolvedArkInfo,
@@ -4121,6 +4138,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
   }
   /**
    * Waits for a submarine swap's Lightning payment to settle.
+   * Resolves only at the terminal "transaction.claimed" status, once Boltz
+   * has swept the HTLC. To resolve as soon as the payment is in flight, use
+   * {@link waitForSwapFunded} instead.
    * @param pendingSwap - The submarine swap to monitor.
    * @returns The preimage from the settled Lightning payment (proof of payment).
    * @throws {SwapExpiredError} If the swap expires.
@@ -4128,19 +4148,59 @@ var ArkadeSwaps = class _ArkadeSwaps {
    * @throws {TransactionLockupFailedError} If the lockup transaction fails.
    */
   async waitForSwapSettlement(pendingSwap) {
+    return this.waitForSubmarineSwap(pendingSwap);
+  }
+  /**
+   * Waits until a submarine swap is funded: resolves as soon as the lockup
+   * transaction is observed ("transaction.mempool" or any later status in
+   * the lifecycle — statuses can be skipped since subscriptions report only
+   * the current one). The sender's funds are committed and the swap is
+   * refundable from this point, which is when most Lightning wallets show
+   * a payment as "sent".
+   *
+   * Monitoring continues in the background until the swap reaches a
+   * terminal status, persisting updates to the repository (the preimage on
+   * claim, the refundable flag on failure), but this promise no longer
+   * rejects once resolved — acting on a late failure is the caller's
+   * responsibility (the SwapManager handles it automatically when enabled).
+   * @param pendingSwap - The submarine swap to monitor.
+   * @throws {SwapExpiredError} If the swap expires before funding.
+   * @throws {InvoiceFailedToPayError} If Boltz fails to route the payment.
+   * @throws {TransactionLockupFailedError} If the lockup transaction fails.
+   */
+  async waitForSwapFunded(pendingSwap) {
+    await this.waitForSubmarineSwap(pendingSwap, "transaction.mempool");
+  }
+  /**
+   * Shared wait machinery: monitors the swap and resolves at the terminal
+   * "transaction.claimed" status (with the preimage) or, when `resolveAt`
+   * is given, as soon as that status — or any later one in the successful
+   * progression — is observed (without a preimage).
+   */
+  async waitForSubmarineSwap(pendingSwap, resolveAt) {
     return new Promise((resolve, reject) => {
-      let isResolved = false;
+      let isFinal = false;
+      let isSettled = false;
       const onStatusUpdate = async (status) => {
-        if (isResolved) return;
-        const saveStatus = (additionalFields) => updateSubmarineSwapStatus(
-          pendingSwap,
-          status,
-          this.savePendingSubmarineSwap.bind(this),
-          additionalFields
-        );
+        if (isFinal) return;
+        const saveStatus = async (additionalFields) => {
+          try {
+            await updateSubmarineSwapStatus(
+              pendingSwap,
+              status,
+              this.savePendingSubmarineSwap.bind(this),
+              additionalFields
+            );
+          } catch (error) {
+            logger.error(
+              `Swap ${pendingSwap.id}: failed to persist status "${status}": ${error}`
+            );
+          }
+        };
         switch (status) {
           case "swap.expired":
-            isResolved = true;
+            isFinal = true;
+            isSettled = true;
             await saveStatus({ refundable: true });
             reject(
               new SwapExpiredError({
@@ -4150,7 +4210,8 @@ var ArkadeSwaps = class _ArkadeSwaps {
             );
             break;
           case "invoice.failedToPay":
-            isResolved = true;
+            isFinal = true;
+            isSettled = true;
             await saveStatus({ refundable: true });
             reject(
               new InvoiceFailedToPayError({
@@ -4160,7 +4221,8 @@ var ArkadeSwaps = class _ArkadeSwaps {
             );
             break;
           case "transaction.lockupFailed":
-            isResolved = true;
+            isFinal = true;
+            isSettled = true;
             await saveStatus({ refundable: true });
             reject(
               new TransactionLockupFailedError({
@@ -4170,23 +4232,47 @@ var ArkadeSwaps = class _ArkadeSwaps {
             );
             break;
           case "transaction.claimed": {
-            isResolved = true;
-            const { preimage } = await this.swapProvider.getSwapPreimage(
-              pendingSwap.id
-            );
-            await saveStatus({ preimage });
-            resolve({ preimage });
+            isFinal = true;
+            isSettled = true;
+            try {
+              const { preimage } = await this.swapProvider.getSwapPreimage(
+                pendingSwap.id
+              );
+              await saveStatus({ preimage });
+              resolve({ preimage });
+            } catch (error) {
+              logger.error(
+                `Swap ${pendingSwap.id}: failed to fetch preimage on claim: ${error}`
+              );
+              reject(error);
+            }
             break;
           }
           default:
             await saveStatus();
+            if (resolveAt && hasSubmarineStatusReached(status, resolveAt)) {
+              isSettled = true;
+              resolve({ preimage: void 0 });
+            }
             break;
         }
       };
-      this.swapProvider.monitorSwap(pendingSwap.id, onStatusUpdate).catch((error) => {
-        if (!isResolved) {
-          isResolved = true;
+      this.swapProvider.monitorSwap(pendingSwap.id, (status) => {
+        onStatusUpdate(status).catch(
+          (error) => logger.error(
+            `Swap ${pendingSwap.id}: error handling status "${status}": ${error}`
+          )
+        );
+      }).catch((error) => {
+        if (!isSettled) {
+          isFinal = true;
+          isSettled = true;
           reject(error);
+        } else {
+          isFinal = true;
+          logger.warn(
+            `Swap ${pendingSwap.id}: monitor failed after settlement: ${error}`
+          );
         }
       });
     });
@@ -4424,29 +4510,26 @@ var ArkadeSwaps = class _ArkadeSwaps {
       "user",
       pendingSwap.id
     );
-    const serverXOnlyPublicKey = normalizeToXOnlyKey(
-      hex8.decode(arkInfo.signerPubkey),
-      "server",
-      pendingSwap.id
-    );
     const boltzXOnlyPublicKey = normalizeToXOnlyKey(
       hex8.decode(pendingSwap.response.lockupDetails.serverPublicKey),
       "boltz",
       pendingSwap.id
     );
-    const { vhtlcAddress, vhtlcScript } = this.createVHTLCScript({
-      network: arkInfo.network,
-      preimageHash: hex8.decode(pendingSwap.request.preimageHash),
-      serverPubkey: hex8.encode(serverXOnlyPublicKey),
-      senderPubkey: hex8.encode(ourXOnlyPublicKey),
-      receiverPubkey: hex8.encode(boltzXOnlyPublicKey),
-      timeoutBlockHeights: pendingSwap.response.lockupDetails.timeouts
-    });
-    if (!vhtlcScript.refundScript)
-      throw new Error(`Swap ${pendingSwap.id}: failed to create VHTLC script for chain swap`);
-    if (pendingSwap.response.lockupDetails.lockupAddress !== vhtlcAddress) {
+    let vhtlcScript;
+    let serverXOnlyPublicKey;
+    try {
+      ({ vhtlcScript, serverXOnlyPublicKey } = this.resolveVHTLCForLockup({
+        arkInfo,
+        preimageHash: hex8.decode(pendingSwap.request.preimageHash),
+        senderPubkey: hex8.encode(ourXOnlyPublicKey),
+        receiverPubkey: hex8.encode(boltzXOnlyPublicKey),
+        timeoutBlockHeights: pendingSwap.response.lockupDetails.timeouts,
+        lockupAddress: pendingSwap.response.lockupDetails.lockupAddress,
+        swapId: pendingSwap.id
+      }));
+    } catch (error) {
       throw new SwapError({
-        message: "Unable to claim: invalid VHTLC address"
+        message: error instanceof Error ? error.message : "Unable to refund: invalid VHTLC address"
       });
     }
     const { vtxos } = await this.indexerProvider.getVtxos({
@@ -4705,20 +4788,21 @@ var ArkadeSwaps = class _ArkadeSwaps {
       pendingSwap.response.claimDetails.serverPublicKey,
       "sender"
     );
-    const serverXOnlyPublicKey = normalizeToXOnlyKey(arkInfo.signerPubkey, "server");
-    const { vhtlcAddress, vhtlcScript } = this.createVHTLCScript({
-      network: arkInfo.network,
-      preimageHash: hex8.decode(pendingSwap.request.preimageHash),
-      serverPubkey: hex8.encode(serverXOnlyPublicKey),
-      senderPubkey: hex8.encode(senderXOnlyPublicKey),
-      receiverPubkey: hex8.encode(receiverXOnlyPublicKey),
-      timeoutBlockHeights: pendingSwap.response.claimDetails.timeouts
-    });
-    if (!vhtlcScript.claimScript)
-      throw new Error(`Swap ${pendingSwap.id}: failed to create VHTLC script for chain swap`);
-    if (pendingSwap.response.claimDetails.lockupAddress !== vhtlcAddress) {
+    let vhtlcScript;
+    let serverXOnlyPublicKey;
+    try {
+      ({ vhtlcScript, serverXOnlyPublicKey } = this.resolveVHTLCForLockup({
+        arkInfo,
+        preimageHash: hex8.decode(pendingSwap.request.preimageHash),
+        senderPubkey: hex8.encode(senderXOnlyPublicKey),
+        receiverPubkey: hex8.encode(receiverXOnlyPublicKey),
+        timeoutBlockHeights: pendingSwap.response.claimDetails.timeouts,
+        lockupAddress: pendingSwap.response.claimDetails.lockupAddress,
+        swapId: pendingSwap.id
+      }));
+    } catch (error) {
       throw new SwapError({
-        message: "Unable to claim: invalid VHTLC address"
+        message: error instanceof Error ? error.message : "Unable to claim: invalid VHTLC address"
       });
     }
     let vtxo;
@@ -5080,6 +5164,55 @@ var ArkadeSwaps = class _ArkadeSwaps {
   createVHTLCScript(args) {
     return createVHTLCScript(args);
   }
+  /**
+   * Reconstruct a swap's VHTLC by matching the persisted `lockupAddress`
+   * against the current and deprecated server signers, returning the matched
+   * script together with the server key it was minted under.
+   *
+   * Recovery paths (claim/refund/lookup) must use this instead of building the
+   * VHTLC from the current signer alone: a swap created before a planned arkd
+   * signer rotation is locked to a now-deprecated signer, so the current key
+   * would yield the wrong address and strand the funds. The returned
+   * `serverXOnlyPublicKey` is the original (possibly deprecated) key and MUST
+   * be threaded into downstream signing/verification.
+   *
+   * Throws a descriptive mismatch error when no candidate reproduces the
+   * lockup address (e.g. the swap predates an already-pruned deprecated
+   * signer) — replacing the previous current-signer-only equality check.
+   */
+  resolveVHTLCForLockup(args) {
+    const candidates = candidateServerPubkeys(args.arkInfo);
+    for (const serverPubkey of candidates) {
+      const { vhtlcScript, vhtlcAddress } = this.createVHTLCScript({
+        network: args.arkInfo.network,
+        preimageHash: args.preimageHash,
+        receiverPubkey: args.receiverPubkey,
+        senderPubkey: args.senderPubkey,
+        serverPubkey,
+        timeoutBlockHeights: args.timeoutBlockHeights
+      });
+      if (vhtlcAddress !== args.lockupAddress) continue;
+      if (!vhtlcScript.claimScript && !vhtlcScript.refundScript) {
+        throw new Error(
+          `Swap ${args.swapId}: VHTLC address matched but claim/refund script leaves are empty`
+        );
+      }
+      return {
+        vhtlcScript,
+        // The matched (possibly deprecated) key must flow into downstream
+        // signing/verification: arkd signs a deprecated-signer input with
+        // the deprecated key, so the claim/refund leaf checks use it.
+        serverXOnlyPublicKey: normalizeToXOnlyKey(
+          hex8.decode(serverPubkey),
+          "server",
+          args.swapId
+        )
+      };
+    }
+    throw new Error(
+      `Swap ${args.swapId}: VHTLC address mismatch. Expected ${args.lockupAddress}; no current or deprecated server signer (${candidates.length} candidate(s) tried) reproduced it`
+    );
+  }
   async getFees(from, to) {
     if (from && to) {
       return this.swapProvider.getChainFees(from, to);
@@ -5163,13 +5296,28 @@ var ArkadeSwaps = class _ArkadeSwaps {
     for (const swap of await this.getPendingSubmarineSwapsFromStorage()) {
       if (isSubmarineFinalStatus(swap.status)) continue;
       promises.push(
-        this.getSwapStatus(swap.id).then(
-          ({ status }) => updateSubmarineSwapStatus(
+        this.getSwapStatus(swap.id).then(async ({ status }) => {
+          let additionalFields;
+          if (isSubmarineSuccessStatus(status) && !swap.preimage) {
+            try {
+              const { preimage } = await this.swapProvider.getSwapPreimage(
+                swap.id
+              );
+              additionalFields = { preimage };
+            } catch (error) {
+              logger.warn(
+                `Failed to fetch preimage for settled swap ${swap.id}:`,
+                error
+              );
+            }
+          }
+          await updateSubmarineSwapStatus(
             swap,
             status,
-            this.savePendingSubmarineSwap.bind(this)
-          )
-        ).catch((error) => {
+            this.savePendingSubmarineSwap.bind(this),
+            additionalFields
+          );
+        }).catch((error) => {
           logger.error(`Failed to refresh swap status for ${swap.id}:`, error);
         })
       );
@@ -5339,6 +5487,7 @@ export {
   isSubmarineFinalStatus,
   isSubmarinePendingStatus,
   isSubmarineRefundableStatus,
+  hasSubmarineStatusReached,
   isSubmarineSuccessStatus,
   isReverseFailedStatus,
   isReverseFinalStatus,