@d8x/perpetuals-sdk 0.0.39 → 0.0.41

package/dist/marketData.d.ts

@@ -139,7 +139,15 @@ export default class MarketData extends PerpetualDataHandler {
      * @returns {MarginAccount} Position risk after trade
      */
     positionRiskOnTrade(traderAddr: string, order: Order, currentPositionRisk?: MarginAccount): Promise<MarginAccount>;
-    protected static _positionRiskOnTrade(symbol: string, tradeAmount: number, tradeLeverage: number | undefined, keepPositionLvg: boolean | undefined, tradePrice: number, feeRate: number, perpetualState: PerpetualState, currentPositionRisk: MarginAccount, symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>): MarginAccount;
+    /**
+     * Estimates what the position risk will be if given amount of collateral is added/removed from the account.
+     * @param traderAddr Address of trader
+     * @param deltaCollateral Amount of collateral to add or remove (signed)
+     * @param currentPositionRisk Position risk before
+     * @returns {MarginAccount} Position risk after
+     */
+    positionRiskOnCollateralAction(deltaCollateral: number, currentPositionRisk: MarginAccount): Promise<MarginAccount>;
+    protected static _positionRiskOnAccountAction(symbol: string, tradeAmount: number, marginDeposit: number, tradeLeverage: number | undefined, keepPositionLvg: boolean | undefined, tradePrice: number, feeRate: number, perpetualState: PerpetualState, currentPositionRisk: MarginAccount, symbolToPerpStaticInfo: Map<string, PerpetualStaticInfo>): MarginAccount;
     maxOrderSizeForTrader(side: string, positionRisk: MarginAccount, perpetualState: PerpetualState): number;
     /**
      * Uses the Oracle(s) in the exchange to get the latest price of a given index in a given currency, if a route exists.
@@ -253,5 +261,6 @@ export default class MarketData extends PerpetualDataHandler {
      * @ignore
      */
     static orderIdsOfTrader(traderAddr: string, orderBookContract: ethers.Contract): Promise<string[]>;
+    getAvailableMargin(traderAddr: string, symbol: string): Promise<number>;
     static _exchangeInfo(_proxyContract: ethers.Contract, _poolStaticInfos: Array<PoolStaticInfo>, _symbolList: Map<string, string>): Promise<ExchangeInfo>;
 }

package/dist/marketData.js

@@ -217,15 +217,33 @@ class MarketData extends perpetualDataHandler_1.default {
             let feeRate = (yield this.proxyContract.queryExchangeFee(poolId, traderAddr, (_b = order.brokerAddr) !== null && _b !== void 0 ? _b : nodeSDKTypes_1.ZERO_ADDRESS)) +
                 ((_c = order.brokerFeeTbps) !== null && _c !== void 0 ? _c : 0) / 100000;
             let perpetualState = yield this.getPerpetualState(order.symbol);
-            console.log("perpetualState", perpetualState);
-            return MarketData._positionRiskOnTrade(order.symbol, tradeAmount, order.leverage, order.keepPositionLvg, tradePrice, feeRate, perpetualState, currentPositionRisk, this.symbolToPerpStaticInfo);
+            return MarketData._positionRiskOnAccountAction(order.symbol, tradeAmount, 0, order.leverage, order.keepPositionLvg, tradePrice, feeRate, perpetualState, currentPositionRisk, this.symbolToPerpStaticInfo);
         });
     }
