@velocity-exchange/sdk 0.3.0 → 0.6.0

package/src/tx/fastSingleTxSender.ts

@@ -1,146 +0,0 @@
-import { ConfirmationStrategy, TxSigAndSlot } from './types';
-import {
-	ConfirmOptions,
-	TransactionSignature,
-	Connection,
-	Commitment,
-	BlockhashWithExpiryBlockHeight,
-} from '@solana/web3.js';
-import { BaseTxSender } from './baseTxSender';
-import { TxHandler } from './txHandler';
-import { IWallet } from '../types';
-import { DEFAULT_CONFIRMATION_OPTS } from '../config';
-
-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?: BlockhashWithExpiryBlockHeight;
-	skipConfirmation: boolean;
-	confirmInBackground: boolean;
-	blockhashCommitment: Commitment;
-	blockhashIntervalId?: NodeJS.Timer;
-
-	public constructor({
-		connection,
-		wallet,
-		opts = { ...DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 },
-		timeout = DEFAULT_TIMEOUT,
-		blockhashRefreshInterval = DEFAULT_BLOCKHASH_REFRESH,
-		additionalConnections = new Array<Connection>(),
-		skipConfirmation = false,
-		confirmInBackground = false,
-		blockhashCommitment = 'finalized',
-		confirmationStrategy = ConfirmationStrategy.Combo,
-		trackTxLandRate,
-		txHandler,
-		txLandRateLookbackWindowMinutes,
-		landRateToFeeFunc,
-		throwOnTimeoutError = true,
-	}: {
-		connection: Connection;
-		wallet: IWallet;
-		opts?: ConfirmOptions;
-		timeout?: number;
-		blockhashRefreshInterval?: number;
-		additionalConnections?: Connection[];
-		skipConfirmation?: boolean;
-		confirmInBackground?: boolean;
-		blockhashCommitment?: Commitment;
-		confirmationStrategy?: ConfirmationStrategy;
-		trackTxLandRate?: boolean;
-		txHandler?: TxHandler;
-		txLandRateLookbackWindowMinutes?: number;
-		landRateToFeeFunc?: (landRate: number) => number;
-		throwOnTimeoutError?: boolean;
-	}) {
-		super({
-			connection,
-			wallet,
-			opts,
-			timeout,
-			additionalConnections,
-			confirmationStrategy,
-			txHandler,
-			trackTxLandRate,
-			txLandRateLookbackWindowMinutes,
-			landRateToFeeFunc,
-			throwOnTimeoutError,
-		});
-		this.connection = connection;
-		this.wallet = wallet;
-		this.opts = opts;
-		this.timeout = timeout;
-		this.blockhashRefreshInterval = blockhashRefreshInterval;
-		this.additionalConnections = additionalConnections;
-		this.skipConfirmation = skipConfirmation;
-		this.confirmInBackground = confirmInBackground;
-		this.blockhashCommitment = blockhashCommitment;
-		this.startBlockhashRefreshLoop();
-	}
-
-	startBlockhashRefreshLoop(): void {
-		if (this.blockhashRefreshInterval > 0) {
-			this.blockhashIntervalId = setInterval(async () => {
-				try {
-					this.recentBlockhash = await this.connection.getLatestBlockhash(
-						this.blockhashCommitment
-					);
-				} catch (e) {
-					console.error('Error in startBlockhashRefreshLoop: ', e);
-				}
-			}, this.blockhashRefreshInterval);
-		}
-	}
-
-	async sendRawTransaction(
-		rawTransaction: Buffer | Uint8Array,
-		opts: ConfirmOptions
-	): Promise<TxSigAndSlot> {
-		let txid: TransactionSignature;
-		try {
-			txid = await this.connection.sendRawTransaction(rawTransaction, opts);
-			this.txSigCache?.set(txid, false);
-			this.sendToAdditionalConnections(rawTransaction, opts);
-		} catch (e) {
-			console.error(e);
-			throw e;
-		}
-
-		let slot: number | undefined;
-		if (!this.skipConfirmation) {
-			try {
-				if (this.confirmInBackground) {
-					this.confirmTransaction(txid, opts.commitment).then(
-						async (result) => {
-							this.txSigCache?.set(txid, true);
-							if (result) {
-								await this.checkConfirmationResultForError(txid, result.value);
-								slot = result.context.slot;
-							}
-						}
-					);
-				} else {
-					const result = await this.confirmTransaction(txid, opts.commitment);
-					this.txSigCache?.set(txid, true);
-					if (result) {
-						await this.checkConfirmationResultForError(txid, result.value);
-						slot = result.context.slot;
-					}
-				}
-			} catch (e) {
-				console.error(e);
-				throw e;
-			}
-		}
-
-		return { txSig: txid, slot };
-	}
-}

