@d8x/perpetuals-sdk 0.1.12 → 0.2.0

package/src/priceFeeds.ts

@@ -1,381 +0,0 @@
-import { BigNumber } from "ethers";
-import PerpetualDataHandler from "./perpetualDataHandler";
-import Triangulator from "./triangulator";
-import { PriceFeedConfig, PriceFeedSubmission, PriceFeedFormat } from "./nodeSDKTypes";
-import { decNToFloat } from "./d8XMath";
-import { Buffer } from "buffer";
-
-/**
- * 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: PriceFeedConfig;
-  private feedEndpoints: Array<string>; //feedEndpoints[endpointId] = endpointstring
-  private feedInfo: Map<string, { symbol: string; endpointId: number }>; // priceFeedId -> symbol, endpointId
-  private dataHandler: PerpetualDataHandler;
-  // store triangulation paths given the price feeds
-  private triangulations: Map<string, [string[], boolean[]]>;
-  private THRESHOLD_MARKET_CLOSED_SEC = 15; // smallest lag for which we consider the market as being closed
-
-  constructor(dataHandler: PerpetualDataHandler, priceFeedConfigNetwork: string) {
-    let configs = <PriceFeedConfig[]>require("../config/priceFeedConfig.json");
-    this.config = PriceFeeds._selectConfig(configs, priceFeedConfigNetwork);
-    [this.feedInfo, this.feedEndpoints] = PriceFeeds._constructFeedInfo(this.config);
-    this.dataHandler = dataHandler;
-    this.triangulations = new Map<string, [string[], boolean[]]>();
-  }
-
-  /**
-   * Pre-processing of triangulations for symbols, given the price feeds
-   * @param symbols set of symbols we want to triangulate from price feeds
-   */
-  public initializeTriangulations(symbols: Set<string>) {
-    let feedSymbols = new Array<string>();
-    for (let [key, value] of this.feedInfo) {
-      feedSymbols.push(value.symbol);
-    }
-    for (let symbol of symbols.values()) {
-      let triangulation = Triangulator.triangulate(feedSymbols, symbol);
-      this.triangulations.set(symbol, triangulation);
-    }
-  }
-
-  /**
-   * 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
-   */
-  public async fetchFeedPriceInfoAndIndicesForPerpetual(
-    symbol: string
-  ): Promise<{ submission: PriceFeedSubmission; pxS2S3: [number, number]; mktClosed: [boolean, boolean] }> {
-    let indexSymbols = this.dataHandler.getIndexSymbols(symbol);
-    // fetch prices from required price-feeds (REST)
-    let submission: PriceFeedSubmission = await this.fetchLatestFeedPriceInfoForPerpetual(symbol);
-    // calculate index-prices from price-feeds
-    let [_idxPrices, _mktClosed] = this.calculateTriangulatedPricesFromFeedInfo(
-      indexSymbols.filter((x) => x != ""),
-      submission
-    );
-    let idxPrices: [number, number] = [_idxPrices[0], 0];
-    let mktClosed: [boolean, boolean] = [_mktClosed[0], false];
-    if (idxPrices.length > 1) {
-      idxPrices[1] = _idxPrices[1];
-      mktClosed[1] = _mktClosed[1];
-    }
-    return { submission: submission, pxS2S3: idxPrices, mktClosed: mktClosed };
-  }
-
-  /**
-   * 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
-   */
-  public async fetchPrices(symbols: string[]): Promise<Map<string, [number, boolean]>> {
-    let feedPrices = await this.fetchAllFeedPrices();
-    let [prices, mktClosed] = this.triangulatePricesFromFeedPrices(symbols, feedPrices);
-    let symMap = new Map<string, [number, boolean]>();
-    for (let k = 0; k < symbols.length; k++) {
-      symMap.set(symbols[k], [prices[k], mktClosed[k]]);
-    }
-    return symMap;
-  }
-
-  /**
-   * Get index prices and market closed information for the given perpetual
-   * @param symbol perpetual symbol such as ETH-USD-MATIC
-   * @returns Index prices and market closed information
-   */
-  public async fetchPricesForPerpetual(symbol: string): Promise<{ idxPrices: number[]; mktClosed: boolean[] }> {
-    let indexSymbols = this.dataHandler.getIndexSymbols(symbol).filter((x) => x != "");
-    // determine relevant price feeds
-    let feedSymbols = new Array<string>();
-    for (let sym of indexSymbols) {
-      if (sym != "") {
-        let triang: [string[], boolean[]] | undefined = this.triangulations.get(sym);
-        if (triang == undefined) {
-          // no triangulation defined, so symbol must be a feed (unless misconfigured)
-          feedSymbols.push(sym);
-        } else {
-          // push all required feeds to array
-          triang[0].map((feedSym) => feedSymbols.push(feedSym));
-        }
-      }
-    }
-    // get all feed prices
-    let feedPrices = await this.fetchFeedPrices(feedSymbols);
-    // triangulate
-    let [prices, mktClosed] = this.triangulatePricesFromFeedPrices(indexSymbols, feedPrices);
-    // ensure we return an array of 2 in all cases
-    if (prices.length == 1) {
-      prices.push(0);
-      mktClosed.push(false);
-    }
-    return { idxPrices: prices, mktClosed: mktClosed };
-  }
-
-  /**
-   * 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]
-   */
-  public async fetchFeedPrices(symbols?: string[]): Promise<Map<string, [number, boolean]>> {
-    let queries = new Array<string>(this.feedEndpoints.length);
-    let symbolsOfEndpoint: string[][] = [];
-    for (let j = 0; j < queries.length; j++) {
-      symbolsOfEndpoint.push([]);
-    }
-    for (let k = 0; k < this.config.ids.length; k++) {
-      let currFeed = this.config.ids[k];
-      if (symbols != undefined && !symbols.includes(currFeed.symbol)) {
-        continue;
-      }
-      // feedInfo: Map<string, {symbol:string, endpointId: number}>; // priceFeedId -> symbol, endpointId
-      let endpointId = this.feedInfo.get(currFeed.id)!.endpointId;
-      symbolsOfEndpoint[endpointId].push(currFeed.symbol);
-      if (queries[endpointId] == undefined) {
-        // each id can have a different endpoint, but we cluster
-        // the queries into one per endpoint
-        queries[endpointId] = this.feedEndpoints[endpointId] + "/latest_price_feeds?";
-      }
-      queries[endpointId] = queries[endpointId] + "ids[]=" + currFeed.id + "&";
-    }
-    let resultPrices = new Map<string, [number, boolean]>();
-    for (let k = 0; k < queries.length; k++) {
-      if (queries[k] == undefined) {
-        continue;
-      }
-      let [id, pxInfo]: [string[], PriceFeedFormat[]] = await this.fetchPriceQuery(queries[k]);
-      let tsSecNow = Math.round(Date.now() / 1000);
-      for (let j = 0; j < pxInfo.length; j++) {
-        let price = decNToFloat(BigNumber.from(pxInfo[j].price), -pxInfo[j].expo);
-        let isMarketClosed = tsSecNow - pxInfo[j].publish_time > this.THRESHOLD_MARKET_CLOSED_SEC;
-        resultPrices.set(symbolsOfEndpoint[k][j], [price, isMarketClosed]);
-      }
-    }
-    return resultPrices;
-  }
-
-  /**
-   * Get all configured feed prices via "latest_price_feeds"
-   * @returns map of feed-price symbol to price/isMarketClosed
-   */
-  public async fetchAllFeedPrices(): Promise<Map<string, [number, boolean]>> {
-    return this.fetchFeedPrices();
-  }
-
-  /**
-   * 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
-   */
-  public async fetchLatestFeedPriceInfoForPerpetual(symbol: string): Promise<PriceFeedSubmission> {
-    let feedIds = this.dataHandler.getPriceIds(symbol);
-    let queries = new Array<string>(this.feedEndpoints.length);
-    // we need to preserve the order of the price feeds
-    let orderEndpointNumber = new Array<number>();
-    // count how many prices per endpoint
-    let idCountPriceFeeds = new Array<number>(this.feedEndpoints.length);
-    let symbols = new Array<string>();
-    for (let k = 0; k < feedIds.length; k++) {
-      let info = this.feedInfo.get(feedIds[k]);
-      if (info == undefined) {
-        throw new Error(`priceFeeds: config for symbol ${symbol} insufficient`);
-      }
-      let id = info.endpointId;
-      symbols.push(info.symbol);
-      if (queries[id] == undefined) {
-        // each id can have a different endpoint, but we cluster
-        // the queries into one per endpoint
-        queries[id] = this.feedEndpoints[id] + "/latest_vaas_px?";
-        idCountPriceFeeds[id] = 0;
-      }
-      queries[id] = queries[id] + "ids[]=" + feedIds[k] + "&";
-      orderEndpointNumber.push(id * 100 + idCountPriceFeeds[id]);
-      idCountPriceFeeds[id] = idCountPriceFeeds[id] + 1;
-    }
-
-    let data = await Promise.all(
-      queries.map(async (q) => {
-        if (q != undefined) {
-          return this.fetchVAAQuery(q);
-        } else {
-          return [[], []];
-        }
-      })
-    );
-
-    // re-order arrays so we preserve the order of the feeds
-    const priceFeedUpdates = new Array<string>();
-    const prices = new Array<number>();
-    const mktClosed = new Array<boolean>();
-    const timestamps = new Array<number>();
-    const tsSecNow = Math.round(Date.now() / 1000);
-    for (let k = 0; k < orderEndpointNumber.length; k++) {
-      let endpointId = Math.floor(orderEndpointNumber[k] / 100);
-      let idWithinEndpoint = orderEndpointNumber[k] - 100 * endpointId;
-      priceFeedUpdates.push(data[endpointId][0][idWithinEndpoint]);
-      let pxInfo: PriceFeedFormat = data[endpointId][1][idWithinEndpoint];
-      let price = decNToFloat(BigNumber.from(pxInfo.price), -pxInfo.expo);
-      let isMarketClosed = tsSecNow - pxInfo.publish_time > this.THRESHOLD_MARKET_CLOSED_SEC;
-      mktClosed.push(isMarketClosed);
-      prices.push(price);
-      timestamps.push(pxInfo.publish_time);
-    }
-
-    return {
-      symbols: symbols,
-      priceFeedVaas: priceFeedUpdates,
-      prices: prices,
-      isMarketClosed: mktClosed,
-      timestamps: timestamps,
-    };
-  }
-
-  /**
-   * 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
-   */
-  public calculateTriangulatedPricesFromFeedInfo(symbols: string[], feeds: PriceFeedSubmission): [number[], boolean[]] {
-    let priceMap = new Map<string, [number, boolean]>();
-    for (let j = 0; j < feeds.prices.length; j++) {
-      priceMap.set(feeds.symbols[j], [feeds.prices[j], feeds.isMarketClosed[j]]);
-    }
-    return this.triangulatePricesFromFeedPrices(symbols, priceMap);
-  }
-  /**
-   * 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
-   */
-  public triangulatePricesFromFeedPrices(
-    symbols: string[],
-    feedPriceMap: Map<string, [number, boolean]>
-  ): [number[], boolean[]] {
-    let prices = new Array<number>();
-    let mktClosed = new Array<boolean>();
-    for (let k = 0; k < symbols.length; k++) {
-      let triangulation: [string[], boolean[]] | undefined = this.triangulations.get(symbols[k]);
-      if (triangulation == undefined) {
-        let feedPrice = feedPriceMap.get(symbols[k]);
-        if (feedPrice == undefined) {
-          throw new Error(`PriceFeeds: no triangulation defined for ${symbols[k]}`);
-        } else {
-          prices.push(feedPrice[0]); //price
-          mktClosed.push(feedPrice[1]); //market closed?
-          continue;
-        }
-      }
-      let [px, isMktClosed]: [number, boolean] = Triangulator.calculateTriangulatedPrice(triangulation, feedPriceMap);
-      prices.push(px);
-      mktClosed.push(isMktClosed);
-    }
-    return [prices, mktClosed];
-  }
-
-  /**
-   * Queries the REST endpoint and returns parsed VAA price data
-   * @param query query price-info from endpoint
-   * @returns vaa and price info
-   */
-  private async fetchVAAQuery(query: string): Promise<[string[], PriceFeedFormat[]]> {
-    const headers = { headers: { "Content-Type": "application/json" } };
-    let response = await fetch(query, headers);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch posts (${response.status}): ${response.statusText}`);
-    }
-    let values = (await response.json()) as Array<[string, PriceFeedFormat]>;
-    const priceFeedUpdates = new Array<string>();
-    const px = new Array<PriceFeedFormat>();
-    for (let k = 0; k < values.length; k++) {
-      priceFeedUpdates.push("0x" + Buffer.from(values[k][0], "base64").toString("hex"));
-      px.push(values[k][1]);
-    }
-    return [priceFeedUpdates, px];
-  }
-
-  /**
-   * Queries the REST endpoint and returns parsed price data
-   * @param query query price-info from endpoint
-   * @returns vaa and price info
-   */
-  public async fetchPriceQuery(query: string): Promise<[string[], PriceFeedFormat[]]> {
-    const headers = { headers: { "Content-Type": "application/json" } };
-    let response = await fetch(query, headers);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch posts (${response.status}): ${response.statusText}`);
-    }
-    let values = await response.json();
-    const priceFeedUpdates = new Array<string>();
-    const px = new Array<PriceFeedFormat>();
-    for (let k = 0; k < values.length; k++) {
-      priceFeedUpdates.push("0x" + Buffer.from(values[k].id, "base64").toString("hex"));
-      px.push(values[k].price as PriceFeedFormat);
-    }
-    return [priceFeedUpdates, px];
-  }
-
-  /**
-   * 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 {
-    let k = 0;
-    while (k < configs.length) {
-      if (configs[k].network == network) {
-        return configs[k];
-      }
-      k = k + 1;
-    }
-    throw new Error(`PriceFeeds: config not found for network ${network}`);
-  }
-
-  /**
-   * 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[]] {
-    let feed = new Map<string, { symbol: string; endpointId: number }>();
-    let endpointId = -1;
-    let type = "";
-    let feedEndpoints = new Array<string>();
-    for (let k = 0; k < config.endpoints.length; k++) {
-      feedEndpoints.push(config.endpoints[k].endpoint);
-    }
-    for (let k = 0; k < config.ids.length; k++) {
-      if (type != config.ids[k].type) {
-        type = config.ids[k].type;
-        let j = 0;
-        while (j < config.endpoints.length) {
-          if (config.endpoints[j].type == type) {
-            endpointId = j;
-            j = config.endpoints.length;
-          }
-          j++;
-        }
-        if (config.endpoints[endpointId].type != type) {
-          throw new Error(`priceFeeds: no enpoint found for ${type} check priceFeedConfig`);
-        }
-      }
-      feed.set(config.ids[k].id, { symbol: config.ids[k].symbol.toUpperCase(), endpointId: endpointId });
-    }
-    return [feed, feedEndpoints];
-  }
-}

package/src/traderDigests.ts

@@ -1,91 +0,0 @@
-import { toUtf8Bytes } from "@ethersproject/strings";
-import { concat } from "@ethersproject/bytes";
-import { ethers } from "ethers";
-import { SmartContractOrder } from "./nodeSDKTypes";
-import { Buffer } from "buffer";
-
-export default class TraderDigests {
-  /**
-   * Creates an order-id from the digest. Order-id is the 'digest' used in the smart contract.
-   * @param digest  created with _createDigest
-   * @returns orderId string
-   * @ignore
-   */
-  public async createOrderId(digest: string) {
-    let digestBuffer = Buffer.from(digest.substring(2, digest.length), "hex");
-    const messagePrefix = "\x19Ethereum Signed Message:\n";
-    let tmp = concat([toUtf8Bytes(messagePrefix), toUtf8Bytes(String(digestBuffer.length)), digestBuffer]);
-    // see: https://github.com/ethers-io/ethers.js/blob/c80fcddf50a9023486e9f9acb1848aba4c19f7b6/packages/hash/src.ts/message.ts#L7
-    return ethers.utils.keccak256(tmp);
-  }
-
-  /**
-   * Creates a digest (order-id)
-   * @param order         smart-contract-type order
-   * @param chainId       chainId of network
-   * @param isNewOrder    true unless we cancel
-   * @param signer        ethereum-type wallet
-   * @param proxyAddress  address of the contract
-   * @returns digest
-   * @ignore
-   */
-  public async createDigest(
-    order: SmartContractOrder,
-    chainId: number,
-    isNewOrder: boolean,
-    proxyAddress: string
-  ): Promise<string> {
-    const NAME = "Perpetual Trade Manager";
-    const DOMAIN_TYPEHASH = ethers.utils.keccak256(
-      Buffer.from("EIP712Domain(string name,uint256 chainId,address verifyingContract)")
-    );
-    let abiCoder = ethers.utils.defaultAbiCoder;
-    let domainSeparator = ethers.utils.keccak256(
-      abiCoder.encode(
-        ["bytes32", "bytes32", "uint256", "address"],
-        [DOMAIN_TYPEHASH, ethers.utils.keccak256(Buffer.from(NAME)), chainId, proxyAddress]
-      )
-    );
-    const TRADE_ORDER_TYPEHASH = ethers.utils.keccak256(
-      Buffer.from(
-        "Order(uint24 iPerpetualId,uint16 brokerFeeTbps,address traderAddr,address brokerAddr,int128 fAmount,int128 fLimitPrice,int128 fTriggerPrice,uint64 iDeadline,uint32 flags,int128 fLeverage,uint64 createdTimestamp)"
-      )
-    );
-    let structHash = ethers.utils.keccak256(
-      abiCoder.encode(
-        [
-          "bytes32",
-          "uint24",
-          "uint16",
-          "address",
-          "address",
-          "int128",
-          "int128",
-          "int128",
-          "uint64",
-          "uint32",
-          "int128",
-          "uint64",
-        ],
-        [
-          TRADE_ORDER_TYPEHASH,
-          order.iPerpetualId,
-          order.brokerFeeTbps,
-          order.traderAddr,
-          order.brokerAddr,
-          order.fAmount,
-          order.fLimitPrice,
-          order.fTriggerPrice,
-          order.iDeadline,
-          order.flags,
-          order.fLeverage,
-          order.createdTimestamp,
-        ]
-      )
-    );
-    let digest = ethers.utils.keccak256(
-      abiCoder.encode(["bytes32", "bytes32", "bool"], [domainSeparator, structHash, isNewOrder])
-    );
-    return digest;
-  }
-}

