@toruslabs/ethereum-controllers 9.0.0 → 9.2.0

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

@@ -1,5 +1,6 @@
 'use strict';
 
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
 var baseControllers = require('@toruslabs/base-controllers');
 var auth = require('@web3auth/auth');
 var walletGetCallsStatus = require('../Eip5792/walletGetCallsStatus.js');
@@ -12,117 +13,219 @@ var eip5792Types = require('../utils/eip5792Types.js');
 var eip7702Types = require('../utils/eip7702Types.js');
 var transaction = require('../utils/transaction.js');
 
+function formatTxMetaForRpcResult(txMeta) {
+  const {
+    r,
+    s,
+    v,
+    txReceipt,
+    transaction,
+    transactionHash,
+    accessList
+  } = txMeta;
+  const {
+    to,
+    data,
+    nonce,
+    gas,
+    from,
+    value,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas
+  } = transaction;
+  const formattedTxMeta = {
+    v,
+    r,
+    s,
+    to,
+    gas,
+    from,
+    hash: transactionHash,
+    nonce,
+    input: data || "0x",
+    value: value || "0x0",
+    accessList: accessList || null,
+    blockHash: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.blockHash) || null,
+    blockNumber: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.blockNumber) || null,
+    transactionIndex: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.transactionIndex) || null,
+    type: null
+  };
+  if (maxFeePerGas && maxPriorityFeePerGas) {
+    formattedTxMeta.maxFeePerGas = maxFeePerGas;
+    formattedTxMeta.maxPriorityFeePerGas = maxPriorityFeePerGas;
+    formattedTxMeta.type = constants.TRANSACTION_ENVELOPE_TYPES.FEE_MARKET;
+  } else {
+    formattedTxMeta.gasPrice = gasPrice;
+    formattedTxMeta.type = constants.TRANSACTION_ENVELOPE_TYPES.LEGACY;
+  }
+  return formattedTxMeta;
+}
+function createGetProviderStateMiddleware({
+  getProviderState
+}) {
+  return async ({
+    request,
+    next
+  }) => {
+    if (request.method !== baseControllers.PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE) {
+      await next();
+      return undefined;
+    }
+    const result = await getProviderState();
+    return result;
+  };
+}
 function createGetAccountsMiddleware({
   getAccounts
 }) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== constants.METHOD_TYPES.GET_ACCOUNTS) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== constants.METHOD_TYPES.GET_ACCOUNTS) {
+      await next();
+      return undefined;
+    }
     if (!getAccounts) throw new Error("WalletMiddleware - opts.getAccounts not provided");
-    const accounts = await getAccounts(request);
-    response.result = accounts;
-  });
+    // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+    const accounts = await getAccounts(auth.propagateToMutableRequest(request, context));
+    return accounts;
+  };
 }
 function createProcessTransactionMiddleware({
   processTransaction
 }) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== constants.METHOD_TYPES.ETH_TRANSACTION) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== constants.METHOD_TYPES.ETH_TRANSACTION) {
+      await next();
+      return undefined;
+    }
     if (!processTransaction) throw new Error("WalletMiddleware - opts.processTransaction not provided");
-    response.result = await processTransaction(request.params, request);
-  });
+    // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+    const mutableRequestClone = auth.propagateToMutableRequest(request, context);
+    const result = await processTransaction(mutableRequestClone.params, mutableRequestClone);
+    return result;
+  };
 }
 function createProcessSignTransactionMiddleware({
   processSignTransaction
 }) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== constants.METHOD_TYPES.ETH_SIGN_TRANSACTION) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== constants.METHOD_TYPES.ETH_SIGN_TRANSACTION) {
+      await next();
+      return undefined;
+    }
     if (!processSignTransaction) throw new Error("WalletMiddleware - opts.processSignTransaction not provided");
