@across-protocol/sdk 4.4.0-alpha.1 → 4.4.0-alpha.4

package/dist/esm/src/coingecko/Coingecko.js

@@ -1,4 +1,3 @@
-import { __awaiter, __generator } from "tslib";
 import axios from "axios";
 import assert from "assert";
 import get from "lodash.get";
@@ -7,8 +6,24 @@ export function msToS(ms) {
     return Math.floor(ms / 1000);
 }
 // Singleton Coingecko class.
-var Coingecko = /** @class */ (function () {
-    function Coingecko(host, proHost, logger, apiKey, customPlatformIdMap) {
+export class Coingecko {
+    static get(logger, apiKey, customPlatformIdMap) {
+        if (!this.instance)
+            this.instance = new Coingecko("https://api.coingecko.com/api/v3", "https://pro-api.coingecko.com/api/v3", logger, apiKey, customPlatformIdMap);
+        return this.instance;
+    }
+    get maxPriceAge() {
+        return this._maxPriceAge;
+    }
+    set maxPriceAge(age) {
+        assert(age >= 0);
+        this.logger.debug({
+            at: "Coingecko#maxPriceAge",
+            message: `Setting maxPriceAge (S) ${this._maxPriceAge} => ${age}.`,
+        });
+        this._maxPriceAge = age;
+    }
+    constructor(host, proHost, logger, apiKey, customPlatformIdMap) {
         this.host = host;
         this.proHost = proHost;
         this.logger = logger;
@@ -24,152 +39,84 @@ var Coingecko = /** @class */ (function () {
         this.prices = {};
         this.pricesBySymbol = {};
     }
-    Coingecko.get = function (logger, apiKey, customPlatformIdMap) {
-        if (!this.instance)
-            this.instance = new Coingecko("https://api.coingecko.com/api/v3", "https://pro-api.coingecko.com/api/v3", logger, apiKey, customPlatformIdMap);
-        return this.instance;
-    };
-    Object.defineProperty(Coingecko.prototype, "maxPriceAge", {
-        get: function () {
-            return this._maxPriceAge;
-        },
-        set: function (age) {
-            assert(age >= 0);
-            this.logger.debug({
-                at: "Coingecko#maxPriceAge",
-                message: "Setting maxPriceAge (S) ".concat(this._maxPriceAge, " => ").concat(age, "."),
+    async getPlatformId(chainId) {
+        let id = this.platformIdMap.get(chainId);
+        if (id) {
+            return id;
+        }
+        const platforms = await this.getPlatforms();
+        this.platformIdMap = new Map(platforms.filter((chain) => Boolean(chain.chain_identifier)).map((chain) => [chain.chain_identifier, chain.id]));
+        // Extend the platformIdMap with any custom platform ids
+        if (this.customPlatformIdMap) {
+            Object.entries(this.customPlatformIdMap).forEach(([chainId, platformId]) => {
+                this.platformIdMap.set(Number(chainId), platformId);
             });
-            this._maxPriceAge = age;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Coingecko.prototype.getPlatformId = function (chainId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var id, platforms;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        id = this.platformIdMap.get(chainId);
-                        if (id) {
-                            return [2 /*return*/, id];
-                        }
-                        return [4 /*yield*/, this.getPlatforms()];
-                    case 1:
-                        platforms = _a.sent();
-                        this.platformIdMap = new Map(platforms.filter(function (chain) { return Boolean(chain.chain_identifier); }).map(function (chain) { return [chain.chain_identifier, chain.id]; }));
-                        // Extend the platformIdMap with any custom platform ids
-                        if (this.customPlatformIdMap) {
-                            Object.entries(this.customPlatformIdMap).forEach(function (_a) {
-                                var chainId = _a[0], platformId = _a[1];
-                                _this.platformIdMap.set(Number(chainId), platformId);
-                            });
-                        }
-                        id = this.platformIdMap.get(chainId);
-                        if (!id) {
-                            this.logger.error({
-                                message: "Coingecko does not support chain with id ".concat(chainId),
-                                at: "Coingecko#getPlatformId",
-                            });
-                            throw new Error("Coingecko does not support chain with id ".concat(chainId));
-                        }
-                        return [2 /*return*/, id];
-                }
+        }
+        id = this.platformIdMap.get(chainId);
+        if (!id) {
+            this.logger.error({
+                message: `Coingecko does not support chain with id ${chainId}`,
+                at: "Coingecko#getPlatformId",
             });
-        });
-    };
+            throw new Error(`Coingecko does not support chain with id ${chainId}`);
+        }
+        return id;
+    }
     // for tokens not found in our constants, we can attempt to fetch the id from coingecko itself
-    Coingecko.prototype.getCoingeckoTokenId = function (address, chainId) {
-        return __awaiter(this, void 0, void 0, function () {
-            var id, platformId, message;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        try {
-                            id = getCoingeckoTokenIdByAddress(address, chainId);
-                            return [2 /*return*/, id];
-                        }
-                        catch (error) {
-                            this.logger.warn({
-                                at: "Coingecko#getCoingeckoTokenIdByAddress",
-                                message: "Token with address ".concat(address, " not found in constants. Attempting to fetch ID from coingecko API..."),
-                            });
-                        }
-                        return [4 /*yield*/, this.getPlatformId(chainId)];
-                    case 1:
-                        platformId = _a.sent();
-                        id = this.getTokenIdFromAddress(address, platformId);
-                        if (id) {
-                            return [2 /*return*/, id];
-                        }
-                        return [4 /*yield*/, this.updateTokenMap()];
-                    case 2:
-                        _a.sent();
-                        id = this.getTokenIdFromAddress(address, platformId);
-                        if (!id) {
-                            message = "Coin with address ".concat(address, " does not exist on chain with id ").concat(chainId);
-                            this.logger.error({
-                                at: "Coingecko#getCoingeckoTokenIdByAddress",
-                                message: message,
-                            });
-                            throw new Error(message);
-                        }
-                        return [2 /*return*/, id];
-                }
+    async getCoingeckoTokenId(address, chainId) {
+        let id;
+        try {
+            id = getCoingeckoTokenIdByAddress(address, chainId);
+            return id;
+        }
+        catch (error) {
+            this.logger.warn({
+                at: "Coingecko#getCoingeckoTokenIdByAddress",
+                message: `Token with address ${address} not found in constants. Attempting to fetch ID from coingecko API...`,
             });
-        });
-    };
-    Coingecko.prototype.getTokenIdFromAddress = function (address, platformId) {
-        var _a;
-        return (_a = Object.entries(this.tokenIdMap).find(function (_a) {
-            var _b;
-            var _ = _a[0], value = _a[1];
-            return Boolean(((_b = value === null || value === void 0 ? void 0 : value[platformId]) === null || _b === void 0 ? void 0 : _b.toLowerCase()) === address.toLowerCase());
-        })) === null || _a === void 0 ? void 0 : _a[0];
-    };
-    Coingecko.prototype.updateTokenMap = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var rawTokenList;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.call("coins/list?include_platform=true")];
-                    case 1:
-                        rawTokenList = _a.sent();
-                        this.tokenIdMap = Object.fromEntries(rawTokenList
-                            .filter(function (token) { var _a; return Boolean(((_a = Object.values(token === null || token === void 0 ? void 0 : token.platforms)) === null || _a === void 0 ? void 0 : _a.length) > 0); })
-                            .map(function (token) { return [token.id, token.platforms]; }));
-                        return [2 /*return*/, this.tokenIdMap];
-                }
+        }
+        const platformId = await this.getPlatformId(chainId);
+        id = this.getTokenIdFromAddress(address, platformId);
+        if (id) {
+            return id;
+        }
+        await this.updateTokenMap();
+        id = this.getTokenIdFromAddress(address, platformId);
+        if (!id) {
+            const message = `Coin with address ${address} does not exist on chain with id ${chainId}`;
+            this.logger.error({
+                at: "Coingecko#getCoingeckoTokenIdByAddress",
+                message,
             });
-        });
-    };
+            throw new Error(message);
+        }
+        return id;
+    }
+    getTokenIdFromAddress(address, platformId) {
+        return Object.entries(this.tokenIdMap).find(([_, value]) => Boolean(value?.[platformId]?.toLowerCase() === address.toLowerCase()))?.[0];
+    }
+    async updateTokenMap() {
+        const rawTokenList = await this.call("coins/list?include_platform=true");
+        this.tokenIdMap = Object.fromEntries(rawTokenList
+            .filter((token) => Boolean(Object.values(token?.platforms)?.length > 0))
+            .map((token) => [token.id, token.platforms]));
+        return this.tokenIdMap;
+    }
     // Fetch historic prices for a `contract` denominated in `currency` between timestamp `from` and `to`. Note timestamps
     // are assumed to be js timestamps and are converted to unixtimestamps by dividing by 1000.
-    Coingecko.prototype.getHistoricContractPrices = function (contract_1, from_1, to_1) {
-        return __awaiter(this, arguments, void 0, function (contract, from, to, currency) {
-            var _from, _to, result;
-            if (currency === void 0) { currency = "usd"; }
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        assert(contract, "requires contract address");
-                        assert(currency, "requires currency symbol");
-                        assert(from, "requires from timestamp");
-                        assert(to, "requires to timestamp");
-                        _from = msToS(from);
-                        _to = msToS(to);
-                        return [4 /*yield*/, this.call("coins/ethereum/contract/".concat(contract.toLowerCase(), "/market_chart/range/?vs_currency=").concat(currency, "&from=").concat(_from, "&to=").concat(_to))];
-                    case 1:
-                        result = _a.sent();
-                        // fyi timestamps are returned in ms in contrast to the current price endpoint
-                        if (result.prices)
-                            return [2 /*return*/, result.prices];
-                        throw new Error("Something went wrong fetching coingecko prices!");
-                }
-            });
-        });
-    };
+    async getHistoricContractPrices(contract, from, to, currency = "usd") {
+        assert(contract, "requires contract address");
+        assert(currency, "requires currency symbol");
+        assert(from, "requires from timestamp");
+        assert(to, "requires to timestamp");
+        const _from = msToS(from);
+        const _to = msToS(to);
+        const result = await this.call(`coins/ethereum/contract/${contract.toLowerCase()}/market_chart/range/?vs_currency=${currency}&from=${_from}&to=${_to}`);
+        // fyi timestamps are returned in ms in contrast to the current price endpoint
+        if (result.prices)
+            return result.prices;
+        throw new Error("Something went wrong fetching coingecko prices!");
+    }
     /**
      * Get the current price of a token denominated in `currency`.
      * @param contractAddress The L1 token address to fetch the price for.
@@ -178,253 +125,177 @@ var Coingecko = /** @class */ (function () {
      * @returns The price of the token at the given date.
      * @throws If today is selected and it is before 3am UTC or if the price is not found.
      */
-    Coingecko.prototype.getContractHistoricDayPrice = function (contractAddress_1, date_1) {
-        return __awaiter(this, arguments, void 0, function (contractAddress, date, currency, chainId) {
-            var coingeckoTokenIdentifier, url, queryParams, result, price;
-            var _a, _b;
-            if (currency === void 0) { currency = "usd"; }
-            if (chainId === void 0) { chainId = 1; }
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.getCoingeckoTokenId(contractAddress, chainId)];
-                    case 1:
-                        coingeckoTokenIdentifier = _c.sent();
-                        assert(date, "Requires date string");
-                        url = "coins/".concat(coingeckoTokenIdentifier, "/history");
-                        queryParams = {
-                            date: date,
-                            localization: "false",
-                        };
-                        return [4 /*yield*/, this.call("".concat(url, "?").concat(new URLSearchParams(queryParams).toString()))];
-                    case 2:
-                        result = _c.sent();
-                        price = (_b = (_a = result === null || result === void 0 ? void 0 : result.market_data) === null || _a === void 0 ? void 0 : _a.current_price) === null || _b === void 0 ? void 0 : _b[currency];
-                        assert(price, "No price found for ".concat(contractAddress, " on ").concat(date));
-                        return [2 /*return*/, price];
-                }
-            });
-        });
-    };
-    Coingecko.prototype.getContractDetails = function (contract_address, platform_id) {
-        if (platform_id === void 0) { platform_id = "ethereum"; }
-        return this.call("coins/".concat(platform_id, "/contract/").concat(contract_address.toLowerCase()));
-    };
-    Coingecko.prototype.getCurrentPriceByContract = function (contractAddress_1) {
-        return __awaiter(this, arguments, void 0, function (contractAddress, currency, chainId) {
-            var platform_id, priceCache, tokenPrice;
-            if (currency === void 0) { currency = "usd"; }
-            if (chainId === void 0) { chainId = 1; }
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getPlatformId(chainId)];
-                    case 1:
-                        platform_id = _a.sent();
-                        priceCache = this.getPriceCache(currency, platform_id);
-                        tokenPrice = this.getCachedAddressPrice(contractAddress, currency, platform_id);
-                        if (!(tokenPrice === undefined)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.getContractPrices([contractAddress], currency, platform_id)];
-                    case 2:
-                        _a.sent();
-                        tokenPrice = priceCache[contractAddress];
-                        _a.label = 3;
-                    case 3:
-                        assert(tokenPrice !== undefined);
-                        return [2 /*return*/, [tokenPrice.timestamp.toString(), tokenPrice.price]];
-                }
-            });
-        });
-    };
-    Coingecko.prototype.getCurrentPriceById = function (contractAddress_1) {
-        return __awaiter(this, arguments, void 0, function (contractAddress, currency, chainId) {
-            var platform_id, priceCache, tokenPrice, coingeckoId, result, cgPrice, errMsg;
-            if (currency === void 0) { currency = "usd"; }
-            if (chainId === void 0) { chainId = 1; }
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getPlatformId(chainId)];
-                    case 1:
-                        platform_id = _a.sent();
-                        priceCache = this.getPriceCache(currency, platform_id);
-                        tokenPrice = this.getCachedAddressPrice(contractAddress, currency, platform_id);
-                        if (!(tokenPrice === undefined)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this.getCoingeckoTokenId(contractAddress, chainId)];
-                    case 2:
-                        coingeckoId = _a.sent();
-                        return [4 /*yield*/, this.call("simple/price?ids=".concat(coingeckoId, "&vs_currencies=").concat(currency, "&include_last_updated_at=true"))];
-                    case 3:
-                        result = _a.sent();
-                        cgPrice = result === null || result === void 0 ? void 0 : result[coingeckoId];
-                        if (cgPrice === undefined || !(cgPrice === null || cgPrice === void 0 ? void 0 : cgPrice[currency])) {
-                            errMsg = "No price found for ".concat(coingeckoId);
-                            this.logger.debug({
-                                at: "Coingecko#getCurrentPriceById",
-                                message: errMsg,
-                            });
-                            throw new Error(errMsg);
-                        }
-                        else {
-                            this.updatePriceCache(cgPrice, contractAddress, currency, platform_id);
-                        }
-                        _a.label = 4;
-                    case 4:
-                        tokenPrice = priceCache[contractAddress];
-                        assert(tokenPrice !== undefined);
-                        return [2 /*return*/, [tokenPrice.timestamp.toString(), tokenPrice.price]];
-                }
-            });
-        });
-    };
-    Coingecko.prototype.getCurrentPriceBySymbol = function (symbol_1) {
-        return __awaiter(this, arguments, void 0, function (symbol, currency) {
-            var tokenPrice, result, cgPrice, errMsg;
-            if (currency === void 0) { currency = "usd"; }
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        tokenPrice = this.getCachedSymbolPrice(symbol, currency);
-                        if (!(tokenPrice === undefined)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.call("simple/price?symbols=".concat(symbol, "&vs_currencies=").concat(currency, "&include_last_updated_at=true"))];
-                    case 1:
-                        result = _a.sent();
-                        cgPrice = (result === null || result === void 0 ? void 0 : result[symbol.toLowerCase()]) || (result === null || result === void 0 ? void 0 : result[symbol.toUpperCase()]);
-                        if (cgPrice === undefined || !(cgPrice === null || cgPrice === void 0 ? void 0 : cgPrice[currency])) {
-                            errMsg = "Failed to retrieve ".concat(symbol, "/").concat(currency, " price via Coingecko API");
-                            this.logger.debug({
-                                at: "Coingecko#getCurrentPriceBySymbol",
-                                message: errMsg,
-                            });
-                            throw new Error(errMsg);
-                        }
-                        else {
-                            this.updatePriceCacheBySymbol(cgPrice, symbol, currency);
-                        }
-                        _a.label = 2;
-                    case 2:
-                        tokenPrice = this.getCachedSymbolPrice(symbol, currency);
-                        assert(tokenPrice !== undefined);
-                        return [2 /*return*/, [tokenPrice.timestamp.toString(), tokenPrice.price]];
-                }
-            });
-        });
-    };
+    async getContractHistoricDayPrice(contractAddress, date, currency = "usd", chainId = 1) {
+        const coingeckoTokenIdentifier = await this.getCoingeckoTokenId(contractAddress, chainId);
+        assert(date, "Requires date string");
+        // Build the path for the Coingecko API request
+        const url = `coins/${coingeckoTokenIdentifier}/history`;
+        // Build the query parameters for the Coingecko API request
+        const queryParams = {
+            date,
+            localization: "false",
+        };
+        // Grab the result - parse out price, market cap, total volume, and timestamp
+        const result = await this.call(`${url}?${new URLSearchParams(queryParams).toString()}`);
+        const price = result?.market_data?.current_price?.[currency];
+        assert(price, `No price found for ${contractAddress} on ${date}`);
+        return price;
+    }
+    getContractDetails(contract_address, platform_id = "ethereum") {
+        return this.call(`coins/${platform_id}/contract/${contract_address.toLowerCase()}`);
+    }
+    async getCurrentPriceByContract(contractAddress, currency = "usd", chainId = 1) {
+        const platform_id = await this.getPlatformId(chainId);
+        const priceCache = this.getPriceCache(currency, platform_id);
+        let tokenPrice = this.getCachedAddressPrice(contractAddress, currency, platform_id);
+        if (tokenPrice === undefined) {
+            await this.getContractPrices([contractAddress], currency, platform_id);
+            tokenPrice = priceCache[contractAddress];
+        }
+        assert(tokenPrice !== undefined);
+        return [tokenPrice.timestamp.toString(), tokenPrice.price];
+    }
+    async getCurrentPriceById(contractAddress, currency = "usd", chainId = 1) {
+        const platform_id = await this.getPlatformId(chainId);
+        const priceCache = this.getPriceCache(currency, platform_id);
+        let tokenPrice = this.getCachedAddressPrice(contractAddress, currency, platform_id);
+        if (tokenPrice === undefined) {
+            const coingeckoId = await this.getCoingeckoTokenId(contractAddress, chainId);
+            // Build the path for the Coingecko API request
+            const result = await this.call(`simple/price?ids=${coingeckoId}&vs_currencies=${currency}&include_last_updated_at=true`);
+            const cgPrice = result?.[coingeckoId];
+            if (cgPrice === undefined || !cgPrice?.[currency]) {
+                const errMsg = `No price found for ${coingeckoId}`;
+                this.logger.debug({
+                    at: "Coingecko#getCurrentPriceById",
+                    message: errMsg,
+                });
+                throw new Error(errMsg);
+            }
+            else {
+                this.updatePriceCache(cgPrice, contractAddress, currency, platform_id);
+            }
+        }
+        tokenPrice = priceCache[contractAddress];
+        assert(tokenPrice !== undefined);
+        return [tokenPrice.timestamp.toString(), tokenPrice.price];
+    }
+    async getCurrentPriceBySymbol(symbol, currency = "usd") {
+        let tokenPrice = this.getCachedSymbolPrice(symbol, currency);
+        if (tokenPrice === undefined) {
+            const result = await this.call(`simple/price?symbols=${symbol}&vs_currencies=${currency}&include_last_updated_at=true`);
+            const cgPrice = result?.[symbol.toLowerCase()] || result?.[symbol.toUpperCase()];
+            if (cgPrice === undefined || !cgPrice?.[currency]) {
+                const errMsg = `Failed to retrieve ${symbol}/${currency} price via Coingecko API`;
+                this.logger.debug({
+                    at: "Coingecko#getCurrentPriceBySymbol",
+                    message: errMsg,
+                });
+                throw new Error(errMsg);
+            }
+            else {
+                this.updatePriceCacheBySymbol(cgPrice, symbol, currency);
+            }
+        }
+        tokenPrice = this.getCachedSymbolPrice(symbol, currency);
+        assert(tokenPrice !== undefined);
+        return [tokenPrice.timestamp.toString(), tokenPrice.price];
+    }
     // Return an array of spot prices for an array of collateral addresses in one async call. Note we might in future
     // This was adapted from packages/merkle-distributor/kpi-options-helpers/calculate-uma-tvl.ts
