@arkade-os/boltz-swap 0.3.35 → 0.3.36

package/dist/expo/index.cjs

@@ -1438,6 +1438,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;
@@ -1579,6 +1586,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);
     }
@@ -1672,6 +1680,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);
@@ -1714,9 +1723,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);
@@ -1731,10 +1745,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;
@@ -1749,13 +1765,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}`));
           }
@@ -1766,6 +1782,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
@@ -1969,6 +2016,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);
@@ -2139,7 +2187,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
@@ -2149,7 +2199,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
@@ -2936,6 +3002,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);
@@ -3094,12 +3161,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);
         },
@@ -4110,6 +4173,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 () => {
@@ -4127,16 +4191,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(
@@ -4185,6 +4257,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)
@@ -4257,6 +4330,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
@@ -4456,6 +4530,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 = () => {
@@ -4468,15 +4543,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) => {
@@ -4535,6 +4618,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)
@@ -4597,24 +4681,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.

package/dist/expo/index.d.cts

@@ -1,7 +1,7 @@
-import { I as IArkadeSwaps, A as ArkadeSwaps, Q as QuoteSwapOptions, V as VhtlcTimeouts } from '../arkade-swaps-CfMets16.cjs';
-import { o as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, b as BoltzReverseSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, F as FeesResponse, a as BoltzChainSwap, k as ArkToBtcResponse, m as ChainArkRefundOutcome, l as BtcToArkResponse, d as Chain, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from '../types--axEWA8c.cjs';
-import { E as ExpoArkadeSwapsConfig } from '../swapsPollProcessor-BpAqG0V6.cjs';
-export { D as DefineSwapBackgroundTaskOptions, b as ExpoArkadeLightningConfig, c as ExpoSwapBackgroundConfig, P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies } from '../swapsPollProcessor-BpAqG0V6.cjs';
+import { I as IArkadeSwaps, A as ArkadeSwaps, Q as QuoteSwapOptions, V as VhtlcTimeouts } from '../arkade-swaps-DG9UepoS.cjs';
+import { o as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, b as BoltzReverseSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, F as FeesResponse, a as BoltzChainSwap, k as ArkToBtcResponse, m as ChainArkRefundOutcome, l as BtcToArkResponse, d as Chain, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from '../types-D97i1LFu.cjs';
+import { E as ExpoArkadeSwapsConfig } from '../swapsPollProcessor-BlyUrhtO.cjs';
+export { D as DefineSwapBackgroundTaskOptions, b as ExpoArkadeLightningConfig, c as ExpoSwapBackgroundConfig, P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies } from '../swapsPollProcessor-BlyUrhtO.cjs';
 import { ArkInfo, Identity, ArkTxInput, VHTLC } from '@arkade-os/sdk';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
 import '@arkade-os/sdk/worker/expo';
@@ -115,7 +115,9 @@ declare class ExpoArkadeSwaps implements IArkadeSwaps {
     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;
@@ -125,7 +127,9 @@ declare class ExpoArkadeSwaps implements IArkadeSwaps {
     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/expo/index.d.ts

@@ -1,7 +1,7 @@
-import { I as IArkadeSwaps, A as ArkadeSwaps, Q as QuoteSwapOptions, V as VhtlcTimeouts } from '../arkade-swaps-BXAD1s8j.js';
-import { o as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, b as BoltzReverseSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, F as FeesResponse, a as BoltzChainSwap, k as ArkToBtcResponse, m as ChainArkRefundOutcome, l as BtcToArkResponse, d as Chain, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from '../types--axEWA8c.js';
-import { E as ExpoArkadeSwapsConfig } from '../swapsPollProcessor-DFVOAy_-.js';
-export { D as DefineSwapBackgroundTaskOptions, b as ExpoArkadeLightningConfig, c as ExpoSwapBackgroundConfig, P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies } from '../swapsPollProcessor-DFVOAy_-.js';
+import { I as IArkadeSwaps, A as ArkadeSwaps, Q as QuoteSwapOptions, V as VhtlcTimeouts } from '../arkade-swaps-Uet3tgN6.js';
+import { o as SwapManagerClient, C as CreateLightningInvoiceRequest, e as CreateLightningInvoiceResponse, S as SendLightningPaymentRequest, f as SendLightningPaymentResponse, c as BoltzSubmarineSwap, b as BoltzReverseSwap, g as SubmarineRefundOutcome, h as SubmarineRecoveryInfo, i as SubmarineRecoveryResult, F as FeesResponse, a as BoltzChainSwap, k as ArkToBtcResponse, m as ChainArkRefundOutcome, l as BtcToArkResponse, d as Chain, j as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, B as BoltzSwap } from '../types-D97i1LFu.js';
+import { E as ExpoArkadeSwapsConfig } from '../swapsPollProcessor-Bv4Z2R7g.js';
+export { D as DefineSwapBackgroundTaskOptions, b as ExpoArkadeLightningConfig, c as ExpoSwapBackgroundConfig, P as PersistedSwapBackgroundConfig, S as SWAP_POLL_TASK_TYPE, a as SwapTaskDependencies } from '../swapsPollProcessor-Bv4Z2R7g.js';
 import { ArkInfo, Identity, ArkTxInput, VHTLC } from '@arkade-os/sdk';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
 import '@arkade-os/sdk/worker/expo';
@@ -115,7 +115,9 @@ declare class ExpoArkadeSwaps implements IArkadeSwaps {
     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;
@@ -125,7 +127,9 @@ declare class ExpoArkadeSwaps implements IArkadeSwaps {
     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/expo/index.js

@@ -1,9 +1,9 @@
 import {
   SWAP_POLL_TASK_TYPE
-} from "../chunk-H6F67K2A.js";
+} from "../chunk-DNCIVDU5.js";
 import {
   ArkadeSwaps
-} from "../chunk-B4CYBKFJ.js";
+} from "../chunk-CFB2NNGT.js";
 import "../chunk-SJQJQO7P.js";
 
 // src/expo/arkade-lightning.ts