@toruslabs/ethereum-controllers 8.17.1 → 9.1.0

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

@@ -1,34 +1,31 @@
 'use strict';
 
 var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
-var util = require('@ethereumjs/util');
 var baseControllers = require('@toruslabs/base-controllers');
+var metadataHelpers = require('@toruslabs/metadata-helpers');
 var auth = require('@web3auth/auth');
-var ethers = require('ethers');
 var log = require('loglevel');
+var viem = require('viem');
 var abis = require('../utils/abis.js');
 var constants = require('../utils/constants.js');
 
-const erc20Interface = new ethers.Interface(abis.erc20Abi);
-const erc721Interface = new ethers.Interface(abis.erc721Abi);
-const erc1155Interface = new ethers.Interface(abis.erc1155Abi);
 const normalizers = {
-  from: (from, LowerCase = true) => LowerCase ? util.addHexPrefix(from).toLowerCase() : util.addHexPrefix(from),
-  to: (to, LowerCase = true) => LowerCase ? util.addHexPrefix(to).toLowerCase() : util.addHexPrefix(to),
-  nonce: nonce => util.addHexPrefix(nonce),
-  customNonceValue: nonce => util.addHexPrefix(nonce),
-  value: value => util.addHexPrefix(value),
-  data: data => util.addHexPrefix(data),
-  gas: gas => util.addHexPrefix(gas),
-  gasPrice: gasPrice => util.addHexPrefix(gasPrice),
-  type: util.addHexPrefix,
-  maxFeePerGas: util.addHexPrefix,
-  maxPriorityFeePerGas: util.addHexPrefix,
-  callGasLimit: util.addHexPrefix,
-  preVerificationGas: util.addHexPrefix,
-  verificationGasLimit: util.addHexPrefix,
-  paymasterVerificationGasLimit: util.addHexPrefix,
-  paymasterPostOpGasLimit: util.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
 };
 /**
@@ -62,7 +59,9 @@ function transactionMatchesNetwork(transaction, chainId) {
  */
 function isEIP1559Transaction(transaction) {
   var _transaction$transact, _transaction$transact2;
-  return util.isHexString(util.addHexPrefix(transaction === null || transaction === void 0 || (_transaction$transact = transaction.transaction) === null || _transaction$transact === void 0 ? void 0 : _transaction$transact.maxFeePerGas)) && util.isHexString(util.addHexPrefix(transaction === null || transaction === void 0 || (_transaction$transact2 = transaction.transaction) === null || _transaction$transact2 === void 0 ? void 0 : _transaction$transact2.maxPriorityFeePerGas));
+  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(metadataHelpers.add0x(maxFeePerGas)) && viem.isHex(metadataHelpers.add0x(maxPriorityFeePerGas));
 }
 /**
  * Determine if the maxFeePerGas and maxPriorityFeePerGas fields are not
@@ -74,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" || util.isHexString(util.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,
@@ -121,7 +120,7 @@ function validateFrom(txParams) {
   if (!(typeof txParams.from === "string")) {
     throw auth.rpcErrors.invalidParams(`Invalid "from" address "${txParams.from}": not a string.`);
   }
-  if (!util.isValidAddress(txParams.from)) {
+  if (!viem.isAddress(txParams.from)) {
     throw auth.rpcErrors.invalidParams('Invalid "from" address.');
   }
 }
@@ -135,7 +134,7 @@ function validateRecipient(txParameters) {
     } else {
       throw auth.rpcErrors.invalidParams('Invalid "to" address.');
     }
-  } else if (txParameters.to !== undefined && !util.isValidAddress(txParameters.to)) {
+  } else if (txParameters.to !== undefined && !viem.isAddress(txParameters.to)) {
     throw auth.rpcErrors.invalidParams('Invalid "to" address.');
   }
   return txParameters;
@@ -203,10 +202,10 @@ function validateTxParameters(txParams, eip1559Compatibility = true) {
           if (typeof authorization !== "object" || authorization === null) {
             throw auth.rpcErrors.invalidParams(`Invalid transaction params: ${key} is not an object. got: (${authorization})`);
           }
-          if (typeof authorization.address !== "string" || !util.isValidAddress(authorization.address)) {
+          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" || !util.isHexString(util.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})`);
           }
         });
@@ -236,36 +235,42 @@ function getFinalStates() {
 }
 function parseStandardTokenTransactionData(data) {
   try {
-    const txDesc = erc20Interface.parseTransaction({
-      data
+    var _txDesc$args;
+    const txDesc = viem.decodeFunctionData({
+      abi: abis.erc20Abi,
+      data: data
     });
     if (txDesc) return {
-      name: txDesc.name,
-      methodParams: txDesc.args.toArray(),
+      name: txDesc.functionName,
+      methodParams: [...((_txDesc$args = txDesc.args) !== null && _txDesc$args !== void 0 ? _txDesc$args : [])],
       type: constants.CONTRACT_TYPE_ERC20
     };
   } catch {
     // ignore and next try to parse with erc721 ABI
   }
   try {
-    const txDesc = erc721Interface.parseTransaction({
-      data
+    var _txDesc$args2;
+    const txDesc = viem.decodeFunctionData({
+      abi: abis.erc721Abi,
+      data: data
     });
     if (txDesc) return {
-      name: txDesc.name,
-      methodParams: txDesc.args.toArray(),
+      name: txDesc.functionName,
+      methodParams: [...((_txDesc$args2 = txDesc.args) !== null && _txDesc$args2 !== void 0 ? _txDesc$args2 : [])],
       type: constants.CONTRACT_TYPE_ERC721
     };
   } catch {
     // ignore and next try to parse with erc1155 ABI
   }
   try {
-    const txDesc = erc1155Interface.parseTransaction({
-      data
+    var _txDesc$args3;
+    const txDesc = viem.decodeFunctionData({
+      abi: abis.erc1155Abi,
+      data: data
     });
     if (txDesc) return {
-      name: txDesc.name,
-      methodParams: txDesc.args.toArray(),
+      name: txDesc.functionName,
+      methodParams: [...((_txDesc$args3 = txDesc.args) !== null && _txDesc$args3 !== void 0 ? _txDesc$args3 : [])],
       type: constants.CONTRACT_TYPE_ERC1155
     };
   } catch {

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/Account/AccountTrackerController.d.ts

@@ -23,7 +23,7 @@ export declare class AccountTrackerController extends BaseController<AccountTrac
     private provider;
     private blockTracker;
     private mutex;
-    private ethersProvider;
+    private publicClient;
     private getIdentities;
     private getCurrentChainId;
     constructor({ config, state, provider, blockTracker, getIdentities, onPreferencesStateChange, getCurrentChainId, }: AccountTrackerControllerOptions);

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;
@@ -52,8 +52,6 @@ export declare class AccountAbstractionController extends BaseController<Account
     estimateGas(txParams: TransactionParams, address: string): Promise<UserOperationGas>;
     signMessage(message: string, address: string): Promise<string>;
     signPersonalMessage(message: string, address: string): Promise<string>;
-    signTypedData(data: SignTypedDataMessageV4 & {
-        primaryType: string;
-    }, address: string): Promise<string>;
+    signTypedData(data: SignTypedDataMessageV4, address: string): Promise<string>;
     private updateUserOpMeta;
 }

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/Keyring/KeyringController.d.ts

@@ -9,11 +9,11 @@ export declare class KeyringController extends BaseKeyringController<Partial<Bas
     signTransaction<T, U>(tx: T, address: string): Promise<U>;
     signEip7702Authorization(authorization: UnsignedAuthorization, address: string): Promise<Required<Authorization>>;
     getAccounts(): string[];
-    importAccount(accountPrivateKey: string): string;
+    importAccount(accountPrivateKey: string): Promise<string>;
     removeAccount(address: string): void;
-    getBufferPrivateKey(privateKey: string): Buffer<ArrayBuffer>;
+    getPrivateKeyBytes(privateKey: string): Uint8Array;
     signMessage(data: string, address: string): Promise<string>;
-    signPersonalMessage(data: string, address: string): Promise<string>;
-    signTypedData(typedData: SignTypedDataMessageV4, address: string): Promise<string>;
+    signPersonalMessage(data: string, address: string): Promise<`0x${string}`>;
+    signTypedData(typedData: SignTypedDataMessageV4, address: string): Promise<`0x${string}`>;
     private _getWalletForAccount;
 }

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";

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

@@ -0,0 +1,58 @@
+import { InPageWalletProviderState, SwitchChainMessageParams } from "@toruslabs/base-controllers";
+import { JRPCRequest } from "@web3auth/auth";
+import { TransactionStateManager } from "../Transaction/TransactionStateManager";
+import { Eip5792SendCallsParams, TransactionBatchRequest } from "../utils/eip5792Types";
+import { AddChainMessageParams, EthereumTransactionMeta, GetEthCodeFn, MessageParams, TransactionParams, TypedMessageParams, UserOperationGas, UserRequestApprovalParams } 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: () => Promise<InPageWalletProviderState>;
+    /**
+     * 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;
+    };
+}

package/dist/lib.cjs/types/Nfts/NftHandler.d.ts

@@ -1,5 +1,5 @@
 import { CustomNftItemInfo } from "@toruslabs/base-controllers";
-import { Provider } from "ethers";
+import { SafeEventEmitterProvider } from "@web3auth/auth";
 import { EthereumNftInfo as CustomNftInfo } from "../Nfts/INftsController";
 export interface INftOptions {
     contractAddress: string;
@@ -11,7 +11,7 @@ export interface INftOptions {
     nftStandard?: "erc721" | "erc1155";
     contractDescription?: string;
     chainId: string;
-    provider: Provider;
+    provider: SafeEventEmitterProvider;
 }
 export declare class NftHandler {
     contractAddress: string;
@@ -23,8 +23,9 @@ export declare class NftHandler {
     nftStandard: "erc721" | "erc1155";
     contractDescription?: string;
     chainId: string;
-    provider: Provider;
+    provider: SafeEventEmitterProvider;
     isSpecial?: boolean;
+    private publicClient;
     constructor({ chainId, contractAddress, contractImage, contractName, contractSymbol, nftStandard, provider, contractDescription, contractFallbackLogo, contractSupply, }: INftOptions);
     getNftMetadata(userAddress: string, tokenInfo: Partial<CustomNftItemInfo>): Promise<CustomNftItemInfo>;
     getContractMetadata(): Promise<Omit<CustomNftInfo, "assets">>;

package/dist/lib.cjs/types/Nfts/NftsController.d.ts

@@ -17,7 +17,6 @@ export interface INftsControllerOptions {
 export declare class NftsController extends BaseController<EthereumNftsControllerConfig, EthereumNftsControllerState> implements INftsController<EthereumNftsControllerConfig, EthereumNftsControllerState> {
     name: string;
     private provider;
-    private ethersProvider;
     private getCustomNfts;
     private getSimpleHashNfts;
     private pollingManager;

package/dist/lib.cjs/types/Tokens/TokenHandler.d.ts

@@ -1,17 +1,18 @@
-import { BrowserProvider, Contract } from "ethers";
+import { SafeEventEmitterProvider } from "@web3auth/auth";
 export interface ITokenOptions {
     address: string;
     symbol: string;
     decimals: number;
     name: string;
-    provider: BrowserProvider;
+    provider: SafeEventEmitterProvider;
 }
 export declare class TokenHandler {
     address: string;
     symbol: string;
     decimals: number;
     name: string;
-    contract: Contract;
+    provider: SafeEventEmitterProvider;
+    private publicClient;
     constructor({ address, symbol, decimals, name, provider }: ITokenOptions);
     getSymbol(): Promise<string>;
     getDecimals(): Promise<number>;

package/dist/lib.cjs/types/Tokens/TokensController.d.ts

@@ -19,7 +19,7 @@ export interface ITokensControllerOptions {
 export declare class TokensController extends BaseController<EthereumTokensControllerConfig, EthereumTokensControllerState> implements ITokensController<EthereumTokensControllerConfig, EthereumTokensControllerState, CustomTokenInfo> {
     name: string;
     private provider;
-    private ethersProvider;
+    private publicClient;
     private pollingManager;
     private getProviderConfig;
     private getCustomTokens;

package/dist/lib.cjs/types/Transaction/TransactionUtils.d.ts

@@ -54,8 +54,16 @@ export declare function normalizeAndValidateTxParams(txParams: TransactionParams
  */
 export declare function getFinalStates(): TransactionStatus[];
 export declare function parseStandardTokenTransactionData(data: string): {
-    name: string;
-    methodParams: any[];
+    name: "symbol" | "decimals" | "transfer" | "transferFrom" | "approve" | "name" | "totalSupply" | "balanceOf" | "approveAndCall" | "allowance";
+    methodParams: (bigint | `0x${string}`)[];
+    type: string;
+} | {
+    name: "symbol" | "transferFrom" | "approve" | "safeTransferFrom" | "name" | "totalSupply" | "balanceOf" | "supportsInterface" | "getApproved" | "tokenOfOwnerByIndex" | "tokenByIndex" | "ownerOf" | "tokenURI";
+    methodParams: (bigint | `0x${string}`)[];
+    type: string;
+} | {
+    name: "safeTransferFrom" | "setApprovalForAll" | "balanceOf" | "supportsInterface" | "balanceOfBatch" | "isApprovedForAll" | "uri";
+    methodParams: (bigint | boolean | `0x${string}` | readonly `0x${string}`[] | readonly bigint[])[];
     type: string;
 };
 export declare const readAddressAsContract: (provider: SafeEventEmitterProvider, address: string) => Promise<{
@@ -65,7 +73,7 @@ export declare const readAddressAsContract: (provider: SafeEventEmitterProvider,
 export declare function determineTransactionType(txParams: TransactionParams, provider: SafeEventEmitterProvider, overrideTxMeta?: Partial<EthereumTransactionMeta>): Promise<{
     type: string;
     category: string;
-    methodParams: any[];
+    methodParams: unknown[];
     getCodeResponse: string;
 }>;
 /**

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

@@ -15,9 +15,7 @@ export * from "./Message/SwitchChainController";
 export * from "./Message/TypedMessageController";
 export * from "./Message/types";
 export * from "./Message/utils";
-export * from "./Network/createEthereumMiddleware";
-export * from "./Network/createJsonRpcClient";
-export { NetworkController } from "./Network/NetworkController";
+export * from "./Network";
 export * from "./Nfts/INftsController";
 export * from "./Nfts/NftHandler";
 export * from "./Nfts/NftsController";