@drift-labs/sdk 2.48.0-beta.2 → 2.48.0-beta.21

package/src/constants/spotMarkets.ts

@@ -150,6 +150,16 @@ export const MainnetSpotMarkets: SpotMarketConfig[] = [
 			'2sTMN9A1D1qeZLF95XQgJCUPiKe5DiV52jLfZGqMP46m'
 		),
 	},
+	{
+		symbol: 'bSOL',
+		marketIndex: 8,
+		oracle: new PublicKey('AFrYBhb5wKQtxRS9UA9YRS4V3dwFm7SqmS6DHKq6YVgo'),
+		oracleSource: OracleSource.PYTH,
+		mint: new PublicKey('bSo13r4TkiE4KumL71LsHTPpL2euBYLFx6h9HP3piy1'),
+		precision: new BN(10).pow(NINE),
+		precisionExp: NINE,
+		serumMarket: new PublicKey('ARjaHVxGCQfTvvKjLd7U7srvk6orthZSE6uqWchCczZc'),
+	},
 ];
 
 export const SpotMarkets: { [key in DriftEnv]: SpotMarketConfig[] } = {

package/src/dlob/orderBookLevels.ts

@@ -173,7 +173,7 @@ export function getVammL2Generator({
 		updatedAmm.orderStepSize
 	);
 
-	const minOrderSize = marketAccount.amm.orderStepSize;
+	const minOrderSize = marketAccount.amm.minOrderSize;
 	if (openBids.lt(minOrderSize.muln(2))) {
 		openBids = ZERO;
 	}

package/src/driftClient.ts

@@ -283,7 +283,8 @@ export class DriftClient {
 				config.spotMarketIndexes ?? [],
 				config.oracleInfos ?? [],
 				noMarketsAndOraclesSpecified,
-				config.accountSubscription?.resubTimeoutMs
+				config.accountSubscription?.resubTimeoutMs,
+				config.accountSubscription?.commitment
 			);
 		}
 		this.eventEmitter = this.accountSubscriber.eventEmitter;
@@ -2028,7 +2029,7 @@ export class DriftClient {
 		}
 
 		const tx = await this.buildTransaction(withdrawIxs, {
-			computeUnits: 600_000,
+			computeUnits: 1_400_000,
 		});
 		const { txSig, slot } = await this.sendTransaction(
 			tx,

package/src/events/eventSubscriber.ts

@@ -8,6 +8,7 @@ import {
 	EventMap,
 	LogProvider,
 	EventSubscriberEvents,
+	WebSocketLogProviderConfig,
 } from './types';
 import { TxEventCache } from './txEventCache';
 import { EventList } from './eventList';
@@ -56,7 +57,8 @@ export class EventSubscriber {
 			this.logProvider = new WebSocketLogProvider(
 				this.connection,
 				this.address,
-				this.options.commitment
+				this.options.commitment,
+				this.options.logProviderConfig.resubTimeoutMs
 			);
 		} else {
 			this.logProvider = new PollingLogProvider(
@@ -75,6 +77,48 @@ export class EventSubscriber {
 				return true;
 			}
 
+			if (this.options.logProviderConfig.type === 'websocket') {
+				if (this.options.logProviderConfig.resubTimeoutMs) {
+					if (
+						this.options.logProviderConfig.maxReconnectAttempts &&
+						this.options.logProviderConfig.maxReconnectAttempts > 0
+					) {
+						const logProviderConfig = this.options
+							.logProviderConfig as WebSocketLogProviderConfig;
+						this.logProvider.eventEmitter.on(
+							'reconnect',
+							(reconnectAttempts) => {
+								if (
+									reconnectAttempts > logProviderConfig.maxReconnectAttempts
+								) {
+									console.log('Failing over to polling');
+									this.logProvider.eventEmitter.removeAllListeners('reconnect');
+									this.unsubscribe().then(() => {
+										this.logProvider = new PollingLogProvider(
+											this.connection,
+											this.address,
+											this.options.commitment,
+											logProviderConfig.fallbackFrequency,
+											logProviderConfig.fallbackBatchSize
+										);
+										this.logProvider.subscribe(
+											(txSig, slot, logs, mostRecentBlockTime) => {
+												this.handleTxLogs(
+													txSig,
+													slot,
+													logs,
+													mostRecentBlockTime
+												);
+											},
+											true
+										);
+									});
+								}
+							}
+						);
+					}
+				}
+			}
 			this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
 				this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
 			}, true);
@@ -158,7 +202,7 @@ export class EventSubscriber {
 	}
 
 	public async unsubscribe(): Promise<boolean> {
-		return await this.logProvider.unsubscribe();
+		return await this.logProvider.unsubscribe(true);
 	}
 
 	private parseEventsFromLogs(

package/src/events/pollingLogProvider.ts

@@ -25,10 +25,10 @@ export class PollingLogProvider implements LogProvider {
 		this.finality = commitment === 'finalized' ? 'finalized' : 'confirmed';
 	}
 
-	public subscribe(
+	public async subscribe(
 		callback: logProviderCallback,
 		skipHistory?: boolean
-	): boolean {
+	): Promise<boolean> {
 		if (this.intervalId) {
 			return true;
 		}

package/src/events/types.ts

@@ -15,6 +15,7 @@ import {
 	CurveRecord,
 	SwapRecord,
 } from '../index';
+import { EventEmitter } from 'events';
 
 export type EventSubscriptionOptions = {
 	address?: PublicKey;
@@ -126,12 +127,20 @@ export type logProviderCallback = (
 
 export interface LogProvider {
 	isSubscribed(): boolean;
-	subscribe(callback: logProviderCallback, skipHistory?: boolean): boolean;
-	unsubscribe(): Promise<boolean>;
+	subscribe(
+		callback: logProviderCallback,
+		skipHistory?: boolean
+	): Promise<boolean>;
+	unsubscribe(external: boolean): Promise<boolean>;
+	eventEmitter?: EventEmitter;
 }
 
 export type WebSocketLogProviderConfig = {
 	type: 'websocket';
+	resubTimeoutMs?: number;
+	maxReconnectAttempts?: number;
+	fallbackFrequency?: number;
+	fallbackBatchSize?: number;
 };
 
 export type PollingLogProviderConfig = {

package/src/events/webSocketLogProvider.ts

@@ -1,38 +1,108 @@
 import { LogProvider, logProviderCallback } from './types';
 import { Commitment, Connection, PublicKey } from '@solana/web3.js';
+import { EventEmitter } from 'events';
 
 export class WebSocketLogProvider implements LogProvider {
 	private subscriptionId: number;
+	private isUnsubscribing = false;
+	private externalUnsubscribe = false;
+	private receivingData = false;
+	private timeoutId?: NodeJS.Timeout;
+	private reconnectAttempts = 0;
+	eventEmitter?: EventEmitter;
+	private callback?: logProviderCallback;
 	public constructor(
 		private connection: Connection,
 		private address: PublicKey,
-		private commitment: Commitment
-	) {}
+		private commitment: Commitment,
+		private resubTimeoutMs?: number
+	) {
+		if (this.resubTimeoutMs) {
+			this.eventEmitter = new EventEmitter();
+		}
+	}
 
-	public subscribe(callback: logProviderCallback): boolean {
+	public async subscribe(callback: logProviderCallback): Promise<boolean> {
 		if (this.subscriptionId) {
 			return true;
 		}
 
+		this.callback = callback;
+		try {
+			this.setSubscription(callback);
+		} catch (error) {
+			// Sometimes ws connection isn't ready, give it a few secs
+			setTimeout(() => this.setSubscription(callback), 2000);
+		}
+
+		if (this.resubTimeoutMs) {
+			this.setTimeout();
+		}
+
+		return true;
+	}
+
+	public setSubscription(callback: logProviderCallback): void {
 		this.subscriptionId = this.connection.onLogs(
 			this.address,
 			(logs, ctx) => {
+				if (this.resubTimeoutMs && !this.isUnsubscribing) {
+					this.receivingData = true;
+					clearTimeout(this.timeoutId);
+					this.setTimeout();
+				}
 				callback(logs.signature, ctx.slot, logs.logs, undefined);
 			},
 			this.commitment
 		);
-		return true;
 	}
 
 	public isSubscribed(): boolean {
 		return this.subscriptionId !== undefined;
 	}
 
-	public async unsubscribe(): Promise<boolean> {
+	public async unsubscribe(external = false): Promise<boolean> {
+		this.isUnsubscribing = true;
+		this.externalUnsubscribe = external;
+		clearTimeout(this.timeoutId);
+		this.timeoutId = undefined;
+
 		if (this.subscriptionId !== undefined) {
-			await this.connection.removeOnLogsListener(this.subscriptionId);
-			this.subscriptionId = undefined;
+			try {
+				await this.connection.removeOnLogsListener(this.subscriptionId);
+				this.subscriptionId = undefined;
+				this.isUnsubscribing = false;
+				return true;
+			} catch (err) {
+				console.log('Error unsubscribing from logs: ', err);
+				this.isUnsubscribing = false;
+				return false;
+			}
+		} else {
+			this.isUnsubscribing = false;
+			return true;
 		}
-		return true;
+	}
+
+	private setTimeout(): void {
+		this.timeoutId = setTimeout(async () => {
+			if (this.isUnsubscribing || this.externalUnsubscribe) {
+				// If we are in the process of unsubscribing, do not attempt to resubscribe
+				return;
+			}
+
+			if (this.receivingData) {
+				console.log(
+					`No log data in ${this.resubTimeoutMs}ms, resubscribing on attempt ${
+						this.reconnectAttempts + 1
+					}`
+				);
+				await this.unsubscribe();
+				this.receivingData = false;
+				this.reconnectAttempts++;
+				this.eventEmitter.emit('reconnect', this.reconnectAttempts);
+				this.subscribe(this.callback);
+			}
+		}, this.resubTimeoutMs);
 	}
 }

package/src/orderSubscriber/OrderSubscriber.ts

@@ -1,7 +1,7 @@
 import { DriftClient } from '../driftClient';
 import { UserAccount } from '../types';
 import { getUserFilter, getUserWithOrderFilter } from '../memcmp';
-import { PublicKey, RpcResponseAndContext } from '@solana/web3.js';
+import { Commitment, PublicKey, RpcResponseAndContext } from '@solana/web3.js';
 import { Buffer } from 'buffer';
 import { DLOB } from '../dlob/DLOB';
 import { OrderSubscriberConfig, OrderSubscriberEvents } from './types';
@@ -14,13 +14,17 @@ export class OrderSubscriber {
 	driftClient: DriftClient;
 	usersAccounts = new Map<string, { slot: number; userAccount: UserAccount }>();
 	subscription: PollingSubscription | WebsocketSubscription;
+	commitment: Commitment;
 	eventEmitter: StrictEventEmitter<EventEmitter, OrderSubscriberEvents>;
 
 	fetchPromise?: Promise<void>;
 	fetchPromiseResolver: () => void;
 
+	mostRecentSlot: number;
+
 	constructor(config: OrderSubscriberConfig) {
 		this.driftClient = config.driftClient;
+		this.commitment = config.subscriptionConfig.commitment || 'processed';
 		if (config.subscriptionConfig.type === 'polling') {
 			this.subscription = new PollingSubscription({
 				orderSubscriber: this,
@@ -29,6 +33,7 @@ export class OrderSubscriber {
 		} else {
 			this.subscription = new WebsocketSubscription({
 				orderSubscriber: this,
+				commitment: this.commitment,
 				skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
 				resubTimeoutMs: config.subscriptionConfig.resubTimeoutMs,
 			});
@@ -53,7 +58,7 @@ export class OrderSubscriber {
 			const rpcRequestArgs = [
 				this.driftClient.program.programId.toBase58(),
 				{
-					commitment: this.driftClient.opts.commitment,
+					commitment: this.commitment,
 					filters: [getUserFilter(), getUserWithOrderFilter()],
 					encoding: 'base64',
 					withContext: true,
@@ -81,18 +86,13 @@ export class OrderSubscriber {
 			const programAccountSet = new Set<string>();
 			for (const programAccount of rpcResponseAndContext.value) {
 				const key = programAccount.pubkey.toString();
-				// @ts-ignore
-				const buffer = Buffer.from(
-					programAccount.account.data[0],
-					programAccount.account.data[1]
-				);
 				programAccountSet.add(key);
-				const userAccount =
-					this.driftClient.program.account.user.coder.accounts.decode(
-						'User',
-						buffer
-					) as UserAccount;
-				this.tryUpdateUserAccount(key, userAccount, slot);
+				this.tryUpdateUserAccount(
+					key,
+					'raw',
+					programAccount.account.data,
+					slot
+				);
 			}
 
 			for (const key of this.usersAccounts.keys()) {
@@ -110,11 +110,31 @@ export class OrderSubscriber {
 
 	tryUpdateUserAccount(
 		key: string,
-		userAccount: UserAccount,
+		dataType: 'raw' | 'decoded',
+		data: string[] | UserAccount,
 		slot: number
 	): void {
+		if (!this.mostRecentSlot || slot > this.mostRecentSlot) {
+			this.mostRecentSlot = slot;
+		}
+
 		const slotAndUserAccount = this.usersAccounts.get(key);
-		if (!slotAndUserAccount || slotAndUserAccount.slot < slot) {
+		if (!slotAndUserAccount || slotAndUserAccount.slot <= slot) {
+			let userAccount: UserAccount;
+			// Polling leads to a lot of redundant decoding, so we only decode if data is from a fresh slot
+			if (dataType === 'raw') {
+				// @ts-ignore
+				const buffer = Buffer.from(data[0], data[1]);
+
+				userAccount =
+					this.driftClient.program.account.user.coder.accounts.decodeUnchecked(
+						'User',
+						buffer
+					) as UserAccount;
+			} else {
+				userAccount = data as UserAccount;
+			}
+
 			const newOrders = userAccount.orders.filter(
 				(order) =>
 					order.slot.toNumber() > (slotAndUserAccount?.slot ?? 0) &&
@@ -148,6 +168,10 @@ export class OrderSubscriber {
 		return dlob;
 	}
 
+	public getSlot(): number {
+		return this.mostRecentSlot ?? 0;
+	}
+
 	public async unsubscribe(): Promise<void> {
 		await this.subscription.unsubscribe();
 	}

package/src/orderSubscriber/WebsocketSubscription.ts

@@ -2,10 +2,11 @@ import { OrderSubscriber } from './OrderSubscriber';
 import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
 import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
 import { UserAccount } from '../types';
-import { Context, PublicKey } from '@solana/web3.js';
+import { Commitment, Context, PublicKey } from '@solana/web3.js';
 
 export class WebsocketSubscription {
 	private orderSubscriber: OrderSubscriber;
+	private commitment: Commitment;
 	private skipInitialLoad: boolean;
 	private resubTimeoutMs?: number;
 
@@ -13,14 +14,17 @@ export class WebsocketSubscription {
 
 	constructor({
 		orderSubscriber,
+		commitment,
 		skipInitialLoad = false,
 		resubTimeoutMs,
 	}: {
 		orderSubscriber: OrderSubscriber;
+		commitment: Commitment;
 		skipInitialLoad?: boolean;
 		resubTimeoutMs?: number;
 	}) {
 		this.orderSubscriber = orderSubscriber;
+		this.commitment = commitment;
 		this.skipInitialLoad = skipInitialLoad;
 		this.resubTimeoutMs = resubTimeoutMs;
 	}
@@ -36,7 +40,7 @@ export class WebsocketSubscription {
 				),
 				{
 					filters: [getUserFilter(), getNonIdleUserFilter()],
-					commitment: this.orderSubscriber.driftClient.opts.commitment,
+					commitment: this.commitment,
 				},
 				this.resubTimeoutMs
 			);
@@ -47,6 +51,7 @@ export class WebsocketSubscription {
 				const userKey = accountId.toBase58();
 				this.orderSubscriber.tryUpdateUserAccount(
 					userKey,
+					'decoded',
 					account,
 					context.slot
 				);

package/src/orderSubscriber/types.ts

@@ -1,4 +1,4 @@
-import { PublicKey } from '@solana/web3.js';
+import { Commitment, PublicKey } from '@solana/web3.js';
 import { Order, UserAccount } from '../types';
 import { DriftClient } from '../driftClient';
 
@@ -8,11 +8,13 @@ export type OrderSubscriberConfig = {
 		| {
 				type: 'polling';
 				frequency: number;
+				commitment?: Commitment;
 		  }
 		| {
 				type: 'websocket';
 				skipInitialLoad?: boolean;
 				resubTimeoutMs?: number;
+				commitment?: Commitment;
 		  };
 };
 

package/src/slot/SlotSubscriber.ts

@@ -29,8 +29,10 @@ export class SlotSubscriber {
 		this.currentSlot = await this.connection.getSlot('confirmed');
 
 		this.subscriptionId = this.connection.onSlotChange((slotInfo) => {
-			this.currentSlot = slotInfo.slot;
-			this.eventEmitter.emit('newSlot', slotInfo.slot);
+			if (!this.currentSlot || this.currentSlot < slotInfo.slot) {
+				this.currentSlot = slotInfo.slot;
+				this.eventEmitter.emit('newSlot', slotInfo.slot);
+			}
 		});
 	}
 

package/src/user.ts

@@ -109,12 +109,12 @@ export class User {
 			);
 		} else if (config.accountSubscription?.type === 'custom') {
 			this.accountSubscriber = config.accountSubscription.userAccountSubscriber;
-		} else if (config.accountSubscription?.type === 'websocket') {
+		} else {
 			this.accountSubscriber = new WebSocketUserAccountSubscriber(
 				config.driftClient.program,
 				config.userAccountPublicKey,
-				config.accountSubscription.resubTimeoutMs,
-				config.accountSubscription.commitment
+				config.accountSubscription?.resubTimeoutMs,
+				config.accountSubscription?.commitment
 			);
 		}
 		this.eventEmitter = this.accountSubscriber.eventEmitter;