@toruslabs/ethereum-controllers 9.0.0 → 9.2.0

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

@@ -1,5 +1,6 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import { createFetchMiddleware, PROVIDER_JRPC_METHODS, createGenericJRPCMiddleware } from '@toruslabs/base-controllers';
-import { mergeMiddleware, createScaffoldMiddleware, createAsyncMiddleware } from '@web3auth/auth';
+import { createScaffoldMiddlewareV2, propagateToMutableRequest, JRPCEngineV2, getUniqueId } from '@web3auth/auth';
 import { walletGetUpgradeStatus } from '../Eip7702/walletGetUpgradeStatus.js';
 import { walletUpgradeAccount } from '../Eip7702/walletUpgradeAccount.js';
 import { METHOD_TYPES, TRANSACTION_ENVELOPE_TYPES, BUNDLER_METHOD_TYPES, PAYMASTER_METHOD_TYPES } from '../utils/constants.js';
@@ -10,117 +11,224 @@ import { walletGetCallsStatus } from '../Eip5792/walletGetCallsStatus.js';
 import { walletSendCalls } from '../Eip5792/walletSendCalls.js';
 import { walletGetCapabilities } from '../Eip5792/walletGetCapabilities.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 = TRANSACTION_ENVELOPE_TYPES.FEE_MARKET;
+  } else {
+    formattedTxMeta.gasPrice = gasPrice;
+    formattedTxMeta.type = TRANSACTION_ENVELOPE_TYPES.LEGACY;
+  }
+  return formattedTxMeta;
+}
+function createGetProviderStateMiddleware({
+  getProviderState
+}) {
+  return async ({
+    request,
+    next
+  }) => {
+    if (request.method !== PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE) {
+      await next();
+      return undefined;
+    }
+    const result = await getProviderState();
+    return result;
+  };
+}
 function createGetAccountsMiddleware({
   getAccounts
 }) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.GET_ACCOUNTS) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== 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(propagateToMutableRequest(request, context));
+    return accounts;
+  };
 }
 function createProcessTransactionMiddleware({
   processTransaction
 }) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_TRANSACTION) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== 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 = propagateToMutableRequest(request, context);
+    const result = await processTransaction(mutableRequestClone.params, mutableRequestClone);
+    return result;
+  };
 }
 function createProcessSignTransactionMiddleware({
   processSignTransaction
 }) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_SIGN_TRANSACTION) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== 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 = propagateToMutableRequest(request, context);
+    return await processSignTransaction(mutableRequestClone.params, mutableRequestClone);
+  };
 }
 function createProcessEstimateUserOperationGasMiddleware({
   processEstimateUserOperationGas
 }) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_ESTIMATE_AA_TRANSACTION_GAS) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== 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 = propagateToMutableRequest(request, context);
+    const txParams = mutableReq.params;
+    return processEstimateUserOperationGas(txParams, mutableReq);
+  };
 }
 function createProcessEthSignMessage({
   processEthSignMessage
 }) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_SIGN) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== 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 = 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 createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_SIGN_TYPED_DATA_V4) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== 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 = 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 createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.PERSONAL_SIGN) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== 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 = 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,
@@ -131,174 +239,155 @@ 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 createAsyncMiddleware(async (request, response, next) => {
-    const {
-      params,
-      method
-    } = request;
-    if (method !== 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 !== 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 = propagateToMutableRequest(request, context);
+    return getPendingNonce(params, mutableReq);
   };
-  if (maxFeePerGas && maxPriorityFeePerGas) {
-    formattedTxMeta.maxFeePerGas = maxFeePerGas;
-    formattedTxMeta.maxPriorityFeePerGas = maxPriorityFeePerGas;
-    formattedTxMeta.type = TRANSACTION_ENVELOPE_TYPES.FEE_MARKET;
-  } else {
-    formattedTxMeta.gasPrice = gasPrice;
-    formattedTxMeta.type = TRANSACTION_ENVELOPE_TYPES.LEGACY;
-  }
-  return formattedTxMeta;
 }
 function createPendingTxMiddleware({
   getPendingTransactionByHash
 }) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      params,
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ETH_GET_TRANSACTION_BY_HASH) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== 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 = propagateToMutableRequest(request, context);
+    const txMeta = await getPendingTransactionByHash(request.params, mutableReq);
+    if (!txMeta) return next();
+    return formatTxMetaForRpcResult(txMeta);
+  };
 }
 function createProcessSwitchEthereumChain({
   processSwitchEthereumChain
 }) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.SWITCH_CHAIN) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== 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 = propagateToMutableRequest(request, context);
