@d8x/perpetuals-sdk 0.0.1

package/src/d8XMath.ts

@@ -0,0 +1,176 @@
+import { BigNumber } from "ethers";
+import { DECIMALS, ONE_64x64 } from "./nodeSDKTypes";
+const BN = BigNumber;
+
+/**
+ * Convert ABK64x64 bigint-format to float.
+ * Result = x/2^64 if big number, x/2^29 if number
+ * @param   x number in ABDK-format or 2^29
+ * @returns x/2^64 in number-format (float)
+ */
+export function ABK64x64ToFloat(x: BigNumber | number): number {
+  if (typeof x == "number") {
+    return x / 2 ** 29;
+  }
+  let s = x.lt(0) ? -1 : 1;
+  x = x.mul(s);
+  let xInt = x.div(ONE_64x64);
+  let dec18 = BigNumber.from(10).pow(BigNumber.from(18));
+  let xDec = x.sub(xInt.mul(ONE_64x64));
+  xDec = xDec.mul(dec18).div(ONE_64x64);
+  let k = 18 - xDec.toString().length;
+  // console.assert(k >= 0);
+  let sPad = "0".repeat(k);
+  let NumberStr = xInt.toString() + "." + sPad + xDec.toString();
+  return parseFloat(NumberStr) * s;
+}
+
+/**
+ *
+ * @param x BigNumber in Dec18 format
+ * @returns x as a float (number)
+ */
+export function dec18ToFloat(x: BigNumber): number {
+  //x: BigNumber in Dec18 format to float
+  let s = x.lt(0) ? -1 : 1;
+  x = x.mul(s);
+  let xInt = x.div(DECIMALS);
+  let xDec = x.sub(xInt.mul(DECIMALS));
+  let k = 18 - xDec.toString().length;
+  let sPad = "0".repeat(k);
+  let NumberStr = xInt.toString() + "." + sPad + xDec.toString();
+  return parseFloat(NumberStr) * s;
+}
+
+/**
+ * Converts x into ABDK64x64 format
+ * @param   x   number (float)
+ * @returns x^64 in big number format
+ */
+export function floatToABK64x64(x: number): BigNumber {
+  // convert float to ABK64x64 bigint-format
+  // Create string from number with 18 decimals
+  if (x === 0) {
+    return BigNumber.from(0);
+  }
+  let sg = Math.sign(x);
+  x = Math.abs(x);
+  let strX = Number(x).toFixed(18);
+  const arrX = strX.split(".");
+  let xInt = BigNumber.from(arrX[0]);
+  let xDec = BigNumber.from(arrX[1]);
+  let xIntBig = xInt.mul(ONE_64x64);
+  let dec18 = BigNumber.from(10).pow(BigNumber.from(18));
+  let xDecBig = xDec.mul(ONE_64x64).div(dec18);
+  return xIntBig.add(xDecBig).mul(sg);
+}
+
+/**
+ *
+ * @param x number (float)
+ * @returns x as a BigNumber in Dec18 format
+ */
+export function floatToDec18(x: number): BigNumber {
+  // float number to dec 18
+  if (x === 0) {
+    return BigNumber.from(0);
+  }
+  let sg = Math.sign(x);
+  x = Math.abs(x);
+  let strX = x.toFixed(18);
+  const arrX = strX.split(".");
+  let xInt = BigNumber.from(arrX[0]);
+  let xDec = BigNumber.from(arrX[1]);
+  let xIntBig = xInt.mul(DECIMALS);
+  return xIntBig.add(xDec).mul(sg);
+}
+
+/**
+ *
+ * @param x
+ * @param y
+ * @returns x * y
+ */
+export function mul64x64(x: BigNumber, y: BigNumber) {
+  return x.mul(y).div(ONE_64x64);
+}
+
+/**
+ *
+ * @param x
+ * @param y
+ * @returns x / y
+ */
+export function div64x64(x: BigNumber, y: BigNumber) {
+  return x.mul(ONE_64x64).div(y);
+}
+
+/**
+ * Determine the liquidation price
+ * @param {number} LockedInValueQC - trader locked in value in quote currency
+ * @param {number} position - trader position in base currency
+ * @param {number} cash_cc - trader available margin cash in collateral currency
+ * @param {number} maintenance_margin_rate - maintenance margin ratio
+ * @param {number} S3 - collateral to quote conversion (=S2 if base-collateral, =1 if quuote collateral, = index S3 if quanto)
+ * @returns {number} Amount to be deposited to have the given leverage when trading into position pos
+ */
+export function calculateLiquidationPriceCollateralBase(
+  LockedInValueQC: number,
+  position: number,
+  cash_cc: number,
+  maintenance_margin_rate: number
+): number {
+  // correct only if markprice = spot price
+  // m_r  <= (Sm * Pi - L + cash * S3) / (Sm * |Pi|)
+  // -> Sm * (Pi + cash - m_r|Pi|) => L
+  return LockedInValueQC / (position - maintenance_margin_rate * Math.abs(position) + cash_cc);
+}
+
+/**
+ * Determine the liquidation price
+ * @param {number} LockedInValueQC - trader locked in value in quote currency
+ * @param {number} position - trader position in base currency
+ * @param {number} cash_cc - trader available margin cash in collateral currency
+ * @param {number} maintenance_margin_rate - maintenance margin ratio
+ * @param {number} S3 - collateral to quote conversion (=S2 if base-collateral, =1 if quuote collateral, = index S3 if quanto)
+ * @param {number} Sm - mark price
+ * @returns {number} Amount to be deposited to have the given leverage when trading into position pos
+ */
+export function calculateLiquidationPriceCollateralQuanto(
+  LockedInValueQC: number,
+  position: number,
+  cash_cc: number,
+  maintenance_margin_rate: number,
+  S3: number,
+  Sm: number
+): number {
+  // correct only if markprice = spot price and S3 co-moves with Sm
+  // m_r  = (Sm * Pi - L + cash * S3) / (Sm * |Pi|)
+  // m_r  = [Sm * Pi - L + cash * S3(0) * (1 + sign(Pi) (Sm / Sm(0) - 1)] / (Sm * |Pi|)
+  // -> Sm * (m_r |Pi| - Pi - cash * S3(0) * sign(Pi) / Sm(0)) = - L + cash * S3(0) * (1 - sign(Pi))
+  let numerator = -LockedInValueQC + cash_cc * S3 * (1 - Math.sign(position));
+  let denominator = maintenance_margin_rate * Math.abs(position) - position - (cash_cc * S3 * Math.sign(position)) / Sm;
+  return numerator / denominator;
+}
+
+/**
+ * Determine the liquidation price
+ * @param {number} LockedInValueQC - trader locked in value in quote currency
+ * @param {number} position - trader position in base currency
+ * @param {number} cash_cc - trader available margin cash in collateral currency
+ * @param {number} maintenance_margin_rate - maintenance margin ratio
+ * @param {number} S3 - collateral to quote conversion (=S2 if base-collateral, =1 if quuote collateral, = index S3 if quanto)
+ * @returns {number} Amount to be deposited to have the given leverage when trading into position pos
+ */
+export function calculateLiquidationPriceCollateralQuote(
+  LockedInValueQC: number,
+  position: number,
+  cash_cc: number,
+  maintenance_margin_rate: number
+): number {
+  // m_r  = (Sm * Pi - L + cash ) / (Sm * |Pi|)
+  // -> Sm * (m_r |Pi| - Pi) = - L + cash
+  let numerator = -LockedInValueQC + cash_cc;
+  let denominator = maintenance_margin_rate * Math.abs(position) - position;
+  return numerator / denominator;
+}

