@drift-labs/sdk-browser 2.104.0-beta.21

package/lib/node/math/repeg.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateBudgetedPeg = exports.calculateBudgetedK = exports.calculateBudgetedKBN = exports.calculateRepegCost = exports.calculateAdjustKCost = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const assert_1 = require("../assert/assert");
+const numericConstants_1 = require("../constants/numericConstants");
+/**
+ * Helper function calculating adjust k cost
+ * @param amm
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+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.baseAssetAmountWithAmm;
+    const Q = amm.pegMultiplier;
+    const quoteScale = y.mul(d).mul(Q); //.div(AMM_RESERVE_PRECISION);
+    const p = numerator.mul(numericConstants_1.PRICE_PRECISION).div(denomenator);
+    const cost = quoteScale
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .div(x.add(d))
+        .sub(quoteScale
+        .mul(p)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .mul(numericConstants_1.PERCENTAGE_PRECISION)
+        .div(numericConstants_1.PRICE_PRECISION)
+        .div(x.mul(p).div(numericConstants_1.PRICE_PRECISION).add(d)))
+        .div(numericConstants_1.PERCENTAGE_PRECISION)
+        .div(numericConstants_1.PERCENTAGE_PRECISION)
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(numericConstants_1.PEG_PRECISION);
+    return cost.mul(new anchor_1.BN(-1));
+}
+exports.calculateAdjustKCost = calculateAdjustKCost;
+// /**
+//  * Helper function calculating adjust k cost
+//  * @param amm
+//  * @param numerator
+//  * @param denomenator
+//  * @returns cost : Precision QUOTE_ASSET_PRECISION
+//  */
+// export function calculateAdjustKCost2(
+// 	amm: AMM,
+// 	numerator: BN,
+// 	denomenator: BN
+// ): BN {
+// 	// const k = market.amm.sqrtK.mul(market.amm.sqrtK);
+// 	const directionToClose = amm.baseAssetAmountWithAmm.gt(ZERO)
+// 		? PositionDirection.SHORT
+// 		: PositionDirection.LONG;
+// 	const [newQuoteAssetReserve, _newBaseAssetReserve] =
+// 		calculateAmmReservesAfterSwap(
+// 			amm,
+// 			'base',
+// 			amm.baseAssetAmountWithAmm.abs(),
+// 			getSwapDirection('base', directionToClose)
+// 		);
+// }
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param amm
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+function calculateRepegCost(amm, newPeg) {
+    const dqar = amm.quoteAssetReserve.sub(amm.terminalQuoteAssetReserve);
+    const cost = dqar
+        .mul(newPeg.sub(amm.pegMultiplier))
+        .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(numericConstants_1.PEG_PRECISION);
+    return cost;
+}
+exports.calculateRepegCost = calculateRepegCost;
+function calculateBudgetedKBN(x, y, budget, Q, d) {
+    (0, 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);
+    if (d.lt(new anchor_1.BN(0))) {
+        dSign = new anchor_1.BN(-1);
+    }
+    const 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)
+        .div(numericConstants_1.QUOTE_PRECISION)
+        .mul(x.add(d))
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .mul(dSign);
+    const 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;
+    // 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];
+}
+exports.calculateBudgetedKBN = calculateBudgetedKBN;
+function calculateBudgetedK(amm, cost) {
+    // wolframalpha.com
+    // (1/(x+d) - p/(x*p+d))*y*d*Q = C solve for p
+    // p = (d(y*d*Q - C(x+d))) / (C*x(x+d) + y*d*d*Q)
+    // numer
+    //   =  y*d*d*Q - Cxd - Cdd
+    //   =  y/x*Q*d*d - Cd - Cd/x
+    //   = mark      - C/d - C/(x)
+    //   =  mark/C    - 1/d - 1/x
+    // denom
+    // = C*x*x + C*x*d + y*d*d*Q
+    // = 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.baseAssetAmountWithAmm;
+    const Q = amm.pegMultiplier;
+    const [numerator, denominator] = calculateBudgetedKBN(x, y, cost, Q, d);
+    return [numerator, denominator];
+}
+exports.calculateBudgetedK = calculateBudgetedK;
+function calculateBudgetedPeg(amm, budget, targetPrice) {
+    let perPegCost = amm.quoteAssetReserve
+        .sub(amm.terminalQuoteAssetReserve)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION.div(numericConstants_1.PRICE_PRECISION));
+    if (perPegCost.gt(numericConstants_1.ZERO)) {
+        perPegCost = perPegCost.add(numericConstants_1.ONE);
+    }
+    else if (perPegCost.lt(numericConstants_1.ZERO)) {
+        perPegCost = perPegCost.sub(numericConstants_1.ONE);
+    }
+    const targetPeg = targetPrice
+        .mul(amm.baseAssetReserve)
+        .div(amm.quoteAssetReserve)
+        .div(numericConstants_1.PRICE_DIV_PEG);
+    const pegChangeDirection = targetPeg.sub(amm.pegMultiplier);
+    const useTargetPeg = (perPegCost.lt(numericConstants_1.ZERO) && pegChangeDirection.gt(numericConstants_1.ZERO)) ||
+        (perPegCost.gt(numericConstants_1.ZERO) && pegChangeDirection.lt(numericConstants_1.ZERO));
+    if (perPegCost.eq(numericConstants_1.ZERO) || useTargetPeg) {
+        return targetPeg;
+    }
+    const budgetDeltaPeg = budget.mul(numericConstants_1.PEG_PRECISION).div(perPegCost);
+    const newPeg = anchor_1.BN.max(numericConstants_1.ONE, amm.pegMultiplier.add(budgetDeltaPeg));
+    return newPeg;
+}
+exports.calculateBudgetedPeg = calculateBudgetedPeg;

