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

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(
@@ -61,23 +52,19 @@ export class SwitchboardClient implements OracleClient {
 		};
 	}
 
-	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.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/oracles/types.ts

@@ -1,5 +1,6 @@
 import { BN } from '@project-serum/anchor';
 import { PublicKey } from '@solana/web3.js';
+import { OracleSource } from '../types';
 
 export type OraclePriceData = {
 	price: BN;
@@ -10,7 +11,12 @@ export type OraclePriceData = {
 	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/orderParams.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
+const types_1 = require("./types");
+function getLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.LIMIT });
+}
+exports.getLimitOrderParams = getLimitOrderParams;
+function getTriggerMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_MARKET });
+}
+exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
+function getTriggerLimitOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.TRIGGER_LIMIT });
+}
+exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
+function getMarketOrderParams(params) {
+    return Object.assign({}, params, { orderType: types_1.OrderType.MARKET });
+}
+exports.getMarketOrderParams = getMarketOrderParams;

package/src/orderParams.ts

@@ -1,154 +1,33 @@
-import {
-	OrderParams,
-	OrderTriggerCondition,
-	OrderType,
-	PositionDirection,
-} from './types';
+import { OptionalOrderParams, OrderTriggerCondition, OrderType } from './types';
 import { BN } from '@project-serum/anchor';
-import { ZERO } from './constants/numericConstants';
 
 export function getLimitOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	price: BN,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false,
-	userOrderId = 0,
-	postOnly = false,
-	oraclePriceOffset = ZERO,
-	immediateOrCancel = false
-): OrderParams {
-	return {
-		orderType: OrderType.LIMIT,
-		userOrderId,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly,
-		immediateOrCancel,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition: OrderTriggerCondition.ABOVE,
-		triggerPrice: ZERO,
-		oraclePriceOffset,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'> & { price: BN }
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.LIMIT });
 }
 
 export function getTriggerMarketOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	triggerPrice: BN,
-	triggerCondition: OrderTriggerCondition,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false,
-	userOrderId = 0
-): OrderParams {
-	return {
-		orderType: OrderType.TRIGGER_MARKET,
-		userOrderId,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price: ZERO,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition,
-		triggerPrice,
-		oraclePriceOffset: ZERO,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'> & {
+		triggerCondition: OrderTriggerCondition;
+		triggerPrice: BN;
+	}
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.TRIGGER_MARKET });
 }
 
 export function getTriggerLimitOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	baseAssetAmount: BN,
-	price: BN,
-	triggerPrice: BN,
-	triggerCondition: OrderTriggerCondition,
-	reduceOnly: boolean,
-	discountToken = false,
-	referrer = false,
-	userOrderId = 0
-): OrderParams {
-	return {
-		orderType: OrderType.TRIGGER_LIMIT,
-		userOrderId,
-		marketIndex,
-		direction,
-		quoteAssetAmount: ZERO,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition,
-		triggerPrice,
-		oraclePriceOffset: ZERO,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'> & {
+		triggerCondition: OrderTriggerCondition;
+		triggerPrice: BN;
+		price: BN;
+	}
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.TRIGGER_LIMIT });
 }
 
 export function getMarketOrderParams(
-	marketIndex: BN,
-	direction: PositionDirection,
-	quoteAssetAmount: BN,
-	baseAssetAmount: BN,
-	reduceOnly: boolean,
-	price = ZERO,
-	discountToken = false,
-	referrer = false
-): OrderParams {
-	if (baseAssetAmount.eq(ZERO) && quoteAssetAmount.eq(ZERO)) {
-		throw Error('baseAssetAmount or quoteAssetAmount must be zero');
-	}
-
-	return {
-		orderType: OrderType.MARKET,
-		userOrderId: 0,
-		marketIndex,
-		direction,
-		quoteAssetAmount,
-		baseAssetAmount,
-		price,
-		reduceOnly,
-		postOnly: false,
-		immediateOrCancel: false,
-		positionLimit: ZERO,
-		padding0: true,
-		padding1: ZERO,
-		optionalAccounts: {
-			discountToken,
-			referrer,
-		},
-		triggerCondition: OrderTriggerCondition.ABOVE,
-		triggerPrice: ZERO,
-		oraclePriceOffset: ZERO,
-	};
+	params: Omit<OptionalOrderParams, 'orderType'>
+): OptionalOrderParams {
+	return Object.assign({}, params, { orderType: OrderType.MARKET });
 }