-    Coingecko.prototype.getContractPrices = function (addresses_1) {
-        return __awaiter(this, arguments, void 0, function (addresses, currency, platform_id) {
-            var priceCache, contract_addresses, result, err_1, errMsg;
-            var _this = this;
-            if (currency === void 0) { currency = "usd"; }
-            if (platform_id === void 0) { platform_id = "ethereum"; }
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        priceCache = this.getPriceCache(currency, platform_id);
-                        // Pre-populate price cache with requested token addresses
-                        addresses.forEach(function (addr) {
-                            if (priceCache[addr] === undefined) {
-                                priceCache[addr] = { address: addr, price: 0, timestamp: 0 };
-                            }
-                        });
-                        contract_addresses = Object.keys(priceCache);
-                        assert(contract_addresses.length > 0, "Must supply at least 1 contract address");
-                        this.logger.debug({
-                            at: "Coingecko#getContractPrices",
-                            message: "Updating ".concat(platform_id, "/").concat(currency, " token prices."),
-                            tokens: contract_addresses,
-                        });
-                        result = {};
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.call("simple/token_price/".concat(platform_id, "?contract_addresses=").concat(contract_addresses.join("%2C"), "&vs_currencies=").concat(currency, "&include_last_updated_at=true"))];
-                    case 2:
-                        // Coingecko expects a comma-delimited (%2c) list.
-                        result = _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        err_1 = _a.sent();
-                        errMsg = "Failed to retrieve ".concat(platform_id, "/").concat(currency, " prices (").concat(err_1, ")");
-                        this.logger.debug({
-                            at: "Coingecko#getContractPrices",
-                            message: errMsg,
-                            tokens: contract_addresses,
-                        });
-                        throw new Error(errMsg);
-                    case 4:
-                        // Note: contract_addresses is a reliable reference for the price lookup.
-                        // priceCache might have been updated subsequently by concurrent price requests.
-                        contract_addresses.forEach(function (addr) {
-                            var cgPrice = result[addr.toLowerCase()];
-                            if (cgPrice === undefined) {
-                                _this.logger.debug({
-                                    at: "Coingecko#getContractPrices",
-                                    message: "Token ".concat(addr, " not included in CoinGecko response."),
-                                });
-                            }
-                            else {
-                                _this.updatePriceCache(cgPrice, addr, currency, platform_id);
-                            }
-                        });
-                        return [2 /*return*/, addresses.map(function (addr) { return priceCache[addr]; })];
-                }
+    async getContractPrices(addresses, currency = "usd", platform_id = "ethereum") {
+        const priceCache = this.getPriceCache(currency, platform_id);
+        // Pre-populate price cache with requested token addresses
+        addresses.forEach((addr) => {
+            if (priceCache[addr] === undefined) {
+                priceCache[addr] = { address: addr, price: 0, timestamp: 0 };
+            }
+        });
+        // Collect all known token addresses (requested + other cached).
+        const contract_addresses = Object.keys(priceCache);
+        assert(contract_addresses.length > 0, "Must supply at least 1 contract address");
+        this.logger.debug({
+            at: "Coingecko#getContractPrices",
+            message: `Updating ${platform_id}/${currency} token prices.`,
+            tokens: contract_addresses,
+        });
+        let result = {};
+        try {
+            // Coingecko expects a comma-delimited (%2c) list.
+            result = await this.call(`simple/token_price/${platform_id}?contract_addresses=${contract_addresses.join("%2C")}&vs_currencies=${currency}&include_last_updated_at=true`);
+        }
+        catch (err) {
+            const errMsg = `Failed to retrieve ${platform_id}/${currency} prices (${err})`;
+            this.logger.debug({
+                at: "Coingecko#getContractPrices",
+                message: errMsg,
+                tokens: contract_addresses,
             });
+            throw new Error(errMsg);
+        }
+        // Note: contract_addresses is a reliable reference for the price lookup.
+        // priceCache might have been updated subsequently by concurrent price requests.
+        contract_addresses.forEach((addr) => {
+            const cgPrice = result[addr.toLowerCase()];
+            if (cgPrice === undefined) {
+                this.logger.debug({
+                    at: "Coingecko#getContractPrices",
+                    message: `Token ${addr} not included in CoinGecko response.`,
+                });
+            }
+            else {
+                this.updatePriceCache(cgPrice, addr, currency, platform_id);
+            }
         });
-    };
-    Coingecko.prototype.getPlatforms = function () {
+        return addresses.map((addr) => priceCache[addr]);
+    }
+    getPlatforms() {
         return this.call("asset_platforms");
-    };
-    Coingecko.prototype.call = function (path) {
-        var _this = this;
-        var sendRequest = function () { return __awaiter(_this, void 0, void 0, function () {
-            var proHost, err_2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        proHost = this.proHost;
-                        if (!(this.apiKey === undefined)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this._callBasic(path)];
-                    case 1: return [2 /*return*/, (_a.sent())];
-                    case 2:
-                        _a.trys.push([2, 4, , 6]);
-                        return [4 /*yield*/, this._callBasic(path, this.basicApiTimeout)];
-                    case 3: return [2 /*return*/, (_a.sent())];
-                    case 4:
-                        err_2 = _a.sent();
-                        this.logger.debug({
-                            at: "sdk/coingecko",
-                            message: "Basic CG url request failed, falling back to CG PRO host ".concat(proHost),
-                            errMessage: err_2.message,
-                        });
-                        return [4 /*yield*/, this._callPro(path)];
-                    case 5: return [2 /*return*/, _a.sent()];
-                    case 6: return [2 /*return*/];
-                }
-            });
-        }); };
+    }
+    call(path) {
+        const sendRequest = async () => {
+            const { proHost } = this;
+            // If no pro api key, only send basic request:
+            if (this.apiKey === undefined) {
+                return (await this._callBasic(path));
+            }
+            // If pro api key, try basic and use pro as fallback.
+            try {
+                return (await this._callBasic(path, this.basicApiTimeout));
+            }
+            catch (err) {
+                this.logger.debug({
+                    at: "sdk/coingecko",
+                    message: `Basic CG url request failed, falling back to CG PRO host ${proHost}`,
+                    errMessage: err.message,
+                });
+                return await this._callPro(path);
+            }
+        };
         // Note: If a pro API key is configured, there is no need to retry as the Pro API will act as the basic's fall back.
         return retry(sendRequest, this.apiKey === undefined ? this.numRetries : 0, this.retryDelay);
-    };
-    Coingecko.prototype.getPriceCache = function (currency, platform_id) {
+    }
+    getPriceCache(currency, platform_id) {
         if (this.prices[platform_id] === undefined)
             this.prices[platform_id] = {};
         if (this.prices[platform_id][currency] === undefined)
             this.prices[platform_id][currency] = {};
         return this.prices[platform_id][currency];
-    };
-    Coingecko.prototype.getPriceCacheBySymbol = function (symbol) {
+    }
+    getPriceCacheBySymbol(symbol) {
         if (this.pricesBySymbol[symbol] === undefined)
             this.pricesBySymbol[symbol] = {};
         return this.pricesBySymbol[symbol];
-    };
-    Coingecko.prototype.getCachedAddressPrice = function (contractAddress, currency, platform_id) {
-        var priceCache = this.getPriceCache(currency, platform_id);
-        var now = msToS(Date.now());
-        var tokenPrice = priceCache[contractAddress];
+    }
+    getCachedAddressPrice(contractAddress, currency, platform_id) {
+        const priceCache = this.getPriceCache(currency, platform_id);
+        const now = msToS(Date.now());
+        const tokenPrice = priceCache[contractAddress];
         if (tokenPrice === undefined || tokenPrice.timestamp + this.maxPriceAge <= now) {
             if (this.maxPriceAge > 0) {
                 this.logger.debug({
                     at: "Coingecko#getCachedAddressPrice",
-                    message: "Cache miss on ".concat(platform_id, "/").concat(currency, " for ").concat(contractAddress),
+                    message: `Cache miss on ${platform_id}/${currency} for ${contractAddress}`,
                     maxPriceAge: this.maxPriceAge,
                     tokenPrice: tokenPrice,
                 });
@@ -434,23 +305,23 @@ var Coingecko = /** @class */ (function () {
         else {
             this.logger.debug({
                 at: "Coingecko#getCachedAddressPrice",
-                message: "Cache hit on token ".concat(contractAddress, " (age ").concat(now - tokenPrice.timestamp, " S)."),
+                message: `Cache hit on token ${contractAddress} (age ${now - tokenPrice.timestamp} S).`,
                 price: tokenPrice,
             });
             return tokenPrice;
         }
-    };
-    Coingecko.prototype.getCachedSymbolPrice = function (symbol, currency) {
-        var priceCache = this.getPriceCacheBySymbol(symbol);
-        var now = msToS(Date.now());
-        var tokenPrice = priceCache[currency];
+    }
+    getCachedSymbolPrice(symbol, currency) {
+        const priceCache = this.getPriceCacheBySymbol(symbol);
+        const now = msToS(Date.now());
+        const tokenPrice = priceCache[currency];
         if (tokenPrice === undefined || tokenPrice.timestamp + this.maxPriceAge <= now) {
             return undefined;
         }
         return tokenPrice;
-    };
-    Coingecko.prototype.updatePriceCache = function (cgPrice, contractAddress, currency, platform_id) {
-        var priceCache = this.getPriceCache(currency, platform_id);
+    }
+    updatePriceCache(cgPrice, contractAddress, currency, platform_id) {
+        const priceCache = this.getPriceCache(currency, platform_id);
         if (priceCache[contractAddress] === undefined) {
             priceCache[contractAddress] = { address: contractAddress, price: 0, timestamp: 0 };
         }
@@ -462,19 +333,19 @@ var Coingecko = /** @class */ (function () {
             };
             this.logger.debug({
                 at: "Coingecko#updatePriceCache",
-                message: "Updated ".concat(platform_id, "/").concat(currency, "/").concat(contractAddress, " token price cache."),
+                message: `Updated ${platform_id}/${currency}/${contractAddress} token price cache.`,
             });
         }
         else {
             this.logger.debug({
                 at: "Coingecko#updatePriceCache",
-                message: "No new price available for token ".concat(contractAddress, "."),
+                message: `No new price available for token ${contractAddress}.`,
                 token: cgPrice,
             });
         }
-    };
-    Coingecko.prototype.updatePriceCacheBySymbol = function (cgPrice, symbol, currency) {
-        var priceCache = this.getPriceCacheBySymbol(symbol);
+    }
+    updatePriceCacheBySymbol(cgPrice, symbol, currency) {
+        const priceCache = this.getPriceCacheBySymbol(symbol);
         if (priceCache[currency] === undefined) {
             priceCache[currency] = { price: 0, timestamp: 0 };
         }
@@ -485,64 +356,40 @@ var Coingecko = /** @class */ (function () {
             };
             this.logger.debug({
                 at: "Coingecko#updatePriceCacheBySymbol",
-                message: "Updated ".concat(symbol, "/").concat(currency, " token price cache."),
+                message: `Updated ${symbol}/${currency} token price cache.`,
             });
         }
         else {
             this.logger.debug({
                 at: "Coingecko#updatePriceCacheBySymbol",
-                message: "No new price available for symbol ".concat(symbol, "."),
+                message: `No new price available for symbol ${symbol}.`,
                 token: cgPrice,
             });
         }
-    };
-    Coingecko.prototype._callBasic = function (path, timeout) {
-        return __awaiter(this, void 0, void 0, function () {
-            var url, result, err_3, msg;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        url = "".concat(this.host, "/").concat(path);
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, axios(url, { timeout: timeout })];
-                    case 2:
-                        result = _a.sent();
-                        return [2 /*return*/, result.data];
-                    case 3:
-                        err_3 = _a.sent();
-                        msg = get(err_3, "response.data.error", get(err_3, "response.statusText", err_3.message));
-                        throw new Error(msg);
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    Coingecko.prototype._callPro = function (path) {
-        return __awaiter(this, void 0, void 0, function () {
-            var url, result, err_4, msg;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        url = "".concat(this.proHost, "/").concat(path);
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, axios(url, { params: { x_cg_pro_api_key: this.apiKey } })];
-                    case 2:
-                        result = _a.sent();
-                        return [2 /*return*/, result.data];
-                    case 3:
-                        err_4 = _a.sent();
-                        msg = get(err_4, "response.data.error", get(err_4, "response.statusText", err_4.message));
-                        throw new Error(msg);
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return Coingecko;
-}());
-export { Coingecko };
+    }
+    async _callBasic(path, timeout) {
+        const url = `${this.host}/${path}`;
+        try {
+            // Don't use timeout if there is no pro API to fallback to.
+            const result = await axios(url, { timeout });
+            return result.data;
+        }
+        catch (err) {
+            const msg = get(err, "response.data.error", get(err, "response.statusText", err.message));
+            throw new Error(msg);
+        }
+    }
+    async _callPro(path) {
+        const url = `${this.proHost}/${path}`;
+        try {
+            // Don't use timeout if there is no pro API to fallback to.
+            const result = await axios(url, { params: { x_cg_pro_api_key: this.apiKey } });
+            return result.data;
+        }
+        catch (err) {
+            const msg = get(err, "response.data.error", get(err, "response.statusText", err.message));
+            throw new Error(msg);
+        }
+    }
+}
 //# sourceMappingURL=Coingecko.js.map