@metamask/assets-controllers 20.0.0 → 22.0.0

package/dist/TokenRatesController.js

@@ -8,60 +8,67 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _TokenRatesController_instances, _TokenRatesController_pollState, _TokenRatesController_updateTokenList, _TokenRatesController_stopPoll, _TokenRatesController_poll;
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TokenRatesController_instances, _TokenRatesController_pollState, _TokenRatesController_tokenPricesService, _TokenRatesController_inProcessExchangeRateUpdates, _TokenRatesController_getTokenAddresses, _TokenRatesController_stopPoll, _TokenRatesController_poll, _TokenRatesController_fetchAndMapExchangeRates, _TokenRatesController_fetchAndMapExchangeRatesForSupportedNativeCurrency, _TokenRatesController_fetchAndMapExchangeRatesForUnsupportedNativeCurrency;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenRatesController = void 0;
 const controller_utils_1 = require("@metamask/controller-utils");
 const polling_controller_1 = require("@metamask/polling-controller");
+const lodash_1 = require("lodash");
+const assetsUtil_1 = require("./assetsUtil");
 const crypto_compare_1 = require("./crypto-compare");
 var PollState;
 (function (PollState) {
     PollState["Active"] = "Active";
     PollState["Inactive"] = "Inactive";
 })(PollState || (PollState = {}));
-const CoinGeckoApi = {
-    BASE_URL: 'https://api.coingecko.com/api/v3',
-    getTokenPriceURL(chainSlug, query) {
-        return `${this.BASE_URL}/simple/token_price/${chainSlug}?${query}`;
-    },
-    getPlatformsURL() {
-        return `${this.BASE_URL}/asset_platforms`;
-    },
-    getSupportedVsCurrencies() {
-        return `${this.BASE_URL}/simple/supported_vs_currencies`;
-    },
-};
 /**
- * Finds the chain slug in the data array given a chainId.
+ * The maximum number of token addresses that should be sent to the Price API in
+ * a single request.
+ */
+const TOKEN_PRICES_BATCH_SIZE = 100;
+/**
+ * Uses the CryptoCompare API to fetch the exchange rate between one currency
+ * and another, i.e., the multiplier to apply the amount of one currency in
+ * order to convert it to another.
  *
- * @param chainId - The current chain ID.
- * @param data - A list platforms supported by the CoinGecko API.
- * @returns The CoinGecko slug for the given chain ID, or `null` if the slug was not found.
+ * @param args - The arguments to this function.
+ * @param args.from - The currency to convert from.
+ * @param args.to - The currency to convert to.
+ * @returns The exchange rate between `fromCurrency` to `toCurrency` if one
+ * exists, or null if one does not.
  */
-function findChainSlug(chainId, data) {
-    var _a;
-    if (!data) {
-        return null;
-    }
-    const chain = (_a = data.find(({ chain_identifier }) => chain_identifier !== null && (0, controller_utils_1.toHex)(chain_identifier) === chainId)) !== null && _a !== void 0 ? _a : null;
-    return (chain === null || chain === void 0 ? void 0 : chain.id) || null;
+function getCurrencyConversionRate({ from, to, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const includeUSDRate = false;
+        try {
+            const result = yield (0, crypto_compare_1.fetchExchangeRate)(to, from, includeUSDRate);
+            return result.conversionRate;
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.includes('market does not exist for this coin pair')) {
+                return null;
+            }
+            throw error;
+        }
+    });
 }
 /**
  * Controller that passively polls on a set interval for token-to-fiat exchange rates
  * for tokens stored in the TokensController
  */
