@drift-labs/sdk 0.2.0-master.25 → 0.2.0-master.26

package/src/math/position.js

@@ -0,0 +1,172 @@
+"use strict";
+exports.__esModule = true;
+exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateCostBasis = exports.calculateEntryPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculateUnsettledPnl = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
+var __1 = require("../");
+var numericConstants_1 = require("../constants/numericConstants");
+var types_1 = require("../types");
+var amm_1 = require("./amm");
+var margin_1 = require("./margin");
+/**
+ * calculateBaseAssetValue
+ * = market value of closing entire position
+ * @param market
+ * @param userPosition
+ * @param oraclePriceData
+ * @returns Base Asset Value. : Precision QUOTE_PRECISION
+ */
+function calculateBaseAssetValue(market, userPosition, oraclePriceData) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    var directionToClose = findDirectionToClose(userPosition);
+    var prepegAmm;
+    if (market.amm.baseSpread > 0) {
+        var _a = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, directionToClose, oraclePriceData), baseAssetReserve = _a.baseAssetReserve, quoteAssetReserve = _a.quoteAssetReserve, sqrtK = _a.sqrtK, newPeg = _a.newPeg;
+        prepegAmm = {
+            baseAssetReserve: baseAssetReserve,
+            quoteAssetReserve: quoteAssetReserve,
+            sqrtK: sqrtK,
+            pegMultiplier: newPeg
+        };
+    }
+    else {
+        prepegAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+    }
+    var _b = (0, amm_1.calculateAmmReservesAfterSwap)(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', directionToClose)), newQuoteAssetReserve = _b[0], _ = _b[1];
+    switch (directionToClose) {
+        case types_1.PositionDirection.SHORT:
+            return prepegAmm.quoteAssetReserve
+                .sub(newQuoteAssetReserve)
+                .mul(prepegAmm.pegMultiplier)
+                .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+        case types_1.PositionDirection.LONG:
+            return newQuoteAssetReserve
+                .sub(prepegAmm.quoteAssetReserve)
+                .mul(prepegAmm.pegMultiplier)
+                .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+                .add(numericConstants_1.ONE);
+    }
+}
+exports.calculateBaseAssetValue = calculateBaseAssetValue;
+/**
+ * calculatePositionPNL
+ * = BaseAssetAmount * (Avg Exit Price - Avg Entry Price)
+ * @param market
+ * @param PerpPosition
+ * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
+ * @returns BaseAssetAmount : Precision QUOTE_PRECISION
+ */
+function calculatePositionPNL(market, perpPosition, withFunding, oraclePriceData) {
+    if (withFunding === void 0) { withFunding = false; }
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return perpPosition.quoteAssetAmount;
+    }
+    var baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, perpPosition, oraclePriceData);
+    var baseAssetValueSign = perpPosition.baseAssetAmount.isNeg()
+        ? new __1.BN(-1)
+        : new __1.BN(1);
+    var pnl = baseAssetValue
+        .mul(baseAssetValueSign)
+        .add(perpPosition.quoteAssetAmount);
+    if (withFunding) {
+        var fundingRatePnL = calculatePositionFundingPNL(market, perpPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        pnl = pnl.add(fundingRatePnL);
+    }
+    return pnl;
+}
+exports.calculatePositionPNL = calculatePositionPNL;
+function calculateUnsettledPnl(market, perpPosition, oraclePriceData) {
+    var unrealizedPnl = calculatePositionPNL(market, perpPosition, true, oraclePriceData);
+    var unsettledPnl = unrealizedPnl;
+    if (unrealizedPnl.gt(numericConstants_1.ZERO)) {
+        var fundingPnL = calculatePositionFundingPNL(market, perpPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        var maxPositivePnl = __1.BN.max(perpPosition.quoteAssetAmount
+            .sub(perpPosition.quoteEntryAmount)
+            .add(fundingPnL), numericConstants_1.ZERO);
+        unsettledPnl = __1.BN.min(maxPositivePnl, unrealizedPnl);
+    }
+    return unsettledPnl;
+}
+exports.calculateUnsettledPnl = calculateUnsettledPnl;
+/**
+ *
+ * @param market
+ * @param PerpPosition
+ * @returns // TODO-PRECISION
+ */
+function calculatePositionFundingPNL(market, perpPosition) {
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    var ammCumulativeFundingRate;
+    if (perpPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+        ammCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
+    }
+    else {
+        ammCumulativeFundingRate = market.amm.cumulativeFundingRateShort;
+    }
+    var perPositionFundingRate = ammCumulativeFundingRate
+        .sub(perpPosition.lastCumulativeFundingRate)
+        .mul(perpPosition.baseAssetAmount)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.FUNDING_PAYMENT_PRECISION)
+        .mul(new __1.BN(-1));
+    return perPositionFundingRate;
+}
+exports.calculatePositionFundingPNL = calculatePositionFundingPNL;
+function positionIsAvailable(position) {
+    return (position.baseAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.openOrders.eq(numericConstants_1.ZERO) &&
+        position.quoteAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.lpShares.eq(numericConstants_1.ZERO));
+}
+exports.positionIsAvailable = positionIsAvailable;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ */
+function calculateEntryPrice(userPosition) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    return userPosition.quoteEntryAmount
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(userPosition.baseAssetAmount)
+        .abs();
+}
+exports.calculateEntryPrice = calculateEntryPrice;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ */
+function calculateCostBasis(userPosition) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    return userPosition.quoteAssetAmount
+        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(userPosition.baseAssetAmount)
+        .abs();
+}
+exports.calculateCostBasis = calculateCostBasis;
+function findDirectionToClose(userPosition) {
+    return userPosition.baseAssetAmount.gt(numericConstants_1.ZERO)
+        ? types_1.PositionDirection.SHORT
+        : types_1.PositionDirection.LONG;
+}
+exports.findDirectionToClose = findDirectionToClose;
+function positionCurrentDirection(userPosition) {
+    return userPosition.baseAssetAmount.gte(numericConstants_1.ZERO)
+        ? types_1.PositionDirection.LONG
+        : types_1.PositionDirection.SHORT;
+}
+exports.positionCurrentDirection = positionCurrentDirection;
+function isEmptyPosition(userPosition) {
+    return (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) && userPosition.openOrders.eq(numericConstants_1.ZERO));
+}
+exports.isEmptyPosition = isEmptyPosition;

