wb3-eth 0.0.1-security → 4.10.0

package/src/utils/wait_for_transaction_receipt.ts

@@ -0,0 +1,83 @@
+/*
+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 { TransactionPollingTimeoutError } from 'web3-errors';
+import { EthExecutionAPI, Bytes, TransactionReceipt, DataFormat } from 'web3-types';
+
+// eslint-disable-next-line import/no-cycle
+import { pollTillDefinedAndReturnIntervalId, rejectIfTimeout } from 'web3-utils';
+// eslint-disable-next-line import/no-cycle
+import { rejectIfBlockTimeout } from './reject_if_block_timeout.js';
+// eslint-disable-next-line import/no-cycle
+import { getTransactionReceipt } from '../rpc_method_wrappers.js';
+
+export async function waitForTransactionReceipt<ReturnFormat extends DataFormat>(
+	web3Context: Web3Context<EthExecutionAPI>,
+	transactionHash: Bytes,
+	returnFormat: ReturnFormat,
+	customGetTransactionReceipt?: (
+		web3Context: Web3Context<EthExecutionAPI>,
+		transactionHash: Bytes,
+		returnFormat: ReturnFormat,
+	) => Promise<TransactionReceipt>,
+): Promise<TransactionReceipt> {
+	const pollingInterval =
+		web3Context.transactionReceiptPollingInterval ?? web3Context.transactionPollingInterval;
+
+	const [awaitableTransactionReceipt, IntervalId] = pollTillDefinedAndReturnIntervalId(
+		async () => {
+			try {
+				return (customGetTransactionReceipt ?? getTransactionReceipt)(
+					web3Context,
+					transactionHash,
+					returnFormat,
+				);
+			} catch (error) {
+				console.warn('An error happen while trying to get the transaction receipt', error);
+				return undefined;
+			}
+		},
+		pollingInterval,
+	);
+
+	const [timeoutId, rejectOnTimeout] = rejectIfTimeout(
+		web3Context.transactionPollingTimeout,
+		new TransactionPollingTimeoutError({
+			numberOfSeconds: web3Context.transactionPollingTimeout / 1000,
+			transactionHash,
+		}),
+	);
+
+	const [rejectOnBlockTimeout, blockTimeoutResourceCleaner] = await rejectIfBlockTimeout(
+		web3Context,
+		transactionHash,
+	);
+
+	try {
+		// If an error happened here, do not catch it, just clear the resources before raising it to the caller function.
+		return await Promise.race([
+			awaitableTransactionReceipt,
+			rejectOnTimeout, // this will throw an error on Transaction Polling Timeout
+			rejectOnBlockTimeout, // this will throw an error on Transaction Block Timeout
+		]);
+	} finally {
+		if (timeoutId) clearTimeout(timeoutId);
+		if (IntervalId) clearInterval(IntervalId);
+		blockTimeoutResourceCleaner.clean();
+	}
+}

package/src/utils/watch_transaction_by_polling.ts

@@ -0,0 +1,89 @@
+/*
+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 { Bytes, EthExecutionAPI, TransactionReceipt } from 'web3-types';
+import { Web3Context, Web3PromiEvent } from 'web3-core';
+import { format, numberToHex } from 'web3-utils';
+import { ethRpcMethods } from 'web3-rpc-methods';
+
+import { DataFormat } from 'web3-types';
+import { JsonSchema } from 'web3-validator';
+import { SendSignedTransactionEvents, SendTransactionEvents } from '../types.js';
+import { transactionReceiptSchema } from '../schemas.js';
+
+export type Web3PromiEventEventTypeBase<ReturnFormat extends DataFormat> =
+	| SendTransactionEvents<ReturnFormat>
+	| SendSignedTransactionEvents<ReturnFormat>;
+
+export type WaitProps<ReturnFormat extends DataFormat, ResolveType = TransactionReceipt> = {
+	web3Context: Web3Context<EthExecutionAPI>;
+	transactionReceipt: TransactionReceipt;
+	customTransactionReceiptSchema?: JsonSchema;
+	transactionPromiEvent: Web3PromiEvent<ResolveType, Web3PromiEventEventTypeBase<ReturnFormat>>;
+	returnFormat: ReturnFormat;
+};
+
+/**
+ * This function watches a Transaction by subscribing to new heads.
+ * It is used by `watchTransactionForConfirmations`, in case the provider does not support subscription.
+ * And it is also used by `watchTransactionBySubscription`, as a fallback, if the subscription failed for any reason.
+ */
+export const watchTransactionByPolling = <
+	ReturnFormat extends DataFormat,
+	ResolveType = TransactionReceipt,
+>({
+	web3Context,
+	transactionReceipt,
+	transactionPromiEvent,
+	customTransactionReceiptSchema,
+	returnFormat,
+}: WaitProps<ReturnFormat, ResolveType>) => {
+	// Having a transactionReceipt means that the transaction has already been included
+	// in at least one block, so we start with 1
+	let confirmations = 1;
+	const intervalId = setInterval(() => {
+		(async () => {
+			if (confirmations >= web3Context.transactionConfirmationBlocks) {
+				clearInterval(intervalId);
+				return;
+			}
+
+			const nextBlock = await ethRpcMethods.getBlockByNumber(
+				web3Context.requestManager,
+				numberToHex(BigInt(transactionReceipt.blockNumber) + BigInt(confirmations)),
+				false,
+			);
+
+			if (nextBlock?.hash) {
+				confirmations += 1;
+
+				transactionPromiEvent.emit('confirmation', {
+					confirmations: format({ format: 'uint' }, confirmations, returnFormat),
+					receipt: format(
+						customTransactionReceiptSchema ?? transactionReceiptSchema,
+						transactionReceipt,
+						returnFormat,
+					),
+					latestBlockHash: format(
+						{ format: 'bytes32' },
+						nextBlock.hash as Bytes,
+						returnFormat,
+					),
+				});
+			}
+		})() as unknown;
+	}, web3Context.transactionReceiptPollingInterval ?? web3Context.transactionPollingInterval);
+};