package/src/tx/forwardOnlyTxSender.ts

@@ -1,145 +0,0 @@
-import {
-	ConfirmOptions,
-	Connection,
-	VersionedTransaction,
-} from '@solana/web3.js';
-import bs58 from 'bs58';
-import { BaseTxSender } from './baseTxSender';
-import { ConfirmationStrategy, TxSigAndSlot } from './types';
-import { TxHandler } from './txHandler';
-import { IWallet } from '../types';
-import { DEFAULT_CONFIRMATION_OPTS } from '../config';
-
-const DEFAULT_TIMEOUT = 35000;
-const DEFAULT_RETRY = 5000;
-
-type ResolveReference = {
-	resolve?: () => void;
-};
-
-export class ForwardOnlyTxSender extends BaseTxSender {
-	connection: Connection;
-	wallet: IWallet;
-	opts: ConfirmOptions;
-	timeout: number;
-	retrySleep: number;
-	additionalConnections: Connection[];
-	timoutCount = 0;
-
-	public constructor({
-		connection,
-		wallet,
-		opts = { ...DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 },
-		timeout = DEFAULT_TIMEOUT,
-		retrySleep = DEFAULT_RETRY,
-		confirmationStrategy = ConfirmationStrategy.Combo,
-		additionalTxSenderCallbacks = [],
-		txHandler,
-		trackTxLandRate,
-		txLandRateLookbackWindowMinutes,
-		landRateToFeeFunc,
-		throwOnTimeoutError = true,
-	}: {
-		connection: Connection;
-		wallet: IWallet;
-		opts?: ConfirmOptions;
-		timeout?: number;
-		retrySleep?: number;
-		confirmationStrategy?: ConfirmationStrategy;
-		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
-		txHandler?: TxHandler;
-		trackTxLandRate?: boolean;
-		txLandRateLookbackWindowMinutes?: number;
-		landRateToFeeFunc?: (landRate: number) => number;
-		throwOnTimeoutError?: boolean;
-	}) {
-		super({
-			connection,
-			wallet,
-			opts,
-			timeout,
-			additionalConnections: [],
-			confirmationStrategy,
-			additionalTxSenderCallbacks,
-			txHandler,
-			trackTxLandRate,
-			txLandRateLookbackWindowMinutes,
-			landRateToFeeFunc,
-			throwOnTimeoutError,
-		});
-		this.connection = connection;
-		this.wallet = wallet;
-		this.opts = opts;
-		this.timeout = timeout;
-		this.retrySleep = retrySleep;
-		this.additionalConnections = [];
-	}
-
-	async sleep(reference: ResolveReference): Promise<void> {
-		return new Promise((resolve) => {
-			reference.resolve = resolve;
-			setTimeout(resolve, this.retrySleep);
-		});
-	}
-
-	sendToAdditionalConnections(
-		rawTx: Buffer | Uint8Array,
-		_opts: ConfirmOptions
-	): void {
-		this.additionalTxSenderCallbacks?.map((callback) => {
-			callback(bs58.encode(rawTx));
-		});
-	}
-
-	async sendRawTransaction(
-		rawTransaction: Buffer | Uint8Array,
-		opts: ConfirmOptions
-	): Promise<TxSigAndSlot> {
-		const deserializedTx = VersionedTransaction.deserialize(rawTransaction);
-
-		const txSig = deserializedTx.signatures[0];
-		const encodedTxSig = bs58.encode(txSig);
-
-		const startTime = this.getTimestamp();
-
-		this.sendToAdditionalConnections(rawTransaction, opts);
-		this.txSigCache?.set(encodedTxSig, false);
-
-		let done = false;
-		const resolveReference: ResolveReference = {
-			resolve: undefined,
-		};
-		const stopWaiting = () => {
-			done = true;
-			if (resolveReference.resolve) {
-				resolveReference.resolve();
-			}
-		};
-
-		(async () => {
-			while (!done && this.getTimestamp() - startTime < this.timeout) {
-				await this.sleep(resolveReference);
-				if (!done) {
-					this.sendToAdditionalConnections(rawTransaction, opts);
-				}
-			}
-		})();
-
-		let slot: number | undefined;
-		try {
-			const result = await this.confirmTransaction(
-				encodedTxSig,
-				opts.commitment
-			);
-			slot = result?.context?.slot;
-			this.txSigCache?.set(encodedTxSig, true);
-			// eslint-disable-next-line no-useless-catch
-		} catch (e) {
-			throw e;
-		} finally {
-			stopWaiting();
-		}
-
-		return { txSig: encodedTxSig, slot };
-	}
-}