package/src/math/position.ts

@@ -10,7 +10,7 @@ import {
 	ZERO,
 } from '../constants/numericConstants';
 import { OraclePriceData } from '../oracles/types';
-import { MarketAccount, PositionDirection, UserPosition } from '../types';
+import { PerpMarketAccount, PositionDirection, PerpPosition } from '../types';
 import {
 	calculateUpdatedAMM,
 	calculateUpdatedAMMSpreadReserves,
@@ -29,8 +29,8 @@ import { calculateBaseAssetValueWithOracle } from './margin';
  * @returns Base Asset Value. : Precision QUOTE_PRECISION
  */
 export function calculateBaseAssetValue(
-	market: MarketAccount,
-	userPosition: UserPosition,
+	market: PerpMarketAccount,
+	userPosition: PerpPosition,
 	oraclePriceData: OraclePriceData
 ): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
@@ -84,38 +84,38 @@ export function calculateBaseAssetValue(
  * calculatePositionPNL
  * = BaseAssetAmount * (Avg Exit Price - Avg Entry Price)
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @param withFunding (adds unrealized funding payment pnl to result)
  * @param oraclePriceData
  * @returns BaseAssetAmount : Precision QUOTE_PRECISION
  */
 export function calculatePositionPNL(
-	market: MarketAccount,
-	marketPosition: UserPosition,
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition,
 	withFunding = false,
 	oraclePriceData: OraclePriceData
 ): BN {
-	if (marketPosition.baseAssetAmount.eq(ZERO)) {
-		return marketPosition.quoteAssetAmount;
+	if (perpPosition.baseAssetAmount.eq(ZERO)) {
+		return perpPosition.quoteAssetAmount;
 	}
 
 	const baseAssetValue = calculateBaseAssetValueWithOracle(
 		market,
-		marketPosition,
+		perpPosition,
 		oraclePriceData
 	);
 
-	const baseAssetValueSign = marketPosition.baseAssetAmount.isNeg()
+	const baseAssetValueSign = perpPosition.baseAssetAmount.isNeg()
 		? new BN(-1)
 		: new BN(1);
 	let pnl = baseAssetValue
 		.mul(baseAssetValueSign)
-		.add(marketPosition.quoteAssetAmount);
+		.add(perpPosition.quoteAssetAmount);
 
 	if (withFunding) {
 		const fundingRatePnL = calculatePositionFundingPNL(
 			market,
-			marketPosition
+			perpPosition
 		).div(PRICE_TO_QUOTE_PRECISION);
 
 		pnl = pnl.add(fundingRatePnL);
@@ -125,26 +125,26 @@ export function calculatePositionPNL(
 }
 
 export function calculateUnsettledPnl(
-	market: MarketAccount,
-	marketPosition: UserPosition,
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition,
 	oraclePriceData: OraclePriceData
 ): BN {
 	const unrealizedPnl = calculatePositionPNL(
 		market,
-		marketPosition,
+		perpPosition,
 		true,
 		oraclePriceData
 	);
 
 	let unsettledPnl = unrealizedPnl;
 	if (unrealizedPnl.gt(ZERO)) {
-		const fundingPnL = calculatePositionFundingPNL(market, marketPosition).div(
+		const fundingPnL = calculatePositionFundingPNL(market, perpPosition).div(
 			PRICE_TO_QUOTE_PRECISION
 		);
 
 		const maxPositivePnl = BN.max(
-			marketPosition.quoteAssetAmount
-				.sub(marketPosition.quoteEntryAmount)
+			perpPosition.quoteAssetAmount
+				.sub(perpPosition.quoteEntryAmount)
 				.add(fundingPnL),
 			ZERO
 		);
@@ -157,27 +157,27 @@ export function calculateUnsettledPnl(
 /**
  *
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @returns // TODO-PRECISION
  */
 export function calculatePositionFundingPNL(
-	market: MarketAccount,
-	marketPosition: UserPosition
+	market: PerpMarketAccount,
+	perpPosition: PerpPosition
 ): BN {
-	if (marketPosition.baseAssetAmount.eq(ZERO)) {
+	if (perpPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
 	}
 
 	let ammCumulativeFundingRate: BN;
-	if (marketPosition.baseAssetAmount.gt(ZERO)) {
+	if (perpPosition.baseAssetAmount.gt(ZERO)) {
 		ammCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
 	} else {
 		ammCumulativeFundingRate = market.amm.cumulativeFundingRateShort;
 	}
 
 	const perPositionFundingRate = ammCumulativeFundingRate
-		.sub(marketPosition.lastCumulativeFundingRate)
-		.mul(marketPosition.baseAssetAmount)
+		.sub(perpPosition.lastCumulativeFundingRate)
+		.mul(perpPosition.baseAssetAmount)
 		.div(AMM_RESERVE_PRECISION)
 		.div(FUNDING_PAYMENT_PRECISION)
 		.mul(new BN(-1));
@@ -185,7 +185,7 @@ export function calculatePositionFundingPNL(
 	return perPositionFundingRate;
 }
 
-export function positionIsAvailable(position: UserPosition): boolean {
+export function positionIsAvailable(position: PerpPosition): boolean {
 	return (
 		position.baseAssetAmount.eq(ZERO) &&
 		position.openOrders.eq(ZERO) &&
@@ -199,7 +199,7 @@ export function positionIsAvailable(position: UserPosition): boolean {
  * @param userPosition
  * @returns Precision: MARK_PRICE_PRECISION (10^10)
  */
-export function calculateEntryPrice(userPosition: UserPosition): BN {
+export function calculateEntryPrice(userPosition: PerpPosition): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
 	}
@@ -216,7 +216,7 @@ export function calculateEntryPrice(userPosition: UserPosition): BN {
  * @param userPosition
  * @returns Precision: MARK_PRICE_PRECISION (10^10)
  */
-export function calculateCostBasis(userPosition: UserPosition): BN {
+export function calculateCostBasis(userPosition: PerpPosition): BN {
 	if (userPosition.baseAssetAmount.eq(ZERO)) {
 		return ZERO;
 	}
@@ -229,7 +229,7 @@ export function calculateCostBasis(userPosition: UserPosition): BN {
 }
 
 export function findDirectionToClose(
-	userPosition: UserPosition
+	userPosition: PerpPosition
 ): PositionDirection {
 	return userPosition.baseAssetAmount.gt(ZERO)
 		? PositionDirection.SHORT
@@ -237,14 +237,14 @@ export function findDirectionToClose(
 }
 
 export function positionCurrentDirection(
-	userPosition: UserPosition
+	userPosition: PerpPosition
 ): PositionDirection {
 	return userPosition.baseAssetAmount.gte(ZERO)
 		? PositionDirection.LONG
 		: PositionDirection.SHORT;
 }
 
-export function isEmptyPosition(userPosition: UserPosition): boolean {
+export function isEmptyPosition(userPosition: PerpPosition): boolean {
 	return (
 		userPosition.baseAssetAmount.eq(ZERO) && userPosition.openOrders.eq(ZERO)
 	);

package/src/math/repeg.js

@@ -1,9 +1,9 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+exports.__esModule = true;
 exports.calculateBudgetedPeg = exports.calculateBudgetedK = exports.calculateBudgetedKBN = exports.calculateRepegCost = exports.calculateAdjustKCost = void 0;
-const anchor_1 = require("@project-serum/anchor");
-const assert_1 = require("../assert/assert");
-const numericConstants_1 = require("../constants/numericConstants");
+var anchor_1 = require("@project-serum/anchor");
+var assert_1 = require("../assert/assert");
+var numericConstants_1 = require("../constants/numericConstants");
 /**
  * Helper function calculating adjust k cost
  * @param amm
@@ -13,13 +13,13 @@ const numericConstants_1 = require("../constants/numericConstants");
  */
 function calculateAdjustKCost(amm, numerator, denomenator) {
     // const k = market.amm.sqrtK.mul(market.amm.sqrtK);
-    const x = amm.baseAssetReserve;
-    const y = amm.quoteAssetReserve;
-    const d = amm.netBaseAssetAmount;
-    const Q = amm.pegMultiplier;
-    const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
-    const p = numerator.mul(numericConstants_1.MARK_PRICE_PRECISION).div(denomenator);
-    const cost = quoteScale
+    var x = amm.baseAssetReserve;
+    var y = amm.quoteAssetReserve;
+    var d = amm.netBaseAssetAmount;
+    var Q = amm.pegMultiplier;
+    var quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
+    var p = numerator.mul(numericConstants_1.MARK_PRICE_PRECISION).div(denomenator);
+    var cost = quoteScale
         .div(x.add(d))
         .sub(quoteScale
         .mul(p)
@@ -38,8 +38,8 @@ exports.calculateAdjustKCost = calculateAdjustKCost;
  * @returns cost : Precision QUOTE_ASSET_PRECISION
  */
 function calculateRepegCost(amm, newPeg) {
-    const dqar = amm.quoteAssetReserve.sub(amm.terminalQuoteAssetReserve);
-    const cost = dqar
+    var dqar = amm.quoteAssetReserve.sub(amm.terminalQuoteAssetReserve);
+    var cost = dqar
         .mul(newPeg.sub(amm.pegMultiplier))
         .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .div(numericConstants_1.PEG_PRECISION);
@@ -47,32 +47,32 @@ function calculateRepegCost(amm, newPeg) {
 }
 exports.calculateRepegCost = calculateRepegCost;
 function calculateBudgetedKBN(x, y, budget, Q, d) {
-    assert_1.assert(Q.gt(new anchor_1.BN(0)));
-    const C = budget.mul(new anchor_1.BN(-1));
-    let dSign = new anchor_1.BN(1);
+    (0, assert_1.assert)(Q.gt(new anchor_1.BN(0)));
+    var C = budget.mul(new anchor_1.BN(-1));
+    var dSign = new anchor_1.BN(1);
     if (d.lt(new anchor_1.BN(0))) {
         dSign = new anchor_1.BN(-1);
     }
-    const pegged_y_d_d = y
+    var pegged_y_d_d = y
         .mul(d)
         .mul(d)
         .mul(Q)
         .div(numericConstants_1.AMM_RESERVE_PRECISION)
         .div(numericConstants_1.AMM_RESERVE_PRECISION)
         .div(numericConstants_1.PEG_PRECISION);
-    const numer1 = pegged_y_d_d;
-    const numer2 = C.mul(d)
+    var numer1 = pegged_y_d_d;
+    var numer2 = C.mul(d)
         .div(numericConstants_1.QUOTE_PRECISION)
         .mul(x.add(d))
         .div(numericConstants_1.AMM_RESERVE_PRECISION)
         .mul(dSign);
-    const denom1 = C.mul(x)
+    var denom1 = C.mul(x)
         .mul(x.add(d))
         .div(numericConstants_1.AMM_RESERVE_PRECISION)
         .div(numericConstants_1.QUOTE_PRECISION);
-    const denom2 = pegged_y_d_d;
-    const numerator = numer1.sub(numer2).div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
-    const denominator = denom1.add(denom2).div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    var denom2 = pegged_y_d_d;
+    var numerator = numer1.sub(numer2).div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
+    var denominator = denom1.add(denom2).div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO);
     return [numerator, denominator];
 }
 exports.calculateBudgetedKBN = calculateBudgetedKBN;
@@ -90,11 +90,11 @@ function calculateBudgetedK(amm, cost) {
     // = x/d**2 + 1 / d + mark/C
     // todo: assumes k = x * y
     // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
-    const x = amm.baseAssetReserve;
-    const y = amm.quoteAssetReserve;
-    const d = amm.netBaseAssetAmount;
-    const Q = amm.pegMultiplier;
-    const [numerator, denominator] = calculateBudgetedKBN(x, y, cost, Q, d);
+    var x = amm.baseAssetReserve;
+    var y = amm.quoteAssetReserve;
+    var d = amm.netBaseAssetAmount;
+    var Q = amm.pegMultiplier;
+    var _a = calculateBudgetedKBN(x, y, cost, Q, d), numerator = _a[0], denominator = _a[1];
     return [numerator, denominator];
 }
 exports.calculateBudgetedK = calculateBudgetedK;
@@ -104,25 +104,25 @@ function calculateBudgetedPeg(amm, cost, targetPrice) {
     // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*y*d*Q)
     // todo: assumes k = x * y
     // otherwise use: (y(1-p) + (kp^2/(x*p+d)) - k/(x+d)) * Q = C solve for p
-    const targetPeg = targetPrice
+    var targetPeg = targetPrice
         .mul(amm.baseAssetReserve)
         .div(amm.quoteAssetReserve)
         .div(numericConstants_1.PRICE_DIV_PEG);
-    const k = amm.sqrtK.mul(amm.sqrtK);
-    const x = amm.baseAssetReserve;
-    const y = amm.quoteAssetReserve;
-    const d = amm.netBaseAssetAmount;
-    const Q = amm.pegMultiplier;
-    const C = cost.mul(new anchor_1.BN(-1));
-    const deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
-    const pegChangeDirection = targetPeg.sub(Q);
-    const useTargetPeg = (deltaQuoteAssetReserves.lt(numericConstants_1.ZERO) && pegChangeDirection.gt(numericConstants_1.ZERO)) ||
+    var k = amm.sqrtK.mul(amm.sqrtK);
+    var x = amm.baseAssetReserve;
+    var y = amm.quoteAssetReserve;
+    var d = amm.netBaseAssetAmount;
+    var Q = amm.pegMultiplier;
+    var C = cost.mul(new anchor_1.BN(-1));
+    var deltaQuoteAssetReserves = y.sub(k.div(x.add(d)));
+    var pegChangeDirection = targetPeg.sub(Q);
+    var useTargetPeg = (deltaQuoteAssetReserves.lt(numericConstants_1.ZERO) && pegChangeDirection.gt(numericConstants_1.ZERO)) ||
         (deltaQuoteAssetReserves.gt(numericConstants_1.ZERO) && pegChangeDirection.lt(numericConstants_1.ZERO));
     if (deltaQuoteAssetReserves.eq(numericConstants_1.ZERO) || useTargetPeg) {
         return targetPeg;
     }
-    const deltaPegMultiplier = C.mul(numericConstants_1.MARK_PRICE_PRECISION).div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO));
-    const newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.MARK_PRICE_PRECISION));
+    var deltaPegMultiplier = C.mul(numericConstants_1.MARK_PRICE_PRECISION).div(deltaQuoteAssetReserves.div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO));
+    var newPeg = Q.sub(deltaPegMultiplier.mul(numericConstants_1.PEG_PRECISION).div(numericConstants_1.MARK_PRICE_PRECISION));
     return newPeg;
 }
 exports.calculateBudgetedPeg = calculateBudgetedPeg;

package/src/math/spotBalance.js

@@ -0,0 +1,176 @@
+"use strict";
+exports.__esModule = true;
+exports.calculateWithdrawLimit = exports.calculateInterestAccumulated = exports.calculateBorrowRate = exports.calculateDepositRate = exports.calculateInterestRate = exports.calculateUtilization = exports.calculateLiabilityWeight = exports.calculateAssetWeight = exports.getTokenAmount = exports.getBalance = void 0;
+var types_1 = require("../types");
+var anchor_1 = require("@project-serum/anchor");
+var numericConstants_1 = require("../constants/numericConstants");
+var margin_1 = require("./margin");
+function getBalance(tokenAmount, spotMarket, balanceType) {
+    var precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - spotMarket.decimals));
+    var cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
+        ? spotMarket.cumulativeDepositInterest
+        : spotMarket.cumulativeBorrowInterest;
+    var balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
+    if (!balance.eq(numericConstants_1.ZERO) && (0, types_1.isVariant)(balanceType, 'borrow')) {
+        balance = balance.add(numericConstants_1.ONE);
+    }
+    return balance;
+}
+exports.getBalance = getBalance;
+function getTokenAmount(balanceAmount, spotMarket, balanceType) {
+    var precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - spotMarket.decimals));
+    var cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
+        ? spotMarket.cumulativeDepositInterest
+        : spotMarket.cumulativeBorrowInterest;
+    return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
+}
+exports.getTokenAmount = getTokenAmount;
+function calculateAssetWeight(balanceAmount, spotMarket, marginCategory) {
+    var sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(spotMarket.decimals));
+    var sizeInAmmReservePrecision;
+    if (sizePrecision.gt(numericConstants_1.AMM_RESERVE_PRECISION)) {
+        sizeInAmmReservePrecision = balanceAmount.div(sizePrecision.div(numericConstants_1.AMM_RESERVE_PRECISION));
+    }
+    else {
+        sizeInAmmReservePrecision = balanceAmount
+            .mul(numericConstants_1.AMM_RESERVE_PRECISION)
+            .div(sizePrecision);
+    }
+    var assetWeight;
+    switch (marginCategory) {
+        case 'Initial':
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, spotMarket.imfFactor, spotMarket.initialAssetWeight);
+            break;
+        case 'Maintenance':
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, spotMarket.imfFactor, spotMarket.maintenanceAssetWeight);
+            break;
+        default:
+            assetWeight = spotMarket.initialAssetWeight;
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateAssetWeight = calculateAssetWeight;
+function calculateLiabilityWeight(balanceAmount, spotMarket, marginCategory) {
+    var sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(spotMarket.decimals));
+    var sizeInAmmReservePrecision;
+    if (sizePrecision.gt(numericConstants_1.AMM_RESERVE_PRECISION)) {
+        sizeInAmmReservePrecision = balanceAmount.div(sizePrecision.div(numericConstants_1.AMM_RESERVE_PRECISION));
+    }
+    else {
+        sizeInAmmReservePrecision = balanceAmount
+            .mul(numericConstants_1.AMM_RESERVE_PRECISION)
+            .div(sizePrecision);
+    }
+    var assetWeight;
+    switch (marginCategory) {
+        case 'Initial':
+            assetWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, spotMarket.imfFactor, spotMarket.initialLiabilityWeight, numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            break;
+        case 'Maintenance':
+            assetWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, spotMarket.imfFactor, spotMarket.maintenanceLiabilityWeight, numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            break;
+        default:
+            assetWeight = spotMarket.initialLiabilityWeight;
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateLiabilityWeight = calculateLiabilityWeight;
+function calculateUtilization(bank) {
+    var tokenDepositAmount = getTokenAmount(bank.depositBalance, bank, types_1.SpotBalanceType.DEPOSIT);
+    var tokenBorrowAmount = getTokenAmount(bank.borrowBalance, bank, types_1.SpotBalanceType.BORROW);
+    var utilization;
+    if (tokenBorrowAmount.eq(numericConstants_1.ZERO) && tokenDepositAmount.eq(numericConstants_1.ZERO)) {
+        utilization = numericConstants_1.ZERO;
+    }
+    else if (tokenDepositAmount.eq(numericConstants_1.ZERO)) {
+        utilization = numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION;
+    }
+    else {
+        utilization = tokenBorrowAmount
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(tokenDepositAmount);
+    }
+    return utilization;
+}
+exports.calculateUtilization = calculateUtilization;
+function calculateInterestRate(bank) {
+    var utilization = calculateUtilization(bank);
+    var interestRate;
+    if (utilization.gt(bank.optimalUtilization)) {
+        var surplusUtilization = utilization.sub(bank.optimalUtilization);
+        var borrowRateSlope = bank.maxBorrowRate
+            .sub(bank.optimalBorrowRate)
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+        interestRate = bank.optimalBorrowRate.add(surplusUtilization
+            .mul(borrowRateSlope)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION));
+    }
+    else {
+        var borrowRateSlope = bank.optimalBorrowRate
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+        interestRate = utilization
+            .mul(borrowRateSlope)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    }
+    return interestRate;
+}
+exports.calculateInterestRate = calculateInterestRate;
+function calculateDepositRate(bank) {
+    var utilization = calculateUtilization(bank);
+    var borrowRate = calculateBorrowRate(bank);
+    var depositRate = borrowRate
+        .mul(utilization)
+        .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    return depositRate;
+}
+exports.calculateDepositRate = calculateDepositRate;
+function calculateBorrowRate(bank) {
+    return calculateInterestRate(bank);
+}
+exports.calculateBorrowRate = calculateBorrowRate;
+function calculateInterestAccumulated(bank, now) {
+    var interestRate = calculateInterestRate(bank);
+    var timeSinceLastUpdate = now.sub(bank.lastInterestTs);
+    var modifiedBorrowRate = interestRate.mul(timeSinceLastUpdate);
+    var utilization = calculateUtilization(bank);
+    var modifiedDepositRate = modifiedBorrowRate
+        .mul(utilization)
+        .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    var borrowInterest = bank.cumulativeBorrowInterest
+        .mul(modifiedBorrowRate)
+        .div(numericConstants_1.ONE_YEAR)
+        .div(numericConstants_1.SPOT_MARKET_INTEREST_PRECISION)
+        .add(numericConstants_1.ONE);
+    var depositInterest = bank.cumulativeDepositInterest
+        .mul(modifiedDepositRate)
+        .div(numericConstants_1.ONE_YEAR)
+        .div(numericConstants_1.SPOT_MARKET_INTEREST_PRECISION);
+    return { borrowInterest: borrowInterest, depositInterest: depositInterest };
+}
+exports.calculateInterestAccumulated = calculateInterestAccumulated;
+function calculateWithdrawLimit(spotMarket, now) {
+    var marketDepositTokenAmount = getTokenAmount(spotMarket.depositBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    var marketBorrowTokenAmount = getTokenAmount(spotMarket.borrowBalance, spotMarket, types_1.SpotBalanceType.BORROW);
+    var twentyFourHours = new anchor_1.BN(60 * 60 * 24);
+    var sinceLast = now.sub(spotMarket.lastTwapTs);
+    var sinceStart = anchor_1.BN.max(numericConstants_1.ZERO, twentyFourHours.sub(sinceLast));
+    var borrowTokenTwapLive = spotMarket.borrowTokenTwap
+        .mul(sinceStart)
+        .add(marketBorrowTokenAmount.mul(sinceLast))
+        .div(sinceLast.add(sinceLast));
+    var depositTokenTwapLive = spotMarket.depositTokenTwap
+        .mul(sinceStart)
+        .add(marketDepositTokenAmount.mul(sinceLast))
+        .div(sinceLast.add(sinceLast));
+    var maxBorrowTokens = anchor_1.BN.min(anchor_1.BN.max(marketDepositTokenAmount.div(new anchor_1.BN(6)), borrowTokenTwapLive.add(borrowTokenTwapLive.div(new anchor_1.BN(5)))), marketDepositTokenAmount.sub(marketDepositTokenAmount.div(new anchor_1.BN(10)))); // between ~15-90% utilization with friction on twap
+    var minDepositTokens = depositTokenTwapLive.sub(anchor_1.BN.min(anchor_1.BN.max(depositTokenTwapLive.div(new anchor_1.BN(5)), spotMarket.withdrawGuardThreshold), depositTokenTwapLive));
+    return {
+        borrowLimit: maxBorrowTokens.sub(marketBorrowTokenAmount),
+        withdrawLimit: marketDepositTokenAmount.sub(minDepositTokens)
+    };
+}
+exports.calculateWithdrawLimit = calculateWithdrawLimit;