catching promise - legacy provider error

packages/web3-core/src/web3_request_manager.ts

@@ -210,7 +210,7 @@ export class Web3RequestManager<
 		) as JsonRpcPayload;
 
 		if (!isNullish(this.middleware)) {
-			payload = (await this.middleware.processRequest(payload));
+			payload = await this.middleware.processRequest(payload);
 		}
 		if (isWeb3Provider(provider)) {
 			let response;
@@ -248,7 +248,7 @@ export class Web3RequestManager<
 		// TODO: This could be deprecated and removed.
 		if (isLegacyRequestProvider(provider)) {
 			return new Promise<JsonRpcResponse<ResponseType>>((resolve, reject) => {
-				const rejectWithError = (err: unknown) =>
+				const rejectWithError = (err: unknown) => {
 					reject(
 						this._processJsonRpcResponse(
 							payload,
@@ -259,6 +259,8 @@ export class Web3RequestManager<
 							},
 						),
 					);
+				};
+
 				const resolveWithResponse = (response: JsonRpcResponse<ResponseType>) =>
 					resolve(
 						this._processJsonRpcResponse(payload, response, {
@@ -288,7 +290,20 @@ export class Web3RequestManager<
 					const responsePromise = result as unknown as Promise<
 						JsonRpcResponse<ResponseType>
 					>;
-					responsePromise.then(resolveWithResponse).catch(rejectWithError);
+					responsePromise.then(resolveWithResponse).catch(error => {
+						try {
+							// Attempt to process the error response
+							const processedError = this._processJsonRpcResponse(
+								payload,
+								error as JsonRpcResponse<ResponseType, unknown>,
+								{ legacy: true, error: true },
+							);
+							reject(processedError);
+						} catch (processingError) {
+							// Catch any errors that occur during the error processing
+							reject(processingError);
+						}
+					});
 				}
 			});
 		}

packages/web3-core/test/unit/web3_request_manager.test.ts

@@ -280,6 +280,7 @@ describe('Web3RequestManager', () => {
 			expect(myProvider.request).toHaveBeenCalledTimes(1);
 			expect(await pr).toBe('test');
 		});
+
 		it('Got a "nullish" response from provider', async () => {
 			const manager = new Web3RequestManager(undefined, undefined);
 			const myProvider = {
@@ -1134,6 +1135,38 @@ describe('Web3RequestManager', () => {
 				expect(myProvider.request).toHaveBeenCalledWith(payload, expect.any(Function));
 			});
 
+			it('should error in isPromise', async () => {
+				const manager = new Web3RequestManager();
+				const myProvider = {
+					request: jest
+						.fn()
+						.mockImplementation(async () => Promise.reject(errorResponse)),
+				} as any;
+
+				jest.spyOn(manager, 'provider', 'get').mockReturnValue(myProvider);
+
+				await expect(manager.sendBatch(request)).rejects.toEqual(errorResponse);
+				expect(myProvider.request).toHaveBeenCalledTimes(1);
+				expect(myProvider.request).toHaveBeenCalledWith(payload, expect.any(Function));
+			});
+
+			it('should catch error and process json response in isPromise', async () => {
+				const manager = new Web3RequestManager();
+				const myProvider = {
+					request: jest
+						.fn()
+						.mockImplementation(async () => Promise.reject(errorResponse)),
+				} as any;
+				jest.spyOn(manager as any, '_processJsonRpcResponse').mockImplementation(() => {
+					return errorResponse;
+				});
+				jest.spyOn(manager, 'provider', 'get').mockReturnValue(myProvider);
+
+				await expect(manager.sendBatch(request)).rejects.toEqual(errorResponse);
+				expect(myProvider.request).toHaveBeenCalledTimes(1);
+				expect(myProvider.request).toHaveBeenCalledWith(payload, expect.any(Function));
+			});
+
 			it('should pass request to provider and reject if provider returns error', async () => {
 				const manager = new Web3RequestManager();
 				const myProvider = {

packages/web3-eth/test/integration/web3_eth/send_transaction.test.ts

@@ -90,7 +90,9 @@ describe('Web3Eth.sendTransaction', () => {
 		expect(response.status).toBe(BigInt(1));
 		expect(response.events).toBeUndefined();
 
-		const minedTransactionData = await web3EthWithWallet.getTransaction(response.transactionHash);
+		const minedTransactionData = await web3EthWithWallet.getTransaction(
+			response.transactionHash,
+		);
 
 		expect(minedTransactionData).toMatchObject({
 			from: tempAcc.address,
@@ -119,7 +121,9 @@ describe('Web3Eth.sendTransaction', () => {
 		expect(response.status).toBe(BigInt(1));
 		expect(response.events).toBeUndefined();
 
-		const minedTransactionData = await web3EthWithWallet.getTransaction(response.transactionHash);
+		const minedTransactionData = await web3EthWithWallet.getTransaction(
+			response.transactionHash,
+		);
 
 		expect(minedTransactionData).toMatchObject({
 			from: tempAcc.address,
@@ -152,7 +156,9 @@ describe('Web3Eth.sendTransaction', () => {
 		expect(response.status).toBe(BigInt(1));
 		expect(response.events).toBeUndefined();
 
-		const minedTransactionData = await web3EthWithWallet.getTransaction(response.transactionHash);
+		const minedTransactionData = await web3EthWithWallet.getTransaction(
+			response.transactionHash,
+		);
 
 		expect(minedTransactionData).toMatchObject({
 			from: tempAcc.address,
@@ -534,9 +540,12 @@ describe('Web3Eth.sendTransaction', () => {
 				from: tempAcc.address,
 				data: SimpleRevertDeploymentData,
 			};
-			simpleRevertDeployTransaction.gas = await web3Eth.estimateGas(simpleRevertDeployTransaction);
-			simpleRevertContractAddress = (await web3Eth.sendTransaction(simpleRevertDeployTransaction))
-				.contractAddress as Address;
+			simpleRevertDeployTransaction.gas = await web3Eth.estimateGas(
+				simpleRevertDeployTransaction,
+			);
+			simpleRevertContractAddress = (
+				await web3Eth.sendTransaction(simpleRevertDeployTransaction)
+			).contractAddress as Address;
 		});
 
 		it('Should throw TransactionRevertInstructionError because gas too low', async () => {
@@ -578,7 +587,9 @@ describe('Web3Eth.sendTransaction', () => {
 				const transaction: Transaction = {
 					from: tempAcc.address,
 					to: '0x0000000000000000000000000000000000000000',
-					value: BigInt('99999999999999999999999999999999999999999999999999999999999999999'),
+					value: BigInt(
+						'99999999999999999999999999999999999999999999999999999999999999999',
+					),
 				};
 
 				const expectedThrownError = {
@@ -587,7 +598,9 @@ describe('Web3Eth.sendTransaction', () => {
 					code: 402,
 					reason:
 						getSystemTestBackend() === BACKEND.GETH
-							? expect.stringContaining('err: insufficient funds for gas * price + value: address')
+							? expect.stringContaining(
+									'err: insufficient funds for gas * price + value: address',
+							  )
 							: 'VM Exception while processing transaction: insufficient balance',
 				};
 

packages/web3/test/integration/external-providers/hardhat.test.ts

@@ -18,11 +18,16 @@ along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 // eslint-disable-next-line import/no-extraneous-dependencies
 import hardhat from 'hardhat';
 
-import { performBasicRpcCalls } from './helper';
+import { performBasicRpcCalls, failErrorCalls} from './helper';
 
 describe('compatibility with `hardhat` provider', () => {
 	it('should initialize Web3, get accounts & block number and send a transaction', async () => {
 		// use the hardhat provider for web3.js
-		await performBasicRpcCalls(hardhat.network.provider);
+		await expect(performBasicRpcCalls(hardhat.network.provider)).resolves.not.toThrow();
 	});
+	it('should throw on error calls', async () => {
+		const result = failErrorCalls(hardhat.network.provider);
+		await expect(result).rejects.toThrow();
+
+	})
 });

packages/web3/test/integration/external-providers/helper.ts

@@ -16,7 +16,9 @@ along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { SupportedProviders } from 'web3-types';
+import { Contract } from 'web3-eth-contract';
 import Web3 from '../../../src/index';
+import { BasicAbi, BasicBytecode } from '../../shared_fixtures/build/Basic';
 
 /**
  * Performs basic RPC calls (like `eth_accounts`, `eth_blockNumber` and `eth_sendTransaction`)
@@ -36,7 +38,7 @@ export async function performBasicRpcCalls(provider: SupportedProviders) {
 		to: accounts[1],
 		from: accounts[0],
 		value: '1',
-		gas: 21000
+		gas: 21000,
 	});
 	expect(tx.status).toBe(BigInt(1));
 
@@ -46,3 +48,27 @@ export async function performBasicRpcCalls(provider: SupportedProviders) {
 	// After sending a transaction, the blocknumber is supposed to be greater than or equal the block number before sending the transaction
 	expect(blockNumber1).toBeGreaterThanOrEqual(blockNumber0);
 }
+
+export async function failErrorCalls(provider: SupportedProviders) {
+	let contract: Contract<typeof BasicAbi>;
+	const web3 = new Web3(provider);
+
+	contract = new web3.eth.Contract(BasicAbi, undefined, {
+		provider,
+	});
+
+	let deployOptions: Record<string, unknown>;
+
+	// eslint-disable-next-line prefer-const
+	deployOptions = {
+		data: BasicBytecode,
+		arguments: [10, 'string init value'],
+	};
+	const accounts = await web3.eth.getAccounts();
+
+	const sendOptions = { from: accounts[0], gas: '1000000' };
+
+	contract = await contract.deploy(deployOptions).send(sendOptions);
+
+	await contract.methods.reverts().send({ from: accounts[0] });
+}