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

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/txParamProcessor.ts

@@ -32,7 +32,8 @@ export class TransactionParamProcessor {
 	public static async getTxSimComputeUnits(
 		tx: VersionedTransaction,
 		connection: Connection,
-		bufferMultiplier: number // Making this a mandatory param to force the user to remember that simulated CU's can be inaccurate and a buffer should be applied
+		bufferMultiplier: number, // Making this a mandatory param to force the user to remember that simulated CU's can be inaccurate and a buffer should be applied
+		lowerBoundCu?: number
 	): Promise<{ success: boolean; computeUnits: number }> {
 		try {
 			if (TEST_SIMS_ALWAYS_FAIL)
@@ -49,10 +50,18 @@ export class TransactionParamProcessor {
 			const computeUnits = await this.getComputeUnitsFromSim(simTxResult);
 
 			// Apply the buffer, but round down to the MAX_COMPUTE_UNITS, and round up to the nearest whole number
-			const bufferedComputeUnits = Math.ceil(
+			let bufferedComputeUnits = Math.ceil(
 				Math.min(computeUnits * bufferMultiplier, MAX_COMPUTE_UNITS)
 			);
 
+			// If a lower bound CU is passed then enforce it
+			if (lowerBoundCu) {
+				bufferedComputeUnits = Math.max(
+					bufferedComputeUnits,
+					Math.min(lowerBoundCu, MAX_COMPUTE_UNITS)
+				);
+			}
+
 			return {
 				success: true,
 				computeUnits: bufferedComputeUnits,

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/src/types.ts

@@ -1042,6 +1042,7 @@ export type ProcessingTxParams = {
 	computeUnitsBufferMultiplier?: number;
 	useSimulatedComputeUnitsForCUPriceCalculation?: boolean;
 	getCUPriceFromComputeUnits?: (computeUnits: number) => number;
+	lowerBoundCu?: number;
 };
 
 export type TxParams = BaseTxParams & ProcessingTxParams;

package/src/user.ts

@@ -108,9 +108,12 @@ export class User {
 		this.userAccountPublicKey = config.userAccountPublicKey;
 		if (config.accountSubscription?.type === 'polling') {
 			this.accountSubscriber = new PollingUserAccountSubscriber(
-				config.driftClient.program,
+				config.driftClient.connection,
 				config.userAccountPublicKey,
-				config.accountSubscription.accountLoader
+				config.accountSubscription.accountLoader,
+				this.driftClient.program.account.user.coder.accounts.decodeUnchecked.bind(
+					this.driftClient.program.account.user.coder.accounts
+				)
 			);
 		} else if (config.accountSubscription?.type === 'custom') {
 			this.accountSubscriber = config.accountSubscription.userAccountSubscriber;

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