package/src/index.ts

@@ -0,0 +1,32 @@
+import AccountTrade from "./accountTrade";
+import BrokerTool from "./brokerTool";
+import LiquidityProviderTool from "./liquidityProviderTool";
+import MarketData from "./marketData";
+import OrderReferrerTool from "./orderReferrerTool";
+import PerpetualDataHandler from "./perpetualDataHandler";
+import WriteAccessHandler from "./writeAccessHandler";
+// import {
+//   NodeSDKConfig,
+//   MarginAccount,
+//   CollaterlCCY,
+//   PoolStaticInfo,
+//   PerpetualStaticInfo,
+//   ExchangeInfo,
+//   PoolState,
+//   PerpetualState,
+//   Order,
+//   SmartContractOrder,
+// } from "./nodeSDKTypes";
+export * from "./nodeSDKTypes";
+export * from "./utils";
+export * from "./d8XMath";
+
+export {
+  AccountTrade,
+  BrokerTool,
+  LiquidityProviderTool,
+  MarketData,
+  OrderReferrerTool,
+  PerpetualDataHandler,
+  WriteAccessHandler,
+};

package/src/liquiditatorTool.ts

@@ -0,0 +1,21 @@
+import WriteAccessHandler from "./writeAccessHandler";
+import { NodeSDKConfig } from "./nodeSDKTypes";
+
+/**
+ * LiquidatorTool
+ * Methods to liquidate traders
+ */
+export default class LiquidatorTool extends WriteAccessHandler {
+  /**
+   * Constructor
+   * @param config configuration
+   * @param privateKey private key of account that trades
+   */
+  public constructor(config: NodeSDKConfig, privateKey: string) {
+    super(config, privateKey);
+  }
+
+  /*
+  TODO
+  */
+}

