@drift-labs/sdk 2.26.0-beta.1 → 2.26.0-beta.3

package/src/driftClient.ts

@@ -85,7 +85,7 @@ import { wrapInTx } from './tx/utils';
 import { QUOTE_SPOT_MARKET_INDEX, ZERO } from './constants/numericConstants';
 import { findDirectionToClose, positionIsAvailable } from './math/position';
 import { getTokenAmount } from './math/spotBalance';
-import { DEFAULT_USER_NAME, encodeName } from './userName';
+import { decodeName, DEFAULT_USER_NAME, encodeName } from './userName';
 import { OraclePriceData } from './oracles/types';
 import { DriftClientConfig } from './driftClientConfig';
 import { PollingDriftClientAccountSubscriber } from './accounts/pollingDriftClientAccountSubscriber';
@@ -118,9 +118,10 @@ export class DriftClient {
 	public program: Program;
 	provider: AnchorProvider;
 	opts?: ConfirmOptions;
-	users = new Map<number, User>();
+	users = new Map<string, User>();
 	userStats?: UserStats;
 	activeSubAccountId: number;
+	activeAuthority: PublicKey;
 	userAccountSubscriptionConfig: UserSubscriptionConfig;
 	accountSubscriber: DriftClientAccountSubscriber;
 	eventEmitter: StrictEventEmitter<EventEmitter, DriftClientAccountEvents>;
@@ -131,6 +132,9 @@ export class DriftClient {
 	authority: PublicKey;
 	marketLookupTable: PublicKey;
 	lookupTableAccount: AddressLookupTableAccount;
+	includeDelegates?: boolean;
+	authoritySubaccountMap?: Map<string, number[]>;
+	skipLoadUsers?: boolean;
 
 	public get isSubscribed() {
 		return this._isSubscribed && this.accountSubscriber.isSubscribed;
@@ -156,8 +160,35 @@ export class DriftClient {
 		);
 
 		this.authority = config.authority ?? this.wallet.publicKey;
-		const subAccountIds = config.subAccountIds ?? [0];
-		this.activeSubAccountId = config.activeSubAccountId ?? subAccountIds[0];
+		this.activeSubAccountId = config.activeSubAccountId ?? 0;
+		this.skipLoadUsers = config.skipLoadUsers ?? false;
+
+		if (config.includeDelegates && config.subAccountIds) {
+			throw new Error(
+				'Can only pass one of includeDelegates or subAccountIds. If you want to specify subaccount ids for multiple authorities, pass authoritySubaccountMap instead'
+			);
+		}
+
+		if (config.authoritySubaccountMap && config.subAccountIds) {
+			throw new Error(
+				'Can only pass one of authoritySubaccountMap or subAccountIds'
+			);
+		}
+
+		if (config.authoritySubaccountMap && config.includeDelegates) {
+			throw new Error(
+				'Can only pass one of authoritySubaccountMap or includeDelegates'
+			);
+		}
+
+		this.authoritySubaccountMap = config.authoritySubaccountMap
+			? config.authoritySubaccountMap
+			: config.subAccountIds
+			? new Map([[this.authority.toString(), config.subAccountIds]])
+			: new Map<string, number[]>();
+
+		this.includeDelegates = config.includeDelegates ?? false;
+		this.activeAuthority = this.authority;
 		this.userAccountSubscriptionConfig =
 			config.accountSubscription?.type === 'polling'
 				? {
@@ -167,7 +198,7 @@ export class DriftClient {
 				: {
 						type: 'websocket',
 				  };
-		this.createUsers(subAccountIds, this.userAccountSubscriptionConfig);
+
 		if (config.userStats) {
 			this.userStats = new UserStats({
 				driftClient: this,
@@ -229,23 +260,18 @@ export class DriftClient {
 		);
 	}
 
-	createUsers(
-		subAccountIds: number[],
-		accountSubscriptionConfig: UserSubscriptionConfig
-	): void {
-		for (const subAccountId of subAccountIds) {
-			const user = this.createUser(subAccountId, accountSubscriptionConfig);
-			this.users.set(subAccountId, user);
-		}
+	public getUserMapKey(subAccountId: number, authority: PublicKey): string {
+		return `${subAccountId}_${authority.toString()}`;
 	}
 
 	createUser(
 		subAccountId: number,
-		accountSubscriptionConfig: UserSubscriptionConfig
+		accountSubscriptionConfig: UserSubscriptionConfig,
+		authority?: PublicKey
 	): User {
 		const userAccountPublicKey = getUserAccountPublicKeySync(
 			this.program.programId,
-			this.authority,
+			authority ?? this.authority,
 			subAccountId
 		);
 
@@ -257,15 +283,17 @@ export class DriftClient {
 	}
 
 	public async subscribe(): Promise<boolean> {
-		let subscribePromises = this.subscribeUsers().concat(
+		let subscribePromises = [this.addAndSubscribeToUsers()].concat(
 			this.accountSubscriber.subscribe()
 		);
+
 		if (this.userStats !== undefined) {
 			subscribePromises = subscribePromises.concat(this.userStats.subscribe());
 		}
 		this.isSubscribed = (await Promise.all(subscribePromises)).reduce(
 			(success, prevSuccess) => success && prevSuccess
 		);
+
 		return this.isSubscribed;
 	}
 
@@ -448,12 +476,15 @@ export class DriftClient {
 	 * @param newWallet
 	 * @param subAccountIds
 	 * @param activeSubAccountId
+	 * @param includeDelegates
 	 */
 	public async updateWallet(
 		newWallet: IWallet,
-		subAccountIds = [0],
-		activeSubAccountId = 0
-	): Promise<void> {
+		subAccountIds?: number[],
+		activeSubAccountId?: number,
+		includeDelegates?: boolean,
+		authoritySubaccountMap?: Map<string, number[]>
+	): Promise<boolean> {
 		const newProvider = new AnchorProvider(
 			this.connection,
 			newWallet,
@@ -465,13 +496,42 @@ export class DriftClient {
 			newProvider
 		);
 
+		this.skipLoadUsers = false;
 		// Update provider for txSender with new wallet details
 		this.txSender.provider = newProvider;
-
 		this.wallet = newWallet;
 		this.provider = newProvider;
 		this.program = newProgram;
 		this.authority = newWallet.publicKey;
+		this.activeSubAccountId = activeSubAccountId;
+		this.userStatsAccountPublicKey = undefined;
+		this.includeDelegates = includeDelegates ?? false;
+
+		if (includeDelegates && subAccountIds) {
+			throw new Error(
+				'Can only pass one of includeDelegates or subAccountIds. If you want to specify subaccount ids for multiple authorities, pass authoritySubaccountMap instead'
+			);
+		}
+
+		if (authoritySubaccountMap && subAccountIds) {
+			throw new Error(
+				'Can only pass one of authoritySubaccountMap or subAccountIds'
+			);
+		}
+
+		if (authoritySubaccountMap && includeDelegates) {
+			throw new Error(
+				'Can only pass one of authoritySubaccountMap or includeDelegates'
+			);
+		}
+
+		this.authoritySubaccountMap = authoritySubaccountMap
+			? authoritySubaccountMap
+			: subAccountIds
+			? new Map([[this.authority.toString(), subAccountIds]])
+			: new Map<string, number[]>();
+
+		let success = true;
 
 		if (this.isSubscribed) {
 			await Promise.all(this.unsubscribeUsers());
@@ -481,50 +541,103 @@ export class DriftClient {
 
 				this.userStats = new UserStats({
 					driftClient: this,
-					userStatsAccountPublicKey: getUserStatsAccountPublicKey(
-						this.program.programId,
-						this.authority
-					),
+					userStatsAccountPublicKey: this.getUserStatsAccountPublicKey(),
 					accountSubscription: this.userAccountSubscriptionConfig,
 				});
-			}
-		}
-		this.users.clear();
-		this.createUsers(subAccountIds, this.userAccountSubscriptionConfig);
-		if (this.isSubscribed) {
-			await Promise.all(this.subscribeUsers());
 
-			if (this.userStats) {
 				await this.userStats.subscribe();
 			}
+
+			this.users.clear();
+			success = await this.addAndSubscribeToUsers();
 		}
 
-		this.activeSubAccountId = activeSubAccountId;
-		this.userStatsAccountPublicKey = undefined;
+		return success;
 	}
 
-	public switchActiveUser(subAccountId: number) {
+	public switchActiveUser(subAccountId: number, authority?: PublicKey) {
 		this.activeSubAccountId = subAccountId;
+		this.activeAuthority = authority ?? this.authority;
 	}
 
-	public async addUser(subAccountId: number): Promise<void> {
-		if (this.users.has(subAccountId)) {
-			return;
+	public async addUser(
+		subAccountId: number,
+		authority?: PublicKey
+	): Promise<boolean> {
+		authority = authority ?? this.authority;
+		const userKey = this.getUserMapKey(subAccountId, authority);
+
+		if (this.users.has(userKey) && this.users.get(userKey).isSubscribed) {
+			return true;
 		}
 
 		const user = this.createUser(
 			subAccountId,
-			this.userAccountSubscriptionConfig
+			this.userAccountSubscriptionConfig,
+			authority
 		);
-		await user.subscribe();
-		this.users.set(subAccountId, user);
+
+		const result = await user.subscribe();
+
+		if (result) {
+			this.users.set(userKey, user);
+			return true;
+		} else {
+			return false;
+		}
 	}
 
-	public async addAllUsers(): Promise<void> {
-		const userAccounts = await this.getUserAccountsForAuthority(this.authority);
-		for (const userAccount of userAccounts) {
-			await this.addUser(userAccount.subAccountId);
+	/**
+	 * Adds and subscribes to users based on params set by the constructor or by updateWallet.
+	 */
+	public async addAndSubscribeToUsers(): Promise<boolean> {
+		// save the rpc calls if driftclient is initialized without a real wallet
+		if (this.skipLoadUsers) return true;
+
+		let result = true;
+
+		if (this.authoritySubaccountMap && this.authoritySubaccountMap.size > 0) {
+			this.authoritySubaccountMap.forEach(async (value, key) => {
+				for (const subAccountId of value) {
+					result =
+						result && (await this.addUser(subAccountId, new PublicKey(key)));
+				}
+			});
+
+			if (this.activeSubAccountId == undefined) {
+				this.switchActiveUser(
+					[...this.authoritySubaccountMap.values()][0][0] ?? 0,
+					new PublicKey(
+						[...this.authoritySubaccountMap.keys()][0] ??
+							this.authority.toString()
+					)
+				);
+			}
+		} else {
+			const userAccounts =
+				(await this.getUserAccountsForAuthority(this.authority)) ?? [];
+			let delegatedAccounts = [];
+
+			if (this.includeDelegates) {
+				delegatedAccounts =
+					(await this.getUserAccountsForDelegate(this.authority)) ?? [];
+			}
+
+			for (const account of userAccounts.concat(delegatedAccounts)) {
+				result =
+					result &&
+					(await this.addUser(account.subAccountId, account.authority));
+			}
+
+			if (this.activeSubAccountId == undefined) {
+				this.switchActiveUser(
+					userAccounts.concat(delegatedAccounts)[0]?.subAccountId ?? 0,
+					userAccounts.concat(delegatedAccounts)[0]?.authority ?? this.authority
+				);
+			}
 		}
+
+		return result;
 	}
 
 	public async initializeUserAccount(
@@ -710,7 +823,7 @@ export class DriftClient {
 			subAccountId
 		);
 
-		await this.addUser(subAccountId);
+		await this.addUser(subAccountId, this.wallet.publicKey);
 		const remainingAccounts = this.getRemainingAccounts({
 			userAccounts: [this.getUserAccount(subAccountId)],
 		});
@@ -782,9 +895,9 @@ export class DriftClient {
 			},
 		]);
 
-		return programAccounts.map(
-			(programAccount) => programAccount.account as UserAccount
-		);
+		return programAccounts
+			.map((programAccount) => programAccount.account as UserAccount)
+			.sort((a, b) => a.subAccountId - b.subAccountId);
 	}
 
 	public async getUserAccountsAndAddressesForAuthority(
@@ -818,9 +931,9 @@ export class DriftClient {
 			},
 		]);
 
-		return programAccounts.map(
-			(programAccount) => programAccount.account as UserAccount
-		);
+		return programAccounts
+			.map((programAccount) => programAccount.account as UserAccount)
+			.sort((a, b) => a.subAccountId - b.subAccountId);
 	}
 
 	public async getReferredUserStatsAccountsByReferrer(
@@ -884,22 +997,33 @@ export class DriftClient {
 			this.opts
 		);
 
-		await this.users.get(subAccountId)?.unsubscribe();
-		this.users.delete(subAccountId);
+		const userMapKey = this.getUserMapKey(subAccountId, this.wallet.publicKey);
+		await this.users.get(userMapKey)?.unsubscribe();
+		this.users.delete(userMapKey);
 
 		return txSig;
 	}
 
-	public getUser(subAccountId?: number): User {
+	public getUser(subAccountId?: number, authority?: PublicKey): User {
 		subAccountId = subAccountId ?? this.activeSubAccountId;
-		if (!this.users.has(subAccountId)) {
+		authority = authority ?? this.activeAuthority;
+		const userMapKey = this.getUserMapKey(subAccountId, authority);
+
+		if (!this.users.has(userMapKey)) {
 			throw new Error(`Clearing House has no user for user id ${subAccountId}`);
 		}
-		return this.users.get(subAccountId);
+		return this.users.get(userMapKey);
 	}
 
 	public getUsers(): User[] {
-		return [...this.users.values()];
+		// delegate users get added to the end
+		return [...this.users.values()]
+			.filter((acct) => acct.getUserAccount().authority.equals(this.authority))
+			.concat(
+				[...this.users.values()].filter(
+					(acct) => !acct.getUserAccount().authority.equals(this.authority)
+				)
+			);
 	}
 
 	public getUserStats(): UserStats {
@@ -927,17 +1051,23 @@ export class DriftClient {
 
 		this.userStatsAccountPublicKey = getUserStatsAccountPublicKey(
 			this.program.programId,
-			this.authority
+			this.activeAuthority
 		);
 		return this.userStatsAccountPublicKey;
 	}
 
-	public async getUserAccountPublicKey(): Promise<PublicKey> {
-		return this.getUser().userAccountPublicKey;
+	public async getUserAccountPublicKey(
+		subAccountId?: number,
+		authority?: PublicKey
+	): Promise<PublicKey> {
+		return this.getUser(subAccountId, authority).userAccountPublicKey;
 	}
 
-	public getUserAccount(subAccountId?: number): UserAccount | undefined {
-		return this.getUser(subAccountId).getUserAccount();
+	public getUserAccount(
+		subAccountId?: number,
+		authority?: PublicKey
+	): UserAccount | undefined {
+		return this.getUser(subAccountId, authority).getUserAccount();
 	}
 
 	/**
@@ -1798,9 +1928,14 @@ export class DriftClient {
 		);
 
 		let remainingAccounts;
-		if (this.users.has(fromSubAccountId)) {
+
+		const userMapKey = this.getUserMapKey(
+			fromSubAccountId,
+			this.wallet.publicKey
+		);
+		if (this.users.has(userMapKey)) {
 			remainingAccounts = this.getRemainingAccounts({
-				userAccounts: [this.users.get(fromSubAccountId).getUserAccount()],
+				userAccounts: [this.users.get(userMapKey).getUserAccount()],
 				useMarketLastSlotCache: true,
 				writableSpotMarketIndexes: [marketIndex],
 			});
@@ -3039,7 +3174,7 @@ export class DriftClient {
 		user: UserAccount,
 		txParams?: TxParams
 	): Promise<TransactionSignature> {
-		const { txSig } = await this.txSender.send(
+		const { txSig } = await this.sendTransaction(
 			wrapInTx(
 				await this.getForceCancelOrdersIx(userAccountPublicKey, user),
 				txParams?.computeUnits,
@@ -3078,7 +3213,7 @@ export class DriftClient {
 		user: UserAccount,
 		txParams?: TxParams
 	): Promise<TransactionSignature> {
-		const { txSig } = await this.txSender.send(
+		const { txSig } = await this.sendTransaction(
 			wrapInTx(
 				await this.getUpdateUserIdleIx(userAccountPublicKey, user),
 				txParams?.computeUnits,
@@ -4738,6 +4873,36 @@ export class DriftClient {
 		return extendedInfo;
 	}
 
+	/**
+	 * Returns the market index and type for a given market name
+	 * E.g. "SOL-PERP" -> { marketIndex: 0, marketType: MarketType.PERP }
+	 *
+	 * @param name
+	 */
+	getMarketIndexAndType(
+		name: string
+	): { marketIndex: number; marketType: MarketType } | undefined {
+		for (const perpMarketAccount of this.getPerpMarketAccounts()) {
+			if (decodeName(perpMarketAccount.name) === name) {
+				return {
+					marketIndex: perpMarketAccount.marketIndex,
+					marketType: MarketType.PERP,
+				};
+			}
+		}
+
+		for (const spotMarketAccount of this.getSpotMarketAccounts()) {
+			if (decodeName(spotMarketAccount.name) === name) {
+				return {
+					marketIndex: spotMarketAccount.marketIndex,
+					marketType: MarketType.SPOT,
+				};
+			}
+		}
+
+		return undefined;
+	}
+
 	sendTransaction(
 		tx: Transaction,
 		additionalSigners?: Array<Signer>,

package/src/driftClientConfig.ts

@@ -20,6 +20,9 @@ export type DriftClientConfig = {
 	env?: DriftEnv;
 	userStats?: boolean;
 	authority?: PublicKey; // explicitly pass an authority if signer is delegate
+	includeDelegates?: boolean; // flag for whether to load delegate accounts as well
+	authoritySubaccountMap?: Map<string, number[]>; // if passed this will override subAccountIds and includeDelegates
+	skipLoadUsers?: boolean; // if passed to constructor, no user accounts will be loaded. they will load if updateWallet is called afterwards.
 };
 
 export type DriftClientSubscriptionConfig =

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.26.0-beta.1",
+  "version": "2.26.0-beta.3",
   "name": "drift",
   "instructions": [
     {

package/src/index.ts

@@ -70,6 +70,7 @@ export * from './dlob/DLOBOrders';
 export * from './dlob/NodeList';
 export * from './dlob/DLOBSubscriber';
 export * from './dlob/types';
+export * from './dlob/orderBookLevels';
 export * from './userMap/userMap';
 export * from './userMap/userStatsMap';
 export * from './math/bankruptcy';

package/src/serum/serumSubscriber.ts

@@ -4,8 +4,9 @@ import { Market, Orderbook } from '@project-serum/serum';
 import { SerumMarketSubscriberConfig } from './types';
 import { BN } from '@coral-xyz/anchor';
 import { PRICE_PRECISION } from '../constants/numericConstants';
+import { L2Level, L2OrderBookGenerator } from '../dlob/orderBookLevels';
 
-export class SerumSubscriber {
+export class SerumSubscriber implements L2OrderBookGenerator {
 	connection: Connection;
 	programId: PublicKey;
 	marketAddress: PublicKey;
@@ -112,6 +113,33 @@ export class SerumSubscriber {
 		return new BN(bestAsk[0] * PRICE_PRECISION.toNumber());
 	}
 
+	public getL2Bids(): Generator<L2Level> {
+		return this.getL2Levels('bids');
+	}
+
+	public getL2Asks(): Generator<L2Level> {
+		return this.getL2Levels('asks');
+	}
+
+	*getL2Levels(side: 'bids' | 'asks'): Generator<L2Level> {
+		// @ts-ignore
+		const basePrecision = Math.pow(10, this.market._baseSplTokenDecimals);
+		const pricePrecision = PRICE_PRECISION.toNumber();
+		for (const { price: priceNum, size: sizeNum } of this[side].items(
+			side === 'bids'
+		)) {
+			const price = new BN(priceNum * pricePrecision);
+			const size = new BN(sizeNum * basePrecision);
+			yield {
+				price,
+				size,
+				sources: {
+					serum: size,
+				},
+			};
+		}
+	}
+
 	public async unsubscribe(): Promise<void> {
 		if (!this.subscribed) {
 			return;

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/types.ts

@@ -585,6 +585,7 @@ export type HistoricalIndexData = {
 export type SpotMarketAccount = {
 	status: MarketStatus;
 	assetTier: AssetTier;
+	name: number[];
 
 	marketIndex: number;
 	pubkey: PublicKey;

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/getTokenAddress.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenAddress = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const getTokenAddress = (mintAddress, userPubKey) => {
+    return spl_token_1.Token.getAssociatedTokenAddress(spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, spl_token_1.TOKEN_PROGRAM_ID, new web3_js_1.PublicKey(mintAddress), new web3_js_1.PublicKey(userPubKey));
+};
+exports.getTokenAddress = getTokenAddress;

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;