@atomiqlabs/sdk 8.1.8 → 8.3.5

package/dist/intermediaries/IntermediaryDiscovery.d.ts

@@ -4,8 +4,9 @@ import { SwapType } from "../enums/SwapType";
 import { SwapContract } from "@atomiqlabs/base";
 import { EventEmitter } from "events";
 /**
- * Swap handler type enum for intermediary communication
- * @category Pricing and LPs
+ * Swap handler type mapping for intermediary communication
+ *
+ * @category LPs
  */
 export declare enum SwapHandlerType {
     TO_BTC = "TO_BTC",
@@ -19,7 +20,8 @@ export declare enum SwapHandlerType {
 }
 /**
  * Swap handler information type
- * @category Pricing and LPs
+ *
+ * @category LPs
  */
 export type SwapHandlerInfoType = {
     swapFeePPM: number;
@@ -34,7 +36,8 @@ export type SwapHandlerInfoType = {
 };
 /**
  * Token bounds (min/max) for swaps
- * @category Pricing and LPs
+ *
+ * @category LPs
  */
 export type TokenBounds = {
     [token: string]: {
@@ -43,41 +46,63 @@ export type TokenBounds = {
     };
 };
 /**
- * Multi-chain token bounds
- * @category Pricing and LPs
+ * Multi-chain token bounds (min/max) for swaps
+ *
+ * @category LPs
  */
 export type MultichainTokenBounds = {
     [chainId: string]: TokenBounds;
 };
 /**
- * Swap bounds by type
- * @category Pricing and LPs
+ * Swap bounds by swap protocol type
+ *
+ * @category LPs
  */
 export type SwapBounds = {
     [key in SwapType]?: TokenBounds;
 };
 /**
  * Multi-chain swap bounds
- * @category Pricing and LPs
+ *
+ * @category LPs
  */
 export type MultichainSwapBounds = {
     [key in SwapType]?: MultichainTokenBounds;
 };
 /**
- * Discovery service for available liquidity providers/intermediaries
- * @category Pricing and LPs
+ * Discovery service for available intermediaries (liquidity providers)
+ *
+ * @category LPs
  */
 export declare class IntermediaryDiscovery extends EventEmitter {
+    /**
+     * A current list of active intermediaries
+     */
     intermediaries: Intermediary[];
+    /**
+     * Swap contracts for checking intermediary signatures
+     */
     swapContracts: {
         [key: string]: SwapContract;
     };
+    /**
+     * Registry URL used as a source for the list of intermediaries, this should be a link to a
+     *  github-hosted JSON file
+     */
     registryUrl: string;
+    /**
+     * Timeout for the HTTP handshake (/info) requests sent to the intermediaries
+     */
     httpRequestTimeout?: number;
     /**
-     * Maximum time (in millis) to wait for other LP's responses after the first one was founds
+     * Maximum time (in millis) to wait for other intermediary's responses after the first one was founds
      */
     maxWaitForOthersTimeout?: number;
+    /**
+     * The intermediary URLs passed in the constructor, to be used instead of querying the registry
+     *
+     * @private
+     */
     private overrideNodeUrls?;
     constructor(swapContracts: {
         [key: string]: SwapContract;
@@ -107,14 +132,19 @@ export declare class IntermediaryDiscovery extends EventEmitter {
      */
     private loadIntermediary;
     /**
-     * Returns the intermediary at the provided URL, either from the already fetched list of LPs or fetches the data on-demand
+     * Returns the intermediary at the provided URL, either from the already fetched list of LPs
+     *  or fetches the data on-demand, by sending the handshake HTTP request (/info) to the LP.
      *
-     * @param url
+     * Doesn't save the fetched intermediary to the list of intermediaries if it isn't already
+     *  part of the known intermediaries
+     *
+     * @param url Base URL of the intermediary, which accepts HTTP requests
      * @param abortSignal
      */
     getIntermediary(url: string, abortSignal?: AbortSignal): Promise<Intermediary | null>;
     /**
      * Reloads the saves a list of intermediaries
+     *
      * @param abortSignal
      */
     reloadIntermediaries(abortSignal?: AbortSignal): Promise<void>;
@@ -124,39 +154,42 @@ export declare class IntermediaryDiscovery extends EventEmitter {
      * @param abortSignal
      */
     init(abortSignal?: AbortSignal): Promise<void>;
+    /**
+     * Returns known swap bounds (in satoshis - BTC) by aggregating values from all known intermediaries
+     */
     getMultichainSwapBounds(): MultichainSwapBounds;
     /**
-     * Returns aggregate swap bounds (in sats - BTC) as indicated by the intermediaries
+     * Returns aggregate swap bounds (in satoshis - BTC) as indicated by the intermediaries
      */
     getSwapBounds(chainIdentifier: string): SwapBounds;
     /**
-     * Returns the aggregate swap minimum (in sats - BTC) for a specific swap type & token
+     * Returns the aggregate swap minimum (in satoshis - BTC) for a specific swap type & token
      *  as indicated by the intermediaries
      *
-     * @param chainIdentifier
-     * @param swapType
-     * @param token
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param swapType Swap protocol type
+     * @param tokenAddress Token address
      */
-    getSwapMinimum(chainIdentifier: string, swapType: SwapType, token: any): number | null;
+    getSwapMinimum(chainIdentifier: string, swapType: SwapType, tokenAddress: string): number | null;
     /**
-     * Returns the aggregate swap maximum (in sats - BTC) for a specific swap type & token
+     * Returns the aggregate swap maximum (in satoshis - BTC) for a specific swap type & token
      *  as indicated by the intermediaries
      *
-     * @param chainIdentifier
-     * @param swapType
-     * @param token
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param swapType Swap protocol type
+     * @param tokenAddress Token address
      */
-    getSwapMaximum(chainIdentifier: string, swapType: SwapType, token: any): number | null;
+    getSwapMaximum(chainIdentifier: string, swapType: SwapType, tokenAddress: string): number | null;
     /**
      * Returns swap candidates for a specific swap type & token address
      *
-     * @param chainIdentifier
-     * @param swapType
-     * @param tokenAddress
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param swapType Swap protocol type
+     * @param tokenAddress Token address
      * @param amount Amount to be swapped in sats - BTC
      * @param count How many intermediaries to return at most
      */
-    getSwapCandidates(chainIdentifier: string, swapType: SwapType, tokenAddress: any, amount?: bigint, count?: number): Intermediary[];
+    getSwapCandidates(chainIdentifier: string, swapType: SwapType, tokenAddress: string, amount?: bigint, count?: number): Intermediary[];
     /**
      * Removes a specific intermediary from the list of active intermediaries (used for blacklisting)
      *

package/dist/intermediaries/IntermediaryDiscovery.js

@@ -11,8 +11,9 @@ const Logger_1 = require("../utils/Logger");
 const HttpUtils_1 = require("../http/HttpUtils");
 const RetryUtils_1 = require("../utils/RetryUtils");
 /**
- * Swap handler type enum for intermediary communication
- * @category Pricing and LPs
+ * Swap handler type mapping for intermediary communication
+ *
+ * @category LPs
  */
 var SwapHandlerType;
 (function (SwapHandlerType) {
@@ -27,7 +28,7 @@ var SwapHandlerType;
 })(SwapHandlerType = exports.SwapHandlerType || (exports.SwapHandlerType = {}));
 /**
  * Converts SwapHandlerType (represented as string & used in REST API communication with intermediaries) to regular
- *  SwapType
+ *  {@link SwapType}
  *
  * @param swapHandlerType
  */
@@ -49,10 +50,12 @@ function swapHandlerTypeToSwapType(swapHandlerType) {
             return SwapType_1.SwapType.SPV_VAULT_FROM_BTC;
         case SwapHandlerType.FROM_BTCLN_AUTO:
             return SwapType_1.SwapType.FROM_BTCLN_AUTO;
+        default:
+            return SwapType_1.SwapType.TRUSTED_FROM_BTCLN;
     }
 }
 /**
- * A default intermediary comparator, only takes to announced fee into consideration
+ * A default intermediary comparator, only takes the announced fee into consideration
  *
  * @param swapType
  * @param tokenAddress
@@ -86,12 +89,16 @@ const REGISTRY_URL = "https://api.github.com/repos/adambor/SolLightning-registry
 //To allow for legacy responses from not-yet updated LPs
 const DEFAULT_CHAIN = "SOLANA";
 /**
- * Discovery service for available liquidity providers/intermediaries
- * @category Pricing and LPs
+ * Discovery service for available intermediaries (liquidity providers)
+ *
+ * @category LPs
  */
 class IntermediaryDiscovery extends events_1.EventEmitter {
     constructor(swapContracts, registryUrl = REGISTRY_URL, nodeUrls, httpRequestTimeout, maxWaitForOthersTimeout) {
         super();
+        /**
+         * A current list of active intermediaries
+         */
         this.intermediaries = [];
         this.swapContracts = swapContracts;
         this.registryUrl = registryUrl;
@@ -189,9 +196,13 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
         }
     }
     /**
-     * Returns the intermediary at the provided URL, either from the already fetched list of LPs or fetches the data on-demand
+     * Returns the intermediary at the provided URL, either from the already fetched list of LPs
+     *  or fetches the data on-demand, by sending the handshake HTTP request (/info) to the LP.
      *
-     * @param url
+     * Doesn't save the fetched intermediary to the list of intermediaries if it isn't already
+     *  part of the known intermediaries
+     *
+     * @param url Base URL of the intermediary, which accepts HTTP requests
      * @param abortSignal
      */
     getIntermediary(url, abortSignal) {
@@ -202,6 +213,7 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
     }
     /**
      * Reloads the saves a list of intermediaries
+     *
      * @param abortSignal
      */
     async reloadIntermediaries(abortSignal) {
@@ -236,6 +248,9 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
         logger.info("init(): Initializing with registryUrl: " + this.registryUrl + " intermediary array: " + (this.overrideNodeUrls || []).join());
         return this.reloadIntermediaries(abortSignal);
     }
+    /**
+     * Returns known swap bounds (in satoshis - BTC) by aggregating values from all known intermediaries
+     */
     getMultichainSwapBounds() {
         const bounds = {};
         this.intermediaries.forEach(intermediary => {
@@ -265,7 +280,7 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
         return bounds;
     }
     /**
-     * Returns aggregate swap bounds (in sats - BTC) as indicated by the intermediaries
+     * Returns aggregate swap bounds (in satoshis - BTC) as indicated by the intermediaries
      */
     getSwapBounds(chainIdentifier) {
         const bounds = {};
@@ -294,15 +309,15 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
         return bounds;
     }
     /**
-     * Returns the aggregate swap minimum (in sats - BTC) for a specific swap type & token
+     * Returns the aggregate swap minimum (in satoshis - BTC) for a specific swap type & token
      *  as indicated by the intermediaries
      *
-     * @param chainIdentifier
-     * @param swapType
-     * @param token
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param swapType Swap protocol type
+     * @param tokenAddress Token address
      */
-    getSwapMinimum(chainIdentifier, swapType, token) {
-        const tokenStr = token.toString();
+    getSwapMinimum(chainIdentifier, swapType, tokenAddress) {
+        const tokenStr = tokenAddress.toString();
         return this.intermediaries.reduce((prevMin, intermediary) => {
             const swapService = intermediary.services[swapType];
             if (swapService == null)
@@ -316,15 +331,15 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
         }, null);
     }
     /**
-     * Returns the aggregate swap maximum (in sats - BTC) for a specific swap type & token
+     * Returns the aggregate swap maximum (in satoshis - BTC) for a specific swap type & token
      *  as indicated by the intermediaries
      *
-     * @param chainIdentifier
-     * @param swapType
-     * @param token
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param swapType Swap protocol type
+     * @param tokenAddress Token address
      */
-    getSwapMaximum(chainIdentifier, swapType, token) {
-        const tokenStr = token.toString();
+    getSwapMaximum(chainIdentifier, swapType, tokenAddress) {
+        const tokenStr = tokenAddress.toString();
         return this.intermediaries.reduce((prevMax, intermediary) => {
             const swapService = intermediary.services[swapType];
             if (swapService == null)
@@ -340,9 +355,9 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
     /**
      * Returns swap candidates for a specific swap type & token address
      *
-     * @param chainIdentifier
-     * @param swapType
-     * @param tokenAddress
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param swapType Swap protocol type
+     * @param tokenAddress Token address
      * @param amount Amount to be swapped in sats - BTC
      * @param count How many intermediaries to return at most
      */

package/dist/prices/RedundantSwapPrice.d.ts

@@ -3,7 +3,8 @@ import { ICachedSwapPrice } from "./abstract/ICachedSwapPrice";
 import { ChainIds, MultiChain } from "../swapper/Swapper";
 /**
  * Asset configuration for redundant swap pricing
- * @category Pricing and LPs
+ *
+ * @category Pricing
  */
 export type RedundantSwapPriceAssets<T extends MultiChain> = {
     binancePair?: string;
@@ -34,12 +35,22 @@ type CoinDecimals<T extends MultiChain> = {
 /**
  * Swap price API using multiple price sources, handles errors on the APIs and automatically switches between them, such
  *  that there always is a functional API
- * @category Pricing and LPs
+ *
+ * @category Pricing
  */
 export declare class RedundantSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T> {
+    /**
+     * Creates a new {@link RedundantSwapPrice} instance from an asset list and other data, using all
+     *  the available price providers: {@link BinancePriceProvider}, {@link OKXPriceProvider},
+     *  {@link CoinGeckoPriceProvider}, {@link CoinPaprikaPriceProvider}, {@link KrakenPriceProvider}
+     *
+     * @param maxAllowedFeeDiffPPM Maximum allowed price difference between returned swap prices & market prices
+     * @param assets Specifications of the assets
+     * @param cacheTimeout Timeout of the internal cache holding prices
+     */
     static createFromTokenMap<T extends MultiChain>(maxAllowedFeeDiffPPM: bigint, assets: RedundantSwapPriceAssets<T>, cacheTimeout?: number): RedundantSwapPrice<T>;
-    coinsDecimals: CoinDecimals<T>;
-    priceApis: {
+    protected coinsDecimals: CoinDecimals<T>;
+    protected priceApis: {
         priceApi: IPriceProvider<T>;
         operational?: boolean;
     }[];
@@ -73,9 +84,12 @@ export declare class RedundantSwapPrice<T extends MultiChain> extends ICachedSwa
      * @param chainIdentifier
      * @param token
      * @param abortSignal
-     * @private
+     * @protected
      */
     protected fetchPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint>;
+    /**
+     * @inheritDoc
+     */
     protected getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number | null;
     /**
      * Fetches BTC price in USD in parallel from multiple maybe operational price APIs
@@ -84,6 +98,13 @@ export declare class RedundantSwapPrice<T extends MultiChain> extends ICachedSwa
      * @private
      */
     private fetchUsdPriceFromMaybeOperationalPriceApis;
+    /**
+     * Fetches the USD prices, first tries to use the operational price API (if any) and if that fails it falls back
+     *  to using maybe operational price APIs
+     *
+     * @param abortSignal
+     * @protected
+     */
     protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
 }
 export {};

package/dist/prices/RedundantSwapPrice.js

@@ -15,9 +15,19 @@ const logger = (0, Logger_1.getLogger)("RedundantSwapPrice: ");
 /**
  * Swap price API using multiple price sources, handles errors on the APIs and automatically switches between them, such
  *  that there always is a functional API
- * @category Pricing and LPs
+ *
+ * @category Pricing
  */
 class RedundantSwapPrice extends ICachedSwapPrice_1.ICachedSwapPrice {
+    /**
+     * Creates a new {@link RedundantSwapPrice} instance from an asset list and other data, using all
+     *  the available price providers: {@link BinancePriceProvider}, {@link OKXPriceProvider},
+     *  {@link CoinGeckoPriceProvider}, {@link CoinPaprikaPriceProvider}, {@link KrakenPriceProvider}
+     *
+     * @param maxAllowedFeeDiffPPM Maximum allowed price difference between returned swap prices & market prices
+     * @param assets Specifications of the assets
+     * @param cacheTimeout Timeout of the internal cache holding prices
+     */
     static createFromTokenMap(maxAllowedFeeDiffPPM, assets, cacheTimeout) {
         const priceApis = [
             new BinancePriceProvider_1.BinancePriceProvider(assets.map(coinData => {
@@ -130,7 +140,7 @@ class RedundantSwapPrice extends ICachedSwapPrice_1.ICachedSwapPrice {
      * @param chainIdentifier
      * @param token
      * @param abortSignal
-     * @private
+     * @protected
      */
     fetchPrice(chainIdentifier, token, abortSignal) {
         return (0, RetryUtils_1.tryWithRetries)(async () => {
@@ -149,6 +159,9 @@ class RedundantSwapPrice extends ICachedSwapPrice_1.ICachedSwapPrice {
             return await this.fetchPriceFromMaybeOperationalPriceApis(chainIdentifier, token, abortSignal);
         }, undefined, RequestError_1.RequestError, abortSignal);
     }
+    /**
+     * @inheritDoc
+     */
     getDecimals(chainIdentifier, token) {
         if (this.coinsDecimals[chainIdentifier] == null)
             return null;
@@ -184,6 +197,13 @@ class RedundantSwapPrice extends ICachedSwapPrice_1.ICachedSwapPrice {
             throw e.find(err => !(err instanceof RequestError_1.RequestError)) || e[0];
         }
     }
+    /**
+     * Fetches the USD prices, first tries to use the operational price API (if any) and if that fails it falls back
+     *  to using maybe operational price APIs
+     *
+     * @param abortSignal
+     * @protected
+     */
     fetchUsdPrice(abortSignal) {
         return (0, RetryUtils_1.tryWithRetries)(() => {
             const operationalPriceApi = this.getOperationalPriceApi();

package/dist/prices/SingleSwapPrice.d.ts

@@ -2,8 +2,9 @@ import { IPriceProvider } from "./abstract/IPriceProvider";
 import { ICachedSwapPrice } from "./abstract/ICachedSwapPrice";
 import { ChainIds, MultiChain } from "../swapper/Swapper";
 /**
- * Swap price API using single price source
- * @category Pricing and LPs
+ * Swap price API using a single price source
+ *
+ * @category Pricing
  */
 export declare class SingleSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T> {
     priceProvider: IPriceProvider<T>;
@@ -19,13 +20,15 @@ export declare class SingleSwapPrice<T extends MultiChain> extends ICachedSwapPr
      */
     protected fetchPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint>;
     /**
-     * Returns the decimal places of the specified token, or -1 if token should be ignored, returns null if
-     *  token is not found
+     * @inheritDoc
+     */
+    protected getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number | null;
+    /**
+     * Fetches BTC price in USD
      *
-     * @param chainIdentifier
-     * @param token
+     * @param abortSignal
      * @protected
+     * @returns token price in uSats (micro sats)
      */
-    protected getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number | null;
     protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
 }

package/dist/prices/SingleSwapPrice.js

@@ -3,8 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SingleSwapPrice = void 0;
 const ICachedSwapPrice_1 = require("./abstract/ICachedSwapPrice");
 /**
- * Swap price API using single price source
- * @category Pricing and LPs
+ * Swap price API using a single price source
+ *
+ * @category Pricing
  */
 class SingleSwapPrice extends ICachedSwapPrice_1.ICachedSwapPrice {
     constructor(maxAllowedFeeDiffPPM, priceProvider, cacheTimeout) {
@@ -24,16 +25,18 @@ class SingleSwapPrice extends ICachedSwapPrice_1.ICachedSwapPrice {
         return this.priceProvider.getPrice(chainIdentifier, token, abortSignal);
     }
     /**
-     * Returns the decimal places of the specified token, or -1 if token should be ignored, returns null if
-     *  token is not found
-     *
-     * @param chainIdentifier
-     * @param token
-     * @protected
+     * @inheritDoc
      */
     getDecimals(chainIdentifier, token) {
         return this.priceProvider.getDecimals(chainIdentifier, token.toString());
     }
+    /**
+     * Fetches BTC price in USD
+     *
+     * @param abortSignal
+     * @protected
+     * @returns token price in uSats (micro sats)
+     */
     fetchUsdPrice(abortSignal) {
         return this.priceProvider.getUsdPrice(abortSignal);
     }

package/dist/prices/SwapPriceWithChain.d.ts

@@ -4,7 +4,8 @@ import { Token } from "../types/Token";
 import { PriceInfoType } from "../types/PriceInfoType";
 /**
  * Chain-specific wrapper for swap pricing
- * @category Pricing and LPs
+ *
+ * @category Pricing
  */
 export declare class SwapPriceWithChain<T extends MultiChain, ChainIdentifier extends ChainIds<T>> {
     swapPrice: ISwapPrice<T>;
@@ -18,11 +19,11 @@ export declare class SwapPriceWithChain<T extends MultiChain, ChainIdentifier ex
      * @param satsBaseFee Base fee in sats (BTC) as reported by the intermediary
      * @param feePPM PPM fee rate as reported by the intermediary
      * @param paidToken Amount of token to be paid to the swap
-     * @param token
-     * @param abortSignal
-     * @param preFetchedPrice Already pre-fetched price
+     * @param tokenAddress Token address to be paid
+     * @param abortSignal Abort signal
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
      */
-    isValidAmountSend(amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, paidToken: bigint, token: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<PriceInfoType>;
+    isValidAmountSend(amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, paidToken: bigint, tokenAddress: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<PriceInfoType>;
     /**
      * Checks whether the swap amounts are valid given the current market rate for a given pair
      *
@@ -30,41 +31,77 @@ export declare class SwapPriceWithChain<T extends MultiChain, ChainIdentifier ex
      * @param satsBaseFee Base fee in sats (BTC) as reported by the intermediary
      * @param feePPM PPM fee rate as reported by the intermediary
      * @param receiveToken Amount of token to be received from the swap
-     * @param token
+     * @param tokenAddress Token address to be received
+     * @param abortSignal Abort signal
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     */
+    isValidAmountReceive(amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, receiveToken: bigint, tokenAddress: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<PriceInfoType>;
+    /**
+     * Pre-fetches the pricing data for a given token, such that further calls to {@link isValidAmountReceive} or
+     *  {@link isValidAmountSend} are quicker and don't need to wait for the price fetch
+     *
+     * @param tokenAddress Token address
+     * @param abortSignal Abort signal
+     */
+    preFetchPrice(tokenAddress: string, abortSignal?: AbortSignal): Promise<bigint>;
+    /**
+     * Pre-fetches the Bitcoin USD price data, such that further calls to {@link getBtcUsdValue},
+     *  {@link getTokenUsdValue} or {@link getUsdValue} are quicker and don't need to wait for the price fetch
+     *
      * @param abortSignal
-     * @param preFetchedPrice Already pre-fetched price
      */
-    isValidAmountReceive(amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, receiveToken: bigint, token: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<PriceInfoType>;
-    preFetchPrice(token: string, abortSignal?: AbortSignal): Promise<bigint>;
     preFetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
     /**
-     * Returns amount of {toToken} that are equivalent to {fromAmount} satoshis
+     * Returns amount of `toToken` that is equivalent to `fromAmount` satoshis
      *
-     * @param fromAmount        Amount of satoshis
-     * @param toToken           Token
+     * @param fromAmount Amount of satoshis
+     * @param toToken Token address
      * @param abortSignal
-     * @param preFetchedPrice
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
      * @throws {Error} when token is not found
      */
     getFromBtcSwapAmount(fromAmount: bigint, toToken: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<bigint>;
     /**
-     * Returns amount of satoshis that are equivalent to {fromAmount} of {fromToken}
+     * Returns amount of satoshis that are equivalent to `fromAmount` of `fromToken`
      *
      * @param fromAmount Amount of the token
-     * @param fromToken Token
+     * @param fromToken Token address
      * @param abortSignal
-     * @param preFetchedPrice Pre-fetched swap price if available
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
      * @throws {Error} when token is not found
      */
     getToBtcSwapAmount(fromAmount: bigint, fromToken: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<bigint>;
     /**
      * Returns whether the token should be ignored and pricing for it not calculated
      *
-     * @param tokenAddress
+     * @param tokenAddress Token address
      * @throws {Error} if token is not found
      */
     shouldIgnore(tokenAddress: string): boolean;
-    getBtcUsdValue(btcSats: bigint, abortSignal?: AbortSignal, preFetchedPrice?: number): Promise<number>;
-    getTokenUsdValue(tokenAmount: bigint, token: string, abortSignal?: AbortSignal, preFetchedPrice?: number): Promise<number>;
+    /**
+     * Returns the USD value of the bitcoin amount
+     *
+     * @param btcSats Bitcoin amount in satoshis
+     * @param abortSignal
+     * @param preFetchedUsdPrice An optional price pre-fetched with {@link preFetchUsdPrice}
+     */
+    getBtcUsdValue(btcSats: bigint, abortSignal?: AbortSignal, preFetchedUsdPrice?: number): Promise<number>;
+    /**
+     * Returns the USD value of the smart chain token amount
+     *
+     * @param tokenAmount Amount of the token in base units
+     * @param tokenAddress Token address
+     * @param abortSignal
+     * @param preFetchedUsdPrice An optional price pre-fetched with {@link preFetchUsdPrice}
+     */
+    getTokenUsdValue(tokenAmount: bigint, tokenAddress: string, abortSignal?: AbortSignal, preFetchedUsdPrice?: number): Promise<number>;
+    /**
+     * Returns the USD value of the token amount
+     *
+     * @param amount Amount in base units of the token
+     * @param token Token to fetch the usd price for
+     * @param abortSignal
+     * @param preFetchedUsdPrice An optional price pre-fetched with {@link preFetchUsdPrice}
+     */
     getUsdValue(amount: bigint, token: Token<ChainIdentifier>, abortSignal?: AbortSignal, preFetchedUsdPrice?: number): Promise<number>;
 }