@arkade-os/boltz-swap 0.3.0 → 0.3.2

package/dist/{types-BRYTZH1Z.d.ts → types-t0r41rlw.d.ts}

@@ -1,34 +1,69 @@
 import { Transaction, NetworkName, IWallet, ArkProvider, IndexerProvider } from '@arkade-os/sdk';
 
+/** Configuration for BoltzSwapProvider. */
 interface SwapProviderConfig {
+    /** Custom API URL. If omitted, defaults based on `network` (e.g. bitcoin → https://api.ark.boltz.exchange). */
     apiUrl?: string;
+    /** The network to operate on (e.g. "mutinynet", "regtest", "bitcoin"). */
     network: Network;
+    /** Optional referral ID appended to swap requests. */
     referralId?: string;
 }
+/**
+ * All possible Boltz swap status values.
+ *
+ * Lifecycle (submarine): swap.created → invoice.set → invoice.pending → invoice.paid → transaction.claimed
+ * Lifecycle (reverse):   swap.created → transaction.mempool → transaction.confirmed → invoice.settled
+ * Lifecycle (chain):     swap.created → transaction.mempool → transaction.server.mempool → transaction.claimed
+ */
 type BoltzSwapStatus = "invoice.expired" | "invoice.failedToPay" | "invoice.paid" | "invoice.pending" | "invoice.set" | "invoice.settled" | "swap.created" | "swap.expired" | "transaction.claim.pending" | "transaction.claimed" | "transaction.confirmed" | "transaction.failed" | "transaction.lockupFailed" | "transaction.mempool" | "transaction.refunded" | "transaction.server.mempool" | "transaction.server.confirmed";
+/** Returns true if the status indicates a failed submarine swap. */
 declare const isSubmarineFailedStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the submarine swap has reached a terminal state. */
 declare const isSubmarineFinalStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the submarine swap is still in progress. */
 declare const isSubmarinePendingStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the submarine swap is eligible for refund. */
 declare const isSubmarineRefundableStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the submarine swap completed successfully. */
 declare const isSubmarineSuccessStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the reverse swap failed. */
 declare const isReverseFailedStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the reverse swap has reached a terminal state. */
 declare const isReverseFinalStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the reverse swap is still in progress. */
 declare const isReversePendingStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the reverse swap VHTLC can be claimed. */
 declare const isReverseClaimableStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the reverse swap completed successfully. */
 declare const isReverseSuccessStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the chain swap failed. */
 declare const isChainFailedStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the chain swap is claimable (server transaction in mempool or confirmed). */
 declare const isChainClaimableStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the chain swap has reached a terminal state. */
 declare const isChainFinalStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the chain swap is still in progress. */
 declare const isChainPendingStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the chain swap is eligible for refund (swap.expired). */
 declare const isChainRefundableStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the chain swap is ready for cooperative signing. */
 declare const isChainSignableStatus: (status: BoltzSwapStatus) => boolean;
+/** Returns true if the chain swap completed successfully. */
 declare const isChainSuccessStatus: (status: BoltzSwapStatus) => boolean;
+/** Type guard: narrows PendingSwap to PendingReverseSwap. */
 declare const isPendingReverseSwap: (swap: PendingSwap) => swap is PendingReverseSwap;
+/** Type guard: narrows PendingSwap to PendingSubmarineSwap. */
 declare const isPendingSubmarineSwap: (swap: PendingSwap) => swap is PendingSubmarineSwap;
+/** Type guard: narrows PendingSwap to PendingChainSwap. */
 declare const isPendingChainSwap: (swap: PendingSwap) => swap is PendingChainSwap;
+/** Type guard: checks if swap is a refundable submarine swap (failed + not yet refunded). */
 declare const isSubmarineSwapRefundable: (swap: PendingSwap) => swap is PendingSubmarineSwap;
+/** Type guard: checks if swap is a refundable chain swap (expired ARK → BTC). */
 declare const isChainSwapRefundable: (swap: PendingSwap) => swap is PendingChainSwap;
