@arkade-os/boltz-swap 0.3.32 → 0.3.33

package/dist/expo/background.cjs

@@ -41,6 +41,7 @@ var TaskManager = __toESM(require("expo-task-manager"), 1);
 var BackgroundTask = __toESM(require("expo-background-task"), 1);
 var import_expo = require("@arkade-os/sdk/worker/expo");
 var import_expo2 = require("@arkade-os/sdk/adapters/expo");
+var import_sdk9 = require("@arkade-os/sdk");
 
 // src/boltz-swap-provider.ts
 var import_sdk = require("@arkade-os/sdk");
@@ -54,7 +55,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;
@@ -131,6 +135,96 @@ 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 "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":
+        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",
+  "no_baseline"
+]);
 var BoltzRefundError = class extends Error {
   constructor(message, cause) {
     super(message);
@@ -142,18 +236,10 @@ var BoltzRefundError = class extends Error {
 // src/boltz-swap-provider.ts
 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";
@@ -172,10 +258,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 [
@@ -292,8 +375,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 {
@@ -307,10 +389,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";
   }
@@ -329,10 +408,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))
@@ -352,10 +428,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 {
@@ -365,10 +438,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"
@@ -398,10 +468,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);
@@ -497,12 +564,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"
@@ -557,12 +622,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. */
@@ -581,53 +642,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":
@@ -636,13 +697,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":
@@ -652,9 +713,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). */
@@ -662,10 +791,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]) {
@@ -680,10 +806,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]) {
@@ -812,9 +935,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}`);
     }
   }
 };
@@ -837,8 +958,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);
@@ -846,9 +966,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) {
@@ -895,18 +1013,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
@@ -914,12 +1026,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;
@@ -951,10 +1062,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,
@@ -964,12 +1073,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;
@@ -1015,11 +1122,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;
@@ -1028,12 +1131,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 {
@@ -1047,14 +1145,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);
@@ -1062,14 +1157,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
@@ -1145,9 +1233,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;
@@ -1159,9 +1245,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) => {
@@ -1176,8 +1260,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,
@@ -1196,9 +1279,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
@@ -1206,9 +1287,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),
@@ -1271,10 +1350,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;
@@ -1378,9 +1454,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;
@@ -1531,9 +1605,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) {
@@ -1542,10 +1614,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();
@@ -1630,9 +1699,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)) {
@@ -1649,31 +1716,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}`));
           }
         }
       };
