@drift-labs/sdk 0.1.18-orders.2 → 0.1.18-orders.6

package/lib/examples/makeTradeExample.js

@@ -53,7 +53,7 @@ const main = () => __awaiter(void 0, void 0, void 0, function* () {
     // Get current price
     const solMarketInfo = __2.Markets.find((market) => market.baseAssetSymbol === 'SOL');
     const currentMarketPrice = __2.calculateMarkPrice(clearingHouse.getMarket(solMarketInfo.marketIndex));
-    const formattedPrice = __2.convertToNumber(currentMarketPrice, __2.QUOTE_PRECISION);
+    const formattedPrice = __2.convertToNumber(currentMarketPrice, __2.MARK_PRICE_PRECISION);
     console.log(`Current Market Price is $${formattedPrice}`);
     // Estimate the slippage for a $5000 LONG trade
     const solMarketAccount = clearingHouse.getMarket(solMarketInfo.marketIndex);

package/lib/idl/clearing_house.json

@@ -572,7 +572,7 @@
                 },
                 {
                     "name": "markets",
-                    "isMut": true,
+                    "isMut": false,
                     "isSigner": false
                 },
                 {
@@ -628,7 +628,7 @@
                 },
                 {
                     "name": "markets",
-                    "isMut": true,
+                    "isMut": false,
                     "isSigner": false
                 },
                 {
@@ -3547,6 +3547,10 @@
                         "name": "price",
                         "type": "u128"
                     },
+                    {
+                        "name": "userBaseAssetAmount",
+                        "type": "i128"
+                    },
                     {
                         "name": "quoteAssetAmount",
                         "type": "u128"
@@ -3734,10 +3738,10 @@
                         "name": "Limit"
                     },
                     {
-                        "name": "Stop"
+                        "name": "TriggerMarket"
                     },
                     {
-                        "name": "StopLimit"
+                        "name": "TriggerLimit"
                     }
                 ]
             }

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-import BN from 'bn.js';
+import { BN } from '@project-serum/anchor';
 import { PublicKey } from '@solana/web3.js';
 export * from './mockUSDCFaucet';
 export * from './pythClient';

package/lib/index.js

@@ -9,13 +9,10 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PublicKey = exports.BN = void 0;
-const bn_js_1 = __importDefault(require("bn.js"));
-exports.BN = bn_js_1.default;
+const anchor_1 = require("@project-serum/anchor");
+Object.defineProperty(exports, "BN", { enumerable: true, get: function () { return anchor_1.BN; } });
 const web3_js_1 = require("@solana/web3.js");
 Object.defineProperty(exports, "PublicKey", { enumerable: true, get: function () { return web3_js_1.PublicKey; } });
 __exportStar(require("./mockUSDCFaucet"), exports);

package/lib/math/conversion.d.ts

@@ -1,3 +1,3 @@
-import BN from 'bn.js';
+import { BN } from '../';
 export declare const convertToNumber: (bigNumber: BN, precision?: BN) => number;
 export declare const convertBaseAssetAmountToNumber: (baseAssetAmount: BN) => number;

package/lib/math/insuranceFund.d.ts

@@ -1,5 +1,6 @@
+/// <reference types="bn.js" />
 import { MarketsAccount, StateAccount } from '../types';
