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

package/src/accounts/pollingOracleSubscriber.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.PollingOracleSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+class PollingOracleSubscriber {
+    constructor(publicKey, oracleClient, accountLoader) {
+        this.isSubscribed = false;
+        this.publicKey = publicKey;
+        this.oracleClient = oracleClient;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed) {
+                return true;
+            }
+            this.addToAccountLoader();
+            let subscriptionSucceeded = false;
+            let retries = 0;
+            while (!subscriptionSucceeded && retries < 5) {
+                yield this.fetch();
+                subscriptionSucceeded = this.didSubscriptionSucceed();
+                retries++;
+            }
+            if (subscriptionSucceeded) {
+                this.eventEmitter.emit('update');
+            }
+            this.isSubscribed = subscriptionSucceeded;
+            return subscriptionSucceeded;
+        });
+    }
+    addToAccountLoader() {
+        if (this.callbackId) {
+            return;
+        }
+        this.callbackId = this.accountLoader.addAccount(this.publicKey, (buffer, slot) => __awaiter(this, void 0, void 0, function* () {
+            const oraclePriceData = yield this.oracleClient.getOraclePriceDataFromBuffer(buffer);
+            this.oraclePriceData = { data: oraclePriceData, slot };
+            // @ts-ignore
+            this.eventEmitter.emit('oracleUpdate', oraclePriceData);
+            this.eventEmitter.emit('update');
+        }));
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.accountLoader.load();
+            const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.publicKey);
+            this.oraclePriceData = {
+                data: yield this.oracleClient.getOraclePriceDataFromBuffer(buffer),
+                slot,
+            };
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            this.accountLoader.removeAccount(this.publicKey, this.callbackId);
+            this.callbackId = undefined;
+            this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+            this.errorCallbackId = undefined;
+            this.isSubscribed = false;
+        });
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getOraclePriceData() {
+        this.assertIsSubscribed();
+        return this.oraclePriceData;
+    }
+    didSubscriptionSucceed() {
+        return !!this.oraclePriceData;
+    }
+}
+exports.PollingOracleSubscriber = PollingOracleSubscriber;

package/src/accounts/pollingOracleSubscriber.ts

@@ -1,4 +1,9 @@
-import { NotSubscribedError, OracleEvents, OracleSubscriber } from './types';
+import {
+	DataAndSlot,
+	NotSubscribedError,
+	OracleEvents,
+	OracleSubscriber,
+} from './types';
 import { Program } from '@project-serum/anchor';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
