wb3-eth 0.0.1-security → 4.10.0

package/src/utils/get_transaction_gas_pricing.ts

@@ -0,0 +1,117 @@
+/*
+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 {
+	EthExecutionAPI,
+	Numbers,
+	Transaction,
+	DataFormat,
+	FormatType,
+	ETH_DATA_FORMAT,
+} from 'web3-types';
+import { isNullish } from 'web3-validator';
+import { Eip1559NotSupportedError, UnsupportedTransactionTypeError } from 'web3-errors';
+import { format } from 'web3-utils';
+// eslint-disable-next-line import/no-cycle
+import { getBlock, getGasPrice } from '../rpc_method_wrappers.js';
+import { InternalTransaction } from '../types.js';
+// eslint-disable-next-line import/no-cycle
+import { getTransactionType } from './transaction_builder.js';
+
+async function getEip1559GasPricing<ReturnFormat extends DataFormat>(
+	transaction: FormatType<Transaction, typeof ETH_DATA_FORMAT>,
+	web3Context: Web3Context<EthExecutionAPI>,
+	returnFormat: ReturnFormat,
+): Promise<FormatType<{ maxPriorityFeePerGas?: Numbers; maxFeePerGas?: Numbers }, ReturnFormat>> {
+	const block = await getBlock(web3Context, web3Context.defaultBlock, false, ETH_DATA_FORMAT);
+	if (isNullish(block.baseFeePerGas)) throw new Eip1559NotSupportedError();
+
+	let gasPrice: Numbers | undefined;
+	if (isNullish(transaction.gasPrice) && BigInt(block.baseFeePerGas) === BigInt(0)) {
+		gasPrice = await getGasPrice(web3Context, returnFormat);
+	}
+	if (!isNullish(transaction.gasPrice) || !isNullish(gasPrice)) {
+		const convertedTransactionGasPrice = format(
+			{ format: 'uint' },
+			transaction.gasPrice ?? gasPrice,
+			returnFormat,
+		);
+
+		return {
+			maxPriorityFeePerGas: convertedTransactionGasPrice,
+			maxFeePerGas: convertedTransactionGasPrice,
+		};
+	}
+	return {
+		maxPriorityFeePerGas: format(
+			{ format: 'uint' },
+			transaction.maxPriorityFeePerGas ?? web3Context.defaultMaxPriorityFeePerGas,
+			returnFormat,
+		),
+		maxFeePerGas: format(
+			{ format: 'uint' },
+			(transaction.maxFeePerGas ??
+				BigInt(block.baseFeePerGas) * BigInt(2) +
+					BigInt(
+						transaction.maxPriorityFeePerGas ?? web3Context.defaultMaxPriorityFeePerGas,
+					)) as Numbers,
+			returnFormat,
+		),
+	};
+}
+
+export async function getTransactionGasPricing<ReturnFormat extends DataFormat>(
+	transaction: InternalTransaction,
+	web3Context: Web3Context<EthExecutionAPI>,
+	returnFormat: ReturnFormat,
+): Promise<
+	| FormatType<
+			{ gasPrice?: Numbers; maxPriorityFeePerGas?: Numbers; maxFeePerGas?: Numbers },
+			ReturnFormat
+	  >
+	| undefined
+> {
+	const transactionType = getTransactionType(transaction, web3Context);
+	if (!isNullish(transactionType)) {
+		if (transactionType.startsWith('-'))
+			throw new UnsupportedTransactionTypeError(transactionType);
+
+		// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-2718.md#transactions
+		if (Number(transactionType) < 0 || Number(transactionType) > 127)
+			throw new UnsupportedTransactionTypeError(transactionType);
+
+		if (
+			isNullish(transaction.gasPrice) &&
+			(transactionType === '0x0' || transactionType === '0x1')
+		)
+			return {
+				gasPrice: await getGasPrice(web3Context, returnFormat),
+				maxPriorityFeePerGas: undefined,
+				maxFeePerGas: undefined,
+			};
+
+		if (transactionType === '0x2') {
+			return {
+				gasPrice: undefined,
+				...(await getEip1559GasPricing(transaction, web3Context, returnFormat)),
+			};
+		}
+	}
+
+	return undefined;
+}

package/src/utils/index.ts

@@ -0,0 +1,21 @@
+/*
+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/>.
+*/
+
+export * from './detect_transaction_type.js';
+export * from './format_transaction.js';
+export * from './prepare_transaction_for_signing.js';
+export * from './transaction_builder.js';

