sendTransaction and sendSignedTransaction Error Refactors

packages/web3-core/src/web3_request_manager.ts

@@ -369,7 +369,7 @@ export class Web3RequestManager<
 					throw new RpcError(rpcErrorResponse);
 				}
 			} else if (!Web3RequestManager._isReverted(response)) {
-				throw new InvalidResponseError<ErrorType>(response);
+				throw new InvalidResponseError<ErrorType, RequestType>(response, payload);
 			}
 		}
 

packages/web3-errors/src/error_codes.ts

@@ -86,6 +86,7 @@ export const ERR_TX_GAS_MISMATCH = 434;
 export const ERR_TX_CHAIN_MISMATCH = 435;
 export const ERR_TX_HARDFORK_MISMATCH = 436;
 export const ERR_TX_INVALID_RECEIVER = 437;
+export const ERR_TX_REVERT_TRANSACTION_CUSTOM_ERROR = 438;
 
 // Connection error codes
 export const ERR_CONN = 500;

packages/web3-errors/src/errors/response_errors.ts

@@ -16,7 +16,12 @@ along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 // eslint-disable-next-line max-classes-per-file
-import { JsonRpcError, JsonRpcResponse, JsonRpcResponseWithError } from 'web3-types';
+import {
+	JsonRpcError,
+	JsonRpcPayload,
+	JsonRpcResponse,
+	JsonRpcResponseWithError,
+} from 'web3-types';
 import { BaseWeb3Error } from '../web3_error_base';
 import { ERR_INVALID_RESPONSE, ERR_RESPONSE } from '../error_codes';
 