package/src/traderInterface.ts

@@ -1,159 +0,0 @@
-import { ethers } from "ethers";
-import MarketData from "./marketData";
-import PerpetualDataHandler from "./perpetualDataHandler";
-import { NodeSDKConfig, SmartContractOrder, Order, ClientOrder, ZERO_ORDER_ID } from "./nodeSDKTypes";
-import TraderDigests from "./traderDigests";
-import { ABK64x64ToFloat } from "./d8XMath";
-/**
- * Interface that can be used by front-end that wraps all private functions
- * so that signatures can be handled in frontend via wallet
- * @extends MarketData
- */
-export default class TraderInterface extends MarketData {
-  public digestTool: TraderDigests;
-
-  // accTrade.order(order)
-  // cancelOrder(symbol: string, orderId: string)
-  // accTrade.setAllowance
-  // accTrade.getOrderIds("MATIC-USD-MATIC")
-
-  /**
-   * Constructor
-   * @param {NodeSDKConfig} config Configuration object, see
-   * PerpetualDataHandler.readSDKConfig.
-   */
-  constructor(config: NodeSDKConfig) {
-    super(config);
-    this.digestTool = new TraderDigests();
-  }
-
-  /**
-   * Get the fee that is charged to the trader for a given broker (can be ZERO-address),
-   * without broker fee
-   * @param poolSymbolName pool currency (e.g. MATIC)
-   * @param traderAddr address of trader
-   * @param brokerAddr address of broker
-   * @returns fee (in decimals) that is charged by exchange (without broker)
-   */
-  public async queryExchangeFee(poolSymbolName: string, traderAddr: string, brokerAddr: string): Promise<number> {
-    if (this.proxyContract == null) {
-      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
-    }
-    let poolId = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
-    let feeTbps = await this.proxyContract.queryExchangeFee(poolId, traderAddr, brokerAddr);
-    return feeTbps / 100_000;
-  }
-
-  /**
-   *
-   * @param poolSymbolName pool symbol, e.g. MATIC
-   * @param traderAddr address of the trader
-   * @returns volume in USD
-   */
-  public async getCurrentTraderVolume(poolSymbolName: string, traderAddr: string): Promise<number> {
-    if (this.proxyContract == null) {
-      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
-    }
-    let poolId = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
-    let volume = await this.proxyContract.getCurrentTraderVolume(poolId, traderAddr);
-    return ABK64x64ToFloat(volume);
-  }
-
-  /**
-   * Get digest to cancel an order. Digest needs to be signed and submitted via
-   * orderBookContract.cancelOrder(orderId, signature);
-   * @param symbol
-   * @param orderId
-   * @returns tuple of digest which the trader needs to sign and address of order book contract
-   */
-  public async cancelOrderDigest(symbol: string, orderId: string): Promise<{ digest: string; OBContractAddr: string }> {
-    if (this.proxyContract == null) {
-      throw Error("no proxy contract initialized. Use createProxyInstance().");
-    }
-    let orderBookContract = this.getOrderBookContract(symbol);
-    let scOrder: SmartContractOrder = await orderBookContract.orderOfDigest(orderId);
-    let digest = await this.digestTool.createDigest(scOrder, this.chainId, false, this.proxyAddr);
-    return { digest: digest, OBContractAddr: orderBookContract.address };
-  }
-
-  /**
-   * Get the order book address for a perpetual
-   * @param symbol symbol (e.g. MATIC-USD-MATIC)
-   * @returns order book address for the perpetual
-   */
-  public getOrderBookAddress(symbol: string): string {
-    let orderBookContract: ethers.Contract = this.getOrderBookContract(symbol);
-    return orderBookContract.address;
-  }
-
-  /**
-   * createSmartContractOrder from user-friendly order
-   * @param order order struct
-   * @param traderAddr address of trader
-   * @returns Smart contract type order struct
-   */
-  public createSmartContractOrder(order: Order, traderAddr: string): SmartContractOrder {
-    let scOrder = TraderInterface.toSmartContractOrder(order, traderAddr, this.symbolToPerpStaticInfo);
-    return scOrder;
-  }
-
-  /**
-   * Create smart contract order and digest that the trader signs.
-   * await orderBookContract.postOrder(scOrder, signature, { gasLimit: gasLimit });
-   * Order must contain broker fee and broker address if there is supposed to be a broker.
-   * @param scOrder smart contract order struct (get from order via createSCOrder)
-   * @returns digest that the trader has to sign
-   */
-  public async orderDigest(scOrder: SmartContractOrder): Promise<string> {
-    if (this.proxyContract == null) {
-      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
-    }
-    let digest = await this.digestTool.createDigest(scOrder, this.chainId, true, this.proxyContract.address);
-    return digest;
-  }
-
-  /**
-   * Get the ABI of a method in the proxy contract
-   * @param method Name of the method
-   * @returns ABI as a single string
-   */
-  public getProxyABI(method: string): string {
-    if (this.proxyContract == null) {
-      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
-    }
-    return PerpetualDataHandler._getABIFromContract(this.proxyContract, method);
-  }
-
-  /**
-   * Get the ABI of a method in the Limit Order Book contract corresponding to a given symbol.
-   * @param symbol Symbol of the form MATIC-USD-MATIC
-   * @param method Name of the method
-   * @returns ABI as a single string
-   */
-  public getOrderBookABI(symbol: string, method: string): string {
-    if (this.proxyContract == null) {
-      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
-    }
-    let orderBookContract: ethers.Contract = this.getOrderBookContract(symbol);
-    return PerpetualDataHandler._getABIFromContract(orderBookContract, method);
-  }
-
-  public static chainOrders(orders: SmartContractOrder[], ids: string[]): ClientOrder[] {
-    // add dependency
-    let obOrders: ClientOrder[] = new Array<ClientOrder>(orders.length);
-    if (orders.length == 1 || orders.length > 3) {
-      // nothing to add
-      obOrders = orders.map((o) => PerpetualDataHandler.fromSmartContratOrderToClientOrder(o));
-    } else if (orders.length == 2) {
-      // first order is parent, second a child
-      obOrders[0] = PerpetualDataHandler.fromSmartContratOrderToClientOrder(orders[0], [ids[1], ZERO_ORDER_ID]);
-      obOrders[1] = PerpetualDataHandler.fromSmartContratOrderToClientOrder(orders[1], [ZERO_ORDER_ID, ids[0]]);
-    } else {
-      // first order is parent, other two its children
-      obOrders[0] = PerpetualDataHandler.fromSmartContratOrderToClientOrder(orders[0], [ids[1], ids[2]]);
-      obOrders[1] = PerpetualDataHandler.fromSmartContratOrderToClientOrder(orders[1], [ZERO_ORDER_ID, ids[0]]);
-      obOrders[2] = PerpetualDataHandler.fromSmartContratOrderToClientOrder(orders[2], [ZERO_ORDER_ID, ids[0]]);
-    }
-    return obOrders;
-  }
-}