-class TokenRatesController extends polling_controller_1.PollingControllerV1 {
+class TokenRatesController extends polling_controller_1.StaticIntervalPollingControllerV1 {
     /**
      * Creates a TokenRatesController instance.
      *
@@ -75,22 +82,16 @@ class TokenRatesController extends polling_controller_1.PollingControllerV1 {
      * @param options.onPreferencesStateChange - Allows subscribing to preference controller state changes.
      * @param options.onTokensStateChange - Allows subscribing to token controller state changes.
      * @param options.onNetworkStateChange - Allows subscribing to network state changes.
+     * @param options.tokenPricesService - An object in charge of retrieving token prices.
      * @param config - Initial options used to configure this controller.
      * @param state - Initial state to set on this controller.
      */
-    constructor({ interval = 3 * 60 * 1000, threshold = 6 * 60 * 60 * 1000, getNetworkClientById, chainId: initialChainId, ticker: initialTicker, selectedAddress: initialSelectedAddress, onPreferencesStateChange, onTokensStateChange, onNetworkStateChange, }, config, state) {
+    constructor({ interval = 3 * 60 * 1000, threshold = 6 * 60 * 60 * 1000, getNetworkClientById, chainId: initialChainId, ticker: initialTicker, selectedAddress: initialSelectedAddress, onPreferencesStateChange, onTokensStateChange, onNetworkStateChange, tokenPricesService, }, config, state) {
         super(config, state);
         _TokenRatesController_instances.add(this);
-        this.tokenList = [];
-        this.supportedChains = {
-            timestamp: 0,
-            data: null,
-        };
-        this.supportedVsCurrencies = {
-            timestamp: 0,
-            data: [],
-        };
         _TokenRatesController_pollState.set(this, PollState.Inactive);
+        _TokenRatesController_tokenPricesService.set(this, void 0);
+        _TokenRatesController_inProcessExchangeRateUpdates.set(this, {});
         /**
          * Name of this controller used during composition
          */
@@ -112,28 +113,25 @@ class TokenRatesController extends polling_controller_1.PollingControllerV1 {
         this.initialize();
         this.setIntervalLength(interval);
         this.getNetworkClientById = getNetworkClientById;
+        __classPrivateFieldSet(this, _TokenRatesController_tokenPricesService, tokenPricesService, "f");
         if (config === null || config === void 0 ? void 0 : config.disabled) {
             this.configure({ disabled: true }, false, false);
         }
-        __classPrivateFieldGet(this, _TokenRatesController_instances, "m", _TokenRatesController_updateTokenList).call(this);
         onPreferencesStateChange(({ selectedAddress }) => __awaiter(this, void 0, void 0, function* () {
             if (this.config.selectedAddress !== selectedAddress) {
                 this.configure({ selectedAddress });
-                __classPrivateFieldGet(this, _TokenRatesController_instances, "m", _TokenRatesController_updateTokenList).call(this);
                 if (__classPrivateFieldGet(this, _TokenRatesController_pollState, "f") === PollState.Active) {
                     yield this.updateExchangeRates();
                 }
             }
         }));
         onTokensStateChange(({ allTokens, allDetectedTokens }) => __awaiter(this, void 0, void 0, function* () {
-            // These two state properties are assumed to be immutable
-            if (this.config.allTokens !== allTokens ||
-                this.config.allDetectedTokens !== allDetectedTokens) {
-                this.configure({ allTokens, allDetectedTokens });
-                __classPrivateFieldGet(this, _TokenRatesController_instances, "m", _TokenRatesController_updateTokenList).call(this);
-                if (__classPrivateFieldGet(this, _TokenRatesController_pollState, "f") === PollState.Active) {
-                    yield this.updateExchangeRates();
-                }
+            const previousTokenAddresses = __classPrivateFieldGet(this, _TokenRatesController_instances, "m", _TokenRatesController_getTokenAddresses).call(this, this.config.chainId);
+            this.configure({ allTokens, allDetectedTokens });
+            const newTokenAddresses = __classPrivateFieldGet(this, _TokenRatesController_instances, "m", _TokenRatesController_getTokenAddresses).call(this, this.config.chainId);
+            if (!(0, lodash_1.isEqual)(previousTokenAddresses, newTokenAddresses) &&
+                __classPrivateFieldGet(this, _TokenRatesController_pollState, "f") === PollState.Active) {
+                yield this.updateExchangeRates();
             }
         }));
         onNetworkStateChange(({ providerConfig }) => __awaiter(this, void 0, void 0, function* () {
@@ -142,7 +140,6 @@ class TokenRatesController extends polling_controller_1.PollingControllerV1 {
                 this.config.nativeCurrency !== ticker) {
                 this.update({ contractExchangeRates: {} });
                 this.configure({ chainId, nativeCurrency: ticker });
-                __classPrivateFieldGet(this, _TokenRatesController_instances, "m", _TokenRatesController_updateTokenList).call(this);
                 if (__classPrivateFieldGet(this, _TokenRatesController_pollState, "f") === PollState.Active) {
                     yield this.updateExchangeRates();
                 }
@@ -166,84 +163,15 @@ class TokenRatesController extends polling_controller_1.PollingControllerV1 {
         __classPrivateFieldGet(this, _TokenRatesController_instances, "m", _TokenRatesController_stopPoll).call(this);
         __classPrivateFieldSet(this, _TokenRatesController_pollState, PollState.Inactive, "f");
     }
-    /**
-     * Fetches a pairs of token address and native currency.
-     *
-     * @param chainSlug - The chain string identifier.
-     * @param vsCurrency - The currency used to generate pairs against the tokens.
-     * @param tokenAddresses - The addresses for the token contracts.
-     * @returns The exchange rates for the given pairs.
-     */
-    fetchExchangeRate(chainSlug, vsCurrency, tokenAddresses = this.tokenList.map((token) => token.address)) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tokenPairs = tokenAddresses.join(',');
-            const query = `contract_addresses=${tokenPairs}&vs_currencies=${vsCurrency.toLowerCase()}`;
-            return (0, controller_utils_1.handleFetch)(CoinGeckoApi.getTokenPriceURL(chainSlug, query));
-        });
-    }
-    /**
-     * Checks if the current native currency is a supported vs currency to use
-     * to query for token exchange rates.
-     *
-     * @param nativeCurrency - The native currency to check.
-     * @returns A boolean indicating whether it's a supported vsCurrency.
-     */
-    checkIsSupportedVsCurrency(nativeCurrency) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { threshold } = this.config;
-            const { timestamp, data } = this.supportedVsCurrencies;
-            const now = Date.now();
-            if (now - timestamp > threshold) {
-                const currencies = yield (0, controller_utils_1.handleFetch)(CoinGeckoApi.getSupportedVsCurrencies());
-                this.supportedVsCurrencies = {
-                    data: currencies,
-                    timestamp: Date.now(),
-                };
-                return currencies.includes(nativeCurrency.toLowerCase());
-            }
-            return data.includes(nativeCurrency.toLowerCase());
-        });
-    }
-    /**
-     * Gets the slug from cached supported platforms CoinGecko API response for the chain ID.
-     * If cached supported platforms response is stale, fetches and updates it.
-     *
-     * @param chainId - The chain ID.
-     * @returns The CoinGecko slug for the chain ID.
-     */
-    getChainSlug(chainId = this.config.chainId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { threshold } = this.config;
-            const { data, timestamp } = this.supportedChains;
-            const now = Date.now();
-            if (now - timestamp > threshold) {
-                const platforms = yield (0, controller_utils_1.handleFetch)(CoinGeckoApi.getPlatformsURL());
-                this.supportedChains = {
-                    data: platforms,
-                    timestamp: Date.now(),
-                };
-                return findChainSlug(chainId, platforms);
-            }
-            return findChainSlug(chainId, data);
-        });
-    }
     /**
      * Updates exchange rates for all tokens.
      */
     updateExchangeRates() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.tokenList.length === 0 || this.disabled) {
-                return;
-            }
             const { chainId, nativeCurrency } = this.config;
-            const tokenAddresses = this.tokenList.map((token) => token.address);
             yield this.updateExchangeRatesByChainId({
                 chainId,
                 nativeCurrency,
-                tokenAddresses,
-            });
-            this.update({
-                contractExchangeRates: this.state.contractExchangeRatesByChainId[chainId][nativeCurrency],
             });
         });
     }
