@drift-labs/sdk 0.1.36-master.5 → 0.2.0-master.0

package/src/math/trade.ts

@@ -1,4 +1,4 @@
-import { Market, PositionDirection } from '../types';
+import { MarketAccount, PositionDirection, SwapDirection } from '../types';
 import { BN } from '@project-serum/anchor';
 import { assert } from '../assert/assert';
 import {
@@ -7,15 +7,22 @@ import {
 	AMM_TO_QUOTE_PRECISION_RATIO,
 	ZERO,
 } from '../constants/numericConstants';
-import { calculateMarkPrice } from './market';
+import {
+	calculateBidPrice,
+	calculateAskPrice,
+	calculateMarkPrice,
+} from './market';
 import {
 	calculateAmmReservesAfterSwap,
 	calculatePrice,
 	getSwapDirection,
 	AssetType,
-	calculateSpreadReserves,
+	calculateUpdatedAMMSpreadReserves,
+	calculateQuoteAssetAmountSwapped,
 } from './amm';
 import { squareRootBN } from './utils';
+import { isVariant } from '../types';
+import { OraclePriceData } from '../oracles/types';
 
 const MAXPCT = new BN(1000); //percentage units are [0,1000] => [0,1]
 
@@ -37,6 +44,8 @@ export type PriceImpactUnit =
  * @param direction
  * @param amount
  * @param market
+ * @param inputAssetType which asset is being traded
+ * @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
@@ -50,10 +59,22 @@ export type PriceImpactUnit =
 export function calculateTradeSlippage(
 	direction: PositionDirection,
 	amount: BN,
-	market: Market,
-	inputAssetType: AssetType = 'quote'
+	market: MarketAccount,
+	inputAssetType: AssetType = 'quote',
+	oraclePriceData?: OraclePriceData,
+	useSpread = true
 ): [BN, BN, BN, BN] {
-	const oldPrice = calculateMarkPrice(market);
+	let oldPrice: BN;
+
+	if (useSpread && market.amm.baseSpread > 0) {
+		if (isVariant(direction, 'long')) {
+			oldPrice = calculateAskPrice(market, oraclePriceData);
+		} else {
+			oldPrice = calculateBidPrice(market, oraclePriceData);
+		}
+	} else {
+		oldPrice = calculateMarkPrice(market, oraclePriceData);
+	}
 	if (amount.eq(ZERO)) {
 		return [ZERO, ZERO, oldPrice, oldPrice];
 	}
@@ -61,25 +82,49 @@ export function calculateTradeSlippage(
 		direction,
 		amount,
 		market,
-		inputAssetType
+		inputAssetType,
+		oraclePriceData,
+		useSpread
+	);
+
+	const swapDirection = isVariant(direction, 'long')
+		? SwapDirection.REMOVE
+		: SwapDirection.ADD;
+	const quoteAssetAmountAcquired = calculateQuoteAssetAmountSwapped(
+		acquiredQuote.abs(),
+		market.amm.pegMultiplier,
+		swapDirection
 	);
 
-	const entryPrice = calculatePrice(
-		acquiredBase,
-		acquiredQuote,
-		market.amm.pegMultiplier
-	).mul(new BN(-1));
+	const entryPrice = quoteAssetAmountAcquired
+		.mul(AMM_TO_QUOTE_PRECISION_RATIO)
+		.mul(MARK_PRICE_PRECISION)
+		.div(acquiredBase.abs());
+
+	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
+	if (useSpread && market.amm.baseSpread > 0) {
+		const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+			calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
+		amm = {
+			baseAssetReserve,
+			quoteAssetReserve,
+			sqrtK: sqrtK,
+			pegMultiplier: newPeg,
+		};
+	} else {
+		amm = market.amm;
+	}
 
 	const newPrice = calculatePrice(
-		market.amm.baseAssetReserve.sub(acquiredBase),
-		market.amm.quoteAssetReserve.sub(acquiredQuote),
-		market.amm.pegMultiplier
+		amm.baseAssetReserve.sub(acquiredBase),
+		amm.quoteAssetReserve.sub(acquiredQuote),
+		amm.pegMultiplier
 	);
 
 	if (direction == PositionDirection.SHORT) {
-		assert(newPrice.lt(oldPrice));
+		assert(newPrice.lte(oldPrice));
 	} else {
-		assert(oldPrice.lt(newPrice));
+		assert(oldPrice.lte(newPrice));
 	}
 
 	const pctMaxSlippage = newPrice
@@ -104,14 +149,15 @@ export function calculateTradeSlippage(
  * @param inputAssetType
  * @param useSpread
  * @return
- * 	| 'acquiredBase' =>  positive/negative change in user's base : BN TODO-PRECISION
+ * 	| 'acquiredBase' =>  positive/negative change in user's base : BN AMM_RESERVE_PRECISION
  * 	| 'acquiredQuote' => positive/negative change in user's quote : BN TODO-PRECISION
  */
 export function calculateTradeAcquiredAmounts(
 	direction: PositionDirection,
 	amount: BN,
-	market: Market,
+	market: MarketAccount,
 	inputAssetType: AssetType = 'quote',
+	oraclePriceData: OraclePriceData,
 	useSpread = true
 ): [BN, BN] {
 	if (amount.eq(ZERO)) {
@@ -122,15 +168,13 @@ export function calculateTradeAcquiredAmounts(
 
 	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
 	if (useSpread && market.amm.baseSpread > 0) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			direction
-		);
+		const { baseAssetReserve, quoteAssetReserve, sqrtK, newPeg } =
+			calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
 		amm = {
 			baseAssetReserve,
 			quoteAssetReserve,
-			sqrtK: market.amm.sqrtK,
-			pegMultiplier: market.amm.pegMultiplier,
+			sqrtK: sqrtK,
+			pegMultiplier: newPeg,
 		};
 	} else {
 		amm = market.amm;
@@ -150,44 +194,65 @@ export function calculateTradeAcquiredAmounts(
  * @param market
  * @param targetPrice
  * @param pct optional default is 100% gap filling, can set smaller.
+ * @param outputAssetType which asset to trade.
+ * @param useSpread whether or not to consider the spread when calculating the trade size
  * @returns trade direction/size in order to push price to a targetPrice,
  *
  * [
- *   direction => direction of trade required, TODO-PRECISION
+ *   direction => direction of trade required, PositionDirection
  *   tradeSize => size of trade required, TODO-PRECISION
- *   entryPrice => the entry price for the trade, TODO-PRECISION
- *   targetPrice => the target price TODO-PRECISION
+ *   entryPrice => the entry price for the trade, MARK_PRICE_PRECISION
+ *   targetPrice => the target price MARK_PRICE_PRECISION
  * ]
  */
 export function calculateTargetPriceTrade(
-	market: Market,
+	market: MarketAccount,
 	targetPrice: BN,
 	pct: BN = MAXPCT,
-	outputAssetType: AssetType = 'quote'
+	outputAssetType: AssetType = 'quote',
+	oraclePriceData?: OraclePriceData,
+	useSpread = true
 ): [PositionDirection, BN, BN, BN] {
 	assert(market.amm.baseAssetReserve.gt(ZERO));
 	assert(targetPrice.gt(ZERO));
 	assert(pct.lte(MAXPCT) && pct.gt(ZERO));
 
-	const markPriceBefore = calculateMarkPrice(market);
+	const markPriceBefore = calculateMarkPrice(market, oraclePriceData);
+	const bidPriceBefore = calculateBidPrice(market, oraclePriceData);
+	const askPriceBefore = calculateAskPrice(market, oraclePriceData);
 
+	let direction;
 	if (targetPrice.gt(markPriceBefore)) {
 		const priceGap = targetPrice.sub(markPriceBefore);
 		const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
 		targetPrice = markPriceBefore.add(priceGapScaled);
+		direction = PositionDirection.LONG;
 	} else {
 		const priceGap = markPriceBefore.sub(targetPrice);
 		const priceGapScaled = priceGap.mul(pct).div(MAXPCT);
 		targetPrice = markPriceBefore.sub(priceGapScaled);
+		direction = PositionDirection.SHORT;
 	}
 
-	let direction;
 	let tradeSize;
 	let baseSize;
 
-	const baseAssetReserveBefore = market.amm.baseAssetReserve;
-	const quoteAssetReserveBefore = market.amm.quoteAssetReserve;
-	const peg = market.amm.pegMultiplier;
+	let baseAssetReserveBefore: BN;
+	let quoteAssetReserveBefore: BN;
+
+	let peg = market.amm.pegMultiplier;
+
+	if (useSpread && market.amm.baseSpread > 0) {
+		const { baseAssetReserve, quoteAssetReserve, newPeg } =
+			calculateUpdatedAMMSpreadReserves(market.amm, direction, oraclePriceData);
+		baseAssetReserveBefore = baseAssetReserve;
+		quoteAssetReserveBefore = quoteAssetReserve;
+		peg = newPeg;
+	} else {
+		baseAssetReserveBefore = market.amm.baseAssetReserve;
+		quoteAssetReserveBefore = market.amm.quoteAssetReserve;
+	}
+
 	const invariant = market.amm.sqrtK.mul(market.amm.sqrtK);
 	const k = invariant.mul(MARK_PRICE_PRECISION);
 
@@ -196,7 +261,20 @@ export function calculateTargetPriceTrade(
 	const biasModifier = new BN(1);
 	let markPriceAfter;
 
-	if (markPriceBefore.gt(targetPrice)) {
+	if (
+		useSpread &&
+		targetPrice.lt(askPriceBefore) &&
+		targetPrice.gt(bidPriceBefore)
+	) {
+		// no trade, market is at target
+		if (markPriceBefore.gt(targetPrice)) {
+			direction = PositionDirection.SHORT;
+		} else {
+			direction = PositionDirection.LONG;
+		}
+		tradeSize = ZERO;
+		return [direction, tradeSize, targetPrice, targetPrice];
+	} else if (markPriceBefore.gt(targetPrice)) {
 		// overestimate y2
 		baseAssetReserveAfter = squareRootBN(
 			k.div(targetPrice).mul(peg).div(PEG_PRECISION).sub(biasModifier)

package/src/math/utils.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squareRootBN = void 0;
+const __1 = require("../");
+const squareRootBN = (n, closeness = new __1.BN(1)) => {
+    // Assuming the sqrt of n as n only
+    let x = n;
+    // The closed guess will be stored in the root
+    let root;
+    // To count the number of iterations
+    let count = 0;
+    const TWO = new __1.BN(2);
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    while (count < Number.MAX_SAFE_INTEGER) {
+        count++;
+        // Calculate more closed x
+        root = x.add(n.div(x)).div(TWO);
+        // Check for closeness
+        if (x.sub(root).abs().lte(closeness))
+            break;
+        // Update root
+        x = root;
+    }
+    return root;
+};
+exports.squareRootBN = squareRootBN;
+//# sourceMappingURL=utils.js.map

package/src/math/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":";;;AAAA,2BAAyB;AAElB,MAAM,YAAY,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,EAAE,EAAE;IACxD,mCAAmC;IACnC,IAAI,CAAC,GAAG,CAAC,CAAC;IAEV,8CAA8C;IAC9C,IAAI,IAAI,CAAC;IAET,oCAAoC;IACpC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,MAAM,GAAG,GAAG,IAAI,MAAE,CAAC,CAAC,CAAC,CAAC;IAEtB,6DAA6D;IAC7D,OAAO,KAAK,GAAG,MAAM,CAAC,gBAAgB,EAAE;QACvC,KAAK,EAAE,CAAC;QAER,0BAA0B;QAC1B,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAEhC,sBAAsB;QACtB,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,MAAM;QAE5C,cAAc;QACd,CAAC,GAAG,IAAI,CAAC;KACT;IAED,OAAO,IAAI,CAAC;AACb,CAAC,CAAC;AA1BW,QAAA,YAAY,gBA0BvB"}

package/src/oracles/oracleClientCache.ts

@@ -0,0 +1,20 @@
+import { OracleClient } from './types';
+import { OracleSource } from '../types';
+import { getOracleClient } from '../factory/oracleClient';
+import { Connection } from '@solana/web3.js';
+
+export class OracleClientCache {
+	cache = new Map<string, OracleClient>();
+	public constructor() {}
+
+	public get(oracleSource: OracleSource, connection: Connection) {
+		const key = Object.keys(oracleSource)[0];
+		if (this.cache.has(key)) {
+			return this.cache.get(key);
+		}
+
+		const client = getOracleClient(oracleSource, connection);
+		this.cache.set(key, client);
+		return client;
+	}
+}

package/src/oracles/pythClient.ts

@@ -1,21 +1,16 @@
-import { parsePriceData, PriceData } from '@pythnetwork/client';
+import { parsePriceData } from '@pythnetwork/client';
 import { Connection, PublicKey } from '@solana/web3.js';
-import { OraclePriceData } from './types';
+import { OracleClient, OraclePriceData } from './types';
 import { BN } from '@project-serum/anchor';
 import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
 
-export class PythClient {
+export class PythClient implements OracleClient {
 	private connection: Connection;
 
 	public constructor(connection: Connection) {
 		this.connection = connection;
 	}
 
-	public async getPriceData(pricePublicKey: PublicKey): Promise<PriceData> {
-		const account = await this.connection.getAccountInfo(pricePublicKey);
-		return parsePriceData(account.data);
-	}
-
 	public async getOraclePriceData(
 		pricePublicKey: PublicKey
 	): Promise<OraclePriceData> {
@@ -23,9 +18,7 @@ export class PythClient {
 		return this.getOraclePriceDataFromBuffer(accountInfo.data);
 	}
 
-	public async getOraclePriceDataFromBuffer(
-		buffer: Buffer
-	): Promise<OraclePriceData> {
+	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {
 		const priceData = parsePriceData(buffer);
 		return {
 			price: convertPythPrice(priceData.aggregate.price, priceData.exponent),
@@ -36,6 +29,7 @@ export class PythClient {
 				priceData.twac.value,
 				priceData.exponent
 			),
+			hasSufficientNumberOfDataPoints: true,
 		};
 	}
 }

package/src/oracles/quoteAssetOracleClient.ts

@@ -0,0 +1,25 @@
+import { PublicKey } from '@solana/web3.js';
+import { OracleClient, OraclePriceData } from './types';
+import { BN } from '@project-serum/anchor';
+import { MARK_PRICE_PRECISION } from '../constants/numericConstants';
+
+export const QUOTE_ORACLE_PRICE_DATA: OraclePriceData = {
+	price: MARK_PRICE_PRECISION,
+	slot: new BN(0),
+	confidence: new BN(1),
+	hasSufficientNumberOfDataPoints: true,
+};
+
+export class QuoteAssetOracleClient implements OracleClient {
+	public constructor() {}
+
+	public async getOraclePriceData(
+		_pricePublicKey: PublicKey
+	): Promise<OraclePriceData> {
+		return Promise.resolve(QUOTE_ORACLE_PRICE_DATA);
+	}
+
+	public getOraclePriceDataFromBuffer(_buffer: Buffer): OraclePriceData {
+		return QUOTE_ORACLE_PRICE_DATA;
+	}
+}

package/src/oracles/switchboardClient.ts

@@ -1,25 +1,18 @@
-import {
-	getSwitchboardPid,
-	SwitchboardDecimal,
-} from '@switchboard-xyz/switchboard-v2';
+import { SwitchboardDecimal } from '@switchboard-xyz/switchboard-v2';
 import { Connection, Keypair, PublicKey } from '@solana/web3.js';
-import { DriftEnv } from '../config';
 import { BN, Program, Idl, AnchorProvider } from '@project-serum/anchor';
 import { MARK_PRICE_PRECISION, TEN } from '../constants/numericConstants';
 import { OracleClient, OraclePriceData } from './types';
 import { Wallet } from '../wallet';
 import switchboardV2Idl from '../idl/switchboard_v2.json';
 
-// cache switchboard program for every client object since itll always be the same
-const programMap = new Map<string, Program>();
+let program: Program | undefined;
 
 export class SwitchboardClient implements OracleClient {
 	connection: Connection;
-	env: DriftEnv;
 
-	public constructor(connection: Connection, env: DriftEnv) {
+	public constructor(connection: Connection) {
 		this.connection = connection;
-		this.env = env;
 	}
 
 	public async getOraclePriceData(
@@ -29,10 +22,8 @@ export class SwitchboardClient implements OracleClient {
 		return this.getOraclePriceDataFromBuffer(accountInfo.data);
 	}
 
-	public async getOraclePriceDataFromBuffer(
-		buffer: Buffer
-	): Promise<OraclePriceData> {
-		const program = await this.getProgram();
+	public getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData {
+		const program = this.getProgram();
 
 		const aggregatorAccountData =
 			program.account.aggregatorAccountData.coder.accounts.decode(
@@ -48,31 +39,32 @@ export class SwitchboardClient implements OracleClient {
 				.stdDeviation as SwitchboardDecimal
 		);
 
+		const hasSufficientNumberOfDataPoints =
+			aggregatorAccountData.latestConfirmedRound.numSuccess >=
+			aggregatorAccountData.minOracleResults;
+
 		const slot: BN = aggregatorAccountData.latestConfirmedRound.roundOpenSlot;
 		return {
 			price,
 			slot,
 			confidence,
+			hasSufficientNumberOfDataPoints,
 		};
 	}
 
-	public async getProgram(): Promise<Program> {
-		if (programMap.has(this.env)) {
-			return programMap.get(this.env);
+	public getProgram(): Program {
+		if (program) {
+			return program;
 		}
 
-		const program = await getSwitchboardProgram(this.env, this.connection);
-		programMap.set(this.env, program);
+		program = getSwitchboardProgram(this.connection);
 		return program;
 	}
 }
 
-async function getSwitchboardProgram(
-	env: DriftEnv,
-	connection: Connection
-): Promise<Program> {
+function getSwitchboardProgram(connection: Connection): Program {
 	const DEFAULT_KEYPAIR = Keypair.fromSeed(new Uint8Array(32).fill(1));
-	const programId = getSwitchboardPid(env);
+	const programId = PublicKey.default;
 	const wallet = new Wallet(DEFAULT_KEYPAIR);
 	const provider = new AnchorProvider(connection, wallet, {});
 

package/src/oracles/types.ts

@@ -1,15 +1,22 @@
 import { BN } from '@project-serum/anchor';
 import { PublicKey } from '@solana/web3.js';
+import { OracleSource } from '../types';
 
 export type OraclePriceData = {
 	price: BN;
 	slot: BN;
 	confidence: BN;
+	hasSufficientNumberOfDataPoints: boolean;
 	twap?: BN;
 	twapConfidence?: BN;
 };
 
+export type OracleInfo = {
+	publicKey: PublicKey;
+	source: OracleSource;
+};
+
 export interface OracleClient {
-	getOraclePriceDataFromBuffer(buffer: Buffer): Promise<OraclePriceData>;
+	getOraclePriceDataFromBuffer(buffer: Buffer): OraclePriceData;
 	getOraclePriceData(publicKey: PublicKey): Promise<OraclePriceData>;
 }

package/src/orders.ts

@@ -1,6 +1,6 @@
 import {
 	isVariant,
-	Market,
+	MarketAccount,
 	Order,
 	PositionDirection,
 	SwapDirection,
@@ -14,6 +14,7 @@ import {
 	calculateSpreadReserves,
 	ClearingHouseUser,
 	isOrderRiskIncreasingInSameDirection,
+	standardizeBaseAssetAmount,
 	TEN_THOUSAND,
 } from '.';
 import {
@@ -36,9 +37,9 @@ import { OraclePriceData } from '.';
 export function calculateNewStateAfterOrder(
 	userAccount: UserAccount,
 	userPosition: UserPosition,
-	market: Market,
+	market: MarketAccount,
 	order: Order
-): [UserAccount, UserPosition, Market] | null {
+): [UserAccount, UserPosition, MarketAccount] | null {
 	if (isVariant(order.status, 'init')) {
 		return null;
 	}
@@ -47,7 +48,7 @@ export function calculateNewStateAfterOrder(
 		market,
 		order
 	);
-	if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
+	if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
 		return null;
 	}
 
@@ -155,8 +156,8 @@ export function calculateNewStateAfterOrder(
 }
 
 function calculateAmountSwapped(
-	marketBefore: Market,
-	marketAfter: Market
+	marketBefore: MarketAccount,
+	marketAfter: MarketAccount
 ): { quoteAssetAmountSwapped: BN; baseAssetAmountSwapped: BN } {
 	return {
 		quoteAssetAmountSwapped: marketBefore.amm.quoteAssetReserve
@@ -172,7 +173,7 @@ function calculateAmountSwapped(
 }
 
 export function calculateBaseAssetAmountMarketCanExecute(
-	market: Market,
+	market: MarketAccount,
 	order: Order,
 	oraclePriceData?: OraclePriceData
 ): BN {
@@ -189,7 +190,7 @@ export function calculateBaseAssetAmountMarketCanExecute(
 }
 
 export function calculateAmountToTradeForLimit(
-	market: Market,
+	market: MarketAccount,
 	order: Order,
 	oraclePriceData?: OraclePriceData
 ): BN {
@@ -213,8 +214,12 @@ export function calculateAmountToTradeForLimit(
 	const [maxAmountToTrade, direction] = calculateMaxBaseAssetAmountToTrade(
 		market.amm,
 		limitPrice,
-		order.direction,
-		!order.postOnly
+		order.direction
+	);
+
+	const baseAssetAmount = standardizeBaseAssetAmount(
+		maxAmountToTrade,
+		market.amm.baseAssetAmountStepSize
 	);
 
 	// Check that directions are the same
@@ -223,13 +228,13 @@ export function calculateAmountToTradeForLimit(
 		return ZERO;
 	}
 
-	return maxAmountToTrade.gt(order.baseAssetAmount)
+	return baseAssetAmount.gt(order.baseAssetAmount)
 		? order.baseAssetAmount
-		: maxAmountToTrade;
+		: baseAssetAmount;
 }
 
 export function calculateAmountToTradeForTriggerLimit(
-	market: Market,
+	market: MarketAccount,
 	order: Order
 ): BN {
 	if (order.baseAssetAmountFilled.eq(ZERO)) {
@@ -256,7 +261,7 @@ function isSameDirection(
 }
 
 function calculateAmountToTradeForTriggerMarket(
-	market: Market,
+	market: MarketAccount,
 	order: Order
 ): BN {
 	return isTriggerConditionSatisfied(market, order)
@@ -264,8 +269,12 @@ function calculateAmountToTradeForTriggerMarket(
 		: ZERO;
 }
 
-function isTriggerConditionSatisfied(market: Market, order: Order): boolean {
-	const markPrice = calculateMarkPrice(market);
+function isTriggerConditionSatisfied(
+	market: MarketAccount,
+	order: Order,
+	oraclePriceData?: OraclePriceData
+): boolean {
+	const markPrice = calculateMarkPrice(market, oraclePriceData);
 	if (isVariant(order.triggerCondition, 'above')) {
 		return markPrice.gt(order.triggerPrice);
 	} else {
@@ -274,9 +283,10 @@ function isTriggerConditionSatisfied(market: Market, order: Order): boolean {
 }
 
 export function calculateBaseAssetAmountUserCanExecute(
-	market: Market,
+	market: MarketAccount,
 	order: Order,
-	user: ClearingHouseUser
+	user: ClearingHouseUser,
+	oraclePriceData?: OraclePriceData
 ): BN {
 	const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
 	const freeCollateral = user.getFreeCollateral();
@@ -287,7 +297,11 @@ export function calculateBaseAssetAmountUserCanExecute(
 		const position =
 			user.getUserPosition(order.marketIndex) ||
 			user.getEmptyPosition(order.marketIndex);
-		const positionValue = calculateBaseAssetValue(market, position);
+		const positionValue = calculateBaseAssetValue(
+			market,
+			position,
+			oraclePriceData
+		);
 		quoteAssetAmount = freeCollateral
 			.mul(maxLeverage)
 			.div(TEN_THOUSAND)
@@ -307,7 +321,8 @@ export function calculateBaseAssetAmountUserCanExecute(
 	if (useSpread) {
 		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
 			market.amm,
-			order.direction
+			order.direction,
+			oraclePriceData
 		);
 		amm = {
 			baseAssetReserve,

package/src/slot/SlotSubscriber.ts

@@ -0,0 +1,32 @@
+import { Connection } from '@solana/web3.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type SlotSubscriberConfig = {}; // for future customization
+
+export class SlotSubscriber {
+	currentSlot: number;
+	subscriptionId: number;
+
+	public constructor(
+		private connection: Connection,
+		_config?: SlotSubscriberConfig
+	) {}
+
+	public async subscribe(): Promise<void> {
+		this.currentSlot = await this.connection.getSlot('confirmed');
+
+		this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
+			this.currentSlot = slotInfo.slot;
+		});
+	}
+
+	public getSlot(): number {
+		return this.currentSlot;
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (this.subscriptionId) {
+			await this.connection.removeSlotChangeListener(this.subscriptionId);
+		}
+	}
+}