@atomiqlabs/sdk 8.1.7 → 8.3.1

package/dist/swapper/SwapperWithSigner.js

@@ -7,24 +7,36 @@ const SwapWithSigner_1 = require("../types/SwapWithSigner");
  * @category Core
  */
 class SwapperWithSigner {
+    /**
+     * Pricing API used by the SDK
+     */
     get prices() {
         return this.swapper.prices;
     }
+    /**
+     * Intermediary discovery instance
+     */
     get intermediaryDiscovery() {
         return this.swapper.intermediaryDiscovery;
     }
-    get mempoolApi() {
-        return this.swapper.mempoolApi;
-    }
-    get bitcoinRpc() {
-        return this.swapper.bitcoinRpc;
-    }
-    get bitcoinNetwork() {
-        return this.swapper.bitcoinNetwork;
-    }
+    /**
+     * Miscellaneous utility functions
+     */
     get Utils() {
         return this.swapper.Utils;
     }
+    /**
+     * Helper information about various swap protocol and their features:
+     * - `requiresInputWallet`: Whether a swap requires a connected wallet on the input chain able to sign
+     *  arbitrary transaction
+     * - `requiresOutputWallet`: Whether a swap requires a connected wallet on the output chain able to sign
+     *  arbitrary transactions
+     * - `supportsGasDrop`: Whether a swap supports the "gas drop" feature, allowing to user to receive a small
+     *  amount of native token as part of the swap when swapping to smart chains
+     *
+     * Uses a `Record` type here, use the {@link SwapProtocolInfo} import for a literal readonly type, with
+     *  pre-filled exact values in the type.
+     */
     get SwapTypeInfo() {
         return this.swapper.SwapTypeInfo;
     }
@@ -33,43 +45,162 @@ class SwapperWithSigner {
         this.signer = signer;
         this.chainIdentifier = swapper.chainIdentifier;
     }
+    /**
+     * Creates Smart chain -> Bitcoin ({@link SwapType.TO_BTC}) swap
+     *
+     * @param tokenAddress Token address to pay with
+     * @param address Recipient's bitcoin address
+     * @param amount Amount to send in token based units (if `exactIn=true`) or receive in satoshis (if `exactIn=false`)
+     * @param exactIn Whether to use exact in instead of exact out
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
     createToBTCSwap(tokenAddress, address, amount, exactIn, additionalParams, options) {
         return this.swapper.createToBTCSwap(this.signer.getAddress(), tokenAddress, address, amount, exactIn, additionalParams, options)
             .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
     }
+    /**
+     * Creates Smart chain -> Bitcoin Lightning ({@link SwapType.TO_BTCLN}) swap
+     *
+     * @param tokenAddress Token address to pay with
+     * @param paymentRequest BOLT11 lightning network invoice to be paid (needs to have a fixed amount), and the swap
+     *  amount is taken from this fixed amount, hence only exact output swaps are supported
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
     createToBTCLNSwap(tokenAddress, paymentRequest, additionalParams, options) {
         return this.swapper.createToBTCLNSwap(this.signer.getAddress(), tokenAddress, paymentRequest, additionalParams, options)
             .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
     }
+    /**
+     * Creates Smart chain -> Bitcoin Lightning ({@link SwapType.TO_BTCLN}) swap via LNURL-pay link
+     *
+     * @param tokenAddress Token address to pay with
+     * @param lnurlPay LNURL-pay link to use for the payment
+     * @param amount Amount to send in token based units (if `exactIn=true`) or receive in satoshis (if `exactIn=false`)
+     * @param exactIn Whether to do an exact in swap instead of exact out
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
     createToBTCLNSwapViaLNURL(tokenAddress, lnurlPay, amount, exactIn, additionalParams, options) {
         return this.swapper.createToBTCLNSwapViaLNURL(this.signer.getAddress(), tokenAddress, lnurlPay, amount, exactIn, additionalParams, options)
             .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
     }
+    /**
+     * Creates Smart chain -> Bitcoin Lightning ({@link SwapType.TO_BTCLN}) swap via {@link LightningInvoiceCreateService}
+     *
+     * @param tokenAddress Token address to pay with
+     * @param service Invoice create service object which facilitates the creation of fixed amount LN invoices
+     * @param amount Amount to send in token based units (if `exactIn=true`) or receive in satoshis (if `exactIn=false`)
+     * @param exactIn Whether to do an exact in swap instead of exact out
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
+    createToBTCLNSwapViaInvoiceCreateService(tokenAddress, service, amount, exactIn, additionalParams, options) {
+        return this.swapper.createToBTCLNSwapViaInvoiceCreateService(this.signer.getAddress(), tokenAddress, service, amount, exactIn, additionalParams, options)
+            .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
+    }
+    /**
+     * Creates Bitcoin -> Smart chain ({@link SwapType.SPV_VAULT_FROM_BTC}) swap
+     *
+     * @param tokenAddress Token address to receive
+     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
+     * @param exactOut Whether to use a exact out instead of exact in
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
+    createFromBTCSwapNew(tokenAddress, amount, exactOut, additionalParams, options) {
+        return this.swapper.createFromBTCSwapNew(this.signer.getAddress(), tokenAddress, amount, exactOut, additionalParams, options)
+            .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
+    }
+    /**
+     * Creates LEGACY Bitcoin -> Smart chain ({@link SwapType.FROM_BTC}) swap
+     *
+     * @param tokenAddress Token address to receive
+     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
+     * @param exactOut Whether to use a exact out instead of exact in
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
     createFromBTCSwap(tokenAddress, amount, exactOut, additionalParams, options) {
         return this.swapper.createFromBTCSwap(this.signer.getAddress(), tokenAddress, amount, exactOut, additionalParams, options)
             .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
     }
+    /**
+     * Creates LEGACY Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN}) swap
+     *
+     * @param tokenAddress Token address to receive
+     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
+     * @param exactOut Whether to use a exact out instead of exact in
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
     createFromBTCLNSwap(tokenAddress, amount, exactOut, additionalParams, options) {
         return this.swapper.createFromBTCLNSwap(this.signer.getAddress(), tokenAddress, amount, exactOut, additionalParams, options)
             .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
     }
+    /**
+     * Creates LEGACY Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN}) swap, withdrawing from
+     *  an LNURL-withdraw link
+     *
+     * @param tokenAddress Token address to receive
+     * @param lnurl LNURL-withdraw link to pull the funds from
+     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
+     * @param exactOut Whether to use a exact out instead of exact in
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     */
     createFromBTCLNSwapViaLNURL(tokenAddress, lnurl, amount, exactOut, additionalParams) {
         return this.swapper.createFromBTCLNSwapViaLNURL(this.signer.getAddress(), tokenAddress, lnurl, amount, exactOut, additionalParams)
             .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
     }
+    /**
+     * Creates Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN_AUTO}) swap
+     *
+     * @param tokenAddress Token address to receive
+     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
+     * @param exactOut Whether to use a exact out instead of exact in
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
     createFromBTCLNSwapNew(tokenAddress, amount, exactOut, additionalParams, options) {
         return this.swapper.createFromBTCLNSwapNew(this.signer.getAddress(), tokenAddress, amount, exactOut, additionalParams, options)
             .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
     }
+    /**
+     * Creates Bitcoin Lightning -> Smart chain ({@link SwapType.FROM_BTCLN_AUTO}) swap, withdrawing from
+     *  an LNURL-withdraw link
+     *
+     * @param tokenAddress Token address to receive
+     * @param lnurl LNURL-withdraw link to pull the funds from
+     * @param amount Amount to send in satoshis (if `exactOut=false`) or receive in token based units (if `exactOut=true`)
+     * @param exactOut Whether to use a exact out instead of exact in
+     * @param additionalParams Additional parameters sent to the LP when creating the swap
+     * @param options Additional options for the swap
+     */
     createFromBTCLNSwapNewViaLNURL(tokenAddress, lnurl, amount, exactOut, additionalParams, options) {
         return this.swapper.createFromBTCLNSwapNewViaLNURL(this.signer.getAddress(), tokenAddress, lnurl, amount, exactOut, additionalParams, options)
             .then(swap => (0, SwapWithSigner_1.wrapSwapWithSigner)(swap, this.signer));
     }
-    createTrustedLNForGasSwap(amount, trustedIntermediaryUrl) {
-        return this.swapper.createTrustedLNForGasSwap(this.signer.getAddress(), amount, trustedIntermediaryUrl);
+    /**
+     * Creates a trusted Bitcoin Lightning -> Smart chain ({@link SwapType.TRUSTED_FROM_BTCLN}) gas swap
+     *
+     * @param amount Amount of native token to receive, in base units
+     * @param trustedIntermediaryOrUrl  URL or Intermediary object of the trusted intermediary to use, otherwise uses default
+     * @throws {Error} If no trusted intermediary specified
+     */
+    createTrustedLNForGasSwap(amount, trustedIntermediaryOrUrl) {
+        return this.swapper.createTrustedLNForGasSwap(this.signer.getAddress(), amount, trustedIntermediaryOrUrl);
     }
-    createTrustedOnchainForGasSwap(amount, refundAddress, trustedIntermediaryUrl) {
-        return this.swapper.createTrustedOnchainForGasSwap(this.signer.getAddress(), amount, refundAddress, trustedIntermediaryUrl);
+    /**
+     * Creates a trusted Bitcoin -> Smart chain ({@link SwapType.TRUSTED_FROM_BTC}) gas swap
+     *
+     * @param amount Amount of native token to receive, in base units
+     * @param refundAddress Bitcoin refund address, in case the swap fails the funds are refunded here
+     * @param trustedIntermediaryOrUrl URL or Intermediary object of the trusted intermediary to use, otherwise uses default
+     * @throws {Error} If no trusted intermediary specified
+     */
+    createTrustedOnchainForGasSwap(amount, refundAddress, trustedIntermediaryOrUrl) {
+        return this.swapper.createTrustedOnchainForGasSwap(this.signer.getAddress(), amount, refundAddress, trustedIntermediaryOrUrl);
     }
     /**
      * Creates a swap from srcToken to dstToken, of a specific token amount, either specifying input amount (exactIn=true)
@@ -111,23 +242,67 @@ class SwapperWithSigner {
     getSwapById(id) {
         return this.swapper.getSwapById(id, this.signer.getAddress());
     }
+    /**
+     * Returns the swap with a proper return type, or `undefined` if not found or has wrong type
+     *
+     * @param id An ID of the swap ({@link ISwap.getId})
+     * @param swapType Type of the swap
+     */
+    async getTypedSwapById(id, swapType) {
+        return this.swapper.getTypedSwapById(id, swapType, this.signer.getAddress());
+    }
     /**
      * Synchronizes swaps from chain, this is usually ran when SDK is initialized, deletes expired quotes
      */
     async _syncSwaps() {
         return this.swapper._syncSwaps(this.signer.getAddress());
     }
+    /**
+     * Recovers swaps from on-chain historical data.
+     *
+     * Please note that the recovered swaps might not be complete (i.e. missing amounts or addresses), as some
+     *  of the swap data is purely off-chain and can never be recovered purely from on-chain data. This
+     *  functions tries to recover as much swap data as possible.
+     *
+     * @param startBlockheight Optional starting blockheight for swap data recovery, will only check swaps
+     *  initiated after this blockheight
+     */
+    async recoverSwaps(startBlockheight) {
+        return this.swapper.recoverSwaps(this.signer.getAddress(), startBlockheight);
+    }
+    /**
+     * Returns the {@link Token} object for a given token
+     *
+     * @param tickerOrAddress Token to return the object for, can use multiple formats:
+     *  - a) token ticker, such as `"BTC"`, `"SOL"`, etc.
+     *  - b) token ticker prefixed with smart chain identifier, such as `"SOLANA-SOL"`, `"SOLANA-USDC"`, etc.
+     *  - c) token address
+     */
+    getToken(tickerOrAddress) {
+        return this.swapper.getToken(tickerOrAddress);
+    }
+    /**
+     * Returns whether the SDK supports a given swap type on this chain based on currently known LPs
+     *
+     * @param swapType Swap protocol type
+     */
     supportsSwapType(swapType) {
         return this.swapper.supportsSwapType(swapType);
     }
+    /**
+     * Returns type of the swap based on input and output tokens specified
+     *
+     * @param srcToken Source token
+     * @param dstToken Destination token
+     */
     getSwapType(srcToken, dstToken) {
         return this.swapper.getSwapType(srcToken, dstToken);
     }
     /**
      * Returns minimum/maximum limits for inputs and outputs for a swap between given tokens
      *
-     * @param srcToken
-     * @param dstToken
+     * @param srcToken Source token
+     * @param dstToken Destination token
      */
     getSwapLimits(srcToken, dstToken) {
         return this.swapper.getSwapLimits(srcToken, dstToken);
@@ -139,34 +314,5 @@ class SwapperWithSigner {
     getSwapCounterTokens(token, input) {
         return this.swapper.getSwapCounterTokens(token, input);
     }
-    ///////////////////////////////////
-    /// Deprecated
-    /**
-     * Returns swap bounds (minimums & maximums) for different swap types & tokens
-     * @deprecated Use getSwapLimits() instead!
-     */
-    getSwapBounds() {
-        return this.swapper.getSwapBounds();
-    }
-    /**
-     * Returns maximum possible swap amount
-     * @deprecated Use getSwapLimits() instead!
-     *
-     * @param type      Type of the swap
-     * @param token     Token of the swap
-     */
-    getMaximum(type, token) {
-        return this.swapper.getMaximum(type, token);
-    }
-    /**
-     * Returns minimum possible swap amount
-     * @deprecated Use getSwapLimits() instead!
-     *
-     * @param type      Type of swap
-     * @param token     Token of the swap
-     */
-    getMinimum(type, token) {
-        return this.swapper.getMinimum(type, token);
-    }
 }
 exports.SwapperWithSigner = SwapperWithSigner;

package/dist/swaps/IAddressSwap.d.ts

@@ -1,13 +1,22 @@
 /**
- * Type guard to check if an object is an IAddressSwap
+ * Type guard to check if an object is an {@link IAddressSwap}
+ *
  * @category Swaps
  */
 export declare function isIAddressSwap(obj: any): obj is IAddressSwap;
 /**
  * Interface for swaps which require a user to send funds to a specific address
+ *
  * @category Swaps
  */
 export interface IAddressSwap {
+    /**
+     * An address to which the user needs to send funds on the source chain
+     */
     getAddress(): string;
+    /**
+     * A hyperlink representation of the address + amount that the user needs to sends on the source chain.
+     *  This is suitable to be displayed in a form of QR code.
+     */
     getHyperlink(): string;
 }

package/dist/swaps/IAddressSwap.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isIAddressSwap = void 0;
 /**
- * Type guard to check if an object is an IAddressSwap
+ * Type guard to check if an object is an {@link IAddressSwap}
+ *
  * @category Swaps
  */
 function isIAddressSwap(obj) {

package/dist/swaps/IBTCWalletSwap.d.ts

@@ -4,22 +4,24 @@ import { MinimalBitcoinWalletInterface, MinimalBitcoinWalletInterfaceWithSigner
 import { TokenAmount } from "../types/TokenAmount";
 import { BtcToken } from "../types/Token";
 /**
- * Type guard to check if an object is an IBTCWalletSwap
+ * Type guard to check if an object is an {@link IBTCWalletSwap}
+ *
  * @category Swaps
  */
 export declare function isIBTCWalletSwap(obj: any): obj is IBTCWalletSwap;
 /**
  * Interface for swaps requiring Bitcoin wallet interaction
+ *
  * @category Swaps
  */
 export interface IBTCWalletSwap {
     /**
      * Returns the PSBT that is already funded with wallet's UTXOs (runs a coin-selection algorithm to choose UTXOs to use),
      *  also returns inputs indices that need to be signed by the wallet before submitting the PSBT back to the SDK with
-     *  `swap.submitPsbt()`
+     *  {@link submitPsbt}
      *
      * @param _bitcoinWallet Sender's bitcoin wallet
-     * @param feeRate Optional fee rate for the transaction, needs to be at least as big as {minimumBtcFeeRate} field
+     * @param feeRate Optional fee rate in sats/vB for the transaction
      * @param additionalOutputs additional outputs to add to the PSBT - can be used to collect fees from users
      */
     getFundedPsbt(_bitcoinWallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number, additionalOutputs?: ({
@@ -37,19 +39,35 @@ export interface IBTCWalletSwap {
     /**
      * Submits a PSBT signed by the wallet back to the SDK
      *
-     * @param psbt A psbt - either a Transaction object or a hex or base64 encoded PSBT string
+     * @param psbt A PSBT, either a Transaction object or a hex or base64 encoded PSBT string
      */
     submitPsbt(psbt: Transaction | string): Promise<string>;
+    /**
+     * Estimates a bitcoin on-chain fee paid for the bitcoin swap transaction
+     *
+     * @param wallet Sender's bitcoin wallet
+     * @param feeRate Optional fee rate in sats/vB for the transaction
+     */
     estimateBitcoinFee(wallet: IBitcoinWallet | MinimalBitcoinWalletInterface, feeRate?: number): Promise<TokenAmount<any, BtcToken<false>> | null>;
+    /**
+     * Sends a swap bitcoin transaction via the passed bitcoin wallet
+     *
+     * @param wallet Sender's bitcoin wallet
+     * @param feeRate Optional fee rate in sats/vB for the transaction
+     */
     sendBitcoinTransaction(wallet: IBitcoinWallet | MinimalBitcoinWalletInterfaceWithSigner, feeRate?: number): Promise<string>;
     /**
-     * Waits till the bitcoin transaction confirms
+     * Waits till the bitcoin transaction gets the required number of confirmations
      *
      * @param updateCallback Callback called when txId is found, and also called with subsequent confirmations
      * @param checkIntervalSeconds How often to check the bitcoin transaction
      * @param abortSignal Abort signal
-     * @throws {Error} if in invalid state (must be CLAIM_COMMITED)
+     * @throws {Error} if in invalid state
      */
     waitForBitcoinTransaction(updateCallback?: (txId?: string, confirmations?: number, targetConfirmations?: number, txEtaMs?: number) => void, checkIntervalSeconds?: number, abortSignal?: AbortSignal): Promise<string>;
+    /**
+     * Returns the number of confirmations required for the bitcoin transaction for this swap
+     *  to complete and settle
+     */
     getRequiredConfirmationsCount(): number;
 }

package/dist/swaps/IBTCWalletSwap.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isIBTCWalletSwap = void 0;
 /**
- * Type guard to check if an object is an IBTCWalletSwap
+ * Type guard to check if an object is an {@link IBTCWalletSwap}
+ *
  * @category Swaps
  */
 function isIBTCWalletSwap(obj) {

package/dist/swaps/IClaimableSwap.d.ts

@@ -2,16 +2,48 @@ import { ChainType } from "@atomiqlabs/base";
 import { ISwap } from "./ISwap";
 import { ISwapWrapper, SwapTypeDefinition } from "./ISwapWrapper";
 /**
- * Type guard to check if an object is an IClaimableSwap
+ * Type guard to check if an object is an {@link IClaimableSwap}
+ *
  * @category Swaps
  */
 export declare function isIClaimableSwap(obj: any): obj is IClaimableSwap;
 /**
- * Interface for swaps that can be claimed
+ * Interface for swaps that can end up in a claimable state, requiring the user to claim the
+ *  assets on the destination chain.
+ *
  * @category Swaps
  */
 export interface IClaimableSwap<T extends ChainType = ChainType, D extends SwapTypeDefinition<T, ISwapWrapper<T, D>, IClaimableSwap<T, D, S>> = SwapTypeDefinition<T, ISwapWrapper<T, any>, IClaimableSwap<T, any, any>>, S extends number = number> extends ISwap<T, D, S> {
+    /**
+     * Checks whether a swap currently requires a manual claiming (settlement)
+     */
     isClaimable(): boolean;
-    txsClaim(_signer?: T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
-    claim(_signer?: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal): Promise<string>;
+    /**
+     * Returns transactions for settling (claiming) the swap if the swap requires manual settlement, you can check
+     *  so with {@link isClaimable}. After sending the transaction manually be sure to call the {@link waitTillClaimed}
+     *  function to wait till the claim transaction is observed, processed by the SDK and state of the swap
+     *  properly updated.
+     *
+     * @param _signer Address of the signer to create the refund transactions for
+     */
+    txsClaim(_signer?: string | T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
+    /**
+     * Settles the swap by claiming the funds on the destination chain if the swap requires manual settlement,
+     *  you can check so with {@link isClaimable}
+     *
+     * @param _signer Signer to use for signing the settlement transactions
+     * @param abortSignal Abort signal
+     * @param onBeforeTxSent Optional callback triggered before the claim transaction is broadcasted
+     */
+    claim(_signer?: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal, onBeforeTxSent?: (txId: string) => void): Promise<string>;
+    /**
+     * Waits till the swap is successfully settled (claimed), should be called after sending the claim (settlement)
+     *  transactions manually to wait till the SDK processes the settlement and updates the swap state accordingly
+     *
+     * @param maxWaitTimeSeconds Maximum time in seconds to wait for the swap to be settled
+     * @param abortSignal AbortSignal
+     *
+     * @returns {boolean} whether the swap was claimed in time or not
+     */
+    waitTillClaimed(maxWaitTimeSeconds?: number, abortSignal?: AbortSignal): Promise<boolean>;
 }

package/dist/swaps/IClaimableSwap.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isIClaimableSwap = void 0;
 /**
- * Type guard to check if an object is an IClaimableSwap
+ * Type guard to check if an object is an {@link IClaimableSwap}
+ *
  * @category Swaps
  */
 function isIClaimableSwap(obj) {

package/dist/swaps/IClaimableSwapWrapper.d.ts

@@ -1,5 +1,15 @@
 import { ISwap } from "./ISwap";
 import { IClaimableSwap } from "./IClaimableSwap";
+/**
+ * Interface for a swap wrapper for swaps that can end up in a claimable state, requiring the user to claim the
+ *  assets on the destination chain.
+ *
+ * @category Swaps
+ */
 export interface IClaimableSwapWrapper<T extends ISwap & IClaimableSwap = ISwap & IClaimableSwap> {
-    claimableSwapStates: T["state"][];
+    /**
+     * A list of swap states when the swap is potentially claimable
+     * @internal
+     */
+    _claimableSwapStates: T["_state"][];
 }

package/dist/swaps/IRefundableSwap.d.ts

@@ -2,16 +2,42 @@ import { ChainType } from "@atomiqlabs/base";
 import { ISwap } from "./ISwap";
 import { ISwapWrapper, SwapTypeDefinition } from "./ISwapWrapper";
 /**
- * Type guard to check if an object is an IRefundableSwap
+ * Type guard to check if an object is an {@link IRefundableSwap}
+ *
  * @category Swaps
  */
 export declare function isIRefundableSwap(obj: any): obj is IRefundableSwap;
 /**
- * Interface for swaps that can be refunded
+ * Interface for swaps that can be refunded in case of failure
+ *
  * @category Swaps
  */
 export interface IRefundableSwap<T extends ChainType = ChainType, D extends SwapTypeDefinition<T, ISwapWrapper<T, D>, IRefundableSwap<T, D, S>> = SwapTypeDefinition<T, ISwapWrapper<T, any>, IRefundableSwap<T, any, any>>, S extends number = number> extends ISwap<T, D, S> {
+    /**
+     * Checks whether a swap is currently refundable
+     */
     isRefundable(): boolean;
-    txsRefund(_signer?: T["Signer"] | T["NativeSigner"]): Promise<T["TX"][]>;
+    /**
+     * Returns transactions for refunding the swap if the swap is in refundable state, you can check so with
+     *  {@link isRefundable}. After sending the transaction manually be sure to call the {@link waitTillRefunded}
+     *  function to wait till the refund transaction is observed, processed by the SDK and state of the swap
+     *  properly updated.
+     *
+     * @param _signer Address of the signer to create the refund transactions for
+     */
+    txsRefund(_signer?: string): Promise<T["TX"][]>;
+    /**
+     * Refunds the swap if the swap is in refundable state, you can check so with {@link isRefundable}
+     *
+     * @param _signer Signer to sign the transactions with, must be the same as used in the initialization
+     * @param abortSignal Abort signal
+     */
     refund(_signer?: T["Signer"] | T["NativeSigner"], abortSignal?: AbortSignal): Promise<string>;
+    /**
+     * Waits till a swap is refunded, should be called after sending the refund transactions manually to
+     *  wait till the SDK processes the refund and updates the swap state accordingly
+     *
+     * @param abortSignal AbortSignal
+     */
+    waitTillRefunded(abortSignal?: AbortSignal): Promise<void>;
 }

package/dist/swaps/IRefundableSwap.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isIRefundableSwap = void 0;
 /**
- * Type guard to check if an object is an IRefundableSwap
+ * Type guard to check if an object is an {@link IRefundableSwap}
+ *
  * @category Swaps
  */
 function isIRefundableSwap(obj) {