wb3-eth 0.0.1-security → 4.10.0

package/src/utils/send_tx_helper.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 {
+	ETH_DATA_FORMAT,
+	FormatType,
+	DataFormat,
+	EthExecutionAPI,
+	TransactionWithSenderAPI,
+	Web3BaseWalletAccount,
+	HexString,
+	TransactionReceipt,
+	Transaction,
+	TransactionCall,
+	TransactionWithFromLocalWalletIndex,
+	TransactionWithToLocalWalletIndex,
+	TransactionWithFromAndToLocalWalletIndex,
+	LogsInput,
+	TransactionHash,
+	ContractAbiWithSignature,
+} from 'web3-types';
+import { Web3Context, Web3EventEmitter, Web3PromiEvent } from 'web3-core';
+import { isNullish, JsonSchema } from 'web3-validator';
+import {
+	ContractExecutionError,
+	InvalidResponseError,
+	TransactionPollingTimeoutError,
+	TransactionRevertedWithoutReasonError,
+	TransactionRevertInstructionError,
+	TransactionRevertWithCustomError,
+} from 'web3-errors';
+import { ethRpcMethods } from 'web3-rpc-methods';
+
+import {
+	SendSignedTransactionEvents,
+	SendTransactionEvents,
+	SendTransactionOptions,
+} from '../types.js';
+// eslint-disable-next-line import/no-cycle
+import { getTransactionGasPricing } from './get_transaction_gas_pricing.js';
+// eslint-disable-next-line import/no-cycle
+import { trySendTransaction } from './try_send_transaction.js';
+// eslint-disable-next-line import/no-cycle
+import { watchTransactionForConfirmations } from './watch_transaction_for_confirmations.js';
+import { ALL_EVENTS_ABI } from '../constants.js';
+// eslint-disable-next-line import/no-cycle
+import { getTransactionError } from './get_transaction_error.js';
+// eslint-disable-next-line import/no-cycle
+import { getRevertReason } from './get_revert_reason.js';
+import { decodeEventABI } from './decoding.js';
+
+export class SendTxHelper<
+	ReturnFormat extends DataFormat,
+	ResolveType = FormatType<TransactionReceipt, ReturnFormat>,
+	TxType =
+		| Transaction
+		| TransactionWithFromLocalWalletIndex
+		| TransactionWithToLocalWalletIndex
+		| TransactionWithFromAndToLocalWalletIndex,
+> {
+	private readonly web3Context: Web3Context<EthExecutionAPI>;
+	private readonly promiEvent: Web3PromiEvent<
+		ResolveType,
+		SendSignedTransactionEvents<ReturnFormat> | SendTransactionEvents<ReturnFormat>
+	>;
+	private readonly options: SendTransactionOptions<ResolveType> = {
+		checkRevertBeforeSending: true,
+	};
+	private readonly returnFormat: ReturnFormat;
+	public constructor({
+		options,
+		web3Context,
+		promiEvent,
+		returnFormat,
+	}: {
+		web3Context: Web3Context<EthExecutionAPI>;
+		options: SendTransactionOptions<ResolveType>;
+		promiEvent: Web3PromiEvent<
+			ResolveType,
+			SendSignedTransactionEvents<ReturnFormat> | SendTransactionEvents<ReturnFormat>
+		>;
+		returnFormat: ReturnFormat;
+	}) {
+		this.options = options;
+		this.web3Context = web3Context;
+		this.promiEvent = promiEvent;
+		this.returnFormat = returnFormat;
+	}
+
+	public getReceiptWithEvents(data: TransactionReceipt): ResolveType {
+		const result = { ...(data ?? {}) };
+		if (this.options?.contractAbi && result.logs && result.logs.length > 0) {
+			result.events = {};
+			for (const log of result.logs) {
+				const event = decodeEventABI(
+					ALL_EVENTS_ABI,
+					log as LogsInput,
+					this.options?.contractAbi as ContractAbiWithSignature,
+					this.returnFormat,
+				);
+				if (event.event) {
+					result.events[event.event] = event;
+				}
+			}
+		}
+
+		return result as unknown as ResolveType;
+	}
+
+	public async checkRevertBeforeSending(tx: TransactionCall) {
+		if (this.options.checkRevertBeforeSending !== false) {
+			let formatTx = tx;
+			if (isNullish(tx.data) && isNullish(tx.input) && isNullish(tx.gas)) {
+				// eth.call runs into error if data isnt filled and gas is not defined, its a simple transaction so we fill it with 21000
+				formatTx = {
+					...tx,
+					gas: 21000,
+				};
+			}
+			const reason = await getRevertReason(
+				this.web3Context,
+				formatTx,
+				this.options.contractAbi,
+			);
+			if (reason !== undefined) {
+				throw await getTransactionError<ReturnFormat>(
+					this.web3Context,
+					tx,
+					undefined,
+					undefined,
+					this.options.contractAbi,
+					reason,
+				);
+			}
+		}
+	}
+
+	public emitSending(tx: TxType | HexString) {
+		if (this.promiEvent.listenerCount('sending') > 0) {
+			this.promiEvent.emit('sending', tx);
+		}
+	}
+
+	public async populateGasPrice({
+		transactionFormatted,
+		transaction,
+	}: {
+		transactionFormatted: TxType;
+		transaction: TxType;
+	}): Promise<TxType> {
+		let result = transactionFormatted;
+		if (
+			!this.web3Context.config.ignoreGasPricing &&
+			!this.options?.ignoreGasPricing &&
+			isNullish((transactionFormatted as Transaction).gasPrice) &&
+			(isNullish((transaction as Transaction).maxPriorityFeePerGas) ||
+				isNullish((transaction as Transaction).maxFeePerGas))
+		) {
+			result = {
+				...transactionFormatted,
+				// @TODO gasPrice, maxPriorityFeePerGas, maxFeePerGas
+				// should not be included if undefined, but currently are
+				...(await getTransactionGasPricing(
+					transactionFormatted,
+					this.web3Context,
+					ETH_DATA_FORMAT,
+				)),
+			};
+		}
+
+		return result;
+	}
+
+	public async signAndSend({
+		wallet,
+		tx,
+	}: {
+		wallet: Web3BaseWalletAccount | undefined;
+		tx: TxType;
+	}) {
+		if (wallet) {
+			const signedTransaction = await wallet.signTransaction(tx);
+
+			return trySendTransaction(
+				this.web3Context,
+				async (): Promise<string> =>
+					ethRpcMethods.sendRawTransaction(
+						this.web3Context.requestManager,
+						signedTransaction.rawTransaction,
+					),
+				signedTransaction.transactionHash,
+			);
+		}
+		return trySendTransaction(
+			this.web3Context,
+			async (): Promise<string> =>
+				ethRpcMethods.sendTransaction(
+					this.web3Context.requestManager,
+					tx as Partial<TransactionWithSenderAPI>,
+				),
+		);
+	}
+
+	public emitSent(tx: TxType | HexString) {
+		if (this.promiEvent.listenerCount('sent') > 0) {
+			this.promiEvent.emit('sent', tx);
+		}
+	}
+	public emitTransactionHash(hash: string & Uint8Array) {
+		if (this.promiEvent.listenerCount('transactionHash') > 0) {
+			this.promiEvent.emit('transactionHash', hash);
+		}
+	}
+
+	public emitReceipt(receipt: ResolveType) {
+		if (this.promiEvent.listenerCount('receipt') > 0) {
+			(
+				this.promiEvent as Web3EventEmitter<
+					SendTransactionEvents<ReturnFormat> | SendSignedTransactionEvents<ReturnFormat>
+				>
+			).emit(
+				'receipt',
+				// @ts-expect-error unknown type fix
+				receipt,
+			);
+		}
+	}
+
+	public async handleError({ error, tx }: { error: unknown; tx: TransactionCall }) {
+		let _error = error;
+
+		if (_error instanceof ContractExecutionError && this.web3Context.handleRevert) {
+			_error = await getTransactionError(
+				this.web3Context,
+				tx,
+				undefined,
+				undefined,
+				this.options?.contractAbi,
+			);
+		}
+
+		if (
+			(_error instanceof InvalidResponseError ||
+				_error instanceof ContractExecutionError ||
+				_error instanceof TransactionRevertWithCustomError ||
+				_error instanceof TransactionRevertedWithoutReasonError ||
+				_error instanceof TransactionRevertInstructionError ||
+				_error instanceof TransactionPollingTimeoutError) &&
+			this.promiEvent.listenerCount('error') > 0
+		) {
+			this.promiEvent.emit('error', _error);
+		}
+
+		return _error;
+	}
+
+	public emitConfirmation({
+		receipt,
+		transactionHash,
+		customTransactionReceiptSchema,
+	}: {
+		receipt: ResolveType;
+		transactionHash: TransactionHash;
+		customTransactionReceiptSchema?: JsonSchema;
+	}) {
+		if (this.promiEvent.listenerCount('confirmation') > 0) {
+			watchTransactionForConfirmations<
+				ReturnFormat,
+				SendSignedTransactionEvents<ReturnFormat> | SendTransactionEvents<ReturnFormat>,
+				ResolveType
+			>(
+				this.web3Context,
+				this.promiEvent,
+				receipt as unknown as TransactionReceipt,
+				transactionHash,
+				this.returnFormat,
+				customTransactionReceiptSchema,
+			);
+		}
+	}
+
+	public async handleResolve({ receipt, tx }: { receipt: ResolveType; tx: TransactionCall }) {
+		if (this.options?.transactionResolver) {
+			return this.options?.transactionResolver(receipt as unknown as TransactionReceipt);
+		}
+		if ((receipt as unknown as TransactionReceipt).status === BigInt(0)) {
+			const error = await getTransactionError<ReturnFormat>(
+				this.web3Context,
+				tx,
+				// @ts-expect-error unknown type fix
+				receipt,
+				undefined,
+				this.options?.contractAbi,
+			);
+			if (this.promiEvent.listenerCount('error') > 0) {
+				this.promiEvent.emit('error', error);
+			}
+
+			throw error;
+		} else {
+			return receipt;
+		}
+	}
+}