-    response.result = await processSignTransaction(request.params, request);
-  });
+    // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+    const mutableRequestClone = auth.propagateToMutableRequest(request, context);
+    return await processSignTransaction(mutableRequestClone.params, mutableRequestClone);
+  };
 }
 function createProcessEstimateUserOperationGasMiddleware({
   processEstimateUserOperationGas
 }) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== constants.METHOD_TYPES.ETH_ESTIMATE_AA_TRANSACTION_GAS) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== constants.METHOD_TYPES.ETH_ESTIMATE_AA_TRANSACTION_GAS) {
+      await next();
+      return undefined;
+    }
     if (!processEstimateUserOperationGas) throw new Error("WalletMiddleware - opts.processEstimateUserOperationGas not provided");
-    response.result = await processEstimateUserOperationGas(request.params, request);
-  });
+    // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+    const mutableReq = auth.propagateToMutableRequest(request, context);
+    const txParams = mutableReq.params;
+    return processEstimateUserOperationGas(txParams, mutableReq);
+  };
 }
 function createProcessEthSignMessage({
   processEthSignMessage
 }) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== constants.METHOD_TYPES.ETH_SIGN) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== constants.METHOD_TYPES.ETH_SIGN) {
+      await next();
+      return undefined;
+    }
     if (!processEthSignMessage) throw new Error("WalletMiddleware - opts.processEthSignMessage not provided");
     if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
-    let msgParams = request.params;
+    // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+    const mutableRequestClone = auth.propagateToMutableRequest(request, context);
+    let msgParams = mutableRequestClone.params;
     if (Array.isArray(request.params)) {
-      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address, message]`);
+      if (request.params.length !== 2) throw new Error(`WalletMiddleware - incorrect params for ${request.method} method. expected [address, message]`);
       const params = request.params;
-      const address = params[0];
-      const message = params[1];
       msgParams = {
-        from: address,
-        data: message
+        from: params[0],
+        data: params[1]
       };
     }
-    response.result = await processEthSignMessage(msgParams, request);
-  });
+    return processEthSignMessage(msgParams, mutableRequestClone);
+  };
 }
 function createProcessTypedMessageV4({
   processTypedMessageV4
 }) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== constants.METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== constants.METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4) {
+      await next();
+      return undefined;
+    }
     if (!processTypedMessageV4) throw new Error("WalletMiddleware - opts.processTypedMessageV4 is not provided");
     if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
-    let msgParams = request.params;
-    if (Array.isArray(request.params)) {
-      if (!(request.params.length === 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [address, typedData]`);
-      const params = request.params;
-      const address = params[0];
-      const message = params[1];
+    // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+    const mutableRequestClone = auth.propagateToMutableRequest(request, context);
+    let msgParams = mutableRequestClone.params;
+    if (Array.isArray(mutableRequestClone.params)) {
+      if (mutableRequestClone.params.length !== 2) throw new Error(`WalletMiddleware - incorrect params for ${request.method} method. expected [address, typedData]`);
+      const params = mutableRequestClone.params;
       msgParams = {
-        from: address,
-        data: message
+        from: params[0],
+        data: params[1]
       };
     }
-    response.result = await processTypedMessageV4(msgParams, request);
-  });
+    return processTypedMessageV4(msgParams, mutableRequestClone);
+  };
 }
 function createProcessPersonalMessage({
   processPersonalMessage
 }) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== constants.METHOD_TYPES.PERSONAL_SIGN) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== constants.METHOD_TYPES.PERSONAL_SIGN) {
+      await next();
+      return undefined;
+    }
     if (!processPersonalMessage) throw new Error("WalletMiddleware - opts.processPersonalMessage is not provided");
     if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
