@d8x/perpetuals-sdk 0.0.21 → 0.0.22

package/dist/perpetualEventHandler.d.ts

@@ -0,0 +1,181 @@
+import { BigNumber } from "ethers";
+import { PerpetualState, ExchangeInfo, SmartContractOrder, MarginAccount, OrderStruct, TradeEvent } from "./nodeSDKTypes";
+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 {
+    private mktData;
+    private traderAddr;
+    private ordersInPerpetual;
+    private positionInPerpetual;
+    private exchangeInfo;
+    constructor(mktData: MarketData, traderAddr: string);
+    /**
+     * Call this async function to initialize the
+     * market data
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get the current exchange info
+     * @returns exchange info
+     */
+    getExchangeInfo(): ExchangeInfo | undefined;
+    /**
+     * getOrdersInPerpetualMap
+     * @returns this.ordersInPerpetual
+     */
+    getOrdersInPerpetualMap(): Map<number, OrderStruct>;
+    /**
+     * getpositionInPerpetualMap
+     * @returns this.positionInPerpetual
+     */
+    getpositionInPerpetualMap(): Map<number, MarginAccount>;
+    /**
+     * 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
+     */
+    getPerpetualData(perpetualIdOrSymbol: string): PerpetualState | undefined;
+    /**
+     * 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')
+     */
+    getCurrentPositionRisk(perpetualIdOrSymbol: string): MarginAccount | undefined;
+    /**
+     * Update the following prices:
+     *  - index price
+     *  - collateral price
+     *  - mid-price
+     * @param perpetualIdOrSymbol perpetual id as string ('100003') or symbol ('BTC-USD-MATIC')
+     */
+    updatePrices(perpetualIdOrSymbol: string): Promise<void>;
+    /**
+     * 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
+     */
+    onUpdateMarkPrice(perpetualId: number, fMarkPricePremium: BigNumber, fSpotIndexPrice: BigNumber): void;
+    /**
+     * Handle the event UpdateFundingRate and update relevant
+     * data
+     * UpdateFundingRate(uint24 indexed perpetualId, int128 fFundingRate)
+     * @param fFundingRate funding rate in ABDK format
+     */
+    onUpdateUpdateFundingRate(perpetualId: number, fFundingRate: BigNumber): void;
+    /**
+     * 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
+     */
+    onExecutionFailed(perpetualId: number, trader: string, digest: string, reason: string): void;
+    /**
+     * Event emitted by perpetual proxy
+     * event PerpetualLimitOrderCancelled(bytes32 indexed orderHash);
+     * @param orderId string order id/digest
+     */
+    onPerpetualLimitOrderCancelled(orderId: string): void;
+    /**
+     * 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
+     */
+    onPerpetualLimitOrderCreated(perpetualId: number, trader: string, referrerAddr: string, brokerAddr: string, Order: SmartContractOrder, digest: string): void;
+    /**
+     * 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
+     */
+    onUpdateMarginAccount(perpetualId: number, trader: string, positionId: string, fPositionBC: BigNumber, fCashCC: BigNumber, fLockedInValueQC: BigNumber, fFundingPaymentCC: BigNumber, fOpenInterestBC: BigNumber): Promise<void>;
+    /**
+     *
+     * @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
+     */
+    onTrade(perpetualId: number, trader: string, positionId: string, order: SmartContractOrder, orderDigest: string, newPositionSizeBC: BigNumber, price: BigNumber): TradeEvent;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * 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;
+}

package/dist/perpetualEventHandler.js

