@drift-labs/sdk 2.0.14 → 2.0.16

package/lib/math/amm.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateMaxBaseAssetAmountFillable = exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateSpreadBN = exports.calculateMaxSpread = exports.calculateEffectiveLeverage = exports.calculateInventoryScale = exports.calculateMarketOpenBidAsk = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = exports.calculateOptimalPegAndBudget = exports.calculatePegFromTargetPrice = void 0;
+exports.calculateMaxBaseAssetAmountFillable = exports.calculateQuoteAssetAmountSwapped = exports.calculateMaxBaseAssetAmountToTrade = exports.calculateTerminalPrice = exports.getSwapDirection = exports.calculateSwapOutput = exports.calculateSpreadReserves = exports.calculateSpread = exports.calculateSpreadBN = exports.calculateVolSpreadBN = exports.calculateMaxSpread = exports.calculateEffectiveLeverage = exports.calculateInventoryScale = exports.calculateMarketOpenBidAsk = exports.calculateAmmReservesAfterSwap = exports.calculatePrice = exports.calculateBidAskPrice = exports.calculateUpdatedAMMSpreadReserves = exports.calculateUpdatedAMM = exports.calculateNewAmm = exports.calculateOptimalPegAndBudget = exports.calculatePegFromTargetPrice = void 0;
 const anchor_1 = require("@project-serum/anchor");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
 const assert_1 = require("../assert/assert");
 const __1 = require("..");
 const repeg_1 = require("./repeg");
