@d8x/perpetuals-sdk 0.7.6 → 0.7.7

package/dist/esm/priceFeeds.js

@@ -1,3 +1,4 @@
+import { __awaiter, __generator, __read, __values } from "tslib";
 import { BigNumber } from "@ethersproject/bignumber";
 import Triangulator from "./triangulator";
 import { decNToFloat } from "./d8XMath";
@@ -7,12 +8,13 @@ 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.
  */
-export default class PriceFeeds {
-    constructor(dataHandler, priceFeedConfigNetwork) {
+var PriceFeeds = /** @class */ (function () {
+    function PriceFeeds(dataHandler, priceFeedConfigNetwork) {
+        var _a;
         this.THRESHOLD_MARKET_CLOSED_SEC = 15; // smallest lag for which we consider the market as being closed
-        let configs = require("./config/priceFeedConfig.json");
+        var configs = require("./config/priceFeedConfig.json");
         this.config = PriceFeeds._selectConfig(configs, priceFeedConfigNetwork);
-        [this.feedInfo, this.feedEndpoints] = PriceFeeds._constructFeedInfo(this.config);
+        _a = __read(PriceFeeds._constructFeedInfo(this.config), 2), this.feedInfo = _a[0], this.feedEndpoints = _a[1];
         this.dataHandler = dataHandler;
         this.triangulations = new Map();
     }
@@ -20,84 +22,140 @@ export default class PriceFeeds {
      * Pre-processing of triangulations for symbols, given the price feeds
      * @param symbols set of symbols we want to triangulate from price feeds
      */
-    initializeTriangulations(symbols) {
-        let feedSymbols = new Array();
-        for (let [, value] of this.feedInfo) {
-            feedSymbols.push(value.symbol);
+    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);
+            }
         }
-        for (let symbol of symbols.values()) {
-            let triangulation = Triangulator.triangulate(feedSymbols, symbol);
-            this.triangulations.set(symbol, triangulation);
+        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; }
         }
-    }
+        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);
+            }
+        }
+        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
      */
-    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 };
-    }
+    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 }];
+                }
+            });
+        });
+    };
     /**
      * 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
      */
-    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;
-    }
+    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];
+                }
+            });
+        });
+    };
     /**
      * 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
      */
-    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);
+    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 }];
                 }
-                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
@@ -105,49 +163,68 @@ export default class PriceFeeds {
      * @param symbols array of feed-price symbols (e.g., [btc-usd, eth-usd]) or undefined
      * @returns mapping symbol-> [price, isMarketClosed]
      */
-    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;
-    }
+    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];
+                }
+            });
+        });
+    };
     /**
      * Get all configured feed prices via "latest_price_feeds"
      * @returns map of feed-price symbol to price/isMarketClosed
      */
-    async fetchAllFeedPrices() {
-        return this.fetchFeedPrices();
-    }
+    PriceFeeds.prototype.fetchAllFeedPrices = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchFeedPrices()];
+            });
+        });
+    };
     /**
      * Get the latest prices for a given perpetual from the offchain oracle
      * networks
@@ -155,64 +232,75 @@ export default class PriceFeeds {
      * @returns array of price feed updates that can be submitted to the smart contract
      * and corresponding price information
      */
-    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,
-        };
-    }
+    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,
+                            }];
+                }
+            });
+        });
+    };
     /**
      * Extract pair-prices from underlying price feeds via triangulation
      * The function either needs a direct price feed or a defined triangulation to succesfully
@@ -221,13 +309,13 @@ export default class PriceFeeds {
      * @param feeds data obtained via fetchLatestFeedPriceInfo or fetchLatestFeedPrices
      * @returns array of prices with same order as symbols
      */
-    calculateTriangulatedPricesFromFeedInfo(symbols, feeds) {
-        let priceMap = new Map();
-        for (let j = 0; j < feeds.prices.length; j++) {
+    PriceFeeds.prototype.calculateTriangulatedPricesFromFeedInfo = function (symbols, feeds) {
+        var priceMap = new Map();
+        for (var 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
@@ -236,15 +324,15 @@ export default class PriceFeeds {
      * @param feeds data obtained via fetchLatestFeedPriceInfo or fetchLatestFeedPrices
      * @returns array of prices with same order as symbols
      */
-    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]);
+    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]);
             if (triangulation == undefined) {
-                let feedPrice = feedPriceMap.get(symbols[k]);
+                var feedPrice = feedPriceMap.get(symbols[k]);
                 if (feedPrice == undefined) {
-                    throw new Error(`PriceFeeds: no triangulation defined for ${symbols[k]}`);
+                    throw new Error("PriceFeeds: no triangulation defined for ".concat(symbols[k]));
                 }
                 else {
                     prices.push(feedPrice[0]); //price
@@ -252,86 +340,110 @@ export default class PriceFeeds {
                     continue;
                 }
             }
-            let [px, isMktClosed] = Triangulator.calculateTriangulatedPrice(triangulation, feedPriceMap);
+            var _a = __read(Triangulator.calculateTriangulatedPrice(triangulation, feedPriceMap), 2), px = _a[0], isMktClosed = _a[1];
             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
      */
-    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];
-    }
+    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]];
+                }
+            });
+        });
+    };
     /**
      * Queries the REST endpoint and returns parsed price data
      * @param query query price-info from endpoint
      * @returns vaa and price info
      */
-    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];
-    }
+    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]];
+                }
+            });
+        });
+    };
     /**
      * Searches for configuration for given network
      * @param configs pricefeed configuration from json
      * @param network e.g. testnet
      * @returns selected configuration
      */
-    static _selectConfig(configs, network) {
-        let k = 0;
+    PriceFeeds._selectConfig = function (configs, network) {
+        var 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 ${network}`);
-    }
+        throw new Error("PriceFeeds: config not found for network ".concat(network));
+    };
     /**
      * Wraps configuration into convenient data-structure
      * @param config configuration for the selected network
      * @returns feedInfo-map and endPoints-array
      */
-    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++) {
+    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++) {
             feedEndpoints.push(config.endpoints[k].endpoint);
         }
-        for (let k = 0; k < config.ids.length; k++) {
+        for (var k = 0; k < config.ids.length; k++) {
             if (type != config.ids[k].type) {
                 type = config.ids[k].type;
-                let j = 0;
+                var j = 0;
                 while (j < config.endpoints.length) {
                     if (config.endpoints[j].type == type) {
                         endpointId = j;
@@ -340,12 +452,14 @@ export default class PriceFeeds {
                     j++;
                 }
                 if (config.endpoints[endpointId].type != type) {
-                    throw new Error(`priceFeeds: no enpoint found for ${type} check priceFeedConfig`);
+                    throw new Error("priceFeeds: no enpoint found for ".concat(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