@drift-labs/sdk 2.31.0-beta.2 → 2.31.0-beta.5

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.31.0-beta.2",
+  "version": "2.31.0-beta.5",
   "name": "drift",
   "instructions": [
     {
@@ -1305,6 +1305,32 @@
       ],
       "args": []
     },
+    {
+      "name": "updateUserOpenOrdersCount",
+      "accounts": [
+        {
+          "name": "state",
+          "isMut": false,
+          "isSigner": false
+        },
+        {
+          "name": "authority",
+          "isMut": false,
+          "isSigner": true
+        },
+        {
+          "name": "filler",
+          "isMut": true,
+          "isSigner": false
+        },
+        {
+          "name": "user",
+          "isMut": true,
+          "isSigner": false
+        }
+      ],
+      "args": []
+    },
     {
       "name": "settlePnl",
       "accounts": [
@@ -5438,12 +5464,40 @@
             ],
             "type": "bool"
           },
+          {
+            "name": "openOrders",
+            "docs": [
+              "number of open orders"
+            ],
+            "type": "u8"
+          },
+          {
+            "name": "hasOpenOrder",
+            "docs": [
+              "Whether or not user has open order"
+            ],
+            "type": "bool"
+          },
+          {
+            "name": "openAuctions",
+            "docs": [
+              "number of open orders with auction"
+            ],
+            "type": "u8"
+          },
+          {
+            "name": "hasOpenAuction",
+            "docs": [
+              "Whether or not user has open order with auction"
+            ],
+            "type": "bool"
+          },
           {
             "name": "padding",
             "type": {
               "array": [
                 "u8",
-                25
+                21
               ]
             }
           }
@@ -10433,6 +10487,11 @@
       "code": 6250,
       "name": "SpotMarketReduceOnly",
       "msg": "SpotMarketReduceOnly"
+    },
+    {
+      "code": 6251,
+      "name": "FundingWasNotUpdated",
+      "msg": "FundingWasNotUpdated"
     }
   ]
 }

package/src/index.ts

@@ -76,5 +76,6 @@ export * from './dlob/orderBookLevels';
 export * from './userMap/userMap';
 export * from './userMap/userStatsMap';
 export * from './math/bankruptcy';
+export * from './orderSubscriber';
 
 export { BN, PublicKey, pyth };

package/src/math/spotBalance.ts

@@ -282,9 +282,7 @@ export function calculateInterestRate(bank: SpotMarketAccount): BN {
 	} else {
 		const borrowRateSlope = new BN(bank.optimalBorrowRate)
 			.mul(SPOT_MARKET_UTILIZATION_PRECISION)
-			.div(
-				SPOT_MARKET_UTILIZATION_PRECISION.sub(new BN(bank.optimalUtilization))
-			);
+			.div(new BN(bank.optimalUtilization));
 
 		interestRate = utilization
 			.mul(borrowRateSlope)

package/src/memcmp.ts

@@ -0,0 +1,48 @@
+import { MemcmpFilter } from '@solana/web3.js';
+import bs58 from 'bs58';
+import { BorshAccountsCoder } from '@coral-xyz/anchor';
+
+export function getUserFilter(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 0,
+			bytes: bs58.encode(BorshAccountsCoder.accountDiscriminator('User')),
+		},
+	};
+}
+
+export function getNonIdleUserFilter(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 4350,
+			bytes: bs58.encode(Uint8Array.from([0])),
+		},
+	};
+}
+
+export function getUserWithOrderFilter(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 4352,
+			bytes: bs58.encode(Uint8Array.from([1])),
+		},
+	};
+}
+
+export function getUserWithAuctionFilter(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 4354,
+			bytes: bs58.encode(Uint8Array.from([1])),
+		},
+	};
+}
+
+export function getUserThatHasBeenLP(): MemcmpFilter {
+	return {
+		memcmp: {
+			offset: 4267,
+			bytes: bs58.encode(Uint8Array.from([99])),
+		},
+	};
+}

package/src/orderSubscriber/OrderSubscriber.ts