+    const result = await processSwitchEthereumChain(msgParams, mutableRequestClone);
+    return result;
+  };
 }
 function createProcessWalletSwitchChain({
   processWalletSwitchChain
 }) {
-  return createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== PROVIDER_JRPC_METHODS.WALLET_SWITCH_CHAIN) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== 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 = 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 createAsyncMiddleware(async (request, response, next) => {
-    const {
-      method
-    } = request;
-    if (method !== METHOD_TYPES.ADD_CHAIN) return next();
+  return async ({
+    request,
+    context,
+    next
+  }) => {
+    if (request.method !== 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 = propagateToMutableRequest(request, context);
+    const result = await processAddEthereumChain(msgParams, mutableRequestClone);
+    return result;
+  };
 }
 function createRequestAccountsMiddleware({
   requestAccounts
 }) {
-  return 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(propagateToMutableRequest(request, context));
+    return accounts;
+  };
 }
 
 /**
- * Middleware to handle bundler/paymaster rpc method
+ * Middleware to handle bundler/paymaster rpc methods.
  */
 function createAAMiddleware({
   bundlerUrl,
@@ -306,97 +395,91 @@ 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 (!BUNDLER_METHOD_TYPES.includes(req.method) && !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 = createFetchMiddleware({
     rpcTarget: bundlerUrl,
     providerConfig,
     analytics,
     transactionDecoder
   });
-  middlewares.push(idNumberRemapMiddleware);
-  middlewares.push((request, response, next, end) => {
-    if (!BUNDLER_METHOD_TYPES.includes(request.method)) {
-      return next();
-    }
-    bundlerFetchMiddleware(request, response, next, end);
-  });
-  if (paymasterUrl) {
-    const paymasterFetchMiddleware = createFetchMiddleware({
-      rpcTarget: paymasterUrl,
-      providerConfig,
-      analytics,
-      transactionDecoder
-    });
-    middlewares.push((request, response, next, end) => {
-      if (!PAYMASTER_METHOD_TYPES.includes(request.method)) {
-        return next();
-      }
-      paymasterFetchMiddleware(request, response, next, end);
+  const paymasterFetchMiddleware = paymasterUrl ? createFetchMiddleware({
+    rpcTarget: paymasterUrl,
+    providerConfig,
+    analytics,
+    transactionDecoder
+  }) : null;
+  const idRemapAndBundlerMiddleware = async ({
+    request,
+    next,
+    context
+  }) => {
+    const isBundlerMethod = BUNDLER_METHOD_TYPES.includes(request.method);
+    const isPaymasterMethod = 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: getUniqueId()
     });
-  }
-  return 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 createScaffoldMiddleware({
-    [EIP_7702_METHODS.WALLET_UPGRADE_ACCOUNT]: createAsyncMiddleware(async (request, response, next) => {
-      if (request.method !== EIP_7702_METHODS.WALLET_UPGRADE_ACCOUNT) {
-        return next();
-      }
+  return createScaffoldMiddlewareV2({
+    [EIP_7702_METHODS.WALLET_UPGRADE_ACCOUNT]: async ({
+      request,
+      context,
+      next
+    }) => {
+      if (request.method !== 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(request, getEthCode, processTransaction);
-      response.result = result;
-    }),
-    [EIP_7702_METHODS.WALLET_GET_ACCOUNT_UPGRADE_STATUS]: createAsyncMiddleware(async (request, response, next) => {
-      if (request.method !== EIP_7702_METHODS.WALLET_GET_ACCOUNT_UPGRADE_STATUS) {
-        return next();
-      }
-      if (!getEthCode) {
-        throw new Error("getEthCode not provided");
-      }
-      const result = await walletGetUpgradeStatus(request, getEthCode);
-      response.result = result;
-    })
+
+      // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+      const mutableReq = propagateToMutableRequest(request, context);
+      const result = await walletUpgradeAccount(mutableReq, getEthCode, processTransaction);
+      return result;
+    },
+    [EIP_7702_METHODS.WALLET_GET_ACCOUNT_UPGRADE_STATUS]: async ({
+      request,
+      context,
+      next
+    }) => {
+      if (request.method !== 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 = propagateToMutableRequest(request, context);
+      const result = await 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,
@@ -406,48 +489,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 createScaffoldMiddleware({
-    [EIP_5792_METHODS.WALLET_GET_CAPABILITIES]: createAsyncMiddleware(async (request, response, next) => {
-      if (request.method !== EIP_5792_METHODS.WALLET_GET_CAPABILITIES) {
-        return next();
-      }
-      const result = await walletGetCapabilities(request, getEthCode, getCapabilitiesContext);
-      response.result = result;
-    }),
-    [EIP_5792_METHODS.WALLET_SEND_CALLS]: createAsyncMiddleware(async (request, response, next) => {
-      if (request.method !== EIP_5792_METHODS.WALLET_SEND_CALLS) {
-        return next();
-      }
-      const result = await walletSendCalls(request, getEthCode, sendCallsContext);
-      response.result = result;
-    }),
-    [EIP_5792_METHODS.WALLET_GET_CALLS_STATUS]: createAsyncMiddleware(async (request, response, next) => {
-      if (request.method !== EIP_5792_METHODS.WALLET_GET_CALLS_STATUS) {
-        return next();
-      }
-      const result = walletGetCallsStatus(request, getTransactionByBatchId);
-      response.result = result;
-    })
+  return createScaffoldMiddlewareV2({
+    [EIP_5792_METHODS.WALLET_GET_CAPABILITIES]: async ({
+      request,
+      context,
+      next
+    }) => {
+      if (request.method !== EIP_5792_METHODS.WALLET_GET_CAPABILITIES) return next();
+      // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+      const mutableReq = propagateToMutableRequest(request, context);
+      const result = await walletGetCapabilities(mutableReq, getEthCode, getCapabilitiesContext);
+      return result;
+    },
+    [EIP_5792_METHODS.WALLET_SEND_CALLS]: async ({
+      request,
+      context,
+      next
+    }) => {
+      if (request.method !== EIP_5792_METHODS.WALLET_SEND_CALLS) return next();
+      // Propagate V2 request and context into a mutable V1-like request for handler consumption.
+      const mutableReq = propagateToMutableRequest(request, context);
+      const result = await walletSendCalls(mutableReq, getEthCode, sendCallsContext);
+      return result;
+    },
+    [EIP_5792_METHODS.WALLET_GET_CALLS_STATUS]: async ({
+      request,
+      context,
+      next
+    }) => {
+      if (request.method !== 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 = propagateToMutableRequest(request, context);
+      const result = walletGetCallsStatus(mutableReq, getTransactionByBatchId);
+      return result;
+    }
   });
 }
 function createEthereumMiddleware(providerHandlers, providerConfig, analytics) {
@@ -475,9 +567,11 @@ function createEthereumMiddleware(providerHandlers, providerConfig, analytics) {
     getEthCode,
     eip5792Config
   } = providerHandlers;
-  const middlewares = [createScaffoldMiddleware({
-    version,
-    [PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE]: getProviderState
+  const middlewares = [createScaffoldMiddlewareV2({
+    version: async () => version,
+    [PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE]: createGetProviderStateMiddleware({
+      getProviderState
+    })
   }), createEip7702Middleware({
     getEthCode,
     processTransaction
@@ -514,7 +608,7 @@ function createEthereumMiddleware(providerHandlers, providerConfig, analytics) {
   }), createProcessAddEthereumChain({
     processAddEthereumChain
   })];
-  if (aaConfig) {
+  if (aaConfig && providerConfig) {
     middlewares.push(createAAMiddleware({
       bundlerUrl: aaConfig.bundlerUrl,
       paymasterUrl: aaConfig.paymasterUrl,
@@ -522,7 +616,10 @@ function createEthereumMiddleware(providerHandlers, providerConfig, analytics) {
       analytics
     }));
   }
-  return mergeMiddleware(middlewares);
+  const engine = JRPCEngineV2.create({
+    middleware: middlewares
+  });
+  return engine.asMiddleware();
 }
 
-export { createAAMiddleware, createEip5792Middleware, createEip7702Middleware, createEthereumMiddleware, createGetAccountsMiddleware, createPendingNonceMiddleware, createPendingTxMiddleware, createProcessAddEthereumChain, createProcessEstimateUserOperationGasMiddleware, createProcessEthSignMessage, createProcessPersonalMessage, createProcessSignTransactionMiddleware, createProcessSwitchEthereumChain, createProcessTransactionMiddleware, createProcessTypedMessageV4, createProcessWalletSwitchChain, createRequestAccountsMiddleware, formatTxMetaForRpcResult };
+export { createAAMiddleware, createEip5792Middleware, createEip7702Middleware, createEthereumMiddleware, createGetAccountsMiddleware, createGetProviderStateMiddleware, createPendingNonceMiddleware, createPendingTxMiddleware, createProcessAddEthereumChain, createProcessEstimateUserOperationGasMiddleware, createProcessEthSignMessage, createProcessPersonalMessage, createProcessSignTransactionMiddleware, createProcessSwitchEthereumChain, createProcessTransactionMiddleware, createProcessTypedMessageV4, createProcessWalletSwitchChain, createRequestAccountsMiddleware, formatTxMetaForRpcResult };