@drift-labs/sdk 2.85.0-beta.9 → 2.86.0-beta.1

package/src/oracles/pythPullClient.ts

@@ -9,11 +9,10 @@ import {
 } from '../constants/numericConstants';
 import {
 	PythSolanaReceiverProgram,
-	DEFAULT_RECEIVER_PROGRAM_ID,
 	pythSolanaReceiverIdl,
 } from '@pythnetwork/pyth-solana-receiver';
 import { PriceUpdateAccount } from '@pythnetwork/pyth-solana-receiver/lib/PythSolanaReceiver';
-import { Wallet } from '..';
+import { DRIFT_ORACLE_RECEIVER_ID, Wallet } from '..';
 
 export class PythPullClient implements OracleClient {
 	private connection: Connection;
@@ -40,7 +39,7 @@ export class PythPullClient implements OracleClient {
 		);
 		this.receiver = new Program<PythSolanaReceiverProgram>(
 			pythSolanaReceiverIdl as PythSolanaReceiverProgram,
-			DEFAULT_RECEIVER_PROGRAM_ID,
+			DRIFT_ORACLE_RECEIVER_ID,
 			provider
 		);
 		this.decodeFunc =

package/src/tx/baseTxSender.ts

@@ -394,6 +394,7 @@ export abstract class BaseTxSender implements TxSender {
 
 		const friendlyMessage = lastLog?.match(/(failed:) (.+)/)?.[2];
 
+		// @ts-ignore
 		throw new SendTransactionError({
 			action: 'send',
 			signature: txSig,

package/src/tx/blockhashFetcher/baseBlockhashFetcher.ts

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

package/src/tx/blockhashFetcher/cachedBlockhashFetcher.ts

@@ -0,0 +1,90 @@
+import {
+	BlockhashWithExpiryBlockHeight,
+	Commitment,
+	Connection,
+} from '@solana/web3.js';
+import { BlockhashFetcher } from './types';
+
+/**
+ * Fetches the latest blockhash and caches it for a configurable amount of time.
+ *
+ * - Prevents RPC spam by reusing cached values
+ * - Retries on failure with exponential backoff
+ * - Prevents concurrent requests for the same blockhash
+ */
+export class CachedBlockhashFetcher implements BlockhashFetcher {
+	private recentBlockhashCache: {
+		value: BlockhashWithExpiryBlockHeight | undefined;
+		lastUpdated: number;
+	} = { value: undefined, lastUpdated: 0 };
+
+	private blockhashFetchingPromise: Promise<void> | null = null;
+
+	constructor(
+		private connection: Connection,
+		private blockhashCommitment: Commitment,
+		private retryCount: number,
+		private retrySleepTimeMs: number,
+		private staleCacheTimeMs: number
+	) {}
+
+	private async fetchBlockhashWithRetry(): Promise<BlockhashWithExpiryBlockHeight> {
+		for (let i = 0; i < this.retryCount; i++) {
+			try {
+				return await this.connection.getLatestBlockhash(
+					this.blockhashCommitment
+				);
+			} catch (err) {
+				if (i === this.retryCount - 1) {
+					throw new Error('Failed to fetch blockhash after maximum retries');
+				}
+				await this.sleep(this.retrySleepTimeMs * 2 ** i);
+			}
+		}
+		throw new Error('Failed to fetch blockhash after maximum retries');
+	}
+
+	private sleep(ms: number): Promise<void> {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+
+	private async updateBlockhashCache(): Promise<void> {
+		const result = await this.fetchBlockhashWithRetry();
+		this.recentBlockhashCache = {
+			value: result,
+			lastUpdated: Date.now(),
+		};
+	}
+
+	public async getLatestBlockhash(): Promise<
+		BlockhashWithExpiryBlockHeight | undefined
+	> {
+		if (this.isCacheStale()) {
+			await this.refreshBlockhash();
+		}
+		return this.recentBlockhashCache.value;
+	}
+
+	private isCacheStale(): boolean {
+		const lastUpdateTime = this.recentBlockhashCache.lastUpdated;
+		return (
+			!lastUpdateTime || Date.now() > lastUpdateTime + this.staleCacheTimeMs
+		);
+	}
+
+	/**
+	 * Refresh the blockhash cache, await a pending refresh if it exists
+	 */
+	private async refreshBlockhash(): Promise<void> {
+		if (!this.blockhashFetchingPromise) {
+			this.blockhashFetchingPromise = this.updateBlockhashCache();
+			try {
+				await this.blockhashFetchingPromise;
+			} finally {
+				this.blockhashFetchingPromise = null;
+			}
+		} else {
+			await this.blockhashFetchingPromise;
+		}
+	}
+}

package/src/tx/blockhashFetcher/types.ts

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

package/src/tx/txHandler.ts

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

package/src/tx/utils.ts

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

package/src/util/pythPullOracleUtils.ts

@@ -0,0 +1,11 @@
+export function trimFeedId(feedId: string): string {
+	if (feedId.startsWith('0x')) {
+		return feedId.slice(2);
+	}
+	return feedId;
+}
+
+export function getFeedIdUint8Array(feedId: string): Uint8Array {
+	const trimmedFeedId = trimFeedId(feedId);
+	return Uint8Array.from(Buffer.from(trimmedFeedId, 'hex'));
+}

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