catching promise - legacy provider error

packages/web3-core/src/web3_request_manager.ts

@@ -241,14 +241,14 @@
  payload,
  error as JsonRpcResponse<ResponseType, unknown>,
  { legacy: true, error: true },
- ),
+ )
  );
  }
 
  // 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,
@@ -257,8 +257,9 @@
  legacy: true,
  error: true,
  },
- ),
- );
+ ))
+ }
+
  const resolveWithResponse = (response: JsonRpcResponse<ResponseType>) =>
  resolve(
  this._processJsonRpcResponse(payload, response, {
@@ -288,7 +289,20 @@
  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,21 @@ describe('Web3RequestManager', () => {
  expect(myProvider.request).toHaveBeenCalledTimes(1);
  expect(await pr).toBe('test');
  });
+
+ it('promise of legacy provider should be error', async () => {
+ const manager = new Web3RequestManager(undefined, undefined);
+ const pr = new Promise(resolve => {
+ resolve('test');
+ });
+ const myProvider = {
+ request: jest.fn().mockImplementation(async () => pr),
+ } as any;
+ manager.setProvider(myProvider);
+ await manager.send(request);
+ 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 +1149,22 @@ 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 pass request to provider and reject if provider returns error', async () => {
  const manager = new Web3RequestManager();
  const myProvider = {

packages/web3-eth/src/rpc_method_wrappers.ts

@@ -581,7 +581,7 @@ export function sendTransaction<
  transaction,
  transactionFormatted,
  });
-
+ 
  await sendTxHelper.checkRevertBeforeSending(
  transactionFormatted as TransactionCall,
  );

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

@@ -720,4 +720,4 @@ describe('Web3Eth.sendTransaction', () => {
  ).rejects.toMatchObject(expectedThrownError);
  });
  });
-});
+});

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`)
@@ -44,5 +46,31 @@ export async function performBasicRpcCalls(provider: SupportedProviders) {
  expect(typeof blockNumber1).toBe('bigint');
 
  // 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);
+ 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] })
+
+}