@drift-labs/sdk 2.37.1-beta.1 → 2.37.1-beta.2

package/src/tx/baseTxSender.ts

@@ -0,0 +1,276 @@
+import { TxSender, TxSigAndSlot } from './types';
+import {
+	Commitment,
+	ConfirmOptions,
+	Context,
+	RpcResponseAndContext,
+	Signer,
+	SignatureResult,
+	Transaction,
+	TransactionSignature,
+	Connection,
+	VersionedTransaction,
+	TransactionMessage,
+	TransactionInstruction,
+	AddressLookupTableAccount,
+} from '@solana/web3.js';
+import { AnchorProvider } from '@coral-xyz/anchor';
+import assert from 'assert';
+import bs58 from 'bs58';
+import { IWallet } from '../types';
+
+const DEFAULT_TIMEOUT = 35000;
+
+export abstract class BaseTxSender implements TxSender {
+	connection: Connection;
+	wallet: IWallet;
+	opts: ConfirmOptions;
+	timeout: number;
+	additionalConnections: Connection[];
+	timeoutCount = 0;
+
+	public constructor({
+		connection,
+		wallet,
+		opts = AnchorProvider.defaultOptions(),
+		timeout = DEFAULT_TIMEOUT,
+		additionalConnections = new Array<Connection>(),
+	}: {
+		connection: Connection;
+		wallet: IWallet;
+		opts?: ConfirmOptions;
+		timeout?: number;
+		additionalConnections?;
+	}) {
+		this.connection = connection;
+		this.wallet = wallet;
+		this.opts = opts;
+		this.timeout = timeout;
+		this.additionalConnections = additionalConnections;
+	}
+
+	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 = preSigned
+			? tx
+			: await this.prepareTx(tx, additionalSigners, opts);
+
+		return this.sendRawTransaction(signedTx.serialize(), opts);
+	}
+
+	async prepareTx(
+		tx: Transaction,
+		additionalSigners: Array<Signer>,
+		opts: ConfirmOptions
+	): Promise<Transaction> {
+		tx.feePayer = this.wallet.publicKey;
+		tx.recentBlockhash = (
+			await this.connection.getLatestBlockhash(opts.preflightCommitment)
+		).blockhash;
+
+		additionalSigners
+			.filter((s): s is Signer => s !== undefined)
+			.forEach((kp) => {
+				tx.partialSign(kp);
+			});
+
+		const signedTx = await this.wallet.signTransaction(tx);
+
+		return signedTx;
+	}
+
+	async getVersionedTransaction(
+		ixs: TransactionInstruction[],
+		lookupTableAccounts: AddressLookupTableAccount[],
+		additionalSigners?: Array<Signer>,
+		opts?: ConfirmOptions
+	): Promise<VersionedTransaction> {
+		if (additionalSigners === undefined) {
+			additionalSigners = [];
+		}
+		if (opts === undefined) {
+			opts = this.opts;
+		}
+
+		const message = new TransactionMessage({
+			payerKey: this.wallet.publicKey,
+			recentBlockhash: (
+				await this.connection.getLatestBlockhash(opts.preflightCommitment)
+			).blockhash,
+			instructions: ixs,
+		}).compileToV0Message(lookupTableAccounts);
+
+		const tx = new VersionedTransaction(message);
+
+		return tx;
+	}
+
+	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 {
+			additionalSigners
+				?.filter((s): s is Signer => s !== undefined)
+				.forEach((kp) => {
+					tx.sign([kp]);
+				});
+			// @ts-ignore
+			signedTx = await this.wallet.signTransaction(tx);
+		}
+
+		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');
+	}
+
+	async confirmTransaction(
+		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) {
+			this.timeoutCount += 1;
+			const duration = (Date.now() - start) / 1000;
+			throw new Error(
+				`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.`
+			);
+		}
+
+		return response;
+	}
+
+	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);
+			});
+		});
+	}
+
+	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;
+	}
+}

package/src/tx/fastSingleTxSender.ts

