@atomiqlabs/sdk 8.1.8 → 8.3.5

package/dist/prices/SwapPriceWithChain.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SwapPriceWithChain = void 0;
 /**
  * Chain-specific wrapper for swap pricing
- * @category Pricing and LPs
+ *
+ * @category Pricing
  */
 class SwapPriceWithChain {
     constructor(swapPrice, chainIdentifier) {
@@ -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 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}
      */
-    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,51 @@ 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 abortSignal
-     * @param preFetchedPrice Already pre-fetched price
+     * @param tokenAddress Token address to be received
+     * @param abortSignal Abort signal
+     * @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);
     }
-    preFetchPrice(token, abortSignal) {
-        return this.swapPrice.preFetchPrice(this.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 tokenAddress Token address
+     * @param abortSignal Abort signal
+     */
+    preFetchPrice(tokenAddress, abortSignal) {
+        return this.swapPrice.preFetchPrice(this.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.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 +86,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);
     }

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

@@ -1,7 +1,7 @@
 import { ChainIds, MultiChain } from "../../swapper/Swapper";
 /**
  * Coin type definition for price providers
- * @category Pricing and LPs
+ * @category Pricing
  */
 export type CoinType = {
     coinId: string;
@@ -9,7 +9,7 @@ export type CoinType = {
 };
 /**
  * Constructor coin types for price providers
- * @category Pricing and LPs
+ * @category Pricing
  */
 export type CtorCoinTypes<T extends MultiChain> = {
     coinId?: string;
@@ -22,7 +22,7 @@ export type CtorCoinTypes<T extends MultiChain> = {
 }[];
 /**
  * Coin types mapping by chain
- * @category Pricing and LPs
+ * @category Pricing
  */
 export type CoinTypes<T extends MultiChain> = {
     [chainId in keyof T]?: {
@@ -31,7 +31,7 @@ export type CoinTypes<T extends MultiChain> = {
 };
 /**
  * Abstract base class for price provider implementations
- * @category Pricing and LPs
+ * @category Pricing
  */
 export declare abstract class IPriceProvider<T extends MultiChain> {
     coinsMap: CoinTypes<T>;

package/dist/prices/abstract/IPriceProvider.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IPriceProvider = void 0;
 /**
  * Abstract base class for price provider implementations
- * @category Pricing and LPs
+ * @category Pricing
  */
 class IPriceProvider {
     constructor(coins) {

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
+ *
+ * @category Pricing
  */
 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>;
 }