web-eth 0.0.1-security → 4.10.0

package/src/types.ts

@@ -0,0 +1,113 @@
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+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 {
+	ContractExecutionError,
+	TransactionRevertedWithoutReasonError,
+	TransactionRevertInstructionError,
+	TransactionRevertWithCustomError,
+	InvalidResponseError,
+	TransactionPollingTimeoutError,
+} from 'web3-errors';
+import {
+	FormatType,
+	ETH_DATA_FORMAT,
+	DataFormat,
+	Bytes,
+	ContractAbi,
+	HexString,
+	Numbers,
+	Transaction,
+	TransactionReceipt,
+	TransactionWithFromAndToLocalWalletIndex,
+	TransactionWithFromLocalWalletIndex,
+	TransactionWithToLocalWalletIndex,
+} from 'web3-types';
+import { Schema } from 'web3-validator';
+
+export type InternalTransaction = FormatType<Transaction, typeof ETH_DATA_FORMAT>;
+
+export type SendTransactionEventsBase<ReturnFormat extends DataFormat, TxType> = {
+	sending: FormatType<TxType, typeof ETH_DATA_FORMAT>;
+	sent: FormatType<TxType, typeof ETH_DATA_FORMAT>;
+	transactionHash: FormatType<Bytes, ReturnFormat>;
+	receipt: FormatType<TransactionReceipt, ReturnFormat>;
+	confirmation: {
+		confirmations: FormatType<Numbers, ReturnFormat>;
+		receipt: FormatType<TransactionReceipt, ReturnFormat>;
+		latestBlockHash: FormatType<Bytes, ReturnFormat>;
+	};
+	error:
+		| TransactionRevertedWithoutReasonError<FormatType<TransactionReceipt, ReturnFormat>>
+		| TransactionRevertInstructionError<FormatType<TransactionReceipt, ReturnFormat>>
+		| TransactionRevertWithCustomError<FormatType<TransactionReceipt, ReturnFormat>>
+		| TransactionPollingTimeoutError
+		| InvalidResponseError
+		| ContractExecutionError;
+};
+
+export type SendTransactionEvents<ReturnFormat extends DataFormat> = SendTransactionEventsBase<
+	ReturnFormat,
+	Transaction
+>;
+export type SendSignedTransactionEvents<ReturnFormat extends DataFormat> =
+	SendTransactionEventsBase<ReturnFormat, Bytes>;
+
+export interface SendTransactionOptions<ResolveType = TransactionReceipt> {
+	ignoreGasPricing?: boolean;
+	transactionResolver?: (receipt: TransactionReceipt) => ResolveType;
+	contractAbi?: ContractAbi;
+	checkRevertBeforeSending?: boolean;
+	ignoreFillingGasLimit?: boolean;
+}
+
+export interface SendSignedTransactionOptions<ResolveType = TransactionReceipt> {
+	transactionResolver?: (receipt: TransactionReceipt) => ResolveType;
+	contractAbi?: ContractAbi;
+	checkRevertBeforeSending?: boolean;
+}
+
+export interface RevertReason {
+	reason: string;
+	signature?: HexString;
+	data?: HexString;
+}
+
+export interface RevertReasonWithCustomError extends RevertReason {
+	customErrorName: string;
+	customErrorDecodedSignature: string;
+	customErrorArguments: Record<string, unknown>;
+}
+
+export type TransactionMiddlewareData =
+	| Transaction
+	| TransactionWithFromLocalWalletIndex
+	| TransactionWithToLocalWalletIndex
+	| TransactionWithFromAndToLocalWalletIndex;
+
+export interface TransactionMiddleware {
+	// for transaction processing before signing
+	processTransaction(
+		transaction: TransactionMiddlewareData,
+		options?: { [key: string]: unknown },
+	): Promise<TransactionMiddlewareData>;
+}
+
+export type CustomTransactionSchema = {
+	type: string;
+	properties: Record<string, Schema>;
+};

package/src/utils/decode_signed_transaction.ts