package/src/utils/transaction_builder.ts

@@ -0,0 +1,264 @@
+/*
+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,
+	Address,
+	HexString,
+	ValidChains,
+	Hardfork,
+	Transaction,
+	TransactionWithFromLocalWalletIndex,
+	TransactionWithToLocalWalletIndex,
+	TransactionWithFromAndToLocalWalletIndex,
+	Common,
+	Web3NetAPI,
+	Numbers,
+	DataFormat,
+	FormatType,
+	ETH_DATA_FORMAT,
+} from 'web3-types';
+import { Web3Context } from 'web3-core';
+import { privateKeyToAddress } from 'web3-eth-accounts';
+import { getId } from 'web3-net';
+import { isNullish, isNumber, isHexStrict, isAddress } from 'web3-validator';
+import {
+	InvalidTransactionWithSender,
+	InvalidTransactionWithReceiver,
+	LocalWalletNotAvailableError,
+	TransactionDataAndInputError,
+	UnableToPopulateNonceError,
+} from 'web3-errors';
+import { bytesToHex, format } from 'web3-utils';
+import { NUMBER_DATA_FORMAT } from '../constants.js';
+// eslint-disable-next-line import/no-cycle
+import { getChainId, getTransactionCount, estimateGas } from '../rpc_method_wrappers.js';
+import { detectTransactionType } from './detect_transaction_type.js';
+import { transactionSchema } from '../schemas.js';
+import { InternalTransaction } from '../types.js';
+// eslint-disable-next-line import/no-cycle
+import { getTransactionGasPricing } from './get_transaction_gas_pricing.js';
+
+export const getTransactionFromOrToAttr = (
+	attr: 'from' | 'to',
+	web3Context: Web3Context<EthExecutionAPI>,
+	transaction?:
+		| Transaction
+		| TransactionWithFromLocalWalletIndex
+		| TransactionWithToLocalWalletIndex
+		| TransactionWithFromAndToLocalWalletIndex,
+	privateKey?: HexString | Uint8Array,
+): Address | undefined => {
+	if (transaction !== undefined && attr in transaction && transaction[attr] !== undefined) {
+		if (typeof transaction[attr] === 'string' && isAddress(transaction[attr] as string)) {
+			return transaction[attr] as Address;
+		}
+		if (!isHexStrict(transaction[attr] as string) && isNumber(transaction[attr] as Numbers)) {
+			if (web3Context.wallet) {
+				const account = web3Context.wallet.get(
+					format({ format: 'uint' }, transaction[attr] as Numbers, NUMBER_DATA_FORMAT),
+				);
+
+				if (!isNullish(account)) {
+					return account.address;
+				}
+
+				throw new LocalWalletNotAvailableError();
+			}
+			throw new LocalWalletNotAvailableError();
+		} else {
+			throw attr === 'from'
+				? new InvalidTransactionWithSender(transaction.from)
+				: // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+				  new InvalidTransactionWithReceiver(transaction.to);
+		}
+	}
+	if (attr === 'from') {
+		if (!isNullish(privateKey)) return privateKeyToAddress(privateKey);
+		if (!isNullish(web3Context.defaultAccount)) return web3Context.defaultAccount;
+	}
+
+	return undefined;
+};
+
+export const getTransactionNonce = async <ReturnFormat extends DataFormat>(
+	web3Context: Web3Context<EthExecutionAPI>,
+	address?: Address,
+	returnFormat: ReturnFormat = web3Context.defaultReturnFormat as ReturnFormat,
+) => {
+	if (isNullish(address)) {
+		// TODO if (web3.eth.accounts.wallet) use address from local wallet
+		throw new UnableToPopulateNonceError();
+	}
+
+	return getTransactionCount(web3Context, address, web3Context.defaultBlock, returnFormat);
+};
+
+export const getTransactionType = (
+	transaction: FormatType<Transaction, typeof ETH_DATA_FORMAT>,
+	web3Context: Web3Context<EthExecutionAPI>,
+) => {
+	const inferredType = detectTransactionType(transaction, web3Context);
+	if (!isNullish(inferredType)) return inferredType;
+	if (!isNullish(web3Context.defaultTransactionType))
+		return format({ format: 'uint' }, web3Context.defaultTransactionType, ETH_DATA_FORMAT);
+
+	return undefined;
+};
+
+// Keep in mind that the order the properties of populateTransaction get populated matters
+// as some of the properties are dependent on others
+export async function defaultTransactionBuilder<ReturnType = Transaction>(options: {
+	transaction: Transaction;
+	web3Context: Web3Context<EthExecutionAPI & Web3NetAPI>;
+	privateKey?: HexString | Uint8Array;
+	fillGasPrice?: boolean;
+	fillGasLimit?: boolean;
+}): Promise<ReturnType> {
+	let populatedTransaction = format(
+		transactionSchema,
+		options.transaction,
+		options.web3Context.defaultReturnFormat,
+	) as InternalTransaction;
+
+	if (isNullish(populatedTransaction.from)) {
+		populatedTransaction.from = getTransactionFromOrToAttr(
+			'from',
+			options.web3Context,
+			undefined,
+			options.privateKey,
+		);
+	}
+
+	// TODO: Debug why need to typecase getTransactionNonce
+	if (isNullish(populatedTransaction.nonce)) {
+		populatedTransaction.nonce = await getTransactionNonce(
+			options.web3Context,
+			populatedTransaction.from,
+			ETH_DATA_FORMAT,
+		);
+	}
+
+	if (isNullish(populatedTransaction.value)) {
+		populatedTransaction.value = '0x0';
+	}
+
+	if (!isNullish(populatedTransaction.data)) {
+		if (
+			!isNullish(populatedTransaction.input) &&
+			populatedTransaction.data !== populatedTransaction.input
+		)
+			throw new TransactionDataAndInputError({
+				data: bytesToHex(populatedTransaction.data),
+				input: bytesToHex(populatedTransaction.input),
+			});
+
+		if (!populatedTransaction.data.startsWith('0x'))
+			populatedTransaction.data = `0x${populatedTransaction.data}`;
+	} else if (!isNullish(populatedTransaction.input)) {
+		if (!populatedTransaction.input.startsWith('0x'))
+			populatedTransaction.input = `0x${populatedTransaction.input}`;
+	} else {
+		populatedTransaction.input = '0x';
+	}
+
+	if (isNullish(populatedTransaction.common)) {
+		if (options.web3Context.defaultCommon) {
+			const common = options.web3Context.defaultCommon as unknown as Common;
+			const chainId = common.customChain.chainId as string;
+			const networkId = common.customChain.networkId as string;
+			const name = common.customChain.name as string;
+			populatedTransaction.common = {
+				...common,
+				customChain: { chainId, networkId, name },
+			};
+		}
+
+		if (isNullish(populatedTransaction.chain)) {
+			populatedTransaction.chain = options.web3Context.defaultChain as ValidChains;
+		}
+		if (isNullish(populatedTransaction.hardfork)) {
+			populatedTransaction.hardfork = options.web3Context.defaultHardfork as Hardfork;
+		}
+	}
+
+	if (
+		isNullish(populatedTransaction.chainId) &&
+		isNullish(populatedTransaction.common?.customChain.chainId)
+	) {
+		populatedTransaction.chainId = await getChainId(options.web3Context, ETH_DATA_FORMAT);
+	}
+
+	if (isNullish(populatedTransaction.networkId)) {
+		populatedTransaction.networkId =
+			(options.web3Context.defaultNetworkId as string) ??
+			(await getId(options.web3Context, ETH_DATA_FORMAT));
+	}
+
+	if (isNullish(populatedTransaction.gasLimit) && !isNullish(populatedTransaction.gas)) {
+		populatedTransaction.gasLimit = populatedTransaction.gas;
+	}
+
+	populatedTransaction.type = getTransactionType(populatedTransaction, options.web3Context);
+	if (
+		isNullish(populatedTransaction.accessList) &&
+		(populatedTransaction.type === '0x1' || populatedTransaction.type === '0x2')
+	) {
+		populatedTransaction.accessList = [];
+	}
+	if (options.fillGasPrice)
+		populatedTransaction = {
+			...populatedTransaction,
+			...(await getTransactionGasPricing(
+				populatedTransaction,
+				options.web3Context,
+				ETH_DATA_FORMAT,
+			)),
+		};
+	if (
+		isNullish(populatedTransaction.gas) &&
+		isNullish(populatedTransaction.gasLimit) &&
+		options.fillGasLimit
+	) {
+		const fillGasLimit = await estimateGas(
+			options.web3Context,
+			populatedTransaction,
+			'latest',
+			ETH_DATA_FORMAT,
+		);
+		populatedTransaction = {
+			...populatedTransaction,
+			gas: format({ format: 'uint' }, fillGasLimit as Numbers, ETH_DATA_FORMAT),
+		};
+	}
+	return populatedTransaction as ReturnType;
+}
+
+export const transactionBuilder = async <ReturnType = Transaction>(
+	options: {
+		transaction: Transaction;
+		web3Context: Web3Context<EthExecutionAPI>;
+		privateKey?: HexString | Uint8Array;
+		fillGasPrice?: boolean;
+		fillGasLimit?: boolean;
+	},
+	// eslint-disable-next-line @typescript-eslint/require-await
+) =>
+	(options.web3Context.transactionBuilder ?? defaultTransactionBuilder)({
+		...options,
+		transaction: options.transaction,
+	}) as unknown as ReturnType;

package/src/utils/try_send_transaction.ts

@@ -0,0 +1,61 @@
+/*
+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, Bytes } from 'web3-types';
+import { AsyncFunction, rejectIfTimeout } from 'web3-utils';
+import { TransactionSendTimeoutError } from 'web3-errors';
+
+// eslint-disable-next-line import/no-cycle
+import { rejectIfBlockTimeout } from './reject_if_block_timeout.js';
+
+/**
+ * An internal function to send a transaction or throws if sending did not finish during the timeout during the blocks-timeout.
+ * @param web3Context - the context to read the configurations from
+ * @param sendTransactionFunc - the function that will send the transaction (could be sendTransaction or sendRawTransaction)
+ * @param transactionHash - to be used inside the exception message if there will be any exceptions.
+ * @returns the Promise<string> returned by the `sendTransactionFunc`.
+ */
+export async function trySendTransaction(
+	web3Context: Web3Context<EthExecutionAPI>,
+	sendTransactionFunc: AsyncFunction<string>,
+	transactionHash?: Bytes,
+): Promise<string> {
+	const [timeoutId, rejectOnTimeout] = rejectIfTimeout(
+		web3Context.transactionSendTimeout,
+		new TransactionSendTimeoutError({
+			numberOfSeconds: web3Context.transactionSendTimeout / 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([
+			sendTransactionFunc(), // this is the function that will send the transaction
+			rejectOnTimeout, // this will throw an error on Transaction Send Timeout
+			rejectOnBlockTimeout, // this will throw an error on Transaction Block Timeout
+		]);
+	} finally {
+		clearTimeout(timeoutId);
+		blockTimeoutResourceCleaner.clean();
+	}
+}