@@ -1716,16 +1771,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);
@@ -1765,9 +1816,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"));
     }
   }
   /**
@@ -1802,11 +1851,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;
@@ -1821,8 +1867,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",
@@ -1845,9 +1890,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;
@@ -1865,19 +1908,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);
         }
       });
     }
@@ -1902,9 +1940,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 {
@@ -1919,9 +1955,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) {
@@ -1933,9 +1967,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)) {
@@ -1985,13 +2017,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);
     }
@@ -2092,9 +2119,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) {
@@ -2153,9 +2178,7 @@ var SwapManager = class _SwapManager {
   }
   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);
@@ -2166,9 +2189,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(
@@ -2176,25 +2197,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)
         );
@@ -2246,9 +2259,7 @@ var SwapManager = class _SwapManager {
       this.pollRetryTimers.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) => {
@@ -2313,9 +2324,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) {
@@ -2372,6 +2381,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";
@@ -2387,6 +2416,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;
@@ -2401,10 +2434,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();
@@ -2414,10 +2444,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();
@@ -2430,10 +2457,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();
@@ -2450,11 +2474,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) {
@@ -2464,9 +2487,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) => {
@@ -2476,34 +2498,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);
@@ -2513,22 +2518,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");
@@ -2548,30 +2538,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");
@@ -2583,13 +2555,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;
@@ -2644,17 +2611,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) {
@@ -2670,18 +2633,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) => {
@@ -2689,9 +2645,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();
@@ -2706,9 +2660,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())]);
     }
   };
 }
@@ -2768,36 +2720,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 };
@@ -2831,11 +2769,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),
@@ -2859,14 +2793,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
     });
@@ -2887,14 +2815,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()),
@@ -2902,9 +2824,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");
@@ -2914,13 +2834,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());
@@ -2930,61 +2846,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
@@ -3008,25 +2900,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);
@@ -3034,21 +2917,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;
@@ -3084,10 +2967,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 });
@@ -3098,16 +2978,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) {
@@ -3118,10 +2993,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);
@@ -3269,19 +3141,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,
@@ -3311,18 +3179,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();
@@ -3367,15 +3231,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`);
     }
     if (vtxo.isSpent) {
       throw new Error(`Swap ${pendingSwap.id}: VHTLC is already spent`);
@@ -3389,10 +3249,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);
     let finalStatus;
     if ((0, import_sdk8.isRecoverable)(vtxo)) {
       await this.joinBatch(vhtlcIdentity, input, output, arkInfo);
@@ -3511,9 +3368,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,
@@ -3546,9 +3401,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"
@@ -3586,9 +3439,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(),
@@ -3602,9 +3453,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",
@@ -3619,9 +3468,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}`
@@ -3660,10 +3507,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({
@@ -3683,13 +3527,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,
@@ -3753,19 +3592,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;
@@ -3817,9 +3650,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
           input,
           output,
           arkInfo,
-          this.swapProvider.refundSubmarineSwap.bind(
-            this.swapProvider
-          )
+          this.swapProvider.refundSubmarineSwap.bind(this.swapProvider)
         );
         boltzCallCount++;
         sweptCount++;
@@ -3842,13 +3673,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++;
       }
     }
@@ -3944,10 +3769,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
         try {
           return {
             swap,
-            context: await this.buildSubmarineVHTLCContext(
-              swap,
-              arkInfo
-            )
+            context: await this.buildSubmarineVHTLCContext(swap, arkInfo)
           };
         } catch (err) {
           return {
@@ -3960,9 +3782,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([
@@ -3997,9 +3817,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
@@ -4178,9 +3996,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) => {
@@ -4207,24 +4023,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();
@@ -4262,30 +4079,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),
@@ -4306,19 +4111,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,
@@ -4332,14 +4132,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();
@@ -4359,13 +4155,9 @@ var ArkadeSwaps = class _ArkadeSwaps {
    */
   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(
@@ -4407,9 +4199,7 @@ 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"
@@ -4490,9 +4280,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) => {
@@ -4513,37 +4301,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(
@@ -4583,17 +4367,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();
@@ -4605,10 +4383,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),
@@ -4618,9 +4393,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"
@@ -4637,15 +4410,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,
@@ -4656,10 +4425,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 {
@@ -4685,16 +4451,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(
@@ -4710,9 +4470,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();
@@ -4731,10 +4489,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}`
     });
@@ -4749,11 +4505,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;
@@ -4768,8 +4522,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)
@@ -4818,30 +4571,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,
@@ -4859,15 +4602,110 @@ 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) {
+  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 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;
+    return Math.floor(floor - floor * slippageBps / 1e4);
+  }
+  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 (!(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
   // =========================================================================
@@ -4881,14 +4719,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.
@@ -4926,9 +4757,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`).
@@ -4936,9 +4765,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`).
@@ -4977,10 +4804,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);
         })
       );
     }
@@ -4994,23 +4818,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);
         })
       );
     }
@@ -5027,9 +4843,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 = [];
@@ -5081,25 +4895,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({
@@ -5137,12 +4940,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",
@@ -5195,19 +4993,11 @@ var SWAP_POLL_TASK_TYPE = "swap-poll";
 var swapsPollProcessor = {
   taskType: SWAP_POLL_TASK_TYPE,
   async execute(item, deps) {
-    const {
-      swapRepository,
-      swapProvider,
-      wallet,
-      arkProvider,
-      indexerProvider
-    } = deps;
+    const { swapRepository, swapProvider, wallet, arkProvider, indexerProvider } = deps;
     const allSwaps = await swapRepository.getAllSwaps();
     const pendingSwaps = allSwaps.filter((swap) => {
-      if (isPendingReverseSwap(swap))
-        return !isReverseFinalStatus(swap.status);
-      if (isPendingSubmarineSwap(swap))
-        return !isSubmarineFinalStatus(swap.status);
+      if (isPendingReverseSwap(swap)) return !isReverseFinalStatus(swap.status);
+      if (isPendingSubmarineSwap(swap)) return !isSubmarineFinalStatus(swap.status);
       return false;
     });
     let polled = 0;
@@ -5237,19 +5027,14 @@ var swapsPollProcessor = {
           }
           if (isPendingReverseSwap(swap) && isReverseClaimableStatus(currentStatus)) {
             if (!swap.preimage) {
-              logger.warn(
-                `[swap-poll] Skipping claim for ${swap.id}: no preimage`
-              );
+              logger.warn(`[swap-poll] Skipping claim for ${swap.id}: no preimage`);
               continue;
             }
             try {
               await tempSwaps.claimVHTLC(swap);
               claimed++;
             } catch (claimError) {
-              logger.error(
-                `[swap-poll] Claim failed for ${swap.id}:`,
-                claimError
-              );
+              logger.error(`[swap-poll] Claim failed for ${swap.id}:`, claimError);
               errors++;
             }
           }
@@ -5265,18 +5050,12 @@ var swapsPollProcessor = {
               await tempSwaps.refundVHTLC(swapWithStatus);
               refunded++;
             } catch (refundError) {
-              logger.error(
-                `[swap-poll] Refund failed for ${swap.id}:`,
-                refundError
-              );
+              logger.error(`[swap-poll] Refund failed for ${swap.id}:`, refundError);
               errors++;
             }
           }
         } catch (swapError) {
-          logger.error(
-            `[swap-poll] Error processing swap ${swap.id}:`,
-            swapError
-          );
+          logger.error(`[swap-poll] Error processing swap ${swap.id}:`, swapError);
           errors++;
         }
       }
@@ -5293,9 +5072,6 @@ var swapsPollProcessor = {
 };
 
 // src/expo/background.ts
-function getRandomId() {
-  return Math.random().toString(36).slice(2) + Date.now().toString(36);
-}
 function createBackgroundWalletShim(args) {
   const notImplemented = (method) => {
     throw new Error(
@@ -5330,9 +5106,7 @@ function defineExpoSwapBackgroundTask(taskName, options) {
       }
       const identity = await identityFactory();
       const arkProvider = new import_expo2.ExpoArkProvider(config.arkServerUrl);
-      const indexerProvider = new import_expo2.ExpoIndexerProvider(
-        config.arkServerUrl
-      );
+      const indexerProvider = new import_expo2.ExpoIndexerProvider(config.arkServerUrl);
       const swapProvider = new BoltzSwapProvider({
         network: config.network,
         apiUrl: config.boltzApiUrl
@@ -5347,11 +5121,7 @@ function defineExpoSwapBackgroundTask(taskName, options) {
           const serverPubKey = hex9.decode(info.signerPubkey);
           const xOnlyServerPubKey = serverPubKey.length === 33 ? serverPubKey.slice(1) : serverPubKey;
           const hrp = info.network === "bitcoin" ? "ark" : "tark";
-          return new ArkAddress3(
-            xOnlyServerPubKey,
-            pubkey,
-            hrp
-          ).encode();
+          return new ArkAddress3(xOnlyServerPubKey, pubkey, hrp).encode();
         }
       });
       const deps = {
@@ -5365,14 +5135,12 @@ function defineExpoSwapBackgroundTask(taskName, options) {
       await (0, import_expo.runTasks)(taskQueue, [swapsPollProcessor], deps);
       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));
       }
       const existing = await taskQueue.getTasks(SWAP_POLL_TASK_TYPE);
       if (existing.length === 0) {
         const task = {
-          id: getRandomId(),
+          id: (0, import_sdk9.getRandomId)(),
           type: SWAP_POLL_TASK_TYPE,
           data: {},
           createdAt: Date.now()