@atomiqlabs/sdk 8.1.8 → 8.3.1

package/dist/prices/abstract/ISwapPrice.d.ts

@@ -3,115 +3,164 @@ import { Token } from "../../types/Token";
 import { PriceInfoType } from "../../types/PriceInfoType";
 /**
  * Abstract base class for swap pricing implementations
+ *
  * @category Pricing and LPs
  */
 export declare abstract class ISwapPrice<T extends MultiChain = MultiChain> {
     maxAllowedFeeDifferencePPM: bigint;
     protected constructor(maxAllowedFeeDifferencePPM: bigint);
     /**
-     * Gets the decimal places for a given token, returns -1 if token should be ignored & null if token is not found
-     * @param chainIdentifier
-     * @param token
+     * Gets the decimal places for a given token, returns `-1` if token should be ignored & `null` if token is not found
+     *
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param tokenAddress Token address
      * @protected
      */
-    protected abstract getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number | null;
+    protected abstract getDecimals<C extends ChainIds<T>>(chainIdentifier: C, tokenAddress: string): number | null;
     /**
      * Returns the price of the token in BTC uSats (microSats)
      *
-     * @param chainIdentifier
-     * @param token
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param tokenAddress Token address
      * @param abortSignal
      * @protected
      */
-    protected abstract getPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint>;
+    protected abstract getPrice<C extends ChainIds<T>>(chainIdentifier: C, tokenAddress: string, abortSignal?: AbortSignal): Promise<bigint>;
     /**
-     * Returns the price of bitcoin in USD, (sats/USD)
+     * Returns the price of bitcoin in USD (sats/USD)
      *
      * @param abortSignal
      * @protected
      */
     protected abstract getUsdPrice(abortSignal?: AbortSignal): Promise<number>;
-    protected getDecimalsThrowing<C extends ChainIds<T>>(chainIdentifier: C, token: string): number;
+    /**
+     * Gets the decimal places for a given token, returns `-1` if token should be ignored & throws if token is not found
+     *
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param tokenAddress Token address
+     * @throws {Error} When token is not known
+     * @protected
+     */
+    protected getDecimalsThrowing<C extends ChainIds<T>>(chainIdentifier: C, tokenAddress: string): number;
     /**
      * Recomputes pricing info without fetching the current price
      *
-     * @param chainIdentifier
-     * @param amountSats
-     * @param satsBaseFee
-     * @param feePPM
-     * @param paidToken
-     * @param token
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param amountSats Amount of sats (BTC) to be received from the swap
+     * @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 tokenAddress Token address to be paid
      */
-    recomputePriceInfoSend<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, paidToken: bigint, token: string): PriceInfoType;
+    recomputePriceInfoSend<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, paidToken: bigint, tokenAddress: string): PriceInfoType;
     /**
      * Checks whether the swap amounts are valid given the current market rate for a given pair
      *
-     * @param chainIdentifier
+     * @param chainIdentifier Chain identifier of the smart chain
      * @param amountSats Amount of sats (BTC) to be received from the swap
      * @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<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, paidToken: bigint, token: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint | null): Promise<PriceInfoType>;
+    isValidAmountSend<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, paidToken: bigint, tokenAddress: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint | null): Promise<PriceInfoType>;
     /**
      * Recomputes pricing info without fetching the current price
      *
-     * @param chainIdentifier
-     * @param amountSats
-     * @param satsBaseFee
-     * @param feePPM
-     * @param receiveToken
-     * @param token
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param amountSats Amount of sats (BTC) to be paid to the swap
+     * @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 tokenAddress Token address to be received
      */