@@ -0,0 +1,60 @@
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+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 {
+	DataFormat,
+	HexStringBytes,
+	SignedTransactionInfoAPI,
+	TransactionSignedAPI,
+} from 'web3-types';
+import { bytesToHex, format, hexToBytes, keccak256 } from 'web3-utils';
+import { TransactionFactory } from 'web3-eth-accounts';
+import { detectRawTransactionType } from './detect_transaction_type.js';
+import { formatTransaction } from './format_transaction.js';
+import { type CustomTransactionSchema } from '../types.js';
+
+/**
+ * Decodes an [RLP](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/#top) encoded transaction.
+ *
+ * @param encodedSignedTransaction The RLP encoded transaction.
+ * @param returnFormat ({@link DataFormat} Specifies how the return data should be formatted.
+ * @returns {@link SignedTransactionInfoAPI}, an object containing the RLP encoded signed transaction (accessed via the `raw` property) and the signed transaction object (accessed via the `tx` property).
+ */
+export function decodeSignedTransaction<ReturnFormat extends DataFormat>(
+	encodedSignedTransaction: HexStringBytes,
+	returnFormat: ReturnFormat,
+	options: { fillInputAndData?: boolean; transactionSchema?: CustomTransactionSchema } = {
+		fillInputAndData: false,
+	},
+): SignedTransactionInfoAPI {
+	return {
+		raw: format({ format: 'bytes' }, encodedSignedTransaction, returnFormat),
+		tx: formatTransaction(
+			{
+				...TransactionFactory.fromSerializedData(
+					hexToBytes(encodedSignedTransaction),
+				).toJSON(),
+				hash: bytesToHex(keccak256(hexToBytes(encodedSignedTransaction))),
+				type: detectRawTransactionType(hexToBytes(encodedSignedTransaction)),
+			} as TransactionSignedAPI,
+			returnFormat,
+			{
+				fillInputAndData: options.fillInputAndData,
+				transactionSchema: options.transactionSchema,
+			},
+		),
+	};
+}

package/src/utils/decoding.ts

@@ -0,0 +1,95 @@
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+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 { format } from 'web3-utils';
+
+import {
+	AbiEventFragment,
+	LogsInput,
+	DataFormat,
+	DEFAULT_RETURN_FORMAT,
+	EventLog,
+	ContractAbiWithSignature,
+} from 'web3-types';
+
+import { decodeLog } from 'web3-eth-abi';
+
+import { logSchema } from '../schemas.js';
+import { ALL_EVENTS } from '../constants.js';
+
+export const decodeEventABI = (
+	event: AbiEventFragment & { signature: string },
+	data: LogsInput,
+	jsonInterface: ContractAbiWithSignature,
+	returnFormat: DataFormat = DEFAULT_RETURN_FORMAT,
+): EventLog => {
+	let modifiedEvent = { ...event };
+
+	const result = format(logSchema, data, returnFormat);
+
+	// if allEvents get the right event
+	if ([ALL_EVENTS, 'allEvents'].includes(modifiedEvent.name)) {
+		const matchedEvent = jsonInterface.find(j => j.signature === data.topics[0]);
+		if (matchedEvent) {
+			modifiedEvent = matchedEvent as AbiEventFragment & { signature: string };
+		} else {
+			modifiedEvent = { anonymous: true } as unknown as AbiEventFragment & {
+				signature: string;
+			};
+		}
+	}
+
+	// create empty inputs if none are present (e.g. anonymous events on allEvents)
+	modifiedEvent.inputs = modifiedEvent.inputs ?? event.inputs ?? [];
+
+	// Handle case where an event signature shadows the current ABI with non-identical
+	// arg indexing. If # of topics doesn't match, event is anon.
+	if (!modifiedEvent.anonymous) {
+		let indexedInputs = 0;
+		(modifiedEvent.inputs ?? []).forEach(input => {
+			if (input.indexed) {
+				indexedInputs += 1;
+			}
+		});
+
+		if (indexedInputs > 0 && data?.topics && data?.topics.length !== indexedInputs + 1) {
+			// checks if event is anonymous
+			modifiedEvent = {
+				...modifiedEvent,
+				anonymous: true,
+				inputs: [],
+			};
+		}
+	}
+
+	const argTopics = modifiedEvent.anonymous ? data.topics : (data.topics ?? []).slice(1);
+
+	return {
+		...result,
+		returnValues: decodeLog([...(modifiedEvent.inputs ?? [])], data.data, argTopics),
+		event: modifiedEvent.name,
+		signature:
+			modifiedEvent.anonymous || !data.topics || data.topics.length === 0 || !data.topics[0]
+				? undefined
+				: data.topics[0],
+
+		raw: {
+			data: data.data,
+			topics: data.topics,
+		},
+	};
+};

package/src/utils/detect_transaction_type.ts

