@toruslabs/ethereum-controllers 8.16.0 → 8.17.1

package/dist/lib.cjs/types/utils/eip7702Types.d.ts

@@ -0,0 +1,60 @@
+import { Hex } from "viem";
+import { TransactionParams } from "./interfaces";
+export declare const EIP_7702_METHODS: {
+    readonly WALLET_UPGRADE_ACCOUNT: "wallet_upgradeAccount";
+    readonly WALLET_GET_ACCOUNT_UPGRADE_STATUS: "wallet_getAccountUpgradeStatus";
+};
+export declare const EIP_7702_PREFIX = "0xef0100";
+export declare const EIP_7702_REVOKE_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const DUMMY_AUTHORIZATION_SIGNATURE = "0x1111111111111111111111111111111111111111111111111111111111111111";
+/**
+ * An authorization to be included in a `setCode` transaction.
+ * Specifies code to be added to the authorization signer's EOA account.
+ * Introduced in EIP-7702.
+ */
+export type Authorization = {
+    /** Address of a smart contract that contains the code to be set. */
+    address: Hex;
+    /**
+     * Specific chain the authorization applies to.
+     * If not provided, defaults to the chain ID of the transaction.
+     */
+    chainId: Hex;
+    /**
+     * Nonce at which the authorization will be valid.
+     * If not provided, defaults to the nonce following the transaction's nonce.
+     */
+    nonce?: Hex;
+    /** R component of the signature. */
+    r?: Hex;
+    /** S component of the signature. */
+    s?: Hex;
+    /** Y parity generated from the signature. */
+    yParity?: Hex;
+};
+export type UnsignedAuthorization = Omit<Required<Authorization>, "r" | "s" | "yParity">;
+export type SignedAuthorization = Required<Authorization>;
+export interface Eip7702Params extends TransactionParams {
+    /**
+     * Address of the account to upgrade or get upgrade status for.
+     */
+    account: Hex;
+    /**
+     * Chain ID of the account to upgrade.
+     */
+    chainId: Hex;
+    /**
+     * Optional contract address for delegation.
+     */
+    implementation?: Hex;
+}
+export interface Eip7702WalletGetUpgradeStatusResponse {
+    /**
+     * Whether the account is upgraded.
+     */
+    isUpgraded: boolean;
+    /**
+     * The implementation address of the contract that the account is delegated to.
+     */
+    implementation: Hex;
+}

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