package/lib/node/math/spotBalance.d.ts

@@ -0,0 +1,83 @@
+/// <reference types="bn.js" />
+import { SpotMarketAccount, SpotBalanceType, MarginCategory } from '../types';
+import { BN } from '@coral-xyz/anchor';
+import { OraclePriceData } from '../oracles/types';
+import { StrictOraclePrice } from '../oracles/strictOraclePrice';
+/**
+ * Calculates the balance of a given token amount including any accumulated interest. This
+ * is the same as `SpotPosition.scaledBalance`.
+ *
+ * @param {BN} tokenAmount - the amount of tokens
+ * @param {SpotMarketAccount} spotMarket - the spot market account
+ * @param {SpotBalanceType} balanceType - the balance type ('deposit' or 'borrow')
+ * @return {BN} the calculated balance, scaled by `SPOT_MARKET_BALANCE_PRECISION`
+ */
+export declare function getBalance(tokenAmount: BN, spotMarket: SpotMarketAccount, balanceType: SpotBalanceType): BN;
+/**
+ * Calculates the spot token amount including any accumulated interest.
+ *
+ * @param {BN} balanceAmount - The balance amount, typically from `SpotPosition.scaledBalance`
+ * @param {SpotMarketAccount} spotMarket - The spot market account details
+ * @param {SpotBalanceType} balanceType - The balance type to be used for calculation
+ * @returns {BN} The calculated token amount, scaled by `SpotMarketConfig.precision`
+ */
+export declare function getTokenAmount(balanceAmount: BN, spotMarket: SpotMarketAccount, balanceType: SpotBalanceType): BN;
+/**
+ * Returns the signed (positive for deposit,negative for borrow) token amount based on the balance type.
+ *
+ * @param {BN} tokenAmount - The token amount to convert (from `getTokenAmount`)
+ * @param {SpotBalanceType} balanceType - The balance type to determine the sign of the token amount.
+ * @returns {BN} - The signed token amount, scaled by `SpotMarketConfig.precision`
+ */
+export declare function getSignedTokenAmount(tokenAmount: BN, balanceType: SpotBalanceType): BN;
+/**
+ * Calculates the value of a given token amount using the worst of the provided oracle price and its TWAP.
+ *
+ * @param {BN} tokenAmount - The amount of tokens to calculate the value for (from `getTokenAmount`)
+ * @param {number} spotDecimals - The number of decimals in the token.
+ * @param {StrictOraclePrice} strictOraclePrice - Contains oracle price and 5min twap.
+ * @return {BN} The calculated value of the given token amount, scaled by `PRICE_PRECISION`
+ */
+export declare function getStrictTokenValue(tokenAmount: BN, spotDecimals: number, strictOraclePrice: StrictOraclePrice): BN;
+/**
+ * Calculates the value of a given token amount in relation to an oracle price data
+ *
+ * @param {BN} tokenAmount - The amount of tokens to calculate the value for (from `getTokenAmount`)
+ * @param {number} spotDecimals - The number of decimal places of the token.
+ * @param {OraclePriceData} oraclePriceData - The oracle price data (typically a token/USD oracle).
+ * @return {BN} The value of the token based on the oracle, scaled by `PRICE_PRECISION`
+ */
+export declare function getTokenValue(tokenAmount: BN, spotDecimals: number, oraclePriceData: Pick<OraclePriceData, 'price'>): BN;
+export declare function calculateAssetWeight(balanceAmount: BN, oraclePrice: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
+export declare function calculateScaledInitialAssetWeight(spotMarket: SpotMarketAccount, oraclePrice: BN): BN;
+export declare function calculateLiabilityWeight(size: BN, spotMarket: SpotMarketAccount, marginCategory: MarginCategory): BN;
+export declare function calculateUtilization(bank: SpotMarketAccount, delta?: BN): BN;
+/**
+ * calculates max borrow amount where rate would stay below targetBorrowRate
+ * @param spotMarketAccount
+ * @param targetBorrowRate
+ * @returns : Precision: TOKEN DECIMALS
+ */
+export declare function calculateSpotMarketBorrowCapacity(spotMarketAccount: SpotMarketAccount, targetBorrowRate: BN): {
+    totalCapacity: BN;
+    remainingCapacity: BN;
+};
+export declare function calculateInterestRate(bank: SpotMarketAccount, delta?: BN, currentUtilization?: BN): BN;
+export declare function calculateDepositRate(bank: SpotMarketAccount, delta?: BN, currentUtilization?: BN): BN;
+export declare function calculateBorrowRate(bank: SpotMarketAccount, delta?: BN, currentUtilization?: BN): BN;
+export declare function calculateInterestAccumulated(bank: SpotMarketAccount, now: BN): {
+    borrowInterest: BN;
+    depositInterest: BN;
+};
+export declare function calculateTokenUtilizationLimits(depositTokenAmount: BN, borrowTokenAmount: BN, spotMarket: SpotMarketAccount): {
+    minDepositTokensForUtilization: BN;
+    maxBorrowTokensForUtilization: BN;
+};
+export declare function calculateWithdrawLimit(spotMarket: SpotMarketAccount, now: BN): {
+    borrowLimit: BN;
+    withdrawLimit: BN;
+    minDepositAmount: BN;
+    maxBorrowAmount: BN;
+    currentDepositAmount: any;
+    currentBorrowAmount: any;
+};

package/lib/node/math/spotBalance.js

@@ -0,0 +1,373 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWithdrawLimit = exports.calculateTokenUtilizationLimits = exports.calculateInterestAccumulated = exports.calculateBorrowRate = exports.calculateDepositRate = exports.calculateInterestRate = exports.calculateSpotMarketBorrowCapacity = exports.calculateUtilization = exports.calculateLiabilityWeight = exports.calculateScaledInitialAssetWeight = exports.calculateAssetWeight = exports.getTokenValue = exports.getStrictTokenValue = exports.getSignedTokenAmount = exports.getTokenAmount = exports.getBalance = void 0;
+const types_1 = require("../types");
+const anchor_1 = require("@coral-xyz/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const margin_1 = require("./margin");
+const numericConstants_2 = require("../constants/numericConstants");
+const utils_1 = require("./utils");
+/**
+ * Calculates the balance of a given token amount including any accumulated interest. This
+ * is the same as `SpotPosition.scaledBalance`.
+ *
+ * @param {BN} tokenAmount - the amount of tokens
+ * @param {SpotMarketAccount} spotMarket - the spot market account
+ * @param {SpotBalanceType} balanceType - the balance type ('deposit' or 'borrow')
+ * @return {BN} the calculated balance, scaled by `SPOT_MARKET_BALANCE_PRECISION`
+ */
+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;
+/**
+ * Calculates the spot token amount including any accumulated interest.
+ *
+ * @param {BN} balanceAmount - The balance amount, typically from `SpotPosition.scaledBalance`
+ * @param {SpotMarketAccount} spotMarket - The spot market account details
+ * @param {SpotBalanceType} balanceType - The balance type to be used for calculation
+ * @returns {BN} The calculated token amount, scaled by `SpotMarketConfig.precision`
+ */
+function getTokenAmount(balanceAmount, spotMarket, balanceType) {
+    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(19 - spotMarket.decimals));
+    if ((0, types_1.isVariant)(balanceType, 'deposit')) {
+        return balanceAmount
+            .mul(spotMarket.cumulativeDepositInterest)
+            .div(precisionDecrease);
+    }
+    else {
+        return (0, utils_1.divCeil)(balanceAmount.mul(spotMarket.cumulativeBorrowInterest), precisionDecrease);
+    }
+}
+exports.getTokenAmount = getTokenAmount;
+/**
+ * Returns the signed (positive for deposit,negative for borrow) token amount based on the balance type.
+ *
+ * @param {BN} tokenAmount - The token amount to convert (from `getTokenAmount`)
+ * @param {SpotBalanceType} balanceType - The balance type to determine the sign of the token amount.
+ * @returns {BN} - The signed token amount, scaled by `SpotMarketConfig.precision`
+ */
+function getSignedTokenAmount(tokenAmount, balanceType) {
+    if ((0, types_1.isVariant)(balanceType, 'deposit')) {
+        return tokenAmount;
+    }
+    else {
+        return tokenAmount.abs().neg();
+    }
+}
+exports.getSignedTokenAmount = getSignedTokenAmount;
+/**
+ * Calculates the value of a given token amount using the worst of the provided oracle price and its TWAP.
+ *
+ * @param {BN} tokenAmount - The amount of tokens to calculate the value for (from `getTokenAmount`)
+ * @param {number} spotDecimals - The number of decimals in the token.
+ * @param {StrictOraclePrice} strictOraclePrice - Contains oracle price and 5min twap.
+ * @return {BN} The calculated value of the given token amount, scaled by `PRICE_PRECISION`
+ */
+function getStrictTokenValue(tokenAmount, spotDecimals, strictOraclePrice) {
+    if (tokenAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    let price;
+    if (tokenAmount.gte(numericConstants_1.ZERO)) {
+        price = strictOraclePrice.min();
+    }
+    else {
+        price = strictOraclePrice.max();
+    }
+    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(spotDecimals));
+    return tokenAmount.mul(price).div(precisionDecrease);
+}
+exports.getStrictTokenValue = getStrictTokenValue;
+/**
+ * Calculates the value of a given token amount in relation to an oracle price data
+ *
+ * @param {BN} tokenAmount - The amount of tokens to calculate the value for (from `getTokenAmount`)
+ * @param {number} spotDecimals - The number of decimal places of the token.
+ * @param {OraclePriceData} oraclePriceData - The oracle price data (typically a token/USD oracle).
+ * @return {BN} The value of the token based on the oracle, scaled by `PRICE_PRECISION`
+ */
+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, oraclePrice, 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, new anchor_1.BN(spotMarket.imfFactor), calculateScaledInitialAssetWeight(spotMarket, oraclePrice));
+            break;
+        case 'Maintenance':
+            assetWeight = (0, margin_1.calculateSizeDiscountAssetWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceAssetWeight));
+            break;
+        default:
+            assetWeight = calculateScaledInitialAssetWeight(spotMarket, oraclePrice);
+            break;
+    }
+    return assetWeight;
+}
+exports.calculateAssetWeight = calculateAssetWeight;
+function calculateScaledInitialAssetWeight(spotMarket, oraclePrice) {
+    if (spotMarket.scaleInitialAssetWeightStart.eq(numericConstants_1.ZERO)) {
+        return new anchor_1.BN(spotMarket.initialAssetWeight);
+    }
+    const deposits = getTokenAmount(spotMarket.depositBalance, spotMarket, types_1.SpotBalanceType.DEPOSIT);
+    const depositsValue = getTokenValue(deposits, spotMarket.decimals, {
+        price: oraclePrice,
+    });
+    if (depositsValue.lt(spotMarket.scaleInitialAssetWeightStart)) {
+        return new anchor_1.BN(spotMarket.initialAssetWeight);
+    }
+    else {
+        return new anchor_1.BN(spotMarket.initialAssetWeight)
+            .mul(spotMarket.scaleInitialAssetWeightStart)
+            .div(depositsValue);
+    }
+}
+exports.calculateScaledInitialAssetWeight = calculateScaledInitialAssetWeight;
+function calculateLiabilityWeight(size, 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 = size.div(sizePrecision.div(numericConstants_1.AMM_RESERVE_PRECISION));
+    }
+    else {
+        sizeInAmmReservePrecision = size
+            .mul(numericConstants_1.AMM_RESERVE_PRECISION)
+            .div(sizePrecision);
+    }
+    let liabilityWeight;
+    switch (marginCategory) {
+        case 'Initial':
+            liabilityWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.initialLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            break;
+        case 'Maintenance':
+            liabilityWeight = (0, margin_1.calculateSizePremiumLiabilityWeight)(sizeInAmmReservePrecision, new anchor_1.BN(spotMarket.imfFactor), new anchor_1.BN(spotMarket.maintenanceLiabilityWeight), numericConstants_1.SPOT_MARKET_WEIGHT_PRECISION);
+            break;
+        default:
+            liabilityWeight = new anchor_1.BN(spotMarket.initialLiabilityWeight);
+            break;
+    }
+    return liabilityWeight;
+}
+exports.calculateLiabilityWeight = calculateLiabilityWeight;
+function calculateUtilization(bank, delta = numericConstants_1.ZERO) {
+    let tokenDepositAmount = getTokenAmount(bank.depositBalance, bank, types_1.SpotBalanceType.DEPOSIT);
+    let tokenBorrowAmount = getTokenAmount(bank.borrowBalance, bank, types_1.SpotBalanceType.BORROW);
+    if (delta.gt(numericConstants_1.ZERO)) {
+        tokenDepositAmount = tokenDepositAmount.add(delta);
+    }
+    else if (delta.lt(numericConstants_1.ZERO)) {
+        tokenBorrowAmount = tokenBorrowAmount.add(delta.abs());
+    }
+    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;
+/**
+ * calculates max borrow amount where rate would stay below targetBorrowRate
+ * @param spotMarketAccount
+ * @param targetBorrowRate
+ * @returns : Precision: TOKEN DECIMALS
+ */
+function calculateSpotMarketBorrowCapacity(spotMarketAccount, targetBorrowRate) {
+    const currentBorrowRate = calculateBorrowRate(spotMarketAccount);
+    const tokenDepositAmount = getTokenAmount(spotMarketAccount.depositBalance, spotMarketAccount, types_1.SpotBalanceType.DEPOSIT);
+    const tokenBorrowAmount = getTokenAmount(spotMarketAccount.borrowBalance, spotMarketAccount, types_1.SpotBalanceType.BORROW);
+    let targetUtilization;
+    // target utilization past mid point
+    if (targetBorrowRate.gte(new anchor_1.BN(spotMarketAccount.optimalBorrowRate))) {
+        const borrowRateSlope = new anchor_1.BN(spotMarketAccount.maxBorrowRate - spotMarketAccount.optimalBorrowRate)
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(new anchor_1.BN(spotMarketAccount.optimalUtilization)));
+        const surplusTargetUtilization = targetBorrowRate
+            .sub(new anchor_1.BN(spotMarketAccount.optimalBorrowRate))
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(borrowRateSlope);
+        targetUtilization = surplusTargetUtilization.add(new anchor_1.BN(spotMarketAccount.optimalUtilization));
+    }
+    else {
+        const borrowRateSlope = new anchor_1.BN(spotMarketAccount.optimalBorrowRate)
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(new anchor_1.BN(spotMarketAccount.optimalUtilization));
+        targetUtilization = targetBorrowRate
+            .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+            .div(borrowRateSlope);
+    }
+    const totalCapacity = tokenDepositAmount
+        .mul(targetUtilization)
+        .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    let remainingCapacity;
+    if (currentBorrowRate.gte(targetBorrowRate)) {
+        remainingCapacity = numericConstants_1.ZERO;
+    }
+    else {
+        remainingCapacity = anchor_1.BN.max(numericConstants_1.ZERO, totalCapacity.sub(tokenBorrowAmount));
+    }
+    if (spotMarketAccount.maxTokenBorrowsFraction > 0) {
+        const maxTokenBorrows = spotMarketAccount.maxTokenDeposits
+            .mul(new anchor_1.BN(spotMarketAccount.maxTokenBorrowsFraction))
+            .divn(10000);
+        remainingCapacity = anchor_1.BN.min(remainingCapacity, anchor_1.BN.max(numericConstants_1.ZERO, maxTokenBorrows.sub(tokenBorrowAmount)));
+    }
+    return { totalCapacity, remainingCapacity };
+}
+exports.calculateSpotMarketBorrowCapacity = calculateSpotMarketBorrowCapacity;
+function calculateInterestRate(bank, delta = numericConstants_1.ZERO, currentUtilization = null) {
+    const utilization = currentUtilization || calculateUtilization(bank, delta);
+    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(new anchor_1.BN(bank.optimalUtilization));
+        interestRate = utilization
+            .mul(borrowRateSlope)
+            .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    }
+    return anchor_1.BN.max(interestRate, new anchor_1.BN(bank.minBorrowRate).mul(numericConstants_2.PERCENTAGE_PRECISION.divn(200)));
+}
+exports.calculateInterestRate = calculateInterestRate;
+function calculateDepositRate(bank, delta = numericConstants_1.ZERO, currentUtilization = null) {
+    // positive delta => adding to deposit
+    // negative delta => adding to borrow
+    const utilization = currentUtilization || calculateUtilization(bank, delta);
+    const borrowRate = calculateBorrowRate(bank, delta, utilization);
+    const depositRate = borrowRate
+        .mul(numericConstants_2.PERCENTAGE_PRECISION.sub(new anchor_1.BN(bank.insuranceFund.totalFactor)))
+        .mul(utilization)
+        .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+        .div(numericConstants_2.PERCENTAGE_PRECISION);
+    return depositRate;
+}
+exports.calculateDepositRate = calculateDepositRate;
+function calculateBorrowRate(bank, delta = numericConstants_1.ZERO, currentUtilization = null) {
+    return calculateInterestRate(bank, delta, currentUtilization);
+}
+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 calculateTokenUtilizationLimits(depositTokenAmount, borrowTokenAmount, spotMarket) {
+    // Calculates the allowable minimum deposit and maximum borrow amounts for immediate withdrawal based on market utilization.
+    // First, it determines a maximum withdrawal utilization from the market's target and historic utilization.
+    // Then, it deduces corresponding deposit/borrow amounts.
+    // Note: For deposit sizes below the guard threshold, withdrawals aren't blocked.
+    const maxWithdrawUtilization = anchor_1.BN.max(new anchor_1.BN(spotMarket.optimalUtilization), spotMarket.utilizationTwap.add(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION.sub(spotMarket.utilizationTwap).div(new anchor_1.BN(2))));
+    let minDepositTokensForUtilization = borrowTokenAmount
+        .mul(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION)
+        .div(maxWithdrawUtilization);
+    // don't block withdraws for deposit sizes below guard threshold
+    minDepositTokensForUtilization = anchor_1.BN.min(minDepositTokensForUtilization, depositTokenAmount.sub(spotMarket.withdrawGuardThreshold));
+    let maxBorrowTokensForUtilization = maxWithdrawUtilization
+        .mul(depositTokenAmount)
+        .div(numericConstants_1.SPOT_MARKET_UTILIZATION_PRECISION);
+    maxBorrowTokensForUtilization = anchor_1.BN.max(spotMarket.withdrawGuardThreshold, maxBorrowTokensForUtilization);
+    return {
+        minDepositTokensForUtilization,
+        maxBorrowTokensForUtilization,
+    };
+}
+exports.calculateTokenUtilizationLimits = calculateTokenUtilizationLimits;
+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(sinceStart));
+    const depositTokenTwapLive = spotMarket.depositTokenTwap
+        .mul(sinceStart)
+        .add(marketDepositTokenAmount.mul(sinceLast))
+        .div(sinceLast.add(sinceStart));
+    const lesserDepositAmount = anchor_1.BN.min(marketDepositTokenAmount, depositTokenTwapLive);
+    const maxBorrowTokensTwap = anchor_1.BN.max(spotMarket.withdrawGuardThreshold, anchor_1.BN.min(anchor_1.BN.max(marketDepositTokenAmount.div(new anchor_1.BN(6)), borrowTokenTwapLive.add(lesserDepositAmount.div(new anchor_1.BN(10)))), lesserDepositAmount.sub(lesserDepositAmount.div(new anchor_1.BN(5))))); // between ~15-80% utilization with friction on twap
+    const minDepositTokensTwap = depositTokenTwapLive.sub(anchor_1.BN.max(depositTokenTwapLive.div(new anchor_1.BN(4)), anchor_1.BN.min(spotMarket.withdrawGuardThreshold, depositTokenTwapLive)));
+    const { minDepositTokensForUtilization, maxBorrowTokensForUtilization } = calculateTokenUtilizationLimits(marketDepositTokenAmount, marketBorrowTokenAmount, spotMarket);
+    const minDepositTokens = anchor_1.BN.max(minDepositTokensForUtilization, minDepositTokensTwap);
+    let maxBorrowTokens = anchor_1.BN.min(maxBorrowTokensForUtilization, maxBorrowTokensTwap);
+    const withdrawLimit = anchor_1.BN.max(marketDepositTokenAmount.sub(minDepositTokens), numericConstants_1.ZERO);
+    let borrowLimit = maxBorrowTokens.sub(marketBorrowTokenAmount);
+    borrowLimit = anchor_1.BN.min(borrowLimit, marketDepositTokenAmount.sub(marketBorrowTokenAmount));
+    if (spotMarket.maxTokenBorrowsFraction > 0) {
+        const maxTokenBorrowsByFraction = spotMarket.maxTokenDeposits
+            .mul(new anchor_1.BN(spotMarket.maxTokenBorrowsFraction))
+            .divn(10000);
+        const trueMaxBorrowTokensAvailable = maxTokenBorrowsByFraction.sub(marketBorrowTokenAmount);
+        maxBorrowTokens = anchor_1.BN.min(maxBorrowTokens, trueMaxBorrowTokensAvailable);
+        borrowLimit = anchor_1.BN.min(borrowLimit, maxBorrowTokens);
+    }
+    if (withdrawLimit.eq(numericConstants_1.ZERO)) {
+        borrowLimit = numericConstants_1.ZERO;
+    }
+    return {
+        borrowLimit,
+        withdrawLimit,
+        maxBorrowAmount: maxBorrowTokens,
+        minDepositAmount: minDepositTokens,
+        currentDepositAmount: marketDepositTokenAmount,
+        currentBorrowAmount: marketBorrowTokenAmount,
+    };
+}
+exports.calculateWithdrawLimit = calculateWithdrawLimit;

package/lib/node/math/spotMarket.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="bn.js" />
+import { BN } from '@coral-xyz/anchor';
+import { MarginCategory, SpotBalanceType, SpotMarketAccount } from '../types';
+export declare function castNumberToSpotPrecision(value: number | BN, spotMarket: SpotMarketAccount): BN;
+export declare function calculateSpotMarketMarginRatio(market: SpotMarketAccount, oraclePrice: BN, marginCategory: MarginCategory, size: BN, balanceType: SpotBalanceType, customMarginRatio?: number): number;
+/**
+ * Returns the maximum remaining deposit that can be made to the spot market. If the maxTokenDeposits on the market is zero then there is no limit and this function will also return zero. (so that needs to be checked)
+ * @param market
+ * @returns
+ */
+export declare function calculateMaxRemainingDeposit(market: SpotMarketAccount): BN;