@d8x/perpetuals-sdk 0.0.23 → 0.0.24

package/config/symbolList.json

@@ -1,9 +1,13 @@
-[
-  { "symbol": "USD", "cleanSymbol": "USD" },
-  { "symbol": "BTC", "cleanSymbol": "BTC" },
-  { "symbol": "ETH", "cleanSymbol": "ETH" },
-  { "symbol": "MATIC", "cleanSymbol": "MATC" },
-  { "symbol": "CHF", "cleanSymbol": "CHF" },
-  { "symbol": "GBP", "cleanSymbol": "GBP" },
-  { "symbol": "XAU", "cleanSymbol": "XAU" }
-]
+{
+  "MATC": "MATIC",
+  "ETH": "ETH",
+  "BTC": "BTC",
+  "USDC": "USDC",
+  "XAU": "XAU",
+  "XAG": "XAG",
+  "USD": "USD",
+  "GBP": "GBP",
+  "CHF": "CHF",
+  "EUR": "EUR",
+  "JPY": "JPY"
+}

package/dist/accountTrade.js

@@ -154,8 +154,6 @@ class AccountTrade extends writeAccessHandler_1.default {
                 throw Error("order size too small");
             }
             let orderBookContract = this.getOrderBookContract(order.symbol);
-            let tx;
-            let orderId;
             let res = yield this._order(order, this.traderAddr, this.symbolToPerpStaticInfo, this.proxyContract, orderBookContract, this.chainId, this.signer, this.gasLimit);
             return res;
         });

package/dist/brokerTool.d.ts

@@ -249,11 +249,8 @@ export default class BrokerTool extends WriteAccessHandler {
     /**
      * Adds this broker's signature to an order. An order signed by a broker is considered
      * to be routed through this broker and benefits from the broker's fee conditions.
-     * @param {Order} order Order to sign.
+     * @param {Order} order Order to sign. It must contain valid broker fee, broker address, and order deadline.
      * @param {string} traderAddr Address of trader submitting the order.
-     * @param {number} feeDecimals Fee that this broker imposes on this order.
-     * The fee is sent to the broker's wallet. Fee should be specified in decimals, e.g., 0.0001 equals 1bps.
-     * @param {number} deadline Deadline for the order to be executed. Specify deadline as a unix timestamp
      * @example
      * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
      * async function main() {
@@ -281,7 +278,7 @@ export default class BrokerTool extends WriteAccessHandler {
      *
      * @returns {Order} An order signed by this broker, which can be submitted directly with AccountTrade.order.
      */
-    signOrder(order: Order, traderAddr: string, brokerFee: number, deadline: number): Promise<Order>;
+    signOrder(order: Order, traderAddr: string): Promise<Order>;
     /**
      * Creates a signature that a trader can use to place orders with this broker.
      * This signature can be used to pass on to a trader who wishes to trade via this SDK or directly on the blockchain.

package/dist/brokerTool.js

@@ -367,11 +367,8 @@ class BrokerTool extends writeAccessHandler_1.default {
     /**
      * Adds this broker's signature to an order. An order signed by a broker is considered
      * to be routed through this broker and benefits from the broker's fee conditions.
-     * @param {Order} order Order to sign.
+     * @param {Order} order Order to sign. It must contain valid broker fee, broker address, and order deadline.
      * @param {string} traderAddr Address of trader submitting the order.
-     * @param {number} feeDecimals Fee that this broker imposes on this order.
-     * The fee is sent to the broker's wallet. Fee should be specified in decimals, e.g., 0.0001 equals 1bps.
-     * @param {number} deadline Deadline for the order to be executed. Specify deadline as a unix timestamp
      * @example
      * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
      * async function main() {
@@ -399,15 +396,12 @@ class BrokerTool extends writeAccessHandler_1.default {
      *
      * @returns {Order} An order signed by this broker, which can be submitted directly with AccountTrade.order.
      */
-    signOrder(order, traderAddr, brokerFee, deadline) {
+    signOrder(order, traderAddr) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.proxyContract == null || this.signer == null) {
                 throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
             }
-            order.brokerAddr = this.traderAddr;
-            order.brokerFeeTbps = brokerFee * 100000;
-            order.deadline = Math.round(deadline);
-            order.brokerSignature = yield BrokerTool._signOrder(order.symbol, order.brokerFeeTbps, traderAddr, ethers_1.BigNumber.from(Math.round(deadline)), this.signer, this.chainId, this.proxyAddr, this.symbolToPerpStaticInfo);
+            order.brokerSignature = yield BrokerTool._signOrder(order.symbol, order.brokerFeeTbps, traderAddr, ethers_1.BigNumber.from(order.deadline), this.signer, this.chainId, this.proxyAddr, this.symbolToPerpStaticInfo);
             return order;
         });
     }

