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

package/VERSION

@@ -1 +1 @@
-2.85.0-beta.10
+2.85.0-beta.11

package/lib/driftClient.d.ts

@@ -221,6 +221,7 @@ export declare class DriftClient {
      */
     getAssociatedTokenAccount(marketIndex: number, useNative?: boolean): Promise<PublicKey>;
     createAssociatedTokenAccountIdempotentInstruction(account: PublicKey, payer: PublicKey, owner: PublicKey, mint: PublicKey): TransactionInstruction;
+    createDepositTxn(amount: BN, marketIndex: number, associatedTokenAccount: PublicKey, subAccountId?: number, reduceOnly?: boolean, txParams?: TxParams): Promise<ReturnType<typeof this.buildTransaction>>;
     /**
      * Deposit funds into the given spot market
      *
@@ -240,6 +241,7 @@ export declare class DriftClient {
         pubkey: PublicKey;
     }>;
     getAssociatedTokenAccountCreationIx(tokenMintAddress: PublicKey, associatedTokenAddress: PublicKey): anchor.web3.TransactionInstruction;
+    createInitializeUserAccountAndDepositCollateral(amount: BN, userTokenAccount: PublicKey, marketIndex?: number, subAccountId?: number, name?: string, fromSubAccountId?: number, referrerInfo?: ReferrerInfo, donateAmount?: BN, txParams?: TxParams, customMaxMarginRatio?: number): Promise<[Transaction | VersionedTransaction, PublicKey]>;
     /**
      * Creates the User account for a user, and deposits some initial collateral
      * @param amount

package/lib/driftClient.js

@@ -58,6 +58,7 @@ const utils_1 = require("./math/utils");
 const txParamProcessor_1 = require("./tx/txParamProcessor");
 const oracles_1 = require("./math/oracles");
 const txHandler_1 = require("./tx/txHandler");
+const utils_2 = require("./tx/utils");
 /**
  * # DriftClient
  * This class is the main way to interact with Drift Protocol. It allows you to subscribe to the various accounts where the Market's state is stored, as well as: opening positions, liquidating, settling funding, depositing & withdrawing, and more.
@@ -106,6 +107,7 @@ class DriftClient {
                     onSignedCb: this.handleSignedTransaction.bind(this),
                     preSignedCb: this.handlePreSignedTransaction.bind(this),
                 },
+                config: config.txHandlerConfig,
             });
         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');
@@ -1061,17 +1063,7 @@ class DriftClient {
             data: Buffer.from([0x1]),
         });
     }
-    /**
-     * 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
-     */
-    async deposit(amount, marketIndex, associatedTokenAccount, subAccountId, reduceOnly = false, txParams) {
-        const additionalSigners = [];
+    async createDepositTxn(amount, marketIndex, associatedTokenAccount, subAccountId, reduceOnly = false, txParams) {
         const spotMarketAccount = this.getSpotMarketAccount(marketIndex);
         const isSolMarket = spotMarketAccount.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
         const signerAuthority = this.wallet.publicKey;
@@ -1090,7 +1082,20 @@ class DriftClient {
         }
         txParams = { ...(txParams !== null && txParams !== void 0 ? txParams : this.txParams), computeUnits: 600000 };
         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
+     */
+    async deposit(amount, marketIndex, associatedTokenAccount, subAccountId, reduceOnly = false, txParams) {
+        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;
     }
@@ -1165,23 +1170,9 @@ class DriftClient {
     getAssociatedTokenAccountCreationIx(tokenMintAddress, associatedTokenAddress) {
         return (0, spl_token_1.createAssociatedTokenAccountInstruction)(this.wallet.publicKey, associatedTokenAddress, this.wallet.publicKey, tokenMintAddress);
     }
-    /**
-     * 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
-     */
-    async initializeUserAccountAndDepositCollateral(amount, userTokenAccount, marketIndex = 0, subAccountId = 0, name, fromSubAccountId, referrerInfo, donateAmount, txParams, customMaxMarginRatio) {
+    async createInitializeUserAccountAndDepositCollateral(amount, userTokenAccount, marketIndex = 0, subAccountId = 0, name, fromSubAccountId, referrerInfo, donateAmount, txParams, customMaxMarginRatio) {
         const ixs = [];
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(subAccountId, name, referrerInfo);
-        const additionalSigners = [];
         const spotMarket = this.getSpotMarketAccount(marketIndex);
         const isSolMarket = spotMarket.mint.equals(spotMarkets_1.WRAPPED_SOL_MINT);
         const authority = this.wallet.publicKey;
@@ -1226,6 +1217,24 @@ class DriftClient {
             ixs.push((0, spl_token_1.createCloseAccountInstruction)(wsolTokenAccount, authority, authority, []));
         }
         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
+     */
+    async initializeUserAccountAndDepositCollateral(amount, userTokenAccount, marketIndex = 0, subAccountId = 0, name, fromSubAccountId, referrerInfo, donateAmount, txParams, customMaxMarginRatio) {
+        const [tx, userAccountPublicKey] = await this.createInitializeUserAccountAndDepositCollateral(amount, userTokenAccount, marketIndex, subAccountId, name, fromSubAccountId, referrerInfo, donateAmount, txParams, customMaxMarginRatio);
+        const additionalSigners = [];
         const { txSig, slot } = await this.sendTransaction(tx, additionalSigners, this.opts);
         this.spotMarketLastSlotCache.set(marketIndex, slot);
         await this.addUser(subAccountId);
@@ -3636,9 +3645,7 @@ class DriftClient {
         }
     }
     isVersionedTransaction(tx) {
-        const version = tx === null || tx === void 0 ? void 0 : tx.version;
-        const isVersionedTx = tx instanceof web3_js_1.VersionedTransaction || version !== undefined;
-        return isVersionedTx;
+        return (0, utils_2.isVersionedTransaction)(tx);
     }
     sendTransaction(tx, additionalSigners, opts, preSigned) {
         const isVersionedTx = this.isVersionedTransaction(tx);

package/lib/driftClientConfig.d.ts

@@ -4,7 +4,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;
     wallet: IWallet;
@@ -28,6 +28,7 @@ export type DriftClientConfig = {
     txVersion?: TransactionVersion;
     txParams?: TxParams;
     enableMetricsEvents?: boolean;
+    txHandlerConfig?: TxHandlerConfig;
 };
 export type DriftClientSubscriptionConfig = {
     type: 'websocket';

package/lib/tx/blockhashFetcher/baseBlockhashFetcher.d.ts

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

package/lib/tx/blockhashFetcher/baseBlockhashFetcher.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseBlockhashFetcher = void 0;
+class BaseBlockhashFetcher {
+    constructor(connection, blockhashCommitment) {
+        this.connection = connection;
+        this.blockhashCommitment = blockhashCommitment;
+    }
+    async getLatestBlockhash() {
+        return this.connection.getLatestBlockhash(this.blockhashCommitment);
+    }
+}
+exports.BaseBlockhashFetcher = BaseBlockhashFetcher;

package/lib/tx/blockhashFetcher/cachedBlockhashFetcher.d.ts

@@ -0,0 +1,28 @@
+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 declare class CachedBlockhashFetcher implements BlockhashFetcher {
+    private connection;
+    private blockhashCommitment;
+    private retryCount;
+    private retrySleepTimeMs;
+    private staleCacheTimeMs;
+    private recentBlockhashCache;
+    private blockhashFetchingPromise;
+    constructor(connection: Connection, blockhashCommitment: Commitment, retryCount: number, retrySleepTimeMs: number, staleCacheTimeMs: number);
+    private fetchBlockhashWithRetry;
+    private sleep;
+    private updateBlockhashCache;
+    getLatestBlockhash(): Promise<BlockhashWithExpiryBlockHeight | undefined>;
+    private isCacheStale;
+    /**
+     * Refresh the blockhash cache, await a pending refresh if it exists
+     */
+    private refreshBlockhash;
+}

package/lib/tx/blockhashFetcher/cachedBlockhashFetcher.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedBlockhashFetcher = void 0;
+/**
+ * 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
+ */
+class CachedBlockhashFetcher {
+    constructor(connection, blockhashCommitment, retryCount, retrySleepTimeMs, staleCacheTimeMs) {
+        this.connection = connection;
+        this.blockhashCommitment = blockhashCommitment;
+        this.retryCount = retryCount;
+        this.retrySleepTimeMs = retrySleepTimeMs;
+        this.staleCacheTimeMs = staleCacheTimeMs;
+        this.recentBlockhashCache = { value: undefined, lastUpdated: 0 };
+        this.blockhashFetchingPromise = null;
+    }
+    async fetchBlockhashWithRetry() {
+        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');
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async updateBlockhashCache() {
+        const result = await this.fetchBlockhashWithRetry();
+        this.recentBlockhashCache = {
+            value: result,
+            lastUpdated: Date.now(),
+        };
+    }
+    async getLatestBlockhash() {
+        if (this.isCacheStale()) {
+            await this.refreshBlockhash();
+        }
+        return this.recentBlockhashCache.value;
+    }
+    isCacheStale() {
+        const lastUpdateTime = this.recentBlockhashCache.lastUpdated;
+        return (!lastUpdateTime || Date.now() > lastUpdateTime + this.staleCacheTimeMs);
+    }
+    /**
+     * Refresh the blockhash cache, await a pending refresh if it exists
+     */
+    async refreshBlockhash() {
+        if (!this.blockhashFetchingPromise) {
+            this.blockhashFetchingPromise = this.updateBlockhashCache();
+            try {
+                await this.blockhashFetchingPromise;
+            }
+            finally {
+                this.blockhashFetchingPromise = null;
+            }
+        }
+        else {
+            await this.blockhashFetchingPromise;
+        }
+    }
+}
+exports.CachedBlockhashFetcher = CachedBlockhashFetcher;

package/lib/tx/blockhashFetcher/types.d.ts

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

package/lib/tx/blockhashFetcher/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/tx/txHandler.d.ts

@@ -13,6 +13,14 @@ export type TxBuildingProps = {
     recentBlockhash?: BlockhashWithExpiryBlockHeight;
     wallet?: IWallet;
 };
+export type TxHandlerConfig = {
+    blockhashCachingEnabled?: boolean;
+    blockhashCachingConfig?: {
+        retryCount: number;
+        retrySleepTimeMs: number;
+        staleCacheTimeMs: number;
+    };
+};
 /**
  * This class is responsible for creating and signing transactions.
  */
@@ -25,6 +33,7 @@ export declare class TxHandler {
     private preSignedCb?;
     private onSignedCb?;
     private blockhashCommitment;
+    private blockHashFetcher;
     constructor(props: {
         connection: Connection;
         wallet: IWallet;
@@ -34,6 +43,7 @@ export declare class TxHandler {
             onSignedCb?: (txSigs: DriftClientMetricsEvents['txSigned']) => void;
             preSignedCb?: () => void;
         };
+        config?: TxHandlerConfig;
     });
     private addHashAndExpiryToLookup;
     private getProps;

package/lib/tx/txHandler.js

@@ -8,6 +8,9 @@ const web3_js_1 = require("@solana/web3.js");
 const txParamProcessor_1 = require("./txParamProcessor");
 const bs58_1 = __importDefault(require("bs58"));
 const computeUnits_1 = require("../util/computeUnits");
+const cachedBlockhashFetcher_1 = require("./blockhashFetcher/cachedBlockhashFetcher");
+const baseBlockhashFetcher_1 = require("./blockhashFetcher/baseBlockhashFetcher");
+const utils_1 = require("./utils");
 /**
  * Explanation for SIGNATURE_BLOCK_AND_EXPIRY:
  *
@@ -15,12 +18,15 @@ const computeUnits_1 = require("../util/computeUnits");
  */
 const DEV_TRY_FORCE_TX_TIMEOUTS = process.env.DEV_TRY_FORCE_TX_TIMEOUTS === 'true' || false;
 exports.COMPUTE_UNITS_DEFAULT = 200000;
+const BLOCKHASH_FETCH_RETRY_COUNT = 3;
+const BLOCKHASH_FETCH_RETRY_SLEEP = 200;
+const RECENT_BLOCKHASH_STALE_TIME_MS = 2000; // Reuse blockhashes within this timeframe during bursts of tx contruction
 /**
  * This class is responsible for creating and signing transactions.
  */
 class TxHandler {
     constructor(props) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
         this.blockHashToLastValidBlockHeightLookup = {};
         this.returnBlockHeightsWithSignedTxCallbackData = false;
         this.blockhashCommitment = 'finalized';
@@ -28,11 +34,14 @@ class TxHandler {
         this.connection = props.connection;
         this.wallet = props.wallet;
         this.confirmationOptions = props.confirmationOptions;
+        this.blockHashFetcher = ((_a = props === null || props === void 0 ? void 0 : props.config) === null || _a === void 0 ? void 0 : _a.blockhashCachingEnabled)
+            ? new cachedBlockhashFetcher_1.CachedBlockhashFetcher(this.connection, this.blockhashCommitment, (_d = (_c = (_b = props === null || props === void 0 ? void 0 : props.config) === null || _b === void 0 ? void 0 : _b.blockhashCachingConfig) === null || _c === void 0 ? void 0 : _c.retryCount) !== null && _d !== void 0 ? _d : BLOCKHASH_FETCH_RETRY_COUNT, (_g = (_f = (_e = props === null || props === void 0 ? void 0 : props.config) === null || _e === void 0 ? void 0 : _e.blockhashCachingConfig) === null || _f === void 0 ? void 0 : _f.retrySleepTimeMs) !== null && _g !== void 0 ? _g : BLOCKHASH_FETCH_RETRY_SLEEP, (_k = (_j = (_h = props === null || props === void 0 ? void 0 : props.config) === null || _h === void 0 ? void 0 : _h.blockhashCachingConfig) === null || _j === void 0 ? void 0 : _j.staleCacheTimeMs) !== null && _k !== void 0 ? _k : RECENT_BLOCKHASH_STALE_TIME_MS)
+            : new baseBlockhashFetcher_1.BaseBlockhashFetcher(this.connection, this.blockhashCommitment);
         // #Optionals
         this.returnBlockHeightsWithSignedTxCallbackData =
-            (_b = (_a = props.opts) === null || _a === void 0 ? void 0 : _a.returnBlockHeightsWithSignedTxCallbackData) !== null && _b !== void 0 ? _b : false;
-        this.onSignedCb = (_c = props.opts) === null || _c === void 0 ? void 0 : _c.onSignedCb;
-        this.preSignedCb = (_d = props.opts) === null || _d === void 0 ? void 0 : _d.preSignedCb;
+            (_m = (_l = props.opts) === null || _l === void 0 ? void 0 : _l.returnBlockHeightsWithSignedTxCallbackData) !== null && _m !== void 0 ? _m : false;
+        this.onSignedCb = (_o = props.opts) === null || _o === void 0 ? void 0 : _o.onSignedCb;
+        this.preSignedCb = (_p = props.opts) === null || _p === void 0 ? void 0 : _p.preSignedCb;
     }
     addHashAndExpiryToLookup(hashAndExpiry) {
         if (!this.returnBlockHeightsWithSignedTxCallbackData)
@@ -50,8 +59,8 @@ class TxHandler {
      *
      * @returns
      */
-    getLatestBlockhashForTransaction() {
-        return this.connection.getLatestBlockhash(this.blockhashCommitment);
+    async getLatestBlockhashForTransaction() {
+        return this.blockHashFetcher.getLatestBlockhash();
     }
     /**
      * Applies recent blockhash and signs a given transaction
@@ -80,7 +89,7 @@ class TxHandler {
         return signedTx;
     }
     isVersionedTransaction(tx) {
-        return (tx === null || tx === void 0 ? void 0 : tx.message) && true;
+        return (0, utils_1.isVersionedTransaction)(tx);
     }
     isLegacyTransaction(tx) {
         return !this.isVersionedTransaction(tx);

package/lib/tx/utils.d.ts

@@ -0,0 +1,2 @@
+import { Transaction, VersionedTransaction } from '@solana/web3.js';
+export declare const isVersionedTransaction: (tx: Transaction | VersionedTransaction) => boolean;

package/lib/tx/utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVersionedTransaction = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const isVersionedTransaction = (tx) => {
+    const version = tx === null || tx === void 0 ? void 0 : tx.version;
+    const isVersionedTx = tx instanceof web3_js_1.VersionedTransaction || version !== undefined;
+    return isVersionedTx;
+};
+exports.isVersionedTransaction = isVersionedTransaction;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.85.0-beta.10",
+	"version": "2.85.0-beta.11",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",
@@ -65,6 +65,7 @@
 		"mocha": "^10.0.0",
 		"object-sizeof": "^2.6.3",
 		"prettier": "3.0.1",
+		"sinon": "^18.0.0",
 		"ts-node": "^10.8.0",
 		"typescript": "^4.9.5"
 	},

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,
@@ -6863,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/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>;
+}

package/src/tx/txHandler.ts

@@ -25,6 +25,10 @@ import {
 	TxParams,
 } from '../types';
 import { containsComputeUnitIxs } from '../util/computeUnits';
+import { CachedBlockhashFetcher } from './blockhashFetcher/cachedBlockhashFetcher';
+import { BaseBlockhashFetcher } from './blockhashFetcher/baseBlockhashFetcher';
+import { BlockhashFetcher } from './blockhashFetcher/types';
+import { isVersionedTransaction } from './utils';
 
 /**
  * Explanation for SIGNATURE_BLOCK_AND_EXPIRY:
@@ -37,6 +41,10 @@ const DEV_TRY_FORCE_TX_TIMEOUTS =
 
 export const COMPUTE_UNITS_DEFAULT = 200_000;
 
+const BLOCKHASH_FETCH_RETRY_COUNT = 3;
+const BLOCKHASH_FETCH_RETRY_SLEEP = 200;
+const RECENT_BLOCKHASH_STALE_TIME_MS = 2_000; // Reuse blockhashes within this timeframe during bursts of tx contruction
+
 export type TxBuildingProps = {
 	instructions: TransactionInstruction | TransactionInstruction[];
 	txVersion: TransactionVersion;
@@ -50,6 +58,15 @@ export type TxBuildingProps = {
 	wallet?: IWallet;
 };
 
+export type TxHandlerConfig = {
+	blockhashCachingEnabled?: boolean;
+	blockhashCachingConfig?: {
+		retryCount: number;
+		retrySleepTimeMs: number;
+		staleCacheTimeMs: number;
+	};
+};
+
 /**
  * This class is responsible for creating and signing transactions.
  */
@@ -65,6 +82,7 @@ export class TxHandler {
 	private onSignedCb?: (txSigs: DriftClientMetricsEvents['txSigned']) => void;
 
 	private blockhashCommitment: Commitment = 'finalized';
+	private blockHashFetcher: BlockhashFetcher;
 
 	constructor(props: {
 		connection: Connection;
@@ -75,11 +93,25 @@ export class TxHandler {
 			onSignedCb?: (txSigs: DriftClientMetricsEvents['txSigned']) => void;
 			preSignedCb?: () => void;
 		};
+		config?: TxHandlerConfig;
 	}) {
 		this.connection = props.connection;
 		this.wallet = props.wallet;
 		this.confirmationOptions = props.confirmationOptions;
 
+		this.blockHashFetcher = props?.config?.blockhashCachingEnabled
+			? new CachedBlockhashFetcher(
+					this.connection,
+					this.blockhashCommitment,
+					props?.config?.blockhashCachingConfig?.retryCount ??
+						BLOCKHASH_FETCH_RETRY_COUNT,
+					props?.config?.blockhashCachingConfig?.retrySleepTimeMs ??
+						BLOCKHASH_FETCH_RETRY_SLEEP,
+					props?.config?.blockhashCachingConfig?.staleCacheTimeMs ??
+						RECENT_BLOCKHASH_STALE_TIME_MS
+			  )
+			: new BaseBlockhashFetcher(this.connection, this.blockhashCommitment);
+
 		// #Optionals
 		this.returnBlockHeightsWithSignedTxCallbackData =
 			props.opts?.returnBlockHeightsWithSignedTxCallbackData ?? false;
@@ -113,8 +145,8 @@ export class TxHandler {
 	 *
 	 * @returns
 	 */
-	public getLatestBlockhashForTransaction() {
-		return this.connection.getLatestBlockhash(this.blockhashCommitment);
+	public async getLatestBlockhashForTransaction() {
+		return this.blockHashFetcher.getLatestBlockhash();
 	}
 
 	/**
@@ -157,8 +189,10 @@ export class TxHandler {
 		return signedTx;
 	}
 
-	private isVersionedTransaction(tx: Transaction | VersionedTransaction) {
-		return (tx as VersionedTransaction)?.message && true;
+	private isVersionedTransaction(
+		tx: Transaction | VersionedTransaction
+	): boolean {
+		return isVersionedTransaction(tx);
 	}
 
 	private isLegacyTransaction(tx: Transaction | VersionedTransaction) {

package/src/tx/utils.ts

@@ -0,0 +1,11 @@
+import { Transaction, VersionedTransaction } from '@solana/web3.js';
+
+export const isVersionedTransaction = (
+	tx: Transaction | VersionedTransaction
+): boolean => {
+	const version = (tx as VersionedTransaction)?.version;
+	const isVersionedTx =
+		tx instanceof VersionedTransaction || version !== undefined;
+
+	return isVersionedTx;
+};

package/tests/tx/cachedBlockhashFetcher.test.ts

@@ -0,0 +1,96 @@
+import { expect } from 'chai';
+import sinon from 'sinon';
+import {
+	Connection,
+	Commitment,
+	BlockhashWithExpiryBlockHeight,
+} from '@solana/web3.js';
+import { CachedBlockhashFetcher } from '../../src/tx/blockhashFetcher/cachedBlockhashFetcher';
+
+describe('CachedBlockhashFetcher', () => {
+	let connection: sinon.SinonStubbedInstance<Connection>;
+	let cachedBlockhashFetcher: CachedBlockhashFetcher;
+	const mockBlockhash: BlockhashWithExpiryBlockHeight = {
+		blockhash: 'mockedBlockhash',
+		lastValidBlockHeight: 1000,
+	};
+
+	beforeEach(() => {
+		connection = sinon.createStubInstance(Connection);
+		connection.getLatestBlockhash.resolves(mockBlockhash);
+
+		cachedBlockhashFetcher = new CachedBlockhashFetcher(
+			connection as unknown as Connection,
+			'confirmed' as Commitment,
+			3,
+			100,
+			1000
+		);
+	});
+
+	afterEach(() => {
+		sinon.restore();
+	});
+
+	it('should fetch and cache the latest blockhash', async () => {
+		const result = await cachedBlockhashFetcher.getLatestBlockhash();
+		expect(result).to.deep.equal(mockBlockhash);
+		expect(connection.getLatestBlockhash.calledOnce).to.be.true;
+	});
+
+	it('should use cached blockhash if not stale', async () => {
+		await cachedBlockhashFetcher.getLatestBlockhash();
+		await cachedBlockhashFetcher.getLatestBlockhash();
+		expect(connection.getLatestBlockhash.calledOnce).to.be.true;
+	});
+
+	it('should refresh blockhash if cache is stale', async () => {
+		const clock = sinon.useFakeTimers();
+
+		await cachedBlockhashFetcher.getLatestBlockhash();
+
+		// Advance time to make cache stale
+		clock.tick(1100);
+
+		await cachedBlockhashFetcher.getLatestBlockhash();
+		expect(connection.getLatestBlockhash.calledTwice).to.be.true;
+
+		clock.restore();
+	});
+
+	it('should retry on failure', async () => {
+		connection.getLatestBlockhash
+			.onFirstCall()
+			.rejects(new Error('Network error'))
+			.onSecondCall()
+			.rejects(new Error('Network error'))
+			.onThirdCall()
+			.resolves(mockBlockhash);
+
+		const result = await cachedBlockhashFetcher.getLatestBlockhash();
+		expect(result).to.deep.equal(mockBlockhash);
+		expect(connection.getLatestBlockhash.calledThrice).to.be.true;
+	});
+
+	it('should throw error after maximum retries', async () => {
+		connection.getLatestBlockhash.rejects(new Error('Network error'));
+
+		try {
+			await cachedBlockhashFetcher.getLatestBlockhash();
+			expect.fail('Should have thrown an error');
+		} catch (error) {
+			expect(error.message).to.equal(
+				'Failed to fetch blockhash after maximum retries'
+			);
+		}
+		expect(connection.getLatestBlockhash.calledThrice).to.be.true;
+	});
+
+	it('should prevent concurrent requests for the same blockhash', async () => {
+		const promise1 = cachedBlockhashFetcher.getLatestBlockhash();
+		const promise2 = cachedBlockhashFetcher.getLatestBlockhash();
+
+		await Promise.all([promise1, promise2]);
+		expect(connection.getLatestBlockhash.calledOnce).to.be.true;
+	});
+});