@drift-labs/sdk 2.40.0-beta.1 → 2.40.0-beta.10

package/src/accounts/webSocketDriftClientAccountSubscriber.ts

@@ -31,6 +31,7 @@ export class WebSocketDriftClientAccountSubscriber
 	oracleInfos: OracleInfo[];
 	oracleClientCache = new OracleClientCache();
 
+	resubTimeoutMs?: number;
 	shouldFindAllMarketsAndOracles: boolean;
 
 	eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
@@ -54,7 +55,8 @@ export class WebSocketDriftClientAccountSubscriber
 		perpMarketIndexes: number[],
 		spotMarketIndexes: number[],
 		oracleInfos: OracleInfo[],
-		shouldFindAllMarketsAndOracles: boolean
+		shouldFindAllMarketsAndOracles: boolean,
+		resubTimeoutMs?: number
 	) {
 		this.isSubscribed = false;
 		this.program = program;
@@ -63,6 +65,7 @@ export class WebSocketDriftClientAccountSubscriber
 		this.spotMarketIndexes = spotMarketIndexes;
 		this.oracleInfos = oracleInfos;
 		this.shouldFindAllMarketsAndOracles = shouldFindAllMarketsAndOracles;
+		this.resubTimeoutMs = resubTimeoutMs;
 	}
 
 	public async subscribe(): Promise<boolean> {
@@ -96,7 +99,9 @@ export class WebSocketDriftClientAccountSubscriber
 		this.stateAccountSubscriber = new WebSocketAccountSubscriber(
 			'state',
 			this.program,
-			statePublicKey
+			statePublicKey,
+			undefined,
+			this.resubTimeoutMs
 		);
 		await this.stateAccountSubscriber.subscribe((data: StateAccount) => {
 			this.eventEmitter.emit('stateAccountUpdate', data);
@@ -136,7 +141,9 @@ export class WebSocketDriftClientAccountSubscriber
 		const accountSubscriber = new WebSocketAccountSubscriber<PerpMarketAccount>(
 			'perpMarket',
 			this.program,
-			perpMarketPublicKey
+			perpMarketPublicKey,
+			undefined,
+			this.resubTimeoutMs
 		);
 		await accountSubscriber.subscribe((data: PerpMarketAccount) => {
 			this.eventEmitter.emit('perpMarketAccountUpdate', data);
@@ -161,7 +168,9 @@ export class WebSocketDriftClientAccountSubscriber
 		const accountSubscriber = new WebSocketAccountSubscriber<SpotMarketAccount>(
 			'spotMarket',
 			this.program,
-			marketPublicKey
+			marketPublicKey,
+			undefined,
+			this.resubTimeoutMs
 		);
 		await accountSubscriber.subscribe((data: SpotMarketAccount) => {
 			this.eventEmitter.emit('spotMarketAccountUpdate', data);
@@ -192,7 +201,8 @@ export class WebSocketDriftClientAccountSubscriber
 			oracleInfo.publicKey,
 			(buffer: Buffer) => {
 				return client.getOraclePriceDataFromBuffer(buffer);
-			}
+			},
+			this.resubTimeoutMs
 		);
 
 		await accountSubscriber.subscribe((data: OraclePriceData) => {

package/src/accounts/webSocketProgramAccountSubscriber.ts

@@ -0,0 +1,152 @@
+import { DataAndSlot, BufferAndSlot, ProgramAccountSubscriber } from './types';
+import { AnchorProvider, Program } from '@coral-xyz/anchor';
+import {
+	Commitment,
+	Context,
+	KeyedAccountInfo,
+	MemcmpFilter,
+	PublicKey,
+} from '@solana/web3.js';
+import * as Buffer from 'buffer';
+
+export class WebSocketProgramAccountSubscriber<T>
+	implements ProgramAccountSubscriber<T>
+{
+	subscriptionName: string;
+	accountDiscriminator: string;
+	dataAndSlot?: DataAndSlot<T> & { accountId: PublicKey };
+	bufferAndSlot?: BufferAndSlot;
+	program: Program;
+	decodeBuffer: (accountName: string, ix: Buffer) => T;
+	onChange: (accountId: PublicKey, data: T, context: Context) => void;
+	listenerId?: number;
+	resubTimeoutMs?: number;
+	timeoutId?: NodeJS.Timeout;
+	options: { filters: MemcmpFilter[]; commitment?: Commitment };
+
+	receivingData = false;
+
+	public constructor(
+		subscriptionName: string,
+		accountDiscriminator: string,
+		program: Program,
+		decodeBufferFn: (accountName: string, ix: Buffer) => T,
+		options: { filters: MemcmpFilter[]; commitment?: Commitment } = {
+			filters: [],
+		},
+		resubTimeoutMs?: number
+	) {
+		this.subscriptionName = subscriptionName;
+		this.accountDiscriminator = accountDiscriminator;
+		this.program = program;
+		this.decodeBuffer = decodeBufferFn;
+		this.resubTimeoutMs = resubTimeoutMs;
+		this.options = options;
+		this.receivingData = false;
+	}
+
+	async subscribe(
+		onChange: (accountId: PublicKey, data: T, context: Context) => void
+	): Promise<void> {
+		if (this.listenerId) {
+			return;
+		}
+
+		this.onChange = onChange;
+
+		this.listenerId = this.program.provider.connection.onProgramAccountChange(
+			this.program.programId,
+			(keyedAccountInfo, context) => {
+				if (this.resubTimeoutMs) {
+					this.receivingData = true;
+					clearTimeout(this.timeoutId);
+					this.handleRpcResponse(context, keyedAccountInfo);
+					this.setTimeout();
+				} else {
+					this.handleRpcResponse(context, keyedAccountInfo);
+				}
+			},
+			this.options.commitment ??
+				(this.program.provider as AnchorProvider).opts.commitment,
+			this.options.filters
+		);
+
+		if (this.resubTimeoutMs) {
+			this.setTimeout();
+		}
+	}
+
+	private setTimeout(): void {
+		if (!this.onChange) {
+			throw new Error('onChange callback function must be set');
+		}
+		this.timeoutId = setTimeout(async () => {
+			if (this.receivingData) {
+				console.log(
+					`No ws data from ${this.subscriptionName} in ${this.resubTimeoutMs}ms, resubscribing`
+				);
+				await this.unsubscribe();
+				this.receivingData = false;
+				await this.subscribe(this.onChange);
+			}
+		}, this.resubTimeoutMs);
+	}
+
+	handleRpcResponse(
+		context: Context,
+		keyedAccountInfo: KeyedAccountInfo
+	): void {
+		const newSlot = context.slot;
+		let newBuffer: Buffer | undefined = undefined;
+		if (keyedAccountInfo) {
+			newBuffer = keyedAccountInfo.accountInfo.data;
+		}
+
+		if (!this.bufferAndSlot) {
+			this.bufferAndSlot = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			if (newBuffer) {
+				const account = this.decodeBuffer(this.accountDiscriminator, newBuffer);
+				this.dataAndSlot = {
+					data: account,
+					slot: newSlot,
+					accountId: keyedAccountInfo.accountId,
+				};
+				this.onChange(keyedAccountInfo.accountId, account, context);
+			}
+			return;
+		}
+
+		if (newSlot <= this.bufferAndSlot.slot) {
+			return;
+		}
+
+		const oldBuffer = this.bufferAndSlot.buffer;
+		if (newBuffer && (!oldBuffer || !newBuffer.equals(oldBuffer))) {
+			this.bufferAndSlot = {
+				buffer: newBuffer,
+				slot: newSlot,
+			};
+			const account = this.decodeBuffer(this.accountDiscriminator, newBuffer);
+			this.dataAndSlot = {
+				data: account,
+				slot: newSlot,
+				accountId: keyedAccountInfo.accountId,
+			};
+			this.onChange(keyedAccountInfo.accountId, account, context);
+		}
+	}
+
+	unsubscribe(): Promise<void> {
+		if (this.listenerId) {
+			const promise =
+				this.program.provider.connection.removeAccountChangeListener(
+					this.listenerId
+				);
+			this.listenerId = undefined;
+			return promise;
+		}
+	}
+}

package/src/accounts/webSocketUserAccountSubscriber.ts

@@ -14,17 +14,23 @@ import { UserAccount } from '../types';
 
 export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 	isSubscribed: boolean;
+	reconnectTimeoutMs?: number;
 	program: Program;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserAccountEvents>;
 	userAccountPublicKey: PublicKey;
 
 	userDataAccountSubscriber: AccountSubscriber<UserAccount>;
 
-	public constructor(program: Program, userAccountPublicKey: PublicKey) {
+	public constructor(
+		program: Program,
+		userAccountPublicKey: PublicKey,
+		reconnectTimeoutMs?: number
+	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.userAccountPublicKey = userAccountPublicKey;
 		this.eventEmitter = new EventEmitter();
+		this.reconnectTimeoutMs = reconnectTimeoutMs;
 	}
 
 	async subscribe(userAccount?: UserAccount): Promise<boolean> {
@@ -35,7 +41,9 @@ export class WebSocketUserAccountSubscriber implements UserAccountSubscriber {
 		this.userDataAccountSubscriber = new WebSocketAccountSubscriber(
 			'user',
 			this.program,
-			this.userAccountPublicKey
+			this.userAccountPublicKey,
+			undefined,
+			this.reconnectTimeoutMs
 		);
 
 		if (userAccount) {

package/src/accounts/webSocketUserStatsAccountSubsriber.ts

@@ -16,17 +16,23 @@ export class WebSocketUserStatsAccountSubscriber
 	implements UserStatsAccountSubscriber
 {
 	isSubscribed: boolean;
+	reconnectTimeoutMs?: number;
 	program: Program;
 	eventEmitter: StrictEventEmitter<EventEmitter, UserStatsAccountEvents>;
 	userStatsAccountPublicKey: PublicKey;
 
 	userStatsAccountSubscriber: AccountSubscriber<UserStatsAccount>;
 
-	public constructor(program: Program, userStatsAccountPublicKey: PublicKey) {
+	public constructor(
+		program: Program,
+		userStatsAccountPublicKey: PublicKey,
+		reconnectTimeoutMs?: number
+	) {
 		this.isSubscribed = false;
 		this.program = program;
 		this.userStatsAccountPublicKey = userStatsAccountPublicKey;
 		this.eventEmitter = new EventEmitter();
+		this.reconnectTimeoutMs = reconnectTimeoutMs;
 	}
 
 	async subscribe(userStatsAccount?: UserStatsAccount): Promise<boolean> {
@@ -37,7 +43,9 @@ export class WebSocketUserStatsAccountSubscriber
 		this.userStatsAccountSubscriber = new WebSocketAccountSubscriber(
 			'userStats',
 			this.program,
-			this.userStatsAccountPublicKey
+			this.userStatsAccountPublicKey,
+			undefined,
+			this.reconnectTimeoutMs
 		);
 
 		if (userStatsAccount) {

package/src/auctionSubscriber/auctionSubscriber.ts

@@ -4,48 +4,57 @@ import { getUserFilter, getUserWithAuctionFilter } from '../memcmp';
 import StrictEventEmitter from 'strict-event-emitter-types';
 import { EventEmitter } from 'events';
 import { UserAccount } from '../types';
-import { ConfirmOptions } from '@solana/web3.js';
+import { ConfirmOptions, Context, PublicKey } from '@solana/web3.js';
+import { WebSocketProgramAccountSubscriber } from '../accounts/webSocketProgramAccountSubscriber';
 
 export class AuctionSubscriber {
 	private driftClient: DriftClient;
 	private opts: ConfirmOptions;
+	private resubTimeoutMs?: number;
 
 	eventEmitter: StrictEventEmitter<EventEmitter, AuctionSubscriberEvents>;
+	private subscriber: WebSocketProgramAccountSubscriber<UserAccount>;
 
-	private websocketId: number;
-
-	constructor({ driftClient, opts }: AuctionSubscriberConfig) {
+	constructor({ driftClient, opts, resubTimeoutMs }: AuctionSubscriberConfig) {
 		this.driftClient = driftClient;
 		this.opts = opts || this.driftClient.opts;
 		this.eventEmitter = new EventEmitter();
+		this.resubTimeoutMs = resubTimeoutMs;
 	}
 
 	public async subscribe() {
-		this.websocketId = this.driftClient.connection.onProgramAccountChange(
-			this.driftClient.program.programId,
-			(keyAccountInfo, context) => {
-				const userAccount =
-					this.driftClient.program.account.user.coder.accounts.decode(
-						'User',
-						keyAccountInfo.accountInfo.data
-					) as UserAccount;
+		if (!this.subscriber) {
+			this.subscriber = new WebSocketProgramAccountSubscriber<UserAccount>(
+				'AuctionSubscriber',
+				'User',
+				this.driftClient.program,
+				this.driftClient.program.account.user.coder.accounts.decode.bind(
+					this.driftClient.program.account.user.coder.accounts
+				),
+				{
+					filters: [getUserFilter(), getUserWithAuctionFilter()],
+					commitment: this.driftClient.opts.commitment,
+				},
+				this.resubTimeoutMs
+			);
+		}
+
+		await this.subscriber.subscribe(
+			(accountId: PublicKey, data: UserAccount, context: Context) => {
 				this.eventEmitter.emit(
 					'onAccountUpdate',
-					userAccount,
-					keyAccountInfo.accountId,
+					data,
+					accountId,
 					context.slot
 				);
-			},
-			this.driftClient.opts.commitment,
-			[getUserFilter(), getUserWithAuctionFilter()]
+			}
 		);
 	}
 
 	public async unsubscribe() {
-		if (this.websocketId) {
-			await this.driftClient.connection.removeProgramAccountChangeListener(
-				this.websocketId
-			);
+		if (!this.subscriber) {
+			return;
 		}
+		this.subscriber.unsubscribe();
 	}
 }

package/src/auctionSubscriber/types.ts

@@ -5,6 +5,7 @@ import { ConfirmOptions, PublicKey } from '@solana/web3.js';
 export type AuctionSubscriberConfig = {
 	driftClient: DriftClient;
 	opts?: ConfirmOptions;
+	resubTimeoutMs?: number;
 };
 
 export interface AuctionSubscriberEvents {

package/src/driftClient.ts

@@ -278,7 +278,8 @@ export class DriftClient {
 				config.perpMarketIndexes ?? [],
 				config.spotMarketIndexes ?? [],
 				config.oracleInfos ?? [],
-				noMarketsAndOraclesSpecified
+				noMarketsAndOraclesSpecified,
+				config.accountSubscription?.resubTimeoutMs
 			);
 		}
 		this.eventEmitter = this.accountSubscriber.eventEmitter;
@@ -3424,6 +3425,7 @@ export class DriftClient {
 		reduceOnly,
 		txParams,
 		v6,
+		onlyDirectRoutes = false,
 	}: {
 		jupiterClient: JupiterClient;
 		outMarketIndex: number;
@@ -3436,6 +3438,7 @@ export class DriftClient {
 		route?: Route;
 		reduceOnly?: SwapReduceOnly;
 		txParams?: TxParams;
+		onlyDirectRoutes?: boolean;
 		v6?: {
 			quote?: QuoteResponse;
 		};
@@ -3455,6 +3458,7 @@ export class DriftClient {
 				swapMode,
 				quote: v6.quote,
 				reduceOnly,
+				onlyDirectRoutes,
 			});
 			ixs = res.ixs;
 			lookupTables = res.lookupTables;

package/src/driftClientConfig.ts

@@ -36,6 +36,7 @@ export type DriftClientConfig = {
 export type DriftClientSubscriptionConfig =
 	| {
 			type: 'websocket';
+			resubTimeoutMs?: number;
 	  }
 	| {
 			type: 'polling';

package/src/idl/drift.json

@@ -6314,6 +6314,24 @@
         ]
       }
     },
+    {
+      "name": "MarketIdentifier",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "marketType",
+            "type": {
+              "defined": "MarketType"
+            }
+          },
+          {
+            "name": "marketIndex",
+            "type": "u16"
+          }
+        ]
+      }
+    },
     {
       "name": "HistoricalOracleData",
       "type": {
@@ -8198,6 +8216,34 @@
         ]
       }
     },
+    {
+      "name": "MarginCalculationMode",
+      "type": {
+        "kind": "enum",
+        "variants": [
+          {
+            "name": "Standard"
+          },
+          {
+            "name": "Liquidation",
+            "fields": [
+              {
+                "name": "margin_buffer",
+                "type": "u128"
+              },
+              {
+                "name": "market_to_track_margin_requirement",
+                "type": {
+                  "option": {
+                    "defined": "MarketIdentifier"
+                  }
+                }
+              }
+            ]
+          }
+        ]
+      }
+    },
     {
       "name": "OracleSource",
       "type": {
@@ -10781,6 +10827,11 @@
       "code": 6254,
       "name": "UserReduceOnly",
       "msg": "UserReduceOnly"
+    },
+    {
+      "code": 6255,
+      "name": "InvalidMarginCalculation",
+      "msg": "InvalidMarginCalculation"
     }
   ]
 }

package/src/jupiter/jupiterClient.ts

@@ -275,6 +275,7 @@ export class JupiterClient {
 		inputMint,
 		outputMint,
 		amount,
+		maxAccounts = 52, // 52 is an estimated amount with buffer
 		slippageBps = 50,
 		swapMode = 'ExactIn',
 		onlyDirectRoutes = false,
@@ -282,6 +283,7 @@ export class JupiterClient {
 		inputMint: PublicKey;
 		outputMint: PublicKey;
 		amount: BN;
+		maxAccounts?: number;
 		slippageBps?: number;
 		swapMode?: SwapMode;
 		onlyDirectRoutes?: boolean;
@@ -293,6 +295,7 @@ export class JupiterClient {
 			slippageBps: slippageBps.toString(),
 			swapMode,
 			onlyDirectRoutes: onlyDirectRoutes.toString(),
+			maxAccounts: maxAccounts.toString(),
 		}).toString();
 		const quote = await (await fetch(`${this.url}/v6/quote?${params}`)).json();
 		return quote;

package/src/math/amm.ts

@@ -471,12 +471,19 @@ export function calculateVolSpreadBN(
 		clampMax
 	);
 
+	// only consider confidence interval at full value when above 25 bps
+	let confComponent = lastOracleConfPct;
+
+	if (lastOracleConfPct.lte(PRICE_PRECISION.div(new BN(400)))) {
+		confComponent = lastOracleConfPct.div(new BN(10));
+	}
+
 	const longVolSpread = BN.max(
-		lastOracleConfPct,
+		confComponent,
 		volSpread.mul(longVolSpreadFactor).div(PERCENTAGE_PRECISION)
 	);
 	const shortVolSpread = BN.max(
-		lastOracleConfPct,
+		confComponent,
 		volSpread.mul(shortVolSpreadFactor).div(PERCENTAGE_PRECISION)
 	);