+const oracles_1 = require("./oracles");
 function calculatePegFromTargetPrice(targetPrice, baseAssetReserve, quoteAssetReserve) {
     return anchor_1.BN.max(targetPrice
         .mul(baseAssetReserve)
@@ -23,15 +24,16 @@ function calculateOptimalPegAndBudget(amm, oraclePriceData) {
     const totalFeeLB = amm.totalExchangeFee.div(new anchor_1.BN(2));
     const budget = anchor_1.BN.max(numericConstants_1.ZERO, amm.totalFeeMinusDistributions.sub(totalFeeLB));
     if (budget.lt(prePegCost)) {
-        const maxPriceSpread = new anchor_1.BN(amm.maxSpread)
+        const halfMaxPriceSpread = new anchor_1.BN(amm.maxSpread)
+            .div(new anchor_1.BN(2))
             .mul(targetPrice)
             .div(numericConstants_1.BID_ASK_SPREAD_PRECISION);
         let newTargetPrice;
         let newOptimalPeg;
         let newBudget;
         const targetPriceGap = reservePriceBefore.sub(targetPrice);
-        if (targetPriceGap.abs().gt(maxPriceSpread)) {
-            const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
+        if (targetPriceGap.abs().gt(halfMaxPriceSpread)) {
+            const markAdj = targetPriceGap.abs().sub(halfMaxPriceSpread);
             if (targetPriceGap.lt(new anchor_1.BN(0))) {
                 newTargetPrice = reservePriceBefore.add(markAdj);
             }
@@ -91,12 +93,17 @@ function calculateUpdatedAMM(amm, oraclePriceData) {
     newAmm.terminalQuoteAssetReserve = newQuoteAssetReserve;
     newAmm.totalFeeMinusDistributions =
         newAmm.totalFeeMinusDistributions.sub(prepegCost);
+    newAmm.netRevenueSinceLastFunding =
+        newAmm.netRevenueSinceLastFunding.sub(prepegCost);
     return newAmm;
 }
 exports.calculateUpdatedAMM = calculateUpdatedAMM;
 function calculateUpdatedAMMSpreadReserves(amm, direction, oraclePriceData) {
     const newAmm = calculateUpdatedAMM(amm, oraclePriceData);
-    const dirReserves = calculateSpreadReserves(newAmm, direction, oraclePriceData);
+    const [shortReserves, longReserves] = calculateSpreadReserves(newAmm, oraclePriceData);
+    const dirReserves = (0, types_1.isVariant)(direction, 'long')
+        ? longReserves
+        : shortReserves;
     const result = {
         baseAssetReserve: dirReserves.baseAssetReserve,
         quoteAssetReserve: dirReserves.quoteAssetReserve,
@@ -114,8 +121,7 @@ function calculateBidAskPrice(amm, oraclePriceData, withUpdate = true) {
     else {
         newAmm = amm;
     }
-    const askReserves = calculateSpreadReserves(newAmm, types_1.PositionDirection.LONG, oraclePriceData);
-    const bidReserves = calculateSpreadReserves(newAmm, types_1.PositionDirection.SHORT, oraclePriceData);
+    const [bidReserves, askReserves] = calculateSpreadReserves(newAmm, oraclePriceData);
     const askPrice = calculatePrice(askReserves.baseAssetReserve, askReserves.quoteAssetReserve, newAmm.pegMultiplier);
     const bidPrice = calculatePrice(bidReserves.baseAssetReserve, bidReserves.quoteAssetReserve, newAmm.pegMultiplier);
     return [bidPrice, askPrice];
@@ -168,14 +174,14 @@ exports.calculateAmmReservesAfterSwap = calculateAmmReservesAfterSwap;
 function calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
     // open orders
     let openAsks;
-    if (maxBaseAssetReserve > baseAssetReserve) {
+    if (maxBaseAssetReserve.gt(baseAssetReserve)) {
         openAsks = maxBaseAssetReserve.sub(baseAssetReserve).mul(new anchor_1.BN(-1));
     }
     else {
         openAsks = numericConstants_1.ZERO;
     }
     let openBids;
-    if (minBaseAssetReserve < baseAssetReserve) {
+    if (minBaseAssetReserve.lt(baseAssetReserve)) {
         openBids = baseAssetReserve.sub(minBaseAssetReserve);
     }
     else {
@@ -184,13 +190,26 @@ function calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBas
     return [openBids, openAsks];
 }
 exports.calculateMarketOpenBidAsk = calculateMarketOpenBidAsk;
-function calculateInventoryScale(netBaseAssetAmount, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
-    const maxScale = numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(10));
+function calculateInventoryScale(baseAssetAmountWithAmm, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve, directionalSpread, maxSpread) {
+    if (baseAssetAmountWithAmm.eq(numericConstants_1.ZERO)) {
+        return 0;
+    }
+    const defaultLargeBidAskFactor = numericConstants_1.BID_ASK_SPREAD_PRECISION.mul(new anchor_1.BN(10));
     // inventory skew
     const [openBids, openAsks] = calculateMarketOpenBidAsk(baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve);
     const minSideLiquidity = anchor_1.BN.max(new anchor_1.BN(1), anchor_1.BN.min(openBids.abs(), openAsks.abs()));
-    const inventoryScale = anchor_1.BN.min(maxScale, netBaseAssetAmount.mul(maxScale).div(minSideLiquidity).abs()).toNumber() / numericConstants_1.BID_ASK_SPREAD_PRECISION.toNumber();
-    return inventoryScale;
+    const inventoryScaleMax = anchor_1.BN.max(defaultLargeBidAskFactor, new anchor_1.BN(maxSpread / 2)
+        .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
+        .div(new anchor_1.BN(Math.max(directionalSpread, 1)))).toNumber() / numericConstants_1.BID_ASK_SPREAD_PRECISION.toNumber();
+    const inventoryScale = baseAssetAmountWithAmm
+        .mul(anchor_1.BN.max(baseAssetAmountWithAmm.abs(), numericConstants_1.BASE_PRECISION))
+        .div(numericConstants_1.BASE_PRECISION)
+        .mul(defaultLargeBidAskFactor)
+        .div(minSideLiquidity)
+        .abs()
+        .toNumber() / numericConstants_1.BID_ASK_SPREAD_PRECISION.toNumber();
+    const inventorySpreadScale = Math.min(inventoryScaleMax, 1 + inventoryScale);
+    return inventorySpreadScale;
 }
 exports.calculateInventoryScale = calculateInventoryScale;
 function calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, reservePrice, totalFeeMinusDistributions) {
@@ -215,31 +234,47 @@ function calculateMaxSpread(marginRatioInitial) {
     return maxTargetSpread;
 }
 exports.calculateMaxSpread = calculateMaxSpread;
-function calculateSpreadBN(baseSpread, lastOracleReservePriceSpreadPct, lastOracleConfPct, maxSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, reservePrice, totalFeeMinusDistributions, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve) {
-    let longSpread = baseSpread / 2;
-    let shortSpread = baseSpread / 2;
-    if (lastOracleReservePriceSpreadPct.gte(numericConstants_1.ZERO)) {
+function calculateVolSpreadBN(lastOracleConfPct, reservePrice, markStd, oracleStd, longIntensity, shortIntensity, volume24H) {
+    const marketAvgStdPct = markStd
+        .add(oracleStd)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .div(reservePrice)
+        .div(new anchor_1.BN(2));
+    const volSpread = anchor_1.BN.max(lastOracleConfPct, marketAvgStdPct.div(new anchor_1.BN(2)));
+    const clampMin = numericConstants_1.PERCENTAGE_PRECISION.div(new anchor_1.BN(100));
+    const clampMax = numericConstants_1.PERCENTAGE_PRECISION.mul(new anchor_1.BN(16)).div(new anchor_1.BN(10));
+    const longVolSpreadFactor = (0, __1.clampBN)(longIntensity.mul(numericConstants_1.PERCENTAGE_PRECISION).div(anchor_1.BN.max(numericConstants_1.ONE, volume24H)), clampMin, clampMax);
+    const shortVolSpreadFactor = (0, __1.clampBN)(shortIntensity.mul(numericConstants_1.PERCENTAGE_PRECISION).div(anchor_1.BN.max(numericConstants_1.ONE, volume24H)), clampMin, clampMax);
+    const longVolSpread = anchor_1.BN.max(lastOracleConfPct, volSpread.mul(longVolSpreadFactor).div(numericConstants_1.PERCENTAGE_PRECISION));
+    const shortVolSpread = anchor_1.BN.max(lastOracleConfPct, volSpread.mul(shortVolSpreadFactor).div(numericConstants_1.PERCENTAGE_PRECISION));
+    return [longVolSpread, shortVolSpread];
+}
+exports.calculateVolSpreadBN = calculateVolSpreadBN;
+function calculateSpreadBN(baseSpread, lastOracleReservePriceSpreadPct, lastOracleConfPct, maxSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, baseAssetAmountWithAmm, reservePrice, totalFeeMinusDistributions, netRevenueSinceLastFunding, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve, markStd, oracleStd, longIntensity, shortIntensity, volume24H) {
+    const [longVolSpread, shortVolSpread] = calculateVolSpreadBN(lastOracleConfPct, reservePrice, markStd, oracleStd, longIntensity, shortIntensity, volume24H);
+    let longSpread = Math.max(baseSpread / 2, longVolSpread.toNumber());
+    let shortSpread = Math.max(baseSpread / 2, shortVolSpread.toNumber());
+    if (lastOracleReservePriceSpreadPct.gt(numericConstants_1.ZERO)) {
         shortSpread = Math.max(shortSpread, lastOracleReservePriceSpreadPct.abs().toNumber() +
-            lastOracleConfPct.toNumber());
+            shortVolSpread.toNumber());
     }
     else if (lastOracleReservePriceSpreadPct.lt(numericConstants_1.ZERO)) {
         longSpread = Math.max(longSpread, lastOracleReservePriceSpreadPct.abs().toNumber() +
-            lastOracleConfPct.toNumber());
+            longVolSpread.toNumber());
     }
     const maxTargetSpread = Math.max(maxSpread, lastOracleReservePriceSpreadPct.abs().toNumber());
-    const MAX_BID_ASK_INVENTORY_SKEW_FACTOR = 10;
-    const inventoryScale = calculateInventoryScale(netBaseAssetAmount, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve);
-    const inventorySpreadScale = Math.min(MAX_BID_ASK_INVENTORY_SKEW_FACTOR, 1 + inventoryScale);
-    if (netBaseAssetAmount.gt(numericConstants_1.ZERO)) {
+    const inventorySpreadScale = calculateInventoryScale(baseAssetAmountWithAmm, baseAssetReserve, minBaseAssetReserve, maxBaseAssetReserve, baseAssetAmountWithAmm.gt(numericConstants_1.ZERO) ? longSpread : shortSpread, maxTargetSpread);
+    if (baseAssetAmountWithAmm.gt(numericConstants_1.ZERO)) {
         longSpread *= inventorySpreadScale;
     }
-    else if (netBaseAssetAmount.lt(numericConstants_1.ZERO)) {
+    else if (baseAssetAmountWithAmm.lt(numericConstants_1.ZERO)) {
         shortSpread *= inventorySpreadScale;
     }
-    const effectiveLeverage = calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, netBaseAssetAmount, reservePrice, totalFeeMinusDistributions);
+    const MAX_SPREAD_SCALE = 10;
     if (totalFeeMinusDistributions.gt(numericConstants_1.ZERO)) {
-        const spreadScale = Math.min(MAX_BID_ASK_INVENTORY_SKEW_FACTOR, 1 + effectiveLeverage);
-        if (netBaseAssetAmount.gt(numericConstants_1.ZERO)) {
+        const effectiveLeverage = calculateEffectiveLeverage(baseSpread, quoteAssetReserve, terminalQuoteAssetReserve, pegMultiplier, baseAssetAmountWithAmm, reservePrice, totalFeeMinusDistributions);
+        const spreadScale = Math.min(MAX_SPREAD_SCALE, 1 + effectiveLeverage);
+        if (baseAssetAmountWithAmm.gt(numericConstants_1.ZERO)) {
             longSpread *= spreadScale;
         }
         else {
@@ -247,26 +282,43 @@ function calculateSpreadBN(baseSpread, lastOracleReservePriceSpreadPct, lastOrac
         }
     }
     else {
-        longSpread *= MAX_BID_ASK_INVENTORY_SKEW_FACTOR;
-        shortSpread *= MAX_BID_ASK_INVENTORY_SKEW_FACTOR;
+        longSpread *= MAX_SPREAD_SCALE;
+        shortSpread *= MAX_SPREAD_SCALE;
+    }
+    if (netRevenueSinceLastFunding.lt(numericConstants_1.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT)) {
+        const retreatAmount = Math.min(maxTargetSpread / 10, Math.floor((baseSpread * netRevenueSinceLastFunding.abs().toNumber()) /
+            numericConstants_1.DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT.toNumber()));
+        const halfRetreatAmount = Math.floor(retreatAmount / 2);
+        if (baseAssetAmountWithAmm.gt(numericConstants_1.ZERO)) {
+            longSpread += retreatAmount;
+            shortSpread += halfRetreatAmount;
+        }
+        else if (baseAssetAmountWithAmm.lt(numericConstants_1.ZERO)) {
+            longSpread += halfRetreatAmount;
+            shortSpread += retreatAmount;
+        }
+        else {
+            longSpread += halfRetreatAmount;
+            shortSpread += halfRetreatAmount;
+        }
     }
     const totalSpread = longSpread + shortSpread;
     if (totalSpread > maxTargetSpread) {
         if (longSpread > shortSpread) {
-            longSpread = Math.min(longSpread, maxTargetSpread);
+            longSpread = Math.ceil((longSpread * maxTargetSpread) / totalSpread);
             shortSpread = maxTargetSpread - longSpread;
         }
         else {
-            shortSpread = Math.min(shortSpread, maxTargetSpread);
+            shortSpread = Math.ceil((shortSpread * maxTargetSpread) / totalSpread);
             longSpread = maxTargetSpread - shortSpread;
         }
     }
     return [longSpread, shortSpread];
 }
 exports.calculateSpreadBN = calculateSpreadBN;
-function calculateSpread(amm, direction, oraclePriceData) {
+function calculateSpread(amm, oraclePriceData) {
     if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
-        return amm.baseSpread / 2;
+        return [amm.baseSpread / 2, amm.baseSpread / 2];
     }
     const reservePrice = calculatePrice(amm.baseAssetReserve, amm.quoteAssetReserve, amm.pegMultiplier);
     const targetPrice = (oraclePriceData === null || oraclePriceData === void 0 ? void 0 : oraclePriceData.price) || reservePrice;
@@ -278,38 +330,38 @@ function calculateSpread(amm, direction, oraclePriceData) {
     const confIntervalPct = confInterval
         .mul(numericConstants_1.BID_ASK_SPREAD_PRECISION)
         .div(reservePrice);
-    const [longSpread, shortSpread] = calculateSpreadBN(amm.baseSpread, targetMarkSpreadPct, confIntervalPct, amm.maxSpread, amm.quoteAssetReserve, amm.terminalQuoteAssetReserve, amm.pegMultiplier, amm.baseAssetAmountWithAmm, reservePrice, amm.totalFeeMinusDistributions, amm.baseAssetReserve, amm.minBaseAssetReserve, amm.maxBaseAssetReserve);
-    let spread;
-    if ((0, types_1.isVariant)(direction, 'long')) {
-        spread = longSpread;
-    }
-    else {
-        spread = shortSpread;
-    }
-    return spread;
+    const now = new anchor_1.BN(new Date().getTime() / 1000); //todo
+    const liveOracleStd = (0, oracles_1.calculateLiveOracleStd)(amm, oraclePriceData, now);
+    const [longSpread, shortSpread] = calculateSpreadBN(amm.baseSpread, targetMarkSpreadPct, confIntervalPct, amm.maxSpread, amm.quoteAssetReserve, amm.terminalQuoteAssetReserve, amm.pegMultiplier, amm.baseAssetAmountWithAmm, reservePrice, amm.totalFeeMinusDistributions, amm.netRevenueSinceLastFunding, amm.baseAssetReserve, amm.minBaseAssetReserve, amm.maxBaseAssetReserve, amm.markStd, liveOracleStd, amm.longIntensityVolume, amm.shortIntensityVolume, amm.volume24H);
+    return [longSpread, shortSpread];
 }
 exports.calculateSpread = calculateSpread;
-function calculateSpreadReserves(amm, direction, oraclePriceData) {
-    const spread = calculateSpread(amm, direction, oraclePriceData);
-    if (spread === 0) {
+function calculateSpreadReserves(amm, oraclePriceData) {
+    function calculateSpreadReserve(spread, direction, amm) {
+        if (spread === 0) {
+            return {
+                baseAssetReserve: amm.baseAssetReserve,
+                quoteAssetReserve: amm.quoteAssetReserve,
+            };
+        }
+        const quoteAssetReserveDelta = amm.quoteAssetReserve.div(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(new anchor_1.BN(spread / 2)));
+        let quoteAssetReserve;
+        if ((0, types_1.isVariant)(direction, 'long')) {
+            quoteAssetReserve = amm.quoteAssetReserve.add(quoteAssetReserveDelta);
+        }
+        else {
+            quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAssetReserveDelta);
+        }
+        const baseAssetReserve = amm.sqrtK.mul(amm.sqrtK).div(quoteAssetReserve);
         return {
-            baseAssetReserve: amm.baseAssetReserve,
-            quoteAssetReserve: amm.quoteAssetReserve,
+            baseAssetReserve,
+            quoteAssetReserve,
         };
     }
-    const quoteAsserReserveDelta = amm.quoteAssetReserve.div(numericConstants_1.BID_ASK_SPREAD_PRECISION.div(new anchor_1.BN(spread / 2)));
-    let quoteAssetReserve;
-    if ((0, types_1.isVariant)(direction, 'long')) {
-        quoteAssetReserve = amm.quoteAssetReserve.add(quoteAsserReserveDelta);
-    }
-    else {
-        quoteAssetReserve = amm.quoteAssetReserve.sub(quoteAsserReserveDelta);
-    }
-    const baseAssetReserve = amm.sqrtK.mul(amm.sqrtK).div(quoteAssetReserve);
-    return {
-        baseAssetReserve,
-        quoteAssetReserve,
-    };
+    const [longSpread, shortSpread] = calculateSpread(amm, oraclePriceData);
+    const askReserves = calculateSpreadReserve(longSpread, types_1.PositionDirection.LONG, amm);
+    const bidReserves = calculateSpreadReserve(shortSpread, types_1.PositionDirection.SHORT, amm);
+    return [bidReserves, askReserves];
 }
 exports.calculateSpreadReserves = calculateSpreadReserves;
 /**
@@ -376,7 +428,10 @@ function calculateMaxBaseAssetAmountToTrade(amm, limit_price, direction, oracleP
         .div(limit_price)
         .div(numericConstants_1.PEG_PRECISION);
     const newBaseAssetReserve = (0, __1.squareRootBN)(newBaseAssetReserveSquared);
-    const baseAssetReserveBefore = calculateSpreadReserves(amm, direction, oraclePriceData).baseAssetReserve;
+    const [shortSpreadReserves, longSpreadReserves] = calculateSpreadReserves(amm, oraclePriceData);
+    const baseAssetReserveBefore = (0, types_1.isVariant)(direction, 'long')
+        ? longSpreadReserves.baseAssetReserve
+        : shortSpreadReserves.baseAssetReserve;
     if (newBaseAssetReserve.gt(baseAssetReserveBefore)) {
         return [
             newBaseAssetReserve.sub(baseAssetReserveBefore),

package/lib/math/oracles.d.ts

@@ -5,3 +5,5 @@ import { BN, PerpMarketAccount } from '../index';
 export declare function oraclePriceBands(market: PerpMarketAccount, oraclePriceData: OraclePriceData): [BN, BN];
 export declare function isOracleValid(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, slot: number): boolean;
 export declare function isOracleTooDivergent(amm: AMM, oraclePriceData: OraclePriceData, oracleGuardRails: OracleGuardRails, now: BN): boolean;
+export declare function calculateLiveOracleTwap(amm: AMM, oraclePriceData: OraclePriceData, now: BN): BN;
+export declare function calculateLiveOracleStd(amm: AMM, oraclePriceData: OraclePriceData, now: BN): BN;

package/lib/math/oracles.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isOracleTooDivergent = exports.isOracleValid = exports.oraclePriceBands = void 0;
+exports.calculateLiveOracleStd = exports.calculateLiveOracleTwap = exports.isOracleTooDivergent = exports.isOracleValid = exports.oraclePriceBands = void 0;
 const numericConstants_1 = require("../constants/numericConstants");
 const index_1 = require("../index");
 const assert_1 = require("../assert/assert");
@@ -52,3 +52,25 @@ function isOracleTooDivergent(amm, oraclePriceData, oracleGuardRails, now) {
     return tooDivergent;
 }
 exports.isOracleTooDivergent = isOracleTooDivergent;
+function calculateLiveOracleTwap(amm, oraclePriceData, now) {
+    const sinceLastUpdate = now.sub(amm.historicalOracleData.lastOraclePriceTwapTs);
+    const sinceStart = index_1.BN.max(numericConstants_1.ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
+    const clampRange = amm.historicalOracleData.lastOraclePriceTwap.div(new index_1.BN(3));
+    const clampedOraclePrice = index_1.BN.min(amm.historicalOracleData.lastOraclePriceTwap.add(clampRange), index_1.BN.max(oraclePriceData.price, amm.historicalOracleData.lastOraclePriceTwap.sub(clampRange)));
+    const newOracleTwap = amm.historicalOracleData.lastOraclePriceTwap
+        .mul(sinceStart)
+        .add(clampedOraclePrice)
+        .mul(sinceLastUpdate)
+        .div(sinceStart.add(sinceLastUpdate));
+    return newOracleTwap;
+}
+exports.calculateLiveOracleTwap = calculateLiveOracleTwap;
+function calculateLiveOracleStd(amm, oraclePriceData, now) {
+    const sinceLastUpdate = now.sub(amm.historicalOracleData.lastOraclePriceTwapTs);
+    const sinceStart = index_1.BN.max(numericConstants_1.ZERO, amm.fundingPeriod.sub(sinceLastUpdate));
+    const liveOracleTwap = calculateLiveOracleTwap(amm, oraclePriceData, now);
+    const priceDeltaVsTwap = oraclePriceData.price.sub(liveOracleTwap).abs();
+    const oracleStd = priceDeltaVsTwap.add(amm.oracleStd.mul(sinceStart).div(sinceStart.add(sinceLastUpdate)));
+    return oracleStd;
+}
+exports.calculateLiveOracleStd = calculateLiveOracleStd;

package/lib/math/utils.d.ts

@@ -1,3 +1,4 @@
 /// <reference types="bn.js" />
 import { BN } from '../';
-export declare const squareRootBN: (n: any, closeness?: BN) => any;
+export declare function clampBN(x: BN, min: BN, max: BN): BN;
+export declare const squareRootBN: (n: any, closeness?: BN) => BN;

package/lib/math/utils.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.squareRootBN = void 0;
+exports.squareRootBN = exports.clampBN = void 0;
 const __1 = require("../");
+function clampBN(x, min, max) {
+    return __1.BN.max(min, __1.BN.min(x, max));
+}
+exports.clampBN = clampBN;
 const squareRootBN = (n, closeness = new __1.BN(1)) => {
     // Assuming the sqrt of n as n only
     let x = n;

package/lib/types.d.ts

@@ -606,6 +606,8 @@ export declare type StateAccount = {
     perpFeeStructure: FeeStructure;
     spotFeeStructure: FeeStructure;
     lpCooldownTime: BN;
+    initialPctToLiquidate: number;
+    liquidationDuration: number;
 };
 export declare type PerpMarketAccount = {
     status: MarketStatus;
@@ -805,8 +807,8 @@ export declare type PerpPosition = {
     settledPnl: BN;
     lpShares: BN;
     remainderBaseAssetAmount: number;
-    lastNetBaseAssetAmountPerLp: BN;
-    lastNetQuoteAssetAmountPerLp: BN;
+    lastBaseAssetAmountPerLp: BN;
+    lastQuoteAssetAmountPerLp: BN;
 };
 export declare type UserStatsAccount = {
     numberOfSubAccounts: number;
@@ -848,6 +850,8 @@ export declare type UserAccount = {
     totalWithdraws: BN;
     totalSocialLoss: BN;
     cumulativePerpFunding: BN;
+    liquidationMarginFreed: BN;
+    liquidationStartSlot: BN;
 };
 export declare type SpotPosition = {
     marketIndex: number;

package/lib/user.js

@@ -85,8 +85,8 @@ class User {
             openAsks: numericConstants_1.ZERO,
             settledPnl: numericConstants_1.ZERO,
             lpShares: numericConstants_1.ZERO,
-            lastNetBaseAssetAmountPerLp: numericConstants_1.ZERO,
-            lastNetQuoteAssetAmountPerLp: numericConstants_1.ZERO,
+            lastBaseAssetAmountPerLp: numericConstants_1.ZERO,
+            lastQuoteAssetAmountPerLp: numericConstants_1.ZERO,
         };
     }
     getClonedPosition(position) {
@@ -161,11 +161,11 @@ class User {
         const market = this.driftClient.getPerpMarketAccount(position.marketIndex);
         const nShares = position.lpShares;
         const deltaBaa = market.amm.baseAssetAmountPerLp
-            .sub(position.lastNetBaseAssetAmountPerLp)
+            .sub(position.lastBaseAssetAmountPerLp)
             .mul(nShares)
             .div(numericConstants_1.AMM_RESERVE_PRECISION);
         const deltaQaa = market.amm.quoteAssetAmountPerLp
-            .sub(position.lastNetQuoteAssetAmountPerLp)
+            .sub(position.lastQuoteAssetAmountPerLp)
             .mul(nShares)
             .div(numericConstants_1.AMM_RESERVE_PRECISION);
         function sign(v) {
@@ -364,6 +364,7 @@ class User {
                 newTotalLiabilityValue =
                     newTotalLiabilityValue.add(weightedTokenValue);
             }
+            newTotalLiabilityValue = newTotalLiabilityValue.add(new _1.BN(spotPosition.openOrders).mul(numericConstants_1.OPEN_ORDER_MARGIN_REQUIREMENT));
             return newTotalLiabilityValue;
         }, numericConstants_1.ZERO);
     }
@@ -523,6 +524,9 @@ class User {
                 baseAssetValue = baseAssetValue
                     .mul(marginRatio)
                     .div(numericConstants_1.MARGIN_PRECISION);
+                if (includeOpenOrders) {
+                    baseAssetValue = baseAssetValue.add(new _1.BN(perpPosition.openOrders).mul(numericConstants_1.OPEN_ORDER_MARGIN_REQUIREMENT));
+                }
             }
             return totalPerpValue.add(baseAssetValue);
         }, numericConstants_1.ZERO);
@@ -760,8 +764,8 @@ class User {
             openAsks: new _1.BN(0),
             settledPnl: numericConstants_1.ZERO,
             lpShares: numericConstants_1.ZERO,
-            lastNetBaseAssetAmountPerLp: numericConstants_1.ZERO,
-            lastNetQuoteAssetAmountPerLp: numericConstants_1.ZERO,
+            lastBaseAssetAmountPerLp: numericConstants_1.ZERO,
+            lastQuoteAssetAmountPerLp: numericConstants_1.ZERO,
         };
         if (proposedBaseAssetAmount.eq(numericConstants_1.ZERO))
             return new _1.BN(-1);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.0.14",
+	"version": "2.0.16",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/accounts/pollingDriftClientAccountSubscriber.ts

@@ -317,10 +317,6 @@ export class PollingDriftClientAccountSubscriber
 	}
 
 	public async unsubscribe(): Promise<void> {
-		if (!this.isSubscribed) {
-			return;
-		}
-
 		for (const [_, accountToPoll] of this.accountsToPoll) {
 			this.accountLoader.removeAccount(
 				accountToPoll.publicKey,

package/src/accounts/pollingUserStatsAccountSubscriber.ts

@@ -132,10 +132,6 @@ export class PollingUserStatsAccountSubscriber
 	}
 
 	async unsubscribe(): Promise<void> {
-		if (!this.isSubscribed) {
-			return;
-		}
-
 		for (const [_, accountToPoll] of this.accountsToPoll) {
 			this.accountLoader.removeAccount(
 				accountToPoll.publicKey,

package/src/adminClient.ts

@@ -606,6 +606,34 @@ export class AdminClient extends DriftClient {
 		});
 	}
 
+	public async updateInitialPctToLiquidate(
+		initialPctToLiquidate: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateInitialPctToLiquidate(
+			initialPctToLiquidate,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+				},
+			}
+		);
+	}
+
+	public async updateLiquidationDuration(
+		liquidationDuration: number
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateLiquidationDuration(
+			liquidationDuration,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+				},
+			}
+		);
+	}
+
 	public async updateOracleGuardRails(
 		oracleGuardRails: OracleGuardRails
 	): Promise<TransactionSignature> {

package/src/constants/numericConstants.ts

@@ -81,6 +81,7 @@ export const AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO =
 	AMM_RESERVE_PRECISION.mul(PEG_PRECISION).div(QUOTE_PRECISION); // 10^9
 export const MARGIN_PRECISION = TEN_THOUSAND;
 export const BID_ASK_SPREAD_PRECISION = new BN(1000000); // 10^6
+export const LIQUIDATION_PCT_PRECISION = TEN_THOUSAND;
 
 export const ONE_YEAR = new BN(31536000);
 
@@ -88,3 +89,9 @@ export const QUOTE_SPOT_MARKET_INDEX = 0;
 
 export const LAMPORTS_PRECISION = new BN(LAMPORTS_PER_SOL);
 export const LAMPORTS_EXP = new BN(Math.log10(LAMPORTS_PER_SOL));
+
+export const OPEN_ORDER_MARGIN_REQUIREMENT = QUOTE_PRECISION.div(new BN(100));
+
+export const DEFAULT_REVENUE_SINCE_LAST_FUNDING_SPREAD_RETREAT = new BN(
+	-25
+).mul(QUOTE_PRECISION);