@d8x/perpetuals-sdk 0.7.5 → 0.7.6

package/dist/esm/priceFeeds.js

@@ -1,4 +1,3 @@
-import { __awaiter, __generator, __read, __values } from "tslib";
 import { BigNumber } from "@ethersproject/bignumber";
 import Triangulator from "./triangulator";
 import { decNToFloat } from "./d8XMath";
@@ -8,13 +7,12 @@ import { Buffer } from "buffer";
  * to be submitted to the smart contracts for certain functions such as
  * trader liquidations, trade executions, change of trader margin amount.
  */
-var PriceFeeds = /** @class */ (function () {
-    function PriceFeeds(dataHandler, priceFeedConfigNetwork) {
-        var _a;
+export default class PriceFeeds {
+    constructor(dataHandler, priceFeedConfigNetwork) {
         this.THRESHOLD_MARKET_CLOSED_SEC = 15; // smallest lag for which we consider the market as being closed
-        var configs = require("./config/priceFeedConfig.json");
+        let configs = require("./config/priceFeedConfig.json");
         this.config = PriceFeeds._selectConfig(configs, priceFeedConfigNetwork);
-        _a = __read(PriceFeeds._constructFeedInfo(this.config), 2), this.feedInfo = _a[0], this.feedEndpoints = _a[1];
+        [this.feedInfo, this.feedEndpoints] = PriceFeeds._constructFeedInfo(this.config);
         this.dataHandler = dataHandler;
         this.triangulations = new Map();
     }
@@ -22,140 +20,84 @@ var PriceFeeds = /** @class */ (function () {
      * Pre-processing of triangulations for symbols, given the price feeds
      * @param symbols set of symbols we want to triangulate from price feeds
      */
-    PriceFeeds.prototype.initializeTriangulations = function (symbols) {
-        var e_1, _a, e_2, _b;
-        var feedSymbols = new Array();
-        try {
-            for (var _c = __values(this.feedInfo), _d = _c.next(); !_d.done; _d = _c.next()) {
-                var _e = __read(_d.value, 2), value = _e[1];
-                feedSymbols.push(value.symbol);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
-            }
-            finally { if (e_1) throw e_1.error; }
+    initializeTriangulations(symbols) {
+        let feedSymbols = new Array();
+        for (let [, value] of this.feedInfo) {
+            feedSymbols.push(value.symbol);
         }
-        try {
-            for (var _f = __values(symbols.values()), _g = _f.next(); !_g.done; _g = _f.next()) {
-                var symbol = _g.value;
-                var triangulation = Triangulator.triangulate(feedSymbols, symbol);
-                this.triangulations.set(symbol, triangulation);
-            }
+        for (let symbol of symbols.values()) {
+            let triangulation = Triangulator.triangulate(feedSymbols, symbol);
+            this.triangulations.set(symbol, triangulation);
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-    };
+    }
     /**
      * Get required information to be able to submit a blockchain transaction with price-update
      * such as trade execution, liquidation
      * @param symbol symbol of perpetual, e.g., BTC-USD-MATIC
      * @returns PriceFeedSubmission, index prices, market closed information
      */
-    PriceFeeds.prototype.fetchFeedPriceInfoAndIndicesForPerpetual = function (symbol) {
-        return __awaiter(this, void 0, void 0, function () {
-            var indexSymbols, submission, _a, _idxPrices, _mktClosed, idxPrices, mktClosed;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        indexSymbols = this.dataHandler.getIndexSymbols(symbol);
-                        return [4 /*yield*/, this.fetchLatestFeedPriceInfoForPerpetual(symbol)];
-                    case 1:
-                        submission = _b.sent();
-                        _a = __read(this.calculateTriangulatedPricesFromFeedInfo(indexSymbols.filter(function (x) { return x != ""; }), submission), 2), _idxPrices = _a[0], _mktClosed = _a[1];
-                        idxPrices = [_idxPrices[0], 0];
-                        mktClosed = [_mktClosed[0], false];
-                        if (idxPrices.length > 1) {
-                            idxPrices[1] = _idxPrices[1];
-                            mktClosed[1] = _mktClosed[1];
-                        }
-                        return [2 /*return*/, { submission: submission, pxS2S3: idxPrices, mktClosed: mktClosed }];
-                }
-            });
-        });
-    };
+    async fetchFeedPriceInfoAndIndicesForPerpetual(symbol) {
+        let indexSymbols = this.dataHandler.getIndexSymbols(symbol);
+        // fetch prices from required price-feeds (REST)
+        let submission = await this.fetchLatestFeedPriceInfoForPerpetual(symbol);
+        // calculate index-prices from price-feeds
+        let [_idxPrices, _mktClosed] = this.calculateTriangulatedPricesFromFeedInfo(indexSymbols.filter((x) => x != ""), submission);
+        let idxPrices = [_idxPrices[0], 0];
+        let mktClosed = [_mktClosed[0], false];
+        if (idxPrices.length > 1) {
+            idxPrices[1] = _idxPrices[1];
+            mktClosed[1] = _mktClosed[1];
+        }
+        return { submission: submission, pxS2S3: idxPrices, mktClosed: mktClosed };
+    }
     /**
      * Get all prices/isMarketClosed for the provided symbols via
      * "latest_price_feeds" and triangulation. Triangulation must be defined in config, unless
      * it is a direct price feed.
      * @returns map of feed-price symbol to price/isMarketClosed
      */
-    PriceFeeds.prototype.fetchPrices = function (symbols) {
-        return __awaiter(this, void 0, void 0, function () {
-            var feedPrices, _a, prices, mktClosed, symMap, k;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0: return [4 /*yield*/, this.fetchAllFeedPrices()];
-                    case 1:
-                        feedPrices = _b.sent();
-                        _a = __read(this.triangulatePricesFromFeedPrices(symbols, feedPrices), 2), prices = _a[0], mktClosed = _a[1];
-                        symMap = new Map();
-                        for (k = 0; k < symbols.length; k++) {
-                            symMap.set(symbols[k], [prices[k], mktClosed[k]]);
-                        }
-                        return [2 /*return*/, symMap];
-                }
-            });
-        });
-    };
+    async fetchPrices(symbols) {
+        let feedPrices = await this.fetchAllFeedPrices();
+        let [prices, mktClosed] = this.triangulatePricesFromFeedPrices(symbols, feedPrices);
+        let symMap = new Map();
+        for (let k = 0; k < symbols.length; k++) {
+            symMap.set(symbols[k], [prices[k], mktClosed[k]]);
+        }
+        return symMap;
+    }
     /**
      * Get index prices and market closed information for the given perpetual
      * @param symbol perpetual symbol such as ETH-USD-MATIC
      * @returns Index prices and market closed information
      */
-    PriceFeeds.prototype.fetchPricesForPerpetual = function (symbol) {
-        return __awaiter(this, void 0, void 0, function () {
-            var indexSymbols, feedSymbols, indexSymbols_1, indexSymbols_1_1, sym, triang, feedPrices, _a, prices, mktClosed;
-            var e_3, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        indexSymbols = this.dataHandler.getIndexSymbols(symbol).filter(function (x) { return x != ""; });
-                        feedSymbols = new Array();
-                        try {
-                            for (indexSymbols_1 = __values(indexSymbols), indexSymbols_1_1 = indexSymbols_1.next(); !indexSymbols_1_1.done; indexSymbols_1_1 = indexSymbols_1.next()) {
-                                sym = indexSymbols_1_1.value;
-                                if (sym != "") {
-                                    triang = this.triangulations.get(sym);
-                                    if (triang == undefined) {
-                                        // no triangulation defined, so symbol must be a feed (unless misconfigured)
-                                        feedSymbols.push(sym);
-                                    }
-                                    else {
-                                        // push all required feeds to array
-                                        triang[0].map(function (feedSym) { return feedSymbols.push(feedSym); });
-                                    }
-                                }
-                            }
-                        }
-                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                        finally {
-                            try {
-                                if (indexSymbols_1_1 && !indexSymbols_1_1.done && (_b = indexSymbols_1.return)) _b.call(indexSymbols_1);
-                            }
-                            finally { if (e_3) throw e_3.error; }
-                        }
-                        return [4 /*yield*/, this.fetchFeedPrices(feedSymbols)];
-                    case 1:
-                        feedPrices = _c.sent();
-                        _a = __read(this.triangulatePricesFromFeedPrices(indexSymbols, feedPrices), 2), prices = _a[0], mktClosed = _a[1];
-                        // ensure we return an array of 2 in all cases
-                        if (prices.length == 1) {
-                            prices.push(0);
-                            mktClosed.push(false);
-                        }
-                        return [2 /*return*/, { idxPrices: prices, mktClosed: mktClosed }];
+    async fetchPricesForPerpetual(symbol) {
+        let indexSymbols = this.dataHandler.getIndexSymbols(symbol).filter((x) => x != "");
+        // determine relevant price feeds
+        let feedSymbols = new Array();
+        for (let sym of indexSymbols) {
+            if (sym != "") {
+                let triang = this.triangulations.get(sym);
+                if (triang == undefined) {
+                    // no triangulation defined, so symbol must be a feed (unless misconfigured)
+                    feedSymbols.push(sym);
                 }
-            });
-        });
-    };
+                else {
+                    // push all required feeds to array
+                    triang[0].map((feedSym) => feedSymbols.push(feedSym));
+                }
+            }
+        }
+        // get all feed prices
+        let feedPrices = await this.fetchFeedPrices(feedSymbols);
+        // triangulate
+        let [prices, mktClosed] = this.triangulatePricesFromFeedPrices(indexSymbols, feedPrices);
+        // ensure we return an array of 2 in all cases
+        if (prices.length == 1) {
+            prices.push(0);
+            mktClosed.push(false);
+        }
+        return { idxPrices: prices, mktClosed: mktClosed };
+    }
     /**
      * Fetch the provided feed prices and bool whether market is closed or open
      * - requires the feeds to be defined in priceFeedConfig.json
@@ -163,68 +105,49 @@ var PriceFeeds = /** @class */ (function () {
      * @param symbols array of feed-price symbols (e.g., [btc-usd, eth-usd]) or undefined
      * @returns mapping symbol-> [price, isMarketClosed]
      */
-    PriceFeeds.prototype.fetchFeedPrices = function (symbols) {
-        return __awaiter(this, void 0, void 0, function () {
-            var queries, symbolsOfEndpoint, j, k, currFeed, endpointId, resultPrices, k, _a, pxInfo, tsSecNow, j, price, isMarketClosed;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        queries = new Array(this.feedEndpoints.length);
-                        symbolsOfEndpoint = [];
-                        for (j = 0; j < queries.length; j++) {
-                            symbolsOfEndpoint.push([]);
-                        }
-                        for (k = 0; k < this.config.ids.length; k++) {
-                            currFeed = this.config.ids[k];
-                            if (symbols != undefined && !symbols.includes(currFeed.symbol)) {
-                                continue;
-                            }
-                            endpointId = this.feedInfo.get(currFeed.id).endpointId;
-                            symbolsOfEndpoint[endpointId].push(currFeed.symbol);
-                            if (queries[endpointId] == undefined) {
-                                // each id can have a different endpoint, but we cluster
-                                // the queries into one per endpoint
-                                queries[endpointId] = this.feedEndpoints[endpointId] + "/latest_price_feeds?";
-                            }
-                            queries[endpointId] = queries[endpointId] + "ids[]=" + currFeed.id + "&";
-                        }
-                        resultPrices = new Map();
-                        k = 0;
-                        _b.label = 1;
-                    case 1:
-                        if (!(k < queries.length)) return [3 /*break*/, 4];
-                        if (queries[k] == undefined) {
-                            return [3 /*break*/, 3];
-                        }
-                        return [4 /*yield*/, this.fetchPriceQuery(queries[k])];
-                    case 2:
-                        _a = __read.apply(void 0, [_b.sent(), 2]), pxInfo = _a[1];
-                        tsSecNow = Math.round(Date.now() / 1000);
-                        for (j = 0; j < pxInfo.length; j++) {
-                            price = decNToFloat(BigNumber.from(pxInfo[j].price), -pxInfo[j].expo);
-                            isMarketClosed = tsSecNow - pxInfo[j].publish_time > this.THRESHOLD_MARKET_CLOSED_SEC;
-                            resultPrices.set(symbolsOfEndpoint[k][j], [price, isMarketClosed]);
-                        }
-                        _b.label = 3;
-                    case 3:
-                        k++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, resultPrices];
-                }
-            });
-        });
-    };
+    async fetchFeedPrices(symbols) {
+        let queries = new Array(this.feedEndpoints.length);
+        let symbolsOfEndpoint = [];
+        for (let j = 0; j < queries.length; j++) {
+            symbolsOfEndpoint.push([]);
+        }
+        for (let k = 0; k < this.config.ids.length; k++) {
+            let currFeed = this.config.ids[k];
+            if (symbols != undefined && !symbols.includes(currFeed.symbol)) {
+                continue;
+            }
+            // feedInfo: Map<string, {symbol:string, endpointId: number}>; // priceFeedId -> symbol, endpointId
+            let endpointId = this.feedInfo.get(currFeed.id).endpointId;
+            symbolsOfEndpoint[endpointId].push(currFeed.symbol);
+            if (queries[endpointId] == undefined) {
+                // each id can have a different endpoint, but we cluster
+                // the queries into one per endpoint
+                queries[endpointId] = this.feedEndpoints[endpointId] + "/latest_price_feeds?";
+            }
+            queries[endpointId] = queries[endpointId] + "ids[]=" + currFeed.id + "&";
+        }
+        let resultPrices = new Map();
+        for (let k = 0; k < queries.length; k++) {
+            if (queries[k] == undefined) {
+                continue;
+            }
+            let [, pxInfo] = await this.fetchPriceQuery(queries[k]);
+            let tsSecNow = Math.round(Date.now() / 1000);
+            for (let j = 0; j < pxInfo.length; j++) {
+                let price = decNToFloat(BigNumber.from(pxInfo[j].price), -pxInfo[j].expo);
+                let isMarketClosed = tsSecNow - pxInfo[j].publish_time > this.THRESHOLD_MARKET_CLOSED_SEC;
+                resultPrices.set(symbolsOfEndpoint[k][j], [price, isMarketClosed]);
+            }
+        }
+        return resultPrices;
+    }
     /**
      * Get all configured feed prices via "latest_price_feeds"
      * @returns map of feed-price symbol to price/isMarketClosed
      */