@@ -0,0 +1,144 @@
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+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 { format, toHex } from 'web3-utils';
+import { TransactionTypeParser, Web3Context } from 'web3-core';
+import { EthExecutionAPI, HardforksOrdered, Transaction, ETH_DATA_FORMAT } from 'web3-types';
+import { Web3ValidatorError, isNullish, validator } from 'web3-validator';
+import { InvalidPropertiesForTransactionTypeError } from 'web3-errors';
+
+import { InternalTransaction } from '../types.js';
+
+// undefined is treated as null for JSON schema validator
+const transactionType0x0Schema = {
+	type: 'object',
+	properties: {
+		accessList: {
+			type: 'null',
+		},
+		maxFeePerGas: {
+			type: 'null',
+		},
+		maxPriorityFeePerGas: {
+			type: 'null',
+		},
+	},
+};
+const transactionType0x1Schema = {
+	type: 'object',
+	properties: {
+		maxFeePerGas: {
+			type: 'null',
+		},
+		maxPriorityFeePerGas: {
+			type: 'null',
+		},
+	},
+};
+const transactionType0x2Schema = {
+	type: 'object',
+	properties: {
+		gasPrice: {
+			type: 'null',
+		},
+	},
+};
+
+const validateTxTypeAndHandleErrors = (
+	txSchema: object,
+	tx: Transaction,
+	txType: '0x0' | '0x1' | '0x2',
+) => {
+	try {
+		validator.validateJSONSchema(txSchema, tx);
+	} catch (error) {
+		if (error instanceof Web3ValidatorError)
+			// Erroneously reported error
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-call
+			throw new InvalidPropertiesForTransactionTypeError(error.errors, txType);
+
+		throw error;
+	}
+};
+
+export const defaultTransactionTypeParser: TransactionTypeParser = transaction => {
+	const tx = transaction as unknown as Transaction;
+	if (!isNullish(tx.type)) {
+		let txSchema;
+		switch (tx.type) {
+			case '0x0':
+				txSchema = transactionType0x0Schema;
+				break;
+			case '0x1':
+				txSchema = transactionType0x1Schema;
+				break;
+			case '0x2':
+				txSchema = transactionType0x2Schema;
+				break;
+
+			default:
+				return format({ format: 'uint' }, tx.type, ETH_DATA_FORMAT);
+		}
+
+		validateTxTypeAndHandleErrors(txSchema, tx, tx.type);
+
+		return format({ format: 'uint' }, tx.type, ETH_DATA_FORMAT);
+	}
+
+	if (!isNullish(tx.maxFeePerGas) || !isNullish(tx.maxPriorityFeePerGas)) {
+		validateTxTypeAndHandleErrors(transactionType0x2Schema, tx, '0x2');
+		return '0x2';
+	}
+
+	if (!isNullish(tx.accessList)) {
+		validateTxTypeAndHandleErrors(transactionType0x1Schema, tx, '0x1');
+		return '0x1';
+	}
+
+	const givenHardfork = tx.hardfork ?? tx.common?.hardfork;
+
+	if (!isNullish(givenHardfork)) {
+		const hardforkIndex = Object.keys(HardforksOrdered).indexOf(givenHardfork);
+
+		// givenHardfork is London or later, so EIP-2718 is supported
+		if (hardforkIndex >= Object.keys(HardforksOrdered).indexOf('london'))
+			return !isNullish(tx.gasPrice) ? '0x0' : '0x2';
+
+		// givenHardfork is Berlin, tx.accessList is undefined, assume type is 0x0
+		if (hardforkIndex === Object.keys(HardforksOrdered).indexOf('berlin')) return '0x0';
+	}
+
+	// gasprice is defined
+	if (!isNullish(tx.gasPrice)) {
+		validateTxTypeAndHandleErrors(transactionType0x0Schema, tx, '0x0');
+		return '0x0';
+	}
+
+	// no transaction type can be inferred from properties, use default transaction type
+	return undefined;
+};
+
+export const detectTransactionType = (
+	transaction: InternalTransaction,
+	web3Context?: Web3Context<EthExecutionAPI>,
+) =>
+	(web3Context?.transactionTypeParser ?? defaultTransactionTypeParser)(
+		transaction as unknown as Record<string, unknown>,
+	);
+
+export const detectRawTransactionType = (transaction: Uint8Array) =>
+	transaction[0] > 0x7f ? '0x0' : toHex(transaction[0]);

package/src/utils/format_transaction.ts

