@toruslabs/ethereum-controllers 9.0.0 → 9.1.0

package/dist/lib.cjs/Network/createJsonRpcClient.js

@@ -8,24 +8,27 @@ var transaction = require('../utils/transaction.js');
 var cacheIdentifier = require('./cacheIdentifier.js');
 
 function createChainIdMiddleware(chainId) {
-  return (req, res, next, end) => {
-    if (req.method === "eth_chainId") {
-      res.result = chainId;
-      return end();
+  return async ({
+    request,
+    next
+  }) => {
+    if (request.method === "eth_chainId") {
+      return chainId;
     }
-    if (req.method === "net_version") {
+    if (request.method === "net_version") {
       // convert to decimal
-      res.result = Number.parseInt(chainId, 16).toString(10);
-      return end();
+      return Number.parseInt(chainId, 16).toString(10);
     }
     return next();
   };
 }
 function createProviderConfigMiddleware(providerConfig) {
-  return (req, res, next, end) => {
-    if (req.method === "eth_provider_config") {
-      res.result = providerConfig;
-      return end();
+  return async ({
+    request,
+    next
+  }) => {
+    if (request.method === "eth_provider_config") {
+      return providerConfig;
     }
     return next();
   };
@@ -41,7 +44,7 @@ function createJsonRpcClient(providerConfig, networkConfig, idleTimeTracker, ana
     analytics,
     transactionDecoder: transaction.transactionDecoder
   });
-  const blockProvider = auth.providerFromMiddleware(fetchMiddleware);
+  const blockProvider = auth.providerFromMiddlewareV2(fetchMiddleware);
   const blockTracker = new PollingBlockTracker.PollingBlockTracker({
     config: _objectSpread(_objectSpread({}, networkConfig), {}, {
       provider: blockProvider
@@ -49,15 +52,12 @@ function createJsonRpcClient(providerConfig, networkConfig, idleTimeTracker, ana
     state: {},
     idleTimeTracker
   });
-  const networkMiddleware = auth.mergeMiddleware([createChainIdMiddleware(chainId), createProviderConfigMiddleware(providerConfig),
-  // No need for the following middlewares for web because all browser sessions are quite short lived and each session is limited to scope of a window/tab
-  // createBlockRefRewriteMiddleware({ blockTracker }),
-  // createBlockCacheMiddleware({ blockTracker }),
-  baseControllers.createInflightCacheMiddleware({
-    cacheIdentifierForRequest: cacheIdentifier.cacheIdentifierForRequest
-  }),
-  // createBlockTrackerInspectorMiddleware({ blockTracker }),
-  fetchMiddleware]);
+  const jrpcEngineV2 = auth.JRPCEngineV2.create({
+    middleware: [createChainIdMiddleware(chainId), createProviderConfigMiddleware(providerConfig), baseControllers.createInflightCacheMiddleware({
+      cacheIdentifierForRequest: cacheIdentifier.cacheIdentifierForRequest
+    }), fetchMiddleware]
+  });
+  const networkMiddleware = jrpcEngineV2.asMiddleware();
   return {
     networkMiddleware,
     blockTracker

package/dist/lib.cjs/Preferences/PreferencesController.js

@@ -2,11 +2,11 @@
 
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 var baseControllers = require('@toruslabs/base-controllers');
+var metadataHelpers = require('@toruslabs/metadata-helpers');
 var asyncMutex = require('async-mutex');
 var log = require('loglevel');
 var constants = require('../utils/constants.js');
 var helpers = require('../utils/helpers.js');
-var hex = require('../utils/hex.js');
 
 class PreferencesController extends baseControllers.BasePreferencesController {
   constructor({
@@ -302,7 +302,7 @@ class PreferencesController extends baseControllers.BasePreferencesController {
   }
   isChainIdSupported(address, chainId) {
     const approveChainOptions = this.getChainOptions(address);
-    const providerConfig = approveChainOptions.find(x => hex.stripHexPrefix(x.chainId) === chainId);
+    const providerConfig = approveChainOptions.find(x => metadataHelpers.remove0x(x.chainId) === chainId);
     return !!providerConfig;
   }
   async addChain(network) {

package/dist/lib.cjs/Transaction/TransactionController.js

@@ -3,11 +3,11 @@
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 var baseControllers = require('@toruslabs/base-controllers');
+var metadataHelpers = require('@toruslabs/metadata-helpers');
 var auth = require('@web3auth/auth');
 var bignumber_js = require('bignumber.js');
 var log = require('loglevel');
 var viem = require('viem');
-var hex = require('../utils/hex.js');
 var eip7702Utils = require('../Eip7702/eip7702Utils.js');
 var walletSendCalls = require('../Eip5792/walletSendCalls.js');
 var constants = require('../utils/constants.js');
@@ -130,7 +130,7 @@ class TransactionController extends TransactionStateManager.TransactionStateMana
         }
         txParams.authorizationList = [{
           address: delegationAddress,
-          chainId: hex.addHexPrefix(chainId)
+          chainId: metadataHelpers.add0x(chainId)
         }];
         txParams.type = constants.TRANSACTION_ENVELOPE_TYPES.SET_CODE;
       }
@@ -181,7 +181,7 @@ class TransactionController extends TransactionStateManager.TransactionStateMana
       // higher gas settings and therefor the nonce should not be recalculated
       const nonce = nonceLock.nextNonce;
       const customOrNonce = customNonceValueNumber === 0 ? customNonceValue : customNonceValue || nonce;
-      txMeta.transaction.nonce = hex.addHexPrefix(customOrNonce.toString(16));
+      txMeta.transaction.nonce = metadataHelpers.add0x(customOrNonce.toString(16));
       // add nonce debugging information to txMeta
       txMeta.nonceDetails = nonceLock.nonceDetails;
       this.updateTransactionInState(txMeta, "transactions#approveTransaction");
@@ -274,7 +274,7 @@ class TransactionController extends TransactionStateManager.TransactionStateMana
       });
     } catch (error) {
       if (error.message.toLowerCase().includes("known transaction")) {
-        txHash = viem.keccak256(hex.addHexPrefix(rawTx));
+        txHash = viem.keccak256(metadataHelpers.add0x(rawTx));
       } else {
         throw error;
       }
@@ -350,7 +350,7 @@ class TransactionController extends TransactionStateManager.TransactionStateMana
         txMeta.transaction.maxFeePerGas = txMeta.transaction.gasPrice;
         // If the dapp has suggested a gas price, but no maxFeePerGas or maxPriorityFeePerGas
         // then we set maxFeePerGas to the suggested gasPrice.
-        txMeta.transaction.maxPriorityFeePerGas = helpers.bnLessThan(typeof defaultMaxPriorityFeePerGas === "string" ? hex.stripHexPrefix(defaultMaxPriorityFeePerGas) : defaultMaxPriorityFeePerGas, typeof txMeta.transaction.gasPrice === "string" ? hex.stripHexPrefix(txMeta.transaction.gasPrice) : txMeta.transaction.gasPrice) ? defaultMaxPriorityFeePerGas : txMeta.transaction.gasPrice;
+        txMeta.transaction.maxPriorityFeePerGas = helpers.bnLessThan(typeof defaultMaxPriorityFeePerGas === "string" ? metadataHelpers.remove0x(defaultMaxPriorityFeePerGas) : defaultMaxPriorityFeePerGas, typeof txMeta.transaction.gasPrice === "string" ? metadataHelpers.remove0x(txMeta.transaction.gasPrice) : txMeta.transaction.gasPrice) ? defaultMaxPriorityFeePerGas : txMeta.transaction.gasPrice;
       } else {
         if (defaultMaxFeePerGas && !txMeta.transaction.maxFeePerGas) {
           // If the dapp has not set the gasPrice or the maxFeePerGas, then we set maxFeePerGas
@@ -422,8 +422,8 @@ class TransactionController extends TransactionStateManager.TransactionStateMana
         if (suggestedMaxPriorityFeePerGas && suggestedMaxFeePerGas) {
           return {
             // send to controller in hex wei
-            maxFeePerGas: hex.addHexPrefix(conversionUtils.decGWEIToHexWEI(new bignumber_js.BigNumber(suggestedMaxFeePerGas)).toString(16)),
-            maxPriorityFeePerGas: hex.addHexPrefix(conversionUtils.decGWEIToHexWEI(new bignumber_js.BigNumber(suggestedMaxPriorityFeePerGas)).toString(16))
+            maxFeePerGas: metadataHelpers.add0x(conversionUtils.decGWEIToHexWEI(new bignumber_js.BigNumber(suggestedMaxFeePerGas)).toString(16)),
+            maxPriorityFeePerGas: metadataHelpers.add0x(conversionUtils.decGWEIToHexWEI(new bignumber_js.BigNumber(suggestedMaxPriorityFeePerGas)).toString(16))
           };
         }
       } else if (gasEstimateType === constants.GAS_ESTIMATE_TYPES.LEGACY) {
@@ -433,7 +433,7 @@ class TransactionController extends TransactionStateManager.TransactionStateMana
         // The LEGACY type includes low, medium and high estimates of
         // gas price values.
         return {
-          gasPrice: hex.addHexPrefix(conversionUtils.decGWEIToHexWEI(new bignumber_js.BigNumber(medium)).toString(16))
+          gasPrice: metadataHelpers.add0x(conversionUtils.decGWEIToHexWEI(new bignumber_js.BigNumber(medium)).toString(16))
         };
       } else if (gasEstimateType === constants.GAS_ESTIMATE_TYPES.ETH_GASPRICE) {
         const {
@@ -442,7 +442,7 @@ class TransactionController extends TransactionStateManager.TransactionStateMana
         // The ETH_GASPRICE type just includes a single gas price property,
         // which we can assume was retrieved from eth_gasPrice
         return {
-          gasPrice: hex.addHexPrefix(conversionUtils.decGWEIToHexWEI(new bignumber_js.BigNumber(gasPrice)).toString(16))
+          gasPrice: metadataHelpers.add0x(conversionUtils.decGWEIToHexWEI(new bignumber_js.BigNumber(gasPrice)).toString(16))
         };
       }
     } catch (error) {
@@ -452,7 +452,7 @@ class TransactionController extends TransactionStateManager.TransactionStateMana
       method: constants.METHOD_TYPES.ETH_GET_GAS_PRICE
     });
     return {
-      gasPrice: gasPrice && hex.addHexPrefix(gasPrice)
+      gasPrice: gasPrice && metadataHelpers.add0x(gasPrice)
     };
   }
   async getDefaultGasLimit(txMeta) {
@@ -486,9 +486,9 @@ class TransactionController extends TransactionStateManager.TransactionStateMana
       const baseMultiplier = 1.5;
       const perCallBuffer = 0.1;
       const eip7702UpgradeWithDataToSelfGasBufferMultiplier = baseMultiplier + perCallBuffer * batchCallsCount;
-      gasLimit = this.txGasUtil.addGasBuffer(hex.addHexPrefix(estimatedGasHex), blockGasLimit, eip7702UpgradeWithDataToSelfGasBufferMultiplier);
+      gasLimit = this.txGasUtil.addGasBuffer(metadataHelpers.add0x(estimatedGasHex), blockGasLimit, eip7702UpgradeWithDataToSelfGasBufferMultiplier);
     } else {
-      gasLimit = this.txGasUtil.addGasBuffer(hex.addHexPrefix(estimatedGasHex), blockGasLimit, customNetworkGasBuffer);
+      gasLimit = this.txGasUtil.addGasBuffer(metadataHelpers.add0x(estimatedGasHex), blockGasLimit, customNetworkGasBuffer);
     }
     return {
       gasLimit,
@@ -513,7 +513,7 @@ class TransactionController extends TransactionStateManager.TransactionStateMana
     txMeta.methodParams = methodParams;
     txMeta.isUserOperation = req.isUserOperation;
     txMeta.isSignOnly = req.isSignOnly;
-    txMeta.transaction.value = txMeta.transaction.value ? hex.addHexPrefix(txMeta.transaction.value) : "0x0";
+    txMeta.transaction.value = txMeta.transaction.value ? metadataHelpers.add0x(txMeta.transaction.value) : "0x0";
     txMeta.batchId = overrideTxMeta === null || overrideTxMeta === void 0 ? void 0 : overrideTxMeta.batchId;
     txMeta.nestedTransactions = overrideTxMeta === null || overrideTxMeta === void 0 ? void 0 : overrideTxMeta.nestedTransactions;
     this.emit(`${txMeta.id}:unapproved`, txMeta);

package/dist/lib.cjs/Transaction/TransactionGasUtil.js

@@ -3,9 +3,9 @@
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
 var baseControllers = require('@toruslabs/base-controllers');
+var metadataHelpers = require('@toruslabs/metadata-helpers');
 var log = require('loglevel');
 var eip7702Types = require('../utils/eip7702Types.js');
-var hex = require('../utils/hex.js');
 var TransactionUtils = require('./TransactionUtils.js');
 
 class TransactionGasUtil {
@@ -18,9 +18,9 @@ class TransactionGasUtil {
   async analyzeGasUsage(txMeta) {
     const block = await this.blockTracker.getLatestBlock();
     // fallback to block gasLimit
-    const blockGasLimit = BigInt(hex.addHexPrefix(block.gasLimit));
+    const blockGasLimit = metadataHelpers.hexToBigInt(block.gasLimit);
     const saferGasLimit = blockGasLimit * 19n / 20n;
-    let estimatedGasHex = hex.addHexPrefix(saferGasLimit.toString(16));
+    let estimatedGasHex = metadataHelpers.add0x(saferGasLimit.toString(16));
     let simulationFails;
     try {
       estimatedGasHex = await this.estimateTxGas(txMeta);
@@ -45,16 +45,16 @@ class TransactionGasUtil {
     Adds a gas buffer with out exceeding the block gas limit
   */
   addGasBuffer(initialGasLimitHex, blockGasLimitHex, multiplier = 1.5) {
-    const initialGasLimit = BigInt(hex.addHexPrefix(initialGasLimitHex));
-    const blockGasLimit = BigInt(hex.addHexPrefix(blockGasLimitHex));
+    const initialGasLimit = metadataHelpers.hexToBigInt(initialGasLimitHex);
+    const blockGasLimit = metadataHelpers.hexToBigInt(blockGasLimitHex);
     const upperGasLimit = blockGasLimit * 9n / 10n;
     const bufferedGasLimit = initialGasLimit * BigInt(Math.round(multiplier * 10)) / 10n;
     // if initialGasLimit is above blockGasLimit, dont modify it
-    if (initialGasLimit > upperGasLimit) return hex.addHexPrefix(initialGasLimit.toString(16));
+    if (initialGasLimit > upperGasLimit) return metadataHelpers.bigIntToHexPrefixedString(initialGasLimit);
     // if bufferedGasLimit is below blockGasLimit, use bufferedGasLimit
-    if (bufferedGasLimit < upperGasLimit) return hex.addHexPrefix(bufferedGasLimit.toString(16));
+    if (bufferedGasLimit < upperGasLimit) return metadataHelpers.bigIntToHexPrefixedString(bufferedGasLimit);
     // otherwise use blockGasLimit
-    return hex.addHexPrefix(upperGasLimit.toString(16));
+    return metadataHelpers.bigIntToHexPrefixedString(upperGasLimit);
   }
   /**
     Estimates the tx's gas usage

package/dist/lib.cjs/Transaction/TransactionUtils.js

@@ -2,30 +2,30 @@
 
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var baseControllers = require('@toruslabs/base-controllers');
+var metadataHelpers = require('@toruslabs/metadata-helpers');
 var auth = require('@web3auth/auth');
 var log = require('loglevel');
 var viem = require('viem');
 var abis = require('../utils/abis.js');
 var constants = require('../utils/constants.js');
-var hex = require('../utils/hex.js');
 
 const normalizers = {
-  from: (from, LowerCase = true) => LowerCase ? hex.addHexPrefix(from).toLowerCase() : hex.addHexPrefix(from),
-  to: (to, LowerCase = true) => LowerCase ? hex.addHexPrefix(to).toLowerCase() : hex.addHexPrefix(to),
-  nonce: nonce => hex.addHexPrefix(nonce),
-  customNonceValue: nonce => hex.addHexPrefix(nonce),
-  value: value => hex.addHexPrefix(value),
-  data: data => hex.addHexPrefix(data),
-  gas: gas => hex.addHexPrefix(gas),
-  gasPrice: gasPrice => hex.addHexPrefix(gasPrice),
-  type: hex.addHexPrefix,
-  maxFeePerGas: hex.addHexPrefix,
-  maxPriorityFeePerGas: hex.addHexPrefix,
-  callGasLimit: hex.addHexPrefix,
-  preVerificationGas: hex.addHexPrefix,
-  verificationGasLimit: hex.addHexPrefix,
-  paymasterVerificationGasLimit: hex.addHexPrefix,
-  paymasterPostOpGasLimit: hex.addHexPrefix,
+  from: (from, LowerCase = true) => LowerCase ? metadataHelpers.add0x(from).toLowerCase() : metadataHelpers.add0x(from),
+  to: (to, LowerCase = true) => LowerCase ? metadataHelpers.add0x(to).toLowerCase() : metadataHelpers.add0x(to),
+  nonce: nonce => metadataHelpers.add0x(nonce),
+  customNonceValue: nonce => metadataHelpers.add0x(nonce),
+  value: value => metadataHelpers.add0x(value),
+  data: data => metadataHelpers.add0x(data),
+  gas: gas => metadataHelpers.add0x(gas),
+  gasPrice: gasPrice => metadataHelpers.add0x(gasPrice),
+  type: metadataHelpers.add0x,
+  maxFeePerGas: metadataHelpers.add0x,
+  maxPriorityFeePerGas: metadataHelpers.add0x,
+  callGasLimit: metadataHelpers.add0x,
+  preVerificationGas: metadataHelpers.add0x,
+  verificationGasLimit: metadataHelpers.add0x,
+  paymasterVerificationGasLimit: metadataHelpers.add0x,
+  paymasterPostOpGasLimit: metadataHelpers.add0x,
   authorizationList: authorizationList => authorizationList
 };
 /**
@@ -61,7 +61,7 @@ function isEIP1559Transaction(transaction) {
   var _transaction$transact, _transaction$transact2;
   const maxFeePerGas = transaction === null || transaction === void 0 || (_transaction$transact = transaction.transaction) === null || _transaction$transact === void 0 ? void 0 : _transaction$transact.maxFeePerGas;
   const maxPriorityFeePerGas = transaction === null || transaction === void 0 || (_transaction$transact2 = transaction.transaction) === null || _transaction$transact2 === void 0 ? void 0 : _transaction$transact2.maxPriorityFeePerGas;
-  return typeof maxFeePerGas === "string" && typeof maxPriorityFeePerGas === "string" && viem.isHex(hex.addHexPrefix(maxFeePerGas)) && viem.isHex(hex.addHexPrefix(maxPriorityFeePerGas));
+  return typeof maxFeePerGas === "string" && typeof maxPriorityFeePerGas === "string" && viem.isHex(metadataHelpers.add0x(maxFeePerGas)) && viem.isHex(metadataHelpers.add0x(maxPriorityFeePerGas));
 }
 /**
  * Determine if the maxFeePerGas and maxPriorityFeePerGas fields are not
@@ -73,7 +73,7 @@ function isEIP1559Transaction(transaction) {
  *  EIP1559 fields
  */
 function isLegacyTransaction(transaction) {
-  return typeof transaction.transaction.maxFeePerGas === "undefined" && typeof transaction.transaction.maxPriorityFeePerGas === "undefined" && (typeof transaction.transaction.gasPrice === "undefined" || viem.isHex(hex.addHexPrefix(transaction.transaction.gasPrice)));
+  return typeof transaction.transaction.maxFeePerGas === "undefined" && typeof transaction.transaction.maxPriorityFeePerGas === "undefined" && (typeof transaction.transaction.gasPrice === "undefined" || viem.isHex(metadataHelpers.add0x(transaction.transaction.gasPrice)));
 }
 /**
  * Given two fields, ensure that the second field is not included in txParams,
@@ -205,7 +205,7 @@ function validateTxParameters(txParams, eip1559Compatibility = true) {
           if (typeof authorization.address !== "string" || !viem.isAddress(authorization.address)) {
             throw auth.rpcErrors.invalidParams(`Invalid transaction params: authorization.address is not a valid address. got: (${authorization.address})`);
           }
-          if (typeof authorization.chainId !== "string" || !viem.isHex(hex.addHexPrefix(authorization.chainId))) {
+          if (typeof authorization.chainId !== "string" || !viem.isHex(metadataHelpers.add0x(authorization.chainId))) {
             throw auth.rpcErrors.invalidParams(`Invalid transaction params: authorization.chainId is not a valid hex string. got: (${authorization.chainId})`);
           }
         });

package/dist/lib.cjs/index.js

@@ -22,6 +22,7 @@ var PersonalMessageController = require('./Message/PersonalMessageController.js'
 var SwitchChainController = require('./Message/SwitchChainController.js');
 var TypedMessageController = require('./Message/TypedMessageController.js');
 var utils = require('./Message/utils.js');
+var cacheIdentifier = require('./Network/cacheIdentifier.js');
 var createEthereumMiddleware = require('./Network/createEthereumMiddleware.js');
 var createJsonRpcClient = require('./Network/createJsonRpcClient.js');
 var NetworkController = require('./Network/NetworkController.js');
@@ -85,11 +86,19 @@ exports.validateAddress = utils.validateAddress;
 exports.validateSignMessageData = utils.validateSignMessageData;
 exports.validateSwitchChainData = utils.validateSwitchChainData;
 exports.validateTypedSignMessageDataV4 = utils.validateTypedSignMessageDataV4;
+Object.defineProperty(exports, "CacheStrategy", {
+	enumerable: true,
+	get: function () { return cacheIdentifier.CacheStrategy; }
+});
+exports.blockTagParamIndex = cacheIdentifier.blockTagParamIndex;
+exports.cacheIdentifierForRequest = cacheIdentifier.cacheIdentifierForRequest;
+exports.cacheTypeForMethod = cacheIdentifier.cacheTypeForMethod;
 exports.createAAMiddleware = createEthereumMiddleware.createAAMiddleware;
 exports.createEip5792Middleware = createEthereumMiddleware.createEip5792Middleware;
 exports.createEip7702Middleware = createEthereumMiddleware.createEip7702Middleware;
 exports.createEthereumMiddleware = createEthereumMiddleware.createEthereumMiddleware;
 exports.createGetAccountsMiddleware = createEthereumMiddleware.createGetAccountsMiddleware;
+exports.createGetProviderStateMiddleware = createEthereumMiddleware.createGetProviderStateMiddleware;
 exports.createPendingNonceMiddleware = createEthereumMiddleware.createPendingNonceMiddleware;
 exports.createPendingTxMiddleware = createEthereumMiddleware.createPendingTxMiddleware;
 exports.createProcessAddEthereumChain = createEthereumMiddleware.createProcessAddEthereumChain;

package/dist/lib.cjs/types/AccountAbstraction/AccountAbstractionController.d.ts

@@ -1,5 +1,5 @@
 import { type BaseConfig, BaseController, type BaseState, TransactionStatus } from "@toruslabs/base-controllers";
-import { JRPCMiddleware, type JRPCRequest, type JRPCResponse, type SafeEventEmitterProvider } from "@web3auth/auth";
+import { type JRPCMiddlewareV2, type JRPCRequest, type Json, type SafeEventEmitterProvider } from "@web3auth/auth";
 import { type BundlerClient, type SmartAccount } from "viem/account-abstraction";
 import { type NetworkController } from "../Network/NetworkController";
 import type { BundlerConfig, EthereumNetworkState, ISmartAccount, PaymasterConfig, SignTypedDataMessageV4, SmartAccountType, TransactionParams, UserOperationGas } from "../utils/interfaces";
@@ -30,8 +30,8 @@ export interface AccountAbstractionControllerConfig extends BaseConfig {
     smartAccountInit?: ISmartAccount;
     chainId?: string;
 }
-export declare const eoaInterceptorMiddleware: (eoaAddress: string) => (req: JRPCRequest<unknown>, res: JRPCResponse<unknown>, next: () => void, end: () => void) => void;
-export declare function eoaProviderAsMiddleware(provider: SafeEventEmitterProvider): JRPCMiddleware<unknown, unknown>;
+export declare const eoaInterceptorMiddleware: (eoaAddress: string) => JRPCMiddlewareV2<JRPCRequest, Json>;
+export declare function eoaProviderAsMiddleware(provider: SafeEventEmitterProvider): JRPCMiddlewareV2<JRPCRequest, Json>;
 export declare class AccountAbstractionController extends BaseController<AccountAbstractionControllerConfig, AccountAbstractionControllerState> {
     private _smartAccount;
     private _publicClient;

package/dist/lib.cjs/types/Eip5792/walletSendCalls.d.ts

@@ -1,5 +1,5 @@
 import { JRPCRequest } from "@web3auth/auth";
-import { IProviderHandlers } from "../Network/createEthereumMiddleware";
+import { IProviderHandlers } from "../Network/interfaces";
 import { BatchTransactionParams, Eip5792SendCallsParams } from "../utils/eip5792Types";
 import { GetEthCodeFn } from "../utils/interfaces";
 export interface WalletSendCallsContext {

package/dist/lib.cjs/types/Eip7702/walletUpgradeAccount.d.ts

@@ -1,5 +1,5 @@
 import { JRPCRequest } from "@web3auth/auth";
-import { IProviderHandlers } from "../Network/createEthereumMiddleware";
+import { IProviderHandlers } from "../Network/interfaces";
 import { Eip7702Params } from "../utils/eip7702Types";
 import { GetEthCodeFn } from "../utils/interfaces";
 /**

package/dist/lib.cjs/types/Network/NetworkController.d.ts

@@ -2,7 +2,7 @@ import { type Analytics, BaseController, IdleTimeTracker, INetworkController } f
 import { SafeEventEmitterProvider } from "@web3auth/auth";
 import { PollingBlockTracker } from "../Block/PollingBlockTracker";
 import { EthereumNetworkConfig, EthereumNetworkState, EthereumProviderConfig, NetworkControllerEvents } from "../utils/interfaces";
-import { IProviderHandlers } from "./createEthereumMiddleware";
+import { IProviderHandlers } from "./interfaces";
 export declare class NetworkController extends BaseController<EthereumNetworkConfig, EthereumNetworkState, NetworkControllerEvents<EthereumNetworkState>> implements INetworkController<EthereumNetworkConfig, EthereumNetworkState> {
     name: string;
     providerProxy: SafeEventEmitterProvider;

package/dist/lib.cjs/types/Network/createEthereumMiddleware.d.ts

@@ -1,131 +1,69 @@
-import { type Analytics, InPageWalletProviderState, MessageParams, type ProviderConfig, SwitchChainMessageParams, UserRequestApprovalParams } from "@toruslabs/base-controllers";
-import { JRPCEngineEndCallback, JRPCEngineNextCallback, JRPCMiddleware, JRPCRequest, JRPCResponse } from "@web3auth/auth";
+import { type Analytics, InPageWalletProviderState, type ProviderConfig } from "@toruslabs/base-controllers";
+import { type JRPCMiddlewareV2, type JRPCRequest } from "@web3auth/auth";
 import { TransactionStateManager } from "../Transaction/TransactionStateManager";
-import { Eip5792SendCallsParams, TransactionBatchRequest } from "../utils/eip5792Types";
-import { AddChainMessageParams, BlockParams, EthereumTransactionMeta, GetEthCodeFn, TransactionParams, TransactionRPCMeta, TypedMessageParams, UserOperationGas } from "../utils/interfaces";
-export interface IProviderHandlers {
-    version: string;
-    aaConfig?: {
-        bundlerUrl: string;
-        paymasterUrl?: string;
-    };
-    requestAccounts?: (req: JRPCRequest<string[]>) => Promise<string[]>;
-    getAccounts: (req: JRPCRequest<string[]>) => Promise<string[]>;
-    getPrivateKey?: (req: JRPCRequest<unknown>) => Promise<string>;
-    getPublicKey?: (req: JRPCRequest<unknown>) => Promise<string>;
-    processTransaction?: (txParams: TransactionParams, req: JRPCRequest<TransactionParams> & UserRequestApprovalParams) => Promise<string>;
-    processTransactionBatch?: (batchRequest: TransactionBatchRequest, req: JRPCRequest<Eip5792SendCallsParams>) => Promise<string>;
-    processSignTransaction?: (txParams: TransactionParams, req: JRPCRequest<TransactionParams> & UserRequestApprovalParams) => Promise<string>;
-    processEthSignMessage?: (msgParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
-    processTypedMessageV4?: (msgParams: TypedMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
-    processPersonalMessage?: (msgParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
-    processSwitchEthereumChain?: (msgParams: SwitchChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
-    processWalletSwitchChain?: (msgParams: SwitchChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
-    processAddEthereumChain?: (msgParams: AddChainMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
-    processEstimateUserOperationGas?: (txParams: TransactionParams, req: JRPCRequest<TransactionParams>) => Promise<UserOperationGas>;
-    getPendingNonce?: (nonceParams: {
-        address: string;
-        blockReference: string;
-    }, req: JRPCRequest<{
-        address: string;
-        blockReference: string;
-    }>) => Promise<string>;
-    getPendingTransactionByHash?: (hash: string, req: JRPCRequest<string>) => Promise<EthereumTransactionMeta>;
-    getTransactionByBatchId: TransactionStateManager["getTransactionByBatchId"];
-    getProviderState: (req: JRPCRequest<[]>, res: JRPCResponse<InPageWalletProviderState>, next: JRPCEngineNextCallback, end: JRPCEngineEndCallback) => void;
-    /**
-     * Query the deployment bytecode of an address. (eth_getCode)
-     */
-    getEthCode?: GetEthCodeFn;
-    /**
-     * EIP-5792 configuration for wallet capabilities and batch calls.
-     */
-    eip5792Config?: {
-        /**
-         * Get the list of supported chain IDs for EIP-5792/EIP-7702.
-         */
-        getSupportedChains: () => `0x${string}`[];
-        /**
-         * Get cached delegation addresses.
-         * Key format: `${walletAddress}-${chainId}`
-         */
-        getCachedDelegations?: () => Record<string, `0x${string}` | null>;
-        /**
-         * Update the delegation cache.
-         */
-        updateDelegationCache?: (walletAddress: `0x${string}`, chainId: `0x${string}`, delegation: `0x${string}` | null) => void;
-    };
-}
-export declare function createGetAccountsMiddleware({ getAccounts }: {
+import { EthereumTransactionMeta, GetEthCodeFn, TransactionRPCMeta, UserOperationGas } from "../utils/interfaces";
+import { IProviderHandlers } from "./interfaces";
+export declare function formatTxMetaForRpcResult(txMeta: EthereumTransactionMeta): TransactionRPCMeta;
+export declare function createGetProviderStateMiddleware({ getProviderState, }: {
+    getProviderState: IProviderHandlers["getProviderState"];
+}): JRPCMiddlewareV2<JRPCRequest, InPageWalletProviderState>;
+export declare function createGetAccountsMiddleware({ getAccounts, }: {
     getAccounts: IProviderHandlers["getAccounts"];
-}): JRPCMiddleware<never, string[]>;
+}): JRPCMiddlewareV2<JRPCRequest, string[]>;
 export declare function createProcessTransactionMiddleware({ processTransaction, }: {
     processTransaction: IProviderHandlers["processTransaction"];
-}): JRPCMiddleware<TransactionParams, string>;
+}): JRPCMiddlewareV2<JRPCRequest, string>;
 export declare function createProcessSignTransactionMiddleware({ processSignTransaction, }: {
-    processSignTransaction: IProviderHandlers["processTransaction"];
-}): JRPCMiddleware<TransactionParams, string>;
+    processSignTransaction: IProviderHandlers["processSignTransaction"];
+}): JRPCMiddlewareV2<JRPCRequest, string>;
 export declare function createProcessEstimateUserOperationGasMiddleware({ processEstimateUserOperationGas, }: {
     processEstimateUserOperationGas: IProviderHandlers["processEstimateUserOperationGas"];
-}): JRPCMiddleware<TransactionParams, string | UserOperationGas>;
+}): JRPCMiddlewareV2<JRPCRequest, UserOperationGas>;
 export declare function createProcessEthSignMessage({ processEthSignMessage, }: {
     processEthSignMessage: IProviderHandlers["processEthSignMessage"];
-}): JRPCMiddleware<unknown, string>;
+}): JRPCMiddlewareV2<JRPCRequest, string>;
 export declare function createProcessTypedMessageV4({ processTypedMessageV4, }: {
     processTypedMessageV4: IProviderHandlers["processTypedMessageV4"];
-}): JRPCMiddleware<unknown, string>;
+}): JRPCMiddlewareV2<JRPCRequest, string>;
 export declare function createProcessPersonalMessage({ processPersonalMessage, }: {
     processPersonalMessage: IProviderHandlers["processPersonalMessage"];
-}): JRPCMiddleware<unknown, string>;
+}): JRPCMiddlewareV2<JRPCRequest, string>;
 export declare function createPendingNonceMiddleware({ getPendingNonce, }: {
     getPendingNonce: IProviderHandlers["getPendingNonce"];
-}): JRPCMiddleware<{
-    address: string;
-    blockReference: BlockParams;
-}, string>;
-export declare function formatTxMetaForRpcResult(txMeta: EthereumTransactionMeta): TransactionRPCMeta;
+}): JRPCMiddlewareV2<JRPCRequest, string>;
 export declare function createPendingTxMiddleware({ getPendingTransactionByHash, }: {
     getPendingTransactionByHash: IProviderHandlers["getPendingTransactionByHash"];
-}): JRPCMiddleware<string, TransactionRPCMeta>;
+}): JRPCMiddlewareV2<JRPCRequest>;
 export declare function createProcessSwitchEthereumChain({ processSwitchEthereumChain, }: {
     processSwitchEthereumChain: IProviderHandlers["processSwitchEthereumChain"];
-}): JRPCMiddleware<unknown, string>;
+}): JRPCMiddlewareV2<JRPCRequest, string>;
 export declare function createProcessWalletSwitchChain({ processWalletSwitchChain, }: {
     processWalletSwitchChain: IProviderHandlers["processWalletSwitchChain"];
-}): JRPCMiddleware<unknown, string>;
+}): JRPCMiddlewareV2<JRPCRequest, string>;
 export declare function createProcessAddEthereumChain({ processAddEthereumChain, }: {
     processAddEthereumChain: IProviderHandlers["processAddEthereumChain"];
-}): JRPCMiddleware<unknown, string>;
+}): JRPCMiddlewareV2<JRPCRequest, string>;
 export declare function createRequestAccountsMiddleware({ requestAccounts, }: {
     requestAccounts: IProviderHandlers["requestAccounts"];
-}): JRPCMiddleware<string[], unknown>;
+}): JRPCMiddlewareV2<JRPCRequest, string[]>;
 /**
- * Middleware to handle bundler/paymaster rpc method
+ * Middleware to handle bundler/paymaster rpc methods.
  */
 export declare function createAAMiddleware({ bundlerUrl, paymasterUrl, providerConfig, analytics, }: {
     bundlerUrl: string;
     paymasterUrl?: string;
     providerConfig: ProviderConfig;
     analytics?: Analytics;
-}): JRPCMiddleware<unknown, unknown>;
+}): JRPCMiddlewareV2<JRPCRequest>;
 /**
  * Middleware to handle EIP-7702 methods.
- *
- * @param getEthCode - Function to get the deployment bytecode of an address. (eth_getCode)
- * @param processTransaction - Function to process a transaction.
- * @returns JRPCMiddleware to handle EIP-7702 methods
  */
 export declare function createEip7702Middleware({ getEthCode, processTransaction, }: {
     getEthCode: GetEthCodeFn;
     processTransaction: IProviderHandlers["processTransaction"];
-}): JRPCMiddleware<unknown, unknown>;
+}): JRPCMiddlewareV2<JRPCRequest>;
 /**
  * Middleware to handle EIP-5792 methods.
- * Supports wallet capabilities and batch call operations for EIP-7702 upgraded accounts.
- *
- * @param eip5792Config - Configuration for EIP-5792 handlers.
- * @param processTransaction - Function to process a transaction.
- * @returns JRPCMiddleware to handle EIP-5792 methods
  */
 export declare function createEip5792Middleware({ eip5792Config, processTransaction, processTransactionBatch, getTransactionByBatchId, getEthCode, }: {
     eip5792Config: IProviderHandlers["eip5792Config"];
@@ -133,5 +71,5 @@ export declare function createEip5792Middleware({ eip5792Config, processTransact
     processTransactionBatch: IProviderHandlers["processTransactionBatch"];
     getTransactionByBatchId: TransactionStateManager["getTransactionByBatchId"];
     getEthCode: GetEthCodeFn;
-}): JRPCMiddleware<unknown, unknown>;
-export declare function createEthereumMiddleware(providerHandlers: IProviderHandlers, providerConfig?: ProviderConfig, analytics?: Analytics): JRPCMiddleware<unknown, unknown>;
+}): JRPCMiddlewareV2<JRPCRequest>;
+export declare function createEthereumMiddleware(providerHandlers: IProviderHandlers, providerConfig?: ProviderConfig, analytics?: Analytics): JRPCMiddlewareV2<JRPCRequest>;

