@atomiqlabs/sdk 8.1.7 → 8.3.1

package/src/prices/SwapPriceWithChain.ts

@@ -6,6 +6,7 @@ import {PriceInfoType} from "../types/PriceInfoType";
 
 /**
  * Chain-specific wrapper for swap pricing
+ *
  * @category Pricing and LPs
  */
 export class SwapPriceWithChain<T extends MultiChain, ChainIdentifier extends ChainIds<T>> {
@@ -27,21 +28,21 @@ export class SwapPriceWithChain<T extends MultiChain, ChainIdentifier extends Ch
      * @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}
      */
     public async isValidAmountSend(
         amountSats: bigint,
         satsBaseFee: bigint,
         feePPM: bigint,
         paidToken: bigint,
-        token: string,
+        tokenAddress: string,
         abortSignal?: AbortSignal,
         preFetchedPrice?: bigint
     ): Promise<PriceInfoType> {
         return this.swapPrice.isValidAmountSend<ChainIdentifier>(
-            this.chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, token, abortSignal, preFetchedPrice
+            this.chainIdentifier, amountSats, satsBaseFee, feePPM, paidToken, tokenAddress, abortSignal, preFetchedPrice
         );
     }
 
@@ -52,39 +53,53 @@ export class SwapPriceWithChain<T extends MultiChain, ChainIdentifier extends Ch
      * @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}
      */
     public async isValidAmountReceive(
         amountSats: bigint,
         satsBaseFee: bigint,
         feePPM: bigint,
         receiveToken: bigint,
-        token: string,
+        tokenAddress: string,
         abortSignal?: AbortSignal,
         preFetchedPrice?: bigint
     ): Promise<PriceInfoType> {
         return this.swapPrice.isValidAmountReceive<ChainIdentifier>(
-            this.chainIdentifier, amountSats, satsBaseFee, feePPM, receiveToken, token, abortSignal, preFetchedPrice
+            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
+     */
     public preFetchPrice(token: string, abortSignal?: AbortSignal): Promise<bigint> {
         return this.swapPrice.preFetchPrice<ChainIdentifier>(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
+     */
     public preFetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
         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
      */
     public async getFromBtcSwapAmount(
@@ -99,12 +114,12 @@ export class SwapPriceWithChain<T extends MultiChain, ChainIdentifier extends Ch
     }
 
     /**
-     * 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
      */
     public async getToBtcSwapAmount(
@@ -121,30 +136,53 @@ export class SwapPriceWithChain<T extends MultiChain, ChainIdentifier extends Ch
     /**
      * 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
      */
     public shouldIgnore(tokenAddress: string): boolean {
         return this.swapPrice.shouldIgnore<ChainIdentifier>(this.chainIdentifier, tokenAddress);
     }
 
+    /**
+     * 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}
+     */
     public async getBtcUsdValue(
         btcSats: bigint,
         abortSignal?: AbortSignal,
-        preFetchedPrice?: number
+        preFetchedUsdPrice?: number
     ): Promise<number> {
-        return this.swapPrice.getBtcUsdValue(btcSats, abortSignal, preFetchedPrice);
+        return this.swapPrice.getBtcUsdValue(btcSats, abortSignal, preFetchedUsdPrice);
     }
 
+    /**
+     * 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}
+     */
     public async getTokenUsdValue(
         tokenAmount: bigint,
-        token: string,
+        tokenAddress: string,
         abortSignal?: AbortSignal,
-        preFetchedPrice?: number
+        preFetchedUsdPrice?: number
     ): Promise<number> {
-        return this.swapPrice.getTokenUsdValue(this.chainIdentifier, tokenAmount, token, abortSignal, preFetchedPrice);
+        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}
+     */
     public getUsdValue(
         amount: bigint,
         token: Token<ChainIdentifier>,

package/src/prices/abstract/ISwapPrice.ts

@@ -4,6 +4,7 @@ import {PriceInfoType} from "../../types/PriceInfoType";
 
 /**
  * Abstract base class for swap pricing implementations
+ *
  * @category Pricing and LPs
  */
 export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
@@ -15,46 +16,55 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
     }
 
     /**
-     * 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 {
-        const decimals = this.getDecimals(chainIdentifier, token);
-        if(decimals==null) throw new Error(`Cannot get decimal count for token ${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
+     */
+    protected getDecimalsThrowing<C extends ChainIds<T>>(chainIdentifier: C, tokenAddress: string): number {
+        const decimals = this.getDecimals(chainIdentifier, tokenAddress);
+        if(decimals==null) 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
      */
     public recomputePriceInfoSend<C extends ChainIds<T>>(
         chainIdentifier: C,
@@ -62,19 +72,19 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
         satsBaseFee: bigint,
         feePPM: bigint,
         paidToken: bigint,
-        token: string
+        tokenAddress: string
     ): PriceInfoType {
         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
         };
     }
@@ -82,14 +92,14 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
     /**
      * 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}
      */
     public async isValidAmountSend<C extends ChainIds<T>>(
         chainIdentifier: C,
@@ -97,16 +107,16 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
         satsBaseFee: bigint,
         feePPM: bigint,
         paidToken: bigint,
-        token: string,
+        tokenAddress: string,
         abortSignal?: AbortSignal,
         preFetchedPrice?: bigint | null
     ): Promise<PriceInfoType> {
         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;
 
-        if(this.shouldIgnore(chainIdentifier, token)) return {
+        if(this.shouldIgnore(chainIdentifier, tokenAddress)) return {
             isValid: true,
             differencePPM: 0n,
             satsBaseFee,
@@ -115,8 +125,8 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
             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;
@@ -134,12 +144,12 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
     /**
      * 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
      */
     public recomputePriceInfoReceive<C extends ChainIds<T>>(
         chainIdentifier: C,
@@ -147,19 +157,19 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
         satsBaseFee: bigint,
         feePPM: bigint,
         receiveToken: bigint,
-        token: string,
+        tokenAddress: string,
     ): PriceInfoType {
         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
         };
     }
@@ -167,14 +177,14 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
     /**
      * 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}
      */
     public async isValidAmountReceive<C extends ChainIds<T>>(
         chainIdentifier: C,
@@ -182,16 +192,16 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
         satsBaseFee: bigint,
         feePPM: bigint,
         receiveToken: bigint,
-        token: string,
+        tokenAddress: string,
         abortSignal?: AbortSignal,
         preFetchedPrice?: bigint | null
     ): Promise<PriceInfoType> {
         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;
 
-        if(this.shouldIgnore(chainIdentifier, token)) return {
+        if(this.shouldIgnore(chainIdentifier, tokenAddress)) return {
             isValid: true,
             differencePPM: 0n,
             satsBaseFee,
@@ -200,8 +210,8 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
             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;
@@ -216,22 +226,36 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
         };
     }
 
-    public preFetchPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint> {
-        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
+     */
+    public preFetchPrice<C extends ChainIds<T>>(chainIdentifier: C, tokenAddress: string, abortSignal?: AbortSignal): Promise<bigint> {
+        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
+     */
     public preFetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
         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
      */
     public async getFromBtcSwapAmount<C extends ChainIds<T>>(
@@ -252,13 +276,13 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
     }
 
     /**
-     * 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
      */
     public async getToBtcSwapAmount<C extends ChainIds<T>>(
@@ -280,8 +304,9 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
 
     /**
      * 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
      */
     public shouldIgnore<C extends ChainIds<T>>(chainIdentifier: C, tokenAddress: string): boolean {
@@ -290,28 +315,52 @@ export abstract class ISwapPrice<T extends MultiChain = MultiChain> {
         return coin===-1;
     }
 
+    /**
+     * 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}
+     */
     public async getBtcUsdValue(
         btcSats: bigint,
         abortSignal?: AbortSignal,
-        preFetchedPrice?: number
+        preFetchedUsdPrice?: number
     ): Promise<number> {
-        return Number(btcSats)*(preFetchedPrice || await this.getUsdPrice(abortSignal));
+        return Number(btcSats)*(preFetchedUsdPrice || await this.getUsdPrice(abortSignal));
     }
 
+    /**
+     * 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}
+     */
     public async getTokenUsdValue<C extends ChainIds<T>>(
-        chainId: C,
+        chainIdentifier: C,
         tokenAmount: bigint,
-        token: string,
+        tokenAddress: string,
         abortSignal?: AbortSignal,
-        preFetchedPrice?: number
+        preFetchedUsdPrice?: number
     ): Promise<number> {
         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}
+     */
     public getUsdValue<C extends ChainIds<T>>(
         amount: bigint,
         token: Token<C>,

package/src/prices/providers/BinancePriceProvider.ts

@@ -10,6 +10,7 @@ export type BinanceResponse = {
 
 /**
  * Price provider using Binance exchange API
+ *
  * @category Pricing and LPs
  */
 export class BinancePriceProvider<T extends MultiChain> extends ExchangePriceProvider<T> {
@@ -18,6 +19,9 @@ export class BinancePriceProvider<T extends MultiChain> extends ExchangePricePro
         super(coinsMap, url, httpRequestTimeout);
     }
 
+    /**
+     * @inheritDoc
+     */
     protected async fetchPair(pair: string, abortSignal?: AbortSignal) {
         const response = await httpGet<BinanceResponse>(
             this.url+"/ticker/price?symbol="+pair,
@@ -28,6 +32,9 @@ export class BinancePriceProvider<T extends MultiChain> extends ExchangePricePro
         return parseFloat(response.price);
     }
 
+    /**
+     * @inheritDoc
+     */
     protected async fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
         const response = await httpGet<BinanceResponse>(
             this.url+"/ticker/price?symbol=BTCUSDC",

package/src/prices/providers/CoinGeckoPriceProvider.ts

@@ -17,6 +17,9 @@ export class CoinGeckoPriceProvider<T extends MultiChain> extends HttpPriceProvi
         super(coinsMap, url, httpRequestTimeout);
     }
 
+    /**
+     * @inheritDoc
+     */
     protected async fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint> {
         let response = await httpGet<CoinGeckoResponse<"sats">>(
             this.url+"/simple/price?ids="+token.coinId+"&vs_currencies=sats&precision=6",
@@ -27,6 +30,9 @@ export class CoinGeckoPriceProvider<T extends MultiChain> extends HttpPriceProvi
         return BigInt(response[token.coinId].sats*1000000);
     }
 
+    /**
+     * @inheritDoc
+     */
     protected async fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
         let response = await httpGet<CoinGeckoResponse<"usd">>(
             this.url+"/simple/price?ids=bitcoin&vs_currencies=usd&precision=9",

package/src/prices/providers/CoinPaprikaPriceProvider.ts

@@ -21,6 +21,9 @@ export class CoinPaprikaPriceProvider<T extends MultiChain> extends HttpPricePro
         super(coinsMap, url, httpRequestTimeout);
     }
 
+    /**
+     * @inheritDoc
+     */
     async fetchPrice(token: CoinType, abortSignal?: AbortSignal) {
         const response = await httpGet<CoinPaprikaResponse<"BTC">>(
             this.url+"/tickers/"+token.coinId+"?quotes=BTC",
@@ -31,6 +34,9 @@ export class CoinPaprikaPriceProvider<T extends MultiChain> extends HttpPricePro
         return BigInt(Math.floor(response.quotes.BTC.price*100000000000000));
     }
 
+    /**
+     * @inheritDoc
+     */
     protected async fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
         const response = await httpGet<CoinPaprikaResponse<"USD">>(
             this.url+"/tickers/btc-bitcoin?quotes=USD",

package/src/prices/providers/CustomPriceProvider.ts

@@ -4,23 +4,34 @@ import {CustomPriceFunction} from "../../types/CustomPriceFunction";
 
 /**
  * Price provider using custom pricing function
+ *
  * @category Pricing and LPs
  */
 export 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) {
         super(coinsMap);
         this.getUsdPriceFn = getUsdPriceFn;
     }
 
+    /**
+     * @inheritDoc
+     */
     protected async fetchPrice(token: CoinType, abortSignal?: AbortSignal): Promise<bigint> {
         const [btcPrice, tokenPrice] = await this.getUsdPriceFn(["BTC",token.coinId], abortSignal);
         const priceInBtc = tokenPrice / btcPrice;
         return BigInt(Math.floor(priceInBtc*100_000_000*1_000_000));
     }
 
+    /**
+     * @inheritDoc
+     */
     protected async fetchUsdPrice(abortSignal?: AbortSignal): Promise<number> {
         const [btcPrice] = await this.getUsdPriceFn(["BTC"], abortSignal);
         return btcPrice / 100_000_000;