@velocity-exchange/sdk 0.0.1

package/lib/browser/math/position.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasOpenOrders = exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateCostBasis = exports.calculateEntryPrice = exports.calculateBreakEvenPrice = exports.positionIsBeingLiquidated = exports.positionIsAvailable = exports.calculatePositionFundingPNL = exports.calculateUnsettledFundingPnl = exports.calculateFeesAndFundingPnl = exports.calculateClaimablePnl = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
+const anchor_1 = require("../isomorphic/anchor");
+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
+ * @param market
+ * @param userPosition
+ * @param oraclePriceData
+ * @returns Base Asset Value. : Precision QUOTE_PRECISION
+ */
+function calculateBaseAssetValue(market, userPosition, mmOraclePriceData, useSpread = true, skipUpdate = false, latestSlot) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    const directionToClose = findDirectionToClose(userPosition);
+    let prepegAmm;
+    if (!skipUpdate) {
+        if (market.amm.baseSpread > 0 && useSpread) {
+            const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } = (0, amm_1.calculateUpdatedAMMSpreadReserves)(market.amm, directionToClose, mmOraclePriceData, latestSlot);
+            prepegAmm = {
+                baseAssetReserve,
+                quoteAssetReserve,
+                sqrtK: sqrtK,
+                pegMultiplier: newPeg,
+            };
+        }
+        else {
+            prepegAmm = (0, amm_1.calculateUpdatedAMM)(market.amm, mmOraclePriceData);
+        }
+    }
+    else {
+        prepegAmm = market.amm;
+    }
+    const [newQuoteAssetReserve, _] = (0, amm_1.calculateAmmReservesAfterSwap)(prepegAmm, 'base', userPosition.baseAssetAmount.abs(), (0, amm_1.getSwapDirection)('base', directionToClose));
+    switch (directionToClose) {
+        case types_1.PositionDirection.SHORT:
+            return prepegAmm.quoteAssetReserve
+                .sub(newQuoteAssetReserve)
+                .mul(prepegAmm.pegMultiplier)
+                .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
+        case types_1.PositionDirection.LONG:
+            return newQuoteAssetReserve
+                .sub(prepegAmm.quoteAssetReserve)
+                .mul(prepegAmm.pegMultiplier)
+                .div(numericConstants_1.AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO)
+                .add(numericConstants_1.ONE);
+    }
+}
+exports.calculateBaseAssetValue = calculateBaseAssetValue;
+/**
+ * calculatePositionPNL
+ * = BaseAssetAmount * (Avg Exit Price - Avg Entry Price)
+ * @param market
+ * @param PerpPosition
+ * @param withFunding (adds unrealized funding payment pnl to result)
+ * @param oraclePriceData
+ * @returns BaseAssetAmount : Precision QUOTE_PRECISION
+ */
+function calculatePositionPNL(market, perpPosition, withFunding = 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 anchor_1.BN(-1)
+        : new anchor_1.BN(1);
+    let pnl = baseAssetValue
+        .mul(baseAssetValueSign)
+        .add(perpPosition.quoteAssetAmount);
+    if (withFunding) {
+        const fundingRatePnL = calculateUnsettledFundingPnl(market, perpPosition);
+        pnl = pnl.add(fundingRatePnL);
+    }
+    return pnl;
+}
+exports.calculatePositionPNL = calculatePositionPNL;
+function calculateClaimablePnl(market, spotMarket, perpPosition, oraclePriceData) {
+    const unrealizedPnl = calculatePositionPNL(market, perpPosition, true, oraclePriceData);
+    let unsettledPnl = unrealizedPnl;
+    if (unrealizedPnl.gt(numericConstants_1.ZERO)) {
+        const excessPnlPool = anchor_1.BN.max(numericConstants_1.ZERO, (0, market_1.calculateNetUserPnlImbalance)(market, spotMarket, oraclePriceData).mul(new anchor_1.BN(-1)));
+        const maxPositivePnl = anchor_1.BN.max(perpPosition.quoteAssetAmount.sub(perpPosition.quoteEntryAmount), numericConstants_1.ZERO).add(excessPnlPool);
+        unsettledPnl = anchor_1.BN.min(maxPositivePnl, unrealizedPnl);
+    }
+    return unsettledPnl;
+}
+exports.calculateClaimablePnl = calculateClaimablePnl;
+/**
+ * Returns total fees and funding pnl for a position
+ *
+ * @param market
+ * @param PerpPosition
+ * @param includeUnsettled include unsettled funding in return value (default: true)
+ * @returns — // QUOTE_PRECISION
+ */
+function calculateFeesAndFundingPnl(market, perpPosition, includeUnsettled = true) {
+    const settledFundingAndFeesPnl = perpPosition.quoteBreakEvenAmount.sub(perpPosition.quoteEntryAmount);
+    if (!includeUnsettled) {
+        return settledFundingAndFeesPnl;
+    }
+    const unsettledFundingPnl = calculateUnsettledFundingPnl(market, perpPosition);
+    return settledFundingAndFeesPnl.add(unsettledFundingPnl);
+}
+exports.calculateFeesAndFundingPnl = calculateFeesAndFundingPnl;
+/**
+ * Returns unsettled funding pnl for the position
+ *
+ * To calculate all fees and funding pnl including settled, use calculateFeesAndFundingPnl
+ *
+ * @param market
+ * @param PerpPosition
+ * @returns // QUOTE_PRECISION
+ */
+function calculateUnsettledFundingPnl(market, perpPosition) {
+    if (perpPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    let ammCumulativeFundingRate;
+    if (perpPosition.baseAssetAmount.gt(numericConstants_1.ZERO)) {
+        ammCumulativeFundingRate = market.amm.cumulativeFundingRateLong;
+    }
+    else {
+        ammCumulativeFundingRate = market.amm.cumulativeFundingRateShort;
+    }
+    const perPositionFundingRate = ammCumulativeFundingRate
+        .sub(perpPosition.lastCumulativeFundingRate)
+        .mul(perpPosition.baseAssetAmount)
+        .div(numericConstants_1.AMM_RESERVE_PRECISION)
+        .div(numericConstants_1.FUNDING_RATE_BUFFER_PRECISION)
+        .mul(new anchor_1.BN(-1));
+    return perPositionFundingRate;
+}
+exports.calculateUnsettledFundingPnl = calculateUnsettledFundingPnl;
+/**
+ * @deprecated use calculateUnsettledFundingPnl or calculateFeesAndFundingPnl instead
+ */
+function calculatePositionFundingPNL(market, perpPosition) {
+    return calculateUnsettledFundingPnl(market, perpPosition);
+}
+exports.calculatePositionFundingPNL = calculatePositionFundingPNL;
+function positionIsAvailable(position) {
+    return (position.baseAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.openOrders === 0 &&
+        position.quoteAssetAmount.eq(numericConstants_1.ZERO) &&
+        position.isolatedPositionScaledBalance.eq(numericConstants_1.ZERO) &&
+        !positionIsBeingLiquidated(position));
+}
+exports.positionIsAvailable = positionIsAvailable;
+function positionIsBeingLiquidated(position) {
+    return ((position.positionFlag &
+        (types_1.PositionFlag.BeingLiquidated | types_1.PositionFlag.Bankruptcy)) >
+        0);
+}
+exports.positionIsBeingLiquidated = positionIsBeingLiquidated;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^6)
+ */
+function calculateBreakEvenPrice(userPosition) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    return userPosition.quoteBreakEvenAmount
+        .mul(numericConstants_1.PRICE_PRECISION)
+        .mul(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO)
+        .div(userPosition.baseAssetAmount)
+        .abs();
+}
+exports.calculateBreakEvenPrice = calculateBreakEvenPrice;
+/**
+ *
+ * @param userPosition
+ * @returns Precision: PRICE_PRECISION (10^6)
+ */
+function calculateEntryPrice(userPosition) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    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, includeSettledPnl = false) {
+    if (userPosition.baseAssetAmount.eq(numericConstants_1.ZERO)) {
+        return numericConstants_1.ZERO;
+    }
+    return userPosition.quoteAssetAmount
+        .add(includeSettledPnl ? userPosition.settledPnl : numericConstants_1.ZERO)
+        .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
+        : types_1.PositionDirection.LONG;
+}
+exports.findDirectionToClose = findDirectionToClose;
+function positionCurrentDirection(userPosition) {
+    return userPosition.baseAssetAmount.gte(numericConstants_1.ZERO)
+        ? types_1.PositionDirection.LONG
+        : types_1.PositionDirection.SHORT;
+}
+exports.positionCurrentDirection = positionCurrentDirection;
+function isEmptyPosition(userPosition) {
+    return userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) && userPosition.openOrders === 0;
+}
+exports.isEmptyPosition = isEmptyPosition;
+function hasOpenOrders(position) {
+    return (position.openOrders != 0 ||
+        !position.openBids.eq(numericConstants_1.ZERO) ||
+        !position.openAsks.eq(numericConstants_1.ZERO));
+}
+exports.hasOpenOrders = hasOpenOrders;

