@atomiqlabs/sdk 8.7.7 → 8.8.4

package/dist/prices/SingleSwapPrice.d.ts

@@ -1,34 +1,34 @@
-import { IPriceProvider } from "./abstract/IPriceProvider";
-import { ICachedSwapPrice } from "./abstract/ICachedSwapPrice";
-import { ChainIds, MultiChain } from "../swapper/Swapper";
-/**
- * Swap price API using a single price source
- *
- * @category Pricing
- */
-export declare class SingleSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T> {
-    priceProvider: IPriceProvider<T>;
-    constructor(maxAllowedFeeDiffPPM: bigint, priceProvider: IPriceProvider<T>, cacheTimeout?: number);
-    /**
-     * Fetch price in uSats (micro sats) for a given token against BTC
-     *
-     * @param chainIdentifier
-     * @param token
-     * @param abortSignal
-     * @protected
-     * @returns token price in uSats (micro sats)
-     */
-    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
-     *
-     * @param abortSignal
-     * @protected
-     * @returns token price in uSats (micro sats)
-     */
-    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
-}
+import { IPriceProvider } from "./abstract/IPriceProvider";
+import { ICachedSwapPrice } from "./abstract/ICachedSwapPrice";
+import { ChainIds, MultiChain } from "../swapper/Swapper";
+/**
+ * Swap price API using a single price source
+ *
+ * @category Pricing
+ */
+export declare class SingleSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T> {
+    priceProvider: IPriceProvider<T>;
+    constructor(maxAllowedFeeDiffPPM: bigint, priceProvider: IPriceProvider<T>, cacheTimeout?: number);
+    /**
+     * Fetch price in uSats (micro sats) for a given token against BTC
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param abortSignal
+     * @protected
+     * @returns token price in uSats (micro sats)
+     */
+    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
+     *
+     * @param abortSignal
+     * @protected
+     * @returns token price in uSats (micro sats)
+     */
+    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+}

package/dist/prices/SingleSwapPrice.js