-    let msgParams = request.params;
-    if (Array.isArray(request.params)) {
-      if (!(request.params.length >= 2)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [message, address]`);
-      const params = request.params;
+    // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+    const mutableRequestClone = auth.propagateToMutableRequest(request, context);
+    let msgParams = mutableRequestClone.params;
+    if (Array.isArray(mutableRequestClone.params)) {
+      if (mutableRequestClone.params.length < 2) throw new Error(`WalletMiddleware - incorrect params for ${mutableRequestClone.method} method. expected [message, address]`);
+      const params = mutableRequestClone.params;
       if (typeof params[0] === "object") {
         const {
           challenge,
@@ -133,173 +236,149 @@ function createProcessPersonalMessage({
           data: challenge
         };
       } else {
-        const message = params[0];
-        const address = params[1];
         msgParams = {
-          from: address,
-          data: message
+          from: params[1],
+          data: params[0]
         };
       }
     }
-    response.result = await processPersonalMessage(msgParams, request);
-  });
+    return processPersonalMessage(msgParams, mutableRequestClone);
+  };
 }
 function createPendingNonceMiddleware({
   getPendingNonce
 }) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      params,
-      method
-    } = request;
-    if (method !== constants.METHOD_TYPES.ETH_GET_TRANSACTION_COUNT) return next();
-    const {
-      blockReference
-    } = params;
-    if (blockReference !== "pending") return next();
-    response.result = await getPendingNonce(params, request);
-  });
-}
-function formatTxMetaForRpcResult(txMeta) {
-  const {
-    r,
-    s,
-    v,
-    txReceipt,
-    transaction,
-    transactionHash,
-    accessList
-  } = txMeta;
-  const {
-    to,
-    data,
-    nonce,
-    gas,
-    from,
-    value,
-    gasPrice,
-    maxFeePerGas,
-    maxPriorityFeePerGas
-  } = transaction;
-  const formattedTxMeta = {
-    v,
-    r,
-    s,
-    to,
-    gas,
-    from,
-    hash: transactionHash,
-    nonce,
-    input: data || "0x",
-    value: value || "0x0",
-    accessList: accessList || null,
-    blockHash: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.blockHash) || null,
-    blockNumber: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.blockNumber) || null,
-    transactionIndex: (txReceipt === null || txReceipt === void 0 ? void 0 : txReceipt.transactionIndex) || null,
-    type: null
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== constants.METHOD_TYPES.ETH_GET_TRANSACTION_COUNT) {
+      await next();
+      return undefined;
+    }
+    const params = request.params;
+    if (params.blockReference !== "pending") {
+      await next();
+      return undefined;
+    }
+    // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+    const mutableReq = auth.propagateToMutableRequest(request, context);
+    return getPendingNonce(params, mutableReq);
   };
-  if (maxFeePerGas && maxPriorityFeePerGas) {
-    formattedTxMeta.maxFeePerGas = maxFeePerGas;
-    formattedTxMeta.maxPriorityFeePerGas = maxPriorityFeePerGas;
-    formattedTxMeta.type = constants.TRANSACTION_ENVELOPE_TYPES.FEE_MARKET;
-  } else {
-    formattedTxMeta.gasPrice = gasPrice;
-    formattedTxMeta.type = constants.TRANSACTION_ENVELOPE_TYPES.LEGACY;
-  }
-  return formattedTxMeta;
 }
 function createPendingTxMiddleware({
   getPendingTransactionByHash
 }) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      params,
-      method
-    } = request;
-    if (method !== constants.METHOD_TYPES.ETH_GET_TRANSACTION_BY_HASH) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== constants.METHOD_TYPES.ETH_GET_TRANSACTION_BY_HASH) return next();
     if (!getPendingTransactionByHash) throw new Error("WalletMiddleware - opts.getPendingTransactionByHash not provided");
-    const txMeta = await getPendingTransactionByHash(params, request);
-    if (!txMeta) {
-      return next();
-    }
-    response.result = formatTxMetaForRpcResult(txMeta);
-    return undefined;
-  });
+    // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+    const mutableReq = auth.propagateToMutableRequest(request, context);
+    const txMeta = await getPendingTransactionByHash(request.params, mutableReq);
+    if (!txMeta) return next();
+    return formatTxMetaForRpcResult(txMeta);
+  };
 }
 function createProcessSwitchEthereumChain({
   processSwitchEthereumChain
 }) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== constants.METHOD_TYPES.SWITCH_CHAIN) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== constants.METHOD_TYPES.SWITCH_CHAIN) {
+      await next();
+      return undefined;
+    }
     if (!processSwitchEthereumChain) throw new Error("WalletMiddleware - opts.processSwitchEthereumChain not provided");
     if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
     let msgParams = request.params;
     if (Array.isArray(request.params)) {
-      if (!(request.params.length === 1)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [data]`);
-      const [message] = request.params;
-      msgParams = message;
+      if (request.params.length !== 1) throw new Error(`WalletMiddleware - incorrect params for ${request.method} method. expected [data]`);
+      [msgParams] = request.params;
     }