package/lib/browser/math/repeg.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="bn.js" />
+import { BN } from '../isomorphic/anchor';
+import { AMM } from '../types';
+/**
+ * Helper function calculating adjust k cost
+ * @param amm
+ * @param numerator
+ * @param denomenator
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export declare function calculateAdjustKCost(amm: AMM, numerator: BN, denomenator: BN): BN;
+/**
+ * Helper function calculating adjust pegMultiplier (repeg) cost
+ *
+ * @param amm
+ * @param newPeg
+ * @returns cost : Precision QUOTE_ASSET_PRECISION
+ */
+export declare function calculateRepegCost(amm: AMM, newPeg: BN): BN;
+export declare function calculateBudgetedKBN(x: BN, y: BN, budget: BN, Q: BN, d: BN): [BN, BN];
+export declare function calculateBudgetedK(amm: AMM, cost: BN): [BN, BN];
+export declare function calculateBudgetedPeg(amm: AMM, budget: BN, targetPrice: BN): BN;

package/lib/browser/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("../isomorphic/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/browser/math/spotBalance.d.ts

@@ -0,0 +1,85 @@
+/// <reference types="bn.js" />
+import { SpotMarketAccount, SpotBalanceType, MarginCategory } from '../types';
+import { BN } from '../isomorphic/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;
+};
+export declare function getSpotAssetValue(tokenAmount: BN, strictOraclePrice: StrictOraclePrice, spotMarketAccount: SpotMarketAccount, maxMarginRatio: number, marginCategory?: MarginCategory): BN;
+export declare function getSpotLiabilityValue(tokenAmount: BN, strictOraclePrice: StrictOraclePrice, spotMarketAccount: SpotMarketAccount, maxMarginRatio: number, marginCategory?: MarginCategory, liquidationBuffer?: BN): BN;