@arkade-os/boltz-swap 0.3.32 → 0.3.33

package/dist/index.cjs

@@ -41,6 +41,7 @@ __export(index_exports, {
   InvoiceFailedToPayError: () => InvoiceFailedToPayError,
   NetworkError: () => NetworkError,
   PreimageFetchError: () => PreimageFetchError,
+  QuoteRejectedError: () => QuoteRejectedError,
   SchemaError: () => SchemaError,
   ServiceWorkerArkadeLightning: () => ServiceWorkerArkadeSwaps,
   ServiceWorkerArkadeSwaps: () => ServiceWorkerArkadeSwaps,
@@ -99,7 +100,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;
@@ -191,6 +195,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);
@@ -206,18 +300,10 @@ var import_sdk8 = require("@arkade-os/sdk");
 var import_sdk = require("@arkade-os/sdk");
 var import_base = require("@scure/base");
 var isSubmarineFailedStatus = (status) => {
-  return [
-    "invoice.failedToPay",
-    "transaction.lockupFailed",
-    "swap.expired"
-  ].includes(status);
+  return ["invoice.failedToPay", "transaction.lockupFailed", "swap.expired"].includes(status);
 };
 var isSubmarineFinalStatus = (status) => {
-  return [
-    "invoice.failedToPay",
-    "transaction.claimed",
-    "swap.expired"
-  ].includes(status);
+  return ["invoice.failedToPay", "transaction.claimed", "swap.expired"].includes(status);
 };
 var isSubmarinePendingStatus = (status) => {
   return [
@@ -231,11 +317,7 @@ var isSubmarinePendingStatus = (status) => {
   ].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";
@@ -259,11 +341,7 @@ var isReverseFinalStatus = (status) => {
   ].includes(status);
 };
 var isReversePendingStatus = (status) => {
-  return [
-    "swap.created",
-    "transaction.mempool",
-    "transaction.confirmed"
-  ].includes(status);
+  return ["swap.created", "transaction.mempool", "transaction.confirmed"].includes(status);
 };
 var isReverseClaimableStatus = (status) => {
   return ["transaction.mempool", "transaction.confirmed"].includes(status);
@@ -275,10 +353,7 @@ var isChainFailedStatus = (status) => {
   return ["transaction.failed", "swap.expired"].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 [
@@ -417,8 +492,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 {
@@ -432,10 +506,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";
   }
@@ -454,10 +525,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))
@@ -477,10 +545,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 {
@@ -490,10 +555,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"
@@ -523,10 +585,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);
@@ -622,12 +681,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"
@@ -682,12 +739,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. */
@@ -706,53 +759,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":
@@ -761,13 +814,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":
@@ -777,9 +830,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). */
@@ -787,10 +908,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]) {
@@ -805,10 +923,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]) {
@@ -937,9 +1052,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}`);
     }
   }
 };
@@ -961,8 +1074,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);
@@ -970,9 +1082,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) {
@@ -1019,18 +1129,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
@@ -1038,12 +1142,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;
@@ -1075,10 +1178,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,
@@ -1088,12 +1189,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;
@@ -1139,11 +1238,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;
@@ -1152,12 +1247,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 {
@@ -1171,14 +1261,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);
@@ -1186,14 +1273,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
@@ -1269,9 +1349,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;
@@ -1283,9 +1361,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) => {
@@ -1300,8 +1376,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,
@@ -1320,9 +1395,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
@@ -1330,9 +1403,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),
@@ -1406,10 +1477,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;
@@ -1516,9 +1584,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;
@@ -1669,9 +1735,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) {
@@ -1680,10 +1744,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();
@@ -1768,9 +1829,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)) {
@@ -1787,31 +1846,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}`));
           }
         }
       };
