@drift-labs/sdk 0.2.0-master.3 → 0.2.0-master.31

package/lib/math/position.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="bn.js" />
-import { BN } from '../';
+import { BN, SpotMarketAccount } from '../';
 import { OraclePriceData } from '../oracles/types';
-import { MarketAccount, PositionDirection, UserPosition } from '../types';
+import { PerpMarketAccount, PositionDirection, PerpPosition } from '../types';
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -10,30 +10,38 @@ import { MarketAccount, PositionDirection, UserPosition } from '../types';
  * @param oraclePriceData
  * @returns Base Asset Value. : Precision QUOTE_PRECISION
  */
-export declare function calculateBaseAssetValue(market: MarketAccount, userPosition: UserPosition, oraclePriceData: OraclePriceData): BN;
+export declare function calculateBaseAssetValue(market: PerpMarketAccount, userPosition: PerpPosition, oraclePriceData: OraclePriceData, useSpread?: boolean, skipUpdate?: boolean): BN;
 /**
  * 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 declare function calculatePositionPNL(market: MarketAccount, marketPosition: UserPosition, withFunding: boolean, oraclePriceData: OraclePriceData): BN;
+export declare function calculatePositionPNL(market: PerpMarketAccount, perpPosition: PerpPosition, withFunding: boolean, oraclePriceData: OraclePriceData): BN;
+export declare function calculateClaimablePnl(market: PerpMarketAccount, spotMarket: SpotMarketAccount, perpPosition: PerpPosition, oraclePriceData: OraclePriceData): BN;
 /**
  *
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @returns // TODO-PRECISION
  */
-export declare function calculatePositionFundingPNL(market: MarketAccount, marketPosition: UserPosition): BN;
-export declare function positionIsAvailable(position: UserPosition): boolean;
+export declare function calculatePositionFundingPNL(market: PerpMarketAccount, perpPosition: PerpPosition): BN;
+export declare function positionIsAvailable(position: PerpPosition): boolean;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^10)
+ */
+export declare function calculateEntryPrice(userPosition: PerpPosition): BN;
 /**
  *
  * @param userPosition
- * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ * @returns Precision: PRICE_PRECISION (10^10)
  */
-export declare function calculateEntryPrice(userPosition: UserPosition): BN;
-export declare function findDirectionToClose(userPosition: UserPosition): PositionDirection;
-export declare function positionCurrentDirection(userPosition: UserPosition): PositionDirection;
-export declare function isEmptyPosition(userPosition: UserPosition): boolean;
+export declare function calculateCostBasis(userPosition: PerpPosition): BN;
+export declare function findDirectionToClose(userPosition: PerpPosition): PositionDirection;
+export declare function positionCurrentDirection(userPosition: PerpPosition): PositionDirection;
+export declare function isEmptyPosition(userPosition: PerpPosition): boolean;

package/lib/math/position.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
+exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateCostBasis = exports.calculateEntryPrice = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculateClaimablePnl = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
 const __1 = require("../");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
+const margin_1 = require("./margin");
+const market_1 = require("./market");
 /**
  * calculateBaseAssetValue
  * = market value of closing entire position
@@ -13,23 +15,28 @@ const amm_1 = require("./amm");
  * @param oraclePriceData
  * @returns Base Asset Value. : Precision QUOTE_PRECISION
  */