@@ -0,0 +1,390 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const d8XMath_1 = require("./d8XMath");
+const nodeSDKTypes_1 = require("./nodeSDKTypes");
+const process_1 = require("process");
+/**
+ * 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
+ */
+class PerpetualEventHandler {
+    constructor(mktData, traderAddr) {
+        this.mktData = mktData;
+        this.traderAddr = traderAddr;
+        this.ordersInPerpetual = new Map();
+        this.positionInPerpetual = new Map();
+    }
+    /**
+     * Call this async function to initialize the
+     * market data
+     */
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.exchangeInfo = yield 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 = poolState.perpetuals[j];
+                    let perpSymbol = perpState.baseCurrency + "-" + perpState.quoteCurrency + "-" + poolSymbol;
+                    let orders = yield this.mktData.openOrders(this.traderAddr, perpSymbol);
+                    let perpId = perpState.id;
+                    this.ordersInPerpetual.set(perpId, orders);
+                    let position = yield this.mktData.positionRisk(this.traderAddr, perpSymbol);
+                    this.positionInPerpetual.set(perpId, position);
+                }
+            }
+        });
+    }
+    /**
+     * Get the current exchange info
+     * @returns exchange info
+     */
+    getExchangeInfo() {
+        return this.exchangeInfo;
+    }
+    /**
+     * getOrdersInPerpetualMap
+     * @returns this.ordersInPerpetual
+     */
+    getOrdersInPerpetualMap() {
+        return this.ordersInPerpetual;
+    }
+    /**
+     * getpositionInPerpetualMap
+     * @returns this.positionInPerpetual
+     */
+    getpositionInPerpetualMap() {
+        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
+     */
+    getPerpetualData(perpetualIdOrSymbol) {
+        var _a;
+        let perpId = Number(perpetualIdOrSymbol);
+        if (isNaN(perpId)) {
+            perpId = this.mktData.getPerpIdFromSymbol(perpetualIdOrSymbol);
+        }
+        //uint24 perpetualId = uint24(_iPoolId) * 100_000 + iPerpetualIndex;
+        let poolIdx = Math.floor(perpId / 100000);
+        let perpetuals = (_a = this.exchangeInfo) === null || _a === void 0 ? void 0 : _a.pools[poolIdx].perpetuals;
+        if (perpetuals == undefined) {
+            (0, process_1.emitWarning)(`exchangeInfo not found, initialize perpetualEventHandler`);
+            return undefined;
+        }
+        // find perpetual
+        let k;
+        for (k = 0; k < (perpetuals === null || perpetuals === void 0 ? void 0 : perpetuals.length) && perpetuals[k].id != perpId; k++)
+            ;
+        if (perpetuals[k].id != perpId) {
+            (0, process_1.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')
+     */
+    getCurrentPositionRisk(perpetualIdOrSymbol) {
+        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')
+     */
+    updatePrices(perpetualIdOrSymbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = yield 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
+     */
+    onUpdateMarkPrice(perpetualId, fMarkPricePremium, fSpotIndexPrice) {
+        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
+     */
+    onUpdateUpdateFundingRate(perpetualId, fFundingRate) {
+        let newRate = (0, d8XMath_1.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
+     */
+    onExecutionFailed(perpetualId, trader, digest, reason) {
+        if (trader != this.traderAddr) {
+            (0, process_1.emitWarning)(`onExecutionFailed: trader ${trader} not relevant`);
+            return;
+        }
+        // remove order from open orders
+        let orderStructs = this.ordersInPerpetual.get(perpetualId);
+        if (orderStructs == undefined) {
+            (0, process_1.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
+     */
+    onPerpetualLimitOrderCancelled(orderId) {
+        // remove order from open orders
+        let perpId = PerpetualEventHandler.findOrderForId(orderId, this.ordersInPerpetual);
+        if (perpId == undefined) {
+            (0, process_1.emitWarning)(`onPerpetualLimitOrderCancelled: no order found with id ${orderId}`);
+            return;
+        }
+        let orderStruct = 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
+     */
+    onPerpetualLimitOrderCreated(perpetualId, trader, referrerAddr, brokerAddr, Order, digest) {
+        if (trader != this.traderAddr) {
+            (0, process_1.emitWarning)(`onPerpetualLimitOrderCreated: trader ${trader} not relevant`);
+            return;
+        }
+        let order = this.mktData.smartContractOrderToOrder(Order);
+        let orderStruct = 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
+     */
+    onUpdateMarginAccount(perpetualId, trader, positionId, fPositionBC, fCashCC, fLockedInValueQC, fFundingPaymentCC, fOpenInterestBC) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let perpetual = this.getPerpetualData(perpetualId.toString());
+            if (perpetual == undefined) {
+                (0, process_1.emitWarning)(`onUpdateMarginAccount: perpetual ${perpetualId} not found`);
+                return;
+            }
+            perpetual.openInterestBC = (0, d8XMath_1.ABK64x64ToFloat)(fOpenInterestBC);
+            if (trader != this.traderAddr) {
+                return;
+            }
+            let perpetualIdStr = perpetualId.toString();
+            let margin = yield 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
+     */
+    onTrade(perpetualId, trader, positionId, order, orderDigest, newPositionSizeBC, price) {
+        // remove order digest from open orders
+        let orderStructs = this.ordersInPerpetual.get(perpetualId);
+        if (orderStructs == undefined) {
+            (0, process_1.emitWarning)(`onTrade: executed order not found ${orderDigest}`);
+        }
+        else {
+            PerpetualEventHandler.deleteOrder(orderStructs, orderDigest);
+        }
+        // return transformed trade info
+        return {
+            perpetualId: perpetualId,
+            positionId: positionId,
+            orderId: orderDigest,
+            newPositionSizeBC: (0, d8XMath_1.ABK64x64ToFloat)(newPositionSizeBC),
+            executionPrice: (0, d8XMath_1.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
+     */
+    static findOrderForId(orderId, orderMap) {
+        /*orderMapMap<number, {
+          orders: Order[];
+          orderIds: string[];*/
+        for (const perpId of orderMap.keys()) {
+            let orderStructs = orderMap.get(perpId);
+            if (orderStructs === null || orderStructs === void 0 ? void 0 : 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
+     */
+    static deleteOrder(orderStructs, orderId) {
+        // find order
+        let k;
+        for (k = 0; k < orderStructs.orderIds.length && orderStructs.orderIds[k] != orderId; k++)
+            ;
+        if (orderStructs.orderIds[k] != orderId) {
+            (0, process_1.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
+     */
+    static ConvertUpdateMarkPrice(fMarkPricePremium, fSpotIndexPrice) {
+        let fMarkPrice = (0, d8XMath_1.mul64x64)(fSpotIndexPrice, nodeSDKTypes_1.ONE_64x64.add(fMarkPricePremium));
+        let markPrice = (0, d8XMath_1.ABK64x64ToFloat)(fMarkPrice);
+        let indexPrice = (0, d8XMath_1.ABK64x64ToFloat)(fSpotIndexPrice);
+        return [markPrice, indexPrice];
+    }
+}
+exports.default = PerpetualEventHandler;

package/dist/utils.d.ts

@@ -33,5 +33,23 @@ export declare function fromBytes4(b: Buffer): string;
  * returned by the smart contract as bytes4
  */
 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"
+ */
+export declare function contractSymbolToSymbol(s: string, mapping: Array<{
+    [key: string]: string;
+}>): string | undefined;
+/**
+ * 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 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.fromBytes4HexString = exports.fromBytes4 = exports.toBytes4 = exports.to4Chars = void 0;
+exports.containsFlag = exports.combineFlags = exports.symbol4BToLongSymbol = exports.contractSymbolToSymbol = exports.fromBytes4HexString = exports.fromBytes4 = exports.toBytes4 = exports.to4Chars = void 0;
 const ethers_1 = require("ethers");
 /**
  * @module utils
@@ -76,6 +76,42 @@ function fromBytes4HexString(s) {
     return res;
 }
 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"
+ */
+function contractSymbolToSymbol(s, mapping) {
+    s = fromBytes4HexString(s);
+    for (let pair of mapping) {
+        if (pair.cleanSymbol == s) {
+            return pair.symbol;
+        }
+    }
+}
+exports.contractSymbolToSymbol = contractSymbolToSymbol;
+/**
+ * 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 ""
+ */
+function symbol4BToLongSymbol(s, mapping) {
+    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;
+            }
+        }
+    }
+    return longCCY.substring(1);
+}
+exports.symbol4BToLongSymbol = symbol4BToLongSymbol;
 function combineFlags(f1, f2) {
     return ethers_1.BigNumber.from(parseInt(f1.toString()) | parseInt(f2.toString()));
 }

package/package.json

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

package/src/accountTrade.ts

@@ -190,13 +190,13 @@ export default class AccountTrade extends WriteAccessHandler {
    * @returns Exchange fee, in decimals (i.e. 0.1% is 0.001).
    */
   public async queryExchangeFee(poolSymbolName: string, brokerAddr?: string): Promise<number> {
-    if (this.proxyContract == null || this.signer == null) {
+    if (this.proxyContract == null) {
       throw Error("no proxy contract or wallet initialized. Use createProxyInstance().");
     }
     if (typeof brokerAddr == "undefined") {
       brokerAddr = ZERO_ADDRESS;
     }
-    let poolId = WriteAccessHandler._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+    let poolId = PerpetualDataHandler._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
     let feeTbps = await this.proxyContract.queryExchangeFee(poolId, this.traderAddr, brokerAddr);
     return feeTbps / 100_000;
   }