@d8x/perpetuals-sdk 2.1.27-alpha2 → 2.1.29-alpha2

package/src/constants.ts

@@ -4,7 +4,7 @@ import { NodeSDKConfig } from "./nodeSDKTypes";
 export const ERC20_ABI = require("./abi/ERC20.json");
 export const MOCK_TOKEN_SWAP_ABI = require("./abi/MockTokenSwap.json");
 export const PROXY_ABI = require("./abi/IPerpetualManager.json");
-export const PROXY_ZKEVM_ABI = require("./abi-zkevm/IPerpetualManager.json");
+//export const PROXY_ZKEVM_ABI = require("./abi-zkevm/IPerpetualManager.json");
 export const LOB_FACTORY_ABI = require("./abi/LimitOrderBookFactory.json");
 export const LOB_ABI = require("./abi/LimitOrderBook.json");
 export const SHARE_TOKEN_ABI = require("./abi/ShareToken.json");
@@ -58,7 +58,8 @@ export const DEFAULT_CONFIG_TESTNET_NAME = "testnet";
 
 let defaultConfigs = require("./config/defaultConfig.json") as NodeSDKConfig[];
 defaultConfigs.map((config) => {
-  config.proxyABI = config.proxyABILocation.includes("abi-zkevm") ? PROXY_ZKEVM_ABI : PROXY_ABI;
+  //config.proxyABI = config.proxyABILocation.includes("abi-zkevm") ? PROXY_ZKEVM_ABI : PROXY_ABI;
+  config.proxyABI = PROXY_ABI;
   config.lobABI = LOB_ABI;
   config.lobFactoryABI = LOB_FACTORY_ABI;
   config.shareTokenABI = SHARE_TOKEN_ABI;

package/src/d8XMath.ts

@@ -778,23 +778,24 @@ function pmExcessCashAtLvg(
 }
 
 /**
- * Find maximal trade size (short dir=-1 or long dir=1) for prediction
+ * Find maximal *affordable* trade size (short dir=-1 or long dir=1) for prediction
  * markets at provided leverage and incorporating the current position
  * and wallet balance.
  * Factors in lot size and global max short/long
- * @param dir
- * @param lvg
- * @param walletBalCC
- * @param slippage  slippage percent
- * @param currentPosition
- * @param currentCashCC
- * @param currentLockedInValue
- * @param S2
- * @param Sm
- * @param S3
- * @param maxShort global max short order size (sign irrelevant)
- * @param maxLong global max long order size (positive)
- * @returns max trade size
+ * @param dir   direction of trade (-1 sell, 1 buy)
+ * @param lvg   leverage of the trade
+ * @param walletBalCC wallet balance of the trader (collateral currency)
+ * @param slippage  slippage percent used to estimate a traded price
+ * @param currentPosition position in base currency of the trader
+ * @param currentCashCC this is the cash available net of unpaid funding (often called available cash)
+ * @param currentLockedInValue average entry price * signed position size in base currency, in margin account
+ * @param S2  current index price of the form 1+p (regardless whether short or long)
+ * @param Sm  current mark price (not just the mark price index but including the ema-premium from the contract)
+ * @param S3  current collateral to quote index price
+ * @param glblMaxTrade global max short or long order size that we retreive, e.g., from position risk (sign irrelevant)
+ *        based on  long: (*ℓ+n) * (1-p) - m (1-p) s = F → n = (F+m*(1-p)*s)/(1-p)-ℓ*
+ *                  short: (s+n)*p - m p *ℓ* = F →n = (F+m*p**ℓ*)/p-s
+ * @returns max *signed* trade size
  */
 export function pmFindMaxPersonalTradeSizeAtLeverage(
   dir: number,
@@ -807,8 +808,7 @@ export function pmFindMaxPersonalTradeSizeAtLeverage(
   S2: number,
   Sm: number,
   S3: number,
-  maxShort: number,
-  maxLong: number
+  glblMaxTrade: number
 ): number {
   if (dir < 0) {
     dir = -1;
@@ -880,94 +880,17 @@ export function pmFindMaxPersonalTradeSizeAtLeverage(
     // Newton algorithm failed,
     // choose new starting value
     if (dir > 0) {
-      sNew = Math.random() * (maxLong - currentPosition);
-    } else {
-      sNew = -Math.random() * (Math.abs(maxShort) + currentPosition);
-    }
-  }
-  // ensure trade maximal trade sNew does not exceed
-  // the contract limits
-  if (sNew < -Math.abs(maxShort)) {
-    sNew = -Math.abs(maxShort);
-  } else if (sNew > maxLong) {
-    sNew = maxLong;
-  }
-  // round trade size down to lot
-  sNew = Math.sign(sNew) * Math.floor(Math.abs(sNew) / lot) * lot;
-  return sNew;
-}
-
-/**
- * Find maximal trade size (short dir=-1 or long dir=1) for prediction
- * markets at maximal leverage and incorporating the current position.
- * Agnostic about wallet balance.
- * @param dir
- * @param currentPosition
- * @param currentCashCC
- * @param currentLockedInValue
- * @param limitPrice
- * @param Sm
- * @param S3
- * @param totLong
- * @param totShort
- * @param maxShort
- * @param maxLong
- * @returns signed max trade size
- */
-export function pmFindMaxTradeSize(
-  dir: number,
-  currentPosition: number,
-  currentCashCC: number,
-  currentLockedInValue: number,
-  limitPrice: number,
-  Sm: number,
-  S3: number,
-  maxShort: number,
-  maxLong: number
-): number {
-  if (dir < 0) {
-    dir = -1;
-  } else {
-    dir = 1;
-  }
-  const lot = 10;
-  const deltaS = 1; //for derivative
-  const f0 = excessMargin(dir * deltaS, currentCashCC, currentPosition, currentLockedInValue, limitPrice, Sm, S3);
-  if (f0 < lot) {
-    // no trade possible
-    return 0;
-  }
-  // numerically find maximal trade size
-  let sNew = dir * lot * 10;
-  let s = 2 * sNew;
-  while (true) {
-    let count = 0;
-    while (Math.abs(sNew - s) > 1 && count < 100) {
-      s = sNew;
-      const f = excessMargin(s, currentCashCC, currentPosition, currentLockedInValue, limitPrice, Sm, S3) ** 2;
-      const f2 =
-        excessMargin(s + deltaS, currentCashCC, currentPosition, currentLockedInValue, limitPrice, Sm, S3) ** 2;
-      let ds = (f2 - f) / deltaS;
-      sNew = s - f / ds;
-      count += 1;
-    }
-    if (count < 100) {
-      break;
-    }
-    // Newton algorithm failed,
-    // choose new starting value
-    if (dir > 0) {
-      sNew = Math.random() * (maxLong - currentPosition);
+      sNew = Math.random() * (glblMaxTrade - currentPosition);
     } else {
-      sNew = -Math.random() * (Math.abs(maxShort) + currentPosition);
+      sNew = -Math.random() * (Math.abs(glblMaxTrade) + currentPosition);
     }
   }
   // ensure trade maximal trade sNew does not exceed
   // the contract limits
-  if (currentPosition + sNew < maxShort) {
-    sNew = maxShort - currentPosition;
-  } else if (currentPosition + sNew > maxLong) {
-    sNew = maxLong - currentPosition;
+  if (sNew < -Math.abs(glblMaxTrade)) {
+    sNew = -Math.abs(glblMaxTrade);
+  } else if (sNew > glblMaxTrade) {
+    sNew = glblMaxTrade;
   }
   // round trade size down to lot
   sNew = Math.sign(sNew) * Math.floor(Math.abs(sNew) / lot) * lot;

package/src/marketData.ts

@@ -38,7 +38,6 @@ import {
   entropy,
   expectedLoss,
   pmExchangeFee,
-  pmFindMaxTradeSize,
 } from "./d8XMath";
 import {
   type ExchangeInfo,
@@ -571,13 +570,13 @@ export default class MarketData extends PerpetualDataHandler {
       "getMaxSignedOpenTradeSizeForPos",
       encodedResults[2].returnData
     )[0] as bigint;
-    const maxLongTrade = Math.max(0, ABK64x64ToFloat(fMaxLong) - signedPositionNotionalBaseCCY);
+    const maxLongTrade = ABK64x64ToFloat(fMaxLong);
     // max sell
     const fMaxShort = this.proxyContract.interface.decodeFunctionResult(
       "getMaxSignedOpenTradeSizeForPos",
       encodedResults[3].returnData
     )[0] as bigint;
-    const maxShortTrade = Math.max(0, Math.abs(ABK64x64ToFloat(fMaxShort)) - signedPositionNotionalBaseCCY);
+    const maxShortTrade = ABK64x64ToFloat(fMaxShort);
     return { account: account, ammPrice: ammPrice, maxShortTrade: maxShortTrade, maxLongTrade: maxLongTrade };
   }
 
@@ -1160,7 +1159,7 @@ export default class MarketData extends PerpetualDataHandler {
    * Accounts for user's wallet balance.
    * @param {string} traderAddr Address of trader
    * @param {symbol} symbol Symbol of the form ETH-USD-MATIC
-   * @returns Maximal trade sizes
+   * @returns Maximal buy and sell trade sizes (positive)
    * @example
    * import { MarketData, PerpetualDataHandler } from '@d8x/perpetuals-sdk';
    * async function main() {
@@ -1191,6 +1190,15 @@ export default class MarketData extends PerpetualDataHandler {
     return this.rmMaxOrderSizeForTrader(traderAddr, symbol, overrides);
   }
 
+  /**
+   * pmMaxOrderSizeForTrader returns the max order size for the
+   * trader that is possible from AMM perspective (agnostic about wallet
+   * balance and leverage)
+   * @param traderAddr address of trader
+   * @param symbol perp symbol
+   * @param overrides optional
+   * @returns buy: number; sell: number absolute
+   */
   private async pmMaxOrderSizeForTrader(
     traderAddr: string,
     symbol: string,
@@ -1199,13 +1207,9 @@ export default class MarketData extends PerpetualDataHandler {
     if (!this.proxyContract || !this.multicall) {
       throw new Error("proxy contract not initialized");
     }
-    const IERC20 = new Interface(ERC20_ABI) as ERC20Interface;
     const perpId = PerpetualDataHandler.symbolToPerpetualId(symbol, this.symbolToPerpStaticInfo);
-    const poolInfo = this.poolStaticInfos[this.getPoolStaticInfoIndexFromSymbol(symbol)];
     const indexPriceInfo = await this.priceFeedGetter.fetchPricesForPerpetual(symbol);
-    const [fS2, fS3, fEma] = [indexPriceInfo.s2, indexPriceInfo.s3 ?? 0, indexPriceInfo.ema].map((x) =>
-      floatToABK64x64(x)
-    ) as [bigint, bigint, bigint];
+    const [fS3, fEma] = [indexPriceInfo.s3 ?? 0, indexPriceInfo.ema].map((x) => floatToABK64x64(x)) as [bigint, bigint];
     const proxyCalls: Multicall3.Call3Struct[] = [
       // 0: traderState
       {
@@ -1213,19 +1217,6 @@ export default class MarketData extends PerpetualDataHandler {
         allowFailure: false,
         callData: this.proxyContract.interface.encodeFunctionData("getTraderState", [perpId, traderAddr, [fEma, fS3]]),
       },
-
-      // 1: wallet balance
-      {
-        target: poolInfo.poolSettleTokenAddr,
-        allowFailure: false,
-        callData: IERC20.encodeFunctionData("balanceOf", [traderAddr]),
-      },
-      // 2: amm state
-      {
-        target: this.proxyContract.target,
-        allowFailure: false,
-        callData: this.proxyContract.interface.encodeFunctionData("getAMMState", [perpId, [fS2, fS3]]),
-      },
     ];
 
     // multicall
@@ -1234,11 +1225,6 @@ export default class MarketData extends PerpetualDataHandler {
       "getTraderState",
       encodedResults[0].returnData
     )[0];
-    const walletBalance = decNToFloat(
-      IERC20.decodeFunctionResult("balanceOf", encodedResults[1].returnData)[0],
-      poolInfo.poolSettleTokenDecimals
-    );
-    const ammState = this.proxyContract.interface.decodeFunctionResult("getAMMState", encodedResults[2].returnData)[0];
 
     const account = MarketData.buildMarginAccountFromState(
       symbol,
@@ -1247,51 +1233,17 @@ export default class MarketData extends PerpetualDataHandler {
       indexPriceInfo,
       true //isPredMkt
     );
-    const openInterestBC = ABK64x64ToFloat(ammState[11]);
-    const net = -ABK64x64ToFloat(ammState[1]);
-    let totLong, totShort;
-    if (net < 0) {
-      totLong = openInterestBC;
-      totShort = openInterestBC - Math.abs(net);
-    } else {
-      totLong = openInterestBC - net;
-      totShort = openInterestBC;
-    }
-
     let currentPositionBC = (account.side == BUY_SIDE ? 1 : -1) * account.positionNotionalBaseCCY;
-    const Sm = ABK64x64ToFloat(traderState[8]);
-    // settlement token must be equal to collateral token for walletBalance to be correct
-    const availCashCC = account.collateralCC + walletBalance + account.unrealizedFundingCollateralCCY;
     const idxNotional = 4;
     const [maxShortPosPerp, maxLongPosPerp] = await this.getMaxShortLongPos(
       perpId,
       traderState[idxNotional],
       overrides
     );
-
-    const maxShort = pmFindMaxTradeSize(
-      -1,
-      currentPositionBC,
-      availCashCC,
-      account.entryPrice * currentPositionBC,
-      Sm,
-      Sm,
-      indexPriceInfo.s3 ?? 0,
-      maxShortPosPerp,
-      maxLongPosPerp
-    );
-    const maxLong = pmFindMaxTradeSize(
-      1,
-      currentPositionBC,
-      availCashCC,
-      account.entryPrice * currentPositionBC,
-      Sm,
-      Sm,
-      indexPriceInfo.s3 ?? 0,
-      maxShortPosPerp,
-      maxLongPosPerp
-    );
-    return { buy: maxLong, sell: maxShort };
+    // max trade size from position; return positive value
+    const maxLongTrade = Math.abs(maxLongPosPerp - currentPositionBC);
+    const maxShortTrade = Math.abs(maxShortPosPerp - currentPositionBC);
+    return { buy: maxLongTrade, sell: maxShortTrade };
   }
 
   /**

package/src/version.ts

@@ -1 +1 @@
-export const D8X_SDK_VERSION = "2.1.27-alpha2";
+export const D8X_SDK_VERSION = "2.1.29-alpha2";