@d8x/perpetuals-sdk 0.0.45 → 0.0.46

package/src/liquidatorTool.ts

@@ -1,5 +1,5 @@
 import WriteAccessHandler from "./writeAccessHandler";
-import { NodeSDKConfig } from "./nodeSDKTypes";
+import { NodeSDKConfig, PriceFeedSubmission } from "./nodeSDKTypes";
 import { ethers } from "ethers";
 
 /**
@@ -37,6 +37,7 @@ export default class LiquidatorTool extends WriteAccessHandler {
    * @param {string} symbol Symbol of the form ETH-USD-MATIC.
    * @param {string} traderAddr Address of the trader to be liquidated.
    * @param {string=} liquidatorAddr Address to be credited if the liquidation succeeds.
+   * @param {PriceFeedSubmission} priceFeedData optional. VAA and timestamps for oracle. If not provided will query from REST API.
    * Defaults to the wallet used to execute the liquidation.
    * @example
    * import { LiquidatorTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
@@ -59,7 +60,8 @@ export default class LiquidatorTool extends WriteAccessHandler {
   public async liquidateTrader(
     symbol: string,
     traderAddr: string,
-    liquidatorAddr: string = ""
+    liquidatorAddr: string = "",
+    priceFeedData?: PriceFeedSubmission
   ): Promise<ethers.ContractTransaction> {
     // this operation spends gas, so signer is required
     if (this.proxyContract == null || this.signer == null) {
@@ -70,7 +72,13 @@ export default class LiquidatorTool extends WriteAccessHandler {
       liquidatorAddr = this.traderAddr;
     }
     let perpID = LiquidatorTool.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
-    return await this._liquidateByAMM(perpID, liquidatorAddr, traderAddr, this.gasLimit);
+    if (priceFeedData == undefined) {
+      priceFeedData = await this.fetchLatestFeedPriceInfo(symbol);
+    }
+    return await this._liquidateByAMM(perpID, liquidatorAddr, traderAddr, priceFeedData, {
+      gasLimit: this.gasLimit,
+      value: this.PRICE_UPDATE_FEE_GWEI * priceFeedData.priceFeedVaas.length,
+    });
   }
 
   /**
@@ -116,13 +124,25 @@ export default class LiquidatorTool extends WriteAccessHandler {
    * @param perpetualId Perpetual id.
    * @param liquidatorAddr Address to be credited for the liquidation.
    * @param traderAddr Address of the trader to be liquidated.
-   * @param gasLimit Gas limit.
+   * @param priceFeedData contains VAA and timestamps required
+   * @param options E.g., Gas limit, fee.
    * @ignore
    */