-import BN from 'bn.js';
+import { BN } from '../';
 import { Connection } from '@solana/web3.js';
 /**
  * In the case of a levered loss, the exchange first pays out undistributed fees and then the insurance fund.

package/lib/math/insuranceFund.js

@@ -8,12 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateInsuranceFundSize = void 0;
-const bn_js_1 = __importDefault(require("bn.js"));
+const __1 = require("../");
 /**
  * In the case of a levered loss, the exchange first pays out undistributed fees and then the insurance fund.
  * Thus the de facto size of the insurance fund is the amount in the insurance vault plus the sum of each markets
@@ -27,9 +24,9 @@ const bn_js_1 = __importDefault(require("bn.js"));
 function calculateInsuranceFundSize(connection, state, marketsAccount) {
     return __awaiter(this, void 0, void 0, function* () {
         const insuranceVaultPublicKey = state.insuranceVault;
-        const insuranceVaultAmount = new bn_js_1.default((yield connection.getTokenAccountBalance(insuranceVaultPublicKey)).value.amount);
+        const insuranceVaultAmount = new __1.BN((yield connection.getTokenAccountBalance(insuranceVaultPublicKey)).value.amount);
         return marketsAccount.markets.reduce((insuranceVaultAmount, market) => {
-            return insuranceVaultAmount.add(market.amm.totalFee.div(new bn_js_1.default(2)));
+            return insuranceVaultAmount.add(market.amm.totalFee.div(new __1.BN(2)));
         }, insuranceVaultAmount);
     });
 }

package/lib/math/orders.js

@@ -23,8 +23,9 @@ function isOrderRiskIncreasing(user, order) {
         return true;
     }
     // if order will flip position
-    if (position.baseAssetAmount.abs().gt(order.baseAssetAmountFilled)) {
+    if (order.baseAssetAmountFilled.gt(position.baseAssetAmount.abs().mul(numericConstants_1.TWO))) {
         return true;
     }
+    return false;
 }
 exports.isOrderRiskIncreasing = isOrderRiskIncreasing;

package/lib/math/position.d.ts

@@ -1,4 +1,5 @@
-import BN from 'bn.js';
+/// <reference types="bn.js" />
+import { BN } from '../';
 import { Market, PositionDirection, UserPosition } from '../types';
 /**
  * calculateBaseAssetValue

package/lib/math/position.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isEmptyPosition = exports.positionCurrentDirection = exports.findDirectionToClose = exports.calculateEntryPrice = exports.calculatePositionFundingPNL = exports.calculatePositionPNL = exports.calculateBaseAssetValue = void 0;
-const bn_js_1 = __importDefault(require("bn.js"));
+const __1 = require("../");
 const numericConstants_1 = require("../constants/numericConstants");
 const types_1 = require("../types");
 const amm_1 = require("./amm");
@@ -84,7 +81,7 @@ function calculatePositionFundingPNL(market, marketPosition) {
         .mul(marketPosition.baseAssetAmount)
         .div(numericConstants_1.AMM_RESERVE_PRECISION)
         .div(numericConstants_1.FUNDING_PAYMENT_PRECISION)
-        .mul(new bn_js_1.default(-1));
+        .mul(new __1.BN(-1));
     return perPositionFundingRate;
 }
 exports.calculatePositionFundingPNL = calculatePositionFundingPNL;

package/lib/math/utils.d.ts

@@ -1,2 +1,3 @@
-import BN from 'bn.js';
+/// <reference types="bn.js" />
+import { BN } from '../';
 export declare const squareRootBN: (n: any, closeness?: BN) => any;

package/lib/math/utils.js

@@ -1,18 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.squareRootBN = void 0;
-const bn_js_1 = __importDefault(require("bn.js"));
-const squareRootBN = (n, closeness = new bn_js_1.default(1)) => {
+const __1 = require("../");
+const squareRootBN = (n, closeness = new __1.BN(1)) => {
     // Assuming the sqrt of n as n only
     let x = n;
     // The closed guess will be stored in the root
     let root;
     // To count the number of iterations
     let count = 0;
-    const TWO = new bn_js_1.default(2);
+    const TWO = new __1.BN(2);
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     while (count < Number.MAX_SAFE_INTEGER) {
         count++;

package/lib/mockUSDCFaucet.d.ts

@@ -1,8 +1,9 @@
+/// <reference types="bn.js" />
 import * as anchor from '@project-serum/anchor';
 import { Program, Provider } from '@project-serum/anchor';
 import { AccountInfo } from '@solana/spl-token';
 import { ConfirmOptions, Connection, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
-import BN from 'bn.js';
+import { BN } from '.';
 import { IWallet } from './types';
 export declare class MockUSDCFaucet {
     connection: Connection;

package/lib/orderParams.d.ts

@@ -2,6 +2,6 @@
 import { OrderParams, OrderTriggerCondition, PositionDirection } from './types';
 import { BN } from '@project-serum/anchor';
 export declare function getLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
-export declare function getStopOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
-export declare function getStopLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
+export declare function getTriggerMarketOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
+export declare function getTriggerLimitOrderParams(marketIndex: BN, direction: PositionDirection, baseAssetAmount: BN, price: BN, triggerPrice: BN, triggerCondition: OrderTriggerCondition, reduceOnly: boolean, discountToken?: boolean, referrer?: boolean, userOrderId?: number): OrderParams;
 export declare function getMarketOrderParams(marketIndex: BN, direction: PositionDirection, quoteAssetAmount: BN, baseAssetAmount: BN, reduceOnly: boolean, price?: BN, discountToken?: boolean, referrer?: boolean): OrderParams;

package/lib/orderParams.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMarketOrderParams = exports.getStopLimitOrderParams = exports.getStopOrderParams = exports.getLimitOrderParams = void 0;
+exports.getMarketOrderParams = exports.getTriggerLimitOrderParams = exports.getTriggerMarketOrderParams = exports.getLimitOrderParams = void 0;
 const types_1 = require("./types");
 const numericConstants_1 = require("./constants/numericConstants");
 function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
@@ -28,9 +28,9 @@ function getLimitOrderParams(marketIndex, direction, baseAssetAmount, price, red
     };
 }
 exports.getLimitOrderParams = getLimitOrderParams;
-function getStopOrderParams(marketIndex, direction, baseAssetAmount, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
+function getTriggerMarketOrderParams(marketIndex, direction, baseAssetAmount, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
     return {
-        orderType: types_1.OrderType.STOP,
+        orderType: types_1.OrderType.TRIGGER_MARKET,
         userOrderId,
         marketIndex,
         direction,
@@ -52,10 +52,10 @@ function getStopOrderParams(marketIndex, direction, baseAssetAmount, triggerPric
         oraclePriceOffset: numericConstants_1.ZERO,
     };
 }
-exports.getStopOrderParams = getStopOrderParams;
-function getStopLimitOrderParams(marketIndex, direction, baseAssetAmount, price, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
+exports.getTriggerMarketOrderParams = getTriggerMarketOrderParams;
+function getTriggerLimitOrderParams(marketIndex, direction, baseAssetAmount, price, triggerPrice, triggerCondition, reduceOnly, discountToken = false, referrer = false, userOrderId = 0) {
     return {
-        orderType: types_1.OrderType.STOP_LIMIT,
+        orderType: types_1.OrderType.TRIGGER_LIMIT,
         userOrderId,
         marketIndex,
         direction,
@@ -77,7 +77,7 @@ function getStopLimitOrderParams(marketIndex, direction, baseAssetAmount, price,
         oraclePriceOffset: numericConstants_1.ZERO,
     };
 }
-exports.getStopLimitOrderParams = getStopLimitOrderParams;
+exports.getTriggerLimitOrderParams = getTriggerLimitOrderParams;
 function getMarketOrderParams(marketIndex, direction, quoteAssetAmount, baseAssetAmount, reduceOnly, price = numericConstants_1.ZERO, discountToken = false, referrer = false) {
     if (baseAssetAmount.eq(numericConstants_1.ZERO) && quoteAssetAmount.eq(numericConstants_1.ZERO)) {
         throw Error('baseAssetAmount or quoteAssetAmount must be zero');

package/lib/orders.d.ts

@@ -1,5 +1,6 @@
+/// <reference types="bn.js" />
 import { Market, Order, UserAccount, UserPosition } from './types';
-import BN from 'bn.js';
+import { BN } from '.';
 export declare function calculateNewStateAfterOrder(userAccount: UserAccount, userPosition: UserPosition, market: Market, order: Order): [UserAccount, UserPosition, Market] | null;
 export declare function calculateAmountToTradeForLimit(market: Market, order: Order): BN;
-export declare function calculateAmountToTradeForStopLimit(market: Market, order: Order): BN;
+export declare function calculateAmountToTradeForTriggerLimit(market: Market, order: Order): BN;

package/lib/orders.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAmountToTradeForStopLimit = exports.calculateAmountToTradeForLimit = exports.calculateNewStateAfterOrder = void 0;
+exports.calculateAmountToTradeForTriggerLimit = exports.calculateAmountToTradeForLimit = exports.calculateNewStateAfterOrder = void 0;
 const types_1 = require("./types");
 const market_1 = require("./math/market");
 const numericConstants_1 = require("./constants/numericConstants");
@@ -83,15 +83,15 @@ function calculateAmountToTrade(market, order) {
     if (types_1.isVariant(order.orderType, 'limit')) {
         return calculateAmountToTradeForLimit(market, order);
     }
-    else if (types_1.isVariant(order.orderType, 'stopLimit')) {
-        return calculateAmountToTradeForStopLimit(market, order);
+    else if (types_1.isVariant(order.orderType, 'triggerLimit')) {
+        return calculateAmountToTradeForTriggerLimit(market, order);
     }
     else if (types_1.isVariant(order.orderType, 'market')) {
         // should never be a market order queued
         return numericConstants_1.ZERO;
     }
     else {
-        return calculateAmountToTradeForStop(market, order);
+        return calculateAmountToTradeForTriggerMarket(market, order);
     }
 }
 function calculateAmountToTradeForLimit(market, order) {
@@ -106,21 +106,21 @@ function calculateAmountToTradeForLimit(market, order) {
         : maxAmountToTrade;
 }
 exports.calculateAmountToTradeForLimit = calculateAmountToTradeForLimit;
-function calculateAmountToTradeForStopLimit(market, order) {
+function calculateAmountToTradeForTriggerLimit(market, order) {
     if (order.baseAssetAmountFilled.eq(numericConstants_1.ZERO)) {
-        const baseAssetAmount = calculateAmountToTradeForStop(market, order);
+        const baseAssetAmount = calculateAmountToTradeForTriggerMarket(market, order);
         if (baseAssetAmount.eq(numericConstants_1.ZERO)) {
             return numericConstants_1.ZERO;
         }
     }
     return calculateAmountToTradeForLimit(market, order);
 }
-exports.calculateAmountToTradeForStopLimit = calculateAmountToTradeForStopLimit;
+exports.calculateAmountToTradeForTriggerLimit = calculateAmountToTradeForTriggerLimit;
 function isSameDirection(firstDirection, secondDirection) {
     return ((types_1.isVariant(firstDirection, 'long') && types_1.isVariant(secondDirection, 'long')) ||
         (types_1.isVariant(firstDirection, 'short') && types_1.isVariant(secondDirection, 'short')));
 }
-function calculateAmountToTradeForStop(market, order) {
+function calculateAmountToTradeForTriggerMarket(market, order) {
     return isTriggerConditionSatisfied(market, order)
         ? order.baseAssetAmount
         : numericConstants_1.ZERO;

package/lib/types.d.ts

@@ -1,5 +1,6 @@
+/// <reference types="bn.js" />
 import { PublicKey, Transaction } from '@solana/web3.js';
-import BN from 'bn.js';
+import { BN } from '.';
 export declare class SwapDirection {
     static readonly ADD: {
         add: {};
@@ -28,11 +29,11 @@ export declare class OrderType {
     static readonly LIMIT: {
         limit: {};
     };
-    static readonly STOP: {
-        stop: {};
+    static readonly TRIGGER_MARKET: {
+        triggerMarket: {};
     };
-    static readonly STOP_LIMIT: {
-        stopLimit: {};
+    static readonly TRIGGER_LIMIT: {
+        triggerLimit: {};
     };
     static readonly MARKET: {
         market: {};
@@ -341,6 +342,7 @@ export declare type Order = {
     userOrderId: number;
     marketIndex: BN;
     price: BN;
+    userBaseAssetAmount: BN;
     baseAssetAmount: BN;
     baseAssetAmountFilled: BN;
     quoteAssetAmount: BN;
@@ -354,6 +356,7 @@ export declare type Order = {
     referrer: PublicKey;
     postOnly: boolean;
     immediateOrCancel: boolean;
+    oraclePriceOffset: BN;
 };
 export declare type OrderParams = {
     orderType: OrderType;

package/lib/types.js

@@ -21,8 +21,8 @@ class OrderType {
 }
 exports.OrderType = OrderType;
 OrderType.LIMIT = { limit: {} };
-OrderType.STOP = { stop: {} };
-OrderType.STOP_LIMIT = { stopLimit: {} };
+OrderType.TRIGGER_MARKET = { triggerMarket: {} };
+OrderType.TRIGGER_LIMIT = { triggerLimit: {} };
 OrderType.MARKET = { market: {} };
 class OrderStatus {
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "0.1.18-orders.2",
+	"version": "0.1.18-orders.6",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -10,6 +10,7 @@
 		"url": "git@github.com:drift-labs/protocol-v1.git"
 	},
 	"scripts": {
+		"lint": "eslint './**/*.{ts,tsx}' --quiet",
 		"build": "yarn clean && tsc",
 		"clean": "rm -rf lib",
 		"patch-and-pub": "npm version patch --force && npm publish"
