@d8x/perpetuals-sdk 0.1.12 → 0.2.0

package/src/nodeSDKTypes.ts

@@ -1,293 +0,0 @@
-import { BigNumber, BigNumberish, BytesLike, constants, ContractTransaction, ContractInterface, Bytes } from "ethers";
-
-export const ERC20_ABI = require("../abi/ERC20.json");
-export const MOCK_TOKEN_SWAP_ABI = require("../abi/MockTokenSwap.json");
-export const SYMBOL_LIST = new Map<string, string>(Object.entries(require(`../config/symbolList.json`)));
-export const COLLATERAL_CURRENCY_QUOTE = 0;
-export const COLLATERAL_CURRENCY_BASE = 1;
-export const COLLATERAL_CURRENCY_QUANTO = 2;
-export const PERP_STATE_STR = ["INVALID", "INITIALIZING", "NORMAL", "EMERGENCY", "CLEARED"];
-export const ZERO_ADDRESS = constants.AddressZero;
-export const ZERO_ORDER_ID = constants.HashZero;
-
-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));
-export const DECIMALS = BigNumber.from(10).pow(BigNumber.from(18));
-
-export const ORDER_MAX_DURATION_SEC = 60 * 60 * 24 * 30 * 4;
-
-export const MASK_CLOSE_ONLY = BigNumber.from("0x80000000");
-export const MASK_LIMIT_ORDER = BigNumber.from("0x04000000");
-export const MASK_MARKET_ORDER = BigNumber.from("0x40000000");
-export const MASK_STOP_ORDER = BigNumber.from("0x20000000");
-export const MASK_KEEP_POS_LEVERAGE = BigNumber.from("0x08000000");
-
-export const ORDER_TYPE_LIMIT = "LIMIT";
-export const ORDER_TYPE_MARKET = "MARKET";
-export const ORDER_TYPE_STOP_MARKET = "STOP_MARKET";
-export const ORDER_TYPE_STOP_LIMIT = "STOP_LIMIT";
-export const BUY_SIDE = "BUY";
-export const SELL_SIDE = "SELL";
-export const CLOSED_SIDE = "CLOSED";
-export interface NodeSDKConfig {
-  name: string | undefined;
-  chainId: number;
-  version: number;
-  nodeURL: string;
-  proxyAddr: string;
-  proxyABILocation: string;
-  limitOrderBookABILocation: string;
-  limitOrderBookFactoryABILocation: string;
-  symbolListLocation: string;
-  priceFeedConfigNetwork: string;
-  gasLimit?: number | undefined;
-  proxyABI?: ContractInterface | undefined;
-  lobFactoryABI?: ContractInterface | undefined;
-  lobABI?: ContractInterface | undefined;
-}
-
-export interface MarginAccount {
-  symbol: string;
-  positionNotionalBaseCCY: number;
-  side: string;
-  entryPrice: number;
-  leverage: number;
-  markPrice: number;
-  unrealizedPnlQuoteCCY: number;
-  unrealizedFundingCollateralCCY: number;
-  collateralCC: number;
-  liquidationPrice: [number, number | undefined];
-  liquidationLvg: number;
-  collToQuoteConversion: number;
-}
-
-export enum CollaterlCCY {
-  QUOTE = 0,
-  BASE,
-  QUANTO,
-}
-
-export interface PoolStaticInfo {
-  poolId: number;
-  poolMarginSymbol: string;
-  poolMarginTokenAddr: string;
-  shareTokenAddr: string;
-  oracleFactoryAddr: string;
-}
-
-export interface PerpetualStaticInfo {
-  id: number;
-  limitOrderBookAddr: string;
-  initialMarginRate: number;
-  maintenanceMarginRate: number;
-  collateralCurrencyType: CollaterlCCY;
-  S2Symbol: string;
-  S3Symbol: string;
-  lotSizeBC: number;
-  referralRebate: number;
-  priceIds: string[];
-}
-
-/**
- * @global
- * @typedef {Object} ExchangeInfo
- * @property {PoolState[]} pools Array of state objects for all pools in the exchange.
- * @property {string} oracleFactoryAddr Address of the oracle factory used by the pools in the exchange.
- */
-export interface ExchangeInfo {
-  pools: PoolState[];
-  oracleFactoryAddr: string;
-  proxyAddr: string;
-}
-
-/**
- * @global
- * @typedef {Object} PoolState
- * @property {boolean} isRunning True if the pool is running.
- * @property {string} marginTokenAddr  Address of the token used by the pool.
- * This is the token used for margin deposits, liquidity provision, and trading fees.
- * @property {string} poolShareTokenAddr Address of the pool share token.
- * This is the token issued to external liquidity providers.
- * @property {number} defaultFundCashCC Amount of cash in the default fund of this pool, denominated in margin tokens.
- * @property {number} pnlParticipantCashCC Amount of cash in the PnL participation pool, i.e. cash deposited by external liquidity providers.
- * @property {number} totalAMMFundCashCC Amount of cash aggregated across all perpetual AMM funds in this pool.
- * @property {number} totalTargetAMMFundSizeCC Target AMM funds aggregated across all perpetuals in this pool.
- * @property {number} brokerCollateralLotSize Price of one lot for brokers who wish to participate in this pool. Denominated in margin tokens.
- * @property {PerpetualState[]} perpetuals Array of all perpetuals in this pool.
- */
-export interface PoolState {
-  isRunning: boolean;
-  poolSymbol: string;
-  marginTokenAddr: string;
-  poolShareTokenAddr: string;
-  defaultFundCashCC: number;
-  pnlParticipantCashCC: number;
-  totalAMMFundCashCC: number;
-  totalTargetAMMFundSizeCC: number;
-  brokerCollateralLotSize: number;
-  perpetuals: PerpetualState[];
-}
-
-export interface PerpetualState {
-  id: number;
-  state: string;
-  baseCurrency: string;
-  quoteCurrency: string;
-  indexPrice: number;
-  collToQuoteIndexPrice: number;
-  markPrice: number;
-  midPrice: number;
-  currentFundingRateBps: number;
-  openInterestBC: number;
-  isMarketClosed: boolean;
-}
-
-export interface OrderResponse {
-  tx: ContractTransaction;
-  orderId: string;
-}
-
-export interface OrderStruct {
-  orders: Order[];
-  orderIds: string[];
-}
-
-export interface Order {
-  symbol: string; //symbol of the form ETH-USD-MATIC
-  side: string;
-  type: string;
-  quantity: number;
-  reduceOnly?: boolean | undefined;
-  limitPrice?: number | undefined;
-  keepPositionLvg?: boolean | undefined;
-  brokerFeeTbps?: number | undefined;
-  brokerAddr?: string | undefined;
-  brokerSignature?: BytesLike | undefined;
-  stopPrice?: number | undefined;
-  leverage?: number | undefined;
-  deadline?: number | undefined;
-  timestamp: number;
-  submittedBlock?: number;
-  parentChildOrderIds?: [string, string];
-}
-
-export interface TradeEvent {
-  perpetualId: number;
-  positionId: string;
-  orderId: string;
-  newPositionSizeBC: number;
-  executionPrice: number;
-}
-
-/**
- *     struct Order {
-        uint32 flags;
-        uint24 iPerpetualId;
-        uint16 brokerFeeTbps;
-        address traderAddr;
-        address brokerAddr;
-        address referrerAddr;
-        bytes brokerSignature;
-        int128 fAmount;
-        int128 fLimitPrice;
-        int128 fTriggerPrice;
-        int128 fLeverage; // 0 if deposit and trade separate
-        uint64 iDeadline;
-        uint64 createdTimestamp;
-        uint64 submittedBlock;
-    }
- */
-export interface SmartContractOrder {
-  flags: BigNumberish;
-  iPerpetualId: BigNumberish;
-  brokerFeeTbps: BigNumberish;
-  traderAddr: string;
-  brokerAddr: string;
-  referrerAddr: string;
-  brokerSignature: BytesLike;
-  fAmount: BigNumberish;
-  fLimitPrice: BigNumberish;
-  fTriggerPrice: BigNumberish;
-  fLeverage: BigNumberish;
-  iDeadline: BigNumberish;
-  createdTimestamp: BigNumberish;
-  submittedBlock: BigNumberish;
-}
-
-/**
- *     struct ClientOrder {
-        uint32 flags;
-        uint24 iPerpetualId;
-        uint16 brokerFeeTbps;
-        address traderAddr;
-        address brokerAddr;
-        address referrerAddr;
-        bytes brokerSignature;
-        int128 fAmount;
-        int128 fLimitPrice;
-        int128 fTriggerPrice;
-        int128 fLeverage; // 0 if deposit and trade separate
-        uint64 iDeadline;
-        uint64 createdTimestamp;
-        //uint64 submittedBlock <- will be set by LimitOrderBook
-        bytes32 parentChildDigest1;
-        bytes32 parentChildDigest2;
-    }
- */
-export interface ClientOrder {
-  flags: BigNumberish;
-  iPerpetualId: BigNumberish;
-  brokerFeeTbps: BigNumberish;
-  traderAddr: string;
-  brokerAddr: string;
-  referrerAddr: string;
-  brokerSignature: BytesLike;
-  fAmount: BigNumberish;
-  fLimitPrice: BigNumberish;
-  fTriggerPrice: BigNumberish;
-  fLeverage: BigNumberish;
-  iDeadline: BigNumberish;
-  createdTimestamp: BigNumberish;
-  parentChildDigest1: string;
-  parentChildDigest2: string;
-}
-
-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;
-}
-
-export const DEFAULT_CONFIG_MAINNET_NAME = "mainnet";
-export const DEFAULT_CONFIG_TESTNET_NAME = "central-park";
-
-export async function loadABIs(config: NodeSDKConfig) {
-  if (config.proxyABILocation.length > 0) {
-    config.proxyABI = require(`../abi/${config.proxyABILocation}`);
-    config.lobFactoryABI = require(`../abi/${config.limitOrderBookFactoryABILocation}`);
-    config.lobABI = require(`../abi/${config.limitOrderBookABILocation}`);
-  }
-}
-
-const constConfig = require("../config/defaultConfig.json");
-for (let config of constConfig) {
-  loadABIs(config);
-}
-
-export const DEFAULT_CONFIG: NodeSDKConfig[] = constConfig;

