@toruslabs/ethereum-controllers 8.16.0 → 8.17.0

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

@@ -0,0 +1,56 @@
+import { rpcErrors } from '@web3auth/auth';
+import { TRANSACTION_ENVELOPE_TYPES } from '../utils/constants.js';
+import { getIsEip7702UpgradeSupported } from './eip7702Utils.js';
+
+/**
+ * Handle and prepare the transaction to upgrade an EOA to the EIP-7702 smart account.
+ *
+ * @param req - The request object.
+ * @param getEthCode - The function to get the code of an account.
+ * @param processTransaction - The function to process a transaction.
+ * @returns The transaction hash.
+ */
+async function walletUpgradeAccount(req, getEthCode, processTransaction) {
+  const {
+    method,
+    params
+  } = req;
+  if (method !== "wallet_upgradeAccount") {
+    return;
+  }
+  const upgradeAccountParam = Array.isArray(params) ? params[0] : params;
+  const account = upgradeAccountParam.account;
+  const chainId = upgradeAccountParam.chainId;
+  if (!account || !chainId) {
+    throw rpcErrors.invalidParams("wallet_upgradeAccount: account and chainId are required");
+  }
+  const {
+    isSupported,
+    upgradeContractAddress,
+    delegationAddress
+  } = await getIsEip7702UpgradeSupported(account, chainId, getEthCode);
+  if (!isSupported) {
+    throw rpcErrors.methodNotSupported(`Account upgrade is not supported for chain ${chainId}`);
+  }
+  if (!upgradeContractAddress) {
+    throw rpcErrors.internal({
+      message: `Upgrade contract address not found for chain ${chainId}`
+    });
+  }
+  const isAlreadyUpgraded = Boolean(delegationAddress);
+  if (isAlreadyUpgraded) {
+    throw rpcErrors.invalidParams(`Account is already upgraded for chain ${chainId}`);
+  }
+  return processTransaction({
+    from: account,
+    to: account,
+    type: TRANSACTION_ENVELOPE_TYPES.SET_CODE,
+    // Type 4 transaction
+    authorizationList: [{
+      address: upgradeContractAddress,
+      chainId
+    }]
+  }, req);
+}
+
+export { walletUpgradeAccount };

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

@@ -1,6 +1,8 @@
+import { encode } from '@ethereumjs/rlp';
 import { addHexPrefix, bytesToHex, privateToPublic, toChecksumAddress, privateToAddress, stripHexPrefix, bigIntToBytes, isHexString } from '@ethereumjs/util';
 import { BaseKeyringController, ecsignature, concatSig } from '@toruslabs/base-controllers';
