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

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);
@@ -2267,6 +2276,9 @@ class DriftClient {
     async getJupiterSwapIxV6({ jupiterClient, outMarketIndex, inMarketIndex, outAssociatedTokenAccount, inAssociatedTokenAccount, amount, slippageBps, swapMode, onlyDirectRoutes, quote, reduceOnly, userAccountPublicKey, }) {
         const outMarket = this.getSpotMarketAccount(outMarketIndex);
         const inMarket = this.getSpotMarketAccount(inMarketIndex);
+        const isExactOut = swapMode === 'ExactOut' || quote.swapMode === 'ExactOut';
+        const amountIn = new anchor_1.BN(quote.inAmount);
+        const exactOutBufferedAmountIn = amountIn.muln(1001).divn(1000); // Add 10bp buffer
         if (!quote) {
             const fetchedQuote = await jupiterClient.getQuote({
                 inputMint: inMarket.mint,
@@ -2312,7 +2324,7 @@ class DriftClient {
         const { beginSwapIx, endSwapIx } = await this.getSwapIx({
             outMarketIndex,
             inMarketIndex,
-            amountIn: new anchor_1.BN(quote.inAmount),
+            amountIn: isExactOut ? exactOutBufferedAmountIn : amountIn,
             inTokenAccount: inAssociatedTokenAccount,
             outTokenAccount: outAssociatedTokenAccount,
             reduceOnly,
@@ -2544,7 +2556,7 @@ class DriftClient {
             };
             if (shouldUseSimulationComputeUnits || shouldExitIfSimulationFails) {
                 const placeAndTakeTxToSim = (await this.buildTransaction(placeAndTakeIxs, txParams, undefined, undefined, true, recentBlockHash));
-                const simulationResult = await txParamProcessor_1.TransactionParamProcessor.getTxSimComputeUnits(placeAndTakeTxToSim, this.connection, (_a = txParams.computeUnitsBufferMultiplier) !== null && _a !== void 0 ? _a : 1.2);
+                const simulationResult = await txParamProcessor_1.TransactionParamProcessor.getTxSimComputeUnits(placeAndTakeTxToSim, this.connection, (_a = txParams.computeUnitsBufferMultiplier) !== null && _a !== void 0 ? _a : 1.2, txParams.lowerBoundCu);
                 if (shouldExitIfSimulationFails && !simulationResult.success) {
                     earlyExitFailedPlaceAndTakeSim = true;
                     return;
@@ -2586,6 +2598,9 @@ class DriftClient {
     }
     async placeAndTakePerpWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams = new Array(), txParams, subAccountId, cancelExistingOrders, settlePnl, exitEarlyIfSimFails) {
         const txsToSign = await this.preparePlaceAndTakePerpOrderWithAdditionalOrders(orderParams, makerInfo, referrerInfo, bracketOrdersParams, txParams, subAccountId, cancelExistingOrders, settlePnl, exitEarlyIfSimFails);
+        if (!txsToSign) {
+            return null;
+        }
         const signedTxs = (await this.txHandler.getSignedTransactionMap(txsToSign, this.provider.wallet)).signedTxMap;
         const { txSig, slot } = await this.sendTransaction(signedTxs.placeAndTakeTx, [], this.opts, true);
         this.perpMarketLastSlotCache.set(orderParams.marketIndex, slot);
@@ -3630,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/events/eventSubscriber.js

@@ -24,10 +24,14 @@ class EventSubscriber {
         this.eventListMap = new Map();
         this.eventEmitter = new events_1.EventEmitter();
         if (this.options.logProviderConfig.type === 'websocket') {
-            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(this.connection, this.address, this.options.commitment, this.options.logProviderConfig.resubTimeoutMs);
+            this.logProvider = new webSocketLogProvider_1.WebSocketLogProvider(
+            // @ts-ignore
+            this.connection, this.address, this.options.commitment, this.options.logProviderConfig.resubTimeoutMs);
         }
         else {
-            this.logProvider = new pollingLogProvider_1.PollingLogProvider(this.connection, this.address, options.commitment, this.options.logProviderConfig.frequency, this.options.logProviderConfig.batchSize);
+            this.logProvider = new pollingLogProvider_1.PollingLogProvider(
+            // @ts-ignore
+            this.connection, this.address, options.commitment, this.options.logProviderConfig.frequency, this.options.logProviderConfig.batchSize);
         }
     }
     populateInitialEventListMap() {
@@ -52,7 +56,9 @@ class EventSubscriber {
                                 console.log('Failing over to polling');
                                 this.logProvider.eventEmitter.removeAllListeners('reconnect');
                                 this.unsubscribe().then(() => {
-                                    this.logProvider = new pollingLogProvider_1.PollingLogProvider(this.connection, this.address, this.options.commitment, logProviderConfig.fallbackFrequency, logProviderConfig.fallbackBatchSize);
+                                    this.logProvider = new pollingLogProvider_1.PollingLogProvider(
+                                    // @ts-ignore
+                                    this.connection, this.address, this.options.commitment, logProviderConfig.fallbackFrequency, logProviderConfig.fallbackBatchSize);
                                     this.logProvider.subscribe((txSig, slot, logs, mostRecentBlockTime) => {
                                         this.handleTxLogs(txSig, slot, logs, mostRecentBlockTime);
                                     }, true);
@@ -108,7 +114,9 @@ class EventSubscriber {
         let beforeTx = undefined;
         const untilTx = this.options.untilTx;
         while (txFetched < this.options.maxTx) {
-            const response = await (0, fetchLogs_1.fetchLogs)(this.connection, this.address, this.options.commitment === 'finalized' ? 'finalized' : 'confirmed', beforeTx, untilTx);
+            const response = await (0, fetchLogs_1.fetchLogs)(
+            // @ts-ignore
+            this.connection, this.address, this.options.commitment === 'finalized' ? 'finalized' : 'confirmed', beforeTx, untilTx);
             if (response === undefined) {
                 break;
             }

package/lib/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/lib/testClient.js

@@ -8,12 +8,11 @@ class TestClient extends adminClient_1.AdminClient {
             throw new Error('Test client must be polling');
         }
         super(config);
-        // @ts-ignore
-        this.txHandler.blockhashCommitment = 'recent';
     }
     async sendTransaction(tx, additionalSigners, opts, preSigned) {
         const { txSig, slot } = await super.sendTransaction(tx, additionalSigners, opts, preSigned);
         let lastFetchedSlot = this.accountSubscriber.accountLoader.mostRecentSlot;
+        await this.fetchAccounts();
         while (lastFetchedSlot < slot) {
             await this.fetchAccounts();
             lastFetchedSlot = this.accountSubscriber.accountLoader.mostRecentSlot;

package/lib/tokenFaucet.d.ts

@@ -5,14 +5,16 @@ import { Account } from '@solana/spl-token';
 import { ConfirmOptions, Connection, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
 import { BN } from '.';
 import { IWallet } from './types';
+import { BankrunContextWrapper } from './bankrun/bankrunConnection';
 export declare class TokenFaucet {
+    context?: BankrunContextWrapper;
     connection: Connection;
     wallet: IWallet;
     program: Program;
     provider: AnchorProvider;
     mint: PublicKey;
     opts?: ConfirmOptions;
-    constructor(connection: Connection, wallet: IWallet, programId: PublicKey, mint: PublicKey, opts?: ConfirmOptions);
+    constructor(connection: Connection, wallet: IWallet, programId: PublicKey, mint: PublicKey, opts?: ConfirmOptions, context?: BankrunContextWrapper);
     getFaucetConfigPublicKeyAndNonce(): Promise<[
         PublicKey,
         number

package/lib/tokenFaucet.js

@@ -33,12 +33,15 @@ const spl_token_1 = require("@solana/spl-token");
 const web3_js_1 = require("@solana/web3.js");
 const token_faucet_json_1 = __importDefault(require("./idl/token_faucet.json"));
 class TokenFaucet {
-    constructor(connection, wallet, programId, mint, opts) {
+    constructor(connection, wallet, programId, mint, opts, context) {
         this.connection = connection;
+        this.context = context;
         this.wallet = wallet;
         this.opts = opts || anchor_1.AnchorProvider.defaultOptions();
         // @ts-ignore
-        const provider = new anchor_1.AnchorProvider(connection, wallet, this.opts);
+        const provider = new anchor_1.AnchorProvider(context ? context.connection.toConnection() : this.connection, 
+        // @ts-ignore
+        wallet, this.opts);
         this.provider = provider;
         this.program = new anchor_1.Program(token_faucet_json_1.default, programId, provider);
         this.mint = mint;
@@ -60,7 +63,7 @@ class TokenFaucet {
     }
     async initialize() {
         const [faucetConfigPublicKey] = await this.getFaucetConfigPublicKeyAndNonce();
-        return await this.program.rpc.initialize({
+        const ix = this.program.instruction.initialize({
             accounts: {
                 faucetConfig: faucetConfigPublicKey,
                 admin: this.wallet.publicKey,
@@ -70,6 +73,9 @@ class TokenFaucet {
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
         });
+        const tx = new web3_js_1.Transaction().add(ix);
+        const txSig = await this.context.sendTransaction(tx);
+        return txSig;
     }
     async fetchState() {
         return await this.program.account.faucetConfig.fetch(await this.getFaucetConfigPublicKey());
@@ -88,10 +94,28 @@ class TokenFaucet {
     async mintToUser(userTokenAccount, amount) {
         const mintIx = await this.mintToUserIx(userTokenAccount, amount);
         const tx = new web3_js_1.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);
+        }
     }
     async transferMintAuthority() {
+        if (this.context) {
+            const ix = this.program.instruction.transferMintAuthority({
+                accounts: {
+                    faucetConfig: await this.getFaucetConfigPublicKey(),
+                    mintAccount: this.mint,
+                    mintAuthority: await this.getMintAuthority(),
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                    admin: this.wallet.publicKey,
+                },
+            });
+            const tx = new web3_js_1.Transaction().add(ix);
+            const txSig = await this.context.sendTransaction(tx);
+            return txSig;
+        }
         return await this.program.rpc.transferMintAuthority({
             accounts: {
                 faucetConfig: await this.getFaucetConfigPublicKey(),
@@ -107,7 +131,7 @@ class TokenFaucet {
         const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] = await this.createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount);
         let associatedTokenAccountExists = false;
         try {
-            const assosciatedTokenAccount = await this.connection.getAccountInfo(associatedTokenPublicKey);
+            const assosciatedTokenAccount = await this.context.connection.getAccountInfo(associatedTokenPublicKey);
             associatedTokenAccountExists = !!assosciatedTokenAccount;
         }
         catch (e) {
@@ -118,7 +142,13 @@ class TokenFaucet {
         if (!skipAccountCreation)
             tx.add(createAssociatedAccountIx);
         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];
     }
     async createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount) {
@@ -134,6 +164,9 @@ class TokenFaucet {
     }
     async getTokenAccountInfo(props) {
         const associatedKey = await this.getAssosciatedMockUSDMintAddress(props);
+        if (this.context) {
+            return await this.context.connection.getTokenAccount(associatedKey);
+        }
         return await (0, spl_token_1.getAccount)(this.connection, associatedKey);
     }
     async subscribeToTokenAccount(props) {
@@ -141,7 +174,7 @@ class TokenFaucet {
             const tokenAccountKey = await this.getAssosciatedMockUSDMintAddress(props);
             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(tokenAccountKey, async (_accountInfo /* accountInfo is a buffer which we don't know how to deserialize */) => {
+            this.context.connection.onAccountChange(tokenAccountKey, async (_accountInfo /* accountInfo is a buffer which we don't know how to deserialize */) => {
                 props.callback(await this.getTokenAccountInfo(props));
             });
             return true;

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);