@d8x/perpetuals-sdk 0.0.1

package/dist/d8XMath.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateLiquidationPriceCollateralQuote = exports.calculateLiquidationPriceCollateralQuanto = exports.calculateLiquidationPriceCollateralBase = exports.div64x64 = exports.mul64x64 = exports.floatToDec18 = exports.floatToABK64x64 = exports.dec18ToFloat = exports.ABK64x64ToFloat = void 0;
+const ethers_1 = require("ethers");
+const nodeSDKTypes_1 = require("./nodeSDKTypes");
+const BN = ethers_1.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)
+ */
+function ABK64x64ToFloat(x) {
+    if (typeof x == "number") {
+        return x / Math.pow(2, 29);
+    }
+    let s = x.lt(0) ? -1 : 1;
+    x = x.mul(s);
+    let xInt = x.div(nodeSDKTypes_1.ONE_64x64);
+    let dec18 = ethers_1.BigNumber.from(10).pow(ethers_1.BigNumber.from(18));
+    let xDec = x.sub(xInt.mul(nodeSDKTypes_1.ONE_64x64));
+    xDec = xDec.mul(dec18).div(nodeSDKTypes_1.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;
+}
+exports.ABK64x64ToFloat = ABK64x64ToFloat;
+/**
+ *
+ * @param x BigNumber in Dec18 format
+ * @returns x as a float (number)
+ */
+function dec18ToFloat(x) {
+    //x: BigNumber in Dec18 format to float
+    let s = x.lt(0) ? -1 : 1;
+    x = x.mul(s);
+    let xInt = x.div(nodeSDKTypes_1.DECIMALS);
+    let xDec = x.sub(xInt.mul(nodeSDKTypes_1.DECIMALS));
+    let k = 18 - xDec.toString().length;
+    let sPad = "0".repeat(k);
+    let NumberStr = xInt.toString() + "." + sPad + xDec.toString();
+    return parseFloat(NumberStr) * s;
+}
+exports.dec18ToFloat = dec18ToFloat;
+/**
+ * Converts x into ABDK64x64 format
+ * @param   x   number (float)
+ * @returns x^64 in big number format
+ */
+function floatToABK64x64(x) {
+    // convert float to ABK64x64 bigint-format
+    // Create string from number with 18 decimals
+    if (x === 0) {
+        return ethers_1.BigNumber.from(0);
+    }
+    let sg = Math.sign(x);
+    x = Math.abs(x);
+    let strX = Number(x).toFixed(18);
+    const arrX = strX.split(".");
+    let xInt = ethers_1.BigNumber.from(arrX[0]);
+    let xDec = ethers_1.BigNumber.from(arrX[1]);
+    let xIntBig = xInt.mul(nodeSDKTypes_1.ONE_64x64);
+    let dec18 = ethers_1.BigNumber.from(10).pow(ethers_1.BigNumber.from(18));
+    let xDecBig = xDec.mul(nodeSDKTypes_1.ONE_64x64).div(dec18);
+    return xIntBig.add(xDecBig).mul(sg);
+}
+exports.floatToABK64x64 = floatToABK64x64;
+/**
+ *
+ * @param x number (float)
+ * @returns x as a BigNumber in Dec18 format
+ */
+function floatToDec18(x) {
+    // float number to dec 18
+    if (x === 0) {
+        return ethers_1.BigNumber.from(0);
+    }
+    let sg = Math.sign(x);
+    x = Math.abs(x);
+    let strX = x.toFixed(18);
+    const arrX = strX.split(".");
+    let xInt = ethers_1.BigNumber.from(arrX[0]);
+    let xDec = ethers_1.BigNumber.from(arrX[1]);
+    let xIntBig = xInt.mul(nodeSDKTypes_1.DECIMALS);
+    return xIntBig.add(xDec).mul(sg);
+}
+exports.floatToDec18 = floatToDec18;
+/**
+ *
+ * @param x
+ * @param y
+ * @returns x * y
+ */
+function mul64x64(x, y) {
+    return x.mul(y).div(nodeSDKTypes_1.ONE_64x64);
+}
+exports.mul64x64 = mul64x64;
+/**
+ *
+ * @param x
+ * @param y
+ * @returns x / y
+ */
+function div64x64(x, y) {
+    return x.mul(nodeSDKTypes_1.ONE_64x64).div(y);
+}
+exports.div64x64 = div64x64;
+/**
+ * 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
+ */
+function calculateLiquidationPriceCollateralBase(LockedInValueQC, position, cash_cc, maintenance_margin_rate) {
+    // 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);
+}
+exports.calculateLiquidationPriceCollateralBase = calculateLiquidationPriceCollateralBase;
+/**
+ * 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
+ */
+function calculateLiquidationPriceCollateralQuanto(LockedInValueQC, position, cash_cc, maintenance_margin_rate, S3, Sm) {
+    // 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;
+}
+exports.calculateLiquidationPriceCollateralQuanto = calculateLiquidationPriceCollateralQuanto;
+/**
+ * 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
+ */
+function calculateLiquidationPriceCollateralQuote(LockedInValueQC, position, cash_cc, maintenance_margin_rate) {
+    // 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;
+}
+exports.calculateLiquidationPriceCollateralQuote = calculateLiquidationPriceCollateralQuote;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+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";
+export * from "./nodeSDKTypes";
+export * from "./utils";
+export * from "./d8XMath";
+export { AccountTrade, BrokerTool, LiquidityProviderTool, MarketData, OrderReferrerTool, PerpetualDataHandler, WriteAccessHandler, };

package/dist/index.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WriteAccessHandler = exports.PerpetualDataHandler = exports.OrderReferrerTool = exports.MarketData = exports.LiquidityProviderTool = exports.BrokerTool = exports.AccountTrade = void 0;
+const accountTrade_1 = __importDefault(require("./accountTrade"));
+exports.AccountTrade = accountTrade_1.default;
+const brokerTool_1 = __importDefault(require("./brokerTool"));
+exports.BrokerTool = brokerTool_1.default;
+const liquidityProviderTool_1 = __importDefault(require("./liquidityProviderTool"));
+exports.LiquidityProviderTool = liquidityProviderTool_1.default;
+const marketData_1 = __importDefault(require("./marketData"));
+exports.MarketData = marketData_1.default;
+const orderReferrerTool_1 = __importDefault(require("./orderReferrerTool"));
+exports.OrderReferrerTool = orderReferrerTool_1.default;
+const perpetualDataHandler_1 = __importDefault(require("./perpetualDataHandler"));
+exports.PerpetualDataHandler = perpetualDataHandler_1.default;
+const writeAccessHandler_1 = __importDefault(require("./writeAccessHandler"));
+exports.WriteAccessHandler = writeAccessHandler_1.default;
+// import {
+//   NodeSDKConfig,
+//   MarginAccount,
+//   CollaterlCCY,
+//   PoolStaticInfo,
+//   PerpetualStaticInfo,
+//   ExchangeInfo,
+//   PoolState,
+//   PerpetualState,
+//   Order,
+//   SmartContractOrder,
+// } from "./nodeSDKTypes";
+__exportStar(require("./nodeSDKTypes"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./d8XMath"), exports);

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/liquidityProviderTool.d.ts

@@ -0,0 +1,39 @@
+import { ethers } from "ethers";
+import WriteAccessHandler from "./writeAccessHandler";
+import { NodeSDKConfig } from "./nodeSDKTypes";
+/**
+ * LiquidityProviderTool
+ * Methods to provide liquidity
+ */
+export default class LiquidityProviderTool extends WriteAccessHandler {
+    /**
+     * Constructor
+     * @param config configuration
+     * @param privateKey private key of account that trades
+     */
+    constructor(config: NodeSDKConfig, privateKey: string);
+    /**
+     * 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)
+     */
+    getParticipationValue(poolSymbolName: string): Promise<{
+        value: number;
+        shareTokenBalance: number;
+        poolShareToken: string;
+    }>;
+    /**
+     *  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
+     */
+    addLiquidity(poolSymbolName: string, amountCC: number): Promise<ethers.providers.TransactionResponse>;
+    /**
+     * 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
+     */
+    removeLiquidity(poolSymbolName: string, amountPoolShares: number): Promise<ethers.providers.TransactionResponse>;
+}

package/dist/liquidityProviderTool.js

@@ -0,0 +1,100 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const writeAccessHandler_1 = __importDefault(require("./writeAccessHandler"));
+const nodeSDKTypes_1 = require("./nodeSDKTypes");
+const perpetualDataHandler_1 = __importDefault(require("./perpetualDataHandler"));
+const d8XMath_1 = require("./d8XMath");
+/**
+ * LiquidityProviderTool
+ * Methods to provide liquidity
+ */
+class LiquidityProviderTool extends writeAccessHandler_1.default {
+    /**
+     * Constructor
+     * @param config configuration
+     * @param privateKey private key of account that trades
+     */
+    constructor(config, privateKey) {
+        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)
+     */
+    getParticipationValue(poolSymbolName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+            let shareTokenAddr = this.poolStaticInfos[poolId - 1].shareTokenAddr;
+            let shareToken = new ethers_1.ethers.Contract(shareTokenAddr, nodeSDKTypes_1.ERC20_ABI, this.signer);
+            let dShareTokenBalanceOfAddr = yield shareToken.balanceOf(this.traderAddr);
+            let shareTokenBalanceOfAddr = (0, d8XMath_1.dec18ToFloat)(dShareTokenBalanceOfAddr);
+            if (shareTokenBalanceOfAddr == 0) {
+                return { value: 0, shareTokenBalance: 0, poolShareToken: shareTokenAddr };
+            }
+            let pool = yield this.proxyContract.getLiquidityPool(poolId);
+            let fPnLParticipantFundCash = pool.fPnLparticipantsCashCC;
+            let pnlParticipantFundCash = (0, d8XMath_1.ABK64x64ToFloat)(fPnLParticipantFundCash);
+            let dTotalSupply = yield shareToken.totalSupply();
+            let totalSupply = (0, d8XMath_1.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
+     */
+    addLiquidity(poolSymbolName, amountCC) {
+        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().");
+            }
+            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+            let tx = yield this.proxyContract.addLiquidity(poolId, (0, d8XMath_1.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
+     */
+    removeLiquidity(poolSymbolName, amountPoolShares) {
+        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().");
+            }
+            let poolId = perpetualDataHandler_1.default._getPoolIdFromSymbol(poolSymbolName, this.poolStaticInfos);
+            let tx = yield this.proxyContract.addLiquidity(poolId, (0, d8XMath_1.floatToABK64x64)(amountPoolShares), {
+                gasLimit: this.gasLimit,
+            });
+            return tx;
+        });
+    }
+}
+exports.default = LiquidityProviderTool;

package/dist/marketData.d.ts

@@ -0,0 +1,39 @@
+import { ExchangeInfo, NodeSDKConfig, MarginAccount } from "./nodeSDKTypes";
+import { ethers } from "ethers";
+import PerpetualDataHandler from "./perpetualDataHandler";
+import { 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 {
+    constructor(config: NodeSDKConfig);
+    createProxyInstance(): Promise<void>;
+    exchangeInfo(): Promise<ExchangeInfo>;
+    /**
+     * 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
+     */
+    openOrders(traderAddr: string, symbol: string): Promise<{
+        orders: Order[];
+        orderIds: string[];
+    }>;
+    positionRisk(traderAddr: string, symbol: string): Promise<MarginAccount>;
+    /**
+     * 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 openOrdersOnOrderBook(traderAddr: string, orderBookContract: ethers.Contract): Promise<Order[]>;
+    /**
+     *
+     * @param traderAddr address of the trader
+     * @param orderBookContract instance of order book contract
+     * @returns array of order-id's
+     */
+    protected orderIdsOfTrader(traderAddr: string, orderBookContract: ethers.Contract): Promise<string[]>;
+    static _exchangeInfo(_proxyContract: ethers.Contract): Promise<ExchangeInfo>;
+}

package/dist/marketData.js

@@ -0,0 +1,160 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nodeSDKTypes_1 = require("./nodeSDKTypes");
+const ethers_1 = require("ethers");
+const d8XMath_1 = require("./d8XMath");
+const utils_1 = require("./utils");
+const perpetualDataHandler_1 = __importDefault(require("./perpetualDataHandler"));
+/**
+ * This class requires no private key and is blockchain read-only.
+ * No gas required for the queries here.
+ */
+class MarketData extends perpetualDataHandler_1.default {
+    constructor(config) {
+        super(config);
+    }
+    createProxyInstance() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.provider = new ethers_1.ethers.providers.JsonRpcProvider(this.nodeURL);
+            yield this.initContractsAndData(this.provider);
+        });
+    }
+    exchangeInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized. Use createProxyInstance().");
+            }
+            return yield 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
+     */
+    openOrders(traderAddr, symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // open orders requested only for given symbol
+            let orderBookContract = this.getOrderBookContract(symbol);
+            let [orders, digests] = yield Promise.all([
+                this.openOrdersOnOrderBook(traderAddr, orderBookContract),
+                this.orderIdsOfTrader(traderAddr, orderBookContract),
+            ]);
+            return { orders: orders, orderIds: digests };
+        });
+    }
+    positionRisk(traderAddr, symbol) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized. Use createProxyInstance().");
+            }
+            let mgnAcct = yield perpetualDataHandler_1.default.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
+     */
+    openOrdersOnOrderBook(traderAddr, orderBookContract) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let orders = yield orderBookContract.getOrders(traderAddr, 0, 15);
+            //eliminate empty orders and map to user friendly orders
+            let userFriendlyOrders = new Array();
+            let k = 0;
+            while (k < orders.length && orders[k].traderAddr != nodeSDKTypes_1.ZERO_ADDRESS) {
+                userFriendlyOrders.push(perpetualDataHandler_1.default.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
+     */
+    orderIdsOfTrader(traderAddr, orderBookContract) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let digestsRaw = yield orderBookContract.limitDigestsOfTrader(traderAddr, 0, 15);
+            let k = 0;
+            let digests = [];
+            while (k < digestsRaw.length && ethers_1.BigNumber.from(digestsRaw[k]).gt(0)) {
+                digests.push(digestsRaw[k]);
+                k++;
+            }
+            return digests;
+        });
+    }
+    static _exchangeInfo(_proxyContract) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let nestedPerpetualIDs = yield perpetualDataHandler_1.default.getNestedPerpetualIds(_proxyContract);
+            let info = { pools: [] };
+            const numPools = nestedPerpetualIDs.length;
+            for (var j = 0; j < numPools; j++) {
+                let perpetualIDs = nestedPerpetualIDs[j];
+                let pool = yield _proxyContract.getLiquidityPool(j + 1);
+                let PoolState = {
+                    isRunning: pool.isRunning,
+                    marginTokenAddr: pool.marginTokenAddress,
+                    poolShareTokenAddr: pool.shareTokenAddress,
+                    defaultFundCashCC: (0, d8XMath_1.ABK64x64ToFloat)(pool.fDefaultFundCashCC),
+                    pnlParticipantCashCC: (0, d8XMath_1.ABK64x64ToFloat)(pool.fPnLparticipantsCashCC),
+                    totalAMMFundCashCC: (0, d8XMath_1.ABK64x64ToFloat)(pool.fAMMFundCashCC),
+                    totalTargetAMMFundSizeCC: (0, d8XMath_1.ABK64x64ToFloat)(pool.fTargetAMMFundSize),
+                    brokerCollateralLotSize: (0, d8XMath_1.ABK64x64ToFloat)(pool.fBrokerCollateralLotSize),
+                    perpetuals: [],
+                };
+                for (var k = 0; k < perpetualIDs.length; k++) {
+                    let perp = yield _proxyContract.getPerpetual(perpetualIDs[k]);
+                    let fIndexS2 = yield _proxyContract.getOraclePrice([perp.S2BaseCCY, perp.S2QuoteCCY]);
+                    let indexS2 = (0, d8XMath_1.ABK64x64ToFloat)(fIndexS2);
+                    let indexS3 = 1;
+                    if (perp.eCollateralCurrency == nodeSDKTypes_1.COLLATERAL_CURRENCY_BASE) {
+                        indexS3 = indexS2;
+                    }
+                    else if (perp.eCollateralCurrency == nodeSDKTypes_1.COLLATERAL_CURRENCY_QUANTO) {
+                        indexS3 = (0, d8XMath_1.ABK64x64ToFloat)(yield _proxyContract.getOraclePrice([perp.S3BaseCCY, perp.S3QuoteCCY]));
+                    }
+                    let markPremiumRate = (0, d8XMath_1.ABK64x64ToFloat)(perp.currentMarkPremiumRate.fPrice);
+                    let currentFundingRateBps = 1e4 * (0, d8XMath_1.ABK64x64ToFloat)(perp.fCurrentFundingRate);
+                    let state = nodeSDKTypes_1.PERP_STATE_STR[perp.state];
+                    let PerpetualState = {
+                        id: perp.id,
+                        state: state,
+                        baseCurrency: (0, utils_1.fromBytes4HexString)(perp.S2BaseCCY),
+                        quoteCurrency: (0, utils_1.fromBytes4HexString)(perp.S2QuoteCCY),
+                        indexPrice: indexS2,
+                        collToQuoteIndexPrice: indexS3,
+                        markPrice: indexS2 * (1 + markPremiumRate),
+                        currentFundingRateBps: currentFundingRateBps,
+                        initialMarginRate: (0, d8XMath_1.ABK64x64ToFloat)(perp.fInitialMarginRate),
+                        maintenanceMarginRate: (0, d8XMath_1.ABK64x64ToFloat)(perp.fMaintenanceMarginRate),
+                        openInterestBC: (0, d8XMath_1.ABK64x64ToFloat)(perp.fOpenInterest),
+                        maxPositionBC: (0, d8XMath_1.ABK64x64ToFloat)(perp.fMaxPositionBC),
+                    };
+                    PoolState.perpetuals.push(PerpetualState);
+                }
+                info.pools.push(PoolState);
+            }
+            return info;
+        });
+    }
+}
+exports.default = MarketData;