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

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

@@ -15,6 +15,7 @@ import { BaseTxSender } from './baseTxSender';
 import bs58 from 'bs58';
 
 const DEFAULT_RETRY = 2000;
+const PLACEHOLDER_BLOCKHASH = 'Fdum64WVeej6DeL85REV9NvfSxEJNPZ74DBk7A8kTrKP';
 
 type ResolveReference = {
 	resolve?: () => void;
@@ -103,11 +104,12 @@ export class WhileValidTxSender extends BaseTxSender {
 		ixs: TransactionInstruction[],
 		lookupTableAccounts: AddressLookupTableAccount[],
 		_additionalSigners?: Array<Signer>,
-		_opts?: ConfirmOptions
+		_opts?: ConfirmOptions,
+		blockhash?: string
 	): Promise<VersionedTransaction> {
 		const message = new TransactionMessage({
 			payerKey: this.wallet.publicKey,
-			recentBlockhash: '', // set blank and reset in sendVersionTransaction
+			recentBlockhash: blockhash ?? PLACEHOLDER_BLOCKHASH, // set blank and reset in sendVersionTransaction
 			instructions: ixs,
 		}).compileToV0Message(lookupTableAccounts);
 
@@ -124,17 +126,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;
 		}