@arkade-os/boltz-swap 0.3.0 → 0.3.2

package/dist/index.cjs

@@ -90,8 +90,11 @@ module.exports = __toCommonJS(index_exports);
 
 // src/errors.ts
 var SwapError = class extends Error {
+  /** Whether the swap can still be claimed (default: false). */
   isClaimable;
+  /** Whether the swap can be refunded (default: false). */
   isRefundable;
+  /** The pending swap associated with this error, if available. */
   pendingSwap;
   constructor(options = {}) {
     super(options.message ?? "Error during swap.");
@@ -123,7 +126,9 @@ var InsufficientFundsError = class extends SwapError {
   }
 };
 var NetworkError = class extends Error {
+  /** HTTP status code from the failed request, if available. */
   statusCode;
+  /** Raw error payload from the Boltz API, if available. */
   errorData;
   constructor(message, statusCode, errorData) {
     super(message);
@@ -365,7 +370,10 @@ var isTree = (data) => {
   return data && typeof data === "object" && isLeaf(data.claimLeaf) && isLeaf(data.refundLeaf) && isLeaf(data.refundWithoutBoltzLeaf) && isLeaf(data.unilateralClaimLeaf) && isLeaf(data.unilateralRefundLeaf) && isLeaf(data.unilateralRefundWithoutBoltzLeaf);
 };
 var isDetails = (data) => {
-  return data && typeof data === "object" && isTree(data.tree) && (data.amount === void 0 || typeof data.amount === "number") && typeof data.keyIndex === "number" && (data.transaction === void 0 || data.transaction && typeof data.transaction === "object" && typeof data.transaction.id === "string" && typeof data.transaction.vout === "number") && typeof data.lockupAddress === "string" && typeof data.serverPublicKey === "string" && typeof data.timeoutBlockHeight === "number" && isTimeoutBlockHeights(data.timeoutBlockHeights) && (data.preimageHash === void 0 || typeof data.preimageHash === "string");
+  return data && typeof data === "object" && isTree(data.tree) && (data.amount === void 0 || typeof data.amount === "number") && typeof data.keyIndex === "number" && (data.transaction === void 0 || data.transaction && typeof data.transaction === "object" && typeof data.transaction.id === "string" && typeof data.transaction.vout === "number") && typeof data.lockupAddress === "string" && typeof data.serverPublicKey === "string" && typeof data.timeoutBlockHeight === "number" && (data.timeoutBlockHeights === void 0 || isTimeoutBlockHeights(data.timeoutBlockHeights)) && (data.preimageHash === void 0 || typeof data.preimageHash === "string");
+};
+var isRestoredChainSwap = (data) => {
+  return data && typeof data === "object" && typeof data.id === "string" && data.type === "chain" && typeof data.status === "string" && typeof data.createdAt === "number" && (data.from === "ARK" || data.from === "BTC") && (data.to === "ARK" || data.to === "BTC") && typeof data.preimageHash === "string" && data.refundDetails && typeof data.refundDetails === "object" && isTree(data.refundDetails.tree) && typeof data.refundDetails.amount === "number" && typeof data.refundDetails.keyIndex === "number" && (data.refundDetails.transaction === void 0 || data.refundDetails.transaction && typeof data.refundDetails.transaction === "object" && typeof data.refundDetails.transaction.id === "string" && typeof data.refundDetails.transaction.vout === "number") && typeof data.refundDetails.lockupAddress === "string" && typeof data.refundDetails.serverPublicKey === "string" && typeof data.refundDetails.timeoutBlockHeight === "number";
 };
 var isRestoredSubmarineSwap = (data) => {
   return data && typeof data === "object" && data.to === "BTC" && typeof data.id === "string" && data.from === "ARK" && data.type === "submarine" && typeof data.createdAt === "number" && typeof data.preimageHash === "string" && typeof data.status === "string" && isDetails(data.refundDetails);
@@ -375,10 +383,11 @@ var isRestoredReverseSwap = (data) => {
 };
 var isCreateSwapsRestoreResponse = (data) => {
   return Array.isArray(data) && data.every(
-    (item) => isRestoredReverseSwap(item) || isRestoredSubmarineSwap(item)
+    (item) => isRestoredChainSwap(item) || isRestoredReverseSwap(item) || isRestoredSubmarineSwap(item)
   );
 };
 var BASE_URLS = {
+  bitcoin: "https://api.ark.boltz.exchange",
   mutinynet: "https://api.boltz.mutinynet.arkade.sh",
   regtest: "http://localhost:9069"
 };
@@ -387,6 +396,7 @@ var BoltzSwapProvider = class {
   apiUrl;
   network;
   referralId;
+  /** @param config Provider configuration with network and optional API URL. */
   constructor(config) {
     this.network = config.network;
     this.referralId = config.referralId;
@@ -398,15 +408,19 @@ var BoltzSwapProvider = class {
     this.apiUrl = apiUrl;
     this.wsUrl = this.apiUrl.replace(/^http(s)?:\/\//, "ws$1://").replace("9069", "9004") + "/v2/ws";
   }
+  /** Returns the Boltz API base URL. */
   getApiUrl() {
     return this.apiUrl;
   }
+  /** Returns the Boltz WebSocket URL (derived from apiUrl). */
   getWsUrl() {
     return this.wsUrl;
   }
+  /** Returns the configured network. */
   getNetwork() {
     return this.network;
   }
+  /** Returns current Lightning swap fees (submarine + reverse) from Boltz. */
   async getFees() {
     const [submarine, reverse] = await Promise.all([
       this.request(
@@ -430,6 +444,7 @@ var BoltzSwapProvider = class {
       }
     };
   }
+  /** Returns current Lightning swap min/max limits from Boltz. */
   async getLimits() {
     const response = await this.request(
       "/v2/swap/submarine",
@@ -442,6 +457,7 @@ var BoltzSwapProvider = class {
       max: response.ARK.BTC.limits.maximal
     };
   }
+  /** Gets the lockup transaction ID for a reverse swap. */
   async getReverseSwapTxId(id) {
     const res = await this.request(
       `/v2/swap/reverse/${id}/transaction`,
@@ -453,6 +469,7 @@ var BoltzSwapProvider = class {
       });
     return res;
   }
+  /** Queries the current status of a swap by ID. */
   async getSwapStatus(id) {
     const response = await this.request(
       `/v2/swap/${id}`,
@@ -464,6 +481,7 @@ var BoltzSwapProvider = class {
       });
     return response;
   }
+  /** Gets the preimage for a settled submarine swap (proof of payment). */
   async getSwapPreimage(id) {
     const res = await this.request(
       `/v2/swap/submarine/${id}/preimage`,
@@ -475,6 +493,7 @@ var BoltzSwapProvider = class {
       });
     return res;
   }
+  /** Creates a submarine swap (Arkade → Lightning) on Boltz. */
   async createSubmarineSwap({
     invoice,
     refundPublicKey
@@ -500,6 +519,7 @@ var BoltzSwapProvider = class {
       throw new SchemaError({ message: "Error creating submarine swap" });
     return response;
   }
+  /** Creates a reverse swap (Lightning → Arkade) on Boltz. */
   async createReverseSwap({
     invoiceAmount,
     claimPublicKey,
@@ -529,6 +549,7 @@ var BoltzSwapProvider = class {
       throw new SchemaError({ message: "Error creating reverse swap" });
     return response;
   }
+  /** Creates a chain swap (ARK ↔ BTC) on Boltz. */
   async createChainSwap({
     to,
     from,
@@ -587,6 +608,7 @@ var BoltzSwapProvider = class {
       throw new SchemaError({ message: "Error creating chain swap" });
     return response;
   }
+  /** Requests Boltz co-signature for a submarine swap refund. Returns signed transaction + checkpoint. */
   async refundSubmarineSwap(swapId, transaction, checkpoint) {
     const requestBody = {
       checkpoint: import_base.base64.encode(checkpoint.toPSBT()),
@@ -610,6 +632,7 @@ var BoltzSwapProvider = class {
       )
     };
   }
+  /** Requests Boltz co-signature for a chain swap refund. Returns signed transaction + checkpoint. */
   async refundChainSwap(swapId, transaction, checkpoint) {
     const requestBody = {
       checkpoint: import_base.base64.encode(checkpoint.toPSBT()),
@@ -633,6 +656,7 @@ var BoltzSwapProvider = class {
       )
     };
   }
+  /** Monitors swap status updates via WebSocket. Calls update callback on each status change. Resolves when terminal. */
   async monitorSwap(swapId, update) {
     return new Promise((resolve, reject) => {
       const webSocket = new globalThis.WebSocket(this.wsUrl);
@@ -700,6 +724,7 @@ var BoltzSwapProvider = class {
       };
     });
   }
+  /** Returns current chain swap fees for a given pair (e.g. ARK→BTC). */
   async getChainFees(from, to) {
     if (from === to) {
       throw new SwapError({ message: "Invalid chain pair" });
@@ -717,6 +742,7 @@ var BoltzSwapProvider = class {
     }
     return response[from][to].fees;
   }
+  /** Returns current chain swap min/max limits for a given pair. */
   async getChainLimits(from, to) {
     if (from === to) {
       throw new SwapError({ message: "Invalid chain pair" });
@@ -737,6 +763,7 @@ var BoltzSwapProvider = class {
       max: response[from][to].limits.maximal
     };
   }
+  /** Gets claim details (pubNonce, publicKey, transactionHash) for cooperative chain swap claiming. */
   async getChainClaimDetails(swapId) {
     const response = await this.request(
       `/v2/swap/chain/${swapId}/claim`,
@@ -748,6 +775,7 @@ var BoltzSwapProvider = class {
       });
     return response;
   }
+  /** Gets a renegotiated quote for a chain swap when lockup amount differs from expected. */
   async getChainQuote(swapId) {
     const response = await this.request(
       `/v2/swap/chain/${swapId}/quote`,
@@ -759,6 +787,7 @@ var BoltzSwapProvider = class {
       });
     return response;
   }
+  /** Accepts a renegotiated quote amount for a chain swap. */
   async postChainQuote(swapId, request) {
     const response = await this.request(
       `/v2/swap/chain/${swapId}/quote`,
@@ -771,6 +800,7 @@ var BoltzSwapProvider = class {
       });
     return response;
   }
+  /** Broadcasts a raw BTC transaction through Boltz. */
   async postBtcTransaction(hex9) {
     const requestBody = { hex: hex9 };
     const response = await this.request(
@@ -784,6 +814,7 @@ var BoltzSwapProvider = class {
       });
     return response;
   }
+  /** Posts claim details (preimage + signing data) or cooperative signature for a chain swap. */
   async postChainClaimDetails(swapId, request) {
     const response = await this.request(
       `/v2/swap/chain/${swapId}/claim`,
@@ -796,6 +827,7 @@ var BoltzSwapProvider = class {
       });
     return response;
   }
+  /** Restores swaps from Boltz API using the wallet's public key. */
   async restoreSwaps(publicKey) {
     const requestBody = {
       publicKey
@@ -2858,24 +2890,61 @@ var validFinalArkTx = (finalArkTx, _pubkey, _tapLeaves) => {
 };
 
 // src/arkade-swaps.ts
-var ArkadeSwaps = class {
+var ArkadeSwaps = class _ArkadeSwaps {
+  /** The Arkade wallet instance used for signing and address generation. */
   wallet;
+  /** Provider for Ark protocol operations (VTXO management, batch joining). */
   arkProvider;
+  /** Boltz API client for creating and monitoring swaps. */
   swapProvider;
+  /** Provider for querying VTXO state on the Ark indexer. */
   indexerProvider;
+  /** Background swap monitor, or null if not enabled. */
   swapManager = null;
+  /** Storage backend for persisting swap data. */
   swapRepository;
+  /**
+   * Creates an ArkadeSwaps instance, auto-detecting the network from the wallet's Ark server.
+   * If no `swapProvider` is given, one is created automatically using the detected network.
+   *
+   * This is the recommended way to initialize ArkadeSwaps.
+   *
+   * @param config - Configuration options. swapProvider is auto-created from the wallet's network if omitted.
+   * @returns A fully initialized ArkadeSwaps instance.
+   *
+   * @example
+   * ```ts
+   * const swaps = await ArkadeSwaps.create({
+   *   wallet,
+   *   swapManager: true,
+   * });
+   * ```
+   */
+  static async create(config) {
+    if (config.swapProvider) {
+      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."
+      );
+    const arkInfo = await arkProvider.getInfo();
+    const network = arkInfo.network;
+    const swapProvider = new BoltzSwapProvider({ network });
+    return new _ArkadeSwaps({ ...config, swapProvider });
+  }
   constructor(config) {
     if (!config.wallet) throw new Error("Wallet is required.");
     if (!config.swapProvider) throw new Error("Swap provider is required.");
     this.wallet = config.wallet;
-    const arkProvider = config.wallet.arkProvider ?? config.arkProvider;
+    const arkProvider = config.arkProvider ?? config.wallet.arkProvider;
     if (!arkProvider)
       throw new Error(
         "Ark provider is required either in wallet or config."
       );
     this.arkProvider = arkProvider;
-    const indexerProvider = config.wallet.indexerProvider ?? config.indexerProvider;
+    const indexerProvider = config.indexerProvider ?? config.wallet.indexerProvider;
     if (!indexerProvider)
       throw new Error(
         "Indexer provider is required either in wallet or config."
@@ -2887,8 +2956,8 @@ var ArkadeSwaps = class {
     } else {
       this.swapRepository = new IndexedDbSwapRepository();
     }
-    if (config.swapManager) {
-      const swapManagerConfig = config.swapManager === true ? {} : config.swapManager;
+    if (config.swapManager !== false) {
+      const swapManagerConfig = !config.swapManager || config.swapManager === true ? {} : config.swapManager;
       const shouldAutostart = swapManagerConfig.autoStart ?? true;
       this.swapManager = new SwapManager(
         this.swapProvider,
@@ -3005,9 +3074,11 @@ var ArkadeSwaps = class {
   // Lightning: Reverse swaps (receive Lightning -> Arkade)
   // =========================================================================
   /**
-   * Creates a Lightning invoice.
-   * @param args - The arguments for creating a Lightning invoice.
-   * @returns The response containing the created Lightning invoice.
+   * Creates a Lightning invoice via a reverse swap (Lightning → Arkade).
+   * @param args.amount - Invoice amount in satoshis.
+   * @param args.description - Optional description for the BOLT11 invoice.
+   * @returns Object containing the BOLT11 invoice, payment hash, preimage, and pending swap for monitoring.
+   * @throws {SwapError} If amount is <= 0 or wallet key retrieval fails.
    */
   async createLightningInvoice(args) {
     const pendingSwap = await this.createReverseSwap(args);
@@ -3022,9 +3093,11 @@ var ArkadeSwaps = class {
     };
   }
   /**
-   * Creates a reverse swap.
-   * @param args - The arguments for creating a reverse swap.
-   * @returns The created pending reverse swap.
+   * Creates a reverse swap (Lightning → Arkade) and saves it to storage.
+   * @param args.amount - Amount in satoshis for the reverse swap.
+   * @param args.description - Optional invoice description.
+   * @returns The pending reverse swap, added to SwapManager if enabled.
+   * @throws {SwapError} If amount is <= 0 or key retrieval fails.
    */
   async createReverseSwap(args) {
     if (args.amount <= 0)
@@ -3063,8 +3136,9 @@ var ArkadeSwaps = class {
     return pendingSwap;
   }
   /**
-   * Claims the VHTLC for a pending reverse swap.
-   * @param pendingSwap - The pending reverse swap to claim the VHTLC.
+   * Claims the VHTLC for a pending reverse swap, transferring locked funds to the wallet.
+   * @param pendingSwap - The reverse swap whose VHTLC should be claimed.
+   * @throws {Error} If preimage is missing, VHTLC script creation fails, or no spendable VTXOs found.
    */
   async claimVHTLC(pendingSwap) {
     if (!pendingSwap.preimage)
@@ -3144,9 +3218,13 @@ var ArkadeSwaps = class {
     );
   }
   /**
-   * Waits for the swap to be confirmed and claims the VHTLC.
-   * @param pendingSwap - The pending reverse swap.
+   * Waits for a reverse swap to be confirmed and claims the VHTLC.
+   * Delegates to SwapManager if enabled, otherwise monitors via WebSocket.
+   * @param pendingSwap - The reverse swap to monitor and claim.
    * @returns The transaction ID of the claimed VHTLC.
+   * @throws {InvoiceExpiredError} If the Lightning invoice expires.
+   * @throws {SwapExpiredError} If the swap exceeds its time limit.
+   * @throws {TransactionFailedError} If the on-chain transaction fails.
    */
   async waitAndClaim(pendingSwap) {
     if (this.swapManager && await this.swapManager.hasSwap(pendingSwap.id)) {
@@ -3226,9 +3304,11 @@ var ArkadeSwaps = class {
   // Lightning: Submarine swaps (send Arkade -> Lightning)
   // =========================================================================
   /**
-   * Sends a Lightning payment.
-   * @param args - The arguments for sending a Lightning payment.
-   * @returns The result of the payment.
+   * Sends a Lightning payment via a submarine swap (Arkade → Lightning).
+   * Creates the swap, sends funds, and waits for settlement. Auto-refunds on failure.
+   * @param args.invoice - BOLT11 Lightning invoice to pay.
+   * @returns The amount paid, preimage (proof of payment), and transaction ID.
+   * @throws {TransactionFailedError} If the payment fails (auto-refunds if possible).
    */
   async sendLightningPayment(args) {
     const pendingSwap = await this.createSubmarineSwap(args);
@@ -3258,9 +3338,10 @@ var ArkadeSwaps = class {
     }
   }
   /**
-   * Creates a submarine swap.
-   * @param args - The arguments for creating a submarine swap.
-   * @returns The created pending submarine swap.
+   * Creates a submarine swap (Arkade → Lightning) and saves it to storage.
+   * @param args.invoice - BOLT11 Lightning invoice to pay.
+   * @returns The pending submarine swap, added to SwapManager if enabled.
+   * @throws {SwapError} If invoice is missing or key retrieval fails.
    */
   async createSubmarineSwap(args) {
     const refundPublicKey = import_base9.hex.encode(
@@ -3292,8 +3373,10 @@ var ArkadeSwaps = class {
     return pendingSwap;
   }
   /**
-   * Claims the VHTLC for a pending submarine swap (aka refund).
-   * @param pendingSwap - The pending submarine swap to refund the VHTLC.
+   * Refunds the VHTLC for a failed submarine swap, returning locked funds to the wallet.
+   * Uses multi-party signatures (user + Boltz + server) for non-recoverable VTXOs.
+   * @param pendingSwap - The submarine swap to refund.
+   * @throws {Error} If preimage hash is unavailable, VHTLC not found, or already spent.
    */
   async refundVHTLC(pendingSwap) {
     const preimageHash = pendingSwap.request.invoice ? getInvoicePaymentHash(pendingSwap.request.invoice) : pendingSwap.preimageHash;
@@ -3377,9 +3460,12 @@ var ArkadeSwaps = class {
     );
   }
   /**
-   * Waits for the swap settlement.
-   * @param pendingSwap - The pending submarine swap.
-   * @returns The status of the swap settlement.
+   * Waits for a submarine swap's Lightning payment to settle.
+   * @param pendingSwap - The submarine swap to monitor.
+   * @returns The preimage from the settled Lightning payment (proof of payment).
+   * @throws {SwapExpiredError} If the swap expires.
+   * @throws {InvoiceFailedToPayError} If Boltz fails to route the payment.
+   * @throws {TransactionLockupFailedError} If the lockup transaction fails.
    */
   async waitForSwapSettlement(pendingSwap) {
     return new Promise((resolve, reject) => {
@@ -3450,8 +3536,12 @@ var ArkadeSwaps = class {
   // =========================================================================
   /**
    * Creates a chain swap from ARK to BTC.
-   * @param args - Swap arguments.
-   * @returns The payment details and pending chain swap.
+   * @param args.btcAddress - Destination Bitcoin address.
+   * @param args.senderLockAmount - Exact amount sender locks (receiver gets less after fees). Specify this OR receiverLockAmount.
+   * @param args.receiverLockAmount - Exact amount receiver gets (sender pays more). Specify this OR senderLockAmount.
+   * @param args.feeSatsPerByte - Fee rate for the BTC claim transaction (default: 1).
+   * @returns The ARK lockup address, amount to pay, and pending swap.
+   * @throws {SwapError} If chain swap verification fails.
    */
   async arkToBtc(args) {
     const pendingSwap = await this.createChainSwap({
@@ -3743,8 +3833,11 @@ var ArkadeSwaps = class {
   // =========================================================================
   /**
    * Creates a chain swap from BTC to ARK.
-   * @param args - Swap arguments.
-   * @returns The pending chain swap and payment details.
+   * @param args.feeSatsPerByte - Fee rate for BTC transactions (default: 1).
+   * @param args.senderLockAmount - Exact BTC amount to lock. Specify this OR receiverLockAmount.
+   * @param args.receiverLockAmount - Exact ARK amount to receive. Specify this OR senderLockAmount.
+   * @returns The BTC lockup address, amount to pay, and pending swap.
+   * @throws {SwapError} If chain swap verification fails.
    */
   async btcToArk(args) {
     const pendingSwap = await this.createChainSwap({
@@ -4286,6 +4379,7 @@ var ArkadeSwaps = class {
     );
     if (!publicKey) throw new Error("Failed to get public key from wallet");
     const fees = boltzFees ?? await this.swapProvider.getFees();
+    const chainSwaps = [];
     const reverseSwaps = [];
     const submarineSwaps = [];
     const restoredSwaps = await this.swapProvider.restoreSwaps(publicKey);
@@ -4378,9 +4472,45 @@ var ArkadeSwaps = class {
             }
           }
         });
+      } else if (isRestoredChainSwap(swap)) {
+        const {
+          amount,
+          lockupAddress,
+          serverPublicKey,
+          timeoutBlockHeight
+        } = swap.refundDetails;
+        chainSwaps.push({
+          id,
+          type: "chain",
+          createdAt,
+          preimage: "",
+          ephemeralKey: "",
+          feeSatsPerByte: 1,
+          amount,
+          status,
+          request: {
+            to: swap.to,
+            from: swap.from,
+            preimageHash: swap.preimageHash,
+            claimPublicKey: "",
+            feeSatsPerByte: 1,
+            refundPublicKey: "",
+            serverLockAmount: amount,
+            userLockAmount: amount
+          },
+          response: {
+            id,
+            lockupDetails: {
+              amount,
+              lockupAddress,
+              serverPublicKey,
+              timeoutBlockHeight
+            }
+          }
+        });
       }
     }
-    return { reverseSwaps, submarineSwaps };
+    return { chainSwaps, reverseSwaps, submarineSwaps };
   }
   /**
    * Enrich a restored reverse swap with its preimage.

package/dist/index.d.cts

@@ -1,46 +1,74 @@
-import { I as IArkadeSwaps } from './arkade-swaps-Brpa88Fg.cjs';
-export { A as ArkadeSwaps } from './arkade-swaps-Brpa88Fg.cjs';
-import { P as PendingSwap, D as DecodedInvoice, a as PendingChainSwap, b as PendingReverseSwap, c as PendingSubmarineSwap, A as ArkadeSwapsConfig, N as Network, C as CreateLightningInvoiceRequest, S as SendLightningPaymentRequest, F as FeesResponse, d as Chain, e as CreateLightningInvoiceResponse, f as SendLightningPaymentResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, h as ArkToBtcResponse, B as BtcToArkResponse, i as SwapRepository, j as SwapManagerClient, k as GetSwapsFilter } from './types-BRYTZH1Z.cjs';
-export { l as BoltzSwapProvider, m as BoltzSwapStatus, W as IncomingPaymentSubscription, V as SwapManager, _ as SwapManagerCallbacks, Y as SwapManagerConfig, Z as SwapManagerEvents, X as Vtxo, n as isChainClaimableStatus, o as isChainFailedStatus, p as isChainFinalStatus, q as isChainPendingStatus, r as isChainRefundableStatus, s as isChainSignableStatus, t as isChainSuccessStatus, u as isChainSwapClaimable, v as isChainSwapRefundable, w as isPendingChainSwap, x as isPendingReverseSwap, y as isPendingSubmarineSwap, z as isReverseClaimableStatus, E as isReverseFailedStatus, H as isReverseFinalStatus, I as isReversePendingStatus, J as isReverseSuccessStatus, K as isReverseSwapClaimable, M as isSubmarineFailedStatus, O as isSubmarineFinalStatus, Q as isSubmarinePendingStatus, T as isSubmarineRefundableStatus, R as isSubmarineSuccessStatus, U as isSubmarineSwapRefundable } from './types-BRYTZH1Z.cjs';
+import { I as IArkadeSwaps } from './arkade-swaps-w-cm-cPg.cjs';
+export { A as ArkadeSwaps } from './arkade-swaps-w-cm-cPg.cjs';
+import { P as PendingSwap, D as DecodedInvoice, a as PendingChainSwap, b as PendingReverseSwap, c as PendingSubmarineSwap, A as ArkadeSwapsConfig, N as Network, C as CreateLightningInvoiceRequest, S as SendLightningPaymentRequest, F as FeesResponse, d as Chain, e as CreateLightningInvoiceResponse, f as SendLightningPaymentResponse, g as ChainFeesResponse, L as LimitsResponse, G as GetSwapStatusResponse, h as ArkToBtcResponse, B as BtcToArkResponse, i as SwapRepository, j as SwapManagerClient, k as GetSwapsFilter } from './types-t0r41rlw.cjs';
+export { X as ArkadeSwapsCreateConfig, l as BoltzSwapProvider, m as BoltzSwapStatus, W as IncomingPaymentSubscription, V as SwapManager, $ as SwapManagerCallbacks, Z as SwapManagerConfig, _ as SwapManagerEvents, Y as Vtxo, n as isChainClaimableStatus, o as isChainFailedStatus, p as isChainFinalStatus, q as isChainPendingStatus, r as isChainRefundableStatus, s as isChainSignableStatus, t as isChainSuccessStatus, u as isChainSwapClaimable, v as isChainSwapRefundable, w as isPendingChainSwap, x as isPendingReverseSwap, y as isPendingSubmarineSwap, z as isReverseClaimableStatus, E as isReverseFailedStatus, H as isReverseFinalStatus, I as isReversePendingStatus, J as isReverseSuccessStatus, K as isReverseSwapClaimable, M as isSubmarineFailedStatus, O as isSubmarineFinalStatus, Q as isSubmarinePendingStatus, T as isSubmarineRefundableStatus, R as isSubmarineSuccessStatus, U as isSubmarineSwapRefundable } from './types-t0r41rlw.cjs';
 import { Transaction } from '@scure/btc-signer';
 import { MessageHandler, RequestEnvelope, ArkInfo, ResponseEnvelope, IWallet, IReadonlyWallet, VHTLC, Identity, ArkTxInput } from '@arkade-os/sdk';
 import { TransactionOutput } from '@scure/btc-signer/psbt.js';
 
+/** Options for constructing swap errors. */
 interface ErrorOptions {
+    /** Custom error message (overrides the default). */
     message?: string;
+    /** Whether the swap's funds can still be claimed. */
     isClaimable?: boolean;
+    /** Whether the swap's funds can be refunded. */
     isRefundable?: boolean;
+    /** The associated pending swap, if available. */
     pendingSwap?: PendingSwap;
 }
+/**
+ * Base error class for all swap-related errors.
+ * Extends Error with swap-specific metadata (`isClaimable`, `isRefundable`, `pendingSwap`).
+ */
 declare class SwapError extends Error {
+    /** Whether the swap can still be claimed (default: false). */
     isClaimable: boolean;
+    /** Whether the swap can be refunded (default: false). */
     isRefundable: boolean;
+    /** The pending swap associated with this error, if available. */
     pendingSwap?: PendingSwap;
     constructor(options?: ErrorOptions);
 }
+/** Thrown when a Lightning invoice expires before being paid. The swap may be refundable. */
 declare class InvoiceExpiredError extends SwapError {
     constructor(options?: ErrorOptions);
 }
+/** Thrown when Boltz fails to route the Lightning payment to the destination. Typically refundable. */
 declare class InvoiceFailedToPayError extends SwapError {
     constructor(options?: ErrorOptions);
 }
+/** Thrown when the wallet does not have enough funds to complete the swap. */
 declare class InsufficientFundsError extends SwapError {
     constructor(options?: ErrorOptions);
 }
+/**
+ * Thrown for HTTP/network failures when communicating with the Boltz API.
+ * Not a SwapError — does not carry swap metadata.
+ */
 declare class NetworkError extends Error {
+    /** HTTP status code from the failed request, if available. */
     statusCode?: number;
+    /** Raw error payload from the Boltz API, if available. */
     errorData?: any;
     constructor(message: string, statusCode?: number, errorData?: any);
 }
+/** Thrown when the Boltz API returns a response that doesn't match the expected schema. */
 declare class SchemaError extends SwapError {
     constructor(options?: ErrorOptions);
 }
+/** Thrown when a swap exceeds its time limit. May be refundable depending on swap type. */
 declare class SwapExpiredError extends SwapError {
     constructor(options?: ErrorOptions);
 }
+/** Thrown when an on-chain or off-chain transaction fails. */
 declare class TransactionFailedError extends SwapError {
     constructor(options?: ErrorOptions);
 }
+/**
+ * Thrown when a submarine swap's Lightning payment settles but retrieving the
+ * preimage from Boltz fails. The payment was made but proof-of-payment is unavailable.
+ */
 declare class PreimageFetchError extends SwapError {
     constructor(options?: ErrorOptions);
 }
@@ -177,6 +205,7 @@ type RequestRestoreSwaps = RequestEnvelope & {
 type ResponseRestoreSwaps = ResponseEnvelope & {
     type: "SWAPS_RESTORED";
     payload: {
+        chainSwaps: PendingChainSwap[];
         reverseSwaps: PendingReverseSwap[];
         submarineSwaps: PendingSubmarineSwap[];
     };
@@ -541,6 +570,7 @@ declare class ServiceWorkerArkadeSwaps implements IArkadeSwaps {
         preimage: string;
     }>;
     restoreSwaps(boltzFees?: FeesResponse): Promise<{
+        chainSwaps: PendingChainSwap[];
         reverseSwaps: PendingReverseSwap[];
         submarineSwaps: PendingSubmarineSwap[];
     }>;