@d8x/perpetuals-sdk 0.6.4 → 0.6.6

package/src/priceFeeds.ts

@@ -0,0 +1,382 @@
+import { BigNumber } from "@ethersproject/bignumber";
+import PerpetualDataHandler from "./perpetualDataHandler";
+import Triangulator from "./triangulator";
+import { PriceFeedConfig, PriceFeedSubmission, PriceFeedFormat, PythLatestPriceFeed } 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 [, 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 [, 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_price_feeds?target_chain=default&";
+        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<PythLatestPriceFeed>;
+    const priceFeedUpdates = new Array<string>();
+    const px = new Array<PriceFeedFormat>();
+    for (let k = 0; k < values.length; k++) {
+      const vaa = values[k].vaa;
+      priceFeedUpdates.push("0x" + Buffer.from(vaa, "base64").toString("hex"));
+      px.push(values[k].price);
+    }
+    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

@@ -0,0 +1,86 @@
+import { defaultAbiCoder } from "@ethersproject/abi";
+import { concat } from "@ethersproject/bytes";
+import { keccak256 } from "@ethersproject/keccak256";
+import { toUtf8Bytes } from "@ethersproject/strings";
+import { Buffer } from "buffer";
+import { SmartContractOrder } from "./nodeSDKTypes";
+
+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 createOrderId(digest: string): 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 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 createDigest(order: SmartContractOrder, chainId: number, isNewOrder: boolean, proxyAddress: string): string {
+    const NAME = "Perpetual Trade Manager";
+    const DOMAIN_TYPEHASH = keccak256(
+      Buffer.from("EIP712Domain(string name,uint256 chainId,address verifyingContract)")
+    );
+    let domainSeparator = keccak256(
+      defaultAbiCoder.encode(
+        ["bytes32", "bytes32", "uint256", "address"],
+        [DOMAIN_TYPEHASH, keccak256(Buffer.from(NAME)), chainId, proxyAddress]
+      )
+    );
+    const TRADE_ORDER_TYPEHASH = keccak256(
+      Buffer.from(
+        "Order(uint24 iPerpetualId,uint16 brokerFeeTbps,address traderAddr,address brokerAddr,int128 fAmount,int128 fLimitPrice,int128 fTriggerPrice,uint32 iDeadline,uint32 flags,uint16 leverageTDR,uint32 executionTimestamp)"
+      )
+    );
+    let structHash = keccak256(
+      defaultAbiCoder.encode(
+        [
+          "bytes32",
+          "uint24",
+          "uint16",
+          "address",
+          "address",
+          "int128",
+          "int128",
+          "int128",
+          "uint64",
+          "uint32",
+          "uint16",
+          "uint64",
+        ],
+        [
+          TRADE_ORDER_TYPEHASH,
+          order.iPerpetualId,
+          order.brokerFeeTbps,
+          order.traderAddr,
+          order.brokerAddr,
+          order.fAmount,
+          order.fLimitPrice,
+          order.fTriggerPrice,
+          order.iDeadline,
+          order.flags,
+          order.leverageTDR,
+          order.executionTimestamp,
+        ]
+      )
+    );
+    let digest = keccak256(
+      defaultAbiCoder.encode(["bytes32", "bytes32", "bool"], [domainSeparator, structHash, isNewOrder])
+    );
+    return digest;
+  }
+}

package/src/traderInterface.ts

@@ -0,0 +1,172 @@
+import { CallOverrides, Contract } from "@ethersproject/contracts";
+import { ABK64x64ToFloat } from "./d8XMath";
+import MarketData from "./marketData";
+import { ClientOrder, NodeSDKConfig, Order, SmartContractOrder, ZERO_ORDER_ID } from "./nodeSDKTypes";
+import PerpetualDataHandler from "./perpetualDataHandler";
+import TraderDigests from "./traderDigests";
+/**
+ * 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,
+    overrides?: CallOverrides
+  ): 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, overrides || {});
+    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,
+    overrides?: CallOverrides
+  ): 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, overrides || {});
+    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,
+    overrides?: CallOverrides
+  ): 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, overrides || {});
+    let digest = 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: 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 orderDigest(scOrder: SmartContractOrder): string {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+    }
+    let digest = 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: 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;
+  }
+}