@drift-labs/sdk 0.2.0-temp.2 → 2.0.0

package/src/accounts/{webSocketClearingHouseAccountSubscriber.ts → webSocketDriftClientAccountSubscriber.ts}

@@ -1,17 +1,17 @@
 import {
-	ClearingHouseAccountSubscriber,
-	ClearingHouseAccountEvents,
+	DriftClientAccountSubscriber,
+	DriftClientAccountEvents,
 	DataAndSlot,
 } from './types';
 import { AccountSubscriber, NotSubscribedError } from './types';
-import { BankAccount, MarketAccount, StateAccount } from '../types';
-import { BN, Program } from '@project-serum/anchor';
+import { SpotMarketAccount, PerpMarketAccount, StateAccount } from '../types';
+import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import {
-	getClearingHouseStateAccountPublicKey,
-	getBankPublicKey,
-	getMarketPublicKey,
+	getDriftStateAccountPublicKey,
+	getSpotMarketPublicKey,
+	getPerpMarketPublicKey,
 } from '../addresses/pda';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
 import { PublicKey } from '@solana/web3.js';
@@ -20,23 +20,26 @@ import { OracleClientCache } from '../oracles/oracleClientCache';
 import * as Buffer from 'buffer';
 import { QUOTE_ORACLE_PRICE_DATA } from '../oracles/quoteAssetOracleClient';
 
-export class WebSocketClearingHouseAccountSubscriber
-	implements ClearingHouseAccountSubscriber
+export class WebSocketDriftClientAccountSubscriber
+	implements DriftClientAccountSubscriber
 {
 	isSubscribed: boolean;
 	program: Program;
-	marketIndexes: BN[];
-	bankIndexes: BN[];
+	perpMarketIndexes: number[];
+	spotMarketIndexes: number[];
 	oracleInfos: OracleInfo[];
 	oracleClientCache = new OracleClientCache();
 
-	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
+	eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
 	stateAccountSubscriber?: AccountSubscriber<StateAccount>;
-	marketAccountSubscribers = new Map<
+	perpMarketAccountSubscribers = new Map<
 		number,
-		AccountSubscriber<MarketAccount>
+		AccountSubscriber<PerpMarketAccount>
+	>();
+	spotMarketAccountSubscribers = new Map<
+		number,
+		AccountSubscriber<SpotMarketAccount>
 	>();
-	bankAccountSubscribers = new Map<number, AccountSubscriber<BankAccount>>();
 	oracleSubscribers = new Map<string, AccountSubscriber<OraclePriceData>>();
 
 	private isSubscribing = false;
@@ -45,15 +48,15 @@ export class WebSocketClearingHouseAccountSubscriber
 
 	public constructor(
 		program: Program,
-		marketIndexes: BN[],
-		bankIndexes: BN[],
+		perpMarketIndexes: number[],
+		spotMarketIndexes: number[],
 		oracleInfos: OracleInfo[]
 	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.eventEmitter = new EventEmitter();
-		this.marketIndexes = marketIndexes;
-		this.bankIndexes = bankIndexes;
+		this.perpMarketIndexes = perpMarketIndexes;
+		this.spotMarketIndexes = spotMarketIndexes;
 		this.oracleInfos = oracleInfos;
 	}
 
@@ -72,7 +75,7 @@ export class WebSocketClearingHouseAccountSubscriber
 			this.subscriptionPromiseResolver = res;
 		});
 
-		const statePublicKey = await getClearingHouseStateAccountPublicKey(
+		const statePublicKey = await getDriftStateAccountPublicKey(
 			this.program.programId
 		);
 
@@ -88,10 +91,10 @@ export class WebSocketClearingHouseAccountSubscriber
 		});
 
 		// subscribe to market accounts
-		await this.subscribeToMarketAccounts();
+		await this.subscribeToPerpMarketAccounts();
 
-		// subscribe to bank accounts
-		await this.subscribeToBankAccounts();
+		// subscribe to spot market accounts
+		await this.subscribeToSpotMarketAccounts();
 
 		// subscribe to oracles
 		await this.subscribeToOracles();
@@ -105,56 +108,53 @@ export class WebSocketClearingHouseAccountSubscriber
 		return true;
 	}
 