+/** Type guard: checks if swap is a claimable reverse swap. */
 declare const isReverseSwapClaimable: (swap: PendingSwap) => swap is PendingReverseSwap;
+/** Type guard: checks if swap is a claimable chain swap. */
 declare const isChainSwapClaimable: (swap: PendingSwap) => swap is PendingChainSwap;
 type TimeoutBlockHeights = {
     refund: number;
@@ -50,33 +85,55 @@ type GetSwapStatusResponse = {
         preimage?: string;
     };
 };
+/** Request to create a submarine swap (Arkade → Lightning). */
 type CreateSubmarineSwapRequest = {
+    /** BOLT11 Lightning invoice to pay. */
     invoice: string;
+    /** Compressed public key (33 bytes / 66 hex chars) for the refund path. */
     refundPublicKey: string;
 };
+/** Response from creating a submarine swap. */
 type CreateSubmarineSwapResponse = {
+    /** Unique swap ID. */
     id: string;
+    /** ARK lockup address to send funds to. */
     address: string;
+    /** Amount in satoshis to send. */
     expectedAmount: number;
+    /** Boltz's public key for the claim path. */
     claimPublicKey: string;
+    /** Whether zero-conf transactions are accepted. */
     acceptZeroConf: boolean;
+    /** Block heights for various timeout/refund scenarios. */
     timeoutBlockHeights: TimeoutBlockHeights;
 };
 type GetSwapPreimageResponse = {
     preimage: string;
 };
+/** Request to create a reverse swap (Lightning → Arkade). */
 type CreateReverseSwapRequest = {
+    /** Compressed public key (33 bytes / 66 hex chars) for the claim path. */
     claimPublicKey: string;
+    /** Invoice amount in satoshis. */
     invoiceAmount: number;
+    /** SHA256 hash of the preimage (hex-encoded). */
     preimageHash: string;
+    /** Optional description for the BOLT11 invoice. */
     description?: string;
 };