@@ -253,117 +181,80 @@ class TokenRatesController extends polling_controller_1.PollingControllerV1 {
      * @param options - The options to fetch exchange rates.
      * @param options.chainId - The chain ID.
      * @param options.nativeCurrency - The ticker for the chain.
-     * @param options.tokenAddresses - The addresses for the token contracts.
      */
-    updateExchangeRatesByChainId({ chainId, nativeCurrency, tokenAddresses, }) {
-        var _a, _b;
+    updateExchangeRatesByChainId({ chainId, nativeCurrency, }) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            if (!tokenAddresses.length) {
+            if (this.disabled) {
                 return;
             }
-            const chainSlug = yield this.getChainSlug(chainId);
-            let newContractExchangeRates = {};
-            if (!chainSlug) {
-                tokenAddresses.forEach((tokenAddress) => {
-                    const address = (0, controller_utils_1.toChecksumHexAddress)(tokenAddress);
-                    newContractExchangeRates[address] = undefined;
-                });
+            const tokenAddresses = __classPrivateFieldGet(this, _TokenRatesController_instances, "m", _TokenRatesController_getTokenAddresses).call(this, chainId);
+            if (tokenAddresses.length === 0) {
+                return;
             }
-            else {
-                newContractExchangeRates = yield this.fetchAndMapExchangeRates(nativeCurrency, chainSlug, tokenAddresses);
+            const updateKey = `${chainId}:${nativeCurrency}`;
+            if (updateKey in __classPrivateFieldGet(this, _TokenRatesController_inProcessExchangeRateUpdates, "f")) {
+                // This prevents redundant updates
+                // This promise is resolved after the in-progress update has finished,
+                // and state has been updated.
+                yield __classPrivateFieldGet(this, _TokenRatesController_inProcessExchangeRateUpdates, "f")[updateKey];
+                return;
             }
-            const existingContractExchangeRatesForChainId = (_a = this.state.contractExchangeRatesByChainId[chainId]) !== null && _a !== void 0 ? _a : {};
-            this.update({
-                contractExchangeRatesByChainId: Object.assign(Object.assign({}, this.state.contractExchangeRatesByChainId), { [chainId]: Object.assign(Object.assign({}, existingContractExchangeRatesForChainId), { [nativeCurrency]: Object.assign(Object.assign({}, ((_b = existingContractExchangeRatesForChainId[nativeCurrency]) !== null && _b !== void 0 ? _b : {})), newContractExchangeRates) }) }),
-            });
-        });
-    }
-    /**
-     * Checks if the active network's native currency is supported by the coingecko API.
-     * If supported, it fetches and maps contractExchange rates to a format to be consumed by the UI.
-     * If not supported, it fetches contractExchange rates and maps them from token/fallback-currency
-     * to token/nativeCurrency.
-     *
-     * @param nativeCurrency - The native currency ticker against which to fetch exchange rates
-     * @param chainSlug - The unique slug used to id the chain by the coingecko api
-     * should be used to query token exchange rates.
-     * @param tokenAddresses - The addresses for the token contracts against which to fetch exchange rates.
-     * @returns An object with conversion rates for each token
-     * related to the network's native currency.
-     */
-    fetchAndMapExchangeRates(nativeCurrency, chainSlug, tokenAddresses = this.tokenList.map((token) => token.address)) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const contractExchangeRates = {};
-            // check if native currency is supported as a vs_currency by the API
-            const nativeCurrencySupported = yield this.checkIsSupportedVsCurrency(nativeCurrency);
-            if (nativeCurrencySupported) {
-                // If it is we can do a simple fetch against the CoinGecko API
-                const prices = yield this.fetchExchangeRate(chainSlug, nativeCurrency, tokenAddresses);
-                tokenAddresses.forEach((tokenAddress) => {
-                    const price = prices[tokenAddress.toLowerCase()];
-                    contractExchangeRates[(0, controller_utils_1.toChecksumHexAddress)(tokenAddress)] = price
-                        ? price[nativeCurrency.toLowerCase()]
-                        : 0;
+            const { promise: inProgressUpdate, resolve: updateSucceeded, reject: updateFailed, } = createDeferredPromise({ suppressUnhandledRejection: true });
+            __classPrivateFieldGet(this, _TokenRatesController_inProcessExchangeRateUpdates, "f")[updateKey] = inProgressUpdate;
+            try {
+                const newContractExchangeRates = yield __classPrivateFieldGet(this, _TokenRatesController_instances, "m", _TokenRatesController_fetchAndMapExchangeRates).call(this, {
+                    tokenAddresses,
+                    chainId,
+                    nativeCurrency,
                 });
+                const existingContractExchangeRates = this.state.contractExchangeRates;
+                const updatedContractExchangeRates = chainId === this.config.chainId &&
+                    nativeCurrency === this.config.nativeCurrency
+                    ? newContractExchangeRates
+                    : existingContractExchangeRates;
+                const existingContractExchangeRatesForChainId = (_a = this.state.contractExchangeRatesByChainId[chainId]) !== null && _a !== void 0 ? _a : {};
+                const updatedContractExchangeRatesForChainId = Object.assign(Object.assign({}, this.state.contractExchangeRatesByChainId), { [chainId]: Object.assign(Object.assign({}, existingContractExchangeRatesForChainId), { [nativeCurrency]: Object.assign(Object.assign({}, existingContractExchangeRatesForChainId[nativeCurrency]), newContractExchangeRates) }) });
+                this.update({
+                    contractExchangeRates: updatedContractExchangeRates,
+                    contractExchangeRatesByChainId: updatedContractExchangeRatesForChainId,
+                });
+                updateSucceeded();
             }
-            else {
-                // if native currency is not supported we need to use a fallback vsCurrency, get the exchange rates
-                // in token/fallback-currency format and convert them to expected token/nativeCurrency format.
-                let tokenExchangeRates;
-                let vsCurrencyToNativeCurrencyConversionRate = 0;
-                try {
-                    [
-                        tokenExchangeRates,
-                        { conversionRate: vsCurrencyToNativeCurrencyConversionRate },
-                    ] = yield Promise.all([
-                        this.fetchExchangeRate(chainSlug, controller_utils_1.FALL_BACK_VS_CURRENCY, tokenAddresses),
-                        (0, crypto_compare_1.fetchExchangeRate)(nativeCurrency, controller_utils_1.FALL_BACK_VS_CURRENCY, false),
-                    ]);
-                }
-                catch (error) {
-                    if (error instanceof Error &&
-                        error.message.includes('market does not exist for this coin pair')) {
-                        return {};
-                    }
-                    throw error;
-                }
-                for (const [tokenAddress, conversion] of Object.entries(tokenExchangeRates)) {
-                    const tokenToVsCurrencyConversionRate = conversion[controller_utils_1.FALL_BACK_VS_CURRENCY.toLowerCase()];
-                    contractExchangeRates[(0, controller_utils_1.toChecksumHexAddress)(tokenAddress)] =
-                        tokenToVsCurrencyConversionRate *
-                            vsCurrencyToNativeCurrencyConversionRate;
-                }
+            catch (error) {
+                updateFailed(error);
+                throw error;
+            }
+            finally {
+                delete __classPrivateFieldGet(this, _TokenRatesController_inProcessExchangeRateUpdates, "f")[updateKey];
             }
-            return contractExchangeRates;
         });
     }
     /**
-     * Updates token rates for the given networkClientId and contract addresses
+     * Updates token rates for the given networkClientId
      *
      * @param networkClientId - The network client ID used to get a ticker value.
-     * @param options - The polling options.
-     * @param options.tokenAddresses - The addresses for the token contracts.
      * @returns The controller state.
      */
-    _executePoll(networkClientId, options) {
+    _executePoll(networkClientId) {
         return __awaiter(this, void 0, void 0, function* () {
             const networkClient = this.getNetworkClientById(networkClientId);
             yield this.updateExchangeRatesByChainId({
                 chainId: networkClient.configuration.chainId,
                 nativeCurrency: networkClient.configuration.ticker,
-                tokenAddresses: options.tokenAddresses,
             });
         });
     }
 }
 exports.TokenRatesController = TokenRatesController;
-_TokenRatesController_pollState = new WeakMap(), _TokenRatesController_instances = new WeakSet(), _TokenRatesController_updateTokenList = function _TokenRatesController_updateTokenList() {
+_TokenRatesController_pollState = new WeakMap(), _TokenRatesController_tokenPricesService = new WeakMap(), _TokenRatesController_inProcessExchangeRateUpdates = new WeakMap(), _TokenRatesController_instances = new WeakSet(), _TokenRatesController_getTokenAddresses = function _TokenRatesController_getTokenAddresses(chainId) {
     var _a, _b;
     const { allTokens, allDetectedTokens } = this.config;
-    const tokens = ((_a = allTokens[this.config.chainId]) === null || _a === void 0 ? void 0 : _a[this.config.selectedAddress]) || [];
-    const detectedTokens = ((_b = allDetectedTokens[this.config.chainId]) === null || _b === void 0 ? void 0 : _b[this.config.selectedAddress]) ||
-        [];
-    this.tokenList = [...tokens, ...detectedTokens];
+    const tokens = ((_a = allTokens[chainId]) === null || _a === void 0 ? void 0 : _a[this.config.selectedAddress]) || [];
+    const detectedTokens = ((_b = allDetectedTokens[chainId]) === null || _b === void 0 ? void 0 : _b[this.config.selectedAddress]) || [];
+    return [
+        ...new Set([...tokens, ...detectedTokens].map((token) => (0, controller_utils_1.toHex)((0, controller_utils_1.toChecksumHexAddress)(token.address)))),
+    ].sort();
 }, _TokenRatesController_stopPoll = function _TokenRatesController_stopPoll() {
     if (this.handle) {
         clearTimeout(this.handle);
@@ -377,6 +268,92 @@ _TokenRatesController_pollState = new WeakMap(), _TokenRatesController_instances
             __classPrivateFieldGet(this, _TokenRatesController_instances, "m", _TokenRatesController_poll).call(this);
         }, this.config.interval);
     });
+}, _TokenRatesController_fetchAndMapExchangeRates = function _TokenRatesController_fetchAndMapExchangeRates({ tokenAddresses, chainId, nativeCurrency, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!__classPrivateFieldGet(this, _TokenRatesController_tokenPricesService, "f").validateChainIdSupported(chainId)) {
+            return tokenAddresses.reduce((obj, tokenAddress) => {
+                return Object.assign(Object.assign({}, obj), { [tokenAddress]: undefined });
+            }, {});
+        }
+        if (__classPrivateFieldGet(this, _TokenRatesController_tokenPricesService, "f").validateCurrencySupported(nativeCurrency)) {
+            return yield __classPrivateFieldGet(this, _TokenRatesController_instances, "m", _TokenRatesController_fetchAndMapExchangeRatesForSupportedNativeCurrency).call(this, {
+                tokenAddresses,
+                chainId,
+                nativeCurrency,
+            });
+        }
+        return yield __classPrivateFieldGet(this, _TokenRatesController_instances, "m", _TokenRatesController_fetchAndMapExchangeRatesForUnsupportedNativeCurrency).call(this, {
+            tokenAddresses,
+            nativeCurrency,
+        });
+    });
+}, _TokenRatesController_fetchAndMapExchangeRatesForSupportedNativeCurrency = function _TokenRatesController_fetchAndMapExchangeRatesForSupportedNativeCurrency({ tokenAddresses, chainId, nativeCurrency, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tokenPricesByTokenAddress = yield (0, assetsUtil_1.reduceInBatchesSerially)({
+            values: tokenAddresses,
+            batchSize: TOKEN_PRICES_BATCH_SIZE,
+            eachBatch: (allTokenPricesByTokenAddress, batch) => __awaiter(this, void 0, void 0, function* () {
+                const tokenPricesByTokenAddressForBatch = yield __classPrivateFieldGet(this, _TokenRatesController_tokenPricesService, "f").fetchTokenPrices({
+                    tokenAddresses: batch,
+                    chainId,
+                    currency: nativeCurrency,
+                });
+                return Object.assign(Object.assign({}, allTokenPricesByTokenAddress), tokenPricesByTokenAddressForBatch);
+            }),
+            initialResult: {},
+        });
+        return Object.entries(tokenPricesByTokenAddress).reduce((obj, [tokenAddress, tokenPrice]) => {
+            return Object.assign(Object.assign({}, obj), { [tokenAddress]: tokenPrice.value });
+        }, {});
+    });
+}, _TokenRatesController_fetchAndMapExchangeRatesForUnsupportedNativeCurrency = function _TokenRatesController_fetchAndMapExchangeRatesForUnsupportedNativeCurrency({ tokenAddresses, nativeCurrency, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [contractExchangeRates, fallbackCurrencyToNativeCurrencyConversionRate,] = yield Promise.all([
+            __classPrivateFieldGet(this, _TokenRatesController_instances, "m", _TokenRatesController_fetchAndMapExchangeRatesForSupportedNativeCurrency).call(this, {
+                tokenAddresses,
+                chainId: this.config.chainId,
+                nativeCurrency: controller_utils_1.FALL_BACK_VS_CURRENCY,
+            }),
+            getCurrencyConversionRate({
+                from: controller_utils_1.FALL_BACK_VS_CURRENCY,
+                to: nativeCurrency,
+            }),
+        ]);
+        if (fallbackCurrencyToNativeCurrencyConversionRate === null) {
+            return {};
+        }
+        return Object.entries(contractExchangeRates).reduce((obj, [tokenAddress, tokenValue]) => {
+            return Object.assign(Object.assign({}, obj), { [tokenAddress]: tokenValue
+                    ? tokenValue * fallbackCurrencyToNativeCurrencyConversionRate
+                    : undefined });
+        }, {});
+    });
 };
+/**
+ * Create a defered Promise.
+ *
+ * TODO: Migrate this to utils
+ *
+ * @param args - The arguments.
+ * @param args.suppressUnhandledRejection - This option adds an empty error handler
+ * to the Promise to suppress the UnhandledPromiseRejection error. This can be
+ * useful if the deferred Promise is sometimes intentionally not used.
+ * @returns A deferred Promise.
+ */
+function createDeferredPromise({ suppressUnhandledRejection = false, }) {
+    let resolve;
+    let reject;
+    const promise = new Promise((innerResolve, innerReject) => {
+        resolve = innerResolve;
+        reject = innerReject;
+    });
+    if (suppressUnhandledRejection) {
+        promise.catch((_error) => {
+            // This handler is used to suppress the UnhandledPromiseRejection error
+        });
+    }
+    // @ts-expect-error We know that these are assigned, but TypeScript doesn't
+    return { promise, resolve, reject };
+}
 exports.default = TokenRatesController;
 //# sourceMappingURL=TokenRatesController.js.map