-import { SigningKey, hashMessage, TypedDataEncoder } from 'ethers';
+import { SigningKey, concat, keccak256, hashMessage, TypedDataEncoder } from 'ethers';
+import { toHex } from 'viem';
 
 class KeyringController extends BaseKeyringController {
   constructor({
@@ -23,24 +25,60 @@ class KeyringController extends BaseKeyringController {
     localTx.signature = privKey.sign(localTx.unsignedHash);
     return localTx;
   }
+  async signEip7702Authorization(authorization, address) {
+    const wallet = this._getWalletForAccount(address);
+    const privKey = new SigningKey(addHexPrefix(wallet.privateKey));
+
+    // Convert hex strings to proper types for RLP encoding
+    // EIP-7702 authorization tuple: [chain_id_decimal, address, nonce_decimal]
+    const chainIdDecimal = parseInt(authorization.chainId, 16);
+    const nonceDecimal = parseInt(authorization.nonce, 16);
+
+    // RLP encode the eip7702 authorization
+    const encodedAuthorization = encode([chainIdDecimal, authorization.address, nonceDecimal]);
+    // Prefixed with EIP7702 Domain Separator (0x05)
+    const prefixedAuthorization = concat(["0x05", encodedAuthorization]);
+    const authorizationHash = keccak256(prefixedAuthorization);
+    const {
+      r,
+      s,
+      v
+    } = privKey.sign(authorizationHash);
+    const signedAuthorization = {
+      address: authorization.address,
+      chainId: authorization.chainId,
+      nonce: authorization.nonce,
+      r: addHexPrefix(r),
+      s: addHexPrefix(s),
+      yParity: toHex(v - 27 === 0 ? 0 : 1)
+    };
+    return signedAuthorization;
+  }
   getAccounts() {
     return this.state.wallets.map(w => w.publicKey);
   }
   importAccount(accountPrivateKey) {
-    const hexPrivateKey = accountPrivateKey.padStart(64, "0");
-    const bufferPrivKey = Buffer.from(hexPrivateKey, "hex");
-    const publicKey = bytesToHex(privateToPublic(bufferPrivKey));
-    const address = toChecksumAddress(bytesToHex(privateToAddress(bufferPrivKey)));
-    const existingWallet = this.state.wallets.find(w => w.address === address);
-    if (existingWallet) return existingWallet.address;
-    this.update({
-      wallets: [...this.state.wallets, {
-        publicKey,
-        privateKey: accountPrivateKey,
-        address
-      }]
-    });
-    return address;
+    try {
+      const hexPrivateKey = accountPrivateKey.padStart(64, "0");
+      const bufferPrivKey = Buffer.from(hexPrivateKey, "hex");
+      const publicKey = bytesToHex(privateToPublic(bufferPrivKey));
+      const address = toChecksumAddress(bytesToHex(privateToAddress(bufferPrivKey)));
+      const existingWallet = this.state.wallets.find(w => w.address === address);
+      if (existingWallet) return existingWallet.address;
+      this.update({
+        wallets: [...this.state.wallets, {
+          publicKey,
+          privateKey: accountPrivateKey,
+          address
+        }]
+      });
+      return address;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("expected 32 bytes")) {
+        throw new Error("invalid private key, expected hex or");
+      }
+      throw error;
+    }
   }
   removeAccount(address) {
     const newWallets = [...this.state.wallets];

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

@@ -1,7 +1,14 @@
 import { PROVIDER_JRPC_METHODS, createFetchMiddleware, createGenericJRPCMiddleware } from '@toruslabs/base-controllers';
 import { createAsyncMiddleware, mergeMiddleware, createScaffoldMiddleware } 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';
+import { EIP_5792_METHODS } from '../utils/eip5792Types.js';
+import { EIP_7702_METHODS } from '../utils/eip7702Types.js';
 import { transactionDecoder } from '../utils/transaction.js';
+import { walletGetCallsStatus } from '../Eip5792/walletGetCallsStatus.js';
+import { walletSendCalls } from '../Eip5792/walletSendCalls.js';
+import { walletGetCapabilities } from '../Eip5792/walletGetCapabilities.js';
 
 function createGetAccountsMiddleware({
   getAccounts
@@ -348,6 +355,101 @@ function createAAMiddleware({
   }
   return mergeMiddleware(middlewares);
 }
+
+/**
+ * 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();
+      }
+      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;
+    })
+  });
+}
+
+/**
+ * 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,
+  processTransaction,
+  processTransactionBatch,
+  getTransactionByBatchId,
+  getEthCode
+}) {
+  if (!eip5792Config) {
+    // Return a pass-through middleware if EIP-5792 is not configured
+    return (_req, _res, 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;
+    })
+  });
+}
 function createEthereumMiddleware(providerHandlers, providerConfig, analytics) {
   const {
     requestAccounts,
@@ -355,6 +457,7 @@ function createEthereumMiddleware(providerHandlers, providerConfig, analytics) {
     getPrivateKey,
     getPublicKey,
     processTransaction,
+    processTransactionBatch,
     processSignTransaction,
     processEstimateUserOperationGas,
     processEthSignMessage,
@@ -362,16 +465,28 @@ function createEthereumMiddleware(providerHandlers, providerConfig, analytics) {
     processPersonalMessage,
     getPendingNonce,
     getPendingTransactionByHash,
+    getTransactionByBatchId,
     processSwitchEthereumChain,
     processWalletSwitchChain,
     processAddEthereumChain,
     getProviderState,
     aaConfig,
-    version
+    version,
+    getEthCode,
+    eip5792Config
   } = providerHandlers;
   const middlewares = [createScaffoldMiddleware({
     version,
     [PROVIDER_JRPC_METHODS.GET_PROVIDER_STATE]: getProviderState
+  }), createEip7702Middleware({
+    getEthCode,
+    processTransaction
+  }), createEip5792Middleware({
+    eip5792Config,
+    processTransaction,
+    processTransactionBatch,
+    getEthCode,
+    getTransactionByBatchId
   }), createRequestAccountsMiddleware({
     requestAccounts
   }), createGetAccountsMiddleware({
@@ -410,4 +525,4 @@ function createEthereumMiddleware(providerHandlers, providerConfig, analytics) {
   return mergeMiddleware(middlewares);
 }
 
-export { createAAMiddleware, createEthereumMiddleware, createGetAccountsMiddleware, createPendingNonceMiddleware, createPendingTxMiddleware, createProcessAddEthereumChain, createProcessEstimateUserOperationGasMiddleware, createProcessEthSignMessage, createProcessPersonalMessage, createProcessSignTransactionMiddleware, createProcessSwitchEthereumChain, createProcessTransactionMiddleware, createProcessTypedMessageV4, createProcessWalletSwitchChain, createRequestAccountsMiddleware, formatTxMetaForRpcResult };
+export { createAAMiddleware, createEip5792Middleware, createEip7702Middleware, createEthereumMiddleware, createGetAccountsMiddleware, createPendingNonceMiddleware, createPendingTxMiddleware, createProcessAddEthereumChain, createProcessEstimateUserOperationGasMiddleware, createProcessEthSignMessage, createProcessPersonalMessage, createProcessSignTransactionMiddleware, createProcessSwitchEthereumChain, createProcessTransactionMiddleware, createProcessTypedMessageV4, createProcessWalletSwitchChain, createRequestAccountsMiddleware, formatTxMetaForRpcResult };

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

@@ -2,18 +2,22 @@ import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { addHexPrefix, stripHexPrefix } from '@ethereumjs/util';
 import { TRANSACTION_TYPES, TX_EVENTS, TransactionStatus } from '@toruslabs/base-controllers';
-import { providerErrors, rpcErrors } from '@web3auth/auth';
+import { rpcErrors, providerErrors } from '@web3auth/auth';
 import { BigNumber } from 'bignumber.js';
-import { Transaction, keccak256 } from 'ethers';
+import { Signature, Transaction, keccak256 } from 'ethers';
 import log from 'loglevel';
-import { METHOD_TYPES, TRANSACTION_ENVELOPE_TYPES, GAS_ESTIMATE_TYPES, CHAIN_ID_TO_GAS_LIMIT_BUFFER_MAP } from '../utils/constants.js';
+import { toHex } from 'viem';
+import { generateEIP7702BatchTransaction } from '../Eip7702/eip7702Utils.js';
+import { METHOD_TYPES, TRANSACTION_ENVELOPE_TYPES, CONTRACT_TYPE_ERC7821, GAS_ESTIMATE_TYPES, CHAIN_ID_TO_GAS_LIMIT_BUFFER_MAP } from '../utils/constants.js';
 import { decGWEIToHexWEI } from '../utils/conversionUtils.js';
 import { bnLessThan, getChainType, GAS_LIMITS } from '../utils/helpers.js';
+import { TRANSACTION_CATEGORY_EIP7702 } from '../utils/interfaces.js';
 import { NonceTracker } from './NonceTracker.js';
 import { PendingTransactionTracker } from './PendingTransactionTracker.js';
 import { TransactionGasUtil } from './TransactionGasUtil.js';
 import { TransactionStateManager } from './TransactionStateManager.js';
-import { isEIP1559Transaction, normalizeTxParameters, validateTxParameters, determineTransactionType } from './TransactionUtils.js';
+import { createNestedTransactionMeta, isEip7702SetCodeTx, isEip7702UpgradeWithDataToSelfTransaction, normalizeTxParameters, validateTxParameters, determineTransactionType, isEIP1559Transaction } from './TransactionUtils.js';
+import { generateBatchId } from '../Eip5792/walletSendCalls.js';
 
 class TransactionController extends TransactionStateManager {
   constructor({
@@ -22,6 +26,7 @@ class TransactionController extends TransactionStateManager {
     provider,
     blockTracker,
     signEthTx,
+    signEip7702Authorization,
     getCurrentChainId,
     getCurrentNetworkEIP1559Compatibility,
     getCurrentAccountEIP1559Compatibility,
@@ -41,6 +46,7 @@ class TransactionController extends TransactionStateManager {
     _defineProperty(this, "_getCurrentNetworkEIP1559Compatibility", void 0);
     _defineProperty(this, "_getCurrentAccountEIP1559Compatibility", void 0);
     _defineProperty(this, "signEthTx", void 0);
+    _defineProperty(this, "signEip7702Authorization", void 0);
     _defineProperty(this, "provider", void 0);
     _defineProperty(this, "blockTracker", void 0);
     _defineProperty(this, "inProcessOfSigning", new Set());
@@ -52,6 +58,7 @@ class TransactionController extends TransactionStateManager {
     this.getSelectedAddress = getSelectedAddress;
     this.getEIP1559GasFeeEstimates = getEIP1559GasFeeEstimates;
     this.signEthTx = signEthTx;
+    this.signEip7702Authorization = signEip7702Authorization;
     this.provider = provider;
     this.txGasUtil = new TransactionGasUtil(this.provider, this.blockTracker);
     this.nonceTracker = new NonceTracker({
@@ -82,6 +89,57 @@ class TransactionController extends TransactionStateManager {
     const txMeta = await this.createTransaction(txParams, req);
     return this.processApproval(txMeta);
   }
+  async addNewUnapprovedTransactionsBatch(batchRequest, req) {
+    var _batchRequest$batchId;
+    const batchRequestParams = Array.isArray(req.params) ? req.params[0] : req.params;
+    const {
+      from,
+      chainId
+    } = batchRequestParams;
+    const {
+      transactions,
+      requiredEip7702Upgrade,
+      eip7702UpgradeContractAddress: delegationAddress
+    } = batchRequest;
+    const batchId = (_batchRequest$batchId = batchRequest.batchId) !== null && _batchRequest$batchId !== void 0 ? _batchRequest$batchId : generateBatchId();
+    let txParams;
+    const txMetaOverride = {
+      batchId,
+      type: CONTRACT_TYPE_ERC7821
+    };
+    if (transactions.length === 1) {
+      // if it's single call, we can just process as a normal transaction
+      txParams = {
+        from,
+        to: transactions[0].params.to,
+        value: transactions[0].params.value,
+        data: transactions[0].params.data,
+        chainId
+      };
+    } else {
+      // process multiple transactions as a batch
+      const nestedTxMeta = await Promise.all(transactions.map(txParam => createNestedTransactionMeta(from, txParam, this.provider)));
+      const batchTransaction = generateEIP7702BatchTransaction(from, nestedTxMeta);
+      txParams = _objectSpread(_objectSpread({}, batchTransaction), {}, {
+        from
+      });
+      if (requiredEip7702Upgrade) {
+        if (!delegationAddress) {
+          throw rpcErrors.invalidParams("Delegation address is required for EIP-7702 upgrade");
+        }
+        txParams.authorizationList = [{
+          address: delegationAddress,
+          chainId: addHexPrefix(chainId)
+        }];
+        txParams.type = TRANSACTION_ENVELOPE_TYPES.SET_CODE;
+      }
+      txMetaOverride.nestedTransactions = nestedTxMeta;
+      txMetaOverride.transactionCategory = TRANSACTION_CATEGORY_EIP7702.BATCH;
+    }
+    const txMeta = await this.createTransaction(txParams, req, txMetaOverride);
+    await this.processApproval(txMeta);
+    return batchId;
+  }
   async processApproval(txMeta) {
     return new Promise((resolve, reject) => {
       const handleFinished = msg => {
@@ -152,7 +210,7 @@ class TransactionController extends TransactionStateManager {
   async signTransaction(txId, isSignOnly) {
     const txMeta = this.getTransaction(txId);
     const chainId = this.getCurrentChainId();
-    const type = isEIP1559Transaction(txMeta) ? TRANSACTION_ENVELOPE_TYPES.FEE_MARKET : TRANSACTION_ENVELOPE_TYPES.LEGACY;
+    const type = this.getTransactionType(txMeta);
     const txParams = {
       type: Number.parseInt(type, 16),
       chainId,
@@ -167,6 +225,34 @@ class TransactionController extends TransactionStateManager {
       value: txMeta.transaction.value
     };
     const fromAddress = txMeta.transaction.from;
+
+    // Sign Authorization if present
+    if (txMeta.transaction.authorizationList) {
+      const signedAuthorizations = [];
+      txParams.authorizationList = [];
+      for (const authorization of txMeta.transaction.authorizationList) {
+        // prepare and normalize the authorization
+        const authorizationNonce = authorization.nonce ? parseInt(authorization.nonce, 16) : parseInt(txMeta.transaction.nonce, 16) + 1;
+        const normalizedAuthorization = {
+          address: authorization.address,
+          chainId: authorization.chainId,
+          nonce: toHex(authorizationNonce)
+        };
+        const signedAuthorization = await this.signEip7702Authorization(normalizedAuthorization, fromAddress);
+        signedAuthorizations.push(signedAuthorization);
+        txParams.authorizationList.push({
+          address: signedAuthorization.address,
+          chainId: BigInt(signedAuthorization.chainId),
+          nonce: BigInt(signedAuthorization.nonce),
+          signature: Signature.from({
+            r: signedAuthorization.r,
+            s: signedAuthorization.s,
+            yParity: parseInt(signedAuthorization.yParity, 16)
+          })
+        });
+      }
+      txMeta.transaction.authorizationList = signedAuthorizations;
+    }
     const tx = Transaction.from(txParams);
     const signedEthTx = await this.signEthTx(tx, fromAddress);
     txMeta.r = signedEthTx.signature.r;
@@ -242,7 +328,11 @@ class TransactionController extends TransactionStateManager {
     return updateTxMeta;
   }
   async addTxGasDefaults(txMeta) {
-    const eip1559Compatibility = txMeta.transaction.type !== TRANSACTION_ENVELOPE_TYPES.LEGACY && (await this.getEIP1559Compatibility());
+    const isSetCodeTx = isEip7702SetCodeTx(txMeta);
+
+    // EIP-7702 type 4 (SET_CODE) transactions are EIP-1559 compatible
+    // They use maxFeePerGas and maxPriorityFeePerGas like type 2 transactions
+    const eip1559Compatibility = isSetCodeTx || txMeta.transaction.type !== TRANSACTION_ENVELOPE_TYPES.LEGACY && (await this.getEIP1559Compatibility());
     const {
       gasPrice: defaultGasPrice,
       maxFeePerGas: defaultMaxFeePerGas,
@@ -374,13 +464,18 @@ class TransactionController extends TransactionStateManager {
     };
   }
   async getDefaultGasLimit(txMeta) {
+    var _txMeta$nestedTransac;
     const chainId = this.getCurrentChainId();
     const customNetworkGasBuffer = CHAIN_ID_TO_GAS_LIMIT_BUFFER_MAP[chainId];
     const chainType = getChainType(chainId);
+    const isSetCodeTx = isEip7702SetCodeTx(txMeta);
     if (txMeta.transaction.gas) {
       return {};
     }
-    if (txMeta.transaction.to && txMeta.transactionCategory === TRANSACTION_TYPES.SENT_ETHER && chainType !== "custom" && !txMeta.transaction.data) {
+
+    // For EIP-7702 type 4 transactions (SET_CODE), we need to estimate gas including authorization costs
+    // Simple send optimization doesn't apply to SET_CODE transactions as they involve code execution
+    if (!isSetCodeTx && txMeta.transaction.to && txMeta.transactionCategory === TRANSACTION_TYPES.SENT_ETHER && chainType !== "custom" && !txMeta.transaction.data) {
       // This is a standard ether simple send, gas requirement is exactly 21k
       return {
         gasLimit: GAS_LIMITS.SIMPLE
@@ -393,13 +488,24 @@ class TransactionController extends TransactionStateManager {
     } = await this.txGasUtil.analyzeGasUsage(txMeta);
 
     // add additional gas buffer to our estimation for safety
-    const gasLimit = this.txGasUtil.addGasBuffer(addHexPrefix(estimatedGasHex), blockGasLimit, customNetworkGasBuffer);
+    let gasLimit;
+    if (isEip7702UpgradeWithDataToSelfTransaction(txMeta) && (_txMeta$nestedTransac = txMeta.nestedTransactions) !== null && _txMeta$nestedTransac !== void 0 && _txMeta$nestedTransac.length) {
+      // Base multiplier for EIP-7702 upgrade with data to self transactions
+      // Add additional buffer based on the number of batch calls in ERC7821 execute
+      const batchCallsCount = txMeta.nestedTransactions.length;
+      const baseMultiplier = 1.5;
+      const perCallBuffer = 0.1;
+      const eip7702UpgradeWithDataToSelfGasBufferMultiplier = baseMultiplier + perCallBuffer * batchCallsCount;
+      gasLimit = this.txGasUtil.addGasBuffer(addHexPrefix(estimatedGasHex), blockGasLimit, eip7702UpgradeWithDataToSelfGasBufferMultiplier);
+    } else {
+      gasLimit = this.txGasUtil.addGasBuffer(addHexPrefix(estimatedGasHex), blockGasLimit, customNetworkGasBuffer);
+    }
     return {
       gasLimit,
       simulationFails
     };
   }
-  async createTransaction(txParameters, req) {
+  async createTransaction(txParameters, req, overrideTxMeta) {
     const normalizedTxParameters = normalizeTxParameters(txParameters);
     const eip1559Compatibility = await this.getEIP1559Compatibility(txParameters.from);
     validateTxParameters(normalizedTxParameters, eip1559Compatibility);
@@ -411,13 +517,15 @@ class TransactionController extends TransactionStateManager {
       type,
       category,
       methodParams
-    } = await determineTransactionType(txParameters, this.provider);
+    } = await determineTransactionType(txParameters, this.provider, overrideTxMeta);
     txMeta.contractType = type;
     txMeta.transactionCategory = category;
     txMeta.methodParams = methodParams;
     txMeta.isUserOperation = req.isUserOperation;
     txMeta.isSignOnly = req.isSignOnly;
     txMeta.transaction.value = txMeta.transaction.value ? addHexPrefix(txMeta.transaction.value) : "0x0";
+    txMeta.batchId = overrideTxMeta === null || overrideTxMeta === void 0 ? void 0 : overrideTxMeta.batchId;
+    txMeta.nestedTransactions = overrideTxMeta === null || overrideTxMeta === void 0 ? void 0 : overrideTxMeta.nestedTransactions;
     this.emit(`${txMeta.id}:unapproved`, txMeta);
     txMeta = this.addTransactionToState(txMeta);
     txMeta = await this.addTransactionGasDefaults(txMeta);
@@ -499,6 +607,12 @@ class TransactionController extends TransactionStateManager {
       if (tx.status !== TransactionStatus.failed) this.setTxStatusDropped(tx.id);
     });
   }
+  getTransactionType(txMeta) {
+    if (isEip7702SetCodeTx(txMeta)) {
+      return TRANSACTION_ENVELOPE_TYPES.SET_CODE;
+    }
+    return isEIP1559Transaction(txMeta) ? TRANSACTION_ENVELOPE_TYPES.FEE_MARKET : TRANSACTION_ENVELOPE_TYPES.LEGACY;
+  }
 }
 
 export { TransactionController };

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

@@ -1,8 +1,11 @@
+import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import { stripHexPrefix, addHexPrefix } from '@ethereumjs/util';
 import { cloneDeep } from '@toruslabs/base-controllers';
 import { BN } from 'bn.js';
 import log from 'loglevel';
+import { DUMMY_AUTHORIZATION_SIGNATURE } from '../utils/eip7702Types.js';
+import { isEip7702SetCodeTx } from './TransactionUtils.js';
 
 class TransactionGasUtil {
   constructor(provider, blockTracker) {
@@ -69,6 +72,16 @@ class TransactionGasUtil {
     delete txParams.gasPrice;
     delete txParams.maxFeePerGas;
     delete txParams.maxPriorityFeePerGas;
+    const eip7702SetCodeTx = isEip7702SetCodeTx(txMeta);
+    if (eip7702SetCodeTx) {
+      // assign dummy signature for the gas estimation
+      txParams.authorizationList = txParams.authorizationList.map(authorization => _objectSpread(_objectSpread({}, authorization), {}, {
+        nonce: authorization.nonce || "0x1",
+        r: DUMMY_AUTHORIZATION_SIGNATURE,
+        s: DUMMY_AUTHORIZATION_SIGNATURE,
+        yParity: "0x1"
+      }));
+    }
     return this.provider.request({
       method: "eth_estimateGas",
       params: [txParams]

package/dist/lib.esm/Transaction/TransactionStateManager.js

@@ -206,6 +206,15 @@ class TransactionStateManager extends BaseTransactionStateManager {
     }
     return filteredTransactions;
   }
+  getTransactionByBatchId(batchId) {
+    const searchCriteria = {
+      batchId
+    };
+    const [batchTx] = this.getTransactions({
+      searchCriteria
+    });
+    return batchTx;
+  }
   getApprovedTransactions(address) {
     const searchCriteria = {
       status: TransactionStatus.approved