@@ -1,44 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SingleSwapPrice = void 0;
-const ICachedSwapPrice_1 = require("./abstract/ICachedSwapPrice");
-/**
- * Swap price API using a single price source
- *
- * @category Pricing
- */
-class SingleSwapPrice extends ICachedSwapPrice_1.ICachedSwapPrice {
-    constructor(maxAllowedFeeDiffPPM, priceProvider, cacheTimeout) {
-        super(maxAllowedFeeDiffPPM, cacheTimeout);
-        this.priceProvider = priceProvider;
-    }
-    /**
-     * Fetch price in uSats (micro sats) for a given token against BTC
-     *
-     * @param chainIdentifier
-     * @param token
-     * @param abortSignal
-     * @protected
-     * @returns token price in uSats (micro sats)
-     */
-    fetchPrice(chainIdentifier, token, abortSignal) {
-        return this.priceProvider.getPrice(chainIdentifier, token, abortSignal);
-    }
-    /**
-     * @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);
-    }
-}
-exports.SingleSwapPrice = SingleSwapPrice;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingleSwapPrice = void 0;
+const ICachedSwapPrice_1 = require("./abstract/ICachedSwapPrice");
+/**
+ * Swap price API using a single price source
+ *
+ * @category Pricing
+ */
+class SingleSwapPrice extends ICachedSwapPrice_1.ICachedSwapPrice {
+    constructor(maxAllowedFeeDiffPPM, priceProvider, cacheTimeout) {
+        super(maxAllowedFeeDiffPPM, cacheTimeout);
+        this.priceProvider = priceProvider;
+    }
+    /**
+     * Fetch price in uSats (micro sats) for a given token against BTC
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param abortSignal
+     * @protected
+     * @returns token price in uSats (micro sats)
+     */
+    fetchPrice(chainIdentifier, token, abortSignal) {
+        return this.priceProvider.getPrice(chainIdentifier, token, abortSignal);
+    }
+    /**
+     * @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);
+    }
+}
+exports.SingleSwapPrice = SingleSwapPrice;

package/dist/prices/SwapPriceWithChain.d.ts

@@ -1,107 +1,107 @@
-import { ISwapPrice } from "./abstract/ISwapPrice";
-import { ChainIds, MultiChain } from "../swapper/Swapper";
-import { Token } from "../types/Token";
-import { PriceInfoType } from "../types/PriceInfoType";
-/**
- * Chain-specific wrapper for swap pricing
- *
- * @category Pricing
- */
-export declare class SwapPriceWithChain<T extends MultiChain, ChainIdentifier extends ChainIds<T>> {
-    swapPrice: ISwapPrice<T>;
-    chainIdentifier: ChainIdentifier;
-    maxAllowedFeeDifferencePPM: bigint;
-    constructor(swapPrice: ISwapPrice<T>, chainIdentifier: ChainIdentifier);
-    /**
-     * Checks whether the swap amounts are valid given the current market rate for a given pair
-     *
-     * @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
-     * @param abortSignal Abort signal
-     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
-     */
-    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
-     *
-     * @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
-     * @param abortSignal Abort signal
-     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
-     */
-    isValidAmountReceive(amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, receiveToken: bigint, tokenAddress: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<PriceInfoType>;
-    /**
-     * Pre-fetches the pricing data for a given token, such that further calls to {@link isValidAmountReceive} or
-     *  {@link isValidAmountSend} are quicker and don't need to wait for the price fetch
-     *
-     * @param tokenAddress Token address
-     * @param abortSignal Abort signal
-     */
-    preFetchPrice(tokenAddress: string, abortSignal?: AbortSignal): Promise<bigint>;
-    /**
-     * Pre-fetches the Bitcoin USD price data, such that further calls to {@link getBtcUsdValue},
-     *  {@link getTokenUsdValue} or {@link getUsdValue} are quicker and don't need to wait for the price fetch
-     *
-     * @param abortSignal
-     */
-    preFetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
-    /**
-     * Returns amount of `toToken` that is equivalent to `fromAmount` satoshis
-     *
-     * @param fromAmount Amount of satoshis
-     * @param toToken Token address
-     * @param abortSignal
-     * @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`
-     *
-     * @param fromAmount Amount of the token
-     * @param fromToken Token address
-     * @param abortSignal
-     * @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 Token address
-     * @throws {Error} if token is not found
-     */
-    shouldIgnore(tokenAddress: string): boolean;
-    /**
-     * 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>;
-}
+import { ISwapPrice } from "./abstract/ISwapPrice";
+import { ChainIds, MultiChain } from "../swapper/Swapper";
+import { Token } from "../types/Token";
+import { PriceInfoType } from "../types/PriceInfoType";
+/**
+ * Chain-specific wrapper for swap pricing
+ *
+ * @category Pricing
+ */
+export declare class SwapPriceWithChain<T extends MultiChain, ChainIdentifier extends ChainIds<T>> {
+    swapPrice: ISwapPrice<T>;
+    chainIdentifier: ChainIdentifier;
+    maxAllowedFeeDifferencePPM: bigint;
+    constructor(swapPrice: ISwapPrice<T>, chainIdentifier: ChainIdentifier);
+    /**
+     * Checks whether the swap amounts are valid given the current market rate for a given pair
+     *
+     * @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
+     * @param abortSignal Abort signal
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     */
+    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
+     *
+     * @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
+     * @param abortSignal Abort signal
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     */
+    isValidAmountReceive(amountSats: bigint, satsBaseFee: bigint, feePPM: bigint, receiveToken: bigint, tokenAddress: string, abortSignal?: AbortSignal, preFetchedPrice?: bigint): Promise<PriceInfoType>;
+    /**
+     * Pre-fetches the pricing data for a given token, such that further calls to {@link isValidAmountReceive} or
+     *  {@link isValidAmountSend} are quicker and don't need to wait for the price fetch
+     *
+     * @param tokenAddress Token address
+     * @param abortSignal Abort signal
+     */
+    preFetchPrice(tokenAddress: string, abortSignal?: AbortSignal): Promise<bigint>;
+    /**
+     * Pre-fetches the Bitcoin USD price data, such that further calls to {@link getBtcUsdValue},
+     *  {@link getTokenUsdValue} or {@link getUsdValue} are quicker and don't need to wait for the price fetch
+     *
+     * @param abortSignal
+     */
+    preFetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+    /**
+     * Returns amount of `toToken` that is equivalent to `fromAmount` satoshis
+     *
+     * @param fromAmount Amount of satoshis
+     * @param toToken Token address
+     * @param abortSignal
+     * @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`
+     *
+     * @param fromAmount Amount of the token
+     * @param fromToken Token address
+     * @param abortSignal
+     * @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 Token address
+     * @throws {Error} if token is not found
+     */
+    shouldIgnore(tokenAddress: string): boolean;
+    /**
+     * 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

@@ -1,128 +1,128 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwapPriceWithChain = void 0;
-/**
- * Chain-specific wrapper for swap pricing
- *
- * @category Pricing
- */
-class SwapPriceWithChain {
-    constructor(swapPrice, chainIdentifier) {
-        this.swapPrice = swapPrice;
-        this.chainIdentifier = chainIdentifier;
-        this.maxAllowedFeeDifferencePPM = swapPrice.maxAllowedFeeDifferencePPM;
-    }
-    /**
-     * Checks whether the swap amounts are valid given the current market rate for a given pair
-     *
-     * @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
-     * @param abortSignal Abort signal
-     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
-     */
-    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
-     *
-     * @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
-     * @param abortSignal Abort signal
-     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
-     */
-    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 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 is equivalent to `fromAmount` satoshis
-     *
-     * @param fromAmount Amount of satoshis
-     * @param toToken Token address
-     * @param abortSignal
-     * @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`
-     *
-     * @param fromAmount Amount of the token
-     * @param fromToken Token address
-     * @param abortSignal
-     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
-     * @throws {Error} when token is not found
-     */
-    async getToBtcSwapAmount(fromAmount, fromToken, abortSignal, preFetchedPrice) {
-        return this.swapPrice.getToBtcSwapAmount(this.chainIdentifier, fromAmount, fromToken, abortSignal, preFetchedPrice);
-    }
-    /**
-     * Returns whether the token should be ignored and pricing for it not calculated
-     *
-     * @param tokenAddress Token address
-     * @throws {Error} if token is not found
-     */
-    shouldIgnore(tokenAddress) {
-        return this.swapPrice.shouldIgnore(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}
-     */
-    async getBtcUsdValue(btcSats, abortSignal, preFetchedUsdPrice) {
-        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}
-     */
-    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);
-    }
-}
-exports.SwapPriceWithChain = SwapPriceWithChain;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SwapPriceWithChain = void 0;
+/**
+ * Chain-specific wrapper for swap pricing
+ *
+ * @category Pricing
+ */
+class SwapPriceWithChain {
+    constructor(swapPrice, chainIdentifier) {
+        this.swapPrice = swapPrice;
+        this.chainIdentifier = chainIdentifier;
+        this.maxAllowedFeeDifferencePPM = swapPrice.maxAllowedFeeDifferencePPM;
+    }
+    /**
+     * Checks whether the swap amounts are valid given the current market rate for a given pair
+     *
+     * @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
+     * @param abortSignal Abort signal
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     */
+    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
+     *
+     * @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
+     * @param abortSignal Abort signal
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     */
+    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 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 is equivalent to `fromAmount` satoshis
+     *
+     * @param fromAmount Amount of satoshis
+     * @param toToken Token address
+     * @param abortSignal
+     * @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`
+     *
+     * @param fromAmount Amount of the token
+     * @param fromToken Token address
+     * @param abortSignal
+     * @param preFetchedPrice An optional price pre-fetched with {@link preFetchPrice}
+     * @throws {Error} when token is not found
+     */
+    async getToBtcSwapAmount(fromAmount, fromToken, abortSignal, preFetchedPrice) {
+        return this.swapPrice.getToBtcSwapAmount(this.chainIdentifier, fromAmount, fromToken, abortSignal, preFetchedPrice);
+    }
+    /**
+     * Returns whether the token should be ignored and pricing for it not calculated
+     *
+     * @param tokenAddress Token address
+     * @throws {Error} if token is not found
+     */
+    shouldIgnore(tokenAddress) {
+        return this.swapPrice.shouldIgnore(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}
+     */
+    async getBtcUsdValue(btcSats, abortSignal, preFetchedUsdPrice) {
+        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}
+     */
+    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);
+    }
+}
+exports.SwapPriceWithChain = SwapPriceWithChain;