package/src/orderReferrerTool.ts

@@ -1,389 +0,0 @@
-import { BigNumber, ethers } from "ethers";
-import {
-  BUY_SIDE,
-  NodeSDKConfig,
-  Order,
-  PerpetualStaticInfo,
-  SELL_SIDE,
-  ZERO_ADDRESS,
-  ZERO_ORDER_ID,
-  PriceFeedSubmission,
-  ClientOrder,
-  SmartContractOrder,
-} from "./nodeSDKTypes";
-import PerpetualDataHandler from "./perpetualDataHandler";
-import WriteAccessHandler from "./writeAccessHandler";
-
-/**
- * Functions to execute existing conditional orders from the limit order book. This class
- * requires a private key and executes smart-contract interactions that require
- * gas-payments.
- * @extends WriteAccessHandler
- */
-export default class OrderReferrerTool extends WriteAccessHandler {
-  static BLOCK_DELAY = 2;
-  /**
-   * Constructor.
-   * @param {NodeSDKConfig} config Configuration object, see PerpetualDataHandler.readSDKConfig.
-   * @example
-   * import { OrderReferrerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
-   * async function main() {
-   *   console.log(OrderReferrerTool);
-   *   // load configuration for testnet
-   *   const config = PerpetualDataHandler.readSDKConfig("testnet");
-   *   // OrderReferrerTool (authentication required, PK is an environment variable with a private key)
-   *   const pk: string = <string>process.env.PK;
-   *   let orderTool = new OrderReferrerTool(config, pk);
-   *   // Create a proxy instance to access the blockchain
-   *   await orderTool.createProxyInstance();
-   * }
-   * main();
-   *
-   * @param {string} privateKey Private key of the wallet that executes the conditional orders.
-   */
-  public constructor(config: NodeSDKConfig, privateKey: string) {
-    super(config, privateKey);
-  }
-
-  /**
-   * 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 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() {
-   *   console.log(OrderReferrerTool);
-   *   // Setup (authentication required, PK is an environment variable with a private key)
-   *   const config = PerpetualDataHandler.readSDKConfig("testnet");
-   *   const pk: string = <string>process.env.PK;
-   *   const symbol = "ETH-USD-MATIC";
-   *   let orderTool = new OrderReferrerTool(config, pk);
-   *   await orderTool.createProxyInstance();
-   *   // get some open orders
-   *   const maxOrdersToGet = 5;
-   *   let [orders, ids]: [Order[], string[]] = await orderTool.pollLimitOrders(symbol, maxOrdersToGet);
-   *   console.log(`Got ${ids.length} orders`);
-   *   for (let k = 0; k < ids.length; k++) {
-   *     // check whether order meets conditions
-   *     let doExecute = await orderTool.isTradeable(orders[k]);
-   *     if (doExecute) {
-   *       // execute
-   *       let tx = await orderTool.executeOrder(symbol, ids[k]);
-   *       console.log(`Sent order id ${ids[k]} for execution, tx hash = ${tx.hash}`);
-   *     }
-   *   }
-   * }
-   * main();
-   * @returns Transaction object.
-   */
-  public async executeOrder(
-    symbol: string,
-    orderId: string,
-    referrerAddr?: string,
-    nonce?: number,
-    submission?: PriceFeedSubmission
-  ): Promise<ethers.ContractTransaction> {
-    if (this.proxyContract == null || this.signer == null) {
-      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
-    }
-    const orderBookSC = this.getOrderBookContract(symbol);
-    if (typeof referrerAddr == "undefined") {
-      referrerAddr = this.traderAddr;
-    }
-    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,
-    };
-    return await orderBookSC.executeOrder(
-      orderId,
-      referrerAddr,
-      submission?.priceFeedVaas,
-      submission?.timestamps,
-      options
-    );
-  }
-
-  /**
-   * All the orders in the order book for a given symbol that are currently open.
-   * @param {string} symbol Symbol of the form ETH-USD-MATIC.
-   * @example
-   * import { OrderReferrerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
-   * async function main() {
-   *   console.log(OrderReferrerTool);
-   *   // setup (authentication required, PK is an environment variable with a private key)
-   *   const config = PerpetualDataHandler.readSDKConfig("testnet");
-   *   const pk: string = <string>process.env.PK;
-   *   let orderTool = new OrderReferrerTool(config, pk);
-   *   await orderTool.createProxyInstance();
-   *   // get all open orders
-   *   let openOrders = await orderTool.getAllOpenOrders("ETH-USD-MATIC");
-   *   console.log(openOrders);
-   * }
-   * main();
-   *
-   * @returns Array with all open orders and their IDs.
-   */
-  public async getAllOpenOrders(symbol: string): Promise<[Order[], string[]]> {
-    let totalOrders = await this.numberOfOpenOrders(symbol);
-    return await this.pollLimitOrders(symbol, totalOrders);
-  }
-
-  /**
-   * Total number of limit orders for this symbol, excluding those that have been cancelled/removed.
-   * @param {string} symbol Symbol of the form ETH-USD-MATIC.
-   * @example
-   * import { OrderReferrerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
-   * async function main() {
-   *   console.log(OrderReferrerTool);
-   *   // setup (authentication required, PK is an environment variable with a private key)
-   *   const config = PerpetualDataHandler.readSDKConfig("testnet");
-   *   const pk: string = <string>process.env.PK;
-   *   let orderTool = new OrderReferrerTool(config, pk);
-   *   await orderTool.createProxyInstance();
-   *   // get all open orders
-   *   let numberOfOrders = await orderTool.numberOfOpenOrders("ETH-USD-MATIC");
-   *   console.log(numberOfOrders);
-   * }
-   * main();
-   *
-   * @returns {number} Number of open orders.
-   */
-  public async numberOfOpenOrders(symbol: string): Promise<number> {
-    if (this.proxyContract == null) {
-      throw Error("no proxy contract initialized. Use createProxyInstance().");
-    }
-    const orderBookSC = this.getOrderBookContract(symbol);
-    let numOrders = await orderBookSC.numberOfOrderBookDigests();
-    return Number(numOrders);
-  }
-
-  /**
-   * Get order from the digest (=id)
-   * @param symbol symbol of order book, e.g. ETH-USD-MATIC
-   * @param digest digest of the order (=order ID)
-   * @example
-   * import { OrderReferrerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
-   * async function main() {
-   *   console.log(OrderReferrerTool);
-   *   // setup (authentication required, PK is an environment variable with a private key)
-   *   const config = PerpetualDataHandler.readSDKConfig("testnet");
-   *   const pk: string = <string>process.env.PK;
-   *   let orderTool = new OrderReferrerTool(config, pk);
-   *   await orderTool.createProxyInstance();
-   *   // get order by ID
-   *   let myorder = await orderTool.getOrderById("MATIC-USD-MATIC",
-   *       "0x0091a1d878491479afd09448966c1403e9d8753122e25260d3b2b9688d946eae");
-   *   console.log(myorder);
-   * }
-   * main();
-   *
-   * @returns order or undefined
-   */
-  public async getOrderById(symbol: string, id: string): Promise<Order | undefined> {
-    let ob = await this.getOrderBookContract(symbol);
-    let smartContractOrder: SmartContractOrder = await ob.orderOfDigest(id);
-    if (smartContractOrder.traderAddr == ZERO_ADDRESS) {
-      return undefined;
-    }
-    let order = OrderReferrerTool.fromSmartContractOrder(smartContractOrder, this.symbolToPerpStaticInfo);
-    return order;
-  }
-
-  /**
-   * Get a list of active conditional orders in the order book.
-   * This a read-only action and does not incur in gas costs.
-   * @param {string} symbol Symbol of the form ETH-USD-MATIC.
-   * @param {number} numElements Maximum number of orders to poll.
-   * @param {string=} startAfter Optional order ID from where to start polling. Defaults to the first order.
-   * @example
-   * import { OrderReferrerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
-   * async function main() {
-   *   console.log(OrderReferrerTool);
-   *   // setup (authentication required, PK is an environment variable with a private key)
-   *   const config = PerpetualDataHandler.readSDKConfig("testnet");
-   *   const pk: string = <string>process.env.PK;
-   *   let orderTool = new OrderReferrerTool(config, pk);
-   *   await orderTool.createProxyInstance();
-   *   // get all open orders
-   *   let activeOrders = await orderTool.pollLimitOrders("ETH-USD-MATIC", 2);
-   *   console.log(activeOrders);
-   * }
-   * main();
-   *
-   * @returns Array of orders and corresponding order IDs
-   */
-  public async pollLimitOrders(symbol: string, numElements: number, startAfter?: string): Promise<[Order[], string[]]> {
-    if (this.proxyContract == null) {
-      throw Error("no proxy contract initialized. Use createProxyInstance().");
-    }
-    const orderBookSC = this.getOrderBookContract(symbol);
-    if (typeof startAfter == "undefined") {
-      startAfter = ZERO_ORDER_ID;
-    }
-    let orders: ClientOrder[];
-    let orderIds: string[];
-    [orders, orderIds] = await orderBookSC.pollLimitOrders(startAfter, BigNumber.from(numElements));
-    let userFriendlyOrders: Order[] = new Array<Order>();
-    let orderIdsOut = [];
-    let k = 0;
-    while (k < orders.length && orders[k].traderAddr != ZERO_ADDRESS) {
-      userFriendlyOrders.push(WriteAccessHandler.fromClientOrder(orders[k], this.symbolToPerpStaticInfo));
-      orderIdsOut.push(orderIds[k]);
-      k++;
-    }
-    return [userFriendlyOrders, orderIdsOut];
-  }
-
-  /**
-   * 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() {
-   *   console.log(OrderReferrerTool);
-   *   // setup (authentication required, PK is an environment variable with a private key)
-   *   const config = PerpetualDataHandler.readSDKConfig("testnet");
-   *   const pk: string = <string>process.env.PK;
-   *   let orderTool = new OrderReferrerTool(config, pk);
-   *   await orderTool.createProxyInstance();
-   *   // check if tradeable
-   *   let openOrders = await orderTool.getAllOpenOrders("MATIC-USD-MATIC");
-   *   let check = await orderTool.isTradeable(openOrders[0][0]);
-   *   console.log(check);
-   * }
-   * main();
-   * @returns true if order can be executed for the current state of the perpetuals
-   */
-  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,
-      indexPrices
-    );
-    let markPrice = await PerpetualDataHandler._queryPerpetualMarkPrice(
-      order.symbol,
-      this.symbolToPerpStaticInfo,
-      this.proxyContract,
-      indexPrices
-    );
-    let block = await this.provider!.getBlockNumber();
-    return OrderReferrerTool._isTradeable(order, orderPrice, markPrice, block, this.symbolToPerpStaticInfo);
-  }
-
-  /**
-   * 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 [];
-    }
-    if (this.proxyContract == null) {
-      throw Error("no proxy contract initialized. Use createProxyInstance().");
-    }
-    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!,
-          [indexPrices![0], indexPrices![1]]
-        )
-      )
-    );
-    let markPrice = await PerpetualDataHandler._queryPerpetualMarkPrice(
-      orders[0].symbol,
-      this.symbolToPerpStaticInfo,
-      this.proxyContract,
-      [indexPrices![0], indexPrices![1]]
-    );
-    let block = await this.provider!.getBlockNumber();
-    return orders.map((o, idx) =>
-      OrderReferrerTool._isTradeable(o, orderPrice[idx], markPrice, block, this.symbolToPerpStaticInfo)
-    );
-  }
-
-  public static _isTradeable(
-    order: Order,
-    tradePrice: number,
-    markPrice: number,
-    block: number,
-    symbolToPerpInfoMap: Map<string, PerpetualStaticInfo>
-  ): boolean {
-    // check expiration date
-    if (order.deadline != undefined && order.deadline < Date.now() / 1000) {
-      return false;
-    }
-
-    if (order.submittedBlock == undefined || order.submittedBlock + this.BLOCK_DELAY > block) {
-      return false;
-    }
-
-    // check order size
-    if (order.quantity < PerpetualDataHandler._getLotSize(order.symbol, symbolToPerpInfoMap)) {
-      return false;
-    }
-    // check limit price: fromSmartContractOrder will set it to undefined when not tradeable
-    if (order.limitPrice == undefined) {
-      return false;
-    }
-    let limitPrice = order.limitPrice!;
-    if ((order.side == BUY_SIDE && tradePrice > limitPrice) || (order.side == SELL_SIDE && tradePrice < limitPrice)) {
-      return false;
-    }
-    // do we need to check trigger/stop?
-    if (order.stopPrice == undefined) {
-      // nothing to check, order is tradeable
-      return true;
-    }
-    if (
-      (order.side == BUY_SIDE && markPrice < order.stopPrice) ||
-      (order.side == SELL_SIDE && markPrice > order.stopPrice)
-    ) {
-      return false;
-    }
-    // all checks passed -> order is tradeable
-    return true;
-  }
-
-  public async getTransactionCount(blockTag?: ethers.providers.BlockTag): Promise<number> {
-    if (this.signer == null) {
-      throw Error("no wallet initialized. Use createProxyInstance().");
-    }
-    return await this.signer.getTransactionCount(blockTag);
-  }
-}