@atomiqlabs/sdk 8.9.1 → 8.9.2

package/dist/prices/RedundantSwapPrice.d.ts

@@ -1,110 +1,110 @@
-import { IPriceProvider } from "./abstract/IPriceProvider";
-import { ICachedSwapPrice } from "./abstract/ICachedSwapPrice";
-import { ChainIds, MultiChain } from "../swapper/Swapper";
-/**
- * Asset configuration for redundant swap pricing
- *
- * @category Pricing
- */
-export type RedundantSwapPriceAssets<T extends MultiChain> = {
-    binancePair?: string;
-    okxPair?: string;
-    coinGeckoCoinId?: string;
-    coinPaprikaCoinId?: string;
-    krakenPair?: string;
-    chains: {
-        [chainIdentifier in keyof T]?: {
-            address: string;
-            decimals: number;
-        };
-    };
-}[];
-export type CtorCoinDecimals<T extends MultiChain> = {
-    chains: {
-        [chainIdentifier in keyof T]?: {
-            address: string;
-            decimals: number;
-        };
-    };
-}[];
-type CoinDecimals<T extends MultiChain> = {
-    [chainIdentifier in keyof T]?: {
-        [tokenAddress: string]: number;
-    };
-};
-/**
- * Swap price API using multiple price sources, handles errors on the APIs and automatically switches between them, such
- *  that there always is a functional API
- *
- * @category Pricing
- */
-export declare class RedundantSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T> {
-    /**
-     * Creates a new {@link RedundantSwapPrice} instance from an asset list and other data, using all
-     *  the available price providers: {@link BinancePriceProvider}, {@link OKXPriceProvider},
-     *  {@link CoinGeckoPriceProvider}, {@link CoinPaprikaPriceProvider}, {@link KrakenPriceProvider}
-     *
-     * @param maxAllowedFeeDiffPPM Maximum allowed price difference between returned swap prices & market prices
-     * @param assets Specifications of the assets
-     * @param cacheTimeout Timeout of the internal cache holding prices
-     */
-    static createFromTokenMap<T extends MultiChain>(maxAllowedFeeDiffPPM: bigint, assets: RedundantSwapPriceAssets<T>, cacheTimeout?: number): RedundantSwapPrice<T>;
-    protected coinsDecimals: CoinDecimals<T>;
-    protected priceApis: {
-        priceApi: IPriceProvider<T>;
-        operational?: boolean;
-    }[];
-    constructor(maxAllowedFeeDiffPPM: bigint, coinsDecimals: CtorCoinDecimals<T>, priceApis: IPriceProvider<T>[], cacheTimeout?: number);
-    /**
-     * Returns price api that should be operational
-     *
-     * @private
-     */
-    private getOperationalPriceApi;
-    /**
-     * Returns price apis that are maybe operational, in case none is considered operational returns all of the price
-     *  apis such that they can be tested again whether they are operational
-     *
-     * @private
-     */
-    private getMaybeOperationalPriceApis;
-    /**
-     * Fetches price in parallel from multiple maybe operational price APIs
-     *
-     * @param chainIdentifier
-     * @param token
-     * @param abortSignal
-     * @private
-     */
-    private fetchPriceFromMaybeOperationalPriceApis;
-    /**
-     * Fetches the prices, first tries to use the operational price API (if any) and if that fails it falls back
-     *  to using maybe operational price APIs
-     *
-     * @param chainIdentifier
-     * @param token
-     * @param abortSignal
-     * @protected
-     */
-    protected fetchPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint>;
-    /**
-     * @inheritDoc
-     */
-    protected getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number | null;
-    /**
-     * Fetches BTC price in USD in parallel from multiple maybe operational price APIs
-     *
-     * @param abortSignal
-     * @private
-     */
-    private fetchUsdPriceFromMaybeOperationalPriceApis;
-    /**
-     * Fetches the USD prices, first tries to use the operational price API (if any) and if that fails it falls back
-     *  to using maybe operational price APIs
-     *
-     * @param abortSignal
-     * @protected
-     */
-    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
-}
-export {};
+import { IPriceProvider } from "./abstract/IPriceProvider";
+import { ICachedSwapPrice } from "./abstract/ICachedSwapPrice";
+import { ChainIds, MultiChain } from "../swapper/Swapper";
+/**
+ * Asset configuration for redundant swap pricing
+ *
+ * @category Pricing
+ */
+export type RedundantSwapPriceAssets<T extends MultiChain> = {
+    binancePair?: string;
+    okxPair?: string;
+    coinGeckoCoinId?: string;
+    coinPaprikaCoinId?: string;
+    krakenPair?: string;
+    chains: {
+        [chainIdentifier in keyof T]?: {
+            address: string;
+            decimals: number;
+        };
+    };
+}[];
+export type CtorCoinDecimals<T extends MultiChain> = {
+    chains: {
+        [chainIdentifier in keyof T]?: {
+            address: string;
+            decimals: number;
+        };
+    };
+}[];
+type CoinDecimals<T extends MultiChain> = {
+    [chainIdentifier in keyof T]?: {
+        [tokenAddress: string]: number;
+    };
+};
+/**
+ * Swap price API using multiple price sources, handles errors on the APIs and automatically switches between them, such
+ *  that there always is a functional API
+ *
+ * @category Pricing
+ */
+export declare class RedundantSwapPrice<T extends MultiChain> extends ICachedSwapPrice<T> {
+    /**
+     * Creates a new {@link RedundantSwapPrice} instance from an asset list and other data, using all
+     *  the available price providers: {@link BinancePriceProvider}, {@link OKXPriceProvider},
+     *  {@link CoinGeckoPriceProvider}, {@link CoinPaprikaPriceProvider}, {@link KrakenPriceProvider}
+     *
+     * @param maxAllowedFeeDiffPPM Maximum allowed price difference between returned swap prices & market prices
+     * @param assets Specifications of the assets
+     * @param cacheTimeout Timeout of the internal cache holding prices
+     */
+    static createFromTokenMap<T extends MultiChain>(maxAllowedFeeDiffPPM: bigint, assets: RedundantSwapPriceAssets<T>, cacheTimeout?: number): RedundantSwapPrice<T>;
+    protected coinsDecimals: CoinDecimals<T>;
+    protected priceApis: {
+        priceApi: IPriceProvider<T>;
+        operational?: boolean;
+    }[];
+    constructor(maxAllowedFeeDiffPPM: bigint, coinsDecimals: CtorCoinDecimals<T>, priceApis: IPriceProvider<T>[], cacheTimeout?: number);
+    /**
+     * Returns price api that should be operational
+     *
+     * @private
+     */
+    private getOperationalPriceApi;
+    /**
+     * Returns price apis that are maybe operational, in case none is considered operational returns all of the price
+     *  apis such that they can be tested again whether they are operational
+     *
+     * @private
+     */
+    private getMaybeOperationalPriceApis;
+    /**
+     * Fetches price in parallel from multiple maybe operational price APIs
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param abortSignal
+     * @private
+     */
+    private fetchPriceFromMaybeOperationalPriceApis;
+    /**
+     * Fetches the prices, first tries to use the operational price API (if any) and if that fails it falls back
+     *  to using maybe operational price APIs
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param abortSignal
+     * @protected
+     */
+    protected fetchPrice<C extends ChainIds<T>>(chainIdentifier: C, token: string, abortSignal?: AbortSignal): Promise<bigint>;
+    /**
+     * @inheritDoc
+     */
+    protected getDecimals<C extends ChainIds<T>>(chainIdentifier: C, token: string): number | null;
+    /**
+     * Fetches BTC price in USD in parallel from multiple maybe operational price APIs
+     *
+     * @param abortSignal
+     * @private
+     */
+    private fetchUsdPriceFromMaybeOperationalPriceApis;
+    /**
+     * Fetches the USD prices, first tries to use the operational price API (if any) and if that fails it falls back
+     *  to using maybe operational price APIs
+     *
+     * @param abortSignal
+     * @protected
+     */
+    protected fetchUsdPrice(abortSignal?: AbortSignal): Promise<number>;
+}
+export {};

