@atomiqlabs/sdk 8.1.7 → 8.3.1

package/dist/intermediaries/IntermediaryDiscovery.js

@@ -11,7 +11,8 @@ 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
+ * Swap handler type mapping for intermediary communication
+ *
  * @category Pricing and LPs
  */
 var 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
  */
@@ -52,7 +53,7 @@ function swapHandlerTypeToSwapType(swapHandlerType) {
     }
 }
 /**
- * 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 +87,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
+ * Discovery service for available intermediaries (liquidity providers)
+ *
  * @category Pricing and 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 +194,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 +211,7 @@ class IntermediaryDiscovery extends events_1.EventEmitter {
     }
     /**
      * Reloads the saves a list of intermediaries
+     *
      * @param abortSignal
      */
     async reloadIntermediaries(abortSignal) {
@@ -236,6 +246,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 +278,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 +307,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 +329,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 +353,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,6 +3,7 @@ import { ICachedSwapPrice } from "./abstract/ICachedSwapPrice";
 import { ChainIds, MultiChain } from "../swapper/Swapper";
 /**
  * Asset configuration for redundant swap pricing
+ *
  * @category Pricing and LPs
  */
 export type RedundantSwapPriceAssets<T extends MultiChain> = {
@@ -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
  */
 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
  */
 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,7 +2,8 @@ import { IPriceProvider } from "./abstract/IPriceProvider";
 import { ICachedSwapPrice } from "./abstract/ICachedSwapPrice";
 import { ChainIds, MultiChain } from "../swapper/Swapper";
 /**
- * Swap price API using single price source
+ * Swap price API using a single price source
+ *
  * @category Pricing and LPs
  */
 export declare class SingleSwapPrice<T extends MultiChain> extends ICachedSwapPrice<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,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SingleSwapPrice = void 0;
 const ICachedSwapPrice_1 = require("./abstract/ICachedSwapPrice");
 /**
- * Swap price API using single price source
+ * Swap price API using a single price source
+ *
  * @category Pricing and LPs
  */
 class SingleSwapPrice extends ICachedSwapPrice_1.ICachedSwapPrice {
@@ -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,6 +4,7 @@ import { Token } from "../types/Token";
 import { PriceInfoType } from "../types/PriceInfoType";
 /**
  * Chain-specific wrapper for swap pricing
+ *
  * @category Pricing and LPs
  */
 export declare class SwapPriceWithChain<T extends MultiChain, ChainIdentifier extends ChainIds<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 tokenAddress Token address to be paid
      * @param abortSignal
-     * @param preFetchedPrice Already pre-fetched price
+     * @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,78 @@ 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
+     * @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 chainIdentifier Chain identifier of the smart chain
+     * @param tokenAddress Token address
      * @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>;
+    /**
+     * 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
+     */
     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>;
 }

package/dist/prices/SwapPriceWithChain.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwapPriceWithChain = void 0;
 /**
  * Chain-specific wrapper for swap pricing
+ *
  * @category Pricing and LPs
  */
 class SwapPriceWithChain {
@@ -18,12 +19,12 @@ class SwapPriceWithChain {
      * @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 tokenAddress Token address to be paid
      * @param abortSignal
-     * @param preFetchedPrice Already pre-fetched price
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
      */
-    async isValidAmountSend(amountSats, satsBaseFee, feePPM, paidToken, token, abortSignal, preFetchedPrice) {
-        return this.swapPrice.isValidAmountSend(this.chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, token, abortSignal, preFetchedPrice);
+    async isValidAmountSend(amountSats, satsBaseFee, feePPM, paidToken, tokenAddress, abortSignal, preFetchedPrice) {
+        return this.swapPrice.isValidAmountSend(this.chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, tokenAddress, abortSignal, preFetchedPrice);
     }
     /**
      * Checks whether the swap amounts are valid given the current market rate for a given pair
@@ -32,38 +33,52 @@ class SwapPriceWithChain {
      * @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
-     * @param preFetchedPrice Already pre-fetched price
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
      */
-    async isValidAmountReceive(amountSats, satsBaseFee, feePPM, receiveToken, token, abortSignal, preFetchedPrice) {
-        return this.swapPrice.isValidAmountReceive(this.chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, token, abortSignal, preFetchedPrice);
+    async isValidAmountReceive(amountSats, satsBaseFee, feePPM, receiveToken, tokenAddress, abortSignal, preFetchedPrice) {
+        return this.swapPrice.isValidAmountReceive(this.chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, tokenAddress, abortSignal, preFetchedPrice);
     }
+    /**
+     * 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 chainIdentifier Chain identifier of the smart chain
+     * @param tokenAddress Token address
+     * @param abortSignal
+     */
     preFetchPrice(token, abortSignal) {
         return this.swapPrice.preFetchPrice(this.chainIdentifier, token, abortSignal);
     }
+    /**
+     * 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
+     */
     preFetchUsdPrice(abortSignal) {
         return this.swapPrice.preFetchUsdPrice(abortSignal);
     }
     /**
-     * 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
      */
     async getFromBtcSwapAmount(fromAmount, toToken, abortSignal, preFetchedPrice) {
         return this.swapPrice.getFromBtcSwapAmount(this.chainIdentifier, fromAmount, toToken, abortSignal, preFetchedPrice);
     }
     /**
-     * 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
      */
     async getToBtcSwapAmount(fromAmount, fromToken, abortSignal, preFetchedPrice) {
@@ -72,18 +87,41 @@ class SwapPriceWithChain {
     /**
      * 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) {
         return this.swapPrice.shouldIgnore(this.chainIdentifier, tokenAddress);
     }
-    async getBtcUsdValue(btcSats, abortSignal, preFetchedPrice) {
-        return this.swapPrice.getBtcUsdValue(btcSats, abortSignal, preFetchedPrice);
+    /**
+     * 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}
+     */
+    async getBtcUsdValue(btcSats, abortSignal, preFetchedUsdPrice) {
+        return this.swapPrice.getBtcUsdValue(btcSats, abortSignal, preFetchedUsdPrice);
     }
-    async getTokenUsdValue(tokenAmount, token, abortSignal, preFetchedPrice) {
-        return this.swapPrice.getTokenUsdValue(this.chainIdentifier, tokenAmount, token, abortSignal, preFetchedPrice);
+    /**
+     * 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}
+     */
+    async getTokenUsdValue(tokenAmount, tokenAddress, abortSignal, preFetchedUsdPrice) {
+        return this.swapPrice.getTokenUsdValue(this.chainIdentifier, tokenAmount, tokenAddress, abortSignal, preFetchedUsdPrice);
     }
+    /**
+     * 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, token, abortSignal, preFetchedUsdPrice) {
         return this.swapPrice.getUsdValue(amount, token, abortSignal, preFetchedUsdPrice);
     }