package/dist/lib.cjs/types/Network/createJsonRpcClient.d.ts

@@ -1,10 +1,10 @@
 import { type Analytics, IdleTimeTracker, ProviderConfig } from "@toruslabs/base-controllers";
-import { JRPCMiddleware } from "@web3auth/auth";
+import { JRPCMiddlewareV2, JRPCRequest } from "@web3auth/auth";
 import { PollingBlockTracker } from "../Block/PollingBlockTracker";
 import { EthereumNetworkConfig } from "../utils/interfaces";
-export declare function createChainIdMiddleware(chainId: string): JRPCMiddleware<unknown, string>;
-export declare function createProviderConfigMiddleware(providerConfig: ProviderConfig): JRPCMiddleware<unknown, ProviderConfig>;
+export declare function createChainIdMiddleware(chainId: string): JRPCMiddlewareV2<JRPCRequest>;
+export declare function createProviderConfigMiddleware(providerConfig: ProviderConfig): JRPCMiddlewareV2<JRPCRequest>;
 export declare function createJsonRpcClient(providerConfig: ProviderConfig, networkConfig: EthereumNetworkConfig, idleTimeTracker?: IdleTimeTracker, analytics?: Analytics): {
-    networkMiddleware: JRPCMiddleware<unknown, unknown>;
+    networkMiddleware: JRPCMiddlewareV2<JRPCRequest>;
     blockTracker: PollingBlockTracker;
 };

package/dist/lib.cjs/types/Network/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./cacheIdentifier";
+export * from "./createEthereumMiddleware";
+export * from "./createJsonRpcClient";
+export { type IProviderHandlers } from "./interfaces";
+export { NetworkController } from "./NetworkController";