@d8x/perpetuals-sdk 0.0.21 → 0.0.23

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/dist/writeAccessHandler.js

@@ -15,7 +15,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const perpetualDataHandler_1 = __importDefault(require("./perpetualDataHandler"));
 const nodeSDKTypes_1 = require("./nodeSDKTypes");
-const utils_1 = require("./utils");
 const d8XMath_1 = require("./d8XMath");
 /**
  * This is a parent class for the classes that require
@@ -73,9 +72,7 @@ class WriteAccessHandler extends perpetualDataHandler_1.default {
             //extract margin-currency name
             let symbolarr = symbol.split("-");
             symbol = symbol.length == 3 ? symbolarr[2] : symbolarr[0];
-            //transform into bytes4 currencies (without the space): "BTC", "USD", "MATC"
-            symbol = (0, utils_1.to4Chars)(symbol);
-            symbol = symbol.replace(/\0/g, "");
+            //note: symbol is in long format
             let marginTokenAddr = this.symbolToTokenAddrMap.get(symbol);
             if (marginTokenAddr == undefined || this.signer == null) {
                 throw Error("No margin token or signer defined, call createProxyInstance");

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.23",
   "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;
   }

package/src/d8XMath.ts

@@ -1,3 +1,4 @@
+import { assert } from "console";
 import { BigNumber } from "ethers";
 import { DECIMALS, ONE_64x64 } from "./nodeSDKTypes";
 
@@ -177,3 +178,87 @@ export function calculateLiquidationPriceCollateralQuote(
   let denominator = maintenance_margin_rate * Math.abs(position) - position;
   return numerator / denominator;
 }
+
+/**
+ *
+ * @param targetLeverage Leverage of the resulting position. It must be positive unless the resulting position is closed.
+ * @param currentPosition Current position size, in base currency, signed.
+ * @param currentLockedInValue Current locked in value, average entry price times position size, in quote currency.
+ * @param tradeAmount Trade amount, in base currency, signed.
+ * @param markPrice Mark price, positive.
+ * @param indexPriceS2 Index price, positive.
+ * @param indexPriceS3 Collateral index price, positive.
+ * @param tradePrice Expected price to trade tradeAmount.
+ * @param feeRate
+ * @returns
+ */
+export function getMarginRequiredForLeveragedTrade(
+  targetLeverage: number | undefined,
+  currentPosition: number,
+  currentLockedInValue: number,
+  tradeAmount: number,
+  markPrice: number,
+  indexPriceS2: number,
+  indexPriceS3: number,
+  tradePrice: number,
+  feeRate: number
+): number {
+  // we solve for margin in:
+  // |new position| * Sm / leverage + fee rate * |trade amount| * S2 = margin * S3 + current position * Sm - L + trade amount * (Sm - trade price)
+  // --> M S3 = |P'|Sm/L + FeeQC - PnL + (P'-P)(Price - Sm) = pos value / leverage + fees + price impact - pnl
+  let isClosing =
+    currentPosition != 0 && currentPosition * tradeAmount < 0 && currentPosition * (currentPosition + tradeAmount) >= 0;
+  let feesCC = (feeRate * Math.abs(tradeAmount) * indexPriceS2) / indexPriceS3;
+  let collRequired = feesCC;
+
+  if (!isClosing) {
+    if (targetLeverage == undefined || targetLeverage <= 0) {
+      throw Error("opening trades must have positive leverage");
+    }
+    // unrealized pnl (could be + or -)  - price impact premium (+)
+    let pnlQC = currentPosition * markPrice - currentLockedInValue - tradeAmount * (tradePrice - markPrice);
+    collRequired +=
+      Math.max(0, (Math.abs(currentPosition + tradeAmount) * markPrice) / targetLeverage - pnlQC) / indexPriceS3;
+  }
+  return collRequired;
+}
+
+export function getMaxSignedPositionSize(
+  marginCollateral: number,
+  currentPosition: number,
+  currentLockedInValue: number,
+  direction: number,
+  limitPrice: number,
+  initialMarginRate: number,
+  feeRate: number,
+  markPrice: number,
+  indexPriceS2: number,
+  indexPriceS3: number
+): number {
+  // we solve for new position in:
+  // |new position| * Sm / leverage + fee rate * |trade amount| * S2 = margin * S3 + current position * Sm - L + trade amount * (Sm - entry price)
+  // |trade amount| = (new position - current position) * direction
+  let availableCash = marginCollateral * indexPriceS3 + currentPosition * markPrice - currentLockedInValue;
+  let effectiveMarginRate =
+    markPrice * initialMarginRate + feeRate * indexPriceS2 + direction * (limitPrice - markPrice);
+
+  return availableCash / effectiveMarginRate;
+}
+
+export function getNewPositionLeverage(
+  tradeAmount: number,
+  marginCollateral: number,
+  currentPosition: number,
+  currentLockedInValue: number,
+  indexPriceS2: number,
+  indexPriceS3: number,
+  markPrice: number,
+  limitPrice: number,
+  feeRate: number
+): number {
+  let newPosition = tradeAmount + currentPosition;
+  let pnlQC = currentPosition * markPrice - currentLockedInValue + tradeAmount * (markPrice - limitPrice);
+  return (
+    (Math.abs(newPosition) * indexPriceS2) / (marginCollateral * indexPriceS3 + pnlQC - feeRate * Math.abs(tradeAmount))
+  );
+}

package/src/liquidityProviderTool.ts

@@ -149,12 +149,4 @@ export default class LiquidityProviderTool extends WriteAccessHandler {
     });
     return tx;
   }
-
-  /*
-  TODO:
-  - add liquidity
-    addLiquidity(uint8 _poolId, int128 _fTokenAmount)
-  - remove liquidity
-    function removeLiquidity(uint8 _poolId, int128 _fShareAmount) external override nonReentrant 
-  */
 }