package/src/orders.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateBaseAssetAmountMarketCanExecute = exports.calculateNewStateAfterOrder = void 0;
+const types_1 = require("./types");
+const _1 = require(".");
+const market_1 = require("./math/market");
+const numericConstants_1 = require("./constants/numericConstants");
+const amm_1 = require("./math/amm");
+const position_1 = require("./math/position");
+function calculateNewStateAfterOrder(userAccount, userPosition, market, order) {
+    if (types_1.isVariant(order.status, 'init')) {
+        return null;
+    }
+    const baseAssetAmountToTrade = calculateBaseAssetAmountMarketCanExecute(market, order);
+    if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
+        return null;
+    }
+    const userAccountAfter = Object.assign({}, userAccount);
+    const userPositionAfter = Object.assign({}, userPosition);
+    const currentPositionDirection = position_1.positionCurrentDirection(userPosition);
+    const increasePosition = userPosition.baseAssetAmount.eq(numericConstants_1.ZERO) ||
+        isSameDirection(order.direction, currentPositionDirection);
+    if (increasePosition) {
+        const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountToTrade, order.direction, market);
+        const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(market, marketAfter);
+        userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
+        userPositionAfter.quoteAssetAmount = userPositionAfter.quoteAssetAmount.add(quoteAssetAmountSwapped);
+        return [userAccountAfter, userPositionAfter, marketAfter];
+    }
+    else {
+        const reversePosition = baseAssetAmountToTrade.gt(userPosition.baseAssetAmount.abs());
+        if (reversePosition) {
+            const intermediateMarket = market_1.calculateNewMarketAfterTrade(userPosition.baseAssetAmount, position_1.findDirectionToClose(userPosition), market);
+            const { quoteAssetAmountSwapped: baseAssetValue } = calculateAmountSwapped(market, intermediateMarket);
+            let pnl;
+            if (types_1.isVariant(currentPositionDirection, 'long')) {
+                pnl = baseAssetValue.sub(userPosition.quoteAssetAmount);
+            }
+            else {
+                pnl = userPosition.quoteAssetAmount.sub(baseAssetValue);
+            }
+            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
+            const baseAssetAmountLeft = baseAssetAmountToTrade.sub(userPosition.baseAssetAmount.abs());
+            const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountLeft, order.direction, intermediateMarket);
+            const { quoteAssetAmountSwapped, baseAssetAmountSwapped } = calculateAmountSwapped(intermediateMarket, marketAfter);
+            userPositionAfter.quoteAssetAmount = quoteAssetAmountSwapped;
+            userPositionAfter.baseAssetAmount = baseAssetAmountSwapped;
+            return [userAccountAfter, userPositionAfter, marketAfter];
+        }
+        else {
+            const marketAfter = market_1.calculateNewMarketAfterTrade(baseAssetAmountToTrade, order.direction, market);
+            const { quoteAssetAmountSwapped: baseAssetValue, baseAssetAmountSwapped, } = calculateAmountSwapped(market, marketAfter);
+            const costBasisRealized = userPosition.quoteAssetAmount
+                .mul(baseAssetAmountSwapped.abs())
+                .div(userPosition.baseAssetAmount.abs());
+            let pnl;
+            if (types_1.isVariant(currentPositionDirection, 'long')) {
+                pnl = baseAssetValue.sub(costBasisRealized);
+            }
+            else {
+                pnl = costBasisRealized.sub(baseAssetValue);
+            }
+            userAccountAfter.collateral = userAccountAfter.collateral.add(pnl);
+            userPositionAfter.baseAssetAmount = userPositionAfter.baseAssetAmount.add(baseAssetAmountSwapped);
+            userPositionAfter.quoteAssetAmount =
+                userPositionAfter.quoteAssetAmount.sub(costBasisRealized);
+            return [userAccountAfter, userPositionAfter, marketAfter];
+        }
+    }
+}
+exports.calculateNewStateAfterOrder = calculateNewStateAfterOrder;
+function calculateAmountSwapped(marketBefore, marketAfter) {
+    return {
+        quoteAssetAmountSwapped: marketBefore.amm.quoteAssetReserve
+            .sub(marketAfter.amm.quoteAssetReserve)
+            .abs()
+            .mul(marketBefore.amm.pegMultiplier)
+            .div(numericConstants_1.PEG_PRECISION)
+            .div(numericConstants_1.AMM_TO_QUOTE_PRECISION_RATIO),
+        baseAssetAmountSwapped: marketBefore.amm.baseAssetReserve.sub(marketAfter.amm.baseAssetReserve),
+    };
+}
+function calculateBaseAssetAmountMarketCanExecute(market, order, oraclePriceData) {
+    if (types_1.isVariant(order.orderType, 'limit')) {
+        return calculateAmountToTradeForLimit(market, order, oraclePriceData);
+    }
+    else if (types_1.isVariant(order.orderType, 'triggerLimit')) {
+        return calculateAmountToTradeForTriggerLimit(market, order);
+    }
+    else if (types_1.isVariant(order.orderType, 'market')) {
+        return numericConstants_1.ZERO;
+    }
+    else {
+        return calculateAmountToTradeForTriggerMarket(market, order);
+    }
+}
+exports.calculateBaseAssetAmountMarketCanExecute = calculateBaseAssetAmountMarketCanExecute;
+function calculateAmountToTradeForLimit(market, order, oraclePriceData) {
+    let limitPrice = order.price;
+    if (!order.oraclePriceOffset.eq(numericConstants_1.ZERO)) {
+        if (!oraclePriceData) {
+            throw Error('Cant calculate limit price for oracle offset oracle without OraclePriceData');
+        }
+        limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
+    }
+    const [maxAmountToTrade, direction] = amm_1.calculateMaxBaseAssetAmountToTrade(market.amm, limitPrice, order.direction);
+    const baseAssetAmount = _1.standardizeBaseAssetAmount(maxAmountToTrade, market.amm.baseAssetAmountStepSize);
+    // Check that directions are the same
+    const sameDirection = isSameDirection(direction, order.direction);
+    if (!sameDirection) {
+        return numericConstants_1.ZERO;
+    }
+    return baseAssetAmount.gt(order.baseAssetAmount)
+        ? order.baseAssetAmount
+        : baseAssetAmount;
+}
+exports.calculateAmountToTradeForLimit = calculateAmountToTradeForLimit;
+function calculateAmountToTradeForTriggerLimit(market, order) {
+    if (!order.triggered) {
+        return numericConstants_1.ZERO;
+    }
+    return calculateAmountToTradeForLimit(market, order);
+}
+exports.calculateAmountToTradeForTriggerLimit = calculateAmountToTradeForTriggerLimit;
+function isSameDirection(firstDirection, secondDirection) {
+    return ((types_1.isVariant(firstDirection, 'long') && types_1.isVariant(secondDirection, 'long')) ||
+        (types_1.isVariant(firstDirection, 'short') && types_1.isVariant(secondDirection, 'short')));
+}
+function calculateAmountToTradeForTriggerMarket(market, order) {
+    if (!order.triggered) {
+        return numericConstants_1.ZERO;
+    }
+    return order.baseAssetAmount;
+}