@@ -17,7 +22,7 @@ export class PollingOracleSubscriber implements OracleSubscriber {
 	callbackId?: string;
 	errorCallbackId?: string;
 
-	oraclePriceData?: OraclePriceData;
+	oraclePriceData?: DataAndSlot<OraclePriceData>;
 
 	public constructor(
 		publicKey: PublicKey,
@@ -61,10 +66,10 @@ export class PollingOracleSubscriber implements OracleSubscriber {
 
 		this.callbackId = this.accountLoader.addAccount(
 			this.publicKey,
-			async (buffer) => {
+			async (buffer, slot) => {
 				const oraclePriceData =
 					await this.oracleClient.getOraclePriceDataFromBuffer(buffer);
-				this.oraclePriceData = oraclePriceData;
+				this.oraclePriceData = { data: oraclePriceData, slot };
 				// @ts-ignore
 				this.eventEmitter.emit('oracleUpdate', oraclePriceData);
 				this.eventEmitter.emit('update');
@@ -78,10 +83,13 @@ export class PollingOracleSubscriber implements OracleSubscriber {
 
 	async fetch(): Promise<void> {
 		await this.accountLoader.load();
-		const buffer = this.accountLoader.getAccountData(this.publicKey);
-		this.oraclePriceData = await this.oracleClient.getOraclePriceDataFromBuffer(
-			buffer
+		const { buffer, slot } = this.accountLoader.getBufferAndSlot(
+			this.publicKey
 		);
+		this.oraclePriceData = {
+			data: await this.oracleClient.getOraclePriceDataFromBuffer(buffer),
+			slot,
+		};
 	}
 
 	async unsubscribe(): Promise<void> {
@@ -106,7 +114,7 @@ export class PollingOracleSubscriber implements OracleSubscriber {
 		}
 	}
 
-	public getOraclePriceData(): OraclePriceData {
+	public getOraclePriceData(): DataAndSlot<OraclePriceData> {
 		this.assertIsSubscribed();
 		return this.oraclePriceData;
 	}

package/src/accounts/pollingTokenAccountSubscriber.js

@@ -0,0 +1,90 @@
+"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.PollingTokenAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const token_1 = require("../token");
+class PollingTokenAccountSubscriber {
+    constructor(publicKey, accountLoader) {
+        this.isSubscribed = false;
+        this.publicKey = publicKey;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed) {
+                return true;
+            }
+            this.addToAccountLoader();
+            let subscriptionSucceeded = false;
+            let retries = 0;
+            while (!subscriptionSucceeded && retries < 5) {
+                yield this.fetch();
+                subscriptionSucceeded = this.didSubscriptionSucceed();
+                retries++;
+            }
+            if (subscriptionSucceeded) {
+                this.eventEmitter.emit('update');
+            }
+            this.isSubscribed = subscriptionSucceeded;
+            return subscriptionSucceeded;
+        });
+    }
+    addToAccountLoader() {
+        if (this.callbackId) {
+            return;
+        }
+        this.callbackId = this.accountLoader.addAccount(this.publicKey, (buffer, slot) => {
+            const tokenAccount = token_1.parseTokenAccount(buffer);
+            this.tokenAccountAndSlot = { data: tokenAccount, slot };
+            // @ts-ignore
+            this.eventEmitter.emit('tokenAccountUpdate', tokenAccount);
+            this.eventEmitter.emit('update');
+        });
+        this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+            this.eventEmitter.emit('error', error);
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.accountLoader.load();
+            const { buffer, slot } = this.accountLoader.getBufferAndSlot(this.publicKey);
+            this.tokenAccountAndSlot = { data: token_1.parseTokenAccount(buffer), slot };
+        });
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            this.accountLoader.removeAccount(this.publicKey, this.callbackId);
+            this.callbackId = undefined;
+            this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+            this.errorCallbackId = undefined;
+            this.isSubscribed = false;
+        });
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getTokenAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.tokenAccountAndSlot;
+    }
+    didSubscriptionSucceed() {
+        return !!this.tokenAccountAndSlot;
+    }
+}
+exports.PollingTokenAccountSubscriber = PollingTokenAccountSubscriber;

package/src/accounts/pollingTokenAccountSubscriber.ts

@@ -1,4 +1,5 @@
 import {
+	DataAndSlot,
 	NotSubscribedError,
 	TokenAccountEvents,
 	TokenAccountSubscriber,
@@ -21,7 +22,7 @@ export class PollingTokenAccountSubscriber implements TokenAccountSubscriber {
 	callbackId?: string;
 	errorCallbackId?: string;
 
-	tokenAccount?: AccountInfo;
+	tokenAccountAndSlot?: DataAndSlot<AccountInfo>;
 
 	public constructor(publicKey: PublicKey, accountLoader: BulkAccountLoader) {
 		this.isSubscribed = false;
@@ -59,9 +60,9 @@ export class PollingTokenAccountSubscriber implements TokenAccountSubscriber {
 
 		this.callbackId = this.accountLoader.addAccount(
 			this.publicKey,
-			(buffer) => {
+			(buffer, slot: number) => {
 				const tokenAccount = parseTokenAccount(buffer);
-				this.tokenAccount = tokenAccount;
+				this.tokenAccountAndSlot = { data: tokenAccount, slot };
 				// @ts-ignore
 				this.eventEmitter.emit('tokenAccountUpdate', tokenAccount);
 				this.eventEmitter.emit('update');
@@ -75,8 +76,10 @@ export class PollingTokenAccountSubscriber implements TokenAccountSubscriber {
 
 	async fetch(): Promise<void> {
 		await this.accountLoader.load();
-		const buffer = this.accountLoader.getAccountData(this.publicKey);
-		this.tokenAccount = parseTokenAccount(buffer);
+		const { buffer, slot } = this.accountLoader.getBufferAndSlot(
+			this.publicKey
+		);
+		this.tokenAccountAndSlot = { data: parseTokenAccount(buffer), slot };
 	}
 
 	async unsubscribe(): Promise<void> {
@@ -101,12 +104,12 @@ export class PollingTokenAccountSubscriber implements TokenAccountSubscriber {
 		}
 	}
 
-	public getTokenAccount(): AccountInfo {
+	public getTokenAccountAndSlot(): DataAndSlot<AccountInfo> {
 		this.assertIsSubscribed();
-		return this.tokenAccount;
+		return this.tokenAccountAndSlot;
 	}
 
 	didSubscriptionSucceed(): boolean {
-		return !!this.tokenAccount;
+		return !!this.tokenAccountAndSlot;
 	}
 }

package/src/accounts/pollingUserAccountSubscriber.js

@@ -0,0 +1,132 @@
+"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.PollingUserAccountSubscriber = void 0;
+const types_1 = require("./types");
+const events_1 = require("events");
+const utils_1 = require("./utils");
+class PollingUserAccountSubscriber {
+    constructor(program, userAccountPublicKey, accountLoader) {
+        this.accountsToPoll = new Map();
+        this.isSubscribed = false;
+        this.program = program;
+        this.accountLoader = accountLoader;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.userAccountPublicKey = userAccountPublicKey;
+    }
+    subscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSubscribed) {
+                return true;
+            }
+            yield this.addToAccountLoader();
+            let subscriptionSucceeded = false;
+            let retries = 0;
+            while (!subscriptionSucceeded && retries < 5) {
+                yield this.fetchIfUnloaded();
+                subscriptionSucceeded = this.didSubscriptionSucceed();
+                retries++;
+            }
+            if (subscriptionSucceeded) {
+                this.eventEmitter.emit('update');
+            }
+            this.isSubscribed = subscriptionSucceeded;
+            return subscriptionSucceeded;
+        });
+    }
+    addToAccountLoader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.accountsToPoll.size > 0) {
+                return;
+            }
+            this.accountsToPoll.set(this.userAccountPublicKey.toString(), {
+                key: 'user',
+                publicKey: this.userAccountPublicKey,
+                eventType: 'userAccountUpdate',
+            });
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                accountToPoll.callbackId = this.accountLoader.addAccount(accountToPoll.publicKey, (buffer, slot) => {
+                    if (!buffer) {
+                        return;
+                    }
+                    const account = this.program.account[accountToPoll.key].coder.accounts.decode(utils_1.capitalize(accountToPoll.key), buffer);
+                    this[accountToPoll.key] = { data: account, slot };
+                    // @ts-ignore
+                    this.eventEmitter.emit(accountToPoll.eventType, account);
+                    this.eventEmitter.emit('update');
+                });
+            }
+            this.errorCallbackId = this.accountLoader.addErrorCallbacks((error) => {
+                this.eventEmitter.emit('error', error);
+            });
+        });
+    }
+    fetchIfUnloaded() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let shouldFetch = false;
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                if (this[accountToPoll.key] === undefined) {
+                    shouldFetch = true;
+                    break;
+                }
+            }
+            if (shouldFetch) {
+                yield this.fetch();
+            }
+        });
+    }
+    fetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.accountLoader.load();
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                const { buffer, slot } = this.accountLoader.getBufferAndSlot(accountToPoll.publicKey);
+                if (buffer) {
+                    const account = this.program.account[accountToPoll.key].coder.accounts.decode(utils_1.capitalize(accountToPoll.key), buffer);
+                    this[accountToPoll.key] = { data: account, slot };
+                }
+            }
+        });
+    }
+    didSubscriptionSucceed() {
+        let success = true;
+        for (const [_, accountToPoll] of this.accountsToPoll) {
+            if (!this[accountToPoll.key]) {
+                success = false;
+                break;
+            }
+        }
+        return success;
+    }
+    unsubscribe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isSubscribed) {
+                return;
+            }
+            for (const [_, accountToPoll] of this.accountsToPoll) {
+                this.accountLoader.removeAccount(accountToPoll.publicKey, accountToPoll.callbackId);
+            }
+            this.accountLoader.removeErrorCallbacks(this.errorCallbackId);
+            this.errorCallbackId = undefined;
+            this.accountsToPoll.clear();
+            this.isSubscribed = false;
+        });
+    }
+    assertIsSubscribed() {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    }
+    getUserAccountAndSlot() {
+        this.assertIsSubscribed();
+        return this.user;
+    }
+}
+exports.PollingUserAccountSubscriber = PollingUserAccountSubscriber;

