@velocity-exchange/sdk 0.4.0 → 0.6.0

package/src/tx/reportTransactionError.ts

@@ -1,176 +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 - Signature of the transaction already known/confirmed to have failed.
- * @param connection - RPC connection used to fetch the transaction (retried up to 3 times over ~3s).
- * @param commitment - Commitment to fetch at; defaults to `connection.commitment`, then `DEFAULT_CONFIRMATION_OPTS.commitment`. Must resolve to `'confirmed'` or `'finalized'`.
- * @returns Resolves with no value if no error could be extracted (should not normally happen for a known-failed signature).
- * @throws SendTransactionError with the resolved on-chain error/logs — or a generic "Transaction Failed" error if the transaction result couldn't be fetched after retrying.
- */
-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 - Signature of the transaction already known/confirmed to have failed.
- * @param connection - RPC connection used to fetch the transaction (retried up to 3 times over ~3s).
- * @param commitment - Commitment to fetch at; defaults to `connection.commitment`, then `DEFAULT_CONFIRMATION_OPTS.commitment`. Must resolve to `'confirmed'` or `'finalized'`.
- * @returns The resolved `SendTransactionError` (with parsed logs/friendly message), a generic
- * "Transaction Failed" `SendTransactionError` if the transaction couldn't be fetched after
- * retrying, or `undefined` if the fetched transaction unexpectedly has no recorded error.
- */
-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);
-};
-
-/**
- * Builds a `SendTransactionError` from an already-fetched transaction response, extracting a
- * "friendly" message from the last log line (matching `failed: <message>`) when present.
- * @param transactionResult - A fetched `VersionedTransactionResponse`.
- * @returns A `SendTransactionError` populated with the signature, logs, and (if parseable) a
- * friendly failure message, or `undefined` if `transactionResult.meta.err` is not set.
- */
-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,177 +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;
-};
-
-/**
- * Default `TxSender` for most clients: sends a transaction once, then keeps resending the exact
- * same signed bytes (to `connection` and every `additionalConnections` entry) every `retrySleep`
- * ms until it confirms or `timeout` elapses. This is client-side resend, independent of the RPC
- * node's own forwarding — useful when relying on rebroadcast to improve inclusion odds under
- * congestion, at the cost of extra RPC load compared to `FastSingleTxSender`.
- */
-export class RetryTxSender extends BaseTxSender {
-	connection: Connection;
-	wallet: IWallet;
-	opts: ConfirmOptions;
-	timeout: number;
-	/** Interval (ms) between resend attempts of the same signed transaction. */
-	retrySleep: number;
-	additionalConnections: Connection[];
-	timoutCount = 0;
-
-	/**
-	 * @param props.connection - RPC connection used for sending, resending, and confirming.
-	 * @param props.wallet - Wallet used to sign transactions that aren't already `preSigned`.
-	 * @param props.opts - Default `ConfirmOptions`; defaults to `DEFAULT_CONFIRMATION_OPTS` with `maxRetries: 0` (retries are handled by this sender's own resend loop, not the RPC node).
-	 * @param props.timeout - Total time (ms) to keep resending and waiting for confirmation before giving up; defaults to 35000 (35s).
-	 * @param props.retrySleep - Interval (ms) between resend attempts; defaults to 2000 (2s).
-	 * @param props.additionalConnections - Extra connections to also (re)broadcast raw transactions to.
-	 * @param props.confirmationStrategy - How to wait for confirmation; defaults to `ConfirmationStrategy.Combo`.
-	 * @param props.additionalTxSenderCallbacks - Callbacks invoked with each (re)sent transaction's base58 encoding.
-	 * @param props.txHandler - Custom `TxHandler` for signing/building transactions.
-	 * @param props.trackTxLandRate - Enables land-rate tracking.
-	 * @param props.txLandRateLookbackWindowMinutes - Rolling window, in minutes, for the land-rate calculation.
-	 * @param props.landRateToFeeFunc - Custom mapping from land rate to priority-fee multiplier.
-	 * @param props.throwOnTimeoutError - Whether confirmation timeouts throw `TxSendError`; defaults to `true`.
-	 */
-	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;
-	}
-
-	/**
-	 * Waits `retrySleep` milliseconds, exposing an early-wake `resolve` via `reference` so the
-	 * resend loop in `sendRawTransaction` can stop promptly once the transaction confirms or a
-	 * resend fails.
-	 * @param reference - Mutable holder `sendRawTransaction` uses to resolve this sleep early.
-	 */
-	async sleep(reference: ResolveReference): Promise<void> {
-		return new Promise((resolve) => {
-			reference.resolve = resolve;
-			setTimeout(resolve, this.retrySleep);
-		});
-	}
-
-	/**
-	 * Sends a raw transaction, then repeatedly resends the identical signed bytes to `connection`
-	 * (and broadcasts to `additionalConnections`/`additionalTxSenderCallbacks`) every `retrySleep`
-	 * ms while concurrently waiting for confirmation. The resend loop stops as soon as
-	 * confirmation resolves, a resend attempt itself throws, or `timeout` elapses.
-	 * @param rawTransaction - Serialized, signed transaction bytes.
-	 * @param opts - Options passed to each send/resend and to confirmation; `opts.commitment` selects confirmation level.
-	 * @returns The signature and confirmation slot once confirmed.
-	 * @throws Whatever `confirmTransaction` or `checkConfirmationResultForError` throw (e.g.
-	 * `TxSendError` on timeout, or the resolved on-chain error for a failed transaction).
-	 */
-	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 };
-	}
-}