@d8x/perpetuals-sdk 2.6.23 → 2.7.1

package/dist/esm/d8XMath.d.ts

@@ -160,10 +160,27 @@ export declare function getNewPositionLeverage(tradeAmount: number, marginCollat
  * @param {number} price - price to trade amount 'tradeAmnt'
  * @param {number} S3 - collateral to quote conversion (=S2 if base-collateral, =1 if quote collateral, = index S3 if quanto)
  * @param {number} S2Mark - mark price
- * @param {boolean} isPredMkt - true if prediction market
+ * @param {number} cmin - Absolute minimum margin per contract, only for pred markets
  * @returns {number} Amount to be deposited to have the given leverage when trading into position pos before fees
  */
-export declare function getDepositAmountForLvgTrade(pos0: number, b0: number, tradeAmnt: number, targetLvg: number, price: number, S3: number, S2Mark: number, isPredMkt: boolean): number;
+export declare function getDepositAmountForLvgTrade(pos0: number, b0: number, tradeAmnt: number, targetLvg: number, price: number, S3: number, S2Mark: number, cmin: number | undefined): number;
+/**
+ * Determine amount to be deposited into margin account so that the given leverage
+ * is obtained when opening a prediction market position
+ * Does NOT include fees, but accounts for a possible non-zero current position
+ * Smart contract equivalent: getDepositAmountForPredMktLvgPosition
+ * @param {number} pos0 - current position
+ * @param {number} b0 - current balance
+ * @param {number} c0 - current available cash
+ * @param {number} tradeAmnt - amount to trade
+ * @param {number} targetLvg - target leverage
+ * @param {number} prob - prob to trade amount 'tradeAmnt'
+ * @param {number} S3 - collateral to quote conversion (=S2 if base-collateral, =1 if quote collateral, = index S3 if quanto)
+ * @param {number} markProb - mark prob
+ * @param {number} imr - minimum absolute margin per contract (fInitialMarginRate)
+ * @returns {number} Amount to be deposited to have the given leverage when trading into position pos before fees
+ */
+export declare function getDepositAmountForPredMktLvgTrade(pos0: number, b0: number, c0: number, tradeAmnt: number, targetLvg: number, prob: number, S3: number, markProb: number, imr: number): number;
 /**
  * Convert a perpetual price to probability (predtictive markets)
  * @param px Perpetual price
@@ -177,34 +194,16 @@ export declare function priceToProb(px: number): number;
  */
 export declare function probToPrice(prob: number): number;
 export declare function entropy(prob: number): number;
+export declare function pmMaintenanceMarginRate(position: number, lockedInQC: number, sm: number, m: number): number;
 /**
- * Maintenance margin rate for prediction markets.
+ * Initial margin rate for prediction markets.
  * @param posSign sign of position in base currency (can be signed position or -1, 1)
+ * @param s0 trade price
  * @param sm  mark-price (=1+p)
- * @param m   max margin rate from fInitialMarginRate
- * @returns margin rate to be applied (Math.abs(pos) * p * tau) / s3;
+ * @param cmin Absolute min margin saved as `fInitialMarginRate`
+ * @returns {number} The margin rate to be applied: `(Math.abs(pos) * p * tau) / s3`
  */
-export declare function pmMaintenanceMarginRate(posSign: number, sm: number, m?: number | undefined): number;
-/**
- * Maintenance margin rate for prediction markets.
- * @param posSign sign of position in base currency (can be signed position or -1, 1)
- * @param sm  mark-price (=1+p)
- * @param m   max margin rate from fMaintenanceMarginRate
- * @returns margin rate to be applied (Math.abs(pos) * p * tau) / s3;
- */
-export declare function pmInitialMarginRate(posSign: number, sm: number, m?: number | undefined): number;
-/**
- * Calculate the expected loss for a prediction market trade used for
- * prediction market fees
- * @param p probability derived from mark price (long)
- * @param m maximal maintenance rate from which we defer the actual maintenance margin rate
- * @param totLong total long in base currency
- * @param totShort total short
- * @param tradeAmt signed trade amount, can be zero
- * @param tradeMgnRate margin rate of the trader
- * @returns expected loss in dollars
- */
-export declare function expectedLoss(p: number, m: number, totLong: number, totShort: number, tradeAmt: number, tradeMgnRate: number): number;
+export declare function pmInitialMarginRate(posSign: number, s0: number, sm: number, cmin: number): number;
 /**
  * Exchange fee as a rate for prediction markets
  * For opening trades only
@@ -215,6 +214,8 @@ export declare function expectedLoss(p: number, m: number, totLong: number, totS
  * @returns dollar fee relative to tradeAmt
  */
 export declare function pmExchangeFee(prob: number, m: number, tradeAmt: number, tradeMgnRate: number): number;
+export declare function pmExitFee(varphi: number, varphiBar: number, mu_m: number, m_0: number, sigt: number, jump: number): number;
+export declare function pmOpenFee(varphi: number, varphiBar: number, mu_m: number, m_0: number, sigt: number, jump: number): number;
 /**
  * Margin balance for prediction markets
  * @param pos signed position
@@ -225,8 +226,18 @@ export declare function pmExchangeFee(prob: number, m: number, tradeAmt: number,
  * @returns current margin balance
  */
 export declare function pmMarginBalance(pos: number, s2: number, s3: number, ell: number, mc: number): number;
-export declare function pmExcessBalance(pos: number, s2: number, s3: number, ell: number, mc: number, m: number | undefined): number;
-export declare function pmFindLiquidationPrice(pos: number, s3: number, ell: number, mc: number, baseMarginRate: number | undefined, s2Start?: number | undefined): number;
+export declare function pmExcessBalance(pos: number, s2: number, s3: number, ell: number, mc: number, m: number): number;
+/**
+ *
+ * @param pos Signed position size
+ * @param s3 Collateral to quote conversion at spot
+ * @param ell Locked-in value
+ * @param mc Margin collateral
+ * @param baseMarginRate Maintenance margin per contract (mu_m)
+ * @param sm Mark price at entry
+ * @returns {number} Liquidation price as a probability in the range [0, 1]
+ */
+export declare function pmFindLiquidationPrice(pos: number, s3: number, ell: number, mc: number, baseMarginRate: number): number;
 /**
  * Find maximal *affordable* trade size (short dir=-1 or long dir=1) for prediction
  * markets at provided leverage and incorporating the current position
@@ -254,6 +265,6 @@ export declare function pmFindMaxPersonalTradeSizeAtLeverage(dir: number, lvg: n
  * @param short Short open OI
  * @param sm Mark price (>1)
  * @param isBuy True if trade is long
- * @param mr Maintenance margin rate
+ * @param mr Margin threshold per contract for liquidation (mu_m)
  */
 export declare function pmMaxSignedOpenTradeSize(long: number, short: number, sm: number, isBuy: boolean, mr: number, ammFundsQC: number): number;

package/dist/esm/d8XMath.js

@@ -331,30 +331,100 @@ export function getNewPositionLeverage(tradeAmount, marginCollateral, currentPos
  * @param {number} price - price to trade amount 'tradeAmnt'
  * @param {number} S3 - collateral to quote conversion (=S2 if base-collateral, =1 if quote collateral, = index S3 if quanto)
  * @param {number} S2Mark - mark price
- * @param {boolean} isPredMkt - true if prediction market
+ * @param {number} cmin - Absolute minimum margin per contract, only for pred markets
  * @returns {number} Amount to be deposited to have the given leverage when trading into position pos before fees
  */
-export function getDepositAmountForLvgTrade(pos0, b0, tradeAmnt, targetLvg, price, S3, S2Mark, isPredMkt) {
-    let pnl = (tradeAmnt * (S2Mark - price)) / S3;
-    let S2MarkBefore = S2Mark;
-    if (isPredMkt) {
-        // adjust mark price to 'probability'
-        S2Mark = S2Mark - 1;
-        S2MarkBefore = S2Mark;
-        if (pos0 < 0) {
-            S2MarkBefore = 1 - S2Mark;
-        }
-        if (pos0 + tradeAmnt < 0) {
-            S2Mark = 1 - S2Mark;
+export function getDepositAmountForLvgTrade(pos0, b0, tradeAmnt, targetLvg, price, S3, S2Mark, cmin) {
+    if (cmin && cmin > 0) {
+        // TODO: c0?
+        if (b0 != 0) {
+            console.log("b0 != 0");
         }
+        return getDepositAmountForPredMktLvgTrade(pos0, b0, 0, tradeAmnt, targetLvg, price - 1, S3, S2Mark - 1, cmin);
     }
+    let pnl = (tradeAmnt * (S2Mark - price)) / S3;
     if (targetLvg == 0) {
         // use current leverage
-        targetLvg = (Math.abs(pos0) * S2MarkBefore) / S3 / b0;
+        targetLvg = (Math.abs(pos0) * S2Mark) / S3 / b0;
     }
     let b = (Math.abs(pos0 + tradeAmnt) * S2Mark) / S3 / targetLvg;
     return -(b0 + pnl - b);
 }
+/**
+ * Determine amount to be deposited into margin account so that the given leverage
+ * is obtained when opening a prediction market position
+ * Does NOT include fees, but accounts for a possible non-zero current position
+ * Smart contract equivalent: getDepositAmountForPredMktLvgPosition
+ * @param {number} pos0 - current position
+ * @param {number} b0 - current balance
+ * @param {number} c0 - current available cash
+ * @param {number} tradeAmnt - amount to trade
+ * @param {number} targetLvg - target leverage
+ * @param {number} prob - prob to trade amount 'tradeAmnt'
+ * @param {number} S3 - collateral to quote conversion (=S2 if base-collateral, =1 if quote collateral, = index S3 if quanto)
+ * @param {number} markProb - mark prob
+ * @param {number} imr - minimum absolute margin per contract (fInitialMarginRate)
+ * @returns {number} Amount to be deposited to have the given leverage when trading into position pos before fees
+ */
+export function getDepositAmountForPredMktLvgTrade(pos0, b0, c0, tradeAmnt, targetLvg, prob, S3, markProb, imr) {
+    /**
+     * Smart contract implementation:
+          // find smallest x such that:
+          //      bal * s3 >= pos value / lvg
+          // where:
+          //      pos value / lvg = |pos| * R(pm, sign(pos)) * margin rate
+          //      pos = pos0 + k
+          //      cash = cash0 + x
+          //      ell = ell0 + px * k
+          //      bal * s3 = cash * s3 + pos * sm - ell
+          //               = bal0 * s3 + x * s3 + k * (sm - px)
+  
+          // subject to:
+          //      x >= 0
+          //      cash * s3 >= |pos| * min(cmin, prob(sign(pos)))
+          //      k * (sm - px) <= 0 a.s.
+          //      (positive pnl does not contribute, i.e. ignore px better than mark)
+  
+          // solution:
+          //  bal0 * s3 + x * s3 >= pos value / lvg + (k * (px - sm))_+ = v * s3
+          // -->
+          //  x >= v + (cash0 - bal0)_+ - cash0 = v - min(bal0, cash0)
+          //     = pos value / lvg/ s3 + (k * (px - sm))_+ / s3  - min (bal0, cash0)
+          //     = A + B - C
+          //  x >= |pos| *  min(cmin, prob(sign(pos))) / s3 - cash0
+          //  x >= 0
+  
+          // init x = A = pos value / lvg / s3
+          int128 fNewPos = _fPosition0.add(_fTradeAmount);
+          int128 v = (
+              fNewPos > 0 ? fNewPos.mul(_fMarkProb) : fNewPos.neg().mul(ONE_64x64.sub(_fMarkProb))
+          ).mul(_fMarginRate).div(_fS3);
+          // + B = max(0,k * (px - sm)) / s3
+          {
+              int128 fPnL = _fTradeAmount.mul(_fMarkProb.sub(_fTradeProb));
+              if (fPnL < 0) {
+                  v = v.sub(fPnL.div(_fS3)); // pnl < 0 -> increase v
+              }
+          }
+          // - C = - min(bal0, cash0) = - Equity
+          {
+              int128 equity = _fCash0CC < _fBalance0 ? _fCash0CC : _fBalance0;
+              v = v.sub(equity); // equity can be used / must be covered if negative
+          }
+          return v > 0 ? v : int128(0);
+     */
+    const newPos = pos0 + tradeAmnt;
+    const posProb = newPos > 0 ? markProb : 1 - markProb; // R(pm, sign(new pos))
+    const maxLvg = pmMaxLeverage(newPos, markProb, imr);
+    targetLvg = targetLvg > maxLvg ? maxLvg : targetLvg;
+    const posValue = (Math.abs(newPos) * posProb) / S3;
+    const tradeLoss = Math.max(0, tradeAmnt * (prob - markProb)) / S3;
+    const curEquity = Math.min(c0, b0);
+    return Math.max(posValue / targetLvg + tradeLoss - curEquity, 0);
+}
+function pmMaxLeverage(posSign, markProb, minMarginPerCtrct) {
+    return Math.round(100 * (posSign > 0 ? markProb / minMarginPerCtrct : (1 - markProb) / minMarginPerCtrct)) / 100;
+}
 /**
  * Convert a perpetual price to probability (predtictive markets)
  * @param px Perpetual price
@@ -369,7 +439,7 @@ export function priceToProb(px) {
  * @returns Perpetual price
  */
 export function probToPrice(prob) {
-    return 1 + prob;
+    return Math.max(1, Math.min(2, 1 + prob));
 }
 // shannon entropy
 export function entropy(prob) {
@@ -381,109 +451,61 @@ export function entropy(prob) {
 /**
  * Maintenance margin requirement for prediction markets
  * @param pos signed position
+ * @param lockedInQC locked in value
  * @param s2 mark price
  * @param s3 collateral to quote conversion
  * @param m base margin rate
  * @returns required margin balance
  */
-function pmMarginThresh(pos, s2, s3, m = 0.18) {
-    let p = s2 - 1;
-    if (pos < 0) {
-        p = 1 - p;
-    }
-    const h = entropy(p);
-    const tau = m + (0.4 - m) * h;
-    return (Math.abs(pos) * p * tau) / s3;
+function pmMarginThresh(pos, lockedInQC, s2, s3, m) {
+    return (pmMaintenanceMarginRate(pos, lockedInQC, s2, m) * Math.abs(pos)) / s3;
 }
 /**
  * Maintenance margin rate for prediction markets.
- * @param posSign sign of position in base currency (can be signed position or -1, 1)
+ * @param position signed position in base currency
+ * @param lockedInQC locked in value, p or 1-p times number of contracts
  * @param sm  mark-price (=1+p)
- * @param m   max margin rate from fInitialMarginRate
- * @returns margin rate to be applied (Math.abs(pos) * p * tau) / s3;
- */
-export function pmMaintenanceMarginRate(posSign, sm, m = 0.18) {
-    let p = sm - 1;
-    if (posSign < 0) {
-        p = 1 - p;
+ * @param m absolute maintenance buffer per contract (mu_m, fMaintenanceMarginRate)
+ * @returns {number} The margin rate to be applied: (Math.abs(pos) * p * tau) / s3
+ */ pmExchangeFee;
+export function pmMaintenanceMarginRate(position, lockedInQC, sm, m) {
+    let pm = sm - 1;
+    let entryP = position == 0 ? pm : Math.abs(lockedInQC / position) - 1;
+    if (position < 0) {
+        pm = 1 - pm;
+        entryP = 1 - entryP;
+    }
+    const L = Math.max(entryP - pm, 0);
+    if (position == 0) {
+        return Math.min(m + L, entryP) / pm;
+    }
+    else {
+        const balAtLiq = Math.min(m + L, entryP) * Math.abs(position) + (position * sm - lockedInQC);
+        return balAtLiq / pm / Math.abs(position);
     }
-    const h = entropy(p);
-    return m + (0.4 - m) * h;
 }
 /**
- * Maintenance margin rate for prediction markets.
+ * Initial margin rate for prediction markets.
  * @param posSign sign of position in base currency (can be signed position or -1, 1)
+ * @param s0 trade price
  * @param sm  mark-price (=1+p)
- * @param m   max margin rate from fMaintenanceMarginRate
- * @returns margin rate to be applied (Math.abs(pos) * p * tau) / s3;
+ * @param cmin Absolute min margin saved as `fInitialMarginRate`
+ * @returns {number} The margin rate to be applied: `(Math.abs(pos) * p * tau) / s3`
  */
-export function pmInitialMarginRate(posSign, sm, m = 0.2) {
-    let p = sm - 1;
+export function pmInitialMarginRate(posSign, s0, sm, cmin) {
+    let pm = sm - 1;
+    let p0 = s0 - 1;
     if (posSign < 0) {
-        p = 1 - p;
+        pm = 1 - pm; // R(p_mark, sign(pos))
+        p0 = 1 - p0; // R(p_entry, sign(pos))
     }
-    const h = entropy(p);
-    return m + (0.5 - m) * h;
-}
-/**
- * Calculate the expected loss for a prediction market trade used for
- * prediction market fees
- * @param p probability derived from mark price (long)
- * @param m maximal maintenance rate from which we defer the actual maintenance margin rate
- * @param totLong total long in base currency
- * @param totShort total short
- * @param tradeAmt signed trade amount, can be zero
- * @param tradeMgnRate margin rate of the trader
- * @returns expected loss in dollars
- */
-export function expectedLoss(p, m, totLong, totShort, tradeAmt, tradeMgnRate) {
-    // maintenance margin rate
-    m = (0.4 - m) * entropy(p) + m;
-    let dlm = 0;
-    let dl = 0;
-    let dsm = 0;
-    let ds = 0;
-    if (tradeAmt > 0) {
-        dlm = p * tradeAmt * tradeMgnRate;
-        dl = tradeAmt;
-    }
-    else if (tradeAmt < 0) {
-        dsm = (1 - p) * Math.abs(tradeAmt) * tradeMgnRate;
-        ds = Math.abs(tradeAmt);
-    }
-    const a = dl + totLong - m * totShort - dsm;
-    const b = ds + totShort - m * totLong - dlm;
-    return p * (1 - p) * Math.max(0, a + b);
-}
-/**
- * Equivalent to
- * const el0 = expectedLoss(prob, m, totLong, totShort, 0, 0);
- * const el1 = expectedLoss(prob, m, totLong, totShort, tradeAmt, tradeMgnRate)
- * const fee = (el1 - el0) / Math.abs(tradeAmt);
- * @param p prob long probability
- * @param m max maintenance margin rate (0.18)
- * @param tradeAmt trade amount in base currency
- * @param tradeMgnRate margin rate for this trade
- * @returns dollar fee
- */
-function expectedLossImpact(p, m, tradeAmt, tradeMgnRate) {
-    m = (0.4 - m) * entropy(p) + m;
-    let dlm = 0;
-    let dl = 0;
-    let dsm = 0;
-    let ds = 0;
-    if (tradeAmt > 0) {
-        dlm = p * tradeAmt * tradeMgnRate;
-        dl = tradeAmt;
-    }
-    else if (tradeAmt < 0) {
-        dsm = (1 - p) * Math.abs(tradeAmt) * tradeMgnRate;
-        ds = Math.abs(tradeAmt);
-    }
-    //long: p * (1 - p) max(0, dl-dlm) = p * (1 - p) max(0, tradeAmt - p * tradeAmt * tradeMgnRate)
-    const a = dl - dsm;
-    const b = ds - dlm;
-    return p * (1 - p) * Math.max(0, a + b);
+    // mu0 = max(Rm/lvg, min(Rm, cmin))
+    // balance  = (mu0 * |k| + k *(sm - s0)) / s3
+    // pos value = |k| * Rm / s3
+    // at max init lvg: Rm/lvg = min(cmin, Rm)
+    // --> margin rate = (mu0 + Rm - R0) / Rm
+    const mu0 = Math.min(pm, cmin) + Math.max(0, p0 - pm);
+    return (mu0 + pm - p0) / pm;
 }
 /**
  * Exchange fee as a rate for prediction markets
@@ -495,15 +517,63 @@ function expectedLossImpact(p, m, tradeAmt, tradeMgnRate) {
  * @returns dollar fee relative to tradeAmt
  */
 export function pmExchangeFee(prob, m, tradeAmt, tradeMgnRate) {
-    /*
-    equivalent:
-      const el0 = expectedLoss(prob, m, totLong, totShort, 0, 0);
-      const el1 = expectedLoss(prob, m, totLong, totShort, tradeAmt, tradeMgnRate);
-      const fee = (el1 - el0) / Math.abs(tradeAmt);
-    */
-    let fee = expectedLossImpact(prob, m, tradeAmt, tradeMgnRate) / Math.abs(tradeAmt);
+    // TODO: port contract logic here
+    const [kappa, es] = [0, 0];
+    prob = tradeAmt > 0 ? prob : 1 - prob;
+    let fee = prob * (1 - kappa);
+    const scaledLvg = prob * tradeMgnRate * (1 - fee);
+    fee = fee * (1 - prob) - scaledLvg + es;
     return Math.max(fee, 0.001);
 }
+export function pmExitFee(varphi, varphiBar, mu_m, m_0, sigt, jump) {
+    const pLiq = varphi + mu_m - m_0;
+    const kappa = calcKappa(varphiBar, pLiq, sigt);
+    let fee = prdMktLvgFee(kappa, varphi, m_0);
+    return fee;
+}
+export function pmOpenFee(varphi, varphiBar, mu_m, m_0, sigt, jump) {
+    const pLiq = varphi + mu_m - m_0;
+    const kappa = calcKappa(varphiBar, pLiq, sigt);
+    const es = calcJumpRisk(kappa, varphiBar, jump);
+    const feecap = (1 - varphiBar) * varphiBar - (1 - varphiBar) * m_0;
+    let fee = prdMktLvgFee(kappa, varphi, m_0);
+    fee = fee + es;
+    if (fee > feecap) {
+        fee = feecap;
+    }
+    if (fee < 0.001) {
+        fee = 0.001;
+    }
+    return fee;
+}
+//sigt = sigma*sqrt(t)
+function calcKappa(varphi, varphiLiq, sigt) {
+    const p = 1 - varphi;
+    const pStar = 1 - varphiLiq;
+    const x0 = Math.log(p / (1 - p));
+    const a = Math.log(pStar / (1 - pStar));
+    const kappa = 2 * (1 - cdfNormalStd((a - x0) / sigt));
+    return kappa;
+}
+function calcJumpRisk(kappa, varphi, jump) {
+    jump = Math.floor(jump / 0.05) * 0.05;
+    const jr = jump * (1 - varphi * (1 - kappa));
+    return jr;
+}
+//opening leverage fee with cash per contract of m0, without jump risk
+function prdMktLvgFee(kappa, varphi, m0) {
+    const f = (1 - kappa) * varphi * (1 - varphi) - (1 - varphi * (1 - kappa)) * m0;
+    return f;
+}
+function cdfNormalStd(x) {
+    const t = 1 / (1 + 0.2315419 * Math.abs(x));
+    const d = 0.3989423 * Math.exp((-x * x) / 2);
+    let prob = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))));
+    if (x > 0) {
+        prob = 1 - prob;
+    }
+    return prob;
+}
 /**
  * Margin balance for prediction markets
  * @param pos signed position
@@ -517,27 +587,39 @@ export function pmMarginBalance(pos, s2, s3, ell, mc) {
     return (pos * s2) / s3 - ell / s3 + mc;
 }
 export function pmExcessBalance(pos, s2, s3, ell, mc, m) {
-    return pmMarginBalance(pos, s2, s3, ell, mc) - pmMarginThresh(pos, s2, s3, m);
-}
-// finds the liquidation price for prediction markets
-// using Newton's algorithm
-export function pmFindLiquidationPrice(pos, s3, ell, mc, baseMarginRate, s2Start = 0.5) {
-    const delta_s = 0.01;
-    let s = 100;
-    let s_new = s2Start;
-    while (Math.abs(s_new - s) > 0.01) {
-        s = s_new;
-        const f = Math.pow(pmExcessBalance(pos, s, s3, ell, mc, baseMarginRate), 2);
-        const ds = (Math.pow(pmExcessBalance(pos, s + delta_s, s3, ell, mc, baseMarginRate), 2) - f) / delta_s;
-        s_new = s - f / ds;
-        if (s_new < 1) {
-            return 1;
-        }
-        if (s_new > 2) {
-            return 2;
-        }
+    return pmMarginBalance(pos, s2, s3, ell, mc) - pmMarginThresh(pos, ell, s2, s3, m);
+}
+/**
+ *
+ * @param pos Signed position size
+ * @param s3 Collateral to quote conversion at spot
+ * @param ell Locked-in value
+ * @param mc Margin collateral
+ * @param baseMarginRate Maintenance margin per contract (mu_m)
+ * @param sm Mark price at entry
+ * @returns {number} Liquidation price as a probability in the range [0, 1]
+ */
+export function pmFindLiquidationPrice(pos, s3, ell, mc, baseMarginRate) {
+    // liq <--> (A) c / |k| < R0  && (B) E < |k| * mu_m
+    // if not (A), return 0 (long) or 1 (short) [no liq]
+    // else, solve for pm:
+    //  E = c - |k| max(0, s * (p0 - pm)) = |k| * mu_m
+    //  if c/|k| < mu_m:
+    //    any number would do --> return 1 (long) or 0 (short)
+    //  else:
+    //    pm = p0 - s * (c/|k| - mu_m)
+    const p0 = Math.abs(ell / pos) - 1;
+    const R0 = pos > 0 ? p0 : 1 - p0;
+    const excessPerCtrct = (mc * s3) / Math.abs(pos) - baseMarginRate; // c/|k| - mu_m, mu_m < CMINUS
+    if (mc * s3 > R0 * Math.abs(pos)) {
+        // c > |k| R(p0, s) --> no liquidation
+        return probToPrice(pos > 0 ? 0.0001 : 0.9999);
     }
-    return s;
+    if (excessPerCtrct < 0) {
+        // already underwater
+        return probToPrice(pos > 0 ? 0.9999 : 0.0001);
+    }
+    return probToPrice(pos > 0 ? p0 - excessPerCtrct : p0 + excessPerCtrct);
 }
 /**
  * Calculate the excess margin defined as
@@ -581,19 +663,22 @@ function excessMargin(tradeAmt, currentCashCC, currentPos, currentLockedInQC, li
  * @returns deposit amount
  */
 function pmGetDepositAmtForLvgTrade(tradeAmt, targetLvg, price, S3, S2Mark) {
-    const pnl = (tradeAmt * (S2Mark - price)) / S3;
-    let p = S2Mark - 1;
-    if (tradeAmt < 0) {
-        p = 1 - p;
-    }
-    const b = (Math.abs(tradeAmt) * p) / S3 / targetLvg;
-    const amt = -(pnl - b);
-    // check:
-    //bal = amt+pnl
-    //pos_val = (np.abs(trade_amt) * p) / S3
-    //lvg = pos_val/bal
-    //assert(np.abs(lvg-targetLvg)<0.1)
-    return amt;
+    const cmin = 0.05;
+    // refer to main contract function for this:
+    return getDepositAmountForPredMktLvgTrade(0, 0, 0, tradeAmt, targetLvg, price - 1, S3, S2Mark - 1, cmin);
+    // const pnl = (tradeAmt * (S2Mark - price)) / S3;
+    // let p = S2Mark - 1;
+    // if (tradeAmt < 0) {
+    //   p = 1 - p;
+    // }
+    // const b = (Math.abs(tradeAmt) * p) / S3 / targetLvg;
+    // const amt = -(pnl - b);
+    // // check:
+    // //bal = amt+pnl
+    // //pos_val = (np.abs(trade_amt) * p) / S3
+    // //lvg = pos_val/bal
+    // //assert(np.abs(lvg-targetLvg)<0.1)
+    // return amt;
 }
 /**
  * Internal function to calculate cash over initial margin rate
@@ -613,16 +698,19 @@ function pmGetDepositAmtForLvgTrade(tradeAmt, targetLvg, price, S3, S2Mark) {
  * @returns excess cash
  */
 function pmExcessCashAtLvg(tradeAmt, lvg, walletBalCC, currentCashCC, currentPosition, currentLockedInValue, slippage, S2, Sm, S3) {
+    const cmin = 0.05;
+    const mu_m = 0.01;
+    const maxLvg = pmMaxLeverage(currentPosition + tradeAmt, Sm - 1, cmin);
+    lvg = lvg < maxLvg ? lvg : maxLvg;
     //determine deposit amount for given leverage
     const limitPrice = S2 * (1 + Math.sign(tradeAmt) * slippage);
     const depositFromWallet = pmGetDepositAmtForLvgTrade(tradeAmt, lvg, limitPrice, S3, Sm);
-    const m0 = 0.18;
     //leverage fee
     let p0 = Sm - 1;
     if (tradeAmt < 0) {
         p0 = 2 - Sm; //=1-(Sm-1)
     }
-    const feeCc = (Math.abs(tradeAmt) * pmExchangeFee(p0, m0, tradeAmt, 1 / lvg)) / S3;
+    const feeCc = (Math.abs(tradeAmt) * pmExchangeFee(p0, mu_m, tradeAmt, 1 / lvg)) / S3;
     //excess cash
     let exc = walletBalCC - depositFromWallet - feeCc;
     if (exc < 0) {
@@ -631,12 +719,13 @@ function pmExcessCashAtLvg(tradeAmt, lvg, walletBalCC, currentCashCC, currentPos
     // margin balance
     let pos = currentPosition + tradeAmt;
     let p = Sm - 1;
+    let entryP = limitPrice - 1;
     if (pos < 0) {
-        p = 2 - Sm;
+        p = 1 - Sm;
+        entryP = 1 - entryP;
     }
-    const h = entropy(p);
-    const tau = m0 + (0.5 - m0) * h;
-    const thresh = Math.abs(pos) * p * tau;
+    const mu0 = p / lvg + Math.max(0, entryP - p);
+    const thresh = Math.abs(pos) * mu0;
     const b0 = depositFromWallet +
         currentCashCC +
         Math.abs(currentPosition) * Sm -
@@ -748,13 +837,15 @@ export function pmFindMaxPersonalTradeSizeAtLeverage(dir, lvg, walletBalCC, slip
  * @param short Short open OI
  * @param sm Mark price (>1)
  * @param isBuy True if trade is long
- * @param mr Maintenance margin rate
+ * @param mr Margin threshold per contract for liquidation (mu_m)
  */
 export function pmMaxSignedOpenTradeSize(long, short, sm, isBuy, mr, ammFundsQC) {
-    if (sm < 1) {
+    if (sm <= 1 || sm >= 2) {
+        // closed
         return 0;
     }
-    const m = pmMaintenanceMarginRate(isBuy ? 1 : -1, sm, mr);
+    const counterPos = isBuy ? -short : long;
+    const m = pmMaintenanceMarginRate(counterPos, counterPos * sm, sm, mr);
     let p = !isBuy ? sm - 1 : 2 - sm;
     p = p < 0.01 ? 0.01 : p > 0.99 ? 0.99 : p; // same cap as contract
     return isBuy ? (ammFundsQC + m * p * short) / p - long : -(ammFundsQC + m * p * long) / p + short;