package/src/utils/watch_transaction_by_subscription.ts

@@ -0,0 +1,120 @@
+/*
+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 { Bytes, Numbers, BlockHeaderOutput, TransactionReceipt } from 'web3-types';
+import { format } from 'web3-utils';
+
+import { DataFormat } from 'web3-types';
+import { NewHeadsSubscription } from '../web3_subscriptions.js';
+import { transactionReceiptSchema } from '../schemas.js';
+import { WaitProps, watchTransactionByPolling } from './watch_transaction_by_polling.js';
+/**
+ * This function watches a Transaction by subscribing to new heads.
+ * It is used by `watchTransactionForConfirmations`, in case the provider supports subscription.
+ */
+export const watchTransactionBySubscription = <
+	ReturnFormat extends DataFormat,
+	ResolveType = TransactionReceipt,
+>({
+	web3Context,
+	transactionReceipt,
+	transactionPromiEvent,
+	customTransactionReceiptSchema,
+	returnFormat,
+}: WaitProps<ReturnFormat, ResolveType>) => {
+	// The following variable will stay true except if the data arrived,
+	//	or if watching started after an error had occurred.
+	let needToWatchLater = true;
+	let lastCaughtBlockHash: string;
+	setImmediate(() => {
+		web3Context.subscriptionManager
+			?.subscribe('newHeads')
+			.then((subscription: NewHeadsSubscription) => {
+				subscription.on('data', async (newBlockHeader: BlockHeaderOutput) => {
+					needToWatchLater = false;
+					if (
+						!newBlockHeader?.number ||
+						// For some cases, the on-data event is fired couple times for the same block!
+						// This needs investigation but seems to be because of multiple `subscription.on('data'...)` even this should not cause that.
+						lastCaughtBlockHash === newBlockHeader?.parentHash
+					) {
+						return;
+					}
+					lastCaughtBlockHash = newBlockHeader?.parentHash as string;
+
+					const confirmations =
+						BigInt(newBlockHeader.number) -
+						BigInt(transactionReceipt.blockNumber) +
+						BigInt(1);
+
+					transactionPromiEvent.emit('confirmation', {
+						confirmations: format(
+							{ format: 'uint' },
+							confirmations as Numbers,
+							returnFormat,
+						),
+						receipt: format(
+							customTransactionReceiptSchema ?? transactionReceiptSchema,
+							transactionReceipt,
+							returnFormat,
+						),
+						latestBlockHash: format(
+							{ format: 'bytes32' },
+							newBlockHeader.parentHash as Bytes,
+							returnFormat,
+						),
+					});
+					if (confirmations >= web3Context.transactionConfirmationBlocks) {
+						await web3Context.subscriptionManager?.removeSubscription(subscription);
+					}
+				});
+				subscription.on('error', async () => {
+					await web3Context.subscriptionManager?.removeSubscription(subscription);
+
+					needToWatchLater = false;
+					watchTransactionByPolling({
+						web3Context,
+						transactionReceipt,
+						transactionPromiEvent,
+						customTransactionReceiptSchema,
+						returnFormat,
+					});
+				});
+			})
+			.catch(() => {
+				needToWatchLater = false;
+				watchTransactionByPolling({
+					web3Context,
+					transactionReceipt,
+					customTransactionReceiptSchema,
+					transactionPromiEvent,
+					returnFormat,
+				});
+			});
+	});
+
+	// Fallback to polling if tx receipt didn't arrived in "blockHeaderTimeout" [10 seconds]
+	setTimeout(() => {
+		if (needToWatchLater) {
+			watchTransactionByPolling({
+				web3Context,
+				transactionReceipt,
+				transactionPromiEvent,
+				returnFormat,
+			});
+		}
+	}, web3Context.blockHeaderTimeout * 1000);
+};

