@drift-labs/sdk 2.85.0-beta.1 → 2.85.0-beta.11

package/src/driftClient.ts

@@ -129,6 +129,7 @@ import { numberToSafeBN } from './math/utils';
 import { TransactionParamProcessor } from './tx/txParamProcessor';
 import { isOracleValid } from './math/oracles';
 import { TxHandler } from './tx/txHandler';
+import { isVersionedTransaction } from './tx/utils';
 
 type RemainingAccountParams = {
 	userAccounts: UserAccount[];
@@ -227,6 +228,7 @@ export class DriftClient {
 					onSignedCb: this.handleSignedTransaction.bind(this),
 					preSignedCb: this.handlePreSignedTransaction.bind(this),
 				},
+				config: config.txHandlerConfig,
 			});
 
 		if (config.includeDelegates && config.subAccountIds) {
@@ -1800,25 +1802,14 @@ export class DriftClient {
 		});
 	}
 
-	/**
-	 * Deposit funds into the given spot market
-	 *
-	 * @param amount to deposit
-	 * @param marketIndex spot market index to deposit into
-	 * @param associatedTokenAccount can be the wallet public key if using native sol
-	 * @param subAccountId subaccountId to deposit
-	 * @param reduceOnly if true, deposit must not increase account risk
-	 */
-	public async deposit(
+	public async createDepositTxn(
 		amount: BN,
 		marketIndex: number,
 		associatedTokenAccount: PublicKey,
 		subAccountId?: number,
 		reduceOnly = false,
 		txParams?: TxParams
-	): Promise<TransactionSignature> {
-		const additionalSigners: Array<Signer> = [];
-
+	): Promise<ReturnType<typeof this.buildTransaction>> {
 		const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
 
 		const isSolMarket = spotMarketAccount.mint.equals(WRAPPED_SOL_MINT);
@@ -1868,11 +1859,36 @@ export class DriftClient {
 
 		const tx = await this.buildTransaction(instructions, txParams);
 
-		const { txSig, slot } = await this.sendTransaction(
-			tx,
-			additionalSigners,
-			this.opts
+		return tx;
+	}
+
+	/**
+	 * Deposit funds into the given spot market
+	 *
+	 * @param amount to deposit
+	 * @param marketIndex spot market index to deposit into
+	 * @param associatedTokenAccount can be the wallet public key if using native sol
+	 * @param subAccountId subaccountId to deposit
+	 * @param reduceOnly if true, deposit must not increase account risk
+	 */
+	public async deposit(
+		amount: BN,
+		marketIndex: number,
+		associatedTokenAccount: PublicKey,
+		subAccountId?: number,
+		reduceOnly = false,
+		txParams?: TxParams
+	): Promise<TransactionSignature> {
+		const tx = await this.createDepositTxn(
+			amount,
+			marketIndex,
+			associatedTokenAccount,
+			subAccountId,
+			reduceOnly,
+			txParams
 		);
+
+		const { txSig, slot } = await this.sendTransaction(tx, [], this.opts);
 		this.spotMarketLastSlotCache.set(marketIndex, slot);
 		return txSig;
 	}
@@ -2005,20 +2021,7 @@ export class DriftClient {
 		);
 	}
 
-	/**
-	 * Creates the User account for a user, and deposits some initial collateral
-	 * @param amount
-	 * @param userTokenAccount
-	 * @param marketIndex
-	 * @param subAccountId
-	 * @param name
-	 * @param fromSubAccountId
-	 * @param referrerInfo
-	 * @param donateAmount
-	 * @param txParams
-	 * @returns
-	 */
-	public async initializeUserAccountAndDepositCollateral(
+	public async createInitializeUserAccountAndDepositCollateral(
 		amount: BN,
 		userTokenAccount: PublicKey,
 		marketIndex = 0,
@@ -2029,7 +2032,7 @@ export class DriftClient {
 		donateAmount?: BN,
 		txParams?: TxParams,
 		customMaxMarginRatio?: number
-	): Promise<[TransactionSignature, PublicKey]> {
+	): Promise<[Transaction | VersionedTransaction, PublicKey]> {
 		const ixs = [];
 
 		const [userAccountPublicKey, initializeUserAccountIx] =
@@ -2039,8 +2042,6 @@ export class DriftClient {
 				referrerInfo
 			);
 
-		const additionalSigners: Array<Signer> = [];
-
 		const spotMarket = this.getSpotMarketAccount(marketIndex);
 
 		const isSolMarket = spotMarket.mint.equals(WRAPPED_SOL_MINT);
@@ -2134,6 +2135,49 @@ export class DriftClient {
 
 		const tx = await this.buildTransaction(ixs, txParams);
 
+		return [tx, userAccountPublicKey];
+	}
+
+	/**
+	 * Creates the User account for a user, and deposits some initial collateral
+	 * @param amount
+	 * @param userTokenAccount
+	 * @param marketIndex
+	 * @param subAccountId
+	 * @param name
+	 * @param fromSubAccountId
+	 * @param referrerInfo
+	 * @param donateAmount
+	 * @param txParams
+	 * @returns
+	 */
+	public async initializeUserAccountAndDepositCollateral(
+		amount: BN,
+		userTokenAccount: PublicKey,
+		marketIndex = 0,
+		subAccountId = 0,
+		name?: string,
+		fromSubAccountId?: number,
+		referrerInfo?: ReferrerInfo,
+		donateAmount?: BN,
+		txParams?: TxParams,
+		customMaxMarginRatio?: number
+	): Promise<[TransactionSignature, PublicKey]> {
+		const [tx, userAccountPublicKey] =
+			await this.createInitializeUserAccountAndDepositCollateral(
+				amount,
+				userTokenAccount,
+				marketIndex,
+				subAccountId,
+				name,
+				fromSubAccountId,
+				referrerInfo,
+				donateAmount,
+				txParams,
+				customMaxMarginRatio
+			);
+		const additionalSigners: Array<Signer> = [];
+
 		const { txSig, slot } = await this.sendTransaction(
 			tx,
 			additionalSigners,
@@ -2770,7 +2814,7 @@ export class DriftClient {
 	}
 
 	public async sendSignedTx(
-		tx: Transaction,
+		tx: Transaction | VersionedTransaction,
 		opts?: ConfirmOptions
 	): Promise<TransactionSignature> {
 		const { txSig } = await this.sendTransaction(
@@ -4118,6 +4162,10 @@ export class DriftClient {
 		const outMarket = this.getSpotMarketAccount(outMarketIndex);
 		const inMarket = this.getSpotMarketAccount(inMarketIndex);
 
+		const isExactOut = swapMode === 'ExactOut' || quote.swapMode === 'ExactOut';
+		const amountIn = new BN(quote.inAmount);
+		const exactOutBufferedAmountIn = amountIn.muln(1001).divn(1000); // Add 10bp buffer
+
 		if (!quote) {
 			const fetchedQuote = await jupiterClient.getQuote({
 				inputMint: inMarket.mint,
@@ -4198,7 +4246,7 @@ export class DriftClient {
 		const { beginSwapIx, endSwapIx } = await this.getSwapIx({
 			outMarketIndex,
 			inMarketIndex,
-			amountIn: new BN(quote.inAmount),
+			amountIn: isExactOut ? exactOutBufferedAmountIn : amountIn,
 			inTokenAccount: inAssociatedTokenAccount,
 			outTokenAccount: outAssociatedTokenAccount,
 			reduceOnly,
@@ -4664,7 +4712,8 @@ export class DriftClient {
 					await TransactionParamProcessor.getTxSimComputeUnits(
 						placeAndTakeTxToSim,
 						this.connection,
-						txParams.computeUnitsBufferMultiplier ?? 1.2
+						txParams.computeUnitsBufferMultiplier ?? 1.2,
+						txParams.lowerBoundCu
 					);
 
 				if (shouldExitIfSimulationFails && !simulationResult.success) {
@@ -4784,6 +4833,10 @@ export class DriftClient {
 				exitEarlyIfSimFails
 			);
 
+		if (!txsToSign) {
+			return null;
+		}
+
 		const signedTxs = (
 			await this.txHandler.getSignedTransactionMap(
 				txsToSign,
@@ -6854,11 +6907,7 @@ export class DriftClient {
 	private isVersionedTransaction(
 		tx: Transaction | VersionedTransaction
 	): boolean {
-		const version = (tx as VersionedTransaction)?.version;
-		const isVersionedTx =
-			tx instanceof VersionedTransaction || version !== undefined;
-
-		return isVersionedTx;
+		return isVersionedTransaction(tx);
 	}
 
 	sendTransaction(

package/src/driftClientConfig.ts

@@ -10,7 +10,7 @@ import { OracleInfo } from './oracles/types';
 import { BulkAccountLoader } from './accounts/bulkAccountLoader';
 import { DriftEnv } from './config';
 import { TxSender } from './tx/types';
-import { TxHandler } from './tx/txHandler';
+import { TxHandler, TxHandlerConfig } from './tx/txHandler';
 
 export type DriftClientConfig = {
 	connection: Connection;
@@ -35,6 +35,7 @@ export type DriftClientConfig = {
 	txVersion?: TransactionVersion; // which tx version to use
 	txParams?: TxParams; // default tx params to use
 	enableMetricsEvents?: boolean;
+	txHandlerConfig?: TxHandlerConfig;
 };
 
 export type DriftClientSubscriptionConfig =

package/src/events/eventSubscriber.ts

@@ -45,6 +45,7 @@ export class EventSubscriber {
 
 		if (this.options.logProviderConfig.type === 'websocket') {
 			this.logProvider = new WebSocketLogProvider(
+				// @ts-ignore
 				this.connection,
 				this.address,
 				this.options.commitment,
@@ -52,6 +53,7 @@ export class EventSubscriber {
 			);
 		} else {
 			this.logProvider = new PollingLogProvider(
+				// @ts-ignore
 				this.connection,
 				this.address,
 				options.commitment,
@@ -101,6 +103,7 @@ export class EventSubscriber {
 									this.logProvider.eventEmitter.removeAllListeners('reconnect');
 									this.unsubscribe().then(() => {
 										this.logProvider = new PollingLogProvider(
+											// @ts-ignore
 											this.connection,
 											this.address,
 											this.options.commitment,
@@ -148,6 +151,7 @@ export class EventSubscriber {
 		}
 
 		const wrappedEvents = this.parseEventsFromLogs(txSig, slot, logs);
+
 		for (const wrappedEvent of wrappedEvents) {
 			this.eventListMap.get(wrappedEvent.eventType).insert(wrappedEvent);
 		}
@@ -188,6 +192,7 @@ export class EventSubscriber {
 		const untilTx: TransactionSignature = this.options.untilTx;
 		while (txFetched < this.options.maxTx) {
 			const response = await fetchLogs(
+				// @ts-ignore
 				this.connection,
 				this.address,
 				this.options.commitment === 'finalized' ? 'finalized' : 'confirmed',

package/src/idl/drift.json

@@ -3934,6 +3934,12 @@
         {
           "name": "maxBorrowRate",
           "type": "u32"
+        },
+        {
+          "name": "minBorrowRate",
+          "type": {
+            "option": "u8"
+          }
         }
       ]
     },
@@ -6198,13 +6204,13 @@
             "type": "i16"
           },
           {
-            "name": "padding1",
-            "type": {
-              "array": [
-                "u8",
-                2
-              ]
-            }
+            "name": "maxTokenBorrowsFraction",
+            "docs": [
+              "What fraction of max_token_deposits",
+              "disabled when 0, 1 => 1/10000 => .01% of max_token_deposits",
+              "precision: X/10000"
+            ],
+            "type": "u16"
           },
           {
             "name": "flashLoanAmount",
@@ -6240,12 +6246,21 @@
             ],
             "type": "u64"
           },
+          {
+            "name": "minBorrowRate",
+            "docs": [
+              "The min borrow rate for this market when the market regardless of utilization",
+              "1 => 1/200 => .5%",
+              "precision: X/200"
+            ],
+            "type": "u8"
+          },
           {
             "name": "padding",
             "type": {
               "array": [
                 "u8",
-                48
+                47
               ]
             }
           }
@@ -12009,6 +12024,11 @@
       "code": 6267,
       "name": "UnableToParsePullOracleMessage",
       "msg": "Unable to parse pull oracle message"
+    },
+    {
+      "code": 6268,
+      "name": "MaxBorrows",
+      "msg": "Can not borow more than max borrows"
     }
   ]
 }

package/src/testClient.ts

@@ -10,8 +10,6 @@ export class TestClient extends AdminClient {
 			throw new Error('Test client must be polling');
 		}
 		super(config);
-		// @ts-ignore
-		this.txHandler.blockhashCommitment = 'recent';
 	}
 
 	async sendTransaction(
@@ -30,6 +28,7 @@ export class TestClient extends AdminClient {
 		let lastFetchedSlot = (
 			this.accountSubscriber as PollingDriftClientAccountSubscriber
 		).accountLoader.mostRecentSlot;
+		await this.fetchAccounts();
 		while (lastFetchedSlot < slot) {
 			await this.fetchAccounts();
 			lastFetchedSlot = (

package/src/tokenFaucet.ts

@@ -2,10 +2,10 @@ import * as anchor from '@coral-xyz/anchor';
 import { AnchorProvider, Idl, Program } from '@coral-xyz/anchor';
 import {
 	TOKEN_PROGRAM_ID,
-	getAccount,
 	Account,
 	createAssociatedTokenAccountInstruction,
 	getAssociatedTokenAddress,
+	getAccount,
 } from '@solana/spl-token';
 import {
 	ConfirmOptions,
@@ -19,8 +19,10 @@ import {
 import { BN } from '.';
 import tokenFaucet from './idl/token_faucet.json';
 import { IWallet } from './types';
+import { BankrunContextWrapper } from './bankrun/bankrunConnection';
 
 export class TokenFaucet {
+	context?: BankrunContextWrapper;
 	connection: Connection;
 	wallet: IWallet;
 	public program: Program;
@@ -33,13 +35,20 @@ export class TokenFaucet {
 		wallet: IWallet,
 		programId: PublicKey,
 		mint: PublicKey,
-		opts?: ConfirmOptions
+		opts?: ConfirmOptions,
+		context?: BankrunContextWrapper
 	) {
 		this.connection = connection;
+		this.context = context;
 		this.wallet = wallet;
 		this.opts = opts || AnchorProvider.defaultOptions();
 		// @ts-ignore
-		const provider = new AnchorProvider(connection, wallet, this.opts);
+		const provider = new AnchorProvider(
+			context ? context.connection.toConnection() : this.connection,
+			// @ts-ignore
+			wallet,
+			this.opts
+		);
 		this.provider = provider;
 		this.program = new Program(tokenFaucet as Idl, programId, provider);
 		this.mint = mint;
@@ -76,7 +85,7 @@ export class TokenFaucet {
 	public async initialize(): Promise<TransactionSignature> {
 		const [faucetConfigPublicKey] =
 			await this.getFaucetConfigPublicKeyAndNonce();
-		return await this.program.rpc.initialize({
+		const ix = this.program.instruction.initialize({
 			accounts: {
 				faucetConfig: faucetConfigPublicKey,
 				admin: this.wallet.publicKey,
@@ -86,6 +95,9 @@ export class TokenFaucet {
 				tokenProgram: TOKEN_PROGRAM_ID,
 			},
 		});
+		const tx = new Transaction().add(ix);
+		const txSig = await this.context.sendTransaction(tx);
+		return txSig;
 	}
 
 	public async fetchState(): Promise<any> {
@@ -114,12 +126,29 @@ export class TokenFaucet {
 
 		const tx = new Transaction().add(mintIx);
 
-		const txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
-
-		return txSig;
+		if (this.context) {
+			return await this.context.sendTransaction(tx);
+		} else {
+			return await this.program.provider.sendAndConfirm(tx, [], this.opts);
+		}
 	}
 
 	public async transferMintAuthority(): Promise<TransactionSignature> {
+		if (this.context) {
+			const ix = this.program.instruction.transferMintAuthority({
+				accounts: {
+					faucetConfig: await this.getFaucetConfigPublicKey(),
+					mintAccount: this.mint,
+					mintAuthority: await this.getMintAuthority(),
+					tokenProgram: TOKEN_PROGRAM_ID,
+					admin: this.wallet.publicKey,
+				},
+			});
+			const tx = new Transaction().add(ix);
+			const txSig = await this.context.sendTransaction(tx);
+			return txSig;
+		}
+
 		return await this.program.rpc.transferMintAuthority({
 			accounts: {
 				faucetConfig: await this.getFaucetConfigPublicKey(),
@@ -146,9 +175,8 @@ export class TokenFaucet {
 		let associatedTokenAccountExists = false;
 
 		try {
-			const assosciatedTokenAccount = await this.connection.getAccountInfo(
-				associatedTokenPublicKey
-			);
+			const assosciatedTokenAccount =
+				await this.context.connection.getAccountInfo(associatedTokenPublicKey);
 
 			associatedTokenAccountExists = !!assosciatedTokenAccount;
 		} catch (e) {
@@ -162,7 +190,13 @@ export class TokenFaucet {
 
 		tx.add(mintToTx);
 
-		const txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
+		let txSig;
+		if (this.context) {
+			txSig = await this.context.sendTransaction(tx);
+		} else {
+			txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
+		}
+
 		return [associatedTokenPublicKey, txSig];
 	}
 
@@ -200,6 +234,9 @@ export class TokenFaucet {
 		userPubKey: PublicKey;
 	}): Promise<Account> {
 		const associatedKey = await this.getAssosciatedMockUSDMintAddress(props);
+		if (this.context) {
+			return await this.context.connection.getTokenAccount(associatedKey);
+		}
 		return await getAccount(this.connection, associatedKey);
 	}
 
@@ -215,7 +252,7 @@ export class TokenFaucet {
 			props.callback(await this.getTokenAccountInfo(props));
 
 			// Couldn't find a way to do it using anchor framework subscription, someone on serum discord recommended this way
-			this.connection.onAccountChange(
+			this.context.connection.onAccountChange(
 				tokenAccountKey,
 				async (
 					_accountInfo /* accountInfo is a buffer which we don't know how to deserialize */

package/src/tx/blockhashFetcher/baseBlockhashFetcher.ts

@@ -0,0 +1,19 @@
+import {
+	BlockhashWithExpiryBlockHeight,
+	Commitment,
+	Connection,
+} from '@solana/web3.js';
+import { BlockhashFetcher } from './types';
+
+export class BaseBlockhashFetcher implements BlockhashFetcher {
+	constructor(
+		private connection: Connection,
+		private blockhashCommitment: Commitment
+	) {}
+
+	public async getLatestBlockhash(): Promise<
+		BlockhashWithExpiryBlockHeight | undefined
+	> {
+		return this.connection.getLatestBlockhash(this.blockhashCommitment);
+	}
+}

package/src/tx/blockhashFetcher/cachedBlockhashFetcher.ts

@@ -0,0 +1,90 @@
+import {
+	BlockhashWithExpiryBlockHeight,
+	Commitment,
+	Connection,
+} from '@solana/web3.js';
+import { BlockhashFetcher } from './types';
+
+/**
+ * Fetches the latest blockhash and caches it for a configurable amount of time.
+ *
+ * - Prevents RPC spam by reusing cached values
+ * - Retries on failure with exponential backoff
+ * - Prevents concurrent requests for the same blockhash
+ */
+export class CachedBlockhashFetcher implements BlockhashFetcher {
+	private recentBlockhashCache: {
+		value: BlockhashWithExpiryBlockHeight | undefined;
+		lastUpdated: number;
+	} = { value: undefined, lastUpdated: 0 };
+
+	private blockhashFetchingPromise: Promise<void> | null = null;
+
+	constructor(
+		private connection: Connection,
+		private blockhashCommitment: Commitment,
+		private retryCount: number,
+		private retrySleepTimeMs: number,
+		private staleCacheTimeMs: number
+	) {}
+
+	private async fetchBlockhashWithRetry(): Promise<BlockhashWithExpiryBlockHeight> {
+		for (let i = 0; i < this.retryCount; i++) {
+			try {
+				return await this.connection.getLatestBlockhash(
+					this.blockhashCommitment
+				);
+			} catch (err) {
+				if (i === this.retryCount - 1) {
+					throw new Error('Failed to fetch blockhash after maximum retries');
+				}
+				await this.sleep(this.retrySleepTimeMs * 2 ** i);
+			}
+		}
+		throw new Error('Failed to fetch blockhash after maximum retries');
+	}
+
+	private sleep(ms: number): Promise<void> {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+
+	private async updateBlockhashCache(): Promise<void> {
+		const result = await this.fetchBlockhashWithRetry();
+		this.recentBlockhashCache = {
+			value: result,
+			lastUpdated: Date.now(),
+		};
+	}
+
+	public async getLatestBlockhash(): Promise<
+		BlockhashWithExpiryBlockHeight | undefined
+	> {
+		if (this.isCacheStale()) {
+			await this.refreshBlockhash();
+		}
+		return this.recentBlockhashCache.value;
+	}
+
+	private isCacheStale(): boolean {
+		const lastUpdateTime = this.recentBlockhashCache.lastUpdated;
+		return (
+			!lastUpdateTime || Date.now() > lastUpdateTime + this.staleCacheTimeMs
+		);
+	}
+
+	/**
+	 * Refresh the blockhash cache, await a pending refresh if it exists
+	 */
+	private async refreshBlockhash(): Promise<void> {
+		if (!this.blockhashFetchingPromise) {
+			this.blockhashFetchingPromise = this.updateBlockhashCache();
+			try {
+				await this.blockhashFetchingPromise;
+			} finally {
+				this.blockhashFetchingPromise = null;
+			}
+		} else {
+			await this.blockhashFetchingPromise;
+		}
+	}
+}

package/src/tx/blockhashFetcher/types.ts

@@ -0,0 +1,5 @@
+import { BlockhashWithExpiryBlockHeight } from '@solana/web3.js';
+
+export interface BlockhashFetcher {
+	getLatestBlockhash(): Promise<BlockhashWithExpiryBlockHeight | undefined>;
+}