package/src/liquidityProviderTool.ts

@@ -0,0 +1,100 @@
+import { ethers } from "ethers";
+import WriteAccessHandler from "./writeAccessHandler";
+import { NodeSDKConfig, ERC20_ABI } from "./nodeSDKTypes";
+import PerpetualDataHandler from "./perpetualDataHandler";
+import { floatToABK64x64, dec18ToFloat, ABK64x64ToFloat } from "./d8XMath";
+/**
+ * LiquidityProviderTool
+ * Methods to provide liquidity
+ */
+export default class LiquidityProviderTool extends WriteAccessHandler {
+  /**
+   * Constructor
+   * @param config configuration
+   * @param privateKey private key of account that trades
+   */
+  public constructor(config: NodeSDKConfig, privateKey: string) {
+    super(config, privateKey);
+  }
+
+  /**
+   * Returns the value of the share tokens for this liquidity provider
+   * in poolSymbol-currency (e.g. MATIC, USDC)
+   * @param poolSymbolName pool symbol name (e.g. MATIC)
+   */
+  public async getParticipationValue(
+    poolSymbolName: string
+  ): Promise<{ value: number; shareTokenBalance: number; poolShareToken: string }> {
+    if (
+      this.proxyContract == null ||
+      this.signer == null ||
+      this.poolStaticInfos.length == 0 ||
+      this.provider == null
+    ) {
+      throw Error("no proxy contract or wallet or data initialized. Use createProxyInstance().");
+    }
+    let poolId = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+
+    let shareTokenAddr = this.poolStaticInfos[poolId - 1].shareTokenAddr;
+    let shareToken = new ethers.Contract(shareTokenAddr, ERC20_ABI, this.signer);
+    let dShareTokenBalanceOfAddr = await shareToken.balanceOf(this.traderAddr);
+    let shareTokenBalanceOfAddr = dec18ToFloat(dShareTokenBalanceOfAddr);
+    if (shareTokenBalanceOfAddr == 0) {
+      return { value: 0, shareTokenBalance: 0, poolShareToken: shareTokenAddr };
+    }
+    let pool = await this.proxyContract.getLiquidityPool(poolId);
+    let fPnLParticipantFundCash = pool.fPnLparticipantsCashCC;
+    let pnlParticipantFundCash = ABK64x64ToFloat(fPnLParticipantFundCash);
+
+    let dTotalSupply = await shareToken.totalSupply();
+
+    let totalSupply = dec18ToFloat(dTotalSupply);
+    let valueCC = (shareTokenBalanceOfAddr / totalSupply) * pnlParticipantFundCash;
+    return { value: valueCC, shareTokenBalance: shareTokenBalanceOfAddr, poolShareToken: shareTokenAddr };
+  }
+
+  /**
+   *  Add liquidity to the PnL participant fund. The address gets pool shares in return.
+   * @param poolname  name of pool symbol (e.g. MATIC)
+   * @param amountCC  amount in pool-collateral currency
+   * @return transaction object
+   */
+  public async addLiquidity(poolSymbolName: string, amountCC: number): Promise<ethers.providers.TransactionResponse> {
+    if (this.proxyContract == null || this.signer == null) {
+      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+    }
+    let poolId = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+    let tx = await this.proxyContract.addLiquidity(poolId, floatToABK64x64(amountCC), {
+      gasLimit: this.gasLimit,
+    });
+    return tx;
+  }
+
+  /**
+   * Remove liquidity from the pool
+   * @param poolSymbolName name of pool symbol (e.g. MATIC)
+   * @param amountPoolShares amount in pool-tokens, removes everything if > available amount
+   * @return transaction object
+   */
+  public async removeLiquidity(
+    poolSymbolName: string,
+    amountPoolShares: number
+  ): Promise<ethers.providers.TransactionResponse> {
+    if (this.proxyContract == null || this.signer == null) {
+      throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
+    }
+    let poolId = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+    let tx = await this.proxyContract.addLiquidity(poolId, floatToABK64x64(amountPoolShares), {
+      gasLimit: this.gasLimit,
+    });
+    return tx;
+  }
+
+  /*
+  TODO:
+  - add liquidity
+    addLiquidity(uint8 _poolId, int128 _fTokenAmount)
+  - remove liquidity
+    function removeLiquidity(uint8 _poolId, int128 _fShareAmount) external override nonReentrant 
+  */
+}

