@arkade-os/boltz-swap 0.3.32 → 0.3.34

package/dist/expo/index.cjs

@@ -45,7 +45,10 @@ var SwapError = class extends Error {
   /** The pending swap associated with this error, if available. */
   pendingSwap;
   constructor(options = {}) {
-    super(options.message ?? "Error during swap.");
+    super(
+      options.message ?? "Error during swap.",
+      options.cause !== void 0 ? { cause: options.cause } : void 0
+    );
     this.name = "SwapError";
     this.isClaimable = options.isClaimable ?? false;
     this.isRefundable = options.isRefundable ?? false;
@@ -122,6 +125,100 @@ var TransactionRefundedError = class extends SwapError {
     this.name = "TransactionRefundedError";
   }
 };
+var QuoteRejectedError = class _QuoteRejectedError extends SwapError {
+  reason;
+  quotedAmount;
+  floor;
+  constructor(options) {
+    super({
+      message: options.message ?? _QuoteRejectedError.defaultMessage(options),
+      ...options
+    });
+    this.name = "QuoteRejectedError";
+    this.reason = options.reason;
+    this.quotedAmount = "quotedAmount" in options ? options.quotedAmount : void 0;
+    this.floor = "floor" in options ? options.floor : void 0;
+  }
+  static defaultMessage(options) {
+    switch (options.reason) {
+      case "below_floor":
+        return `Boltz quote ${options.quotedAmount} is below acceptable floor ${options.floor}`;
+      case "non_positive":
+        return `Boltz quote ${options.quotedAmount} is not positive`;
+      case "non_safe_integer":
+        return `Boltz quote ${options.quotedAmount} is not a safe positive satoshi integer`;
+      case "no_baseline":
+        return "Cannot accept quote: no minAcceptableAmount and no stored pending swap";
+    }
+  }
+  /**
+   * Serialize into a plain `Error` whose `.message` carries the full
+   * rejection payload as JSON behind a marker prefix. Structured clone
+   * (used by `postMessage` between page and service worker) preserves
+   * `Error.message` reliably but strips custom `.name` and own properties,
+   * so we move the typed data into the message field for transport.
+   */
+  toTransportError() {
+    return new Error(
+      QUOTE_REJECTION_TRANSPORT_PREFIX + JSON.stringify({
+        reason: this.reason,
+        message: this.message,
+        quotedAmount: this.quotedAmount,
+        floor: this.floor
+      })
+    );
+  }
+  /**
+   * Inverse of `toTransportError`. Returns a real `QuoteRejectedError` if
+   * `error` carries the transport prefix, else `null`.
+   */
+  static fromTransportError(error) {
+    if (!(error instanceof Error) || !error.message.startsWith(QUOTE_REJECTION_TRANSPORT_PREFIX)) {
+      return null;
+    }
+    const payload = error.message.slice(QUOTE_REJECTION_TRANSPORT_PREFIX.length);
+    let data;
+    try {
+      data = JSON.parse(payload);
+    } catch {
+      return null;
+    }
+    if (typeof data.reason !== "string" || !QUOTE_REJECTION_REASONS.has(data.reason)) {
+      return null;
+    }
+    const message = typeof data.message === "string" ? data.message : void 0;
+    const reason = data.reason;
+    const quotedAmount = typeof data.quotedAmount === "number" ? data.quotedAmount : null;
+    const floor = typeof data.floor === "number" ? data.floor : null;
+    switch (reason) {
+      case "below_floor":
+        if (quotedAmount === null || floor === null) return null;
+        return new _QuoteRejectedError({
+          reason,
+          quotedAmount,
+          floor,
+          message
+        });
+      case "non_positive":
+      case "non_safe_integer":
+        if (quotedAmount === null) return null;
+        return new _QuoteRejectedError({
+          reason,
+          quotedAmount,
+          message
+        });
+      case "no_baseline":
+        return new _QuoteRejectedError({ reason, message });
+    }
+  }
+};
+var QUOTE_REJECTION_TRANSPORT_PREFIX = "QUOTE_REJECTED::";
+var QUOTE_REJECTION_REASONS = /* @__PURE__ */ new Set([
+  "below_floor",
+  "non_positive",
+  "non_safe_integer",
+  "no_baseline"
+]);
 var BoltzRefundError = class extends Error {
   constructor(message, cause) {
     super(message);
@@ -137,18 +234,10 @@ var import_sdk8 = require("@arkade-os/sdk");
 var import_sdk = require("@arkade-os/sdk");
 var import_base = require("@scure/base");
 var isSubmarineFinalStatus = (status) => {
-  return [
-    "invoice.failedToPay",
-    "transaction.claimed",
-    "swap.expired"
-  ].includes(status);
+  return ["invoice.failedToPay", "transaction.claimed", "swap.expired"].includes(status);
 };
 var isSubmarineRefundableStatus = (status) => {
-  return [
-    "invoice.failedToPay",
-    "transaction.lockupFailed",
-    "swap.expired"
-  ].includes(status);
+  return ["invoice.failedToPay", "transaction.lockupFailed", "swap.expired"].includes(status);
 };
 var isSubmarineSuccessStatus = (status) => {
   return status === "transaction.claimed";
@@ -167,10 +256,7 @@ var isReverseClaimableStatus = (status) => {
   return ["transaction.mempool", "transaction.confirmed"].includes(status);
 };
 var isChainClaimableStatus = (status) => {
-  return [
-    "transaction.server.mempool",
-    "transaction.server.confirmed"
-  ].includes(status);
+  return ["transaction.server.mempool", "transaction.server.confirmed"].includes(status);
 };
 var isChainFinalStatus = (status) => {
   return [
@@ -284,8 +370,7 @@ var BASE_URLS = {
 var isSwapNotFoundBody = (error) => {
   const needle = "could not find swap";
   const fromJson = error.errorData?.error;
-  if (typeof fromJson === "string" && fromJson.toLowerCase().includes(needle))
-    return true;
+  if (typeof fromJson === "string" && fromJson.toLowerCase().includes(needle)) return true;
   return error.message.toLowerCase().includes(needle);
 };
 var BoltzSwapProvider = class {
@@ -299,10 +384,7 @@ var BoltzSwapProvider = class {
     this.network = config.network;
     this.referralId = config.referralId ?? "arkade-ts-sdk";
     const apiUrl = config.apiUrl || BASE_URLS[config.network];
-    if (!apiUrl)
-      throw new Error(
-        `API URL is required for network: ${config.network}`
-      );
+    if (!apiUrl) throw new Error(`API URL is required for network: ${config.network}`);
     this.apiUrl = apiUrl;
     this.wsUrl = this.apiUrl.replace(/^http(s)?:\/\//, "ws$1://").replace("9069", "9004") + "/v2/ws";
   }
@@ -321,10 +403,7 @@ var BoltzSwapProvider = class {
   /** Returns current Lightning swap fees (submarine + reverse) from Boltz. */
   async getFees() {
     const [submarine, reverse] = await Promise.all([
-      this.request(
-        "/v2/swap/submarine",
-        "GET"
-      ),
+      this.request("/v2/swap/submarine", "GET"),
       this.request("/v2/swap/reverse", "GET")
     ]);
     if (!isGetSubmarinePairsResponse(submarine))
@@ -344,10 +423,7 @@ var BoltzSwapProvider = class {
   }
   /** Returns current Lightning swap min/max limits from Boltz. */
   async getLimits() {
-    const response = await this.request(
-      "/v2/swap/submarine",
-      "GET"
-    );
+    const response = await this.request("/v2/swap/submarine", "GET");
     if (!isGetSubmarinePairsResponse(response))
       throw new SchemaError({ message: "error fetching limits" });
     return {
@@ -357,10 +433,7 @@ var BoltzSwapProvider = class {
   }
   /** Returns the current BTC chain tip height from Boltz. */
   async getChainHeight() {
-    const response = await this.request(
-      "/v2/chain/heights",
-      "GET"
-    );
+    const response = await this.request("/v2/chain/heights", "GET");
     if (typeof response?.BTC !== "number")
       throw new SchemaError({
         message: "error fetching chain heights"
@@ -390,10 +463,7 @@ var BoltzSwapProvider = class {
   async getSwapStatus(id) {
     let response;
     try {
-      response = await this.request(
-        `/v2/swap/${id}`,
-        "GET"
-      );
+      response = await this.request(`/v2/swap/${id}`, "GET");
     } catch (error) {
       if (error instanceof NetworkError && error.statusCode === 404 && isSwapNotFoundBody(error)) {
         throw new SwapNotFoundError(id, error.errorData);
@@ -489,12 +559,10 @@ var BoltzSwapProvider = class {
       throw new SwapError({ message: "Invalid 'to' chain" });
     if (["BTC", "ARK"].indexOf(from) === -1)
       throw new SwapError({ message: "Invalid 'from' chain" });
-    if (to === from)
-      throw new SwapError({ message: "Invalid swap direction" });
+    if (to === from) throw new SwapError({ message: "Invalid swap direction" });
     if (!preimageHash || preimageHash.length != 64)
       throw new SwapError({ message: "Invalid preimageHash" });
-    if (feeSatsPerByte <= 0)
-      throw new SwapError({ message: "Invalid feeSatsPerByte" });
+    if (feeSatsPerByte <= 0) throw new SwapError({ message: "Invalid feeSatsPerByte" });
     if (serverLockAmount !== void 0 && userLockAmount !== void 0 || serverLockAmount === void 0 && userLockAmount === void 0)
       throw new SwapError({
         message: "Either serverLockAmount or userLockAmount must be provided"
@@ -549,12 +617,8 @@ var BoltzSwapProvider = class {
         message: "Error refunding submarine swap"
       });
     return {
-      transaction: import_sdk.Transaction.fromPSBT(
-        import_base.base64.decode(response.transaction)
-      ),
-      checkpoint: import_sdk.Transaction.fromPSBT(
-        import_base.base64.decode(response.checkpoint)
-      )
+      transaction: import_sdk.Transaction.fromPSBT(import_base.base64.decode(response.transaction)),
+      checkpoint: import_sdk.Transaction.fromPSBT(import_base.base64.decode(response.checkpoint))
     };
   }
   /** Requests Boltz co-signature for a chain swap refund. Returns signed transaction + checkpoint. */
@@ -573,53 +637,53 @@ var BoltzSwapProvider = class {
         message: "Error refunding chain swap"
       });
     return {
-      transaction: import_sdk.Transaction.fromPSBT(
-        import_base.base64.decode(response.transaction)
-      ),
-      checkpoint: import_sdk.Transaction.fromPSBT(
-        import_base.base64.decode(response.checkpoint)
-      )
+      transaction: import_sdk.Transaction.fromPSBT(import_base.base64.decode(response.transaction)),
+      checkpoint: import_sdk.Transaction.fromPSBT(import_base.base64.decode(response.checkpoint))
     };
   }
-  /** Monitors swap status updates via WebSocket. Calls update callback on each status change. Resolves when terminal. */
+  /**
+   * Monitors swap status updates and forwards them to the update callback.
+   * Prefers a WebSocket subscription; on connection error or premature close
+   * it falls back to REST polling so callers don't fail when the WS endpoint
+   * is flaky (observed in CI). Resolves when the swap reaches a terminal
+   * status.
+   */
   async monitorSwap(swapId, update) {
     return new Promise((resolve, reject) => {
-      const webSocket = new globalThis.WebSocket(this.wsUrl);
-      const connectionTimeout = setTimeout(() => {
-        webSocket.close();
-        reject(new NetworkError("WebSocket connection timeout"));
-      }, 3e4);
-      webSocket.onerror = (error) => {
-        clearTimeout(connectionTimeout);
-        reject(
-          new NetworkError(
-            `WebSocket error: ${error.message}`
-          )
-        );
-      };
-      webSocket.onopen = () => {
-        clearTimeout(connectionTimeout);
-        webSocket.send(
-          JSON.stringify({
-            op: "subscribe",
-            channel: "swap.update",
-            args: [swapId]
-          })
-        );
+      let settled = false;
+      let lastStatus = null;
+      let pollTimer = null;
+      let webSocket = null;
+      let connectionTimeout = null;
+      const cleanup = () => {
+        if (connectionTimeout) {
+          clearTimeout(connectionTimeout);
+          connectionTimeout = null;
+        }
+        if (pollTimer) {
+          clearInterval(pollTimer);
+          pollTimer = null;
+        }
+        if (webSocket) {
+          try {
+            webSocket.close();
+          } catch {
+          }
+          webSocket = null;
+        }
       };
-      webSocket.onclose = () => {
-        clearTimeout(connectionTimeout);
-        resolve();
+      const finish = (err) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        if (err) reject(err);
+        else resolve();
       };
-      webSocket.onmessage = async (rawMsg) => {
-        const msg = JSON.parse(rawMsg.data);
-        if (msg.event !== "update" || msg.args[0].id !== swapId) return;
-        if (msg.args[0].error) {
-          webSocket.close();
-          reject(new SwapError({ message: msg.args[0].error }));
-        }
-        const status = msg.args[0].status;
-        const negotiable = status === "transaction.lockupFailed" && msg.args[0].failureDetails?.actual !== void 0 && msg.args[0].failureDetails?.expected !== void 0;
+      const handleStatus = (status, data) => {
+        if (settled) return;
+        if (status === lastStatus) return;
+        lastStatus = status;
+        const negotiable = status === "transaction.lockupFailed" && data?.failureDetails?.actual !== void 0 && data?.failureDetails?.expected !== void 0;
         switch (status) {
           case "invoice.settled":
           case "transaction.claimed":
@@ -628,13 +692,13 @@ var BoltzSwapProvider = class {
           case "invoice.failedToPay":
           case "transaction.failed":
           case "swap.expired":
-            webSocket.close();
-            update(status, msg.args[0]);
-            break;
+            update(status, data);
+            finish();
+            return;
           case "transaction.lockupFailed":
-            if (!negotiable) webSocket.close();
-            update(status, msg.args[0]);
-            break;
+            update(status, data);
+            if (!negotiable) finish();
+            return;
           case "invoice.paid":
           case "invoice.pending":
           case "invoice.set":
@@ -644,9 +708,77 @@ var BoltzSwapProvider = class {
           case "transaction.claim.pending":
           case "transaction.server.mempool":
           case "transaction.server.confirmed":
-            update(status, msg.args[0]);
+            update(status, data);
+            return;
         }
       };
+      const startPolling = () => {
+        if (settled || pollTimer) return;
+        const poll = async () => {
+          if (settled) return;
+          try {
+            const result = await this.getSwapStatus(swapId);
+            handleStatus(result.status, { ...result, id: swapId });
+          } catch {
+          }
+        };
+        pollTimer = setInterval(poll, 1e3);
+        poll();
+      };
+      try {
+        webSocket = new globalThis.WebSocket(this.wsUrl);
+        connectionTimeout = setTimeout(() => {
+          try {
+            webSocket?.close();
+          } catch {
+          }
+          webSocket = null;
+          startPolling();
+        }, 5e3);
+        webSocket.onerror = () => {
+          if (connectionTimeout) {
+            clearTimeout(connectionTimeout);
+            connectionTimeout = null;
+          }
+          webSocket = null;
+          startPolling();
+        };
+        webSocket.onopen = () => {
+          if (connectionTimeout) {
+            clearTimeout(connectionTimeout);
+            connectionTimeout = null;
+          }
+          webSocket?.send(
+            JSON.stringify({
+              op: "subscribe",
+              channel: "swap.update",
+              args: [swapId]
+            })
+          );
+        };
+        webSocket.onclose = () => {
+          if (connectionTimeout) {
+            clearTimeout(connectionTimeout);
+            connectionTimeout = null;
+          }
+          if (!settled && !pollTimer) startPolling();
+        };
+        webSocket.onmessage = (rawMsg) => {
+          try {
+            const msg = JSON.parse(rawMsg.data);
+            if (msg.event !== "update" || msg.args?.[0]?.id !== swapId) return;
+            if (msg.args[0].error) {
+              finish(new SwapError({ message: msg.args[0].error }));
+              return;
+            }
+            handleStatus(msg.args[0].status, msg.args[0]);
+          } catch {
+          }
+        };
+      } catch {
+        webSocket = null;
+        startPolling();
+      }
     });
   }
   /** Returns current chain swap fees for a given pair (e.g. ARK→BTC). */
@@ -654,10 +786,7 @@ var BoltzSwapProvider = class {
     if (from === to) {
       throw new SwapError({ message: "Invalid chain pair" });
     }
-    const response = await this.request(
-      "/v2/swap/chain",
-      "GET"
-    );
+    const response = await this.request("/v2/swap/chain", "GET");
     if (!isGetChainPairsResponse(response))
       throw new SchemaError({ message: "error fetching fees" });
     if (!response[from]?.[to]) {
@@ -672,10 +801,7 @@ var BoltzSwapProvider = class {
     if (from === to) {
       throw new SwapError({ message: "Invalid chain pair" });
     }
-    const response = await this.request(
-      "/v2/swap/chain",
-      "GET"
-    );
+    const response = await this.request("/v2/swap/chain", "GET");
     if (!isGetChainPairsResponse(response))
       throw new SchemaError({ message: "error fetching limits" });
     if (!response[from]?.[to]) {
@@ -804,9 +930,7 @@ var BoltzSwapProvider = class {
       return await response.json();
     } catch (error) {
       if (error instanceof NetworkError) throw error;
-      throw new NetworkError(
-        `Request to ${url} failed: ${error.message}`
-      );
+      throw new NetworkError(`Request to ${url} failed: ${error.message}`);
     }
   }
 };
@@ -828,8 +952,7 @@ var findKeyIndex = (keys, target) => keys.findIndex((k) => (0, import_utils.equa
 var assertPublicKeys = (keys) => {
   const seen = /* @__PURE__ */ new Set();
   for (const key of keys) {
-    if (key.length !== 33)
-      throw new Error(`public key must be 33 bytes, got ${key.length}`);
+    if (key.length !== 33) throw new Error(`public key must be 33 bytes, got ${key.length}`);
     const enc = import_base2.hex.encode(key);
     if (seen.has(enc)) throw new Error(`duplicate public key ${enc}`);
     seen.add(enc);
@@ -837,9 +960,7 @@ var assertPublicKeys = (keys) => {
 };
 var aggregateKeys = (publicKeys, tweak) => {
   assertPublicKeys([...publicKeys]);
-  return (0, import_musig2.keyAggExport)(
-    (0, import_musig2.keyAggregate)([...publicKeys], tweak ? [tweak] : [], tweak ? [true] : [])
-  );
+  return (0, import_musig2.keyAggExport)((0, import_musig2.keyAggregate)([...publicKeys], tweak ? [tweak] : [], tweak ? [true] : []));
 };
 var MusigKeyAgg = class _MusigKeyAgg {
   constructor(privateKey, myPublicKey, publicKeys, myIndex, aggPubkey, internalKey, _tweak) {
@@ -886,18 +1007,12 @@ var MusigWithMessage = class {
     this.msg = msg;
   }
   generateNonce() {
-    const nonce = (0, import_musig2.nonceGen)(
-      this.myPublicKey,
-      this.privateKey,
-      this.aggPubkey,
-      this.msg
-    );
+    const nonce = (0, import_musig2.nonceGen)(this.myPublicKey, this.privateKey, this.aggPubkey, this.msg);
     return new MusigWithNonce(
       this.privateKey,
       this.myPublicKey,
       this.publicKeys,
       this.myIndex,
-      this.aggPubkey,
       this.tweak,
       this.msg,
       nonce
@@ -905,12 +1020,11 @@ var MusigWithMessage = class {
   }
 };
 var MusigWithNonce = class {
-  constructor(privateKey, myPublicKey, publicKeys, myIndex, aggPubkey, tweak, msg, nonce) {
+  constructor(privateKey, myPublicKey, publicKeys, myIndex, tweak, msg, nonce) {
     this.privateKey = privateKey;
     this.myPublicKey = myPublicKey;
     this.publicKeys = publicKeys;
     this.myIndex = myIndex;
-    this.aggPubkey = aggPubkey;
     this.tweak = tweak;
     this.msg = msg;
     this.nonce = nonce;
@@ -942,10 +1056,8 @@ var MusigWithNonce = class {
     const aggregatedNonce = (0, import_musig2.nonceAggregate)([...ordered]);
     return new MusigNoncesAggregated(
       this.privateKey,
-      this.myPublicKey,
       this.publicKeys,
       this.myIndex,
-      this.aggPubkey,
       this.tweak,
       this.msg,
       this.nonce,
@@ -955,12 +1067,10 @@ var MusigWithNonce = class {
   }
 };
 var MusigNoncesAggregated = class {
-  constructor(privateKey, myPublicKey, publicKeys, myIndex, aggPubkey, tweak, msg, nonce, pubNonces, aggregatedNonce) {
+  constructor(privateKey, publicKeys, myIndex, tweak, msg, nonce, pubNonces, aggregatedNonce) {
     this.privateKey = privateKey;
-    this.myPublicKey = myPublicKey;
     this.publicKeys = publicKeys;
     this.myIndex = myIndex;
-    this.aggPubkey = aggPubkey;
     this.tweak = tweak;
     this.msg = msg;
     this.nonce = nonce;
@@ -1006,11 +1116,7 @@ var MusigSession = class {
     const index = typeof publicKeyOrIndex === "number" ? publicKeyOrIndex : findKeyIndex(this.publicKeys, publicKeyOrIndex);
     if (index < 0 || index >= this.publicKeys.length)
       throw new Error("public key not found or index out of range");
-    if (!this.session.partialSigVerify(
-      signature,
-      [...this.pubNonces],
-      index
-    )) {
+    if (!this.session.partialSigVerify(signature, [...this.pubNonces], index)) {
       throw new Error("invalid partial signature");
     }
     this.partialSignatures[index] = signature;
@@ -1019,12 +1125,7 @@ var MusigSession = class {
   signPartial() {
     const sig = this.session.sign(this.nonce.secret, this.privateKey, true);
     this.partialSignatures[this.myIndex] = sig;
-    return new MusigSigned(
-      this.session,
-      [...this.partialSignatures],
-      sig,
-      this.nonce.public
-    );
+    return new MusigSigned(this.session, [...this.partialSignatures], sig, this.nonce.public);
   }
 };
 var MusigSigned = class {
@@ -1038,14 +1139,11 @@ var MusigSigned = class {
     if (this.partialSignatures.some((s) => s === null)) {
       throw new Error("not all partial signatures are set");
     }
-    return this.session.partialSigAgg(
-      this.partialSignatures
-    );
+    return this.session.partialSigAgg(this.partialSignatures);
   }
 };
 var create = (privateKey, publicKeys) => {
-  if (publicKeys.length < 2)
-    throw new Error("need at least 2 keys to aggregate");
+  if (publicKeys.length < 2) throw new Error("need at least 2 keys to aggregate");
   const keys = [...publicKeys];
   assertPublicKeys(keys);
   Object.freeze(keys);
@@ -1053,14 +1151,7 @@ var create = (privateKey, publicKeys) => {
   const myIndex = findKeyIndex(keys, myPublicKey);
   if (myIndex === -1) throw new Error("our key is not in publicKeys");
   const aggPubkey = aggregateKeys(keys);
-  return new MusigKeyAgg(
-    privateKey,
-    myPublicKey,
-    keys,
-    myIndex,
-    aggPubkey,
-    aggPubkey
-  );
+  return new MusigKeyAgg(privateKey, myPublicKey, keys, myIndex, aggPubkey, aggPubkey);
 };
 
 // src/utils/boltz-swap-tx.ts
@@ -1136,9 +1227,7 @@ var taprootHashTree = (tree) => {
 };
 var tweakMusig = (musig, tree) => {
   const tweak = taprootHashTree(tree).hash;
-  return musig.xonlyTweakAdd(
-    import_secp256k12.schnorr.utils.taggedHash("TapTweak", musig.aggPubkey, tweak)
-  );
+  return musig.xonlyTweakAdd(import_secp256k12.schnorr.utils.taggedHash("TapTweak", musig.aggPubkey, tweak));
 };
 var toXOnly = (pubKey) => {
   if (pubKey.length === 32) return pubKey;
@@ -1150,9 +1239,7 @@ var toXOnly = (pubKey) => {
     }
     return pubKey.subarray(1, 33);
   }
-  throw new Error(
-    `Invalid public key length: expected 32 or 33 bytes, got ${pubKey.length}`
-  );
+  throw new Error(`Invalid public key length: expected 32 or 33 bytes, got ${pubKey.length}`);
 };
 var p2trScript = (publicKey) => import_btc_signer.Script.encode(["OP_1", toXOnly(publicKey)]);
 var detectSwapOutput = (tweakedKey, transaction) => {
@@ -1167,8 +1254,7 @@ var detectSwapOutput = (tweakedKey, transaction) => {
 };
 var DUMMY_TAPROOT_SIGNATURE = new Uint8Array(64);
 var constructClaimTransaction = (utxo, destinationScript, fee) => {
-  if (fee < BigInt(0) || fee >= utxo.amount)
-    throw new Error("fee exceeds utxo amount");
+  if (fee < BigInt(0) || fee >= utxo.amount) throw new Error("fee exceeds utxo amount");
   const tx = new import_btc_signer.Transaction({ version: 2 });
   tx.addOutput({
     amount: utxo.amount - fee,
@@ -1187,9 +1273,7 @@ var constructClaimTransaction = (utxo, destinationScript, fee) => {
 };
 var targetFee = (satPerVbyte, constructTx) => {
   const tx = constructTx(BigInt(1));
-  return constructTx(
-    BigInt(Math.ceil((tx.vsize + tx.inputsLength) * satPerVbyte))
-  );
+  return constructTx(BigInt(Math.ceil((tx.vsize + tx.inputsLength) * satPerVbyte)));
 };
 
 // src/utils/decoding.ts
@@ -1197,9 +1281,7 @@ var import_light_bolt11_decoder = __toESM(require("light-bolt11-decoder"), 1);
 var import_sdk2 = require("@arkade-os/sdk");
 var decodeInvoice = (invoice) => {
   const decoded = import_light_bolt11_decoder.default.decode(invoice);
-  const millisats = Number(
-    decoded.sections.find((s) => s.name === "amount")?.value ?? "0"
-  );
+  const millisats = Number(decoded.sections.find((s) => s.name === "amount")?.value ?? "0");
   return {
     expiry: decoded.expiry ?? 3600,
     amountSats: Math.floor(millisats / 1e3),
@@ -1262,10 +1344,7 @@ function extractTimeLockFromLeafOutput(scriptHex) {
       const data = opcodes[hasCSV - 1];
       if (data instanceof Uint8Array) {
         const dataBytes = new Uint8Array(data).reverse();
-        const {
-          blocks,
-          seconds
-        } = import_bip68.default.decode(
+        const { blocks, seconds } = import_bip68.default.decode(
           parseInt(import_base5.hex.encode(dataBytes), 16)
         );
         return blocks ?? seconds ?? 0;
@@ -1298,6 +1377,13 @@ var SwapManager = class _SwapManager {
    * enough that a real "swap unknown to this provider" surfaces quickly.
    */
   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.
+   */
+  static REFUND_RETRY_DELAY_MS = 6e4;
   swapProvider;
   config;
   // Event listeners storage (supports multiple listeners per event)
@@ -1316,6 +1402,11 @@ 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.
+  refundRetryTimers = /* @__PURE__ */ new Map();
   // Per-swap counter of consecutive `SwapNotFoundError` responses from
   // `getSwapStatus`. Reset on any successful poll. Once a swap reaches
   // `NOT_FOUND_THRESHOLD` consecutive 404s the safety net trips and the
@@ -1369,9 +1460,7 @@ var SwapManager = class _SwapManager {
       this.wsConnectedListeners.add(config.events.onWebSocketConnected);
     }
     if (config.events?.onWebSocketDisconnected) {
-      this.wsDisconnectedListeners.add(
-        config.events.onWebSocketDisconnected
-      );
+      this.wsDisconnectedListeners.add(config.events.onWebSocketDisconnected);
     }
     this.currentReconnectDelay = this.config.reconnectDelayMs;
     this.currentPollRetryDelay = this.config.pollRetryDelayMs;
@@ -1514,6 +1603,10 @@ var SwapManager = class _SwapManager {
       clearTimeout(timer);
     }
     this.pollRetryTimers.clear();
+    for (const timer of this.refundRetryTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.refundRetryTimers.clear();
     this.notFoundCounts.clear();
   }
   /**
@@ -1522,9 +1615,7 @@ var SwapManager = class _SwapManager {
    */
   setPollInterval(ms) {
     if (ms <= 0) {
-      throw new RangeError(
-        `setPollInterval: ms must be a positive number, got ${ms}`
-      );
+      throw new RangeError(`setPollInterval: ms must be a positive number, got ${ms}`);
     }
     const cappedInterval = Math.min(ms, this.config.maxPollIntervalMs);
     if (cappedInterval !== ms) {
@@ -1533,10 +1624,7 @@ var SwapManager = class _SwapManager {
       );
     }
     this.config.pollInterval = cappedInterval;
-    this.currentPollRetryDelay = Math.min(
-      cappedInterval,
-      this.config.pollRetryDelayMs
-    );
+    this.currentPollRetryDelay = Math.min(cappedInterval, this.config.pollRetryDelayMs);
     if (this.isRunning) {
       if (this.usePollingFallback) {
         this.startPollingFallback();
@@ -1575,6 +1663,11 @@ var SwapManager = class _SwapManager {
       clearTimeout(retryTimer);
       this.pollRetryTimers.delete(swapId);
     }
+    const refundRetryTimer = this.refundRetryTimers.get(swapId);
+    if (refundRetryTimer) {
+      clearTimeout(refundRetryTimer);
+      this.refundRetryTimers.delete(swapId);
+    }
     this.notFoundCounts.delete(swapId);
     logger.log(`Removed swap ${swapId} from monitoring`);
   }
@@ -1621,9 +1714,7 @@ var SwapManager = class _SwapManager {
     }
     if (this.isFinalStatus(swap)) {
       if (isPendingReverseSwap(swap)) {
-        const response = await this.swapProvider.getReverseSwapTxId(
-          swap.id
-        );
+        const response = await this.swapProvider.getReverseSwapTxId(swap.id);
         return { txid: response.id };
       }
       if (isPendingSubmarineSwap(swap)) {
@@ -1640,31 +1731,19 @@ var SwapManager = class _SwapManager {
           if (updatedSwap.status === "invoice.settled") {
             this.swapProvider.getReverseSwapTxId(updatedSwap.id).then((response) => resolve({ txid: response.id })).catch((error) => reject(error));
           } else {
-            reject(
-              new Error(
-                `Swap failed with status: ${updatedSwap.status}`
-              )
-            );
+            reject(new Error(`Swap failed with status: ${updatedSwap.status}`));
           }
         } else if (isPendingSubmarineSwap(updatedSwap)) {
           if (updatedSwap.status === "transaction.claimed") {
             resolve({ txid: updatedSwap.id });
           } else {
-            reject(
-              new Error(
-                `Swap failed with status: ${updatedSwap.status}`
-              )
-            );
+            reject(new Error(`Swap failed with status: ${updatedSwap.status}`));
           }
         } else if (isPendingChainSwap(updatedSwap)) {
           if (updatedSwap.status === "transaction.claimed") {
             resolve({ txid: updatedSwap.id });
           } else {
-            reject(
-              new Error(
-                `Swap failed with status: ${updatedSwap.status}`
-              )
-            );
+            reject(new Error(`Swap failed with status: ${updatedSwap.status}`));
           }
         }
       };
@@ -1707,16 +1786,12 @@ var SwapManager = class _SwapManager {
       const connectionTimeout = setTimeout(() => {
         logger.error("WebSocket connection timeout");
         this.websocket?.close();
-        this.enterPollingFallback(
-          new NetworkError("WebSocket connection failed")
-        );
+        this.enterPollingFallback(new NetworkError("WebSocket connection failed"));
       }, 1e4);
       this.websocket.onerror = (error) => {
         clearTimeout(connectionTimeout);
         logger.error("WebSocket error:", error);
-        this.enterPollingFallback(
-          new NetworkError("WebSocket connection failed")
-        );
+        this.enterPollingFallback(new NetworkError("WebSocket connection failed"));
       };
       this.websocket.onopen = () => {
         clearTimeout(connectionTimeout);
@@ -1756,9 +1831,7 @@ var SwapManager = class _SwapManager {
       };
     } catch (error) {
       logger.error("Failed to create WebSocket:", error);
-      this.enterPollingFallback(
-        new NetworkError("WebSocket connection failed")
-      );
+      this.enterPollingFallback(new NetworkError("WebSocket connection failed"));
     }
   }
   /**
@@ -1793,11 +1866,8 @@ var SwapManager = class _SwapManager {
    * Schedule WebSocket reconnection with exponential backoff
    */
   scheduleReconnect() {
-    if (this.reconnectTimer || this.webSocketUnavailable || !this.hasWebSocketSupport())
-      return;
-    logger.log(
-      `Scheduling WebSocket reconnect in ${this.currentReconnectDelay}ms`
-    );
+    if (this.reconnectTimer || this.webSocketUnavailable || !this.hasWebSocketSupport()) return;
+    logger.log(`Scheduling WebSocket reconnect in ${this.currentReconnectDelay}ms`);
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.isReconnecting = false;
@@ -1812,8 +1882,7 @@ var SwapManager = class _SwapManager {
    * Subscribe to a specific swap ID on the WebSocket
    */
   subscribeToSwap(swapId) {
-    if (!this.websocket || this.websocket.readyState !== WebSocket.OPEN)
-      return;
+    if (!this.websocket || this.websocket.readyState !== WebSocket.OPEN) return;
     this.websocket.send(
       JSON.stringify({
         op: "subscribe",
@@ -1836,9 +1905,7 @@ var SwapManager = class _SwapManager {
       if (msg.args[0].error) {
         logger.error(`Swap ${swapId} error:`, msg.args[0].error);
         const error = new Error(msg.args[0].error);
-        this.swapFailedListeners.forEach(
-          (listener) => listener(swap, error)
-        );
+        this.swapFailedListeners.forEach((listener) => listener(swap, error));
         return;
       }
       const newStatus = msg.args[0].status;
@@ -1856,19 +1923,14 @@ var SwapManager = class _SwapManager {
     const oldStatus = swap.status;
     if (oldStatus === newStatus) return;
     swap.status = newStatus;
-    this.swapUpdateListeners.forEach(
-      (listener) => listener(swap, oldStatus)
-    );
+    this.swapUpdateListeners.forEach((listener) => listener(swap, oldStatus));
     const subscribers = this.swapSubscriptions.get(swap.id);
     if (subscribers) {
       subscribers.forEach((callback) => {
         try {
           callback(swap, oldStatus);
         } catch (error) {
-          logger.error(
-            `Error in swap subscription callback for ${swap.id}:`,
-            error
-          );
+          logger.error(`Error in swap subscription callback for ${swap.id}:`, error);
         }
       });
     }
@@ -1877,15 +1939,57 @@ var SwapManager = class _SwapManager {
       await this.executeAutonomousAction(swap);
     }
     if (this.isFinalStatus(swap)) {
-      this.monitoredSwaps.delete(swap.id);
-      this.swapSubscriptions.delete(swap.id);
-      const retryTimer = this.pollRetryTimers.get(swap.id);
-      if (retryTimer) {
-        clearTimeout(retryTimer);
-        this.pollRetryTimers.delete(swap.id);
+      if (this.refundRetryTimers.has(swap.id)) {
+        return;
       }
-      this.swapCompletedListeners.forEach((listener) => listener(swap));
+      this.finalizeMonitoredSwap(swap);
+    }
+  }
+  /**
+   * Drop a swap from monitoring and emit the terminal completion event.
+   * Shared between the on-status-update finalization path and the
+   * refund-retry finalization path (used when a previously-deferred
+   * chain refund has finished its remaining work).
+   */
+  finalizeMonitoredSwap(swap) {
+    if (!this.monitoredSwaps.has(swap.id)) return;
+    this.monitoredSwaps.delete(swap.id);
+    this.swapSubscriptions.delete(swap.id);
+    const retryTimer = this.pollRetryTimers.get(swap.id);
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+      this.pollRetryTimers.delete(swap.id);
+    }
+    const refundRetry = this.refundRetryTimers.get(swap.id);
+    if (refundRetry) {
+      clearTimeout(refundRetry);
+      this.refundRetryTimers.delete(swap.id);
     }
+    this.swapCompletedListeners.forEach((listener) => listener(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.
+   */
+  scheduleRefundRetry(swap, delayMs) {
+    const existing = this.refundRetryTimers.get(swap.id);
+    if (existing) clearTimeout(existing);
+    this.refundRetryTimers.set(
+      swap.id,
+      setTimeout(async () => {
+        this.refundRetryTimers.delete(swap.id);
+        if (!this.isRunning) return;
+        if (!this.monitoredSwaps.has(swap.id)) return;
+        try {
+          await this.executeAutonomousAction(swap);
+        } finally {
+          if (!this.refundRetryTimers.has(swap.id) && this.isFinalStatus(swap)) {
+            this.finalizeMonitoredSwap(swap);
+          }
+        }
+      }, delayMs)
+    );
   }
   /**
    * Execute autonomous action based on swap status
@@ -1893,9 +1997,7 @@ var SwapManager = class _SwapManager {
    */
   async executeAutonomousAction(swap) {
     if (this.swapsInProgress.has(swap.id)) {
-      logger.log(
-        `Swap ${swap.id} is already being processed, skipping autonomous action`
-      );
+      logger.log(`Swap ${swap.id} is already being processed, skipping autonomous action`);
       return;
     }
     try {
@@ -1910,9 +2012,7 @@ var SwapManager = class _SwapManager {
         if (isReverseClaimableStatus(swap.status)) {
           logger.log(`Auto-claiming reverse swap ${swap.id}`);
           await this.executeClaimAction(swap);
-          this.actionExecutedListeners.forEach(
-            (listener) => listener(swap, "claim")
-          );
+          this.actionExecutedListeners.forEach((listener) => listener(swap, "claim"));
         }
       } else if (isPendingSubmarineSwap(swap)) {
         if (!swap.request?.invoice || swap.request.invoice.length === 0) {
@@ -1924,9 +2024,7 @@ var SwapManager = class _SwapManager {
         if (isSubmarineRefundableStatus(swap.status)) {
           logger.log(`Auto-refunding submarine swap ${swap.id}`);
           await this.executeRefundAction(swap);
-          this.actionExecutedListeners.forEach(
-            (listener) => listener(swap, "refund")
-          );
+          this.actionExecutedListeners.forEach((listener) => listener(swap, "refund"));
         }
       } else if (isPendingChainSwap(swap)) {
         if (isChainClaimableStatus(swap.status)) {
@@ -1946,10 +2044,27 @@ var SwapManager = class _SwapManager {
         } else if (isChainRefundableStatus(swap.status)) {
           if (swap.request.from === "ARK") {
             logger.log(`Auto-refunding ARK chain swap ${swap.id}`);
-            await this.executeRefundArkAction(swap);
-            this.actionExecutedListeners.forEach(
-              (listener) => listener(swap, "refundArk")
-            );
+            try {
+              const outcome = await this.executeRefundArkAction(swap);
+              if (outcome && outcome.skipped > 0) {
+                logger.log(
+                  `Chain swap ${swap.id}: ${outcome.skipped} VTXO(s) deferred \u2014 scheduling refund retry`
+                );
+                this.scheduleRefundRetry(swap, _SwapManager.REFUND_RETRY_DELAY_MS);
+              }
+              this.actionExecutedListeners.forEach(
+                (listener) => listener(swap, "refundArk")
+              );
+            } catch (error) {
+              logger.error(
+                `Auto-refunding ARK chain swap ${swap.id} failed; scheduling retry`,
+                error
+              );
+              this.swapFailedListeners.forEach(
+                (listener) => listener(swap, error)
+              );
+              this.scheduleRefundRetry(swap, _SwapManager.REFUND_RETRY_DELAY_MS);
+            }
           }
           if (swap.request.from === "BTC") {
             logger.warn(
@@ -1976,13 +2091,8 @@ var SwapManager = class _SwapManager {
         }
       }
     } catch (error) {
-      logger.error(
-        `Failed to execute autonomous action for swap ${swap.id}:`,
-        error
-      );
-      this.swapFailedListeners.forEach(
-        (listener) => listener(swap, error)
-      );
+      logger.error(`Failed to execute autonomous action for swap ${swap.id}:`, error);
+      this.swapFailedListeners.forEach((listener) => listener(swap, error));
     } finally {
       this.swapsInProgress.delete(swap.id);
     }
@@ -2035,7 +2145,7 @@ var SwapManager = class _SwapManager {
       logger.error("refundArk callback not set");
       return;
     }
-    await this.refundArkCallback(swap);
+    return this.refundArkCallback(swap);
   }
   /**
    * Execute sign server claim action for chain swap.
@@ -2083,9 +2193,7 @@ var SwapManager = class _SwapManager {
           logger.log(`Resuming chain refund for swap ${swap.id}`);
           await this.executeAutonomousAction(swap);
         } else if (isPendingChainSwap(swap) && swap.request.to === "ARK" && isChainSignableStatus(swap.status)) {
-          logger.log(
-            `Resuming server claim signing for swap ${swap.id}`
-          );
+          logger.log(`Resuming server claim signing for swap ${swap.id}`);
           await this.executeAutonomousAction(swap);
         }
       } catch (error) {
@@ -2137,16 +2245,12 @@ var SwapManager = class _SwapManager {
    */
   async pollAllSwaps() {
     if (this.monitoredSwaps.size === 0) return;
-    const pollPromises = Array.from(this.monitoredSwaps.values()).map(
-      (swap) => this.pollSingleSwap(swap)
-    );
+    const pollPromises = Array.from(this.monitoredSwaps.values()).filter((swap) => !this.refundRetryTimers.has(swap.id)).map((swap) => this.pollSingleSwap(swap));
     await Promise.allSettled(pollPromises);
   }
   async pollSingleSwap(swap) {
     try {
-      const statusResponse = await this.swapProvider.getSwapStatus(
-        swap.id
-      );
+      const statusResponse = await this.swapProvider.getSwapStatus(swap.id);
       this.notFoundCounts.delete(swap.id);
       if (statusResponse.status !== swap.status) {
         await this.handleSwapStatusUpdate(swap, statusResponse.status);
@@ -2157,9 +2261,7 @@ var SwapManager = class _SwapManager {
         return;
       }
       if (error instanceof NetworkError && error.statusCode === 429) {
-        logger.warn(
-          `Rate-limited polling swap ${swap.id}, retrying in 2s`
-        );
+        logger.warn(`Rate-limited polling swap ${swap.id}, retrying in 2s`);
         const existing = this.pollRetryTimers.get(swap.id);
         if (existing) clearTimeout(existing);
         this.pollRetryTimers.set(
@@ -2167,25 +2269,17 @@ var SwapManager = class _SwapManager {
           setTimeout(async () => {
             this.pollRetryTimers.delete(swap.id);
             try {
-              const retry = await this.swapProvider.getSwapStatus(
-                swap.id
-              );
+              const retry = await this.swapProvider.getSwapStatus(swap.id);
               this.notFoundCounts.delete(swap.id);
               if (retry.status !== swap.status) {
-                await this.handleSwapStatusUpdate(
-                  swap,
-                  retry.status
-                );
+                await this.handleSwapStatusUpdate(swap, retry.status);
               }
             } catch (retryError) {
               if (retryError instanceof SwapNotFoundError) {
                 await this.handleSwapNotFound(swap);
                 return;
               }
-              logger.error(
-                `Retry poll for swap ${swap.id} also failed:`,
-                retryError
-              );
+              logger.error(`Retry poll for swap ${swap.id} also failed:`, retryError);
             }
           }, 2e3)
         );
@@ -2204,6 +2298,7 @@ var SwapManager = class _SwapManager {
    * Boltz endpoint).
    */
   async handleSwapNotFound(swap) {
+    if (this.refundRetryTimers.has(swap.id)) return;
     const count = (this.notFoundCounts.get(swap.id) ?? 0) + 1;
     this.notFoundCounts.set(swap.id, count);
     logger.warn(
@@ -2224,6 +2319,7 @@ var SwapManager = class _SwapManager {
    * 404s without recovering anything.
    */
   async markSwapAsUnknownToProvider(swap) {
+    if (this.refundRetryTimers.has(swap.id)) return;
     if (!this.monitoredSwaps.has(swap.id)) {
       this.notFoundCounts.delete(swap.id);
       return;
@@ -2236,10 +2332,13 @@ var SwapManager = class _SwapManager {
       clearTimeout(retryTimer);
       this.pollRetryTimers.delete(swap.id);
     }
+    const refundRetryTimer = this.refundRetryTimers.get(swap.id);
+    if (refundRetryTimer) {
+      clearTimeout(refundRetryTimer);
+      this.refundRetryTimers.delete(swap.id);
+    }
     this.notFoundCounts.delete(swap.id);
-    this.swapUpdateListeners.forEach(
-      (listener) => listener(swap, oldStatus)
-    );
+    this.swapUpdateListeners.forEach((listener) => listener(swap, oldStatus));
     const subscribers = this.swapSubscriptions.get(swap.id);
     if (subscribers) {
       subscribers.forEach((callback) => {
@@ -2304,9 +2403,7 @@ async function saveSwap(swap, saver) {
     if (saver.saveSubmarineSwap) {
       await saver.saveSubmarineSwap(swap);
     } else {
-      console.warn(
-        "No saveSubmarineSwap handler provided, swap not saved"
-      );
+      console.warn("No saveSubmarineSwap handler provided, swap not saved");
     }
   } else if (isPendingChainSwap(swap)) {
     if (saver.saveChainSwap) {
@@ -2363,6 +2460,26 @@ function enrichSubmarineSwapInvoice(swap, invoice) {
   return swap;
 }
 
+// src/repositories/swap-repository.ts
+function hasImpossibleSwapsFilter(filter) {
+  if (!filter) return false;
+  return Array.isArray(filter.id) && filter.id.length === 0 || Array.isArray(filter.status) && filter.status.length === 0 || Array.isArray(filter.type) && filter.type.length === 0;
+}
+function matchesCriterion(value, criterion) {
+  if (criterion === void 0) return true;
+  return Array.isArray(criterion) ? criterion.includes(value) : value === criterion;
+}
+function applySwapsFilter(swaps, filter) {
+  return swaps.filter(
+    (swap) => !!swap && matchesCriterion(swap.id, filter.id) && matchesCriterion(swap.status, filter.status) && matchesCriterion(swap.type, filter.type)
+  );
+}
+function applyCreatedAtOrder(swaps, filter) {
+  if (filter?.orderBy !== "createdAt") return swaps;
+  const direction = filter.orderDirection === "asc" ? 1 : -1;
+  return swaps.slice().sort((a, b) => (a.createdAt - b.createdAt) * direction);
+}
+
 // src/repositories/IndexedDb/swap-repository.ts
 var import_sdk4 = require("@arkade-os/sdk");
 var DEFAULT_DB_NAME = "arkade-boltz-swap";
@@ -2378,6 +2495,10 @@ function initDatabase(db) {
     swapStore.createIndex("createdAt", "createdAt", { unique: false });
   }
 }
+function asArray(v) {
+  if (v === void 0) return void 0;
+  return Array.isArray(v) ? v : [v];
+}
 var IndexedDbSwapRepository = class {
   constructor(dbName = DEFAULT_DB_NAME) {
     this.dbName = dbName;
@@ -2392,10 +2513,7 @@ var IndexedDbSwapRepository = class {
   async saveSwap(swap) {
     const db = await this.getDB();
     return new Promise((resolve, reject) => {
-      const transaction = db.transaction(
-        [STORE_SWAPS_STATE],
-        "readwrite"
-      );
+      const transaction = db.transaction([STORE_SWAPS_STATE], "readwrite");
       const store = transaction.objectStore(STORE_SWAPS_STATE);
       const request = store.put(swap);
       request.onsuccess = () => resolve();
@@ -2405,10 +2523,7 @@ var IndexedDbSwapRepository = class {
   async deleteSwap(id) {
     const db = await this.getDB();
     return new Promise((resolve, reject) => {
-      const transaction = db.transaction(
-        [STORE_SWAPS_STATE],
-        "readwrite"
-      );
+      const transaction = db.transaction([STORE_SWAPS_STATE], "readwrite");
       const store = transaction.objectStore(STORE_SWAPS_STATE);
       const request = store.delete(id);
       request.onsuccess = () => resolve();
@@ -2421,10 +2536,7 @@ var IndexedDbSwapRepository = class {
   async clear() {
     const db = await this.getDB();
     return new Promise((resolve, reject) => {
-      const transaction = db.transaction(
-        [STORE_SWAPS_STATE],
-        "readwrite"
-      );
+      const transaction = db.transaction([STORE_SWAPS_STATE], "readwrite");
       const store = transaction.objectStore(STORE_SWAPS_STATE);
       const request = store.clear();
       request.onsuccess = () => resolve();
@@ -2441,11 +2553,10 @@ var IndexedDbSwapRepository = class {
         request.onsuccess = () => resolve(request.result ?? []);
       })
     );
-    return Promise.all(requests).then(
-      (results) => results.flatMap((result) => result)
-    );
+    return Promise.all(requests).then((results) => results.flatMap((result) => result));
   }
   async getAllSwapsFromStore(filter) {
+    if (hasImpossibleSwapsFilter(filter)) return [];
     const db = await this.getDB();
     const store = db.transaction([STORE_SWAPS_STATE], "readonly").objectStore(STORE_SWAPS_STATE);
     if (!filter || Object.keys(filter).length === 0) {
@@ -2455,9 +2566,8 @@ var IndexedDbSwapRepository = class {
         request.onerror = () => reject(request.error);
       });
     }
-    const normalizedFilter = normalizeFilter(filter);
-    if (normalizedFilter.has("id")) {
-      const ids = normalizedFilter.get("id");
+    const ids = asArray(filter.id);
+    if (ids) {
       const swaps = await Promise.all(
         ids.map(
           (id) => new Promise((resolve, reject) => {
@@ -2467,34 +2577,17 @@ var IndexedDbSwapRepository = class {
           })
         )
       );
-      return this.sortIfNeeded(
-        this.applySwapsFilter(swaps, normalizedFilter),
-        filter
-      );
+      return applyCreatedAtOrder(applySwapsFilter(swaps, filter), filter);
     }
-    if (normalizedFilter.has("type")) {
-      const types = normalizedFilter.get("type");
-      const swaps = await this.getSwapsByIndexValues(
-        store,
-        "type",
-        types
-      );
-      return this.sortIfNeeded(
-        this.applySwapsFilter(swaps, normalizedFilter),
-        filter
-      );
+    const types = asArray(filter.type);
+    if (types) {
+      const swaps = await this.getSwapsByIndexValues(store, "type", types);
+      return applyCreatedAtOrder(applySwapsFilter(swaps, filter), filter);
     }
-    if (normalizedFilter.has("status")) {
-      const ids = normalizedFilter.get("status");
-      const swaps = await this.getSwapsByIndexValues(
-        store,
-        "status",
-        ids
-      );
-      return this.sortIfNeeded(
-        this.applySwapsFilter(swaps, normalizedFilter),
-        filter
-      );
+    const statuses = asArray(filter.status);
+    if (statuses) {
+      const swaps = await this.getSwapsByIndexValues(store, "status", statuses);
+      return applyCreatedAtOrder(applySwapsFilter(swaps, filter), filter);
     }
     if (filter.orderBy === "createdAt") {
       return this.getAllSwapsByCreatedAt(store, filter.orderDirection);
@@ -2504,22 +2597,7 @@ var IndexedDbSwapRepository = class {
       request.onsuccess = () => resolve(request.result ?? []);
       request.onerror = () => reject(request.error);
     });
-    return this.sortIfNeeded(
-      this.applySwapsFilter(allSwaps, normalizedFilter),
-      filter
-    );
-  }
-  applySwapsFilter(swaps, filter) {
-    return swaps.filter((swap) => {
-      if (swap === void 0) return false;
-      if (filter.has("id") && !filter.get("id")?.includes(swap.id))
-        return false;
-      if (filter.has("status") && !filter.get("status")?.includes(swap.status))
-        return false;
-      if (filter.has("type") && !filter.get("type")?.includes(swap.type))
-        return false;
-      return true;
-    });
+    return applyCreatedAtOrder(applySwapsFilter(allSwaps, filter), filter);
   }
   async getAllSwapsByCreatedAt(store, orderDirection) {
     const index = store.index("createdAt");
@@ -2539,30 +2617,12 @@ var IndexedDbSwapRepository = class {
       };
     });
   }
-  sortIfNeeded(swaps, filter) {
-    if (filter?.orderBy !== "createdAt") return swaps;
-    const direction = filter.orderDirection === "asc" ? 1 : -1;
-    return swaps.slice().sort((a, b) => (a.createdAt - b.createdAt) * direction);
-  }
   async [Symbol.asyncDispose]() {
     if (!this.db) return;
     await (0, import_sdk4.closeDatabase)(this.dbName);
     this.db = null;
   }
 };
-var FILTER_FIELDS = ["id", "status", "type"];
-function normalizeFilter(filter) {
-  const res = /* @__PURE__ */ new Map();
-  FILTER_FIELDS.forEach((current) => {
-    if (!filter?.[current]) return;
-    if (Array.isArray(filter[current])) {
-      res.set(current, filter[current]);
-    } else {
-      res.set(current, [filter[current]]);
-    }
-  });
-  return res;
-}
 
 // src/utils/identity.ts
 var import_sdk5 = require("@arkade-os/sdk");
@@ -2574,13 +2634,8 @@ function claimVHTLCIdentity(identity, preimage) {
       let signedTx = await identity.sign(cpy, inputIndexes);
       signedTx = import_sdk5.Transaction.fromPSBT(signedTx.toPSBT());
       if (preimage) {
-        for (const inputIndex of inputIndexes || Array.from(
-          { length: signedTx.inputsLength },
-          (_, i) => i
-        )) {
-          (0, import_sdk5.setArkPsbtField)(signedTx, inputIndex, import_sdk5.ConditionWitness, [
-            preimage
-          ]);
+        for (const inputIndex of inputIndexes || Array.from({ length: signedTx.inputsLength }, (_, i) => i)) {
+          (0, import_sdk5.setArkPsbtField)(signedTx, inputIndex, import_sdk5.ConditionWitness, [preimage]);
         }
       }
       return signedTx;
@@ -2635,17 +2690,13 @@ function createVHTLCBatchHandler(intentId, vhtlc, arkProvider, identity, session
       if (!sweepTapTreeRoot) {
         throw new Error("Sweep tap tree root not set");
       }
-      const xOnlyPublicKeys = event.cosignersPublicKeys.map(
-        (k) => k.slice(2)
-      );
+      const xOnlyPublicKeys = event.cosignersPublicKeys.map((k) => k.slice(2));
       const signerPublicKey = await session.getPublicKey();
       const xonlySignerPublicKey = signerPublicKey.subarray(1);
       if (!xOnlyPublicKeys.includes(import_base7.hex.encode(xonlySignerPublicKey))) {
         return { skip: true };
       }
-      const commitmentTx = import_sdk6.Transaction.fromPSBT(
-        import_base7.base64.decode(event.unsignedCommitmentTx)
-      );
+      const commitmentTx = import_sdk6.Transaction.fromPSBT(import_base7.base64.decode(event.unsignedCommitmentTx));
       (0, import_sdk6.validateVtxoTxGraph)(vtxoTree, commitmentTx, sweepTapTreeRoot);
       const sharedOutput = commitmentTx.getOutput(0);
       if (!sharedOutput?.amount) {
@@ -2661,18 +2712,11 @@ function createVHTLCBatchHandler(intentId, vhtlc, arkProvider, identity, session
       if (!session) {
         return { fullySigned: true };
       }
-      const { hasAllNonces } = await session.aggregatedNonces(
-        event.txid,
-        event.nonces
-      );
+      const { hasAllNonces } = await session.aggregatedNonces(event.txid, event.nonces);
       if (!hasAllNonces) return { fullySigned: false };
       const signatures = await session.sign();
       const pubkey = import_base7.hex.encode(await session.getPublicKey());
-      await arkProvider.submitTreeSignatures(
-        event.id,
-        pubkey,
-        signatures
-      );
+      await arkProvider.submitTreeSignatures(event.id, pubkey, signatures);
       return { fullySigned: true };
     },
     onBatchFinalization: async (event, _, connectorTree) => {
@@ -2680,9 +2724,7 @@ function createVHTLCBatchHandler(intentId, vhtlc, arkProvider, identity, session
         return;
       }
       if (!connectorTree) {
-        throw new Error(
-          "BatchFinalizationEvent: expected connector tree to be defined"
-        );
+        throw new Error("BatchFinalizationEvent: expected connector tree to be defined");
       }
       (0, import_sdk6.validateConnectorsTxGraph)(event.commitmentTx, connectorTree);
       const connectors = connectorTree.leaves();
@@ -2697,9 +2739,7 @@ function createVHTLCBatchHandler(intentId, vhtlc, arkProvider, identity, session
         connectors[connectorIndex]
       );
       const signedForfeitTx = await identity.sign(forfeitTx);
-      await arkProvider.submitSignedForfeitTxs([
-        import_base7.base64.encode(signedForfeitTx.toPSBT())
-      ]);
+      await arkProvider.submitSignedForfeitTxs([import_base7.base64.encode(signedForfeitTx.toPSBT())]);
     }
   };
 }
@@ -2759,36 +2799,22 @@ var createVHTLCScript = (args) => {
     serverPubkey,
     timeoutBlockHeights: vhtlcTimeouts
   } = args;
-  const receiverXOnlyPublicKey = normalizeToXOnlyKey(
-    import_base8.hex.decode(receiverPubkey),
-    "receiver"
-  );
-  const senderXOnlyPublicKey = normalizeToXOnlyKey(
-    import_base8.hex.decode(senderPubkey),
-    "sender"
-  );
-  const serverXOnlyPublicKey = normalizeToXOnlyKey(
-    import_base8.hex.decode(serverPubkey),
-    "server"
-  );
+  const receiverXOnlyPublicKey = normalizeToXOnlyKey(import_base8.hex.decode(receiverPubkey), "receiver");
+  const senderXOnlyPublicKey = normalizeToXOnlyKey(import_base8.hex.decode(senderPubkey), "sender");
+  const serverXOnlyPublicKey = normalizeToXOnlyKey(import_base8.hex.decode(serverPubkey), "server");
   const vhtlcScript = new import_sdk7.VHTLC.Script({
     preimageHash: (0, import_legacy.ripemd160)(preimageHash),
     sender: senderXOnlyPublicKey,
     receiver: receiverXOnlyPublicKey,
     server: serverXOnlyPublicKey,
     refundLocktime: BigInt(vhtlcTimeouts.refund),
-    unilateralClaimDelay: toBip68RelativeTimelock(
-      vhtlcTimeouts.unilateralClaim
-    ),
-    unilateralRefundDelay: toBip68RelativeTimelock(
-      vhtlcTimeouts.unilateralRefund
-    ),
+    unilateralClaimDelay: toBip68RelativeTimelock(vhtlcTimeouts.unilateralClaim),
+    unilateralRefundDelay: toBip68RelativeTimelock(vhtlcTimeouts.unilateralRefund),
     unilateralRefundWithoutReceiverDelay: toBip68RelativeTimelock(
       vhtlcTimeouts.unilateralRefundWithoutReceiver
     )
   });
-  if (!vhtlcScript.claimScript)
-    throw new Error("Failed to create VHTLC script");
+  if (!vhtlcScript.claimScript) throw new Error("Failed to create VHTLC script");
   const hrp = network === "bitcoin" ? "ark" : "tark";
   const vhtlcAddress = vhtlcScript.address(hrp, serverXOnlyPublicKey).encode();
   return { vhtlcScript, vhtlcAddress };
@@ -2822,11 +2848,7 @@ var joinBatch = async (arkProvider, identity, input, output, {
     unknown: [import_sdk7.VtxoTaprootTree.encode(input.tapTree)],
     sequence: (0, import_sdk7.getSequence)(input.tapLeafScript)
   };
-  const registerIntent = import_sdk7.Intent.create(
-    intentMessage,
-    [intentInput],
-    [output]
-  );
+  const registerIntent = import_sdk7.Intent.create(intentMessage, [intentInput], [output]);
   const deleteIntent = import_sdk7.Intent.create(deleteMessage, [intentInput]);
   const [signedRegisterIntent, signedDeleteIntent] = await Promise.all([
     identity.sign(registerIntent),
@@ -2850,14 +2872,8 @@ var joinBatch = async (arkProvider, identity, input, output, {
       normalizeToXOnlyKey(forfeitPubkey, "forfeit"),
       isRecoverable2 ? void 0 : import_btc_signer4.OutScript.encode(decodedAddress)
     );
-    const topics = [
-      import_base8.hex.encode(signerPublicKey),
-      `${input.txid}:${input.vout}`
-    ];
-    const eventStream = arkProvider.getEventStream(
-      abortController.signal,
-      topics
-    );
+    const topics = [import_base8.hex.encode(signerPublicKey), `${input.txid}:${input.vout}`];
+    const eventStream = arkProvider.getEventStream(abortController.signal, topics);
     const commitmentTxid = await import_sdk7.Batch.join(eventStream, handler, {
       abortController
     });
@@ -2878,14 +2894,8 @@ var joinBatch = async (arkProvider, identity, input, output, {
 };
 var claimVHTLCwithOffchainTx = async (identity, vhtlcScript, serverXOnlyPublicKey, input, output, arkInfo, arkProvider) => {
   const rawCheckpointTapscript = import_base8.hex.decode(arkInfo.checkpointTapscript);
-  const serverUnrollScript = import_sdk7.CSVMultisigTapscript.decode(
-    rawCheckpointTapscript
-  );
-  const { arkTx, checkpoints } = (0, import_sdk7.buildOffchainTx)(
-    [input],
-    [output],
-    serverUnrollScript
-  );
+  const serverUnrollScript = import_sdk7.CSVMultisigTapscript.decode(rawCheckpointTapscript);
+  const { arkTx, checkpoints } = (0, import_sdk7.buildOffchainTx)([input], [output], serverUnrollScript);
   const signedArkTx = await identity.sign(arkTx);
   const { arkTxid, finalArkTx, signedCheckpointTxs } = await arkProvider.submitTx(
     import_base8.base64.encode(signedArkTx.toPSBT()),
@@ -2893,9 +2903,7 @@ var claimVHTLCwithOffchainTx = async (identity, vhtlcScript, serverXOnlyPublicKe
   );
   const finalTx = import_sdk7.Transaction.fromPSBT(import_base8.base64.decode(finalArkTx));
   const serverPubkeyHex = import_base8.hex.encode(serverXOnlyPublicKey);
-  const claimLeafHash = (0, import_payment3.tapLeafHash)(
-    scriptFromTapLeafScript(vhtlcScript.claim())
-  );
+  const claimLeafHash = (0, import_payment3.tapLeafHash)(scriptFromTapLeafScript(vhtlcScript.claim()));
   for (let i = 0; i < finalTx.inputsLength; i++) {
     if (!verifySignatures(finalTx, i, [serverPubkeyHex], claimLeafHash)) {
       throw new Error("Invalid final Ark transaction");
@@ -2905,13 +2913,9 @@ var claimVHTLCwithOffchainTx = async (identity, vhtlcScript, serverXOnlyPublicKe
     signedCheckpointTxs.map(async (c, idx) => {
       const tx = import_sdk7.Transaction.fromPSBT(import_base8.base64.decode(c));
       const checkpointLeaf = checkpoints[idx].getInput(0).tapLeafScript[0];
-      const cpLeafHash = (0, import_payment3.tapLeafHash)(
-        scriptFromTapLeafScript(checkpointLeaf)
-      );
+      const cpLeafHash = (0, import_payment3.tapLeafHash)(scriptFromTapLeafScript(checkpointLeaf));
       if (!verifySignatures(tx, 0, [serverPubkeyHex], cpLeafHash)) {
-        throw new Error(
-          "Invalid server signature in checkpoint transaction"
-        );
+        throw new Error("Invalid server signature in checkpoint transaction");
       }
       const signedCheckpoint = await identity.sign(tx, [0]);
       return import_base8.base64.encode(signedCheckpoint.toPSBT());
@@ -2921,61 +2925,37 @@ var claimVHTLCwithOffchainTx = async (identity, vhtlcScript, serverXOnlyPublicKe
 };
 var refundVHTLCwithOffchainTx = async (swapId, identity, arkProvider, boltzXOnlyPublicKey, ourXOnlyPublicKey, serverXOnlyPublicKey, input, output, arkInfo, refundFunc) => {
   const rawCheckpointTapscript = import_base8.hex.decode(arkInfo.checkpointTapscript);
-  const serverUnrollScript = import_sdk7.CSVMultisigTapscript.decode(
-    rawCheckpointTapscript
+  const serverUnrollScript = import_sdk7.CSVMultisigTapscript.decode(rawCheckpointTapscript);
+  const { arkTx: unsignedRefundTx, checkpoints: checkpointPtxs } = (0, import_sdk7.buildOffchainTx)(
+    [input],
+    [output],
+    serverUnrollScript
   );
-  const { arkTx: unsignedRefundTx, checkpoints: checkpointPtxs } = (0, import_sdk7.buildOffchainTx)([input], [output], serverUnrollScript);
   if (checkpointPtxs.length !== 1)
-    throw new Error(
-      `Expected one checkpoint transaction, got ${checkpointPtxs.length}`
-    );
+    throw new Error(`Expected one checkpoint transaction, got ${checkpointPtxs.length}`);
   const unsignedCheckpointTx = checkpointPtxs[0];
   let boltzSignedRefundTx;
   let boltzSignedCheckpointTx;
   try {
-    const result = await refundFunc(
-      swapId,
-      unsignedRefundTx,
-      unsignedCheckpointTx
-    );
+    const result = await refundFunc(swapId, unsignedRefundTx, unsignedCheckpointTx);
     boltzSignedRefundTx = result.transaction;
     boltzSignedCheckpointTx = result.checkpoint;
   } catch (error) {
-    throw new BoltzRefundError(
-      `Boltz rejected refund for swap ${swapId}`,
-      error
-    );
+    throw new BoltzRefundError(`Boltz rejected refund for swap ${swapId}`, error);
   }
   const boltzXOnlyPublicKeyHex = import_base8.hex.encode(boltzXOnlyPublicKey);
-  const refundLeafHash = (0, import_payment3.tapLeafHash)(
-    scriptFromTapLeafScript(input.tapLeafScript)
-  );
-  if (!verifySignatures(
-    boltzSignedRefundTx,
-    0,
-    [boltzXOnlyPublicKeyHex],
-    refundLeafHash
-  )) {
+  const refundLeafHash = (0, import_payment3.tapLeafHash)(scriptFromTapLeafScript(input.tapLeafScript));
+  if (!verifySignatures(boltzSignedRefundTx, 0, [boltzXOnlyPublicKeyHex], refundLeafHash)) {
     throw new Error("Invalid Boltz signature in refund transaction");
   }
   const checkpointLeaf = unsignedCheckpointTx.getInput(0).tapLeafScript[0];
-  const checkpointLeafHash = (0, import_payment3.tapLeafHash)(
-    scriptFromTapLeafScript(checkpointLeaf)
-  );
-  if (!verifySignatures(
-    boltzSignedCheckpointTx,
-    0,
-    [boltzXOnlyPublicKeyHex],
-    checkpointLeafHash
-  )) {
+  const checkpointLeafHash = (0, import_payment3.tapLeafHash)(scriptFromTapLeafScript(checkpointLeaf));
+  if (!verifySignatures(boltzSignedCheckpointTx, 0, [boltzXOnlyPublicKeyHex], checkpointLeafHash)) {
     throw new Error("Invalid Boltz signature in checkpoint transaction");
   }
   const signedRefundTx = await identity.sign(unsignedRefundTx);
   const signedCheckpointTx = await identity.sign(unsignedCheckpointTx);
-  const combinedSignedRefundTx = (0, import_sdk7.combineTapscriptSigs)(
-    boltzSignedRefundTx,
-    signedRefundTx
-  );
+  const combinedSignedRefundTx = (0, import_sdk7.combineTapscriptSigs)(boltzSignedRefundTx, signedRefundTx);
   const combinedSignedCheckpointTx = (0, import_sdk7.combineTapscriptSigs)(
     boltzSignedCheckpointTx,
     signedCheckpointTx
@@ -2999,25 +2979,16 @@ var refundVHTLCwithOffchainTx = async (swapId, identity, arkProvider, boltzXOnly
       `Expected one signed checkpoint transaction, got ${signedCheckpointTxs.length}`
     );
   }
-  const serverSignedCheckpointTx = import_sdk7.Transaction.fromPSBT(
-    import_base8.base64.decode(signedCheckpointTxs[0])
-  );
+  const serverSignedCheckpointTx = import_sdk7.Transaction.fromPSBT(import_base8.base64.decode(signedCheckpointTxs[0]));
   const serverPubkeyHex = import_base8.hex.encode(serverXOnlyPublicKey);
-  if (!verifySignatures(
-    serverSignedCheckpointTx,
-    0,
-    [serverPubkeyHex],
-    checkpointLeafHash
-  )) {
+  if (!verifySignatures(serverSignedCheckpointTx, 0, [serverPubkeyHex], checkpointLeafHash)) {
     throw new Error("Invalid server signature in checkpoint transaction");
   }
   const finalCheckpointTx = (0, import_sdk7.combineTapscriptSigs)(
     combinedSignedCheckpointTx,
     serverSignedCheckpointTx
   );
-  await arkProvider.finalizeTx(arkTxid, [
-    import_base8.base64.encode(finalCheckpointTx.toPSBT())
-  ]);
+  await arkProvider.finalizeTx(arkTxid, [import_base8.base64.encode(finalCheckpointTx.toPSBT())]);
 };
 function scriptFromTapLeafScript(leaf) {
   return leaf[1].subarray(0, leaf[1].length - 1);
@@ -3025,21 +2996,21 @@ function scriptFromTapLeafScript(leaf) {
 
 // src/arkade-swaps.ts
 var dedupeVtxos = (vtxos) => [
-  ...new Map(
-    vtxos.map((vtxo) => [`${vtxo.txid}:${vtxo.vout}`, vtxo])
-  ).values()
+  ...new Map(vtxos.map((vtxo) => [`${vtxo.txid}:${vtxo.vout}`, vtxo])).values()
 ];
 var hasNonEmptyString = (value) => typeof value === "string" && value.length > 0;
 var canRecoverViaBoltz3of3 = (refundableVtxos, swap) => {
   const hasRequiredSwapMetadata = hasNonEmptyString(swap.id) && hasNonEmptyString(swap.request.refundPublicKey) && hasNonEmptyString(swap.response.address) && hasNonEmptyString(swap.response.claimPublicKey) && !!swap.response.timeoutBlockHeights;
   if (!hasRequiredSwapMetadata) return false;
-  return refundableVtxos.some(
-    (vtxo) => !vtxo.isSpent && !(0, import_sdk8.isRecoverable)(vtxo)
-  );
+  return refundableVtxos.some((vtxo) => !vtxo.isSpent && !(0, import_sdk8.isRecoverable)(vtxo));
 };
 var isSubmarineRefundLocktimeReached = (refundTimestamp) => Math.floor(Date.now() / 1e3) >= refundTimestamp;
 var CLAIM_VTXO_RETRY_ATTEMPTS = 3;
 var CLAIM_VTXO_RETRY_DELAY_MS = 500;
+var quoteOptionsForSwap = (swap) => {
+  const amount = swap.response?.claimDetails?.amount;
+  return typeof amount === "number" ? { minAcceptableAmount: amount } : void 0;
+};
 var ArkadeSwaps = class _ArkadeSwaps {
   /** The Arkade wallet instance used for signing and address generation. */
   wallet;
@@ -3075,10 +3046,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       return new _ArkadeSwaps(config);
     }
     const arkProvider = config.arkProvider ?? config.wallet.arkProvider;
-    if (!arkProvider)
-      throw new Error(
-        "Ark provider is required either in wallet or config."
-      );
+    if (!arkProvider) throw new Error("Ark provider is required either in wallet or config.");
     const arkInfo = await arkProvider.getInfo();
     const network = arkInfo.network;
     const swapProvider = new BoltzSwapProvider({ network });
@@ -3089,16 +3057,11 @@ var ArkadeSwaps = class _ArkadeSwaps {
     if (!config.swapProvider) throw new Error("Swap provider is required.");
     this.wallet = config.wallet;
     const arkProvider = config.arkProvider ?? config.wallet.arkProvider;
-    if (!arkProvider)
-      throw new Error(
-        "Ark provider is required either in wallet or config."
-      );
+    if (!arkProvider) throw new Error("Ark provider is required either in wallet or config.");
     this.arkProvider = arkProvider;
     const indexerProvider = config.indexerProvider ?? config.wallet.indexerProvider;
     if (!indexerProvider)
-      throw new Error(
-        "Indexer provider is required either in wallet or config."
-      );
+      throw new Error("Indexer provider is required either in wallet or config.");
     this.indexerProvider = indexerProvider;
     this.swapProvider = config.swapProvider;
     if (config.swapRepository) {
@@ -3109,10 +3072,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
     if (config.swapManager !== false) {
       const swapManagerConfig = !config.swapManager || config.swapManager === true ? {} : config.swapManager;
       const shouldAutostart = swapManagerConfig.autoStart ?? true;
-      this.swapManager = new SwapManager(
-        this.swapProvider,
-        swapManagerConfig
-      );
+      this.swapManager = new SwapManager(this.swapProvider, swapManagerConfig);
       this.swapManager.setCallbacks({
         claim: async (swap) => {
           await this.claimVHTLC(swap);
@@ -3127,7 +3087,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
           await this.claimBtc(swap);
         },
         refundArk: async (swap) => {
-          await this.refundArk(swap);
+          return this.refundArk(swap);
         },
         signServerClaim: async (swap) => {
           await this.signCooperativeClaimForServer(swap);
@@ -3260,19 +3220,15 @@ var ArkadeSwaps = class _ArkadeSwaps {
    * @throws {SwapError} If amount is <= 0 or key retrieval fails.
    */
   async createReverseSwap(args) {
-    if (args.amount <= 0)
-      throw new SwapError({ message: "Amount must be greater than 0" });
-    const claimPublicKey = import_base9.hex.encode(
-      await this.wallet.identity.compressedPublicKey()
-    );
+    if (args.amount <= 0) throw new SwapError({ message: "Amount must be greater than 0" });
+    const claimPublicKey = import_base9.hex.encode(await this.wallet.identity.compressedPublicKey());
     if (!claimPublicKey)
       throw new SwapError({
         message: "Failed to get claim public key from wallet"
       });
     const preimage = (0, import_utils3.randomBytes)(32);
     const preimageHash = import_base9.hex.encode((0, import_sha23.sha256)(preimage));
-    if (!preimageHash)
-      throw new SwapError({ message: "Failed to get preimage hash" });
+    if (!preimageHash) throw new SwapError({ message: "Failed to get preimage hash" });
     const swapRequest = {
       invoiceAmount: args.amount,
       claimPublicKey,
@@ -3302,18 +3258,14 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async claimVHTLC(pendingSwap) {
     if (!pendingSwap.preimage)
-      throw new Error(
-        `Swap ${pendingSwap.id}: preimage is required to claim VHTLC`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: preimage is required to claim VHTLC`);
     const {
       refundPublicKey,
       lockupAddress,
       timeoutBlockHeights: vhtlcTimeouts
     } = pendingSwap.response;
     if (!refundPublicKey || !lockupAddress || !vhtlcTimeouts)
-      throw new Error(
-        `Swap ${pendingSwap.id}: incomplete reverse swap response`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: incomplete reverse swap response`);
     const preimage = import_base9.hex.decode(pendingSwap.preimage);
     const arkInfo = await this.arkProvider.getInfo();
     const address = await this.wallet.getAddress();
@@ -3348,58 +3300,67 @@ var ArkadeSwaps = class _ArkadeSwaps {
       throw new Error(
         `Swap ${pendingSwap.id}: VHTLC address mismatch. Expected ${lockupAddress}, got ${vhtlcAddress}`
       );
-    let vtxo;
+    let unspentVtxos = [];
+    let rawVtxos = [];
     for (let attempt = 1; attempt <= CLAIM_VTXO_RETRY_ATTEMPTS; attempt++) {
-      const { vtxos } = await this.indexerProvider.getVtxos({
+      const result = await this.indexerProvider.getVtxos({
         scripts: [import_base9.hex.encode(vhtlcScript.pkScript)]
       });
-      if (vtxos.length > 0) {
-        vtxo = vtxos[0];
+      rawVtxos = result.vtxos;
+      unspentVtxos = result.vtxos.filter((vtxo) => !vtxo.isSpent);
+      if (unspentVtxos.length > 0) {
         break;
       }
       if (attempt < CLAIM_VTXO_RETRY_ATTEMPTS) {
-        await new Promise(
-          (resolve) => setTimeout(resolve, CLAIM_VTXO_RETRY_DELAY_MS)
-        );
+        await new Promise((resolve) => setTimeout(resolve, CLAIM_VTXO_RETRY_DELAY_MS));
       }
     }
-    if (!vtxo) {
-      throw new Error(
-        `Swap ${pendingSwap.id}: no spendable virtual coins found`
-      );
-    }
-    if (vtxo.isSpent) {
+    if (unspentVtxos.length === 0) {
+      if (rawVtxos.length === 0) {
+        throw new Error(`Swap ${pendingSwap.id}: no spendable virtual coins found`);
+      }
       throw new Error(`Swap ${pendingSwap.id}: VHTLC is already spent`);
     }
-    const input = {
-      ...vtxo,
-      tapLeafScript: vhtlcScript.claim(),
-      tapTree: vhtlcScript.encode()
-    };
-    const output = {
-      amount: BigInt(vtxo.value),
-      script: import_sdk8.ArkAddress.decode(address).pkScript
-    };
-    const vhtlcIdentity = claimVHTLCIdentity(
-      this.wallet.identity,
-      preimage
-    );
-    let finalStatus;
-    if ((0, import_sdk8.isRecoverable)(vtxo)) {
-      await this.joinBatch(vhtlcIdentity, input, output, arkInfo);
-      finalStatus = "transaction.claimed";
-    } else {
-      await claimVHTLCwithOffchainTx(
-        vhtlcIdentity,
-        vhtlcScript,
-        serverXOnly,
-        input,
-        output,
-        arkInfo,
-        this.arkProvider
+    const vhtlcIdentity = claimVHTLCIdentity(this.wallet.identity, preimage);
+    const outputScript = import_sdk8.ArkAddress.decode(address).pkScript;
+    const claimErrors = [];
+    let usedOffchainClaim = false;
+    for (const vtxo of unspentVtxos) {
+      const input = {
+        ...vtxo,
+        tapLeafScript: vhtlcScript.claim(),
+        tapTree: vhtlcScript.encode()
+      };
+      const output = {
+        amount: BigInt(vtxo.value),
+        script: outputScript
+      };
+      try {
+        if ((0, import_sdk8.isRecoverable)(vtxo)) {
+          await this.joinBatch(vhtlcIdentity, input, output, arkInfo);
+        } else {
+          await claimVHTLCwithOffchainTx(
+            vhtlcIdentity,
+            vhtlcScript,
+            serverXOnly,
+            input,
+            output,
+            arkInfo,
+            this.arkProvider
+          );
+          usedOffchainClaim = true;
+        }
+      } catch (error) {
+        claimErrors.push({ vtxo, error });
+      }
+    }
+    if (claimErrors.length > 0) {
+      const details = claimErrors.map(({ vtxo, error }) => `${vtxo.txid}:${vtxo.vout} (${error.message})`).join("; ");
+      throw new Error(
+        `Swap ${pendingSwap.id}: failed to claim ${claimErrors.length}/${unspentVtxos.length} VTXOs: ${details}`
       );
-      finalStatus = (await this.getSwapStatus(pendingSwap.id)).status;
     }
+    const finalStatus = usedOffchainClaim ? (await this.getSwapStatus(pendingSwap.id)).status : "transaction.claimed";
     await updateReverseSwapStatus(
       pendingSwap,
       finalStatus,
@@ -3502,9 +3463,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
   async sendLightningPayment(args) {
     const pendingSwap = await this.createSubmarineSwap(args);
     if (!pendingSwap.response.address)
-      throw new Error(
-        `Swap ${pendingSwap.id}: missing address in submarine swap response`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: missing address in submarine swap response`);
     await this.savePendingSubmarineSwap(pendingSwap);
     const txid = await this.wallet.send({
       address: pendingSwap.response.address,
@@ -3537,9 +3496,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
    * @throws {SwapError} If invoice is missing or key retrieval fails.
    */
   async createSubmarineSwap(args) {
-    const refundPublicKey = import_base9.hex.encode(
-      await this.wallet.identity.compressedPublicKey()
-    );
+    const refundPublicKey = import_base9.hex.encode(await this.wallet.identity.compressedPublicKey());
     if (!refundPublicKey)
       throw new SwapError({
         message: "Failed to get refund public key from wallet"
@@ -3577,9 +3534,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
   async buildSubmarineVHTLCContext(swap, arkInfo) {
     const preimageHash = swap.request.invoice ? getInvoicePaymentHash(swap.request.invoice) : swap.preimageHash;
     if (!preimageHash)
-      throw new Error(
-        `Swap ${swap.id}: preimage hash is required to refund VHTLC`
-      );
+      throw new Error(`Swap ${swap.id}: preimage hash is required to refund VHTLC`);
     const resolvedArkInfo = arkInfo ?? await this.arkProvider.getInfo();
     const ourXOnlyPublicKey = normalizeToXOnlyKey(
       await this.wallet.identity.xOnlyPublicKey(),
@@ -3593,9 +3548,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
     );
     const { claimPublicKey, timeoutBlockHeights: vhtlcTimeouts } = swap.response;
     if (!claimPublicKey || !vhtlcTimeouts)
-      throw new Error(
-        `Swap ${swap.id}: incomplete submarine swap response`
-      );
+      throw new Error(`Swap ${swap.id}: incomplete submarine swap response`);
     const boltzXOnlyPublicKey = normalizeToXOnlyKey(
       import_base9.hex.decode(claimPublicKey),
       "boltz",
@@ -3610,9 +3563,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       timeoutBlockHeights: vhtlcTimeouts
     });
     if (!vhtlcScript.claimScript)
-      throw new Error(
-        `Swap ${swap.id}: failed to create VHTLC script for submarine swap`
-      );
+      throw new Error(`Swap ${swap.id}: failed to create VHTLC script for submarine swap`);
     if (vhtlcAddress !== swap.response.address)
       throw new Error(
         `VHTLC address mismatch for swap ${swap.id}: expected ${swap.response.address}, got ${vhtlcAddress}`
@@ -3651,10 +3602,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
         recoverableOnly: true
       })
     ]);
-    const refundableVtxos = dedupeVtxos([
-      ...spendableResult.vtxos,
-      ...recoverableResult.vtxos
-    ]);
+    const refundableVtxos = dedupeVtxos([...spendableResult.vtxos, ...recoverableResult.vtxos]);
     let diagnostic;
     if (refundableVtxos.length === 0) {
       const { vtxos: allVtxos } = await this.indexerProvider.getVtxos({
@@ -3674,13 +3622,8 @@ var ArkadeSwaps = class _ArkadeSwaps {
   submarineRecoveryInfoFromLookup(swap, lookup) {
     const { refundableVtxos, diagnostic, vhtlcTimeouts } = lookup;
     if (refundableVtxos.length > 0) {
-      const cltvSatisfied = isSubmarineRefundLocktimeReached(
-        vhtlcTimeouts.refund
-      );
-      const amountSats = refundableVtxos.reduce(
-        (sum, vtxo) => sum + Number(vtxo.value),
-        0
-      );
+      const cltvSatisfied = isSubmarineRefundLocktimeReached(vhtlcTimeouts.refund);
+      const amountSats = refundableVtxos.reduce((sum, vtxo) => sum + Number(vtxo.value), 0);
       const isRecoverable2 = cltvSatisfied || canRecoverViaBoltz3of3(refundableVtxos, swap);
       return {
         swap,
@@ -3744,19 +3687,13 @@ var ArkadeSwaps = class _ArkadeSwaps {
         );
       }
       if (diagnostic.allSpent) {
-        throw new Error(
-          `Swap ${pendingSwap.id}: VHTLC is already spent`
-        );
+        throw new Error(`Swap ${pendingSwap.id}: VHTLC is already spent`);
       }
-      throw new Error(
-        `Swap ${pendingSwap.id}: VHTLC has no refundable VTXOs yet`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: VHTLC has no refundable VTXOs yet`);
     }
     const outputScript = import_sdk8.ArkAddress.decode(address).pkScript;
     const refundWithoutReceiverLeaf = vhtlcScript.refundWithoutReceiver();
-    const cltvSatisfied = isSubmarineRefundLocktimeReached(
-      vhtlcTimeouts.refund
-    );
+    const cltvSatisfied = isSubmarineRefundLocktimeReached(vhtlcTimeouts.refund);
     let boltzCallCount = 0;
     let sweptCount = 0;
     let skippedCount = 0;
@@ -3798,6 +3735,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
         if (boltzCallCount > 0) {
           await new Promise((r) => setTimeout(r, 2e3));
         }
+        boltzCallCount++;
         await refundVHTLCwithOffchainTx(
           pendingSwap.id,
           this.wallet.identity,
@@ -3808,11 +3746,8 @@ var ArkadeSwaps = class _ArkadeSwaps {
           input,
           output,
           arkInfo,
-          this.swapProvider.refundSubmarineSwap.bind(
-            this.swapProvider
-          )
+          this.swapProvider.refundSubmarineSwap.bind(this.swapProvider)
         );
-        boltzCallCount++;
         sweptCount++;
       } catch (error) {
         if (!(error instanceof BoltzRefundError)) {
@@ -3833,13 +3768,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
           tapLeafScript: refundWithoutReceiverLeaf,
           tapTree: vhtlcScript.encode()
         };
-        await this.joinBatch(
-          this.wallet.identity,
-          fallbackInput,
-          output,
-          arkInfo,
-          false
-        );
+        await this.joinBatch(this.wallet.identity, fallbackInput, output, arkInfo, false);
         sweptCount++;
       }
     }
@@ -3935,10 +3864,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
         try {
           return {
             swap,
-            context: await this.buildSubmarineVHTLCContext(
-              swap,
-              arkInfo
-            )
+            context: await this.buildSubmarineVHTLCContext(swap, arkInfo)
           };
         } catch (err) {
           return {
@@ -3951,9 +3877,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
     const valid = prepared.filter(
       (item) => "context" in item
     );
-    const scripts = [
-      ...new Set(valid.map(({ context }) => context.vhtlcPkScriptHex))
-    ];
+    const scripts = [...new Set(valid.map(({ context }) => context.vhtlcPkScriptHex))];
     const refundableByScript = /* @__PURE__ */ new Map();
     if (scripts.length > 0) {
       const [spendableResult, recoverableResult] = await Promise.all([
@@ -3988,9 +3912,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
           error: item.error
         };
       }
-      const refundableVtxos = refundableByScript.get(
-        item.context.vhtlcPkScriptHex.toLowerCase()
-      ) ?? [];
+      const refundableVtxos = refundableByScript.get(item.context.vhtlcPkScriptHex.toLowerCase()) ?? [];
       return this.submarineRecoveryInfoFromLookup(item.swap, {
         ...item.context,
         refundableVtxos
@@ -4169,9 +4091,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async waitAndClaimBtc(pendingSwap) {
     if (this.swapManager && await this.swapManager.hasSwap(pendingSwap.id)) {
-      const { txid } = await this.swapManager.waitForSwapCompletion(
-        pendingSwap.id
-      );
+      const { txid } = await this.swapManager.waitForSwapCompletion(pendingSwap.id);
       return { txid };
     }
     return new Promise((resolve, reject) => {
@@ -4198,24 +4118,25 @@ var ArkadeSwaps = class _ArkadeSwaps {
           }
           case "transaction.claimed":
             await updateSwapStatus();
-            const claimedStatus = await this.getSwapStatus(
-              pendingSwap.id
-            );
+            const claimedStatus = await this.getSwapStatus(pendingSwap.id);
             resolve({
               txid: claimedStatus.transaction?.id ?? ""
             });
             break;
           case "transaction.lockupFailed":
             await updateSwapStatus();
-            await this.quoteSwap(swap.response.id).catch((err) => {
-              reject(
-                new SwapError({
-                  message: `Failed to renegotiate quote: ${err.message}`,
-                  isRefundable: true,
-                  pendingSwap: swap
-                })
-              );
-            });
+            await this.quoteSwap(swap.response.id, quoteOptionsForSwap(swap)).catch(
+              (err) => {
+                reject(
+                  new SwapError({
+                    message: `Failed to renegotiate quote: ${err.message}`,
+                    isRefundable: true,
+                    pendingSwap: swap,
+                    cause: err
+                  })
+                );
+              }
+            );
             break;
           case "swap.expired":
             await updateSwapStatus();
@@ -4253,30 +4174,18 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async claimBtc(pendingSwap) {
     if (!pendingSwap.toAddress)
-      throw new Error(
-        `Swap ${pendingSwap.id}: destination address is required`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: destination address is required`);
     if (!pendingSwap.response.claimDetails.swapTree)
-      throw new Error(
-        `Swap ${pendingSwap.id}: missing swap tree in claim details`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: missing swap tree in claim details`);
     if (!pendingSwap.response.claimDetails.serverPublicKey)
-      throw new Error(
-        `Swap ${pendingSwap.id}: missing server public key in claim details`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: missing server public key in claim details`);
     const swapStatus = await this.getSwapStatus(pendingSwap.id);
     if (!swapStatus.transaction?.hex)
-      throw new Error(
-        `Swap ${pendingSwap.id}: BTC transaction hex is required`
-      );
-    const lockupTx = import_btc_signer5.Transaction.fromRaw(
-      import_base9.hex.decode(swapStatus.transaction.hex)
-    );
+      throw new Error(`Swap ${pendingSwap.id}: BTC transaction hex is required`);
+    const lockupTx = import_btc_signer5.Transaction.fromRaw(import_base9.hex.decode(swapStatus.transaction.hex));
     const arkInfo = await this.arkProvider.getInfo();
     const network = arkInfo.network === "bitcoin" ? import_utils4.NETWORK : arkInfo.network === "mutinynet" ? MUTINYNET_NETWORK : REGTEST_NETWORK;
-    const swapTree = deserializeSwapTree(
-      pendingSwap.response.claimDetails.swapTree
-    );
+    const swapTree = deserializeSwapTree(pendingSwap.response.claimDetails.swapTree);
     const musig = tweakMusig(
       create(import_base9.hex.decode(pendingSwap.ephemeralKey), [
         import_base9.hex.decode(pendingSwap.response.claimDetails.serverPublicKey),
@@ -4297,19 +4206,14 @@ var ArkadeSwaps = class _ArkadeSwaps {
           vout: swapOutput.vout,
           transactionId: lockupTx.id
         },
-        import_btc_signer5.OutScript.encode(
-          (0, import_btc_signer5.Address)(network).decode(pendingSwap.toAddress)
-        ),
+        import_btc_signer5.OutScript.encode((0, import_btc_signer5.Address)(network).decode(pendingSwap.toAddress)),
         feeToDeliverExactAmount > fee ? feeToDeliverExactAmount : fee
       )
     );
     const musigMessage = musig.message(
-      claimTx.preimageWitnessV1(
-        0,
-        [swapOutput.script],
-        import_btc_signer5.SigHash.DEFAULT,
-        [swapOutput.amount]
-      )
+      claimTx.preimageWitnessV1(0, [swapOutput.script], import_btc_signer5.SigHash.DEFAULT, [
+        swapOutput.amount
+      ])
     ).generateNonce();
     const signedTxData = await this.swapProvider.postChainClaimDetails(
       pendingSwap.response.id,
@@ -4323,14 +4227,10 @@ var ArkadeSwaps = class _ArkadeSwaps {
       }
     );
     if (!signedTxData.pubNonce || !signedTxData.partialSignature)
-      throw new Error(
-        `Swap ${pendingSwap.id}: invalid signature data from server`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: invalid signature data from server`);
     const musigSession = musigMessage.aggregateNonces([
       [
-        import_base9.hex.decode(
-          pendingSwap.response.claimDetails.serverPublicKey
-        ),
+        import_base9.hex.decode(pendingSwap.response.claimDetails.serverPublicKey),
         import_base9.hex.decode(signedTxData.pubNonce)
       ]
     ]).initializeSession();
@@ -4345,18 +4245,23 @@ var ArkadeSwaps = class _ArkadeSwaps {
     await this.swapProvider.postBtcTransaction(claimTx.hex);
   }
   /**
-   * When an ARK to BTC swap fails, refund sats on ARK chain by claiming the VHTLC.
+   * When an ARK to BTC swap fails, refund every unspent VTXO at the chain
+   * swap's ARK lockup address.
+   *
+   * Path selection per VTXO:
+   * - CLTV has elapsed → `refundWithoutReceiver` via `joinBatch` (no Boltz).
+   * - Pre-CLTV recoverable → skipped (Boltz can't co-sign swept-batch refund).
+   * - Pre-CLTV non-recoverable → cooperative 3-of-3 refund via Boltz.
+   *
    * @param pendingSwap - The pending chain swap to refund.
+   * @returns Counts of VTXOs swept vs. deferred. A `swept: 0` outcome means
+   *          the call was a no-op — callers should retry after CLTV.
    */
   async refundArk(pendingSwap) {
     if (!pendingSwap.response.lockupDetails.serverPublicKey)
-      throw new Error(
-        `Swap ${pendingSwap.id}: missing server public key in lockup details`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: missing server public key in lockup details`);
     if (!pendingSwap.response.lockupDetails.timeouts)
-      throw new Error(
-        `Swap ${pendingSwap.id}: missing timeouts in lockup details`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: missing timeouts in lockup details`);
     const arkInfo = await this.arkProvider.getInfo();
     const address = await this.wallet.getAddress();
     const ourXOnlyPublicKey = normalizeToXOnlyKey(
@@ -4374,21 +4279,6 @@ var ArkadeSwaps = class _ArkadeSwaps {
       "boltz",
       pendingSwap.id
     );
-    const vhtlcPkScript = import_sdk8.ArkAddress.decode(
-      pendingSwap.response.lockupDetails.lockupAddress
-    ).pkScript;
-    const { vtxos } = await this.indexerProvider.getVtxos({
-      scripts: [import_base9.hex.encode(vhtlcPkScript)]
-    });
-    if (vtxos.length === 0) {
-      throw new Error(
-        `Swap ${pendingSwap.id}: VHTLC not found for address ${pendingSwap.response.lockupDetails.lockupAddress}`
-      );
-    }
-    const vtxo = vtxos[0];
-    if (vtxo.isSpent) {
-      throw new Error(`Swap ${pendingSwap.id}: VHTLC is already spent`);
-    }
     const { vhtlcAddress, vhtlcScript } = this.createVHTLCScript({
       network: arkInfo.network,
       preimageHash: import_base9.hex.decode(pendingSwap.request.preimageHash),
@@ -4398,45 +4288,111 @@ var ArkadeSwaps = class _ArkadeSwaps {
       timeoutBlockHeights: pendingSwap.response.lockupDetails.timeouts
     });
     if (!vhtlcScript.refundScript)
-      throw new Error(
-        `Swap ${pendingSwap.id}: failed to create VHTLC script for chain swap`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: failed to create VHTLC script for chain swap`);
     if (pendingSwap.response.lockupDetails.lockupAddress !== vhtlcAddress) {
       throw new SwapError({
         message: "Unable to claim: invalid VHTLC address"
       });
     }
-    const isRecoverableVtxo = (0, import_sdk8.isRecoverable)(vtxo);
-    const input = {
-      ...vtxo,
-      tapLeafScript: isRecoverableVtxo ? vhtlcScript.refundWithoutReceiver() : vhtlcScript.refund(),
-      tapTree: vhtlcScript.encode()
-    };
-    const output = {
-      amount: BigInt(vtxo.value),
-      script: import_sdk8.ArkAddress.decode(address).pkScript
-    };
-    if (isRecoverableVtxo) {
-      await this.joinBatch(this.wallet.identity, input, output, arkInfo);
-    } else {
-      await refundVHTLCwithOffchainTx(
-        pendingSwap.id,
-        this.wallet.identity,
-        this.arkProvider,
-        boltzXOnlyPublicKey,
-        ourXOnlyPublicKey,
-        serverXOnlyPublicKey,
-        input,
-        output,
-        arkInfo,
-        this.swapProvider.refundChainSwap.bind(this.swapProvider)
+    const { vtxos } = await this.indexerProvider.getVtxos({
+      scripts: [import_base9.hex.encode(vhtlcScript.pkScript)]
+    });
+    if (vtxos.length === 0) {
+      throw new Error(
+        `Swap ${pendingSwap.id}: VHTLC not found for address ${pendingSwap.response.lockupDetails.lockupAddress}`
       );
     }
+    const unspentVtxos = vtxos.filter((vtxo) => !vtxo.isSpent);
+    if (unspentVtxos.length === 0) {
+      throw new Error(`Swap ${pendingSwap.id}: VHTLC is already spent`);
+    }
+    const outputScript = import_sdk8.ArkAddress.decode(address).pkScript;
+    const refundWithoutReceiverLeaf = vhtlcScript.refundWithoutReceiver();
+    const refundLocktime = pendingSwap.response.lockupDetails.timeouts.refund;
+    let boltzCallCount = 0;
+    let sweptCount = 0;
+    let skippedCount = 0;
+    for (const vtxo of unspentVtxos) {
+      const isRecoverableVtxo = (0, import_sdk8.isRecoverable)(vtxo);
+      const output = {
+        amount: BigInt(vtxo.value),
+        script: outputScript
+      };
+      if (isSubmarineRefundLocktimeReached(refundLocktime)) {
+        const input2 = {
+          ...vtxo,
+          tapLeafScript: refundWithoutReceiverLeaf,
+          tapTree: vhtlcScript.encode()
+        };
+        await this.joinBatch(
+          this.wallet.identity,
+          input2,
+          output,
+          arkInfo,
+          isRecoverableVtxo
+        );
+        sweptCount++;
+        continue;
+      }
+      if (isRecoverableVtxo) {
+        logger.error(
+          `Swap ${pendingSwap.id}: 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++;
+        continue;
+      }
+      const input = {
+        ...vtxo,
+        tapLeafScript: vhtlcScript.refund(),
+        tapTree: vhtlcScript.encode()
+      };
+      try {
+        if (boltzCallCount > 0) {
+          await new Promise((r) => setTimeout(r, 2e3));
+        }
+        boltzCallCount++;
+        await refundVHTLCwithOffchainTx(
+          pendingSwap.id,
+          this.wallet.identity,
+          this.arkProvider,
+          boltzXOnlyPublicKey,
+          ourXOnlyPublicKey,
+          serverXOnlyPublicKey,
+          input,
+          output,
+          arkInfo,
+          this.swapProvider.refundChainSwap.bind(this.swapProvider)
+        );
+        sweptCount++;
+      } catch (error) {
+        if (!(error instanceof BoltzRefundError)) {
+          throw error;
+        }
+        if (!isSubmarineRefundLocktimeReached(refundLocktime)) {
+          logger.error(
+            `Swap ${pendingSwap.id}: 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++;
+          continue;
+        }
+        logger.warn(
+          `Swap ${pendingSwap.id}: Boltz rejected VTXO outpoint, falling back to refundWithoutReceiver via joinBatch`
+        );
+        const fallbackInput = {
+          ...vtxo,
+          tapLeafScript: refundWithoutReceiverLeaf,
+          tapTree: vhtlcScript.encode()
+        };
+        await this.joinBatch(this.wallet.identity, fallbackInput, output, arkInfo, false);
+        sweptCount++;
+      }
+    }
     const finalStatus = await this.getSwapStatus(pendingSwap.id);
     await this.savePendingChainSwap({
       ...pendingSwap,
       status: finalStatus.status
     });
+    return { swept: sweptCount, skipped: skippedCount };
   }
   // =========================================================================
   // Chain swaps: BTC -> ARK
@@ -4481,9 +4437,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async waitAndClaimArk(pendingSwap) {
     if (this.swapManager && await this.swapManager.hasSwap(pendingSwap.id)) {
-      const { txid } = await this.swapManager.waitForSwapCompletion(
-        pendingSwap.id
-      );
+      const { txid } = await this.swapManager.waitForSwapCompletion(pendingSwap.id);
       return { txid };
     }
     return new Promise((resolve, reject) => {
@@ -4504,37 +4458,33 @@ var ArkadeSwaps = class _ArkadeSwaps {
             break;
           case "transaction.claimed":
             await updateSwapStatus();
-            const claimedStatus = await this.getSwapStatus(
-              pendingSwap.id
-            );
+            const claimedStatus = await this.getSwapStatus(pendingSwap.id);
             resolve({
               txid: claimedStatus.transaction?.id ?? ""
             });
             break;
           case "transaction.claim.pending":
             await updateSwapStatus();
-            await this.signCooperativeClaimForServer(swap).catch(
+            await this.signCooperativeClaimForServer(swap).catch((err) => {
+              logger.error(`Failed to sign cooperative claim for ${swap.id}:`, err);
+            });
+            break;
+          case "transaction.lockupFailed":
+            await updateSwapStatus();
+            await this.quoteSwap(swap.response.id, quoteOptionsForSwap(swap)).catch(
               (err) => {
-                logger.error(
-                  `Failed to sign cooperative claim for ${swap.id}:`,
-                  err
+                reject(
+                  new SwapError({
+                    message: `Failed to renegotiate quote: ${err.message}`,
+                    isRefundable: false,
+                    // TODO btc refund not implemented yet
+                    pendingSwap: swap,
+                    cause: err
+                  })
                 );
               }
             );
             break;
-          case "transaction.lockupFailed":
-            await updateSwapStatus();
-            await this.quoteSwap(swap.response.id).catch((err) => {
-              reject(
-                new SwapError({
-                  message: `Failed to renegotiate quote: ${err.message}`,
-                  isRefundable: false,
-                  // TODO btc refund not implemented yet
-                  pendingSwap: swap
-                })
-              );
-            });
-            break;
           case "swap.expired":
             await updateSwapStatus();
             reject(
@@ -4574,17 +4524,11 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async claimArk(pendingSwap) {
     if (!pendingSwap.toAddress)
-      throw new Error(
-        `Swap ${pendingSwap.id}: destination address is required`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: destination address is required`);
     if (!pendingSwap.response.claimDetails.serverPublicKey)
-      throw new Error(
-        `Swap ${pendingSwap.id}: missing server public key in claim details`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: missing server public key in claim details`);
     if (!pendingSwap.response.claimDetails.timeouts)
-      throw new Error(
-        `Swap ${pendingSwap.id}: missing timeouts in claim details`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: missing timeouts in claim details`);
     const arkInfo = await this.arkProvider.getInfo();
     const preimage = import_base9.hex.decode(pendingSwap.preimage);
     const address = await this.wallet.getAddress();
@@ -4596,10 +4540,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       pendingSwap.response.claimDetails.serverPublicKey,
       "sender"
     );
-    const serverXOnlyPublicKey = normalizeToXOnlyKey(
-      arkInfo.signerPubkey,
-      "server"
-    );
+    const serverXOnlyPublicKey = normalizeToXOnlyKey(arkInfo.signerPubkey, "server");
     const { vhtlcAddress, vhtlcScript } = this.createVHTLCScript({
       network: arkInfo.network,
       preimageHash: import_base9.hex.decode(pendingSwap.request.preimageHash),
@@ -4609,9 +4550,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       timeoutBlockHeights: pendingSwap.response.claimDetails.timeouts
     });
     if (!vhtlcScript.claimScript)
-      throw new Error(
-        `Swap ${pendingSwap.id}: failed to create VHTLC script for chain swap`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: failed to create VHTLC script for chain swap`);
     if (pendingSwap.response.claimDetails.lockupAddress !== vhtlcAddress) {
       throw new SwapError({
         message: "Unable to claim: invalid VHTLC address"
@@ -4628,15 +4567,11 @@ var ArkadeSwaps = class _ArkadeSwaps {
         break;
       }
       if (attempt < CLAIM_VTXO_RETRY_ATTEMPTS) {
-        await new Promise(
-          (resolve) => setTimeout(resolve, CLAIM_VTXO_RETRY_DELAY_MS)
-        );
+        await new Promise((resolve) => setTimeout(resolve, CLAIM_VTXO_RETRY_DELAY_MS));
       }
     }
     if (!vtxo) {
-      throw new Error(
-        `Swap ${pendingSwap.id}: no spendable virtual coins found`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: no spendable virtual coins found`);
     }
     const input = {
       ...vtxo,
@@ -4647,10 +4582,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       amount: BigInt(vtxo.value),
       script: import_sdk8.ArkAddress.decode(address).pkScript
     };
-    const vhtlcIdentity = claimVHTLCIdentity(
-      this.wallet.identity,
-      preimage
-    );
+    const vhtlcIdentity = claimVHTLCIdentity(this.wallet.identity, preimage);
     if ((0, import_sdk8.isRecoverable)(vtxo)) {
       await this.joinBatch(vhtlcIdentity, input, output, arkInfo);
     } else {
@@ -4676,16 +4608,10 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async signCooperativeClaimForServer(pendingSwap) {
     if (!pendingSwap.response.lockupDetails.swapTree)
-      throw new Error(
-        `Swap ${pendingSwap.id}: missing swap tree in lockup details`
-      );
+      throw new Error(`Swap ${pendingSwap.id}: missing swap tree in lockup details`);
     if (!pendingSwap.response.lockupDetails.serverPublicKey)
-      throw new Error(
-        `Swap ${pendingSwap.id}: missing server public key in lockup details`
-      );
-    const claimDetails = await this.swapProvider.getChainClaimDetails(
-      pendingSwap.id
-    );
+      throw new Error(`Swap ${pendingSwap.id}: missing server public key in lockup details`);
+    const claimDetails = await this.swapProvider.getChainClaimDetails(pendingSwap.id);
     const serverPubKey = pendingSwap.response.lockupDetails.serverPublicKey;
     if (claimDetails.publicKey !== serverPubKey) {
       throw new Error(
@@ -4701,9 +4627,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
     );
     const musigNonces = musig.message(import_base9.hex.decode(claimDetails.transactionHash)).generateNonce().aggregateNonces([
       [
-        import_base9.hex.decode(
-          pendingSwap.response.lockupDetails.serverPublicKey
-        ),
+        import_base9.hex.decode(pendingSwap.response.lockupDetails.serverPublicKey),
         import_base9.hex.decode(claimDetails.pubNonce)
       ]
     ]).initializeSession();
@@ -4722,10 +4646,8 @@ var ArkadeSwaps = class _ArkadeSwaps {
    * @returns The transaction ID of the claim.
    */
   async waitAndClaimChain(pendingSwap) {
-    if (pendingSwap.request.to === "ARK")
-      return this.waitAndClaimArk(pendingSwap);
-    if (pendingSwap.request.to === "BTC")
-      return this.waitAndClaimBtc(pendingSwap);
+    if (pendingSwap.request.to === "ARK") return this.waitAndClaimArk(pendingSwap);
+    if (pendingSwap.request.to === "BTC") return this.waitAndClaimBtc(pendingSwap);
     throw new SwapError({
       message: `Unsupported swap destination: ${pendingSwap.request.to}`
     });
@@ -4740,11 +4662,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   async createChainSwap(args) {
     const { to, from, receiverLockAmount, senderLockAmount, toAddress } = args;
-    if (!toAddress)
-      throw new SwapError({ message: "Destination address is required" });
+    if (!toAddress) throw new SwapError({ message: "Destination address is required" });
     const feeSatsPerByte = args.feeSatsPerByte ?? 1;
-    if (feeSatsPerByte <= 0)
-      throw new SwapError({ message: "Invalid feeSatsPerByte" });
+    if (feeSatsPerByte <= 0) throw new SwapError({ message: "Invalid feeSatsPerByte" });
     let amount, serverLockAmount, userLockAmount;
     if (receiverLockAmount) {
       amount = receiverLockAmount;
@@ -4759,8 +4679,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
     }
     const preimage = (0, import_utils3.randomBytes)(32);
     const preimageHash = import_base9.hex.encode((0, import_sha23.sha256)(preimage));
-    if (!preimageHash)
-      throw new SwapError({ message: "Failed to get preimage hash" });
+    if (!preimageHash) throw new SwapError({ message: "Failed to get preimage hash" });
     const ephemeralKey = import_secp256k13.secp256k1.utils.randomSecretKey();
     const refundPublicKey = to === "ARK" ? import_base9.hex.encode(import_secp256k13.secp256k1.getPublicKey(ephemeralKey)) : import_base9.hex.encode(await this.wallet.identity.compressedPublicKey());
     if (!refundPublicKey)
@@ -4809,30 +4728,20 @@ var ArkadeSwaps = class _ArkadeSwaps {
     const { to, from, swap, arkInfo } = args;
     if (from === "ARK") {
       if (!swap.response.lockupDetails.serverPublicKey)
-        throw new Error(
-          `Swap ${swap.id}: missing serverPublicKey in lockup details`
-        );
+        throw new Error(`Swap ${swap.id}: missing serverPublicKey in lockup details`);
       if (!swap.response.lockupDetails.timeouts)
-        throw new Error(
-          `Swap ${swap.id}: missing timeouts in lockup details`
-        );
+        throw new Error(`Swap ${swap.id}: missing timeouts in lockup details`);
     }
     if (to === "ARK") {
       if (!swap.response.claimDetails.serverPublicKey)
-        throw new Error(
-          `Swap ${swap.id}: missing serverPublicKey in claim details`
-        );
+        throw new Error(`Swap ${swap.id}: missing serverPublicKey in claim details`);
       if (!swap.response.claimDetails.timeouts)
-        throw new Error(
-          `Swap ${swap.id}: missing timeouts in claim details`
-        );
+        throw new Error(`Swap ${swap.id}: missing timeouts in claim details`);
     }
     const lockupAddress = to === "ARK" ? swap.response.claimDetails.lockupAddress : swap.response.lockupDetails.lockupAddress;
     const receiverPubkey = to === "ARK" ? swap.request.claimPublicKey : swap.response.lockupDetails.serverPublicKey;
     const senderPubkey = to === "ARK" ? swap.response.claimDetails.serverPublicKey : swap.request.refundPublicKey;
-    const serverPubkey = import_base9.hex.encode(
-      normalizeToXOnlyKey(arkInfo.signerPubkey, "server")
-    );
+    const serverPubkey = import_base9.hex.encode(normalizeToXOnlyKey(arkInfo.signerPubkey, "server"));
     const vhtlcTimeouts = to === "ARK" ? swap.response.claimDetails.timeouts : swap.response.lockupDetails.timeouts;
     const { vhtlcAddress } = this.createVHTLCScript({
       network: arkInfo.network,
@@ -4850,15 +4759,122 @@ var ArkadeSwaps = class _ArkadeSwaps {
     return true;
   }
   /**
-   * Renegotiates the quote for an existing swap.
+   * Renegotiates the quote for an existing chain swap. Convenience wrapper
+   * over `getSwapQuote` + `acceptSwapQuote` with a safety floor.
+   *
+   * The floor is resolved in order:
+   *   1. `options.minAcceptableAmount` if provided.
+   *   2. The original `response.claimDetails.amount` of the stored
+   *      pending swap (Boltz-confirmed server-lock amount at creation).
+   *   3. Otherwise throws `QuoteRejectedError({ reason: "no_baseline" })`.
+   *
+   * `options.maxSlippageBps` (default 0) relaxes the floor by basis points.
+   * Quotes ≤ 0 are always rejected. On rejection the acceptance is NOT
+   * posted to Boltz.
+   *
+   * Prefer `getSwapQuote` / `acceptSwapQuote` for callers that want to
+   * inspect the quote before committing.
+   *
    * @param swapId - The ID of the swap.
+   * @param options - Optional floor and slippage configuration.
    * @returns The accepted quote amount.
+   * @throws QuoteRejectedError if the quote is non-positive, below the
+   *     effective floor, or no baseline is available.
+   */
+  async quoteSwap(swapId, options) {
+    const effectiveFloor = await this.resolveEffectiveFloor(swapId, options);
+    const amount = await this.getSwapQuote(swapId);
+    this.validateQuote(amount, effectiveFloor);
+    await this.swapProvider.postChainQuote(swapId, { amount });
+    return amount;
+  }
+  /**
+   * Fetches a renegotiated quote from Boltz without accepting it.
+   * Pair with `acceptSwapQuote` to commit a specific value.
    */
-  async quoteSwap(swapId) {
+  async getSwapQuote(swapId) {
     const { amount } = await this.swapProvider.getChainQuote(swapId);
+    return amount;
+  }
+  /**
+   * Accepts a quote amount for an existing chain swap, after validating it
+   * against the configured floor. See `quoteSwap` for floor-resolution rules.
+   *
+   * @throws QuoteRejectedError if `amount` ≤ 0, below the effective floor,
+   *     or no baseline is available.
+   */
+  async acceptSwapQuote(swapId, amount, options) {
+    const effectiveFloor = await this.resolveEffectiveFloor(swapId, options);
+    this.validateQuote(amount, effectiveFloor);
     await this.swapProvider.postChainQuote(swapId, { amount });
     return amount;
   }
+  async resolveEffectiveFloor(swapId, options) {
+    this.validateQuoteOptions(options);
+    const floor = await this.resolveQuoteFloor(swapId, options);
+    const slippageBps = options?.maxSlippageBps ?? 0;
+    const effectiveFloor = Math.floor(floor - floor * slippageBps / 1e4);
+    if (effectiveFloor < 1) {
+      throw new TypeError(
+        `Invalid quote configuration: maxSlippageBps=${slippageBps} reduces floor ${floor} below 1 sat`
+      );
+    }
+    return effectiveFloor;
+  }
+  async resolveQuoteFloor(swapId, options) {
+    if (options?.minAcceptableAmount !== void 0) {
+      return options.minAcceptableAmount;
+    }
+    const swaps = await this.swapRepository.getAllSwaps({
+      id: swapId,
+      type: "chain"
+    });
+    const stored = swaps[0];
+    const amount = stored?.response?.claimDetails?.amount;
+    if (typeof amount !== "number") {
+      throw new QuoteRejectedError({ reason: "no_baseline" });
+    }
+    return amount;
+  }
+  validateQuoteOptions(options) {
+    if (options?.minAcceptableAmount !== void 0) {
+      const v = options.minAcceptableAmount;
+      if (!Number.isInteger(v) || v <= 0) {
+        throw new TypeError(
+          `Invalid minAcceptableAmount: ${v} \u2014 must be a positive integer`
+        );
+      }
+    }
+    if (options?.maxSlippageBps !== void 0) {
+      const v = options.maxSlippageBps;
+      if (!Number.isInteger(v) || v < 0 || v > 1e4) {
+        throw new TypeError(
+          `Invalid maxSlippageBps: ${v} \u2014 must be an integer in [0, 10000]`
+        );
+      }
+    }
+  }
+  validateQuote(amount, effectiveFloor) {
+    if (!Number.isSafeInteger(amount)) {
+      throw new QuoteRejectedError({
+        reason: "non_safe_integer",
+        quotedAmount: amount
+      });
+    }
+    if (amount <= 0) {
+      throw new QuoteRejectedError({
+        reason: "non_positive",
+        quotedAmount: amount
+      });
+    }
+    if (amount < effectiveFloor) {
+      throw new QuoteRejectedError({
+        reason: "below_floor",
+        quotedAmount: amount,
+        floor: effectiveFloor
+      });
+    }
+  }
   // =========================================================================
   // Shared utilities
   // =========================================================================
@@ -4872,14 +4888,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
    * @returns The commitment transaction ID.
    */
   async joinBatch(identity, input, output, arkInfo, isRecoverable2 = true) {
-    return joinBatch(
-      this.arkProvider,
-      identity,
-      input,
-      output,
-      arkInfo,
-      isRecoverable2
-    );
+    return joinBatch(this.arkProvider, identity, input, output, arkInfo, isRecoverable2);
   }
   /**
    * Creates a VHTLC script for the swap.
@@ -4917,9 +4926,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
   async getPendingSubmarineSwaps() {
     const swaps = await this.getPendingSubmarineSwapsFromStorage();
     if (!swaps) return [];
-    return swaps.filter(
-      (swap) => swap.status === "invoice.set"
-    );
+    return swaps.filter((swap) => swap.status === "invoice.set");
   }
   /**
    * Returns pending reverse swaps (those with status `swap.created`).
@@ -4927,9 +4934,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
   async getPendingReverseSwaps() {
     const swaps = await this.getPendingReverseSwapsFromStorage();
     if (!swaps) return [];
-    return swaps.filter(
-      (swap) => swap.status === "swap.created"
-    );
+    return swaps.filter((swap) => swap.status === "swap.created");
   }
   /**
    * Returns pending chain swaps (those with status `swap.created`).
@@ -4968,10 +4973,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
             this.savePendingReverseSwap.bind(this)
           )
         ).catch((error) => {
-          logger.error(
-            `Failed to refresh swap status for ${swap.id}:`,
-            error
-          );
+          logger.error(`Failed to refresh swap status for ${swap.id}:`, error);
         })
       );
     }
@@ -4985,23 +4987,15 @@ var ArkadeSwaps = class _ArkadeSwaps {
             this.savePendingSubmarineSwap.bind(this)
           )
         ).catch((error) => {
-          logger.error(
-            `Failed to refresh swap status for ${swap.id}:`,
-            error
-          );
+          logger.error(`Failed to refresh swap status for ${swap.id}:`, error);
         })
       );
     }
     for (const swap of await this.getPendingChainSwapsFromStorage()) {
       if (isChainFinalStatus(swap.status)) continue;
       promises.push(
-        this.getSwapStatus(swap.id).then(
-          ({ status }) => this.savePendingChainSwap({ ...swap, status })
-        ).catch((error) => {
-          logger.error(
-            `Failed to refresh swap status for ${swap.id}:`,
-            error
-          );
+        this.getSwapStatus(swap.id).then(({ status }) => this.savePendingChainSwap({ ...swap, status })).catch((error) => {
+          logger.error(`Failed to refresh swap status for ${swap.id}:`, error);
         })
       );
     }
@@ -5018,9 +5012,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
    * display/monitoring and are not automatically wired into the SwapManager.
    */
   async restoreSwaps(boltzFees) {
-    const publicKey = import_base9.hex.encode(
-      await this.wallet.identity.compressedPublicKey()
-    );
+    const publicKey = import_base9.hex.encode(await this.wallet.identity.compressedPublicKey());
     if (!publicKey) throw new Error("Failed to get public key from wallet");
     const fees = boltzFees ?? await this.swapProvider.getFees();
     const chainSwaps = [];
@@ -5072,25 +5064,14 @@ var ArkadeSwaps = class _ArkadeSwaps {
           preimage: ""
         });
       } else if (isRestoredSubmarineSwap(swap)) {
-        const {
-          amount,
-          lockupAddress,
-          serverPublicKey,
-          tree,
-          timeoutBlockHeights
-        } = swap.refundDetails;
+        const { amount, lockupAddress, serverPublicKey, tree, timeoutBlockHeights } = swap.refundDetails;
         let preimage = "";
         if (!isSubmarineFinalStatus(status)) {
           try {
-            const data = await this.swapProvider.getSwapPreimage(
-              swap.id
-            );
+            const data = await this.swapProvider.getSwapPreimage(swap.id);
             preimage = data.preimage;
           } catch (error) {
-            logger.warn(
-              `Failed to restore preimage for submarine swap ${id}`,
-              error
-            );
+            logger.warn(`Failed to restore preimage for submarine swap ${id}`, error);
           }
         }
         submarineSwaps.push({
@@ -5128,12 +5109,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
       } else if (isRestoredChainSwap(swap)) {
         const refundDetails = swap.refundDetails;
         if (!refundDetails) continue;
-        const {
-          amount,
-          lockupAddress,
-          serverPublicKey,
-          timeoutBlockHeight
-        } = refundDetails;
+        const { amount, lockupAddress, serverPublicKey, timeoutBlockHeight } = refundDetails;
         chainSwaps.push({
           id,
           type: "chain",
@@ -5185,9 +5161,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
 var SWAP_POLL_TASK_TYPE = "swap-poll";
 
 // src/expo/arkade-lightning.ts
-function getRandomId() {
-  return Math.random().toString(36).slice(2) + Date.now().toString(36);
-}
+var import_sdk9 = require("@arkade-os/sdk");
 function warnOnRemovedBackgroundFields(bg) {
   if (!bg || typeof bg !== "object") return;
   const removed = [];
@@ -5243,9 +5217,7 @@ var ExpoArkadeSwaps = class _ExpoArkadeSwaps {
     const instance = new _ExpoArkadeSwaps(inner, config);
     await instance.seedSwapPollTask();
     if (config.background.foregroundIntervalMs && config.background.foregroundIntervalMs > 0) {
-      instance.startForegroundPolling(
-        config.background.foregroundIntervalMs
-      );
+      instance.startForegroundPolling(config.background.foregroundIntervalMs);
     }
     return instance;
   }
@@ -5259,9 +5231,7 @@ var ExpoArkadeSwaps = class _ExpoArkadeSwaps {
     const { taskQueue } = this.config.background;
     const results = await taskQueue.getResults();
     if (results.length > 0) {
-      await taskQueue.acknowledgeResults(
-        results.map((r) => r.id)
-      );
+      await taskQueue.acknowledgeResults(results.map((r) => r.id));
     }
     await this.seedSwapPollTask();
   }
@@ -5270,7 +5240,7 @@ var ExpoArkadeSwaps = class _ExpoArkadeSwaps {
     const existing = await taskQueue.getTasks(SWAP_POLL_TASK_TYPE);
     if (existing.length > 0) return;
     const task = {
-      id: getRandomId(),
+      id: (0, import_sdk9.getRandomId)(),
       type: SWAP_POLL_TASK_TYPE,
       data: {},
       createdAt: Date.now()
@@ -5387,17 +5357,17 @@ var ExpoArkadeSwaps = class _ExpoArkadeSwaps {
   verifyChainSwap(args) {
     return this.inner.verifyChainSwap(args);
   }
-  quoteSwap(swapId) {
-    return this.inner.quoteSwap(swapId);
+  quoteSwap(swapId, options) {
+    return this.inner.quoteSwap(swapId, options);
+  }
+  getSwapQuote(swapId) {
+    return this.inner.getSwapQuote(swapId);
+  }
+  acceptSwapQuote(swapId, amount, options) {
+    return this.inner.acceptSwapQuote(swapId, amount, options);
   }
   joinBatch(identity, input, output, arkInfo, isRecoverable2) {
-    return this.inner.joinBatch(
-      identity,
-      input,
-      output,
-      arkInfo,
-      isRecoverable2
-    );
+    return this.inner.joinBatch(identity, input, output, arkInfo, isRecoverable2);
   }
   createVHTLCScript(params) {
     return this.inner.createVHTLCScript(params);