@@ -34,6 +35,13 @@
 		"strict-event-emitter-types": "^2.0.0",
 		"uuid": "^8.3.2"
 	},
+	"devDependencies": {
+		"@typescript-eslint/eslint-plugin": "^4.28.0",
+		"@typescript-eslint/parser": "^4.28.0",
+		"eslint": "^7.29.0",
+		"eslint-config-prettier": "^8.3.0",
+		"eslint-plugin-prettier": "^3.4.0"
+	},
 	"description": "SDK for Drift Protocol v1",
 	"engines": {
 		"node": ">=12"

package/src/accounts/bulkAccountLoader.ts

@@ -1,16 +1,12 @@
 import { Commitment, Connection, PublicKey } from '@solana/web3.js';
 import { v4 as uuidv4 } from 'uuid';
+import { AccountData } from './types';
 
 type AccountToLoad = {
 	publicKey: PublicKey;
 	callbacks: Map<string, (buffer: Buffer) => void>;
 };
 
-type AccountData = {
-	slot: number;
-	buffer: Buffer | undefined;
-};
-
 const GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE = 99;
 
 export class BulkAccountLoader {
@@ -21,6 +17,9 @@ export class BulkAccountLoader {
 	accountData = new Map<string, AccountData>();
 	errorCallbacks = new Map<string, (e) => void>();
 	intervalId?: NodeJS.Timer;
+	// to handle clients spamming load
+	loadPromise?: Promise<void>;
+	loadPromiseResolver: () => void;
 
 	public constructor(
 		connection: Connection,
@@ -56,6 +55,9 @@ export class BulkAccountLoader {
 			this.startPolling();
 		}
 
+		// if a new account needs to be polled, remove the cached loadPromise in case client calls load immediately after
+		this.loadPromise = undefined;
+
 		return callbackId;
 	}
 
@@ -91,16 +93,34 @@ export class BulkAccountLoader {
 	}
 
 	public async load(): Promise<void> {
-		const chunks = this.chunks(
-			Array.from(this.accountsToLoad.values()),
-			GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE
-		);
-
-		await Promise.all(
-			chunks.map((chunk) => {
-				return this.loadChunk(chunk);
-			})
-		);
+		if (this.loadPromise) {
+			return this.loadPromise;
+		}
+		this.loadPromise = new Promise((resolver) => {
+			this.loadPromiseResolver = resolver;
+		});
+
+		try {
+			const chunks = this.chunks(
+				Array.from(this.accountsToLoad.values()),
+				GET_MULTIPLE_ACCOUNTS_CHUNK_SIZE
+			);
+
+			await Promise.all(
+				chunks.map((chunk) => {
+					return this.loadChunk(chunk);
+				})
+			);
+		} catch (e) {
+			console.error(`Error in bulkAccountLoader.load()`);
+			console.error(e);
+			for (const [_, callback] of this.errorCallbacks) {
+				callback(e);
+			}
+		}
+
+		this.loadPromiseResolver();
+		this.loadPromise = undefined;
 	}
 
 	async loadChunk(accountsToLoad: AccountToLoad[]): Promise<void> {

package/src/accounts/pollingUserAccountSubscriber.ts

@@ -89,11 +89,19 @@ export class PollingUserAccountSubscriber implements UserAccountSubscriber {
 			userPublicKey
 		);
 
-		this.accountsToPoll.set(userOrdersPublicKey.toString(), {
-			key: 'userOrders',
-			publicKey: userOrdersPublicKey,
-			eventType: 'userOrdersData',
-		});
+		const userOrdersExist =
+			(
+				await this.program.provider.connection.getParsedAccountInfo(
+					userOrdersPublicKey
+				)
+			).value !== null;
+		if (userOrdersExist) {
+			this.accountsToPoll.set(userOrdersPublicKey.toString(), {
+				key: 'userOrders',
+				publicKey: userOrdersPublicKey,
+				eventType: 'userOrdersData',
+			});
+		}
 
 		for (const [_, accountToPoll] of this.accountsToPoll) {
 			accountToPoll.callbackId = this.accountLoader.addAccount(

package/src/accounts/types.ts

@@ -127,3 +127,8 @@ export type AccountToPoll = {
 	eventType: string;
 	callbackId?: string;
 };
+
+export type AccountData = {
+	slot: number;
+	buffer: Buffer | undefined;
+};

package/src/accounts/webSocketAccountSubscriber.ts

@@ -1,13 +1,17 @@
-import { AccountSubscriber } from './types';
+import { AccountData, AccountSubscriber } from './types';
 import { Program } from '@project-serum/anchor';
-import { PublicKey } from '@solana/web3.js';
+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;
 	accountName: string;
 	program: Program;
 	accountPublicKey: PublicKey;
 	onChange: (data: T) => void;
+	listenerId?: number;
 
 	public constructor(
 		accountName: string,
@@ -20,32 +24,78 @@ export class WebSocketAccountSubscriber<T> implements AccountSubscriber<T> {
 	}
 
 	async subscribe(onChange: (data: T) => void): Promise<void> {
+		if (this.listenerId) {
+			return;
+		}
+
 		this.onChange = onChange;
 		await this.fetch();
 
-		this.program.account[this.accountName]
-			.subscribe(this.accountPublicKey, this.program.provider.opts.commitment)
-			.on('change', async (data: T) => {
-				this.data = data;
-				this.onChange(data);
-			});
+		this.listenerId = this.program.provider.connection.onAccountChange(
+			this.accountPublicKey,
+			(accountInfo, context) => {
+				this.handleRpcResponse(context, accountInfo);
+			},
+			this.program.provider.opts.commitment
+		);
 	}
 
 	async fetch(): Promise<void> {
-		const newData = (await this.program.account[this.accountName].fetch(
-			this.accountPublicKey
-		)) as T;
+		const rpcResponse =
+			await this.program.provider.connection.getAccountInfoAndContext(
+				this.accountPublicKey,
+				this.program.provider.opts.commitment
+			);
+		this.handleRpcResponse(rpcResponse.context, rpcResponse?.value);
+	}
+
+	handleRpcResponse(context: Context, accountInfo?: AccountInfo<Buffer>): void {
+		const newSlot = context.slot;
+		let newBuffer: Buffer | undefined = undefined;
+		if (accountInfo) {
+			newBuffer = accountInfo.data;
+		}
 
-		// if data has changed trigger update
-		if (JSON.stringify(newData) !== JSON.stringify(this.data)) {
-			this.data = newData;
+		if (!this.accountData) {
+			this.accountData = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			if (newBuffer) {
+				this.data = this.program.account[
+					this.accountName
+				].coder.accounts.decode(capitalize(this.accountName), newBuffer);
+				this.onChange(this.data);
+			}
+			return;
+		}
+
+		if (newSlot <= this.accountData.slot) {
+			return;
+		}
+
+		const oldBuffer = this.accountData.buffer;
+		if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+			this.accountData = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			this.data = this.program.account[this.accountName].coder.accounts.decode(
+				capitalize(this.accountName),
+				newBuffer
+			);
 			this.onChange(this.data);
 		}
 	}
 
 	unsubscribe(): Promise<void> {
-		return this.program.account[this.accountName].unsubscribe(
-			this.accountPublicKey
-		);
+		if (this.listenerId) {
+			const promise =
+				this.program.provider.connection.removeAccountChangeListener(
+					this.listenerId
+				);
+			this.listenerId = undefined;
+			return promise;
+		}
 	}
 }