package/src/marketData.ts

@@ -0,0 +1,149 @@
+import {
+    ExchangeInfo,
+    NodeSDKConfig,
+    MarginAccount,
+    PoolState,
+    PerpetualState,
+    COLLATERAL_CURRENCY_BASE,
+    COLLATERAL_CURRENCY_QUANTO,
+    PERP_STATE_STR,
+    ZERO_ADDRESS,
+} from "./nodeSDKTypes";
+import { BigNumber, BytesLike, ethers } from "ethers";
+import { floatToABK64x64, ABK64x64ToFloat } from "./d8XMath";
+import { fromBytes4HexString } from "./utils";
+import PerpetualDataHandler from "./perpetualDataHandler";
+import { SmartContractOrder, Order } from "./nodeSDKTypes";
+
+/**
+ * This class requires no private key and is blockchain read-only.
+ * No gas required for the queries here.
+ */
+export default class MarketData extends PerpetualDataHandler {
+    public constructor(config: NodeSDKConfig) {
+        super(config);
+    }
+
+    public async createProxyInstance() {
+        this.provider = new ethers.providers.JsonRpcProvider(this.nodeURL);
+        await this.initContractsAndData(this.provider);
+    }
+
+    public async exchangeInfo(): Promise<ExchangeInfo> {
+        if (this.proxyContract == null) {
+            throw Error("no proxy contract initialized. Use createProxyInstance().");
+        }
+        return await MarketData._exchangeInfo(this.proxyContract);
+    }
+
+    /**
+     * Get all open orders for a trader-address and a symbol
+     * @param traderAddr address of the trader for which we get the open order
+     * @param symbol symbol of the form ETH-USD-MATIC
+     * @returns array of open orders and corresponding order-ids
+     */
+    public async openOrders(traderAddr: string, symbol: string): Promise<{ orders: Order[]; orderIds: string[] }> {
+        // open orders requested only for given symbol
+        let orderBookContract = this.getOrderBookContract(symbol);
+        let [orders, digests] = await Promise.all([
+            this.openOrdersOnOrderBook(traderAddr, orderBookContract),
+            this.orderIdsOfTrader(traderAddr, orderBookContract),
+        ]);
+        return { orders: orders, orderIds: digests };
+    }
+
+    public async positionRisk(traderAddr: string, symbol: string): Promise<MarginAccount> {
+        if (this.proxyContract == null) {
+            throw Error("no proxy contract initialized. Use createProxyInstance().");
+        }
+        let mgnAcct = await PerpetualDataHandler.getMarginAccount(traderAddr, symbol, this.symbolToPerpStaticInfo, this.proxyContract);
+        return mgnAcct;
+    }
+
+    /**
+     * Query smart contract to get user orders and convert to user friendly order format
+     * @param traderAddr address of trader
+     * @param orderBookContract instance of order book
+     * @returns array of user friendly order struct
+     */
+    protected async openOrdersOnOrderBook(traderAddr: string, orderBookContract: ethers.Contract): Promise<Order[]> {
+        let orders: SmartContractOrder[] = await orderBookContract.getOrders(traderAddr, 0, 15);
+        //eliminate empty orders and map to user friendly orders
+        let userFriendlyOrders: Order[] = new Array<Order>();
+        let k = 0;
+        while (k < orders.length && orders[k].traderAddr != ZERO_ADDRESS) {
+            userFriendlyOrders.push(PerpetualDataHandler.fromSmartContractOrder(orders[k], this.symbolToPerpStaticInfo));
+            k++;
+        }
+        return userFriendlyOrders;
+    }
+
+    /**
+     *
+     * @param traderAddr address of the trader
+     * @param orderBookContract instance of order book contract
+     * @returns array of order-id's
+     */
+    protected async orderIdsOfTrader(traderAddr: string, orderBookContract: ethers.Contract): Promise<string[]> {
+        let digestsRaw: string[] = await orderBookContract.limitDigestsOfTrader(traderAddr, 0, 15);
+        let k: number = 0;
+        let digests: string[] = [];
+        while (k < digestsRaw.length && BigNumber.from(digestsRaw[k]).gt(0)) {
+            digests.push(digestsRaw[k]);
+            k++;
+        }
+        return digests;
+    }
+
+    public static async _exchangeInfo(_proxyContract: ethers.Contract): Promise<ExchangeInfo> {
+        let nestedPerpetualIDs = await PerpetualDataHandler.getNestedPerpetualIds(_proxyContract);
+        let info: ExchangeInfo = { pools: [] };
+        const numPools = nestedPerpetualIDs.length;
+        for (var j = 0; j < numPools; j++) {
+            let perpetualIDs = nestedPerpetualIDs[j];
+            let pool = await _proxyContract.getLiquidityPool(j + 1);
+            let PoolState: PoolState = {
+                isRunning: pool.isRunning,
+                marginTokenAddr: pool.marginTokenAddress,
+                poolShareTokenAddr: pool.shareTokenAddress,
+                defaultFundCashCC: ABK64x64ToFloat(pool.fDefaultFundCashCC),
+                pnlParticipantCashCC: ABK64x64ToFloat(pool.fPnLparticipantsCashCC),
+                totalAMMFundCashCC: ABK64x64ToFloat(pool.fAMMFundCashCC),
+                totalTargetAMMFundSizeCC: ABK64x64ToFloat(pool.fTargetAMMFundSize),
+                brokerCollateralLotSize: ABK64x64ToFloat(pool.fBrokerCollateralLotSize),
+                perpetuals: [],
+            };
+            for (var k = 0; k < perpetualIDs.length; k++) {
+                let perp = await _proxyContract.getPerpetual(perpetualIDs[k]);
+                let fIndexS2 = await _proxyContract.getOraclePrice([perp.S2BaseCCY, perp.S2QuoteCCY]);
+                let indexS2 = ABK64x64ToFloat(fIndexS2);
+                let indexS3 = 1;
+                if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_BASE) {
+                    indexS3 = indexS2;
+                } else if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_QUANTO) {
+                    indexS3 = ABK64x64ToFloat(await _proxyContract.getOraclePrice([perp.S3BaseCCY, perp.S3QuoteCCY]));
+                }
+                let markPremiumRate = ABK64x64ToFloat(perp.currentMarkPremiumRate.fPrice);
+                let currentFundingRateBps = 1e4 * ABK64x64ToFloat(perp.fCurrentFundingRate);
+                let state = PERP_STATE_STR[perp.state];
+                let PerpetualState: PerpetualState = {
+                    id: perp.id,
+                    state: state,
+                    baseCurrency: fromBytes4HexString(perp.S2BaseCCY),
+                    quoteCurrency: fromBytes4HexString(perp.S2QuoteCCY),
+                    indexPrice: indexS2,
+                    collToQuoteIndexPrice: indexS3,
+                    markPrice: indexS2 * (1 + markPremiumRate),
+                    currentFundingRateBps: currentFundingRateBps,
+                    initialMarginRate: ABK64x64ToFloat(perp.fInitialMarginRate),
+                    maintenanceMarginRate: ABK64x64ToFloat(perp.fMaintenanceMarginRate),
+                    openInterestBC: ABK64x64ToFloat(perp.fOpenInterest),
+                    maxPositionBC: ABK64x64ToFloat(perp.fMaxPositionBC),
+                };
+                PoolState.perpetuals.push(PerpetualState);
+            }
+            info.pools.push(PoolState);
+        }
+        return info;
+    }
+}