-    response.result = await processSwitchEthereumChain(msgParams, request);
-  });
+    // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+    const mutableRequestClone = auth.propagateToMutableRequest(request, context);
+    const result = await processSwitchEthereumChain(msgParams, mutableRequestClone);
+    return result;
+  };
 }
 function createProcessWalletSwitchChain({
   processWalletSwitchChain
 }) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== baseControllers.PROVIDER_JRPC_METHODS.WALLET_SWITCH_CHAIN) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== baseControllers.PROVIDER_JRPC_METHODS.WALLET_SWITCH_CHAIN) {
+      await next();
+      return undefined;
+    }
     if (!processWalletSwitchChain) throw new Error("WalletMiddleware - opts.processWalletSwitchChain not provided");
     if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
-    let msgParams = request.params;
-    if (Array.isArray(request.params)) {
-      if (!(request.params.length === 1)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [data]`);
-      const [message] = request.params;
-      msgParams = message;
+    // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+    const mutableRequestClone = auth.propagateToMutableRequest(request, context);
+    let msgParams = mutableRequestClone.params;
+    if (Array.isArray(mutableRequestClone.params)) {
+      if (mutableRequestClone.params.length !== 1) throw new Error(`WalletMiddleware - incorrect params for ${request.method} method. expected [data]`);
+      [msgParams] = mutableRequestClone.params;
     }
-    response.result = await processWalletSwitchChain(msgParams, request);
-  });
+    const result = await processWalletSwitchChain(msgParams, mutableRequestClone);
+    return result;
+  };
 }
 function createProcessAddEthereumChain({
   processAddEthereumChain
 }) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== constants.METHOD_TYPES.ADD_CHAIN) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== constants.METHOD_TYPES.ADD_CHAIN) {
+      await next();
+      return undefined;
+    }
     if (!processAddEthereumChain) throw new Error("WalletMiddleware - opts.processAddEthereumChain not provided");
     if (!(request !== null && request !== void 0 && request.params)) throw new Error("WalletMiddleware - missing params");
     let msgParams = request.params;
     if (Array.isArray(request.params)) {
-      if (!(request.params.length === 1)) throw new Error(`WalletMiddleware - incorrect params for ${method} method. expected [data]`);
-      const [message] = request.params;
-      msgParams = message;
+      if (request.params.length !== 1) throw new Error(`WalletMiddleware - incorrect params for ${request.method} method. expected [data]`);
+      [msgParams] = request.params;
     }
-    response.result = await processAddEthereumChain(msgParams, request);
-  });
+    // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+    const mutableRequestClone = auth.propagateToMutableRequest(request, context);
+    const result = await processAddEthereumChain(msgParams, mutableRequestClone);
+    return result;
+  };
 }
 function createRequestAccountsMiddleware({
   requestAccounts
 }) {
-  return auth.createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== "eth_requestAccounts") return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== "eth_requestAccounts") {
+      await next();
+      return undefined;
+    }
     if (!requestAccounts) throw new Error("WalletMiddleware - opts.requestAccounts not provided");
-    // This calls the UI login function
-    const accounts = await requestAccounts(request);
-    response.result = accounts;
-    return undefined;
-  });
+    // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+    const accounts = await requestAccounts(auth.propagateToMutableRequest(request, context));
+    return accounts;
+  };
 }
 /**
- * Middleware to handle bundler/paymaster rpc method
+ * Middleware to handle bundler/paymaster rpc methods.
  */
 function createAAMiddleware({
   bundlerUrl,
@@ -307,94 +386,86 @@ function createAAMiddleware({
   providerConfig,
   analytics
 }) {
-  // forward request to bundler/paymaster
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const middlewares = [];
-  // NOTE: bundler/paymaster rpc only accept number as request id, we need to handle that here if client doesn't handle request id themselves
-  const idNumberRemapMiddleware = (req, res, next, _end) => {
-    // skip if not bundler/paymaster methods
-    if (!constants.BUNDLER_METHOD_TYPES.includes(req.method) && !constants.PAYMASTER_METHOD_TYPES.includes(req.method)) {
-      return next();
-    }
-    const originalId = req.id;
-    const newId = Math.floor(Math.random() * 1000000);
-    req.id = newId;
-    res.id = newId;
-    next(done => {
-      req.id = originalId;
-      res.id = originalId;
-      done();
-    });
-  };
   const bundlerFetchMiddleware = baseControllers.createFetchMiddleware({
     rpcTarget: bundlerUrl,
     providerConfig,
     analytics,
     transactionDecoder: transaction.transactionDecoder
   });
-  middlewares.push(idNumberRemapMiddleware);
-  middlewares.push((request, response, next, end) => {
-    if (!constants.BUNDLER_METHOD_TYPES.includes(request.method)) {
-      return next();
-    }
-    bundlerFetchMiddleware(request, response, next, end);
-  });
-  if (paymasterUrl) {
-    const paymasterFetchMiddleware = baseControllers.createFetchMiddleware({
-      rpcTarget: paymasterUrl,
-      providerConfig,
-      analytics,
-      transactionDecoder: transaction.transactionDecoder
-    });
-    middlewares.push((request, response, next, end) => {
-      if (!constants.PAYMASTER_METHOD_TYPES.includes(request.method)) {
-        return next();
-      }
-      paymasterFetchMiddleware(request, response, next, end);
+  const paymasterFetchMiddleware = paymasterUrl ? baseControllers.createFetchMiddleware({
+    rpcTarget: paymasterUrl,
+    providerConfig,
+    analytics,
+    transactionDecoder: transaction.transactionDecoder
+  }) : null;
+  const idRemapAndBundlerMiddleware = async ({
+    request,
+    next,
+    context
+  }) => {
+    const isBundlerMethod = constants.BUNDLER_METHOD_TYPES.includes(request.method);
+    const isPaymasterMethod = constants.PAYMASTER_METHOD_TYPES.includes(request.method);
+    if (!isBundlerMethod && !isPaymasterMethod) return next();
+    // Bundler/paymaster RPCs only accept numeric request IDs.
+    // Request is Readonly, so we create a shallow copy with a remapped ID.
+    const remappedRequest = _objectSpread(_objectSpread({}, request), {}, {
+      id: auth.getUniqueId()
     });
-  }
-  return auth.mergeMiddleware(middlewares);
+    if (isBundlerMethod) {
+      return bundlerFetchMiddleware({
+        request: remappedRequest,
+        next,
+        context
+      });
+    }
+    if (isPaymasterMethod && paymasterFetchMiddleware) {
+      return paymasterFetchMiddleware({
+        request: remappedRequest,
+        next,
+        context
+      });
+    }
+    return next();
+  };
+  return idRemapAndBundlerMiddleware;
 }
 /**
  * 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
  */
 function createEip7702Middleware({
   getEthCode,
   processTransaction
 }) {
-  return auth.createScaffoldMiddleware({
-    [eip7702Types.EIP_7702_METHODS.WALLET_UPGRADE_ACCOUNT]: auth.createAsyncMiddleware(async (request, response, next) => {
-      if (request.method !== eip7702Types.EIP_7702_METHODS.WALLET_UPGRADE_ACCOUNT) {
-        return next();
-      }
+  return auth.createScaffoldMiddlewareV2({
+    [eip7702Types.EIP_7702_METHODS.WALLET_UPGRADE_ACCOUNT]: async ({
+      request,
+      context,
+      next
+    }) => {
+      if (request.method !== eip7702Types.EIP_7702_METHODS.WALLET_UPGRADE_ACCOUNT) return next();
       if (!getEthCode) throw new Error("WalletMiddleware - opts.getEthCode not provided");
       if (!processTransaction) throw new Error("WalletMiddleware - opts.processTransaction not provided");
-      const result = await walletUpgradeAccount.walletUpgradeAccount(request, getEthCode, processTransaction);
-      response.result = result;
-    }),
-    [eip7702Types.EIP_7702_METHODS.WALLET_GET_ACCOUNT_UPGRADE_STATUS]: auth.createAsyncMiddleware(async (request, response, next) => {
-      if (request.method !== eip7702Types.EIP_7702_METHODS.WALLET_GET_ACCOUNT_UPGRADE_STATUS) {
-        return next();
-      }
-      if (!getEthCode) {
-        throw new Error("getEthCode not provided");
-      }
-      const result = await walletGetUpgradeStatus.walletGetUpgradeStatus(request, getEthCode);
-      response.result = result;
-    })
+      // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+      const mutableReq = auth.propagateToMutableRequest(request, context);
+      const result = await walletUpgradeAccount.walletUpgradeAccount(mutableReq, getEthCode, processTransaction);
+      return result;
+    },
+    [eip7702Types.EIP_7702_METHODS.WALLET_GET_ACCOUNT_UPGRADE_STATUS]: async ({
+      request,
+      context,
+      next
+    }) => {
+      if (request.method !== eip7702Types.EIP_7702_METHODS.WALLET_GET_ACCOUNT_UPGRADE_STATUS) return next();
+      if (!getEthCode) throw new Error("getEthCode not provided");
+      // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+      const mutableReq = auth.propagateToMutableRequest(request, context);
+      const result = await walletGetUpgradeStatus.walletGetUpgradeStatus(mutableReq, getEthCode);
+      return result;
+    }
   });
 }
 /**
  * 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
  */
 function createEip5792Middleware({
   eip5792Config,
@@ -404,46 +475,57 @@ function createEip5792Middleware({
   getEthCode
 }) {
   if (!eip5792Config) {
-    // Return a pass-through middleware if EIP-5792 is not configured
-    return (_req, _res, next) => next();
+    return async ({
+      next
+    }) => next();
   }
   const {
     getSupportedChains,
     getCachedDelegations,
     updateDelegationCache
   } = eip5792Config;
-  // Context for wallet_getCapabilities
   const getCapabilitiesContext = {
     getSupportedChains,
     getCachedDelegations,
     updateDelegationCache
   };
-  // Context for wallet_sendCalls
   const sendCallsContext = {
     processTransactionBatch
   };
-  return auth.createScaffoldMiddleware({
-    [eip5792Types.EIP_5792_METHODS.WALLET_GET_CAPABILITIES]: auth.createAsyncMiddleware(async (request, response, next) => {
-      if (request.method !== eip5792Types.EIP_5792_METHODS.WALLET_GET_CAPABILITIES) {
-        return next();
-      }
-      const result = await walletGetCapabilities.walletGetCapabilities(request, getEthCode, getCapabilitiesContext);
-      response.result = result;
-    }),
-    [eip5792Types.EIP_5792_METHODS.WALLET_SEND_CALLS]: auth.createAsyncMiddleware(async (request, response, next) => {
-      if (request.method !== eip5792Types.EIP_5792_METHODS.WALLET_SEND_CALLS) {
-        return next();
-      }
-      const result = await walletSendCalls.walletSendCalls(request, getEthCode, sendCallsContext);
-      response.result = result;
-    }),
-    [eip5792Types.EIP_5792_METHODS.WALLET_GET_CALLS_STATUS]: auth.createAsyncMiddleware(async (request, response, next) => {
-      if (request.method !== eip5792Types.EIP_5792_METHODS.WALLET_GET_CALLS_STATUS) {
-        return next();
-      }
-      const result = walletGetCallsStatus.walletGetCallsStatus(request, getTransactionByBatchId);
-      response.result = result;
-    })
+  return auth.createScaffoldMiddlewareV2({
+    [eip5792Types.EIP_5792_METHODS.WALLET_GET_CAPABILITIES]: async ({
+      request,
+      context,
+      next
+    }) => {
+      if (request.method !== eip5792Types.EIP_5792_METHODS.WALLET_GET_CAPABILITIES) return next();
+      // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+      const mutableReq = auth.propagateToMutableRequest(request, context);
+      const result = await walletGetCapabilities.walletGetCapabilities(mutableReq, getEthCode, getCapabilitiesContext);
+      return result;
+    },
+    [eip5792Types.EIP_5792_METHODS.WALLET_SEND_CALLS]: async ({
+      request,
+      context,
+      next
+    }) => {
+      if (request.method !== eip5792Types.EIP_5792_METHODS.WALLET_SEND_CALLS) return next();
+      // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+      const mutableReq = auth.propagateToMutableRequest(request, context);
+      const result = await walletSendCalls.walletSendCalls(mutableReq, getEthCode, sendCallsContext);
+      return result;
+    },
+    [eip5792Types.EIP_5792_METHODS.WALLET_GET_CALLS_STATUS]: async ({
+      request,
+      context,
+      next
+    }) => {
+      if (request.method !== eip5792Types.EIP_5792_METHODS.WALLET_GET_CALLS_STATUS) return next();
+      // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+      const mutableReq = auth.propagateToMutableRequest(request, context);
+      const result = walletGetCallsStatus.walletGetCallsStatus(mutableReq, getTransactionByBatchId);
+      return result;
+    }
   });
 }
 function createEthereumMiddleware(providerHandlers, providerConfig, analytics) {
@@ -471,9 +553,11 @@ function createEthereumMiddleware(providerHandlers, providerConfig, analytics) {
     getEthCode,
     eip5792Config
   } = providerHandlers;
-  const middlewares = [auth.createScaffoldMiddleware({
-    version,
-    [baseControllers.PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE]: getProviderState
+  const middlewares = [auth.createScaffoldMiddlewareV2({
+    version: async () => version,
+    [baseControllers.PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE]: createGetProviderStateMiddleware({
+      getProviderState
+    })
   }), createEip7702Middleware({
     getEthCode,
     processTransaction
@@ -510,7 +594,7 @@ function createEthereumMiddleware(providerHandlers, providerConfig, analytics) {
   }), createProcessAddEthereumChain({
     processAddEthereumChain
   })];
-  if (aaConfig) {
+  if (aaConfig && providerConfig) {
     middlewares.push(createAAMiddleware({
       bundlerUrl: aaConfig.bundlerUrl,
       paymasterUrl: aaConfig.paymasterUrl,
@@ -518,7 +602,10 @@ function createEthereumMiddleware(providerHandlers, providerConfig, analytics) {
       analytics
     }));
   }
-  return auth.mergeMiddleware(middlewares);
+  const engine = auth.JRPCEngineV2.create({
+    middleware: middlewares
+  });
+  return engine.asMiddleware();
 }
 
 exports.createAAMiddleware = createAAMiddleware;
@@ -526,6 +613,7 @@ exports.createEip5792Middleware = createEip5792Middleware;
 exports.createEip7702Middleware = createEip7702Middleware;
 exports.createEthereumMiddleware = createEthereumMiddleware;
 exports.createGetAccountsMiddleware = createGetAccountsMiddleware;
+exports.createGetProviderStateMiddleware = createGetProviderStateMiddleware;
 exports.createPendingNonceMiddleware = createPendingNonceMiddleware;
 exports.createPendingTxMiddleware = createPendingTxMiddleware;
 exports.createProcessAddEthereumChain = createProcessAddEthereumChain;