@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.10

package/src/math/auction.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuctionPrice = exports.isAuctionComplete = void 0;
+const types_1 = require("../types");
+const _1 = require("../.");
+function isAuctionComplete(order, slot) {
+    if (order.auctionDuration === 0) {
+        return true;
+    }
+    return new _1.BN(slot).sub(order.slot).gt(new _1.BN(order.auctionDuration));
+}
+exports.isAuctionComplete = isAuctionComplete;
+function getAuctionPrice(order, slot) {
+    const slotsElapsed = new _1.BN(slot).sub(order.slot);
+    const deltaDenominator = new _1.BN(order.auctionDuration);
+    const deltaNumerator = _1.BN.min(slotsElapsed, deltaDenominator);
+    if (deltaDenominator.eq(_1.ZERO)) {
+        return order.auctionEndPrice;
+    }
+    let priceDelta;
+    if (types_1.isVariant(order.direction, 'long')) {
+        priceDelta = order.auctionEndPrice
+            .sub(order.auctionStartPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    else {
+        priceDelta = order.auctionStartPrice
+            .sub(order.auctionEndPrice)
+            .mul(deltaNumerator)
+            .div(deltaDenominator);
+    }
+    let price;
+    if (types_1.isVariant(order.direction, 'long')) {
+        price = order.auctionStartPrice.add(priceDelta);
+    }
+    else {
+        price = order.auctionStartPrice.sub(priceDelta);
+    }
+    return price;
+}
+exports.getAuctionPrice = getAuctionPrice;

package/src/math/auction.ts

@@ -0,0 +1,43 @@
+import { isVariant, Order } from '../types';
+import { BN, ZERO } from '../.';
+
+export function isAuctionComplete(order: Order, slot: number): boolean {
+	if (order.auctionDuration === 0) {
+		return true;
+	}
+
+	return new BN(slot).sub(order.slot).gt(new BN(order.auctionDuration));
+}
+
+export function getAuctionPrice(order: Order, slot: number): BN {
+	const slotsElapsed = new BN(slot).sub(order.slot);
+
+	const deltaDenominator = new BN(order.auctionDuration);
+	const deltaNumerator = BN.min(slotsElapsed, deltaDenominator);
+
+	if (deltaDenominator.eq(ZERO)) {
+		return order.auctionEndPrice;
+	}
+
+	let priceDelta;
+	if (isVariant(order.direction, 'long')) {
+		priceDelta = order.auctionEndPrice
+			.sub(order.auctionStartPrice)
+			.mul(deltaNumerator)
+			.div(deltaDenominator);
+	} else {
+		priceDelta = order.auctionStartPrice
+			.sub(order.auctionEndPrice)
+			.mul(deltaNumerator)
+			.div(deltaDenominator);
+	}
+
+	let price;
+	if (isVariant(order.direction, 'long')) {
+		price = order.auctionStartPrice.add(priceDelta);
+	} else {
+		price = order.auctionStartPrice.sub(priceDelta);
+	}
+
+	return price;
+}

package/src/math/bankBalance.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateInterestAccumulated = exports.getTokenAmount = exports.getBalance = void 0;
+const types_1 = require("../types");
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+function getBalance(tokenAmount, bank, balanceType) {
+    const precisionIncrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - bank.decimals));
+    const cumulativeInterest = types_1.isVariant(balanceType, 'deposit')
+        ? bank.cumulativeDepositInterest
+        : bank.cumulativeBorrowInterest;
+    let balance = tokenAmount.mul(precisionIncrease).div(cumulativeInterest);
+    if (!balance.eq(numericConstants_1.ZERO) && types_1.isVariant(balanceType, 'borrow')) {
+        balance = balance.add(numericConstants_1.ONE);
+    }
+    return balance;
+}
+exports.getBalance = getBalance;
+function getTokenAmount(balanceAmount, bank, balanceType) {
+    const precisionDecrease = numericConstants_1.TEN.pow(new anchor_1.BN(16 - bank.decimals));
+    const cumulativeInterest = types_1.isVariant(balanceType, 'deposit')
+        ? bank.cumulativeDepositInterest
+        : bank.cumulativeBorrowInterest;
+    return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
+}
+exports.getTokenAmount = getTokenAmount;
+function calculateInterestAccumulated(bank, now) {
+    const token_deposit_amount = getTokenAmount(bank.depositBalance, bank, types_1.BankBalanceType.DEPOSIT);
+    const token_borrow_amount = getTokenAmount(bank.borrowBalance, bank, types_1.BankBalanceType.BORROW);
+    let utilization;
+    if (token_borrow_amount.eq(numericConstants_1.ZERO) && token_deposit_amount.eq(numericConstants_1.ZERO)) {
+        utilization = numericConstants_1.ZERO;
+    }
+    else if (token_deposit_amount.eq(numericConstants_1.ZERO)) {
+        utilization = numericConstants_1.BANK_UTILIZATION_PRECISION;
+    }
+    else {
+        utilization = token_borrow_amount
+            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
+            .div(token_deposit_amount);
+    }
+    let interest_rate;
+    if (utilization.gt(bank.optimalUtilization)) {
+        const surplusUtilization = utilization.sub(bank.optimalUtilization);
+        const borrowRateSlope = bank.maxBorrowRate
+            .sub(bank.optimalBorrowRate)
+            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
+            .div(numericConstants_1.BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+        interest_rate = bank.optimalBorrowRate.add(surplusUtilization.mul(borrowRateSlope).div(numericConstants_1.BANK_UTILIZATION_PRECISION));
+    }
+    else {
+        const borrowRateSlope = bank.optimalBorrowRate
+            .mul(numericConstants_1.BANK_UTILIZATION_PRECISION)
+            .div(numericConstants_1.BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+        interest_rate = utilization
+            .mul(borrowRateSlope)
+            .div(numericConstants_1.BANK_UTILIZATION_PRECISION);
+    }
+    const timeSinceLastUpdate = now.sub(bank.lastUpdated);
+    const modifiedBorrowRate = interest_rate.mul(timeSinceLastUpdate);
+    const modifiedDepositRate = modifiedBorrowRate
+        .mul(utilization)
+        .div(numericConstants_1.BANK_UTILIZATION_PRECISION);
+    const borrowInterest = bank.cumulativeBorrowInterest
+        .mul(modifiedBorrowRate)
+        .div(numericConstants_1.ONE_YEAR)
+        .div(numericConstants_1.BANK_INTEREST_PRECISION)
+        .add(numericConstants_1.ONE);
+    const depositInterest = bank.cumulativeDepositInterest
+        .mul(modifiedDepositRate)
+        .div(numericConstants_1.ONE_YEAR)
+        .div(numericConstants_1.BANK_INTEREST_PRECISION);
+    return { borrowInterest, depositInterest };
+}
+exports.calculateInterestAccumulated = calculateInterestAccumulated;

package/src/math/bankBalance.ts

@@ -0,0 +1,112 @@
+import { BankAccount, BankBalanceType, isVariant } from '../types';
+import { BN } from '@project-serum/anchor';
+import {
+	BANK_UTILIZATION_PRECISION,
+	ONE,
+	TEN,
+	ZERO,
+	BANK_INTEREST_PRECISION,
+	ONE_YEAR,
+} from '../constants/numericConstants';
+
+export function getBalance(
+	tokenAmount: BN,
+	bank: BankAccount,
+	balanceType: BankBalanceType
+): BN {
+	const precisionIncrease = TEN.pow(new BN(16 - bank.decimals));
+
+	const cumulativeInterest = isVariant(balanceType, 'deposit')
+		? bank.cumulativeDepositInterest
+		: bank.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,
+	bank: BankAccount,
+	balanceType: BankBalanceType
+): BN {
+	const precisionDecrease = TEN.pow(new BN(16 - bank.decimals));
+
+	const cumulativeInterest = isVariant(balanceType, 'deposit')
+		? bank.cumulativeDepositInterest
+		: bank.cumulativeBorrowInterest;
+
+	return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
+}
+
+export function calculateInterestAccumulated(
+	bank: BankAccount,
+	now: BN
+): { borrowInterest: BN; depositInterest: BN } {
+	const token_deposit_amount = getTokenAmount(
+		bank.depositBalance,
+		bank,
+		BankBalanceType.DEPOSIT
+	);
+	const token_borrow_amount = getTokenAmount(
+		bank.borrowBalance,
+		bank,
+		BankBalanceType.BORROW
+	);
+
+	let utilization: BN;
+	if (token_borrow_amount.eq(ZERO) && token_deposit_amount.eq(ZERO)) {
+		utilization = ZERO;
+	} else if (token_deposit_amount.eq(ZERO)) {
+		utilization = BANK_UTILIZATION_PRECISION;
+	} else {
+		utilization = token_borrow_amount
+			.mul(BANK_UTILIZATION_PRECISION)
+			.div(token_deposit_amount);
+	}
+
+	let interest_rate: BN;
+	if (utilization.gt(bank.optimalUtilization)) {
+		const surplusUtilization = utilization.sub(bank.optimalUtilization);
+		const borrowRateSlope = bank.maxBorrowRate
+			.sub(bank.optimalBorrowRate)
+			.mul(BANK_UTILIZATION_PRECISION)
+			.div(BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+
+		interest_rate = bank.optimalBorrowRate.add(
+			surplusUtilization.mul(borrowRateSlope).div(BANK_UTILIZATION_PRECISION)
+		);
+	} else {
+		const borrowRateSlope = bank.optimalBorrowRate
+			.mul(BANK_UTILIZATION_PRECISION)
+			.div(BANK_UTILIZATION_PRECISION.sub(bank.optimalUtilization));
+
+		interest_rate = utilization
+			.mul(borrowRateSlope)
+			.div(BANK_UTILIZATION_PRECISION);
+	}
+
+	const timeSinceLastUpdate = now.sub(bank.lastUpdated);
+
+	const modifiedBorrowRate = interest_rate.mul(timeSinceLastUpdate);
+
+	const modifiedDepositRate = modifiedBorrowRate
+		.mul(utilization)
+		.div(BANK_UTILIZATION_PRECISION);
+
+	const borrowInterest = bank.cumulativeBorrowInterest
+		.mul(modifiedBorrowRate)
+		.div(ONE_YEAR)
+		.div(BANK_INTEREST_PRECISION)
+		.add(ONE);
+	const depositInterest = bank.cumulativeDepositInterest
+		.mul(modifiedDepositRate)
+		.div(ONE_YEAR)
+		.div(BANK_INTEREST_PRECISION);
+
+	return { borrowInterest, depositInterest };
+}

package/src/math/conversion.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToNumber = void 0;
+const numericConstants_1 = require("../constants/numericConstants");
+const convertToNumber = (bigNumber, precision = numericConstants_1.MARK_PRICE_PRECISION) => {
+    if (!bigNumber)
+        return 0;
+    return (bigNumber.div(precision).toNumber() +
+        bigNumber.mod(precision).toNumber() / precision.toNumber());
+};
+exports.convertToNumber = convertToNumber;

package/src/math/conversion.ts

@@ -1,8 +1,5 @@
 import { BN } from '../';
-import {
-	MARK_PRICE_PRECISION,
-	PEG_PRECISION,
-} from '../constants/numericConstants';
+import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
 
 export const convertToNumber = (
 	bigNumber: BN,
@@ -14,10 +11,3 @@ export const convertToNumber = (
 		bigNumber.mod(precision).toNumber() / precision.toNumber()
 	);
 };
-
-export const convertBaseAssetAmountToNumber = (baseAssetAmount: BN) => {
-	return convertToNumber(
-		baseAssetAmount,
-		MARK_PRICE_PRECISION.mul(PEG_PRECISION)
-	);
-};

package/src/math/funding.js

@@ -0,0 +1,248 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFundingPool = exports.calculateLongShortFundingRateAndLiveTwaps = exports.calculateLongShortFundingRate = exports.calculateEstimatedFundingRate = exports.calculateAllEstimatedFundingRate = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const numericConstants_1 = require("../constants/numericConstants");
+const market_1 = require("./market");
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // periodAdjustment
+        // 	1: hourly
+        //  24: daily
+        //  24 * 365.25: annualized
+        const secondsInHour = new anchor_1.BN(3600);
+        const hoursInDay = new anchor_1.BN(24);
+        const ONE = new anchor_1.BN(1);
+        if (!market.initialized) {
+            return [numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO, numericConstants_1.ZERO];
+        }
+        const payFreq = new anchor_1.BN(market.amm.fundingPeriod);
+        // todo: sufficiently differs from blockchain timestamp?
+        const now = new anchor_1.BN((Date.now() / 1000).toFixed(0));
+        const timeSinceLastUpdate = now.sub(market.amm.lastFundingRateTs);
+        // calculate real-time mark twap
+        const lastMarkTwapWithMantissa = market.amm.lastMarkPriceTwap;
+        const lastMarkPriceTwapTs = market.amm.lastMarkPriceTwapTs;
+        const timeSinceLastMarkChange = now.sub(lastMarkPriceTwapTs);
+        const markTwapTimeSinceLastUpdate = anchor_1.BN.max(secondsInHour, anchor_1.BN.max(numericConstants_1.ZERO, secondsInHour.sub(timeSinceLastMarkChange)));
+        const baseAssetPriceWithMantissa = market_1.calculateMarkPrice(market, oraclePriceData);
+        const markTwapWithMantissa = markTwapTimeSinceLastUpdate
+            .mul(lastMarkTwapWithMantissa)
+            .add(timeSinceLastMarkChange.mul(baseAssetPriceWithMantissa))
+            .div(timeSinceLastMarkChange.add(markTwapTimeSinceLastUpdate));
+        // calculate real-time (predicted) oracle twap
+        // note: oracle twap depends on `when the chord is struck` (market is trade)
+        const lastOracleTwapWithMantissa = market.amm.lastOraclePriceTwap;
+        const lastOraclePriceTwapTs = market.amm.lastOraclePriceTwapTs;
+        const oracleInvalidDuration = anchor_1.BN.max(numericConstants_1.ZERO, lastMarkPriceTwapTs.sub(lastOraclePriceTwapTs));
+        const timeSinceLastOracleTwapUpdate = now.sub(lastOraclePriceTwapTs);
+        const oracleTwapTimeSinceLastUpdate = anchor_1.BN.max(ONE, anchor_1.BN.min(secondsInHour, anchor_1.BN.max(ONE, secondsInHour.sub(timeSinceLastOracleTwapUpdate))));
+        let oracleTwapWithMantissa = lastOracleTwapWithMantissa;
+        // if passing live oracle data, improve predicted calc estimate
+        if (oraclePriceData) {
+            const oraclePrice = oraclePriceData.price;
+            const oracleLiveVsTwap = oraclePrice
+                .sub(lastOracleTwapWithMantissa)
+                .abs()
+                .mul(numericConstants_1.MARK_PRICE_PRECISION)
+                .mul(new anchor_1.BN(100))
+                .div(lastOracleTwapWithMantissa);
+            // verify pyth live input is within 10% of last twap for live update
+            if (oracleLiveVsTwap.lte(numericConstants_1.MARK_PRICE_PRECISION.mul(new anchor_1.BN(10)))) {
+                oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
+                    .mul(lastOracleTwapWithMantissa)
+                    .add(timeSinceLastMarkChange.mul(oraclePrice))
+                    .div(timeSinceLastMarkChange.add(oracleTwapTimeSinceLastUpdate));
+            }
+        }
+        const shrunkLastOracleTwapwithMantissa = oracleTwapTimeSinceLastUpdate
+            .mul(lastOracleTwapWithMantissa)
+            .add(oracleInvalidDuration.mul(lastMarkTwapWithMantissa))
+            .div(oracleTwapTimeSinceLastUpdate.add(oracleInvalidDuration));
+        const twapSpread = lastMarkTwapWithMantissa.sub(shrunkLastOracleTwapwithMantissa);
+        const twapSpreadPct = twapSpread
+            .mul(numericConstants_1.MARK_PRICE_PRECISION)
+            .mul(new anchor_1.BN(100))
+            .div(shrunkLastOracleTwapwithMantissa);
+        const lowerboundEst = twapSpreadPct
+            .mul(payFreq)
+            .mul(anchor_1.BN.min(secondsInHour, timeSinceLastUpdate))
+            .mul(periodAdjustment)
+            .div(secondsInHour)
+            .div(secondsInHour)
+            .div(hoursInDay);
+        const interpEst = twapSpreadPct.mul(periodAdjustment).div(hoursInDay);
+        const interpRateQuote = twapSpreadPct
+            .mul(periodAdjustment)
+            .div(hoursInDay)
+            .div(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION));
+        let feePoolSize = calculateFundingPool(market);
+        if (interpRateQuote.lt(new anchor_1.BN(0))) {
+            feePoolSize = feePoolSize.mul(new anchor_1.BN(-1));
+        }
+        let cappedAltEst;
+        let largerSide;
+        let smallerSide;
+        if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+            largerSide = market.baseAssetAmountLong.abs();
+            smallerSide = market.baseAssetAmountShort.abs();
+            if (twapSpread.gt(new anchor_1.BN(0))) {
+                return [
+                    markTwapWithMantissa,
+                    oracleTwapWithMantissa,
+                    lowerboundEst,
+                    interpEst,
+                    interpEst,
+                ];
+            }
+        }
+        else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+            largerSide = market.baseAssetAmountShort.abs();
+            smallerSide = market.baseAssetAmountLong.abs();
+            if (twapSpread.lt(new anchor_1.BN(0))) {
+                return [
+                    markTwapWithMantissa,
+                    oracleTwapWithMantissa,
+                    lowerboundEst,
+                    interpEst,
+                    interpEst,
+                ];
+            }
+        }
+        else {
+            return [
+                markTwapWithMantissa,
+                oracleTwapWithMantissa,
+                lowerboundEst,
+                interpEst,
+                interpEst,
+            ];
+        }
+        if (largerSide.gt(numericConstants_1.ZERO)) {
+            // funding smaller flow
+            cappedAltEst = smallerSide.mul(twapSpread).div(hoursInDay);
+            const feePoolTopOff = feePoolSize
+                .mul(numericConstants_1.MARK_PRICE_PRECISION.div(numericConstants_1.QUOTE_PRECISION))
+                .mul(numericConstants_1.AMM_RESERVE_PRECISION);
+            cappedAltEst = cappedAltEst.add(feePoolTopOff).div(largerSide);
+            cappedAltEst = cappedAltEst
+                .mul(numericConstants_1.MARK_PRICE_PRECISION)
+                .mul(new anchor_1.BN(100))
+                .div(oracleTwapWithMantissa)
+                .mul(periodAdjustment);
+            if (cappedAltEst.abs().gte(interpEst.abs())) {
+                cappedAltEst = interpEst;
+            }
+        }
+        else {
+            cappedAltEst = interpEst;
+        }
+        return [
+            markTwapWithMantissa,
+            oracleTwapWithMantissa,
+            lowerboundEst,
+            cappedAltEst,
+            interpEst,
+        ];
+    });
+}
+exports.calculateAllEstimatedFundingRate = calculateAllEstimatedFundingRate;
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @param estimationMethod
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateEstimatedFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1), estimationMethod) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [_1, _2, lowerboundEst, cappedAltEst, interpEst] = yield calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
+        if (estimationMethod == 'lowerbound') {
+            //assuming remaining funding period has no gap
+            return lowerboundEst;
+        }
+        else if (estimationMethod == 'capped') {
+            return cappedAltEst;
+        }
+        else {
+            return interpEst;
+        }
+    });
+}
+exports.calculateEstimatedFundingRate = calculateEstimatedFundingRate;
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateLongShortFundingRate(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [_1, _2, _, cappedAltEst, interpEst] = yield calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
+        if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort)) {
+            return [cappedAltEst, interpEst];
+        }
+        else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort)) {
+            return [interpEst, cappedAltEst];
+        }
+        else {
+            return [interpEst, interpEst];
+        }
+    });
+}
+exports.calculateLongShortFundingRate = calculateLongShortFundingRate;
+/**
+ *
+ * @param market
+ * @param oraclePriceData
+ * @param periodAdjustment
+ * @returns Estimated funding rate. : Precision //TODO-PRECISION
+ */
+function calculateLongShortFundingRateAndLiveTwaps(market, oraclePriceData, periodAdjustment = new anchor_1.BN(1)) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [markTwapLive, oracleTwapLive, _2, cappedAltEst, interpEst] = yield calculateAllEstimatedFundingRate(market, oraclePriceData, periodAdjustment);
+        if (market.baseAssetAmountLong.gt(market.baseAssetAmountShort.abs())) {
+            return [markTwapLive, oracleTwapLive, cappedAltEst, interpEst];
+        }
+        else if (market.baseAssetAmountLong.lt(market.baseAssetAmountShort.abs())) {
+            return [markTwapLive, oracleTwapLive, interpEst, cappedAltEst];
+        }
+        else {
+            return [markTwapLive, oracleTwapLive, interpEst, interpEst];
+        }
+    });
+}
+exports.calculateLongShortFundingRateAndLiveTwaps = calculateLongShortFundingRateAndLiveTwaps;
+/**
+ *
+ * @param market
+ * @returns Estimated fee pool size
+ */
+function calculateFundingPool(market) {
+    // todo
+    const totalFeeLB = market.amm.totalExchangeFee.div(new anchor_1.BN(2));
+    const feePool = anchor_1.BN.max(numericConstants_1.ZERO, market.amm.totalFeeMinusDistributions
+        .sub(totalFeeLB)
+        .mul(new anchor_1.BN(1))
+        .div(new anchor_1.BN(3)));
+    return feePool;
+}
+exports.calculateFundingPool = calculateFundingPool;