package/src/nodeSDKTypes.ts

@@ -0,0 +1,158 @@
+import { BytesLike, BigNumber, BigNumberish } from "ethers";
+export const DEFAULT_CONFIG_TESTNET = "../config/defaultConfig.json";
+export const DEFAULT_CONFIG_MAINNET = "notthereyet";
+export const DEFAULT_CONFIG_TESTNET_NAME = "testnet";
+export const DEFAULT_CONFIG_MAINNET_NAME = "mainnet";
+
+export const ERC20_ABI = require("../abi/ERC20.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 = "0x0000000000000000000000000000000000000000";
+
+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 {
+  nodeURL: string;
+  proxyAddr: string;
+  proxyABILocation: string;
+  limitOrderBookFactoryAddr: string;
+  limitOrderBookABILocation: string;
+  limitOrderBookFactoryABILocation: string;
+  gasLimit?: number | 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;
+  maintenanceMarginRate: number;
+  collateralCurrencyType: CollaterlCCY;
+  S2Symbol: string;
+  S3Symbol: string;
+}
+
+export interface ExchangeInfo {
+  pools: PoolState[];
+}
+export interface PoolState {
+  isRunning: boolean;
+  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;
+  currentFundingRateBps: number;
+  initialMarginRate: number;
+  maintenanceMarginRate: number;
+  openInterestBC: number;
+  maxPositionBC: number;
+}
+
+export interface Order {
+  symbol: string;
+  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;
+}
+
+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;
+}
+/*
+        t32 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
+        uint256 iDeadline;
+        uint256 createdTimestamp;
+        */

package/src/orderReferrerTool.ts

@@ -0,0 +1,17 @@
+import WriteAccessHandler from "./writeAccessHandler";
+import { NodeSDKConfig } from "./nodeSDKTypes";
+
+/**
+ * OrderReferrerTool
+ * Methods to refer orders from the limit order book
+ */
+export default class OrderReferrerTool extends WriteAccessHandler {
+  /**
+   * Constructor
+   * @param config configuration
+   * @param privateKey private key of account that trades
+   */
+  public constructor(config: NodeSDKConfig, privateKey: string) {
+    super(config, privateKey);
+  }
+}