@drift-labs/sdk 0.2.0-temp.1 → 2.0.0

package/src/math/spotBalance.ts

@@ -0,0 +1,319 @@
+import {
+	SpotMarketAccount,
+	SpotBalanceType,
+	isVariant,
+	MarginCategory,
+} from '../types';
+import { BN } from '@project-serum/anchor';
+import {
+	SPOT_MARKET_UTILIZATION_PRECISION,
+	ONE,
+	TEN,
+	ZERO,
+	SPOT_MARKET_RATE_PRECISION,
+	SPOT_MARKET_WEIGHT_PRECISION,
+	ONE_YEAR,
+	AMM_RESERVE_PRECISION,
+} from '../constants/numericConstants';
+import {
+	calculateSizeDiscountAssetWeight,
+	calculateSizePremiumLiabilityWeight,
+} from './margin';
+import { OraclePriceData } from '../oracles/types';
+
+export function getBalance(
+	tokenAmount: BN,
+	spotMarket: SpotMarketAccount,
+	balanceType: SpotBalanceType
+): BN {
+	const precisionIncrease = TEN.pow(new BN(19 - 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(19 - spotMarket.decimals));
+
+	const cumulativeInterest = isVariant(balanceType, 'deposit')
+		? spotMarket.cumulativeDepositInterest
+		: spotMarket.cumulativeBorrowInterest;
+
+	return balanceAmount.mul(cumulativeInterest).div(precisionDecrease);
+}
+
+export function getSignedTokenAmount(
+	tokenAmount: BN,
+	balanceType: SpotBalanceType
+): BN {
+	if (isVariant(balanceType, 'deposit')) {
+		return tokenAmount;
+	} else {
+		return tokenAmount.abs().neg();
+	}
+}
+
+export function getTokenValue(
+	tokenAmount: BN,
+	spotDecimals: number,
+	oraclePriceData: OraclePriceData
+): BN {
+	if (tokenAmount.eq(ZERO)) {
+		return ZERO;
+	}
+
+	const precisionDecrease = TEN.pow(new BN(spotDecimals));
+
+	return tokenAmount.mul(oraclePriceData.price).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,
+				new BN(spotMarket.imfFactor),
+				new BN(spotMarket.initialAssetWeight)
+			);
+			break;
+		case 'Maintenance':
+			assetWeight = calculateSizeDiscountAssetWeight(
+				sizeInAmmReservePrecision,
+				new BN(spotMarket.imfFactor),
+				new BN(spotMarket.maintenanceAssetWeight)
+			);
+			break;
+		default:
+			assetWeight = new BN(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,
+				new BN(spotMarket.imfFactor),
+				new BN(spotMarket.initialLiabilityWeight),
+				SPOT_MARKET_WEIGHT_PRECISION
+			);
+			break;
+		case 'Maintenance':
+			assetWeight = calculateSizePremiumLiabilityWeight(
+				sizeInAmmReservePrecision,
+				new BN(spotMarket.imfFactor),
+				new BN(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(new BN(bank.optimalUtilization))) {
+		const surplusUtilization = utilization.sub(new BN(bank.optimalUtilization));
+		const borrowRateSlope = new BN(bank.maxBorrowRate - bank.optimalBorrowRate)
+			.mul(SPOT_MARKET_UTILIZATION_PRECISION)
+			.div(
+				SPOT_MARKET_UTILIZATION_PRECISION.sub(new BN(bank.optimalUtilization))
+			);
+
+		interestRate = new BN(bank.optimalBorrowRate).add(
+			surplusUtilization
+				.mul(borrowRateSlope)
+				.div(SPOT_MARKET_UTILIZATION_PRECISION)
+		);
+	} else {
+		const borrowRateSlope = new BN(bank.optimalBorrowRate)
+			.mul(SPOT_MARKET_UTILIZATION_PRECISION)
+			.div(
+				SPOT_MARKET_UTILIZATION_PRECISION.sub(new BN(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_RATE_PRECISION)
+		.add(ONE);
+	const depositInterest = bank.cumulativeDepositInterest
+		.mul(modifiedDepositRate)
+		.div(ONE_YEAR)
+		.div(SPOT_MARKET_RATE_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(sinceStart));
+
+	const depositTokenTwapLive = spotMarket.depositTokenTwap
+		.mul(sinceStart)
+		.add(marketDepositTokenAmount.mul(sinceLast))
+		.div(sinceLast.add(sinceStart));
+
+	const maxBorrowTokens = BN.min(
+		BN.max(
+			marketDepositTokenAmount.div(new BN(6)),
+			borrowTokenTwapLive.add(borrowTokenTwapLive.div(new BN(5)))
+		),
+		marketDepositTokenAmount.sub(marketDepositTokenAmount.div(new BN(5)))
+	); // between ~15-80% 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.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.ts

@@ -0,0 +1,47 @@
+import { SpotMarketAccount, SpotPosition } from '../types';
+import { ZERO } from '../constants/numericConstants';
+import { BN } from '@project-serum/anchor';
+import {
+	getSignedTokenAmount,
+	getTokenAmount,
+	getTokenValue,
+} from './spotBalance';
+import { OraclePriceData } from '../oracles/types';
+
+export function isSpotPositionAvailable(position: SpotPosition): boolean {
+	return position.scaledBalance.eq(ZERO) && position.openOrders === 0;
+}
+
+export function getWorstCaseTokenAmounts(
+	spotPosition: SpotPosition,
+	spotMarketAccount: SpotMarketAccount,
+	oraclePriceData: OraclePriceData
+): [BN, BN] {
+	const tokenAmount = getSignedTokenAmount(
+		getTokenAmount(
+			spotPosition.scaledBalance,
+			spotMarketAccount,
+			spotPosition.balanceType
+		),
+		spotPosition.balanceType
+	);
+
+	const tokenAmountAllBidsFill = tokenAmount.add(spotPosition.openBids);
+	const tokenAmountAllAsksFill = tokenAmount.add(spotPosition.openAsks);
+
+	if (tokenAmountAllAsksFill.abs().gt(tokenAmountAllBidsFill.abs())) {
+		const worstCaseQuoteTokenAmount = getTokenValue(
+			spotPosition.openAsks.neg(),
+			spotMarketAccount.decimals,
+			oraclePriceData
+		);
+		return [tokenAmountAllBidsFill, worstCaseQuoteTokenAmount];
+	} else {
+		const worstCaseQuoteTokenAmount = getTokenValue(
+			spotPosition.openBids.neg(),
+			spotMarketAccount.decimals,
+			oraclePriceData
+		);
+		return [tokenAmountAllAsksFill, worstCaseQuoteTokenAmount];
+	}
+}

package/src/math/trade.ts

@@ -1,8 +1,8 @@
-import { MarketAccount, PositionDirection } from '../types';
+import { PerpMarketAccount, PositionDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
-	MARK_PRICE_PRECISION,
+	PRICE_PRECISION,
 	PEG_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	ZERO,
@@ -10,7 +10,7 @@ import {
 import {
 	calculateBidPrice,
 	calculateAskPrice,
-	calculateMarkPrice,
+	calculateReservePrice,
 } from './market';
 import {
 	calculateAmmReservesAfterSwap,
@@ -48,18 +48,18 @@ export type PriceImpactUnit =
  * @param useSpread whether to consider spread with calculating slippage
  * @return [pctAvgSlippage, pctMaxSlippage, entryPrice, newPrice]
  *
- * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctAvgSlippage' =>  the percentage change to entryPrice (average est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision MARK_PRICE_PRECISION
+ * 'pctMaxSlippage' =>  the percentage change to maxPrice (highest est slippage in execution) : Precision PRICE_PRECISION
  *
- * 'entryPrice' => the average price of the trade : Precision MARK_PRICE_PRECISION
+ * 'entryPrice' => the average price of the trade : Precision PRICE_PRECISION
  *
- * 'newPrice' => the price of the asset after the trade : Precision MARK_PRICE_PRECISION
+ * 'newPrice' => the price of the asset after the trade : Precision PRICE_PRECISION
  */
 export function calculateTradeSlippage(
 	direction: PositionDirection,
 	amount: BN,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	inputAssetType: AssetType = 'quote',
 	oraclePriceData?: OraclePriceData,
 	useSpread = true
@@ -73,7 +73,7 @@ export function calculateTradeSlippage(
 			oldPrice = calculateBidPrice(market, oraclePriceData);
 		}
 	} else {
-		oldPrice = calculateMarkPrice(market, oraclePriceData);
+		oldPrice = calculateReservePrice(market, oraclePriceData);
 	}
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO, oldPrice, oldPrice];
@@ -90,7 +90,7 @@ export function calculateTradeSlippage(
 
 	const entryPrice = acquiredQuoteAssetAmount
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(acquiredBaseReserve.abs());
 
 	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
@@ -121,12 +121,12 @@ export function calculateTradeSlippage(
 
 	const pctMaxSlippage = newPrice
 		.sub(oldPrice)
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(oldPrice)
 		.abs();
 	const pctAvgSlippage = entryPrice
 		.sub(oldPrice)
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(oldPrice)
 		.abs();
 
@@ -147,7 +147,7 @@ export function calculateTradeSlippage(
 export function calculateTradeAcquiredAmounts(
 	direction: PositionDirection,
 	amount: BN,
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	inputAssetType: AssetType = 'quote',
 	oraclePriceData: OraclePriceData,
 	useSpread = true
@@ -177,13 +177,13 @@ export function calculateTradeAcquiredAmounts(
 
 	const acquiredBase = amm.baseAssetReserve.sub(newBaseAssetReserve);
 	const acquiredQuote = amm.quoteAssetReserve.sub(newQuoteAssetReserve);
-	const acquiredQuoteAssetamount = calculateQuoteAssetAmountSwapped(
+	const acquiredQuoteAssetAmount = calculateQuoteAssetAmountSwapped(
 		acquiredQuote.abs(),
 		amm.pegMultiplier,
 		swapDirection
 	);
 
-	return [acquiredBase, acquiredQuote, acquiredQuoteAssetamount];
+	return [acquiredBase, acquiredQuote, acquiredQuoteAssetAmount];
 }
 
 /**
@@ -199,12 +199,12 @@ export function calculateTradeAcquiredAmounts(
  * [
  *   direction => direction of trade required, PositionDirection
  *   tradeSize => size of trade required, TODO-PRECISION
- *   entryPrice => the entry price for the trade, MARK_PRICE_PRECISION
- *   targetPrice => the target price MARK_PRICE_PRECISION
+ *   entryPrice => the entry price for the trade, PRICE_PRECISION
+ *   targetPrice => the target price PRICE_PRECISION
  * ]
  */
 export function calculateTargetPriceTrade(
-	market: MarketAccount,
+	market: PerpMarketAccount,
 	targetPrice: BN,
 	pct: BN = MAXPCT,
 	outputAssetType: AssetType = 'quote',
@@ -215,20 +215,20 @@ export function calculateTargetPriceTrade(
 	assert(targetPrice.gt(ZERO));
 	assert(pct.lte(MAXPCT) && pct.gt(ZERO));
 
-	const markPriceBefore = calculateMarkPrice(market, oraclePriceData);
+	const reservePriceBefore = calculateReservePrice(market, oraclePriceData);
 	const bidPriceBefore = calculateBidPrice(market, oraclePriceData);
 	const askPriceBefore = calculateAskPrice(market, oraclePriceData);
 
 	let direction;
-	if (targetPrice.gt(markPriceBefore)) {
-		const priceGap = targetPrice.sub(markPriceBefore);
+	if (targetPrice.gt(reservePriceBefore)) {
+		const priceGap = targetPrice.sub(reservePriceBefore);
 		const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
-		targetPrice = markPriceBefore.add(priceGapScaled);
+		targetPrice = reservePriceBefore.add(priceGapScaled);
 		direction = PositionDirection.LONG;
 	} else {
-		const priceGap = markPriceBefore.sub(targetPrice);
+		const priceGap = reservePriceBefore.sub(targetPrice);
 		const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
-		targetPrice = markPriceBefore.sub(priceGapScaled);
+		targetPrice = reservePriceBefore.sub(priceGapScaled);
 		direction = PositionDirection.SHORT;
 	}
 
@@ -252,7 +252,7 @@ export function calculateTargetPriceTrade(
 	}
 
 	const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
-	const k = invariant.mul(MARK_PRICE_PRECISION);
+	const k = invariant.mul(PRICE_PRECISION);
 
 	let baseAssetReserveAfter;
 	let quoteAssetReserveAfter;
@@ -265,21 +265,19 @@ export function calculateTargetPriceTrade(
 		targetPrice.gt(bidPriceBefore)
 	) {
 		// no trade, market is at target
-		if (markPriceBefore.gt(targetPrice)) {
+		if (reservePriceBefore.gt(targetPrice)) {
 			direction = PositionDirection.SHORT;
 		} else {
 			direction = PositionDirection.LONG;
 		}
 		tradeSize = ZERO;
 		return [direction, tradeSize, targetPrice, targetPrice];
-	} else if (markPriceBefore.gt(targetPrice)) {
+	} else if (reservePriceBefore.gt(targetPrice)) {
 		// overestimate y2
 		baseAssetReserveAfter = squareRootBN(
 			k.div(targetPrice).mul(peg).div(PEG_PRECISION).sub(biasModifier)
 		).sub(new BN(1));
-		quoteAssetReserveAfter = k
-			.div(MARK_PRICE_PRECISION)
-			.div(baseAssetReserveAfter);
+		quoteAssetReserveAfter = k.div(PRICE_PRECISION).div(baseAssetReserveAfter);
 
 		markPriceAfter = calculatePrice(
 			baseAssetReserveAfter,
@@ -293,14 +291,12 @@ export function calculateTargetPriceTrade(
 			.div(PEG_PRECISION)
 			.div(AMM_TO_QUOTE_PRECISION_RATIO);
 		baseSize = baseAssetReserveAfter.sub(baseAssetReserveBefore);
-	} else if (markPriceBefore.lt(targetPrice)) {
+	} else if (reservePriceBefore.lt(targetPrice)) {
 		// underestimate y2
 		baseAssetReserveAfter = squareRootBN(
 			k.div(targetPrice).mul(peg).div(PEG_PRECISION).add(biasModifier)
 		).add(new BN(1));
-		quoteAssetReserveAfter = k
-			.div(MARK_PRICE_PRECISION)
-			.div(baseAssetReserveAfter);
+		quoteAssetReserveAfter = k.div(PRICE_PRECISION).div(baseAssetReserveAfter);
 
 		markPriceAfter = calculatePrice(
 			baseAssetReserveAfter,
@@ -324,17 +320,17 @@ export function calculateTargetPriceTrade(
 
 	let tp1 = targetPrice;
 	let tp2 = markPriceAfter;
-	let originalDiff = targetPrice.sub(markPriceBefore);
+	let originalDiff = targetPrice.sub(reservePriceBefore);
 
 	if (direction == PositionDirection.SHORT) {
 		tp1 = markPriceAfter;
 		tp2 = targetPrice;
-		originalDiff = markPriceBefore.sub(targetPrice);
+		originalDiff = reservePriceBefore.sub(targetPrice);
 	}
 
 	const entryPrice = tradeSize
 		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(baseSize.abs());
 
 	assert(tp1.sub(tp2).lte(originalDiff), 'Target Price Calculation incorrect');

package/src/oracles/pythClient.ts

@@ -2,7 +2,7 @@ import { parsePriceData } from '@pythnetwork/client';
 import { Connection, PublicKey } from '@solana/web3.js';
 import { OracleClient, OraclePriceData } from './types';
 import { BN } from '@project-serum/anchor';
-import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
+import { PRICE_PRECISION, TEN } from '../constants/numericConstants';
 
 export class PythClient implements OracleClient {
 	private connection: Connection;
@@ -38,6 +38,6 @@ export function convertPythPrice(price: number, exponent: number): BN {
 	exponent = Math.abs(exponent);
 	const pythPrecision = TEN.pow(new BN(exponent).abs());
 	return new BN(price * Math.pow(10, exponent))
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(pythPrecision);
 }

package/src/oracles/quoteAssetOracleClient.ts

@@ -1,10 +1,10 @@
 import { PublicKey } from '@solana/web3.js';
 import { OracleClient, OraclePriceData } from './types';
 import { BN } from '@project-serum/anchor';
-import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
+import { PRICE_PRECISION } from '../constants/numericConstants';
 
 export const QUOTE_ORACLE_PRICE_DATA: OraclePriceData = {
-	price: MARK_PRICE_PRECISION,
+	price: PRICE_PRECISION,
 	slot: new BN(0),
 	confidence: new BN(1),
 	hasSufficientNumberOfDataPoints: true,

package/src/oracles/switchboardClient.ts

@@ -1,7 +1,7 @@
 import { SwitchboardDecimal } from '@switchboard-xyz/switchboard-v2';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
 import { BN, Program, Idl, AnchorProvider } from '@project-serum/anchor';
-import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
+import { PRICE_PRECISION, TEN } from '../constants/numericConstants';
 import { OracleClient, OraclePriceData } from './types';
 import { Wallet } from '../wallet';
 import switchboardV2Idl from '../idl/switchboard_v2.json';
@@ -74,6 +74,6 @@ function getSwitchboardProgram(connection: Connection): Program {
 function convertSwitchboardDecimal(switchboardDecimal: SwitchboardDecimal): BN {
 	const switchboardPrecision = TEN.pow(new BN(switchboardDecimal.scale));
 	return switchboardDecimal.mantissa
-		.mul(MARK_PRICE_PRECISION)
+		.mul(PRICE_PRECISION)
 		.div(switchboardPrecision);
 }

package/src/orderParams.ts

@@ -2,32 +2,40 @@ import { OptionalOrderParams, OrderTriggerCondition, OrderType } from './types';
 import { BN } from '@project-serum/anchor';
 
 export function getLimitOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType'> & { price: BN }
+	params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & { price: BN }
 ): OptionalOrderParams {
-	return Object.assign({}, params, { orderType: OrderType.LIMIT });
+	return Object.assign({}, params, {
+		orderType: OrderType.LIMIT,
+	});
 }
 
 export function getTriggerMarketOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType'> & {
+	params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
 		triggerCondition: OrderTriggerCondition;
 		triggerPrice: BN;
 	}
 ): OptionalOrderParams {
-	return Object.assign({}, params, { orderType: OrderType.TRIGGER_MARKET });
+	return Object.assign({}, params, {
+		orderType: OrderType.TRIGGER_MARKET,
+	});
 }
 
 export function getTriggerLimitOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType'> & {
+	params: Omit<OptionalOrderParams, 'orderType' | 'marketType'> & {
 		triggerCondition: OrderTriggerCondition;
 		triggerPrice: BN;
 		price: BN;
 	}
 ): OptionalOrderParams {
-	return Object.assign({}, params, { orderType: OrderType.TRIGGER_LIMIT });
+	return Object.assign({}, params, {
+		orderType: OrderType.TRIGGER_LIMIT,
+	});
 }
 
 export function getMarketOrderParams(
-	params: Omit<OptionalOrderParams, 'orderType'>
+	params: Omit<OptionalOrderParams, 'orderType' | 'marketType'>
 ): OptionalOrderParams {
-	return Object.assign({}, params, { orderType: OrderType.MARKET });
+	return Object.assign({}, params, {
+		orderType: OrderType.MARKET,
+	});
 }