package/src/tx/priorityFeeCalculator.ts

@@ -1,117 +0,0 @@
-import { ComputeBudgetProgram, TransactionInstruction } from '@solana/web3.js';
-
-/**
- * This class determines whether a priority fee needs to be included in a transaction based on
- * a recent history of timed out transactions.
- */
-export class PriorityFeeCalculator {
-	lastTxTimeoutCount: number;
-	priorityFeeTriggered: boolean;
-	lastTxTimeoutCountTriggered: number;
-	priorityFeeLatchDurationMs: number; // how long to stay in triggered state before resetting
-
-	/**
-	 * Constructor for the PriorityFeeCalculator class.
-	 * @param currentTimeMs - The current time in milliseconds.
-	 * @param priorityFeeLatchDurationMs - The duration for how long to stay in triggered state before resetting. Default value is 10 seconds.
-	 */
-	constructor(
-		currentTimeMs: number,
-		priorityFeeLatchDurationMs: number = 10 * 1000
-	) {
-		this.lastTxTimeoutCount = 0;
-		this.priorityFeeTriggered = false;
-		this.lastTxTimeoutCountTriggered = currentTimeMs;
-		this.priorityFeeLatchDurationMs = priorityFeeLatchDurationMs;
-	}
-
-	/**
-	 * Update the priority fee state based on the current time and the current timeout count.
-	 * @param currentTimeMs current time in milliseconds
-	 * @returns true if priority fee should be included in the next transaction
-	 */
-	public updatePriorityFee(
-		currentTimeMs: number,
-		txTimeoutCount: number
-	): boolean {
-		let triggerPriorityFee = false;
-
-		if (txTimeoutCount > this.lastTxTimeoutCount) {
-			this.lastTxTimeoutCount = txTimeoutCount;
-			this.lastTxTimeoutCountTriggered = currentTimeMs;
-			triggerPriorityFee = true;
-		} else {
-			if (!this.priorityFeeTriggered) {
-				triggerPriorityFee = false;
-			} else if (
-				currentTimeMs - this.lastTxTimeoutCountTriggered <
-				this.priorityFeeLatchDurationMs
-			) {
-				triggerPriorityFee = true;
-			}
-		}
-
-		this.priorityFeeTriggered = triggerPriorityFee;
-
-		return triggerPriorityFee;
-	}
-
-	/**
-	 * This method returns a transaction instruction list that sets the compute limit on the ComputeBudget program.
-	 * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
-	 * @returns An array of transaction instructions.
-	 */
-	public generateComputeBudgetIxs(
-		computeUnitLimit: number
-	): Array<TransactionInstruction> {
-		const ixs = [
-			ComputeBudgetProgram.setComputeUnitLimit({
-				units: computeUnitLimit,
-			}),
-		];
-
-		return ixs;
-	}
-
-	/**
-	 * Calculates the compute unit price to use based on the desired additional fee to pay and the compute unit limit.
-	 * @param computeUnitLimit desired CU to use
-	 * @param additionalFeeMicroLamports desired additional fee to pay, in micro lamports
-	 * @returns the compute unit price to use, in micro lamports
-	 */
-	public calculateComputeUnitPrice(
-		computeUnitLimit: number,
-		additionalFeeMicroLamports: number
-	): number {
-		return additionalFeeMicroLamports / computeUnitLimit;
-	}
-
-	/**
-	 * This method generates a list of transaction instructions for the ComputeBudget program, and includes a priority fee if it's required
-	 * @param computeUnitLimit - The maximum number of compute units that can be used by the transaction.
-	 * @param usePriorityFee - A boolean indicating whether to include a priority fee in the transaction, this should be from `this.updatePriorityFee()` or `this.priorityFeeTriggered`.
-	 * @param additionalFeeMicroLamports - The additional fee to be paid, in micro lamports, the actual price will be calculated.
-	 * @returns An array of transaction instructions.
-	 */
-	public generateComputeBudgetWithPriorityFeeIx(
-		computeUnitLimit: number,
-		usePriorityFee: boolean,
-		additionalFeeMicroLamports: number
-	): Array<TransactionInstruction> {
-		const ixs = this.generateComputeBudgetIxs(computeUnitLimit);
-
-		if (usePriorityFee) {
-			const computeUnitPrice = this.calculateComputeUnitPrice(
-				computeUnitLimit,
-				additionalFeeMicroLamports
-			);
-			ixs.push(
-				ComputeBudgetProgram.setComputeUnitPrice({
-					microLamports: computeUnitPrice,
-				})
-			);
-		}
-
-		return ixs;
-	}
-}

