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

package/src/idl/{mock_usdc_faucet.json → token_faucet.json}

@@ -1,23 +1,23 @@
 {
-  "version": "0.0.0",
-  "name": "mock_usdc_faucet",
+  "version": "0.1.0",
+  "name": "token_faucet",
   "instructions": [
     {
       "name": "initialize",
       "accounts": [
         {
-          "name": "mockUsdcFaucetState",
+          "name": "faucetConfig",
           "isMut": true,
           "isSigner": false
         },
         {
           "name": "admin",
-          "isMut": false,
+          "isMut": true,
           "isSigner": true
         },
         {
           "name": "mintAccount",
-          "isMut": false,
+          "isMut": true,
           "isSigner": false
         },
         {
@@ -29,20 +29,20 @@
           "name": "systemProgram",
           "isMut": false,
           "isSigner": false
-        }
-      ],
-      "args": [
+        },
         {
-          "name": "mockUsdcFaucetNonce",
-          "type": "u8"
+          "name": "tokenProgram",
+          "isMut": false,
+          "isSigner": false
         }
-      ]
+      ],
+      "args": []
     },
     {
       "name": "mintToUser",
       "accounts": [
         {
-          "name": "mockUsdcFaucetState",
+          "name": "faucetConfig",
           "isMut": false,
           "isSigner": false
         },
@@ -73,11 +73,42 @@
           "type": "u64"
         }
       ]