package/dist/d8XMath.d.ts

@@ -83,7 +83,7 @@ export declare function calculateLiquidationPriceCollateralQuote(LockedInValueQC
  * @param indexPriceS3 Collateral index price, positive.
  * @param tradePrice Expected price to trade tradeAmount.
  * @param feeRate
- * @returns
+ * @returns Total collateral amount needed for the new position to have he desired leverage.
  */
 export declare function getMarginRequiredForLeveragedTrade(targetLeverage: number | undefined, currentPosition: number, currentLockedInValue: number, tradeAmount: number, markPrice: number, indexPriceS2: number, indexPriceS3: number, tradePrice: number, feeRate: number): number;
 export declare function getMaxSignedPositionSize(marginCollateral: number, currentPosition: number, currentLockedInValue: number, direction: number, limitPrice: number, initialMarginRate: number, feeRate: number, markPrice: number, indexPriceS2: number, indexPriceS3: number): number;

package/dist/d8XMath.js

@@ -173,7 +173,7 @@ exports.calculateLiquidationPriceCollateralQuote = calculateLiquidationPriceColl
  * @param indexPriceS3 Collateral index price, positive.
  * @param tradePrice Expected price to trade tradeAmount.
  * @param feeRate
- * @returns
+ * @returns Total collateral amount needed for the new position to have he desired leverage.
  */
 function getMarginRequiredForLeveragedTrade(targetLeverage, currentPosition, currentLockedInValue, tradeAmount, markPrice, indexPriceS2, indexPriceS3, tradePrice, feeRate) {
     // we solve for margin in:

package/dist/liquiditatorTool.d.ts

@@ -0,0 +1,14 @@
+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
+     */
+    constructor(config: NodeSDKConfig, privateKey: string);
+}

package/dist/liquiditatorTool.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const writeAccessHandler_1 = __importDefault(require("./writeAccessHandler"));
+/**
+ * LiquidatorTool
+ * Methods to liquidate traders
+ */
+class LiquidatorTool extends writeAccessHandler_1.default {
+    /**
+     * Constructor
+     * @param config configuration
+     * @param privateKey private key of account that trades
+     */
+    constructor(config, privateKey) {
+        super(config, privateKey);
+    }
+}
+exports.default = LiquidatorTool;

package/dist/marketData.d.ts

@@ -150,6 +150,7 @@ export default class MarketData extends PerpetualDataHandler {
      * @returns {number} Price of index in given currency.
      */
     getOraclePrice(base: string, quote: string): Promise<number | undefined>;
+    getOrderStatus(symbol: string, orderId: string): Promise<string>;
     /**
      * Get the current mark price
      * @param symbol symbol of the form ETH-USD-MATIC
@@ -233,7 +234,5 @@ export default class MarketData extends PerpetualDataHandler {
      * @ignore
      */
     static orderIdsOfTrader(traderAddr: string, orderBookContract: ethers.Contract): Promise<string[]>;
-    static _exchangeInfo(_proxyContract: ethers.Contract, _poolStaticInfos: Array<PoolStaticInfo>, _symbolList: Array<{
-        [key: string]: string;
-    }>): Promise<ExchangeInfo>;
+    static _exchangeInfo(_proxyContract: ethers.Contract, _poolStaticInfos: Array<PoolStaticInfo>, _symbolList: Map<string, string>): Promise<ExchangeInfo>;
 }

package/dist/marketData.js

@@ -293,6 +293,17 @@ class MarketData extends perpetualDataHandler_1.default {
             return px == undefined ? undefined : (0, d8XMath_1.ABK64x64ToFloat)(px);
         });
     }