@@ -0,0 +1,77 @@
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+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 { Transaction, DataFormat, DEFAULT_RETURN_FORMAT, FormatType } from 'web3-types';
+import { isNullish, ValidationSchemaInput } from 'web3-validator';
+import { mergeDeep, format, bytesToHex, toHex } from 'web3-utils';
+import { TransactionDataAndInputError } from 'web3-errors';
+
+import { transactionInfoSchema } from '../schemas.js';
+import { type CustomTransactionSchema } from '../types.js';
+
+export function formatTransaction<
+	ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT,
+	TransactionType extends Transaction = Transaction,
+>(
+	transaction: TransactionType,
+	returnFormat: ReturnFormat = DEFAULT_RETURN_FORMAT as ReturnFormat,
+	options: {
+		transactionSchema?: ValidationSchemaInput | CustomTransactionSchema | undefined;
+		fillInputAndData?: boolean;
+	} = {
+		transactionSchema: transactionInfoSchema,
+		fillInputAndData: false,
+	},
+): FormatType<TransactionType, ReturnFormat> {
+	let formattedTransaction = mergeDeep({}, transaction as Record<string, unknown>) as Transaction;
+	if (!isNullish(transaction?.common)) {
+		formattedTransaction.common = { ...transaction.common };
+		if (!isNullish(transaction.common?.customChain))
+			formattedTransaction.common.customChain = { ...transaction.common.customChain };
+	}
+	formattedTransaction = format(
+		options.transactionSchema ?? transactionInfoSchema,
+		formattedTransaction,
+		returnFormat,
+	);
+	if (
+		!isNullish(formattedTransaction.data) &&
+		!isNullish(formattedTransaction.input) &&
+		// Converting toHex is accounting for data and input being Uint8Arrays
+		// since comparing Uint8Array is not as straightforward as comparing strings
+		toHex(formattedTransaction.data) !== toHex(formattedTransaction.input)
+	)
+		throw new TransactionDataAndInputError({
+			data: bytesToHex(formattedTransaction.data),
+			input: bytesToHex(formattedTransaction.input),
+		});
+
+	if (options.fillInputAndData) {
+		if (!isNullish(formattedTransaction.data)) {
+			formattedTransaction.input = formattedTransaction.data;
+		} else if (!isNullish(formattedTransaction.input)) {
+			formattedTransaction.data = formattedTransaction.input;
+		}
+	}
+
+	if (!isNullish(formattedTransaction.gasLimit)) {
+		formattedTransaction.gas = formattedTransaction.gasLimit;
+		delete formattedTransaction.gasLimit;
+	}
+
+	return formattedTransaction as FormatType<TransactionType, ReturnFormat>;
+}

package/src/utils/get_revert_reason.ts

@@ -0,0 +1,96 @@
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+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 { Web3Context } from 'web3-core';
+import {
+	ContractExecutionError,
+	Eip838ExecutionError,
+	InvalidResponseError,
+	MultipleErrors,
+} from 'web3-errors';
+import { decodeContractErrorData, isAbiErrorFragment } from 'web3-eth-abi';
+import {
+	AbiErrorFragment,
+	ContractAbi,
+	DataFormat,
+	DEFAULT_RETURN_FORMAT,
+	EthExecutionAPI,
+	TransactionCall,
+} from 'web3-types';
+
+// eslint-disable-next-line import/no-cycle
+import { call } from '../rpc_method_wrappers.js';
+import { RevertReason, RevertReasonWithCustomError } from '../types.js';
+
+export const parseTransactionError = (error: unknown, contractAbi?: ContractAbi) => {
+	if (error instanceof ContractExecutionError && error.cause instanceof Eip838ExecutionError) {
+		if (contractAbi !== undefined) {
+			const errorsAbi = contractAbi.filter(abi =>
+				isAbiErrorFragment(abi),
+			) as unknown as AbiErrorFragment[];
+			decodeContractErrorData(errorsAbi, error.cause);
+
+			return {
+				reason: error.cause.message,
+				signature: error.cause.data?.slice(0, 10),
+				data: error.cause.data?.substring(10),
+				customErrorName: error.cause.errorName,
+				customErrorDecodedSignature: error.cause.errorSignature,
+				customErrorArguments: error.cause.errorArgs,
+			} as RevertReasonWithCustomError;
+		}
+
+		return {
+			reason: error.cause.message,
+			signature: error.cause.data?.slice(0, 10),
+			data: error.cause.data?.substring(10),
+		} as RevertReason;
+	}
+
+	if (
+		error instanceof InvalidResponseError &&
+		!Array.isArray((error.cause as MultipleErrors)?.errors) &&
+		error.cause !== undefined
+	) {
+		return error.cause.message;
+	}
+
+	throw error;
+};
+
+/**
+ *	Returns the revert reason generated by the EVM if the transaction were to be executed.
+ *
+ * @param web3Context - ({@link Web3Context}) Web3 configuration object that contains things such as the provider, request manager, wallet, etc.
+ * @param transaction - A transaction object where all properties are optional except `to`, however it's recommended to include the `from` property or it may default to `0x0000000000000000000000000000000000000000` depending on your node or provider.
+ * @returns `undefined` if no revert reason was given, a revert reason object, a revert reason string, or an `unknown` error
+ */
+export async function getRevertReason<
+	ReturnFormat extends DataFormat = typeof DEFAULT_RETURN_FORMAT,
+>(
+	web3Context: Web3Context<EthExecutionAPI>,
+	transaction: TransactionCall,
+	contractAbi?: ContractAbi,
+	returnFormat: ReturnFormat = web3Context.defaultReturnFormat as ReturnFormat,
+): Promise<undefined | RevertReason | RevertReasonWithCustomError | string> {
+	try {
+		await call(web3Context, transaction, web3Context.defaultBlock, returnFormat);
+		return undefined;
+	} catch (error) {
+		return parseTransactionError(error, contractAbi);
+	}
+}

