@d8x/perpetuals-sdk 0.0.45 → 0.1.0

package/dist/perpetualDataHandler.js

@@ -8,17 +8,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const nodeSDKTypes_1 = require("./nodeSDKTypes");
 const utils_1 = require("./utils");
 const d8XMath_1 = require("./d8XMath");
+const priceFeeds_1 = __importDefault(require("./priceFeeds"));
 /**
  * Parent class for MarketData and WriteAccessHandler that handles
  * common data and chain operations.
  */
 class PerpetualDataHandler {
     constructor(config) {
+        this.PRICE_UPDATE_FEE_GWEI = 1;
         this.proxyContract = null;
         // limit order book
         this.lobFactoryContract = null;
@@ -35,6 +40,7 @@ class PerpetualDataHandler {
         this.lobFactoryABI = require(config.limitOrderBookFactoryABILocation);
         this.lobABI = require(config.limitOrderBookABILocation);
         this.symbolList = new Map(Object.entries(require(config.symbolListLocation)));
+        this.priceFeedGetter = new priceFeeds_1.default(this, config.priceFeedConfigNetwork);
     }
     initContractsAndData(signerOrProvider) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -69,6 +75,7 @@ class PerpetualDataHandler {
                 throw Error("proxy or limit order book not defined");
             }
             this.nestedPerpetualIDs = yield PerpetualDataHandler.getNestedPerpetualIds(proxyContract);
+            let requiredPairs = new Set();
             for (let j = 0; j < this.nestedPerpetualIDs.length; j++) {
                 let pool = yield proxyContract.getLiquidityPool(j + 1);
                 let poolMarginTokenAddr = pool.marginTokenAddress;
@@ -87,8 +94,17 @@ class PerpetualDataHandler {
                     let quote = (0, utils_1.contractSymbolToSymbol)(perp.S2QuoteCCY, this.symbolList);
                     let base3 = (0, utils_1.contractSymbolToSymbol)(perp.S3BaseCCY, this.symbolList);
                     let quote3 = (0, utils_1.contractSymbolToSymbol)(perp.S3QuoteCCY, this.symbolList);
-                    currentSymbols.push(base + "-" + quote);
-                    currentSymbolsS3.push(base3 + "-" + quote3);
+                    let sym = base + "-" + quote;
+                    let sym3 = base3 + "-" + quote3;
+                    requiredPairs.add(sym);
+                    if (sym3 != "-") {
+                        requiredPairs.add(sym3);
+                    }
+                    else {
+                        sym3 = "";
+                    }
+                    currentSymbols.push(sym);
+                    currentSymbolsS3.push(sym3);
                     initRate.push((0, d8XMath_1.ABK64x64ToFloat)(perp.fInitialMarginRate));
                     mgnRate.push((0, d8XMath_1.ABK64x64ToFloat)(perp.fMaintenanceMarginRate));
                     lotSizes.push((0, d8XMath_1.ABK64x64ToFloat)(perp.fLotSizeBC));
@@ -129,6 +145,9 @@ class PerpetualDataHandler {
                 let currentSymbols3 = currentSymbols.map((x) => x + "-" + poolCCY);
                 // push into map
                 for (let k = 0; k < perpetualIDs.length; k++) {
+                    // add price IDs
+                    let idsB32, isPyth;
+                    [idsB32, isPyth] = yield proxyContract.getPriceInfo(perpetualIDs[k]);
                     this.symbolToPerpStaticInfo.set(currentSymbols3[k], {
                         id: perpetualIDs[k],
                         limitOrderBookAddr: currentLimitOrderBookAddr[k],
@@ -138,11 +157,16 @@ class PerpetualDataHandler {
                         S2Symbol: currentSymbols[k],
                         S3Symbol: currentSymbolsS3[k],
                         lotSizeBC: lotSizes[k],
+                        priceIds: idsB32,
                     });
                 }
                 // push margin token address into map
                 this.symbolToTokenAddrMap.set(poolCCY, poolMarginTokenAddr);
             }
+            // pre-calculate all triangulation paths so we can easily get from
+            // the prices of price-feeds to the index price required, e.g.
+            // BTC-USDC : BTC-USD / USDC-USD
+            this.priceFeedGetter.initializeTriangulations(requiredPairs);
         });
     }
     /**
@@ -179,6 +203,55 @@ class PerpetualDataHandler {
     symbol4BToLongSymbol(sym) {
         return (0, utils_1.symbol4BToLongSymbol)(sym, this.symbolList);
     }
+    /**
+     * Get PriceFeedSubmission data required for blockchain queries that involve price data, and the corresponding
+     * triangulated prices for the indices S2 and S3
+     * @param symbol pool symbol of the form "ETH-USD-MATIC"
+     * @returns PriceFeedSubmission and prices for S2 and S3. [S2price, 0] if S3 not defined.
+     */
+    fetchPriceSubmissionInfoForPerpetual(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // fetch prices from required price-feeds (REST)
+            return yield this.priceFeedGetter.fetchFeedPriceInfoAndIndicesForPerpetual(symbol);
+        });
+    }
+    /**
+     * Get the symbols required as indices for the given perpetual
+     * @param symbol of the form ETH-USD-MATIC, specifying the perpetual
+     * @returns name of underlying index prices, e.g. ["MATIC-USD", ""]
+     */
+    getIndexSymbols(symbol) {
+        // get index
+        let staticInfo = this.symbolToPerpStaticInfo.get(symbol);
+        if (staticInfo == undefined) {
+            throw new Error(`No static info for perpetual with symbol ${symbol}`);
+        }
+        return [staticInfo.S2Symbol, staticInfo.S3Symbol];
+    }
+    /**
+     * Get the latest prices for a given perpetual from the offchain oracle
+     * networks
+     * @param symbol perpetual symbol of the form BTC-USD-MATIC
+     * @returns array of price feed updates that can be submitted to the smart contract
+     * and corresponding price information
+     */
+    fetchLatestFeedPriceInfo(symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.priceFeedGetter.fetchLatestFeedPriceInfoForPerpetual(symbol);
+        });
+    }
+    /**
+     * Get list of required pyth price source IDs for given perpetual
+     * @param symbol perpetual symbol, e.g., BTC-USD-MATIC
+     * @returns list of required pyth price sources for this perpetual
+     */
+    getPriceIds(symbol) {
+        let perpInfo = this.symbolToPerpStaticInfo.get(symbol);
+        if (perpInfo == undefined) {
+            throw Error(`Perpetual with symbol ${symbol} not found. Check symbol or use createProxyInstance().`);
+        }
+        return perpInfo.priceIds;
+    }
     static _getSymbolFromPoolId(poolId, staticInfos) {
         let idx = poolId - 1;
         return staticInfos[idx].poolMarginSymbol;
@@ -252,26 +325,29 @@ class PerpetualDataHandler {
             return mgn;
         });
     }