+    getOrderStatus(symbol, orderId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized. Use createProxyInstance().");
+            }
+            let orderBookContract = null;
+            orderBookContract = this.getOrderBookContract(symbol);
+            let status = yield orderBookContract.getOrderStatus(orderId);
+            return status;
+        });
+    }
     /**
      * Get the current mark price
      * @param symbol symbol of the form ETH-USD-MATIC

package/dist/perpetualDataHandler.d.ts

@@ -7,9 +7,7 @@ import { NodeSDKConfig, Order, SmartContractOrder, PerpetualStaticInfo, MarginAc
 export default class PerpetualDataHandler {
     protected symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>;
     protected poolStaticInfos: Array<PoolStaticInfo>;
-    protected symbolList: Array<{
-        [key: string]: string;
-    }>;
+    protected symbolList: Map<string, string>;
     protected symbolToTokenAddrMap: Map<string, string>;
     protected proxyContract: ethers.Contract | null;
     protected proxyABI: ethers.ContractInterface;

package/dist/perpetualDataHandler.js

@@ -34,7 +34,7 @@ class PerpetualDataHandler {
         this.proxyABI = require(config.proxyABILocation);
         this.lobFactoryABI = require(config.limitOrderBookFactoryABILocation);
         this.lobABI = require(config.limitOrderBookABILocation);
-        this.symbolList = require(config.symbolListLocation);
+        this.symbolList = new Map(Object.entries(require(config.symbolListLocation)));
     }
     initContractsAndData(signerOrProvider) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -95,21 +95,23 @@ class PerpetualDataHandler {
                     // try to find a limit order book
                     let lobAddr = yield this.lobFactoryContract.getOrderBookAddress(perpetualIDs[k]);
                     currentLimitOrderBookAddr.push(lobAddr);
-                    // we find out the pool currency by looking at all perpetuals
-                    // unless for quanto perpetuals, we know the pool currency
-                    // from the perpetual. This fails if we have a pool with only
-                    // quanto perpetuals
-                    if (perp.eCollateralCurrency == nodeSDKTypes_1.COLLATERAL_CURRENCY_BASE) {
-                        poolCCY = base;
-                        ccy.push(nodeSDKTypes_1.CollaterlCCY.BASE);
-                    }
-                    else if (perp.eCollateralCurrency == nodeSDKTypes_1.COLLATERAL_CURRENCY_QUOTE) {
-                        poolCCY = quote;
-                        ccy.push(nodeSDKTypes_1.CollaterlCCY.QUOTE);
-                    }
-                    else {
-                        poolCCY = base3;
-                        ccy.push(nodeSDKTypes_1.CollaterlCCY.QUANTO);
+                    if (poolCCY == undefined) {
+                        // we find out the pool currency by looking at all perpetuals
+                        // unless for quanto perpetuals, we know the pool currency
+                        // from the perpetual. This fails if we have a pool with only
+                        // quanto perpetuals
+                        if (perp.eCollateralCurrency == nodeSDKTypes_1.COLLATERAL_CURRENCY_BASE) {
+                            poolCCY = base;
+                            ccy.push(nodeSDKTypes_1.CollaterlCCY.BASE);
+                        }
+                        else if (perp.eCollateralCurrency == nodeSDKTypes_1.COLLATERAL_CURRENCY_QUOTE) {
+                            poolCCY = quote;
+                            ccy.push(nodeSDKTypes_1.CollaterlCCY.QUOTE);
+                        }
+                        else {
+                            poolCCY = base3;
+                            ccy.push(nodeSDKTypes_1.CollaterlCCY.QUANTO);
+                        }
                     }
                 }
                 if (perpetualIDs.length == 0) {

package/dist/utils.d.ts

@@ -35,21 +35,24 @@ export declare function fromBytes4(b: Buffer): string;
 export declare function fromBytes4HexString(s: string): string;
 /**
  *
- * @param {string} s string representing a hex-number ("0x...")
- * @param {Object} mapping list of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
- * @returns {string} user friendly currency symbol, e.g. "MATIC"
+ * @param {string} s String representing a hex-number ("0x...")
+ * @param {Object} mapping List of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
+ * @returns {string} User friendly currency symbol, e.g. "MATIC"
+ */
+export declare function contractSymbolToSymbol(s: string, mapping: Map<string, string>): string;
+/**
+ *
+ * @param {string} s User friendly currency symbol, e.g. "MATIC"
+ * @param {Object} mapping List of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
+ * @returns {Buffer} Buffer that can be used with smart contract to identify tokens
  */
