@drift-labs/sdk 2.77.0-beta.0 → 2.77.0-beta.1

package/VERSION

@@ -1 +1 @@
-2.77.0-beta.0
+2.77.0-beta.1

package/lib/driftClient.d.ts

@@ -112,7 +112,8 @@ export declare class DriftClient {
      * Adds and subscribes to users based on params set by the constructor or by updateWallet.
      */
     addAndSubscribeToUsers(): Promise<boolean>;
-    initializeUserAccount(subAccountId?: number, name?: string, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
+    private getProcessedTransactionParams;
+    initializeUserAccount(subAccountId?: number, name?: string, referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<[TransactionSignature, PublicKey]>;
     getInitializeUserInstructions(subAccountId?: number, name?: string, referrerInfo?: ReferrerInfo): Promise<[PublicKey, TransactionInstruction]>;
     getInitializeUserStatsIx(): Promise<TransactionInstruction>;
     getNextSubAccountId(): Promise<number>;
@@ -249,7 +250,7 @@ export declare class DriftClient {
      * @returns
      */
     initializeUserAccountAndDepositCollateral(amount: BN, userTokenAccount: PublicKey, marketIndex?: number, subAccountId?: number, name?: string, fromSubAccountId?: number, referrerInfo?: ReferrerInfo, donateAmount?: BN, txParams?: TxParams, customMaxMarginRatio?: number): Promise<[TransactionSignature, PublicKey]>;
-    initializeUserAccountForDevnet(subAccountId: number, name: string, marketIndex: number, tokenFaucet: TokenFaucet, amount: BN, referrerInfo?: ReferrerInfo): Promise<[TransactionSignature, PublicKey]>;
+    initializeUserAccountForDevnet(subAccountId: number, name: string, marketIndex: number, tokenFaucet: TokenFaucet, amount: BN, referrerInfo?: ReferrerInfo, txParams?: TxParams): Promise<[TransactionSignature, PublicKey]>;
     /**
      * Withdraws from a user account. If deposit doesn't already exist, creates a borrow
      * @param amount
@@ -661,6 +662,15 @@ export declare class DriftClient {
     } | undefined;
     private handleSignedTransaction;
     sendTransaction(tx: Transaction | VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
-    buildTransaction(instructions: TransactionInstruction | TransactionInstruction[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[]): Promise<Transaction | VersionedTransaction>;
+    /**
+     *
+     * @param instructions
+     * @param txParams
+     * @param txVersion
+     * @param lookupTables
+     * @param forceVersionedTransaction Return a VersionedTransaction instance even if the version of the transaction is Legacy
+     * @returns
+     */
+    buildTransaction(instructions: TransactionInstruction | TransactionInstruction[], txParams?: TxParams, txVersion?: TransactionVersion, lookupTables?: AddressLookupTableAccount[], forceVersionedTransaction?: boolean): Promise<Transaction | VersionedTransaction>;
 }
 export {};

package/lib/driftClient.js

@@ -56,6 +56,7 @@ const memcmp_1 = require("./memcmp");
 const marinade_1 = require("./marinade");
 const orderParams_1 = require("./orderParams");
 const utils_2 = require("./math/utils");
+const txParamProcessor_1 = require("./tx/txParamProcessor");
 /**
  * # 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.
@@ -437,7 +438,23 @@ class DriftClient {
         }
         return result;
     }
-    async initializeUserAccount(subAccountId = 0, name, referrerInfo) {
+    async getProcessedTransactionParams(txParams, txParamProcessingParams) {
+        const tx = await txParamProcessor_1.TransactionProcessor.process({
+            txProps: {
+                instructions: txParams.instructions,
+                txParams: txParams.txParams,
+                txVersion: txParams.txVersion,
+                lookupTables: txParams.lookupTables,
+            },
+            txBuilder: (updatedTxParams) => this.buildTransaction(updatedTxParams.instructions, updatedTxParams === null || updatedTxParams === void 0 ? void 0 : updatedTxParams.txParams, updatedTxParams.txVersion, updatedTxParams.lookupTables, true),
+            processConfig: txParamProcessingParams,
+            processParams: {
+                connection: this.connection,
+            },
+        });
+        return tx;
+    }
+    async initializeUserAccount(subAccountId = 0, name, referrerInfo, txParams) {
         const initializeIxs = [];
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(subAccountId, name, referrerInfo);
         if (subAccountId === 0) {
@@ -446,7 +463,7 @@ class DriftClient {
             }
         }
         initializeIxs.push(initializeUserAccountIx);
-        const tx = await this.buildTransaction(initializeIxs);
+        const tx = await this.buildTransaction(initializeIxs, txParams);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         await this.addUser(subAccountId);
         return [txSig, userAccountPublicKey];
@@ -1147,21 +1164,11 @@ class DriftClient {
      * @returns
      */
     async initializeUserAccountAndDepositCollateral(amount, userTokenAccount, marketIndex = 0, subAccountId = 0, name, fromSubAccountId, referrerInfo, donateAmount, txParams, customMaxMarginRatio) {
-        var _a;
         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);
-        let params = {
-            computeUnits: (_a = txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits) !== null && _a !== void 0 ? _a : 600000,
-        };
-        if (txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice) {
-            params = {
-                ...params,
-                computeUnitsPrice: txParams.computeUnitsPrice,
-            };
-        }
         const authority = this.wallet.publicKey;
         const isFromSubaccount = fromSubAccountId !== null &&
             fromSubAccountId !== undefined &&
@@ -1203,13 +1210,13 @@ class DriftClient {
         if (createWSOLTokenAccount) {
             ixs.push((0, spl_token_1.createCloseAccountInstruction)(wsolTokenAccount, authority, authority, []));
         }
-        const tx = await this.buildTransaction(ixs, params);
+        const tx = await this.buildTransaction(ixs, txParams);
         const { txSig, slot } = await this.sendTransaction(tx, additionalSigners, this.opts);
         this.spotMarketLastSlotCache.set(marketIndex, slot);
         await this.addUser(subAccountId);
         return [txSig, userAccountPublicKey];
     }
-    async initializeUserAccountForDevnet(subAccountId = 0, name = userName_1.DEFAULT_USER_NAME, marketIndex, tokenFaucet, amount, referrerInfo) {
+    async initializeUserAccountForDevnet(subAccountId = 0, name = userName_1.DEFAULT_USER_NAME, marketIndex, tokenFaucet, amount, referrerInfo, txParams) {
         const ixs = [];
         const [associateTokenPublicKey, createAssociatedAccountIx, mintToIx] = await tokenFaucet.createAssociatedTokenAccountAndMintToInstructions(this.wallet.publicKey, amount);
         const [userAccountPublicKey, initializeUserAccountIx] = await this.getInitializeUserInstructions(subAccountId, name, referrerInfo);
@@ -1221,7 +1228,7 @@ class DriftClient {
             }
         }
         ixs.push(initializeUserAccountIx, depositCollateralIx);
-        const tx = await this.buildTransaction(ixs);
+        const tx = await this.buildTransaction(ixs, txParams);
         const { txSig } = await this.sendTransaction(tx, [], this.opts);
         await this.addUser(subAccountId);
         return [txSig, userAccountPublicKey];
@@ -1258,10 +1265,7 @@ class DriftClient {
         if (createWSOLTokenAccount) {
             withdrawIxs.push((0, spl_token_1.createCloseAccountInstruction)(associatedTokenAddress, authority, authority, []));
         }
-        const tx = await this.buildTransaction(withdrawIxs, {
-            ...(txParams !== null && txParams !== void 0 ? txParams : this.txParams),
-            computeUnits: 1400000,
-        });
+        const tx = await this.buildTransaction(withdrawIxs, txParams !== null && txParams !== void 0 ? txParams : this.txParams);
         const { txSig, slot } = await this.sendTransaction(tx, additionalSigners, this.opts);
         this.spotMarketLastSlotCache.set(marketIndex, slot);
         return txSig;
@@ -2512,12 +2516,26 @@ class DriftClient {
             const bracketOrdersIx = await this.getPlaceOrdersIx(bracketOrdersParams, subAccountId);
             ixs.push(bracketOrdersIx);
         }
-        const placeAndTakeTx = (await this.buildTransaction(ixs, txParams));
-        // if param is passed, return early before the tx fails so ui can fallback to placeOrder
-        if (simulateFirst) {
-            const success = await this.txSender.simulateTransaction(placeAndTakeTx);
-            if (!success)
+        const shouldUseSimulationComputeUnits = txParams === null || txParams === void 0 ? void 0 : txParams.useSimulatedComputeUnits;
+        const shouldExitIfSimulationFails = simulateFirst;
+        const txParamsWithoutImplicitSimulation = {
+            ...txParams,
+            useSimulationComputeUnits: false,
+        };
+        let placeAndTakeTx = await this.buildTransaction(ixs, txParamsWithoutImplicitSimulation);
+        if (shouldUseSimulationComputeUnits || shouldExitIfSimulationFails) {
+            const simulationResult = await txParamProcessor_1.TransactionProcessor.getTxSimComputeUnits(
+            // @ts-ignore :: TODO - TEST WITH LEGACY TRANSACTION
+            placeAndTakeTx, this.connection);
+            if (shouldExitIfSimulationFails && !simulationResult.success) {
                 return;
+            }
+            if (shouldUseSimulationComputeUnits) {
+                placeAndTakeTx = await this.buildTransaction(ixs, {
+                    ...txParamsWithoutImplicitSimulation,
+                    computeUnits: simulationResult.computeUnits,
+                });
+            }
         }
         let cancelExistingOrdersTx;
         if (cancelExistingOrders && (0, types_1.isVariant)(orderParams.marketType, 'perp')) {
@@ -3506,23 +3524,63 @@ class DriftClient {
                 onSignedCb: this.handleSignedTransaction.bind(this),
             }
             : undefined;
-        if (tx instanceof web3_js_1.VersionedTransaction) {
+        const version = tx === null || tx === void 0 ? void 0 : tx.version;
+        const isVersionedTx = tx instanceof web3_js_1.VersionedTransaction || version !== undefined;
+        if (isVersionedTx) {
             return this.txSender.sendVersionedTransaction(tx, additionalSigners, opts, preSigned, extraConfirmationOptions);
         }
         else {
             return this.txSender.send(tx, additionalSigners, opts, preSigned, extraConfirmationOptions);
         }
     }
-    async buildTransaction(instructions, txParams, txVersion, lookupTables) {
+    /**
+     *
+     * @param instructions
+     * @param txParams
+     * @param txVersion
+     * @param lookupTables
+     * @param forceVersionedTransaction Return a VersionedTransaction instance even if the version of the transaction is Legacy
+     * @returns
+     */
+    async buildTransaction(instructions, txParams, txVersion, lookupTables, forceVersionedTransaction) {
         var _a, _b;
+        txVersion = txVersion !== null && txVersion !== void 0 ? txVersion : this.txVersion;
+        // # Collect and process Tx Params
+        let baseTxParams = {
+            computeUnits: (_a = txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits) !== null && _a !== void 0 ? _a : this.txParams.computeUnits,
+            computeUnitsPrice: (_b = txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice) !== null && _b !== void 0 ? _b : this.txParams.computeUnitsPrice,
+        };
+        if (txParams === null || txParams === void 0 ? void 0 : txParams.useSimulatedComputeUnits) {
+            const splitTxParams = {
+                baseTxParams: {
+                    computeUnits: txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits,
+                    computeUnitsPrice: txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice,
+                },
+                txParamProcessingParams: {
+                    useSimulatedComputeUnits: txParams === null || txParams === void 0 ? void 0 : txParams.useSimulatedComputeUnits,
+                    computeUnitsBufferMultiplier: txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsBufferMultiplier,
+                },
+            };
+            const processedTxParams = await this.getProcessedTransactionParams({
+                instructions,
+                txParams: splitTxParams.baseTxParams,
+                txVersion,
+                lookupTables,
+            }, splitTxParams.txParamProcessingParams);
+            baseTxParams = {
+                ...baseTxParams,
+                ...processedTxParams,
+            };
+        }
+        // # Create Tx Instructions
         const allIx = [];
-        const computeUnits = (_a = txParams === null || txParams === void 0 ? void 0 : txParams.computeUnits) !== null && _a !== void 0 ? _a : this.txParams.computeUnits;
+        const computeUnits = baseTxParams === null || baseTxParams === void 0 ? void 0 : baseTxParams.computeUnits;
         if (computeUnits !== 200000) {
             allIx.push(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({
                 units: computeUnits,
             }));
         }
-        const computeUnitsPrice = (_b = txParams === null || txParams === void 0 ? void 0 : txParams.computeUnitsPrice) !== null && _b !== void 0 ? _b : this.txParams.computeUnitsPrice;
+        const computeUnitsPrice = baseTxParams === null || baseTxParams === void 0 ? void 0 : baseTxParams.computeUnitsPrice;
         if (computeUnitsPrice !== 0) {
             allIx.push(web3_js_1.ComputeBudgetProgram.setComputeUnitPrice({
                 microLamports: computeUnitsPrice,
@@ -3534,9 +3592,22 @@ class DriftClient {
         else {
             allIx.push(instructions);
         }
-        txVersion = txVersion !== null && txVersion !== void 0 ? txVersion : this.txVersion;
+        const latestBlockHashAndContext = await this.connection.getLatestBlockhashAndContext({
+            commitment: this.opts.preflightCommitment,
+        });
+        // # Create and return Transaction
         if (txVersion === 'legacy') {
-            return new web3_js_1.Transaction().add(...allIx);
+            if (forceVersionedTransaction) {
+                const message = new web3_js_1.TransactionMessage({
+                    payerKey: this.provider.wallet.publicKey,
+                    recentBlockhash: latestBlockHashAndContext.value.blockhash,
+                    instructions: allIx,
+                }).compileToLegacyMessage();
+                return new web3_js_1.VersionedTransaction(message);
+            }
+            else {
+                return new web3_js_1.Transaction().add(...allIx);
+            }
         }
         else {
             const marketLookupTable = await this.fetchMarketLookupTableAccount();
@@ -3545,7 +3616,7 @@ class DriftClient {
                 : [marketLookupTable];
             const message = new web3_js_1.TransactionMessage({
                 payerKey: this.provider.wallet.publicKey,
-                recentBlockhash: (await this.provider.connection.getRecentBlockhash(this.opts.preflightCommitment)).blockhash,
+                recentBlockhash: latestBlockHashAndContext.value.blockhash,
                 instructions: allIx,
             }).compileToV0Message(lookupTables);
             return new web3_js_1.VersionedTransaction(message);

package/lib/idl/drift.json

@@ -1,5 +1,5 @@
 {
-    "version": "2.76.0",
+    "version": "2.75.0",
     "name": "drift",
     "instructions": [
         {

package/lib/priorityFee/driftPriorityFeeMethod.d.ts

@@ -1,3 +1,3 @@
 import { HeliusPriorityFeeLevels } from './heliusPriorityFeeMethod';
 export type DriftPriorityFeeResponse = HeliusPriorityFeeLevels[];
-export declare function fetchDriftPriorityFee(url: string, marketType: string, marketIndex: number): Promise<DriftPriorityFeeResponse>;
+export declare function fetchDriftPriorityFee(url: string, marketTypes: string[], marketIndexs: number[]): Promise<DriftPriorityFeeResponse>;

package/lib/priorityFee/driftPriorityFeeMethod.js

@@ -5,8 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchDriftPriorityFee = void 0;
 const node_fetch_1 = __importDefault(require("node-fetch"));
-async function fetchDriftPriorityFee(url, marketType, marketIndex) {
-    const response = await (0, node_fetch_1.default)(`${url}?marketType=${marketType}&marketIndex=${marketIndex}`);
+async function fetchDriftPriorityFee(url, marketTypes, marketIndexs) {
+    const response = await (0, node_fetch_1.default)(`${url}/batchPriorityFees?marketType=${marketTypes.join(',')}&marketIndex=${marketIndexs.join(',')}`);
     return await response.json();
 }
 exports.fetchDriftPriorityFee = fetchDriftPriorityFee;

package/lib/priorityFee/priorityFeeSubscriber.d.ts

@@ -3,7 +3,6 @@ import { PriorityFeeMethod, PriorityFeeStrategy, PriorityFeeSubscriberConfig } f
 import { AverageOverSlotsStrategy } from './averageOverSlotsStrategy';
 import { MaxOverSlotsStrategy } from './maxOverSlotsStrategy';
 import { HeliusPriorityFeeLevels, HeliusPriorityLevel } from './heliusPriorityFeeMethod';
-import { MarketType } from '..';
 export type DriftMarketInfo = {
     marketType: string;
     marketIndex: number;
@@ -12,7 +11,7 @@ export declare class PriorityFeeSubscriber {
     connection: Connection;
     frequencyMs: number;
     addresses: string[];
-    driftMarket?: DriftMarketInfo;
+    driftMarkets?: DriftMarketInfo[];
     customStrategy?: PriorityFeeStrategy;
     averageStrategy: AverageOverSlotsStrategy;
     maxStrategy: MaxOverSlotsStrategy;
@@ -46,5 +45,5 @@ export declare class PriorityFeeSubscriber {
     load(): Promise<void>;
     unsubscribe(): Promise<void>;
     updateAddresses(addresses: PublicKey[]): void;
-    updateMarketTypeAndIndex(marketType: MarketType, marketIndex: number): void;
+    updateMarketTypeAndIndex(driftMarkets: DriftMarketInfo[]): void;
 }

package/lib/priorityFee/priorityFeeSubscriber.js

@@ -7,7 +7,6 @@ const maxOverSlotsStrategy_1 = require("./maxOverSlotsStrategy");
 const solanaPriorityFeeMethod_1 = require("./solanaPriorityFeeMethod");
 const heliusPriorityFeeMethod_1 = require("./heliusPriorityFeeMethod");
 const driftPriorityFeeMethod_1 = require("./driftPriorityFeeMethod");
-const __1 = require("..");
 class PriorityFeeSubscriber {
     constructor(config) {
         var _a, _b;
@@ -24,7 +23,7 @@ class PriorityFeeSubscriber {
         this.addresses = config.addresses
             ? config.addresses.map((address) => address.toBase58())
             : [];
-        this.driftMarket = config.driftMarket;
+        this.driftMarkets = config.driftMarkets;
         if (config.customStrategy) {
             this.customStrategy = config.customStrategy;
         }
@@ -91,22 +90,15 @@ class PriorityFeeSubscriber {
         }
     }
     async loadForDrift() {
-        if (!this.driftMarket) {
+        if (!this.driftMarkets) {
             return;
         }
-        const sample = await (0, driftPriorityFeeMethod_1.fetchDriftPriorityFee)(this.driftPriorityFeeEndpoint, this.driftMarket.marketType, this.driftMarket.marketIndex);
+        const sample = await (0, driftPriorityFeeMethod_1.fetchDriftPriorityFee)(this.driftPriorityFeeEndpoint, this.driftMarkets.map((m) => m.marketType), this.driftMarkets.map((m) => m.marketIndex));
         if (sample.length > 0) {
             this.lastAvgStrategyResult = sample[heliusPriorityFeeMethod_1.HeliusPriorityLevel.MEDIUM];
             this.lastMaxStrategyResult = sample[heliusPriorityFeeMethod_1.HeliusPriorityLevel.UNSAFE_MAX];
             if (this.customStrategy) {
-                // stay compatible with helius response
-                this.lastCustomStrategyResult = this.customStrategy.calculate({
-                    jsonrpc: '',
-                    result: {
-                        priorityFeeLevels: sample[0],
-                    },
-                    id: '',
-                });
+                this.lastCustomStrategyResult = this.customStrategy.calculate(sample);
             }
         }
     }
@@ -186,8 +178,8 @@ class PriorityFeeSubscriber {
     updateAddresses(addresses) {
         this.addresses = addresses.map((k) => k.toBase58());
     }
-    updateMarketTypeAndIndex(marketType, marketIndex) {
-        this.driftMarket = { marketType: (0, __1.getVariant)(marketType), marketIndex };
+    updateMarketTypeAndIndex(driftMarkets) {
+        this.driftMarkets = driftMarkets;
     }
 }
 exports.PriorityFeeSubscriber = PriorityFeeSubscriber;

package/lib/priorityFee/types.d.ts

@@ -2,8 +2,9 @@ import { Connection, PublicKey } from '@solana/web3.js';
 import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { HeliusPriorityFeeResponse } from './heliusPriorityFeeMethod';
 import { DriftMarketInfo } from './priorityFeeSubscriber';
+import { DriftPriorityFeeResponse } from './driftPriorityFeeMethod';
 export interface PriorityFeeStrategy {
-    calculate(samples: SolanaPriorityFeeResponse[] | HeliusPriorityFeeResponse): number;
+    calculate(samples: SolanaPriorityFeeResponse[] | HeliusPriorityFeeResponse | DriftPriorityFeeResponse): number;
 }
 export declare enum PriorityFeeMethod {
     SOLANA = "solana",
@@ -14,7 +15,7 @@ export type PriorityFeeSubscriberConfig = {
     connection?: Connection;
     frequencyMs: number;
     addresses?: PublicKey[];
-    driftMarket?: DriftMarketInfo;
+    driftMarkets?: DriftMarketInfo[];
     customStrategy?: PriorityFeeStrategy;
     priorityFeeMethod?: PriorityFeeMethod;
     slotsToCheck?: number;

package/lib/tx/txParamProcessor.d.ts

@@ -0,0 +1,28 @@
+import { AddressLookupTableAccount, Connection, TransactionInstruction, TransactionVersion, VersionedTransaction } from '@solana/web3.js';
+import { BaseTxParams, ProcessingTxParams } from '..';
+type TransactionProps = {
+    instructions: TransactionInstruction | TransactionInstruction[];
+    txParams?: BaseTxParams;
+    txVersion?: TransactionVersion;
+    lookupTables?: AddressLookupTableAccount[];
+    forceVersionedTransaction?: boolean;
+};
+/**
+ * This class is responsible for running through a "processing" pipeline for a base transaction, to adjust the standard transaction parameters based on a given configuration.
+ */
+export declare class TransactionProcessor {
+    private static getComputeUnitsFromSim;
+    static getTxSimComputeUnits(tx: VersionedTransaction, connection: Connection): Promise<{
+        success: boolean;
+        computeUnits: number;
+    }>;
+    static process(props: {
+        txProps: TransactionProps;
+        txBuilder: (baseTransactionProps: TransactionProps) => Promise<VersionedTransaction>;
+        processConfig: ProcessingTxParams;
+        processParams: {
+            connection: Connection;
+        };
+    }): Promise<BaseTxParams>;
+}
+export {};

package/lib/tx/txParamProcessor.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionProcessor = void 0;
+const COMPUTE_UNIT_BUFFER_FACTOR = 1.2;
+const TEST_SIMS_ALWAYS_FAIL = false;
+/**
+ * This class is responsible for running through a "processing" pipeline for a base transaction, to adjust the standard transaction parameters based on a given configuration.
+ */
+class TransactionProcessor {
+    static async getComputeUnitsFromSim(txSim) {
+        var _a, _b;
+        if ((_a = txSim === null || txSim === void 0 ? void 0 : txSim.value) === null || _a === void 0 ? void 0 : _a.unitsConsumed) {
+            return (_b = txSim === null || txSim === void 0 ? void 0 : txSim.value) === null || _b === void 0 ? void 0 : _b.unitsConsumed;
+        }
+        return undefined;
+    }
+    static async getTxSimComputeUnits(tx, connection) {
+        var _a, _b, _c;
+        try {
+            if (TEST_SIMS_ALWAYS_FAIL)
+                throw new Error('Test Error::SIMS_ALWAYS_FAIL');
+            const simTxResult = await connection.simulateTransaction(tx, {
+                replaceRecentBlockhash: true, // This is important to ensure that the blockhash is not too new.. Otherwise we will very often receive a "blockHashNotFound" error
+            });
+            if ((_a = simTxResult === null || simTxResult === void 0 ? void 0 : simTxResult.value) === null || _a === void 0 ? void 0 : _a.err) {
+                throw new Error((_c = (_b = simTxResult === null || simTxResult === void 0 ? void 0 : simTxResult.value) === null || _b === void 0 ? void 0 : _b.err) === null || _c === void 0 ? void 0 : _c.toString());
+            }
+            const computeUnits = await this.getComputeUnitsFromSim(simTxResult);
+            return {
+                success: true,
+                computeUnits: computeUnits,
+            };
+        }
+        catch (e) {
+            console.warn(`Failed to get Simulated Compute Units for txParamProcessor`, e);
+            return {
+                success: false,
+                computeUnits: undefined,
+            };
+        }
+    }
+    static async process(props) {
+        var _a;
+        // # Exit early if no process config is provided
+        if (!props.processConfig || Object.keys(props.processConfig).length === 0) {
+            return props.txProps.txParams;
+        }
+        // # Setup
+        const { txProps: txProps, txBuilder: txBuilder, processConfig, processParams: processProps, } = props;
+        const baseTransaction = await txBuilder(txProps);
+        const finalTxProps = {
+            ...txProps,
+        };
+        // # Run Processes
+        if (processConfig.useSimulatedComputeUnits) {
+            const txSimComputeUnitsResult = await this.getTxSimComputeUnits(baseTransaction, processProps.connection);
+            if (txSimComputeUnitsResult.success) {
+                const bufferedComputeUnits = txSimComputeUnitsResult.computeUnits *
+                    ((_a = processConfig === null || processConfig === void 0 ? void 0 : processConfig.computeUnitsBufferMultiplier) !== null && _a !== void 0 ? _a : COMPUTE_UNIT_BUFFER_FACTOR);
+                // Adjust the transaction based on the simulated compute units
+                finalTxProps.txParams = {
+                    ...txProps.txParams,
+                    computeUnits: bufferedComputeUnits,
+                };
+            }
+        }
+        // # Return Final Tx Params
+        return finalTxProps.txParams;
+    }
+}
+exports.TransactionProcessor = TransactionProcessor;

package/lib/tx/whileValidTxSender.js

@@ -59,18 +59,19 @@ class WhileValidTxSender extends baseTxSender_1.BaseTxSender {
     }
     async sendVersionedTransaction(tx, additionalSigners, opts, preSigned, extraConfirmationOptions) {
         const latestBlockhash = await this.connection.getLatestBlockhash();
-        tx.message.recentBlockhash = latestBlockhash.blockhash;
         let signedTx;
         if (preSigned) {
             signedTx = tx;
             // @ts-ignore
         }
         else if (this.wallet.payer) {
+            tx.message.recentBlockhash = latestBlockhash.blockhash;
             // @ts-ignore
             tx.sign((additionalSigners !== null && additionalSigners !== void 0 ? additionalSigners : []).concat(this.wallet.payer));
             signedTx = tx;
         }
         else {
+            tx.message.recentBlockhash = latestBlockhash.blockhash;
             additionalSigners === null || additionalSigners === void 0 ? void 0 : additionalSigners.filter((s) => s !== undefined).forEach((kp) => {
                 tx.sign([kp]);
             });

package/lib/types.d.ts

@@ -1038,10 +1038,15 @@ export type ReferrerInfo = {
     referrer: PublicKey;
     referrerStats: PublicKey;
 };
-export type TxParams = {
+export type BaseTxParams = {
     computeUnits?: number;
     computeUnitsPrice?: number;
 };
+export type ProcessingTxParams = {
+    useSimulatedComputeUnits?: boolean;
+    computeUnitsBufferMultiplier?: number;
+};
+export type TxParams = BaseTxParams & ProcessingTxParams;
 export declare class SwapReduceOnly {
     static readonly In: {
         in: {};

package/lib/user.js

@@ -1690,8 +1690,14 @@ class User {
         const feeTier = this.getUserFeeTier(marketType);
         let takerFee = feeTier.feeNumerator / feeTier.feeDenominator;
         let makerFee = feeTier.makerRebateNumerator / feeTier.makerRebateDenominator;
-        if (marketIndex !== undefined && (0, types_1.isVariant)(marketType, 'perp')) {
-            const marketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
+        if (marketIndex !== undefined) {
+            let marketAccount = null;
+            if ((0, types_1.isVariant)(marketType, 'perp')) {
+                marketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
+            }
+            else {
+                marketAccount = this.driftClient.getSpotMarketAccount(marketIndex);
+            }
             takerFee += (takerFee * marketAccount.feeAdjustment) / 100;
             makerFee += (makerFee * marketAccount.feeAdjustment) / 100;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@drift-labs/sdk",
-	"version": "2.77.0-beta.0",
+	"version": "2.77.0-beta.1",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
 	"author": "crispheaney",

package/src/driftClient.ts

@@ -42,6 +42,8 @@ import {
 	PhoenixV1FulfillmentConfigAccount,
 	ModifyOrderPolicy,
 	SwapReduceOnly,
+	BaseTxParams,
+	ProcessingTxParams,
 } from './types';
 import * as anchor from '@coral-xyz/anchor';
 import driftIDL from './idl/drift.json';
@@ -125,6 +127,7 @@ import { UserStatsSubscriptionConfig } from './userStatsConfig';
 import { getMarinadeDepositIx, getMarinadeFinanceProgram } from './marinade';
 import { getOrderParams } from './orderParams';
 import { numberToSafeBN } from './math/utils';
+import { TransactionProcessor as TransactionParamProcessor } from './tx/txParamProcessor';
 
 type RemainingAccountParams = {
 	userAccounts: UserAccount[];
@@ -734,10 +737,44 @@ export class DriftClient {
 		return result;
 	}
 
+	private async getProcessedTransactionParams(
+		txParams: {
+			instructions: TransactionInstruction | TransactionInstruction[];
+			txParams?: BaseTxParams;
+			txVersion?: TransactionVersion;
+			lookupTables?: AddressLookupTableAccount[];
+		},
+		txParamProcessingParams: ProcessingTxParams
+	): Promise<BaseTxParams> {
+		const tx = await TransactionParamProcessor.process({
+			txProps: {
+				instructions: txParams.instructions,
+				txParams: txParams.txParams,
+				txVersion: txParams.txVersion,
+				lookupTables: txParams.lookupTables,
+			},
+			txBuilder: (updatedTxParams) =>
+				this.buildTransaction(
+					updatedTxParams.instructions,
+					updatedTxParams?.txParams,
+					updatedTxParams.txVersion,
+					updatedTxParams.lookupTables,
+					true
+				) as Promise<VersionedTransaction>,
+			processConfig: txParamProcessingParams,
+			processParams: {
+				connection: this.connection,
+			},
+		});
+
+		return tx;
+	}
+
 	public async initializeUserAccount(
 		subAccountId = 0,
 		name?: string,
-		referrerInfo?: ReferrerInfo
+		referrerInfo?: ReferrerInfo,
+		txParams?: TxParams
 	): Promise<[TransactionSignature, PublicKey]> {
 		const initializeIxs = [];
 
@@ -757,7 +794,7 @@ export class DriftClient {
 		}
 
 		initializeIxs.push(initializeUserAccountIx);
-		const tx = await this.buildTransaction(initializeIxs);
+		const tx = await this.buildTransaction(initializeIxs, txParams);
 
 		const { txSig } = await this.sendTransaction(tx, [], this.opts);
 
@@ -1992,17 +2029,6 @@ export class DriftClient {
 
 		const isSolMarket = spotMarket.mint.equals(WRAPPED_SOL_MINT);
 
-		let params: TxParams = {
-			computeUnits: txParams?.computeUnits ?? 600_000,
-		};
-
-		if (txParams?.computeUnitsPrice) {
-			params = {
-				...params,
-				computeUnitsPrice: txParams.computeUnitsPrice,
-			};
-		}
-
 		const authority = this.wallet.publicKey;
 
 		const isFromSubaccount =
@@ -2090,7 +2116,7 @@ export class DriftClient {
 			);
 		}
 
-		const tx = await this.buildTransaction(ixs, params);
+		const tx = await this.buildTransaction(ixs, txParams);
 
 		const { txSig, slot } = await this.sendTransaction(
 			tx,
@@ -2110,7 +2136,8 @@ export class DriftClient {
 		marketIndex: number,
 		tokenFaucet: TokenFaucet,
 		amount: BN,
-		referrerInfo?: ReferrerInfo
+		referrerInfo?: ReferrerInfo,
+		txParams?: TxParams
 	): Promise<[TransactionSignature, PublicKey]> {
 		const ixs = [];
 
@@ -2147,7 +2174,7 @@ export class DriftClient {
 		}
 		ixs.push(initializeUserAccountIx, depositCollateralIx);
 
-		const tx = await this.buildTransaction(ixs);
+		const tx = await this.buildTransaction(ixs, txParams);
 
 		const { txSig } = await this.sendTransaction(tx, [], this.opts);
 
@@ -2231,10 +2258,11 @@ export class DriftClient {
 			);
 		}
 
-		const tx = await this.buildTransaction(withdrawIxs, {
-			...(txParams ?? this.txParams),
-			computeUnits: 1_400_000,
-		});
+		const tx = await this.buildTransaction(
+			withdrawIxs,
+			txParams ?? this.txParams
+		);
+
 		const { txSig, slot } = await this.sendTransaction(
 			tx,
 			additionalSigners,
@@ -4535,15 +4563,37 @@ export class DriftClient {
 			ixs.push(bracketOrdersIx);
 		}
 
-		const placeAndTakeTx = (await this.buildTransaction(
+		const shouldUseSimulationComputeUnits = txParams?.useSimulatedComputeUnits;
+		const shouldExitIfSimulationFails = simulateFirst;
+
+		const txParamsWithoutImplicitSimulation = {
+			...txParams,
+			useSimulationComputeUnits: false,
+		};
+
+		let placeAndTakeTx = await this.buildTransaction(
 			ixs,
-			txParams
-		)) as VersionedTransaction;
+			txParamsWithoutImplicitSimulation
+		);
+
+		if (shouldUseSimulationComputeUnits || shouldExitIfSimulationFails) {
+			const simulationResult =
+				await TransactionParamProcessor.getTxSimComputeUnits(
+					// @ts-ignore :: TODO - TEST WITH LEGACY TRANSACTION
+					placeAndTakeTx,
+					this.connection
+				);
 
-		// if param is passed, return early before the tx fails so ui can fallback to placeOrder
-		if (simulateFirst) {
-			const success = await this.txSender.simulateTransaction(placeAndTakeTx);
-			if (!success) return;
+			if (shouldExitIfSimulationFails && !simulationResult.success) {
+				return;
+			}
+
+			if (shouldUseSimulationComputeUnits) {
+				placeAndTakeTx = await this.buildTransaction(ixs, {
+					...txParamsWithoutImplicitSimulation,
+					computeUnits: simulationResult.computeUnits,
+				});
+			}
 		}
 
 		let cancelExistingOrdersTx: Transaction;
@@ -6504,7 +6554,11 @@ export class DriftClient {
 			  }
 			: undefined;
 
-		if (tx instanceof VersionedTransaction) {
+		const version = (tx as VersionedTransaction)?.version;
+		const isVersionedTx =
+			tx instanceof VersionedTransaction || version !== undefined;
+
+		if (isVersionedTx) {
 			return this.txSender.sendVersionedTransaction(
 				tx as VersionedTransaction,
 				additionalSigners,
@@ -6523,14 +6577,65 @@ export class DriftClient {
 		}
 	}
 
+	/**
+	 *
+	 * @param instructions
+	 * @param txParams
+	 * @param txVersion
+	 * @param lookupTables
+	 * @param forceVersionedTransaction Return a VersionedTransaction instance even if the version of the transaction is Legacy
+	 * @returns
+	 */
 	async buildTransaction(
 		instructions: TransactionInstruction | TransactionInstruction[],
 		txParams?: TxParams,
 		txVersion?: TransactionVersion,
-		lookupTables?: AddressLookupTableAccount[]
+		lookupTables?: AddressLookupTableAccount[],
+		forceVersionedTransaction?: boolean
 	): Promise<Transaction | VersionedTransaction> {
+		txVersion = txVersion ?? this.txVersion;
+
+		// # Collect and process Tx Params
+		let baseTxParams: BaseTxParams = {
+			computeUnits: txParams?.computeUnits ?? this.txParams.computeUnits,
+			computeUnitsPrice:
+				txParams?.computeUnitsPrice ?? this.txParams.computeUnitsPrice,
+		};
+
+		if (txParams?.useSimulatedComputeUnits) {
+			const splitTxParams: {
+				baseTxParams: BaseTxParams;
+				txParamProcessingParams: ProcessingTxParams;
+			} = {
+				baseTxParams: {
+					computeUnits: txParams?.computeUnits,
+					computeUnitsPrice: txParams?.computeUnitsPrice,
+				},
+				txParamProcessingParams: {
+					useSimulatedComputeUnits: txParams?.useSimulatedComputeUnits,
+					computeUnitsBufferMultiplier: txParams?.computeUnitsBufferMultiplier,
+				},
+			};
+
+			const processedTxParams = await this.getProcessedTransactionParams(
+				{
+					instructions,
+					txParams: splitTxParams.baseTxParams,
+					txVersion,
+					lookupTables,
+				},
+				splitTxParams.txParamProcessingParams
+			);
+
+			baseTxParams = {
+				...baseTxParams,
+				...processedTxParams,
+			};
+		}
+
+		// # Create Tx Instructions
 		const allIx = [];
-		const computeUnits = txParams?.computeUnits ?? this.txParams.computeUnits;
+		const computeUnits = baseTxParams?.computeUnits;
 		if (computeUnits !== 200_000) {
 			allIx.push(
 				ComputeBudgetProgram.setComputeUnitLimit({
@@ -6538,8 +6643,7 @@ export class DriftClient {
 				})
 			);
 		}
-		const computeUnitsPrice =
-			txParams?.computeUnitsPrice ?? this.txParams.computeUnitsPrice;
+		const computeUnitsPrice = baseTxParams?.computeUnitsPrice;
 		if (computeUnitsPrice !== 0) {
 			allIx.push(
 				ComputeBudgetProgram.setComputeUnitPrice({
@@ -6554,9 +6658,24 @@ export class DriftClient {
 			allIx.push(instructions);
 		}
 
-		txVersion = txVersion ?? this.txVersion;
+		const latestBlockHashAndContext =
+			await this.connection.getLatestBlockhashAndContext({
+				commitment: this.opts.preflightCommitment,
+			});
+
+		// # Create and return Transaction
 		if (txVersion === 'legacy') {
-			return new Transaction().add(...allIx);
+			if (forceVersionedTransaction) {
+				const message = new TransactionMessage({
+					payerKey: this.provider.wallet.publicKey,
+					recentBlockhash: latestBlockHashAndContext.value.blockhash,
+					instructions: allIx,
+				}).compileToLegacyMessage();
+
+				return new VersionedTransaction(message);
+			} else {
+				return new Transaction().add(...allIx);
+			}
 		} else {
 			const marketLookupTable = await this.fetchMarketLookupTableAccount();
 			lookupTables = lookupTables
@@ -6564,11 +6683,7 @@ export class DriftClient {
 				: [marketLookupTable];
 			const message = new TransactionMessage({
 				payerKey: this.provider.wallet.publicKey,
-				recentBlockhash: (
-					await this.provider.connection.getRecentBlockhash(
-						this.opts.preflightCommitment
-					)
-				).blockhash,
+				recentBlockhash: latestBlockHashAndContext.value.blockhash,
 				instructions: allIx,
 			}).compileToV0Message(lookupTables);
 

package/src/idl/drift.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.76.0",
+  "version": "2.75.0",
   "name": "drift",
   "instructions": [
     {

package/src/priorityFee/driftPriorityFeeMethod.ts

@@ -5,11 +5,13 @@ export type DriftPriorityFeeResponse = HeliusPriorityFeeLevels[];
 
 export async function fetchDriftPriorityFee(
 	url: string,
-	marketType: string,
-	marketIndex: number
+	marketTypes: string[],
+	marketIndexs: number[]
 ): Promise<DriftPriorityFeeResponse> {
 	const response = await fetch(
-		`${url}?marketType=${marketType}&marketIndex=${marketIndex}`
+		`${url}/batchPriorityFees?marketType=${marketTypes.join(
+			','
+		)}&marketIndex=${marketIndexs.join(',')}`
 	);
 	return await response.json();
 }

package/src/priorityFee/priorityFeeSubscriber.ts

@@ -13,7 +13,6 @@ import {
 	fetchHeliusPriorityFee,
 } from './heliusPriorityFeeMethod';
 import { fetchDriftPriorityFee } from './driftPriorityFeeMethod';
-import { getVariant, MarketType } from '..';
 
 export type DriftMarketInfo = {
 	marketType: string;
@@ -24,7 +23,7 @@ export class PriorityFeeSubscriber {
 	connection: Connection;
 	frequencyMs: number;
 	addresses: string[];
-	driftMarket?: DriftMarketInfo;
+	driftMarkets?: DriftMarketInfo[];
 	customStrategy?: PriorityFeeStrategy;
 	averageStrategy = new AverageOverSlotsStrategy();
 	maxStrategy = new MaxOverSlotsStrategy();
@@ -51,7 +50,7 @@ export class PriorityFeeSubscriber {
 		this.addresses = config.addresses
 			? config.addresses.map((address) => address.toBase58())
 			: [];
-		this.driftMarket = config.driftMarket;
+		this.driftMarkets = config.driftMarkets;
 
 		if (config.customStrategy) {
 			this.customStrategy = config.customStrategy;
@@ -137,26 +136,19 @@ export class PriorityFeeSubscriber {
 	}
 
 	private async loadForDrift(): Promise<void> {
-		if (!this.driftMarket) {
+		if (!this.driftMarkets) {
 			return;
 		}
 		const sample = await fetchDriftPriorityFee(
 			this.driftPriorityFeeEndpoint!,
-			this.driftMarket.marketType,
-			this.driftMarket.marketIndex
+			this.driftMarkets.map((m) => m.marketType),
+			this.driftMarkets.map((m) => m.marketIndex)
 		);
 		if (sample.length > 0) {
 			this.lastAvgStrategyResult = sample[HeliusPriorityLevel.MEDIUM];
 			this.lastMaxStrategyResult = sample[HeliusPriorityLevel.UNSAFE_MAX];
 			if (this.customStrategy) {
-				// stay compatible with helius response
-				this.lastCustomStrategyResult = this.customStrategy.calculate({
-					jsonrpc: '',
-					result: {
-						priorityFeeLevels: sample[0],
-					},
-					id: '',
-				});
+				this.lastCustomStrategyResult = this.customStrategy.calculate(sample);
 			}
 		}
 	}
@@ -251,7 +243,7 @@ export class PriorityFeeSubscriber {
 		this.addresses = addresses.map((k) => k.toBase58());
 	}
 
-	public updateMarketTypeAndIndex(marketType: MarketType, marketIndex: number) {
-		this.driftMarket = { marketType: getVariant(marketType), marketIndex };
+	public updateMarketTypeAndIndex(driftMarkets: DriftMarketInfo[]) {
+		this.driftMarkets = driftMarkets;
 	}
 }

package/src/priorityFee/types.ts

@@ -2,12 +2,16 @@ import { Connection, PublicKey } from '@solana/web3.js';
 import { SolanaPriorityFeeResponse } from './solanaPriorityFeeMethod';
 import { HeliusPriorityFeeResponse } from './heliusPriorityFeeMethod';
 import { DriftMarketInfo } from './priorityFeeSubscriber';
+import { DriftPriorityFeeResponse } from './driftPriorityFeeMethod';
 
 export interface PriorityFeeStrategy {
 	// calculate the priority fee for a given set of samples.
 	// expect samples to be sorted in descending order (by slot)
 	calculate(
-		samples: SolanaPriorityFeeResponse[] | HeliusPriorityFeeResponse
+		samples:
+			| SolanaPriorityFeeResponse[]
+			| HeliusPriorityFeeResponse
+			| DriftPriorityFeeResponse
 	): number;
 }
 
@@ -25,7 +29,7 @@ export type PriorityFeeSubscriberConfig = {
 	/// addresses you plan to write lock, used to determine priority fees
 	addresses?: PublicKey[];
 	/// drift market type and index, optionally provide at initialization time if using priorityFeeMethod.DRIFT
-	driftMarket?: DriftMarketInfo;
+	driftMarkets?: DriftMarketInfo[];
 	/// custom strategy to calculate priority fees, defaults to AVERAGE
 	customStrategy?: PriorityFeeStrategy;
 	/// method for fetching priority fee samples

package/src/tx/txParamProcessor.ts

@@ -0,0 +1,126 @@
+import {
+	AddressLookupTableAccount,
+	Connection,
+	RpcResponseAndContext,
+	SimulatedTransactionResponse,
+	TransactionInstruction,
+	TransactionVersion,
+	VersionedTransaction,
+} from '@solana/web3.js';
+import { BaseTxParams, ProcessingTxParams } from '..';
+
+const COMPUTE_UNIT_BUFFER_FACTOR = 1.2;
+
+const TEST_SIMS_ALWAYS_FAIL = false;
+
+type TransactionProps = {
+	instructions: TransactionInstruction | TransactionInstruction[];
+	txParams?: BaseTxParams;
+	txVersion?: TransactionVersion;
+	lookupTables?: AddressLookupTableAccount[];
+	forceVersionedTransaction?: boolean;
+};
+
+/**
+ * This class is responsible for running through a "processing" pipeline for a base transaction, to adjust the standard transaction parameters based on a given configuration.
+ */
+export class TransactionProcessor {
+	private static async getComputeUnitsFromSim(
+		txSim: RpcResponseAndContext<SimulatedTransactionResponse>
+	) {
+		if (txSim?.value?.unitsConsumed) {
+			return txSim?.value?.unitsConsumed;
+		}
+
+		return undefined;
+	}
+
+	public static async getTxSimComputeUnits(
+		tx: VersionedTransaction,
+		connection: Connection
+	): Promise<{ success: boolean; computeUnits: number }> {
+		try {
+			if (TEST_SIMS_ALWAYS_FAIL)
+				throw new Error('Test Error::SIMS_ALWAYS_FAIL');
+
+			const simTxResult = await connection.simulateTransaction(tx, {
+				replaceRecentBlockhash: true, // This is important to ensure that the blockhash is not too new.. Otherwise we will very often receive a "blockHashNotFound" error
+			});
+
+			if (simTxResult?.value?.err) {
+				throw new Error(simTxResult?.value?.err?.toString());
+			}
+
+			const computeUnits = await this.getComputeUnitsFromSim(simTxResult);
+
+			return {
+				success: true,
+				computeUnits: computeUnits,
+			};
+		} catch (e) {
+			console.warn(
+				`Failed to get Simulated Compute Units for txParamProcessor`,
+				e
+			);
+
+			return {
+				success: false,
+				computeUnits: undefined,
+			};
+		}
+	}
+
+	static async process(props: {
+		txProps: TransactionProps;
+		txBuilder: (
+			baseTransactionProps: TransactionProps
+		) => Promise<VersionedTransaction>;
+		processConfig: ProcessingTxParams;
+		processParams: {
+			connection: Connection;
+		};
+	}): Promise<BaseTxParams> {
+		// # Exit early if no process config is provided
+		if (!props.processConfig || Object.keys(props.processConfig).length === 0) {
+			return props.txProps.txParams;
+		}
+
+		// # Setup
+		const {
+			txProps: txProps,
+			txBuilder: txBuilder,
+			processConfig,
+			processParams: processProps,
+		} = props;
+
+		const baseTransaction = await txBuilder(txProps);
+
+		const finalTxProps = {
+			...txProps,
+		};
+
+		// # Run Processes
+		if (processConfig.useSimulatedComputeUnits) {
+			const txSimComputeUnitsResult = await this.getTxSimComputeUnits(
+				baseTransaction,
+				processProps.connection
+			);
+
+			if (txSimComputeUnitsResult.success) {
+				const bufferedComputeUnits =
+					txSimComputeUnitsResult.computeUnits *
+					(processConfig?.computeUnitsBufferMultiplier ??
+						COMPUTE_UNIT_BUFFER_FACTOR);
+
+				// Adjust the transaction based on the simulated compute units
+				finalTxProps.txParams = {
+					...txProps.txParams,
+					computeUnits: bufferedComputeUnits,
+				};
+			}
+		}
+
+		// # Return Final Tx Params
+		return finalTxProps.txParams;
+	}
+}

package/src/tx/whileValidTxSender.ts

@@ -124,17 +124,18 @@ export class WhileValidTxSender extends BaseTxSender {
 		extraConfirmationOptions?: ExtraConfirmationOptions
 	): Promise<TxSigAndSlot> {
 		const latestBlockhash = await this.connection.getLatestBlockhash();
-		tx.message.recentBlockhash = latestBlockhash.blockhash;
 
 		let signedTx;
 		if (preSigned) {
 			signedTx = tx;
 			// @ts-ignore
 		} else if (this.wallet.payer) {
+			tx.message.recentBlockhash = latestBlockhash.blockhash;
 			// @ts-ignore
 			tx.sign((additionalSigners ?? []).concat(this.wallet.payer));
 			signedTx = tx;
 		} else {
+			tx.message.recentBlockhash = latestBlockhash.blockhash;
 			additionalSigners
 				?.filter((s): s is Signer => s !== undefined)
 				.forEach((kp) => {

package/src/types.ts

@@ -999,11 +999,18 @@ export type ReferrerInfo = {
 	referrerStats: PublicKey;
 };
 
-export type TxParams = {
+export type BaseTxParams = {
 	computeUnits?: number;
 	computeUnitsPrice?: number;
 };
 
+export type ProcessingTxParams = {
+	useSimulatedComputeUnits?: boolean;
+	computeUnitsBufferMultiplier?: number;
+};
+
+export type TxParams = BaseTxParams & ProcessingTxParams;
+
 export class SwapReduceOnly {
 	static readonly In = { in: {} };
 	static readonly Out = { out: {} };

package/src/user.ts

@@ -3123,8 +3123,13 @@ export class User {
 		let makerFee =
 			feeTier.makerRebateNumerator / feeTier.makerRebateDenominator;
 
-		if (marketIndex !== undefined && isVariant(marketType, 'perp')) {
-			const marketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
+		if (marketIndex !== undefined) {
+			let marketAccount = null;
+			if (isVariant(marketType, 'perp')) {
+				marketAccount = this.driftClient.getPerpMarketAccount(marketIndex);
+			} else {
+				marketAccount = this.driftClient.getSpotMarketAccount(marketIndex);
+			}
 			takerFee += (takerFee * marketAccount.feeAdjustment) / 100;
 			makerFee += (makerFee * marketAccount.feeAdjustment) / 100;
 		}