@@ -1854,16 +1901,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);
@@ -1903,9 +1946,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"));
     }
   }
   /**
@@ -1940,11 +1981,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;
@@ -1959,8 +1997,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",
@@ -1983,9 +2020,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;
@@ -2003,19 +2038,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);
         }
       });
     }
@@ -2040,9 +2070,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 {
@@ -2057,9 +2085,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) {
@@ -2071,9 +2097,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)) {
@@ -2123,13 +2147,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);
     }
@@ -2230,9 +2249,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) {
@@ -2291,9 +2308,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);
@@ -2304,9 +2319,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(
@@ -2314,25 +2327,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)
         );
@@ -2384,9 +2389,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) => {
@@ -2451,9 +2454,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) {
@@ -2517,6 +2518,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";
@@ -2532,6 +2553,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;
@@ -2546,10 +2571,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();
@@ -2559,10 +2581,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();
@@ -2575,10 +2594,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();
@@ -2595,11 +2611,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) {
@@ -2609,9 +2624,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) => {
@@ -2621,34 +2635,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);
@@ -2658,22 +2655,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");
@@ -2693,30 +2675,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");
@@ -2728,13 +2692,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;
@@ -2789,17 +2748,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) {
@@ -2815,18 +2770,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) => {
@@ -2834,9 +2782,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();
@@ -2851,9 +2797,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())]);
     }
   };
 }
@@ -2913,36 +2857,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 };
@@ -2976,11 +2906,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),
@@ -3004,14 +2930,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
     });
@@ -3032,14 +2952,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()),
@@ -3047,9 +2961,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");
@@ -3059,13 +2971,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());
@@ -3075,61 +2983,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
@@ -3153,25 +3037,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);
@@ -3179,21 +3054,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;
@@ -3229,10 +3104,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 });
@@ -3243,16 +3115,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) {
@@ -3263,10 +3130,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);
@@ -3414,19 +3278,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,
@@ -3456,18 +3316,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();
@@ -3512,15 +3368,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`);
@@ -3534,10 +3386,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);
@@ -3656,9 +3505,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,
@@ -3691,9 +3538,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"
@@ -3731,9 +3576,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(),
@@ -3747,9 +3590,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",
@@ -3764,9 +3605,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}`
@@ -3805,10 +3644,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({
@@ -3828,13 +3664,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,
@@ -3898,19 +3729,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;
@@ -3962,9 +3787,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
           input,
           output,
           arkInfo,
-          this.swapProvider.refundSubmarineSwap.bind(
-            this.swapProvider
-          )
+          this.swapProvider.refundSubmarineSwap.bind(this.swapProvider)
         );
         boltzCallCount++;
         sweptCount++;
@@ -3987,13 +3810,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++;
       }
     }
@@ -4089,10 +3906,7 @@ var ArkadeSwaps = class _ArkadeSwaps {
         try {
           return {
             swap,
-            context: await this.buildSubmarineVHTLCContext(
-              swap,
-              arkInfo
-            )
+            context: await this.buildSubmarineVHTLCContext(swap, arkInfo)
           };
         } catch (err) {
           return {
@@ -4105,9 +3919,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([
@@ -4142,9 +3954,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
@@ -4323,9 +4133,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) => {
@@ -4352,24 +4160,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();
@@ -4407,30 +4216,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),
@@ -4451,19 +4248,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,
@@ -4477,14 +4269,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();
@@ -4504,13 +4292,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(
@@ -4552,9 +4336,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"
@@ -4635,9 +4417,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) => {
@@ -4658,37 +4438,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(
@@ -4728,17 +4504,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();
@@ -4750,10 +4520,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),
@@ -4763,9 +4530,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"
@@ -4782,15 +4547,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,
@@ -4801,10 +4562,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 {
@@ -4830,16 +4588,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(
@@ -4855,9 +4607,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();
@@ -4876,10 +4626,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}`
     });
@@ -4894,11 +4642,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;
@@ -4913,8 +4659,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)
@@ -4963,30 +4708,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,
@@ -5004,15 +4739,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
   // =========================================================================
@@ -5026,14 +4856,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.
@@ -5071,9 +4894,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`).
@@ -5081,9 +4902,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`).
@@ -5122,10 +4941,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);
         })
       );
     }
@@ -5139,23 +4955,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);
         })
       );
     }
@@ -5172,9 +4980,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 = [];
@@ -5226,25 +5032,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({
@@ -5282,12 +5077,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",
@@ -5337,6 +5127,12 @@ var ArkadeSwaps = class _ArkadeSwaps {
 
 // src/serviceWorker/arkade-swaps-message-handler.ts
 var import_sdk9 = require("@arkade-os/sdk");
+function toQuoteTransportError(error) {
+  if (error instanceof QuoteRejectedError) {
+    return error.toTransportError();
+  }
+  return error;
+}
 var DEFAULT_MESSAGE_TAG = "ARKADE_SWAPS_UPDATER";
 var HANDLER_NOT_INITIALIZED = "ArkadeSwaps handler not initialized";
 var HandlerNotInitializedError = class extends Error {
@@ -5452,9 +5248,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
     try {
       switch (message.type) {
         case "CREATE_LIGHTNING_INVOICE": {
-          const res = await this.handler.createLightningInvoice(
-            message.payload
-          );
+          const res = await this.handler.createLightningInvoice(message.payload);
           return this.tagged({
             id,
             type: "LIGHTNING_INVOICE_CREATED",
@@ -5462,9 +5256,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "SEND_LIGHTNING_PAYMENT": {
-          const res = await this.handler.sendLightningPayment(
-            message.payload
-          );
+          const res = await this.handler.sendLightningPayment(message.payload);
           return this.tagged({
             id,
             type: "LIGHTNING_PAYMENT_SENT",
@@ -5472,9 +5264,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "CREATE_SUBMARINE_SWAP": {
-          const res = await this.handler.createSubmarineSwap(
-            message.payload
-          );
+          const res = await this.handler.createSubmarineSwap(message.payload);
           return this.tagged({
             id,
             type: "SUBMARINE_SWAP_CREATED",
@@ -5482,9 +5272,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "CREATE_REVERSE_SWAP": {
-          const res = await this.handler.createReverseSwap(
-            message.payload
-          );
+          const res = await this.handler.createReverseSwap(message.payload);
           return this.tagged({
             id,
             type: "REVERSE_SWAP_CREATED",
@@ -5495,9 +5283,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           await this.handler.claimVHTLC(message.payload);
           return this.tagged({ id, type: "VHTLC_CLAIMED" });
         case "REFUND_VHTLC": {
-          const outcome = await this.handler.refundVHTLC(
-            message.payload
-          );
+          const outcome = await this.handler.refundVHTLC(message.payload);
           return this.tagged({
             id,
             type: "VHTLC_REFUNDED",
@@ -5505,9 +5291,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "INSPECT_SUBMARINE_RECOVERY": {
-          const info = await this.handler.inspectSubmarineRecovery(
-            message.payload
-          );
+          const info = await this.handler.inspectSubmarineRecovery(message.payload);
           return this.tagged({
             id,
             type: "SUBMARINE_RECOVERY_INSPECTED",
@@ -5523,9 +5307,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "RECOVER_SUBMARINE_FUNDS": {
-          const outcome = await this.handler.recoverSubmarineFunds(
-            message.payload
-          );
+          const outcome = await this.handler.recoverSubmarineFunds(message.payload);
           return this.tagged({
             id,
             type: "SUBMARINE_FUNDS_RECOVERED",
@@ -5533,9 +5315,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "RECOVER_ALL_SUBMARINE_FUNDS": {
-          const results = await this.handler.recoverAllSubmarineFunds(
-            message.payload
-          );
+          const results = await this.handler.recoverAllSubmarineFunds(message.payload);
           return this.tagged({
             id,
             type: "ALL_SUBMARINE_FUNDS_RECOVERED",
@@ -5543,9 +5323,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "WAIT_AND_CLAIM": {
-          const res = await this.handler.waitAndClaim(
-            message.payload
-          );
+          const res = await this.handler.waitAndClaim(message.payload);
           return this.tagged({
             id,
             type: "WAIT_AND_CLAIMED",
@@ -5553,9 +5331,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "WAIT_FOR_SWAP_SETTLEMENT": {
-          const res = await this.handler.waitForSwapSettlement(
-            message.payload
-          );
+          const res = await this.handler.waitForSwapSettlement(message.payload);
           return this.tagged({
             id,
             type: "SWAP_SETTLED",
@@ -5563,9 +5339,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "RESTORE_SWAPS": {
-          const res = await this.handler.restoreSwaps(
-            message.payload
-          );
+          const res = await this.handler.restoreSwaps(message.payload);
           return this.tagged({
             id,
             type: "SWAPS_RESTORED",
@@ -5595,23 +5369,15 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "GET_FEES": {
-          const res = message.payload ? await this.handler.getFees(
-            message.payload.from,
-            message.payload.to
-          ) : await this.handler.getFees();
+          const res = message.payload ? await this.handler.getFees(message.payload.from, message.payload.to) : await this.handler.getFees();
           return this.tagged({ id, type: "FEES", payload: res });
         }
         case "GET_LIMITS": {
-          const res = message.payload ? await this.handler.getLimits(
-            message.payload.from,
-            message.payload.to
-          ) : await this.handler.getLimits();
+          const res = message.payload ? await this.handler.getLimits(message.payload.from, message.payload.to) : await this.handler.getLimits();
           return this.tagged({ id, type: "LIMITS", payload: res });
         }
         case "GET_SWAP_STATUS": {
-          const res = await this.handler.getSwapStatus(
-            message.payload.swapId
-          );
+          const res = await this.handler.getSwapStatus(message.payload.swapId);
           return this.tagged({
             id,
             type: "SWAP_STATUS",
@@ -5670,9 +5436,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "CREATE_CHAIN_SWAP": {
-          const res = await this.handler.createChainSwap(
-            message.payload
-          );
+          const res = await this.handler.createChainSwap(message.payload);
           return this.tagged({
             id,
             type: "CHAIN_SWAP_CREATED",
@@ -5680,9 +5444,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "WAIT_AND_CLAIM_CHAIN": {
-          const res = await this.handler.waitAndClaimChain(
-            message.payload
-          );
+          const res = await this.handler.waitAndClaimChain(message.payload);
           return this.tagged({
             id,
             type: "CHAIN_CLAIMED",
@@ -5690,9 +5452,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "WAIT_AND_CLAIM_ARK": {
-          const res = await this.handler.waitAndClaimArk(
-            message.payload
-          );
+          const res = await this.handler.waitAndClaimArk(message.payload);
           return this.tagged({
             id,
             type: "ARK_CLAIMED",
@@ -5700,9 +5460,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "WAIT_AND_CLAIM_BTC": {
-          const res = await this.handler.waitAndClaimBtc(
-            message.payload
-          );
+          const res = await this.handler.waitAndClaimBtc(message.payload);
           return this.tagged({
             id,
             type: "BTC_CLAIMED",
@@ -5719,9 +5477,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           await this.handler.refundArk(message.payload);
           return this.tagged({ id, type: "ARK_REFUND_EXECUTED" });
         case "SIGN_SERVER_CLAIM":
-          await this.handler.signCooperativeClaimForServer(
-            message.payload
-          );
+          await this.handler.signCooperativeClaimForServer(message.payload);
           return this.tagged({ id, type: "SERVER_CLAIM_SIGNED" });
         case "VERIFY_CHAIN_SWAP": {
           const verified = await this.handler.verifyChainSwap({
@@ -5734,14 +5490,47 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "QUOTE_SWAP": {
-          const amount = await this.handler.quoteSwap(
-            message.payload.swapId
-          );
-          return this.tagged({
-            id,
-            type: "SWAP_QUOTED",
-            payload: { amount }
-          });
+          try {
+            const amount = await this.handler.quoteSwap(
+              message.payload.swapId,
+              message.payload.options
+            );
+            return this.tagged({
+              id,
+              type: "SWAP_QUOTED",
+              payload: { amount }
+            });
+          } catch (e) {
+            throw toQuoteTransportError(e);
+          }
+        }
+        case "GET_SWAP_QUOTE": {
+          try {
+            const amount = await this.handler.getSwapQuote(message.payload.swapId);
+            return this.tagged({
+              id,
+              type: "SWAP_QUOTE_RETRIEVED",
+              payload: { amount }
+            });
+          } catch (e) {
+            throw toQuoteTransportError(e);
+          }
+        }
+        case "ACCEPT_SWAP_QUOTE": {
+          try {
+            const amount = await this.handler.acceptSwapQuote(
+              message.payload.swapId,
+              message.payload.amount,
+              message.payload.options
+            );
+            return this.tagged({
+              id,
+              type: "SWAP_QUOTE_ACCEPTED",
+              payload: { amount }
+            });
+          } catch (e) {
+            throw toQuoteTransportError(e);
+          }
         }
         /* --- SwapManager methods --- */
         case "SM-START": {
@@ -5757,9 +5546,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           return this.tagged({ id, type: "SM-SWAP_ADDED" });
         }
         case "SM-REMOVE_SWAP": {
-          await this.getSwapManagerOrThrow().removeSwap(
-            message.payload.swapId
-          );
+          await this.getSwapManagerOrThrow().removeSwap(message.payload.swapId);
           return this.tagged({ id, type: "SM-SWAP_REMOVED" });
         }
         case "SM-GET_PENDING_SWAPS": {
@@ -5771,9 +5558,7 @@ var ArkadeSwapsMessageHandler = class _ArkadeSwapsMessageHandler {
           });
         }
         case "SM-HAS_SWAP": {
-          const has = await this.getSwapManagerOrThrow().hasSwap(
-            message.payload.swapId
-          );
+          const has = await this.getSwapManagerOrThrow().hasSwap(message.payload.swapId);
           return this.tagged({
             id,
             type: "SM-HAS_SWAP_RESULT",
@@ -5893,6 +5678,11 @@ function isMessageBusNotInitializedError(error) {
 function isHandlerNotInitializedError(error) {
   return error instanceof Error && error.message.includes(HANDLER_NOT_INITIALIZED);
 }
+function rethrowIfQuoteRejected(error) {
+  if (error instanceof QuoteRejectedError) throw error;
+  const rebuilt = QuoteRejectedError.fromTransportError(error);
+  if (rebuilt) throw rebuilt;
+}
 var DEFAULT_MESSAGE_TIMEOUT_MS = 3e4;
 var NO_MESSAGE_TIMEOUT_MS = 0;
 var DEDUPABLE_REQUEST_TYPES = /* @__PURE__ */ new Set([
@@ -5949,7 +5739,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
     };
     const initMessage = {
       tag: messageTag,
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       type: "INIT_ARKADE_SWAPS",
       payload: initPayload
     };
@@ -5962,7 +5752,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       throw new Error("SwapManager is not enabled.");
     }
     await this.sendMessage({
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "SM-START"
     });
@@ -5970,7 +5760,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async stopSwapManager() {
     if (!this.withSwapManager) return;
     await this.sendMessage({
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "SM-STOP"
     });
@@ -5985,21 +5775,21 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
     const proxy = {
       start: async () => {
         await send({
-          id: getRandomId(),
+          id: (0, import_sdk10.getRandomId)(),
           tag,
           type: "SM-START"
         });
       },
       stop: async () => {
         await send({
-          id: getRandomId(),
+          id: (0, import_sdk10.getRandomId)(),
           tag,
           type: "SM-STOP"
         });
       },
       addSwap: async (swap) => {
         await send({
-          id: getRandomId(),
+          id: (0, import_sdk10.getRandomId)(),
           tag,
           type: "SM-ADD_SWAP",
           payload: swap
@@ -6007,7 +5797,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       },
       removeSwap: async (swapId) => {
         await send({
-          id: getRandomId(),
+          id: (0, import_sdk10.getRandomId)(),
           tag,
           type: "SM-REMOVE_SWAP",
           payload: { swapId }
@@ -6015,7 +5805,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       },
       getPendingSwaps: async () => {
         const res = await send({
-          id: getRandomId(),
+          id: (0, import_sdk10.getRandomId)(),
           tag,
           type: "SM-GET_PENDING_SWAPS"
         });
@@ -6023,7 +5813,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       },
       hasSwap: async (swapId) => {
         const res = await send({
-          id: getRandomId(),
+          id: (0, import_sdk10.getRandomId)(),
           tag,
           type: "SM-HAS_SWAP",
           payload: { swapId }
@@ -6032,7 +5822,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       },
       isProcessing: async (swapId) => {
         const res = await send({
-          id: getRandomId(),
+          id: (0, import_sdk10.getRandomId)(),
           tag,
           type: "SM-IS_PROCESSING",
           payload: { swapId }
@@ -6041,7 +5831,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       },
       getStats: async () => {
         const res = await send({
-          id: getRandomId(),
+          id: (0, import_sdk10.getRandomId)(),
           tag,
           type: "SM-GET_STATS"
         });
@@ -6049,7 +5839,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       },
       waitForSwapCompletion: async (swapId) => {
         const res = await send({
-          id: getRandomId(),
+          id: (0, import_sdk10.getRandomId)(),
           tag,
           type: "SM-WAIT_FOR_COMPLETION",
           payload: { swapId }
@@ -6113,7 +5903,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async createLightningInvoice(args) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "CREATE_LIGHTNING_INVOICE",
         payload: args
@@ -6126,7 +5916,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async sendLightningPayment(args) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "SEND_LIGHTNING_PAYMENT",
         payload: args
@@ -6139,7 +5929,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async createSubmarineSwap(args) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "CREATE_SUBMARINE_SWAP",
         payload: args
@@ -6152,7 +5942,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async createReverseSwap(args) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "CREATE_REVERSE_SWAP",
         payload: args
@@ -6164,7 +5954,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   }
   async claimVHTLC(pendingSwap) {
     await this.sendMessage({
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "CLAIM_VHTLC",
       payload: pendingSwap
@@ -6172,7 +5962,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   }
   async refundVHTLC(pendingSwap) {
     const res = await this.sendMessage({
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "REFUND_VHTLC",
       payload: pendingSwap
@@ -6181,7 +5971,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   }
   async inspectSubmarineRecovery(swap) {
     const res = await this.sendMessage({
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "INSPECT_SUBMARINE_RECOVERY",
       payload: swap
@@ -6190,7 +5980,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   }
   async scanRecoverableSubmarineSwaps() {
     const res = await this.sendMessage({
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "SCAN_RECOVERABLE_SUBMARINE_SWAPS"
     });
@@ -6198,7 +5988,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   }
   async recoverSubmarineFunds(swap) {
     const res = await this.sendMessage({
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "RECOVER_SUBMARINE_FUNDS",
       payload: swap
@@ -6207,7 +5997,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   }
   async recoverAllSubmarineFunds(swaps) {
     const res = await this.sendMessage({
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "RECOVER_ALL_SUBMARINE_FUNDS",
       payload: swaps
@@ -6217,7 +6007,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async waitAndClaim(pendingSwap) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "WAIT_AND_CLAIM",
         payload: pendingSwap
@@ -6232,7 +6022,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async waitForSwapSettlement(pendingSwap) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "WAIT_FOR_SWAP_SETTLEMENT",
         payload: pendingSwap
@@ -6245,7 +6035,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async restoreSwaps(boltzFees) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "RESTORE_SWAPS",
         payload: boltzFees
@@ -6258,7 +6048,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async arkToBtc(args) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "ARK_TO_BTC",
         payload: args
@@ -6273,7 +6063,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async btcToArk(args) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "BTC_TO_ARK",
         payload: args
@@ -6288,7 +6078,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async createChainSwap(args) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "CREATE_CHAIN_SWAP",
         payload: args
@@ -6301,7 +6091,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async waitAndClaimChain(pendingSwap) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "WAIT_AND_CLAIM_CHAIN",
         payload: pendingSwap
@@ -6316,7 +6106,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async waitAndClaimArk(pendingSwap) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "WAIT_AND_CLAIM_ARK",
         payload: pendingSwap
@@ -6331,7 +6121,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async waitAndClaimBtc(pendingSwap) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "WAIT_AND_CLAIM_BTC",
         payload: pendingSwap
@@ -6345,7 +6135,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   }
   async claimArk(pendingSwap) {
     await this.sendMessage({
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "CLAIM_ARK",
       payload: pendingSwap
@@ -6353,7 +6143,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   }
   async claimBtc(pendingSwap) {
     await this.sendMessage({
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "CLAIM_BTC",
       payload: pendingSwap
@@ -6361,7 +6151,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   }
   async refundArk(pendingSwap) {
     await this.sendMessage({
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "REFUND_ARK",
       payload: pendingSwap
@@ -6369,7 +6159,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   }
   async signCooperativeClaimForServer(pendingSwap) {
     await this.sendMessage({
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "SIGN_SERVER_CLAIM",
       payload: pendingSwap
@@ -6378,7 +6168,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async verifyChainSwap(args) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "VERIFY_CHAIN_SWAP",
         payload: {
@@ -6393,19 +6183,48 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       throw new Error("Cannot verify chain swap", { cause: e });
     }
   }
-  async quoteSwap(swapId) {
+  async quoteSwap(swapId, options) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "QUOTE_SWAP",
-        payload: { swapId }
+        payload: { swapId, options }
       });
       return res.payload.amount;
     } catch (e) {
+      rethrowIfQuoteRejected(e);
       throw new Error("Cannot quote swap", { cause: e });
     }
   }
+  async getSwapQuote(swapId) {
+    try {
+      const res = await this.sendMessage({
+        id: (0, import_sdk10.getRandomId)(),
+        tag: this.messageTag,
+        type: "GET_SWAP_QUOTE",
+        payload: { swapId }
+      });
+      return res.payload.amount;
+    } catch (e) {
+      rethrowIfQuoteRejected(e);
+      throw new Error("Cannot get swap quote", { cause: e });
+    }
+  }
+  async acceptSwapQuote(swapId, amount, options) {
+    try {
+      const res = await this.sendMessage({
+        id: (0, import_sdk10.getRandomId)(),
+        tag: this.messageTag,
+        type: "ACCEPT_SWAP_QUOTE",
+        payload: { swapId, amount, options }
+      });
+      return res.payload.amount;
+    } catch (e) {
+      rethrowIfQuoteRejected(e);
+      throw new Error("Cannot accept swap quote", { cause: e });
+    }
+  }
   enrichReverseSwapPreimage(swap, preimage) {
     return enrichReverseSwapPreimage(swap, preimage);
   }
@@ -6413,9 +6232,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
     return enrichSubmarineSwapInvoice(swap, invoice);
   }
   createVHTLCScript(_args) {
-    throw new Error(
-      "createVHTLCScript is not supported via service worker"
-    );
+    throw new Error("createVHTLCScript is not supported via service worker");
   }
   async joinBatch(_identity, _input, _output, _arkInfo, _isRecoverable = true) {
     throw new Error("joinBatch is not supported via service worker");
@@ -6426,7 +6243,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
     }
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "GET_FEES",
         ...from !== void 0 && to !== void 0 ? { payload: { from, to } } : {}
@@ -6442,7 +6259,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
     }
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "GET_LIMITS",
         ...from !== void 0 && to !== void 0 ? { payload: { from, to } } : {}
@@ -6455,7 +6272,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async getSwapStatus(swapId) {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "GET_SWAP_STATUS",
         payload: { swapId }
@@ -6468,7 +6285,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async getPendingSubmarineSwaps() {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "GET_PENDING_SUBMARINE_SWAPS"
       });
@@ -6482,7 +6299,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async getPendingReverseSwaps() {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "GET_PENDING_REVERSE_SWAPS"
       });
@@ -6494,7 +6311,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async getPendingChainSwaps() {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "GET_PENDING_CHAIN_SWAPS"
       });
@@ -6506,7 +6323,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   async getSwapHistory() {
     try {
       const res = await this.sendMessage({
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         tag: this.messageTag,
         type: "GET_SWAP_HISTORY"
       });
@@ -6517,7 +6334,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   }
   async refreshSwapsStatus() {
     await this.sendMessage({
-      id: getRandomId(),
+      id: (0, import_sdk10.getRandomId)(),
       tag: this.messageTag,
       type: "REFRESH_SWAPS_STATUS"
     });
@@ -6545,10 +6362,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
     return new Promise((resolve, reject) => {
       const cleanup = () => {
         clearTimeout(timeoutId);
-        navigator.serviceWorker.removeEventListener(
-          "message",
-          messageHandler
-        );
+        navigator.serviceWorker.removeEventListener("message", messageHandler);
       };
       const timeoutId = timeoutMs > 0 ? setTimeout(() => {
         cleanup();
@@ -6590,21 +6404,14 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   pingServiceWorker() {
     if (this.pingPromise) return this.pingPromise;
     this.pingPromise = new Promise((resolve, reject) => {
-      const pingId = getRandomId();
+      const pingId = (0, import_sdk10.getRandomId)();
       const cleanup = () => {
         clearTimeout(timeoutId);
-        navigator.serviceWorker.removeEventListener(
-          "message",
-          onMessage
-        );
+        navigator.serviceWorker.removeEventListener("message", onMessage);
       };
       const timeoutId = setTimeout(() => {
         cleanup();
-        reject(
-          new import_sdk10.ServiceWorkerTimeoutError(
-            "Service worker ping timed out"
-          )
-        );
+        reject(new import_sdk10.ServiceWorkerTimeoutError("Service worker ping timed out"));
       }, 2e3);
       const onMessage = (event) => {
         if (event.data?.id === pingId && event.data?.tag === "PONG") {
@@ -6632,9 +6439,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
         await this.reinitialize();
       }
     }
-    const timeoutMs = LONG_RUNNING_ARKADE_SWAPS_REQUEST_TYPES.has(
-      request.type
-    ) ? NO_MESSAGE_TIMEOUT_MS : DEFAULT_MESSAGE_TIMEOUT_MS;
+    const timeoutMs = LONG_RUNNING_ARKADE_SWAPS_REQUEST_TYPES.has(request.type) ? NO_MESSAGE_TIMEOUT_MS : DEFAULT_MESSAGE_TIMEOUT_MS;
     const maxRetries = 2;
     for (let attempt = 0; ; attempt++) {
       try {
@@ -6657,13 +6462,10 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
       const initMessage = {
         tag: this.messageTag,
         type: "INIT_ARKADE_SWAPS",
-        id: getRandomId(),
+        id: (0, import_sdk10.getRandomId)(),
         payload: this.initPayload
       };
-      await this.sendMessageDirect(
-        initMessage,
-        DEFAULT_MESSAGE_TIMEOUT_MS
-      );
+      await this.sendMessageDirect(initMessage, DEFAULT_MESSAGE_TIMEOUT_MS);
     })().finally(() => {
       this.reinitPromise = null;
     });
@@ -6672,10 +6474,7 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
   initEventStream() {
     if (this.eventListenerInitialized) return;
     this.eventListenerInitialized = true;
-    navigator.serviceWorker.addEventListener(
-      "message",
-      this.handleEventMessage
-    );
+    navigator.serviceWorker.addEventListener("message", this.handleEventMessage);
   }
   handleEventMessage = (event) => {
     const data = event.data;
@@ -6722,9 +6521,6 @@ var ServiceWorkerArkadeSwaps = class _ServiceWorkerArkadeSwaps {
     }
   };
 };
-function getRandomId() {
-  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-}
 
 // src/repositories/migrationFromContracts.ts
 var MIGRATION_KEY = "migration-from-storage-adapter-swaps";
@@ -6734,8 +6530,14 @@ async function migrateToSwapRepository(storageAdapter, fresh) {
     if (migration === "done") {
       return false;
     }
-    const reverseSwaps = await getContractCollection(storageAdapter, "reverseSwaps");
-    const submarineSwaps = await getContractCollection(storageAdapter, "submarineSwaps");
+    const reverseSwaps = await getContractCollection(
+      storageAdapter,
+      "reverseSwaps"
+    );
+    const submarineSwaps = await getContractCollection(
+      storageAdapter,
+      "submarineSwaps"
+    );
     for (const swap of reverseSwaps) {
       await fresh.saveSwap(swap);
     }
@@ -6745,9 +6547,7 @@ async function migrateToSwapRepository(storageAdapter, fresh) {
     await storageAdapter.setItem(MIGRATION_KEY, "done");
     return true;
   } catch (error) {
-    if (error instanceof Error && error.message.includes(
-      "One of the specified object stores was not found."
-    )) {
+    if (error instanceof Error && error.message.includes("One of the specified object stores was not found.")) {
       return false;
     }
     throw error;
@@ -6778,6 +6578,7 @@ async function getContractCollection(storage, contractType) {
   InvoiceFailedToPayError,
   NetworkError,
   PreimageFetchError,
+  QuoteRejectedError,
   SchemaError,
   ServiceWorkerArkadeLightning,
   ServiceWorkerArkadeSwaps,