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

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;

package/src/math/spotBalance.ts

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

package/src/math/spotMarket.js

@@ -0,0 +1,8 @@
+"use strict";
+exports.__esModule = true;
+exports.castNumberToSpotPrecision = void 0;
+var 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/src/math/spotMarket.ts

@@ -0,0 +1,9 @@
+import { BN } from '@project-serum/anchor';
+import { SpotMarketAccount } from '../types';
+
+export function castNumberToSpotPrecision(
+	value: number,
+	spotMarket: SpotMarketAccount
+): BN {
+	return new BN(value * Math.pow(10, spotMarket.decimals));
+}

package/src/math/spotPosition.js

@@ -0,0 +1,8 @@
+"use strict";
+exports.__esModule = true;
+exports.isSpotPositionAvailable = void 0;
+var numericConstants_1 = require("../constants/numericConstants");
+function isSpotPositionAvailable(position) {
+    return position.balance.eq(numericConstants_1.ZERO) && position.openOrders === 0;
+}
+exports.isSpotPositionAvailable = isSpotPositionAvailable;

package/src/math/spotPosition.ts

@@ -0,0 +1,6 @@
+import { SpotPosition } from '../types';
+import { ZERO } from '../constants/numericConstants';
+
+export function isSpotPositionAvailable(position: SpotPosition): boolean {
+	return position.balance.eq(ZERO) && position.openOrders === 0;
+}

package/src/math/state.ts

@@ -8,7 +8,7 @@ import { StateAccount } from '../types';
  */
 export function getExchangeFee(state: StateAccount): number {
 	const exchangeFee =
-		state.feeStructure.feeNumerator.toNumber() /
-		state.feeStructure.feeDenominator.toNumber();
+		state.perpFeeStructure.feeNumerator.toNumber() /
+		state.perpFeeStructure.feeDenominator.toNumber();
 	return exchangeFee;
 }