@drift-labs/sdk 0.2.0-master.25 → 0.2.0-master.27

package/lib/userMap/userStatsMap.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserStatsMap = void 0;
+const __1 = require("..");
+const web3_js_1 = require("@solana/web3.js");
+class UserStatsMap {
+    constructor(clearingHouse, accountSubscription) {
+        /**
+         * map from authority pubkey to ClearingHouseUserStats
+         */
+        this.userStatsMap = new Map();
+        this.clearingHouse = clearingHouse;
+        this.accountSubscription = accountSubscription;
+    }
+    async fetchAllUserStats() {
+        const userStatArray = [];
+        const programUserAccounts = (await this.clearingHouse.program.account.userStats.all());
+        for (const programUserAccount of programUserAccounts) {
+            const userStat = programUserAccount.account;
+            if (this.userStatsMap.has(userStat.authority.toString())) {
+                continue;
+            }
+            const chUserStat = new __1.ClearingHouseUserStats({
+                clearingHouse: this.clearingHouse,
+                userStatsAccountPublicKey: (0, __1.getUserStatsAccountPublicKey)(this.clearingHouse.program.programId, userStat.authority),
+                accountSubscription: this.accountSubscription,
+            });
+            userStatArray.push(chUserStat);
+        }
+        if (this.accountSubscription.type === 'polling') {
+            await (0, __1.bulkPollingUserStatsSubscribe)(userStatArray, this.accountSubscription.accountLoader);
+        }
+        for (const userStat of userStatArray) {
+            this.userStatsMap.set(userStat.getAccount().authority.toString(), userStat);
+        }
+    }
+    async addUserStat(authority) {
+        const userStat = new __1.ClearingHouseUserStats({
+            clearingHouse: this.clearingHouse,
+            userStatsAccountPublicKey: (0, __1.getUserStatsAccountPublicKey)(this.clearingHouse.program.programId, authority),
+            accountSubscription: this.accountSubscription,
+        });
+        await userStat.subscribe();
+        this.userStatsMap.set(authority.toString(), userStat);
+    }
+    async updateWithOrderRecord(record, userMap) {
+        if (!this.has(record.user.toString())) {
+            const takerUserAccount = await userMap.mustGet(record.user.toString());
+            this.addUserStat(takerUserAccount.getUserAccount().authority);
+        }
+    }
+    has(authorityPublicKey) {
+        return this.userStatsMap.has(authorityPublicKey);
+    }
+    get(authorityPublicKey) {
+        return this.userStatsMap.get(authorityPublicKey);
+    }
+    async mustGet(authorityPublicKey) {
+        if (!this.has(authorityPublicKey)) {
+            await this.addUserStat(new web3_js_1.PublicKey(authorityPublicKey));
+        }
+        return this.get(authorityPublicKey);
+    }
+    values() {
+        return this.userStatsMap.values();
+    }
+}
+exports.UserStatsMap = UserStatsMap;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.2.0-master.25",
+	"version": "0.2.0-master.27",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -14,7 +14,9 @@
 		"build": "yarn clean && tsc",
 		"clean": "rm -rf lib",
 		"test": "mocha -r ts-node/register tests/**/*.ts",