-	async subscribeToMarketAccounts(): Promise<boolean> {
-		for (const marketIndex of this.marketIndexes) {
-			await this.subscribeToMarketAccount(marketIndex);
+	async subscribeToPerpMarketAccounts(): Promise<boolean> {
+		for (const marketIndex of this.perpMarketIndexes) {
+			await this.subscribeToPerpMarketAccount(marketIndex);
 		}
 		return true;
 	}
 
-	async subscribeToMarketAccount(marketIndex: BN): Promise<boolean> {
-		const marketPublicKey = await getMarketPublicKey(
+	async subscribeToPerpMarketAccount(marketIndex: number): Promise<boolean> {
+		const perpMarketPublicKey = await getPerpMarketPublicKey(
 			this.program.programId,
 			marketIndex
 		);
-		const accountSubscriber = new WebSocketAccountSubscriber<MarketAccount>(
-			'market',
+		const accountSubscriber = new WebSocketAccountSubscriber<PerpMarketAccount>(
+			'perpMarket',
 			this.program,
-			marketPublicKey
+			perpMarketPublicKey
 		);
-		await accountSubscriber.subscribe((data: MarketAccount) => {
-			this.eventEmitter.emit('marketAccountUpdate', data);
+		await accountSubscriber.subscribe((data: PerpMarketAccount) => {
+			this.eventEmitter.emit('perpMarketAccountUpdate', data);
 			this.eventEmitter.emit('update');
 		});
-		this.marketAccountSubscribers.set(
-			marketIndex.toNumber(),
-			accountSubscriber
-		);
+		this.perpMarketAccountSubscribers.set(marketIndex, accountSubscriber);
 		return true;
 	}
 
-	async subscribeToBankAccounts(): Promise<boolean> {
-		for (const bankIndex of this.bankIndexes) {
-			await this.subscribeToBankAccount(bankIndex);
+	async subscribeToSpotMarketAccounts(): Promise<boolean> {
+		for (const marketIndex of this.spotMarketIndexes) {
+			await this.subscribeToSpotMarketAccount(marketIndex);
 		}
 		return true;
 	}
 
-	async subscribeToBankAccount(bankIndex: BN): Promise<boolean> {
-		const bankPublicKey = await getBankPublicKey(
+	async subscribeToSpotMarketAccount(marketIndex: number): Promise<boolean> {
+		const marketPublicKey = await getSpotMarketPublicKey(
 			this.program.programId,
-			bankIndex
+			marketIndex
 		);
-		const accountSubscriber = new WebSocketAccountSubscriber<BankAccount>(
-			'bank',
+		const accountSubscriber = new WebSocketAccountSubscriber<SpotMarketAccount>(
+			'spotMarket',
 			this.program,
-			bankPublicKey
+			marketPublicKey
 		);
-		await accountSubscriber.subscribe((data: BankAccount) => {
-			this.eventEmitter.emit('bankAccountUpdate', data);
+		await accountSubscriber.subscribe((data: SpotMarketAccount) => {
+			this.eventEmitter.emit('spotMarketAccountUpdate', data);
 			this.eventEmitter.emit('update');
 		});
-		this.bankAccountSubscribers.set(bankIndex.toNumber(), accountSubscriber);
+		this.spotMarketAccountSubscribers.set(marketIndex, accountSubscriber);
 		return true;
 	}
 
@@ -195,13 +195,13 @@ export class WebSocketClearingHouseAccountSubscriber
 	}
 
 	async unsubscribeFromMarketAccounts(): Promise<void> {
-		for (const accountSubscriber of this.marketAccountSubscribers.values()) {
+		for (const accountSubscriber of this.perpMarketAccountSubscribers.values()) {
 			await accountSubscriber.unsubscribe();
 		}
 	}
 
-	async unsubscribeFromBankAccounts(): Promise<void> {
-		for (const accountSubscriber of this.bankAccountSubscribers.values()) {
+	async unsubscribeFromSpotMarketAccounts(): Promise<void> {
+		for (const accountSubscriber of this.spotMarketAccountSubscribers.values()) {
 			await accountSubscriber.unsubscribe();
 		}
 	}
@@ -219,13 +219,13 @@ export class WebSocketClearingHouseAccountSubscriber
 
 		const promises = [this.stateAccountSubscriber.fetch()]
 			.concat(
-				Array.from(this.marketAccountSubscribers.values()).map((subscriber) =>
-					subscriber.fetch()
+				Array.from(this.perpMarketAccountSubscribers.values()).map(
+					(subscriber) => subscriber.fetch()
 				)
 			)
 			.concat(
-				Array.from(this.bankAccountSubscribers.values()).map((subscriber) =>
-					subscriber.fetch()
+				Array.from(this.spotMarketAccountSubscribers.values()).map(
+					(subscriber) => subscriber.fetch()
 				)
 			);
 
@@ -240,24 +240,24 @@ export class WebSocketClearingHouseAccountSubscriber
 		await this.stateAccountSubscriber.unsubscribe();
 
 		await this.unsubscribeFromMarketAccounts();
-		await this.unsubscribeFromBankAccounts();
+		await this.unsubscribeFromSpotMarketAccounts();
 		await this.unsubscribeFromOracles();
 
 		this.isSubscribed = false;
 	}
 
-	async addBank(bankIndex: BN): Promise<boolean> {
-		if (this.bankAccountSubscribers.has(bankIndex.toNumber())) {
+	async addSpotMarket(marketIndex: number): Promise<boolean> {
+		if (this.spotMarketAccountSubscribers.has(marketIndex)) {
 			return true;
 		}
-		return this.subscribeToBankAccount(bankIndex);
+		return this.subscribeToSpotMarketAccount(marketIndex);
 	}
 
-	async addMarket(marketIndex: BN): Promise<boolean> {
-		if (this.marketAccountSubscribers.has(marketIndex.toNumber())) {
+	async addPerpMarket(marketIndex: number): Promise<boolean> {
+		if (this.perpMarketAccountSubscribers.has(marketIndex)) {
 			return true;
 		}
-		return this.subscribeToMarketAccount(marketIndex);
+		return this.subscribeToPerpMarketAccount(marketIndex);
 	}
 
 	async addOracle(oracleInfo: OracleInfo): Promise<boolean> {
@@ -286,24 +286,29 @@ export class WebSocketClearingHouseAccountSubscriber
 	}
 
 	public getMarketAccountAndSlot(
-		marketIndex: BN
-	): DataAndSlot<MarketAccount> | undefined {
+		marketIndex: number
+	): DataAndSlot<PerpMarketAccount> | undefined {
 		this.assertIsSubscribed();
-		return this.marketAccountSubscribers.get(marketIndex.toNumber())
-			.dataAndSlot;
+		return this.perpMarketAccountSubscribers.get(marketIndex).dataAndSlot;
 	}
 
-	public getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[] {
-		return Array.from(this.marketAccountSubscribers.values()).map(
+	public getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[] {
+		return Array.from(this.perpMarketAccountSubscribers.values()).map(
 			(subscriber) => subscriber.dataAndSlot
 		);
 	}
 
-	public getBankAccountAndSlot(
-		bankIndex: BN
-	): DataAndSlot<BankAccount> | undefined {
+	public getSpotMarketAccountAndSlot(
+		marketIndex: number
+	): DataAndSlot<SpotMarketAccount> | undefined {
 		this.assertIsSubscribed();
-		return this.bankAccountSubscribers.get(bankIndex.toNumber()).dataAndSlot;
+		return this.spotMarketAccountSubscribers.get(marketIndex).dataAndSlot;
+	}
+
+	public getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[] {
+		return Array.from(this.spotMarketAccountSubscribers.values()).map(
+			(subscriber) => subscriber.dataAndSlot
+		);
 	}
 
 	public getOraclePriceDataAndSlot(

package/src/accounts/webSocketUserStatsAccountSubsriber.ts

@@ -0,0 +1,80 @@
+import {
+	DataAndSlot,
+	AccountSubscriber,
+	NotSubscribedError,
+	UserStatsAccountSubscriber,
+	UserStatsAccountEvents,
+} from './types';
+import { Program } from '@project-serum/anchor';
+import StrictEventEmitter from 'strict-event-emitter-types';
+import { EventEmitter } from 'events';
+import { PublicKey } from '@solana/web3.js';
+import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
+import { UserStatsAccount } from '../types';
+
+export class WebSocketUserStatsAccountSubscriber
+	implements UserStatsAccountSubscriber
+{
+	isSubscribed: boolean;
+	program: Program;
+	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
+	userStatsAccountPublicKey: PublicKey;
+
+	userStatsAccountSubscriber: AccountSubscriber<UserStatsAccount>;
+
+	public constructor(program: Program, userStatsAccountPublicKey: PublicKey) {
+		this.isSubscribed = false;
+		this.program = program;
+		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
+		this.eventEmitter = new EventEmitter();
+	}
+
+	async subscribe(): Promise<boolean> {
+		if (this.isSubscribed) {
+			return true;
+		}
+
+		this.userStatsAccountSubscriber = new WebSocketAccountSubscriber(
+			'userStats',
+			this.program,
+			this.userStatsAccountPublicKey
+		);
+		await this.userStatsAccountSubscriber.subscribe(
+			(data: UserStatsAccount) => {
+				this.eventEmitter.emit('userStatsAccountUpdate', data);
+				this.eventEmitter.emit('update');
+			}
+		);
+
+		this.eventEmitter.emit('update');
+		this.isSubscribed = true;
+		return true;
+	}
+
+	async fetch(): Promise<void> {
+		await Promise.all([this.userStatsAccountSubscriber.fetch()]);
+	}
+
+	async unsubscribe(): Promise<void> {
+		if (!this.isSubscribed) {
+			return;
+		}
+
+		await Promise.all([this.userStatsAccountSubscriber.unsubscribe()]);
+
+		this.isSubscribed = false;
+	}
+
+	assertIsSubscribed(): void {
+		if (!this.isSubscribed) {
+			throw new NotSubscribedError(
+				'You must call `subscribe` before using this function'
+			);
+		}
+	}
+
+	public getUserStatsAccountAndSlot(): DataAndSlot<UserStatsAccount> {
+		this.assertIsSubscribed();
+		return this.userStatsAccountSubscriber.dataAndSlot;
+	}
+}

package/src/addresses/marketAddresses.ts

@@ -1,18 +1,17 @@
 import { PublicKey } from '@solana/web3.js';
-import { BN } from '@project-serum/anchor';
-import { getMarketPublicKey } from './pda';
+import { getPerpMarketPublicKey } from './pda';
 
 const CACHE = new Map<string, PublicKey>();
 export async function getMarketAddress(
 	programId: PublicKey,
-	marketIndex: BN
+	marketIndex: number
 ): Promise<PublicKey> {
 	const cacheKey = `${programId.toString()}-${marketIndex.toString()}`;
 	if (CACHE.has(cacheKey)) {
 		return CACHE.get(cacheKey);
 	}
 
-	const publicKey = await getMarketPublicKey(programId, marketIndex);
+	const publicKey = await getPerpMarketPublicKey(programId, marketIndex);
 	CACHE.set(cacheKey, publicKey);
 	return publicKey;
 }

package/src/addresses/pda.ts

@@ -2,31 +2,31 @@ import { PublicKey } from '@solana/web3.js';
 import * as anchor from '@project-serum/anchor';
 import { BN } from '@project-serum/anchor';
 
-export async function getClearingHouseStateAccountPublicKeyAndNonce(
+export async function getDriftStateAccountPublicKeyAndNonce(
 	programId: PublicKey
 ): Promise<[PublicKey, number]> {
-	return anchor.web3.PublicKey.findProgramAddress(
-		[Buffer.from(anchor.utils.bytes.utf8.encode('clearing_house'))],
+	return PublicKey.findProgramAddress(
+		[Buffer.from(anchor.utils.bytes.utf8.encode('drift_state'))],
 		programId
 	);
 }
 
-export async function getClearingHouseStateAccountPublicKey(
+export async function getDriftStateAccountPublicKey(
 	programId: PublicKey
 ): Promise<PublicKey> {
-	return (await getClearingHouseStateAccountPublicKeyAndNonce(programId))[0];
+	return (await getDriftStateAccountPublicKeyAndNonce(programId))[0];
 }
 
 export async function getUserAccountPublicKeyAndNonce(
 	programId: PublicKey,
 	authority: PublicKey,
-	userId = 0
+	subAccountId = 0
 ): Promise<[PublicKey, number]> {
-	return anchor.web3.PublicKey.findProgramAddress(
+	return PublicKey.findProgramAddress(
 		[
 			Buffer.from(anchor.utils.bytes.utf8.encode('user')),
 			authority.toBuffer(),
-			Uint8Array.from([userId]),
+			new anchor.BN(subAccountId).toArrayLike(Buffer, 'le', 2),
 		],
 		programId
 	);
@@ -35,84 +35,156 @@ export async function getUserAccountPublicKeyAndNonce(
 export async function getUserAccountPublicKey(
 	programId: PublicKey,
 	authority: PublicKey,
-	userId = 0
+	subAccountId = 0
 ): Promise<PublicKey> {
 	return (
-		await getUserAccountPublicKeyAndNonce(programId, authority, userId)
+		await getUserAccountPublicKeyAndNonce(programId, authority, subAccountId)
 	)[0];
 }
 
 export function getUserAccountPublicKeySync(
 	programId: PublicKey,
 	authority: PublicKey,
-	userId = 0
+	subAccountId = 0
 ): PublicKey {
-	return anchor.web3.PublicKey.findProgramAddressSync(
+	return PublicKey.findProgramAddressSync(
 		[
 			Buffer.from(anchor.utils.bytes.utf8.encode('user')),
 			authority.toBuffer(),
-			Uint8Array.from([userId]),
+			new anchor.BN(subAccountId).toArrayLike(Buffer, 'le', 2),
 		],
 		programId
 	)[0];
 }
 
-export async function getMarketPublicKey(
+export function getUserStatsAccountPublicKey(
 	programId: PublicKey,
-	marketIndex: BN
+	authority: PublicKey
+): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('user_stats')),
+			authority.toBuffer(),
+		],
+		programId
+	)[0];
+}
+
+export async function getPerpMarketPublicKey(
+	programId: PublicKey,
+	marketIndex: number
 ): Promise<PublicKey> {
 	return (
-		await anchor.web3.PublicKey.findProgramAddress(
+		await PublicKey.findProgramAddress(
 			[
-				Buffer.from(anchor.utils.bytes.utf8.encode('market')),
-				marketIndex.toArrayLike(Buffer, 'le', 8),
+				Buffer.from(anchor.utils.bytes.utf8.encode('perp_market')),
+				new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
 			],
 			programId
 		)
 	)[0];
 }
 
-export async function getBankPublicKey(
+export async function getSpotMarketPublicKey(
 	programId: PublicKey,
-	bankIndex: BN
+	marketIndex: number
 ): Promise<PublicKey> {
 	return (
-		await anchor.web3.PublicKey.findProgramAddress(
+		await PublicKey.findProgramAddress(
 			[
-				Buffer.from(anchor.utils.bytes.utf8.encode('bank')),
-				bankIndex.toArrayLike(Buffer, 'le', 8),
+				Buffer.from(anchor.utils.bytes.utf8.encode('spot_market')),
+				new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
 			],
 			programId
 		)
 	)[0];
 }
 
-export async function getBankVaultPublicKey(
+export async function getSpotMarketVaultPublicKey(
 	programId: PublicKey,
-	bankIndex: BN
+	marketIndex: number
 ): Promise<PublicKey> {
 	return (
-		await anchor.web3.PublicKey.findProgramAddress(
+		await PublicKey.findProgramAddress(
 			[
-				Buffer.from(anchor.utils.bytes.utf8.encode('bank_vault')),
-				bankIndex.toArrayLike(Buffer, 'le', 8),
+				Buffer.from(anchor.utils.bytes.utf8.encode('spot_market_vault')),
+				new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
 			],
 			programId
 		)
 	)[0];
 }
 
-export async function getBankVaultAuthorityPublicKey(
+export async function getInsuranceFundVaultPublicKey(
 	programId: PublicKey,
-	bankIndex: BN
+	marketIndex: number
 ): Promise<PublicKey> {
 	return (
-		await anchor.web3.PublicKey.findProgramAddress(
+		await PublicKey.findProgramAddress(
 			[
-				Buffer.from(anchor.utils.bytes.utf8.encode('bank_vault_authority')),
-				bankIndex.toArrayLike(Buffer, 'le', 8),
+				Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_vault')),
+				new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
 			],
 			programId
 		)
 	)[0];
 }
+
+export function getInsuranceFundStakeAccountPublicKey(
+	programId: PublicKey,
+	authority: PublicKey,
+	marketIndex: number
+): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('insurance_fund_stake')),
+			authority.toBuffer(),
+			new anchor.BN(marketIndex).toArrayLike(Buffer, 'le', 2),
+		],
+		programId
+	)[0];
+}
+
+export function getDriftSignerPublicKey(programId: PublicKey): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[Buffer.from(anchor.utils.bytes.utf8.encode('drift_signer'))],
+		programId
+	)[0];
+}
+
+export function getSerumOpenOrdersPublicKey(
+	programId: PublicKey,
+	market: PublicKey
+): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('serum_open_orders')),
+			market.toBuffer(),
+		],
+		programId
+	)[0];
+}
+
+export function getSerumSignerPublicKey(
+	programId: PublicKey,
+	market: PublicKey,
+	nonce: BN
+): PublicKey {
+	return anchor.web3.PublicKey.createProgramAddressSync(
+		[market.toBuffer(), nonce.toArrayLike(Buffer, 'le', 8)],
+		programId
+	);
+}
+
+export function getSerumFulfillmentConfigPublicKey(
+	programId: PublicKey,
+	market: PublicKey
+): PublicKey {
+	return PublicKey.findProgramAddressSync(
+		[
+			Buffer.from(anchor.utils.bytes.utf8.encode('serum_fulfillment_config')),
+			market.toBuffer(),
+		],
+		programId
+	)[0];
+}