@avalabs/evm-module 0.0.21 → 0.0.22

package/manifest.json

@@ -32,7 +32,16 @@
   "permissions": {
     "rpc": {
       "dapps": true,
-      "methods": ["eth_sendTransaction", "eth_*", "personal_sign"]
+      "methods": [
+        "personal_sign",
+        "eth_sendTransaction",
+        "eth_*",
+        "web3_clientVersion",
+        "web3_sha3",
+        "net_version",
+        "net_peerCount",
+        "net_listening"
+      ]
     }
   },
   "manifestVersion": "0.0"

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@avalabs/evm-module",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
   "typings": "dist/index.d.ts",
   "type": "module",
   "dependencies": {
-    "@avalabs/vm-module-types": "0.0.21",
+    "@avalabs/vm-module-types": "0.0.22",
     "@avalabs/coingecko-sdk": "v2.8.0-alpha.193",
     "@avalabs/utils-sdk": "2.8.0-alpha.193",
     "@avalabs/etherscan-sdk": "v2.8.0-alpha.193",

package/src/handlers/forward-to-rpc-node/forward-to-rpc-node.test.ts

@@ -0,0 +1,90 @@
+import { forwardToRpcNode } from './forward-to-rpc-node';
+import { getProvider } from '../../utils/get-provider';
+import { rpcErrors } from '@metamask/rpc-errors';
+import { NetworkVMType, RpcMethod } from '@avalabs/vm-module-types';
+
+jest.mock('../../utils/get-provider');
+jest.mock('@metamask/rpc-errors', () => ({
+  rpcErrors: {
+    internal: jest.fn().mockImplementation((message) => ({ error: `mocked error: ${message}` })),
+  },
+}));
+
+const mockProvider = {
+  send: jest.fn(),
+};
+
+const network = {
+  chainId: 1,
+  chainName: 'mainnet',
+  rpcUrl: 'https://example.com',
+  networkToken: {
+    name: 'ethereum',
+    symbol: 'ETH',
+    decimals: 18,
+  },
+  vmName: NetworkVMType.EVM,
+};
+
+describe('forwardToRpcNode', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (getProvider as jest.Mock).mockReturnValue(mockProvider);
+  });
+
+  it('should forward the request and return the result on success', async () => {
+    const request = {
+      method: 'eth_chainId' as RpcMethod,
+      params: [1, 2],
+      requestId: 'requestId',
+      sessionId: 'sessionId',
+      chainId: 'eip155:1',
+      dappInfo: {
+        name: 'some dapp',
+        url: 'some url',
+        icon: 'some icon',
+      },
+    };
+
+    const expectedResult = '0x1';
+
+    mockProvider.send.mockResolvedValue(expectedResult);
+
+    const result = await forwardToRpcNode(request, network);
+
+    expect(getProvider).toHaveBeenCalledWith({
+      chainId: network.chainId,
+      chainName: network.chainName,
+      rpcUrl: network.rpcUrl,
+      multiContractAddress: undefined,
+      pollingInterval: 1000,
+    });
+    expect(mockProvider.send).toHaveBeenCalledWith(request.method, request.params);
+    expect(result).toEqual({ result: expectedResult });
+  });
+
+  it('should handle errors and return a formatted error response', async () => {
+    const request = {
+      method: 'eth_accounts' as RpcMethod,
+      params: [],
+      requestId: 'requestId',
+      sessionId: 'sessionId',
+      chainId: 'eip155:1',
+      dappInfo: {
+        name: 'some dapp',
+        url: 'some url',
+        icon: 'some icon',
+      },
+    };
+
+    const error = new Error('Test error');
+
+    mockProvider.send.mockRejectedValue(error);
+
+    const result = await forwardToRpcNode(request, network);
+
+    expect(rpcErrors.internal).toHaveBeenCalledWith(error.message);
+    expect(result).toHaveProperty('error');
+    expect(result.error).toEqual({ error: `mocked error: ${error.message}` });
+  });
+});

package/src/handlers/forward-to-rpc-node/forward-to-rpc-node.ts

@@ -0,0 +1,23 @@
+import type { Network, RpcRequest } from '@avalabs/vm-module-types';
+import { rpcErrors } from '@metamask/rpc-errors';
+import { getProvider } from '../../utils/get-provider';
+
+export const forwardToRpcNode = async (request: RpcRequest, network: Network) => {
+  try {
+    const provider = getProvider({
+      chainId: network.chainId,
+      chainName: network.chainName,
+      rpcUrl: network.rpcUrl,
+      multiContractAddress: network.utilityAddresses?.multicall,
+      pollingInterval: 1000,
+    });
+
+    const response = await provider.send(request.method, request.params as unknown[]);
+    return { result: response };
+  } catch (error) {
+    // extracting the error message based on the error object structure from ethers lib
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const message = (error as any).info?.error?.message || (error as any).error?.message || (error as Error).message;
+    return { error: rpcErrors.internal(message) };
+  }
+};

package/src/module.ts

@@ -21,6 +21,7 @@ import { getBalances } from './handlers/get-balances/get-balances';
 import { getEnv } from './env';
 import { EvmGlacierService } from './services/glacier-service/glacier-service';
 import { ethSign } from './handlers/eth-sign/eth-sign';
+import { forwardToRpcNode } from './handlers/forward-to-rpc-node/forward-to-rpc-node';
 
 export class EvmModule implements Module {
   #glacierService: EvmGlacierService;
@@ -120,7 +121,18 @@ export class EvmModule implements Module {
           proxyApiUrl: this.#proxyApiUrl,
         });
       default:
+        if (shouldForwardToRpcNode(request.method)) {
+          return forwardToRpcNode(request, network);
+        }
+
         return { error: rpcErrors.methodNotSupported(`Method ${request.method} not supported`) };
     }
   }
 }
+
+const shouldForwardToRpcNode = (method: RpcMethod) => {
+  return (
+    method.startsWith('eth_') ||
+    ['web3_clientVersion', 'web3_sha3', 'net_version', 'net_peerCount', 'net_listening'].includes(method)
+  );
+};