package/src/utils/get_transaction_error.ts

@@ -0,0 +1,93 @@
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+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 { Web3Context } from 'web3-core';
+import {
+	TransactionRevertedWithoutReasonError,
+	TransactionRevertInstructionError,
+	TransactionRevertWithCustomError,
+} from 'web3-errors';
+import {
+	DataFormat,
+	FormatType,
+	ContractAbi,
+	TransactionCall,
+	TransactionReceipt,
+} from 'web3-types';
+import { RevertReason, RevertReasonWithCustomError } from '../types.js';
+// eslint-disable-next-line import/no-cycle
+import { getRevertReason, parseTransactionError } from './get_revert_reason.js';
+
+export async function getTransactionError<ReturnFormat extends DataFormat>(
+	web3Context: Web3Context,
+	transactionFormatted?: TransactionCall,
+	transactionReceiptFormatted?: FormatType<TransactionReceipt, ReturnFormat>,
+	receivedError?: unknown,
+	contractAbi?: ContractAbi,
+	knownReason?: string | RevertReason | RevertReasonWithCustomError,
+) {
+	let _reason: string | RevertReason | RevertReasonWithCustomError | undefined = knownReason;
+
+	if (_reason === undefined) {
+		if (receivedError !== undefined) {
+			_reason = parseTransactionError(receivedError);
+		} else if (web3Context.handleRevert && transactionFormatted !== undefined) {
+			_reason = await getRevertReason(web3Context, transactionFormatted, contractAbi);
+		}
+	}
+
+	let error:
+		| TransactionRevertedWithoutReasonError<FormatType<TransactionReceipt, ReturnFormat>>
+		| TransactionRevertInstructionError<FormatType<TransactionReceipt, ReturnFormat>>
+		| TransactionRevertWithCustomError<FormatType<TransactionReceipt, ReturnFormat>>;
+	if (_reason === undefined) {
+		error = new TransactionRevertedWithoutReasonError<
+			FormatType<TransactionReceipt, ReturnFormat>
+		>(transactionReceiptFormatted);
+	} else if (typeof _reason === 'string') {
+		error = new TransactionRevertInstructionError<FormatType<TransactionReceipt, ReturnFormat>>(
+			_reason,
+			undefined,
+			transactionReceiptFormatted,
+		);
+	} else if (
+		(_reason as RevertReasonWithCustomError).customErrorName !== undefined &&
+		(_reason as RevertReasonWithCustomError).customErrorDecodedSignature !== undefined &&
+		(_reason as RevertReasonWithCustomError).customErrorArguments !== undefined
+	) {
+		const reasonWithCustomError: RevertReasonWithCustomError =
+			_reason as RevertReasonWithCustomError;
+		error = new TransactionRevertWithCustomError<FormatType<TransactionReceipt, ReturnFormat>>(
+			reasonWithCustomError.reason,
+			reasonWithCustomError.customErrorName,
+			reasonWithCustomError.customErrorDecodedSignature,
+			reasonWithCustomError.customErrorArguments,
+			reasonWithCustomError.signature,
+			transactionReceiptFormatted,
+			reasonWithCustomError.data,
+		);
+	} else {
+		error = new TransactionRevertInstructionError<FormatType<TransactionReceipt, ReturnFormat>>(
+			_reason.reason,
+			_reason.signature,
+			transactionReceiptFormatted,
+			_reason.data,
+		);
+	}
+
+	return error;
+}