@arkade-os/boltz-swap 0.3.34 → 0.3.36

package/dist/expo/background.cjs

@@ -1373,6 +1373,20 @@ function extractInvoiceAmount(amountSats, fees) {
   if (miner >= amountSats) return 0;
   return Math.ceil((amountSats - miner) / (1 - percentage / 100));
 }
+function resolveVhtlcTimeouts(tree, timeoutBlockHeights) {
+  const resolved = timeoutBlockHeights ?? {
+    refund: extractTimeLockFromLeafOutput(tree.refundWithoutBoltzLeaf?.output ?? ""),
+    unilateralClaim: extractTimeLockFromLeafOutput(tree.unilateralClaimLeaf?.output ?? ""),
+    unilateralRefund: extractTimeLockFromLeafOutput(tree.unilateralRefundLeaf?.output ?? ""),
+    unilateralRefundWithoutReceiver: extractTimeLockFromLeafOutput(
+      tree.unilateralRefundWithoutBoltzLeaf?.output ?? ""
+    )
+  };
+  if (!resolved.refund || !resolved.unilateralClaim || !resolved.unilateralRefund || !resolved.unilateralRefundWithoutReceiver) {
+    return void 0;
+  }
+  return resolved;
+}
 
 // src/logger.ts
 var logger = console;
