@drift-labs/sdk 0.1.36-master.7 → 0.2.0-master.10

package/src/accounts/types.ts

@@ -1,30 +1,19 @@
 import {
-	DepositHistoryAccount,
-	ExtendedCurveHistoryAccount,
-	FundingPaymentHistoryAccount,
-	FundingRateHistoryAccount,
-	LiquidationHistoryAccount,
-	MarketsAccount,
-	OrderHistoryAccount,
-	OrderStateAccount,
+	BankAccount,
+	MarketAccount,
+	OracleSource,
 	StateAccount,
-	TradeHistoryAccount,
 	UserAccount,
-	UserOrdersAccount,
-	UserPositionsAccount,
 } from '../types';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { PublicKey } from '@solana/web3.js';
 import { AccountInfo } from '@solana/spl-token';
-import {
-	ClearingHouseConfigType,
-	ClearingHouseUserConfigType,
-	OraclePriceData,
-} from '..';
+import { OracleInfo, OraclePriceData } from '..';
+import { BN } from '@project-serum/anchor';
 
 export interface AccountSubscriber<T> {
-	data?: T;
+	dataAndSlot?: DataAndSlot<T>;
 	subscribe(onChange: (data: T) => void): Promise<void>;
 	fetch(): Promise<void>;
 	unsubscribe(): Promise<void>;
@@ -36,66 +25,39 @@ export class NotSubscribedError extends Error {
 
 export interface ClearingHouseAccountEvents {
 	stateAccountUpdate: (payload: StateAccount) => void;
-	marketsAccountUpdate: (payload: MarketsAccount) => void;
-	fundingPaymentHistoryAccountUpdate: (
-		payload: FundingPaymentHistoryAccount
-	) => void;
-	fundingRateHistoryAccountUpdate: (payload: FundingRateHistoryAccount) => void;
-	tradeHistoryAccountUpdate: (payload: TradeHistoryAccount) => void;
-	liquidationHistoryAccountUpdate: (payload: LiquidationHistoryAccount) => void;
-	depositHistoryAccountUpdate: (payload: DepositHistoryAccount) => void;
-	curveHistoryAccountUpdate: (payload: ExtendedCurveHistoryAccount) => void;
-	orderHistoryAccountUpdate: (payload: OrderHistoryAccount) => void;
-	orderStateAccountUpdate: (payload: OrderStateAccount) => void;
+	marketAccountUpdate: (payload: MarketAccount) => void;
+	bankAccountUpdate: (payload: BankAccount) => void;
+	oraclePriceUpdate: (publicKey: PublicKey, data: OraclePriceData) => void;
+	userAccountUpdate: (payload: UserAccount) => void;
 	update: void;
 	error: (e: Error) => void;
 }
 
-export type ClearingHouseAccountTypes =
-	| 'tradeHistoryAccount'
-	| 'depositHistoryAccount'
-	| 'fundingPaymentHistoryAccount'
-	| 'fundingRateHistoryAccount'
-	| 'curveHistoryAccount'
-	| 'liquidationHistoryAccount'
-	| 'orderHistoryAccount';
-
 export interface ClearingHouseAccountSubscriber {
 	eventEmitter: StrictEventEmitter<EventEmitter, ClearingHouseAccountEvents>;
 	isSubscribed: boolean;
 
-	optionalExtraSubscriptions: ClearingHouseAccountTypes[];
-
-	subscribe(
-		optionalSubscriptions?: ClearingHouseAccountTypes[]
-	): Promise<boolean>;
+	subscribe(): Promise<boolean>;
 	fetch(): Promise<void>;
 	unsubscribe(): Promise<void>;
 
-	getStateAccount(): StateAccount;
-	getMarketsAccount(): MarketsAccount;
-	getTradeHistoryAccount(): TradeHistoryAccount;
-	getDepositHistoryAccount(): DepositHistoryAccount;
-	getFundingPaymentHistoryAccount(): FundingPaymentHistoryAccount;
-	getFundingRateHistoryAccount(): FundingRateHistoryAccount;
-	getCurveHistoryAccount(): ExtendedCurveHistoryAccount;
-	getLiquidationHistoryAccount(): LiquidationHistoryAccount;
-	getOrderStateAccount(): OrderStateAccount;
-	getOrderHistoryAccount(): OrderHistoryAccount;
-
-	type: ClearingHouseConfigType;
+	addMarket(marketIndex: BN): Promise<boolean>;
+	addBank(bankIndex: 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;
+	getOraclePriceDataAndSlot(
+		oraclePublicKey: PublicKey
+	): DataAndSlot<OraclePriceData> | undefined;
 }
 
-export type UserPublicKeys = {
-	user: PublicKey;
-	userPositions: PublicKey;
-	userOrders: PublicKey | undefined;
-};
-
 export interface UserAccountEvents {
-	userAccountData: (payload: UserAccount) => void;
-	userPositionsData: (payload: UserPositionsAccount) => void;
-	userOrdersData: (payload: UserOrdersAccount) => void;
+	userAccountUpdate: (payload: UserAccount) => void;
 	update: void;
 	error: (e: Error) => void;
 }
@@ -108,10 +70,7 @@ export interface UserAccountSubscriber {
 	fetch(): Promise<void>;
 	unsubscribe(): Promise<void>;
 
-	getUserAccount(): UserAccount;
-	getUserPositionsAccount(): UserPositionsAccount;
-	getUserOrdersAccount(): UserOrdersAccount;
-	type: ClearingHouseUserConfigType;
+	getUserAccountAndSlot(): DataAndSlot<UserAccount>;
 }
 
 export interface TokenAccountEvents {
@@ -128,7 +87,7 @@ export interface TokenAccountSubscriber {
 	fetch(): Promise<void>;
 	unsubscribe(): Promise<void>;
 
-	getTokenAccount(): AccountInfo;
+	getTokenAccountAndSlot(): DataAndSlot<AccountInfo>;
 }
 
 export interface OracleEvents {
@@ -145,7 +104,7 @@ export interface OracleSubscriber {
 	fetch(): Promise<void>;
 	unsubscribe(): Promise<void>;
 
-	getOraclePriceData(): OraclePriceData;
+	getOraclePriceData(): DataAndSlot<OraclePriceData>;
 }
 
 export type AccountToPoll = {
@@ -153,9 +112,21 @@ export type AccountToPoll = {
 	publicKey: PublicKey;
 	eventType: string;
 	callbackId?: string;
+	mapKey?: number;
 };
 
-export type AccountData = {
+export type OraclesToPoll = {
+	publicKey: PublicKey;
+	source: OracleSource;
+	callbackId?: string;
+};
+
+export type BufferAndSlot = {
 	slot: number;
 	buffer: Buffer | undefined;
 };
+
+export type DataAndSlot<T> = {
+	data: T;
+	slot: number;
+};

package/src/accounts/utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalize = void 0;
+function capitalize(value) {
+    return value[0].toUpperCase() + value.slice(1);
+}
+exports.capitalize = capitalize;

package/src/accounts/webSocketAccountSubscriber.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketAccountSubscriber = void 0;
+const utils_1 = require("./utils");
+class WebSocketAccountSubscriber {
+    constructor(accountName, program, accountPublicKey, decodeBuffer) {
+        this.accountName = accountName;
+        this.program = program;
+        this.accountPublicKey = accountPublicKey;
+        this.decodeBufferFn = decodeBuffer;
+    }
+    subscribe(onChange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.listenerId) {
+                return;
+            }
+            this.onChange = onChange;
+            yield this.fetch();
+            this.listenerId = this.program.provider.connection.onAccountChange(this.accountPublicKey, (accountInfo, context) => {
+                this.handleRpcResponse(context, accountInfo);
+            }, this.program.provider.opts.commitment);
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rpcResponse = yield this.program.provider.connection.getAccountInfoAndContext(this.accountPublicKey, this.program.provider.opts.commitment);
+            this.handleRpcResponse(rpcResponse.context, rpcResponse === null || rpcResponse === void 0 ? void 0 : rpcResponse.value);
+        });
+    }
+    handleRpcResponse(context, accountInfo) {
+        const newSlot = context.slot;
+        let newBuffer = undefined;
+        if (accountInfo) {
+            newBuffer = accountInfo.data;
+        }
+        if (!this.bufferAndSlot) {
+            this.bufferAndSlot = {
+                buffer: newBuffer,
+                slot: newSlot,
+            };
+            if (newBuffer) {
+                const account = this.decodeBuffer(newBuffer);
+                this.dataAndSlot = {
+                    data: account,
+                    slot: newSlot,
+                };
+                this.onChange(account);
+            }
+            return;
+        }
+        if (newSlot <= this.bufferAndSlot.slot) {
+            return;
+        }
+        const oldBuffer = this.bufferAndSlot.buffer;
+        if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+            this.bufferAndSlot = {
+                buffer: newBuffer,
+                slot: newSlot,
+            };
+            const account = this.decodeBuffer(newBuffer);
+            this.dataAndSlot = {
+                data: account,
+                slot: newSlot,
+            };
+            this.onChange(account);
+        }
+    }
+    decodeBuffer(buffer) {
+        if (this.decodeBufferFn) {
+            return this.decodeBufferFn(buffer);
+        }
+        else {
+            return this.program.account[this.accountName].coder.accounts.decode(utils_1.capitalize(this.accountName), buffer);
+        }
+    }
+    unsubscribe() {
+        if (this.listenerId) {
+            const promise = this.program.provider.connection.removeAccountChangeListener(this.listenerId);
+            this.listenerId = undefined;
+            return promise;
+        }
+    }
+}
+exports.WebSocketAccountSubscriber = WebSocketAccountSubscriber;

package/src/accounts/webSocketAccountSubscriber.ts

@@ -1,26 +1,29 @@
-import { AccountData, AccountSubscriber } from './types';
+import { DataAndSlot, BufferAndSlot, AccountSubscriber } from './types';
 import { AnchorProvider, Program } from '@project-serum/anchor';
 import { AccountInfo, Context, PublicKey } from '@solana/web3.js';
 import { capitalize } from './utils';
 import * as Buffer from 'buffer';
 
 export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
-	data?: T;
-	accountData?: AccountData;
+	dataAndSlot?: DataAndSlot<T>;
+	bufferAndSlot?: BufferAndSlot;
 	accountName: string;
 	program: Program;
 	accountPublicKey: PublicKey;
+	decodeBufferFn: (buffer: Buffer) => T;
 	onChange: (data: T) => void;
 	listenerId?: number;
 
 	public constructor(
 		accountName: string,
 		program: Program,
-		accountPublicKey: PublicKey
+		accountPublicKey: PublicKey,
+		decodeBuffer?: (buffer: Buffer) => T
 	) {
 		this.accountName = accountName;
 		this.program = program;
 		this.accountPublicKey = accountPublicKey;
+		this.decodeBufferFn = decodeBuffer;
 	}
 
 	async subscribe(onChange: (data: T) => void): Promise<void> {
@@ -56,35 +59,49 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 			newBuffer = accountInfo.data;
 		}
 
-		if (!this.accountData) {
-			this.accountData = {
+		if (!this.bufferAndSlot) {
+			this.bufferAndSlot = {
 				buffer: newBuffer,
 				slot: newSlot,
 			};
 			if (newBuffer) {
-				this.data = this.program.account[
-					this.accountName
-				].coder.accounts.decode(capitalize(this.accountName), newBuffer);
-				this.onChange(this.data);
+				const account = this.decodeBuffer(newBuffer);
+				this.dataAndSlot = {
+					data: account,
+					slot: newSlot,
+				};
+				this.onChange(account);
 			}
 			return;
 		}
 
-		if (newSlot <= this.accountData.slot) {
+		if (newSlot <= this.bufferAndSlot.slot) {
 			return;
 		}
 
-		const oldBuffer = this.accountData.buffer;
+		const oldBuffer = this.bufferAndSlot.buffer;
 		if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
-			this.accountData = {
+			this.bufferAndSlot = {
 				buffer: newBuffer,
 				slot: newSlot,
 			};
-			this.data = this.program.account[this.accountName].coder.accounts.decode(
+			const account = this.decodeBuffer(newBuffer);
+			this.dataAndSlot = {
+				data: account,
+				slot: newSlot,
+			};
+			this.onChange(account);
+		}
+	}
+
+	decodeBuffer(buffer: Buffer): T {
+		if (this.decodeBufferFn) {
+			return this.decodeBufferFn(buffer);
+		} else {
+			return this.program.account[this.accountName].coder.accounts.decode(
 				capitalize(this.accountName),
-				newBuffer
+				buffer
 			);
-			this.onChange(this.data);
 		}
 	}
 

package/src/accounts/webSocketClearingHouseAccountSubscriber.js

@@ -0,0 +1,233 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClearingHouseAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const pda_1 = require("../addresses/pda");
+const webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+const web3_js_1 = require("@solana/web3.js");
+const oracleClientCache_1 = require("../oracles/oracleClientCache");
+const quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
+class WebSocketClearingHouseAccountSubscriber {
+    constructor(program, marketIndexes, bankIndexes, oracleInfos) {
+        this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
+        this.marketAccountSubscribers = new Map();
+        this.bankAccountSubscribers = new Map();
+        this.oracleSubscribers = new Map();
+        this.isSubscribing = false;
+        this.isSubscribed = false;
+        this.program = program;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.marketIndexes = marketIndexes;
+        this.bankIndexes = bankIndexes;
+        this.oracleInfos = oracleInfos;
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed) {
+                return true;
+            }
+            if (this.isSubscribing) {
+                return yield this.subscriptionPromise;
+            }
+            this.isSubscribing = true;
+            this.subscriptionPromise = new Promise((res) => {
+                this.subscriptionPromiseResolver = res;
+            });
+            const statePublicKey = yield pda_1.getClearingHouseStateAccountPublicKey(this.program.programId);
+            // create and activate main state account subscription
+            this.stateAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('state', this.program, statePublicKey);
+            yield this.stateAccountSubscriber.subscribe((data) => {
+                this.eventEmitter.emit('stateAccountUpdate', data);
+                this.eventEmitter.emit('update');
+            });
+            // subscribe to market accounts
+            yield this.subscribeToMarketAccounts();
+            // subscribe to bank accounts
+            yield this.subscribeToBankAccounts();
+            // subscribe to oracles
+            yield this.subscribeToOracles();
+            this.eventEmitter.emit('update');
+            this.isSubscribing = false;
+            this.isSubscribed = true;
+            this.subscriptionPromiseResolver(true);
+            return true;
+        });
+    }
+    subscribeToMarketAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const marketIndex of this.marketIndexes) {
+                yield this.subscribeToMarketAccount(marketIndex);
+            }
+            return true;
+        });
+    }
+    subscribeToMarketAccount(marketIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const marketPublicKey = yield pda_1.getMarketPublicKey(this.program.programId, marketIndex);
+            const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('market', this.program, marketPublicKey);
+            yield accountSubscriber.subscribe((data) => {
+                this.eventEmitter.emit('marketAccountUpdate', data);
+                this.eventEmitter.emit('update');
+            });
+            this.marketAccountSubscribers.set(marketIndex.toNumber(), accountSubscriber);
+            return true;
+        });
+    }
+    subscribeToBankAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const bankIndex of this.bankIndexes) {
+                yield this.subscribeToBankAccount(bankIndex);
+            }
+            return true;
+        });
+    }
+    subscribeToBankAccount(bankIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bankPublicKey = yield pda_1.getBankPublicKey(this.program.programId, bankIndex);
+            const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('bank', this.program, bankPublicKey);
+            yield accountSubscriber.subscribe((data) => {
+                this.eventEmitter.emit('bankAccountUpdate', data);
+                this.eventEmitter.emit('update');
+            });
+            this.bankAccountSubscribers.set(bankIndex.toNumber(), accountSubscriber);
+            return true;
+        });
+    }
+    subscribeToOracles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const oracleInfo of this.oracleInfos) {
+                if (!oracleInfo.publicKey.equals(web3_js_1.PublicKey.default)) {
+                    yield this.subscribeToOracle(oracleInfo);
+                }
+            }
+            return true;
+        });
+    }
+    subscribeToOracle(oracleInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = this.oracleClientCache.get(oracleInfo.source, this.program.provider.connection);
+            const accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('oracle', this.program, oracleInfo.publicKey, (buffer) => {
+                return client.getOraclePriceDataFromBuffer(buffer);
+            });
+            yield accountSubscriber.subscribe((data) => {
+                this.eventEmitter.emit('oraclePriceUpdate', oracleInfo.publicKey, data);
+                this.eventEmitter.emit('update');
+            });
+            this.oracleSubscribers.set(oracleInfo.publicKey.toString(), accountSubscriber);
+            return true;
+        });
+    }
+    unsubscribeFromMarketAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const accountSubscriber of this.marketAccountSubscribers.values()) {
+                yield accountSubscriber.unsubscribe();
+            }
+        });
+    }
+    unsubscribeFromBankAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const accountSubscriber of this.bankAccountSubscribers.values()) {
+                yield accountSubscriber.unsubscribe();
+            }
+        });
+    }
+    unsubscribeFromOracles() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const accountSubscriber of this.oracleSubscribers.values()) {
+                yield accountSubscriber.unsubscribe();
+            }
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            const promises = [this.stateAccountSubscriber.fetch()]
+                .concat(Array.from(this.marketAccountSubscribers.values()).map((subscriber) => subscriber.fetch()))
+                .concat(Array.from(this.bankAccountSubscribers.values()).map((subscriber) => subscriber.fetch()));
+            yield Promise.all(promises);
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            yield this.stateAccountSubscriber.unsubscribe();
+            yield this.unsubscribeFromMarketAccounts();
+            yield this.unsubscribeFromBankAccounts();
+            yield this.unsubscribeFromOracles();
+            this.isSubscribed = false;
+        });
+    }
+    addBank(bankIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.bankAccountSubscribers.has(bankIndex.toNumber())) {
+                return true;
+            }
+            return this.subscribeToBankAccount(bankIndex);
+        });
+    }
+    addMarket(marketIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.marketAccountSubscribers.has(marketIndex.toNumber())) {
+                return true;
+            }
+            return this.subscribeToMarketAccount(marketIndex);
+        });
+    }
+    addOracle(oracleInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.oracleSubscribers.has(oracleInfo.publicKey.toString())) {
+                return true;
+            }
+            if (oracleInfo.publicKey.equals(web3_js_1.PublicKey.default)) {
+                return true;
+            }
+            return this.subscribeToOracle(oracleInfo);
+        });
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getStateAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.stateAccountSubscriber.dataAndSlot;
+    }
+    getMarketAccountAndSlot(marketIndex) {
+        this.assertIsSubscribed();
+        return this.marketAccountSubscribers.get(marketIndex.toNumber())
+            .dataAndSlot;
+    }
+    getMarketAccountsAndSlots() {
+        return Array.from(this.marketAccountSubscribers.values()).map((subscriber) => subscriber.dataAndSlot);
+    }
+    getBankAccountAndSlot(bankIndex) {
+        this.assertIsSubscribed();
+        return this.bankAccountSubscribers.get(bankIndex.toNumber()).dataAndSlot;
+    }
+    getOraclePriceDataAndSlot(oraclePublicKey) {
+        this.assertIsSubscribed();
+        if (oraclePublicKey.equals(web3_js_1.PublicKey.default)) {
+            return {
+                data: quoteAssetOracleClient_1.QUOTE_ORACLE_PRICE_DATA,
+                slot: 0,
+            };
+        }
+        return this.oracleSubscribers.get(oraclePublicKey.toString()).dataAndSlot;
+    }
+}
+exports.WebSocketClearingHouseAccountSubscriber = WebSocketClearingHouseAccountSubscriber;