-    static _positionRiskOnTrade(symbol, tradeAmount, tradeLeverage, keepPositionLvg, tradePrice, feeRate, perpetualState, currentPositionRisk, symbolToPerpStaticInfo) {
+    /**
+     * Estimates what the position risk will be if given amount of collateral is added/removed from the account.
+     * @param traderAddr Address of trader
+     * @param deltaCollateral Amount of collateral to add or remove (signed)
+     * @param currentPositionRisk Position risk before
+     * @returns {MarginAccount} Position risk after
+     */
+    positionRiskOnCollateralAction(deltaCollateral, currentPositionRisk) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.proxyContract == null) {
+                throw Error("no proxy contract initialized. Use createProxyInstance().");
+            }
+            let perpetualState = yield this.getPerpetualState(currentPositionRisk.symbol);
+            return MarketData._positionRiskOnAccountAction(currentPositionRisk.symbol, 0, deltaCollateral, undefined, false, 0, 0, perpetualState, currentPositionRisk, this.symbolToPerpStaticInfo);
+        });
+    }
+    static _positionRiskOnAccountAction(symbol, tradeAmount, marginDeposit, tradeLeverage, keepPositionLvg, tradePrice, feeRate, perpetualState, currentPositionRisk, symbolToPerpStaticInfo) {
         let currentPosition = currentPositionRisk.positionNotionalBaseCCY;
         let newPosition = currentPositionRisk.positionNotionalBaseCCY + tradeAmount;
         let side = newPosition > 0 ? nodeSDKTypes_1.BUY_SIDE : newPosition < 0 ? nodeSDKTypes_1.SELL_SIDE : nodeSDKTypes_1.CLOSED_SIDE;
         let lockedInValue = currentPositionRisk.entryPrice * currentPosition;
+        if (tradeAmount == 0) {
+            keepPositionLvg = false;
+        }
         // need these for leverage/margin calculations
         let [markPrice, indexPriceS2, indexPriceS3] = [
             perpetualState.markPrice,
@@ -238,27 +256,21 @@ class MarketData extends perpetualDataHandler_1.default {
             // we have a target leverage for the resulting position
             // this gives us the total margin needed in the account so that it satisfies the leverage condition
             newCollateral = (0, d8XMath_1.getMarginRequiredForLeveragedTrade)(currentPositionRisk.leverage, currentPosition, lockedInValue, tradeAmount, markPrice, indexPriceS2, indexPriceS3, tradePrice, feeRate);
-            /**
-             * export function getDepositAmountForLvgTrade(
-          pos0: number,
-          b0: number,
-          tradeAmnt: number,
-          targetLvg: number,
-          price: number,
-          S3: number,
-          S2Mark: number,
-          maxLvg?: number
-             */
             // the new leverage follows from the updated margin and position
             newLeverage = (0, d8XMath_1.getNewPositionLeverage)(tradeAmount, newCollateral, currentPosition, lockedInValue, indexPriceS2, indexPriceS3, markPrice, tradePrice, feeRate);
         }
-        else {
+        else if (tradeAmount != 0) {
             // the order has its own leverage and margin requirements
             let tradeCollateral = (0, d8XMath_1.getMarginRequiredForLeveragedTrade)(tradeLeverage, 0, 0, tradeAmount, markPrice, indexPriceS2, indexPriceS3, tradePrice, feeRate);
             newCollateral = currentPositionRisk.collateralCC + tradeCollateral;
             // the new leverage corresponds to increasing the position and collateral according to the order
             newLeverage = (0, d8XMath_1.getNewPositionLeverage)(tradeAmount, newCollateral, currentPosition, lockedInValue, indexPriceS2, indexPriceS3, markPrice, tradePrice, feeRate);
         }
+        else {
+            // there is no order, adding/removing collateral
+            newCollateral = currentPositionRisk.collateralCC + marginDeposit;
+            newLeverage = (0, d8XMath_1.getNewPositionLeverage)(0, newCollateral, currentPosition, lockedInValue, indexPriceS2, indexPriceS3, markPrice, 0, 0);
+        }
         let newLockedInValue = lockedInValue + tradeAmount * tradePrice;
         // liquidation vars
         let S2Liq, S3Liq;
@@ -282,7 +294,7 @@ class MarketData extends perpetualDataHandler_1.default {
             entryPrice: Math.abs(newLockedInValue / newPosition),
             leverage: newLeverage,
             markPrice: markPrice,
-            unrealizedPnlQuoteCCY: tradeAmount * (markPrice - tradePrice),
+            unrealizedPnlQuoteCCY: currentPositionRisk.unrealizedPnlQuoteCCY + tradeAmount * (markPrice - tradePrice),
             unrealizedFundingCollateralCCY: currentPositionRisk.unrealizedFundingCollateralCCY,
             collateralCC: newCollateral,
             collToQuoteConversion: indexPriceS3,
@@ -496,6 +508,19 @@ class MarketData extends perpetualDataHandler_1.default {
             return digests;
         });
     }
+    getAvailableMargin(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);
+            let perpInfo = this.symbolToPerpStaticInfo.get(symbol);
+            let balanceCC = mgnAcct.collateralCC + mgnAcct.unrealizedPnlQuoteCCY / mgnAcct.collToQuoteConversion;
+            let initalMarginCC = Math.abs((perpInfo.initialMarginRate * mgnAcct.positionNotionalBaseCCY * mgnAcct.markPrice) /
+                mgnAcct.collToQuoteConversion);
+            return balanceCC - initalMarginCC;
+        });
+    }
     static _exchangeInfo(_proxyContract, _poolStaticInfos, _symbolList) {
         return __awaiter(this, void 0, void 0, function* () {
             let nestedPerpetualIDs = yield perpetualDataHandler_1.default.getNestedPerpetualIds(_proxyContract);

package/dist/orderReferrerTool.js

@@ -284,12 +284,12 @@ class OrderReferrerTool extends writeAccessHandler_1.default {
         if (order.quantity < perpetualDataHandler_1.default._getLotSize(order.symbol, symbolToPerpInfoMap)) {
             return false;
         }
-        // check limit price, which may be undefined if it's an unrestricted market order
+        // check limit price: fromSmartContractOrder will set it to undefined when not tradeable
         if (order.limitPrice == undefined) {
-            order.limitPrice = order.side == nodeSDKTypes_1.BUY_SIDE ? Infinity : 0;
+            return false;
         }
-        if ((order.side == nodeSDKTypes_1.BUY_SIDE && orderPrice > order.limitPrice) ||
-            (order.side == nodeSDKTypes_1.SELL_SIDE && orderPrice < order.limitPrice)) {
+        let limitPrice = order.limitPrice;
+        if ((order.side == nodeSDKTypes_1.BUY_SIDE && orderPrice > limitPrice) || (order.side == nodeSDKTypes_1.SELL_SIDE && orderPrice < limitPrice)) {
             return false;
         }
         // do we need to check trigger/stop?

package/dist/perpetualDataHandler.js

@@ -337,7 +337,8 @@ class PerpetualDataHandler {
         else {
             S2Liq = (0, d8XMath_1.calculateLiquidationPriceCollateralQuote)(lockedInValueQC, position, cashCC, tau);
         }
-        let pnl = position * Sm - lockedInValueQC - unpaidFunding;
+        // account cash + pnl = avail cash + pos Sm - L = margin balance
+        let pnl = position * Sm - lockedInValueQC + unpaidFunding;
         return [S2Liq, S3Liq, tau, pnl, unpaidFundingCC];
     }
     /**
@@ -405,8 +406,11 @@ class PerpetualDataHandler {
         let side = order.fAmount > 0 ? nodeSDKTypes_1.BUY_SIDE : nodeSDKTypes_1.SELL_SIDE;
         let limitPrice, stopPrice;
         let fLimitPrice = ethers_1.BigNumber.from(order.fLimitPrice);
-        if (fLimitPrice.eq(0) || fLimitPrice.eq(nodeSDKTypes_1.MAX_64x64)) {
-            limitPrice = undefined;
+        if (fLimitPrice.eq(0)) {
+            limitPrice = side == nodeSDKTypes_1.BUY_SIDE ? undefined : 0;
+        }
+        else if (fLimitPrice.eq(nodeSDKTypes_1.MAX_64x64)) {
+            limitPrice = side == nodeSDKTypes_1.BUY_SIDE ? Infinity : undefined;
         }
         else {
             limitPrice = (0, d8XMath_1.ABK64x64ToFloat)(fLimitPrice);

package/dist/writeAccessHandler.js

@@ -49,7 +49,7 @@ class WriteAccessHandler extends perpetualDataHandler_1.default {
     createProxyInstance(provider) {
         return __awaiter(this, void 0, void 0, function* () {
             if (provider == undefined) {
-                this.provider = new ethers_1.ethers.providers.JsonRpcProvider(this.nodeURL);
+                this.provider = new ethers_1.ethers.providers.JsonRpcBatchProvider(this.nodeURL);
             }
             else {
                 this.provider = provider;

package/package.json

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

package/src/marketData.ts

@@ -237,10 +237,11 @@ export default class MarketData extends PerpetualDataHandler {
       (await this.proxyContract.queryExchangeFee(poolId, traderAddr, order.brokerAddr ?? ZERO_ADDRESS)) +
       (order.brokerFeeTbps ?? 0) / 100_000;
     let perpetualState = await this.getPerpetualState(order.symbol);
-    console.log("perpetualState", perpetualState);
-    return MarketData._positionRiskOnTrade(
+
+    return MarketData._positionRiskOnAccountAction(
       order.symbol,
       tradeAmount,
+      0,
       order.leverage,
       order.keepPositionLvg,
       tradePrice,
@@ -251,9 +252,40 @@ export default class MarketData extends PerpetualDataHandler {
     );
   }
 
-  protected static _positionRiskOnTrade(
+  /**
+   * Estimates what the position risk will be if given amount of collateral is added/removed from the account.
+   * @param traderAddr Address of trader
+   * @param deltaCollateral Amount of collateral to add or remove (signed)
+   * @param currentPositionRisk Position risk before
+   * @returns {MarginAccount} Position risk after
+   */
+  public async positionRiskOnCollateralAction(
+    deltaCollateral: number,
+    currentPositionRisk: MarginAccount
+  ): Promise<MarginAccount> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
+    }
+    let perpetualState = await this.getPerpetualState(currentPositionRisk.symbol);
+
+    return MarketData._positionRiskOnAccountAction(
+      currentPositionRisk.symbol,
+      0,
+      deltaCollateral,
+      undefined,
+      false,
+      0,
+      0,
+      perpetualState,
+      currentPositionRisk,
+      this.symbolToPerpStaticInfo
+    );
+  }
+
+  protected static _positionRiskOnAccountAction(
     symbol: string,
     tradeAmount: number,
+    marginDeposit: number,
     tradeLeverage: number | undefined,
     keepPositionLvg: boolean | undefined,
     tradePrice: number,
@@ -266,7 +298,9 @@ export default class MarketData extends PerpetualDataHandler {
     let newPosition = currentPositionRisk.positionNotionalBaseCCY + tradeAmount;
     let side = newPosition > 0 ? BUY_SIDE : newPosition < 0 ? SELL_SIDE : CLOSED_SIDE;
     let lockedInValue = currentPositionRisk.entryPrice * currentPosition;
-
+    if (tradeAmount == 0) {
+      keepPositionLvg = false;
+    }
     // need these for leverage/margin calculations
     let [markPrice, indexPriceS2, indexPriceS3] = [
       perpetualState.markPrice,
@@ -289,17 +323,6 @@ export default class MarketData extends PerpetualDataHandler {
         tradePrice,
         feeRate
       );
-      /**
-       * export function getDepositAmountForLvgTrade(
-    pos0: number,
-    b0: number,
-    tradeAmnt: number,
-    targetLvg: number,
-    price: number,
-    S3: number,
-    S2Mark: number,
-    maxLvg?: number
-       */
       // the new leverage follows from the updated margin and position
       newLeverage = getNewPositionLeverage(
         tradeAmount,
@@ -312,7 +335,7 @@ export default class MarketData extends PerpetualDataHandler {
         tradePrice,
         feeRate
       );
-    } else {
+    } else if (tradeAmount != 0) {
       // the order has its own leverage and margin requirements
       let tradeCollateral = getMarginRequiredForLeveragedTrade(
         tradeLeverage,
@@ -338,6 +361,20 @@ export default class MarketData extends PerpetualDataHandler {
         tradePrice,
         feeRate
       );
+    } else {
+      // there is no order, adding/removing collateral
+      newCollateral = currentPositionRisk.collateralCC + marginDeposit;
+      newLeverage = getNewPositionLeverage(
+        0,
+        newCollateral,
+        currentPosition,
+        lockedInValue,
+        indexPriceS2,
+        indexPriceS3,
+        markPrice,
+        0,
+        0
+      );
     }
     let newLockedInValue = lockedInValue + tradeAmount * tradePrice;
 
@@ -368,7 +405,7 @@ export default class MarketData extends PerpetualDataHandler {
       entryPrice: Math.abs(newLockedInValue / newPosition),
       leverage: newLeverage,
       markPrice: markPrice,
-      unrealizedPnlQuoteCCY: tradeAmount * (markPrice - tradePrice),
+      unrealizedPnlQuoteCCY: currentPositionRisk.unrealizedPnlQuoteCCY + tradeAmount * (markPrice - tradePrice),
       unrealizedFundingCollateralCCY: currentPositionRisk.unrealizedFundingCollateralCCY,
       collateralCC: newCollateral,
       collToQuoteConversion: indexPriceS3,
@@ -597,6 +634,25 @@ export default class MarketData extends PerpetualDataHandler {
     return digests;
   }
 
+  public async getAvailableMargin(traderAddr: string, symbol: string): Promise<number> {
+    if (this.proxyContract == null) {
+      throw Error("no proxy contract initialized. Use createProxyInstance().");
+    }
+    let mgnAcct = await PerpetualDataHandler.getMarginAccount(
+      traderAddr,
+      symbol,
+      this.symbolToPerpStaticInfo,
+      this.proxyContract
+    );
+    let perpInfo = this.symbolToPerpStaticInfo.get(symbol);
+    let balanceCC = mgnAcct.collateralCC + mgnAcct.unrealizedPnlQuoteCCY / mgnAcct.collToQuoteConversion;
+    let initalMarginCC = Math.abs(
+      (perpInfo!.initialMarginRate * mgnAcct.positionNotionalBaseCCY * mgnAcct.markPrice) /
+        mgnAcct.collToQuoteConversion
+    );
+    return balanceCC - initalMarginCC;
+  }
+
   public static async _exchangeInfo(
     _proxyContract: ethers.Contract,
     _poolStaticInfos: Array<PoolStaticInfo>,

package/src/orderReferrerTool.ts

@@ -311,15 +311,12 @@ export default class OrderReferrerTool extends WriteAccessHandler {
     if (order.quantity < PerpetualDataHandler._getLotSize(order.symbol, symbolToPerpInfoMap)) {
       return false;
     }
-    // check limit price, which may be undefined if it's an unrestricted market order
+    // check limit price: fromSmartContractOrder will set it to undefined when not tradeable
     if (order.limitPrice == undefined) {
-      order.limitPrice = order.side == BUY_SIDE ? Infinity : 0;
+      return false;
     }
-
-    if (
-      (order.side == BUY_SIDE && orderPrice > order.limitPrice) ||
-      (order.side == SELL_SIDE && orderPrice < order.limitPrice)
-    ) {
+    let limitPrice = order.limitPrice!;
+    if ((order.side == BUY_SIDE && orderPrice > limitPrice) || (order.side == SELL_SIDE && orderPrice < limitPrice)) {
       return false;
     }
     // do we need to check trigger/stop?

package/src/perpetualDataHandler.ts

@@ -426,7 +426,8 @@ export default class PerpetualDataHandler {
     } else {
       S2Liq = calculateLiquidationPriceCollateralQuote(lockedInValueQC, position, cashCC, tau);
     }
-    let pnl = position * Sm - lockedInValueQC - unpaidFunding;
+    // account cash + pnl = avail cash + pos Sm - L = margin balance
+    let pnl = position * Sm - lockedInValueQC + unpaidFunding;
     return [S2Liq, S3Liq, tau, pnl, unpaidFundingCC];
   }
 
@@ -506,8 +507,10 @@ export default class PerpetualDataHandler {
     let side = order.fAmount > 0 ? BUY_SIDE : SELL_SIDE;
     let limitPrice, stopPrice;
     let fLimitPrice: BigNumber | undefined = BigNumber.from(order.fLimitPrice);
-    if (fLimitPrice.eq(0) || fLimitPrice.eq(MAX_64x64)) {
-      limitPrice = undefined;
+    if (fLimitPrice.eq(0)) {
+      limitPrice = side == BUY_SIDE ? undefined : 0;
+    } else if (fLimitPrice.eq(MAX_64x64)) {
+      limitPrice = side == BUY_SIDE ? Infinity : undefined;
     } else {
       limitPrice = ABK64x64ToFloat(fLimitPrice);
     }

package/src/writeAccessHandler.ts

@@ -37,7 +37,7 @@ export default class WriteAccessHandler extends PerpetualDataHandler {
    */
   public async createProxyInstance(provider?: ethers.providers.JsonRpcProvider) {
     if (provider == undefined) {
-      this.provider = new ethers.providers.JsonRpcProvider(this.nodeURL);
+      this.provider = new ethers.providers.JsonRpcBatchProvider(this.nodeURL);
     } else {
       this.provider = provider;
     }