+/** Response from creating a reverse swap. */
 type CreateReverseSwapResponse = {
+    /** Unique swap ID. */
     id: string;
+    /** BOLT11-encoded Lightning invoice to be paid. */
     invoice: string;
+    /** On-chain amount in satoshis (after Boltz fees). */
     onchainAmount: number;
+    /** ARK lockup address where Boltz will lock funds. */
     lockupAddress: string;
+    /** Boltz's public key for the refund path. */
     refundPublicKey: string;
+    /** Block heights for various timeout/refund scenarios. */
     timeoutBlockHeights: TimeoutBlockHeights;
 };
 type SwapTree = {
@@ -98,20 +155,34 @@ type ChainSwapDetailsResponse = {
     timeouts?: TimeoutBlockHeights;
     bip21?: string;
 };
+/** Request to create a chain swap (ARK ↔ BTC). */
 type CreateChainSwapRequest = {
+    /** Destination chain. */
     to: Chain;
+    /** Source chain. */
     from: Chain;
+    /** SHA256 hash of the preimage (hex-encoded). */
     preimageHash: string;
+    /** Compressed public key for the claim path. */
     claimPublicKey: string;
+    /** Fee rate (sats/vbyte) for BTC transactions. */
     feeSatsPerByte: number;
+    /** Compressed public key for the refund path. */
     refundPublicKey: string;
+    /** Amount Boltz should lock (specify this OR userLockAmount). */
     serverLockAmount?: number;
+    /** Amount user will lock (specify this OR serverLockAmount). */
     userLockAmount?: number;
+    /** Optional referral ID. */
     referralId?: string;
 };
+/** Response from creating a chain swap. */
 type CreateChainSwapResponse = {
+    /** Unique swap ID. */
     id: string;
+    /** Details for claiming the received funds. */
     claimDetails: ChainSwapDetailsResponse;
+    /** Details for the lockup (user sends funds here). */
     lockupDetails: ChainSwapDetailsResponse;
 };
 type GetChainClaimDetailsResponse = {
@@ -168,9 +239,30 @@ type Details = {
     lockupAddress: string;
     serverPublicKey: string;
     timeoutBlockHeight: number;
-    timeoutBlockHeights: TimeoutBlockHeights;
+    timeoutBlockHeights?: TimeoutBlockHeights;
     preimageHash?: string;
 };
+type RestoredChainSwap = {
+    id: string;
+    type: "chain";
+    status: BoltzSwapStatus;
+    createdAt: number;
+    from: "ARK" | "BTC";
+    to: "ARK" | "BTC";
+    preimageHash: string;
+    refundDetails: {
+        amount: number;
+        keyIndex: number;
+        lockupAddress: string;
+        serverPublicKey: string;
+        timeoutBlockHeight: number;
+        transaction?: {
+            id: string;
+            vout: number;
+        };
+        tree: Tree;
+    };
+};
 type RestoredSubmarineSwap = {
     to: "BTC";
     id: string;
@@ -191,40 +283,68 @@ type RestoredReverseSwap = {
     status: BoltzSwapStatus;
     claimDetails: Details;
 };
-type CreateSwapsRestoreResponse = (RestoredReverseSwap | RestoredSubmarineSwap)[];
+type CreateSwapsRestoreResponse = (RestoredChainSwap | RestoredReverseSwap | RestoredSubmarineSwap)[];
+/**
+ * API client for the Boltz swap service.
+ * Handles swap creation, status monitoring, fee/limit queries, and cooperative signing
+ * for both Lightning and chain swaps.
+ */
 declare class BoltzSwapProvider {
     private readonly wsUrl;
     private readonly apiUrl;
     private readonly network;
     private readonly referralId?;
+    /** @param config Provider configuration with network and optional API URL. */
     constructor(config: SwapProviderConfig);
+    /** Returns the Boltz API base URL. */
     getApiUrl(): string;
+    /** Returns the Boltz WebSocket URL (derived from apiUrl). */
     getWsUrl(): string;
+    /** Returns the configured network. */
     getNetwork(): Network;
+    /** Returns current Lightning swap fees (submarine + reverse) from Boltz. */
     getFees(): Promise<FeesResponse>;
+    /** Returns current Lightning swap min/max limits from Boltz. */
     getLimits(): Promise<LimitsResponse>;
+    /** Gets the lockup transaction ID for a reverse swap. */
     getReverseSwapTxId(id: string): Promise<GetReverseSwapTxIdResponse>;
+    /** Queries the current status of a swap by ID. */
     getSwapStatus(id: string): Promise<GetSwapStatusResponse>;
+    /** Gets the preimage for a settled submarine swap (proof of payment). */
     getSwapPreimage(id: string): Promise<GetSwapPreimageResponse>;
+    /** Creates a submarine swap (Arkade → Lightning) on Boltz. */
     createSubmarineSwap({ invoice, refundPublicKey, }: CreateSubmarineSwapRequest): Promise<CreateSubmarineSwapResponse>;
+    /** Creates a reverse swap (Lightning → Arkade) on Boltz. */
     createReverseSwap({ invoiceAmount, claimPublicKey, preimageHash, description, }: CreateReverseSwapRequest): Promise<CreateReverseSwapResponse>;
+    /** Creates a chain swap (ARK ↔ BTC) on Boltz. */
     createChainSwap({ to, from, preimageHash, feeSatsPerByte, claimPublicKey, refundPublicKey, serverLockAmount, userLockAmount, }: CreateChainSwapRequest): Promise<CreateChainSwapResponse>;
+    /** Requests Boltz co-signature for a submarine swap refund. Returns signed transaction + checkpoint. */
     refundSubmarineSwap(swapId: string, transaction: Transaction, checkpoint: Transaction): Promise<{
         transaction: Transaction;
         checkpoint: Transaction;
     }>;
+    /** Requests Boltz co-signature for a chain swap refund. Returns signed transaction + checkpoint. */
     refundChainSwap(swapId: string, transaction: Transaction, checkpoint: Transaction): Promise<{
         transaction: Transaction;
         checkpoint: Transaction;
     }>;
+    /** Monitors swap status updates via WebSocket. Calls update callback on each status change. Resolves when terminal. */
     monitorSwap(swapId: string, update: (type: BoltzSwapStatus, data?: any) => void): Promise<void>;
+    /** Returns current chain swap fees for a given pair (e.g. ARK→BTC). */
     getChainFees(from: Chain, to: Chain): Promise<ChainFeesResponse>;
+    /** Returns current chain swap min/max limits for a given pair. */
     getChainLimits(from: Chain, to: Chain): Promise<LimitsResponse>;
+    /** Gets claim details (pubNonce, publicKey, transactionHash) for cooperative chain swap claiming. */
     getChainClaimDetails(swapId: string): Promise<GetChainClaimDetailsResponse>;
+    /** Gets a renegotiated quote for a chain swap when lockup amount differs from expected. */
     getChainQuote(swapId: string): Promise<GetChainQuoteResponse>;
+    /** Accepts a renegotiated quote amount for a chain swap. */
     postChainQuote(swapId: string, request: PostChainQuoteRequest): Promise<PostChainQuoteResponse>;
+    /** Broadcasts a raw BTC transaction through Boltz. */
     postBtcTransaction(hex: string): Promise<PostBtcTransactionResponse>;
+    /** Posts claim details (preimage + signing data) or cooperative signature for a chain swap. */
     postChainClaimDetails(swapId: string, request: PostChainClaimDetailsRequest): Promise<PostChainClaimDetailsResponse>;
+    /** Restores swaps from Boltz API using the wallet's public key. */
     restoreSwaps(publicKey: string): Promise<CreateSwapsRestoreResponse>;
     private request;
 }
@@ -266,6 +386,7 @@ interface SwapManagerConfig {
     /** Event callbacks for swap lifecycle events (optional, can use on/off methods instead) */
     events?: SwapManagerEvents;
 }
+/** Event callbacks for swap lifecycle events. Can be provided in config or registered via on/off methods. */
 interface SwapManagerEvents {
     onSwapUpdate?: (swap: PendingSwap, oldStatus: BoltzSwapStatus) => void;
     onSwapCompleted?: (swap: PendingSwap) => void;
@@ -274,25 +395,43 @@ interface SwapManagerEvents {
     onWebSocketConnected?: () => void;
     onWebSocketDisconnected?: (error?: Error) => void;
 }
+/** Callback for swap status changes. Receives the updated swap and its previous status. */
 type SwapUpdateListener = (swap: PendingSwap, oldStatus: BoltzSwapStatus) => void;
+/** Callback for swap completions (final success state reached). */
 type SwapCompletedListener = (swap: PendingSwap) => void;
+/** Callback for swap failures. Includes the error that caused the failure. */
 type SwapFailedListener = (swap: PendingSwap, error: Error) => void;
+/** Callback after a swap action (claim/refund) has been executed. */
 type ActionExecutedListener = (swap: PendingSwap, action: Actions) => void;
+/** Callback when the WebSocket connection is established. */
 type WebSocketConnectedListener = () => void;
+/** Callback when the WebSocket disconnects. Includes the error if disconnection was not clean. */
 type WebSocketDisconnectedListener = (error?: Error) => void;
+/** Per-swap update callback used with subscribeToSwapUpdates. */
 type SwapUpdateCallback = (swap: PendingSwap, oldStatus: BoltzSwapStatus) => void;
+/** Public interface for SwapManager consumers. Provides swap monitoring, event subscription, and lifecycle control. */
 interface SwapManagerClient {
+    /** Starts the manager, loading initial swaps and connecting WebSocket. */
     start(pendingSwaps: PendingSwap[]): Promise<void>;
+    /** Stops the manager, closes WebSocket, and clears all timers. */
     stop(): Promise<void>;
+    /** Adds a new swap to be monitored. Immediately subscribes via WebSocket. */
     addSwap(swap: PendingSwap): Promise<void>;
+    /** Removes a swap from monitoring. */
     removeSwap(swapId: string): Promise<void>;
+    /** Returns all currently monitored (non-final) swaps. */
     getPendingSwaps(): Promise<PendingSwap[]>;
+    /** Subscribes to status updates for a specific swap. @returns Unsubscribe function. */
     subscribeToSwapUpdates(swapId: string, callback: SwapUpdateCallback): Promise<() => void>;
+    /** Returns a promise that resolves with { txid } when the swap completes, or rejects on failure. */
     waitForSwapCompletion(swapId: string): Promise<{
         txid: string;
     }>;
+    /** Returns true if a claim/refund action is currently executing for this swap. */
     isProcessing(swapId: string): Promise<boolean>;
+    /** Returns true if the manager is monitoring this swap. */
     hasSwap(swapId: string): Promise<boolean>;
+    /** Returns operational statistics (running state, WebSocket status, monitored count, etc.). */
     getStats(): Promise<{
         isRunning: boolean;
         monitoredSwaps: number;
@@ -314,6 +453,7 @@ interface SwapManagerClient {
     offWebSocketConnected(listener: WebSocketConnectedListener): void;
     offWebSocketDisconnected(listener: WebSocketDisconnectedListener): void;
 }
+/** Internal callbacks wired by ArkadeSwaps to perform claim/refund/save operations. */
 interface SwapManagerCallbacks {
     claim: (swap: PendingReverseSwap) => Promise<void>;
     refund: (swap: PendingSubmarineSwap) => Promise<void>;
@@ -323,6 +463,16 @@ interface SwapManagerCallbacks {
     signServerClaim?: (swap: PendingChainSwap) => Promise<void>;
     saveSwap: (swap: PendingSwap) => Promise<void>;
 }
+/**
+ * Background swap monitor with WebSocket + polling fallback.
+ *
+ * Monitors all pending swaps via a single multiplexed WebSocket connection to Boltz.
+ * Automatically claims reverse swaps, refunds failed submarine swaps, and handles
+ * chain swap actions (claim/refund on both ARK and BTC sides).
+ *
+ * Falls back to HTTP polling when WebSocket is unavailable, with exponential backoff
+ * for both reconnection and polling intervals.
+ */
 declare class SwapManager implements SwapManagerClient {
     private readonly swapProvider;
     private readonly config;
@@ -583,94 +733,165 @@ interface SwapRepository extends AsyncDisposable {
     clear(): Promise<void>;
 }
 
+/** A virtual transaction output (VTXO) — an off-chain UTXO in the Ark protocol. */
 interface Vtxo {
+    /** Transaction ID of the VTXO. */
     txid: string;
+    /** Output index in the transaction. */
     vout: number;
+    /** Amount in satoshis. */
     sats: number;
+    /** The output script (hex-encoded). */
     script: string;
+    /** Raw transaction data. */
     tx: {
+        /** Raw transaction hex. */
         hex: string;
+        /** Transaction version number. */
         version: number;
+        /** Transaction locktime. */
         locktime: number;
     };
 }
+/** Network name (e.g. "mutinynet", "regtest", "bitcoin"). */
 type Network = NetworkName;
+/** The chain side of a swap: "ARK" (off-chain Ark protocol) or "BTC" (on-chain Bitcoin). */
 type Chain = "ARK" | "BTC";
+/** Response from creating an ARK → BTC chain swap. */
 interface ArkToBtcResponse {
+    /** The ARK lockup address to send funds to. */
     arkAddress: string;
+    /** Amount in satoshis to send to the lockup address. */
     amountToPay: number;
+    /** The pending chain swap object for monitoring. */
     pendingSwap: PendingChainSwap;
 }
+/** Response from creating a BTC → ARK chain swap. */
 interface BtcToArkResponse {
+    /** The BTC lockup address to send funds to. */
     btcAddress: string;
+    /** Amount in satoshis to send to the lockup address. */
     amountToPay: number;
+    /** The pending chain swap object for monitoring. */
     pendingSwap: PendingChainSwap;
 }
+/** Request to create a Lightning invoice (reverse swap: Lightning → Arkade). */
 interface CreateLightningInvoiceRequest {
+    /** Invoice amount in satoshis. */
     amount: number;
+    /** Optional description embedded in the BOLT11 invoice. */
     description?: string;
 }
+/** Response containing the created Lightning invoice and swap details. */
 interface CreateLightningInvoiceResponse {
+    /** The on-chain amount in satoshis (after Boltz fees). */
     amount: number;
+    /** Invoice expiry timestamp (Unix seconds). */
     expiry: number;
+    /** The BOLT11-encoded Lightning invoice string. */
     invoice: string;
+    /** The payment hash (hex-encoded). */
     paymentHash: string;
+    /** The pending reverse swap for monitoring. */
     pendingSwap: PendingReverseSwap;
+    /** The preimage (hex-encoded). Keep secret until claiming. */
     preimage: string;
 }
+/** Request to send a Lightning payment (submarine swap: Arkade → Lightning). */
 interface SendLightningPaymentRequest {
+    /** BOLT11-encoded Lightning invoice to pay. */
     invoice: string;
 }
+/** Response after a successful Lightning payment. */
 interface SendLightningPaymentResponse {
+    /** Amount paid in satoshis. */
     amount: number;
+    /** Payment preimage proving payment was made (hex-encoded). */
     preimage: string;
+    /** Transaction ID of the Arkade payment. */
     txid: string;
 }
+/** Tracks an in-progress reverse swap (Lightning → Arkade). */
 interface PendingReverseSwap {
+    /** Unique swap ID from Boltz. */
     id: string;
+    /** Discriminator — always "reverse". */
     type: "reverse";
+    /** Unix timestamp (seconds) when the swap was created. */
     createdAt: number;
+    /** The swap preimage (hex-encoded). Required for claiming the VHTLC. */
     preimage: string;
+    /** Current Boltz swap status. */
     status: BoltzSwapStatus;
+    /** The original request sent to Boltz. */
     request: CreateReverseSwapRequest;
+    /** Boltz API response with lockup address, invoice, and timeout details. */
     response: CreateReverseSwapResponse;
 }
+/** Tracks an in-progress submarine swap (Arkade → Lightning). */
 interface PendingSubmarineSwap {
+    /** Unique swap ID from Boltz. */
     id: string;
+    /** Discriminator — always "submarine". */
     type: "submarine";
+    /** Unix timestamp (seconds) when the swap was created. */
     createdAt: number;
+    /** Payment preimage (hex-encoded). Available after the Lightning payment settles. */
     preimage?: string;
-    /** Original preimage hash from Boltz (available for restored swaps) */
+    /** Original preimage hash from Boltz (available for restored swaps). */
     preimageHash?: string;
+    /** Whether the swap has been refunded. */
     refunded?: boolean;
+    /** Whether the swap is eligible for refund. */
     refundable?: boolean;
+    /** Current Boltz swap status. */
     status: BoltzSwapStatus;
+    /** The original request sent to Boltz. */
     request: CreateSubmarineSwapRequest;
+    /** Boltz API response with payment address and expected amount. */
     response: CreateSubmarineSwapResponse;
 }
+/** Tracks an in-progress chain swap (ARK ↔ BTC). */
 interface PendingChainSwap {
+    /** Unique swap ID from Boltz. */
     id: string;
+    /** Discriminator — always "chain". */
     type: "chain";
+    /** The swap preimage (hex-encoded). Required for claiming. */
     preimage: string;
+    /** Unix timestamp (seconds) when the swap was created. */
     createdAt: number;
+    /** Ephemeral private key (hex) for BTC MuSig2 claim/refund signing. */
     ephemeralKey: string;
+    /** Fee rate (sats/vbyte) used for on-chain BTC transactions. */
     feeSatsPerByte: number;
+    /** Current Boltz swap status. */
     status: BoltzSwapStatus;
+    /** The original chain swap request sent to Boltz. */
     request: CreateChainSwapRequest;
+    /** Boltz API response with lockup and claim details. */
     response: CreateChainSwapResponse;
+    /** Destination address for the received funds. */
     toAddress?: string;
+    /** Swap amount in satoshis. */
     amount: number;
 }
+/** Union type of all pending swap types. */
 type PendingSwap = PendingReverseSwap | PendingSubmarineSwap | PendingChainSwap;
+/** Configuration for initializing ArkadeSwaps via the constructor (swapProvider is required). */
 interface ArkadeSwapsConfig {
+    /** An IWallet instance from @arkade-os/sdk (must expose arkProvider and indexerProvider). */
     wallet: IWallet;
+    /** Explicit ArkProvider. Falls back to wallet.arkProvider if omitted. */
     arkProvider?: ArkProvider;
+    /** BoltzSwapProvider instance for interacting with the Boltz API. */
     swapProvider: BoltzSwapProvider;
+    /** Explicit IndexerProvider. Falls back to wallet.indexerProvider if omitted. */
     indexerProvider?: IndexerProvider;
     /**
-     * Enable background swap monitoring and autonomous actions.
-     * - `false` or `undefined`: SwapManager disabled
-     * - `true`: SwapManager enabled with default configuration
+     * Background swap monitoring and autonomous actions (enabled by default).
+     * - `undefined` or `true`: SwapManager enabled with default configuration
+     * - `false`: SwapManager disabled
      * - `SwapManagerConfig` object: SwapManager enabled with custom configuration
      */
     swapManager?: boolean | (SwapManagerConfig & {
@@ -683,50 +904,86 @@ interface ArkadeSwapsConfig {
      */
     swapRepository?: SwapRepository;
 }
+/**
+ * Configuration for {@link ArkadeSwaps.create} — same as ArkadeSwapsConfig but
+ * `swapProvider` is optional (auto-created from the wallet's network if omitted).
+ */
+type ArkadeSwapsCreateConfig = Omit<ArkadeSwapsConfig, "swapProvider"> & {
+    swapProvider?: BoltzSwapProvider;
+};
+/** A decoded BOLT11 Lightning invoice. */
 interface DecodedInvoice {
+    /** Invoice expiry timestamp (Unix seconds). */
     expiry: number;
+    /** Invoice amount in satoshis. */
     amountSats: number;
+    /** Invoice description string. */
     description: string;
+    /** Payment hash (hex-encoded). */
     paymentHash: string;
 }
+/** Event subscription for incoming Lightning payments. */
 interface IncomingPaymentSubscription {
+    /** Fires when the payment is pending. */
     on(event: "pending", listener: () => void): this;
+    /** Fires when the swap has been created. */
     on(event: "created", listener: () => void): this;
+    /** Fires when the payment has been settled and funds claimed. */
     on(event: "settled", listener: () => void): this;
+    /** Fires when the payment fails. */
     on(event: "failed", listener: (error: Error) => void): this;
+    /** Removes all listeners and cleans up. */
     unsubscribe(): void;
 }
+/** Swap amount limits from Boltz. */
 interface LimitsResponse {
+    /** Minimum swap amount in satoshis. */
     min: number;
+    /** Maximum swap amount in satoshis. */
     max: number;
 }
 /**
- * Fee info returned by Boltz.
- * - percentage: value (e.g., 0.01 = 0.01%)
- * - minerFees: values in satoshis
+ * Lightning swap fee info from Boltz.
+ * - `percentage`: Boltz fee as a percentage (e.g. 0.1 = 0.1%)
+ * - `minerFees`: values in satoshis
  */
 interface FeesResponse {
+    /** Submarine swap (Arkade → Lightning) fees. */
     submarine: {
+        /** Boltz fee as a percentage (e.g. 0.1 = 0.1%). */
         percentage: number;
+        /** Miner fee in satoshis. */
         minerFees: number;
     };
+    /** Reverse swap (Lightning → Arkade) fees. */
     reverse: {
+        /** Boltz fee as a percentage (e.g. 0.1 = 0.1%). */
         percentage: number;
+        /** Miner fees in satoshis. */
         minerFees: {
+            /** Miner fee for the lockup transaction. */
             lockup: number;
+            /** Miner fee for the claim transaction. */
             claim: number;
         };
     };
 }
+/** Chain swap fee info from Boltz. */
 interface ChainFeesResponse {
+    /** Boltz fee as a percentage (e.g. 0.1 = 0.1%). */
     percentage: number;
+    /** Miner fees in satoshis. */
     minerFees: {
+        /** Server-side miner fee. */
         server: number;
+        /** User-side miner fees. */
         user: {
+            /** Miner fee for the claim transaction. */
             claim: number;
+            /** Miner fee for the lockup transaction. */
             lockup: number;
         };
     };
 }
 
-export { type ArkadeSwapsConfig as A, type BtcToArkResponse as B, type CreateLightningInvoiceRequest as C, type DecodedInvoice as D, isReverseFailedStatus as E, type FeesResponse as F, type GetSwapStatusResponse as G, isReverseFinalStatus as H, isReversePendingStatus as I, isReverseSuccessStatus as J, isReverseSwapClaimable as K, type LimitsResponse as L, isSubmarineFailedStatus as M, type Network as N, isSubmarineFinalStatus as O, type PendingSwap as P, isSubmarinePendingStatus as Q, isSubmarineSuccessStatus as R, type SendLightningPaymentRequest as S, isSubmarineRefundableStatus as T, isSubmarineSwapRefundable as U, SwapManager as V, type IncomingPaymentSubscription as W, type Vtxo as X, type SwapManagerConfig as Y, type SwapManagerEvents as Z, type SwapManagerCallbacks as _, type PendingChainSwap as a, type PendingReverseSwap as b, type PendingSubmarineSwap as c, type Chain as d, type CreateLightningInvoiceResponse as e, type SendLightningPaymentResponse as f, type ChainFeesResponse as g, type ArkToBtcResponse as h, type SwapRepository as i, type SwapManagerClient as j, type GetSwapsFilter as k, BoltzSwapProvider as l, type BoltzSwapStatus as m, isChainClaimableStatus as n, isChainFailedStatus as o, isChainFinalStatus as p, isChainPendingStatus as q, isChainRefundableStatus as r, isChainSignableStatus as s, isChainSuccessStatus as t, isChainSwapClaimable as u, isChainSwapRefundable as v, isPendingChainSwap as w, isPendingReverseSwap as x, isPendingSubmarineSwap as y, isReverseClaimableStatus as z };
+export { type SwapManagerCallbacks as $, type ArkadeSwapsConfig as A, type BtcToArkResponse as B, type CreateLightningInvoiceRequest as C, type DecodedInvoice as D, isReverseFailedStatus as E, type FeesResponse as F, type GetSwapStatusResponse as G, isReverseFinalStatus as H, isReversePendingStatus as I, isReverseSuccessStatus as J, isReverseSwapClaimable as K, type LimitsResponse as L, isSubmarineFailedStatus as M, type Network as N, isSubmarineFinalStatus as O, type PendingSwap as P, isSubmarinePendingStatus as Q, isSubmarineSuccessStatus as R, type SendLightningPaymentRequest as S, isSubmarineRefundableStatus as T, isSubmarineSwapRefundable as U, SwapManager as V, type IncomingPaymentSubscription as W, type ArkadeSwapsCreateConfig as X, type Vtxo as Y, type SwapManagerConfig as Z, type SwapManagerEvents as _, type PendingChainSwap as a, type PendingReverseSwap as b, type PendingSubmarineSwap as c, type Chain as d, type CreateLightningInvoiceResponse as e, type SendLightningPaymentResponse as f, type ChainFeesResponse as g, type ArkToBtcResponse as h, type SwapRepository as i, type SwapManagerClient as j, type GetSwapsFilter as k, BoltzSwapProvider as l, type BoltzSwapStatus as m, isChainClaimableStatus as n, isChainFailedStatus as o, isChainFinalStatus as p, isChainPendingStatus as q, isChainRefundableStatus as r, isChainSignableStatus as s, isChainSuccessStatus as t, isChainSwapClaimable as u, isChainSwapRefundable as v, isPendingChainSwap as w, isPendingReverseSwap as x, isPendingSubmarineSwap as y, isReverseClaimableStatus as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkade-os/boltz-swap",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
   "description": "A production-ready TypeScript package that brings Boltz submarine-swaps to Arkade.",
   "main": "./dist/index.js",
@@ -60,7 +60,7 @@
   "author": "Arkade-OS",
   "license": "MIT",
   "dependencies": {
-    "@arkade-os/sdk": "0.4.0",
+    "@arkade-os/sdk": "0.4.3",
     "@noble/hashes": "2.0.1",
     "@scure/base": "2.0.0",
     "@scure/btc-signer": "2.0.1",