package/src/accounts/pollingUserAccountSubscriber.ts

@@ -1,49 +1,40 @@
 import {
+	DataAndSlot,
 	AccountToPoll,
 	NotSubscribedError,
 	UserAccountEvents,
 	UserAccountSubscriber,
-	UserPublicKeys,
 } 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 {
-	getUserAccountPublicKey,
-	getUserOrdersAccountPublicKey,
-} from '../addresses';
-import { UserAccount, UserOrdersAccount, UserPositionsAccount } from '../types';
+import { UserAccount } from '../types';
 import { BulkAccountLoader } from './bulkAccountLoader';
 import { capitalize } from './utils';
-import { ClearingHouseConfigType } from '../factory/clearingHouse';
 
 export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 	isSubscribed: boolean;
 	program: Program;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
-	authority: PublicKey;
+	userAccountPublicKey: PublicKey;
 
 	accountLoader: BulkAccountLoader;
 	accountsToPoll = new Map<string, AccountToPoll>();
 	errorCallbackId?: string;
 
-	user?: UserAccount;
-	userPositions?: UserPositionsAccount;
-	userOrders?: UserOrdersAccount;
-
-	type: ClearingHouseConfigType = 'polling';
+	user?: DataAndSlot<UserAccount>;
 
 	public constructor(
 		program: Program,
-		authority: PublicKey,
+		userAccountPublicKey: PublicKey,
 		accountLoader: BulkAccountLoader
 	) {
 		this.isSubscribed = false;
 		this.program = program;
-		this.authority = authority;
 		this.accountLoader = accountLoader;
 		this.eventEmitter = new EventEmitter();
+		this.userAccountPublicKey = userAccountPublicKey;
 	}
 
 	async subscribe(): Promise<boolean> {
@@ -69,69 +60,21 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 		return subscriptionSucceeded;
 	}
 
