chore: Better provider wrapping

packages/utils-evm-hardhat/package.json

@@ -51,6 +51,7 @@
     "@layerzerolabs/lz-evm-sdk-v1": "~1.5.72",
     "@layerzerolabs/test-utils": "~0.0.1",
     "@layerzerolabs/utils-evm": "~0.0.1",
+    "@nomiclabs/hardhat-ethers": "^2.2.3",
     "@types/jest": "^29.5.10",
     "fast-check": "^3.14.0",
     "hardhat": "^2.19.2",
@@ -70,6 +71,7 @@
     "@layerzerolabs/io-utils": "~0.0.1",
     "@layerzerolabs/lz-definitions": "~1.5.72",
     "@layerzerolabs/utils-evm": "~0.0.1",
+    "@nomiclabs/hardhat-ethers": "^2.2.3",
     "hardhat": "^2.19.2",
     "hardhat-deploy": "^0.11.43"
   }

packages/utils-evm-hardhat/src/provider.ts

@@ -1,4 +1,4 @@
-import type { Web3Provider } from '@ethersproject/providers'
+import type { JsonRpcProvider } from '@ethersproject/providers'
 import type { ProviderFactory } from '@layerzerolabs/utils-evm'
 import type { HardhatRuntimeEnvironment } from 'hardhat/types'
 import pMemoize from 'p-memoize'
@@ -7,7 +7,7 @@ import { createNetworkEnvironmentFactory, getDefaultRuntimeEnvironment, wrapEIP1
 export const createProviderFactory = (
     hre: HardhatRuntimeEnvironment = getDefaultRuntimeEnvironment(),
     networkEnvironmentFactory = createNetworkEnvironmentFactory(hre)
-): ProviderFactory<Web3Provider> => {
+): ProviderFactory<JsonRpcProvider> => {
     return pMemoize(async (eid) => {
         const env = await networkEnvironmentFactory(eid)
 

packages/utils-evm-hardhat/src/runtime.ts

@@ -1,12 +1,13 @@
-import type { HardhatRuntimeEnvironment, EIP1193Provider } from 'hardhat/types'
+import type { HardhatRuntimeEnvironment, EthereumProvider } from 'hardhat/types'
 
 import pMemoize from 'p-memoize'
-import { Web3Provider } from '@ethersproject/providers'
+import type { JsonRpcProvider } from '@ethersproject/providers'
 import { ConfigurationError } from './errors'
 import { HardhatContext } from 'hardhat/internal/context'
 import { Environment as HardhatRuntimeEnvironmentImplementation } from 'hardhat/internal/core/runtime-environment'
 import { EndpointId } from '@layerzerolabs/lz-definitions'
 import { EndpointBasedFactory, formatEid } from '@layerzerolabs/utils'
+import { EthersProviderWrapper } from '@nomiclabs/hardhat-ethers/internal/ethers-provider-wrapper'
 import assert from 'assert'
 
 /**
@@ -98,13 +99,13 @@ export const getNetworkRuntimeEnvironment: GetByNetwork<HardhatRuntimeEnvironmen
 })
 
 /**
- * Helper function that wraps an EIP1193Provider with Web3Provider
- * so that we can use it further with ethers
+ * Helper function that wraps an EthereumProvider with EthersProviderWrapper
+ * so that we can use it further with ethers as a regular JsonRpcProvider
  *
  * @param {EIP1193Provider} provider
- * @returns {Web3Provider}
+ * @returns {JsonRpcProvider}
  */
-export const wrapEIP1193Provider = (provider: EIP1193Provider): Web3Provider => new Web3Provider(provider)
+export const wrapEIP1193Provider = (provider: EthereumProvider): JsonRpcProvider => new EthersProviderWrapper(provider)
 
 /**
  * Creates a factory function for creating HardhatRuntimeEnvironment

packages/utils-evm-hardhat/test/provider.test.ts

@@ -2,10 +2,10 @@ import { getNetworkRuntimeEnvironment } from '@/runtime'
 import hre from 'hardhat'
 import { EndpointId } from '@layerzerolabs/lz-definitions'
 import { createProviderFactory } from '@/provider'
-import { Web3Provider } from '@ethersproject/providers'
+import { JsonRpcProvider } from '@ethersproject/providers'
 
 // Ethers calls the eth_chainId RPC method when initializing a provider so we mock the result
-jest.spyOn(Web3Provider.prototype, 'send').mockResolvedValue('1')
+jest.spyOn(JsonRpcProvider.prototype, 'detectNetwork').mockResolvedValue({ chainId: 1, name: 'mock' })
 
 describe('provider', () => {
     describe('createProviderFactory', () => {
@@ -17,8 +17,11 @@ describe('provider', () => {
             const env = await getNetworkRuntimeEnvironment('ethereum-mainnet')
             const provider = await createProviderFactory(hre)(EndpointId.ETHEREUM_MAINNET)
 
-            expect(provider).toBeInstanceOf(Web3Provider)
-            expect(provider.provider).toEqual(env.network.provider)
+            expect(provider).toBeInstanceOf(JsonRpcProvider)
+
+            // Here we're checking that the provider is configured with the correct network provider
+            jest.spyOn(env.network.provider, 'send').mockResolvedValue('sent')
+            expect(await provider.send('dummy', [])).toBe('sent')
 
             // Ethers has this ugly habit of importing files here and there,
             // firing RPC requests and all.

packages/utils-evm-hardhat/test/signer.test.ts

@@ -1,11 +1,11 @@
 import 'hardhat'
 import { EndpointId } from '@layerzerolabs/lz-definitions'
 import { createSignerFactory } from '@/signer/factory'
-import { JsonRpcSigner, Web3Provider } from '@ethersproject/providers'
+import { JsonRpcProvider, JsonRpcSigner } from '@ethersproject/providers'
 import { OmniSignerEVM } from '@layerzerolabs/utils-evm'
 
 // Ethers calls the eth_chainId RPC method when initializing a provider so we mock the result
-jest.spyOn(Web3Provider.prototype, 'send').mockResolvedValue('1')
+jest.spyOn(JsonRpcProvider.prototype, 'detectNetwork').mockResolvedValue({ chainId: 1, name: 'mock' })
 
 describe('signer', () => {
     describe('createSignerFactory', () => {
@@ -18,14 +18,14 @@ describe('signer', () => {
 
             expect(signer).toBeInstanceOf(OmniSignerEVM)
             expect(signer.signer).toBeInstanceOf(JsonRpcSigner)
-            expect(signer.signer.provider).toBeInstanceOf(Web3Provider)
+            expect(signer.signer.provider).toBeInstanceOf(JsonRpcProvider)
 
             // Ethers has this ugly habit of importing files here and there,
             // firing RPC requests and all.
             //
             // If we don't wait for the provider to be ready, jest will complain
             // about requests being made after test teardown
-            await (signer.signer.provider as Web3Provider)?.ready
+            await (signer.signer.provider as JsonRpcProvider)?.ready
         })
     })
 })