-    static _queryPerpetualPrice(symbol, tradeAmount, symbolToPerpStaticInfo, _proxyContract) {
+    static _queryPerpetualPrice(symbol, tradeAmount, symbolToPerpStaticInfo, _proxyContract, indexPrices) {
         return __awaiter(this, void 0, void 0, function* () {
             let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
-            let fPrice = yield _proxyContract.queryPerpetualPrice(perpId, (0, d8XMath_1.floatToABK64x64)(tradeAmount));
+            let fIndexPrices = indexPrices.map((x) => (0, d8XMath_1.floatToABK64x64)(x == undefined || Number.isNaN(x) ? 0 : x));
+            let fPrice = yield _proxyContract.queryPerpetualPrice(perpId, (0, d8XMath_1.floatToABK64x64)(tradeAmount), fIndexPrices);
             return (0, d8XMath_1.ABK64x64ToFloat)(fPrice);
         });
     }
-    static _queryPerpetualMarkPrice(symbol, symbolToPerpStaticInfo, _proxyContract) {
+    static _queryPerpetualMarkPrice(symbol, symbolToPerpStaticInfo, _proxyContract, indexPrices) {
         return __awaiter(this, void 0, void 0, function* () {
             let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
-            let ammState = yield _proxyContract.getAMMState(perpId);
+            let [S2, S3] = indexPrices.map((x) => (0, d8XMath_1.floatToABK64x64)(x == undefined || Number.isNaN(x) ? 0 : x));
+            let ammState = yield _proxyContract.getAMMState(perpId, [S2, S3]);
             return (0, d8XMath_1.ABK64x64ToFloat)(ammState[6].mul(nodeSDKTypes_1.ONE_64x64.add(ammState[8])).div(nodeSDKTypes_1.ONE_64x64));
         });
     }
-    static _queryPerpetualState(symbol, symbolToPerpStaticInfo, _proxyContract) {
+    static _queryPerpetualState(symbol, symbolToPerpStaticInfo, _proxyContract, indexPrices) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
             let ccy = symbol.split("-");
-            let ammState = yield _proxyContract.getAMMState(perpId);
+            let [S2, S3] = [indexPrices[0], indexPrices[1]];
+            let ammState = yield _proxyContract.getAMMState(perpId, [S2, S3].map((x) => (0, d8XMath_1.floatToABK64x64)(x == undefined || Number.isNaN(x) ? 0 : x)));
             let markPrice = (0, d8XMath_1.ABK64x64ToFloat)(ammState[6].mul(nodeSDKTypes_1.ONE_64x64.add(ammState[8])).div(nodeSDKTypes_1.ONE_64x64));
             let state = {
                 id: perpId,
@@ -285,6 +361,7 @@ class PerpetualDataHandler {
                 currentFundingRateBps: (0, d8XMath_1.ABK64x64ToFloat)(ammState[14]) * 1e4,
                 openInterestBC: (0, d8XMath_1.ABK64x64ToFloat)(ammState[11]),
                 maxPositionBC: (0, d8XMath_1.ABK64x64ToFloat)(ammState[12]),
+                isMarketClosed: indexPrices[2] || indexPrices[3],
             };
             if (((_a = symbolToPerpStaticInfo.get(symbol)) === null || _a === void 0 ? void 0 : _a.collateralCurrencyType) == nodeSDKTypes_1.CollaterlCCY.BASE) {
                 state.collToQuoteIndexPrice = state.indexPrice;
@@ -569,18 +646,37 @@ class PerpetualDataHandler {
     }
     /**
      * Read config file into NodeSDKConfig interface
-     * @param fileLocation json-file with required variables for config
+     * @param configNameOrfileLocation json-file with required variables for config, or name of a default known config
      * @returns NodeSDKConfig
      */
-    static readSDKConfig(fileLocation) {
-        if (fileLocation == nodeSDKTypes_1.DEFAULT_CONFIG_MAINNET_NAME) {
-            fileLocation = nodeSDKTypes_1.DEFAULT_CONFIG_MAINNET;
+    static readSDKConfig(configNameOrFileLocation, version) {
+        let config;
+        if (/\.json$/.test(configNameOrFileLocation)) {
+            // file path
+            let configFile = require(configNameOrFileLocation);
+            config = configFile;
+        }
+        else {
+            // name
+            let configFile = require(nodeSDKTypes_1.DEFAULT_CONFIG);
+            configFile = configFile.filter((c) => c.name == configNameOrFileLocation);
+            if (configFile.length == 0) {
+                throw Error(`Config name ${configNameOrFileLocation} not found.`);
+            }
+            else if (configFile.length > 1) {
+                // TODO: pick one with highest version, unless version is given
+                throw Error(`Config name ${configNameOrFileLocation} not unique.`);
+            }
+            for (let configItem of configFile) {
+                if (configItem.name == configNameOrFileLocation) {
+                    config = configItem;
+                    break;
+                }
+            }
         }
-        else if (fileLocation == nodeSDKTypes_1.DEFAULT_CONFIG_TESTNET_NAME) {
-            fileLocation = nodeSDKTypes_1.DEFAULT_CONFIG_TESTNET;
+        if (config == undefined) {
+            throw Error(`Config file ${configNameOrFileLocation} not found.`);
         }
-        let configFile = require(fileLocation);
-        let config = configFile;
         return config;
     }
     /**
@@ -593,5 +689,36 @@ class PerpetualDataHandler {
         const FormatTypes = ethers_1.ethers.utils.FormatTypes;
         return contract.interface.getFunction(functionName).format(FormatTypes.full);
     }
+    /**
+     * Gets the pool index (in exchangeInfo) corresponding to a given symbol.
+     * @param symbol Symbol of the form ETH-USD-MATIC
+     * @returns Pool index
+     */
+    getPoolIndexFromSymbol(symbol) {
+        let pools = this.poolStaticInfos;
+        let poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+        let k = 0;
+        while (k < pools.length) {
+            if (pools[k].poolId == poolId) {
+                // pool found
+                return k;
+            }
+            k++;
+        }
+        return -1;
+    }
+    getMarginTokenFromSymbol(symbol) {
+        let pools = this.poolStaticInfos;
+        let poolId = PerpetualDataHandler._getPoolIdFromSymbol(symbol, this.poolStaticInfos);
+        let k = 0;
+        while (k < pools.length) {
+            if (pools[k].poolId == poolId) {
+                // pool found
+                return pools[k].poolMarginTokenAddr;
+            }
+            k++;
+        }
+        return undefined;
+    }
 }
 exports.default = PerpetualDataHandler;

package/dist/perpetualEventHandler.d.ts

@@ -8,9 +8,6 @@ import { ExchangeInfo, MarginAccount, OrderStruct, PerpetualState, SmartContract
  *  ordersInPerpetual: Map<number, OrderStruct> all open orders for the given trader
  *  positionInPerpetual: Map<number, MarginAccount> all open positions for the given trader
  *
- *  TODO:
- *    - update functions for midprice & index & collateral prices without event
- *    - testing
  *
  * Get data:
  *  - getPerpetualData(perp id (string) or symbol) : PerpetualState. This is a reference!

package/dist/perpetualEventHandler.js

@@ -19,9 +19,6 @@ const nodeSDKTypes_1 = require("./nodeSDKTypes");
  *  ordersInPerpetual: Map<number, OrderStruct> all open orders for the given trader
  *  positionInPerpetual: Map<number, MarginAccount> all open positions for the given trader
  *
- *  TODO:
- *    - update functions for midprice & index & collateral prices without event
- *    - testing
  *
  * Get data:
  *  - getPerpetualData(perp id (string) or symbol) : PerpetualState. This is a reference!

package/dist/priceFeeds.d.ts

@@ -0,0 +1,115 @@
+import PerpetualDataHandler from "./perpetualDataHandler";
+import { PriceFeedConfig, PriceFeedSubmission, PriceFeedFormat } from "./nodeSDKTypes";
+/**
+ * This class communicates with the REST API that provides price-data that is
+ * 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 {
+    private config;
+    private feedEndpoints;
+    private feedInfo;
+    private dataHandler;
+    private triangulations;
+    private THRESHOLD_MARKET_CLOSED_SEC;
+    constructor(dataHandler: PerpetualDataHandler, priceFeedConfigNetwork: string);
+    /**
+     * Pre-processing of triangulations for symbols, given the price feeds
+     * @param symbols set of symbols we want to triangulate from price feeds
+     */
+    initializeTriangulations(symbols: Set<string>): void;
+    /**
+     * 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
+     */
+    fetchFeedPriceInfoAndIndicesForPerpetual(symbol: string): Promise<{
+        submission: PriceFeedSubmission;
+        pxS2S3: [number, number];
+        mktClosed: [boolean, boolean];
+    }>;
+    /**
+    * 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
+    */
+    fetchPrices(symbols: string[]): Promise<Map<string, [number, boolean]>>;
+    /**
+     * Get index prices and market closed information for the given perpetual
+     * @param symbol perpetual symbol such as ETH-USD-MATIC
+     * @returns
+     */
+    fetchPricesForPerpetual(symbol: string): Promise<{
+        idxPrices: number[];
+        mktClosed: boolean[];
+    }>;
+    /**
+     * Fetch the provided feed prices and bool whether market is closed or open
+     * - requires the feeds to be defined in priceFeedConfig.json
+     * - if undefined, all feeds are queried
+     * @param symbols array of feed-price symbols (e.g., [btc-usd, eth-usd]) or undefined
+     * @returns mapping symbol-> [price, isMarketClosed]
+     */
+    fetchFeedPrices(symbols?: string[]): Promise<Map<string, [number, boolean]>>;
+    /**
+     * Get all configured feed prices via "latest_price_feeds"
+     * @returns map of feed-price symbol to price/isMarketClosed
+     */
+    fetchAllFeedPrices(): Promise<Map<string, [number, boolean]>>;
+    /**
+     * Get the latest prices for a given perpetual from the offchain oracle
+     * networks
+     * @param symbol perpetual symbol of the form BTC-USD-MATIC
+     * @returns array of price feed updates that can be submitted to the smart contract
+     * and corresponding price information
+     */
+    fetchLatestFeedPriceInfoForPerpetual(symbol: string): Promise<PriceFeedSubmission>;
+    /**
+     * Extract pair-prices from underlying price feeds via triangulation
+     * The function either needs a direct price feed or a defined triangulation to succesfully
+     * return a triangulated price
+     * @param symbols array of pairs for which we want prices, e.g., [BTC-USDC, ETH-USD]
+     * @param feeds data obtained via fetchLatestFeedPriceInfo or fetchLatestFeedPrices
+     * @returns array of prices with same order as symbols
+     */
+    calculateTriangulatedPricesFromFeedInfo(symbols: string[], feeds: PriceFeedSubmission): [number[], boolean[]];
+    /**
+    * Extract pair-prices from underlying price feeds via triangulation
+    * The function either needs a direct price feed or a defined triangulation to succesfully
+    * return a triangulated price
+    * @param symbols array of pairs for which we want prices, e.g., [BTC-USDC, ETH-USD]
+    * @param feeds data obtained via fetchLatestFeedPriceInfo or fetchLatestFeedPrices
+    * @returns array of prices with same order as symbols
+    */
+    triangulatePricesFromFeedPrices(symbols: string[], feedPriceMap: Map<string, [number, boolean]>): [number[], boolean[]];
+    /**
+     * Queries the REST endpoint and returns parsed VAA price data
+     * @param query query price-info from endpoint
+     * @returns vaa and price info
+     */
+    private fetchVAAQuery;
+    /**
+     * Queries the REST endpoint and returns parsed price data
+     * @param query query price-info from endpoint
+     * @returns vaa and price info
+     */
+    fetchPriceQuery(query: string): Promise<[string[], PriceFeedFormat[]]>;
+    /**
+     * Searches for configuration for given network
+     * @param configs pricefeed configuration from json
+     * @param network e.g. testnet
+     * @returns selected configuration
+     */
+    static _selectConfig(configs: PriceFeedConfig[], network: string): PriceFeedConfig;
+    /**
+     * Wraps configuration into convenient data-structure
+     * @param config configuration for the selected network
+     * @returns feedInfo-map and endPoints-array
+     */
+    static _constructFeedInfo(config: PriceFeedConfig): [Map<string, {
+        symbol: string;
+        endpointId: number;
+    }>, string[]];
+}