-    recomputePriceInfoReceive<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, receiveToken: bigint, token: string): PriceInfoType;
+    recomputePriceInfoReceive<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, receiveToken: bigint, tokenAddress: string): PriceInfoType;
     /**
      * Checks whether the swap amounts are valid given the current market rate for a given pair
      *
-     * @param chainIdentifier
+     * @param chainIdentifier Chain identifier of the smart chain
      * @param amountSats Amount of sats (BTC) to be paid to the swap
      * @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<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, receiveToken: bigint, tokenAddress: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint | null): 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
+     */
+    preFetchPrice<C extends ChainIds<T>>(chainIdentifier: C, 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<C extends ChainIds<T>>(chainIdentifier: C, amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, receiveToken: bigint, token: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint | null): Promise<PriceInfoType>;
-    preFetchPrice<C extends ChainIds<T>>(chainIdentifier: C, 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 chainIdentifier
-     * @param fromAmount        Amount of satoshis
-     * @param toToken           Token
+     * @param chainIdentifier Chain identifier string for the smart chain
+     * @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<C extends ChainIds<T>>(chainIdentifier: C, fromAmount: bigint, toToken: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint | null): 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 chainIdentifier
+     * @param chainIdentifier Chain identifier string for the smart chain
      * @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<C extends ChainIds<T>>(chainIdentifier: C, fromAmount: bigint, fromToken: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<bigint>;
     /**
      * Returns whether the token should be ignored and pricing for it not calculated
-     * @param chainIdentifier
-     * @param tokenAddress
+     *
+     * @param chainIdentifier Chain identifier string for the smart chain
+     * @param tokenAddress Token address
      * @throws {Error} if token is not found
      */
     shouldIgnore<C extends ChainIds<T>>(chainIdentifier: C, tokenAddress: string): boolean;
-    getBtcUsdValue(btcSats: bigint, abortSignal?: AbortSignal, preFetchedPrice?: number): Promise<number>;
-    getTokenUsdValue<C extends ChainIds<T>>(chainId: C, 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 chainIdentifier Chain identifier string for the smart chain
+     * @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<C extends ChainIds<T>>(chainIdentifier: C, 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<C extends ChainIds<T>>(amount: bigint, token: Token<C>, abortSignal?: AbortSignal, preFetchedUsdPrice?: number): Promise<number>;
 }

package/dist/prices/abstract/ISwapPrice.js

@@ -3,60 +3,69 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ISwapPrice = void 0;
 /**
  * Abstract base class for swap pricing implementations
+ *
  * @category Pricing and LPs
  */
 class ISwapPrice {
     constructor(maxAllowedFeeDifferencePPM) {
         this.maxAllowedFeeDifferencePPM = maxAllowedFeeDifferencePPM;
     }
-    getDecimalsThrowing(chainIdentifier, token) {
-        const decimals = this.getDecimals(chainIdentifier, token);
+    /**
+     * Gets the decimal places for a given token, returns `-1` if token should be ignored & throws if token is not found
+     *
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param tokenAddress Token address
+     * @throws {Error} When token is not known
+     * @protected
+     */
+    getDecimalsThrowing(chainIdentifier, tokenAddress) {
+        const decimals = this.getDecimals(chainIdentifier, tokenAddress);
         if (decimals == null)
-            throw new Error(`Cannot get decimal count for token ${chainIdentifier}:${token}!`);
+            throw new Error(`Cannot get decimal count for token ${chainIdentifier}:${tokenAddress}!`);
         return decimals;
     }
     /**
      * Recomputes pricing info without fetching the current price
      *
-     * @param chainIdentifier
-     * @param amountSats
-     * @param satsBaseFee
-     * @param feePPM
-     * @param paidToken
-     * @param token
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param amountSats Amount of sats (BTC) to be received from the swap
+     * @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 tokenAddress Token address to be paid
      */
-    recomputePriceInfoSend(chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, token) {
+    recomputePriceInfoSend(chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, tokenAddress) {
         const totalSats = (amountSats * (1000000n + feePPM) / 1000000n)
             + satsBaseFee;
         const totalUSats = totalSats * 1000000n;
-        const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, token))) / paidToken;
+        const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, tokenAddress))) / paidToken;
         return {
             isValid: true,
             differencePPM: 0n,
             satsBaseFee,
             feePPM,
-            realPriceUSatPerToken: this.shouldIgnore(chainIdentifier, token) ? undefined : swapPriceUSatPerToken,
+            realPriceUSatPerToken: this.shouldIgnore(chainIdentifier, tokenAddress) ? undefined : swapPriceUSatPerToken,
             swapPriceUSatPerToken
         };
     }
     /**
      * Checks whether the swap amounts are valid given the current market rate for a given pair
      *
-     * @param chainIdentifier
+     * @param chainIdentifier Chain identifier of the smart chain
      * @param amountSats Amount of sats (BTC) to be received from the swap
      * @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(chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, token, abortSignal, preFetchedPrice) {
+    async isValidAmountSend(chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, tokenAddress, abortSignal, preFetchedPrice) {
         const totalSats = (amountSats * (1000000n + feePPM) / 1000000n)
             + satsBaseFee;
         const totalUSats = totalSats * 1000000n;
-        const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, token))) / paidToken;
-        if (this.shouldIgnore(chainIdentifier, token))
+        const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, tokenAddress))) / paidToken;
+        if (this.shouldIgnore(chainIdentifier, tokenAddress))
             return {
                 isValid: true,
                 differencePPM: 0n,
@@ -65,8 +74,8 @@ class ISwapPrice {
                 realPriceUSatPerToken: undefined,
                 swapPriceUSatPerToken
             };
-        const calculatedAmtInToken = await this.getFromBtcSwapAmount(chainIdentifier, totalSats, token, abortSignal, preFetchedPrice);
-        const realPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, token))) / calculatedAmtInToken;
+        const calculatedAmtInToken = await this.getFromBtcSwapAmount(chainIdentifier, totalSats, tokenAddress, abortSignal, preFetchedPrice);
+        const realPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, tokenAddress))) / calculatedAmtInToken;
         const difference = paidToken - calculatedAmtInToken; //Will be >0 if we need to pay more than we should've
         const differencePPM = difference * 1000000n / calculatedAmtInToken;
         return {
@@ -81,45 +90,45 @@ class ISwapPrice {
     /**
      * Recomputes pricing info without fetching the current price
      *
-     * @param chainIdentifier
-     * @param amountSats
-     * @param satsBaseFee
-     * @param feePPM
-     * @param receiveToken
-     * @param token
+     * @param chainIdentifier Chain identifier of the smart chain
+     * @param amountSats Amount of sats (BTC) to be paid to the swap
+     * @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 tokenAddress Token address to be received
      */
-    recomputePriceInfoReceive(chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, token) {
+    recomputePriceInfoReceive(chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, tokenAddress) {
         const totalSats = (amountSats * (1000000n - feePPM) / 1000000n)
             - satsBaseFee;
         const totalUSats = totalSats * 1000000n;
-        const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, token))) / receiveToken;
+        const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, tokenAddress))) / receiveToken;
         return {
             isValid: true,
             differencePPM: 0n,
             satsBaseFee,
             feePPM,
-            realPriceUSatPerToken: this.shouldIgnore(chainIdentifier, token) ? undefined : swapPriceUSatPerToken,
+            realPriceUSatPerToken: this.shouldIgnore(chainIdentifier, tokenAddress) ? undefined : swapPriceUSatPerToken,
             swapPriceUSatPerToken
         };
     }
     /**
      * Checks whether the swap amounts are valid given the current market rate for a given pair
      *
-     * @param chainIdentifier
+     * @param chainIdentifier Chain identifier of the smart chain
      * @param amountSats Amount of sats (BTC) to be paid to the swap
      * @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(chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, token, abortSignal, preFetchedPrice) {
+    async isValidAmountReceive(chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, tokenAddress, abortSignal, preFetchedPrice) {
         const totalSats = (amountSats * (1000000n - feePPM) / 1000000n)
             - satsBaseFee;
         const totalUSats = totalSats * 1000000n;
-        const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, token))) / receiveToken;
-        if (this.shouldIgnore(chainIdentifier, token))
+        const swapPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, tokenAddress))) / receiveToken;
+        if (this.shouldIgnore(chainIdentifier, tokenAddress))
             return {
                 isValid: true,
                 differencePPM: 0n,
@@ -128,8 +137,8 @@ class ISwapPrice {
                 realPriceUSatPerToken: undefined,
                 swapPriceUSatPerToken
             };
-        const calculatedAmtInToken = await this.getFromBtcSwapAmount(chainIdentifier, totalSats, token, abortSignal, preFetchedPrice);
-        const realPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, token))) / calculatedAmtInToken;
+        const calculatedAmtInToken = await this.getFromBtcSwapAmount(chainIdentifier, totalSats, tokenAddress, abortSignal, preFetchedPrice);
+        const realPriceUSatPerToken = totalUSats * (10n ** BigInt(this.getDecimalsThrowing(chainIdentifier, tokenAddress))) / calculatedAmtInToken;
         const difference = calculatedAmtInToken - receiveToken; //Will be >0 if we receive less than we should've
         const differencePPM = difference * 100000n / calculatedAmtInToken;
         return {
@@ -141,20 +150,34 @@ class ISwapPrice {
             swapPriceUSatPerToken
         };
     }
-    preFetchPrice(chainIdentifier, token, abortSignal) {
-        return this.getPrice(chainIdentifier, token, abortSignal);
+    /**
+     * 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(chainIdentifier, tokenAddress, abortSignal) {
+        return this.getPrice(chainIdentifier, tokenAddress, 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.getUsdPrice(abortSignal);
     }
     /**
-     * Returns amount of {toToken} that are equivalent to {fromAmount} satoshis
+     * Returns amount of `toToken` that is equivalent to `fromAmount` satoshis
      *
-     * @param chainIdentifier
-     * @param fromAmount        Amount of satoshis
-     * @param toToken           Token
+     * @param chainIdentifier Chain identifier string for the smart chain
+     * @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(chainIdentifier, fromAmount, toToken, abortSignal, preFetchedPrice) {
@@ -167,13 +190,13 @@ class ISwapPrice {
             / (price);
     }
     /**
-     * Returns amount of satoshis that are equivalent to {fromAmount} of {fromToken}
+     * Returns amount of satoshis that are equivalent to `fromAmount` of `fromToken`
      *
-     * @param chainIdentifier
+     * @param chainIdentifier Chain identifier string for the smart chain
      * @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(chainIdentifier, fromAmount, fromToken, abortSignal, preFetchedPrice) {
@@ -187,8 +210,9 @@ class ISwapPrice {
     }
     /**
      * Returns whether the token should be ignored and pricing for it not calculated
-     * @param chainIdentifier
-     * @param tokenAddress
+     *
+     * @param chainIdentifier Chain identifier string for the smart chain
+     * @param tokenAddress Token address
      * @throws {Error} if token is not found
      */
     shouldIgnore(chainIdentifier, tokenAddress) {
@@ -197,16 +221,40 @@ class ISwapPrice {
             throw new Error("Token not found");
         return coin === -1;
     }
-    async getBtcUsdValue(btcSats, abortSignal, preFetchedPrice) {
-        return Number(btcSats) * (preFetchedPrice || await this.getUsdPrice(abortSignal));
+    /**
+     * 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 Number(btcSats) * (preFetchedUsdPrice || await this.getUsdPrice(abortSignal));
     }
-    async getTokenUsdValue(chainId, tokenAmount, token, abortSignal, preFetchedPrice) {
+    /**
+     * Returns the USD value of the smart chain token amount
+     *
+     * @param chainIdentifier Chain identifier string for the smart chain
+     * @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(chainIdentifier, tokenAmount, tokenAddress, abortSignal, preFetchedUsdPrice) {
         const [btcAmount, usdPrice] = await Promise.all([
-            this.getToBtcSwapAmount(chainId, tokenAmount, token, abortSignal),
-            preFetchedPrice == null ? this.preFetchUsdPrice(abortSignal) : Promise.resolve(preFetchedPrice)
+            this.getToBtcSwapAmount(chainIdentifier, tokenAmount, tokenAddress, abortSignal),
+            preFetchedUsdPrice == null ? this.preFetchUsdPrice(abortSignal) : Promise.resolve(preFetchedUsdPrice)
         ]);
         return Number(btcAmount) * usdPrice;
     }
+    /**
+     * 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) {
         if (token.chain === "BTC") {
             return this.getBtcUsdValue(amount, abortSignal, preFetchedUsdPrice);

package/dist/prices/providers/BinancePriceProvider.d.ts

@@ -7,10 +7,17 @@ export type BinanceResponse = {
 };
 /**
  * Price provider using Binance exchange API
+ *
  * @category Pricing and LPs
  */
 export declare class BinancePriceProvider<T extends MultiChain> extends ExchangePriceProvider<T> {
     constructor(coinsMap: CtorCoinTypes<T>, url?: string, httpRequestTimeout?: number);
+    /**
+     * @inheritDoc
+     */
     protected fetchPair(pair: string, abortSignal?: AbortSignal): Promise<number>;
+    /**
+     * @inheritDoc
+     */
     protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
 }

package/dist/prices/providers/BinancePriceProvider.js

@@ -5,16 +5,23 @@ const ExchangePriceProvider_1 = require("./abstract/ExchangePriceProvider");
 const HttpUtils_1 = require("../../http/HttpUtils");
 /**
  * Price provider using Binance exchange API
+ *
  * @category Pricing and LPs
  */
 class BinancePriceProvider extends ExchangePriceProvider_1.ExchangePriceProvider {
     constructor(coinsMap, url = "https://api.binance.com/api/v3", httpRequestTimeout) {
         super(coinsMap, url, httpRequestTimeout);
     }
+    /**
+     * @inheritDoc
+     */
     async fetchPair(pair, abortSignal) {
         const response = await (0, HttpUtils_1.httpGet)(this.url + "/ticker/price?symbol=" + pair, this.httpRequestTimeout, abortSignal);
         return parseFloat(response.price);
     }
+    /**
+     * @inheritDoc
+     */
     async fetchUsdPrice(abortSignal) {
         const response = await (0, HttpUtils_1.httpGet)(this.url + "/ticker/price?symbol=BTCUSDC", this.httpRequestTimeout, abortSignal);
         return parseFloat(response.price) / 100000000;

package/dist/prices/providers/CoinGeckoPriceProvider.d.ts

@@ -12,6 +12,12 @@ export type CoinGeckoResponse<Currency extends string> = {
  */
 export declare class CoinGeckoPriceProvider<T extends MultiChain> extends HttpPriceProvider<T> {
     constructor(coinsMap: CtorCoinTypes<T>, url?: string, httpRequestTimeout?: number);
+    /**
+     * @inheritDoc
+     */
     protected fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
+    /**
+     * @inheritDoc
+     */
     protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
 }

package/dist/prices/providers/CoinGeckoPriceProvider.js

@@ -11,10 +11,16 @@ class CoinGeckoPriceProvider extends HttpPriceProvider_1.HttpPriceProvider {
     constructor(coinsMap, url = "https://api.coingecko.com/api/v3", httpRequestTimeout) {
         super(coinsMap, url, httpRequestTimeout);
     }
+    /**
+     * @inheritDoc
+     */
     async fetchPrice(token, abortSignal) {
         let response = await (0, HttpUtils_1.httpGet)(this.url + "/simple/price?ids=" + token.coinId + "&vs_currencies=sats&precision=6", this.httpRequestTimeout, abortSignal);
         return BigInt(response[token.coinId].sats * 1000000);
     }
+    /**
+     * @inheritDoc
+     */
     async fetchUsdPrice(abortSignal) {
         let response = await (0, HttpUtils_1.httpGet)(this.url + "/simple/price?ids=bitcoin&vs_currencies=usd&precision=9", this.httpRequestTimeout, abortSignal);
         return response["bitcoin"].usd / 100000000;

package/dist/prices/providers/CoinPaprikaPriceProvider.d.ts

@@ -14,6 +14,12 @@ export type CoinPaprikaResponse<Currency extends string> = {
  */
 export declare class CoinPaprikaPriceProvider<T extends MultiChain> extends HttpPriceProvider<T> {
     constructor(coinsMap: CtorCoinTypes<T>, url?: string, httpRequestTimeout?: number);
+    /**
+     * @inheritDoc
+     */
     fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
+    /**
+     * @inheritDoc
+     */
     protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
 }

package/dist/prices/providers/CoinPaprikaPriceProvider.js

@@ -11,10 +11,16 @@ class CoinPaprikaPriceProvider extends HttpPriceProvider_1.HttpPriceProvider {
     constructor(coinsMap, url = "https://api.coinpaprika.com/v1", httpRequestTimeout) {
         super(coinsMap, url, httpRequestTimeout);
     }
+    /**
+     * @inheritDoc
+     */
     async fetchPrice(token, abortSignal) {
         const response = await (0, HttpUtils_1.httpGet)(this.url + "/tickers/" + token.coinId + "?quotes=BTC", this.httpRequestTimeout, abortSignal);
         return BigInt(Math.floor(response.quotes.BTC.price * 100000000000000));
     }
+    /**
+     * @inheritDoc
+     */
     async fetchUsdPrice(abortSignal) {
         const response = await (0, HttpUtils_1.httpGet)(this.url + "/tickers/btc-bitcoin?quotes=USD", this.httpRequestTimeout, abortSignal);
         return response.quotes.USD.price / 100000000;

package/dist/prices/providers/CustomPriceProvider.d.ts

@@ -3,11 +3,22 @@ import { MultiChain } from "../../swapper/Swapper";
 import { CustomPriceFunction } from "../../types/CustomPriceFunction";
 /**
  * Price provider using custom pricing function
+ *
  * @category Pricing and LPs
  */
 export declare class CustomPriceProvider<T extends MultiChain> extends IPriceProvider<T> {
     readonly getUsdPriceFn: CustomPriceFunction;
+    /**
+     * @param coinsMap Mapping of token tickers to token addresses
+     * @param getUsdPriceFn Pricing function, used to retrieve USD prices of the tokens
+     */
     constructor(coinsMap: CtorCoinTypes<T>, getUsdPriceFn: CustomPriceFunction);
+    /**
+     * @inheritDoc
+     */
     protected fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint>;
+    /**
+     * @inheritDoc
+     */
     protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
 }