-export declare function contractSymbolToSymbol(s: string, mapping: Array<{
-    [key: string]: string;
-}>): string | undefined;
+export declare function symbolToContractSymbol(s: string, mapping: Map<string, string>): Buffer;
 /**
  * Converts symbol or symbol combination into long format
  * @param {string} s symbol, e.g., USDC-MATC-USDC, MATC, USDC, ...
  * @param {Object} mapping list of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
  * @returns {string} long format e.g. MATIC. if not found the element is ""
  */
-export declare function symbol4BToLongSymbol(s: string, mapping: Array<{
-    [key: string]: string;
-}>): string;
+export declare function symbol4BToLongSymbol(s: string, mapping: Map<string, string>): string;
 export declare function combineFlags(f1: BigNumber, f2: BigNumber): BigNumber;
 export declare function containsFlag(f1: BigNumber, f2: BigNumber): boolean;

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.containsFlag = exports.combineFlags = exports.symbol4BToLongSymbol = exports.contractSymbolToSymbol = exports.fromBytes4HexString = exports.fromBytes4 = exports.toBytes4 = exports.to4Chars = void 0;
+exports.containsFlag = exports.combineFlags = exports.symbol4BToLongSymbol = exports.symbolToContractSymbol = exports.contractSymbolToSymbol = exports.fromBytes4HexString = exports.fromBytes4 = exports.toBytes4 = exports.to4Chars = void 0;
 const ethers_1 = require("ethers");
 /**
  * @module utils
@@ -78,19 +78,36 @@ function fromBytes4HexString(s) {
 exports.fromBytes4HexString = fromBytes4HexString;
 /**
  *
- * @param {string} s string representing a hex-number ("0x...")
- * @param {Object} mapping list of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
- * @returns {string} user friendly currency symbol, e.g. "MATIC"
+ * @param {string} s String representing a hex-number ("0x...")
+ * @param {Object} mapping List of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
+ * @returns {string} User friendly currency symbol, e.g. "MATIC"
  */
 function contractSymbolToSymbol(s, mapping) {
-    s = fromBytes4HexString(s);
-    for (let pair of mapping) {
-        if (pair.cleanSymbol == s) {
-            return pair.symbol;
+    var _a;
+    let shortCCY = fromBytes4HexString(s);
+    // assume CCY is already short if not in the mapping file
+    let longCCY = (_a = mapping.get(shortCCY)) !== null && _a !== void 0 ? _a : shortCCY;
+    return longCCY;
+}
+exports.contractSymbolToSymbol = contractSymbolToSymbol;
+/**
+ *
+ * @param {string} s User friendly currency symbol, e.g. "MATIC"
+ * @param {Object} mapping List of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
+ * @returns {Buffer} Buffer that can be used with smart contract to identify tokens
+ */
+function symbolToContractSymbol(s, mapping) {
+    let shortCCY = undefined;
+    for (let [k, v] of mapping) {
+        if (v == s) {
+            shortCCY = k;
         }
     }
+    // if not in the mapping file, assume ccy is already valid
+    shortCCY = shortCCY !== null && shortCCY !== void 0 ? shortCCY : s;
+    return toBytes4(shortCCY);
 }
-exports.contractSymbolToSymbol = contractSymbolToSymbol;
+exports.symbolToContractSymbol = symbolToContractSymbol;
 /**
  * Converts symbol or symbol combination into long format
  * @param {string} s symbol, e.g., USDC-MATC-USDC, MATC, USDC, ...
@@ -98,16 +115,13 @@ exports.contractSymbolToSymbol = contractSymbolToSymbol;
  * @returns {string} long format e.g. MATIC. if not found the element is ""
  */
 function symbol4BToLongSymbol(s, mapping) {
+    var _a;
     let ccy = s.split("-");
     let longCCY = "";
     for (let k = 0; k < ccy.length; k++) {
-        let sym = ccy[k];
-        for (let pair of mapping) {
-            if (pair.cleanSymbol == sym) {
-                longCCY = longCCY + "-" + pair.symbol;
-                break;
-            }
-        }
+        let sym = (_a = mapping.get(ccy[k])) !== null && _a !== void 0 ? _a : to4Chars(ccy[k]);
+        sym = sym.replace(/\0/g, "");
+        longCCY = longCCY + "-" + sym;
     }
     return longCCY.substring(1);
 }

package/package.json

@@ -27,7 +27,7 @@
   },
   "name": "@d8x/perpetuals-sdk",
   "description": "Node TypeScript SDK for D8X Perpetual Futures",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "directories": {

package/src/accountTrade.ts

@@ -150,8 +150,6 @@ export default class AccountTrade extends WriteAccessHandler {
       throw Error("order size too small");
     }
     let orderBookContract: ethers.Contract = this.getOrderBookContract(order.symbol);
-    let tx: ethers.ContractTransaction;
-    let orderId: string;
     let res: OrderResponse = await this._order(
       order,
       this.traderAddr,

package/src/brokerTool.ts

@@ -349,11 +349,8 @@ export default class BrokerTool extends WriteAccessHandler {
   /**
    * Adds this broker's signature to an order. An order signed by a broker is considered
    * to be routed through this broker and benefits from the broker's fee conditions.
-   * @param {Order} order Order to sign.
+   * @param {Order} order Order to sign. It must contain valid broker fee, broker address, and order deadline.
    * @param {string} traderAddr Address of trader submitting the order.
-   * @param {number} feeDecimals Fee that this broker imposes on this order.
-   * The fee is sent to the broker's wallet. Fee should be specified in decimals, e.g., 0.0001 equals 1bps.
-   * @param {number} deadline Deadline for the order to be executed. Specify deadline as a unix timestamp
    * @example
    * import { BrokerTool, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
    * async function main() {
@@ -381,18 +378,15 @@ export default class BrokerTool extends WriteAccessHandler {
    *
    * @returns {Order} An order signed by this broker, which can be submitted directly with AccountTrade.order.
    */
-  public async signOrder(order: Order, traderAddr: string, brokerFee: number, deadline: number): Promise<Order> {
+  public async signOrder(order: Order, traderAddr: string): Promise<Order> {
     if (this.proxyContract == null || this.signer == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }
-    order.brokerAddr = this.traderAddr;
-    order.brokerFeeTbps = brokerFee * 100_000;
-    order.deadline = Math.round(deadline);
     order.brokerSignature = await BrokerTool._signOrder(
       order.symbol,
-      order.brokerFeeTbps,
+      order.brokerFeeTbps!,
       traderAddr,
-      BigNumber.from(Math.round(deadline)),
+      BigNumber.from(order.deadline),
       this.signer,
       this.chainId,
       this.proxyAddr,

package/src/d8XMath.ts

@@ -190,7 +190,7 @@ export function calculateLiquidationPriceCollateralQuote(
  * @param indexPriceS3 Collateral index price, positive.
  * @param tradePrice Expected price to trade tradeAmount.
  * @param feeRate
- * @returns
+ * @returns Total collateral amount needed for the new position to have he desired leverage.
  */
 export function getMarginRequiredForLeveragedTrade(
   targetLeverage: number | undefined,

package/src/marketData.ts

@@ -371,6 +371,16 @@ export default class MarketData extends PerpetualDataHandler {
     return px == undefined ? undefined : ABK64x64ToFloat(px);
   }
 
+  public async getOrderStatus(symbol: string, orderId: string): Promise<string> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
+    }
+    let orderBookContract: ethers.Contract | null = null;
+    orderBookContract = this.getOrderBookContract(symbol);
+    let status = await orderBookContract.getOrderStatus(orderId);
+    return status;
+  }
+
   /**
    * Get the current mark price
    * @param symbol symbol of the form ETH-USD-MATIC
@@ -512,7 +522,7 @@ export default class MarketData extends PerpetualDataHandler {
   public static async _exchangeInfo(
     _proxyContract: ethers.Contract,
     _poolStaticInfos: Array<PoolStaticInfo>,
-    _symbolList: Array<{ [key: string]: string }>
+    _symbolList: Map<string, string>
   ): Promise<ExchangeInfo> {
     let nestedPerpetualIDs = await PerpetualDataHandler.getNestedPerpetualIds(_proxyContract);
     let factory = await _proxyContract.getOracleFactory();

package/src/perpetualDataHandler.ts

@@ -59,7 +59,7 @@ 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 }>;
+  protected symbolList: Map<string, string>;
 
   //map margin token of the form MATIC or ETH or USDC into
   //the address of the margin token
@@ -94,7 +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);
+    this.symbolList = new Map<string, string>(Object.entries(require(config.symbolListLocation)));
   }
 
   protected async initContractsAndData(signerOrProvider: ethers.Signer | ethers.providers.Provider) {
@@ -155,19 +155,21 @@ export default class PerpetualDataHandler {
         // try to find a limit order book
         let lobAddr = await this.lobFactoryContract.getOrderBookAddress(perpetualIDs[k]);
         currentLimitOrderBookAddr.push(lobAddr);
-        // we find out the pool currency by looking at all perpetuals
-        // unless for quanto perpetuals, we know the pool currency
-        // from the perpetual. This fails if we have a pool with only
-        // quanto perpetuals
-        if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_BASE) {
-          poolCCY = base;
-          ccy.push(CollaterlCCY.BASE);
-        } else if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_QUOTE) {
-          poolCCY = quote;
-          ccy.push(CollaterlCCY.QUOTE);
-        } else {
-          poolCCY = base3;
-          ccy.push(CollaterlCCY.QUANTO);
+        if (poolCCY == undefined) {
+          // we find out the pool currency by looking at all perpetuals
+          // unless for quanto perpetuals, we know the pool currency
+          // from the perpetual. This fails if we have a pool with only
+          // quanto perpetuals
+          if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_BASE) {
+            poolCCY = base;
+            ccy.push(CollaterlCCY.BASE);
+          } else if (perp.eCollateralCurrency == COLLATERAL_CURRENCY_QUOTE) {
+            poolCCY = quote;
+            ccy.push(CollaterlCCY.QUOTE);
+          } else {
+            poolCCY = base3;
+            ccy.push(CollaterlCCY.QUANTO);
+          }
         }
       }
       if (perpetualIDs.length == 0) {

package/src/perpetualEventHandler.ts

@@ -52,6 +52,9 @@ export default class PerpetualEventHandler {
   private ordersInPerpetual: Map<number, OrderStruct>;
   private positionInPerpetual: Map<number, MarginAccount>;
 
+  // perpetual id to pool index in exchange info
+  private poolIndexForPerpetual: Map<number, number>;
+
   // keep current state of the system in exchangeInfo
   // data is updated when calling "onEvent"-functions
   private exchangeInfo: ExchangeInfo | undefined;
@@ -61,6 +64,7 @@ export default class PerpetualEventHandler {
     this.traderAddr = traderAddr;
     this.ordersInPerpetual = new Map<number, OrderStruct>();
     this.positionInPerpetual = new Map<number, MarginAccount>();
+    this.poolIndexForPerpetual = new Map<number, number>();
   }
 
   /**
@@ -82,6 +86,7 @@ export default class PerpetualEventHandler {
         this.ordersInPerpetual.set(perpId, orders);
         let position = await this.mktData.positionRisk(this.traderAddr, perpSymbol);
         this.positionInPerpetual.set(perpId, position);
+        this.poolIndexForPerpetual.set(perpId, k);
       }
     }
   }
@@ -121,7 +126,7 @@ export default class PerpetualEventHandler {
       perpId = this.mktData.getPerpIdFromSymbol(perpetualIdOrSymbol);
     }
     //uint24 perpetualId = uint24(_iPoolId) * 100_000 + iPerpetualIndex;
-    let poolIdx = Math.floor(perpId / 100_000);
+    let poolIdx = this.poolIndexForPerpetual.get(perpId)!; //Math.floor(perpId / 100_000);
     let perpetuals = this.exchangeInfo?.pools[poolIdx].perpetuals;
     if (perpetuals == undefined) {
       emitWarning(`exchangeInfo not found, initialize perpetualEventHandler`);
@@ -192,8 +197,14 @@ export default class PerpetualEventHandler {
    * @param fSpotIndexPrice spot index price in ABDK format
    * @returns void
    */
-  public onUpdateMarkPrice(perpetualId: number, fMarkPricePremium: BigNumber, fSpotIndexPrice: BigNumber): void {
-    let [newMarkPrice, newIndexPrice] = PerpetualEventHandler.ConvertUpdateMarkPrice(
+  public onUpdateMarkPrice(
+    perpetualId: number,
+    fMidPricePremium: BigNumber,
+    fMarkPricePremium: BigNumber,
+    fSpotIndexPrice: BigNumber
+  ): void {
+    let [newMidPrice, newMarkPrice, newIndexPrice] = PerpetualEventHandler.ConvertUpdateMarkPrice(
+      fMidPricePremium,
       fMarkPricePremium,
       fSpotIndexPrice
     );
@@ -201,6 +212,7 @@ export default class PerpetualEventHandler {
     if (perpetual == undefined) {
       return;
     }
+    perpetual.midPrice = newMidPrice;
     perpetual.markPrice = newMarkPrice;
     perpetual.indexPrice = newIndexPrice;
   }
@@ -432,10 +444,16 @@ export default class PerpetualEventHandler {
    * @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] {
+  private static ConvertUpdateMarkPrice(
+    fMidPricePremium: BigNumber,
+    fMarkPricePremium: BigNumber,
+    fSpotIndexPrice: BigNumber
+  ): [number, number, number] {
     let fMarkPrice = mul64x64(fSpotIndexPrice, ONE_64x64.add(fMarkPricePremium));
+    let fMidPrice = mul64x64(fSpotIndexPrice, ONE_64x64.add(fMidPricePremium));
+    let midPrice = ABK64x64ToFloat(fMidPrice);
     let markPrice = ABK64x64ToFloat(fMarkPrice);
     let indexPrice = ABK64x64ToFloat(fSpotIndexPrice);
-    return [markPrice, indexPrice];
+    return [midPrice, markPrice, indexPrice];
   }
 }

package/src/utils.ts

@@ -77,17 +77,33 @@ export function fromBytes4HexString(s: string): string {
 
 /**
  *
- * @param {string} s string representing a hex-number ("0x...")
- * @param {Object} mapping list of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
- * @returns {string} user friendly currency symbol, e.g. "MATIC"
+ * @param {string} s String representing a hex-number ("0x...")
+ * @param {Object} mapping List of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
+ * @returns {string} User friendly currency symbol, e.g. "MATIC"
+ */
+export function contractSymbolToSymbol(s: string, mapping: Map<string, string>): string {
+  let shortCCY = fromBytes4HexString(s);
+  // assume CCY is already short if not in the mapping file
+  let longCCY = mapping.get(shortCCY) ?? shortCCY;
+  return longCCY;
+}
+
+/**
+ *
+ * @param {string} s User friendly currency symbol, e.g. "MATIC"
+ * @param {Object} mapping List of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
+ * @returns {Buffer} Buffer that can be used with smart contract to identify tokens
  */
-export function contractSymbolToSymbol(s: string, mapping: Array<{ [key: string]: string }>): string | undefined {
-  s = fromBytes4HexString(s);
-  for (let pair of mapping) {
-    if (pair.cleanSymbol == s) {
-      return pair.symbol;
+export function symbolToContractSymbol(s: string, mapping: Map<string, string>): Buffer {
+  let shortCCY: string | undefined = undefined;
+  for (let [k, v] of mapping) {
+    if (v == s) {
+      shortCCY = k;
     }
   }
+  // if not in the mapping file, assume ccy is already valid
+  shortCCY = shortCCY ?? s;
+  return toBytes4(shortCCY);
 }
 
 /**
@@ -96,17 +112,13 @@ export function contractSymbolToSymbol(s: string, mapping: Array<{ [key: string]
  * @param {Object} mapping list of symbol and clean symbol pairs, e.g. [{symbol: "MATIC", cleanSymbol: "MATC"}, ...]
  * @returns {string} long format e.g. MATIC. if not found the element is ""
  */
-export function symbol4BToLongSymbol(s: string, mapping: Array<{ [key: string]: string }>): string {
+export function symbol4BToLongSymbol(s: string, mapping: Map<string, string>): string {
   let ccy = s.split("-");
   let longCCY = "";
   for (let k = 0; k < ccy.length; k++) {
-    let sym = ccy[k];
-    for (let pair of mapping) {
-      if (pair.cleanSymbol == sym) {
-        longCCY = longCCY + "-" + pair.symbol;
-        break;
-      }
-    }
+    let sym = mapping.get(ccy[k]) ?? to4Chars(ccy[k]);
+    sym = sym.replace(/\0/g, "");
+    longCCY = longCCY + "-" + sym;
   }
   return longCCY.substring(1);
 }