@drift-labs/sdk 0.1.21-master.0 → 0.1.21-master.3

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, 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';
@@ -38,7 +48,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()
 		);
@@ -162,7 +174,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(
@@ -508,6 +553,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: {
@@ -548,12 +608,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,
 			{

package/src/clearingHouse.ts

@@ -16,6 +16,10 @@ import {
 	TradeHistoryAccount,
 	UserAccount,
 	Market,
+	OrderHistoryAccount,
+	OrderStateAccount,
+	OrderParams,
+	Order,
 	ExtendedCurveHistoryAccount,
 } from './types';
 import * as anchor from '@project-serum/anchor';
@@ -36,8 +40,11 @@ import { EventEmitter } from 'events';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import {
 	getClearingHouseStateAccountPublicKey,
+	getOrderStateAccountPublicKey,
 	getUserAccountPublicKey,
 	getUserAccountPublicKeyAndNonce,
+	getUserOrdersAccountPublicKey,
+	getUserOrdersAccountPublicKeyAndNonce,
 } from './addresses';
 import {
 	ClearingHouseAccountSubscriber,
@@ -144,6 +151,7 @@ export class ClearingHouse {
 			'fundingRateHistoryAccount',
 			'liquidationHistoryAccount',
 			'tradeHistoryAccount',
+			'orderHistoryAccount',
 		]);
 	}
 
@@ -212,6 +220,25 @@ export class ClearingHouse {
 		return this.accountSubscriber.getCurveHistoryAccount();
 	}
 
+	public getOrderHistoryAccount(): OrderHistoryAccount {
+		return this.accountSubscriber.getOrderHistoryAccount();
+	}
+
+	orderStatePublicKey?: PublicKey;
+	public async getOrderStatePublicKey(): Promise<PublicKey> {
+		if (this.orderStatePublicKey) {
+			return this.orderStatePublicKey;
+		}
+		this.orderStatePublicKey = await getOrderStateAccountPublicKey(
+			this.program.programId
+		);
+		return this.orderStatePublicKey;
+	}
+
+	public getOrderStateAccount(): OrderStateAccount {
+		return this.accountSubscriber.getOrderStateAccount();
+	}
+
 	/**
 	 * Update the wallet to use for clearing house transactions and linked user account
 	 * @param newWallet
@@ -240,9 +267,12 @@ export class ClearingHouse {
 			userPositionsAccount,
 			userAccountPublicKey,
 			initializeUserAccountIx,
+			initializeUserOrdersAccountIx,
 		] = await this.getInitializeUserInstructions();
 
-		const tx = new Transaction().add(initializeUserAccountIx);
+		const tx = new Transaction()
+			.add(initializeUserAccountIx)
+			.add(initializeUserOrdersAccountIx);
 		const txSig = await this.txSender.send(
 			tx,
 			[userPositionsAccount],
@@ -252,9 +282,9 @@ export class ClearingHouse {
 	}
 
 	async getInitializeUserInstructions(): Promise<
-		[Keypair, PublicKey, TransactionInstruction]
+		[Keypair, PublicKey, TransactionInstruction, TransactionInstruction]
 	> {
-		const [userPublicKey, userAccountNonce] =
+		const [userAccountPublicKey, userAccountNonce] =
 			await getUserAccountPublicKeyAndNonce(
 				this.program.programId,
 				this.wallet.publicKey
@@ -288,7 +318,7 @@ export class ClearingHouse {
 				optionalAccounts,
 				{
 					accounts: {
-						user: userPublicKey,
+						user: userAccountPublicKey,
 						authority: this.wallet.publicKey,
 						rent: anchor.web3.SYSVAR_RENT_PUBKEY,
 						systemProgram: anchor.web3.SystemProgram.programId,
@@ -298,7 +328,44 @@ export class ClearingHouse {
 					remainingAccounts: remainingAccounts,
 				}
 			);
-		return [userPositions, userPublicKey, initializeUserAccountIx];
+
+		const initializeUserOrdersAccountIx =
+			await this.getInitializeUserOrdersInstruction(userAccountPublicKey);
+
+		return [
+			userPositions,
+			userAccountPublicKey,
+			initializeUserAccountIx,
+			initializeUserOrdersAccountIx,
+		];
+	}
+
+	async getInitializeUserOrdersInstruction(
+		userAccountPublicKey?: PublicKey
+	): Promise<TransactionInstruction> {
+		if (!userAccountPublicKey) {
+			userAccountPublicKey = await this.getUserAccountPublicKey();
+		}
+
+		const [userOrdersAccountPublicKey, userOrdersAccountNonce] =
+			await getUserOrdersAccountPublicKeyAndNonce(
+				this.program.programId,
+				userAccountPublicKey
+			);
+
+		return await this.program.instruction.initializeUserOrders(
+			userOrdersAccountNonce,
+			{
+				accounts: {
+					user: userAccountPublicKey,
+					authority: this.wallet.publicKey,
+					rent: anchor.web3.SYSVAR_RENT_PUBKEY,
+					systemProgram: anchor.web3.SystemProgram.programId,
+					userOrders: userOrdersAccountPublicKey,
+					state: await this.getStatePublicKey(),
+				},
+			}
+		);
 	}
 
 	userAccountPublicKey?: PublicKey;
@@ -330,6 +397,37 @@ export class ClearingHouse {
 		return this.userAccount;
 	}
 
+	userOrdersAccountPublicKey?: PublicKey;
+	/**
+	 * Get the address for the Clearing House User Order's account. NOT the user's wallet address.
+	 * @returns
+	 */
+	public async getUserOrdersAccountPublicKey(): Promise<PublicKey> {
+		if (this.userOrdersAccountPublicKey) {
+			return this.userOrdersAccountPublicKey;
+		}
+
+		this.userOrdersAccountPublicKey = await getUserOrdersAccountPublicKey(
+			this.program.programId,
+			await this.getUserAccountPublicKey()
+		);
+		return this.userOrdersAccountPublicKey;
+	}
+
+	userOrdersExist?: boolean;
+	async userOrdersAccountExists(): Promise<boolean> {
+		if (this.userOrdersExist) {
+			return this.userOrdersExist;
+		}
+		const userOrdersAccountRPCResponse =
+			await this.connection.getParsedAccountInfo(
+				await this.getUserOrdersAccountPublicKey()
+			);
+
+		this.userOrdersExist = userOrdersAccountRPCResponse.value !== null;
+		return this.userOrdersExist;
+	}
+
 	public async depositCollateral(
 		amount: BN,
 		collateralAccountPublicKey: PublicKey,
@@ -387,6 +485,7 @@ export class ClearingHouse {
 			userPositionsAccount,
 			userAccountPublicKey,
 			initializeUserAccountIx,
+			initializeUserOrdersAccountIx,
 		] = await this.getInitializeUserInstructions();
 
 		const depositCollateralIx = await this.getDepositCollateralInstruction(
@@ -397,6 +496,7 @@ export class ClearingHouse {
 
 		const tx = new Transaction()
 			.add(initializeUserAccountIx)
+			.add(initializeUserOrdersAccountIx)
 			.add(depositCollateralIx);
 
 		const txSig = await this.program.provider.send(tx, [userPositionsAccount]);
@@ -418,6 +518,7 @@ export class ClearingHouse {
 			userPositionsAccount,
 			userAccountPublicKey,
 			initializeUserAccountIx,
+			initializeUserOrdersAccountIx,
 		] = await this.getInitializeUserInstructions();
 
 		const depositCollateralIx = await this.getDepositCollateralInstruction(
@@ -430,6 +531,7 @@ export class ClearingHouse {
 			.add(createAssociatedAccountIx)
 			.add(mintToIx)
 			.add(initializeUserAccountIx)
+			.add(initializeUserOrdersAccountIx)
 			.add(depositCollateralIx);
 
 		const txSig = await this.program.provider.send(tx, [userPositionsAccount]);
@@ -580,6 +682,329 @@ export class ClearingHouse {
 		);
 	}
 
+	public async initializeUserOrdersThenPlaceOrder(
+		orderParams: OrderParams,
+		discountToken?: PublicKey,
+		referrer?: PublicKey
+	): Promise<TransactionSignature> {
+		const instructions: anchor.web3.TransactionInstruction[] = [];
+		const userOrdersAccountExists = await this.userOrdersAccountExists();
+		if (!userOrdersAccountExists) {
+			instructions.push(await this.getInitializeUserOrdersInstruction());
+		}
+		instructions.push(
+			await this.getPlaceOrderIx(orderParams, discountToken, referrer)
+		);
+		const tx = new Transaction();
+		for (const instruction of instructions) {
+			tx.add(instruction);
+		}
+
+		return await this.txSender.send(tx, [], this.opts);
+	}
+
+	public async placeOrder(
+		orderParams: OrderParams,
+		discountToken?: PublicKey,
+		referrer?: PublicKey
+	): Promise<TransactionSignature> {
+		return await this.txSender.send(
+			wrapInTx(
+				await this.getPlaceOrderIx(orderParams, discountToken, referrer)
+			),
+			[],
+			this.opts
+		);
+	}
+
+	public async getPlaceOrderIx(
+		orderParams: OrderParams,
+		discountToken?: PublicKey,
+		referrer?: PublicKey
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const userAccount = await this.getUserAccount();
+
+		const priceOracle =
+			this.getMarketsAccount().markets[orderParams.marketIndex.toNumber()].amm
+				.oracle;
+
+		const remainingAccounts = [];
+		if (orderParams.optionalAccounts.discountToken) {
+			if (!discountToken) {
+				throw Error(
+					'Optional accounts specified discount token but no discount token present'
+				);
+			}
+
+			remainingAccounts.push({
+				pubkey: discountToken,
+				isWritable: false,
+				isSigner: false,
+			});
+		}
+
+		if (orderParams.optionalAccounts.referrer) {
+			if (!referrer) {
+				throw Error(
+					'Optional accounts specified referrer but no referrer present'
+				);
+			}
+
+			remainingAccounts.push({
+				pubkey: referrer,
+				isWritable: false,
+				isSigner: false,
+			});
+		}
+
+		const state = this.getStateAccount();
+		const orderState = this.getOrderStateAccount();
+		return await this.program.instruction.placeOrder(orderParams, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
+				markets: state.markets,
+				userOrders: await this.getUserOrdersAccountPublicKey(),
+				userPositions: userAccount.positions,
+				fundingPaymentHistory: state.fundingPaymentHistory,
+				fundingRateHistory: state.fundingRateHistory,
+				orderState: await this.getOrderStatePublicKey(),
+				orderHistory: orderState.orderHistory,
+				oracle: priceOracle,
+			},
+			remainingAccounts,
+		});
+	}
+
+	public async cancelOrder(orderId: BN): Promise<TransactionSignature> {
+		return await this.txSender.send(
+			wrapInTx(await this.getCancelOrderIx(orderId)),
+			[],
+			this.opts
+		);
+	}
+
+	public async getCancelOrderIx(orderId: BN): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const userAccount = await this.getUserAccount();
+
+		const state = this.getStateAccount();
+		const orderState = this.getOrderStateAccount();
+		return await this.program.instruction.cancelOrder(orderId, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
+				markets: state.markets,
+				userOrders: await this.getUserOrdersAccountPublicKey(),
+				userPositions: userAccount.positions,
+				fundingPaymentHistory: state.fundingPaymentHistory,
+				fundingRateHistory: state.fundingRateHistory,
+				orderState: await this.getOrderStatePublicKey(),
+				orderHistory: orderState.orderHistory,
+			},
+		});
+	}
+
+	public async cancelOrderByUserId(
+		userOrderId: number
+	): Promise<TransactionSignature> {
+		return await this.txSender.send(
+			wrapInTx(await this.getCancelOrderByUserIdIx(userOrderId)),
+			[],
+			this.opts
+		);
+	}
+
+	public async getCancelOrderByUserIdIx(
+		userOrderId: number
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const userAccount = await this.getUserAccount();
+
+		const state = this.getStateAccount();
+		const orderState = this.getOrderStateAccount();
+		return await this.program.instruction.cancelOrderByUserId(userOrderId, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
+				markets: state.markets,
+				userOrders: await this.getUserOrdersAccountPublicKey(),
+				userPositions: userAccount.positions,
+				fundingPaymentHistory: state.fundingPaymentHistory,
+				fundingRateHistory: state.fundingRateHistory,
+				orderState: await this.getOrderStatePublicKey(),
+				orderHistory: orderState.orderHistory,
+			},
+		});
+	}
+
+	public async fillOrder(
+		userAccountPublicKey: PublicKey,
+		userOrdersAccountPublicKey: PublicKey,
+		order: Order
+	): Promise<TransactionSignature> {
+		return await this.txSender.send(
+			wrapInTx(
+				await this.getFillOrderIx(
+					userAccountPublicKey,
+					userOrdersAccountPublicKey,
+					order
+				)
+			),
+			[],
+			this.opts
+		);
+	}
+
+	public async getFillOrderIx(
+		userAccountPublicKey: PublicKey,
+		userOrdersAccountPublicKey: PublicKey,
+		order: Order
+	): Promise<TransactionInstruction> {
+		const fillerPublicKey = await this.getUserAccountPublicKey();
+		const userAccount: any = await this.program.account.user.fetch(
+			userAccountPublicKey
+		);
+
+		const marketIndex = order.marketIndex;
+		const oracle = this.getMarket(marketIndex).amm.oracle;
+
+		const state = this.getStateAccount();
+		const orderState = this.getOrderStateAccount();
+
+		const remainingAccounts = [];
+		if (!order.referrer.equals(PublicKey.default)) {
+			remainingAccounts.push({
+				pubkey: order.referrer,
+				isWritable: true,
+				isSigner: false,
+			});
+		}
+
+		const orderId = order.orderId;
+		return await this.program.instruction.fillOrder(orderId, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				filler: fillerPublicKey,
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
+				markets: state.markets,
+				userPositions: userAccount.positions,
+				userOrders: userOrdersAccountPublicKey,
+				tradeHistory: state.tradeHistory,
+				fundingPaymentHistory: state.fundingPaymentHistory,
+				fundingRateHistory: state.fundingRateHistory,
+				orderState: await this.getOrderStatePublicKey(),
+				orderHistory: orderState.orderHistory,
+				extendedCurveHistory: state.extendedCurveHistory,
+				oracle: oracle,
+			},
+			remainingAccounts,
+		});
+	}
+
+	public async initializeUserOrdersThenPlaceAndFillOrder(
+		orderParams: OrderParams,
+		discountToken?: PublicKey,
+		referrer?: PublicKey
+	): Promise<TransactionSignature> {
+		const instructions: anchor.web3.TransactionInstruction[] = [];
+		const userOrdersAccountExists = await this.userOrdersAccountExists();
+		if (!userOrdersAccountExists) {
+			instructions.push(await this.getInitializeUserOrdersInstruction());
+		}
+		instructions.push(
+			await this.getPlaceAndFillOrderIx(orderParams, discountToken, referrer)
+		);
+		const tx = new Transaction();
+		for (const instruction of instructions) {
+			tx.add(instruction);
+		}
+
+		return await this.txSender.send(tx, [], this.opts);
+	}
+
+	public async placeAndFillOrder(
+		orderParams: OrderParams,
+		discountToken?: PublicKey,
+		referrer?: PublicKey
+	): Promise<TransactionSignature> {
+		return await this.txSender.send(
+			wrapInTx(
+				await this.getPlaceAndFillOrderIx(orderParams, discountToken, referrer)
+			),
+			[],
+			this.opts
+		);
+	}
+
+	public async getPlaceAndFillOrderIx(
+		orderParams: OrderParams,
+		discountToken?: PublicKey,
+		referrer?: PublicKey
+	): Promise<TransactionInstruction> {
+		const userAccountPublicKey = await this.getUserAccountPublicKey();
+		const userAccount = await this.getUserAccount();
+
+		const priceOracle =
+			this.getMarketsAccount().markets[orderParams.marketIndex.toNumber()].amm
+				.oracle;
+
+		const remainingAccounts = [];
+		if (orderParams.optionalAccounts.discountToken) {
+			if (!discountToken) {
+				throw Error(
+					'Optional accounts specified discount token but no discount token present'
+				);
+			}
+
+			remainingAccounts.push({
+				pubkey: discountToken,
+				isWritable: false,
+				isSigner: false,
+			});
+		}
+
+		if (orderParams.optionalAccounts.referrer) {
+			if (!referrer) {
+				throw Error(
+					'Optional accounts specified referrer but no referrer present'
+				);
+			}
+
+			remainingAccounts.push({
+				pubkey: referrer,
+				isWritable: true,
+				isSigner: false,
+			});
+		}
+
+		const state = this.getStateAccount();
+		const orderState = this.getOrderStateAccount();
+		return await this.program.instruction.placeAndFillOrder(orderParams, {
+			accounts: {
+				state: await this.getStatePublicKey(),
+				user: userAccountPublicKey,
+				authority: this.wallet.publicKey,
+				markets: state.markets,
+				userOrders: await this.getUserOrdersAccountPublicKey(),
+				userPositions: userAccount.positions,
+				tradeHistory: state.tradeHistory,
+				fundingPaymentHistory: state.fundingPaymentHistory,
+				fundingRateHistory: state.fundingRateHistory,
+				orderState: await this.getOrderStatePublicKey(),
+				orderHistory: orderState.orderHistory,
+				extendedCurveHistory: state.extendedCurveHistory,
+				oracle: priceOracle,
+			},
+			remainingAccounts,
+		});
+	}
+
 	/**
 	 * Close an entire position. If you want to reduce a position, use the {@link openPosition} method in the opposite direction of the current position.
 	 * @param marketIndex