@drift-labs/sdk 0.1.18-master.7 → 0.1.18-orders.2

package/src/clearingHouseUser.ts

@@ -3,8 +3,14 @@ import BN from 'bn.js';
 import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { ClearingHouse } from './clearingHouse';
-import { UserAccount, UserPosition, UserPositionsAccount } from './types';
-import { calculateEntryPrice } from './math/position';
+import {
+	Order,
+	UserAccount,
+	UserOrdersAccount,
+	UserPosition,
+	UserPositionsAccount,
+} from './types';
+import { calculateEntryPrice, isEmptyPosition } from './math/position';
 import {
 	MARK_PRICE_PRECISION,
 	AMM_TO_QUOTE_PRECISION_RATIO,
@@ -18,34 +24,57 @@ import {
 	PRICE_TO_QUOTE_PRECISION,
 } from './constants/numericConstants';
 import { UserAccountSubscriber, UserAccountEvents } from './accounts/types';
-import { DefaultUserAccountSubscriber } from './accounts/defaultUserAccountSubscriber';
 import {
 	calculateMarkPrice,
 	calculateBaseAssetValue,
 	calculatePositionFundingPNL,
 	calculatePositionPNL,
 	PositionDirection,
+	getUserOrdersAccountPublicKey,
+	calculateNewStateAfterOrder,
 	calculateTradeSlippage,
 } from '.';
 import { getUserAccountPublicKey } from './addresses';
+import {
+	getClearingHouseUser,
+	getWebSocketClearingHouseUserConfig,
+} from './factory/clearingHouseUser';
 
 export class ClearingHouseUser {
 	clearingHouse: ClearingHouse;
 	authority: PublicKey;
 	accountSubscriber: UserAccountSubscriber;
 	userAccountPublicKey?: PublicKey;
-	isSubscribed = false;
+	userOrdersAccountPublicKey?: PublicKey;
+	_isSubscribed = false;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
 
+	public get isSubscribed() {
+		return this._isSubscribed && this.accountSubscriber.isSubscribed;
+	}
+
+	public set isSubscribed(val: boolean) {
+		this._isSubscribed = val;
+	}
+
+	/**
+	 * @deprecated You should use getClearingHouseUser factory method instead
+	 * @param clearingHouse
+	 * @param authority
+	 * @returns
+	 */
 	public static from(
 		clearingHouse: ClearingHouse,
 		authority: PublicKey
 	): ClearingHouseUser {
-		const accountSubscriber = new DefaultUserAccountSubscriber(
-			clearingHouse.program,
+		if (clearingHouse.accountSubscriber.type !== 'websocket')
+			throw 'This method only works for clearing houses with a websocket account listener. Try using the getClearingHouseUser factory method to initialize a ClearingHouseUser instead';
+
+		const config = getWebSocketClearingHouseUserConfig(
+			clearingHouse,
 			authority
 		);
-		return new ClearingHouseUser(clearingHouse, authority, accountSubscriber);
+		return getClearingHouseUser(config);
 	}
 
 	public constructor(
@@ -91,6 +120,10 @@ export class ClearingHouseUser {
 		return this.accountSubscriber.getUserPositionsAccount();
 	}
 
+	public getUserOrdersAccount(): UserOrdersAccount {
+		return this.accountSubscriber.getUserOrdersAccount();
+	}
+
 	/**
 	 * Gets the user's current position for a given market. If the user has no position returns undefined
 	 * @param marketIndex
@@ -108,9 +141,20 @@ export class ClearingHouseUser {
 			lastCumulativeFundingRate: ZERO,
 			marketIndex,
 			quoteAssetAmount: ZERO,
+			openOrders: ZERO,
 		};
 	}
 
+	/**
+	 * @param orderId
+	 * @returns Order
+	 */
+	public getOrder(orderId: BN): Order | undefined {
+		return this.getUserOrdersAccount().orders.find((order) =>
+			order.orderId.eq(orderId)
+		);
+	}
+
 	public async getUserAccountPublicKey(): Promise<PublicKey> {
 		if (this.userAccountPublicKey) {
 			return this.userAccountPublicKey;
@@ -123,6 +167,18 @@ export class ClearingHouseUser {
 		return this.userAccountPublicKey;
 	}
 
+	public async getUserOrdersAccountPublicKey(): Promise<PublicKey> {
+		if (this.userOrdersAccountPublicKey) {
+			return this.userOrdersAccountPublicKey;
+		}
+
+		this.userOrdersAccountPublicKey = await getUserOrdersAccountPublicKey(
+			this.clearingHouse.program.programId,
+			await this.getUserAccountPublicKey()
+		);
+		return this.userOrdersAccountPublicKey;
+	}
+
 	public async exists(): Promise<boolean> {
 		const userAccountPublicKey = await this.getUserAccountPublicKey();
 		const userAccountRPCResponse =
@@ -418,6 +474,7 @@ export class ClearingHouseUser {
 			),
 			lastCumulativeFundingRate: new BN(0),
 			quoteAssetAmount: new BN(0),
+			openOrders: new BN(0),
 		};
 
 		const market = this.clearingHouse.getMarket(
@@ -508,14 +565,14 @@ export class ClearingHouseUser {
 		// solves formula for example calc below
 
 		/* example: assume BTC price is $40k (examine 10% up/down)
-			
-			if 10k deposit and levered 10x short BTC => BTC up $400 means:
-			1. higher base_asset_value (+$4k)
-			2. lower collateral (-$4k)
-			3. (10k - 4k)/(100k + 4k) => 6k/104k => .0576
-	
-			for 10x long, BTC down $400:
-			3. (10k - 4k) / (100k - 4k) = 6k/96k => .0625 */
+
+        if 10k deposit and levered 10x short BTC => BTC up $400 means:
+        1. higher base_asset_value (+$4k)
+        2. lower collateral (-$4k)
+        3. (10k - 4k)/(100k + 4k) => 6k/104k => .0576
+
+        for 10x long, BTC down $400:
+        3. (10k - 4k) / (100k - 4k) = 6k/96k => .0625 */
 
 		const tc = this.getTotalCollateral();
 		const tpv = this.getTotalPositionValue();
@@ -546,6 +603,7 @@ export class ClearingHouseUser {
 			lastCumulativeFundingRate:
 				currentMarketPosition.lastCumulativeFundingRate,
 			quoteAssetAmount: new BN(0),
+			openOrders: new BN(0),
 		};
 
 		const market = this.clearingHouse.getMarket(
@@ -665,21 +723,6 @@ export class ClearingHouseUser {
 
 	/**
 	 * Get the maximum trade size for a given market, taking into account the user's current leverage, positions, collateral, etc.
-	 *
-	 * To Calculate Max Quote Available:
-	 *
-	 * Case 1: SameSide
-	 * 	=> Remaining quote to get to maxLeverage
-	 *
-	 * Case 2: NOT SameSide && currentLeverage <= maxLeverage
-	 * 	=> Current opposite position x2 + remaining to get to maxLeverage
-	 *
-	 * Case 3: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition > maxLeverage
-	 * 	=> strictly reduce current position size
-	 *
-	 * Case 4: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition < maxLeverage
-	 * 	=> current position + remaining to get to maxLeverage
-	 *
 	 * @param marketIndex
 	 * @param tradeSide
 	 * @param userMaxLeverageSetting - leverage : Precision TEN_THOUSAND
@@ -690,28 +733,34 @@ export class ClearingHouseUser {
 		tradeSide: PositionDirection,
 		userMaxLeverageSetting: BN
 	): BN {
-		const currentPosition =
-			this.getUserPosition(targetMarketIndex) ||
-			this.getEmptyPosition(targetMarketIndex);
+		// inline function which get's the current position size on the opposite side of the target trade
+		const getOppositePositionValueUSDC = () => {
+			if (!currentPosition) return ZERO;
 
-		const targetSide = tradeSide === PositionDirection.SHORT ? 'short' : 'long';
+			const side = tradeSide === PositionDirection.SHORT ? 'short' : 'long';
 
-		const currentPositionSide = currentPosition?.baseAssetAmount.isNeg()
-			? 'short'
-			: 'long';
+			if (side === 'long' && currentPosition?.baseAssetAmount.isNeg()) {
+				return this.getPositionValue(targetMarketIndex);
+			} else if (
+				side === 'short' &&
+				!currentPosition?.baseAssetAmount.isNeg()
+			) {
+				return this.getPositionValue(targetMarketIndex);
+			}
 
-		const targettingSameSide = !currentPosition
-			? true
-			: targetSide === currentPositionSide;
+			return ZERO;
+		};
 
-		// add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
-		const oppositeSizeValueUSDC = targettingSameSide
-			? ZERO
-			: this.getPositionValue(targetMarketIndex);
+		const currentPosition =
+			this.getUserPosition(targetMarketIndex) ||
+			this.getEmptyPosition(targetMarketIndex);
 
 		// get current leverage
 		const currentLeverage = this.getLeverage();
 
+		// remaining leverage
+		// let remainingLeverage = userMaxLeverageSetting;
+
 		const remainingLeverage = BN.max(
 			userMaxLeverageSetting.sub(currentLeverage),
 			ZERO
@@ -725,57 +774,10 @@ export class ClearingHouseUser {
 			.mul(totalCollateral)
 			.div(TEN_THOUSAND);
 
-		if (userMaxLeverageSetting.sub(currentLeverage).gte(ZERO)) {
-			if (oppositeSizeValueUSDC.eq(ZERO)) {
-				// case 1 : Regular trade where current total position less than max, and no opposite position to account for
-				// do nothing
-			} else {
-				// case 2 : trade where current total position less than max, but need to account for flipping the current position over to the other side
-				maxPositionSize = maxPositionSize.add(
-					oppositeSizeValueUSDC.mul(new BN(2))
-				);
-			}
-		} else {
-			// current leverage is greater than max leverage - can only reduce position size
-
-			if (!targettingSameSide) {
-				const currentPositionQuoteSize =
-					this.getPositionValue(targetMarketIndex);
-
-				const currentTotalQuoteSize = currentLeverage
-					.mul(totalCollateral)
-					.div(TEN_THOUSAND);
-
-				const otherPositionsTotalQuoteSize = currentTotalQuoteSize.sub(
-					currentPositionQuoteSize
-				);
-
-				const quoteValueOfMaxLeverage = userMaxLeverageSetting
-					.mul(totalCollateral)
-					.div(TEN_THOUSAND);
-
-				if (
-					otherPositionsTotalQuoteSize
-						.sub(currentPositionQuoteSize)
-						.gte(quoteValueOfMaxLeverage)
-				) {
-					// case 3: Can only reduce the current position because it will still be greater than max leverage
-
-					maxPositionSize = currentPositionQuoteSize;
-				} else {
-					// case 4: Can reduce the position, and then take extra remaining quote to get to max leverage
-
-					const allowedQuoteSizeAfterClosingCurrentPosition =
-						quoteValueOfMaxLeverage.sub(otherPositionsTotalQuoteSize);
+		// add any position we have on the opposite side of the current trade, because we can "flip" the size of this position without taking any extra leverage.
+		const oppositeSizeValueUSDC = getOppositePositionValueUSDC();
 
-					maxPositionSize = currentPositionQuoteSize.add(
-						allowedQuoteSizeAfterClosingCurrentPosition
-					);
-				}
-			} else {
-				// do nothing if targetting same side
-			}
-		}
+		maxPositionSize = maxPositionSize.add(oppositeSizeValueUSDC.mul(new BN(2)));
 
 		// subtract oneMillionth of maxPositionSize
 		// => to avoid rounding errors when taking max leverage
@@ -820,19 +822,13 @@ export class ClearingHouseUser {
 
 		const totalPositionAfterTradeExcludingTargetMarket =
 			this.getTotalPositionValueExcludingMarket(targetMarketIndex);
+		const newLeverage = currentMarketPositionAfterTrade
+			.add(totalPositionAfterTradeExcludingTargetMarket)
+			.abs()
+			.mul(TEN_THOUSAND)
+			.div(this.getTotalCollateral());
 
-		const totalCollateral = this.getTotalCollateral();
-
-		if (totalCollateral.gt(ZERO)) {
-			const newLeverage = currentMarketPositionAfterTrade
-				.add(totalPositionAfterTradeExcludingTargetMarket)
-				.abs()
-				.mul(TEN_THOUSAND)
-				.div(totalCollateral);
-			return newLeverage;
-		} else {
-			return new BN(0);
-		}
+		return newLeverage;
 	}
 
 	/**
@@ -860,9 +856,85 @@ export class ClearingHouseUser {
 
 		let currentMarketPositionValueUSDC = ZERO;
 		if (currentMarketPosition) {
-			currentMarketPositionValueUSDC = this.getPositionValue(marketToIgnore);
+			const market = this.clearingHouse.getMarket(
+				currentMarketPosition.marketIndex
+			);
+			currentMarketPositionValueUSDC = calculateBaseAssetValue(
+				market,
+				currentMarketPosition
+			);
 		}
 
 		return this.getTotalPositionValue().sub(currentMarketPositionValueUSDC);
 	}
+
+	public canFillOrder(order: Order): boolean {
+		const userAccount = this.getUserAccount();
+		const userPositionsAccount = this.getUserPositionsAccount();
+		const userPosition = this.getUserPosition(order.marketIndex);
+		const market = this.clearingHouse.getMarket(order.marketIndex);
+
+		if (isEmptyPosition(userPosition)) {
+			return false;
+		}
+
+		const newState = calculateNewStateAfterOrder(
+			userAccount,
+			userPosition,
+			market,
+			order
+		);
+		if (newState === null) {
+			return false;
+		}
+		const [userAccountAfter, userPositionAfter, marketAfter] = newState;
+
+		const totalPositionValue = userPositionsAccount.positions.reduce(
+			(positionValue, marketPosition) => {
+				let market = this.clearingHouse.getMarket(marketPosition.marketIndex);
+				if (marketPosition.marketIndex.eq(order.marketIndex)) {
+					market = marketAfter;
+					marketPosition = userPositionAfter;
+				}
+
+				return positionValue.add(
+					calculateBaseAssetValue(market, marketPosition)
+				);
+			},
+			ZERO
+		);
+
+		if (totalPositionValue.eq(ZERO)) {
+			return true;
+		}
+
+		const unrealizedPnL = userPositionsAccount.positions.reduce(
+			(pnl, marketPosition) => {
+				let market = this.clearingHouse.getMarket(marketPosition.marketIndex);
+				pnl = pnl.add(
+					calculatePositionFundingPNL(market, marketPosition).div(
+						PRICE_TO_QUOTE_PRECISION
+					)
+				);
+
+				if (marketPosition.marketIndex.eq(order.marketIndex)) {
+					market = marketAfter;
+					marketPosition = userPositionAfter;
+				}
+
+				// update
+				return pnl.add(calculatePositionPNL(market, marketPosition, false));
+			},
+			ZERO
+		);
+		const totalCollateral = userAccountAfter.collateral.add(unrealizedPnL);
+
+		const marginRatioAfter = totalCollateral
+			.mul(TEN_THOUSAND)
+			.div(totalPositionValue);
+
+		const marginRatioInitial =
+			this.clearingHouse.getStateAccount().marginRatioInitial;
+		return marginRatioAfter.gte(marginRatioInitial);
+	}
 }

package/src/config.ts

@@ -11,7 +11,7 @@ export const configs: { [key in DriftEnv]: DriftConfig } = {
 	devnet: {
 		ENV: 'devnet',
 		PYTH_ORACLE_MAPPING_ADDRESS: 'BmA9Z6FjioHJPpjT39QazZyhDRUdZy2ezwx4GiDdE2u2',
-		CLEARING_HOUSE_PROGRAM_ID: 'AsW7LnXB9UA1uec9wi9MctYTgTz7YH9snhxd16GsFaGX',
+		CLEARING_HOUSE_PROGRAM_ID: '8mKouB1uzsoMAhAu4qAXCiu8KAfwH7nonpuYfTM21Xg2',
 		USDC_MINT_ADDRESS: '8zGuJQqwhZafTah7Uc7Z4tXRnguqkn5KLFAP8oV6PHe2',
 	},
 	'mainnet-beta': {

package/src/constants/markets.ts

@@ -91,11 +91,19 @@ export const Markets: Market[] = [
 		launchTs: 1643084413000,
 	},
 	{
-		symbol: 'mSOL-PERP',
-		baseAssetSymbol: 'mSOL',
+		symbol: 'ALGO-PERP',
+		baseAssetSymbol: 'ALGO',
 		marketIndex: new BN(10),
-		devnetPythOracle: '9a6RNx3tCu1TSs6TBSfV2XRXEPEZXQ6WB7jRojZRvyeZ',
-		mainnetPythOracle: 'E4v1BBgoso9s64TQvmyownAVJbhbEPGyzA3qn4n46qj9',
-		launchTs: 1643346125000,
+		devnetPythOracle: 'c1A946dY5NHuVda77C8XXtXytyR3wK1SCP3eA9VRfC3',
+		mainnetPythOracle: 'HqFyq1wh1xKvL7KDqqT7NJeSPdAqsDqnmBisUC2XdXAX',
+		launchTs: 1643686767000,
 	},
+	// {
+	// 	symbol: 'mSOL-PERP',
+	// 	baseAssetSymbol: 'mSOL',
+	// 	marketIndex: new BN(11), //todo
+	// 	devnetPythOracle: '9a6RNx3tCu1TSs6TBSfV2XRXEPEZXQ6WB7jRojZRvyeZ',
+	// 	mainnetPythOracle: 'E4v1BBgoso9s64TQvmyownAVJbhbEPGyzA3qn4n46qj9',
+	// 	launchTs: 1643346125000,
+	// },
 ];

package/src/factory/clearingHouse.ts

@@ -0,0 +1,125 @@
+import { ConfirmOptions, Connection, PublicKey } from '@solana/web3.js';
+import { IWallet } from '../types';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+import { TxSender } from '../tx/types';
+import { Idl, Program, Provider } from '@project-serum/anchor';
+import { ClearingHouse } from '../clearingHouse';
+import clearingHouseIDL from '../idl/clearing_house.json';
+import { WebSocketClearingHouseAccountSubscriber } from '../accounts/webSocketClearingHouseAccountSubscriber';
+import { DefaultTxSender } from '../tx/defaultTxSender';
+import { ClearingHouseAccountSubscriber } from '../accounts/types';
+import { PollingClearingHouseAccountSubscriber } from '../accounts/pollingClearingHouseAccountSubscriber';
+import { Admin } from '../admin';
+
+export type ClearingHouseConfigType = 'websocket' | 'polling' | 'custom';
+
+type BaseClearingHouseConfig = {
+	type: ClearingHouseConfigType;
+	connection: Connection;
+	wallet: IWallet;
+	programID: PublicKey;
+	opts?: ConfirmOptions;
+	txSender?: TxSender;
+};
+
+type WebSocketClearingHouseConfiguration = BaseClearingHouseConfig;
+
+type PollingClearingHouseConfiguration = BaseClearingHouseConfig & {
+	accountLoader: BulkAccountLoader;
+};
+
+type ClearingHouseConfig =
+	| PollingClearingHouseConfiguration
+	| WebSocketClearingHouseConfiguration;
+
+export function getWebSocketClearingHouseConfig(
+	connection: Connection,
+	wallet: IWallet,
+	programID: PublicKey,
+	opts: ConfirmOptions = Provider.defaultOptions(),
+	txSender?: TxSender
+): WebSocketClearingHouseConfiguration {
+	return {
+		type: 'websocket',
+		connection,
+		wallet,
+		programID,
+		opts,
+		txSender,
+	};
+}
+
+export function getPollingClearingHouseConfig(
+	connection: Connection,
+	wallet: IWallet,
+	programID: PublicKey,
+	accountLoader: BulkAccountLoader,
+	opts: ConfirmOptions = Provider.defaultOptions(),
+	txSender?: TxSender
+): PollingClearingHouseConfiguration {
+	return {
+		type: 'polling',
+		connection,
+		wallet,
+		programID,
+		accountLoader,
+		opts,
+		txSender,
+	};
+}
+
+export function getClearingHouse(config: ClearingHouseConfig): ClearingHouse {
+	const provider = new Provider(config.connection, config.wallet, config.opts);
+	const program = new Program(
+		clearingHouseIDL as Idl,
+		config.programID,
+		provider
+	);
+	let accountSubscriber: ClearingHouseAccountSubscriber;
+	if (config.type === 'websocket') {
+		accountSubscriber = new WebSocketClearingHouseAccountSubscriber(program);
+	} else if (config.type === 'polling') {
+		accountSubscriber = new PollingClearingHouseAccountSubscriber(
+			program,
+			(config as PollingClearingHouseConfiguration).accountLoader
+		);
+	}
+
+	const txSender = config.txSender || new DefaultTxSender(provider);
+	return new ClearingHouse(
+		config.connection,
+		config.wallet,
+		program,
+		accountSubscriber,
+		txSender,
+		config.opts
+	);
+}
+
+export function getAdmin(config: ClearingHouseConfig): Admin {
+	const provider = new Provider(config.connection, config.wallet, config.opts);
+	const program = new Program(
+		clearingHouseIDL as Idl,
+		config.programID,
+		provider
+	);
+	let accountSubscriber: ClearingHouseAccountSubscriber;
+	if (config.type === 'websocket') {
+		accountSubscriber = new WebSocketClearingHouseAccountSubscriber(program);
+	} else if (config.type === 'polling') {
+		accountSubscriber = new PollingClearingHouseAccountSubscriber(
+			program,
+			(config as PollingClearingHouseConfiguration).accountLoader
+		);
+	}
+
+	const txSender = config.txSender || new DefaultTxSender(provider);
+	return new Admin(
+		config.connection,
+		config.wallet,
+		program,
+		accountSubscriber,
+		txSender,
+		config.opts
+	);
+}

package/src/factory/clearingHouseUser.ts

@@ -0,0 +1,73 @@
+import { PublicKey } from '@solana/web3.js';
+import { ClearingHouse } from '../clearingHouse';
+import { BulkAccountLoader } from '../accounts/bulkAccountLoader';
+import { ClearingHouseUser } from '../clearingHouseUser';
+import { UserAccountSubscriber } from '../accounts/types';
+import { WebSocketUserAccountSubscriber } from '../accounts/webSocketUserAccountSubscriber';
+import { PollingUserAccountSubscriber } from '../accounts/pollingUserAccountSubscriber';
+
+export type ClearingHouseUserConfigType = 'websocket' | 'polling' | 'custom';
+
+type BaseClearingHouseUserConfig = {
+	type: ClearingHouseUserConfigType;
+	clearingHouse: ClearingHouse;
+	authority: PublicKey;
+};
+
+type WebSocketClearingHouseUserConfig = BaseClearingHouseUserConfig;
+
+type PollingClearingHouseUserConfig = BaseClearingHouseUserConfig & {
+	accountLoader: BulkAccountLoader;
+};
+
+type ClearingHouseUserConfig =
+	| PollingClearingHouseUserConfig
+	| WebSocketClearingHouseUserConfig;
+
+export function getWebSocketClearingHouseUserConfig(
+	clearingHouse: ClearingHouse,
+	authority: PublicKey
+): WebSocketClearingHouseUserConfig {
+	return {
+		type: 'websocket',
+		clearingHouse,
+		authority,
+	};
+}
+
+export function getPollingClearingHouseUserConfig(
+	clearingHouse: ClearingHouse,
+	authority: PublicKey,
+	accountLoader: BulkAccountLoader
+): PollingClearingHouseUserConfig {
+	return {
+		type: 'polling',
+		clearingHouse,
+		authority,
+		accountLoader,
+	};
+}
+
+export function getClearingHouseUser(
+	config: ClearingHouseUserConfig
+): ClearingHouseUser {
+	let accountSubscriber: UserAccountSubscriber;
+	if (config.type === 'websocket') {
+		accountSubscriber = new WebSocketUserAccountSubscriber(
+			config.clearingHouse.program,
+			config.authority
+		);
+	} else if (config.type === 'polling') {
+		accountSubscriber = new PollingUserAccountSubscriber(
+			config.clearingHouse.program,
+			config.authority,
+			(config as PollingClearingHouseUserConfig).accountLoader
+		);
+	}
+
+	return new ClearingHouseUser(
+		config.clearingHouse,
+		config.authority,
+		accountSubscriber
+	);
+}