@toruslabs/ethereum-controllers 8.17.1 → 9.1.0

package/dist/lib.esm/Account/AccountTrackerController.js

@@ -2,8 +2,8 @@ import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { BaseController } from '@toruslabs/base-controllers';
 import { Mutex } from 'async-mutex';
-import { BrowserProvider, toQuantity, Contract } from 'ethers';
 import log from 'loglevel';
+import { createPublicClient, custom, toHex } from 'viem';
 import { singleBalanceCheckerAbi } from '../utils/abis.js';
 import { SINGLE_CALL_BALANCES_ADDRESSES } from '../utils/contractAddresses.js';
 
@@ -32,7 +32,7 @@ class AccountTrackerController extends BaseController {
     _defineProperty(this, "provider", void 0);
     _defineProperty(this, "blockTracker", void 0);
     _defineProperty(this, "mutex", new Mutex());
-    _defineProperty(this, "ethersProvider", void 0);
+    _defineProperty(this, "publicClient", void 0);
     _defineProperty(this, "getIdentities", void 0);
     _defineProperty(this, "getCurrentChainId", void 0);
     this.defaultState = {
@@ -41,7 +41,9 @@ class AccountTrackerController extends BaseController {
     this.initialize();
     this.provider = provider;
     this.blockTracker = blockTracker;
-    this.ethersProvider = new BrowserProvider(this.provider, "any");
+    this.publicClient = createPublicClient({
+      transport: custom(this.provider)
+    });
     this.getIdentities = getIdentities;
     this.getCurrentChainId = getCurrentChainId;
     onPreferencesStateChange(() => {
@@ -127,21 +129,27 @@ class AccountTrackerController extends BaseController {
     } = this.state;
     if (!accounts[address]) return;
     accounts[address] = {
-      balance: toQuantity(balance)
+      balance: toHex(BigInt(balance))
     };
     this.update({
       accounts
     });
   }
   async _updateAccountsViaBalanceChecker(addresses, deployedContractAddress) {
-    const ethContract = new Contract(deployedContractAddress, singleBalanceCheckerAbi, this.ethersProvider);
     try {
-      const result = await ethContract.balances(addresses, [ZERO_ADDRESS]);
+      const result = await this.publicClient.readContract({
+        address: deployedContractAddress,
+        abi: singleBalanceCheckerAbi,
+        functionName: "balances",
+        args: [addresses, [ZERO_ADDRESS]],
+        authorizationList: undefined // required when public client has no chain specified
+      });
       const {
         accounts
       } = this.state;
       addresses.forEach((address, index) => {
-        const balance = toQuantity(result[index]);
+        var _result$index;
+        const balance = toHex((_result$index = result[index]) !== null && _result$index !== void 0 ? _result$index : 0n);
         if (!accounts[address]) return;
         accounts[address] = {
           balance

package/dist/lib.esm/AccountAbstraction/AccountAbstractionController.js

@@ -1,32 +1,28 @@
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { addHexPrefix } from '@ethereumjs/util';
 import { BaseController, TransactionStatus } from '@toruslabs/base-controllers';
-import { JRPCEngine, providerFromEngine } from '@web3auth/auth';
-import { isHexString } from 'ethers';
+import { JRPCEngineV2, providerFromEngineV2 } from '@web3auth/auth';
 import log from 'loglevel';
-import { defineChain, createPublicClient, http, createWalletClient, custom, parseEther, toHex } from 'viem';
+import { defineChain, createPublicClient, http, createWalletClient, custom, toHex, parseEther, isHex } from 'viem';
 import { createPaymasterClient, createBundlerClient } from 'viem/account-abstraction';
 
-const eoaInterceptorMiddleware = eoaAddress => (req, res, next, end) => {
-  req.isAAProviderRequest = true;
-  if (req.method === "eth_accounts" || req.method === "eth_requestAccounts") {
-    res.result = [eoaAddress];
-    end();
-    return;
+const eoaInterceptorMiddleware = eoaAddress => async ({
+  request,
+  next,
+  context
+}) => {
+  context.set("isAAProviderRequest", true);
+  if (request.method === "eth_accounts" || request.method === "eth_requestAccounts") {
+    return [eoaAddress];
   }
-  next();
+  return next();
 };
 function eoaProviderAsMiddleware(provider) {
-  return async (req, res, _next, end) => {
-    // send request to provider
-    try {
-      const providerRes = await provider.request(req);
-      res.result = providerRes;
-      return end();
-    } catch (error) {
-      return end(error);
-    }
+  return async ({
+    request
+  }) => {
+    const result = await provider.request(request);
+    return result;
   };
 }
 class AccountAbstractionController extends BaseController {
@@ -93,10 +89,10 @@ class AccountAbstractionController extends BaseController {
     });
 
     // viem wallet client using json-rpc account from eoaProvider
-    const aaEngine = new JRPCEngine();
-    aaEngine.push(eoaInterceptorMiddleware(eoaAddress));
-    aaEngine.push(eoaProviderAsMiddleware(eoaProvider));
-    const provider = providerFromEngine(aaEngine);
+    const aaEngine = JRPCEngineV2.create({
+      middleware: [eoaInterceptorMiddleware(eoaAddress), eoaProviderAsMiddleware(eoaProvider)]
+    });
+    const provider = providerFromEngineV2(aaEngine);
     // need to hoist the account address https://viem.sh/docs/clients/wallet#optional-hoist-the-account
     const eoaWalletClient = createWalletClient({
       account: eoaAddress,
@@ -124,7 +120,7 @@ class AccountAbstractionController extends BaseController {
     });
   }
   async sendTransaction(id, tx, address) {
-    var _txParams$chainId, _txReceipt$receipt, _txReceipt$nonce, _txReceipt$receipt2, _txReceipt$receipt3, _txReceipt$receipt4;
+    var _txParams$chainId, _txReceipt$receipt, _txReceipt$nonce, _txReceipt$receipt$ga, _txReceipt$receipt2, _txReceipt$receipt$ef, _txReceipt$receipt3, _txReceipt$receipt4;
     if (address.toLowerCase() !== this.smartAccount.address.toLowerCase()) {
       throw new Error("Invalid address");
     }
@@ -164,8 +160,8 @@ class AccountAbstractionController extends BaseController {
       receipt: {
         transactionHash: (_txReceipt$receipt = txReceipt.receipt) === null || _txReceipt$receipt === void 0 ? void 0 : _txReceipt$receipt.transactionHash,
         nonce: (_txReceipt$nonce = txReceipt.nonce) === null || _txReceipt$nonce === void 0 ? void 0 : _txReceipt$nonce.toString(),
-        gasUsed: addHexPrefix((_txReceipt$receipt2 = txReceipt.receipt) === null || _txReceipt$receipt2 === void 0 || (_txReceipt$receipt2 = _txReceipt$receipt2.gasUsed) === null || _txReceipt$receipt2 === void 0 ? void 0 : _txReceipt$receipt2.toString(16)),
-        effectiveGasPrice: addHexPrefix((_txReceipt$receipt3 = txReceipt.receipt) === null || _txReceipt$receipt3 === void 0 || (_txReceipt$receipt3 = _txReceipt$receipt3.effectiveGasPrice) === null || _txReceipt$receipt3 === void 0 ? void 0 : _txReceipt$receipt3.toString(16)),
+        gasUsed: toHex((_txReceipt$receipt$ga = (_txReceipt$receipt2 = txReceipt.receipt) === null || _txReceipt$receipt2 === void 0 ? void 0 : _txReceipt$receipt2.gasUsed) !== null && _txReceipt$receipt$ga !== void 0 ? _txReceipt$receipt$ga : 0n),
+        effectiveGasPrice: toHex((_txReceipt$receipt$ef = (_txReceipt$receipt3 = txReceipt.receipt) === null || _txReceipt$receipt3 === void 0 ? void 0 : _txReceipt$receipt3.effectiveGasPrice) !== null && _txReceipt$receipt$ef !== void 0 ? _txReceipt$receipt$ef : 0n),
         type: (_txReceipt$receipt4 = txReceipt.receipt) === null || _txReceipt$receipt4 === void 0 ? void 0 : _txReceipt$receipt4.type,
         reason: txReceipt.reason
       },
@@ -278,7 +274,7 @@ class AccountAbstractionController extends BaseController {
       throw new Error("Invalid address");
     }
     return (_this$smartAccount = this.smartAccount) === null || _this$smartAccount === void 0 ? void 0 : _this$smartAccount.signMessage({
-      message: isHexString(message) ? {
+      message: isHex(message) ? {
         raw: message
       } : message
     });

package/dist/lib.esm/Eip5792/walletGetCallsStatus.js

@@ -1,5 +1,5 @@
-import { addHexPrefix } from '@ethereumjs/util';
 import { TransactionStatus } from '@toruslabs/base-controllers';
+import { add0x } from '@toruslabs/metadata-helpers';
 import { rpcErrors, JsonRpcError } from '@web3auth/auth';
 import { GetCallsStatusCode, EIP_5792_METHODS, EIP5792ErrorCode } from '../utils/eip5792Types.js';
 
@@ -67,7 +67,7 @@ function walletGetCallsStatus(request, getTransactionByBatchId) {
   return {
     status: mapTransactionStatusToEip5792Status(batchTx.status),
     id: batchId,
-    chainId: addHexPrefix(batchTx.chainId),
+    chainId: add0x(batchTx.chainId),
     atomic: true,
     receipts: batchTx.txReceipt ? [batchTx.txReceipt] : []
   };

package/dist/lib.esm/Eip5792/walletSendCalls.js

@@ -1,7 +1,6 @@
-import { isValidAddress } from '@ethereumjs/util';
 import { rpcErrors } from '@web3auth/auth';
-import { isHexString } from 'ethers';
 import { v4, parse } from 'uuid';
+import { isHex, isAddress } from 'viem';
 import { getIsEip7702UpgradeSupported } from '../Eip7702/eip7702Utils.js';
 import { EIP_5792_METHODS } from '../utils/eip5792Types.js';
 
@@ -23,20 +22,20 @@ function generateBatchId() {
  */
 function validateCall(call, index) {
   // Validate 'to' address
-  if (!call.to || !isHexString(call.to) || !isValidAddress(call.to)) {
+  if (!call.to || !isHex(call.to) || !isAddress(call.to)) {
     throw rpcErrors.invalidParams(`Invalid 'to' address in call at index ${index}`);
   }
 
   // Validate 'value' if present
   if (call.value !== undefined) {
-    if (!isHexString(call.value)) {
+    if (!isHex(call.value)) {
       throw rpcErrors.invalidParams(`Invalid 'value' in call at index ${index}: must be a valid non-negative hex string`);
     }
   }
 
   // Validate 'data' if present
   if (call.data !== undefined) {
-    if (!isHexString(call.data)) {
+    if (!isHex(call.data)) {
       throw rpcErrors.invalidParams(`Invalid 'data' in call at index ${index}: must be a valid hex string`);
     }
   }
@@ -58,7 +57,7 @@ function validateSendCallsParams(sendCallsParams) {
   }
 
   // Validate chainId format
-  if (!sendCallsParams.chainId || !isHexString(sendCallsParams.chainId)) {
+  if (!sendCallsParams.chainId || !isHex(sendCallsParams.chainId)) {
     throw rpcErrors.invalidParams("Invalid chainId: must be a valid hex string");
   }
 
@@ -66,7 +65,7 @@ function validateSendCallsParams(sendCallsParams) {
   if (!sendCallsParams.from) {
     throw rpcErrors.invalidParams("Missing 'from' address");
   }
-  if (!isHexString(sendCallsParams.from) || !isValidAddress(sendCallsParams.from)) {
+  if (!isHex(sendCallsParams.from) || !isAddress(sendCallsParams.from)) {
     throw rpcErrors.invalidParams("Invalid 'from' address: must be a valid hex address");
   }
 

package/dist/lib.esm/Eip7702/eip7702Utils.js

@@ -1,4 +1,4 @@
-import { addHexPrefix } from '@ethereumjs/util';
+import { add0x } from '@toruslabs/metadata-helpers';
 import { zeroAddress, encodeAbiParameters, parseAbiParameters, encodeFunctionData } from 'viem';
 import { erc7821Abi } from '../utils/abis.js';
 import { SUPPORTED_NETWORKS } from '../utils/constants.js';
@@ -12,10 +12,10 @@ const MetaMask_EIP7702_Stateless_Delegator = "0x63c0c19a282a1B52b07dD5a65b58948A
 async function getDelegationAddress(walletAddress, chainId, getEthCode) {
   // query eth_getCode
   const code = await getEthCode(walletAddress, chainId);
-  const normalizedCode = code ? addHexPrefix(code).toLowerCase() : "0x0";
+  const normalizedCode = code ? add0x(code).toLowerCase() : "0x0";
   const hasDelegation = normalizedCode.length === 48 && normalizedCode.startsWith(EIP_7702_PREFIX);
   if (hasDelegation) {
-    const delegationAddress = addHexPrefix(normalizedCode.slice(EIP_7702_PREFIX.length));
+    const delegationAddress = add0x(normalizedCode.slice(EIP_7702_PREFIX.length));
     return delegationAddress;
   }
   return null;

package/dist/lib.esm/Gas/GasFeeController.js

@@ -1,6 +1,6 @@
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import { isHexString, addHexPrefix } from '@ethereumjs/util';
 import { BaseController, PollingManager, cloneDeep } from '@toruslabs/base-controllers';
+import { isHexString } from '@toruslabs/metadata-helpers';
 import log from 'loglevel';
 import { GAS_ESTIMATE_TYPES } from '../utils/constants.js';
 import { fetchGasEstimates, fetchEthGasPriceEstimate, fetchLegacyGasPriceEstimates, fetchGasEstimatesViaEthFeeHistory, calculateTimeEstimate } from './gasUtil.js';
@@ -119,7 +119,7 @@ class GasFeeController extends BaseController {
     const chainId = this.getNetworkIdentifier();
     if (chainId === "loading") return;
     let chainIdInt;
-    if (typeof chainId === "string" && isHexString(addHexPrefix(chainId))) {
+    if (isHexString(chainId)) {
       chainIdInt = Number.parseInt(chainId, 16);
     }
     try {

package/dist/lib.esm/Keyring/KeyringController.js

@@ -1,8 +1,9 @@
-import { encode } from '@ethereumjs/rlp';
-import { addHexPrefix, bytesToHex, privateToPublic, toChecksumAddress, privateToAddress, stripHexPrefix, bigIntToBytes, isHexString } from '@ethereumjs/util';
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import { BaseKeyringController, ecsignature, concatSig } from '@toruslabs/base-controllers';
-import { SigningKey, concat, keccak256, hashMessage, TypedDataEncoder } from 'ethers';
-import { toHex } from 'viem';
+import { add0x, remove0x, hexToBytes } from '@toruslabs/metadata-helpers';
+import { serializeTransaction, keccak256, parseSignature, toHex, isHex } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { prepareViemTx } from '../utils/viem.js';
 
 class KeyringController extends BaseKeyringController {
   constructor({
@@ -20,49 +21,55 @@ class KeyringController extends BaseKeyringController {
   }
   async signTransaction(tx, address) {
     const wallet = this._getWalletForAccount(address);
-    const privKey = new SigningKey(addHexPrefix(wallet.privateKey));
+    const account = privateKeyToAccount(add0x(wallet.privateKey));
     const localTx = tx;
-    localTx.signature = privKey.sign(localTx.unsignedHash);
-    return localTx;
+    const txToSign = prepareViemTx(localTx);
+    // NOTE: don't use account.signTransaction directly because it only return signed serialized transaction
+    // we don't want to compute unsigned hash and signature again
+    const serializedUnsigned = serializeTransaction(txToSign);
+    const unsignedHash = keccak256(serializedUnsigned);
+    const rawSig = await account.sign({
+      hash: unsignedHash
+    });
+    const signature = parseSignature(rawSig);
+    const serialized = serializeTransaction(txToSign, signature);
+    return _objectSpread(_objectSpread({}, txToSign), {}, {
+      unsignedHash,
+      serialized,
+      signature
+    });
   }
   async signEip7702Authorization(authorization, address) {
     const wallet = this._getWalletForAccount(address);
-    const privKey = new SigningKey(addHexPrefix(wallet.privateKey));
+    const account = privateKeyToAccount(add0x(wallet.privateKey));
 
     // Convert hex strings to proper types for RLP encoding
     // EIP-7702 authorization tuple: [chain_id_decimal, address, nonce_decimal]
     const chainIdDecimal = parseInt(authorization.chainId, 16);
     const nonceDecimal = parseInt(authorization.nonce, 16);
-
-    // RLP encode the eip7702 authorization
-    const encodedAuthorization = encode([chainIdDecimal, authorization.address, nonceDecimal]);
-    // Prefixed with EIP7702 Domain Separator (0x05)
-    const prefixedAuthorization = concat(["0x05", encodedAuthorization]);
-    const authorizationHash = keccak256(prefixedAuthorization);
-    const {
-      r,
-      s,
-      v
-    } = privKey.sign(authorizationHash);
-    const signedAuthorization = {
+    const signedAuthorization = await account.signAuthorization({
+      contractAddress: authorization.address,
+      chainId: chainIdDecimal,
+      nonce: nonceDecimal
+    });
+    return {
       address: authorization.address,
       chainId: authorization.chainId,
       nonce: authorization.nonce,
-      r: addHexPrefix(r),
-      s: addHexPrefix(s),
-      yParity: toHex(v - 27 === 0 ? 0 : 1)
+      r: signedAuthorization.r,
+      s: signedAuthorization.s,
+      yParity: toHex(signedAuthorization.yParity)
     };
-    return signedAuthorization;
   }
   getAccounts() {
     return this.state.wallets.map(w => w.publicKey);
   }
-  importAccount(accountPrivateKey) {
+  async importAccount(accountPrivateKey) {
     try {
-      const hexPrivateKey = accountPrivateKey.padStart(64, "0");
-      const bufferPrivKey = Buffer.from(hexPrivateKey, "hex");
-      const publicKey = bytesToHex(privateToPublic(bufferPrivKey));
-      const address = toChecksumAddress(bytesToHex(privateToAddress(bufferPrivKey)));
+      const hexPrivateKey = remove0x(accountPrivateKey).padStart(64, "0");
+      const account = privateKeyToAccount(add0x(hexPrivateKey));
+      const publicKey = account.publicKey;
+      const address = account.address;
       const existingWallet = this.state.wallets.find(w => w.address === address);
       if (existingWallet) return existingWallet.address;
       this.update({
@@ -90,37 +97,56 @@ class KeyringController extends BaseKeyringController {
       });
     }
   }
-  getBufferPrivateKey(privateKey) {
-    const stripped = stripHexPrefix(privateKey);
-    return Buffer.from(stripped, "hex");
+  getPrivateKeyBytes(privateKey) {
+    return hexToBytes(privateKey);
   }
 
   // For eth_sign, we need to sign arbitrary data:
   async signMessage(data, address) {
+    if (typeof data !== "string") {
+      throw new Error("Torus Keyring - signMessage data must be type 'string'");
+    }
     const wallet = this._getWalletForAccount(address);
-    const privKey = this.getBufferPrivateKey(wallet.privateKey);
-    const messageSig = ecsignature(Buffer.from(stripHexPrefix(data), "hex"), privKey);
-    const sig = concatSig(Buffer.from(bigIntToBytes(messageSig.v)), Buffer.from(messageSig.r), Buffer.from(messageSig.s));
+    const privKey = this.getPrivateKeyBytes(wallet.privateKey);
+    const payload = hexToBytes(data);
+    const messageSig = ecsignature(payload, privKey);
+    const sig = concatSig(messageSig.v, messageSig.r, messageSig.s);
     return sig;
   }
   async signPersonalMessage(data, address) {
     const wallet = this._getWalletForAccount(address);
-    const privKey = new SigningKey(addHexPrefix(wallet.privateKey));
+    const account = privateKeyToAccount(add0x(wallet.privateKey));
     // we need to check if the data is hex or not
     // For historical reasons, you must submit the message to sign in hex-encoded UTF-8.
     // https://docs.metamask.io/wallet/how-to/sign-data/#use-personal_sign
-    const message = isHexString(data) ? Buffer.from(stripHexPrefix(data), "hex") : Buffer.from(data);
-    const signature = privKey.sign(hashMessage(message)).serialized;
-    return signature;
+    const message = isHex(data) ? {
+      raw: data
+    } : data;
+    return account.signMessage({
+      message
+    });
   }
 
   // personal_signTypedData, signs data along with the schema
   async signTypedData(typedData, address) {
     const wallet = this._getWalletForAccount(address);
-    const privKey = new SigningKey(addHexPrefix(wallet.privateKey));
+    const account = privateKeyToAccount(add0x(wallet.privateKey));
     delete typedData.types.EIP712Domain;
-    const signature = privKey.sign(TypedDataEncoder.hash(typedData.domain, typedData.types, typedData.message)).serialized;
-    return signature;
+    const primaryType = typedData.primaryType;
+    if (!primaryType) {
+      throw new Error("Torus Keyring - primaryType is required");
+    }
+    const rawSig = await account.signTypedData({
+      domain: _objectSpread(_objectSpread({}, typedData.domain), {}, {
+        chainId: typeof typedData.domain.chainId === "string" ? parseInt(typedData.domain.chainId, 16) : typedData.domain.chainId,
+        salt: typedData.domain.salt,
+        verifyingContract: typedData.domain.verifyingContract
+      }),
+      types: typedData.types,
+      primaryType,
+      message: typedData.message
+    });
+    return rawSig;
   }
   _getWalletForAccount(account) {
     const address = account.toLowerCase();

package/dist/lib.esm/Message/utils.js

@@ -1,10 +1,9 @@
-import { stripHexPrefix, addHexPrefix, bytesToHex, isValidAddress } from '@ethereumjs/util';
 import { CHAIN_NAMESPACES } from '@toruslabs/base-controllers';
-import { isHexString, JsonRpcProvider, toQuantity } from 'ethers';
+import { isHexString, add0x, bytesToHex, utf8ToBytes } from '@toruslabs/metadata-helpers';
+import { isHex, createPublicClient, http, toHex, isAddress } from 'viem';
 
-const hexRe = /^[0-9A-Fa-f]+$/gu;
 function validateAddress(address, propertyName) {
-  if (!address || typeof address !== "string" || !isValidAddress(address)) {
+  if (!address || typeof address !== "string" || !isAddress(address)) {
     throw new Error(`Invalid "${propertyName}" address: ${address} must be a valid string.`);
   }
 }
@@ -20,14 +19,13 @@ function validateSignMessageData(messageData) {
 }
 function normalizeMessageData(data) {
   try {
-    const stripped = stripHexPrefix(data);
-    if (stripped.match(hexRe)) {
-      return addHexPrefix(stripped);
+    if (isHexString(data)) {
+      return add0x(data);
     }
   } catch {
     // do nothing
   }
-  return bytesToHex(Buffer.from(data, "utf8"));
+  return add0x(bytesToHex(utf8ToBytes(data)));
 }
 async function validateTypedSignMessageDataV4(messageData, currentChainId) {
   validateAddress(messageData.from, "from");
@@ -72,7 +70,7 @@ async function validateAddChainData(data) {
   if (!chainId) {
     throw new Error("Invalid add chain params: please pass chainId in params");
   }
-  if (!isHexString(chainId)) {
+  if (!isHex(chainId)) {
     throw new Error("Invalid add chain params: please pass a valid hex chainId in params, for: ex: 0x1");
   }
   if (!rpcUrls || rpcUrls.length === 0) throw new Error("params.rpcUrls not provided");
@@ -85,12 +83,12 @@ async function validateAddChainData(data) {
   if (!name) throw new Error("params.nativeCurrency.name not provided");
   if (!symbol) throw new Error("params.nativeCurrency.symbol not provided");
   if (decimals === undefined) throw new Error("params.nativeCurrency.decimals not provided");
-  const _web3 = new JsonRpcProvider(rpcUrls[0], "any");
-  const {
-    chainId: networkChainID
-  } = await _web3.getNetwork();
-  if (Number.parseInt(networkChainID.toString()) !== Number.parseInt(chainId, 16)) {
-    throw new Error(`Provided rpc url's chainId version is not matching with provided chainId, expected: ${toQuantity(networkChainID)}, received: ${chainId}`);
+  const client = createPublicClient({
+    transport: http(rpcUrls[0])
+  });
+  const networkChainID = await client.getChainId();
+  if (networkChainID !== Number.parseInt(chainId, 16)) {
+    throw new Error(`Provided rpc url's chainId version is not matching with provided chainId, expected: ${toHex(networkChainID)}, received: ${chainId}`);
   }
 }
 function validateSwitchChainData(data) {
@@ -100,7 +98,7 @@ function validateSwitchChainData(data) {
   if (!fullChainId) {
     throw new Error("Invalid switch chain params: please pass chainId in params");
   }
-  if (!isHexString(fullChainId)) {
+  if (!isHex(fullChainId)) {
     const [namespace, chainId] = fullChainId.split(":");
     if (namespace !== CHAIN_NAMESPACES.SOLANA && namespace !== CHAIN_NAMESPACES.EIP155) {
       throw new Error("Invalid switch chain params: invalid namespace");

package/dist/lib.esm/Network/NetworkController.js

@@ -2,7 +2,7 @@ import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProper
 import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { BaseController, createAnalyticsMiddleware, createSwappableProxy, createEventEmitterProxy } from '@toruslabs/base-controllers';
-import { JRPCEngine, providerFromEngine } from '@web3auth/auth';
+import { JRPCEngineV2, providerFromEngineV2 } from '@web3auth/auth';
 import { Mutex } from 'async-mutex';
 import log from 'loglevel';
 import { SUPPORTED_NETWORKS, MAINNET_CHAIN_ID } from '../utils/constants.js';
@@ -151,15 +151,13 @@ class NetworkController extends BaseController {
     networkMiddleware,
     blockTracker
   }) {
-    const ethereumMiddleware = createEthereumMiddleware(this.baseProviderHandlers, this.getProviderConfig(), this.analytics);
-    const engine = new JRPCEngine();
-    engine.push(createAnalyticsMiddleware({
-      providerConfig: this.getProviderConfig(),
-      analytics: this.analytics
-    }));
-    engine.push(ethereumMiddleware);
-    engine.push(networkMiddleware);
-    const provider = providerFromEngine(engine);
+    const engine = JRPCEngineV2.create({
+      middleware: [createAnalyticsMiddleware({
+        providerConfig: this.getProviderConfig(),
+        analytics: this.analytics
+      }), createEthereumMiddleware(this.baseProviderHandlers, this.getProviderConfig(), this.analytics), networkMiddleware]
+    });
+    const provider = providerFromEngineV2(engine);
     this.setProvider({
       provider,
       blockTracker