@d8x/perpetuals-sdk 0.0.21 → 0.0.22

package/src/perpetualDataHandler.ts

@@ -29,8 +29,17 @@ import {
   DEFAULT_CONFIG_TESTNET_NAME,
   DEFAULT_CONFIG_TESTNET,
   ONE_64x64,
+  PERP_STATE_STR,
+  PerpetualState,
 } from "./nodeSDKTypes";
-import { fromBytes4HexString, to4Chars, combineFlags, containsFlag } from "./utils";
+import {
+  fromBytes4HexString,
+  to4Chars,
+  combineFlags,
+  containsFlag,
+  contractSymbolToSymbol,
+  symbol4BToLongSymbol,
+} from "./utils";
 import {
   ABK64x64ToFloat,
   floatToABK64x64,
@@ -50,6 +59,8 @@ export default class PerpetualDataHandler {
   //this is initialized in the createProxyInstance function
   protected symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>;
   protected poolStaticInfos: Array<PoolStaticInfo>;
+  protected symbolList: Array<{ [key: string]: string }>;
+
   //map margin token of the form MATIC or ETH or USDC into
   //the address of the margin token
   protected symbolToTokenAddrMap: Map<string, string>;
@@ -83,6 +94,7 @@ export default class PerpetualDataHandler {
     this.proxyABI = require(config.proxyABILocation);
     this.lobFactoryABI = require(config.limitOrderBookFactoryABILocation);
     this.lobABI = require(config.limitOrderBookABILocation);
+    this.symbolList = require(config.symbolListLocation);
   }
 
   protected async initContractsAndData(signerOrProvider: ethers.Signer | ethers.providers.Provider) {
@@ -98,8 +110,7 @@ export default class PerpetualDataHandler {
    * @returns order book contract for the perpetual
    */
   public getOrderBookContract(symbol: string): ethers.Contract {
-    let cleanSymbol = PerpetualDataHandler.symbolToBytes4Symbol(symbol);
-    let orderBookAddr = this.symbolToPerpStaticInfo.get(cleanSymbol)?.limitOrderBookAddr;
+    let orderBookAddr = this.symbolToPerpStaticInfo.get(symbol)?.limitOrderBookAddr;
     if (orderBookAddr == "" || orderBookAddr == undefined || this.signerOrProvider == null) {
       throw Error(`no limit order book found for ${symbol} or no signer`);
     }
@@ -132,10 +143,10 @@ export default class PerpetualDataHandler {
 
       for (let k = 0; k < perpetualIDs.length; k++) {
         let perp = await proxyContract.getPerpetual(perpetualIDs[k]);
-        let base = fromBytes4HexString(perp.S2BaseCCY);
-        let quote = fromBytes4HexString(perp.S2QuoteCCY);
-        let base3 = fromBytes4HexString(perp.S3BaseCCY);
-        let quote3 = fromBytes4HexString(perp.S3QuoteCCY);
+        let base = contractSymbolToSymbol(perp.S2BaseCCY, this.symbolList);
+        let quote = contractSymbolToSymbol(perp.S2QuoteCCY, this.symbolList);
+        let base3 = contractSymbolToSymbol(perp.S3BaseCCY, this.symbolList);
+        let quote3 = contractSymbolToSymbol(perp.S3QuoteCCY, this.symbolList);
         currentSymbols.push(base + "-" + quote);
         currentSymbolsS3.push(base3 + "-" + quote3);
         initRate.push(ABK64x64ToFloat(perp.fInitialMarginRate));
@@ -155,19 +166,17 @@ export default class PerpetualDataHandler {
           poolCCY = quote;
           ccy.push(CollaterlCCY.QUOTE);
         } else {
+          poolCCY = base3;
           ccy.push(CollaterlCCY.QUANTO);
         }
       }
       if (perpetualIDs.length == 0) {
         continue;
       }
-      if (poolCCY == undefined) {
-        throw Error("Pool only has quanto perps, unable to determine collateral currency");
-      }
       let oracleFactoryAddr = await proxyContract.getOracleFactory();
       let info: PoolStaticInfo = {
         poolId: j + 1,
-        poolMarginSymbol: poolCCY,
+        poolMarginSymbol: poolCCY!,
         poolMarginTokenAddr: poolMarginTokenAddr,
         shareTokenAddr: pool.shareTokenAddress,
         oracleFactoryAddr: oracleFactoryAddr,
@@ -188,7 +197,7 @@ export default class PerpetualDataHandler {
         });
       }
       // push margin token address into map
-      this.symbolToTokenAddrMap.set(poolCCY, poolMarginTokenAddr);
+      this.symbolToTokenAddrMap.set(poolCCY!, poolMarginTokenAddr);
     }
   }
 
@@ -219,6 +228,21 @@ export default class PerpetualDataHandler {
     return PerpetualDataHandler.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
   }
 
+  /**
+   * Get the symbol in long format of the perpetual id
+   * @param perpId perpetual id
+   */
+  public getSymbolFromPerpId(perpId: number): string | undefined {
+    let symbol4Bytes = PerpetualDataHandler.perpetualIdToSymbol(perpId, this.symbolToPerpStaticInfo);
+    if (symbol4Bytes == undefined) {
+      return undefined;
+    }
+  }
+
+  public symbol4BToLongSymbol(sym: string): string {
+    return symbol4BToLongSymbol(sym, this.symbolList);
+  }
+
   protected static _getSymbolFromPoolId(poolId: number, staticInfos: PoolStaticInfo[]): string {
     let idx = poolId - 1;
     return staticInfos[idx].poolMarginSymbol;
@@ -230,10 +254,8 @@ export default class PerpetualDataHandler {
     if (symbols.length == 3) {
       symbol = symbols[2];
     }
-    let cleanSymbol = to4Chars(symbol);
-    cleanSymbol = cleanSymbol.replace(/\0/g, "");
     let j = 0;
-    while (j < staticInfos.length && staticInfos[j].poolMarginSymbol != cleanSymbol) {
+    while (j < staticInfos.length && staticInfos[j].poolMarginSymbol != symbol) {
       j++;
     }
     if (j == staticInfos.length) {
@@ -262,8 +284,10 @@ export default class PerpetualDataHandler {
     symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>,
     _proxyContract: ethers.Contract
   ): Promise<MarginAccount> {
-    let cleanSymbol = PerpetualDataHandler.symbolToBytes4Symbol(symbol);
-    let perpId = PerpetualDataHandler.symbolToPerpetualId(cleanSymbol, symbolToPerpStaticInfo);
+    let perpId = Number(symbol);
+    if (isNaN(perpId)) {
+      perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+    }
     const idx_cash = 3;
     const idx_notional = 4;
     const idx_locked_in = 5;
@@ -283,7 +307,7 @@ export default class PerpetualDataHandler {
       entryPrice = 0;
     if (!isEmpty) {
       [S2Liq, S3Liq, tau, pnl, unpaidFundingCC] = PerpetualDataHandler._calculateLiquidationPrice(
-        cleanSymbol,
+        symbol,
         traderState,
         symbolToPerpStaticInfo
       );
@@ -329,15 +353,40 @@ export default class PerpetualDataHandler {
     return ABK64x64ToFloat(ammState[6].mul(ONE_64x64.add(ammState[8])).div(ONE_64x64));
   }
 
+  protected static async _queryPerpetualState(
+    symbol: string,
+    symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>,
+    _proxyContract: ethers.Contract
+  ): Promise<PerpetualState> {
+    let perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, symbolToPerpStaticInfo);
+    let ccy = symbol.split("-");
+    let ammState = await _proxyContract.getAMMState(perpId);
+    let markPrice = ABK64x64ToFloat(ammState[6].mul(ONE_64x64.add(ammState[8])).div(ONE_64x64));
+    let state = {
+      id: perpId,
+      state: PERP_STATE_STR[ammState[13]],
+      baseCurrency: ccy[0],
+      quoteCurrency: ccy[1],
+      indexPrice: ABK64x64ToFloat(ammState[6]),
+      collToQuoteIndexPrice: ABK64x64ToFloat(ammState[7]),
+      markPrice: markPrice,
+      midPrice: ABK64x64ToFloat(ammState[10]),
+      currentFundingRateBps: ABK64x64ToFloat(ammState[14]) * 1e4,
+      openInterestBC: ABK64x64ToFloat(ammState[11]),
+      maxPositionBC: ABK64x64ToFloat(ammState[12]),
+    };
+    return state;
+  }
+
   /**
    * Liquidation price
-   * @param cleanSymbol symbol after calling symbolToBytes4Symbol
+   * @param symbol symbol of the form BTC-USD-MATIC
    * @param traderState BigInt array according to smart contract
    * @param symbolToPerpStaticInfo mapping symbol->PerpStaticInfo
    * @returns liquidation mark-price, corresponding collateral/quote conversion
    */
   protected static _calculateLiquidationPrice(
-    cleanSymbol: string,
+    symbol: string,
     traderState: BigNumber[],
     symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>
   ): [number, number, number, number, number] {
@@ -350,9 +399,9 @@ export default class PerpetualDataHandler {
     const idx_s2 = 10;
     let S2Liq: number;
     let S3Liq: number = ABK64x64ToFloat(traderState[idx_s3]);
-    let perpInfo: PerpetualStaticInfo | undefined = symbolToPerpStaticInfo.get(cleanSymbol);
+    let perpInfo: PerpetualStaticInfo | undefined = symbolToPerpStaticInfo.get(symbol);
     if (perpInfo == undefined) {
-      throw new Error(`no info for perpetual ${cleanSymbol}`);
+      throw new Error(`no info for perpetual ${symbol}`);
     }
     let tau = perpInfo.maintenanceMarginRate;
     let lockedInValueQC = ABK64x64ToFloat(traderState[idx_locked_in]);
@@ -382,7 +431,7 @@ export default class PerpetualDataHandler {
    * Finds the perpetual id for a symbol of the form
    * <base>-<quote>-<collateral>. The function first converts the
    * token names into bytes4 representation
-   * @param symbol                  symbol (e.g., BTC-USD-MATIC)
+   * @param symbol                  symbol (e.g., BTC-USD-MATC)
    * @param symbolToPerpStaticInfo  map that contains the bytes4-symbol to PerpetualStaticInfo
    * including id mapping
    * @returns perpetual id or it fails
@@ -391,14 +440,32 @@ export default class PerpetualDataHandler {
     symbol: string,
     symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>
   ): number {
-    let cleanSymbol = PerpetualDataHandler.symbolToBytes4Symbol(symbol);
-    let id = symbolToPerpStaticInfo.get(cleanSymbol)?.id;
+    let id = symbolToPerpStaticInfo.get(symbol)?.id;
     if (id == undefined) {
       throw Error(`No perpetual found for symbol ${symbol}`);
     }
     return id;
   }
 
+  /**
+   * Find the symbol ("ETH-USD-MATC") of the given perpetual id
+   * @param id perpetual id
+   * @param symbolToPerpStaticInfo map that contains the bytes4-symbol to PerpetualStaticInfo
+   * @returns symbol string or undefined
+   */
+  protected static perpetualIdToSymbol(
+    id: number,
+    symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>
+  ): string | undefined {
+    let symbol;
+    for (symbol of symbolToPerpStaticInfo.keys()) {
+      if (symbolToPerpStaticInfo.get(symbol)?.id == id) {
+        return symbol;
+      }
+    }
+    return undefined;
+  }
+
   protected static symbolToBytes4Symbol(symbol: string): string {
     //split by dashes BTC-USD-MATIC
     let symbols: string[] = symbol.split("-");
@@ -588,8 +655,7 @@ export default class PerpetualDataHandler {
   }
 
   protected static _getLotSize(symbol: string, symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>): number {
-    let cleanSymbol = PerpetualDataHandler.symbolToBytes4Symbol(symbol);
-    let perpInfo: PerpetualStaticInfo | undefined = symbolToPerpStaticInfo.get(cleanSymbol);
+    let perpInfo: PerpetualStaticInfo | undefined = symbolToPerpStaticInfo.get(symbol);
     if (perpInfo == undefined) {
       throw new Error(`no info for perpetual ${symbol}`);
     }

package/src/perpetualEventHandler.ts

@@ -0,0 +1,441 @@
+import { BigNumber, utils } from "ethers";
+import { ABK64x64ToFloat, mul64x64, div64x64 } from "./d8XMath";
+import {
+  PerpetualState,
+  ONE_64x64,
+  ExchangeInfo,
+  Order,
+  SmartContractOrder,
+  MarginAccount,
+  OrderStruct,
+  TradeEvent,
+} from "./nodeSDKTypes";
+import { emitWarning } from "process";
+import MarketData from "./marketData";
+
+/**
+ * This class handles events and stores relevant variables
+ * as member variables. The events change the state of the member variables:
+ *  mktData : MarketData relevant market data with current state (e.g. index price)
+ *  ordersInPerpetual: Map<number, OrderStruct> all open orders for the given trader
+ *  positionInPerpetual: Map<number, MarginAccount> all open positions for the given trader
+ *
+ *  TODO:
+ *    - update functions for midprice & index & collateral prices without event
+ *    - testing
+ *
+ * Get data:
+ *  - getPerpetualData(perp id (string) or symbol) : PerpetualState. This is a reference!
+ *  - getExchangeInfo() : ExchangeInfo. This is a reference!
+ *  - getCurrentPositionRisk(perp id (string) or symbol) : MarginAccount. This is a reference!
+ *  - getOrdersInPerpetualMap : Map<number, OrderStruct>. This is a reference!
+ *  - getpositionInPerpetualMap : Map<number, MarginAccount>. This is a reference!
+ *
+ * Construct with a trader address and a marketData object
+ * Initialize to gather all the relevant data.
+ * Send event variables to event handler "on<EventName>" - this updates members
+ * - [x] onUpdateMarkPrice              : emitted on proxy; updates markprice and index price data
+ * - [x] onUpdateUpdateFundingRate      : emitted on proxy; sets funding rate
+ * - [x] onExecutionFailed              : emitted on order book; removes an open order
+ * - [x] onPerpetualLimitOrderCancelled : emitted on order book; removes an open order
+ * - [x] onPerpetualLimitOrderCreated   : emitted on order book; adds an open order to the data
+ * - [x] async onUpdateMarginAccount    : emitted on proxy; updates position data and open interest
+ * - [x] onTrade                        : emitted on proxy; returns TradeEvent to be displayed
+ */
+export default class PerpetualEventHandler {
+  // market data class
+  private mktData: MarketData;
+  // trader for which the data is tracked
+  private traderAddr: string;
+
+  // perpetual id to trader data
+  private ordersInPerpetual: Map<number, OrderStruct>;
+  private positionInPerpetual: Map<number, MarginAccount>;
+
+  // keep current state of the system in exchangeInfo
+  // data is updated when calling "onEvent"-functions
+  private exchangeInfo: ExchangeInfo | undefined;
+
+  constructor(mktData: MarketData, traderAddr: string) {
+    this.mktData = mktData;
+    this.traderAddr = traderAddr;
+    this.ordersInPerpetual = new Map<number, OrderStruct>();
+    this.positionInPerpetual = new Map<number, MarginAccount>();
+  }
+
+  /**
+   * Call this async function to initialize the
+   * market data
+   */
+  public async initialize() {
+    this.exchangeInfo = await this.mktData.exchangeInfo();
+    // loop through all pools and perpetuals and get
+    // open positions and open orders
+    for (let k = 0; k < this.exchangeInfo.pools.length; k++) {
+      let poolState = this.exchangeInfo.pools[k];
+      let poolSymbol = poolState.poolSymbol;
+      for (let j = 0; j < poolState.perpetuals.length; j++) {
+        let perpState: PerpetualState = poolState.perpetuals[j];
+        let perpSymbol = perpState.baseCurrency + "-" + perpState.quoteCurrency + "-" + poolSymbol;
+        let orders = await this.mktData.openOrders(this.traderAddr, perpSymbol);
+        let perpId = perpState.id;
+        this.ordersInPerpetual.set(perpId, orders);
+        let position = await this.mktData.positionRisk(this.traderAddr, perpSymbol);
+        this.positionInPerpetual.set(perpId, position);
+      }
+    }
+  }
+
+  /**
+   * Get the current exchange info
+   * @returns exchange info
+   */
+  public getExchangeInfo(): ExchangeInfo | undefined {
+    return this.exchangeInfo;
+  }
+
+  /**
+   * getOrdersInPerpetualMap
+   * @returns this.ordersInPerpetual
+   */
+  public getOrdersInPerpetualMap(): Map<number, OrderStruct> {
+    return this.ordersInPerpetual;
+  }
+
+  /**
+   * getpositionInPerpetualMap
+   * @returns this.positionInPerpetual
+   */
+  public getpositionInPerpetualMap(): Map<number, MarginAccount> {
+    return this.positionInPerpetual;
+  }
+
+  /**
+   * Get the data for a perpetual with a given index
+   * @param perpetualIdOrSymbol perpetual idx as string or symbol for which we want the data
+   * @returns perpetual data for this idx
+   */
+  public getPerpetualData(perpetualIdOrSymbol: string): PerpetualState | undefined {
+    let perpId = Number(perpetualIdOrSymbol);
+    if (isNaN(perpId)) {
+      perpId = this.mktData.getPerpIdFromSymbol(perpetualIdOrSymbol);
+    }
+    //uint24 perpetualId = uint24(_iPoolId) * 100_000 + iPerpetualIndex;
+    let poolIdx = Math.floor(perpId / 100_000);
+    let perpetuals = this.exchangeInfo?.pools[poolIdx].perpetuals;
+    if (perpetuals == undefined) {
+      emitWarning(`exchangeInfo not found, initialize perpetualEventHandler`);
+      return undefined;
+    }
+    // find perpetual
+    let k;
+    for (k = 0; k < perpetuals?.length && perpetuals[k].id != perpId; k++);
+    if (perpetuals[k].id != perpId) {
+      emitWarning(`getPerpetualData: perpetual id ${perpId} not found`);
+      return undefined;
+    }
+    return perpetuals[k];
+  }
+
+  /**
+   * Get the trader's current position risk (margin account data)
+   * @param perpetualIdOrSymbol perpetual id as string ('100003') or symbol ('BTC-USD-MATIC')
+   * @returns undefined if no position or margin account (='position risk')
+   */
+  public getCurrentPositionRisk(perpetualIdOrSymbol: string): MarginAccount | undefined {
+    let perpId = Number(perpetualIdOrSymbol);
+    if (isNaN(perpId)) {
+      perpId = this.mktData.getPerpIdFromSymbol(perpetualIdOrSymbol);
+    }
+    return this.positionInPerpetual.get(perpId);
+  }
+
+  /**
+   * Update the following prices:
+   *  - index price
+   *  - collateral price
+   *  - mid-price
+   * @param perpetualIdOrSymbol perpetual id as string ('100003') or symbol ('BTC-USD-MATIC')
+   */
+  public async updatePrices(perpetualIdOrSymbol: string) {
+    let perpId = Number(perpetualIdOrSymbol);
+    let symbol = perpetualIdOrSymbol;
+    if (!isNaN(perpId)) {
+      let sym = this.mktData.getSymbolFromPerpId(perpId);
+      if (sym == undefined) {
+        throw new Error(`Symbol not found for perpetual ${perpId}`);
+      }
+      symbol = sym;
+    }
+    let perpState: PerpetualState = await this.mktData.getPerpetualState(symbol);
+    let perp = this.getPerpetualData(symbol);
+    if (perp == undefined) {
+      throw new Error(`Perpetual not found: ${symbol}`);
+    }
+    perp.state = perpState.state;
+    perp.indexPrice = perpState.indexPrice;
+    perp.collToQuoteIndexPrice = perpState.collToQuoteIndexPrice;
+    perp.markPrice = perpState.markPrice;
+    perp.midPrice = perpState.midPrice;
+    perp.currentFundingRateBps = perpState.currentFundingRateBps;
+    perp.openInterestBC = perpState.openInterestBC;
+    perp.maxPositionBC = perpState.maxPositionBC;
+    perp.indexPrice = perpState.indexPrice;
+    perp.collToQuoteIndexPrice = perpState.collToQuoteIndexPrice;
+  }
+
+  /**
+   * Handle the event UpdateMarkPrice and update relevant
+   * data
+   * @param perpetualId perpetual Id
+   * @param fMarkPricePremium premium rate in ABDK format
+   * @param fSpotIndexPrice spot index price in ABDK format
+   * @returns void
+   */
+  public onUpdateMarkPrice(perpetualId: number, fMarkPricePremium: BigNumber, fSpotIndexPrice: BigNumber): void {
+    let [newMarkPrice, newIndexPrice] = PerpetualEventHandler.ConvertUpdateMarkPrice(
+      fMarkPricePremium,
+      fSpotIndexPrice
+    );
+    let perpetual = this.getPerpetualData(perpetualId.toString());
+    if (perpetual == undefined) {
+      return;
+    }
+    perpetual.markPrice = newMarkPrice;
+    perpetual.indexPrice = newIndexPrice;
+  }
+
+  /**
+   * Handle the event UpdateFundingRate and update relevant
+   * data
+   * UpdateFundingRate(uint24 indexed perpetualId, int128 fFundingRate)
+   * @param fFundingRate funding rate in ABDK format
+   */
+  public onUpdateUpdateFundingRate(perpetualId: number, fFundingRate: BigNumber): void {
+    let newRate = ABK64x64ToFloat(fFundingRate);
+    let perpetual = this.getPerpetualData(perpetualId.toString());
+    if (perpetual == undefined) {
+      return;
+    }
+    perpetual.currentFundingRateBps = newRate * 1e4;
+  }
+
+  /**
+   * event ExecutionFailed(
+        uint24 indexed perpetualId,
+        address indexed trader,
+        bytes32 digest,
+        string reason
+    );
+   * @param perpetualId id of the perpetual
+   * @param trader address of the trader
+   * @param digest digest of the order/cancel order
+   * @param reason reason why the execution failed
+   */
+  public onExecutionFailed(perpetualId: number, trader: string, digest: string, reason: string) {
+    if (trader != this.traderAddr) {
+      emitWarning(`onExecutionFailed: trader ${trader} not relevant`);
+      return;
+    }
+    // remove order from open orders
+    let orderStructs:
+      | {
+          orders: Order[];
+          orderIds: string[];
+        }
+      | undefined = this.ordersInPerpetual.get(perpetualId);
+    if (orderStructs == undefined) {
+      emitWarning(`onExecutionFailed: no order found for perpetual ${perpetualId}`);
+      return;
+    }
+    if (reason == "cancel delay required") {
+      // canceling failed. We don't remove the order
+      return;
+    }
+    PerpetualEventHandler.deleteOrder(orderStructs, digest);
+  }
+
+  /**
+   * Event emitted by perpetual proxy
+   * event PerpetualLimitOrderCancelled(bytes32 indexed orderHash);
+   * @param orderId string order id/digest
+   */
+  public onPerpetualLimitOrderCancelled(orderId: string) {
+    // remove order from open orders
+    let perpId: number | undefined = PerpetualEventHandler.findOrderForId(orderId, this.ordersInPerpetual);
+    if (perpId == undefined) {
+      emitWarning(`onPerpetualLimitOrderCancelled: no order found with id ${orderId}`);
+      return;
+    }
+    let orderStruct: OrderStruct | undefined = this.ordersInPerpetual.get(perpId);
+    PerpetualEventHandler.deleteOrder(orderStruct!, orderId);
+  }
+
+  /**
+   * event PerpetualLimitOrderCreated(
+   *    uint24 indexed perpetualId,
+   *    address indexed trader,
+   *    address referrerAddr,
+   *    address brokerAddr,
+   *    Order order,
+   *    bytes32 digest
+   *)
+   * @param perpetualId id of the perpetual
+   * @param trader address of the trader
+   * @param referrerAddr address of the referrer
+   * @param brokerAddr address of the broker
+   * @param Order order struct
+   * @param digest order id
+   */
+  public onPerpetualLimitOrderCreated(
+    perpetualId: number,
+    trader: string,
+    referrerAddr: string,
+    brokerAddr: string,
+    Order: SmartContractOrder,
+    digest: string
+  ): void {
+    if (trader != this.traderAddr) {
+      emitWarning(`onPerpetualLimitOrderCreated: trader ${trader} not relevant`);
+      return;
+    }
+    let order: Order = this.mktData.smartContractOrderToOrder(Order);
+    let orderStruct: OrderStruct | undefined = this.ordersInPerpetual.get(perpetualId);
+    if (orderStruct == undefined) {
+      // no order for this perpetual so far
+      this.ordersInPerpetual.set(perpetualId, { orders: [order], orderIds: [digest] });
+    } else {
+      orderStruct.orderIds.push(digest);
+      orderStruct.orders.push(order);
+    }
+  }
+
+  /**
+   * This function is async -> queries the margin account
+   * @param perpetualId id of the perpetual
+   * @param trader trader address
+   * @param positionId position id
+   * @param fPositionBC position size in base currency
+   * @param fCashCC margin collateral in margin account
+   * @param fLockedInValueQC pos*average opening price
+   * @param fFundingPaymentCC funding payment made
+   * @param fOpenInterestBC open interest
+   */
+  public async onUpdateMarginAccount(
+    perpetualId: number,
+    trader: string,
+    positionId: string,
+    fPositionBC: BigNumber,
+    fCashCC: BigNumber,
+    fLockedInValueQC: BigNumber,
+    fFundingPaymentCC: BigNumber,
+    fOpenInterestBC: BigNumber
+  ): Promise<void> {
+    let perpetual = this.getPerpetualData(perpetualId.toString());
+    if (perpetual == undefined) {
+      emitWarning(`onUpdateMarginAccount: perpetual ${perpetualId} not found`);
+      return;
+    }
+    perpetual.openInterestBC = ABK64x64ToFloat(fOpenInterestBC);
+    if (trader != this.traderAddr) {
+      return;
+    }
+    let perpetualIdStr = perpetualId.toString();
+    let margin = await this.mktData.positionRisk(this.traderAddr, perpetualIdStr);
+    this.positionInPerpetual.set(perpetualId, margin);
+  }
+
+  /**
+   *
+   * @param perpetualId perpetual id
+   * @param trader trader address
+   * @param positionId position id
+   * @param order order struct
+   * @param orderDigest order id
+   * @param newPositionSizeBC new pos size in base currency ABDK
+   * @param price price in ABDK format
+   * @returns trade event data in regular number format
+   */
+  public onTrade(
+    perpetualId: number,
+    trader: string,
+    positionId: string,
+    order: SmartContractOrder,
+    orderDigest: string,
+    newPositionSizeBC: BigNumber,
+    price: BigNumber
+  ): TradeEvent {
+    // remove order digest from open orders
+    let orderStructs = this.ordersInPerpetual.get(perpetualId);
+    if (orderStructs == undefined) {
+      emitWarning(`onTrade: executed order not found ${orderDigest}`);
+    } else {
+      PerpetualEventHandler.deleteOrder(orderStructs, orderDigest);
+    }
+    // return transformed trade info
+    return {
+      perpetualId: perpetualId,
+      positionId: positionId,
+      orderId: orderDigest,
+      newPositionSizeBC: ABK64x64ToFloat(newPositionSizeBC),
+      executionPrice: ABK64x64ToFloat(newPositionSizeBC),
+    };
+  }
+
+  /**
+   * static function to find the number of the  OrderStruct with given orderId
+   * @param orderId id/digest of order
+   * @param orderMap mapping for perpetualId->OrderStruct
+   * @returns id of perpetual that contains order with id = orderId or undefined
+   */
+  private static findOrderForId(orderId: string, orderMap: Map<number, OrderStruct>): number | undefined {
+    /*orderMapMap<number, {
+      orders: Order[];
+      orderIds: string[];*/
+    for (const perpId of orderMap.keys()) {
+      let orderStructs = orderMap.get(perpId);
+      if (orderStructs?.orderIds.includes(orderId)) {
+        return perpId;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Delete the order with given id from the class member data
+   * @param orderStructs array of order struct as stored for the trader and a given perpetual
+   * @param orderId digest/order id
+   * @returns void
+   */
+  private static deleteOrder(orderStructs: OrderStruct, orderId: string): void {
+    // find order
+    let k;
+    for (k = 0; k < orderStructs.orderIds.length && orderStructs.orderIds[k] != orderId; k++);
+    if (orderStructs.orderIds[k] != orderId) {
+      emitWarning(`deleteOrder: no order found with digest ${orderId}`);
+      return;
+    }
+    // delete element k on reference of orders
+    orderStructs.orders[k] = orderStructs.orders[orderStructs.orders.length - 1];
+    orderStructs.orders.pop();
+    orderStructs.orderIds[k] = orderStructs.orderIds[orderStructs.orderIds.length - 1];
+    orderStructs.orderIds.pop();
+  }
+
+  /**
+   * UpdateMarkPrice(
+   *  uint24 indexed perpetualId,
+   *  int128 fMarkPricePremium,
+   *  int128 fSpotIndexPrice
+   * )
+   * @param fMarkPricePremium premium rate in ABDK format
+   * @param fSpotIndexPrice spot index price in ABDK format
+   * @returns mark price and spot index in float
+   */
+  private static ConvertUpdateMarkPrice(fMarkPricePremium: BigNumber, fSpotIndexPrice: BigNumber): [number, number] {
+    let fMarkPrice = mul64x64(fSpotIndexPrice, ONE_64x64.add(fMarkPricePremium));
+    let markPrice = ABK64x64ToFloat(fMarkPrice);
+    let indexPrice = ABK64x64ToFloat(fSpotIndexPrice);
+    return [markPrice, indexPrice];
+  }
+}