package/src/math/funding.ts

@@ -5,7 +5,7 @@ import {
 	QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
-import { Market } from '../types';
+import { MarketAccount } from '../types';
 import { calculateMarkPrice } from './market';
 import { OraclePriceData } from '../oracles/types';
 
@@ -17,7 +17,7 @@ import { OraclePriceData } from '../oracles/types';
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateAllEstimatedFundingRate(
-	market: Market,
+	market: MarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN, BN]> {
@@ -48,7 +48,10 @@ export async function calculateAllEstimatedFundingRate(
 		secondsInHour,
 		BN.max(ZERO, secondsInHour.sub(timeSinceLastMarkChange))
 	);
-	const baseAssetPriceWithMantissa = calculateMarkPrice(market);
+	const baseAssetPriceWithMantissa = calculateMarkPrice(
+		market,
+		oraclePriceData
+	);
 
 	const markTwapWithMantissa = markTwapTimeSinceLastUpdate
 		.mul(lastMarkTwapWithMantissa)
@@ -205,7 +208,7 @@ export async function calculateAllEstimatedFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateEstimatedFundingRate(
-	market: Market,
+	market: MarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1),
 	estimationMethod?: 'interpolated' | 'lowerbound' | 'capped'
@@ -235,7 +238,7 @@ export async function calculateEstimatedFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateLongShortFundingRate(
-	market: Market,
+	market: MarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN]> {
@@ -263,7 +266,7 @@ export async function calculateLongShortFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateLongShortFundingRateAndLiveTwaps(
-	market: Market,
+	market: MarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN]> {
@@ -288,14 +291,14 @@ export async function calculateLongShortFundingRateAndLiveTwaps(
  * @param market
  * @returns Estimated fee pool size
  */
-export function calculateFundingPool(market: Market): BN {
+export function calculateFundingPool(market: MarketAccount): BN {
 	// todo
-	const totalFeeLB = market.amm.totalFee.div(new BN(2));
+	const totalFeeLB = market.amm.totalExchangeFee.div(new BN(2));
 	const feePool = BN.max(
 		ZERO,
 		market.amm.totalFeeMinusDistributions
 			.sub(totalFeeLB)
-			.mul(new BN(2))
+			.mul(new BN(1))
 			.div(new BN(3))
 	);
 	return feePool;

package/src/math/market.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateOracleSpread = exports.calculateMarkOracleSpread = exports.calculateNewMarketAfterTrade = exports.calculateAskPrice = exports.calculateBidPrice = exports.calculateMarkPrice = void 0;
+const types_1 = require("../types");
+const amm_1 = require("./amm");
+/**
+ * Calculates market mark price
+ *
+ * @param market
+ * @return markPrice : Precision MARK_PRICE_PRECISION
+ */
+function calculateMarkPrice(market, oraclePriceData) {
+    const newAmm = amm_1.calculateUpdatedAMM(market.amm, oraclePriceData);
+    return amm_1.calculatePrice(newAmm.baseAssetReserve, newAmm.quoteAssetReserve, newAmm.pegMultiplier);
+}
+exports.calculateMarkPrice = calculateMarkPrice;
+/**
+ * Calculates market bid price
+ *
+ * @param market
+ * @return bidPrice : Precision MARK_PRICE_PRECISION
+ */
+function calculateBidPrice(market, oraclePriceData) {
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, types_1.PositionDirection.SHORT, oraclePriceData);
+    return amm_1.calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
+}
+exports.calculateBidPrice = calculateBidPrice;
+/**
+ * Calculates market ask price
+ *
+ * @param market
+ * @return bidPrice : Precision MARK_PRICE_PRECISION
+ */
+function calculateAskPrice(market, oraclePriceData) {
+    const { baseAssetReserve, quoteAssetReserve, newPeg } = amm_1.calculateUpdatedAMMSpreadReserves(market.amm, types_1.PositionDirection.LONG, oraclePriceData);
+    return amm_1.calculatePrice(baseAssetReserve, quoteAssetReserve, newPeg);
+}
+exports.calculateAskPrice = calculateAskPrice;
+function calculateNewMarketAfterTrade(baseAssetAmount, direction, market) {
+    const [newQuoteAssetReserve, newBaseAssetReserve] = amm_1.calculateAmmReservesAfterSwap(market.amm, 'base', baseAssetAmount.abs(), amm_1.getSwapDirection('base', direction));
+    const newAmm = Object.assign({}, market.amm);
+    const newMarket = Object.assign({}, market);
+    newMarket.amm = newAmm;
+    newMarket.amm.quoteAssetReserve = newQuoteAssetReserve;
+    newMarket.amm.baseAssetReserve = newBaseAssetReserve;
+    return newMarket;
+}
+exports.calculateNewMarketAfterTrade = calculateNewMarketAfterTrade;
+function calculateMarkOracleSpread(market, oraclePriceData) {
+    const markPrice = calculateMarkPrice(market, oraclePriceData);
+    return calculateOracleSpread(markPrice, oraclePriceData);
+}
+exports.calculateMarkOracleSpread = calculateMarkOracleSpread;
+function calculateOracleSpread(price, oraclePriceData) {
+    return price.sub(oraclePriceData.price);
+}
+exports.calculateOracleSpread = calculateOracleSpread;