-		"patch-and-pub": "npm version patch --force && npm publish"
+		"patch-and-pub": "npm version patch --force && npm publish",
+		"prettify": "prettier --check './src/***/*.ts'",
+		"prettify:fix": "prettier --write './{src,tests}/***/*.ts'"
 	},
 	"keywords": [
 		"drift-labs",
@@ -48,7 +50,8 @@
 		"eslint-config-prettier": "^8.3.0",
 		"eslint-plugin-prettier": "^3.4.0",
 		"mocha": "^10.0.0",
-		"ts-node": "^10.8.0"
+		"ts-node": "^10.8.0",
+		"prettier": "^2.4.1"
 	},
 	"description": "SDK for Drift Protocol v1",
 	"engines": {

package/src/accounts/pollingClearingHouseAccountSubscriber.ts

@@ -10,14 +10,14 @@ import { BN, Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import {
-	BankAccount,
-	MarketAccount,
+	SpotMarketAccount,
+	PerpMarketAccount,
 	StateAccount,
 	UserAccount,
 } from '../types';
 import {
 	getClearingHouseStateAccountPublicKey,
-	getBankPublicKey,
+	getSpotMarketPublicKey,
 	getMarketPublicKey,
 } from '../addresses/pda';
 import { BulkAccountLoader } from './bulkAccountLoader';
@@ -32,8 +32,8 @@ export class PollingClearingHouseAccountSubscriber
 {
 	isSubscribed: boolean;
 	program: Program;
-	marketIndexes: BN[];
-	bankIndexes: BN[];
+	perpMarketIndexes: BN[];
+	spotMarketIndexes: BN[];
 	oracleInfos: OracleInfo[];
 	oracleClientCache = new OracleClientCache();
 
@@ -45,8 +45,8 @@ export class PollingClearingHouseAccountSubscriber
 	errorCallbackId?: string;
 
 	state?: DataAndSlot<StateAccount>;
-	market = new Map<number, DataAndSlot<MarketAccount>>();
-	bank = new Map<number, DataAndSlot<BankAccount>>();
+	perpMarket = new Map<number, DataAndSlot<PerpMarketAccount>>();
+	spotMarket = new Map<number, DataAndSlot<SpotMarketAccount>>();
 	oracles = new Map<string, DataAndSlot<OraclePriceData>>();
 	user?: DataAndSlot<UserAccount>;
 
@@ -57,16 +57,16 @@ export class PollingClearingHouseAccountSubscriber
 	public constructor(
 		program: Program,
 		accountLoader: BulkAccountLoader,
-		marketIndexes: BN[],
-		bankIndexes: BN[],
+		perpMarketIndexes: BN[],
+		spotMarketIndexes: BN[],
 		oracleInfos: OracleInfo[]
 	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.eventEmitter = new EventEmitter();
 		this.accountLoader = accountLoader;
-		this.marketIndexes = marketIndexes;
-		this.bankIndexes = bankIndexes;
+		this.perpMarketIndexes = perpMarketIndexes;
+		this.spotMarketIndexes = spotMarketIndexes;
 		this.oracleInfos = oracleInfos;
 	}
 
@@ -122,11 +122,11 @@ export class PollingClearingHouseAccountSubscriber
 		});
 
 		await this.updateMarketAccountsToPoll();
-		await this.updateBankAccountsToPoll();
+		await this.updateSpotMarketAccountsToPoll();
 	}
 
 	async updateMarketAccountsToPoll(): Promise<boolean> {
-		for (const marketIndex of this.marketIndexes) {
+		for (const marketIndex of this.perpMarketIndexes) {
 			await this.addMarketAccountToPoll(marketIndex);
 		}
 		return true;
@@ -139,34 +139,34 @@ export class PollingClearingHouseAccountSubscriber
 		);
 
 		this.accountsToPoll.set(marketPublicKey.toString(), {
-			key: 'market',
+			key: 'perpMarket',
 			publicKey: marketPublicKey,
-			eventType: 'marketAccountUpdate',
+			eventType: 'perpMarketAccountUpdate',
 			mapKey: marketIndex.toNumber(),
 		});
 
 		return true;
 	}
 
