@d8x/perpetuals-sdk 0.0.44 → 0.0.46

package/src/d8XMath.ts

@@ -28,6 +28,24 @@ export function ABK64x64ToFloat(x: BigNumber | number): number {
   return parseFloat(NumberStr) * s;
 }
 
+/**
+ *
+ * @param {BigNumber} x BigNumber in Dec-N format
+ * @returns {number} x as a float (number)
+ */
+export function decNToFloat(x: BigNumber, numDec: number) {
+  //x: BigNumber in DecN format to float
+  const DECIMALS = BigNumber.from(10).pow(BigNumber.from(numDec));
+  let s = x.lt(0) ? -1 : 1;
+  x = x.mul(s);
+  let xInt = x.div(DECIMALS);
+  let xDec = x.sub(xInt.mul(DECIMALS));
+  let k = numDec - xDec.toString().length;
+  let sPad = "0".repeat(k);
+  let NumberStr = xInt.toString() + "." + sPad + xDec.toString();
+  return parseFloat(NumberStr) * s;
+}
+
 /**
  *
  * @param {BigNumber} x BigNumber in Dec18 format
@@ -275,26 +293,33 @@ export function getNewPositionLeverage(
   );
 }
 
-export function getMaxCollateralToRemove(
-  currentPosition: number,
-  currentLockedInValue: number,
-  currentAvailableCash: number,
-  markPrice: number,
-  indexPriceS2: number,
-  indexPriceS3: number,
-  initialMarginRate: number
-): number {
-  return (
-    getMarginRequiredForLeveragedTrade(
-      1 / initialMarginRate,
-      currentPosition,
-      currentLockedInValue,
-      0,
-      markPrice,
-      indexPriceS2,
-      indexPriceS3,
-      indexPriceS2,
-      0
-    ) - currentAvailableCash
-  );
+/**
+ * Determine amount to be deposited into margin account so that the given leverage
+ * is obtained when trading a position pos (trade amount = position)
+ * Does NOT include fees
+ * Smart contract equivalent: calcMarginForTargetLeverage(..., _ignorePosBalance = false & balance = b0)
+ * @param {number} pos0 - current position
+ * @param {number} b0 - current balance
+ * @param {number} tradeAmnt - amount to trade
+ * @param {number} targetLvg - target leverage
+ * @param {number} price - price to trade amount 'tradeAmnt'
+ * @param {number} S3 - collateral to quote conversion (=S2 if base-collateral, =1 if quote collateral, = index S3 if quanto)
+ * @param {number} S2Mark - mark price
+ * @returns {number} Amount to be deposited to have the given leverage when trading into position pos before fees
+ */
+export function getDepositAmountForLvgTrade(
+  pos0: number,
+  b0: number,
+  tradeAmnt: number,
+  targetLvg: number,
+  price: number,
+  S3: number,
+  S2Mark: number
+) {
+  let pnl = (tradeAmnt * (S2Mark - price)) / S3;
+  if (targetLvg == 0) {
+    targetLvg = (Math.abs(pos0) * S2Mark) / S3 / b0;
+  }
+  let b = (Math.abs(pos0 + tradeAmnt) * S2Mark) / S3 / targetLvg;
+  return -(b0 + pnl - b);
 }

package/src/index.ts

@@ -25,3 +25,5 @@ export {
   TraderInterface,
   PerpetualEventHandler,
 };
+
+export * from "./version";

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

