@drift-labs/sdk 0.1.19-master.2 → 0.1.21-master.4

package/src/clearingHouseUser.ts

@@ -1,10 +1,15 @@
 import { PublicKey } from '@solana/web3.js';
-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 +23,58 @@ 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,
+	BN,
 } 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 | undefined {
+		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,30 @@ 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)
+		);
+	}
+
+	/**
+	 * @param userOrderId
+	 * @returns Order
+	 */
+	public getOrderByUserOrderId(userOrderId: number): Order | undefined {
+		return this.getUserOrdersAccount().orders.find(
+			(order) => order.userOrderId === userOrderId
+		);
+	}
+
 	public async getUserAccountPublicKey(): Promise<PublicKey> {
 		if (this.userAccountPublicKey) {
 			return this.userAccountPublicKey;
@@ -123,6 +177,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 +484,7 @@ export class ClearingHouseUser {
 			),
 			lastCumulativeFundingRate: new BN(0),
 			quoteAssetAmount: new BN(0),
+			openOrders: new BN(0),
 		};
 
 		const market = this.clearingHouse.getMarket(
@@ -508,14 +575,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 +613,7 @@ export class ClearingHouseUser {
 			lastCumulativeFundingRate:
 				currentMarketPosition.lastCumulativeFundingRate,
 			quoteAssetAmount: new BN(0),
+			openOrders: new BN(0),
 		};
 
 		const market = this.clearingHouse.getMarket(
@@ -680,7 +748,7 @@ export class ClearingHouseUser {
 	 * Case 4: NOT SameSide && currentLeverage > maxLeverage && otherPositions - currentPosition < maxLeverage
 	 * 	=> current position + remaining to get to maxLeverage
 	 *
-	 * @param marketIndex
+	 * @param targetMarketIndex
 	 * @param tradeSide
 	 * @param userMaxLeverageSetting - leverage : Precision TEN_THOUSAND
 	 * @returns tradeSizeAllowed : Precision QUOTE_PRECISION
@@ -822,7 +890,6 @@ export class ClearingHouseUser {
 			this.getTotalPositionValueExcludingMarket(targetMarketIndex);
 
 		const totalCollateral = this.getTotalCollateral();
-
 		if (totalCollateral.gt(ZERO)) {
 			const newLeverage = currentMarketPositionAfterTrade
 				.add(totalPositionAfterTradeExcludingTargetMarket)
@@ -865,4 +932,74 @@ export class ClearingHouseUser {
 
 		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/constants/markets.ts

@@ -1,4 +1,4 @@
-import BN from 'bn.js';
+import { BN } from '../';
 
 type Market = {
 	symbol: string;
@@ -98,6 +98,22 @@ export const Markets: Market[] = [
 		mainnetPythOracle: 'HqFyq1wh1xKvL7KDqqT7NJeSPdAqsDqnmBisUC2XdXAX',
 		launchTs: 1643686767000,
 	},
+	{
+		symbol: 'FTT-PERP',
+		baseAssetSymbol: 'FTT',
+		marketIndex: new BN(11),
+		devnetPythOracle: '6vivTRs5ZPeeXbjo7dfburfaYDWoXjBtdtuYgQRuGfu',
+		mainnetPythOracle: '8JPJJkmDScpcNmBRKGZuPuG2GYAveQgP3t5gFuMymwvF',
+		launchTs: 1644382122000,
+	},
+	{
+		symbol: 'LTC-PERP',
+		baseAssetSymbol: 'LTC',
+		marketIndex: new BN(12),
+		devnetPythOracle: 'BLArYBCUYhdWiY8PCUTpvFE21iaJq85dvxLk9bYMobcU',
+		mainnetPythOracle: '8RMnV1eD55iqUFJLMguPkYBkq8DCtx81XcmAja93LvRR',
+		launchTs: 1645027429000,
+	},
 	// {
 	// 	symbol: 'mSOL-PERP',
 	// 	baseAssetSymbol: 'mSOL',

package/src/constants/numericConstants.ts

@@ -1,7 +1,8 @@
-import BN from 'bn.js';
+import { BN } from '../';
 
 export const ZERO = new BN(0);
 export const ONE = new BN(1);
+export const TWO = new BN(2);
 export const TEN_THOUSAND = new BN(10000);
 export const BN_MAX = new BN(Number.MAX_SAFE_INTEGER);
 
@@ -15,6 +16,7 @@ export const FUNDING_PAYMENT_PRECISION = new BN(10000);
 export const PEG_PRECISION = new BN(1000);
 
 export const AMM_RESERVE_PRECISION = new BN(10 ** 13);
+export const BASE_PRECISION = AMM_RESERVE_PRECISION;
 export const AMM_TO_QUOTE_PRECISION_RATIO =
 	AMM_RESERVE_PRECISION.div(QUOTE_PRECISION); // 10^7
 export const PRICE_TO_QUOTE_PRECISION =

package/src/examples/makeTradeExample.ts

@@ -95,7 +95,10 @@ const main = async () => {
 		clearingHouse.getMarket(solMarketInfo.marketIndex)
 	);
 
-	const formattedPrice = convertToNumber(currentMarketPrice, QUOTE_PRECISION);
+	const formattedPrice = convertToNumber(
+		currentMarketPrice,
+		MARK_PRICE_PRECISION
+	);
 
 	console.log(`Current Market Price is $${formattedPrice}`);
 

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