@@ -0,0 +1,142 @@
+import { TxSigAndSlot } from './types';
+import {
+	ConfirmOptions,
+	Signer,
+	Transaction,
+	TransactionSignature,
+	Connection,
+	VersionedTransaction,
+	TransactionMessage,
+	TransactionInstruction,
+	AddressLookupTableAccount,
+} from '@solana/web3.js';
+import { AnchorProvider } from '@coral-xyz/anchor';
+import { IWallet } from '../types';
+import { BaseTxSender } from './baseTxSender';
+
+const DEFAULT_TIMEOUT = 35000;
+const DEFAULT_BLOCKHASH_REFRESH = 10000;
+
+export class FastSingleTxSender extends BaseTxSender {
+	connection: Connection;
+	wallet: IWallet;
+	opts: ConfirmOptions;
+	timeout: number;
+	blockhashRefreshInterval: number;
+	additionalConnections: Connection[];
+	timoutCount = 0;
+	recentBlockhash: string;
+
+	public constructor({
+		connection,
+		wallet,
+		opts = AnchorProvider.defaultOptions(),
+		timeout = DEFAULT_TIMEOUT,
+		blockhashRefreshInterval = DEFAULT_BLOCKHASH_REFRESH,
+		additionalConnections = new Array<Connection>(),
+	}: {
+		connection: Connection;
+		wallet: IWallet;
+		opts?: ConfirmOptions;
+		timeout?: number;
+		blockhashRefreshInterval?: number;
+		additionalConnections?;
+	}) {
+		super({ connection, wallet, opts, timeout, additionalConnections });
+		this.connection = connection;
+		this.wallet = wallet;
+		this.opts = opts;
+		this.timeout = timeout;
+		this.blockhashRefreshInterval = blockhashRefreshInterval;
+		this.additionalConnections = additionalConnections;
+		this.startBlockhashRefreshLoop();
+	}
+
+	startBlockhashRefreshLoop(): void {
+		setInterval(async () => {
+			this.recentBlockhash = (
+				await this.connection.getLatestBlockhash(this.opts)
+			).blockhash;
+		}, this.blockhashRefreshInterval);
+	}
+
+	async prepareTx(
+		tx: Transaction,
+		additionalSigners: Array<Signer>,
+		opts: ConfirmOptions
+	): Promise<Transaction> {
+		tx.feePayer = this.wallet.publicKey;
+
+		tx.recentBlockhash =
+			this.recentBlockhash ??
+			(await this.connection.getLatestBlockhash(opts.preflightCommitment))
+				.blockhash;
+
+		additionalSigners
+			.filter((s): s is Signer => s !== undefined)
+			.forEach((kp) => {
+				tx.partialSign(kp);
+			});
+
+		const signedTx = await this.wallet.signTransaction(tx);
+
+		return signedTx;
+	}
+
+	async getVersionedTransaction(
+		ixs: TransactionInstruction[],
+		lookupTableAccounts: AddressLookupTableAccount[],
+		additionalSigners?: Array<Signer>,
+		opts?: ConfirmOptions
+	): Promise<VersionedTransaction> {
+		if (additionalSigners === undefined) {
+			additionalSigners = [];
+		}
+		if (opts === undefined) {
+			opts = this.opts;
+		}
+
+		const message = new TransactionMessage({
+			payerKey: this.wallet.publicKey,
+			recentBlockhash:
+				this.recentBlockhash ??
+				(await this.connection.getLatestBlockhash(opts.preflightCommitment))
+					.blockhash,
+			instructions: ixs,
+		}).compileToV0Message(lookupTableAccounts);
+
+		const tx = new VersionedTransaction(message);
+
+		return tx;
+	}
+
+	async sendRawTransaction(
+		rawTransaction: Buffer | Uint8Array,
+		opts: ConfirmOptions
+	): Promise<TxSigAndSlot> {
+		let txid: TransactionSignature;
+		try {
+			txid = await this.connection.sendRawTransaction(rawTransaction, opts);
+			this.sendToAdditionalConnections(rawTransaction, opts);
+		} catch (e) {
+			console.error(e);
+			throw e;
+		}
+
+		this.connection.sendRawTransaction(rawTransaction, opts).catch((e) => {
+			console.error(e);
+		});
+		this.sendToAdditionalConnections(rawTransaction, opts);
+
+		let slot: number;
+		try {
+			const result = await this.confirmTransaction(txid, opts.commitment);
+			slot = result.context.slot;
+		} catch (e) {
+			console.error(e);
+			throw e;
+		}
+
+		return { txSig: txid, slot };
+	}
+}

package/src/tx/retryTxSender.ts