package/src/orders.ts

@@ -1,28 +1,15 @@
 import {
 	isVariant,
-	Market,
+	MarketAccount,
 	Order,
 	PositionDirection,
-	SwapDirection,
 	UserAccount,
 	UserPosition,
 } from './types';
-import {
-	BN,
-	calculateAmmReservesAfterSwap,
-	calculateBaseAssetValue,
-	calculateSpreadReserves,
-	ClearingHouseUser,
-	isOrderRiskIncreasingInSameDirection,
-	TEN_THOUSAND,
-} from '.';
-import {
-	calculateMarkPrice,
-	calculateNewMarketAfterTrade,
-} from './math/market';
+import { BN, standardizeBaseAssetAmount } from '.';
+import { calculateNewMarketAfterTrade } from './math/market';
 import {
 	AMM_TO_QUOTE_PRECISION_RATIO,
-	TWO,
 	PEG_PRECISION,
 	ZERO,
 } from './constants/numericConstants';
@@ -36,9 +23,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 +34,7 @@ export function calculateNewStateAfterOrder(
 		market,
 		order
 	);
-	if (baseAssetAmountToTrade.lt(market.amm.minimumBaseAssetTradeSize)) {
+	if (baseAssetAmountToTrade.lt(market.amm.baseAssetAmountStepSize)) {
 		return null;
 	}
 
@@ -155,8 +142,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 +159,7 @@ function calculateAmountSwapped(
 }
 
 export function calculateBaseAssetAmountMarketCanExecute(
-	market: Market,
+	market: MarketAccount,
 	order: Order,
 	oraclePriceData?: OraclePriceData
 ): BN {
@@ -181,7 +168,6 @@ export function calculateBaseAssetAmountMarketCanExecute(
 	} else if (isVariant(order.orderType, 'triggerLimit')) {
 		return calculateAmountToTradeForTriggerLimit(market, order);
 	} else if (isVariant(order.orderType, 'market')) {
-		// should never be a market order queued
 		return ZERO;
 	} else {
 		return calculateAmountToTradeForTriggerMarket(market, order);
@@ -189,7 +175,7 @@ export function calculateBaseAssetAmountMarketCanExecute(
 }
 
 export function calculateAmountToTradeForLimit(
-	market: Market,
+	market: MarketAccount,
 	order: Order,
 	oraclePriceData?: OraclePriceData
 ): BN {
@@ -200,21 +186,18 @@ export function calculateAmountToTradeForLimit(
 				'Cant calculate limit price for oracle offset oracle without OraclePriceData'
 			);
 		}
-		const floatingPrice = oraclePriceData.price.add(order.oraclePriceOffset);
-		if (order.postOnly) {
-			limitPrice = isVariant(order.direction, 'long')
-				? BN.min(order.price, floatingPrice)
-				: BN.max(order.price, floatingPrice);
-		} else {
-			limitPrice = floatingPrice;
-		}
+		limitPrice = oraclePriceData.price.add(order.oraclePriceOffset);
 	}
 
 	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,23 +206,17 @@ 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)) {
-		const baseAssetAmount = calculateAmountToTradeForTriggerMarket(
-			market,
-			order
-		);
-		if (baseAssetAmount.eq(ZERO)) {
-			return ZERO;
-		}
+	if (!order.triggered) {
+		return ZERO;
 	}
 
 	return calculateAmountToTradeForLimit(market, order);
@@ -256,98 +233,12 @@ function isSameDirection(
 }
 
 function calculateAmountToTradeForTriggerMarket(
-	market: Market,
+	market: MarketAccount,
 	order: Order
 ): BN {
-	return isTriggerConditionSatisfied(market, order)
-		? order.baseAssetAmount
-		: ZERO;
-}
-
-function isTriggerConditionSatisfied(market: Market, order: Order): boolean {
-	const markPrice = calculateMarkPrice(market);
-	if (isVariant(order.triggerCondition, 'above')) {
-		return markPrice.gt(order.triggerPrice);
-	} else {
-		return markPrice.lt(order.triggerPrice);
-	}
-}
-
-export function calculateBaseAssetAmountUserCanExecute(
-	market: Market,
-	order: Order,
-	user: ClearingHouseUser
-): BN {
-	const maxLeverage = user.getMaxLeverage(order.marketIndex, 'Initial');
-	const freeCollateral = user.getFreeCollateral();
-	let quoteAssetAmount: BN;
-	if (isOrderRiskIncreasingInSameDirection(user, order)) {
-		quoteAssetAmount = freeCollateral.mul(maxLeverage).div(TEN_THOUSAND);
-	} else {
-		const position =
-			user.getUserPosition(order.marketIndex) ||
-			user.getEmptyPosition(order.marketIndex);
-		const positionValue = calculateBaseAssetValue(market, position);
-		quoteAssetAmount = freeCollateral
-			.mul(maxLeverage)
-			.div(TEN_THOUSAND)
-			.add(positionValue.mul(TWO));
-	}
-
-	if (quoteAssetAmount.lte(ZERO)) {
+	if (!order.triggered) {
 		return ZERO;
 	}
 
-	const swapDirection = isVariant(order.direction, 'long')
-		? SwapDirection.ADD
-		: SwapDirection.REMOVE;
-
-	const useSpread = !order.postOnly;
-	let amm: Parameters<typeof calculateAmmReservesAfterSwap>[0];
-	if (useSpread) {
-		const { baseAssetReserve, quoteAssetReserve } = calculateSpreadReserves(
-			market.amm,
-			order.direction
-		);
-		amm = {
-			baseAssetReserve,
-			quoteAssetReserve,
-			sqrtK: market.amm.sqrtK,
-			pegMultiplier: market.amm.pegMultiplier,
-		};
-	} else {
-		amm = market.amm;
-	}
-
-	const baseAssetReservesBefore = amm.baseAssetReserve;
-	const [_, baseAssetReservesAfter] = calculateAmmReservesAfterSwap(
-		amm,
-		'quote',
-		quoteAssetAmount,
-		swapDirection
-	);
-
-	let baseAssetAmount = baseAssetReservesBefore
-		.sub(baseAssetReservesAfter)
-		.abs();
-	if (order.reduceOnly) {
-		const position =
-			user.getUserPosition(order.marketIndex) ||
-			user.getEmptyPosition(order.marketIndex);
-		if (
-			isVariant(order.direction, 'long') &&
-			position.baseAssetAmount.gte(ZERO)
-		) {
-			baseAssetAmount = ZERO;
-		} else if (
-			isVariant(order.direction, 'short') &&
-			position.baseAssetAmount.lte(ZERO)
-		) {
-			baseAssetAmount = ZERO;
-		} else {
-			BN.min(baseAssetAmount, position.baseAssetAmount.abs());
-		}
-	}
-
-	return baseAssetAmount;
+	return order.baseAssetAmount;
 }