@@ -7,6 +7,10 @@ import { ToBiconomySmartAccountParameters, toEcdsaKernelSmartAccount, ToLightSma
 import { Client, Hex, WalletClient } from "viem";
 import { createBundlerClient, createPaymasterClient, SmartAccount, UserOperationReceipt, WebAuthnAccount } from "viem/account-abstraction";
 import { METHOD_TYPES, SMART_ACCOUNT, TRANSACTION_ENVELOPE_TYPES } from "./constants";
+import { NestedTransactionMetadata } from "./eip5792Types";
+import { Authorization } from "./eip7702Types";
+export type { BatchTransactionParams, NestedTransactionMetadata, TransactionBatchRequest, TransactionBatchSingleRequest } from "./eip5792Types";
+export type { Authorization, Eip7702Params, Eip7702WalletGetUpgradeStatusResponse, SignedAuthorization } from "./eip7702Types";
 export type CustomTokenInfo = BaseTokenInfo & {
     erc20: boolean;
     customTokenId?: string;
@@ -167,6 +171,12 @@ export interface TransactionParams extends BaseRequestParams {
      * The amount of gas to allocate for the Paymaster post-operation code
      */
     paymasterPostOpGasLimit?: string;
+    /**
+     * Array of authorizations to set code on EOA accounts.
+     * Only supported in `setCode` transactions.
+     * Introduced in EIP-7702.
+     */
+    authorizationList?: Authorization[];
 }
 export type Nonce = {
     name: string;
@@ -275,6 +285,11 @@ export interface DappSuggestedGasFees {
     maxFeePerGas?: string;
     gas?: string;
 }
+export declare const TRANSACTION_CATEGORY_EIP7702: {
+    readonly BATCH: "batch";
+    readonly REVOKE_DELEGATION: "revokeDelegation";
+};
+export type TransactionCategoryWithBatch = TRANSACTION_TYPE | (typeof TRANSACTION_CATEGORY_EIP7702)[keyof typeof TRANSACTION_CATEGORY_EIP7702];
 export interface EthereumTransactionMeta extends TransactionMeta<TransactionParams> {
     r?: string;
     s?: string;
@@ -287,7 +302,7 @@ export interface EthereumTransactionMeta extends TransactionMeta<TransactionPara
     retryCount?: number;
     simulationFails?: Record<string, unknown>;
     loadingDefaults?: boolean;
-    transactionCategory?: TRANSACTION_TYPE;
+    transactionCategory?: TransactionCategoryWithBatch;
     contractType?: string;
     nonceDetails?: NonceDetails;
     methodParams?: unknown[];
@@ -295,6 +310,8 @@ export interface EthereumTransactionMeta extends TransactionMeta<TransactionPara
     isUserOperation?: boolean;
     userOpHash?: string;
     userOpReceipt?: UserOperationReceipt;
+    batchId?: string;
+    nestedTransactions?: NestedTransactionMetadata[];
 }
 export interface TransactionPayload {
     created_at: Date;
@@ -483,4 +500,7 @@ export interface UserOperationGas {
     paymasterVerificationGasLimit?: string;
     paymasterPostOpGasLimit?: string;
 }
-export {};
+/**
+ * Type Def for function to query the deployment bytecode of an address. (eth_getCode)
+ */
+export type GetEthCodeFn = (address: `0x${string}`, chainId: `0x${string}`) => Promise<`0x${string}`>;

package/dist/lib.cjs/utils/abis.js

@@ -503,8 +503,38 @@ const singleBalanceCheckerAbi = [{
   stateMutability: "view",
   type: "function"
 }];
+const erc7821Abi = [{
+  type: "function",
+  name: "execute",
+  inputs: [{
+    name: "mode",
+    type: "bytes32",
+    internalType: "ModeCode"
+  }, {
+    name: "executionData",
+    type: "bytes",
+    internalType: "bytes"
+  }],
+  outputs: [],
+  stateMutability: "payable"
+}, {
+  type: "function",
+  name: "supportsExecutionMode",
+  inputs: [{
+    name: "mode",
+    type: "bytes32",
+    internalType: "ModeCode"
+  }],
+  outputs: [{
+    name: "",
+    type: "bool",
+    internalType: "bool"
+  }],
+  stateMutability: "view"
+}];
 
 exports.erc1155Abi = erc1155Abi;
 exports.erc20Abi = erc20Abi;
 exports.erc721Abi = erc721Abi;
+exports.erc7821Abi = erc7821Abi;
 exports.singleBalanceCheckerAbi = singleBalanceCheckerAbi;

package/dist/lib.cjs/utils/constants.js

@@ -7,6 +7,7 @@ const CONTRACT_TYPE_ETH = "eth";
 const CONTRACT_TYPE_ERC20 = "erc20";
 const CONTRACT_TYPE_ERC721 = "erc721";
 const CONTRACT_TYPE_ERC1155 = "erc1155";
+const CONTRACT_TYPE_ERC7821 = "erc7821";
 const ERC1155_INTERFACE_ID = "0xd9b67a26";
 const ERC721_INTERFACE_ID = "0x80ac58cd";
 const ERC721_METADATA_INTERFACE_ID = "0x5b5e139f";
@@ -278,7 +279,8 @@ const PAYMASTER_METHOD_TYPES = [METHOD_TYPES.ETH_GET_PAYMASTER_DATA, METHOD_TYPE
 const TRANSACTION_ENVELOPE_TYPES = {
   LEGACY: "0x0",
   ACCESS_LIST: "0x1",
-  FEE_MARKET: "0x2"
+  FEE_MARKET: "0x2",
+  SET_CODE: "0x4" // Type 4 transaction
 };
 const GAS_ESTIMATE_TYPES = {
   // Fee Market describes the way gas is set after the london hardfork, and was
@@ -381,6 +383,7 @@ exports.COINGECKO_SUPPORTED_CURRENCIES = COINGECKO_SUPPORTED_CURRENCIES;
 exports.CONTRACT_TYPE_ERC1155 = CONTRACT_TYPE_ERC1155;
 exports.CONTRACT_TYPE_ERC20 = CONTRACT_TYPE_ERC20;
 exports.CONTRACT_TYPE_ERC721 = CONTRACT_TYPE_ERC721;
+exports.CONTRACT_TYPE_ERC7821 = CONTRACT_TYPE_ERC7821;
 exports.CONTRACT_TYPE_ETH = CONTRACT_TYPE_ETH;
 exports.ERC1155_INTERFACE_ID = ERC1155_INTERFACE_ID;
 exports.ERC721_ENUMERABLE_INTERFACE_ID = ERC721_ENUMERABLE_INTERFACE_ID;

package/dist/lib.cjs/utils/eip5792Types.js

@@ -0,0 +1,39 @@
+'use strict';
+
+// ============================================================================
+// EIP-5792 Method Names
+// ============================================================================
+const EIP_5792_METHODS = {
+  WALLET_GET_CAPABILITIES: "wallet_getCapabilities",
+  WALLET_SEND_CALLS: "wallet_sendCalls",
+  WALLET_GET_CALLS_STATUS: "wallet_getCallsStatus",
+  WALLET_SHOW_CALLS_STATUS: "wallet_showCallsStatus"
+};
+const EIP5792ErrorCode = {
+  UnsupportedNonOptionalCapability: 5700,
+  UnsupportedChainId: 5710,
+  UnknownBundleId: 5730,
+  RejectedUpgrade: 5750
+};
+const GetCallsStatusCode = {
+  PENDING: 100,
+  CONFIRMED: 200,
+  FAILED_OFFCHAIN: 400,
+  REVERTED: 500,
+  REVERTED_PARTIAL: 600
+};
+/**
+ * EIP-5792 atomic status (EIP-5792)
+ *
+ * Reference: https://eips.ethereum.org/EIPS/eip-5792#wallet_getcapabilities
+ */
+const Eip5792AtomicStatus = {
+  SUPPORTED: "supported",
+  READY: "ready",
+  UNSUPPORTED: "unsupported"
+};
+
+exports.EIP5792ErrorCode = EIP5792ErrorCode;
+exports.EIP_5792_METHODS = EIP_5792_METHODS;
+exports.Eip5792AtomicStatus = Eip5792AtomicStatus;
+exports.GetCallsStatusCode = GetCallsStatusCode;

package/dist/lib.cjs/utils/eip7702Types.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const EIP_7702_METHODS = {
+  WALLET_UPGRADE_ACCOUNT: "wallet_upgradeAccount",
+  WALLET_GET_ACCOUNT_UPGRADE_STATUS: "wallet_getAccountUpgradeStatus"
+};
+const EIP_7702_PREFIX = "0xef0100";
+const EIP_7702_REVOKE_ADDRESS = "0x0000000000000000000000000000000000000000";
+const DUMMY_AUTHORIZATION_SIGNATURE = "0x1111111111111111111111111111111111111111111111111111111111111111";
+
+exports.DUMMY_AUTHORIZATION_SIGNATURE = DUMMY_AUTHORIZATION_SIGNATURE;
+exports.EIP_7702_METHODS = EIP_7702_METHODS;
+exports.EIP_7702_PREFIX = EIP_7702_PREFIX;
+exports.EIP_7702_REVOKE_ADDRESS = EIP_7702_REVOKE_ADDRESS;

package/dist/lib.cjs/utils/interfaces.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const TRANSACTION_CATEGORY_EIP7702 = {
+  BATCH: "batch",
+  REVOKE_DELEGATION: "revokeDelegation"
+};
+
+exports.TRANSACTION_CATEGORY_EIP7702 = TRANSACTION_CATEGORY_EIP7702;

package/dist/lib.esm/Eip5792/walletGetCallsStatus.js

@@ -0,0 +1,76 @@
+import { addHexPrefix } from '@ethereumjs/util';
+import { TransactionStatus } from '@toruslabs/base-controllers';
+import { rpcErrors, JsonRpcError } from '@web3auth/auth';
+import { GetCallsStatusCode, EIP_5792_METHODS, EIP5792ErrorCode } from '../utils/eip5792Types.js';
+
+/**
+ * Maps a TransactionStatus to an EIP-5792 GetCallsStatusCode.
+ * @param status - The transaction status.
+ * @returns The corresponding EIP-5792 status code.
+ */
+function mapTransactionStatusToEip5792Status(status) {
+  switch (status) {
+    // Pending states - batch is still being processed
+    case TransactionStatus.unapproved:
+    case TransactionStatus.approved:
+    case TransactionStatus.signed:
+    case TransactionStatus.submitted:
+    case TransactionStatus.pending:
+    case TransactionStatus.cancelling:
+      return GetCallsStatusCode.PENDING;
+
+    // Confirmed states - batch completed successfully
+    case TransactionStatus.confirmed:
+    case TransactionStatus.finalized:
+    case TransactionStatus.processed:
+      return GetCallsStatusCode.CONFIRMED;
+
+    // Failed offchain - rejected/cancelled before reaching the chain
+    case TransactionStatus.rejected:
+    case TransactionStatus.cancelled:
+    case TransactionStatus.expired:
+    case TransactionStatus.dropped:
+      return GetCallsStatusCode.FAILED_OFFCHAIN;
+
+    // Reverted - transaction was submitted but failed on chain
+    case TransactionStatus.failed:
+      return GetCallsStatusCode.REVERTED;
+    default:
+      return GetCallsStatusCode.PENDING;
+  }
+}
+
+/**
+ * Handler for wallet_getCallsStatus (EIP-5792).
+ * Returns the status of a batch of calls.
+ *
+ * @param request - The JRPC request with batch ID parameter.
+ * @param context - Context containing required functions.
+ * @returns The batch status and receipts.
+ */
+function walletGetCallsStatus(request, getTransactionByBatchId) {
+  const {
+    method,
+    params
+  } = request;
+  if (method !== EIP_5792_METHODS.WALLET_GET_CALLS_STATUS) {
+    return;
+  }
+  const batchId = Array.isArray(params) ? params[0] : params;
+  if (!batchId) {
+    throw rpcErrors.invalidParams("wallet_getCallsStatus: batch ID is required");
+  }
+  const batchTx = getTransactionByBatchId(batchId);
+  if (!batchTx) {
+    throw new JsonRpcError(EIP5792ErrorCode.UnknownBundleId, `wallet_getCallsStatus: Batch not found: ${batchId}`);
+  }
+  return {
+    status: mapTransactionStatusToEip5792Status(batchTx.status),
+    id: batchId,
+    chainId: addHexPrefix(batchTx.chainId),
+    atomic: true,
+    receipts: batchTx.txReceipt ? [batchTx.txReceipt] : []
+  };
+}
+
+export { mapTransactionStatusToEip5792Status, walletGetCallsStatus };

package/dist/lib.esm/Eip5792/walletGetCapabilities.js

@@ -0,0 +1,63 @@
+import { rpcErrors } from '@web3auth/auth';
+import { getIsEip7702UpgradeSupported } from '../Eip7702/eip7702Utils.js';
+import { EIP_5792_METHODS, Eip5792AtomicStatus } from '../utils/eip5792Types.js';
+
+/**
+ * Handler for wallet_getCapabilities (EIP-5792).
+ * Returns capabilities per chain, indicating atomicBatch support for upgraded accounts.
+ *
+ * @param request - The JRPC request with wallet address parameter.
+ * @param context - Context containing required functions.
+ * @returns Capabilities per chain.
+ */
+async function walletGetCapabilities(request, getEthCode, context) {
+  var _context$getCachedDel;
+  const {
+    method,
+    params
+  } = request;
+  if (method !== EIP_5792_METHODS.WALLET_GET_CAPABILITIES) {
+    return;
+  }
+  if (!Array.isArray(params)) {
+    throw rpcErrors.invalidParams("wallet_getCapabilities: parameters are required");
+  }
+  const walletAddress = params[0];
+  if (!walletAddress) {
+    throw rpcErrors.invalidParams("wallet_getCapabilities: wallet address is required");
+  }
+  const chainsOverride = params[1];
+  const supportedChains = chainsOverride || context.getSupportedChains();
+  const cachedDelegations = ((_context$getCachedDel = context.getCachedDelegations) === null || _context$getCachedDel === void 0 ? void 0 : _context$getCachedDel.call(context)) || {};
+  const capabilities = {};
+  for (const chainId of supportedChains) {
+    const cacheKey = `${walletAddress.toLowerCase()}-${chainId.toLowerCase()}`;
+    let delegationAddress = cachedDelegations[cacheKey];
+    let atomicStatus = Eip5792AtomicStatus.SUPPORTED;
+
+    // If not cached, try to fetch
+    if (delegationAddress === undefined && getEthCode) {
+      try {
+        const eip7702UpgradeSupported = await getIsEip7702UpgradeSupported(walletAddress, chainId, getEthCode);
+        delegationAddress = eip7702UpgradeSupported.delegationAddress;
+        if (delegationAddress === null) {
+          atomicStatus = eip7702UpgradeSupported.isSupported ? Eip5792AtomicStatus.READY : Eip5792AtomicStatus.UNSUPPORTED;
+        } else {
+          var _context$updateDelega;
+          // account already upgraded, update the cache
+          (_context$updateDelega = context.updateDelegationCache) === null || _context$updateDelega === void 0 || _context$updateDelega.call(context, walletAddress, chainId, delegationAddress);
+        }
+      } catch {
+        atomicStatus = Eip5792AtomicStatus.UNSUPPORTED;
+      }
+    }
+    capabilities[chainId] = {
+      atomic: {
+        status: atomicStatus
+      }
+    };
+  }
+  return capabilities;
+}
+
+export { walletGetCapabilities };

package/dist/lib.esm/Eip5792/walletSendCalls.js

@@ -0,0 +1,168 @@
+import { isValidAddress } from '@ethereumjs/util';
+import { rpcErrors } from '@web3auth/auth';
+import { isHexString } from 'ethers';
+import { v4, parse } from 'uuid';
+import { getIsEip7702UpgradeSupported } from '../Eip7702/eip7702Utils.js';
+import { EIP_5792_METHODS } from '../utils/eip5792Types.js';
+
+/**
+ * Generates a unique batch ID for EIP-5792 calls.
+ * @returns A unique hex string batch ID.
+ */
+function generateBatchId() {
+  const idString = v4();
+  const idBytes = new Uint8Array(parse(idString));
+  const hexString = Array.from(idBytes).map(byte => byte.toString(16).padStart(2, "0")).join("");
+  return `0x${hexString}`;
+}
+
+/**
+ * Validates a single call in the batch.
+ * @param call - The call to validate.
+ * @param index - The index of the call in the batch (for error messages).
+ */
+function validateCall(call, index) {
+  // Validate 'to' address
+  if (!call.to || !isHexString(call.to) || !isValidAddress(call.to)) {
+    throw rpcErrors.invalidParams(`Invalid 'to' address in call at index ${index}`);
+  }
+
+  // Validate 'value' if present
+  if (call.value !== undefined) {
+    if (!isHexString(call.value)) {
+      throw rpcErrors.invalidParams(`Invalid 'value' in call at index ${index}: must be a valid non-negative hex string`);
+    }
+  }
+
+  // Validate 'data' if present
+  if (call.data !== undefined) {
+    if (!isHexString(call.data)) {
+      throw rpcErrors.invalidParams(`Invalid 'data' in call at index ${index}: must be a valid hex string`);
+    }
+  }
+}
+
+/**
+ * Validates the parameters for wallet_sendCalls (EIP-5792).
+ * @param sendCallsParams - The parameters to validate.
+ */
+function validateSendCallsParams(sendCallsParams) {
+  // Basic structure validation
+  if (!sendCallsParams) {
+    throw rpcErrors.invalidParams("Missing send calls parameters");
+  }
+
+  // Validate version format
+  if (!sendCallsParams.version || typeof sendCallsParams.version !== "string") {
+    throw rpcErrors.invalidParams(`Invalid version: expected a string, got "${sendCallsParams.version || "undefined"}"`);
+  }
+
+  // Validate chainId format
+  if (!sendCallsParams.chainId || !isHexString(sendCallsParams.chainId)) {
+    throw rpcErrors.invalidParams("Invalid chainId: must be a valid hex string");
+  }
+
+  // Validate 'from' address
+  if (!sendCallsParams.from) {
+    throw rpcErrors.invalidParams("Missing 'from' address");
+  }
+  if (!isHexString(sendCallsParams.from) || !isValidAddress(sendCallsParams.from)) {
+    throw rpcErrors.invalidParams("Invalid 'from' address: must be a valid hex address");
+  }
+
+  // Validate calls array
+  if (!Array.isArray(sendCallsParams.calls) || sendCallsParams.calls.length === 0) {
+    throw rpcErrors.invalidParams("Invalid calls: must be a non-empty array");
+  }
+
+  // Validate each call
+  sendCallsParams.calls.forEach((call, index) => {
+    validateCall(call, index);
+  });
+}
+async function processMultipleTransactions({
+  from,
+  transactions,
+  request,
+  chainId,
+  getEthCode,
+  processTransactionBatch
+}) {
+  // check if the account is upgraded with EIP-7702 for the given chain
+  const {
+    isSupported,
+    upgradeContractAddress,
+    delegationAddress
+  } = await getIsEip7702UpgradeSupported(from, chainId, getEthCode);
+  if (!isSupported) {
+    throw rpcErrors.methodNotSupported(`EIP-7702 upgrade is not supported for the given chain, ${chainId}`);
+  }
+  const hasAccountAlreadyUpgraded = Boolean(delegationAddress);
+  const batchRequest = {
+    batchId: generateBatchId(),
+    transactions,
+    eip7702UpgradeContractAddress: upgradeContractAddress,
+    requiredEip7702Upgrade: !hasAccountAlreadyUpgraded
+  };
+
+  // prepare batch transactions
+  return processTransactionBatch(batchRequest, request);
+}
+async function processSingleTransaction({
+  transactions,
+  request,
+  processTransactionBatch
+}) {
+  const batchRequestWithSingleCall = {
+    batchId: generateBatchId(),
+    transactions
+  };
+  return processTransactionBatch(batchRequestWithSingleCall, request);
+}
+
+/**
+ * Handler for wallet_sendCalls (EIP-5792).
+ * Sends a batch of calls for an EIP-7702 upgraded account.
+ *
+ * @param request - The JRPC request with send calls parameters.
+ * @param getEthCode - Function to get the code at an address.
+ * @param context - Context containing required functions.
+ * @returns The batch ID.
+ */
+async function walletSendCalls(request, getEthCode, context) {
+  const {
+    method,
+    params
+  } = request;
+  if (method !== EIP_5792_METHODS.WALLET_SEND_CALLS) {
+    return;
+  }
+  const sendCallsParams = Array.isArray(params) ? params[0] : params;
+  validateSendCallsParams(sendCallsParams);
+  const {
+    chainId,
+    from,
+    calls
+  } = sendCallsParams;
+  const transactions = calls.map(call => ({
+    params: call
+  }));
+  const isBatchCalls = Object.keys(transactions).length > 1;
+  if (!isBatchCalls) {
+    return processSingleTransaction({
+      transactions,
+      request,
+      processTransactionBatch: context.processTransactionBatch
+    });
+  }
+  return processMultipleTransactions({
+    from: from,
+    transactions,
+    request,
+    chainId,
+    getEthCode,
+    processTransactionBatch: context.processTransactionBatch
+  });
+}
+
+export { generateBatchId, processMultipleTransactions, processSingleTransaction, validateSendCallsParams, walletSendCalls };

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

@@ -0,0 +1,81 @@
+import { addHexPrefix } from '@ethereumjs/util';
+import { zeroAddress, encodeAbiParameters, parseAbiParameters, encodeFunctionData } from 'viem';
+import { erc7821Abi } from '../utils/abis.js';
+import { SUPPORTED_NETWORKS } from '../utils/constants.js';
+import { EIP_7702_PREFIX } from '../utils/eip7702Types.js';
+
+/**
+ * The MetaMask EIP-7702 Stateless Delegator contract address.
+ * Used as the delegation target for all supported networks.
+ */
+const MetaMask_EIP7702_Stateless_Delegator = "0x63c0c19a282a1B52b07dD5a65b58948A07DAE32B";
+async function getDelegationAddress(walletAddress, chainId, getEthCode) {
+  // query eth_getCode
+  const code = await getEthCode(walletAddress, chainId);
+  const normalizedCode = code ? addHexPrefix(code).toLowerCase() : "0x0";
+  const hasDelegation = normalizedCode.length === 48 && normalizedCode.startsWith(EIP_7702_PREFIX);
+  if (hasDelegation) {
+    const delegationAddress = addHexPrefix(normalizedCode.slice(EIP_7702_PREFIX.length));
+    return delegationAddress;
+  }
+  return null;
+}
+
+/**
+ * Check if the wallet is supported for EIP-7702 on provided chain.
+ */
+async function getIsEip7702UpgradeSupported(address, chainId, getEthCode) {
+  if (!SUPPORTED_NETWORKS[chainId]) {
+    return {
+      isSupported: false,
+      delegationAddress: null
+    };
+  }
+  const delegationAddress = await getDelegationAddress(address, chainId, getEthCode);
+  return {
+    isSupported: true,
+    upgradeContractAddress: MetaMask_EIP7702_Stateless_Delegator,
+    delegationAddress
+  };
+}
+
+/**
+ * Generate an EIP-7702 batch transaction.
+ *
+ * Reference: {@link https://github.com/MetaMask/core/blob/main/packages/transaction-controller/src/utils/eip7702.ts#L119}
+ *
+ * @param from - The sender address.
+ * @param transactions - The transactions to batch.
+ * @returns The batch transaction.
+ */
+function generateEIP7702BatchTransaction(from, transactions) {
+  const calls = transactions.map(transaction => {
+    const {
+      data,
+      to,
+      value
+    } = transaction;
+    return {
+      target: to !== null && to !== void 0 ? to : zeroAddress,
+      value: BigInt(value !== null && value !== void 0 ? value : "0x0"),
+      callData: data !== null && data !== void 0 ? data : "0x"
+    };
+  });
+
+  // Single batch mode, no opData.
+  const mode = "0x01".padEnd(66, "0");
+
+  // Encode the calls array as (address target, uint256 value, bytes callData)[]
+  const executionData = encodeAbiParameters(parseAbiParameters("(address target, uint256 value, bytes callData)[]"), [calls]);
+  const data = encodeFunctionData({
+    abi: erc7821Abi,
+    functionName: "execute",
+    args: [mode, executionData]
+  });
+  return {
+    data,
+    to: from
+  };
+}
+
+export { MetaMask_EIP7702_Stateless_Delegator, generateEIP7702BatchTransaction, getDelegationAddress, getIsEip7702UpgradeSupported };

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

@@ -0,0 +1,33 @@
+import { rpcErrors } from '@web3auth/auth';
+import { getDelegationAddress } from './eip7702Utils.js';
+
+/**
+ * Get the EIP7702 upgrade status of an EOA.
+ *
+ * @param request - The request object.
+ * @param getEthCode - The function to get the code of an account.
+ * @returns The upgrade status.
+ */
+async function walletGetUpgradeStatus(request, getEthCode) {
+  const {
+    method,
+    params
+  } = request;
+  if (method !== "wallet_getAccountUpgradeStatus") {
+    return;
+  }
+  const getUpgradeStatusParam = Array.isArray(params) ? params[0] : params;
+  const account = getUpgradeStatusParam.account;
+  const chainId = getUpgradeStatusParam.chainId;
+  if (!account || !chainId) {
+    throw rpcErrors.invalidParams("wallet_getAccountUpgradeStatus: account and chainId are required");
+  }
+  const delegationAddress = await getDelegationAddress(account, chainId, getEthCode);
+  const isUpgraded = delegationAddress !== null;
+  return {
+    isUpgraded,
+    implementation: delegationAddress !== null && delegationAddress !== void 0 ? delegationAddress : "0x0"
+  };
+}
+
+export { walletGetUpgradeStatus };