-	async addToAccountLoader(userPublicKeys?: UserPublicKeys): Promise<void> {
+	async addToAccountLoader(): Promise<void> {
 		if (this.accountsToPoll.size > 0) {
 			return;
 		}
 
-		if (!userPublicKeys) {
-			const userPublicKey = await getUserAccountPublicKey(
-				this.program.programId,
-				this.authority
-			);
-
-			const userAccount = (await this.program.account.user.fetch(
-				userPublicKey
-			)) as UserAccount;
-
-			this.accountsToPoll.set(userPublicKey.toString(), {
-				key: 'user',
-				publicKey: userPublicKey,
-				eventType: 'userAccountData',
-			});
-
-			this.accountsToPoll.set(userAccount.positions.toString(), {
-				key: 'userPositions',
-				publicKey: userAccount.positions,
-				eventType: 'userPositionsData',
-			});
-
-			const userOrdersPublicKey = await getUserOrdersAccountPublicKey(
-				this.program.programId,
-				userPublicKey
-			);
-
-			this.accountsToPoll.set(userOrdersPublicKey.toString(), {
-				key: 'userOrders',
-				publicKey: userOrdersPublicKey,
-				eventType: 'userOrdersData',
-			});
-		} else {
-			this.accountsToPoll.set(userPublicKeys.user.toString(), {
-				key: 'user',
-				publicKey: userPublicKeys.user,
-				eventType: 'userAccountData',
-			});
-
-			this.accountsToPoll.set(userPublicKeys.userPositions.toString(), {
-				key: 'userPositions',
-				publicKey: userPublicKeys.userPositions,
-				eventType: 'userPositionsData',
-			});
-
-			if (userPublicKeys.userOrders) {
-				this.accountsToPoll.set(userPublicKeys.userOrders.toString(), {
-					key: 'userOrders',
-					publicKey: userPublicKeys.userOrders,
-					eventType: 'userOrdersData',
-				});
-			}
-		}
+		this.accountsToPoll.set(this.userAccountPublicKey.toString(), {
+			key: 'user',
+			publicKey: this.userAccountPublicKey,
+			eventType: 'userAccountUpdate',
+		});
 
 		for (const [_, accountToPoll] of this.accountsToPoll) {
 			accountToPoll.callbackId = this.accountLoader.addAccount(
 				accountToPoll.publicKey,
-				(buffer) => {
+				(buffer, slot) => {
 					if (!buffer) {
 						return;
 					}
@@ -139,7 +82,7 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 					const account = this.program.account[
 						accountToPoll.key
 					].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
-					this[accountToPoll.key] = account;
+					this[accountToPoll.key] = { data: account, slot };
 					// @ts-ignore
 					this.eventEmitter.emit(accountToPoll.eventType, account);
 					this.eventEmitter.emit('update');
@@ -169,11 +112,14 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 	async fetch(): Promise<void> {
 		await this.accountLoader.load();
 		for (const [_, accountToPoll] of this.accountsToPoll) {
-			const buffer = this.accountLoader.getAccountData(accountToPoll.publicKey);
+			const { buffer, slot } = this.accountLoader.getBufferAndSlot(
+				accountToPoll.publicKey
+			);
 			if (buffer) {
-				this[accountToPoll.key] = this.program.account[
+				const account = this.program.account[
 					accountToPoll.key
 				].coder.accounts.decode(capitalize(accountToPoll.key), buffer);
+				this[accountToPoll.key] = { data: account, slot };
 			}
 		}
 	}
@@ -181,8 +127,7 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 	didSubscriptionSucceed(): boolean {
 		let success = true;
 		for (const [_, accountToPoll] of this.accountsToPoll) {
-			// userOrders may not exist
-			if (accountToPoll.key !== 'userOrders' && !this[accountToPoll.key]) {
+			if (!this[accountToPoll.key]) {
 				success = false;
 				break;
 			}
@@ -218,18 +163,8 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 		}
 	}
 
-	public getUserAccount(): UserAccount {
+	public getUserAccountAndSlot(): DataAndSlot<UserAccount> {
 		this.assertIsSubscribed();
 		return this.user;
 	}
-
-	public getUserPositionsAccount(): UserPositionsAccount {
-		this.assertIsSubscribed();
-		return this.userPositions;
-	}
-
-	public getUserOrdersAccount(): UserOrdersAccount {
-		this.assertIsSubscribed();
-		return this.userOrders;
-	}
 }

package/src/accounts/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotSubscribedError = void 0;
+class NotSubscribedError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'NotSubscribedError';
+    }
+}
+exports.NotSubscribedError = NotSubscribedError;