@arkade-os/boltz-swap 0.3.34 → 0.3.36

package/dist/index.cjs

@@ -1501,6 +1501,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;
@@ -1565,6 +1579,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;
@@ -1706,6 +1727,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);
     }
@@ -1799,6 +1821,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);
@@ -1841,9 +1864,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);
@@ -1858,10 +1886,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;
@@ -1876,13 +1906,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}`));
           }
@@ -1893,6 +1923,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
@@ -2096,6 +2157,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);
@@ -2266,7 +2328,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
@@ -2276,7 +2340,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
@@ -3070,6 +3150,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);
@@ -3228,12 +3309,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);
         },
@@ -4244,6 +4321,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 () => {
@@ -4261,16 +4339,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(
@@ -4319,6 +4405,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)
@@ -4391,6 +4478,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
@@ -4590,6 +4678,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 = () => {
@@ -4602,15 +4691,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) => {
@@ -4669,6 +4766,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)
@@ -4731,24 +4829,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.
@@ -5192,20 +5308,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",
@@ -5238,26 +5341,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",
@@ -5283,7 +5380,8 @@ var ArkadeSwaps = class _ArkadeSwaps {
               amount,
               lockupAddress,
               serverPublicKey,
-              timeoutBlockHeight
+              timeoutBlockHeight,
+              timeouts: resolveVhtlcTimeouts(tree, timeoutBlockHeights)
             }
           }
         });
@@ -5647,12 +5745,14 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
             payload: res
           });
         }
-        case "CLAIM_ARK":
-          await this.handler.claimArk(message.payload);
-          return this.tagged({ id, type: "ARK_CLAIM_EXECUTED" });
-        case "CLAIM_BTC":
-          await this.handler.claimBtc(message.payload);
-          return this.tagged({ id, type: "BTC_CLAIM_EXECUTED" });
+        case "CLAIM_ARK": {
+          const res = await this.handler.claimArk(message.payload);
+          return this.tagged({ id, type: "ARK_CLAIM_EXECUTED", payload: res });
+        }
+        case "CLAIM_BTC": {
+          const res = await this.handler.claimBtc(message.payload);
+          return this.tagged({ id, type: "BTC_CLAIM_EXECUTED", payload: res });
+        }
         case "REFUND_ARK": {
           const outcome = await this.handler.refundArk(message.payload);
           return this.tagged({
@@ -6319,20 +6419,22 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
     }
   }
   async claimArk(pendingSwap) {
-    await this.sendMessage({
+    const res = await this.sendMessage({
       id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "CLAIM_ARK",
       payload: pendingSwap
     });
+    return res.payload;
   }
   async claimBtc(pendingSwap) {
-    await this.sendMessage({
+    const res = await this.sendMessage({
       id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "CLAIM_BTC",
       payload: pendingSwap
     });
+    return res.payload;
   }
   async refundArk(pendingSwap) {
     const res = await this.sendMessage({

package/dist/index.d.cts

@@ -1,7 +1,7 @@
-import { Q as QuoteSwapOptions, I as IArkadeSwaps, V as VhtlcTimeouts } from './arkade-swaps-CfMets16.cjs';
-export { A as ArkadeSwaps } from './arkade-swaps-CfMets16.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--axEWA8c.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--axEWA8c.cjs';
+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 { 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';
@@ -485,6 +485,9 @@ type RequestClaimArk = RequestEnvelope & {
 };
 type ResponseClaimArk = ResponseEnvelope & {
     type: "ARK_CLAIM_EXECUTED";
+    payload: {
+        txid: string;
+    };
 };
 type RequestClaimBtc = RequestEnvelope & {
     type: "CLAIM_BTC";
@@ -492,6 +495,9 @@ type RequestClaimBtc = RequestEnvelope & {
 };
 type ResponseClaimBtc = ResponseEnvelope & {
     type: "BTC_CLAIM_EXECUTED";
+    payload: {
+        txid: string;
+    };
 };
 type RequestRefundArk = RequestEnvelope & {
     type: "REFUND_ARK";
@@ -751,8 +757,12 @@ declare class ServiceWorkerArkadeSwaps implements IArkadeSwaps {
     waitAndClaimBtc(pendingSwap: BoltzChainSwap): Promise<{
         txid: string;
     }>;
-    claimArk(pendingSwap: BoltzChainSwap): Promise<void>;
-    claimBtc(pendingSwap: BoltzChainSwap): Promise<void>;
+    claimArk(pendingSwap: BoltzChainSwap): Promise<{
+        txid: string;
+    }>;
+    claimBtc(pendingSwap: BoltzChainSwap): Promise<{
+        txid: string;
+    }>;
     refundArk(pendingSwap: BoltzChainSwap): Promise<ChainArkRefundOutcome>;
     signCooperativeClaimForServer(pendingSwap: BoltzChainSwap): Promise<void>;
     verifyChainSwap(args: {

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { Q as QuoteSwapOptions, I as IArkadeSwaps, V as VhtlcTimeouts } from './arkade-swaps-BXAD1s8j.js';
-export { A as ArkadeSwaps } from './arkade-swaps-BXAD1s8j.js';
-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--axEWA8c.js';
-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--axEWA8c.js';
+import { Q as QuoteSwapOptions, I as IArkadeSwaps, V as VhtlcTimeouts } from './arkade-swaps-Uet3tgN6.js';
+export { A as ArkadeSwaps } from './arkade-swaps-Uet3tgN6.js';
+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.js';
+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.js';
 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';
@@ -485,6 +485,9 @@ type RequestClaimArk = RequestEnvelope & {
 };
 type ResponseClaimArk = ResponseEnvelope & {
     type: "ARK_CLAIM_EXECUTED";
+    payload: {
+        txid: string;
+    };
 };
 type RequestClaimBtc = RequestEnvelope & {
     type: "CLAIM_BTC";
@@ -492,6 +495,9 @@ type RequestClaimBtc = RequestEnvelope & {
 };
 type ResponseClaimBtc = ResponseEnvelope & {
     type: "BTC_CLAIM_EXECUTED";
+    payload: {
+        txid: string;
+    };
 };
 type RequestRefundArk = RequestEnvelope & {
     type: "REFUND_ARK";
@@ -751,8 +757,12 @@ declare class ServiceWorkerArkadeSwaps implements IArkadeSwaps {
     waitAndClaimBtc(pendingSwap: BoltzChainSwap): Promise<{
         txid: string;
     }>;
-    claimArk(pendingSwap: BoltzChainSwap): Promise<void>;
-    claimBtc(pendingSwap: BoltzChainSwap): Promise<void>;
+    claimArk(pendingSwap: BoltzChainSwap): Promise<{
+        txid: string;
+    }>;
+    claimBtc(pendingSwap: BoltzChainSwap): Promise<{
+        txid: string;
+    }>;
     refundArk(pendingSwap: BoltzChainSwap): Promise<ChainArkRefundOutcome>;
     signCooperativeClaimForServer(pendingSwap: BoltzChainSwap): Promise<void>;
     verifyChainSwap(args: {

package/dist/index.js

@@ -52,7 +52,7 @@ import {
   updateReverseSwapStatus,
   updateSubmarineSwapStatus,
   verifySignatures
-} from "./chunk-TDBUZE4N.js";
+} from "./chunk-CFB2NNGT.js";
 import {
   applyCreatedAtOrder,
   applySwapsFilter
@@ -400,12 +400,14 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
             payload: res
           });
         }
-        case "CLAIM_ARK":
-          await this.handler.claimArk(message.payload);
-          return this.tagged({ id, type: "ARK_CLAIM_EXECUTED" });
-        case "CLAIM_BTC":
-          await this.handler.claimBtc(message.payload);
-          return this.tagged({ id, type: "BTC_CLAIM_EXECUTED" });
+        case "CLAIM_ARK": {
+          const res = await this.handler.claimArk(message.payload);
+          return this.tagged({ id, type: "ARK_CLAIM_EXECUTED", payload: res });
+        }
+        case "CLAIM_BTC": {
+          const res = await this.handler.claimBtc(message.payload);
+          return this.tagged({ id, type: "BTC_CLAIM_EXECUTED", payload: res });
+        }
         case "REFUND_ARK": {
           const outcome = await this.handler.refundArk(message.payload);
           return this.tagged({
@@ -1076,20 +1078,22 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
     }
   }
   async claimArk(pendingSwap) {
-    await this.sendMessage({
+    const res = await this.sendMessage({
       id: getRandomId(),
       tag: this.messageTag,
       type: "CLAIM_ARK",
       payload: pendingSwap
     });
+    return res.payload;
   }
   async claimBtc(pendingSwap) {
-    await this.sendMessage({
+    const res = await this.sendMessage({
       id: getRandomId(),
       tag: this.messageTag,
       type: "CLAIM_BTC",
       payload: pendingSwap
     });
+    return res.payload;
   }
   async refundArk(pendingSwap) {
     const res = await this.sendMessage({

package/dist/repositories/realm/index.d.cts

@@ -1,5 +1,5 @@
 import { RealmLike } from '@arkade-os/sdk/repositories/realm';
-import { n as SwapRepository, B as BoltzSwap, p as GetSwapsFilter } from '../../types--axEWA8c.cjs';
+import { n as SwapRepository, B as BoltzSwap, p as GetSwapsFilter } from '../../types-D97i1LFu.cjs';
 import '@arkade-os/sdk';
 
 /**

package/dist/repositories/realm/index.d.ts

@@ -1,5 +1,5 @@
 import { RealmLike } from '@arkade-os/sdk/repositories/realm';
-import { n as SwapRepository, B as BoltzSwap, p as GetSwapsFilter } from '../../types--axEWA8c.js';
+import { n as SwapRepository, B as BoltzSwap, p as GetSwapsFilter } from '../../types-D97i1LFu.js';
 import '@arkade-os/sdk';
 
 /**

package/dist/repositories/sqlite/index.d.cts

@@ -1,5 +1,5 @@
 import { SQLExecutor } from '@arkade-os/sdk/repositories/sqlite';
-import { n as SwapRepository, B as BoltzSwap, p as GetSwapsFilter } from '../../types--axEWA8c.cjs';
+import { n as SwapRepository, B as BoltzSwap, p as GetSwapsFilter } from '../../types-D97i1LFu.cjs';
 import '@arkade-os/sdk';
 
 /**

package/dist/repositories/sqlite/index.d.ts

@@ -1,5 +1,5 @@
 import { SQLExecutor } from '@arkade-os/sdk/repositories/sqlite';
-import { n as SwapRepository, B as BoltzSwap, p as GetSwapsFilter } from '../../types--axEWA8c.js';
+import { n as SwapRepository, B as BoltzSwap, p as GetSwapsFilter } from '../../types-D97i1LFu.js';
 import '@arkade-os/sdk';
 
 /**

package/dist/{swapsPollProcessor-BpAqG0V6.d.cts → swapsPollProcessor-BlyUrhtO.d.cts}

@@ -1,6 +1,6 @@
 import { AsyncStorageTaskQueue, TaskProcessor } from '@arkade-os/sdk/worker/expo';
 import { Identity, ArkProvider, IndexerProvider, IWallet } from '@arkade-os/sdk';
-import { n as SwapRepository, N as Network, r as BoltzSwapProvider, A as ArkadeSwapsConfig } from './types--axEWA8c.cjs';
+import { n as SwapRepository, N as Network, r as BoltzSwapProvider, A as ArkadeSwapsConfig } from './types-D97i1LFu.cjs';
 
 /**
  * Dependencies injected into every swap processor at runtime.