@d8x/perpetuals-sdk 0.8.0 → 0.8.2

package/src/marketData.ts

@@ -2,7 +2,7 @@ import { BigNumber } from "@ethersproject/bignumber";
 import { CallOverrides, Contract } from "@ethersproject/contracts";
 import { Provider, StaticJsonRpcProvider } from "@ethersproject/providers";
 import { formatUnits } from "@ethersproject/units";
-import { ERC20__factory, LimitOrderBook } from "./contracts";
+import { ERC20__factory, LimitOrderBook, Multicall3 } from "./contracts";
 import { IClientOrder } from "./contracts/LimitOrderBook";
 import {
   ABK64x64ToFloat,
@@ -33,6 +33,7 @@ import {
   SELL_SIDE,
   SmartContractOrder,
   ZERO_ADDRESS,
+  ZERO_ORDER_ID,
 } from "./nodeSDKTypes";
 import PerpetualDataHandler from "./perpetualDataHandler";
 import PriceFeeds from "./priceFeeds";
@@ -190,9 +191,13 @@ export default class MarketData extends PerpetualDataHandler {
     // open orders requested only for given symbol
     let resArray: Array<{ orders: Order[]; orderIds: string[] }> = [];
     const symbols = symbol.split("-").length == 1 ? this.getPerpetualSymbolsInPool(symbol) : [symbol];
-    for (let k = 0; k < symbols.length; k++) {
-      let res = await this._openOrdersOfPerpetual(traderAddr, symbols[k], overrides);
+    if (symbols.length < 1) {
+      throw new Error(`No perpetuals found for symbol ${symbol}`);
+    } else if (symbols.length < 2) {
+      let res = await this._openOrdersOfPerpetual(traderAddr, symbols[0], overrides);
       resArray.push(res!);
+    } else {
+      resArray = await this._openOrdersOfPerpetuals(traderAddr, symbols, overrides);
     }
     return resArray;
   }
@@ -215,6 +220,24 @@ export default class MarketData extends PerpetualDataHandler {
     return { orders: orders, orderIds: digests };
   }
 
+  /**
+   * All open orders for a trader-address and a given perpetual symbol.
+   * @param {string} traderAddr Address of the trader for which we get the open orders.
+   * @param {string} symbol perpetual-symbol of the form ETH-USD-MATIC
+   * @returns open orders and order ids
+   */
+  private async _openOrdersOfPerpetuals(
+    traderAddr: string,
+    symbols: string[],
+    overrides?: CallOverrides
+  ): Promise<{ orders: Order[]; orderIds: string[] }[]> {
+    // open orders requested only for given symbol
+    const orderBookContracts = symbols.map((symbol) => this.getOrderBookContract(symbol));
+    const orders = await this._openOrdersOnOrderBooks(traderAddr, orderBookContracts, overrides);
+    const digests = await this._orderIdsOfTrader(traderAddr, orderBookContracts, overrides);
+    return symbols.map((_symbol, i) => ({ orders: orders[i], orderIds: digests[i] }));
+  }
+
   /**
    * Information about the position open by a given trader in a given perpetual contract, or
    * for all perpetuals in a pool
@@ -243,9 +266,13 @@ export default class MarketData extends PerpetualDataHandler {
     }
     let resArray: Array<MarginAccount> = [];
     let symbols = symbol.split("-").length == 1 ? this.getPerpetualSymbolsInPool(symbol) : [symbol];
-    for (let k = 0; k < symbols.length; k++) {
-      let res = await this._positionRiskForTraderInPerpetual(traderAddr, symbols[k], overrides);
+    if (symbols.length < 1) {
+      throw new Error(`No perpetuals found for symbol ${symbol}`);
+    } else if (symbols.length < 2) {
+      let res = await this._positionRiskForTraderInPerpetual(traderAddr, symbols[0], overrides);
       resArray.push(res!);
+    } else {
+      resArray = await this._positionRiskForTraderInPerpetuals(traderAddr, symbols, overrides);
     }
     return resArray;
   }
@@ -256,7 +283,7 @@ export default class MarketData extends PerpetualDataHandler {
    * @param {string} symbol perpetual symbol of the form ETH-USD-MATIC
    * @returns MarginAccount struct for the trader
    */
-  private async _positionRiskForTraderInPerpetual(
+  protected async _positionRiskForTraderInPerpetual(
     traderAddr: string,
     symbol: string,
     overrides?: CallOverrides
@@ -273,6 +300,35 @@ export default class MarketData extends PerpetualDataHandler {
     return mgnAcct;
   }
 
+  /**
+   * Information about the position open by a given trader in a given perpetual contract.
+   * @param {string} traderAddr Address of the trader for which we get the position risk.
+   * @param {string} symbol perpetual symbol of the form ETH-USD-MATIC
+   * @returns MarginAccount struct for the trader
+   */
+  protected async _positionRiskForTraderInPerpetuals(
+    traderAddr: string,
+    symbols: string[],
+    overrides?: CallOverrides
+  ): Promise<MarginAccount[]> {
+    let S2S3 = await Promise.all(
+      symbols.map(async (symbol) => {
+        let obj = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
+        return [obj.idxPrices[0], obj.idxPrices[1]];
+      })
+    );
+    let mgnAcct = await PerpetualDataHandler.getMarginAccounts(
+      Array(symbols.length).fill(traderAddr),
+      symbols,
+      this.symbolToPerpStaticInfo,
+      this.multicall!,
+      this.proxyContract!,
+      S2S3,
+      overrides
+    );
+    return mgnAcct;
+  }
+
   /**
    * Estimates what the position risk will be if a given order is executed.
    * @param traderAddr Address of trader
@@ -971,6 +1027,105 @@ export default class MarketData extends PerpetualDataHandler {
     return userFriendlyOrders;
   }
 
+  /**
+   * Query smart contract to get user orders and convert to user friendly order format.
+   * @param {string} traderAddr Address of trader.
+   * @param {ethers.Contract} orderBookContract Instance of order book.
+   * @returns {Order[]} Array of user friendly order struct.
+   * @ignore
+   */
+  protected async _openOrdersOnOrderBooks(
+    traderAddr: string,
+    orderBookContracts: LimitOrderBook[],
+    overrides?: CallOverrides
+  ): Promise<Order[][]> {
+    // eliminate empty orders and map to user friendly orders
+    const numOBs = orderBookContracts.length;
+
+    let userFriendlyOrders = new Array(numOBs).fill(0).map(() => new Array<Order>());
+
+    let haveMoreOrders = new Array(numOBs).fill(true);
+    let from = new Array(numOBs).fill(0);
+    const bulkSize = 15;
+
+    while (haveMoreOrders.some((x) => x)) {
+      // filter by books with some orders left
+      const contracts = orderBookContracts.filter((_c, i) => haveMoreOrders[i]);
+      // prepare calls
+      const ordersCalls: Multicall3.Call3Struct[] = contracts.map((c, i) => ({
+        target: c.address,
+        allowFailure: true,
+        callData: c.interface.encodeFunctionData("getOrders", [traderAddr, from[i], bulkSize]),
+      }));
+      // call
+      const encodedOrders = await this.multicall!.callStatic.aggregate3(ordersCalls, overrides || {});
+      // parse
+      const allOrders: IClientOrder.ClientOrderStructOutput[][] = encodedOrders.map(({ success, returnData }, i) => {
+        if (!success) throw new Error(`Failed to get orders for order book ${contracts[i].address}`);
+        return contracts[i].interface.decodeFunctionResult("getOrders", returnData)[0];
+      });
+      // arrange
+      for (let j = 0; j < contracts.length; j++) {
+        let orders = allOrders[j].filter((o) => o.traderAddr != ZERO_ADDRESS);
+        let i = orderBookContracts.findIndex((c) => c.address == contracts[j].address);
+        let k = 0;
+        while (k < orders.length && orders[k].traderAddr != ZERO_ADDRESS) {
+          userFriendlyOrders[i].push(PerpetualDataHandler.fromClientOrder(orders[k], this.symbolToPerpStaticInfo));
+          k++;
+        }
+        haveMoreOrders[i] = orders.length > 0 && orders[orders.length - 1].traderAddr != ZERO_ADDRESS;
+        from[i] = from[i] + bulkSize;
+      }
+    }
+    return userFriendlyOrders;
+  }
+
+  protected async _orderIdsOfTrader(
+    traderAddr: string,
+    orderBookContracts: LimitOrderBook[],
+    overrides?: CallOverrides
+  ): Promise<string[][]> {
+    // eliminate empty orders and map to user friendly orders
+    const numOBs = orderBookContracts.length;
+
+    let orderDigests = new Array(numOBs).fill(0).map(() => new Array<string>());
+
+    let haveMoreOrders = new Array(numOBs).fill(true);
+    let from = new Array(numOBs).fill(0);
+    const bulkSize = 15;
+
+    while (haveMoreOrders.some((x) => x)) {
+      // filter by books with some orders left
+      const contracts = orderBookContracts.filter((_c, i) => haveMoreOrders[i]);
+      // prepare alls
+      const digestsCalls: Multicall3.Call3Struct[] = contracts.map((c, i) => ({
+        target: c.address,
+        allowFailure: true,
+        callData: c.interface.encodeFunctionData("limitDigestsOfTrader", [traderAddr, from[i], bulkSize]),
+      }));
+      // call
+      const encodedDigests = await this.multicall!.callStatic.aggregate3(digestsCalls, overrides || {});
+      // parse
+      const allDigests: string[][] = encodedDigests.map(({ success, returnData }, i) => {
+        if (!success) throw new Error(`Failed to get orders for order book ${contracts[i].address}`);
+        return contracts[i].interface.decodeFunctionResult("limitDigestsOfTrader", returnData)[0];
+      });
+      // arrange
+      for (let j = 0; j < contracts.length; j++) {
+        let digests = allDigests[j].filter((d) => d != ZERO_ORDER_ID);
+        let i = orderBookContracts.findIndex((c) => c.address == contracts[j].address);
+        let k = 0;
+        while (k < digests.length && digests[k] != ZERO_ORDER_ID) {
+          orderDigests[i].push(digests[k]);
+          k++;
+        }
+        haveMoreOrders[i] = digests.length > 0 && digests[digests.length - 1] != ZERO_ORDER_ID;
+        from[i] = from[i] + bulkSize;
+      }
+    }
+    return orderDigests;
+  }
+
   /**
    *
    * @param traderAddr Address of the trader
@@ -1286,8 +1441,7 @@ export default class MarketData extends PerpetualDataHandler {
       overrides
     );
     // put together all info
-    for (let k = 0; k < perpStateInfos.length; k++) {
-      const perp = perpStateInfos[k];
+    for (const perp of perpStateInfos) {
       let symbol3s = _perpetualIdToSymbol.get(perp.id);
       let info = _symbolToPerpStaticInfo.get(symbol3s!);
       const idxPriceS2Pair = idxPriceMap.get(info!.S2Symbol);

package/src/nodeSDKTypes.ts

@@ -12,7 +12,7 @@ export const COLLATERAL_CURRENCY_QUANTO = 2;
 export const PERP_STATE_STR = ["INVALID", "INITIALIZING", "NORMAL", "EMERGENCY", "CLEARED"];
 export const ZERO_ADDRESS = AddressZero;
 export const ZERO_ORDER_ID = HashZero;
-
+export const MULTICALL_ADDRESS = "0xcA11bde05977b3631167028862bE2a173976CA11";
 export const ONE_64x64 = BigNumber.from("0x010000000000000000");
 export const MAX_64x64 = BigNumber.from("0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
 export const MAX_UINT_256 = BigNumber.from(2).pow(256).sub(BigNumber.from(1));

package/src/perpetualDataHandler.ts

@@ -12,6 +12,8 @@ import {
   LimitOrderBookFactory,
   LimitOrderBookFactory__factory,
   LimitOrderBook__factory,
+  Multicall3,
+  Multicall3__factory,
 } from "./contracts";
 import { IPerpetualOrder } from "./contracts/IPerpetualManager";
 import { IClientOrder } from "./contracts/LimitOrderBook";
@@ -40,6 +42,7 @@ import {
   MASK_MARKET_ORDER,
   MASK_STOP_ORDER,
   MAX_64x64,
+  MULTICALL_ADDRESS,
   NodeSDKConfig,
   Order,
   ORDER_MAX_DURATION_SEC,
@@ -86,7 +89,11 @@ export default class PerpetualDataHandler {
   protected lobFactoryABI: ContractInterface;
   protected lobFactoryAddr: string | undefined;
   protected lobABI: ContractInterface;
+  // share token
   protected shareTokenABI: ContractInterface;
+  // multicall
+  protected multicall: Multicall3 | null = null;
+  // provider
   protected nodeURL: string;
   protected provider: Provider | null = null;
 
@@ -133,9 +140,9 @@ export default class PerpetualDataHandler {
       throw new Error(`Provider: chain id ${network.chainId} does not match config (${this.chainId})`);
     }
     this.proxyContract = IPerpetualManager__factory.connect(this.proxyAddr, signerOrProvider);
-
     this.lobFactoryAddr = await this.proxyContract.getOrderBookFactoryAddress(overrides || {});
     this.lobFactoryContract = LimitOrderBookFactory__factory.connect(this.lobFactoryAddr, signerOrProvider);
+    this.multicall = Multicall3__factory.connect(MULTICALL_ADDRESS, this.signerOrProvider);
     await this._fillSymbolMaps(overrides);
   }
 
@@ -516,6 +523,16 @@ export default class PerpetualDataHandler {
     return mgn;
   }
 
+  /**
+   * Get trader state from the blockchain and parse into a human-readable margin account
+   * @param traderAddr Trader address
+   * @param symbol Perpetual symbol
+   * @param symbolToPerpStaticInfo Symbol to perp static info mapping
+   * @param _proxyContract Proxy contract instance
+   * @param _pxS2S3 Prices [S2, S3]
+   * @param overrides Optional overrides for eth_call
+   * @returns A Margin account
+   */
   public static async getMarginAccount(
     traderAddr: string,
     symbol: string,
@@ -537,6 +554,55 @@ export default class PerpetualDataHandler {
     return PerpetualDataHandler.buildMarginAccountFromState(symbol, traderState, symbolToPerpStaticInfo, _pxS2S3);
   }
 
+  /**
+   * Get trader states from the blockchain and parse into a list of human-readable margin accounts
+   * @param traderAddrs List of trader addresses
+   * @param symbols List of symbols
+   * @param symbolToPerpStaticInfo Symbol to perp static info mapping
+   * @param _multicall Multicall3 contract instance
+   * @param _proxyContract Proxy contract instance
+   * @param _pxS2S3s  List of price pairs, [[S2, S3] (1st perp), [S2, S3] (2nd perp), ... ]
+   * @param overrides Optional eth_call overrides
+   * @returns List of margin accounts
+   */
+  public static async getMarginAccounts(
+    traderAddrs: string[],
+    symbols: string[],
+    symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>,
+    _multicall: Multicall3,
+    _proxyContract: IPerpetualManager,
+    _pxS2S3s: number[][],
+    overrides?: CallOverrides
+  ): Promise<MarginAccount[]> {
+    if (
+      traderAddrs.length != symbols.length ||
+      traderAddrs.length != _pxS2S3s.length ||
+      symbols.length != _pxS2S3s.length
+    ) {
+      throw new Error("traderAddr, symbol and pxS2S3 should all have the same length");
+    }
+    const proxyCalls: Multicall3.Call3Struct[] = traderAddrs.map((_addr, i) => ({
+      target: _proxyContract.address,
+      allowFailure: true,
+      callData: _proxyContract.interface.encodeFunctionData("getTraderState", [
+        PerpetualDataHandler.symbolToPerpetualId(symbols[i], symbolToPerpStaticInfo),
+        _addr,
+        _pxS2S3s[i].map((x) => floatToABK64x64(x)) as [BigNumber, BigNumber],
+      ]),
+    }));
+    const encodedResults = await _multicall.callStatic.aggregate3(proxyCalls, overrides || {});
+    const traderStates: BigNumber[][] = encodedResults.map(({ success, returnData }, i) => {
+      if (!success) throw new Error(`Failed to get perp info for ${symbols[i]}`);
+      return _proxyContract.interface.decodeFunctionResult("getTraderState", returnData)[0];
+    });
+    return traderStates.map((traderState, i) =>
+      PerpetualDataHandler.buildMarginAccountFromState(symbols[i], traderState, symbolToPerpStaticInfo, [
+        _pxS2S3s[i][0],
+        _pxS2S3s[i][1],
+      ])
+    );
+  }
+
   protected static async _queryPerpetualPrice(
     symbol: string,
     tradeAmount: number,
@@ -579,7 +645,6 @@ export default class PerpetualDataHandler {
   ): Promise<PerpetualState> {
     let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
     let staticInfo = symbolToPerpStaticInfo.get(symbol)!;
-    let ccy = symbol.split("-");
     let [S2, S3] = [indexPrices[0], indexPrices[1]];
     if (staticInfo.collateralCurrencyType == CollaterlCCY.BASE) {
       S3 = S2;
@@ -591,6 +656,24 @@ export default class PerpetualDataHandler {
       [S2, S3].map(floatToABK64x64) as [BigNumber, BigNumber],
       overrides || {}
     );
+    return PerpetualDataHandler._parseAMMState(symbol, ammState, indexPrices, symbolToPerpStaticInfo);
+  }
+
+  protected static _parseAMMState(
+    symbol: string,
+    ammState: BigNumber[],
+    indexPrices: [number, number, boolean, boolean],
+    symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>
+  ) {
+    let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+    let staticInfo = symbolToPerpStaticInfo.get(symbol)!;
+    let ccy = symbol.split("-");
+    let [S2, S3] = [indexPrices[0], indexPrices[1]];
+    if (staticInfo.collateralCurrencyType == CollaterlCCY.BASE) {
+      S3 = S2;
+    } else if (staticInfo.collateralCurrencyType == CollaterlCCY.QUOTE) {
+      S3 = 1;
+    }
     let markPrice = S2 * (1 + ABK64x64ToFloat(ammState[8]));
     let state: PerpetualState = {
       id: perpId,

package/src/version.ts

@@ -1 +1 @@
-export const D8X_SDK_VERSION = "0.8.0";
+export const D8X_SDK_VERSION = "0.8.2";