@drift-labs/sdk-browser 2.104.0-beta.21

package/src/tx/baseTxSender.ts

@@ -0,0 +1,477 @@
+import {
+	ConfirmationStrategy,
+	TxSender,
+	TxSendError,
+	TxSigAndSlot,
+} from './types';
+import {
+	Commitment,
+	ConfirmOptions,
+	Context,
+	RpcResponseAndContext,
+	Signer,
+	SignatureResult,
+	Transaction,
+	TransactionSignature,
+	Connection,
+	VersionedTransaction,
+	TransactionInstruction,
+	AddressLookupTableAccount,
+	BlockhashWithExpiryBlockHeight,
+} from '@solana/web3.js';
+import assert from 'assert';
+import bs58 from 'bs58';
+import { TxHandler } from './txHandler';
+import { IWallet } from '../types';
+import NodeCache from 'node-cache';
+import { DEFAULT_CONFIRMATION_OPTS } from '../config';
+import { NOT_CONFIRMED_ERROR_CODE } from '../constants/txConstants';
+import { throwTransactionError } from './reportTransactionError';
+
+const BASELINE_TX_LAND_RATE = 0.9;
+const DEFAULT_TIMEOUT = 35000;
+const DEFAULT_TX_LAND_RATE_LOOKBACK_WINDOW_MINUTES = 10;
+
+export abstract class BaseTxSender implements TxSender {
+	connection: Connection;
+	wallet: IWallet;
+	opts: ConfirmOptions;
+	timeout: number;
+	additionalConnections: Connection[];
+	timeoutCount = 0;
+	confirmationStrategy: ConfirmationStrategy;
+	additionalTxSenderCallbacks: ((base58EncodedTx: string) => void)[];
+	txHandler: TxHandler;
+	trackTxLandRate?: boolean;
+	throwOnTimeoutError: boolean;
+	throwOnTransactionError: boolean;
+
+	// For landing rate calcs
+	lookbackWindowMinutes: number;
+	txSigCache?: NodeCache;
+	txLandRate = 0;
+	lastPriorityFeeSuggestion = 1;
+	landRateToFeeFunc: (landRate: number) => number;
+
+	public constructor({
+		connection,
+		wallet,
+		opts = DEFAULT_CONFIRMATION_OPTS,
+		timeout = DEFAULT_TIMEOUT,
+		additionalConnections = new Array<Connection>(),
+		confirmationStrategy = ConfirmationStrategy.Combo,
+		additionalTxSenderCallbacks,
+		trackTxLandRate,
+		txHandler,
+		txLandRateLookbackWindowMinutes = DEFAULT_TX_LAND_RATE_LOOKBACK_WINDOW_MINUTES,
+		landRateToFeeFunc,
+		throwOnTimeoutError = true,
+		throwOnTransactionError = true,
+	}: {
+		connection: Connection;
+		wallet: IWallet;
+		opts?: ConfirmOptions;
+		timeout?: number;
+		additionalConnections?;
+		confirmationStrategy?: ConfirmationStrategy;
+		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
+		txHandler?: TxHandler;
+		trackTxLandRate?: boolean;
+		txLandRateLookbackWindowMinutes?: number;
+		landRateToFeeFunc?: (landRate: number) => number;
+		throwOnTimeoutError?: boolean;
+		throwOnTransactionError?: boolean;
+	}) {
+		this.connection = connection;
+		this.wallet = wallet;
+		this.opts = opts;
+		this.timeout = timeout;
+		this.additionalConnections = additionalConnections;
+		this.confirmationStrategy = confirmationStrategy;
+		this.additionalTxSenderCallbacks = additionalTxSenderCallbacks;
+		this.txHandler =
+			txHandler ??
+			new TxHandler({
+				connection: this.connection,
+				wallet: this.wallet,
+				confirmationOptions: this.opts,
+			});
+		this.trackTxLandRate = trackTxLandRate;
+		this.lookbackWindowMinutes = txLandRateLookbackWindowMinutes * 60;
+		if (this.trackTxLandRate) {
+			this.txSigCache = new NodeCache({
+				stdTTL: this.lookbackWindowMinutes,
+				checkperiod: 120,
+			});
+		}
+		this.landRateToFeeFunc =
+			landRateToFeeFunc ?? this.defaultLandRateToFeeFunc.bind(this);
+		this.throwOnTimeoutError = throwOnTimeoutError;
+		this.throwOnTransactionError = throwOnTransactionError;
+	}
+
+	async send(
+		tx: Transaction,
+		additionalSigners?: Array<Signer>,
+		opts?: ConfirmOptions,
+		preSigned?: boolean
+	): Promise<TxSigAndSlot> {
+		if (additionalSigners === undefined) {
+			additionalSigners = [];
+		}
+		if (opts === undefined) {
+			opts = this.opts;
+		}
+
+		const signedTx = await this.prepareTx(
+			tx,
+			additionalSigners,
+			opts,
+			preSigned
+		);
+
+		return this.sendRawTransaction(signedTx.serialize(), opts);
+	}
+
+	async prepareTx(
+		tx: Transaction,
+		additionalSigners: Array<Signer>,
+		opts: ConfirmOptions,
+		preSigned?: boolean
+	): Promise<Transaction> {
+		return this.txHandler.prepareTx(
+			tx,
+			additionalSigners,
+			undefined,
+			opts,
+			preSigned
+		);
+	}
+
+	async getVersionedTransaction(
+		ixs: TransactionInstruction[],
+		lookupTableAccounts: AddressLookupTableAccount[],
+		_additionalSigners?: Array<Signer>,
+		opts?: ConfirmOptions,
+		blockhash?: BlockhashWithExpiryBlockHeight
+	): Promise<VersionedTransaction> {
+		return this.txHandler.generateVersionedTransaction(
+			blockhash,
+			ixs,
+			lookupTableAccounts,
+			this.wallet
+		);
+	}
+
+	async sendVersionedTransaction(
+		tx: VersionedTransaction,
+		additionalSigners?: Array<Signer>,
+		opts?: ConfirmOptions,
+		preSigned?: boolean
+	): Promise<TxSigAndSlot> {
+		let signedTx;
+
+		if (preSigned) {
+			signedTx = tx;
+			// @ts-ignore
+		} else if (this.wallet.payer) {
+			// @ts-ignore
+			tx.sign((additionalSigners ?? []).concat(this.wallet.payer));
+			signedTx = tx;
+		} else {
+			signedTx = await this.txHandler.signVersionedTx(
+				tx,
+				additionalSigners,
+				undefined,
+				this.wallet
+			);
+		}
+
+		if (opts === undefined) {
+			opts = this.opts;
+		}
+
+		return this.sendRawTransaction(signedTx.serialize(), opts);
+	}
+
+	async sendRawTransaction(
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		rawTransaction: Buffer | Uint8Array,
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		opts: ConfirmOptions
+	): Promise<TxSigAndSlot> {
+		throw new Error('Must be implemented by subclass');
+	}
+
+	/* Simulate the tx and return a boolean for success value */
+	async simulateTransaction(tx: VersionedTransaction): Promise<boolean> {
+		try {
+			const result = await this.connection.simulateTransaction(tx);
+			if (result.value.err != null) {
+				console.error('Error in transaction simulation: ', result.value.err);
+				return false;
+			}
+			return true;
+		} catch (e) {
+			console.error('Error calling simulateTransaction: ', e);
+			return false;
+		}
+	}
+
+	async confirmTransactionWebSocket(
+		signature: TransactionSignature,
+		commitment?: Commitment
+	): Promise<RpcResponseAndContext<SignatureResult>> {
+		let decodedSignature;
+		try {
+			decodedSignature = bs58.decode(signature);
+		} catch (err) {
+			throw new Error('signature must be base58 encoded: ' + signature);
+		}
+
+		assert(decodedSignature.length === 64, 'signature has invalid length');
+
+		const start = Date.now();
+		const subscriptionCommitment = commitment || this.opts.commitment;
+
+		const subscriptionIds = new Array<number>();
+		const connections = [this.connection, ...this.additionalConnections];
+		let response: RpcResponseAndContext<SignatureResult> | null = null;
+		const promises = connections.map((connection, i) => {
+			let subscriptionId;
+			const confirmPromise = new Promise((resolve, reject) => {
+				try {
+					subscriptionId = connection.onSignature(
+						signature,
+						(result: SignatureResult, context: Context) => {
+							subscriptionIds[i] = undefined;
+							response = {
+								context,
+								value: result,
+							};
+							resolve(null);
+						},
+						subscriptionCommitment
+					);
+				} catch (err) {
+					reject(err);
+				}
+			});
+			subscriptionIds.push(subscriptionId);
+			return confirmPromise;
+		});
+
+		try {
+			await this.promiseTimeout(promises, this.timeout);
+		} finally {
+			for (const [i, subscriptionId] of subscriptionIds.entries()) {
+				if (subscriptionId) {
+					connections[i].removeSignatureListener(subscriptionId);
+				}
+			}
+		}
+
+		if (response === null) {
+			if (this.confirmationStrategy === ConfirmationStrategy.Combo) {
+				try {
+					const rpcResponse = await this.connection.getSignatureStatuses([
+						signature,
+					]);
+
+					if (rpcResponse?.value?.[0]?.confirmationStatus) {
+						response = {
+							context: rpcResponse.context,
+							value: { err: rpcResponse.value[0].err },
+						};
+						return response;
+					}
+				} catch (error) {
+					// Ignore error to pass through to timeout error
+				}
+			}
+			this.timeoutCount += 1;
+			const duration = (Date.now() - start) / 1000;
+			if (this.throwOnTimeoutError) {
+				throw new TxSendError(
+					`Transaction was not confirmed in ${duration.toFixed(
+						2
+					)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`,
+					NOT_CONFIRMED_ERROR_CODE
+				);
+			}
+		}
+
+		return response;
+	}
+
+	async confirmTransactionPolling(
+		signature: TransactionSignature,
+		commitment: Commitment = 'finalized'
+	): Promise<RpcResponseAndContext<SignatureResult> | undefined> {
+		let totalTime = 0;
+		let backoffTime = 400; // approx block time
+		const start = Date.now();
+
+		while (totalTime < this.timeout) {
+			await new Promise((resolve) => setTimeout(resolve, backoffTime));
+
+			const rpcResponse = await this.connection.getSignatureStatuses([
+				signature,
+			]);
+
+			const signatureResult = rpcResponse && rpcResponse.value?.[0];
+
+			if (
+				rpcResponse &&
+				signatureResult &&
+				signatureResult.confirmationStatus === commitment
+			) {
+				return { context: rpcResponse.context, value: { err: null } };
+			}
+
+			totalTime += backoffTime;
+			backoffTime = Math.min(backoffTime * 2, 5000);
+		}
+
+		// Transaction not confirmed within 30 seconds
+		this.timeoutCount += 1;
+		const duration = (Date.now() - start) / 1000;
+		if (this.throwOnTimeoutError) {
+			throw new TxSendError(
+				`Transaction was not confirmed in ${duration.toFixed(
+					2
+				)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`,
+				NOT_CONFIRMED_ERROR_CODE
+			);
+		}
+	}
+
+	async confirmTransaction(
+		signature: TransactionSignature,
+		commitment?: Commitment
+	): Promise<RpcResponseAndContext<SignatureResult>> {
+		if (
+			this.confirmationStrategy === ConfirmationStrategy.WebSocket ||
+			this.confirmationStrategy === ConfirmationStrategy.Combo
+		) {
+			return await this.confirmTransactionWebSocket(signature, commitment);
+		} else if (this.confirmationStrategy === ConfirmationStrategy.Polling) {
+			return await this.confirmTransactionPolling(signature, commitment);
+		}
+	}
+
+	getTimestamp(): number {
+		return new Date().getTime();
+	}
+
+	promiseTimeout<T>(
+		promises: Promise<T>[],
+		timeoutMs: number
+	): Promise<T | null> {
+		let timeoutId: ReturnType<typeof setTimeout>;
+		const timeoutPromise: Promise<null> = new Promise((resolve) => {
+			timeoutId = setTimeout(() => resolve(null), timeoutMs);
+		});
+
+		return Promise.race([...promises, timeoutPromise]).then(
+			(result: T | null) => {
+				clearTimeout(timeoutId);
+				return result;
+			}
+		);
+	}
+
+	sendToAdditionalConnections(
+		rawTx: Buffer | Uint8Array,
+		opts: ConfirmOptions
+	): void {
+		this.additionalConnections.map((connection) => {
+			connection.sendRawTransaction(rawTx, opts).catch((e) => {
+				console.error(
+					// @ts-ignore
+					`error sending tx to additional connection ${connection._rpcEndpoint}`
+				);
+				console.error(e);
+			});
+		});
+		this.additionalTxSenderCallbacks?.map((callback) => {
+			callback(bs58.encode(rawTx));
+		});
+	}
+
+	public addAdditionalConnection(newConnection: Connection): void {
+		const alreadyUsingConnection =
+			this.additionalConnections.filter((connection) => {
+				// @ts-ignore
+				return connection._rpcEndpoint === newConnection.rpcEndpoint;
+			}).length > 0;
+
+		if (!alreadyUsingConnection) {
+			this.additionalConnections.push(newConnection);
+		}
+	}
+
+	public getTimeoutCount(): number {
+		return this.timeoutCount;
+	}
+
+	public async checkConfirmationResultForError(
+		txSig: string,
+		result: SignatureResult
+	): Promise<void> {
+		if (result?.err) {
+			await throwTransactionError(
+				txSig,
+				this.connection,
+				this.opts?.commitment
+			);
+		}
+
+		return;
+	}
+
+	public getTxLandRate(): number {
+		if (!this.trackTxLandRate) {
+			console.warn(
+				'trackTxLandRate is false, returning default land rate of 0'
+			);
+			return this.txLandRate;
+		}
+		const keys = this.txSigCache.keys();
+		const denominator = keys.length;
+		if (denominator === 0) {
+			return this.txLandRate;
+		}
+		let numerator = 0;
+		for (const key of keys) {
+			const value = this.txSigCache.get(key);
+			if (value) {
+				numerator += 1;
+			}
+		}
+		this.txLandRate = numerator / denominator;
+		return this.txLandRate;
+	}
+
+	private defaultLandRateToFeeFunc(txLandRate: number) {
+		if (
+			txLandRate >= BASELINE_TX_LAND_RATE ||
+			this.txSigCache.keys().length < 3
+		) {
+			return 1;
+		}
+		const multiplier =
+			10 * Math.log10(1 + (BASELINE_TX_LAND_RATE - txLandRate) * 5);
+		return Math.min(multiplier, 10);
+	}
+
+	public getSuggestedPriorityFeeMultiplier(): number {
+		if (!this.trackTxLandRate) {
+			console.warn(
+				'trackTxLandRate is false, returning default multiplier of 1'
+			);
+			return 1;
+		}
+		return this.landRateToFeeFunc(this.getTxLandRate());
+	}
+}

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