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

package/src/accounts/webSocketClearingHouseAccountSubscriber.js

@@ -0,0 +1,433 @@
+"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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+exports.__esModule = true;
+exports.WebSocketClearingHouseAccountSubscriber = void 0;
+var types_1 = require("./types");
+var events_1 = require("events");
+var pda_1 = require("../addresses/pda");
+var webSocketAccountSubscriber_1 = require("./webSocketAccountSubscriber");
+var web3_js_1 = require("@solana/web3.js");
+var oracleClientCache_1 = require("../oracles/oracleClientCache");
+var quoteAssetOracleClient_1 = require("../oracles/quoteAssetOracleClient");
+var WebSocketClearingHouseAccountSubscriber = /** @class */ (function () {
+    function WebSocketClearingHouseAccountSubscriber(program, perpMarketIndexes, spotMarketIndexes, oracleInfos) {
+        this.oracleClientCache = new oracleClientCache_1.OracleClientCache();
+        this.perpMarketAccountSubscribers = new Map();
+        this.spotMarketAccountSubscribers = new Map();
+        this.oracleSubscribers = new Map();
+        this.isSubscribing = false;
+        this.isSubscribed = false;
+        this.program = program;
+        this.eventEmitter = new events_1.EventEmitter();
+        this.perpMarketIndexes = perpMarketIndexes;
+        this.spotMarketIndexes = spotMarketIndexes;
+        this.oracleInfos = oracleInfos;
+    }
+    WebSocketClearingHouseAccountSubscriber.prototype.subscribe = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var statePublicKey;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.isSubscribed) {
+                            return [2 /*return*/, true];
+                        }
+                        if (!this.isSubscribing) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.subscriptionPromise];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        this.isSubscribing = true;
+                        this.subscriptionPromise = new Promise(function (res) {
+                            _this.subscriptionPromiseResolver = res;
+                        });
+                        return [4 /*yield*/, (0, pda_1.getClearingHouseStateAccountPublicKey)(this.program.programId)];
+                    case 3:
+                        statePublicKey = _a.sent();
+                        // create and activate main state account subscription
+                        this.stateAccountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('state', this.program, statePublicKey);
+                        return [4 /*yield*/, this.stateAccountSubscriber.subscribe(function (data) {
+                                _this.eventEmitter.emit('stateAccountUpdate', data);
+                                _this.eventEmitter.emit('update');
+                            })];
+                    case 4:
+                        _a.sent();
+                        // subscribe to market accounts
+                        return [4 /*yield*/, this.subscribeToMarketAccounts()];
+                    case 5:
+                        // subscribe to market accounts
+                        _a.sent();
+                        // subscribe to spot market accounts
+                        return [4 /*yield*/, this.subscribeToSpotMarketAccounts()];
+                    case 6:
+                        // subscribe to spot market accounts
+                        _a.sent();
+                        // subscribe to oracles
+                        return [4 /*yield*/, this.subscribeToOracles()];
+                    case 7:
+                        // subscribe to oracles
+                        _a.sent();
+                        this.eventEmitter.emit('update');
+                        this.isSubscribing = false;
+                        this.isSubscribed = true;
+                        this.subscriptionPromiseResolver(true);
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.subscribeToMarketAccounts = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, _a, marketIndex;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _i = 0, _a = this.perpMarketIndexes;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        marketIndex = _a[_i];
+                        return [4 /*yield*/, this.subscribeToMarketAccount(marketIndex)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.subscribeToMarketAccount = function (marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var marketPublicKey, accountSubscriber;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, pda_1.getMarketPublicKey)(this.program.programId, marketIndex)];
+                    case 1:
+                        marketPublicKey = _a.sent();
+                        accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('perpMarket', this.program, marketPublicKey);
+                        return [4 /*yield*/, accountSubscriber.subscribe(function (data) {
+                                _this.eventEmitter.emit('perpMarketAccountUpdate', data);
+                                _this.eventEmitter.emit('update');
+                            })];
+                    case 2:
+                        _a.sent();
+                        this.perpMarketAccountSubscribers.set(marketIndex.toNumber(), accountSubscriber);
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.subscribeToSpotMarketAccounts = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, _a, marketIndex;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _i = 0, _a = this.spotMarketIndexes;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        marketIndex = _a[_i];
+                        return [4 /*yield*/, this.subscribeToSpotMarketAccount(marketIndex)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.subscribeToSpotMarketAccount = function (marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            var marketPublicKey, accountSubscriber;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, pda_1.getSpotMarketPublicKey)(this.program.programId, marketIndex)];
+                    case 1:
+                        marketPublicKey = _a.sent();
+                        accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('spotMarket', this.program, marketPublicKey);
+                        return [4 /*yield*/, accountSubscriber.subscribe(function (data) {
+                                _this.eventEmitter.emit('spotMarketAccountUpdate', data);
+                                _this.eventEmitter.emit('update');
+                            })];
+                    case 2:
+                        _a.sent();
+                        this.spotMarketAccountSubscribers.set(marketIndex.toNumber(), accountSubscriber);
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.subscribeToOracles = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, _a, oracleInfo;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _i = 0, _a = this.oracleInfos;
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        oracleInfo = _a[_i];
+                        if (!!oracleInfo.publicKey.equals(web3_js_1.PublicKey["default"])) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.subscribeToOracle(oracleInfo)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.subscribeToOracle = function (oracleInfo) {
+        return __awaiter(this, void 0, void 0, function () {
+            var client, accountSubscriber;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        client = this.oracleClientCache.get(oracleInfo.source, this.program.provider.connection);
+                        accountSubscriber = new webSocketAccountSubscriber_1.WebSocketAccountSubscriber('oracle', this.program, oracleInfo.publicKey, function (buffer) {
+                            return client.getOraclePriceDataFromBuffer(buffer);
+                        });
+                        return [4 /*yield*/, accountSubscriber.subscribe(function (data) {
+                                _this.eventEmitter.emit('oraclePriceUpdate', oracleInfo.publicKey, data);
+                                _this.eventEmitter.emit('update');
+                            })];
+                    case 1:
+                        _a.sent();
+                        this.oracleSubscribers.set(oracleInfo.publicKey.toString(), accountSubscriber);
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.unsubscribeFromMarketAccounts = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, _a, accountSubscriber;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _i = 0, _a = this.perpMarketAccountSubscribers.values();
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        accountSubscriber = _a[_i];
+                        return [4 /*yield*/, accountSubscriber.unsubscribe()];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.unsubscribeFromSpotMarketAccounts = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, _a, accountSubscriber;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _i = 0, _a = this.spotMarketAccountSubscribers.values();
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        accountSubscriber = _a[_i];
+                        return [4 /*yield*/, accountSubscriber.unsubscribe()];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.unsubscribeFromOracles = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, _a, accountSubscriber;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _i = 0, _a = this.oracleSubscribers.values();
+                        _b.label = 1;
+                    case 1:
+                        if (!(_i < _a.length)) return [3 /*break*/, 4];
+                        accountSubscriber = _a[_i];
+                        return [4 /*yield*/, accountSubscriber.unsubscribe()];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.fetch = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var promises;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.isSubscribed) {
+                            return [2 /*return*/];
+                        }
+                        promises = [this.stateAccountSubscriber.fetch()]
+                            .concat(Array.from(this.perpMarketAccountSubscribers.values()).map(function (subscriber) { return subscriber.fetch(); }))
+                            .concat(Array.from(this.spotMarketAccountSubscribers.values()).map(function (subscriber) { return subscriber.fetch(); }));
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.unsubscribe = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.isSubscribed) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.stateAccountSubscriber.unsubscribe()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.unsubscribeFromMarketAccounts()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.unsubscribeFromSpotMarketAccounts()];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, this.unsubscribeFromOracles()];
+                    case 4:
+                        _a.sent();
+                        this.isSubscribed = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.addSpotMarket = function (marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (this.spotMarketAccountSubscribers.has(marketIndex.toNumber())) {
+                    return [2 /*return*/, true];
+                }
+                return [2 /*return*/, this.subscribeToSpotMarketAccount(marketIndex)];
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.addPerpMarket = function (marketIndex) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (this.perpMarketAccountSubscribers.has(marketIndex.toNumber())) {
+                    return [2 /*return*/, true];
+                }
+                return [2 /*return*/, this.subscribeToMarketAccount(marketIndex)];
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.addOracle = function (oracleInfo) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (this.oracleSubscribers.has(oracleInfo.publicKey.toString())) {
+                    return [2 /*return*/, true];
+                }
+                if (oracleInfo.publicKey.equals(web3_js_1.PublicKey["default"])) {
+                    return [2 /*return*/, true];
+                }
+                return [2 /*return*/, this.subscribeToOracle(oracleInfo)];
+            });
+        });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.assertIsSubscribed = function () {
+        if (!this.isSubscribed) {
+            throw new types_1.NotSubscribedError('You must call `subscribe` before using this function');
+        }
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.getStateAccountAndSlot = function () {
+        this.assertIsSubscribed();
+        return this.stateAccountSubscriber.dataAndSlot;
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.getMarketAccountAndSlot = function (marketIndex) {
+        this.assertIsSubscribed();
+        return this.perpMarketAccountSubscribers.get(marketIndex.toNumber())
+            .dataAndSlot;
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.getMarketAccountsAndSlots = function () {
+        return Array.from(this.perpMarketAccountSubscribers.values()).map(function (subscriber) { return subscriber.dataAndSlot; });
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.getSpotMarketAccountAndSlot = function (marketIndex) {
+        this.assertIsSubscribed();
+        return this.spotMarketAccountSubscribers.get(marketIndex.toNumber())
+            .dataAndSlot;
+    };
+    WebSocketClearingHouseAccountSubscriber.prototype.getOraclePriceDataAndSlot = function (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;
+    };
+    return WebSocketClearingHouseAccountSubscriber;
+}());
+exports.WebSocketClearingHouseAccountSubscriber = WebSocketClearingHouseAccountSubscriber;

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,24 @@ 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 getOraclePriceDataAndSlot(