package/src/utils/watch_transaction_for_confirmations.ts

@@ -0,0 +1,86 @@
+/*
+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 { Bytes, EthExecutionAPI, Web3BaseProvider, TransactionReceipt } from 'web3-types';
+import { Web3Context, Web3PromiEvent } from 'web3-core';
+import { format } from 'web3-utils';
+import { isNullish, JsonSchema } from 'web3-validator';
+
+import {
+	TransactionMissingReceiptOrBlockHashError,
+	TransactionReceiptMissingBlockNumberError,
+} from 'web3-errors';
+import { DataFormat } from 'web3-types';
+import { transactionReceiptSchema } from '../schemas.js';
+import {
+	watchTransactionByPolling,
+	Web3PromiEventEventTypeBase,
+} from './watch_transaction_by_polling.js';
+import { watchTransactionBySubscription } from './watch_transaction_by_subscription.js';
+
+export function watchTransactionForConfirmations<
+	ReturnFormat extends DataFormat,
+	Web3PromiEventEventType extends Web3PromiEventEventTypeBase<ReturnFormat>,
+	ResolveType = TransactionReceipt,
+>(
+	web3Context: Web3Context<EthExecutionAPI>,
+	transactionPromiEvent: Web3PromiEvent<ResolveType, Web3PromiEventEventType>,
+	transactionReceipt: TransactionReceipt,
+	transactionHash: Bytes,
+	returnFormat: ReturnFormat,
+	customTransactionReceiptSchema?: JsonSchema,
+) {
+	if (isNullish(transactionReceipt) || isNullish(transactionReceipt.blockHash))
+		throw new TransactionMissingReceiptOrBlockHashError({
+			receipt: transactionReceipt,
+			blockHash: format({ format: 'bytes32' }, transactionReceipt?.blockHash, returnFormat),
+			transactionHash: format({ format: 'bytes32' }, transactionHash, returnFormat),
+		});
+
+	if (!transactionReceipt.blockNumber)
+		throw new TransactionReceiptMissingBlockNumberError({ receipt: transactionReceipt });
+
+	// As we have the receipt, it's the first confirmation that tx is accepted.
+	transactionPromiEvent.emit('confirmation', {
+		confirmations: format({ format: 'uint' }, 1, returnFormat),
+		receipt: format(
+			customTransactionReceiptSchema ?? transactionReceiptSchema,
+			transactionReceipt,
+			returnFormat,
+		),
+		latestBlockHash: format({ format: 'bytes32' }, transactionReceipt.blockHash, returnFormat),
+	});
+
+	// so a subscription for newBlockHeaders can be made instead of polling
+	const provider: Web3BaseProvider = web3Context.requestManager.provider as Web3BaseProvider;
+	if (provider && 'supportsSubscriptions' in provider && provider.supportsSubscriptions()) {
+		watchTransactionBySubscription({
+			web3Context,
+			transactionReceipt,
+			transactionPromiEvent,
+			customTransactionReceiptSchema,
+			returnFormat,
+		});
+	} else {
+		watchTransactionByPolling({
+			web3Context,
+			transactionReceipt,
+			transactionPromiEvent,
+			customTransactionReceiptSchema,
+			returnFormat,
+		});
+	}
+}

package/src/validation.ts

@@ -0,0 +1,317 @@
+/*
+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 {
+	AccessList,
+	AccessListEntry,
+	BaseTransactionAPI,
+	Transaction1559UnsignedAPI,
+	Transaction2930UnsignedAPI,
+	TransactionCall,
+	TransactionLegacyUnsignedAPI,
+	Transaction,
+	TransactionWithSenderAPI,
+	ETH_DATA_FORMAT,
+} from 'web3-types';
+import { isAddress, isHexStrict, isHexString32Bytes, isNullish, isUInt } from 'web3-validator';
+import {
+	ChainMismatchError,
+	HardforkMismatchError,
+	ChainIdMismatchError,
+	CommonOrChainAndHardforkError,
+	Eip1559GasPriceError,
+	InvalidGasOrGasPrice,
+	InvalidMaxPriorityFeePerGasOrMaxFeePerGas,
+	InvalidNonceOrChainIdError,
+	InvalidTransactionCall,
+	InvalidTransactionObjectError,
+	InvalidTransactionWithSender,
+	MissingChainOrHardforkError,
+	MissingCustomChainError,
+	MissingCustomChainIdError,
+	MissingGasError,
+	TransactionGasMismatchError,
+	UnsupportedFeeMarketError,
+} from 'web3-errors';
+import { formatTransaction } from './utils/format_transaction.js';
+import { CustomTransactionSchema, InternalTransaction } from './types.js';
+
+export function isBaseTransaction(value: BaseTransactionAPI): boolean {
+	if (!isNullish(value.to) && !isAddress(value.to)) return false;
+	if (!isHexStrict(value.type) && !isNullish(value.type) && value.type.length !== 2) return false;
+	if (!isHexStrict(value.nonce)) return false;
+	if (!isHexStrict(value.gas)) return false;
+	if (!isHexStrict(value.value)) return false;
+	if (!isHexStrict(value.input)) return false;
+	if (value.chainId && !isHexStrict(value.chainId)) return false;
+
+	return true;
+}
+
+export function isAccessListEntry(value: AccessListEntry): boolean {
+	if (!isNullish(value.address) && !isAddress(value.address)) return false;
+	if (
+		!isNullish(value.storageKeys) &&
+		!value.storageKeys.every(storageKey => isHexString32Bytes(storageKey))
+	)
+		return false;
+
+	return true;
+}
+
+export function isAccessList(value: AccessList): boolean {
+	if (
+		!Array.isArray(value) ||
+		!value.every(accessListEntry => isAccessListEntry(accessListEntry))
+	)
+		return false;
+
+	return true;
+}
+
+export function isTransaction1559Unsigned(value: Transaction1559UnsignedAPI): boolean {
+	if (!isBaseTransaction(value)) return false;
+	if (!isHexStrict(value.maxFeePerGas)) return false;
+	if (!isHexStrict(value.maxPriorityFeePerGas)) return false;
+	if (!isAccessList(value.accessList)) return false;
+
+	return true;
+}
+
+export function isTransaction2930Unsigned(value: Transaction2930UnsignedAPI): boolean {
+	if (!isBaseTransaction(value)) return false;
+	if (!isHexStrict(value.gasPrice)) return false;
+	if (!isAccessList(value.accessList)) return false;
+
+	return true;
+}
+
+export function isTransactionLegacyUnsigned(value: TransactionLegacyUnsignedAPI): boolean {
+	if (!isBaseTransaction(value)) return false;
+	if (!isHexStrict(value.gasPrice)) return false;
+
+	return true;
+}
+
+export function isTransactionWithSender(value: TransactionWithSenderAPI): boolean {
+	if (!isAddress(value.from)) return false;
+	if (!isBaseTransaction(value)) return false;
+	if (
+		!isTransaction1559Unsigned(value as Transaction1559UnsignedAPI) &&
+		!isTransaction2930Unsigned(value as Transaction2930UnsignedAPI) &&
+		!isTransactionLegacyUnsigned(value as TransactionLegacyUnsignedAPI)
+	)
+		return false;
+
+	return true;
+}
+
+export function validateTransactionWithSender(value: TransactionWithSenderAPI) {
+	if (!isTransactionWithSender(value)) throw new InvalidTransactionWithSender(value);
+}
+
+export function isTransactionCall(value: TransactionCall): boolean {
+	if (!isNullish(value.from) && !isAddress(value.from)) return false;
+	if (!isAddress(value.to)) return false;
+	if (!isNullish(value.gas) && !isHexStrict(value.gas)) return false;
+	if (!isNullish(value.gasPrice) && !isHexStrict(value.gasPrice)) return false;
+	if (!isNullish(value.value) && !isHexStrict(value.value)) return false;
+	if (!isNullish(value.data) && !isHexStrict(value.data)) return false;
+	if (!isNullish(value.input) && !isHexStrict(value.input)) return false;
+	if (!isNullish(value.type)) return false;
+	if (isTransaction1559Unsigned(value as Transaction1559UnsignedAPI)) return false;
+	if (isTransaction2930Unsigned(value as Transaction2930UnsignedAPI)) return false;
+
+	return true;
+}
+
+export function validateTransactionCall(value: TransactionCall) {
+	if (!isTransactionCall(value)) throw new InvalidTransactionCall(value);
+}
+
+export const validateCustomChainInfo = (transaction: InternalTransaction) => {
+	if (!isNullish(transaction.common)) {
+		if (isNullish(transaction.common.customChain)) throw new MissingCustomChainError();
+		if (isNullish(transaction.common.customChain.chainId))
+			throw new MissingCustomChainIdError();
+		if (
+			!isNullish(transaction.chainId) &&
+			transaction.chainId !== transaction.common.customChain.chainId
+		)
+			throw new ChainIdMismatchError({
+				txChainId: transaction.chainId,
+				customChainId: transaction.common.customChain.chainId,
+			});
+	}
+};
+export const validateChainInfo = (transaction: InternalTransaction) => {
+	if (
+		!isNullish(transaction.common) &&
+		!isNullish(transaction.chain) &&
+		!isNullish(transaction.hardfork)
+	) {
+		throw new CommonOrChainAndHardforkError();
+	}
+	if (
+		(!isNullish(transaction.chain) && isNullish(transaction.hardfork)) ||
+		(!isNullish(transaction.hardfork) && isNullish(transaction.chain))
+	)
+		throw new MissingChainOrHardforkError({
+			chain: transaction.chain,
+			hardfork: transaction.hardfork,
+		});
+};
+export const validateBaseChain = (transaction: InternalTransaction) => {
+	if (!isNullish(transaction.common))
+		if (!isNullish(transaction.common.baseChain))
+			if (
+				!isNullish(transaction.chain) &&
+				transaction.chain !== transaction.common.baseChain
+			) {
+				throw new ChainMismatchError({
+					txChain: transaction.chain,
+					baseChain: transaction.common.baseChain,
+				});
+			}
+};
+export const validateHardfork = (transaction: InternalTransaction) => {
+	if (!isNullish(transaction.common))
+		if (!isNullish(transaction.common.hardfork))
+			if (
+				!isNullish(transaction.hardfork) &&
+				transaction.hardfork !== transaction.common.hardfork
+			) {
+				throw new HardforkMismatchError({
+					txHardfork: transaction.hardfork,
+					commonHardfork: transaction.common.hardfork,
+				});
+			}
+};
+
+export const validateLegacyGas = (transaction: InternalTransaction) => {
+	if (
+		// This check is verifying gas and gasPrice aren't less than 0.
+		isNullish(transaction.gas) ||
+		!isUInt(transaction.gas) ||
+		isNullish(transaction.gasPrice) ||
+		!isUInt(transaction.gasPrice)
+	)
+		throw new InvalidGasOrGasPrice({
+			gas: transaction.gas,
+			gasPrice: transaction.gasPrice,
+		});
+	if (!isNullish(transaction.maxFeePerGas) || !isNullish(transaction.maxPriorityFeePerGas))
+		throw new UnsupportedFeeMarketError({
+			maxFeePerGas: transaction.maxFeePerGas,
+			maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
+		});
+};
+
+export const validateFeeMarketGas = (transaction: InternalTransaction) => {
+	// These errors come from 1.x, so they must be checked before
+	// InvalidMaxPriorityFeePerGasOrMaxFeePerGas to throw the same error
+	// for the same code executing in 1.x
+	if (!isNullish(transaction.gasPrice) && transaction.type === '0x2')
+		throw new Eip1559GasPriceError(transaction.gasPrice);
+	if (transaction.type === '0x0' || transaction.type === '0x1')
+		throw new UnsupportedFeeMarketError({
+			maxFeePerGas: transaction.maxFeePerGas,
+			maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
+		});
+
+	if (
+		isNullish(transaction.maxFeePerGas) ||
+		!isUInt(transaction.maxFeePerGas) ||
+		isNullish(transaction.maxPriorityFeePerGas) ||
+		!isUInt(transaction.maxPriorityFeePerGas)
+	)
+		throw new InvalidMaxPriorityFeePerGasOrMaxFeePerGas({
+			maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
+			maxFeePerGas: transaction.maxFeePerGas,
+		});
+};
+
+/**
+ * This method checks if all required gas properties are present for either
+ * legacy gas (type 0x0 and 0x1) OR fee market transactions (0x2)
+ */
+export const validateGas = (transaction: InternalTransaction) => {
+	const gasPresent = !isNullish(transaction.gas) || !isNullish(transaction.gasLimit);
+	const legacyGasPresent = gasPresent && !isNullish(transaction.gasPrice);
+	const feeMarketGasPresent =
+		gasPresent &&
+		!isNullish(transaction.maxPriorityFeePerGas) &&
+		!isNullish(transaction.maxFeePerGas);
+
+	if (!legacyGasPresent && !feeMarketGasPresent)
+		throw new MissingGasError({
+			gas: transaction.gas,
+			gasPrice: transaction.gasPrice,
+			maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
+			maxFeePerGas: transaction.maxFeePerGas,
+		});
+
+	if (legacyGasPresent && feeMarketGasPresent)
+		throw new TransactionGasMismatchError({
+			gas: transaction.gas,
+			gasPrice: transaction.gasPrice,
+			maxPriorityFeePerGas: transaction.maxPriorityFeePerGas,
+			maxFeePerGas: transaction.maxFeePerGas,
+		});
+
+	(legacyGasPresent ? validateLegacyGas : validateFeeMarketGas)(transaction);
+	(!isNullish(transaction.type) && transaction.type > '0x1'
+		? validateFeeMarketGas
+		: validateLegacyGas)(transaction);
+};
+
+export const validateTransactionForSigning = (
+	transaction: InternalTransaction,
+	overrideMethod?: (transaction: InternalTransaction) => void,
+	options: {
+		transactionSchema?: CustomTransactionSchema;
+	} = { transactionSchema: undefined },
+) => {
+	if (!isNullish(overrideMethod)) {
+		overrideMethod(transaction);
+		return;
+	}
+
+	if (typeof transaction !== 'object' || isNullish(transaction))
+		throw new InvalidTransactionObjectError(transaction);
+
+	validateCustomChainInfo(transaction);
+	validateChainInfo(transaction);
+	validateBaseChain(transaction);
+	validateHardfork(transaction);
+
+	const formattedTransaction = formatTransaction(transaction as Transaction, ETH_DATA_FORMAT, {
+		transactionSchema: options.transactionSchema,
+	});
+	validateGas(formattedTransaction);
+
+	if (
+		isNullish(formattedTransaction.nonce) ||
+		isNullish(formattedTransaction.chainId) ||
+		formattedTransaction.nonce.startsWith('-') ||
+		formattedTransaction.chainId.startsWith('-')
+	)
+		throw new InvalidNonceOrChainIdError({
+			nonce: transaction.nonce,
+			chainId: transaction.chainId,
+		});
+};