-function calculateBaseAssetValue(market, userPosition, oraclePriceData) {
+function calculateBaseAssetValue(market, userPosition, oraclePriceData, useSpread = true, skipUpdate = false) {
     if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
     const directionToClose = findDirectionToClose(userPosition);
     let prepegAmm;
-    if (market.amm.baseSpread > 0) {
-        const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, directionToClose, oraclePriceData);
-        prepegAmm = {
-            baseAssetReserve,
-            quoteAssetReserve,
-            sqrtK: sqrtK,
-            pegMultiplier: newPeg,
-        };
+    if (!skipUpdate) {
+        if (market.amm.baseSpread > 0 && useSpread) {
+            const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, directionToClose, oraclePriceData);
+            prepegAmm = {
+                baseAssetReserve,
+                quoteAssetReserve,
+                sqrtK: sqrtK,
+                pegMultiplier: newPeg,
+            };
+        }
+        else {
+            prepegAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+        }
     }
     else {
-        prepegAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, oraclePriceData);
+        prepegAmm = market.amm;
     }
     const [newQuoteAssetReserve, _] = (0, amm_1.calculateAmmReservesAfterSwap)(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', directionToClose));
     switch (directionToClose) {
@@ -51,75 +58,108 @@ exports.calculateBaseAssetValue = 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
  */
-function calculatePositionPNL(market, marketPosition, withFunding = false, oraclePriceData) {
-    if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
-        return numericConstants_1.ZERO;
-    }
-    const baseAssetValue = calculateBaseAssetValue(market, marketPosition, oraclePriceData);
-    let pnl;
-    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
-        pnl = baseAssetValue.sub(marketPosition.quoteAssetAmount);
-    }
-    else {
-        pnl = marketPosition.quoteAssetAmount.sub(baseAssetValue);
+function calculatePositionPNL(market, perpPosition, withFunding = false, oraclePriceData) {
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return perpPosition.quoteAssetAmount;
     }
+    const baseAssetValue = (0, margin_1.calculateBaseAssetValueWithOracle)(market, perpPosition, oraclePriceData);
+    const baseAssetValueSign = perpPosition.baseAssetAmount.isNeg()
+        ? new __1.BN(-1)
+        : new __1.BN(1);
+    let pnl = baseAssetValue
+        .mul(baseAssetValueSign)
+        .add(perpPosition.quoteAssetAmount);
     if (withFunding) {
-        const fundingRatePnL = calculatePositionFundingPNL(market, marketPosition).div(numericConstants_1.PRICE_TO_QUOTE_PRECISION);
+        const fundingRatePnL = calculatePositionFundingPNL(market, perpPosition);
         pnl = pnl.add(fundingRatePnL);
     }
     return pnl;
 }
 exports.calculatePositionPNL = calculatePositionPNL;
+function calculateClaimablePnl(market, spotMarket, perpPosition, oraclePriceData) {
+    const unrealizedPnl = calculatePositionPNL(market, perpPosition, true, oraclePriceData);
+    const fundingPnL = calculatePositionFundingPNL(market, perpPosition);
+    let unsettledPnl = unrealizedPnl.add(fundingPnL);
+    if (unrealizedPnl.gt(numericConstants_1.ZERO)) {
+        const excessPnlPool = __1.BN.max(numericConstants_1.ZERO, (0, market_1.calculateNetUserPnlImbalance)(market, spotMarket, oraclePriceData).mul(new __1.BN(-1)));
+        const maxPositivePnl = __1.BN.max(perpPosition.quoteAssetAmount
+            .sub(perpPosition.quoteEntryAmount)
+            .add(excessPnlPool), numericConstants_1.ZERO);
+        unsettledPnl = __1.BN.min(maxPositivePnl, unrealizedPnl);
+    }
+    return unsettledPnl;
+}
+exports.calculateClaimablePnl = calculateClaimablePnl;
 /**
  *
  * @param market
- * @param marketPosition
+ * @param PerpPosition
  * @returns // TODO-PRECISION
  */
-function calculatePositionFundingPNL(market, marketPosition) {
-    if (marketPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+function calculatePositionFundingPNL(market, perpPosition) {
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
     let ammCumulativeFundingRate;
-    if (marketPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+    if (perpPosition.baseAssetAmount.gt(numericConstants_1.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(numericConstants_1.AMM_RESERVE_PRECISION)
-        .div(numericConstants_1.FUNDING_PAYMENT_PRECISION)
+        .div(numericConstants_1.FUNDING_RATE_BUFFER_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);
+    return (position.baseAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.openOrders === 0 &&
+        position.quoteAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.lpShares.eq(numericConstants_1.ZERO));
 }
 exports.positionIsAvailable = positionIsAvailable;
 /**
  *
  * @param userPosition
- * @returns Precision: MARK_PRICE_PRECISION (10^10)
+ * @returns Precision: PRICE_PRECISION (10^10)
  */
 function calculateEntryPrice(userPosition) {
     if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
         return numericConstants_1.ZERO;
     }
-    return userPosition.quoteAssetAmount
-        .mul(numericConstants_1.MARK_PRICE_PRECISION)
+    return userPosition.quoteEntryAmount
+        .mul(numericConstants_1.PRICE_PRECISION)
         .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .div(userPosition.baseAssetAmount)
         .abs();
 }
 exports.calculateEntryPrice = calculateEntryPrice;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^10)
+ */
+function calculateCostBasis(userPosition) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    return userPosition.quoteAssetAmount
+        .mul(numericConstants_1.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
@@ -133,6 +173,6 @@ function positionCurrentDirection(userPosition) {
 }
 exports.positionCurrentDirection = positionCurrentDirection;
 function isEmptyPosition(userPosition) {
-    return (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) && userPosition.openOrders.eq(numericConstants_1.ZERO));
+    return userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) && userPosition.openOrders === 0;
 }
 exports.isEmptyPosition = isEmptyPosition;

package/lib/math/repeg.js

@@ -18,13 +18,13 @@ function calculateAdjustKCost(amm, numerator, denomenator) {
     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 p = numerator.mul(numericConstants_1.PRICE_PRECISION).div(denomenator);
     const cost = quoteScale
         .div(x.add(d))
         .sub(quoteScale
         .mul(p)
-        .div(numericConstants_1.MARK_PRICE_PRECISION)
-        .div(x.mul(p).div(numericConstants_1.MARK_PRICE_PRECISION).add(d)))
+        .div(numericConstants_1.PRICE_PRECISION)
+        .div(x.mul(p).div(numericConstants_1.PRICE_PRECISION).add(d)))
         .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
         .div(numericConstants_1.PEG_PRECISION);
     return cost.mul(new anchor_1.BN(-1));
@@ -71,6 +71,15 @@ function calculateBudgetedKBN(x, y, budget, Q, d) {
         .div(numericConstants_1.AMM_RESERVE_PRECISION)
         .div(numericConstants_1.QUOTE_PRECISION);
     const denom2 = pegged_y_d_d;
+    // protocol is spending to increase k
+    if (C.lt(numericConstants_1.ZERO)) {
+        // thus denom1 is negative and solution is unstable
+        if (denom1.abs().gt(denom2.abs())) {
+            console.log('denom1 > denom2', denom1.toString(), denom2.toString());
+            console.log('budget cost exceeds stable K solution');
+            return [new anchor_1.BN(10000), new anchor_1.BN(1)];
+        }
+    }
     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);
     return [numerator, denominator];
@@ -121,8 +130,8 @@ function calculateBudgetedPeg(amm, cost, targetPrice) {
     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));
+    const deltaPegMultiplier = C.mul(numericConstants_1.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.PRICE_PRECISION));
     return newPeg;
 }
 exports.calculateBudgetedPeg = calculateBudgetedPeg;

