Stop waiting after transactionBlockTimeout (#5294)

* stop waiting after `transactionBlockTimeout`
* fix an issue inside `transactionPollingTimeout` at `waitForTransactionReceipt`
* refactor the code for `waitForTransactionReceipt`
* added 3 reusable utility functions at web3-utils: `pollTillDefined`, `rejectIfTimeout` and `rejectIfConditionAtInterval`
* add `removeAllListeners` after finish testing `watch polling transaction`
* add a `warn` if the socket connection raises an error while closing
* tiny fix and improvements to tests at web-eth
* update CHANGELOG.md files

Author: Muhammad-Altabba

CHANGELOG.md

@@ -748,6 +748,12 @@ should use 4.0.1-alpha.0 for testing.
 -   Added the error code `ERR_TX_GAS_MISMATCH` and used it inside `TransactionGasMismatchError` (#5462)
 -   Added `SignatureError` to `web3-errors/src/errors/signature_errors.ts` (moved from `web3-eth/src/errors.ts`) (#5462)
 -   Added the errors' classes to `web3-errors/src/errors/transaction_errors.ts` from `web3-eth/src/errors.ts` (#5462)
+-   Added `TransactionBlockTimeoutError` class and its error code `ERR_TX_BLOCK_TIMEOUT` (#5294)
+
+#### web3-eth
+
+-   [setimmediate](https://github.com/yuzujs/setImmediate) package to polyfill [setImmediate](https://nodejs.org/api/timers.html#setimmediatecallback-args) for browsers (#5450)
+-   Implemented the logic for `transactionBlockTimeout` (#5294)
 
 #### web3-eth-abi
 
@@ -759,6 +765,10 @@ should use 4.0.1-alpha.0 for testing.
 -   Decoding error data, using Error ABI if available, according to EIP-838. (#5434)
 -   The class `Web3ContractError` is moved from this package to `web3-error`. (#5434)
 
+#### web3-utils
+
+-   Added and exported three reusable utility functions: `pollTillDefined`, `rejectIfTimeout` and `rejectIfConditionAtInterval` which are useful when dealing with promises that involves polling, rejecting after timeout or rejecting if a condition was met when calling repeatably at every time intervals.
+
 ### Changed
 
 #### web3-error

packages/web3-errors/CHANGELOG.md

@@ -45,6 +45,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 -   Added the error code `ERR_TX_GAS_MISMATCH` and used it inside `TransactionGasMismatchError` (#5462)
 -   Added `SignatureError` to `web3-errors/src/errors/signature_errors.ts` (moved from `web3-eth/src/errors.ts`) (#5462)
 -   Added the errors' classes to `web3-errors/src/errors/transaction_errors.ts` from `web3-eth/src/errors.ts` (#5462)
+-   Added `TransactionBlockTimeoutError` class and its error code `ERR_TX_BLOCK_TIMEOUT` (#5294)
 
 ### Changed
 

packages/web3-errors/src/error_codes.ts

@@ -76,6 +76,7 @@ export const ERR_TX_LOCAL_WALLET_NOT_AVAILABLE = 429;
 
 export const ERR_TX_NOT_FOUND = 430;
 export const ERR_TX_SEND_TIMEOUT = 431;
+export const ERR_TX_BLOCK_TIMEOUT = 432;
 
 export const ERR_TX_SIGNING = 433;
 export const ERR_TX_GAS_MISMATCH = 434;

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

@@ -21,6 +21,7 @@ import { Bytes, HexString, Numbers, TransactionReceipt } from 'web3-types';
 import {
 	ERR_RAW_TX_UNDEFINED,
 	ERR_TX,
+	ERR_TX_BLOCK_TIMEOUT,
 	ERR_TX_CONTRACT_NOT_STORED,
 	ERR_TX_CHAIN_ID_MISMATCH,
 	ERR_TX_DATA_AND_INPUT,
@@ -40,19 +41,19 @@ import {
 	ERR_TX_MISSING_CUSTOM_CHAIN_ID,
 	ERR_TX_MISSING_GAS,
 	ERR_TX_NO_CONTRACT_ADDRESS,
+	ERR_TX_NOT_FOUND,
 	ERR_TX_OUT_OF_GAS,
+	ERR_TX_POLLING_TIMEOUT,
+	ERR_TX_RECEIPT_MISSING_BLOCK_NUMBER,
+	ERR_TX_RECEIPT_MISSING_OR_BLOCKHASH_NULL,
 	ERR_TX_REVERT_INSTRUCTION,
 	ERR_TX_REVERT_TRANSACTION,
 	ERR_TX_REVERT_WITHOUT_REASON,
-	ERR_TX_NOT_FOUND,
 	ERR_TX_SEND_TIMEOUT,
 	ERR_TX_SIGNING,
 	ERR_TX_UNABLE_TO_POPULATE_NONCE,
 	ERR_TX_UNSUPPORTED_EIP_1559,
 	ERR_TX_UNSUPPORTED_TYPE,
-	ERR_TX_POLLING_TIMEOUT,
-	ERR_TX_RECEIPT_MISSING_OR_BLOCKHASH_NULL,
-	ERR_TX_RECEIPT_MISSING_BLOCK_NUMBER,
 } from '../error_codes';
 import { InvalidValueError, Web3Error } from '../web3_error_base';
 
@@ -157,6 +158,7 @@ export class TransactionNotFound extends TransactionError {
 		this.code = ERR_TX_NOT_FOUND;
 	}
 }
+
 export class InvalidTransactionWithSender extends InvalidValueError {
 	public code = ERR_TX_INVALID_SENDER;
 
@@ -410,6 +412,22 @@ export class TransactionPollingTimeoutError extends Web3Error {
 	}
 }
 
+export class TransactionBlockTimeoutError extends Web3Error {
+	public code = ERR_TX_BLOCK_TIMEOUT;
+
+	public constructor(value: {
+		starterBlockNumber: number;
+		numberOfBlocks: number;
+		transactionHash?: Bytes;
+	}) {
+		super(
+			`Transaction started at ${value.starterBlockNumber} but was not mined within ${
+				value.numberOfBlocks
+			} blocks. ${transactionTimeoutHint(value.transactionHash)}`,
+		);
+	}
+}
+
 export class TransactionMissingReceiptOrBlockHashError extends InvalidValueError {
 	public code = ERR_TX_RECEIPT_MISSING_OR_BLOCKHASH_NULL;
 

packages/web3-eth-personal/test/integration/personal.test.ts

@@ -24,7 +24,7 @@ import {
 	createAccount,
 	createNewAccount,
 	createTempAccount,
-	closeOpenConnection
+	closeOpenConnection,
 } from '../fixtures/system_test_utils';
 
 describe('personal integration tests', () => {

packages/web3-eth/CHANGELOG.md

@@ -40,6 +40,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 -   [setimmediate](https://github.com/yuzujs/setImmediate) package to polyfill [setImmediate](https://nodejs.org/api/timers.html#setimmediatecallback-args) for browsers (#5450)
+-   Implemented the logic for `transactionBlockTimeout` (#5294)
 
 ### Removed
 

packages/web3-eth/src/rpc_method_wrappers.ts

@@ -41,21 +41,11 @@ import {
 	TransactionWithLocalWalletIndex,
 } from 'web3-types';
 import { Web3Context, Web3PromiEvent } from 'web3-core';
-import {
-	ETH_DATA_FORMAT,
-	FormatType,
-	DataFormat,
-	DEFAULT_RETURN_FORMAT,
-	format,
-	waitWithTimeout,
-} from 'web3-utils';
+import { ETH_DATA_FORMAT, FormatType, DataFormat, DEFAULT_RETURN_FORMAT, format } from 'web3-utils';
 import { isBlockTag, isBytes, isNullish, isString } from 'web3-validator';
-import {
-	TransactionError,
-	TransactionRevertError,
-	SignatureError,
-	TransactionSendTimeoutError,
-} from 'web3-errors';
+import { SignatureError, TransactionError, TransactionRevertError } from 'web3-errors';
+
+import { decodeSignedTransaction } from './utils/decode_signed_transaction';
 import * as rpcMethods from './rpc_methods';
 import {
 	accountSchema,
@@ -77,11 +67,12 @@ import { formatTransaction } from './utils/format_transaction';
 // eslint-disable-next-line import/no-cycle
 import { getTransactionGasPricing } from './utils/get_transaction_gas_pricing';
 // eslint-disable-next-line import/no-cycle
+import { trySendTransaction } from './utils/try_send_transaction';
+// eslint-disable-next-line import/no-cycle
 import { waitForTransactionReceipt } from './utils/wait_for_transaction_receipt';
 import { watchTransactionForConfirmations } from './utils/watch_transaction_for_confirmations';
 import { Web3EthExecutionAPI } from './web3_eth_execution_api';
 import { NUMBER_DATA_FORMAT } from './constants';
-import { decodeSignedTransaction } from './utils/decode_signed_transaction';
 
 /**
  *
@@ -1119,27 +1110,23 @@ export function sendTransaction<
 								transactionFormatted as Record<string, unknown>,
 							);
 
-							transactionHash = await waitWithTimeout(
-								rpcMethods.sendRawTransaction(
-									web3Context.requestManager,
-									signedTransaction.rawTransaction,
-								),
-								web3Context.transactionSendTimeout,
-								new TransactionSendTimeoutError({
-									numberOfSeconds: web3Context.transactionSendTimeout / 1000,
-									transactionHash: signedTransaction.transactionHash,
-								}),
+							transactionHash = await trySendTransaction(
+								web3Context,
+								async (): Promise<string> =>
+									rpcMethods.sendRawTransaction(
+										web3Context.requestManager,
+										signedTransaction.rawTransaction,
+									),
+								signedTransaction.transactionHash,
 							);
 						} else {
-							transactionHash = await waitWithTimeout(
-								rpcMethods.sendTransaction(
-									web3Context.requestManager,
-									transactionFormatted as Partial<TransactionWithSenderAPI>,
-								),
-								web3Context.transactionSendTimeout,
-								new TransactionSendTimeoutError({
-									numberOfSeconds: web3Context.transactionSendTimeout / 1000,
-								}),
+							transactionHash = await trySendTransaction(
+								web3Context,
+								async (): Promise<string> =>
+									rpcMethods.sendTransaction(
+										web3Context.requestManager,
+										transactionFormatted as Partial<TransactionWithSenderAPI>,
+									),
 							);
 						}
 
@@ -1190,6 +1177,7 @@ export function sendTransaction<
 								);
 							}
 							reject(transactionReceiptFormatted as unknown as ResolveType);
+							return;
 						} else {
 							resolve(transactionReceiptFormatted as unknown as ResolveType);
 						}
@@ -1340,9 +1328,13 @@ export function sendSignedTransaction<
 						// 	await getRevertReason(web3Context, transaction, returnFormat);
 						// }
 
-						const transactionHash = await rpcMethods.sendRawTransaction(
-							web3Context.requestManager,
-							signedTransactionFormattedHex,
+						const transactionHash = await trySendTransaction(
+							web3Context,
+							async (): Promise<string> =>
+								rpcMethods.sendRawTransaction(
+									web3Context.requestManager,
+									signedTransactionFormattedHex,
+								),
 						);
 
 						if (promiEvent.listenerCount('sent') > 0) {
@@ -1392,6 +1384,7 @@ export function sendSignedTransaction<
 								);
 							}
 							reject(transactionReceiptFormatted as unknown as ResolveType);
+							return;
 						} else {
 							resolve(transactionReceiptFormatted as unknown as ResolveType);
 						}

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

@@ -0,0 +1,53 @@
+/*
+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 } from 'web3-types';
+import { Web3Context } from 'web3-core';
+import { rejectIfConditionAtInterval } from 'web3-utils';
+
+import { TransactionBlockTimeoutError } from 'web3-errors';
+import { NUMBER_DATA_FORMAT } from '../constants';
+// eslint-disable-next-line import/no-cycle
+import { getBlockNumber } from '../rpc_method_wrappers';
+
+/* 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 function rejectIfBlockTimeout(
+	web3Context: Web3Context<EthExecutionAPI>,
+	starterBlockNumber: number,
+	interval: number,
+	transactionHash?: Bytes,
+): [NodeJS.Timer, Promise<never>] {
+	return 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;
+	}, interval);
+}

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

@@ -0,0 +1,64 @@
+/*
+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';
+import { NUMBER_DATA_FORMAT } from '../constants';
+// eslint-disable-next-line import/no-cycle
+import { rejectIfBlockTimeout } from './reject_if_block_timeout';
+// eslint-disable-next-line import/no-cycle
+import { getBlockNumber } from '../rpc_method_wrappers';
+
+/**
+ * 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 pollingInterval = web3Context.transactionPollingInterval;
+
+	const [timeoutId, rejectOnTimeout] = rejectIfTimeout(
+		web3Context.transactionSendTimeout,
+		new TransactionSendTimeoutError({
+			numberOfSeconds: web3Context.transactionSendTimeout / 1000,
+			transactionHash,
+		}),
+	);
+
+	const starterBlockNumber = await getBlockNumber(web3Context, NUMBER_DATA_FORMAT);
+	const [intervalId, rejectOnBlockTimeout] = rejectIfBlockTimeout(
+		web3Context,
+		starterBlockNumber,
+		pollingInterval,
+		transactionHash,
+	);
+
+	try {
+		return await Promise.race([sendTransactionFunc(), rejectOnTimeout, rejectOnBlockTimeout]);
+	} finally {
+		clearTimeout(timeoutId);
+		clearInterval(intervalId);
+	}
+}