@arkade-os/boltz-swap 0.3.50 → 0.3.52

package/dist/index.cjs

@@ -95,7 +95,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // package.json
-var version = "0.3.50";
+var version = "0.3.52";
 
 // src/errors.ts
 var SwapError = class extends Error {
@@ -301,6 +301,7 @@ var BoltzRefundError = class extends Error {
     this.cause = cause;
     this.name = "BoltzRefundError";
   }
+  cause;
 };
 
 // src/arkade-swaps.ts
@@ -1127,6 +1128,13 @@ var MusigKeyAgg = class _MusigKeyAgg {
     this.internalKey = internalKey;
     this._tweak = _tweak;
   }
+  privateKey;
+  myPublicKey;
+  publicKeys;
+  myIndex;
+  aggPubkey;
+  internalKey;
+  _tweak;
   xonlyTweakAdd(tweak) {
     if (this._tweak) throw new Error("musig key already tweaked");
     return new _MusigKeyAgg(
@@ -1161,6 +1169,13 @@ var MusigWithMessage = class {
     this.tweak = tweak;
     this.msg = msg;
   }
+  privateKey;
+  myPublicKey;
+  publicKeys;
+  myIndex;
+  aggPubkey;
+  tweak;
+  msg;
   generateNonce() {
     const nonce = (0, import_musig2.nonceGen)(this.myPublicKey, this.privateKey, this.aggPubkey, this.msg);
     return new MusigWithNonce(
@@ -1184,6 +1199,13 @@ var MusigWithNonce = class {
     this.msg = msg;
     this.nonce = nonce;
   }
+  privateKey;
+  myPublicKey;
+  publicKeys;
+  myIndex;
+  tweak;
+  msg;
+  nonce;
   get publicNonce() {
     return this.nonce.public;
   }
@@ -1232,6 +1254,14 @@ var MusigNoncesAggregated = class {
     this.pubNonces = pubNonces;
     this.aggregatedNonce = aggregatedNonce;
   }
+  privateKey;
+  publicKeys;
+  myIndex;
+  tweak;
+  msg;
+  nonce;
+  pubNonces;
+  aggregatedNonce;
   get publicNonce() {
     return this.nonce.public;
   }
@@ -1263,6 +1293,12 @@ var MusigSession = class {
     this.session = session;
     this.partialSignatures = Array(publicKeys.length).fill(null);
   }
+  privateKey;
+  publicKeys;
+  myIndex;
+  nonce;
+  pubNonces;
+  session;
   partialSignatures;
   get publicNonce() {
     return this.nonce.public;
@@ -1290,6 +1326,10 @@ var MusigSigned = class {
     this.ourPartialSignature = ourPartialSignature;
     this.publicNonce = publicNonce;
   }
+  session;
+  partialSignatures;
+  ourPartialSignature;
+  publicNonce;
   aggregatePartials() {
     if (this.partialSignatures.some((s) => s === null)) {
       throw new Error("not all partial signatures are set");
@@ -1571,12 +1611,20 @@ var SwapManager = class _SwapManager {
    */
   static NOT_FOUND_THRESHOLD = 10;
   /**
-   * Delay between re-attempts of a chain refund that left VTXOs deferred
-   * (e.g. pre-CLTV recoverable VTXO, or Boltz 3-of-3 rejected before CLTV
-   * has elapsed). Boltz won't send another status update once the swap
-   * is `swap.expired`, so the manager owns the local retry cadence.
+   * Floor on the delay between re-attempts of a refund that left VTXOs
+   * deferred, and the delay used when the outcome names no retry time. Boltz
+   * won't send another status update once the swap is refundable-and-final,
+   * so the manager owns the local retry cadence.
    */
   static REFUND_RETRY_DELAY_MS = 6e4;
+  /**
+   * Ceiling on that delay. A deferral can be hours out (a pre-CLTV VTXO waits
+   * out the whole refund locktime), and `setTimeout` fires *immediately* past
+   * its 32-bit millisecond range, so long waits are broken into re-armed
+   * hops. Re-attempting costs an indexer lookup and re-defers, which also lets
+   * the cadence recover from a suspended device or a clock jump.
+   */
+  static MAX_REFUND_RETRY_DELAY_MS = 60 * 6e4;
   swapProvider;
   config;
   // Event listeners storage (supports multiple listeners per event)
@@ -1595,10 +1643,9 @@ var SwapManager = class _SwapManager {
   reconnectTimer = null;
   initialPollTimer = null;
   pollRetryTimers = /* @__PURE__ */ new Map();
-  // Per-swap retry timers for chain refunds that left work undone
-  // (refundArk returned `skipped > 0`). The swap is held in
-  // `monitoredSwaps` past its terminal Boltz status until the local
-  // refund completes or the manager stops.
+  // Per-swap retry timers for deferred refunds that left local work undone.
+  // The swap is held in `monitoredSwaps` past its terminal Boltz status
+  // until the local refund completes or the manager stops.
   refundRetryTimers = /* @__PURE__ */ new Map();
   // Per-swap counter of consecutive `SwapNotFoundError` responses from
   // `getSwapStatus`. Reset on any successful poll. Once a swap reaches
@@ -1770,11 +1817,12 @@ var SwapManager = class _SwapManager {
       this.initialSwaps.set(swap.id, swap);
     }
     for (const swap of pendingSwaps) {
-      if (!this.isFinalStatus(swap)) {
+      if (this.shouldMonitorOnStart(swap)) {
         this.monitoredSwaps.set(swap.id, swap);
       }
     }
     await this.tryConnectWebSocket();
+    this.resumePersistedRefundRetries();
     await this.resumeActionableSwaps();
   }
   /**
@@ -1857,6 +1905,7 @@ var SwapManager = class _SwapManager {
    * Remove a swap from monitoring
    */
   async removeSwap(swapId) {
+    const swap = this.monitoredSwaps.get(swapId);
     this.monitoredSwaps.delete(swapId);
     this.swapSubscriptions.delete(swapId);
     this.chainClaimPromises.delete(swapId);
@@ -1870,6 +1919,9 @@ var SwapManager = class _SwapManager {
       clearTimeout(refundRetryTimer);
       this.refundRetryTimers.delete(swapId);
     }
+    if (swap) {
+      await this.clearRefundRetry(swap);
+    }
     this.notFoundCounts.delete(swapId);
     logger.log(`Removed swap ${swapId} from monitoring`);
   }
@@ -2208,12 +2260,69 @@ var SwapManager = class _SwapManager {
     }
     this.swapCompletedListeners.forEach((listener) => listener(swap));
   }
+  static isRefundRetryableSwap(swap) {
+    return isPendingSubmarineSwap(swap) || isPendingChainSwap(swap);
+  }
+  static hasPendingRefundRetry(swap) {
+    if (!_SwapManager.isRefundRetryableSwap(swap)) return false;
+    return swap.refundRetry?.pending === true && Number.isFinite(swap.refundRetry.nextRetryAt);
+  }
+  shouldMonitorOnStart(swap) {
+    if (!this.isFinalStatus(swap)) return true;
+    return this.config.enableAutoActions === true && _SwapManager.hasPendingRefundRetry(swap);
+  }
   /**
-   * Schedule another `executeAutonomousAction` run for a chain swap whose
-   * refund left VTXOs deferred. After the retry completes, if no further
-   * deferral was reported, finalize monitoring cleanup.
+   * How long to wait before re-attempting a refund, given the `retryAt`
+   * (Unix seconds) the outcome reported. Clamped at both ends: see
+   * {@link SwapManager.REFUND_RETRY_DELAY_MS} and
+   * {@link SwapManager.MAX_REFUND_RETRY_DELAY_MS}.
    */
-  scheduleRefundRetry(swap, delayMs) {
+  static refundRetryDelayMs(retryAt) {
+    if (retryAt === void 0) return _SwapManager.REFUND_RETRY_DELAY_MS;
+    return Math.min(
+      Math.max(retryAt * 1e3 - Date.now(), _SwapManager.REFUND_RETRY_DELAY_MS),
+      _SwapManager.MAX_REFUND_RETRY_DELAY_MS
+    );
+  }
+  static persistedRefundRetryDelayMs(nextRetryAt) {
+    return Math.min(
+      Math.max(nextRetryAt * 1e3 - Date.now(), 0),
+      _SwapManager.MAX_REFUND_RETRY_DELAY_MS
+    );
+  }
+  static nextRefundRetryAt(delayMs) {
+    return Math.ceil((Date.now() + delayMs) / 1e3);
+  }
+  async clearRefundRetry(swap) {
+    if (!_SwapManager.isRefundRetryableSwap(swap) || swap.refundRetry === void 0) return;
+    delete swap.refundRetry;
+    await this.saveSwap(swap);
+  }
+  resumePersistedRefundRetries() {
+    if (!this.config.enableAutoActions) return;
+    for (const swap of this.monitoredSwaps.values()) {
+      if (!_SwapManager.hasPendingRefundRetry(swap)) continue;
+      const delayMs = _SwapManager.persistedRefundRetryDelayMs(swap.refundRetry.nextRetryAt);
+      logger.log(
+        `Swap ${swap.id}: resuming deferred refund retry in ${Math.round(delayMs / 1e3)}s`
+      );
+      this.armRefundRetryTimer(swap, delayMs);
+    }
+  }
+  /**
+   * Schedule another `executeAutonomousAction` run for a swap whose refund
+   * left VTXOs deferred. The pending retry and its next attempt time are saved
+   * with the swap so stop/start and application restart can re-arm it.
+   */
+  async scheduleRefundRetry(swap, delayMs) {
+    swap.refundRetry = {
+      pending: true,
+      nextRetryAt: _SwapManager.nextRefundRetryAt(delayMs)
+    };
+    await this.saveSwap(swap);
+    this.armRefundRetryTimer(swap, delayMs);
+  }
+  armRefundRetryTimer(swap, delayMs) {
     const existing = this.refundRetryTimers.get(swap.id);
     if (existing) clearTimeout(existing);
     this.refundRetryTimers.set(
@@ -2221,12 +2330,14 @@ var SwapManager = class _SwapManager {
       setTimeout(async () => {
         this.refundRetryTimers.delete(swap.id);
         if (!this.isRunning) return;
-        if (!this.monitoredSwaps.has(swap.id)) return;
+        const current = this.monitoredSwaps.get(swap.id);
+        if (!current) return;
+        let ran = false;
         try {
-          await this.executeAutonomousAction(swap);
+          ran = await this.executeAutonomousAction(current);
         } finally {
-          if (!this.refundRetryTimers.has(swap.id) && this.isFinalStatus(swap)) {
-            this.finalizeMonitoredSwap(swap);
+          if (ran && !this.refundRetryTimers.has(current.id) && this.isFinalStatus(current)) {
+            this.finalizeMonitoredSwap(current);
           }
         }
       }, delayMs)
@@ -2235,11 +2346,16 @@ var SwapManager = class _SwapManager {
   /**
    * Execute autonomous action based on swap status
    * Uses locking to prevent race conditions with manual operations
+   *
+   * @returns `false` when another action for this swap already held the lock
+   * and this call did nothing, `true` when it ran. Callers that finalize on
+   * the result must not act on `false`: the in-flight action owns the swap's
+   * outcome and will re-arm or finalize from its own result.
    */
   async executeAutonomousAction(swap) {
     if (this.swapsInProgress.has(swap.id)) {
       logger.log(`Swap ${swap.id} is already being processed, skipping autonomous action`);
-      return;
+      return false;
     }
     try {
       this.swapsInProgress.add(swap.id);
@@ -2248,7 +2364,7 @@ var SwapManager = class _SwapManager {
           logger.log(
             `Skipping claim for swap ${swap.id}: missing preimage (restored swap)`
           );
-          return;
+          return true;
         }
         if (isReverseClaimableStatus(swap.status)) {
           logger.log(`Auto-claiming reverse swap ${swap.id}`);
@@ -2260,11 +2376,26 @@ var SwapManager = class _SwapManager {
           logger.log(
             `Skipping refund for swap ${swap.id}: missing invoice (restored swap)`
           );
-          return;
+          return true;
         }
         if (isSubmarineRefundableStatus(swap.status)) {
           logger.log(`Auto-refunding submarine swap ${swap.id}`);
-          await this.executeRefundAction(swap);
+          let outcome;
+          try {
+            outcome = await this.executeRefundAction(swap);
+          } catch (error) {
+            await this.clearRefundRetry(swap);
+            throw error;
+          }
+          if (outcome && outcome.skipped > 0) {
+            const delayMs = _SwapManager.refundRetryDelayMs(outcome.retryAt);
+            logger.log(
+              `Submarine swap ${swap.id}: ${outcome.skipped} VTXO(s) deferred \u2014 scheduling refund retry in ${Math.round(delayMs / 1e3)}s`
+            );
+            await this.scheduleRefundRetry(swap, delayMs);
+          } else if (outcome) {
+            await this.clearRefundRetry(swap);
+          }
           this.actionExecutedListeners.forEach((listener) => listener(swap, "refund"));
         }
       } else if (isPendingChainSwap(swap)) {
@@ -2288,10 +2419,13 @@ var SwapManager = class _SwapManager {
             try {
               const outcome = await this.executeRefundArkAction(swap);
               if (outcome && outcome.skipped > 0) {
+                const delayMs = _SwapManager.refundRetryDelayMs(outcome.retryAt);
                 logger.log(
-                  `Chain swap ${swap.id}: ${outcome.skipped} VTXO(s) deferred \u2014 scheduling refund retry`
+                  `Chain swap ${swap.id}: ${outcome.skipped} VTXO(s) deferred \u2014 scheduling refund retry in ${Math.round(delayMs / 1e3)}s`
                 );
-                this.scheduleRefundRetry(swap, _SwapManager.REFUND_RETRY_DELAY_MS);
+                await this.scheduleRefundRetry(swap, delayMs);
+              } else if (outcome) {
+                await this.clearRefundRetry(swap);
               }
               this.actionExecutedListeners.forEach(
                 (listener) => listener(swap, "refundArk")
@@ -2304,7 +2438,7 @@ var SwapManager = class _SwapManager {
               this.swapFailedListeners.forEach(
                 (listener) => listener(swap, error)
               );
-              this.scheduleRefundRetry(swap, _SwapManager.REFUND_RETRY_DELAY_MS);
+              await this.scheduleRefundRetry(swap, _SwapManager.REFUND_RETRY_DELAY_MS);
             }
           }
           if (swap.request.from === "BTC") {
@@ -2337,6 +2471,7 @@ var SwapManager = class _SwapManager {
     } finally {
       this.swapsInProgress.delete(swap.id);
     }
+    return true;
   }
   /**
    * Execute claim action for reverse swap
@@ -2350,13 +2485,15 @@ var SwapManager = class _SwapManager {
   }
   /**
    * Execute refund action for submarine swap
+   *
+   * @returns The refund outcome, or `undefined` if no callback is wired.
    */
   async executeRefundAction(swap) {
     if (!this.refundCallback) {
       logger.error("Refund callback not set");
       return;
     }
-    await this.refundCallback(swap);
+    return this.refundCallback(swap);
   }
   /**
    * Execute claim action for chain swap Btc to Ark
@@ -2438,6 +2575,7 @@ var SwapManager = class _SwapManager {
       return;
     }
     for (const swap of this.monitoredSwaps.values()) {
+      if (this.refundRetryTimers.has(swap.id)) continue;
       try {
         if (isPendingReverseSwap(swap) && isReverseClaimableStatus(swap.status)) {
           logger.log(`Resuming claim for swap ${swap.id}`);
@@ -2769,6 +2907,7 @@ var IndexedDbSwapRepository = class {
   constructor(dbName = DEFAULT_DB_NAME) {
     this.dbName = dbName;
   }
+  dbName;
   version = 1;
   db = null;
   async getDB() {
@@ -3319,6 +3458,7 @@ var canRecoverViaBoltz3of3 = (refundableVtxos, swap) => {
   return refundableVtxos.some((vtxo) => !vtxo.isSpent && !(0, import_sdk8.isRecoverable)(vtxo));
 };
 var isSubmarineRefundLocktimeReached = (refundTimestamp) => Math.floor(Date.now() / 1e3) >= refundTimestamp;
+var CLTV_IMMATURE_RETRY_SEC = 60;
 var CLAIM_VTXO_RETRY_ATTEMPTS = 3;
 var CLAIM_VTXO_RETRY_DELAY_MS = 500;
 var quoteOptionsForSwap = (swap) => {
@@ -3391,9 +3531,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
         claim: async (swap) => {
           await this.claimVHTLC(swap);
         },
-        refund: async (swap) => {
-          await this.refundVHTLC(swap);
-        },
+        refund: (swap) => this.refundVHTLC(swap),
         claimArk: (swap) => this.claimArk(swap),
         claimBtc: (swap) => this.claimBtc(swap),
         refundArk: async (swap) => {
@@ -3999,7 +4137,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       refundWithoutReceiverLeaf,
       outputScript
     };
-    const { swept: sweptCount, skipped: skippedCount } = await this.refundVtxos({
+    const outcome = await this.refundVtxos({
       swapId: pendingSwap.id,
       vtxos: refundableVtxos,
       refundLocktime: vhtlcTimeouts.refund,
@@ -4009,7 +4147,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
       refundViaBoltz: this.swapProvider.refundSubmarineSwap.bind(this.swapProvider)
     });
     if (!isSubmarineSuccessStatus(pendingSwap.status)) {
-      const fullyRefunded = skippedCount === 0;
+      const fullyRefunded = outcome.skipped === 0;
+      pendingSwap.refundable = true;
+      pendingSwap.refunded = fullyRefunded;
       await updateSubmarineSwapStatus(
         pendingSwap,
         pendingSwap.status,
@@ -4018,7 +4158,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
         { refundable: true, refunded: fullyRefunded }
       );
     }
-    return { swept: sweptCount, skipped: skippedCount };
+    return outcome;
   }
   /**
    * Inspect a submarine swap's lockup address for recoverable funds.
@@ -4635,7 +4775,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       refundWithoutReceiverLeaf,
       outputScript
     };
-    const { swept: sweptCount, skipped: skippedCount } = await this.refundVtxos({
+    const outcome = await this.refundVtxos({
       swapId: pendingSwap.id,
       vtxos: unspentVtxos,
       refundLocktime,
@@ -4645,11 +4785,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
       refundViaBoltz: this.swapProvider.refundChainSwap.bind(this.swapProvider)
     });
     const finalStatus = await this.getSwapStatus(pendingSwap.id);
-    await this.savePendingChainSwap({
-      ...pendingSwap,
-      status: finalStatus.status
-    });
-    return { swept: sweptCount, skipped: skippedCount };
+    pendingSwap.status = finalStatus.status;
+    await this.savePendingChainSwap(pendingSwap);
+    return outcome;
   }
   // =========================================================================
   // Chain swaps: BTC -> ARK
@@ -5253,18 +5391,44 @@ var ArkadeSwaps = class _ArkadeSwaps {
       );
     }
   }
+  /**
+   * {@link settleRefundWithoutReceiver}, deferring instead of failing when the server
+   * rejects the spend as CLTV-immature ({@link ArkErrorName.FORFEIT_CLOSURE_LOCKED}):
+   * we gate on the local wall clock, the server on the chain tip's, which lags. The
+   * server-authoritative sibling of the wall-clock deferral the pre-CLTV branches
+   * already implement. Anything else propagates.
+   *
+   * Only `submitTx` can raise it, so this is a pass-through for recoverable VTXOs,
+   * which settle via a batch round.
+   *
+   * @returns `true` if settled, `false` if the server deferred it.
+   */
+  async trySettleRefundWithoutReceiver(swapId, ctx, vtxo) {
+    try {
+      await this.settleRefundWithoutReceiver(ctx, vtxo);
+      return true;
+    } catch (error) {
+      if (!(0, import_sdk8.isArkError)(error, import_sdk8.ArkErrorName.FORFEIT_CLOSURE_LOCKED)) throw error;
+      logger.warn(
+        `Swap ${swapId}: server deferred refundWithoutReceiver for VTXO ${vtxo.txid}:${vtxo.vout} \u2014 refund locktime has not matured against the chain tip (locktime=${error.metadata?.locktime}, currentLocktime=${error.metadata?.current_locktime}, type=${error.metadata?.type}). Refund will be retried once a later block carries the locktime.`
+      );
+      return false;
+    }
+  }
   /**
    * Refund every VTXO at a swap's VHTLC address back to the wallet, shared by
    * {@link ArkadeSwaps.refundVHTLC} (submarine) and {@link ArkadeSwaps.refundArk}
    * (chain). Path selection per VTXO:
-   * - CLTV elapsed → `refundWithoutReceiver` (offchain for a live VTXO, via a
-   *   batch round for a swept one — see {@link settleRefundWithoutReceiver}).
+   * - CLTV elapsed by our wall clock → `refundWithoutReceiver` (offchain for a
+   *   live VTXO, via a batch round for a swept one — see
+   *   {@link settleRefundWithoutReceiver}), or skipped if the server defers it as
+   *   still immature (see {@link trySettleRefundWithoutReceiver}).
    * - Pre-CLTV recoverable → skipped (Boltz can't co-sign a swept-batch refund).
    * - Pre-CLTV non-recoverable → cooperative 3-of-3 refund via Boltz, falling
    *   back to `refundWithoutReceiver` offchain if Boltz rejects after the
    *   locktime has since elapsed.
    *
-   * @returns Counts of VTXOs swept vs. deferred.
+   * @returns Counts of VTXOs swept vs. deferred, and when to retry the latter.
    */
   async refundVtxos(params) {
     const {
@@ -5280,19 +5444,27 @@ var ArkadeSwaps = class _ArkadeSwaps {
     let boltzCallCount = 0;
     let sweptCount = 0;
     let skippedCount = 0;
+    let retryAt;
+    const defer = (candidate) => {
+      skippedCount++;
+      retryAt = retryAt === void 0 ? candidate : Math.min(retryAt, candidate);
+    };
     for (const vtxo of vtxos) {
       const isRecoverableVtxo = (0, import_sdk8.isRecoverable)(vtxo);
       const output = { amount: BigInt(vtxo.value), script: outputScript };
       if (isSubmarineRefundLocktimeReached(refundLocktime)) {
-        await this.settleRefundWithoutReceiver(refundContext, vtxo);
-        sweptCount++;
+        if (await this.trySettleRefundWithoutReceiver(swapId, refundContext, vtxo)) {
+          sweptCount++;
+        } else {
+          defer(Math.floor(Date.now() / 1e3) + CLTV_IMMATURE_RETRY_SEC);
+        }
         continue;
       }
       if (isRecoverableVtxo) {
         logger.error(
           `Swap ${swapId}: recoverable VTXO ${vtxo.txid}:${vtxo.vout} cannot be refunded yet \u2014 refundWithoutReceiver locktime has not passed (refundLocktime=${refundLocktime}, currentTimestamp=${Math.floor(Date.now() / 1e3)}). Refund will be retried after locktime.`
         );
-        skippedCount++;
+        defer(refundLocktime);
         continue;
       }
       const input = {
@@ -5326,17 +5498,20 @@ var ArkadeSwaps = class _ArkadeSwaps {
           logger.error(
             `Swap ${swapId}: Boltz rejected VTXO outpoint and refundWithoutReceiver locktime has not passed yet (currentTimestamp=${Math.floor(Date.now() / 1e3)}, locktime=${refundLocktime}). Refund will be retried after locktime.`
           );
-          skippedCount++;
+          defer(refundLocktime);
           continue;
         }
         logger.warn(
           `Swap ${swapId}: Boltz rejected VTXO outpoint, falling back to refundWithoutReceiver offchain`
         );
-        await this.settleRefundWithoutReceiver(refundContext, vtxo);
-        sweptCount++;
+        if (await this.trySettleRefundWithoutReceiver(swapId, refundContext, vtxo)) {
+          sweptCount++;
+        } else {
+          defer(Math.floor(Date.now() / 1e3) + CLTV_IMMATURE_RETRY_SEC);
+        }
       }
     }
-    return { swept: sweptCount, skipped: skippedCount };
+    return { swept: sweptCount, skipped: skippedCount, retryAt };
   }
   /**
    * Creates a VHTLC script for the swap.
@@ -5691,6 +5866,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
   constructor(swapRepository) {
     this.swapRepository = swapRepository;
   }
+  swapRepository;
   static messageTag = DEFAULT_MESSAGE_TAG;
   messageTag = _ArkadeSwapsMessageHandler.messageTag;
   arkProvider;
@@ -6248,6 +6424,10 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
     this.swapRepository = swapRepository;
     this.withSwapManager = withSwapManager;
   }
+  messageTag;
+  serviceWorker;
+  swapRepository;
+  withSwapManager;
   eventListenerInitialized = false;
   swapUpdateListeners = /* @__PURE__ */ new Set();
   swapCompletedListeners = /* @__PURE__ */ new Set();

package/dist/index.d.cts

@@ -1,7 +1,7 @@
-import { Q as QuoteSwapOptions, I as IArkadeSwaps, V as VhtlcTimeouts } from './arkade-swaps-BG3xEK31.cjs';
-export { A as ArkadeSwaps } from './arkade-swaps-BG3xEK31.cjs';
-import { B as BoltzSwap, D as DecodedInvoice, a as BoltzChainSwap, b as BoltzReverseSwap, c as BoltzSubmarineSwap, A as ArkadeSwapsConfig, N as Network, C as CreateLightningInvoiceRequest, S as SendLightningPaymentRequest, F as FeesResponse, d as Chain, e as CreateLightningInvoiceResponse, O as OptimisticSendLightningPaymentResponse, f as SubmarineRefundOutcome, g as SubmarineRecoveryInfo, h as SubmarineRecoveryResult, i as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, j as ArkToBtcResponse, k as BtcToArkResponse, l as ChainArkRefundOutcome, m as SwapRepository, n as SwapManagerClient, o as SendLightningPaymentResponse, p as GetSwapsFilter } from './types-BKEkNZxK.cjs';
-export { q as ArkadeSwapsCreateConfig, r as BoltzSwapProvider, s as BoltzSwapStatus, I as IncomingPaymentSubscription, P as PendingChainSwap, t as PendingReverseSwap, u as PendingSubmarineSwap, v as PendingSwap, w as SubmarineProgressionStatus, x as SubmarineRecoveryStatus, y as SwapManager, z as SwapManagerCallbacks, E as SwapManagerConfig, H as SwapManagerEvents, V as Vtxo, J as hasSubmarineStatusReached, K as isChainClaimableStatus, M as isChainFailedStatus, Q as isChainFinalStatus, R as isChainPendingStatus, T as isChainRefundableStatus, U as isChainSignableStatus, W as isChainSuccessStatus, X as isChainSwapClaimable, Y as isChainSwapRefundable, Z as isPendingChainSwap, _ as isPendingReverseSwap, $ as isPendingSubmarineSwap, a0 as isReverseClaimableStatus, a1 as isReverseFailedStatus, a2 as isReverseFinalStatus, a3 as isReversePendingStatus, a4 as isReverseSuccessStatus, a5 as isReverseSwapClaimable, a6 as isSubmarineFailedStatus, a7 as isSubmarineFinalStatus, a8 as isSubmarinePendingStatus, a9 as isSubmarineRefundableStatus, aa as isSubmarineSuccessStatus, ab as isSubmarineSwapRefundable } from './types-BKEkNZxK.cjs';
+import { Q as QuoteSwapOptions, I as IArkadeSwaps, V as VhtlcTimeouts } from './arkade-swaps-qZmYvnVy.cjs';
+export { A as ArkadeSwaps } from './arkade-swaps-qZmYvnVy.cjs';
+import { B as BoltzSwap, D as DecodedInvoice, a as BoltzChainSwap, b as BoltzReverseSwap, c as BoltzSubmarineSwap, A as ArkadeSwapsConfig, N as Network, C as CreateLightningInvoiceRequest, S as SendLightningPaymentRequest, F as FeesResponse, d as Chain, e as CreateLightningInvoiceResponse, O as OptimisticSendLightningPaymentResponse, f as SubmarineRefundOutcome, g as SubmarineRecoveryInfo, h as SubmarineRecoveryResult, i as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, j as ArkToBtcResponse, k as BtcToArkResponse, l as ChainArkRefundOutcome, m as SwapRepository, n as SwapManagerClient, o as SendLightningPaymentResponse, p as GetSwapsFilter } from './types-Db4JSdjk.cjs';
+export { q as ArkadeSwapsCreateConfig, r as BoltzSwapProvider, s as BoltzSwapStatus, I as IncomingPaymentSubscription, P as PendingChainSwap, t as PendingReverseSwap, u as PendingSubmarineSwap, v as PendingSwap, w as SubmarineProgressionStatus, x as SubmarineRecoveryStatus, y as SwapManager, z as SwapManagerCallbacks, E as SwapManagerConfig, H as SwapManagerEvents, V as Vtxo, J as hasSubmarineStatusReached, K as isChainClaimableStatus, M as isChainFailedStatus, Q as isChainFinalStatus, R as isChainPendingStatus, T as isChainRefundableStatus, U as isChainSignableStatus, W as isChainSuccessStatus, X as isChainSwapClaimable, Y as isChainSwapRefundable, Z as isPendingChainSwap, _ as isPendingReverseSwap, $ as isPendingSubmarineSwap, a0 as isReverseClaimableStatus, a1 as isReverseFailedStatus, a2 as isReverseFinalStatus, a3 as isReversePendingStatus, a4 as isReverseSuccessStatus, a5 as isReverseSwapClaimable, a6 as isSubmarineFailedStatus, a7 as isSubmarineFinalStatus, a8 as isSubmarinePendingStatus, a9 as isSubmarineRefundableStatus, aa as isSubmarineSuccessStatus, ab as isSubmarineSwapRefundable } from './types-Db4JSdjk.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';

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { Q as QuoteSwapOptions, I as IArkadeSwaps, V as VhtlcTimeouts } from './arkade-swaps-A180YN8g.js';
-export { A as ArkadeSwaps } from './arkade-swaps-A180YN8g.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, O as OptimisticSendLightningPaymentResponse, f as SubmarineRefundOutcome, g as SubmarineRecoveryInfo, h as SubmarineRecoveryResult, i as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, j as ArkToBtcResponse, k as BtcToArkResponse, l as ChainArkRefundOutcome, m as SwapRepository, n as SwapManagerClient, o as SendLightningPaymentResponse, p as GetSwapsFilter } from './types-BKEkNZxK.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 SubmarineProgressionStatus, x as SubmarineRecoveryStatus, y as SwapManager, z as SwapManagerCallbacks, E as SwapManagerConfig, H as SwapManagerEvents, V as Vtxo, J as hasSubmarineStatusReached, K as isChainClaimableStatus, M as isChainFailedStatus, Q as isChainFinalStatus, R as isChainPendingStatus, T as isChainRefundableStatus, U as isChainSignableStatus, W as isChainSuccessStatus, X as isChainSwapClaimable, Y as isChainSwapRefundable, Z as isPendingChainSwap, _ as isPendingReverseSwap, $ as isPendingSubmarineSwap, a0 as isReverseClaimableStatus, a1 as isReverseFailedStatus, a2 as isReverseFinalStatus, a3 as isReversePendingStatus, a4 as isReverseSuccessStatus, a5 as isReverseSwapClaimable, a6 as isSubmarineFailedStatus, a7 as isSubmarineFinalStatus, a8 as isSubmarinePendingStatus, a9 as isSubmarineRefundableStatus, aa as isSubmarineSuccessStatus, ab as isSubmarineSwapRefundable } from './types-BKEkNZxK.js';
+import { Q as QuoteSwapOptions, I as IArkadeSwaps, V as VhtlcTimeouts } from './arkade-swaps-CoJKHu2Y.js';
+export { A as ArkadeSwaps } from './arkade-swaps-CoJKHu2Y.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, O as OptimisticSendLightningPaymentResponse, f as SubmarineRefundOutcome, g as SubmarineRecoveryInfo, h as SubmarineRecoveryResult, i as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, j as ArkToBtcResponse, k as BtcToArkResponse, l as ChainArkRefundOutcome, m as SwapRepository, n as SwapManagerClient, o as SendLightningPaymentResponse, p as GetSwapsFilter } from './types-Db4JSdjk.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 SubmarineProgressionStatus, x as SubmarineRecoveryStatus, y as SwapManager, z as SwapManagerCallbacks, E as SwapManagerConfig, H as SwapManagerEvents, V as Vtxo, J as hasSubmarineStatusReached, K as isChainClaimableStatus, M as isChainFailedStatus, Q as isChainFinalStatus, R as isChainPendingStatus, T as isChainRefundableStatus, U as isChainSignableStatus, W as isChainSuccessStatus, X as isChainSwapClaimable, Y as isChainSwapRefundable, Z as isPendingChainSwap, _ as isPendingReverseSwap, $ as isPendingSubmarineSwap, a0 as isReverseClaimableStatus, a1 as isReverseFailedStatus, a2 as isReverseFinalStatus, a3 as isReversePendingStatus, a4 as isReverseSuccessStatus, a5 as isReverseSwapClaimable, a6 as isSubmarineFailedStatus, a7 as isSubmarineFinalStatus, a8 as isSubmarinePendingStatus, a9 as isSubmarineRefundableStatus, aa as isSubmarineSuccessStatus, ab as isSubmarineSwapRefundable } from './types-Db4JSdjk.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';

package/dist/index.js

@@ -53,14 +53,14 @@ import {
   updateReverseSwapStatus,
   updateSubmarineSwapStatus,
   verifySignatures
-} from "./chunk-VKHFXGKL.js";
+} from "./chunk-CZTZTYZU.js";
 import {
   applyCreatedAtOrder,
   applySwapsFilter
 } from "./chunk-SJQJQO7P.js";
 
 // package.json
-var version = "0.3.50";
+var version = "0.3.52";
 
 // src/serviceWorker/arkade-swaps-message-handler.ts
 import { RestArkProvider, RestIndexerProvider } from "@arkade-os/sdk";
@@ -102,6 +102,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
   constructor(swapRepository) {
     this.swapRepository = swapRepository;
   }
+  swapRepository;
   static messageTag = DEFAULT_MESSAGE_TAG;
   messageTag = _ArkadeSwapsMessageHandler.messageTag;
   arkProvider;
@@ -663,6 +664,10 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
     this.swapRepository = swapRepository;
     this.withSwapManager = withSwapManager;
   }
+  messageTag;
+  serviceWorker;
+  swapRepository;
+  withSwapManager;
   eventListenerInitialized = false;
   swapUpdateListeners = /* @__PURE__ */ new Set();
   swapCompletedListeners = /* @__PURE__ */ new Set();

package/dist/repositories/realm/index.cjs

@@ -37,6 +37,7 @@ var RealmSwapRepository = class {
   constructor(realm) {
     this.realm = realm;
   }
+  realm;
   version = 1;
   // ── Lifecycle ──────────────────────────────────────────────────────
   async ensureInit() {

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

@@ -1,5 +1,5 @@
 import { RealmLike } from '@arkade-os/sdk/repositories/realm';
-import { m as SwapRepository, B as BoltzSwap, p as GetSwapsFilter } from '../../types-BKEkNZxK.cjs';
+import { m as SwapRepository, B as BoltzSwap, p as GetSwapsFilter } from '../../types-Db4JSdjk.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 { m as SwapRepository, B as BoltzSwap, p as GetSwapsFilter } from '../../types-BKEkNZxK.js';
+import { m as SwapRepository, B as BoltzSwap, p as GetSwapsFilter } from '../../types-Db4JSdjk.js';
 import '@arkade-os/sdk';
 
 /**

package/dist/repositories/realm/index.js

@@ -7,6 +7,7 @@ var RealmSwapRepository = class {
   constructor(realm) {
     this.realm = realm;
   }
+  realm;
   version = 1;
   // ── Lifecycle ──────────────────────────────────────────────────────
   async ensureInit() {