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

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 {
@@ -213,8 +199,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,23 +213,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 +240,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;
 }

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);
+		}
+	}
+}

package/src/tx/retryTxSender.ts

@@ -1,4 +1,4 @@
-import { TxSender } from './types';
+import { TxSender, TxSigAndSlot } from './types';
 import {
 	Commitment,
 	ConfirmOptions,
@@ -43,7 +43,7 @@ export class RetryTxSender implements TxSender {
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,
 		opts?: ConfirmOptions
-	): Promise<TransactionSignature> {
+	): Promise<TxSigAndSlot> {
 		if (additionalSigners === undefined) {
 			additionalSigners = [];
 		}
@@ -86,8 +86,10 @@ export class RetryTxSender implements TxSender {
 			}
 		})();
 
+		let slot: number;
 		try {
-			await this.confirmTransaction(txid, opts.commitment);
+			const result = await this.confirmTransaction(txid, opts.commitment);
+			slot = result.context.slot;
 		} catch (e) {
 			console.error(e);
 			throw e;
@@ -95,7 +97,7 @@ export class RetryTxSender implements TxSender {
 			stopWaiting();
 		}
 
-		return txid;
+		return { txSig: txid, slot };
 	}
 
 	async prepareTx(

package/src/tx/types.ts

@@ -6,6 +6,11 @@ import {
 	TransactionSignature,
 } from '@solana/web3.js';
 
+export type TxSigAndSlot = {
+	txSig: TransactionSignature;
+	slot: number;
+};
+
 export interface TxSender {
 	provider: Provider;
 
@@ -13,5 +18,5 @@ export interface TxSender {
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,
 		opts?: ConfirmOptions
-	): Promise<TransactionSignature>;
+	): Promise<TxSigAndSlot>;
 }

package/src/tx/utils.ts

@@ -1,5 +1,24 @@
-import { Transaction, TransactionInstruction } from '@solana/web3.js';
+import {
+	Transaction,
+	TransactionInstruction,
+	ComputeBudgetProgram,
+} from '@solana/web3.js';
 
-export function wrapInTx(instruction: TransactionInstruction): Transaction {
-	return new Transaction().add(instruction);
+const COMPUTE_UNITS_DEFAULT = 200_000;
+
+export function wrapInTx(
+	instruction: TransactionInstruction,
+	computeUnits = 500_000 // TODO, requires less code change
+): Transaction {
+	const tx = new Transaction();
+	if (computeUnits != COMPUTE_UNITS_DEFAULT) {
+		tx.add(
+			ComputeBudgetProgram.requestUnits({
+				units: computeUnits,
+				additionalFee: 0,
+			})
+		);
+	}
+
+	return tx.add(instruction);
 }