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

package/src/accounts/defaultHistoryAccountSubscriber.ts

@@ -0,0 +1,176 @@
+import { ClearingHouseAccountEvents, HistoryAccountSubscriber } from './types';
+import { AccountSubscriber, NotSubscribedError } from './types';
+import {
+	CurveHistoryAccount,
+	DepositHistoryAccount,
+	FundingPaymentHistoryAccount,
+	FundingRateHistoryAccount,
+	LiquidationHistoryAccount,
+	TradeHistoryAccount,
+} from '../types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { getClearingHouseStateAccountPublicKey } from '../addresses';
+import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
+
+export class DefaultHistoryAccountSubscriber
+	implements HistoryAccountSubscriber
+{
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
+	tradeHistoryAccountSubscriber?: AccountSubscriber<TradeHistoryAccount>;
+	depositHistoryAccountSubscriber?: AccountSubscriber<DepositHistoryAccount>;
+	fundingPaymentHistoryAccountSubscriber?: AccountSubscriber<FundingPaymentHistoryAccount>;
+	fundingRateHistoryAccountSubscriber?: AccountSubscriber<FundingRateHistoryAccount>;
+	curveHistoryAccountSubscriber?: AccountSubscriber<CurveHistoryAccount>;
+	liquidationHistoryAccountSubscriber?: AccountSubscriber<LiquidationHistoryAccount>;
+
+	public constructor(program: Program) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.eventEmitter = new EventEmitter();
+	}
+
+	public async subscribe(): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		const statePublicKey = await getClearingHouseStateAccountPublicKey(
+			this.program.programId
+		);
+		const state: any = await this.program.account.state.fetch(statePublicKey);
+
+		this.tradeHistoryAccountSubscriber = new WebSocketAccountSubscriber(
+			'tradeHistory',
+			this.program,
+			state.tradeHistory
+		);
+		await this.tradeHistoryAccountSubscriber.subscribe(
+			(data: TradeHistoryAccount) => {
+				this.eventEmitter.emit('tradeHistoryAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.depositHistoryAccountSubscriber = new WebSocketAccountSubscriber(
+			'depositHistory',
+			this.program,
+			state.depositHistory
+		);
+		await this.depositHistoryAccountSubscriber.subscribe(
+			(data: DepositHistoryAccount) => {
+				this.eventEmitter.emit('depositHistoryAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.fundingPaymentHistoryAccountSubscriber =
+			new WebSocketAccountSubscriber(
+				'fundingPaymentHistory',
+				this.program,
+				state.fundingPaymentHistory
+			);
+		await this.fundingPaymentHistoryAccountSubscriber.subscribe(
+			(data: FundingPaymentHistoryAccount) => {
+				this.eventEmitter.emit('fundingPaymentHistoryAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.fundingRateHistoryAccountSubscriber = new WebSocketAccountSubscriber(
+			'fundingRateHistory',
+			this.program,
+			state.fundingRateHistory
+		);
+		await this.fundingRateHistoryAccountSubscriber.subscribe(
+			(data: FundingRateHistoryAccount) => {
+				this.eventEmitter.emit('fundingRateHistoryAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.liquidationHistoryAccountSubscriber = new WebSocketAccountSubscriber(
+			'liquidationHistory',
+			this.program,
+			state.liquidationHistory
+		);
+		await this.liquidationHistoryAccountSubscriber.subscribe(
+			(data: LiquidationHistoryAccount) => {
+				this.eventEmitter.emit('liquidationHistoryAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.curveHistoryAccountSubscriber = new WebSocketAccountSubscriber(
+			'curveHistory',
+			this.program,
+			state.curveHistory
+		);
+		await this.curveHistoryAccountSubscriber.subscribe(
+			(data: CurveHistoryAccount) => {
+				this.eventEmitter.emit('curveHistoryAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.eventEmitter.emit('update');
+
+		this.isSubscribed = true;
+		return true;
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		await this.tradeHistoryAccountSubscriber.unsubscribe();
+		await this.fundingRateHistoryAccountSubscriber.unsubscribe();
+		await this.fundingPaymentHistoryAccountSubscriber.unsubscribe();
+		await this.depositHistoryAccountSubscriber.unsubscribe();
+		await this.curveHistoryAccountSubscriber.unsubscribe();
+		await this.liquidationHistoryAccountSubscriber.unsubscribe();
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getTradeHistoryAccount(): TradeHistoryAccount {
+		this.assertIsSubscribed();
+		return this.tradeHistoryAccountSubscriber.data;
+	}
+
+	public getDepositHistoryAccount(): DepositHistoryAccount {
+		this.assertIsSubscribed();
+		return this.depositHistoryAccountSubscriber.data;
+	}
+
+	public getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount {
+		this.assertIsSubscribed();
+		return this.fundingPaymentHistoryAccountSubscriber.data;
+	}
+
+	public getFundingRateHistoryAccount(): FundingRateHistoryAccount {
+		this.assertIsSubscribed();
+		return this.fundingRateHistoryAccountSubscriber.data;
+	}
+
+	public getCurveHistoryAccount(): CurveHistoryAccount {
+		this.assertIsSubscribed();
+		return this.curveHistoryAccountSubscriber.data;
+	}
+
+	public getLiquidationHistoryAccount(): LiquidationHistoryAccount {
+		this.assertIsSubscribed();
+		return this.liquidationHistoryAccountSubscriber.data;
+	}
+}

package/src/accounts/defaultUserAccountSubscriber.ts

@@ -8,9 +8,12 @@ import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
-import { getUserAccountPublicKey } from '../addresses';
+import {
+	getUserAccountPublicKey,
+	getUserOrdersAccountPublicKey,
+} from '../addresses';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
-import { UserAccount, UserPositionsAccount } from '../types';
+import { UserAccount, UserOrdersAccount, UserPositionsAccount } from '../types';
 
 export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 	isSubscribed: boolean;
@@ -20,6 +23,7 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 
 	userDataAccountSubscriber: AccountSubscriber<UserAccount>;
 	userPositionsAccountSubscriber: AccountSubscriber<UserPositionsAccount>;
+	userOrdersAccountSubscriber: AccountSubscriber<UserOrdersAccount>;
 
 	public constructor(program: Program, authority: PublicKey) {
 		this.isSubscribed = false;
@@ -61,6 +65,23 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 			}
 		);
 
+		const userOrdersPublicKey = await getUserOrdersAccountPublicKey(
+			this.program.programId,
+			this.authority
+		);
+
+		this.userOrdersAccountSubscriber = new WebSocketAccountSubscriber(
+			'userOrders',
+			this.program,
+			userOrdersPublicKey
+		);
+		await this.userOrdersAccountSubscriber.subscribe(
+			(data: UserOrdersAccount) => {
+				this.eventEmitter.emit('userOrdersData', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
 		this.eventEmitter.emit('update');
 		this.isSubscribed = true;
 		return true;
@@ -70,6 +91,7 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 		await Promise.all([
 			this.userDataAccountSubscriber.fetch(),
 			this.userPositionsAccountSubscriber.fetch(),
+			this.userOrdersAccountSubscriber.fetch(),
 		]);
 	}
 
@@ -78,8 +100,9 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 			return;
 		}
 
-		await this.userDataAccountSubscriber.unsubscribe();
-		await this.userPositionsAccountSubscriber.unsubscribe();
+		this.userDataAccountSubscriber.unsubscribe();
+		this.userPositionsAccountSubscriber.unsubscribe();
+		this.userOrdersAccountSubscriber.unsubscribe();
 
 		this.isSubscribed = false;
 	}
@@ -101,4 +124,8 @@ export class DefaultUserAccountSubscriber implements UserAccountSubscriber {
 		this.assertIsSubscribed();
 		return this.userPositionsAccountSubscriber.data;
 	}
+
+	public getUserOrdersAccount(): UserOrdersAccount {
+		return this.userOrdersAccountSubscriber.data;
+	}
 }

package/src/accounts/types.ts

@@ -1,13 +1,16 @@
 import {
+	CurveHistoryAccount,
 	DepositHistoryAccount,
-	ExtendedCurveHistoryAccount,
 	FundingPaymentHistoryAccount,
 	FundingRateHistoryAccount,
 	LiquidationHistoryAccount,
 	MarketsAccount,
+	OrderHistoryAccount,
+	OrderStateAccount,
 	StateAccount,
 	TradeHistoryAccount,
 	UserAccount,
+	UserOrdersAccount,
 	UserPositionsAccount,
 } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
@@ -17,7 +20,7 @@ export interface AccountSubscriber<T> {
 	data?: T;
 	subscribe(onChange: (data: T) => void): Promise<void>;
 	fetch(): Promise<void>;
-	unsubscribe(): Promise<void>;
+	unsubscribe(): void;
 }
 
 export class NotSubscribedError extends Error {
@@ -34,7 +37,9 @@ export interface ClearingHouseAccountEvents {
 	tradeHistoryAccountUpdate: (payload: TradeHistoryAccount) => void;
 	liquidationHistoryAccountUpdate: (payload: LiquidationHistoryAccount) => void;
 	depositHistoryAccountUpdate: (payload: DepositHistoryAccount) => void;
-	curveHistoryAccountUpdate: (payload: ExtendedCurveHistoryAccount) => void;
+	curveHistoryAccountUpdate: (payload: CurveHistoryAccount) => void;
+	orderHistoryAccountUpdate: (payload: OrderHistoryAccount) => void;
+	orderStateAccountUpdate: (payload: OrderStateAccount) => void;
 	update: void;
 }
 
@@ -44,7 +49,8 @@ export type ClearingHouseAccountTypes =
 	| 'fundingPaymentHistoryAccount'
 	| 'fundingRateHistoryAccount'
 	| 'curveHistoryAccount'
-	| 'liquidationHistoryAccount';
+	| 'liquidationHistoryAccount'
+	| 'orderHistoryAccount';
 
 export interface ClearingHouseAccountSubscriber {
 	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
@@ -64,13 +70,43 @@ export interface ClearingHouseAccountSubscriber {
 	getDepositHistoryAccount(): DepositHistoryAccount;
 	getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount;
 	getFundingRateHistoryAccount(): FundingRateHistoryAccount;
-	getCurveHistoryAccount(): ExtendedCurveHistoryAccount;
+	getCurveHistoryAccount(): CurveHistoryAccount;
+	getLiquidationHistoryAccount(): LiquidationHistoryAccount;
+	getOrderStateAccount(): OrderStateAccount;
+	getOrderHistoryAccount(): OrderHistoryAccount;
+}
+
+export interface HistoryAccountEvents {
+	fundingPaymentHistoryAccountUpdate: (
+		payload: FundingPaymentHistoryAccount
+	) => void;
+	fundingRateHistoryAccountUpdate: (payload: FundingRateHistoryAccount) => void;
+	tradeHistoryAccountUpdate: (payload: TradeHistoryAccount) => void;
+	liquidationHistoryAccountUpdate: (payload: LiquidationHistoryAccount) => void;
+	depositHistoryAccountUpdate: (payload: DepositHistoryAccount) => void;
+	curveHistoryAccountUpdate: (payload: CurveHistoryAccount) => void;
+	update: void;
+}
+
+export interface HistoryAccountSubscriber {
+	eventEmitter: StrictEventEmitter<EventEmitter, HistoryAccountEvents>;
+	isSubscribed: boolean;
+
+	subscribe(): Promise<boolean>;
+	unsubscribe(): Promise<void>;
+
+	getTradeHistoryAccount(): TradeHistoryAccount;
+	getDepositHistoryAccount(): DepositHistoryAccount;
+	getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount;
+	getFundingRateHistoryAccount(): FundingRateHistoryAccount;
+	getCurveHistoryAccount(): CurveHistoryAccount;
 	getLiquidationHistoryAccount(): LiquidationHistoryAccount;
 }
 
 export interface UserAccountEvents {
 	userAccountData: (payload: UserAccount) => void;
 	userPositionsData: (payload: UserPositionsAccount) => void;
+	userOrdersData: (payload: UserOrdersAccount) => void;
 	update: void;
 }
 
@@ -84,4 +120,5 @@ export interface UserAccountSubscriber {
 
 	getUserAccount(): UserAccount;
 	getUserPositionsAccount(): UserPositionsAccount;
+	getUserOrdersAccount(): UserOrdersAccount;
 }

package/src/addresses.ts

@@ -10,6 +10,21 @@ export async function getClearingHouseStateAccountPublicKeyAndNonce(
 	);
 }
 
+export async function getOrderStateAccountPublicKey(
+	programId: PublicKey
+): Promise<PublicKey> {
+	return (await getOrderStateAccountPublicKeyAndNonce(programId))[0];
+}
+
+export async function getOrderStateAccountPublicKeyAndNonce(
+	programId: PublicKey
+): Promise<[PublicKey, number]> {
+	return anchor.web3.PublicKey.findProgramAddress(
+		[Buffer.from(anchor.utils.bytes.utf8.encode('order_state'))],
+		programId
+	);
+}
+
 export async function getClearingHouseStateAccountPublicKey(
 	programId: PublicKey
 ): Promise<PublicKey> {
@@ -32,3 +47,23 @@ export async function getUserAccountPublicKey(
 ): Promise<PublicKey> {
 	return (await getUserAccountPublicKeyAndNonce(programId, authority))[0];
 }
+
+export async function getUserOrdersAccountPublicKeyAndNonce(
+	programId: PublicKey,
+	authority: PublicKey
+): Promise<[PublicKey, number]> {
+	return anchor.web3.PublicKey.findProgramAddress(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('user_orders')),
+			authority.toBuffer(),
+		],
+		programId
+	);
+}
+
+export async function getUserOrdersAccountPublicKey(
+	programId: PublicKey,
+	authority: PublicKey
+): Promise<PublicKey> {
+	return (await getUserOrdersAccountPublicKeyAndNonce(programId, authority))[0];
+}

package/src/admin.ts

@@ -5,10 +5,20 @@ import {
 	SYSVAR_RENT_PUBKEY,
 	TransactionSignature,
 } from '@solana/web3.js';
-import { FeeStructure, IWallet, OracleGuardRails, OracleSource } from './types';
+import {
+	FeeStructure,
+	IWallet,
+	OracleGuardRails,
+	OracleSource,
+	OrderFillerRewardStructure,
+} from './types';
 import { BN, Idl, Program, Provider } from '@project-serum/anchor';
 import * as anchor from '@project-serum/anchor';
-import { getClearingHouseStateAccountPublicKeyAndNonce } from './addresses';
+import {
+	getClearingHouseStateAccountPublicKey,
+	getClearingHouseStateAccountPublicKeyAndNonce,
+	getOrderStateAccountPublicKeyAndNonce,
+} from './addresses';
 import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { ClearingHouse } from './clearingHouse';
 import { PEG_PRECISION } from './constants/numericConstants';
@@ -48,7 +58,9 @@ export class Admin extends ClearingHouse {
 	public async initialize(
 		usdcMint: PublicKey,
 		adminControlsPrices: boolean
-	): Promise<[TransactionSignature, TransactionSignature]> {
+	): Promise<
+		[TransactionSignature, TransactionSignature, TransactionSignature]
+	> {
 		const stateAccountRPCResponse = await this.connection.getParsedAccountInfo(
 			await this.getStatePublicKey()
 		);
@@ -153,7 +165,7 @@ export class Admin extends ClearingHouse {
 					await this.program.account.depositHistory.createInstruction(
 						depositHistory
 					),
-					await this.program.account.extendedCurveHistory.createInstruction(
+					await this.program.account.curveHistory.createInstruction(
 						curveHistory
 					),
 				],
@@ -172,7 +184,40 @@ export class Admin extends ClearingHouse {
 			this.opts
 		);
 
-		return [initializeTxSig, initializeHistoryTxSig];
+		const initializeOrderStateTxSig = await this.initializeOrderState();
+
+		return [initializeTxSig, initializeHistoryTxSig, initializeOrderStateTxSig];
+	}
+
+	public async initializeOrderState(): Promise<TransactionSignature> {
+		const orderHistory = anchor.web3.Keypair.generate();
+		const [orderStatePublicKey, orderStateNonce] =
+			await getOrderStateAccountPublicKeyAndNonce(this.program.programId);
+		const clearingHouseStatePublicKey =
+			await getClearingHouseStateAccountPublicKey(this.program.programId);
+
+		const initializeOrderStateTx =
+			await this.program.transaction.initializeOrderState(orderStateNonce, {
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: clearingHouseStatePublicKey,
+					orderHistory: orderHistory.publicKey,
+					orderState: orderStatePublicKey,
+					rent: SYSVAR_RENT_PUBKEY,
+					systemProgram: anchor.web3.SystemProgram.programId,
+				},
+				instructions: [
+					await this.program.account.orderHistory.createInstruction(
+						orderHistory
+					),
+				],
+			});
+
+		return await this.txSender.send(
+			initializeOrderStateTx,
+			[orderHistory],
+			this.opts
+		);
 	}
 
 	public async initializeMarket(
@@ -230,38 +275,13 @@ export class Admin extends ClearingHouse {
 		marketIndex: BN
 	): Promise<TransactionSignature> {
 		const state = this.getStateAccount();
-		const markets = this.getMarketsAccount();
-		const marketData = markets.markets[marketIndex.toNumber()];
-		const ammData = marketData.amm;
-
 		return await this.program.rpc.updateK(sqrtK, marketIndex, {
 			accounts: {
 				state: await this.getStatePublicKey(),
 				admin: this.wallet.publicKey,
 				markets: state.markets,
-				curveHistory: state.extendedCurveHistory,
-				oracle: ammData.oracle,
-			},
-		});
-	}
-
-	public async updateCurveHistory(): Promise<TransactionSignature> {
-		const extendedCurveHistory = anchor.web3.Keypair.generate();
-
-		const state = this.getStateAccount();
-		return await this.program.rpc.updateCurveHistory({
-			accounts: {
-				state: await this.getStatePublicKey(),
-				admin: this.wallet.publicKey,
 				curveHistory: state.curveHistory,
-				extendedCurveHistory: extendedCurveHistory.publicKey,
 			},
-			instructions: [
-				await this.program.account.extendedCurveHistory.createInstruction(
-					extendedCurveHistory
-				),
-			],
-			signers: [extendedCurveHistory],
 		});
 	}
 
@@ -314,7 +334,7 @@ export class Admin extends ClearingHouse {
 				admin: this.wallet.publicKey,
 				oracle: ammData.oracle,
 				markets: state.markets,
-				curveHistory: state.extendedCurveHistory,
+				curveHistory: state.curveHistory,
 			},
 		});
 	}
@@ -480,6 +500,21 @@ export class Admin extends ClearingHouse {
 		);
 	}
 
+	public async updateOrderFillerRewardStructure(
+		orderFillerRewardStructure: OrderFillerRewardStructure
+	): Promise<TransactionSignature> {
+		return await this.program.rpc.updateOrderFillerRewardStructure(
+			orderFillerRewardStructure,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					orderState: await this.getOrderStatePublicKey(),
+				},
+			}
+		);
+	}
+
 	public async updateFee(fees: FeeStructure): Promise<TransactionSignature> {
 		return await this.program.rpc.updateFee(fees, {
 			accounts: {
@@ -520,12 +555,30 @@ export class Admin extends ClearingHouse {
 		);
 	}
 
-	public async updateMarketMinimumTradeSize(
+	public async updateMarketMinimumQuoteAssetTradeSize(
+		marketIndex: BN,
+		minimumTradeSize: BN
+	): Promise<TransactionSignature> {
+		const state = this.getStateAccount();
+		return await this.program.rpc.updateMarketMinimumQuoteAssetTradeSize(
+			marketIndex,
+			minimumTradeSize,
+			{
+				accounts: {
+					admin: this.wallet.publicKey,
+					state: await this.getStatePublicKey(),
+					markets: state.markets,
+				},
+			}
+		);
+	}
+
+	public async updateMarketMinimumBaseAssetTradeSize(
 		marketIndex: BN,
 		minimumTradeSize: BN
 	): Promise<TransactionSignature> {
 		const state = this.getStateAccount();
-		return await this.program.rpc.updateMarketMinimumTradeSize(
+		return await this.program.rpc.updateMarketMinimumBaseAssetTradeSize(
 			marketIndex,
 			minimumTradeSize,
 			{