@@ -0,0 +1,132 @@
+import { DriftClient } from '../driftClient';
+import { UserAccount } from '../types';
+import { getUserFilter, getUserWithOrderFilter } from '../memcmp';
+import { PublicKey, RpcResponseAndContext } from '@solana/web3.js';
+import { Buffer } from 'buffer';
+import { DLOB } from '../dlob/DLOB';
+import { OrderSubscriberConfig } from './types';
+import { PollingSubscription } from './PollingSubscription';
+import { WebsocketSubscription } from './WebsocketSubscription';
+
+export class OrderSubscriber {
+	driftClient: DriftClient;
+	usersAccounts = new Map<string, { slot: number; userAccount: UserAccount }>();
+	subscription: PollingSubscription | WebsocketSubscription;
+
+	fetchPromise?: Promise<void>;
+	fetchPromiseResolver: () => void;
+
+	constructor(config: OrderSubscriberConfig) {
+		this.driftClient = config.driftClient;
+		if (config.subscriptionConfig.type === 'polling') {
+			this.subscription = new PollingSubscription({
+				orderSubscriber: this,
+				frequency: config.subscriptionConfig.frequency,
+			});
+		} else {
+			this.subscription = new WebsocketSubscription({
+				orderSubscriber: this,
+				skipInitialLoad: config.subscriptionConfig.skipInitialLoad,
+			});
+		}
+	}
+
+	public async subscribe(): Promise<void> {
+		await this.subscription.subscribe();
+	}
+
+	async fetch(): Promise<void> {
+		if (this.fetchPromise) {
+			return this.fetchPromise;
+		}
+
+		this.fetchPromise = new Promise((resolver) => {
+			this.fetchPromiseResolver = resolver;
+		});
+
+		try {
+			const rpcRequestArgs = [
+				this.driftClient.program.programId.toBase58(),
+				{
+					commitment: this.driftClient.opts.commitment,
+					filters: [getUserFilter(), getUserWithOrderFilter()],
+					encoding: 'base64',
+					withContext: true,
+				},
+			];
+
+			const rpcJSONResponse: any =
+				// @ts-ignore
+				await this.driftClient.connection._rpcRequest(
+					'getProgramAccounts',
+					rpcRequestArgs
+				);
+
+			const rpcResponseAndContext: RpcResponseAndContext<
+				Array<{
+					pubkey: PublicKey;
+					account: {
+						data: [string, string];
+					};
+				}>
+			> = rpcJSONResponse.result;
+
+			const slot: number = rpcResponseAndContext.context.slot;
+
+			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);
+				this.tryUpdateUserAccount(key, buffer, slot);
+			}
+
+			for (const key of this.usersAccounts.keys()) {
+				if (!programAccountSet.has(key)) {
+					this.usersAccounts.delete(key);
+				}
+			}
+		} catch (e) {
+			console.error(e);
+		} finally {
+			this.fetchPromiseResolver();
+			this.fetchPromise = undefined;
+		}
+	}
+
+	tryUpdateUserAccount(key: string, buffer: Buffer, slot: number): void {
+		const slotAndUserAccount = this.usersAccounts.get(key);
+		if (!slotAndUserAccount || slotAndUserAccount.slot < slot) {
+			const userAccount =
+				this.driftClient.program.account.user.coder.accounts.decode(
+					'User',
+					buffer
+				) as UserAccount;
+
+			if (userAccount.hasOpenOrder) {
+				this.usersAccounts.set(key, { slot, userAccount });
+			} else {
+				this.usersAccounts.delete(key);
+			}
+		}
+	}
+
+	public async getDLOB(slot: number): Promise<DLOB> {
+		const dlob = new DLOB();
+		for (const [key, { userAccount }] of this.usersAccounts.entries()) {
+			const userAccountPubkey = new PublicKey(key);
+			for (const order of userAccount.orders) {
+				dlob.insertOrder(order, userAccountPubkey, slot);
+			}
+		}
+		return dlob;
+	}
+
+	public async unsubscribe(): Promise<void> {
+		await this.subscription.unsubscribe();
+	}
+}

package/src/orderSubscriber/PollingSubscription.ts

@@ -0,0 +1,39 @@
+import { OrderSubscriber } from './OrderSubscriber';
+
+export class PollingSubscription {
+	private orderSubscriber: OrderSubscriber;
+	private frequency: number;
+
+	intervalId?: NodeJS.Timer;
+
+	constructor({
+		orderSubscriber,
+		frequency,
+	}: {
+		orderSubscriber: OrderSubscriber;
+		frequency: number;
+	}) {
+		this.orderSubscriber = orderSubscriber;
+		this.frequency = frequency;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.intervalId) {
+			return;
+		}
+
+		this.intervalId = setInterval(
+			this.orderSubscriber.fetch.bind(this.orderSubscriber),
+			this.frequency
+		);
+
+		await this.orderSubscriber.fetch();
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (this.intervalId) {
+			clearInterval(this.intervalId);
+			this.intervalId = undefined;
+		}
+	}
+}

package/src/orderSubscriber/WebsocketSubscription.ts