@@ -5,6 +5,7 @@ import {
   calculateLiquidationPriceCollateralQuanto,
   calculateLiquidationPriceCollateralQuote,
   floatToABK64x64,
+  getDepositAmountForLvgTrade,
   getMarginRequiredForLeveragedTrade,
   getMaxSignedPositionSize,
   getNewPositionLeverage,
@@ -31,6 +32,7 @@ import {
   ZERO_ADDRESS,
 } from "./nodeSDKTypes";
 import PerpetualDataHandler from "./perpetualDataHandler";
+import PriceFeeds from "./priceFeeds";
 import { contractSymbolToSymbol, toBytes4 } from "./utils";
 
 /**
@@ -144,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);
   }
 
   /**
@@ -297,13 +299,17 @@ export default class MarketData extends PerpetualDataHandler {
     currentPositionRisk: MarginAccount,
     symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>
   ): MarginAccount {
-    let currentPosition = currentPositionRisk.positionNotionalBaseCCY;
-    let newPosition = currentPositionRisk.positionNotionalBaseCCY + tradeAmount;
-    let side = newPosition > 0 ? BUY_SIDE : newPosition < 0 ? SELL_SIDE : CLOSED_SIDE;
+    let currentSide = currentPositionRisk.side;
+    let currentPosition = (currentSide == BUY_SIDE ? 1 : -1) * currentPositionRisk.positionNotionalBaseCCY;
+    let newPosition = currentPosition + tradeAmount;
+    let newSide = newPosition > 0 ? BUY_SIDE : newPosition < 0 ? SELL_SIDE : CLOSED_SIDE;
     let lockedInValue = currentPositionRisk.entryPrice * currentPosition;
     if (tradeAmount == 0) {
       keepPositionLvg = false;
     }
+    let isOpen = newPosition != 0 && (tradeAmount == 0 || currentPosition == 0 || tradeAmount * currentPosition > 0);
+    let isFlip = Math.abs(tradeAmount) > Math.abs(currentPosition) && !isOpen;
+    let keepPositionLvgOnClose = keepPositionLvg && !isOpen;
     // need these for leverage/margin calculations
     let [markPrice, indexPriceS2, indexPriceS3] = [
       perpetualState.markPrice,
@@ -339,19 +345,26 @@ export default class MarketData extends PerpetualDataHandler {
         feeRate
       );
     } else if (tradeAmount != 0) {
-      // the order has its own leverage and margin requirements
-      let tradeCollateral = getMarginRequiredForLeveragedTrade(
-        tradeLeverage,
-        0,
-        0,
-        tradeAmount,
-        markPrice,
-        indexPriceS2,
-        indexPriceS3,
-        tradePrice,
-        feeRate
-      );
-      newCollateral = currentPositionRisk.collateralCC + tradeCollateral;
+      let depositAtTradeTime: number;
+      if (!isOpen && !isFlip && !keepPositionLvgOnClose) {
+        // no deposit from trader's wallet, but there is realized pnl
+        depositAtTradeTime = tradeAmount * (tradePrice - currentPositionRisk.entryPrice);
+      } else {
+        // target lvg will default current lvg if not specified
+        let targetLvg = isFlip || isOpen ? tradeLeverage ?? 0 : 0;
+        let b0, pos0;
+        [b0, pos0] = isOpen ? [0, 0] : [currentPositionRisk.collateralCC, currentPosition];
+        depositAtTradeTime = getDepositAmountForLvgTrade(
+          b0,
+          pos0,
+          tradeAmount,
+          targetLvg,
+          tradePrice,
+          indexPriceS2,
+          markPrice
+        );
+      }
+      newCollateral = currentPositionRisk.collateralCC + depositAtTradeTime;
       // the new leverage corresponds to increasing the position and collateral according to the order
       newLeverage = getNewPositionLeverage(
         tradeAmount,
@@ -380,7 +393,7 @@ export default class MarketData extends PerpetualDataHandler {
       );
     }
     let newLockedInValue = lockedInValue + tradeAmount * tradePrice;
-
+    let entryPrice = newPosition == 0 ? 0 : Math.abs(newLockedInValue / newPosition);
     // liquidation vars
     let S2Liq: number, S3Liq: number | undefined;
     let tau = symbolToPerpStaticInfo.get(symbol)!.maintenanceMarginRate;
@@ -401,14 +414,15 @@ export default class MarketData extends PerpetualDataHandler {
     } else {
       S2Liq = calculateLiquidationPriceCollateralQuote(newLockedInValue, newPosition, newCollateral, tau);
     }
+
     let newPositionRisk: MarginAccount = {
       symbol: currentPositionRisk.symbol,
       positionNotionalBaseCCY: Math.abs(newPosition),
-      side: side,
-      entryPrice: newPosition == 0 ? 0 : Math.abs(newLockedInValue / newPosition),
+      side: newSide,
+      entryPrice: entryPrice,
       leverage: newLeverage,
       markPrice: markPrice,
-      unrealizedPnlQuoteCCY: currentPositionRisk.unrealizedPnlQuoteCCY + tradeAmount * (markPrice - tradePrice),
+      unrealizedPnlQuoteCCY: newPosition * markPrice - newLockedInValue,
       unrealizedFundingCollateralCCY: currentPositionRisk.unrealizedFundingCollateralCCY,
       collateralCC: newCollateral,
       collToQuoteConversion: indexPriceS3,
@@ -418,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
@@ -550,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);
   }
 
   /**
@@ -577,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;
   }
@@ -627,6 +638,7 @@ export default class MarketData extends PerpetualDataHandler {
       S2Symbol: perpInfo.S2Symbol,
       S3Symbol: perpInfo.S3Symbol,
       lotSizeBC: perpInfo.lotSizeBC,
+      priceIds: perpInfo.priceIds,
     };
     return res;
   }
@@ -713,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);
@@ -746,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];
@@ -771,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;
+}