@arkade-os/boltz-swap 0.3.34 → 0.3.36

package/dist/{arkade-swaps-CfMets16.d.cts → arkade-swaps-DG9UepoS.d.cts}

@@ -1,5 +1,5 @@
 import { IWallet, ArkProvider, IndexerProvider, ArkInfo, Identity, ArkTxInput, VHTLC } from '@arkade-os/sdk';
-import { r as BoltzSwapProvider, x as SwapManager, n as SwapRepository, q as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, o as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, k as ArkToBtcResponse, a as BoltzChainSwap, m as ChainArkRefundOutcome, l as BtcToArkResponse, d as Chain, F as FeesResponse, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types--axEWA8c.cjs';
+import { r as BoltzSwapProvider, x as SwapManager, n as SwapRepository, q as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, o as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, k as ArkToBtcResponse, a as BoltzChainSwap, m as ChainArkRefundOutcome, l as BtcToArkResponse, d as Chain, F as FeesResponse, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-D97i1LFu.cjs';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
 
 /**
@@ -264,8 +264,11 @@ declare 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.
      */
-    claimBtc(pendingSwap: BoltzChainSwap): Promise<void>;
+    claimBtc(pendingSwap: BoltzChainSwap): Promise<{
+        txid: string;
+    }>;
     /**
      * When an ARK to BTC swap fails, refund every unspent VTXO at the chain
      * swap's ARK lockup address.
@@ -305,8 +308,22 @@ declare 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.
      */
-    claimArk(pendingSwap: BoltzChainSwap): Promise<void>;
+    claimArk(pendingSwap: BoltzChainSwap): Promise<{
+        txid: string;
+    }>;
+    /**
+     * 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.
+     */
+    private resolveChainClaimTxid;
     /**
      * Sign a cooperative claim for the server in BTC => ARK swaps.
      * @param pendingSwap - The pending chain swap.
@@ -523,7 +540,9 @@ interface IArkadeSwaps extends AsyncDisposable {
     waitAndClaimBtc(pendingSwap: BoltzChainSwap): Promise<{
         txid: string;
     }>;
-    claimBtc(pendingSwap: BoltzChainSwap): Promise<void>;
+    claimBtc(pendingSwap: BoltzChainSwap): Promise<{
+        txid: string;
+    }>;
     refundArk(pendingSwap: BoltzChainSwap): Promise<ChainArkRefundOutcome>;
     btcToArk(args: {
         feeSatsPerByte?: number;
@@ -533,7 +552,9 @@ interface IArkadeSwaps extends AsyncDisposable {
     waitAndClaimArk(pendingSwap: BoltzChainSwap): Promise<{
         txid: string;
     }>;
-    claimArk(pendingSwap: BoltzChainSwap): Promise<void>;
+    claimArk(pendingSwap: BoltzChainSwap): Promise<{
+        txid: string;
+    }>;
     signCooperativeClaimForServer(pendingSwap: BoltzChainSwap): Promise<void>;
     waitAndClaimChain(pendingSwap: BoltzChainSwap): Promise<{
         txid: string;

package/dist/{arkade-swaps-BXAD1s8j.d.ts → arkade-swaps-Uet3tgN6.d.ts}

@@ -1,5 +1,5 @@
 import { IWallet, ArkProvider, IndexerProvider, ArkInfo, Identity, ArkTxInput, VHTLC } from '@arkade-os/sdk';
-import { r as BoltzSwapProvider, x as SwapManager, n as SwapRepository, q as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, o as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, k as ArkToBtcResponse, a as BoltzChainSwap, m as ChainArkRefundOutcome, l as BtcToArkResponse, d as Chain, F as FeesResponse, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types--axEWA8c.js';
+import { r as BoltzSwapProvider, x as SwapManager, n as SwapRepository, q as ArkadeSwapsCreateConfig, A as ArkadeSwapsConfig, o as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, b as BoltzReverseSwap, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, k as ArkToBtcResponse, a as BoltzChainSwap, m as ChainArkRefundOutcome, l as BtcToArkResponse, d as Chain, F as FeesResponse, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from './types-D97i1LFu.js';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
 
 /**
@@ -264,8 +264,11 @@ declare 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.
      */
-    claimBtc(pendingSwap: BoltzChainSwap): Promise<void>;
+    claimBtc(pendingSwap: BoltzChainSwap): Promise<{
+        txid: string;
+    }>;
     /**
      * When an ARK to BTC swap fails, refund every unspent VTXO at the chain
      * swap's ARK lockup address.
@@ -305,8 +308,22 @@ declare 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.
      */
-    claimArk(pendingSwap: BoltzChainSwap): Promise<void>;
+    claimArk(pendingSwap: BoltzChainSwap): Promise<{
+        txid: string;
+    }>;
+    /**
+     * 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.
+     */
+    private resolveChainClaimTxid;
     /**
      * Sign a cooperative claim for the server in BTC => ARK swaps.
      * @param pendingSwap - The pending chain swap.
@@ -523,7 +540,9 @@ interface IArkadeSwaps extends AsyncDisposable {
     waitAndClaimBtc(pendingSwap: BoltzChainSwap): Promise<{
         txid: string;
     }>;
-    claimBtc(pendingSwap: BoltzChainSwap): Promise<void>;
+    claimBtc(pendingSwap: BoltzChainSwap): Promise<{
+        txid: string;
+    }>;
     refundArk(pendingSwap: BoltzChainSwap): Promise<ChainArkRefundOutcome>;
     btcToArk(args: {
         feeSatsPerByte?: number;
@@ -533,7 +552,9 @@ interface IArkadeSwaps extends AsyncDisposable {
     waitAndClaimArk(pendingSwap: BoltzChainSwap): Promise<{
         txid: string;
     }>;
-    claimArk(pendingSwap: BoltzChainSwap): Promise<void>;
+    claimArk(pendingSwap: BoltzChainSwap): Promise<{
+        txid: string;
+    }>;
     signCooperativeClaimForServer(pendingSwap: BoltzChainSwap): Promise<void>;
     waitAndClaimChain(pendingSwap: BoltzChainSwap): Promise<{
         txid: string;

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

@@ -1092,6 +1092,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;
@@ -1233,6 +1240,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);
     }
@@ -1326,6 +1334,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);
@@ -1368,9 +1377,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);
@@ -1385,10 +1399,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;
@@ -1403,13 +1419,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}`));
           }
@@ -1420,6 +1436,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
@@ -1623,6 +1670,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);
@@ -1793,7 +1841,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
@@ -1803,7 +1853,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
@@ -2670,6 +2736,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/utils/identity.ts
 import { ConditionWitness, setArkPsbtField, Transaction as Transaction3 } from "@arkade-os/sdk";
@@ -2989,6 +3069,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 = hex7.decode(arkInfo.checkpointTapscript);
@@ -3147,12 +3228,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);
         },
@@ -4163,6 +4240,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 () => {
@@ -4180,16 +4258,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(
@@ -4238,6 +4324,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)
@@ -4310,6 +4397,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
@@ -4509,6 +4597,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 = () => {
@@ -4521,15 +4610,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) => {
@@ -4588,6 +4685,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)
@@ -4650,24 +4748,42 @@ var ArkadeSwaps = class _ArkadeSwaps {
       script: ArkAddress2.decode(address).pkScript
     };
     const vhtlcIdentity = claimVHTLCIdentity(this.wallet.identity, preimage);
-    if (isRecoverable(vtxo)) {
-      await this.joinBatch(vhtlcIdentity, input, output, arkInfo);
-    } else {
-      await claimVHTLCwithOffchainTx(
-        vhtlcIdentity,
-        vhtlcScript,
-        serverXOnlyPublicKey,
-        input,
-        output,
-        arkInfo,
-        this.arkProvider
-      );
-    }
+    const txid = 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.
@@ -5111,20 +5227,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",
@@ -5157,26 +5260,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",
@@ -5202,7 +5299,8 @@ var ArkadeSwaps = class _ArkadeSwaps {
               amount,
               lockupAddress,
               serverPublicKey,
-              timeoutBlockHeight
+              timeoutBlockHeight,
+              timeouts: resolveVhtlcTimeouts(tree, timeoutBlockHeights)
             }
           }
         });

package/dist/{chunk-5K2FS2FE.js → chunk-DNCIVDU5.js}

@@ -7,7 +7,7 @@ import {
   isSubmarineFinalStatus,
   isSubmarineSwapRefundable,
   logger
-} from "./chunk-TDBUZE4N.js";
+} from "./chunk-CFB2NNGT.js";
 
 // src/expo/swapsPollProcessor.ts
 var SWAP_POLL_TASK_TYPE = "swap-poll";