@@ -36,14 +41,19 @@ const isResponseWithError = <Error = unknown, Result = unknown>(
 const buildErrorMessage = (response: JsonRpcResponse<unknown, unknown>): string =>
 	isResponseWithError(response) ? response.error.message : '';
 
-export class ResponseError<ErrorType = unknown> extends BaseWeb3Error {
+export class ResponseError<ErrorType = unknown, RequestType = unknown> extends BaseWeb3Error {
 	public code = ERR_RESPONSE;
 	public data?: ErrorType | ErrorType[];
+	public request?: JsonRpcPayload<RequestType>;
 
-	public constructor(response: JsonRpcResponse<unknown, ErrorType>, message?: string) {
+	public constructor(
+		response: JsonRpcResponse<unknown, ErrorType>,
+		message?: string,
+		request?: JsonRpcPayload<RequestType>,
+	) {
 		super(
 			message ??
-				`Returned error: ${
+				`${
 					Array.isArray(response)
 						? response.map(r => buildErrorMessage(r)).join(',')
 						: buildErrorMessage(response)
@@ -55,16 +65,24 @@ export class ResponseError<ErrorType = unknown> extends BaseWeb3Error {
 				? response.map(r => r.error?.data as ErrorType)
 				: response?.error?.data;
 		}
+
+		this.request = request;
 	}
 
 	public toJSON() {
-		return { ...super.toJSON(), data: this.data };
+		return { ...super.toJSON(), data: this.data, request: this.request };
 	}
 }
 
-export class InvalidResponseError<ErrorType = unknown> extends ResponseError<ErrorType> {
-	public constructor(result: JsonRpcResponse<unknown, ErrorType>) {
-		super(result);
+export class InvalidResponseError<ErrorType = unknown, RequestType = unknown> extends ResponseError<
+	ErrorType,
+	RequestType
+> {
+	public constructor(
+		result: JsonRpcResponse<unknown, ErrorType>,
+		request?: JsonRpcPayload<RequestType>,
+	) {
+		super(result, undefined, request);
 		this.code = ERR_INVALID_RESPONSE;
 
 		let errorOrErrors: JsonRpcError | JsonRpcError[] | undefined;

packages/web3-errors/src/errors/transaction_errors.ts

@@ -57,6 +57,7 @@ import {
 	ERR_TX_UNABLE_TO_POPULATE_NONCE,
 	ERR_TX_UNSUPPORTED_EIP_1559,
 	ERR_TX_UNSUPPORTED_TYPE,
+	ERR_TX_REVERT_TRANSACTION_CUSTOM_ERROR,
 } from '../error_codes';
 import { InvalidValueError, BaseWeb3Error } from '../web3_error_base';
 
@@ -84,25 +85,54 @@ export class RevertInstructionError extends BaseWeb3Error {
 	}
 }
 
-export class TransactionRevertError extends BaseWeb3Error {
+export class TransactionRevertError<ReceiptType = TransactionReceipt> extends BaseWeb3Error {
 	public code = ERR_TX_REVERT_TRANSACTION;
 
 	public constructor(
 		public reason: string,
 		public signature?: string,
-		public receipt?: TransactionReceipt,
+		public receipt?: ReceiptType,
+		public data?: string,
 	) {
-		super(
-			`Transaction has been reverted by the EVM:\n ${JSON.stringify(receipt, undefined, 2)}`,
-		);
+		super(reason);
+	}
+
+	public toJSON() {
+		return {
+			...super.toJSON(),
+			reason: this.reason,
+			signature: this.signature,
+			receipt: this.receipt,
+			data: this.data
+		};
+	}
+}
+
+export class TransactionRevertWithCustomError<ReceiptType = TransactionReceipt> extends TransactionRevertError<ReceiptType> {
+	public code = ERR_TX_REVERT_TRANSACTION_CUSTOM_ERROR;
+
+	public constructor(
+		public reason: string,
+		public customErrorName: string,
+		public customErrorDecodedSignature: string,
+		public customErrorArguments: Record<string, unknown>,
+		public signature?: string,
+		public receipt?: ReceiptType,
+		public data?: string,
+	) {
+		super(reason);
 	}
 
 	public toJSON() {
 		return {
 			...super.toJSON(),
 			reason: this.reason,
+			customErrorName: this.customErrorName,
+			customErrorDecodedSignature: this.customErrorDecodedSignature,
+			customErrorArguments: this.customErrorArguments,
 			signature: this.signature,
 			receipt: this.receipt,
+			data: this.data
 		};
 	}
 }
@@ -125,10 +155,10 @@ export class ContractCodeNotStoredError extends TransactionError {
 	}
 }
 
-export class TransactionRevertedWithoutReasonError extends TransactionError {
-	public constructor(receipt: TransactionReceipt) {
+export class TransactionRevertedWithoutReasonError<ReceiptType = TransactionReceipt> extends TransactionError<ReceiptType> {
+	public constructor(receipt?: ReceiptType) {
 		super(
-			`Transaction has been reverted by the EVM:\n ${JSON.stringify(receipt, undefined, 2)}`,
+			`Transaction has been reverted by the EVM${receipt === undefined ? '' : `:\n ${JSON.stringify(receipt, undefined, 2)}`}`,
 			receipt,
 		);
 		this.code = ERR_TX_REVERT_WITHOUT_REASON;

packages/web3-eth/src/rpc_method_wrappers.ts

@@ -48,7 +48,11 @@ import {
 import { Web3Context, Web3PromiEvent } from 'web3-core';
 import { ETH_DATA_FORMAT, FormatType, DataFormat, DEFAULT_RETURN_FORMAT, format } from 'web3-utils';
 import { isBlockTag, isBytes, isNullish, isString } from 'web3-validator';
-import { SignatureError, TransactionError, ContractExecutionError } from 'web3-errors';
+import {
+	InvalidResponseError,
+	SignatureError,
+	TransactionError,
+} from 'web3-errors';
 import { ethRpcMethods } from 'web3-rpc-methods';
 import { decodeSignedTransaction } from './utils/decode_signed_transaction';
 import {
@@ -77,8 +81,7 @@ import { trySendTransaction } from './utils/try_send_transaction';
 import { waitForTransactionReceipt } from './utils/wait_for_transaction_receipt';
 import { watchTransactionForConfirmations } from './utils/watch_transaction_for_confirmations';
 import { NUMBER_DATA_FORMAT } from './constants';
-// eslint-disable-next-line import/no-cycle
-import { getRevertReason } from './utils/get_revert_reason';
+import { getTransactionError } from './utils/get_transaction_error';
 
 /**
  *
@@ -1078,14 +1081,6 @@ export function sendTransaction<
 							ETH_DATA_FORMAT,
 						);
 
-						if (web3Context.handleRevert) {
-							// eslint-disable-next-line no-use-before-define
-							await getRevertReason(
-								web3Context,
-								transactionFormatted as TransactionCall,
-							);
-						}
-
 						if (
 							!options?.ignoreGasPricing &&
 							isNullish(transactionFormatted.gasPrice) &&
@@ -1177,17 +1172,17 @@ export function sendTransaction<
 								) as unknown as ResolveType,
 							);
 						} else if (transactionReceipt.status === BigInt(0)) {
+							const error = await getTransactionError<ReturnFormat>(
+								web3Context,
+								transactionFormatted as TransactionCall,
+								transactionReceiptFormatted,
+							);
+
 							if (promiEvent.listenerCount('error') > 0) {
-								promiEvent.emit(
-									'error',
-									new TransactionError(
-										'Transaction failed',
-										transactionReceiptFormatted,
-									),
-								);
+								promiEvent.emit('error', error);
 							}
-							reject(transactionReceiptFormatted as unknown as ResolveType);
-							return;
+
+							reject(error);
 						} else {
 							resolve(transactionReceiptFormatted as unknown as ResolveType);
 						}
@@ -1206,14 +1201,10 @@ export function sendTransaction<
 							);
 						}
 					} catch (error) {
-						if (error instanceof ContractExecutionError) {
-							promiEvent.emit('contractExecutionError', error);
-						}
-						if (promiEvent.listenerCount('error') > 0) {
-							promiEvent.emit(
-								'error',
-								new TransactionError((error as Error).message),
-							);
+						if (error instanceof InvalidResponseError &&
+							promiEvent.listenerCount('error') > 0
+						) {
+							promiEvent.emit('error', error);
 						}
 
 						reject(error);

packages/web3-eth/src/types.ts

@@ -15,7 +15,15 @@ You should have received a copy of the GNU Lesser General Public License
 along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { TransactionError, ContractExecutionError, ResponseError } from 'web3-errors';
+import {
+	TransactionError,
+	ContractExecutionError,
+	ResponseError,
+	TransactionRevertedWithoutReasonError,
+	TransactionRevertError,
+	TransactionRevertWithCustomError,
+	InvalidResponseError,
+} from 'web3-errors';
 import { Bytes, HexString, Numbers, Transaction, TransactionReceipt } from 'web3-types';
 import { DataFormat, ETH_DATA_FORMAT, FormatType } from 'web3-utils';
 
@@ -31,8 +39,11 @@ export type SendTransactionEvents<ReturnFormat extends DataFormat> = {
 		receipt: FormatType<TransactionReceipt, ReturnFormat>;
 		latestBlockHash: FormatType<Bytes, ReturnFormat>;
 	};
-	error: TransactionError<FormatType<TransactionReceipt, ReturnFormat>>;
-	contractExecutionError: ContractExecutionError | ResponseError<any>;
+	error:
+		| TransactionRevertedWithoutReasonError<FormatType<TransactionReceipt, ReturnFormat>>
+		| TransactionRevertError<FormatType<TransactionReceipt, ReturnFormat>>
+		| TransactionRevertWithCustomError<FormatType<TransactionReceipt, ReturnFormat>>
+		| InvalidResponseError;
 };
 
 export type SendSignedTransactionEvents<ReturnFormat extends DataFormat> = {

packages/web3-eth/src/utils/get_revert_reason.ts

@@ -25,6 +25,45 @@ import { DataFormat, DEFAULT_RETURN_FORMAT } from 'web3-utils';
 import { call } from '../rpc_method_wrappers';
 import { RevertReason, RevertReasonWithCustomError } from '../types';
 
+export const parseTransactionError = (error: unknown, contractAbi?: ContractAbi) => {
+	if (
+		error instanceof ContractExecutionError &&
+		error.innerError instanceof Eip838ExecutionError
+	) {
+		if (contractAbi !== undefined) {
+			const errorsAbi = contractAbi.filter(abi =>
+				isAbiErrorFragment(abi),
+			) as unknown as AbiErrorFragment[];
+			decodeContractErrorData(errorsAbi, error.innerError);
+
+			return {
+				reason: error.innerError.message,
+				signature: error.innerError.data?.slice(0, 10),
+				data: error.innerError.data?.substring(10),
+				customErrorName: error.innerError.errorName,
+				customErrorDecodedSignature: error.innerError.errorSignature,
+				customErrorArguments: error.innerError.errorArgs,
+			} as RevertReasonWithCustomError;
+		}
+
+		return {
+			reason: error.innerError.message,
+			signature: error.innerError.data?.slice(0, 10),
+			data: error.innerError.data?.substring(10),
+		} as RevertReason;
+	}
+
+	if (
+		error instanceof InvalidResponseError &&
+		!Array.isArray(error.innerError) &&
+		error.innerError !== undefined
+	) {
+		return error.innerError.message;
+	}
+
+	throw error;
+};
+
 /**
  *	Returns the revert reason generated by the EVM if the transaction were to be executed.
  *
@@ -44,41 +83,6 @@ export async function getRevertReason<
 		await call(web3Context, transaction, web3Context.defaultBlock, returnFormat);
 		return undefined;
 	} catch (error) {
-		if (
-			error instanceof ContractExecutionError &&
-			error.innerError instanceof Eip838ExecutionError
-		) {
-			if (contractAbi !== undefined) {
-				const errorsAbi = contractAbi.filter(abi =>
-					isAbiErrorFragment(abi),
-				) as unknown as AbiErrorFragment[];
-				decodeContractErrorData(errorsAbi, error.innerError);
-
-				return {
-					reason: error.innerError.message,
-					signature: error.innerError.data?.slice(0, 10),
-					data: error.innerError.data?.substring(10),
-					customErrorName: error.innerError.errorName,
-					customErrorDecodedSignature: error.innerError.errorSignature,
-					customErrorArguments: error.innerError.errorArgs,
-				} as RevertReasonWithCustomError;
-			}
-
-			return {
-				reason: error.innerError.message,
-				signature: error.innerError.data?.slice(0, 10),
-				data: error.innerError.data?.substring(10),
-			} as RevertReason;
-		}
-
-		if (
-			error instanceof InvalidResponseError &&
-			!Array.isArray(error.innerError) &&
-			error.innerError !== undefined
-		) {
-			return error.innerError.message;
-		}
-
-		throw error;
+		return parseTransactionError(error, contractAbi);
 	}
 }