@@ -0,0 +1,54 @@
+import { OrderSubscriber } from './OrderSubscriber';
+import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
+
+export class WebsocketSubscription {
+	private orderSubscriber: OrderSubscriber;
+	private skipInitialLoad: boolean;
+
+	private websocketId: number;
+
+	constructor({
+		orderSubscriber,
+		skipInitialLoad = false,
+	}: {
+		orderSubscriber: OrderSubscriber;
+		skipInitialLoad?: boolean;
+	}) {
+		this.orderSubscriber = orderSubscriber;
+		this.skipInitialLoad = skipInitialLoad;
+	}
+
+	public async subscribe(): Promise<void> {
+		if (this.websocketId) {
+			return;
+		}
+
+		this.websocketId =
+			this.orderSubscriber.driftClient.connection.onProgramAccountChange(
+				this.orderSubscriber.driftClient.program.programId,
+				(keyAccountInfo, context) => {
+					const userKey = keyAccountInfo.accountId.toBase58();
+					this.orderSubscriber.tryUpdateUserAccount(
+						userKey,
+						keyAccountInfo.accountInfo.data,
+						context.slot
+					);
+				},
+				this.orderSubscriber.driftClient.opts.commitment,
+				[getUserFilter(), getNonIdleUserFilter()]
+			);
+
+		if (!this.skipInitialLoad) {
+			await this.orderSubscriber.fetch();
+		}
+	}
+
+	public async unsubscribe(): Promise<void> {
+		if (this.websocketId) {
+			await this.orderSubscriber.driftClient.connection.removeProgramAccountChangeListener(
+				this.websocketId
+			);
+			this.websocketId = undefined;
+		}
+	}
+}

package/src/orderSubscriber/index.ts

@@ -0,0 +1,2 @@
+export * from './OrderSubscriber';
+export * from './types';

package/src/orderSubscriber/types.ts

@@ -0,0 +1,14 @@
+import { DriftClient } from '../driftClient';
+
+export type OrderSubscriberConfig = {
+	driftClient: DriftClient;
+	subscriptionConfig:
+		| {
+				type: 'polling';
+				frequency: number;
+		  }
+		| {
+				type: 'websocket';
+				skipInitialLoad?: boolean;
+		  };
+};

package/src/tx/retryTxSender.ts

@@ -119,14 +119,20 @@ export class RetryTxSender implements TxSender {
 		additionalSigners?: Array<Signer>,
 		opts?: ConfirmOptions
 	): Promise<TxSigAndSlot> {
+		additionalSigners
+			?.filter((s): s is Signer => s !== undefined)
+			.forEach((kp) => {
+				tx.sign([kp]);
+			});
+
 		// @ts-ignore
-		tx.sign((additionalSigners ?? []).concat(this.provider.wallet.payer));
+		const signedTx = await this.provider.wallet.signTransaction(tx);
 
 		if (opts === undefined) {
 			opts = this.provider.opts;
 		}
 
-		return this.sendRawTransaction(tx.serialize(), opts);
+		return this.sendRawTransaction(signedTx.serialize(), opts);
 	}
 
 	async sendRawTransaction(

package/src/types.ts

@@ -137,7 +137,7 @@ export class OrderActionExplanation {
 		orderFilledWithAmmJitLpSplit: {},
 	};
 	static readonly ORDER_FILLED_WITH_LP_JIT = {
-		orderFilledWithAmmJitLpSplit: {},
+		orderFilledWithLpJit: {},
 	};
 	static readonly ORDER_FILLED_WITH_MATCH = {
 		orderFilledWithMatch: {},
@@ -829,6 +829,10 @@ export type UserAccount = {
 	lastActiveSlot: BN;
 	isMarginTradingEnabled: boolean;
 	idle: boolean;
+	openOrders: number;
+	hasOpenOrder: boolean;
+	openAuctions: number;
+	hasOpenAuction: boolean;
 };
 
 export type SpotPosition = {

package/src/userMap/userMap.ts

@@ -18,7 +18,7 @@ import {
 
 import { PublicKey, RpcResponseAndContext } from '@solana/web3.js';
 import { Buffer } from 'buffer';
-import bs58 from 'bs58';
+import { getNonIdleUserFilter, getUserFilter } from '../memcmp';
 
 export interface UserMapInterface {
 	subscribe(): Promise<void>;
@@ -188,28 +188,16 @@ export class UserMap implements UserMapInterface {
 	}
 
 	public async sync() {
-		let filters = undefined;
+		const filters = [getUserFilter()];
 		if (!this.includeIdle) {
-			filters = [
-				{
-					memcmp: {
-						offset: 4350,
-						bytes: bs58.encode(Uint8Array.from([0])),
-					},
-				},
-			];
+			filters.push(getNonIdleUserFilter());
 		}
 
 		const rpcRequestArgs = [
 			this.driftClient.program.programId.toBase58(),
 			{
 				commitment: this.driftClient.connection.commitment,
-				filters: [
-					{
-						memcmp: this.driftClient.program.coder.accounts.memcmp('User'),
-					},
-					...(Array.isArray(filters) ? filters : []),
-				],
+				filters,
 				encoding: 'base64',
 				withContext: true,
 			},