@@ -1434,6 +1448,13 @@ var SwapManager = class _SwapManager {
   swapsInProgress = /* @__PURE__ */ new Set();
   // Per-swap subscriptions for UI hooks
   swapSubscriptions = /* @__PURE__ */ new Map();
+  // In-flight (or settled) chain-swap claim promises, keyed by swap id. The
+  // manager performs chain claims itself, so the claim tx it broadcasts is
+  // the swap's on-chain completion; getSwapStatus does not surface that txid
+  // at transaction.claimed. resolveClaimedTxid awaits the stored promise so a
+  // transaction.claimed update that races an in-flight claim still resolves
+  // the real txid instead of falling back to the provider and failing.
+  chainClaimPromises = /* @__PURE__ */ new Map();
   // Action callbacks (injected via setCallbacks)
   claimCallback = null;
   refundCallback = null;
@@ -1575,6 +1596,7 @@ var SwapManager = class _SwapManager {
     }
     this.isRunning = true;
     this.initialSwaps.clear();
+    this.chainClaimPromises.clear();
     for (const swap of pendingSwaps) {
       this.initialSwaps.set(swap.id, swap);
     }
@@ -1668,6 +1690,7 @@ var SwapManager = class _SwapManager {
   async removeSwap(swapId) {
     this.monitoredSwaps.delete(swapId);
     this.swapSubscriptions.delete(swapId);
+    this.chainClaimPromises.delete(swapId);
     const retryTimer = this.pollRetryTimers.get(swapId);
     if (retryTimer) {
       clearTimeout(retryTimer);
@@ -1710,9 +1733,14 @@ var SwapManager = class _SwapManager {
    * Blocks until the swap reaches a final status or fails.
    * Useful when you want blocking behavior even with SwapManager enabled.
    *
-   * @throws If the swap is already in a final status (submarine/chain swaps throw immediately;
-   *         reverse swaps return the existing txid).
+   * If the swap is already in a final status, resolves immediately with the
+   * on-chain txid of the successfully claimed swap (reverse: from
+   * getReverseSwapTxId; submarine/chain: from getSwapStatus) and throws for a
+   * failed final status.
+   *
+   * @throws If the swap is already in a failed final status.
    * @throws If the swap is not found in the manager.
+   * @throws If a completed swap has no transaction id available yet.
    */
   async waitForSwapCompletion(swapId) {
     let swap = this.monitoredSwaps.get(swapId);
@@ -1727,10 +1755,12 @@ var SwapManager = class _SwapManager {
         const response = await this.swapProvider.getReverseSwapTxId(swap.id);
         return { txid: response.id };
       }
-      if (isPendingSubmarineSwap(swap)) {
-        throw new Error("Submarine swap already completed");
+      if (isPendingSubmarineSwap(swap) || isPendingChainSwap(swap)) {
+        if (swap.status === "transaction.claimed") {
+          return this.resolveClaimedTxid(swap.id);
+        }
+        throw new Error(`Swap ${swap.id} already in final status: ${swap.status}`);
       }
-      throw new Error("Chain swap already completed");
     }
     return new Promise((resolve, reject) => {
       let unsubscribe = null;
@@ -1745,13 +1775,13 @@ var SwapManager = class _SwapManager {
           }
         } else if (isPendingSubmarineSwap(updatedSwap)) {
           if (updatedSwap.status === "transaction.claimed") {
-            resolve({ txid: updatedSwap.id });
+            this.resolveClaimedTxid(updatedSwap.id).then(resolve).catch(reject);
           } else {
             reject(new Error(`Swap failed with status: ${updatedSwap.status}`));
           }
         } else if (isPendingChainSwap(updatedSwap)) {
           if (updatedSwap.status === "transaction.claimed") {
-            resolve({ txid: updatedSwap.id });
+            this.resolveClaimedTxid(updatedSwap.id).then(resolve).catch(reject);
           } else {
             reject(new Error(`Swap failed with status: ${updatedSwap.status}`));
           }
@@ -1762,6 +1792,37 @@ var SwapManager = class _SwapManager {
       }).catch(reject);
     });
   }
+  /**
+   * Resolve the on-chain txid for a claimed submarine/chain swap.
+   *
+   * Chain swaps are claimed by the manager itself, so the claim txid captured
+   * from the claimArk/claimBtc callback is the swap's on-chain completion and
+   * is preferred — Boltz does not surface it via getSwapStatus at
+   * transaction.claimed. Submarine swaps (claimed by Boltz) and chain swaps
+   * we never claimed in this session (e.g. restored already-claimed) fall
+   * back to the provider status. Rejects when no transaction id is available,
+   * so callers never receive the Boltz swap id in place of a real txid.
+   */
+  async resolveClaimedTxid(swapId) {
+    const claimPromise = this.chainClaimPromises.get(swapId);
+    if (claimPromise) {
+      const claimTxid = await claimPromise.then(
+        (result) => result?.txid,
+        () => void 0
+      );
+      if (claimTxid && claimTxid.trim() !== "") {
+        return { txid: claimTxid };
+      }
+    }
+    const status = await this.swapProvider.getSwapStatus(swapId);
+    const txid = status.transaction?.id;
+    if (!txid || txid.trim() === "") {
+      throw new SwapError({
+        message: `Transaction ID not available for completed swap ${swapId}`
+      });
+    }
+    return { txid };
+  }
   /**
    * Check if a swap is currently being processed
    * Useful for preventing race conditions
@@ -1965,6 +2026,7 @@ var SwapManager = class _SwapManager {
     if (!this.monitoredSwaps.has(swap.id)) return;
     this.monitoredSwaps.delete(swap.id);
     this.swapSubscriptions.delete(swap.id);
+    this.chainClaimPromises.delete(swap.id);
     const retryTimer = this.pollRetryTimers.get(swap.id);
     if (retryTimer) {
       clearTimeout(retryTimer);
@@ -2135,7 +2197,9 @@ var SwapManager = class _SwapManager {
       logger.error("claimArk callback not set");
       return;
     }
-    await this.claimArkCallback(swap);
+    const claimPromise = this.claimArkCallback(swap);
+    this.rememberChainClaim(swap.id, claimPromise);
+    await claimPromise;
   }
   /**
    * Execute claim action for chain swap Ark to Btc
@@ -2145,7 +2209,23 @@ var SwapManager = class _SwapManager {
       logger.error("claimBtc callback not set");
       return;
     }
-    await this.claimBtcCallback(swap);
+    const claimPromise = this.claimBtcCallback(swap);
+    this.rememberChainClaim(swap.id, claimPromise);
+    await claimPromise;
+  }
+  /**
+   * Store the in-flight claim promise returned by a claim callback so
+   * {@link resolveClaimedTxid} can await it and surface the real on-chain
+   * txid at transaction.claimed — even when that update races the still
+   * in-flight claim. Storing the promise (not the resolved txid) closes the
+   * window where the txid is not yet captured when transaction.claimed
+   * arrives. Defensive against callbacks that don't return a promise (older
+   * integrations, test doubles): those simply fall back to getSwapStatus.
+   */
+  rememberChainClaim(swapId, claimPromise) {
+    if (claimPromise) {
+      this.chainClaimPromises.set(swapId, claimPromise);
+    }
   }
   /**
    * Execute refund action for chain swap Ark to Btc
@@ -2932,6 +3012,7 @@ var claimVHTLCwithOffchainTx = async (identity, vhtlcScript, serverXOnlyPublicKe
     })
   );
   await arkProvider.finalizeTx(arkTxid, finalCheckpoints);
+  return arkTxid;
 };
 var refundVHTLCwithOffchainTx = async (swapId, identity, arkProvider, boltzXOnlyPublicKey, ourXOnlyPublicKey, serverXOnlyPublicKey, input, output, arkInfo, refundFunc) => {
   const rawCheckpointTapscript = import_base8.hex.decode(arkInfo.checkpointTapscript);
@@ -3090,12 +3171,8 @@ var ArkadeSwaps = class _ArkadeSwaps {
         refund: async (swap) => {
           await this.refundVHTLC(swap);
         },
-        claimArk: async (swap) => {
-          await this.claimArk(swap);
-        },
-        claimBtc: async (swap) => {
-          await this.claimBtc(swap);
-        },
+        claimArk: (swap) => this.claimArk(swap),
+        claimBtc: (swap) => this.claimBtc(swap),
         refundArk: async (swap) => {
           return this.refundArk(swap);
         },
@@ -4106,6 +4183,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
     }
     return new Promise((resolve, reject) => {
       let claimStarted = false;
+      let claimPromise;
       const swap = { ...pendingSwap };
       const onStatusUpdate = async (status, data) => {
         const updateSwapStatus = async () => {
@@ -4123,16 +4201,24 @@ var ArkadeSwaps = class _ArkadeSwaps {
             const updatedSwap = await updateSwapStatus();
             if (claimStarted) return;
             claimStarted = true;
-            this.claimBtc(updatedSwap).catch(reject);
+            claimPromise = this.claimBtc(updatedSwap);
+            claimPromise.catch(reject);
             break;
           }
-          case "transaction.claimed":
+          case "transaction.claimed": {
             await updateSwapStatus();
-            const claimedStatus = await this.getSwapStatus(pendingSwap.id);
-            resolve({
-              txid: claimedStatus.transaction?.id ?? ""
-            });
+            const txid = await this.resolveChainClaimTxid(pendingSwap.id, claimPromise);
+            if (!txid) {
+              reject(
+                new SwapError({
+                  message: `Transaction ID not available for claimed swap ${pendingSwap.id}.`
+                })
+              );
+              break;
+            }
+            resolve({ txid });
             break;
+          }
           case "transaction.lockupFailed":
             await updateSwapStatus();
             await this.quoteSwap(swap.response.id, quoteOptionsForSwap(swap)).catch(
@@ -4181,6 +4267,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
   /**
    * Claim sats on BTC chain by claiming the HTLC.
    * @param pendingSwap - The pending chain swap with BTC transaction hex.
+   * @returns The BTC transaction ID of the claim.
    */
   async claimBtc(pendingSwap) {
     if (!pendingSwap.toAddress)
@@ -4253,6 +4340,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       finalScriptWitness: [musigSigned.aggregatePartials()]
     });
     await this.swapProvider.postBtcTransaction(claimTx.hex);
+    return { txid: claimTx.id };
   }
   /**
    * When an ARK to BTC swap fails, refund every unspent VTXO at the chain
@@ -4452,6 +4540,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
     }
     return new Promise((resolve, reject) => {
       let claimStarted = false;
+      let claimPromise;
       const swap = { ...pendingSwap };
       const onStatusUpdate = async (status, data) => {
         const updateSwapStatus = () => {
@@ -4464,15 +4553,23 @@ var ArkadeSwaps = class _ArkadeSwaps {
             await updateSwapStatus();
             if (claimStarted) return;
             claimStarted = true;
-            this.claimArk(swap).catch(reject);
+            claimPromise = this.claimArk(swap);
+            claimPromise.catch(reject);
             break;
-          case "transaction.claimed":
+          case "transaction.claimed": {
             await updateSwapStatus();
-            const claimedStatus = await this.getSwapStatus(pendingSwap.id);
-            resolve({
-              txid: claimedStatus.transaction?.id ?? ""
-            });
+            const txid = await this.resolveChainClaimTxid(pendingSwap.id, claimPromise);
+            if (!txid) {
+              reject(
+                new SwapError({
+                  message: `Transaction ID not available for claimed swap ${pendingSwap.id}.`
+                })
+              );
+              break;
+            }
+            resolve({ txid });
             break;
+          }
           case "transaction.claim.pending":
             await updateSwapStatus();
             await this.signCooperativeClaimForServer(swap).catch((err) => {
@@ -4531,6 +4628,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
    * Claim sats on ARK chain by claiming the VHTLC.
    * Refactored to use claimVHTLCIdentity + claimVHTLCwithOffchainTx utilities.
    * @param pendingSwap - The pending chain swap.
+   * @returns The Ark transaction ID of the claim.
    */
   async claimArk(pendingSwap) {
     if (!pendingSwap.toAddress)
@@ -4593,24 +4691,42 @@ var ArkadeSwaps = class _ArkadeSwaps {
       script: import_sdk8.ArkAddress.decode(address).pkScript
     };
     const vhtlcIdentity = claimVHTLCIdentity(this.wallet.identity, preimage);
-    if ((0, import_sdk8.isRecoverable)(vtxo)) {
-      await this.joinBatch(vhtlcIdentity, input, output, arkInfo);
-    } else {
-      await claimVHTLCwithOffchainTx(
-        vhtlcIdentity,
-        vhtlcScript,
-        serverXOnlyPublicKey,
-        input,
-        output,
-        arkInfo,
-        this.arkProvider
-      );
-    }
+    const txid = (0, import_sdk8.isRecoverable)(vtxo) ? await this.joinBatch(vhtlcIdentity, input, output, arkInfo) : await claimVHTLCwithOffchainTx(
+      vhtlcIdentity,
+      vhtlcScript,
+      serverXOnlyPublicKey,
+      input,
+      output,
+      arkInfo,
+      this.arkProvider
+    );
     const finalStatus = await this.getSwapStatus(pendingSwap.id);
     await this.savePendingChainSwap({
       ...pendingSwap,
       status: finalStatus.status
     });
+    return { txid };
+  }
+  /**
+   * Resolve the on-chain txid for a chain swap at completion.
+   *
+   * The claim transaction we broadcast (claimBtc/claimArk) carries the real
+   * on-chain txid; getSwapStatus does not surface it at transaction.claimed.
+   * Prefer the claim's txid and fall back to the provider status only for
+   * resumed swaps where we never ran the claim ourselves (claimPromise is
+   * undefined). Returns undefined when no usable txid is available, so
+   * callers never resolve with the Boltz swap id in place of a real txid.
+   */
+  async resolveChainClaimTxid(swapId, claimPromise) {
+    if (claimPromise) {
+      const claimTxid = await claimPromise.then(
+        (res) => res.txid,
+        () => void 0
+      );
+      if (claimTxid && claimTxid.trim() !== "") return claimTxid;
+    }
+    const txid = (await this.getSwapStatus(swapId)).transaction?.id;
+    return txid && txid.trim() !== "" ? txid : void 0;
   }
   /**
    * Sign a cooperative claim for the server in BTC => ARK swaps.
@@ -5054,20 +5170,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
             onchainAmount: amount,
             lockupAddress,
             refundPublicKey: serverPublicKey,
-            timeoutBlockHeights: timeoutBlockHeights ?? {
-              refund: extractTimeLockFromLeafOutput(
-                tree.refundWithoutBoltzLeaf?.output ?? ""
-              ),
-              unilateralClaim: extractTimeLockFromLeafOutput(
-                tree.unilateralClaimLeaf?.output ?? ""
-              ),
-              unilateralRefund: extractTimeLockFromLeafOutput(
-                tree.unilateralRefundLeaf?.output ?? ""
-              ),
-              unilateralRefundWithoutReceiver: extractTimeLockFromLeafOutput(
-                tree.unilateralRefundWithoutBoltzLeaf?.output ?? ""
-              )
-            }
+            timeoutBlockHeights: resolveVhtlcTimeouts(tree, timeoutBlockHeights)
           },
           status,
           type: "reverse",
@@ -5100,26 +5203,20 @@ var ArkadeSwaps = class _ArkadeSwaps {
             address: lockupAddress,
             expectedAmount: amount,
             claimPublicKey: serverPublicKey,
-            timeoutBlockHeights: timeoutBlockHeights ?? {
-              refund: extractTimeLockFromLeafOutput(
-                tree.refundWithoutBoltzLeaf?.output ?? ""
-              ),
-              unilateralClaim: extractTimeLockFromLeafOutput(
-                tree.unilateralClaimLeaf?.output ?? ""
-              ),
-              unilateralRefund: extractTimeLockFromLeafOutput(
-                tree.unilateralRefundLeaf?.output ?? ""
-              ),
-              unilateralRefundWithoutReceiver: extractTimeLockFromLeafOutput(
-                tree.unilateralRefundWithoutBoltzLeaf?.output ?? ""
-              )
-            }
+            timeoutBlockHeights: resolveVhtlcTimeouts(tree, timeoutBlockHeights)
           }
         });
       } else if (isRestoredChainSwap(swap)) {
         const refundDetails = swap.refundDetails;
         if (!refundDetails) continue;
-        const { amount, lockupAddress, serverPublicKey, timeoutBlockHeight } = refundDetails;
+        const {
+          amount,
+          lockupAddress,
+          serverPublicKey,
+          timeoutBlockHeight,
+          tree,
+          timeoutBlockHeights
+        } = refundDetails;
         chainSwaps.push({
           id,
           type: "chain",
@@ -5145,7 +5242,8 @@ var ArkadeSwaps = class _ArkadeSwaps {
               amount,
               lockupAddress,
               serverPublicKey,
-              timeoutBlockHeight
+              timeoutBlockHeight,
+              timeouts: resolveVhtlcTimeouts(tree, timeoutBlockHeights)
             }
           }
         });

package/dist/expo/background.d.cts

@@ -1,8 +1,8 @@
-import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor-BpAqG0V6.cjs';
-export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor-BpAqG0V6.cjs';
+import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor-BlyUrhtO.cjs';
+export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor-BlyUrhtO.cjs';
 import '@arkade-os/sdk/worker/expo';
 import '@arkade-os/sdk';
-import '../types--axEWA8c.cjs';
+import '../types-D97i1LFu.cjs';
 
 /**
  * Define the Expo background task handler for swap polling.

package/dist/expo/background.d.ts

@@ -1,8 +1,8 @@
-import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor-DFVOAy_-.js';
-export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor-DFVOAy_-.js';
+import { D as DefineSwapBackgroundTaskOptions } from '../swapsPollProcessor-Bv4Z2R7g.js';
+export { P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies, s as swapsPollProcessor } from '../swapsPollProcessor-Bv4Z2R7g.js';
 import '@arkade-os/sdk/worker/expo';
 import '@arkade-os/sdk';
-import '../types--axEWA8c.js';
+import '../types-D97i1LFu.js';
 
 /**
  * Define the Expo background task handler for swap polling.

package/dist/expo/background.js

@@ -1,10 +1,10 @@
 import {
   SWAP_POLL_TASK_TYPE,
   swapsPollProcessor
-} from "../chunk-5K2FS2FE.js";
+} from "../chunk-DNCIVDU5.js";
 import {
   BoltzSwapProvider
-} from "../chunk-TDBUZE4N.js";
+} from "../chunk-CFB2NNGT.js";
 import "../chunk-SJQJQO7P.js";
 
 // src/expo/background.ts