package/src/tx/reportTransactionError.ts

@@ -1,164 +0,0 @@
-import {
-	Commitment,
-	Connection,
-	Finality,
-	SendTransactionError,
-	VersionedTransactionResponse,
-} from '@solana/web3.js';
-import { DEFAULT_CONFIRMATION_OPTS } from '../config';
-
-/**
- * The new getTransaction method expects a Finality type instead of a Commitment type. The only options for Finality are 'confirmed' and 'finalized'.
- * @param commitment
- * @returns
- */
-const commitmentToFinality = (commitment: Commitment): Finality => {
-	switch (commitment) {
-		case 'confirmed':
-			return 'confirmed';
-		case 'finalized':
-			return 'finalized';
-		default:
-			throw new Error(
-				`Invalid commitment when reporting transaction error. The commitment must be 'confirmed' or 'finalized' but was given '${commitment}'. If you're using this commitment for a specific reason, you may need to roll your own logic here.`
-			);
-	}
-};
-
-const getTransactionResult = async (
-	txSig: string,
-	connection: Connection,
-	commitment?: Commitment
-): Promise<VersionedTransactionResponse | null> => {
-	const resolvedCommitment =
-		commitment || connection.commitment || DEFAULT_CONFIRMATION_OPTS.commitment;
-	if (!resolvedCommitment) {
-		throw new Error(
-			'No commitment available when reporting transaction error. Provide a commitment, set one on the connection, or configure DEFAULT_CONFIRMATION_OPTS.'
-		);
-	}
-	const finality = commitmentToFinality(resolvedCommitment);
-	return await connection.getTransaction(txSig, {
-		maxSupportedTransactionVersion: 0,
-		commitment: finality,
-	});
-};
-
-const getTransactionResultWithRetry = async (
-	txSig: string,
-	connection: Connection,
-	commitment?: Commitment
-): Promise<VersionedTransactionResponse | null> => {
-	const start = Date.now();
-
-	const retryTimeout = 3_000; // Timeout after 3 seconds
-	const retryInterval = 800; // Retry with 800ms interval
-	const retryCount = 3; // Retry 3 times
-
-	let currentCount = 0;
-	let transactionResult = await getTransactionResult(
-		txSig,
-		connection,
-		commitment
-	);
-
-	// Retry 3 times or until timeout as long as we don't have a result yet
-	while (
-		!transactionResult &&
-		Date.now() - start < retryTimeout &&
-		currentCount < retryCount
-	) {
-		// Sleep for 1 second :: Do this first so that we don't run the first loop immediately after the initial fetch above
-		await new Promise((resolve) => setTimeout(resolve, retryInterval));
-
-		transactionResult = await getTransactionResult(
-			txSig,
-			connection,
-			commitment
-		);
-		currentCount++;
-	}
-
-	return transactionResult;
-};
-
-/**
- * THROWS if there is an error
- *
- * Should only be used for a txSig that is confirmed has an error. There is a race-condition where sometimes the transaction is not instantly available to fetch after the confirmation has already failed with an error, so this method has retry logic which we don't want to do wastefully. This method will throw a generic error if it can't get the transaction result after a retry period.
- * @param txSig
- * @param connection
- * @returns
- */
-export const throwTransactionError = async (
-	txSig: string,
-	connection: Connection,
-	commitment?: Commitment
-): Promise<void> => {
-	const err = await getTransactionErrorFromTxSig(txSig, connection, commitment);
-
-	if (err) {
-		throw err;
-	}
-
-	return;
-};
-
-/**
- * RETURNS an error if there is one
- *
- * Should only be used for a txSig that is confirmed has an error. There is a race-condition where sometimes the transaction is not instantly available to fetch after the confirmation has already failed with an error, so this method has retry logic which we don't want to do wastefully. This method will throw a generic error if it can't get the transaction result after a retry period.
- * @param txSig
- * @param connection
- * @returns
- */
-export const getTransactionErrorFromTxSig = async (
-	txSig: string,
-	connection: Connection,
-	commitment?: Commitment
-): Promise<SendTransactionError | undefined> => {
-	const transactionResult = await getTransactionResultWithRetry(
-		txSig,
-		connection,
-		commitment
-	);
-
-	if (!transactionResult) {
-		// Throw a generic error because we couldn't get the transaction result for the given txSig
-		return new SendTransactionError({
-			action: 'send',
-			signature: txSig,
-			transactionMessage: `Transaction Failed`,
-		});
-	}
-
-	if (!transactionResult?.meta?.err) {
-		// Assume that the transaction was successful and we are here erroneously because we have a result with no error
-		return;
-	}
-
-	return getTransactionError(transactionResult);
-};
-
-export const getTransactionError = (
-	transactionResult: VersionedTransactionResponse
-): SendTransactionError | undefined => {
-	if (!transactionResult?.meta?.err) {
-		return;
-	}
-
-	const logs = transactionResult?.meta?.logMessages ?? ['No logs'];
-
-	const lastLog = logs[logs.length - 1];
-
-	const friendlyMessage = lastLog?.match(/(failed:) (.+)/)?.[2];
-
-	return new SendTransactionError({
-		action: 'send',
-		signature: transactionResult?.transaction?.signatures?.[0],
-		transactionMessage: `Transaction Failed${
-			friendlyMessage ? `: ${friendlyMessage}` : ''
-		}`,
-		logs,
-	});
-};