-    PriceFeeds.prototype.fetchAllFeedPrices = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, this.fetchFeedPrices()];
-            });
-        });
-    };
+    async fetchAllFeedPrices() {
+        return this.fetchFeedPrices();
+    }
     /**
      * Get the latest prices for a given perpetual from the offchain oracle
      * networks
@@ -232,75 +155,64 @@ var PriceFeeds = /** @class */ (function () {
      * @returns array of price feed updates that can be submitted to the smart contract
      * and corresponding price information
      */
-    PriceFeeds.prototype.fetchLatestFeedPriceInfoForPerpetual = function (symbol) {
-        return __awaiter(this, void 0, void 0, function () {
-            var feedIds, queries, orderEndpointNumber, idCountPriceFeeds, symbols, k, info, id, data, priceFeedUpdates, prices, mktClosed, timestamps, tsSecNow, k, endpointId, idWithinEndpoint, pxInfo, price, isMarketClosed;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        feedIds = this.dataHandler.getPriceIds(symbol);
-                        queries = new Array(this.feedEndpoints.length);
-                        orderEndpointNumber = new Array();
-                        idCountPriceFeeds = new Array(this.feedEndpoints.length);
-                        symbols = new Array();
-                        for (k = 0; k < feedIds.length; k++) {
-                            info = this.feedInfo.get(feedIds[k]);
-                            if (info == undefined) {
-                                throw new Error("priceFeeds: config for symbol ".concat(symbol, " insufficient"));
-                            }
-                            id = info.endpointId;
-                            symbols.push(info.symbol);
-                            if (queries[id] == undefined) {
-                                // each id can have a different endpoint, but we cluster
-                                // the queries into one per endpoint
-                                queries[id] = this.feedEndpoints[id] + "/latest_price_feeds?target_chain=default&";
-                                idCountPriceFeeds[id] = 0;
-                            }
-                            queries[id] = queries[id] + "ids[]=" + feedIds[k] + "&";
-                            orderEndpointNumber.push(id * 100 + idCountPriceFeeds[id]);
-                            idCountPriceFeeds[id] = idCountPriceFeeds[id] + 1;
-                        }
-                        return [4 /*yield*/, Promise.all(queries.map(function (q) { return __awaiter(_this, void 0, void 0, function () {
-                                return __generator(this, function (_a) {
-                                    if (q != undefined) {
-                                        return [2 /*return*/, this.fetchVAAQuery(q)];
-                                    }
-                                    else {
-                                        return [2 /*return*/, [[], []]];
-                                    }
-                                    return [2 /*return*/];
-                                });
-                            }); }))];
-                    case 1:
-                        data = _a.sent();
-                        priceFeedUpdates = new Array();
-                        prices = new Array();
-                        mktClosed = new Array();
-                        timestamps = new Array();
-                        tsSecNow = Math.round(Date.now() / 1000);
-                        for (k = 0; k < orderEndpointNumber.length; k++) {
-                            endpointId = Math.floor(orderEndpointNumber[k] / 100);
-                            idWithinEndpoint = orderEndpointNumber[k] - 100 * endpointId;
-                            priceFeedUpdates.push(data[endpointId][0][idWithinEndpoint]);
-                            pxInfo = data[endpointId][1][idWithinEndpoint];
-                            price = decNToFloat(BigNumber.from(pxInfo.price), -pxInfo.expo);
-                            isMarketClosed = tsSecNow - pxInfo.publish_time > this.THRESHOLD_MARKET_CLOSED_SEC;
-                            mktClosed.push(isMarketClosed);
-                            prices.push(price);
-                            timestamps.push(pxInfo.publish_time);
-                        }
-                        return [2 /*return*/, {
-                                symbols: symbols,
-                                priceFeedVaas: priceFeedUpdates,
-                                prices: prices,
-                                isMarketClosed: mktClosed,
-                                timestamps: timestamps,
-                            }];
-                }
-            });
-        });
-    };
+    async fetchLatestFeedPriceInfoForPerpetual(symbol) {
+        let feedIds = this.dataHandler.getPriceIds(symbol);
+        let queries = new Array(this.feedEndpoints.length);
+        // we need to preserve the order of the price feeds
+        let orderEndpointNumber = new Array();
+        // count how many prices per endpoint
+        let idCountPriceFeeds = new Array(this.feedEndpoints.length);
+        let symbols = new Array();
+        for (let k = 0; k < feedIds.length; k++) {
+            let info = this.feedInfo.get(feedIds[k]);
+            if (info == undefined) {
+                throw new Error(`priceFeeds: config for symbol ${symbol} insufficient`);
+            }
+            let id = info.endpointId;
+            symbols.push(info.symbol);
+            if (queries[id] == undefined) {
+                // each id can have a different endpoint, but we cluster
+                // the queries into one per endpoint
+                queries[id] = this.feedEndpoints[id] + "/latest_price_feeds?target_chain=default&";
+                idCountPriceFeeds[id] = 0;
+            }
+            queries[id] = queries[id] + "ids[]=" + feedIds[k] + "&";
+            orderEndpointNumber.push(id * 100 + idCountPriceFeeds[id]);
+            idCountPriceFeeds[id] = idCountPriceFeeds[id] + 1;
+        }
+        let data = await Promise.all(queries.map(async (q) => {
+            if (q != undefined) {
+                return this.fetchVAAQuery(q);
+            }
+            else {
+                return [[], []];
+            }
+        }));
+        // re-order arrays so we preserve the order of the feeds
+        const priceFeedUpdates = new Array();
+        const prices = new Array();
+        const mktClosed = new Array();
+        const timestamps = new Array();
+        const tsSecNow = Math.round(Date.now() / 1000);
+        for (let k = 0; k < orderEndpointNumber.length; k++) {
+            let endpointId = Math.floor(orderEndpointNumber[k] / 100);
+            let idWithinEndpoint = orderEndpointNumber[k] - 100 * endpointId;
+            priceFeedUpdates.push(data[endpointId][0][idWithinEndpoint]);
+            let pxInfo = data[endpointId][1][idWithinEndpoint];
+            let price = decNToFloat(BigNumber.from(pxInfo.price), -pxInfo.expo);
+            let isMarketClosed = tsSecNow - pxInfo.publish_time > this.THRESHOLD_MARKET_CLOSED_SEC;
+            mktClosed.push(isMarketClosed);
+            prices.push(price);
+            timestamps.push(pxInfo.publish_time);
+        }
+        return {
+            symbols: symbols,
+            priceFeedVaas: priceFeedUpdates,
+            prices: prices,
+            isMarketClosed: mktClosed,
+            timestamps: timestamps,
+        };
+    }
     /**
      * Extract pair-prices from underlying price feeds via triangulation
      * The function either needs a direct price feed or a defined triangulation to succesfully
@@ -309,13 +221,13 @@ var PriceFeeds = /** @class */ (function () {
      * @param feeds data obtained via fetchLatestFeedPriceInfo or fetchLatestFeedPrices
      * @returns array of prices with same order as symbols
      */
-    PriceFeeds.prototype.calculateTriangulatedPricesFromFeedInfo = function (symbols, feeds) {
-        var priceMap = new Map();
-        for (var j = 0; j < feeds.prices.length; j++) {
+    calculateTriangulatedPricesFromFeedInfo(symbols, feeds) {
+        let priceMap = new Map();
+        for (let j = 0; j < feeds.prices.length; j++) {
             priceMap.set(feeds.symbols[j], [feeds.prices[j], feeds.isMarketClosed[j]]);
         }
         return this.triangulatePricesFromFeedPrices(symbols, priceMap);
-    };
+    }
     /**
      * Extract pair-prices from underlying price feeds via triangulation
      * The function either needs a direct price feed or a defined triangulation to succesfully
@@ -324,15 +236,15 @@ var PriceFeeds = /** @class */ (function () {
      * @param feeds data obtained via fetchLatestFeedPriceInfo or fetchLatestFeedPrices
      * @returns array of prices with same order as symbols
      */
-    PriceFeeds.prototype.triangulatePricesFromFeedPrices = function (symbols, feedPriceMap) {
-        var prices = new Array();
-        var mktClosed = new Array();
-        for (var k = 0; k < symbols.length; k++) {
-            var triangulation = this.triangulations.get(symbols[k]);
+    triangulatePricesFromFeedPrices(symbols, feedPriceMap) {
+        let prices = new Array();
+        let mktClosed = new Array();
+        for (let k = 0; k < symbols.length; k++) {
+            let triangulation = this.triangulations.get(symbols[k]);
             if (triangulation == undefined) {
-                var feedPrice = feedPriceMap.get(symbols[k]);
+                let feedPrice = feedPriceMap.get(symbols[k]);
                 if (feedPrice == undefined) {
-                    throw new Error("PriceFeeds: no triangulation defined for ".concat(symbols[k]));
+                    throw new Error(`PriceFeeds: no triangulation defined for ${symbols[k]}`);
                 }
                 else {
                     prices.push(feedPrice[0]); //price
@@ -340,110 +252,86 @@ var PriceFeeds = /** @class */ (function () {
                     continue;
                 }
             }
-            var _a = __read(Triangulator.calculateTriangulatedPrice(triangulation, feedPriceMap), 2), px = _a[0], isMktClosed = _a[1];
+            let [px, isMktClosed] = Triangulator.calculateTriangulatedPrice(triangulation, feedPriceMap);
             prices.push(px);
             mktClosed.push(isMktClosed);
         }
         return [prices, mktClosed];
-    };
+    }
     /**
      * Queries the REST endpoint and returns parsed VAA price data
      * @param query query price-info from endpoint
      * @returns vaa and price info
      */
-    PriceFeeds.prototype.fetchVAAQuery = function (query) {
-        return __awaiter(this, void 0, void 0, function () {
-            var headers, response, values, priceFeedUpdates, px, k, vaa;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        headers = { headers: { "Content-Type": "application/json" } };
-                        return [4 /*yield*/, fetch(query, headers)];
-                    case 1:
-                        response = _a.sent();
-                        if (!response.ok) {
-                            throw new Error("Failed to fetch posts (".concat(response.status, "): ").concat(response.statusText));
-                        }
-                        return [4 /*yield*/, response.json()];
-                    case 2:
-                        values = (_a.sent());
-                        priceFeedUpdates = new Array();
-                        px = new Array();
-                        for (k = 0; k < values.length; k++) {
-                            vaa = values[k].vaa;
-                            priceFeedUpdates.push("0x" + Buffer.from(vaa, "base64").toString("hex"));
-                            px.push(values[k].price);
-                        }
-                        return [2 /*return*/, [priceFeedUpdates, px]];
-                }
-            });
-        });
-    };
+    async fetchVAAQuery(query) {
+        const headers = { headers: { "Content-Type": "application/json" } };
+        let response = await fetch(query, headers);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch posts (${response.status}): ${response.statusText}`);
+        }
+        let values = (await response.json());
+        const priceFeedUpdates = new Array();
+        const px = new Array();
+        for (let k = 0; k < values.length; k++) {
+            const vaa = values[k].vaa;
+            priceFeedUpdates.push("0x" + Buffer.from(vaa, "base64").toString("hex"));
+            px.push(values[k].price);
+        }
+        return [priceFeedUpdates, px];
+    }
     /**
      * Queries the REST endpoint and returns parsed price data
      * @param query query price-info from endpoint
      * @returns vaa and price info
      */
-    PriceFeeds.prototype.fetchPriceQuery = function (query) {
-        return __awaiter(this, void 0, void 0, function () {
-            var headers, response, values, priceFeedUpdates, px, k;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        headers = { headers: { "Content-Type": "application/json" } };
-                        return [4 /*yield*/, fetch(query, headers)];
-                    case 1:
-                        response = _a.sent();
-                        if (!response.ok) {
-                            throw new Error("Failed to fetch posts (".concat(response.status, "): ").concat(response.statusText));
-                        }
-                        return [4 /*yield*/, response.json()];
-                    case 2:
-                        values = _a.sent();
-                        priceFeedUpdates = new Array();
-                        px = new Array();
-                        for (k = 0; k < values.length; k++) {
-                            priceFeedUpdates.push("0x" + Buffer.from(values[k].id, "base64").toString("hex"));
-                            px.push(values[k].price);
-                        }
-                        return [2 /*return*/, [priceFeedUpdates, px]];
-                }
-            });
-        });
-    };
+    async fetchPriceQuery(query) {
+        const headers = { headers: { "Content-Type": "application/json" } };
+        let response = await fetch(query, headers);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch posts (${response.status}): ${response.statusText}`);
+        }
+        let values = await response.json();
+        const priceFeedUpdates = new Array();
+        const px = new Array();
+        for (let k = 0; k < values.length; k++) {
+            priceFeedUpdates.push("0x" + Buffer.from(values[k].id, "base64").toString("hex"));
+            px.push(values[k].price);
+        }
+        return [priceFeedUpdates, px];
+    }
     /**
      * Searches for configuration for given network
      * @param configs pricefeed configuration from json
      * @param network e.g. testnet
      * @returns selected configuration
      */
-    PriceFeeds._selectConfig = function (configs, network) {
-        var k = 0;
+    static _selectConfig(configs, network) {
+        let k = 0;
         while (k < configs.length) {
             if (configs[k].network == network) {
                 return configs[k];
             }
             k = k + 1;
         }
-        throw new Error("PriceFeeds: config not found for network ".concat(network));
-    };
+        throw new Error(`PriceFeeds: config not found for network ${network}`);
+    }
     /**
      * Wraps configuration into convenient data-structure
      * @param config configuration for the selected network
      * @returns feedInfo-map and endPoints-array
      */
-    PriceFeeds._constructFeedInfo = function (config) {
-        var feed = new Map();
-        var endpointId = -1;
-        var type = "";
-        var feedEndpoints = new Array();
-        for (var k = 0; k < config.endpoints.length; k++) {
+    static _constructFeedInfo(config) {
+        let feed = new Map();
+        let endpointId = -1;
+        let type = "";
+        let feedEndpoints = new Array();
+        for (let k = 0; k < config.endpoints.length; k++) {
             feedEndpoints.push(config.endpoints[k].endpoint);
         }
-        for (var k = 0; k < config.ids.length; k++) {
+        for (let k = 0; k < config.ids.length; k++) {
             if (type != config.ids[k].type) {
                 type = config.ids[k].type;
-                var j = 0;
+                let j = 0;
                 while (j < config.endpoints.length) {
                     if (config.endpoints[j].type == type) {
                         endpointId = j;
@@ -452,14 +340,12 @@ var PriceFeeds = /** @class */ (function () {
                     j++;
                 }
                 if (config.endpoints[endpointId].type != type) {
-                    throw new Error("priceFeeds: no enpoint found for ".concat(type, " check priceFeedConfig"));
+                    throw new Error(`priceFeeds: no enpoint found for ${type} check priceFeedConfig`);
                 }
             }
             feed.set(config.ids[k].id, { symbol: config.ids[k].symbol.toUpperCase(), endpointId: endpointId });
         }
         return [feed, feedEndpoints];
-    };
-    return PriceFeeds;
-}());
-export default PriceFeeds;
+    }
+}
 //# sourceMappingURL=priceFeeds.js.map