-	async updateBankAccountsToPoll(): Promise<boolean> {
-		for (const bankIndex of this.bankIndexes) {
-			await this.addBankAccountToPoll(bankIndex);
+	async updateSpotMarketAccountsToPoll(): Promise<boolean> {
+		for (const marketIndex of this.spotMarketIndexes) {
+			await this.addSpotMarketAccountToPoll(marketIndex);
 		}
 
 		return true;
 	}
 
-	async addBankAccountToPoll(bankIndex: BN): Promise<boolean> {
-		const bankPublicKey = await getBankPublicKey(
+	async addSpotMarketAccountToPoll(marketIndex: BN): Promise<boolean> {
+		const marketPublicKey = await getSpotMarketPublicKey(
 			this.program.programId,
-			bankIndex
+			marketIndex
 		);
 
-		this.accountsToPoll.set(bankPublicKey.toString(), {
-			key: 'bank',
-			publicKey: bankPublicKey,
-			eventType: 'bankAccountUpdate',
-			mapKey: bankIndex.toNumber(),
+		this.accountsToPoll.set(marketPublicKey.toString(), {
+			key: 'spotMarket',
+			publicKey: marketPublicKey,
+			eventType: 'spotMarketAccountUpdate',
+			mapKey: marketIndex.toNumber(),
 		});
 		return true;
 	}
@@ -353,14 +353,14 @@ export class PollingClearingHouseAccountSubscriber
 		this.isSubscribed = false;
 	}
 
-	async addBank(bankIndex: BN): Promise<boolean> {
-		await this.addBankAccountToPoll(bankIndex);
-		const accountToPoll = this.accountsToPoll.get(bankIndex.toString());
+	async addSpotMarket(marketIndex: BN): Promise<boolean> {
+		await this.addSpotMarketAccountToPoll(marketIndex);
+		const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
 		this.addAccountToAccountLoader(accountToPoll);
 		return true;
 	}
 
-	async addMarket(marketIndex: BN): Promise<boolean> {
+	async addPerpMarket(marketIndex: BN): Promise<boolean> {
 		await this.addMarketAccountToPoll(marketIndex);
 		const accountToPoll = this.accountsToPoll.get(marketIndex.toString());
 		this.addAccountToAccountLoader(accountToPoll);
@@ -395,18 +395,22 @@ export class PollingClearingHouseAccountSubscriber
 
 	public getMarketAccountAndSlot(
 		marketIndex: BN
-	): DataAndSlot<MarketAccount> | undefined {
-		return this.market.get(marketIndex.toNumber());
+	): DataAndSlot<PerpMarketAccount> | undefined {
+		return this.perpMarket.get(marketIndex.toNumber());
+	}
+
+	public getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[] {
+		return Array.from(this.perpMarket.values());
 	}
 
-	public getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[] {
-		return Array.from(this.market.values());
+	public getSpotMarketAccountAndSlot(
+		marketIndex: BN
+	): DataAndSlot<SpotMarketAccount> | undefined {
+		return this.spotMarket.get(marketIndex.toNumber());
 	}
 
-	public getBankAccountAndSlot(
-		bankIndex: BN
-	): DataAndSlot<BankAccount> | undefined {
-		return this.bank.get(bankIndex.toNumber());
+	public getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[] {
+		return Array.from(this.spotMarket.values());
 	}
 
 	public getOraclePriceDataAndSlot(

package/src/accounts/types.ts

@@ -1,6 +1,6 @@
 import {
-	BankAccount,
-	MarketAccount,
+	SpotMarketAccount,
+	PerpMarketAccount,
 	OracleSource,
 	StateAccount,
 	UserAccount,
@@ -26,8 +26,8 @@ export class NotSubscribedError extends Error {
 
 export interface ClearingHouseAccountEvents {
 	stateAccountUpdate: (payload: StateAccount) => void;
-	marketAccountUpdate: (payload: MarketAccount) => void;
-	bankAccountUpdate: (payload: BankAccount) => void;
+	perpMarketAccountUpdate: (payload: PerpMarketAccount) => void;
+	spotMarketAccountUpdate: (payload: SpotMarketAccount) => void;
 	oraclePriceUpdate: (publicKey: PublicKey, data: OraclePriceData) => void;
 	userAccountUpdate: (payload: UserAccount) => void;
 	update: void;
@@ -42,16 +42,19 @@ export interface ClearingHouseAccountSubscriber {
 	fetch(): Promise<void>;
 	unsubscribe(): Promise<void>;
 
-	addMarket(marketIndex: BN): Promise<boolean>;
-	addBank(bankIndex: BN): Promise<boolean>;
+	addPerpMarket(marketIndex: BN): Promise<boolean>;
+	addSpotMarket(marketIndex: BN): Promise<boolean>;
 	addOracle(oracleInfo: OracleInfo): Promise<boolean>;
 
 	getStateAccountAndSlot(): DataAndSlot<StateAccount>;
 	getMarketAccountAndSlot(
 		marketIndex: BN
-	): DataAndSlot<MarketAccount> | undefined;
-	getMarketAccountsAndSlots(): DataAndSlot<MarketAccount>[];
-	getBankAccountAndSlot(bankIndex: BN): DataAndSlot<BankAccount> | undefined;
+	): DataAndSlot<PerpMarketAccount> | undefined;
+	getMarketAccountsAndSlots(): DataAndSlot<PerpMarketAccount>[];
+	getSpotMarketAccountAndSlot(
+		marketIndex: BN
+	): DataAndSlot<SpotMarketAccount> | undefined;
+	getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[];
 	getOraclePriceDataAndSlot(
 		oraclePublicKey: PublicKey
 	): DataAndSlot<OraclePriceData> | undefined;

package/src/accounts/webSocketClearingHouseAccountSubscriber.ts

@@ -4,13 +4,13 @@ import {
 	DataAndSlot,
 } from './types';
 import { AccountSubscriber, NotSubscribedError } from './types';
-import { BankAccount, MarketAccount, StateAccount } from '../types';
+import { SpotMarketAccount, PerpMarketAccount, StateAccount } from '../types';
 import { BN, Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import {
 	getClearingHouseStateAccountPublicKey,
-	getBankPublicKey,
+	getSpotMarketPublicKey,
 	getMarketPublicKey,
 } from '../addresses/pda';
 import { WebSocketAccountSubscriber } from './webSocketAccountSubscriber';
@@ -25,18 +25,21 @@ export class WebSocketClearingHouseAccountSubscriber
 {
 	isSubscribed: boolean;
 	program: Program;
-	marketIndexes: BN[];
-	bankIndexes: BN[];
+	perpMarketIndexes: BN[];
+	spotMarketIndexes: BN[];
 	oracleInfos: OracleInfo[];
 	oracleClientCache = new OracleClientCache();
 
 	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
 	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: BN[],
+		spotMarketIndexes: BN[],
 		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;
 	}
 
@@ -90,8 +93,8 @@ export class WebSocketClearingHouseAccountSubscriber
 		// subscribe to market accounts
 		await this.subscribeToMarketAccounts();
 
-		// subscribe to bank accounts
-		await this.subscribeToBankAccounts();
+		// subscribe to spot market accounts
+		await this.subscribeToSpotMarketAccounts();
 
 		// subscribe to oracles
 		await this.subscribeToOracles();
@@ -106,7 +109,7 @@ export class WebSocketClearingHouseAccountSubscriber
 	}
 
 	async subscribeToMarketAccounts(): Promise<boolean> {
-		for (const marketIndex of this.marketIndexes) {
+		for (const marketIndex of this.perpMarketIndexes) {
 			await this.subscribeToMarketAccount(marketIndex);
 		}
 		return true;
@@ -117,44 +120,47 @@ export class WebSocketClearingHouseAccountSubscriber
 			this.program.programId,
 			marketIndex
 		);
-		const accountSubscriber = new WebSocketAccountSubscriber<MarketAccount>(
-			'market',
+		const accountSubscriber = new WebSocketAccountSubscriber<PerpMarketAccount>(
+			'perpMarket',
 			this.program,
 			marketPublicKey
 		);
-		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(
+		this.perpMarketAccountSubscribers.set(
 			marketIndex.toNumber(),
 			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: BN): 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.toNumber(),
+			accountSubscriber
+		);
 		return true;
 	}
 
@@ -195,13 +201,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 +225,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,21 +246,21 @@ 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: BN): Promise<boolean> {
+		if (this.spotMarketAccountSubscribers.has(marketIndex.toNumber())) {
 			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: BN): Promise<boolean> {
+		if (this.perpMarketAccountSubscribers.has(marketIndex.toNumber())) {
 			return true;
 		}
 		return this.subscribeToMarketAccount(marketIndex);
@@ -287,23 +293,30 @@ export class WebSocketClearingHouseAccountSubscriber
 
 	public getMarketAccountAndSlot(
 		marketIndex: BN
-	): DataAndSlot<MarketAccount> | undefined {
+	): DataAndSlot<PerpMarketAccount> | undefined {
 		this.assertIsSubscribed();
-		return this.marketAccountSubscribers.get(marketIndex.toNumber())
+		return this.perpMarketAccountSubscribers.get(marketIndex.toNumber())
 			.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: BN
+	): DataAndSlot<SpotMarketAccount> | undefined {
 		this.assertIsSubscribed();
-		return this.bankAccountSubscribers.get(bankIndex.toNumber()).dataAndSlot;
+		return this.spotMarketAccountSubscribers.get(marketIndex.toNumber())
+			.dataAndSlot;
+	}
+
+	public getSpotMarketAccountsAndSlots(): DataAndSlot<SpotMarketAccount>[] {
+		return Array.from(this.spotMarketAccountSubscribers.values()).map(
+			(subscriber) => subscriber.dataAndSlot
+		);
 	}
 
 	public getOraclePriceDataAndSlot(