package/src/utils/prepare_transaction_for_signing.ts

@@ -0,0 +1,154 @@
+/*
+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 {
+	EthExecutionAPI,
+	HexString,
+	PopulatedUnsignedEip1559Transaction,
+	PopulatedUnsignedEip2930Transaction,
+	PopulatedUnsignedTransaction,
+	Transaction,
+	ValidChains,
+	FormatType,
+	ETH_DATA_FORMAT,
+} from 'web3-types';
+import { Web3Context } from 'web3-core';
+import { toNumber } from 'web3-utils';
+import { TransactionFactory, TxOptions, Common } from 'web3-eth-accounts';
+import { isNullish } from 'web3-validator';
+import { validateTransactionForSigning } from '../validation.js';
+import { formatTransaction } from './format_transaction.js';
+import { transactionBuilder } from './transaction_builder.js';
+
+const getEthereumjsTxDataFromTransaction = (
+	transaction: FormatType<PopulatedUnsignedTransaction, typeof ETH_DATA_FORMAT>,
+) => ({
+	...transaction,
+	nonce: transaction.nonce,
+	gasPrice: transaction.gasPrice,
+	gasLimit: transaction.gasLimit ?? transaction.gas,
+	to: transaction.to,
+	value: transaction.value,
+	data: transaction.data ?? transaction.input,
+	type: transaction.type,
+	chainId: transaction.chainId,
+	accessList: (
+		transaction as FormatType<PopulatedUnsignedEip2930Transaction, typeof ETH_DATA_FORMAT>
+	).accessList,
+	maxPriorityFeePerGas: (
+		transaction as FormatType<PopulatedUnsignedEip1559Transaction, typeof ETH_DATA_FORMAT>
+	).maxPriorityFeePerGas,
+	maxFeePerGas: (
+		transaction as FormatType<PopulatedUnsignedEip1559Transaction, typeof ETH_DATA_FORMAT>
+	).maxFeePerGas,
+});
+
+const getEthereumjsTransactionOptions = (
+	transaction: FormatType<PopulatedUnsignedTransaction, typeof ETH_DATA_FORMAT>,
+	web3Context: Web3Context<EthExecutionAPI>,
+) => {
+	const hasTransactionSigningOptions =
+		(!isNullish(transaction.chain) && !isNullish(transaction.hardfork)) ||
+		!isNullish(transaction.common);
+
+	let common;
+	if (!hasTransactionSigningOptions) {
+		// if defaultcommon is specified, use that.
+		if (web3Context.defaultCommon) {
+			common = { ...web3Context.defaultCommon };
+
+			if (isNullish(common.hardfork))
+				common.hardfork = transaction.hardfork ?? web3Context.defaultHardfork;
+			if (isNullish(common.baseChain))
+				common.baseChain = web3Context.defaultChain as ValidChains;
+		} else {
+			common = Common.custom(
+				{
+					name: 'custom-network',
+					chainId: toNumber(transaction.chainId) as number,
+					networkId: !isNullish(transaction.networkId)
+						? (toNumber(transaction.networkId) as number)
+						: undefined,
+					defaultHardfork: transaction.hardfork ?? web3Context.defaultHardfork,
+				},
+				{
+					baseChain: web3Context.defaultChain,
+				},
+			);
+		}
+	} else {
+		const name =
+			transaction?.common?.customChain?.name ?? transaction.chain ?? 'custom-network';
+		const chainId = toNumber(
+			transaction?.common?.customChain?.chainId ?? transaction?.chainId,
+		) as number;
+		const networkId = toNumber(
+			transaction?.common?.customChain?.networkId ?? transaction?.networkId,
+		) as number;
+		const defaultHardfork =
+			transaction?.common?.hardfork ?? transaction?.hardfork ?? web3Context.defaultHardfork;
+		const baseChain =
+			transaction.common?.baseChain ?? transaction.chain ?? web3Context.defaultChain;
+
+		if (chainId && networkId && name) {
+			common = Common.custom(
+				{
+					name,
+					chainId,
+					networkId,
+					defaultHardfork,
+				},
+				{
+					baseChain,
+				},
+			);
+		}
+	}
+	return { common } as TxOptions;
+};
+
+export const prepareTransactionForSigning = async (
+	transaction: Transaction,
+	web3Context: Web3Context<EthExecutionAPI>,
+	privateKey?: HexString | Uint8Array,
+	fillGasPrice = false,
+	fillGasLimit = true,
+) => {
+	const populatedTransaction = (await transactionBuilder({
+		transaction,
+		web3Context,
+		privateKey,
+		fillGasPrice,
+		fillGasLimit,
+	})) as unknown as PopulatedUnsignedTransaction;
+	const formattedTransaction = formatTransaction(populatedTransaction, ETH_DATA_FORMAT, {
+		transactionSchema: web3Context.config.customTransactionSchema,
+	}) as unknown as FormatType<PopulatedUnsignedTransaction, typeof ETH_DATA_FORMAT>;
+
+	validateTransactionForSigning(
+		formattedTransaction as unknown as FormatType<Transaction, typeof ETH_DATA_FORMAT>,
+		undefined,
+		{
+			transactionSchema: web3Context.config.customTransactionSchema,
+		},
+	);
+
+	return TransactionFactory.fromTxData(
+		getEthereumjsTxDataFromTransaction(formattedTransaction),
+		getEthereumjsTransactionOptions(formattedTransaction, web3Context),
+	);
+};

package/src/utils/reject_if_block_timeout.ts

@@ -0,0 +1,176 @@
+/*
+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 { EthExecutionAPI, Bytes, Web3BaseProvider, BlockHeaderOutput } from 'web3-types';
+import { Web3Context } from 'web3-core';
+import { rejectIfConditionAtInterval } from 'web3-utils';
+
+import { TransactionBlockTimeoutError } from 'web3-errors';
+import { NUMBER_DATA_FORMAT } from '../constants.js';
+// eslint-disable-next-line import/no-cycle
+import { getBlockNumber } from '../rpc_method_wrappers.js';
+import { NewHeadsSubscription } from '../web3_subscriptions.js';
+
+export interface ResourceCleaner {
+	clean: () => void;
+}
+
+function resolveByPolling(
+	web3Context: Web3Context<EthExecutionAPI>,
+	starterBlockNumber: number,
+	transactionHash?: Bytes,
+): [Promise<never>, ResourceCleaner] {
+	const pollingInterval = web3Context.transactionPollingInterval;
+	const [intervalId, promiseToError] = rejectIfConditionAtInterval(async () => {
+		let lastBlockNumber;
+		try {
+			lastBlockNumber = await getBlockNumber(web3Context, NUMBER_DATA_FORMAT);
+		} catch (error) {
+			console.warn('An error happen while trying to get the block number', error);
+			return undefined;
+		}
+		const numberOfBlocks = lastBlockNumber - starterBlockNumber;
+		if (numberOfBlocks >= web3Context.transactionBlockTimeout) {
+			return new TransactionBlockTimeoutError({
+				starterBlockNumber,
+				numberOfBlocks,
+				transactionHash,
+			});
+		}
+		return undefined;
+	}, pollingInterval);
+
+	const clean = () => {
+		clearInterval(intervalId);
+	};
+
+	return [promiseToError, { clean }];
+}
+
+async function resolveBySubscription(
+	web3Context: Web3Context<EthExecutionAPI>,
+	starterBlockNumber: number,
+	transactionHash?: Bytes,
+): Promise<[Promise<never>, ResourceCleaner]> {
+	// The following variable will stay true except if the data arrived,
+	//	or if watching started after an error had occurred.
+	let needToWatchLater = true;
+
+	let subscription: NewHeadsSubscription;
+	let resourceCleaner: ResourceCleaner;
+	// internal helper function
+	function revertToPolling(
+		reject: (value: Error | PromiseLike<Error>) => void,
+		previousError?: Error,
+	) {
+		if (previousError) {
+			console.warn('error happened at subscription. So revert to polling...', previousError);
+		}
+		resourceCleaner.clean();
+
+		needToWatchLater = false;
+		const [promiseToError, newResourceCleaner] = resolveByPolling(
+			web3Context,
+			starterBlockNumber,
+			transactionHash,
+		);
+		resourceCleaner.clean = newResourceCleaner.clean;
+		promiseToError.catch(error => reject(error as Error));
+	}
+	try {
+		subscription = (await web3Context.subscriptionManager?.subscribe(
+			'newHeads',
+		)) as unknown as NewHeadsSubscription;
+		resourceCleaner = {
+			clean: () => {
+				// Remove the subscription, if it was not removed somewhere
+				// 	else by calling, for example, subscriptionManager.clear()
+				if (subscription.id) {
+					web3Context.subscriptionManager
+						?.removeSubscription(subscription)
+						.then(() => {
+							// Subscription ended successfully
+						})
+						.catch(() => {
+							// An error happened while ending subscription. But no need to take any action.
+						});
+				}
+			},
+		};
+	} catch (error) {
+		return resolveByPolling(web3Context, starterBlockNumber, transactionHash);
+	}
+	const promiseToError: Promise<never> = new Promise((_, reject) => {
+		try {
+			subscription.on('data', (lastBlockHeader: BlockHeaderOutput) => {
+				needToWatchLater = false;
+				if (!lastBlockHeader?.number) {
+					return;
+				}
+				const numberOfBlocks = Number(
+					BigInt(lastBlockHeader.number) - BigInt(starterBlockNumber),
+				);
+
+				if (numberOfBlocks >= web3Context.transactionBlockTimeout) {
+					// Transaction Block Timeout is known to be reached by subscribing to new heads
+					reject(
+						new TransactionBlockTimeoutError({
+							starterBlockNumber,
+							numberOfBlocks,
+							transactionHash,
+						}),
+					);
+				}
+			});
+			subscription.on('error', error => {
+				revertToPolling(reject, error);
+			});
+		} catch (error) {
+			revertToPolling(reject, error as Error);
+		}
+
+		// Fallback to polling if tx receipt didn't arrived in "blockHeaderTimeout" [10 seconds]
+		setTimeout(() => {
+			if (needToWatchLater) {
+				revertToPolling(reject);
+			}
+		}, web3Context.blockHeaderTimeout * 1000);
+	});
+
+	return [promiseToError, resourceCleaner];
+}
+
+/* TODO: After merge, there will be constant block mining time (exactly 12 second each block, except slot missed that currently happens in <1% of slots. ) so we can optimize following function
+for POS NWs, we can skip checking getBlockNumber(); after interval and calculate only based on time  that certain num of blocked are mined after that for internal double check, can do one getBlockNumber() call and timeout. 
+*/
+export async function rejectIfBlockTimeout(
+	web3Context: Web3Context<EthExecutionAPI>,
+	transactionHash?: Bytes,
+): Promise<[Promise<never>, ResourceCleaner]> {
+	const { provider } = web3Context.requestManager;
+	let callingRes: [Promise<never>, ResourceCleaner];
+	const starterBlockNumber = await getBlockNumber(web3Context, NUMBER_DATA_FORMAT);
+	// TODO: once https://github.com/web3/web3.js/issues/5521 is implemented, remove checking for `enableExperimentalFeatures.useSubscriptionWhenCheckingBlockTimeout`
+	if (
+		(provider as Web3BaseProvider).supportsSubscriptions?.() &&
+		web3Context.enableExperimentalFeatures.useSubscriptionWhenCheckingBlockTimeout
+	) {
+		callingRes = await resolveBySubscription(web3Context, starterBlockNumber, transactionHash);
+	} else {
+		callingRes = resolveByPolling(web3Context, starterBlockNumber, transactionHash);
+	}
+	return callingRes;
+}