@@ -1,23 +1,12 @@
-import { TxSender, TxSigAndSlot } from './types';
+import { TxSigAndSlot } from './types';
 import {
-	Commitment,
 	ConfirmOptions,
-	Context,
-	RpcResponseAndContext,
-	Signer,
-	SignatureResult,
-	Transaction,
 	TransactionSignature,
 	Connection,
-	VersionedTransaction,
-	TransactionMessage,
-	TransactionInstruction,
-	AddressLookupTableAccount,
 } from '@solana/web3.js';
 import { AnchorProvider } from '@coral-xyz/anchor';
-import assert from 'assert';
-import bs58 from 'bs58';
 import { IWallet } from '../types';
+import { BaseTxSender } from './baseTxSender';
 
 const DEFAULT_TIMEOUT = 35000;
 const DEFAULT_RETRY = 8000;
@@ -26,7 +15,7 @@ type ResolveReference = {
 	resolve?: () => void;
 };
 
-export class RetryTxSender implements TxSender {
+export class RetryTxSender extends BaseTxSender {
 	connection: Connection;
 	wallet: IWallet;
 	opts: ConfirmOptions;
@@ -50,6 +39,7 @@ export class RetryTxSender implements TxSender {
 		retrySleep?: number;
 		additionalConnections?;
 	}) {
+		super({ connection, wallet, opts, timeout, additionalConnections });
 		this.connection = connection;
 		this.wallet = wallet;
 		this.opts = opts;
@@ -58,102 +48,11 @@ export class RetryTxSender implements TxSender {
 		this.additionalConnections = additionalConnections;
 	}
 
-	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 = preSigned
-			? tx
-			: await this.prepareTx(tx, additionalSigners, opts);
-
-		return this.sendRawTransaction(signedTx.serialize(), opts);
-	}
-
-	async prepareTx(
-		tx: Transaction,
-		additionalSigners: Array<Signer>,
-		opts: ConfirmOptions
-	): Promise<Transaction> {
-		tx.feePayer = this.wallet.publicKey;
-		tx.recentBlockhash = (
-			await this.connection.getRecentBlockhash(opts.preflightCommitment)
-		).blockhash;
-
-		additionalSigners
-			.filter((s): s is Signer => s !== undefined)
-			.forEach((kp) => {
-				tx.partialSign(kp);
-			});
-
-		const signedTx = await this.wallet.signTransaction(tx);
-
-		return signedTx;
-	}
-
-	async getVersionedTransaction(
-		ixs: TransactionInstruction[],
-		lookupTableAccounts: AddressLookupTableAccount[],
-		additionalSigners?: Array<Signer>,
-		opts?: ConfirmOptions
-	): Promise<VersionedTransaction> {
-		if (additionalSigners === undefined) {
-			additionalSigners = [];
-		}
-		if (opts === undefined) {
-			opts = this.opts;
-		}
-
-		const message = new TransactionMessage({
-			payerKey: this.wallet.publicKey,
-			recentBlockhash: (
-				await this.connection.getRecentBlockhash(opts.preflightCommitment)
-			).blockhash,
-			instructions: ixs,
-		}).compileToV0Message(lookupTableAccounts);
-
-		const tx = new VersionedTransaction(message);
-
-		return tx;
-	}
-
-	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 {
-			additionalSigners
-				?.filter((s): s is Signer => s !== undefined)
-				.forEach((kp) => {
-					tx.sign([kp]);
-				});
-			// @ts-ignore
-			signedTx = await this.wallet.signTransaction(tx);
-		}
-
-		if (opts === undefined) {
-			opts = this.opts;
-		}
-
-		return this.sendRawTransaction(signedTx.serialize(), opts);
+	async sleep(reference: ResolveReference): Promise<void> {
+		return new Promise((resolve) => {
+			reference.resolve = resolve;
+			setTimeout(resolve, this.retrySleep);
+		});
 	}
 
 	async sendRawTransaction(
@@ -210,129 +109,4 @@ export class RetryTxSender implements TxSender {
 
 		return { txSig: txid, slot };
 	}
-
-	async confirmTransaction(
-		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) {
-			this.timoutCount += 1;
-			const duration = (Date.now() - start) / 1000;
-			throw new Error(
-				`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.`
-			);
-		}
-
-		return response;
-	}
-
-	getTimestamp(): number {
-		return new Date().getTime();
-	}
-
-	async sleep(reference: ResolveReference): Promise<void> {
-		return new Promise((resolve) => {
-			reference.resolve = resolve;
-			setTimeout(resolve, this.retrySleep);
-		});
-	}
-
-	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);
-			});
-		});
-	}
-
-	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.timoutCount;
-	}
 }