-  public async _liquidateByAMM(perpetualId: number, liquidatorAddr: string, traderAddr: string, gasLimit: number) {
-    return await this.proxyContract!.liquidateByAMM(perpetualId, liquidatorAddr, traderAddr, {
-      gasLimit: gasLimit,
-    });
+  public async _liquidateByAMM(
+    perpetualId: number,
+    liquidatorAddr: string,
+    traderAddr: string,
+    priceFeedData: PriceFeedSubmission,
+    options: object
+  ) {
+    return await this.proxyContract!.liquidateByAMM(
+      perpetualId,
+      liquidatorAddr,
+      traderAddr,
+      priceFeedData.priceFeedVaas,
+      priceFeedData.timestamps,
+      options
+    );
   }
 
   /**

package/src/marketData.ts

@@ -32,6 +32,7 @@ import {
   ZERO_ADDRESS,
 } from "./nodeSDKTypes";
 import PerpetualDataHandler from "./perpetualDataHandler";
+import PriceFeeds from "./priceFeeds";
 import { contractSymbolToSymbol, toBytes4 } from "./utils";
 
 /**
@@ -145,7 +146,7 @@ export default class MarketData extends PerpetualDataHandler {
     if (this.proxyContract == null) {
       throw Error("no proxy contract initialized. Use createProxyInstance().");
     }
-    return await MarketData._exchangeInfo(this.proxyContract, this.poolStaticInfos, this.symbolList);
+    return await MarketData._exchangeInfo(this.proxyContract, this.poolStaticInfos, this.symbolToPerpStaticInfo, this.symbolList, this.priceFeedGetter);
   }
 
   /**
@@ -431,25 +432,6 @@ export default class MarketData extends PerpetualDataHandler {
     return newPositionRisk;
   }
 
-  /**
-   * Gets the pool index (in exchangeInfo) corresponding to a given symbol.
-   * @param symbol Symbol of the form ETH-USD-MATIC
-   * @returns Pool index
-   */
-  public getPoolIndexFromSymbol(symbol: string): number {
-    let pools = this.poolStaticInfos!;
-    let poolId = this.getPoolIdFromSymbol(symbol);
-    let k = 0;
-    while (k < pools.length) {
-      if (pools[k].poolId == poolId) {
-        // pool found
-        return k;
-      }
-      k++;
-    }
-    return -1;
-  }
-
   /**
    * Gets the wallet balance in the collateral currency corresponding to a given perpetual symbol.
    * @param address Address to check
@@ -563,11 +545,15 @@ export default class MarketData extends PerpetualDataHandler {
    *
    * @returns mark price
    */
-  public async getMarkPrice(symbol: string): Promise<number> {
+  public async getMarkPrice(symbol: string, indexPrices?: [number, number]): Promise<number> {
     if (this.proxyContract == null) {
       throw Error("no proxy contract initialized. Use createProxyInstance().");
     }
-    return await PerpetualDataHandler._queryPerpetualMarkPrice(symbol, this.symbolToPerpStaticInfo, this.proxyContract);
+    if(indexPrices==undefined) {
+      let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
+      indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
+    }
+    return await PerpetualDataHandler._queryPerpetualMarkPrice(symbol, this.symbolToPerpStaticInfo, this.proxyContract, indexPrices);
   }
 
   /**
@@ -590,31 +576,43 @@ export default class MarketData extends PerpetualDataHandler {
    *
    * @returns price (number)
    */
-  public async getPerpetualPrice(symbol: string, quantity: number): Promise<number> {
+  public async getPerpetualPrice(symbol: string, quantity: number, indexPrices?:[number, number]): Promise<number> {
     if (this.proxyContract == null) {
       throw Error("no proxy contract initialized. Use createProxyInstance().");
     }
+    if (indexPrices==undefined) {
+      // fetch from API
+      let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
+      indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
+    }
     return await PerpetualDataHandler._queryPerpetualPrice(
       symbol,
       quantity,
       this.symbolToPerpStaticInfo,
-      this.proxyContract
+      this.proxyContract,
+      indexPrices
     );
   }
 
   /**
    * Query recent perpetual state from blockchain
    * @param symbol symbol of the form ETH-USD-MATIC
+   * @param indexPrices S2 and S3 prices/isMarketOpen if not provided fetch via REST API
    * @returns PerpetualState reference
    */
-  public async getPerpetualState(symbol: string): Promise<PerpetualState> {
+  public async getPerpetualState(symbol: string, indexPriceInfo?: [number, number, boolean, boolean]): Promise<PerpetualState> {
     if (this.proxyContract == null) {
       throw Error("no proxy contract initialized. Use createProxyInstance().");
     }
+    if (indexPriceInfo==undefined) {
+      let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
+      indexPriceInfo = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
+    }
     let state: PerpetualState = await PerpetualDataHandler._queryPerpetualState(
       symbol,
       this.symbolToPerpStaticInfo,
-      this.proxyContract
+      this.proxyContract,
+      indexPriceInfo
     );
     return state;
   }
@@ -640,6 +638,7 @@ export default class MarketData extends PerpetualDataHandler {
       S2Symbol: perpInfo.S2Symbol,
       S3Symbol: perpInfo.S3Symbol,
       lotSizeBC: perpInfo.lotSizeBC,
+      priceIds: perpInfo.priceIds,
     };
     return res;
   }
@@ -726,24 +725,30 @@ export default class MarketData extends PerpetualDataHandler {
     return balanceCC - initalMarginCC;
   }
 
-  public async getPythIds(symbol: string): Promise<string[]> {
-    if (this.proxyContract == null) {
-      throw Error("no proxy contract initialized. Use createProxyInstance().");
-    }
-    let perpId = this.getPerpIdFromSymbol(symbol);
-    let idsB32 = await this.proxyContract.getPythIds(perpId);
-    return idsB32.apply((id: string) => ethers.utils.parseBytes32String(id));
-  }
-
   public static async _exchangeInfo(
     _proxyContract: ethers.Contract,
     _poolStaticInfos: Array<PoolStaticInfo>,
-    _symbolList: Map<string, string>
+    _symbolToPerpStaticInfo : Map<string, PerpetualStaticInfo>,
+    _symbolList: Map<string, string>,
+    _priceFeedGetter: PriceFeeds
   ): Promise<ExchangeInfo> {
     let nestedPerpetualIDs = await PerpetualDataHandler.getNestedPerpetualIds(_proxyContract);
     let factory = await _proxyContract.getOracleFactory();
     let info: ExchangeInfo = { pools: [], oracleFactoryAddr: factory, proxyAddr: _proxyContract.address };
     const numPools = nestedPerpetualIDs.length;
+    
+    // get all prices
+    let allSym = new Set<string>();
+    for(let perpSymbol of _symbolToPerpStaticInfo.keys()) {
+      let sInfo : PerpetualStaticInfo | undefined = _symbolToPerpStaticInfo.get(perpSymbol);
+      allSym.add(sInfo!.S2Symbol);
+      if(sInfo!.S3Symbol!='') {
+        allSym.add(sInfo!.S3Symbol);
+      }
+    }
+    let allSymArr = Array.from(allSym.values());
+    let idxPriceMap : Map<string, [number,boolean]> = await _priceFeedGetter.fetchPrices(allSymArr);
+
     for (var j = 0; j < numPools; j++) {
       let perpetualIDs = nestedPerpetualIDs[j];
       let pool = await _proxyContract.getLiquidityPool(j + 1);
@@ -759,17 +764,36 @@ export default class MarketData extends PerpetualDataHandler {
         brokerCollateralLotSize: ABK64x64ToFloat(pool.fBrokerCollateralLotSize),
         perpetuals: [],
       };
+      let poolSymbol = PoolState.poolSymbol;
       for (var k = 0; k < perpetualIDs.length; k++) {
         let perp = await _proxyContract.getPerpetual(perpetualIDs[k]);
-        let fIndexS2 = await _proxyContract.getOraclePrice([perp.S2BaseCCY, perp.S2QuoteCCY]);
-        let fMidPrice = await _proxyContract.queryPerpetualPrice(perpetualIDs[k], BigNumber.from(0));
-        let indexS2 = ABK64x64ToFloat(fIndexS2);
+        let symS2 = contractSymbolToSymbol(perp.S2BaseCCY, _symbolList)+"-"+contractSymbolToSymbol(perp.S2QuoteCCY, _symbolList);
+        let symS3 = contractSymbolToSymbol(perp.S3BaseCCY, _symbolList)+"-"+contractSymbolToSymbol(perp.S3QuoteCCY, _symbolList);
+        let perpSymbol = symS2+"-"+poolSymbol;
+        //console.log("perpsymbol=",perpSymbol);
+        let res = idxPriceMap.get(symS2)
+        if (res==undefined) {
+          throw new Error(`Price for index ${symS2} could not be fetched - config issue`);
+        }
+        let [indexS2, isS2MktClosed] : [number, boolean] = [res[0], res[1]];
         let indexS3 = 1;
+        let isS3MktClosed = false;
         if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_BASE) {
           indexS3 = indexS2;
         } else if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_QUANTO) {
-          indexS3 = ABK64x64ToFloat(await _proxyContract.getOraclePrice([perp.S3BaseCCY, perp.S3QuoteCCY]));
+          res = idxPriceMap.get(symS3);
+          if (res==undefined) {
+            throw new Error(`Price for index ${symS3} could not be fetched - config issue`);
+          } else {
+            indexS3 = res[0];
+            isS3MktClosed = res[1]; 
+          }
         }
+        let fMidPrice = await _proxyContract.queryPerpetualPrice(perpetualIDs[k], BigNumber.from(0), [
+          floatToABK64x64(indexS2),
+          floatToABK64x64(indexS3)
+        ]);
+        
         let markPremiumRate = ABK64x64ToFloat(perp.currentMarkPremiumRate.fPrice);
         let currentFundingRateBps = 1e4 * ABK64x64ToFloat(perp.fCurrentFundingRate);
         let state = PERP_STATE_STR[perp.state];
@@ -784,7 +808,8 @@ export default class MarketData extends PerpetualDataHandler {
           midPrice: ABK64x64ToFloat(fMidPrice),
           currentFundingRateBps: currentFundingRateBps,
           openInterestBC: ABK64x64ToFloat(perp.fOpenInterest),
-          maxPositionBC: ABK64x64ToFloat(perp.fMaxPositionBC),
+          maxPositionBC: Infinity,
+          isMarketClosed: isS2MktClosed || isS3MktClosed
         };
         PoolState.perpetuals.push(PerpetualState);
       }

package/src/nodeSDKTypes.ts

@@ -1,10 +1,11 @@
 import { BigNumber, BigNumberish, BytesLike, constants, ContractTransaction } from "ethers";
-export const DEFAULT_CONFIG_TESTNET = "../config/defaultConfig.json";
-export const DEFAULT_CONFIG_MAINNET = "notthereyet";
+import { NumberLiteralType } from "typescript";
+export const DEFAULT_CONFIG = "../config/defaultConfig.json";
 export const DEFAULT_CONFIG_TESTNET_NAME = "testnet";
 export const DEFAULT_CONFIG_MAINNET_NAME = "mainnet";
 
 export const ERC20_ABI = require("../abi/ERC20.json");
+export const MOCK_TOKEN_SWAP_ABI = require("../abi/MockTokenSwap.json");
 export const COLLATERAL_CURRENCY_QUOTE = 0;
 export const COLLATERAL_CURRENCY_BASE = 1;
 export const COLLATERAL_CURRENCY_QUANTO = 2;
@@ -33,6 +34,8 @@ export const BUY_SIDE = "BUY";
 export const SELL_SIDE = "SELL";
 export const CLOSED_SIDE = "CLOSED";
 export interface NodeSDKConfig {
+  name: string | undefined;
+  version: number;
   nodeURL: string;
   proxyAddr: string;
   proxyABILocation: string;
@@ -40,6 +43,7 @@ export interface NodeSDKConfig {
   limitOrderBookABILocation: string;
   limitOrderBookFactoryABILocation: string;
   symbolListLocation: string;
+  priceFeedConfigNetwork: string;
   gasLimit?: number | undefined;
 }
 
@@ -81,6 +85,7 @@ export interface PerpetualStaticInfo {
   S2Symbol: string;
   S3Symbol: string;
   lotSizeBC: number;
+  priceIds: string[];
 }
 
 /**
@@ -135,6 +140,7 @@ export interface PerpetualState {
   currentFundingRateBps: number;
   openInterestBC: number;
   maxPositionBC: number;
+  isMarketClosed: boolean;
 }
 
 export interface OrderResponse {
@@ -148,7 +154,7 @@ export interface OrderStruct {
 }
 
 export interface Order {
-  symbol: string;
+  symbol: string;//symbol of the form ETH-USD-MATIC
   side: string;
   type: string;
   quantity: number;
@@ -204,3 +210,24 @@ export interface SmartContractOrder {
         uint256 iDeadline;
         uint256 createdTimestamp;
         */
+
+export interface PriceFeedConfig {
+  network: string;
+  ids: Array<{ symbol: string; id: string; type: string; origin: string }>;
+  endpoints: Array<{ type: string; endpoint: string }>;
+}
+
+export interface PriceFeedSubmission {
+  symbols: string[];
+  priceFeedVaas: string[]; 
+  prices: number[];
+  isMarketClosed: boolean[];
+  timestamps: number[];
+}
+
+export interface PriceFeedFormat {
+  conf: BigNumber;
+  expo: number;
+  price: BigNumber;
+  publish_time: number;
+}

package/src/orderReferrerTool.ts

@@ -7,6 +7,7 @@ import {
   SELL_SIDE,
   ZERO_ADDRESS,
   ZERO_ORDER_ID,
+  PriceFeedSubmission,
 } from "./nodeSDKTypes";
 import PerpetualDataHandler from "./perpetualDataHandler";
 import WriteAccessHandler from "./writeAccessHandler";
@@ -46,8 +47,9 @@ export default class OrderReferrerTool extends WriteAccessHandler {
    * Executes an order by symbol and ID. This action interacts with the blockchain and incurs gas costs.
    * @param {string} symbol Symbol of the form ETH-USD-MATIC.
    * @param {string} orderId ID of the order to be executed.
-   * @param {string=} referrerAddr Address of the wallet to be credited for executing the order,
-   * if different from the one submitting this transaction.
+   * @param {string=} referrerAddr optional address of the wallet to be credited for executing the order, if different from the one submitting this transaction.
+   * @param {number=} nonce optional nonce
+   * @param {PriceFeedSubmission=} submission optional signed prices obtained via PriceFeeds::fetchLatestFeedPriceInfoForPerpetual
    * @example
    * import { OrderReferrerTool, PerpetualDataHandler, Order } from "@d8x/perpetuals-sdk";
    * async function main() {
@@ -79,7 +81,8 @@ export default class OrderReferrerTool extends WriteAccessHandler {
     symbol: string,
     orderId: string,
     referrerAddr?: string,
-    nonce?: number
+    nonce?: number,
+    submission?: PriceFeedSubmission
   ): Promise<ethers.ContractTransaction> {
     if (this.proxyContract == null || this.signer == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
@@ -88,8 +91,22 @@ export default class OrderReferrerTool extends WriteAccessHandler {
     if (typeof referrerAddr == "undefined") {
       referrerAddr = this.traderAddr;
     }
-    const options = { gasLimit: this.gasLimit, nonce: nonce };
-    return await orderBookSC.executeOrder(orderId, referrerAddr, options);
+    if (submission == undefined) {
+      submission = await this.priceFeedGetter.fetchLatestFeedPriceInfoForPerpetual(symbol);
+    }
+    const options = {
+      gasLimit: this.gasLimit,
+      nonce: nonce,
+      value: this.PRICE_UPDATE_FEE_GWEI * submission?.priceFeedVaas.length,
+    };
+    console.log(submission);
+    return await orderBookSC.executeOrder(
+      orderId,
+      referrerAddr,
+      submission?.priceFeedVaas,
+      submission?.timestamps,
+      options
+    );
   }
 
   /**
@@ -224,6 +241,8 @@ export default class OrderReferrerTool extends WriteAccessHandler {
   /**
    * Check if a conditional order can be executed
    * @param order order structure
+   * @param indexPrices pair of index prices S2 and S3. S3 set to zero if not required. If undefined
+   * the function will fetch the latest prices from the REST API
    * @example
    * import { OrderReferrerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
    * async function main() {
@@ -241,26 +260,39 @@ export default class OrderReferrerTool extends WriteAccessHandler {
    * main();
    * @returns true if order can be executed for the current state of the perpetuals
    */
-  public async isTradeable(order: Order): Promise<boolean> {
+  public async isTradeable(order: Order, indexPrices?: [number, number]): Promise<boolean> {
     if (this.proxyContract == null) {
       throw Error("no proxy contract initialized. Use createProxyInstance().");
     }
+    if (indexPrices == undefined) {
+      let obj = await this.priceFeedGetter.fetchPricesForPerpetual(order.symbol);
+      indexPrices = [obj.idxPrices[0], obj.idxPrices[1]];
+    }
     let orderPrice = await PerpetualDataHandler._queryPerpetualPrice(
       order.symbol,
       order.quantity,
       this.symbolToPerpStaticInfo,
-      this.proxyContract
+      this.proxyContract,
+      indexPrices
     );
     let markPrice = await PerpetualDataHandler._queryPerpetualMarkPrice(
       order.symbol,
       this.symbolToPerpStaticInfo,
-      this.proxyContract
+      this.proxyContract,
+      indexPrices
     );
     let block = await this.provider!.getBlockNumber();
     return OrderReferrerTool._isTradeable(order, orderPrice, markPrice, block, this.symbolToPerpStaticInfo);
   }
 
-  public async isTradeableBatch(orders: Order[]): Promise<boolean[]> {
+  /**
+   * Check for a batch of orders on the same perpetual whether they can be traded
+   * @param orders orders belonging to 1 perpetual
+   * @param indexPrice S2,S3-index prices for the given perpetual. Will fetch prices from REST API
+   * if not defined.
+   * @returns array of tradeable boolean
+   */
+  public async isTradeableBatch(orders: Order[], indexPrices?: [number, number, boolean, boolean]): Promise<boolean[]> {
     if (orders.length == 0) {
       return [];
     }
@@ -270,20 +302,31 @@ export default class OrderReferrerTool extends WriteAccessHandler {
     if (orders.filter((o) => o.symbol == orders[0].symbol).length < orders.length) {
       throw Error("all orders in a batch must have the same symbol");
     }
+    if (indexPrices == undefined) {
+      let obj = await this.priceFeedGetter.fetchPricesForPerpetual(orders[0].symbol);
+      indexPrices = [obj.idxPrices[0], obj.idxPrices[1], obj.mktClosed[0], obj.mktClosed[1]];
+    }
+    if (indexPrices[2] || indexPrices[3]) {
+      // market closed
+      return orders.map((o) => false);
+    }
+
     let orderPrice = await Promise.all(
       orders.map((o) =>
         PerpetualDataHandler._queryPerpetualPrice(
           o.symbol,
           o.quantity,
           this.symbolToPerpStaticInfo,
-          this.proxyContract!
+          this.proxyContract!,
+          [indexPrices![0], indexPrices![1]]
         )
       )
     );
     let markPrice = await PerpetualDataHandler._queryPerpetualMarkPrice(
       orders[0].symbol,
       this.symbolToPerpStaticInfo,
-      this.proxyContract
+      this.proxyContract,
+      [indexPrices![0], indexPrices![1]]
     );
     let block = await this.provider!.getBlockNumber();
     return orders.map((o, idx) =>
@@ -293,7 +336,7 @@ export default class OrderReferrerTool extends WriteAccessHandler {
 
   public static _isTradeable(
     order: Order,
-    orderPrice: number,
+    tradePrice: number,
     markPrice: number,
     block: number,
     symbolToPerpInfoMap: Map<string, PerpetualStaticInfo>
@@ -316,7 +359,7 @@ export default class OrderReferrerTool extends WriteAccessHandler {
       return false;
     }
     let limitPrice = order.limitPrice!;
-    if ((order.side == BUY_SIDE && orderPrice > limitPrice) || (order.side == SELL_SIDE && orderPrice < limitPrice)) {
+    if ((order.side == BUY_SIDE && tradePrice > limitPrice) || (order.side == SELL_SIDE && tradePrice < limitPrice)) {
       return false;
     }
     // do we need to check trigger/stop?