package/src/tx/retryTxSender.ts

@@ -1,137 +0,0 @@
-import { ConfirmationStrategy, TxSigAndSlot } from './types';
-import { ConfirmOptions, Connection } from '@solana/web3.js';
-import { BaseTxSender } from './baseTxSender';
-import { TxHandler } from './txHandler';
-import { IWallet } from '../types';
-import { DEFAULT_CONFIRMATION_OPTS } from '../config';
-
-const DEFAULT_TIMEOUT = 35000;
-const DEFAULT_RETRY = 2000;
-
-type ResolveReference = {
-	resolve?: () => void;
-};
-
-export class RetryTxSender extends BaseTxSender {
-	connection: Connection;
-	wallet: IWallet;
-	opts: ConfirmOptions;
-	timeout: number;
-	retrySleep: number;
-	additionalConnections: Connection[];
-	timoutCount = 0;
-
-	public constructor({
-		connection,
-		wallet,
-		opts = { ...DEFAULT_CONFIRMATION_OPTS, maxRetries: 0 },
-		timeout = DEFAULT_TIMEOUT,
-		retrySleep = DEFAULT_RETRY,
-		additionalConnections = new Array<Connection>(),
-		confirmationStrategy = ConfirmationStrategy.Combo,
-		additionalTxSenderCallbacks = [],
-		txHandler,
-		trackTxLandRate,
-		txLandRateLookbackWindowMinutes,
-		landRateToFeeFunc,
-		throwOnTimeoutError = true,
-	}: {
-		connection: Connection;
-		wallet: IWallet;
-		opts?: ConfirmOptions;
-		timeout?: number;
-		retrySleep?: number;
-		additionalConnections?: Connection[];
-		confirmationStrategy?: ConfirmationStrategy;
-		additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
-		txHandler?: TxHandler;
-		trackTxLandRate?: boolean;
-		txLandRateLookbackWindowMinutes?: number;
-		landRateToFeeFunc?: (landRate: number) => number;
-		throwOnTimeoutError?: boolean;
-	}) {
-		super({
-			connection,
-			wallet,
-			opts,
-			timeout,
-			additionalConnections,
-			confirmationStrategy,
-			additionalTxSenderCallbacks,
-			txHandler,
-			trackTxLandRate,
-			txLandRateLookbackWindowMinutes,
-			landRateToFeeFunc,
-			throwOnTimeoutError,
-		});
-		this.connection = connection;
-		this.wallet = wallet;
-		this.opts = opts;
-		this.timeout = timeout;
-		this.retrySleep = retrySleep;
-		this.additionalConnections = additionalConnections;
-	}
-
-	async sleep(reference: ResolveReference): Promise<void> {
-		return new Promise((resolve) => {
-			reference.resolve = resolve;
-			setTimeout(resolve, this.retrySleep);
-		});
-	}
-
-	async sendRawTransaction(
-		rawTransaction: Buffer | Uint8Array,
-		opts: ConfirmOptions
-	): Promise<TxSigAndSlot> {
-		const startTime = this.getTimestamp();
-
-		const txid = await this.connection.sendRawTransaction(rawTransaction, opts);
-		this.txSigCache?.set(txid, false);
-		this.sendToAdditionalConnections(rawTransaction, opts);
-
-		let done = false;
-		const resolveReference: ResolveReference = {
-			resolve: undefined,
-		};
-		const stopWaiting = () => {
-			done = true;
-			if (resolveReference.resolve) {
-				resolveReference.resolve();
-			}
-		};
-
-		(async () => {
-			while (!done && this.getTimestamp() - startTime < this.timeout) {
-				await this.sleep(resolveReference);
-				if (!done) {
-					this.connection
-						.sendRawTransaction(rawTransaction, opts)
-						.catch((e) => {
-							console.error(e);
-							stopWaiting();
-						});
-					this.sendToAdditionalConnections(rawTransaction, opts);
-				}
-			}
-		})();
-
-		let slot: number | undefined;
-		try {
-			const result = await this.confirmTransaction(txid, opts.commitment);
-			this.txSigCache?.set(txid, true);
-
-			if (result) {
-				await this.checkConfirmationResultForError(txid, result.value);
-
-				slot = result.context?.slot;
-			}
-			// eslint-disable-next-line no-useless-catch
-		} catch (e) {
-			throw e;
-		} finally {
-			stopWaiting();
-		}
-
-		return { txSig: txid, slot };
-	}
-}