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

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/token/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokenAccount = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+function parseTokenAccount(data) {
+    const accountInfo = spl_token_1.AccountLayout.decode(data);
+    accountInfo.mint = new web3_js_1.PublicKey(accountInfo.mint);
+    accountInfo.owner = new web3_js_1.PublicKey(accountInfo.owner);
+    accountInfo.amount = spl_token_1.u64.fromBuffer(accountInfo.amount);
+    if (accountInfo.delegateOption === 0) {
+        accountInfo.delegate = null;
+        // eslint-disable-next-line new-cap
+        accountInfo.delegatedAmount = new spl_token_1.u64(0);
+    }
+    else {
+        accountInfo.delegate = new web3_js_1.PublicKey(accountInfo.delegate);
+        accountInfo.delegatedAmount = spl_token_1.u64.fromBuffer(accountInfo.delegatedAmount);
+    }
+    accountInfo.isInitialized = accountInfo.state !== 0;
+    accountInfo.isFrozen = accountInfo.state === 2;
+    if (accountInfo.isNativeOption === 1) {
+        accountInfo.rentExemptReserve = spl_token_1.u64.fromBuffer(accountInfo.isNative);
+        accountInfo.isNative = true;
+    }
+    else {
+        accountInfo.rentExemptReserve = null;
+        accountInfo.isNative = false;
+    }
+    if (accountInfo.closeAuthorityOption === 0) {
+        accountInfo.closeAuthority = null;
+    }
+    else {
+        accountInfo.closeAuthority = new web3_js_1.PublicKey(accountInfo.closeAuthority);
+    }
+    return accountInfo;
+}
+exports.parseTokenAccount = parseTokenAccount;

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,
 			},

package/src/util/computeUnits.js

@@ -0,0 +1,27 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findComputeUnitConsumption = void 0;
+function findComputeUnitConsumption(programId, connection, txSignature, commitment = 'confirmed') {
+    return __awaiter(this, void 0, void 0, function* () {
+        const tx = yield connection.getTransaction(txSignature, { commitment });
+        const computeUnits = [];
+        const regex = new RegExp(`Program ${programId.toString()} consumed ([0-9]{0,6}) of ([0-9]{0,7}) compute units`);
+        tx.meta.logMessages.forEach((logMessage) => {
+            const match = logMessage.match(regex);
+            if (match && match[1]) {
+                computeUnits.push(match[1]);
+            }
+        });
+        return computeUnits;
+    });
+}
+exports.findComputeUnitConsumption = findComputeUnitConsumption;

package/src/util/promiseTimeout.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseTimeout = void 0;
+function promiseTimeout(promise, timeoutMs) {
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve) => {
+        timeoutId = setTimeout(() => resolve(null), timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]).then((result) => {
+        clearTimeout(timeoutId);
+        return result;
+    });
+}
+exports.promiseTimeout = promiseTimeout;

package/src/util/tps.js

@@ -0,0 +1,27 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTps = void 0;
+function estimateTps(programId, connection, failed) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let signatures = yield connection.getSignaturesForAddress(programId, undefined, 'finalized');
+        if (failed) {
+            signatures = signatures.filter((signature) => signature.err);
+        }
+        const numberOfSignatures = signatures.length;
+        if (numberOfSignatures === 0) {
+            return 0;
+        }
+        return (numberOfSignatures /
+            (signatures[0].blockTime - signatures[numberOfSignatures - 1].blockTime));
+    });
+}
+exports.estimateTps = estimateTps;