+    },
+    {
+      "name": "transferMintAuthority",
+      "accounts": [
+        {
+          "name": "faucetConfig",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "admin",
+          "isMut": true,
+          "isSigner": true
+        },
+        {
+          "name": "mintAccount",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "mintAuthority",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "tokenProgram",
+          "isMut": false,
+          "isSigner": false
+        }
+      ],
+      "args": []
     }
   ],
   "accounts": [
     {
-      "name": "MockUSDCFaucetState",
+      "name": "FaucetConfig",
       "type": {
         "kind": "struct",
         "fields": [
@@ -103,17 +134,9 @@
   ],
   "errors": [
     {
-      "code": 300,
+      "code": 6000,
       "name": "InvalidMintAccountAuthority",
       "msg": "Program not mint authority"
-    },
-    {
-      "code": 301,
-      "name": "Unauthorized",
-      "msg": "Signer must be MockUSDCFaucet admin"
     }
-  ],
-  "metadata": {
-    "address": "2z2DLVD3tBWc86pbvvy5qN31v1NXprM6zA5MDr2FMx64"
-  }
+  ]
 }

package/src/index.ts

@@ -1,30 +1,38 @@
 import { BN } from '@project-serum/anchor';
 import { PublicKey } from '@solana/web3.js';
+import pyth from '@pythnetwork/client';
 
-export * from './mockUSDCFaucet';
+export * from './tokenFaucet';
 export * from './oracles/types';
 export * from './oracles/pythClient';
 export * from './oracles/switchboardClient';
 export * from './types';
-export * from './constants/markets';
+export * from './constants/perpMarkets';
 export * from './accounts/fetch';
 export * from './accounts/webSocketClearingHouseAccountSubscriber';
 export * from './accounts/bulkAccountLoader';
 export * from './accounts/bulkUserSubscription';
+export * from './accounts/bulkUserStatsSubscription';
 export * from './accounts/pollingClearingHouseAccountSubscriber';
 export * from './accounts/pollingOracleSubscriber';
 export * from './accounts/pollingTokenAccountSubscriber';
+export * from './accounts/pollingUserAccountSubscriber';
+export * from './accounts/pollingUserStatsAccountSubscriber';
 export * from './accounts/types';
 export * from './addresses/pda';
 export * from './admin';
 export * from './clearingHouseUser';
 export * from './clearingHouseUserConfig';
+export * from './clearingHouseUserStats';
+export * from './clearingHouseUserStatsConfig';
 export * from './clearingHouse';
 export * from './factory/oracleClient';
 export * from './factory/bigNum';
 export * from './events/types';
 export * from './events/eventSubscriber';
+export * from './events/fetchLogs';
 export * from './math/auction';
+export * from './math/spotMarket';
 export * from './math/conversion';
 export * from './math/funding';
 export * from './math/market';
@@ -34,7 +42,8 @@ export * from './math/amm';
 export * from './math/trade';
 export * from './math/orders';
 export * from './math/repeg';
-export * from './orders';
+export * from './math/margin';
+export * from './math/insurance';
 export * from './orderParams';
 export * from './slot/SlotSubscriber';
 export * from './wallet';
@@ -42,11 +51,17 @@ export * from './types';
 export * from './math/utils';
 export * from './config';
 export * from './constants/numericConstants';
+export * from './serum/serumSubscriber';
 export * from './tx/retryTxSender';
 export * from './util/computeUnits';
 export * from './util/tps';
-export * from './math/bankBalance';
-export * from './constants/banks';
+export * from './math/spotBalance';
+export * from './constants/spotMarkets';
 export * from './clearingHouseConfig';
+export * from './dlob/DLOB';
+export * from './dlob/DLOBNode';
+export * from './dlob/NodeList';
+export * from './userMap/userMap';
+export * from './userMap/userStatsMap';
 
-export { BN, PublicKey };
+export { BN, PublicKey, pyth };

package/src/math/amm.ts

@@ -1,7 +1,7 @@
 import { BN } from '@project-serum/anchor';
 import {
 	AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO,
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	PEG_PRECISION,
 	ZERO,
 	BID_ASK_SPREAD_PRECISION,
@@ -15,11 +15,11 @@ import {
 	AMM,
 	PositionDirection,
 	SwapDirection,
-	MarketAccount,
+	PerpMarketAccount,
 	isVariant,
 } from '../types';
 import { assert } from '../assert/assert';
-import { squareRootBN } from '..';
+import { squareRootBN, standardizeBaseAssetAmount } from '..';
 
 import { OraclePriceData } from '../oracles/types';
 import {
@@ -33,11 +33,14 @@ export function calculatePegFromTargetPrice(
 	baseAssetReserve: BN,
 	quoteAssetReserve: BN
 ): BN {
-	return targetPrice
-		.mul(baseAssetReserve)
-		.div(quoteAssetReserve)
-		.add(PRICE_DIV_PEG.div(new BN(2)))
-		.div(PRICE_DIV_PEG);
+	return BN.max(
+		targetPrice
+			.mul(baseAssetReserve)
+			.div(quoteAssetReserve)
+			.add(PRICE_DIV_PEG.div(new BN(2)))
+			.div(PRICE_DIV_PEG),
+		ONE
+	);
 }
 
 export function calculateOptimalPegAndBudget(
@@ -68,6 +71,7 @@ export function calculateOptimalPegAndBudget(
 		let newOptimalPeg: BN;
 		let newBudget: BN;
 		const targetPriceGap = markPriceBefore.sub(targetPrice);
+
 		if (targetPriceGap.abs().gt(maxPriceSpread)) {
 			const markAdj = targetPriceGap.abs().sub(maxPriceSpread);
 
@@ -238,7 +242,7 @@ export function calculateBidAskPrice(
  * @param baseAssetReserves
  * @param quoteAssetReserves
  * @param pegMultiplier
- * @returns price : Precision MARK_PRICE_PRECISION
+ * @returns price : Precision PRICE_PRECISION
  */
 export function calculatePrice(
 	baseAssetReserves: BN,
@@ -250,7 +254,7 @@ export function calculatePrice(
 	}
 
 	return quoteAssetReserves
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(pegMultiplier)
 		.div(PEG_PRECISION)
 		.div(baseAssetReserves);
@@ -304,6 +308,54 @@ export function calculateAmmReservesAfterSwap(
 	return [newQuoteAssetReserve, newBaseAssetReserve];
 }
 
+export function calculateMarketOpenBidAsk(
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN
+): [BN, BN] {
+	// open orders
+	let openAsks;
+	if (maxBaseAssetReserve > baseAssetReserve) {
+		openAsks = maxBaseAssetReserve.sub(baseAssetReserve).mul(new BN(-1));
+	} else {
+		openAsks = ZERO;
+	}
+
+	let openBids;
+	if (minBaseAssetReserve < baseAssetReserve) {
+		openBids = baseAssetReserve.sub(minBaseAssetReserve);
+	} else {
+		openBids = ZERO;
+	}
+	return [openBids, openAsks];
+}
+
+export function calculateInventoryScale(
+	netBaseAssetAmount: BN,
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN
+): number {
+	// inventory skew
+	const [openBids, openAsks] = calculateMarketOpenBidAsk(
+		baseAssetReserve,
+		minBaseAssetReserve,
+		maxBaseAssetReserve
+	);
+
+	const minSideLiquidity = BN.max(
+		new BN(1),
+		BN.min(openBids.abs(), openAsks.abs())
+	);
+	const inventoryScale =
+		BN.min(netBaseAssetAmount.abs(), minSideLiquidity)
+			.mul(BID_ASK_SPREAD_PRECISION.mul(new BN(10)))
+			.div(minSideLiquidity)
+			.toNumber() / BID_ASK_SPREAD_PRECISION.toNumber();
+
+	return inventoryScale;
+}
+
 export function calculateEffectiveLeverage(
 	baseSpread: number,
 	quoteAssetReserve: BN,
@@ -321,7 +373,7 @@ export function calculateEffectiveLeverage(
 
 	const localBaseAssetValue = netBaseAssetAmount
 		.mul(markPrice)
-		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
+		.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(PRICE_PRECISION));
 
 	const effectiveLeverage =
 		localBaseAssetValue.sub(netBaseAssetValue).toNumber() /
@@ -349,7 +401,10 @@ export function calculateSpreadBN(
 	pegMultiplier: BN,
 	netBaseAssetAmount: BN,
 	markPrice: BN,
-	totalFeeMinusDistributions: BN
+	totalFeeMinusDistributions: BN,
+	baseAssetReserve: BN,
+	minBaseAssetReserve: BN,
+	maxBaseAssetReserve: BN
 ): [number, number] {
 	let longSpread = baseSpread / 2;
 	let shortSpread = baseSpread / 2;
@@ -366,10 +421,27 @@ export function calculateSpreadBN(
 		);
 	}
 
-	const maxTargetSpread: number = maxSpread;
+	const maxTargetSpread: number = Math.max(
+		maxSpread,
+		lastOracleMarkSpreadPct.abs().toNumber()
+	);
 
 	const MAX_INVENTORY_SKEW = 5;
 
+	const inventoryScale = calculateInventoryScale(
+		netBaseAssetAmount,
+		baseAssetReserve,
+		minBaseAssetReserve,
+		maxBaseAssetReserve
+	);
+	const inventorySpreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + inventoryScale);
+
+	if (netBaseAssetAmount.gt(ZERO)) {
+		longSpread *= inventorySpreadScale;
+	} else if (netBaseAssetAmount.lt(ZERO)) {
+		shortSpread *= inventorySpreadScale;
+	}
+
 	const effectiveLeverage = calculateEffectiveLeverage(
 		baseSpread,
 		quoteAssetReserve,
@@ -411,10 +483,8 @@ export function calculateSpread(
 	direction: PositionDirection,
 	oraclePriceData: OraclePriceData
 ): number {
-	let spread = amm.baseSpread / 2;
-
 	if (amm.baseSpread == 0 || amm.curveUpdateIntensity == 0) {
-		return spread;
+		return amm.baseSpread / 2;
 	}
 
 	const markPrice = calculatePrice(
@@ -435,54 +505,28 @@ export function calculateSpread(
 		.mul(BID_ASK_SPREAD_PRECISION)
 		.div(markPrice);
 
-	// oracle retreat
-	if (
-		(isVariant(direction, 'long') && targetMarkSpreadPct.lt(ZERO)) ||
-		(isVariant(direction, 'short') && targetMarkSpreadPct.gt(ZERO))
-	) {
-		spread = Math.max(
-			spread,
-			targetMarkSpreadPct.abs().toNumber() + confIntervalPct.abs().toNumber()
-		);
-	}
-
-	// inventory skew
-	const MAX_INVENTORY_SKEW = 5;
-	if (
-		(amm.netBaseAssetAmount.gt(ZERO) && isVariant(direction, 'long')) ||
-		(amm.netBaseAssetAmount.lt(ZERO) && isVariant(direction, 'short')) ||
-		amm.totalFeeMinusDistributions.eq(ZERO)
-	) {
-		const netCostBasis = amm.quoteAssetAmountLong.sub(
-			amm.quoteAssetAmountShort
-		);
-		const netBaseAssetValue = amm.quoteAssetReserve
-			.sub(amm.terminalQuoteAssetReserve)
-			.mul(amm.pegMultiplier)
-			.div(AMM_TIMES_PEG_TO_QUOTE_PRECISION_RATIO);
-
-		const localBaseAssetValue = amm.netBaseAssetAmount
-			.mul(markPrice)
-			.div(AMM_TO_QUOTE_PRECISION_RATIO.mul(MARK_PRICE_PRECISION));
-		const netPnl = netBaseAssetValue.sub(netCostBasis);
-		const localPnl = localBaseAssetValue.sub(netCostBasis);
-
-		let effectiveLeverage = MAX_INVENTORY_SKEW;
-		if (amm.totalFeeMinusDistributions.gt(ZERO)) {
-			effectiveLeverage =
-				localPnl.sub(netPnl).toNumber() /
-				(amm.totalFeeMinusDistributions.toNumber() + 1);
-		}
+	const [longSpread, shortSpread] = calculateSpreadBN(
+		amm.baseSpread,
+		targetMarkSpreadPct,
+		confIntervalPct,
+		amm.maxSpread,
+		amm.quoteAssetReserve,
+		amm.terminalQuoteAssetReserve,
+		amm.pegMultiplier,
+		amm.netBaseAssetAmount,
+		markPrice,
+		amm.totalFeeMinusDistributions,
+		amm.baseAssetReserve,
+		amm.minBaseAssetReserve,
+		amm.maxBaseAssetReserve
+	);
 
-		let spreadScale = Math.min(MAX_INVENTORY_SKEW, 1 + effectiveLeverage);
-		const maxTargetSpread = BID_ASK_SPREAD_PRECISION.toNumber() / 50; // 2%
-		// cap the scale to attempt to only scale up to maxTargetSpread
-		// always let the oracle retreat methods go through 100%
-		if (spreadScale * spread > maxTargetSpread) {
-			spreadScale = Math.max(1.05, maxTargetSpread / spread);
-		}
+	let spread: number;
 
-		spread *= spreadScale;
+	if (isVariant(direction, 'long')) {
+		spread = longSpread;
+	} else {
+		spread = shortSpread;
 	}
 
 	return spread;
@@ -573,9 +617,9 @@ export function getSwapDirection(
  * Helper function calculating terminal price of amm
  *
  * @param market
- * @returns cost : Precision MARK_PRICE_PRECISION
+ * @returns cost : Precision PRICE_PRECISION
  */
-export function calculateTerminalPrice(market: MarketAccount) {
+export function calculateTerminalPrice(market: PerpMarketAccount) {
 	const directionToClose = market.amm.netBaseAssetAmount.gt(ZERO)
 		? PositionDirection.SHORT
 		: PositionDirection.LONG;
@@ -589,7 +633,7 @@ export function calculateTerminalPrice(market: MarketAccount) {
 		);
 
 	const terminalPrice = newQuoteAssetReserve
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(market.amm.pegMultiplier)
 		.div(PEG_PRECISION)
 		.div(newBaseAssetReserve);
@@ -606,7 +650,7 @@ export function calculateMaxBaseAssetAmountToTrade(
 	const invariant = amm.sqrtK.mul(amm.sqrtK);
 
 	const newBaseAssetReserveSquared = invariant
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(amm.pegMultiplier)
 		.div(limit_price)
 		.div(PEG_PRECISION);
@@ -650,3 +694,29 @@ export function calculateQuoteAssetAmountSwapped(
 
 	return quoteAssetAmount;
 }
+
+export function calculateMaxBaseAssetAmountFillable(
+	amm: AMM,
+	orderDirection: PositionDirection
+): BN {
+	const maxFillSize = amm.baseAssetReserve.div(
+		new BN(amm.maxBaseAssetAmountRatio)
+	);
+	let maxBaseAssetAmountOnSide: BN;
+	if (isVariant(orderDirection, 'long')) {
+		maxBaseAssetAmountOnSide = BN.max(
+			ZERO,
+			amm.baseAssetReserve.sub(amm.minBaseAssetReserve)
+		);
+	} else {
+		maxBaseAssetAmountOnSide = BN.max(
+			ZERO,
+			amm.maxBaseAssetReserve.sub(amm.baseAssetReserve)
+		);
+	}
+
+	return standardizeBaseAssetAmount(
+		BN.min(maxFillSize, maxBaseAssetAmountOnSide),
+		amm.baseAssetAmountStepSize
+	);
+}

package/src/math/auction.ts

@@ -2,7 +2,11 @@ import { isVariant, Order } from '../types';
 import { BN, ZERO } from '../.';
 
 export function isAuctionComplete(order: Order, slot: number): boolean {
-	return new BN(slot).sub(order.slot).gte(new BN(order.auctionDuration));
+	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 {

package/src/math/conversion.ts

@@ -1,9 +1,9 @@
 import { BN } from '../';
-import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
+import { PRICE_PRECISION } from '../constants/numericConstants';
 
 export const convertToNumber = (
 	bigNumber: BN,
-	precision: BN = MARK_PRICE_PRECISION
+	precision: BN = PRICE_PRECISION
 ) => {
 	if (!bigNumber) return 0;
 	return (

package/src/math/funding.ts

@@ -1,12 +1,12 @@
 import { BN } from '@project-serum/anchor';
 import {
 	AMM_RESERVE_PRECISION,
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	QUOTE_PRECISION,
 	ZERO,
 } from '../constants/numericConstants';
-import { MarketAccount } from '../types';
-import { calculateMarkPrice } from './market';
+import { PerpMarketAccount, isVariant } from '../types';
+import { calculateReservePrice } 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: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN, BN]> {
@@ -29,7 +29,7 @@ export async function calculateAllEstimatedFundingRate(
 	const hoursInDay = new BN(24);
 	const ONE = new BN(1);
 
-	if (!market.initialized) {
+	if (isVariant(market.status, 'uninitialized')) {
 		return [ZERO, ZERO, ZERO, ZERO, ZERO];
 	}
 
@@ -48,7 +48,7 @@ export async function calculateAllEstimatedFundingRate(
 		secondsInHour,
 		BN.max(ZERO, secondsInHour.sub(timeSinceLastMarkChange))
 	);
-	const baseAssetPriceWithMantissa = calculateMarkPrice(
+	const baseAssetPriceWithMantissa = calculateReservePrice(
 		market,
 		oraclePriceData
 	);
@@ -60,8 +60,10 @@ export async function calculateAllEstimatedFundingRate(
 
 	// 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 lastOracleTwapWithMantissa =
+		market.amm.historicalOracleData.lastOraclePriceTwap;
+	const lastOraclePriceTwapTs =
+		market.amm.historicalOracleData.lastOraclePriceTwapTs;
 
 	const oracleInvalidDuration = BN.max(
 		ZERO,
@@ -85,12 +87,12 @@ export async function calculateAllEstimatedFundingRate(
 		const oracleLiveVsTwap = oraclePrice
 			.sub(lastOracleTwapWithMantissa)
 			.abs()
-			.mul(MARK_PRICE_PRECISION)
+			.mul(PRICE_PRECISION)
 			.mul(new BN(100))
 			.div(lastOracleTwapWithMantissa);
 
 		// verify pyth live input is within 10% of last twap for live update
-		if (oracleLiveVsTwap.lte(MARK_PRICE_PRECISION.mul(new BN(10)))) {
+		if (oracleLiveVsTwap.lte(PRICE_PRECISION.mul(new BN(10)))) {
 			oracleTwapWithMantissa = oracleTwapTimeSinceLastUpdate
 				.mul(lastOracleTwapWithMantissa)
 				.add(timeSinceLastMarkChange.mul(oraclePrice))
@@ -108,7 +110,7 @@ export async function calculateAllEstimatedFundingRate(
 	);
 
 	const twapSpreadPct = twapSpread
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.mul(new BN(100))
 		.div(shrunkLastOracleTwapwithMantissa);
 
@@ -125,7 +127,7 @@ export async function calculateAllEstimatedFundingRate(
 	const interpRateQuote = twapSpreadPct
 		.mul(periodAdjustment)
 		.div(hoursInDay)
-		.div(MARK_PRICE_PRECISION.div(QUOTE_PRECISION));
+		.div(PRICE_PRECISION.div(QUOTE_PRECISION));
 
 	let feePoolSize = calculateFundingPool(market);
 	if (interpRateQuote.lt(new BN(0))) {
@@ -173,12 +175,12 @@ export async function calculateAllEstimatedFundingRate(
 		// funding smaller flow
 		cappedAltEst = smallerSide.mul(twapSpread).div(hoursInDay);
 		const feePoolTopOff = feePoolSize
-			.mul(MARK_PRICE_PRECISION.div(QUOTE_PRECISION))
+			.mul(PRICE_PRECISION.div(QUOTE_PRECISION))
 			.mul(AMM_RESERVE_PRECISION);
 		cappedAltEst = cappedAltEst.add(feePoolTopOff).div(largerSide);
 
 		cappedAltEst = cappedAltEst
-			.mul(MARK_PRICE_PRECISION)
+			.mul(PRICE_PRECISION)
 			.mul(new BN(100))
 			.div(oracleTwapWithMantissa)
 			.mul(periodAdjustment);
@@ -208,7 +210,7 @@ export async function calculateAllEstimatedFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateEstimatedFundingRate(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1),
 	estimationMethod?: 'interpolated' | 'lowerbound' | 'capped'
@@ -238,7 +240,7 @@ export async function calculateEstimatedFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateLongShortFundingRate(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN]> {
@@ -266,7 +268,7 @@ export async function calculateLongShortFundingRate(
  * @returns Estimated funding rate. : Precision //TODO-PRECISION
  */
 export async function calculateLongShortFundingRateAndLiveTwaps(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	oraclePriceData?: OraclePriceData,
 	periodAdjustment: BN = new BN(1)
 ): Promise<[BN, BN, BN, BN]> {
@@ -291,7 +293,7 @@ export async function calculateLongShortFundingRateAndLiveTwaps(
  * @param market
  * @returns Estimated fee pool size
  */
-export function calculateFundingPool(market: MarketAccount): BN {
+export function calculateFundingPool(market: PerpMarketAccount): BN {
 	// todo
 	const totalFeeLB = market.amm.totalExchangeFee.div(new BN(2));
 	const feePool = BN.max(