@arkade-os/boltz-swap 0.3.39 → 0.3.41

package/dist/index.cjs

@@ -56,6 +56,7 @@ __export(index_exports, {
   enrichSubmarineSwapInvoice: () => enrichSubmarineSwapInvoice,
   getInvoicePaymentHash: () => getInvoicePaymentHash,
   getInvoiceSatoshis: () => getInvoiceSatoshis,
+  hasSubmarineStatusReached: () => hasSubmarineStatusReached,
   isChainClaimableStatus: () => isChainClaimableStatus,
   isChainFailedStatus: () => isChainFailedStatus,
   isChainFinalStatus: () => isChainFinalStatus,
@@ -324,6 +325,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";
 };
@@ -1408,10 +1425,10 @@ var import_light_bolt11_decoder = __toESM(require("light-bolt11-decoder"), 1);
 var import_sdk2 = require("@arkade-os/sdk");
 var decodeInvoice = (invoice) => {
   const decoded = import_light_bolt11_decoder.default.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 ?? ""
   };
@@ -3047,6 +3064,19 @@ var createVHTLCScript = (args) => {
   const vhtlcAddress = vhtlcScript.address(hrp, serverXOnlyPublicKey).encode();
   return { vhtlcScript, vhtlcAddress };
 };
+var candidateServerPubkeys = (arkInfo) => {
+  const current = import_base8.hex.encode(normalizeToXOnlyKey(import_base8.hex.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 = import_base8.hex.encode(normalizeToXOnlyKey(import_base8.hex.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,
@@ -3461,6 +3491,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",
@@ -3504,27 +3538,15 @@ var ArkadeSwaps = class _ArkadeSwaps {
       "boltz",
       pendingSwap.id
     );
-    const serverXOnly = normalizeToXOnlyKey(
-      import_base9.hex.decode(arkInfo.signerPubkey),
-      "server",
-      pendingSwap.id
-    );
-    const { vhtlcScript, vhtlcAddress } = this.createVHTLCScript({
-      network: arkInfo.network,
+    const { vhtlcScript, serverXOnlyPublicKey: serverXOnly } = this.resolveVHTLCForLockup({
+      arkInfo,
       preimageHash: (0, import_sha23.sha256)(preimage),
       receiverPubkey: import_base9.hex.encode(receiverXOnly),
       senderPubkey: import_base9.hex.encode(senderXOnly),
-      serverPubkey: import_base9.hex.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++) {
@@ -3675,16 +3697,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)
@@ -3695,6 +3707,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,
@@ -3766,11 +3790,6 @@ var ArkadeSwaps = class _ArkadeSwaps {
       "our",
       swap.id
     );
-    const serverXOnlyPublicKey = normalizeToXOnlyKey(
-      import_base9.hex.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`);
@@ -3779,20 +3798,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: import_base9.hex.decode(preimageHash),
       receiverPubkey: import_base9.hex.encode(boltzXOnlyPublicKey),
       senderPubkey: import_base9.hex.encode(ourXOnlyPublicKey),
-      serverPubkey: import_base9.hex.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 = import_base9.hex.encode(vhtlcScript.pkScript);
     return {
       arkInfo: resolvedArkInfo,
@@ -4202,6 +4220,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.
@@ -4209,19 +4230,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({
@@ -4231,7 +4292,8 @@ var ArkadeSwaps = class _ArkadeSwaps {
             );
             break;
           case "invoice.failedToPay":
-            isResolved = true;
+            isFinal = true;
+            isSettled = true;
             await saveStatus({ refundable: true });
             reject(
               new InvoiceFailedToPayError({
@@ -4241,7 +4303,8 @@ var ArkadeSwaps = class _ArkadeSwaps {
             );
             break;
           case "transaction.lockupFailed":
-            isResolved = true;
+            isFinal = true;
+            isSettled = true;
             await saveStatus({ refundable: true });
             reject(
               new TransactionLockupFailedError({
@@ -4251,23 +4314,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}`
+          );
         }
       });
     });
@@ -4505,29 +4592,26 @@ var ArkadeSwaps = class _ArkadeSwaps {
       "user",
       pendingSwap.id
     );
-    const serverXOnlyPublicKey = normalizeToXOnlyKey(
-      import_base9.hex.decode(arkInfo.signerPubkey),
-      "server",
-      pendingSwap.id
-    );
     const boltzXOnlyPublicKey = normalizeToXOnlyKey(
       import_base9.hex.decode(pendingSwap.response.lockupDetails.serverPublicKey),
       "boltz",
       pendingSwap.id
     );
-    const { vhtlcAddress, vhtlcScript } = this.createVHTLCScript({
-      network: arkInfo.network,
-      preimageHash: import_base9.hex.decode(pendingSwap.request.preimageHash),
-      serverPubkey: import_base9.hex.encode(serverXOnlyPublicKey),
-      senderPubkey: import_base9.hex.encode(ourXOnlyPublicKey),
-      receiverPubkey: import_base9.hex.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: import_base9.hex.decode(pendingSwap.request.preimageHash),
+        senderPubkey: import_base9.hex.encode(ourXOnlyPublicKey),
+        receiverPubkey: import_base9.hex.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({
@@ -4786,20 +4870,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: import_base9.hex.decode(pendingSwap.request.preimageHash),
-      serverPubkey: import_base9.hex.encode(serverXOnlyPublicKey),
-      senderPubkey: import_base9.hex.encode(senderXOnlyPublicKey),
-      receiverPubkey: import_base9.hex.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: import_base9.hex.decode(pendingSwap.request.preimageHash),
+        senderPubkey: import_base9.hex.encode(senderXOnlyPublicKey),
+        receiverPubkey: import_base9.hex.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;
@@ -5161,6 +5246,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(
+          import_base9.hex.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);
@@ -5244,13 +5378,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);
         })
       );
@@ -5429,6 +5578,7 @@ var LONG_RUNNING_ARKADE_SWAPS_REQUEST_TYPES = /* @__PURE__ */ new Set([
   "RECOVER_ALL_SUBMARINE_FUNDS",
   "WAIT_AND_CLAIM",
   "WAIT_FOR_SWAP_SETTLEMENT",
+  "WAIT_FOR_SWAP_FUNDED",
   "RESTORE_SWAPS",
   "WAIT_AND_CLAIM_CHAIN",
   "WAIT_AND_CLAIM_ARK",
@@ -5616,6 +5766,10 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
             payload: res
           });
         }
+        case "WAIT_FOR_SWAP_FUNDED": {
+          await this.handler.waitForSwapFunded(message.payload);
+          return this.tagged({ id, type: "SWAP_FUNDED" });
+        }
         case "RESTORE_SWAPS": {
           const res = await this.handler.restoreSwaps(message.payload);
           return this.tagged({
@@ -6317,6 +6471,18 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       throw new Error("Cannot wait for swap settlement", { cause: e });
     }
   }
+  async waitForSwapFunded(pendingSwap) {
+    try {
+      await this.sendMessage({
+        id: (0, import_sdk10.getRandomId)(),
+        tag: this.messageTag,
+        type: "WAIT_FOR_SWAP_FUNDED",
+        payload: pendingSwap
+      });
+    } catch (e) {
+      throw new Error("Cannot wait for swap funding", { cause: e });
+    }
+  }
   async restoreSwaps(boltzFees) {
     try {
       const res = await this.sendMessage({
@@ -6905,6 +7071,7 @@ var InMemorySwapRepository = class {
   enrichSubmarineSwapInvoice,
   getInvoicePaymentHash,
   getInvoiceSatoshis,
+  hasSubmarineStatusReached,
   isChainClaimableStatus,
   isChainFailedStatus,
   isChainFinalStatus,

package/dist/index.d.cts

@@ -1,7 +1,7 @@
-import { Q as QuoteSwapOptions, I as IArkadeSwaps, V as VhtlcTimeouts } from './arkade-swaps-DG9UepoS.cjs';
-export { A as ArkadeSwaps } from './arkade-swaps-DG9UepoS.cjs';
-import { B as BoltzSwap, D as DecodedInvoice, a as BoltzChainSwap, b as BoltzReverseSwap, c as BoltzSubmarineSwap, A as ArkadeSwapsConfig, N as Network, C as CreateLightningInvoiceRequest, S as SendLightningPaymentRequest, F as FeesResponse, d as Chain, e as CreateLightningInvoiceResponse, f as SendLightningPaymentResponse, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, k as ArkToBtcResponse, l as BtcToArkResponse, m as ChainArkRefundOutcome, n as SwapRepository, o as SwapManagerClient, p as GetSwapsFilter } from './types-D97i1LFu.cjs';
-export { q as ArkadeSwapsCreateConfig, r as BoltzSwapProvider, s as BoltzSwapStatus, I as IncomingPaymentSubscription, P as PendingChainSwap, t as PendingReverseSwap, u as PendingSubmarineSwap, v as PendingSwap, w as SubmarineRecoveryStatus, x as SwapManager, y as SwapManagerCallbacks, z as SwapManagerConfig, E as SwapManagerEvents, V as Vtxo, H as isChainClaimableStatus, J as isChainFailedStatus, K as isChainFinalStatus, M as isChainPendingStatus, O as isChainRefundableStatus, Q as isChainSignableStatus, R as isChainSuccessStatus, T as isChainSwapClaimable, U as isChainSwapRefundable, W as isPendingChainSwap, X as isPendingReverseSwap, Y as isPendingSubmarineSwap, Z as isReverseClaimableStatus, _ as isReverseFailedStatus, $ as isReverseFinalStatus, a0 as isReversePendingStatus, a1 as isReverseSuccessStatus, a2 as isReverseSwapClaimable, a3 as isSubmarineFailedStatus, a4 as isSubmarineFinalStatus, a5 as isSubmarinePendingStatus, a6 as isSubmarineRefundableStatus, a7 as isSubmarineSuccessStatus, a8 as isSubmarineSwapRefundable } from './types-D97i1LFu.cjs';
+import { Q as QuoteSwapOptions, I as IArkadeSwaps, V as VhtlcTimeouts } from './arkade-swaps-C3sUFr5f.cjs';
+export { A as ArkadeSwaps } from './arkade-swaps-C3sUFr5f.cjs';
+import { B as BoltzSwap, D as DecodedInvoice, a as BoltzChainSwap, b as BoltzReverseSwap, c as BoltzSubmarineSwap, A as ArkadeSwapsConfig, N as Network, C as CreateLightningInvoiceRequest, S as SendLightningPaymentRequest, F as FeesResponse, d as Chain, e as CreateLightningInvoiceResponse, O as OptimisticSendLightningPaymentResponse, f as SubmarineRefundOutcome, g as SubmarineRecoveryInfo, h as SubmarineRecoveryResult, i as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, j as ArkToBtcResponse, k as BtcToArkResponse, l as ChainArkRefundOutcome, m as SwapRepository, n as SwapManagerClient, o as SendLightningPaymentResponse, p as GetSwapsFilter } from './types-8NrCdOpS.cjs';
+export { q as ArkadeSwapsCreateConfig, r as BoltzSwapProvider, s as BoltzSwapStatus, I as IncomingPaymentSubscription, P as PendingChainSwap, t as PendingReverseSwap, u as PendingSubmarineSwap, v as PendingSwap, w as SubmarineProgressionStatus, x as SubmarineRecoveryStatus, y as SwapManager, z as SwapManagerCallbacks, E as SwapManagerConfig, H as SwapManagerEvents, V as Vtxo, J as hasSubmarineStatusReached, K as isChainClaimableStatus, M as isChainFailedStatus, Q as isChainFinalStatus, R as isChainPendingStatus, T as isChainRefundableStatus, U as isChainSignableStatus, W as isChainSuccessStatus, X as isChainSwapClaimable, Y as isChainSwapRefundable, Z as isPendingChainSwap, _ as isPendingReverseSwap, $ as isPendingSubmarineSwap, a0 as isReverseClaimableStatus, a1 as isReverseFailedStatus, a2 as isReverseFinalStatus, a3 as isReversePendingStatus, a4 as isReverseSuccessStatus, a5 as isReverseSwapClaimable, a6 as isSubmarineFailedStatus, a7 as isSubmarineFinalStatus, a8 as isSubmarinePendingStatus, a9 as isSubmarineRefundableStatus, aa as isSubmarineSuccessStatus, ab as isSubmarineSwapRefundable } from './types-8NrCdOpS.cjs';
 import { Transaction } from '@scure/btc-signer';
 import { MessageHandler, RequestEnvelope, ArkInfo, ResponseEnvelope, IWallet, IReadonlyWallet, VHTLC, Identity, ArkTxInput } from '@arkade-os/sdk';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
@@ -225,7 +225,8 @@ type RequestSendLightningPayment = RequestEnvelope & {
 };
 type ResponseSendLightningPayment = ResponseEnvelope & {
     type: "LIGHTNING_PAYMENT_SENT";
-    payload: SendLightningPaymentResponse;
+    /** Strict SendLightningPaymentResponse unless the request used waitFor: "funded". */
+    payload: OptimisticSendLightningPaymentResponse;
 };
 type RequestCreateSubmarineSwap = RequestEnvelope & {
     type: "CREATE_SUBMARINE_SWAP";
@@ -309,6 +310,13 @@ type ResponseWaitForSwapSettlement = ResponseEnvelope & {
         preimage: string;
     };
 };
+type RequestWaitForSwapFunded = RequestEnvelope & {
+    type: "WAIT_FOR_SWAP_FUNDED";
+    payload: BoltzSubmarineSwap;
+};
+type ResponseWaitForSwapFunded = ResponseEnvelope & {
+    type: "SWAP_FUNDED";
+};
 type RequestRestoreSwaps = RequestEnvelope & {
     type: "RESTORE_SWAPS";
     payload?: FeesResponse;
@@ -653,8 +661,8 @@ type ResponseSwapManagerWaitForCompletion = ResponseEnvelope & {
         txid: string;
     };
 };
-type ArkadeSwapsUpdaterRequest = RequestInitArkSwaps | RequestCreateLightningInvoice | RequestSendLightningPayment | RequestCreateSubmarineSwap | RequestCreateReverseSwap | RequestClaimVhtlc | RequestRefundVhtlc | RequestInspectSubmarineRecovery | RequestScanRecoverableSubmarineSwaps | RequestRecoverSubmarineFunds | RequestRecoverAllSubmarineFunds | RequestWaitAndClaim | RequestWaitForSwapSettlement | RequestRestoreSwaps | RequestEnrichReverseSwapPreimage | RequestEnrichSubmarineSwapInvoice | RequestGetFees | RequestGetLimits | RequestGetSwapStatus | RequestGetPendingSubmarineSwaps | RequestGetPendingReverseSwaps | RequestGetPendingChainSwaps | RequestGetSwapHistory | RequestRefreshSwapsStatus | RequestArkToBtc | RequestBtcToArk | RequestCreateChainSwap | RequestWaitAndClaimChain | RequestWaitAndClaimArk | RequestWaitAndClaimBtc | RequestClaimArk | RequestClaimBtc | RequestRefundArk | RequestSignServerClaim | RequestVerifyChainSwap | RequestQuoteSwap | RequestGetSwapQuote | RequestAcceptSwapQuote | RequestSwapManagerStart | RequestSwapManagerStop | RequestSwapManagerAddSwap | RequestSwapManagerRemoveSwap | RequestSwapManagerGetPending | RequestSwapManagerHasSwap | RequestSwapManagerIsProcessing | RequestSwapManagerGetStats | RequestSwapManagerWaitForCompletion;
-type ArkadeSwapsUpdaterResponse = ResponseInitArkSwaps | ResponseCreateLightningInvoice | ResponseSendLightningPayment | ResponseCreateSubmarineSwap | ResponseCreateReverseSwap | ResponseClaimVhtlc | ResponseRefundVhtlc | ResponseInspectSubmarineRecovery | ResponseScanRecoverableSubmarineSwaps | ResponseRecoverSubmarineFunds | ResponseRecoverAllSubmarineFunds | ResponseWaitAndClaim | ResponseWaitForSwapSettlement | ResponseRestoreSwaps | ResponseEnrichReverseSwapPreimage | ResponseEnrichSubmarineSwapInvoice | ResponseGetFees | ResponseGetLimits | ResponseGetSwapStatus | ResponseGetPendingSubmarineSwaps | ResponseGetPendingReverseSwaps | ResponseGetPendingChainSwaps | ResponseGetSwapHistory | ResponseRefreshSwapsStatus | ResponseArkToBtc | ResponseBtcToArk | ResponseCreateChainSwap | ResponseWaitAndClaimChain | ResponseWaitAndClaimArk | ResponseWaitAndClaimBtc | ResponseClaimArk | ResponseClaimBtc | ResponseRefundArk | ResponseSignServerClaim | ResponseVerifyChainSwap | ResponseQuoteSwap | ResponseGetSwapQuote | ResponseAcceptSwapQuote | ResponseSwapManagerStart | ResponseSwapManagerStop | ResponseSwapManagerAddSwap | ResponseSwapManagerRemoveSwap | ResponseSwapManagerGetPending | ResponseSwapManagerHasSwap | ResponseSwapManagerIsProcessing | ResponseSwapManagerGetStats | ResponseSwapManagerWaitForCompletion;
+type ArkadeSwapsUpdaterRequest = RequestInitArkSwaps | RequestCreateLightningInvoice | RequestSendLightningPayment | RequestCreateSubmarineSwap | RequestCreateReverseSwap | RequestClaimVhtlc | RequestRefundVhtlc | RequestInspectSubmarineRecovery | RequestScanRecoverableSubmarineSwaps | RequestRecoverSubmarineFunds | RequestRecoverAllSubmarineFunds | RequestWaitAndClaim | RequestWaitForSwapSettlement | RequestWaitForSwapFunded | RequestRestoreSwaps | RequestEnrichReverseSwapPreimage | RequestEnrichSubmarineSwapInvoice | RequestGetFees | RequestGetLimits | RequestGetSwapStatus | RequestGetPendingSubmarineSwaps | RequestGetPendingReverseSwaps | RequestGetPendingChainSwaps | RequestGetSwapHistory | RequestRefreshSwapsStatus | RequestArkToBtc | RequestBtcToArk | RequestCreateChainSwap | RequestWaitAndClaimChain | RequestWaitAndClaimArk | RequestWaitAndClaimBtc | RequestClaimArk | RequestClaimBtc | RequestRefundArk | RequestSignServerClaim | RequestVerifyChainSwap | RequestQuoteSwap | RequestGetSwapQuote | RequestAcceptSwapQuote | RequestSwapManagerStart | RequestSwapManagerStop | RequestSwapManagerAddSwap | RequestSwapManagerRemoveSwap | RequestSwapManagerGetPending | RequestSwapManagerHasSwap | RequestSwapManagerIsProcessing | RequestSwapManagerGetStats | RequestSwapManagerWaitForCompletion;
+type ArkadeSwapsUpdaterResponse = ResponseInitArkSwaps | ResponseCreateLightningInvoice | ResponseSendLightningPayment | ResponseCreateSubmarineSwap | ResponseCreateReverseSwap | ResponseClaimVhtlc | ResponseRefundVhtlc | ResponseInspectSubmarineRecovery | ResponseScanRecoverableSubmarineSwaps | ResponseRecoverSubmarineFunds | ResponseRecoverAllSubmarineFunds | ResponseWaitAndClaim | ResponseWaitForSwapSettlement | ResponseWaitForSwapFunded | ResponseRestoreSwaps | ResponseEnrichReverseSwapPreimage | ResponseEnrichSubmarineSwapInvoice | ResponseGetFees | ResponseGetLimits | ResponseGetSwapStatus | ResponseGetPendingSubmarineSwaps | ResponseGetPendingReverseSwaps | ResponseGetPendingChainSwaps | ResponseGetSwapHistory | ResponseRefreshSwapsStatus | ResponseArkToBtc | ResponseBtcToArk | ResponseCreateChainSwap | ResponseWaitAndClaimChain | ResponseWaitAndClaimArk | ResponseWaitAndClaimBtc | ResponseClaimArk | ResponseClaimBtc | ResponseRefundArk | ResponseSignServerClaim | ResponseVerifyChainSwap | ResponseQuoteSwap | ResponseGetSwapQuote | ResponseAcceptSwapQuote | ResponseSwapManagerStart | ResponseSwapManagerStop | ResponseSwapManagerAddSwap | ResponseSwapManagerRemoveSwap | ResponseSwapManagerGetPending | ResponseSwapManagerHasSwap | ResponseSwapManagerIsProcessing | ResponseSwapManagerGetStats | ResponseSwapManagerWaitForCompletion;
 declare class ArkadeSwapsMessageHandler implements MessageHandler<ArkadeSwapsUpdaterRequest, ArkadeSwapsUpdaterResponse> {
     private readonly swapRepository;
     static messageTag: string;
@@ -709,7 +717,10 @@ declare class ServiceWorkerArkadeSwaps implements IArkadeSwaps {
     stopSwapManager(): Promise<void>;
     getSwapManager(): SwapManagerClient | null;
     createLightningInvoice(args: CreateLightningInvoiceRequest): Promise<CreateLightningInvoiceResponse>;
-    sendLightningPayment(args: SendLightningPaymentRequest): Promise<SendLightningPaymentResponse>;
+    sendLightningPayment(args: SendLightningPaymentRequest & {
+        waitFor?: "settled";
+    }): Promise<SendLightningPaymentResponse>;
+    sendLightningPayment(args: SendLightningPaymentRequest): Promise<OptimisticSendLightningPaymentResponse>;
     createSubmarineSwap(args: SendLightningPaymentRequest): Promise<BoltzSubmarineSwap>;
     createReverseSwap(args: CreateLightningInvoiceRequest): Promise<BoltzReverseSwap>;
     claimVHTLC(pendingSwap: BoltzReverseSwap): Promise<void>;
@@ -724,6 +735,7 @@ declare class ServiceWorkerArkadeSwaps implements IArkadeSwaps {
     waitForSwapSettlement(pendingSwap: BoltzSubmarineSwap): Promise<{
         preimage: string;
     }>;
+    waitForSwapFunded(pendingSwap: BoltzSubmarineSwap): Promise<void>;
     restoreSwaps(boltzFees?: FeesResponse): Promise<{
         chainSwaps: BoltzChainSwap[];
         reverseSwaps: BoltzReverseSwap[];
@@ -879,4 +891,4 @@ declare class InMemorySwapRepository implements SwapRepository {
     [Symbol.asyncDispose](): Promise<void>;
 }
 
-export { ArkToBtcResponse, ArkadeSwapsMessageHandler as ArkadeLightningMessageHandler, ArkadeSwapsConfig, ArkadeSwapsMessageHandler, BoltzChainSwap, BoltzRefundError, BoltzReverseSwap, BoltzSubmarineSwap, BoltzSwap, BtcToArkResponse, Chain, ChainFeesResponse, CreateLightningInvoiceRequest, CreateLightningInvoiceResponse, DecodedInvoice, FeesResponse, InMemorySwapRepository, IndexedDbSwapRepository, InsufficientFundsError, InvoiceExpiredError, InvoiceFailedToPayError, LimitsResponse, type Logger, Network, NetworkError, PreimageFetchError, QuoteRejectedError, type QuoteRejectionReason, QuoteSwapOptions, SchemaError, SendLightningPaymentRequest, SendLightningPaymentResponse, ServiceWorkerArkadeSwaps as ServiceWorkerArkadeLightning, ServiceWorkerArkadeSwaps, SubmarineRecoveryInfo, SubmarineRecoveryResult, SubmarineRefundOutcome, SwapError, SwapExpiredError, SwapManagerClient, SwapNotFoundError, SwapRepository, type SwapSaver, TransactionFailedError, decodeInvoice, enrichReverseSwapPreimage, enrichSubmarineSwapInvoice, getInvoicePaymentHash, getInvoiceSatoshis, isValidArkAddress, logger, migrateToSwapRepository, saveSwap, setLogger, updateChainSwapStatus, updateReverseSwapStatus, updateSubmarineSwapStatus, verifySignatures };
+export { ArkToBtcResponse, ArkadeSwapsMessageHandler as ArkadeLightningMessageHandler, ArkadeSwapsConfig, ArkadeSwapsMessageHandler, BoltzChainSwap, BoltzRefundError, BoltzReverseSwap, BoltzSubmarineSwap, BoltzSwap, BtcToArkResponse, Chain, ChainFeesResponse, CreateLightningInvoiceRequest, CreateLightningInvoiceResponse, DecodedInvoice, FeesResponse, InMemorySwapRepository, IndexedDbSwapRepository, InsufficientFundsError, InvoiceExpiredError, InvoiceFailedToPayError, LimitsResponse, type Logger, Network, NetworkError, OptimisticSendLightningPaymentResponse, PreimageFetchError, QuoteRejectedError, type QuoteRejectionReason, QuoteSwapOptions, SchemaError, SendLightningPaymentRequest, SendLightningPaymentResponse, ServiceWorkerArkadeSwaps as ServiceWorkerArkadeLightning, ServiceWorkerArkadeSwaps, SubmarineRecoveryInfo, SubmarineRecoveryResult, SubmarineRefundOutcome, SwapError, SwapExpiredError, SwapManagerClient, SwapNotFoundError, SwapRepository, type SwapSaver, TransactionFailedError, decodeInvoice, enrichReverseSwapPreimage, enrichSubmarineSwapInvoice, getInvoicePaymentHash, getInvoiceSatoshis, isValidArkAddress, logger, migrateToSwapRepository, saveSwap, setLogger, updateChainSwapStatus, updateReverseSwapStatus, updateSubmarineSwapStatus, verifySignatures };