package/dist/prices/RedundantSwapPrice.js

@@ -1,222 +1,222 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedundantSwapPrice = void 0;
-const BinancePriceProvider_1 = require("./providers/BinancePriceProvider");
-const OKXPriceProvider_1 = require("./providers/OKXPriceProvider");
-const CoinGeckoPriceProvider_1 = require("./providers/CoinGeckoPriceProvider");
-const CoinPaprikaPriceProvider_1 = require("./providers/CoinPaprikaPriceProvider");
-const Utils_1 = require("../utils/Utils");
-const ICachedSwapPrice_1 = require("./abstract/ICachedSwapPrice");
-const RequestError_1 = require("../errors/RequestError");
-const KrakenPriceProvider_1 = require("./providers/KrakenPriceProvider");
-const Logger_1 = require("../utils/Logger");
-const RetryUtils_1 = require("../utils/RetryUtils");
-const logger = (0, Logger_1.getLogger)("RedundantSwapPrice: ");
-/**
- * Swap price API using multiple price sources, handles errors on the APIs and automatically switches between them, such
- *  that there always is a functional API
- *
- * @category Pricing
- */
-class RedundantSwapPrice extends ICachedSwapPrice_1.ICachedSwapPrice {
-    /**
-     * Creates a new {@link RedundantSwapPrice} instance from an asset list and other data, using all
-     *  the available price providers: {@link BinancePriceProvider}, {@link OKXPriceProvider},
-     *  {@link CoinGeckoPriceProvider}, {@link CoinPaprikaPriceProvider}, {@link KrakenPriceProvider}
-     *
-     * @param maxAllowedFeeDiffPPM Maximum allowed price difference between returned swap prices & market prices
-     * @param assets Specifications of the assets
-     * @param cacheTimeout Timeout of the internal cache holding prices
-     */
-    static createFromTokenMap(maxAllowedFeeDiffPPM, assets, cacheTimeout) {
-        const priceApis = [
-            new BinancePriceProvider_1.BinancePriceProvider(assets.map(coinData => {
-                return {
-                    coinId: coinData.binancePair,
-                    chains: coinData.chains
-                };
-            })),
-            new OKXPriceProvider_1.OKXPriceProvider(assets.map(coinData => {
-                return {
-                    coinId: coinData.okxPair,
-                    chains: coinData.chains
-                };
-            })),
-            new CoinGeckoPriceProvider_1.CoinGeckoPriceProvider(assets.map(coinData => {
-                return {
-                    coinId: coinData.coinGeckoCoinId,
-                    chains: coinData.chains
-                };
-            })),
-            new CoinPaprikaPriceProvider_1.CoinPaprikaPriceProvider(assets.map(coinData => {
-                return {
-                    coinId: coinData.coinPaprikaCoinId,
-                    chains: coinData.chains
-                };
-            })),
-            new KrakenPriceProvider_1.KrakenPriceProvider(assets.map(coinData => {
-                return {
-                    coinId: coinData.krakenPair,
-                    chains: coinData.chains
-                };
-            }))
-        ];
-        return new RedundantSwapPrice(maxAllowedFeeDiffPPM, assets, priceApis, cacheTimeout);
-    }
-    constructor(maxAllowedFeeDiffPPM, coinsDecimals, priceApis, cacheTimeout) {
-        super(maxAllowedFeeDiffPPM, cacheTimeout);
-        this.coinsDecimals = {};
-        for (let coinData of coinsDecimals) {
-            for (let chainId in coinData.chains) {
-                const { address, decimals } = coinData.chains[chainId];
-                this.coinsDecimals[chainId] ??= {};
-                this.coinsDecimals[chainId][address.toString()] = decimals;
-            }
-        }
-        this.priceApis = priceApis.map(api => {
-            return {
-                priceApi: api
-            };
-        });
-    }
-    /**
-     * Returns price api that should be operational
-     *
-     * @private
-     */
-    getOperationalPriceApi() {
-        return this.priceApis.find(e => e.operational === true);
-    }
-    /**
-     * Returns price apis that are maybe operational, in case none is considered operational returns all of the price
-     *  apis such that they can be tested again whether they are operational
-     *
-     * @private
-     */
-    getMaybeOperationalPriceApis() {
-        let operational = this.priceApis.filter(e => e.operational === true || e.operational === undefined);
-        if (operational.length === 0) {
-            this.priceApis.forEach(e => e.operational = undefined);
-            operational = this.priceApis;
-        }
-        return operational;
-    }
-    /**
-     * Fetches price in parallel from multiple maybe operational price APIs
-     *
-     * @param chainIdentifier
-     * @param token
-     * @param abortSignal
-     * @private
-     */
-    async fetchPriceFromMaybeOperationalPriceApis(chainIdentifier, token, abortSignal) {
-        try {
-            return await (0, Utils_1.promiseAny)(this.getMaybeOperationalPriceApis().map(obj => (async () => {
-                try {
-                    const price = await obj.priceApi.getPrice(chainIdentifier, token, abortSignal);
-                    logger.debug("fetchPrice(): Price from " + obj.priceApi.constructor.name + ": ", price.toString(10));
-                    obj.operational = true;
-                    return price;
-                }
-                catch (e) {
-                    if (abortSignal != null)
-                        abortSignal.throwIfAborted();
-                    obj.operational = false;
-                    throw e;
-                }
-            })()));
-        }
-        catch (_e) {
-            const e = _e;
-            if (abortSignal != null)
-                abortSignal.throwIfAborted();
-            throw e.find(err => !(err instanceof RequestError_1.RequestError)) || e[0];
-        }
-    }
-    /**
-     * Fetches the prices, first tries to use the operational price API (if any) and if that fails it falls back
-     *  to using maybe operational price APIs
-     *
-     * @param chainIdentifier
-     * @param token
-     * @param abortSignal
-     * @protected
-     */
-    fetchPrice(chainIdentifier, token, abortSignal) {
-        return (0, RetryUtils_1.tryWithRetries)(async () => {
-            const operationalPriceApi = this.getOperationalPriceApi();
-            if (operationalPriceApi != null) {
-                try {
-                    return await operationalPriceApi.priceApi.getPrice(chainIdentifier, token, abortSignal);
-                }
-                catch (err) {
-                    if (abortSignal != null)
-                        abortSignal.throwIfAborted();
-                    operationalPriceApi.operational = false;
-                    return await this.fetchPriceFromMaybeOperationalPriceApis(chainIdentifier, token, abortSignal);
-                }
-            }
-            return await this.fetchPriceFromMaybeOperationalPriceApis(chainIdentifier, token, abortSignal);
-        }, undefined, RequestError_1.RequestError, abortSignal);
-    }
-    /**
-     * @inheritDoc
-     */
-    getDecimals(chainIdentifier, token) {
-        if (this.coinsDecimals[chainIdentifier] == null)
-            return null;
-        return this.coinsDecimals[chainIdentifier]?.[token.toString()] ?? null;
-    }
-    /**
-     * Fetches BTC price in USD in parallel from multiple maybe operational price APIs
-     *
-     * @param abortSignal
-     * @private
-     */
-    async fetchUsdPriceFromMaybeOperationalPriceApis(abortSignal) {
-        try {
-            return await (0, Utils_1.promiseAny)(this.getMaybeOperationalPriceApis().map(obj => (async () => {
-                try {
-                    const price = await obj.priceApi.getUsdPrice(abortSignal);
-                    logger.debug("fetchPrice(): USD price from " + obj.priceApi.constructor.name + ": ", price.toString(10));
-                    obj.operational = true;
-                    return price;
-                }
-                catch (e) {
-                    if (abortSignal != null)
-                        abortSignal.throwIfAborted();
-                    obj.operational = false;
-                    throw e;
-                }
-            })()));
-        }
-        catch (_e) {
-            const e = _e;
-            if (abortSignal != null)
-                abortSignal.throwIfAborted();
-            throw e.find(err => !(err instanceof RequestError_1.RequestError)) || e[0];
-        }
-    }
-    /**
-     * Fetches the USD prices, first tries to use the operational price API (if any) and if that fails it falls back
-     *  to using maybe operational price APIs
-     *
-     * @param abortSignal
-     * @protected
-     */
-    fetchUsdPrice(abortSignal) {
-        return (0, RetryUtils_1.tryWithRetries)(() => {
-            const operationalPriceApi = this.getOperationalPriceApi();
-            if (operationalPriceApi != null) {
-                return operationalPriceApi.priceApi.getUsdPrice(abortSignal).catch(err => {
-                    if (abortSignal != null)
-                        abortSignal.throwIfAborted();
-                    operationalPriceApi.operational = false;
-                    return this.fetchUsdPriceFromMaybeOperationalPriceApis(abortSignal);
-                });
-            }
-            return this.fetchUsdPriceFromMaybeOperationalPriceApis(abortSignal);
-        }, undefined, RequestError_1.RequestError, abortSignal);
-    }
-}
-exports.RedundantSwapPrice = RedundantSwapPrice;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedundantSwapPrice = void 0;
+const BinancePriceProvider_1 = require("./providers/BinancePriceProvider");
+const OKXPriceProvider_1 = require("./providers/OKXPriceProvider");
+const CoinGeckoPriceProvider_1 = require("./providers/CoinGeckoPriceProvider");
+const CoinPaprikaPriceProvider_1 = require("./providers/CoinPaprikaPriceProvider");
+const Utils_1 = require("../utils/Utils");
+const ICachedSwapPrice_1 = require("./abstract/ICachedSwapPrice");
+const RequestError_1 = require("../errors/RequestError");
+const KrakenPriceProvider_1 = require("./providers/KrakenPriceProvider");
+const Logger_1 = require("../utils/Logger");
+const RetryUtils_1 = require("../utils/RetryUtils");
+const logger = (0, Logger_1.getLogger)("RedundantSwapPrice: ");
+/**
+ * Swap price API using multiple price sources, handles errors on the APIs and automatically switches between them, such
+ *  that there always is a functional API
+ *
+ * @category Pricing
+ */
+class RedundantSwapPrice extends ICachedSwapPrice_1.ICachedSwapPrice {
+    /**
+     * Creates a new {@link RedundantSwapPrice} instance from an asset list and other data, using all
+     *  the available price providers: {@link BinancePriceProvider}, {@link OKXPriceProvider},
+     *  {@link CoinGeckoPriceProvider}, {@link CoinPaprikaPriceProvider}, {@link KrakenPriceProvider}
+     *
+     * @param maxAllowedFeeDiffPPM Maximum allowed price difference between returned swap prices & market prices
+     * @param assets Specifications of the assets
+     * @param cacheTimeout Timeout of the internal cache holding prices
+     */
+    static createFromTokenMap(maxAllowedFeeDiffPPM, assets, cacheTimeout) {
+        const priceApis = [
+            new BinancePriceProvider_1.BinancePriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.binancePair,
+                    chains: coinData.chains
+                };
+            })),
+            new OKXPriceProvider_1.OKXPriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.okxPair,
+                    chains: coinData.chains
+                };
+            })),
+            new CoinGeckoPriceProvider_1.CoinGeckoPriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.coinGeckoCoinId,
+                    chains: coinData.chains
+                };
+            })),
+            new CoinPaprikaPriceProvider_1.CoinPaprikaPriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.coinPaprikaCoinId,
+                    chains: coinData.chains
+                };
+            })),
+            new KrakenPriceProvider_1.KrakenPriceProvider(assets.map(coinData => {
+                return {
+                    coinId: coinData.krakenPair,
+                    chains: coinData.chains
+                };
+            }))
+        ];
+        return new RedundantSwapPrice(maxAllowedFeeDiffPPM, assets, priceApis, cacheTimeout);
+    }
+    constructor(maxAllowedFeeDiffPPM, coinsDecimals, priceApis, cacheTimeout) {
+        super(maxAllowedFeeDiffPPM, cacheTimeout);
+        this.coinsDecimals = {};
+        for (let coinData of coinsDecimals) {
+            for (let chainId in coinData.chains) {
+                const { address, decimals } = coinData.chains[chainId];
+                this.coinsDecimals[chainId] ??= {};
+                this.coinsDecimals[chainId][address.toString()] = decimals;
+            }
+        }
+        this.priceApis = priceApis.map(api => {
+            return {
+                priceApi: api
+            };
+        });
+    }
+    /**
+     * Returns price api that should be operational
+     *
+     * @private
+     */
+    getOperationalPriceApi() {
+        return this.priceApis.find(e => e.operational === true);
+    }
+    /**
+     * Returns price apis that are maybe operational, in case none is considered operational returns all of the price
+     *  apis such that they can be tested again whether they are operational
+     *
+     * @private
+     */
+    getMaybeOperationalPriceApis() {
+        let operational = this.priceApis.filter(e => e.operational === true || e.operational === undefined);
+        if (operational.length === 0) {
+            this.priceApis.forEach(e => e.operational = undefined);
+            operational = this.priceApis;
+        }
+        return operational;
+    }
+    /**
+     * Fetches price in parallel from multiple maybe operational price APIs
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param abortSignal
+     * @private
+     */
+    async fetchPriceFromMaybeOperationalPriceApis(chainIdentifier, token, abortSignal) {
+        try {
+            return await (0, Utils_1.promiseAny)(this.getMaybeOperationalPriceApis().map(obj => (async () => {
+                try {
+                    const price = await obj.priceApi.getPrice(chainIdentifier, token, abortSignal);
+                    logger.debug("fetchPrice(): Price from " + obj.priceApi.constructor.name + ": ", price.toString(10));
+                    obj.operational = true;
+                    return price;
+                }
+                catch (e) {
+                    if (abortSignal != null)
+                        abortSignal.throwIfAborted();
+                    obj.operational = false;
+                    throw e;
+                }
+            })()));
+        }
+        catch (_e) {
+            const e = _e;
+            if (abortSignal != null)
+                abortSignal.throwIfAborted();
+            throw e.find(err => !(err instanceof RequestError_1.RequestError)) || e[0];
+        }
+    }
+    /**
+     * Fetches the prices, first tries to use the operational price API (if any) and if that fails it falls back
+     *  to using maybe operational price APIs
+     *
+     * @param chainIdentifier
+     * @param token
+     * @param abortSignal
+     * @protected
+     */
+    fetchPrice(chainIdentifier, token, abortSignal) {
+        return (0, RetryUtils_1.tryWithRetries)(async () => {
+            const operationalPriceApi = this.getOperationalPriceApi();
+            if (operationalPriceApi != null) {
+                try {
+                    return await operationalPriceApi.priceApi.getPrice(chainIdentifier, token, abortSignal);
+                }
+                catch (err) {
+                    if (abortSignal != null)
+                        abortSignal.throwIfAborted();
+                    operationalPriceApi.operational = false;
+                    return await this.fetchPriceFromMaybeOperationalPriceApis(chainIdentifier, token, abortSignal);
+                }
+            }
+            return await this.fetchPriceFromMaybeOperationalPriceApis(chainIdentifier, token, abortSignal);
+        }, undefined, RequestError_1.RequestError, abortSignal);
+    }
+    /**
+     * @inheritDoc
+     */
+    getDecimals(chainIdentifier, token) {
+        if (this.coinsDecimals[chainIdentifier] == null)
+            return null;
+        return this.coinsDecimals[chainIdentifier]?.[token.toString()] ?? null;
+    }
+    /**
+     * Fetches BTC price in USD in parallel from multiple maybe operational price APIs
+     *
+     * @param abortSignal
+     * @private
+     */
+    async fetchUsdPriceFromMaybeOperationalPriceApis(abortSignal) {
+        try {
+            return await (0, Utils_1.promiseAny)(this.getMaybeOperationalPriceApis().map(obj => (async () => {
+                try {
+                    const price = await obj.priceApi.getUsdPrice(abortSignal);
+                    logger.debug("fetchPrice(): USD price from " + obj.priceApi.constructor.name + ": ", price.toString(10));
+                    obj.operational = true;
+                    return price;
+                }
+                catch (e) {
+                    if (abortSignal != null)
+                        abortSignal.throwIfAborted();
+                    obj.operational = false;
+                    throw e;
+                }
+            })()));
+        }
+        catch (_e) {
+            const e = _e;
+            if (abortSignal != null)
+                abortSignal.throwIfAborted();
+            throw e.find(err => !(err instanceof RequestError_1.RequestError)) || e[0];
+        }
+    }
+    /**
+     * Fetches the USD prices, first tries to use the operational price API (if any) and if that fails it falls back
+     *  to using maybe operational price APIs
+     *
+     * @param abortSignal
+     * @protected
+     */
+    fetchUsdPrice(abortSignal) {
+        return (0, RetryUtils_1.tryWithRetries)(() => {
+            const operationalPriceApi = this.getOperationalPriceApi();
+            if (operationalPriceApi != null) {
+                return operationalPriceApi.priceApi.getUsdPrice(abortSignal).catch(err => {
+                    if (abortSignal != null)
+                        abortSignal.throwIfAborted();
+                    operationalPriceApi.operational = false;
+                    return this.fetchUsdPriceFromMaybeOperationalPriceApis(abortSignal);
+                });
+            }
+            return this.fetchUsdPriceFromMaybeOperationalPriceApis(abortSignal);
+        }, undefined, RequestError_1.RequestError, abortSignal);
+    }
+}
+exports.RedundantSwapPrice = RedundantSwapPrice;