package/lib/math/spotBalance.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="bn.js" />
+import { SpotMarketAccount, SpotBalanceType, MarginCategory } from '../types';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+export declare function getBalance(tokenAmount: BN, spotMarket: SpotMarketAccount, balanceType: SpotBalanceType): BN;
+export declare function getTokenAmount(balanceAmount: BN, spotMarket: SpotMarketAccount, balanceType: SpotBalanceType): BN;
+export declare function getSignedTokenAmount(tokenAmount: BN, balanceType: SpotBalanceType): BN;
+export declare function getTokenValue(tokenAmount: BN, spotDecimals: number, oraclePriceData: OraclePriceData): BN;
+export declare function calculateAssetWeight(balanceAmount: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
+export declare function calculateLiabilityWeight(balanceAmount: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
+export declare function calculateUtilization(bank: SpotMarketAccount): BN;
+export declare function calculateInterestRate(bank: SpotMarketAccount): BN;
+export declare function calculateDepositRate(bank: SpotMarketAccount): BN;
+export declare function calculateBorrowRate(bank: SpotMarketAccount): BN;
+export declare function calculateInterestAccumulated(bank: SpotMarketAccount, now: BN): {
+    borrowInterest: BN;
+    depositInterest: BN;
+};
+export declare function calculateWithdrawLimit(spotMarket: SpotMarketAccount, now: BN): {
+    borrowLimit: BN;
+    withdrawLimit: BN;
+};

package/lib/math/spotBalance.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWithdrawLimit = exports.calculateInterestAccumulated = exports.calculateBorrowRate = exports.calculateDepositRate = exports.calculateInterestRate = exports.calculateUtilization = exports.calculateLiabilityWeight = exports.calculateAssetWeight = exports.getTokenValue = exports.getSignedTokenAmount = exports.getTokenAmount = exports.getBalance = void 0;
+const types_1 = require("../types");
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const margin_1 = require("./margin");
+function getBalance(tokenAmount, spotMarket, balanceType) {
+    const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(19 - spotMarket.decimals));
+    const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
+        ? spotMarket.cumulativeDepositInterest
+        : spotMarket.cumulativeBorrowInterest;
+    let 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) {
+    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(19 - spotMarket.decimals));
+    const cumulativeInterest = (0, types_1.isVariant)(balanceType, 'deposit')
+        ? spotMarket.cumulativeDepositInterest
+        : spotMarket.cumulativeBorrowInterest;
+    return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
+}
+exports.getTokenAmount = getTokenAmount;
+function getSignedTokenAmount(tokenAmount, balanceType) {
+    if ((0, types_1.isVariant)(balanceType, 'deposit')) {
+        return tokenAmount;
+    }
+    else {
+        return tokenAmount.abs().neg();
+    }
+}
+exports.getSignedTokenAmount = getSignedTokenAmount;
+function getTokenValue(tokenAmount, spotDecimals, oraclePriceData) {
+    if (tokenAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(spotDecimals));
+    return tokenAmount.mul(oraclePriceData.price).div(precisionDecrease);
+}
+exports.getTokenValue = getTokenValue;
+function calculateAssetWeight(balanceAmount, spotMarket, marginCategory) {
+    const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(spotMarket.decimals));
+    let 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);
+    }
+    let 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) {
+    const sizePrecision = numericConstants_1.TEN.pow(new anchor_1.BN(spotMarket.decimals));
+    let 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);
+    }
+    let 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) {
+    const tokenDepositAmount = getTokenAmount(bank.depositBalance, bank, types_1.SpotBalanceType.DEPOSIT);
+    const tokenBorrowAmount = getTokenAmount(bank.borrowBalance, bank, types_1.SpotBalanceType.BORROW);
+    let 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) {
+    const utilization = calculateUtilization(bank);
+    let interestRate;
+    if (utilization.gt(new anchor_1.BN(bank.optimalUtilization))) {
+        const surplusUtilization = utilization.sub(new anchor_1.BN(bank.optimalUtilization));
+        const borrowRateSlope = new anchor_1.BN(bank.maxBorrowRate - bank.optimalBorrowRate)
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(new anchor_1.BN(bank.optimalUtilization)));
+        interestRate = new anchor_1.BN(bank.optimalBorrowRate).add(surplusUtilization
+            .mul(borrowRateSlope)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION));
+    }
+    else {
+        const borrowRateSlope = new anchor_1.BN(bank.optimalBorrowRate)
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(new anchor_1.BN(bank.optimalUtilization)));
+        interestRate = utilization
+            .mul(borrowRateSlope)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    }
+    return interestRate;
+}
+exports.calculateInterestRate = calculateInterestRate;
+function calculateDepositRate(bank) {
+    const utilization = calculateUtilization(bank);
+    const borrowRate = calculateBorrowRate(bank);
+    const 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) {
+    const interestRate = calculateInterestRate(bank);
+    const timeSinceLastUpdate = now.sub(bank.lastInterestTs);
+    const modifiedBorrowRate = interestRate.mul(timeSinceLastUpdate);
+    const utilization = calculateUtilization(bank);
+    const modifiedDepositRate = modifiedBorrowRate
+        .mul(utilization)
+        .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    const borrowInterest = bank.cumulativeBorrowInterest
+        .mul(modifiedBorrowRate)
+        .div(numericConstants_1.ONE_YEAR)
+        .div(numericConstants_1.SPOT_MARKET_RATE_PRECISION)
+        .add(numericConstants_1.ONE);
+    const depositInterest = bank.cumulativeDepositInterest
+        .mul(modifiedDepositRate)
+        .div(numericConstants_1.ONE_YEAR)
+        .div(numericConstants_1.SPOT_MARKET_RATE_PRECISION);
+    return { borrowInterest, depositInterest };
+}
+exports.calculateInterestAccumulated = calculateInterestAccumulated;
+function calculateWithdrawLimit(spotMarket, now) {
+    const marketDepositTokenAmount = getTokenAmount(spotMarket.depositBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    const marketBorrowTokenAmount = getTokenAmount(spotMarket.borrowBalance, spotMarket, types_1.SpotBalanceType.BORROW);
+    const twentyFourHours = new anchor_1.BN(60 * 60 * 24);
+    const sinceLast = now.sub(spotMarket.lastTwapTs);
+    const sinceStart = anchor_1.BN.max(numericConstants_1.ZERO, twentyFourHours.sub(sinceLast));
+    const borrowTokenTwapLive = spotMarket.borrowTokenTwap
+        .mul(sinceStart)
+        .add(marketBorrowTokenAmount.mul(sinceLast))
+        .div(sinceLast.add(sinceLast));
+    const depositTokenTwapLive = spotMarket.depositTokenTwap
+        .mul(sinceStart)
+        .add(marketDepositTokenAmount.mul(sinceLast))
+        .div(sinceLast.add(sinceLast));
+    const 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
+    const 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;

package/lib/math/spotMarket.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="bn.js" />
+import { BN } from '@project-serum/anchor';
+import { SpotMarketAccount } from '../types';
+export declare function castNumberToSpotPrecision(value: number, spotMarket: SpotMarketAccount): BN;

package/lib/math/spotMarket.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.castNumberToSpotPrecision = void 0;
+const anchor_1 = require("@project-serum/anchor");
+function castNumberToSpotPrecision(value, spotMarket) {
+    return new anchor_1.BN(value * Math.pow(10, spotMarket.decimals));
+}
+exports.castNumberToSpotPrecision = castNumberToSpotPrecision;

package/lib/math/spotPosition.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="bn.js" />
+import { SpotMarketAccount, SpotPosition } from '../types';
+import { BN } from '@project-serum/anchor';
+import { OraclePriceData } from '../oracles/types';
+export declare function isSpotPositionAvailable(position: SpotPosition): boolean;
+export declare function getWorstCaseTokenAmounts(spotPosition: SpotPosition, spotMarketAccount: SpotMarketAccount, oraclePriceData: OraclePriceData): [BN, BN];

package/lib/math/spotPosition.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWorstCaseTokenAmounts = exports.isSpotPositionAvailable = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const spotBalance_1 = require("./spotBalance");
+function isSpotPositionAvailable(position) {
+    return position.balance.eq(numericConstants_1.ZERO) && position.openOrders === 0;
+}
+exports.isSpotPositionAvailable = isSpotPositionAvailable;
+function getWorstCaseTokenAmounts(spotPosition, spotMarketAccount, oraclePriceData) {
+    const tokenAmount = (0, spotBalance_1.getSignedTokenAmount)((0, spotBalance_1.getTokenAmount)(spotPosition.balance, spotMarketAccount, spotPosition.balanceType), spotPosition.balanceType);
+    const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
+    const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
+    if (tokenAmountAllAsksFill.abs().gt(tokenAmountAllBidsFill.abs())) {
+        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openAsks.neg(), spotMarketAccount.decimals, oraclePriceData);
+        return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
+    }
+    else {
+        const worstCaseQuoteTokenAmount = (0, spotBalance_1.getTokenValue)(spotPosition.openBids.neg(), spotMarketAccount.decimals, oraclePriceData);
+        return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
+    }
+}
+exports.getWorstCaseTokenAmounts = getWorstCaseTokenAmounts;

package/lib/math/trade.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="bn.js" />
-import { MarketAccount, PositionDirection } from '../types';
+import { PerpMarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { AssetType } from './amm';
 import { OraclePriceData } from '../oracles/types';
@@ -13,15 +13,15 @@ export declare type PriceImpactUnit = 'entryPrice' | 'maxPrice' | 'priceDelta' |
  * @param useSpread whether to consider spread with calculating slippage
  * @return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice]
  *
- * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'entryPrice' => the average price of the trade : Precision MARK_PRICE_PRECISION
+ * 'entryPrice' => the average price of the trade : Precision PRICE_PRECISION
  *
- * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
+ * 'newPrice' => the price of the asset after the trade : Precision PRICE_PRECISION
  */
-export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: MarketAccount, inputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [BN, BN, BN, BN];
+export declare function calculateTradeSlippage(direction: PositionDirection, amount: BN, market: PerpMarketAccount, inputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [BN, BN, BN, BN];
 /**
  * Calculates acquired amounts for trade executed
  * @param direction
@@ -33,7 +33,7 @@ export declare function calculateTradeSlippage(direction: PositionDirection, amo
  * 	| 'acquiredBase' =>  positive/negative change in user's base : BN AMM_RESERVE_PRECISION
  * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
  */
-export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: MarketAccount, inputAssetType: AssetType, oraclePriceData: OraclePriceData, useSpread?: boolean): [BN, BN];
+export declare function calculateTradeAcquiredAmounts(direction: PositionDirection, amount: BN, market: PerpMarketAccount, inputAssetType: AssetType, oraclePriceData: OraclePriceData, useSpread?: boolean): [BN, BN, BN];
 /**
  * calculateTargetPriceTrade
  * simple function for finding arbitraging trades
@@ -47,8 +47,8 @@ export declare function calculateTradeAcquiredAmounts(direction: PositionDirecti
  * [
  *   direction => direction of trade required, PositionDirection
  *   tradeSize => size of trade required, TODO-PRECISION
- *   entryPrice => the entry price for the trade, MARK_PRICE_PRECISION
- *   targetPrice => the target price MARK_PRICE_PRECISION
+ *   entryPrice => the entry price for the trade, PRICE_PRECISION
+ *   targetPrice => the target price PRICE_PRECISION
  * ]
  */
-export declare function calculateTargetPriceTrade(market: MarketAccount, targetPrice: BN, pct?: BN, outputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [PositionDirection, BN, BN, BN];
+export declare function calculateTargetPriceTrade(market: PerpMarketAccount, targetPrice: BN, pct?: BN, outputAssetType?: AssetType, oraclePriceData?: OraclePriceData, useSpread?: boolean): [PositionDirection, BN, BN, BN];