@toruslabs/ethereum-controllers 8.15.0 → 8.17.0

package/dist/lib.cjs/index.js

@@ -10,6 +10,10 @@ var SafeSmartAccount = require('./AccountAbstraction/smartAccounts/SafeSmartAcco
 var TrustSmartAccount = require('./AccountAbstraction/smartAccounts/TrustSmartAccount.js');
 var PollingBlockTracker = require('./Block/PollingBlockTracker.js');
 var CurrencyController = require('./Currency/CurrencyController.js');
+var walletGetCallsStatus = require('./Eip5792/walletGetCallsStatus.js');
+var walletGetCapabilities = require('./Eip5792/walletGetCapabilities.js');
+var walletSendCalls = require('./Eip5792/walletSendCalls.js');
+var eip7702Utils = require('./Eip7702/eip7702Utils.js');
 var GasFeeController = require('./Gas/GasFeeController.js');
 var KeyringController = require('./Keyring/KeyringController.js');
 var AddChainController = require('./Message/AddChainController.js');
@@ -37,7 +41,10 @@ var TransactionUtils = require('./Transaction/TransactionUtils.js');
 var abis = require('./utils/abis.js');
 var constants = require('./utils/constants.js');
 var conversionUtils = require('./utils/conversionUtils.js');
+var eip5792Types = require('./utils/eip5792Types.js');
+var eip7702Types = require('./utils/eip7702Types.js');
 var helpers = require('./utils/helpers.js');
+var interfaces = require('./utils/interfaces.js');
 
 
 
@@ -53,6 +60,18 @@ exports.SafeSmartAccount = SafeSmartAccount.SafeSmartAccount;
 exports.TrustSmartAccount = TrustSmartAccount.TrustSmartAccount;
 exports.PollingBlockTracker = PollingBlockTracker.PollingBlockTracker;
 exports.CurrencyController = CurrencyController.CurrencyController;
+exports.mapTransactionStatusToEip5792Status = walletGetCallsStatus.mapTransactionStatusToEip5792Status;
+exports.walletGetCallsStatus = walletGetCallsStatus.walletGetCallsStatus;
+exports.walletGetCapabilities = walletGetCapabilities.walletGetCapabilities;
+exports.generateBatchId = walletSendCalls.generateBatchId;
+exports.processMultipleTransactions = walletSendCalls.processMultipleTransactions;
+exports.processSingleTransaction = walletSendCalls.processSingleTransaction;
+exports.validateSendCallsParams = walletSendCalls.validateSendCallsParams;
+exports.walletSendCalls = walletSendCalls.walletSendCalls;
+exports.MetaMask_EIP7702_Stateless_Delegator = eip7702Utils.MetaMask_EIP7702_Stateless_Delegator;
+exports.generateEIP7702BatchTransaction = eip7702Utils.generateEIP7702BatchTransaction;
+exports.getDelegationAddress = eip7702Utils.getDelegationAddress;
+exports.getIsEip7702UpgradeSupported = eip7702Utils.getIsEip7702UpgradeSupported;
 exports.GasFeeController = GasFeeController.GasFeeController;
 exports.KeyringController = KeyringController.KeyringController;
 exports.AddChainController = AddChainController.AddChainController;
@@ -67,6 +86,8 @@ exports.validateSignMessageData = utils.validateSignMessageData;
 exports.validateSwitchChainData = utils.validateSwitchChainData;
 exports.validateTypedSignMessageDataV4 = utils.validateTypedSignMessageDataV4;
 exports.createAAMiddleware = createEthereumMiddleware.createAAMiddleware;
+exports.createEip5792Middleware = createEthereumMiddleware.createEip5792Middleware;
+exports.createEip7702Middleware = createEthereumMiddleware.createEip7702Middleware;
 exports.createEthereumMiddleware = createEthereumMiddleware.createEthereumMiddleware;
 exports.createGetAccountsMiddleware = createEthereumMiddleware.createGetAccountsMiddleware;
 exports.createPendingNonceMiddleware = createEthereumMiddleware.createPendingNonceMiddleware;
@@ -101,11 +122,14 @@ exports.generateHistoryEntry = TransactionStateHistoryHelper.generateHistoryEntr
 exports.replayHistory = TransactionStateHistoryHelper.replayHistory;
 exports.snapshotFromTxMeta = TransactionStateHistoryHelper.snapshotFromTxMeta;
 exports.TransactionStateManager = TransactionStateManager.TransactionStateManager;
+exports.createNestedTransactionMeta = TransactionUtils.createNestedTransactionMeta;
 exports.determineTransactionType = TransactionUtils.determineTransactionType;
 exports.ensureFieldIsString = TransactionUtils.ensureFieldIsString;
 exports.ensureMutuallyExclusiveFieldsNotProvided = TransactionUtils.ensureMutuallyExclusiveFieldsNotProvided;
 exports.getFinalStates = TransactionUtils.getFinalStates;
 exports.isEIP1559Transaction = TransactionUtils.isEIP1559Transaction;
+exports.isEip7702SetCodeTx = TransactionUtils.isEip7702SetCodeTx;
+exports.isEip7702UpgradeWithDataToSelfTransaction = TransactionUtils.isEip7702UpgradeWithDataToSelfTransaction;
 exports.isLegacyTransaction = TransactionUtils.isLegacyTransaction;
 exports.normalizeAndValidateTxParams = TransactionUtils.normalizeAndValidateTxParams;
 exports.normalizeTxParameters = TransactionUtils.normalizeTxParameters;
@@ -118,6 +142,7 @@ exports.validateTxParameters = TransactionUtils.validateTxParameters;
 exports.erc1155Abi = abis.erc1155Abi;
 exports.erc20Abi = abis.erc20Abi;
 exports.erc721Abi = abis.erc721Abi;
+exports.erc7821Abi = abis.erc7821Abi;
 exports.singleBalanceCheckerAbi = abis.singleBalanceCheckerAbi;
 exports.ARBITRUM_MAINNET_CHAIN_ID = constants.ARBITRUM_MAINNET_CHAIN_ID;
 exports.ARBITRUM_TESTNET_CHAIN_ID = constants.ARBITRUM_TESTNET_CHAIN_ID;
@@ -135,6 +160,7 @@ exports.COINGECKO_SUPPORTED_CURRENCIES = constants.COINGECKO_SUPPORTED_CURRENCIE
 exports.CONTRACT_TYPE_ERC1155 = constants.CONTRACT_TYPE_ERC1155;
 exports.CONTRACT_TYPE_ERC20 = constants.CONTRACT_TYPE_ERC20;
 exports.CONTRACT_TYPE_ERC721 = constants.CONTRACT_TYPE_ERC721;
+exports.CONTRACT_TYPE_ERC7821 = constants.CONTRACT_TYPE_ERC7821;
 exports.CONTRACT_TYPE_ETH = constants.CONTRACT_TYPE_ETH;
 exports.ERC1155_INTERFACE_ID = constants.ERC1155_INTERFACE_ID;
 exports.ERC721_ENUMERABLE_INTERFACE_ID = constants.ERC721_ENUMERABLE_INTERFACE_ID;
@@ -173,6 +199,15 @@ exports.hexWEIToDecGWEI = conversionUtils.hexWEIToDecGWEI;
 exports.multiplyCurrencies = conversionUtils.multiplyCurrencies;
 exports.subtractCurrencies = conversionUtils.subtractCurrencies;
 exports.toNegative = conversionUtils.toNegative;
+exports.EIP5792ErrorCode = eip5792Types.EIP5792ErrorCode;
+exports.EIP_5792_METHODS = eip5792Types.EIP_5792_METHODS;
+exports.Eip5792AtomicStatus = eip5792Types.Eip5792AtomicStatus;
+exports.GetCallsStatusCode = eip5792Types.GetCallsStatusCode;
+exports.SUPPORTED_EIP_5792_VERSIONS = eip5792Types.SUPPORTED_EIP_5792_VERSIONS;
+exports.DUMMY_AUTHORIZATION_SIGNATURE = eip7702Types.DUMMY_AUTHORIZATION_SIGNATURE;
+exports.EIP_7702_METHODS = eip7702Types.EIP_7702_METHODS;
+exports.EIP_7702_PREFIX = eip7702Types.EIP_7702_PREFIX;
+exports.EIP_7702_REVOKE_ADDRESS = eip7702Types.EIP_7702_REVOKE_ADDRESS;
 exports.BNToHex = helpers.BNToHex;
 exports.GAS_LIMITS = helpers.GAS_LIMITS;
 exports.addEtherscanTransactions = helpers.addEtherscanTransactions;
@@ -188,3 +223,4 @@ exports.hexToBn = helpers.hexToBn;
 exports.isAddressByChainId = helpers.isAddressByChainId;
 exports.sanitizeNftMetdataUrl = helpers.sanitizeNftMetdataUrl;
 exports.toChecksumAddressByChainId = helpers.toChecksumAddressByChainId;
+exports.TRANSACTION_CATEGORY_EIP7702 = interfaces.TRANSACTION_CATEGORY_EIP7702;

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

@@ -0,0 +1,3 @@
+export * from "./walletGetCallsStatus";
+export * from "./walletGetCapabilities";
+export * from "./walletSendCalls";

package/dist/lib.cjs/types/Eip5792/walletGetCallsStatus.d.ts

@@ -0,0 +1,19 @@
+import { TransactionStatus } from "@toruslabs/base-controllers";
+import { JRPCRequest } from "@web3auth/auth";
+import { TransactionStateManager } from "../Transaction/TransactionStateManager";
+import { Eip5792GetCallsStatusParams, Eip5792GetCallsStatusResponse, GetCallsStatusCode } from "../utils/eip5792Types";
+/**
+ * Maps a TransactionStatus to an EIP-5792 GetCallsStatusCode.
+ * @param status - The transaction status.
+ * @returns The corresponding EIP-5792 status code.
+ */
+export declare function mapTransactionStatusToEip5792Status(status: TransactionStatus): (typeof GetCallsStatusCode)[keyof typeof GetCallsStatusCode];
+/**
+ * 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.
+ */
+export declare function walletGetCallsStatus(request: JRPCRequest<[Eip5792GetCallsStatusParams]>, getTransactionByBatchId: TransactionStateManager["getTransactionByBatchId"]): Eip5792GetCallsStatusResponse;

package/dist/lib.cjs/types/Eip5792/walletGetCapabilities.d.ts

@@ -0,0 +1,17 @@
+import { JRPCRequest } from "@web3auth/auth";
+import { Eip5792GetCapabilitiesParams, Eip5792GetCapabilitiesResponse, GetCachedDelegationsFn, GetSupportedChainsFn } from "../utils/eip5792Types";
+import { GetEthCodeFn } from "../utils/interfaces";
+export interface WalletGetCapabilitiesContext {
+    getSupportedChains: GetSupportedChainsFn;
+    getCachedDelegations?: GetCachedDelegationsFn;
+    updateDelegationCache?: (walletAddress: `0x${string}`, chainId: `0x${string}`, delegation: `0x${string}` | null) => void;
+}
+/**
+ * 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.
+ */
+export declare function walletGetCapabilities(request: JRPCRequest<Eip5792GetCapabilitiesParams>, getEthCode: GetEthCodeFn, context: WalletGetCapabilitiesContext): Promise<Eip5792GetCapabilitiesResponse | undefined>;

package/dist/lib.cjs/types/Eip5792/walletSendCalls.d.ts

@@ -0,0 +1,45 @@
+import { JRPCRequest } from "@web3auth/auth";
+import { IProviderHandlers } from "../Network/createEthereumMiddleware";
+import { BatchTransactionParams, Eip5792SendCallsParams } from "../utils/eip5792Types";
+import { GetEthCodeFn } from "../utils/interfaces";
+export interface WalletSendCallsContext {
+    processTransaction: IProviderHandlers["processTransaction"];
+    processTransactionBatch: IProviderHandlers["processTransactionBatch"];
+}
+/**
+ * Generates a unique batch ID for EIP-5792 calls.
+ * @returns A unique hex string batch ID.
+ */
+export declare function generateBatchId(): `0x${string}`;
+/**
+ * Validates the parameters for wallet_sendCalls (EIP-5792).
+ * @param sendCallsParams - The parameters to validate.
+ */
+export declare function validateSendCallsParams(sendCallsParams: Eip5792SendCallsParams): void;
+export declare function processMultipleTransactions({ from, transactions, request, chainId, getEthCode, processTransactionBatch, }: {
+    from: `0x${string}`;
+    transactions: {
+        params: BatchTransactionParams;
+    }[];
+    request: JRPCRequest<Eip5792SendCallsParams>;
+    chainId: `0x${string}`;
+    getEthCode: GetEthCodeFn;
+    processTransactionBatch: IProviderHandlers["processTransactionBatch"];
+}): Promise<string>;
+export declare function processSingleTransaction({ transactions, request, processTransactionBatch, }: {
+    transactions: {
+        params: BatchTransactionParams;
+    }[];
+    request: JRPCRequest<Eip5792SendCallsParams>;
+    processTransactionBatch: IProviderHandlers["processTransactionBatch"];
+}): Promise<string>;
+/**
+ * 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.
+ */
+export declare function walletSendCalls(request: JRPCRequest<Eip5792SendCallsParams>, getEthCode: GetEthCodeFn, context: WalletSendCallsContext): Promise<string | undefined>;

package/dist/lib.cjs/types/Eip7702/eip7702Utils.d.ts

@@ -0,0 +1,27 @@
+import { Hex } from "viem";
+import { BatchTransactionParams } from "../utils/eip5792Types";
+import { GetEthCodeFn } from "../utils/interfaces";
+/**
+ * The MetaMask EIP-7702 Stateless Delegator contract address.
+ * Used as the delegation target for all supported networks.
+ */
+export declare const MetaMask_EIP7702_Stateless_Delegator: Hex;
+export declare function getDelegationAddress(walletAddress: `0x${string}`, chainId: `0x${string}`, getEthCode: GetEthCodeFn): Promise<`0x${string}` | null>;
+/**
+ * Check if the wallet is supported for EIP-7702 on provided chain.
+ */
+export declare function getIsEip7702UpgradeSupported(address: `0x${string}`, chainId: `0x${string}`, getEthCode: GetEthCodeFn): Promise<{
+    isSupported: boolean;
+    upgradeContractAddress?: `0x${string}`;
+    delegationAddress: `0x${string}` | null;
+}>;
+/**
+ * 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.
+ */
+export declare function generateEIP7702BatchTransaction(from: `0x${string}`, transactions: BatchTransactionParams[]): BatchTransactionParams;

package/dist/lib.cjs/types/Eip7702/walletGetUpgradeStatus.d.ts

@@ -0,0 +1,11 @@
+import { JRPCRequest } from "@web3auth/auth";
+import { Eip7702Params, Eip7702WalletGetUpgradeStatusResponse } from "../utils/eip7702Types";
+import { GetEthCodeFn } from "../utils/interfaces";
+/**
+ * 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.
+ */
+export declare function walletGetUpgradeStatus(request: JRPCRequest<Eip7702Params>, getEthCode: GetEthCodeFn): Promise<Eip7702WalletGetUpgradeStatusResponse>;

package/dist/lib.cjs/types/Eip7702/walletUpgradeAccount.d.ts

@@ -0,0 +1,13 @@
+import { JRPCRequest } from "@web3auth/auth";
+import { IProviderHandlers } from "../Network/createEthereumMiddleware";
+import { Eip7702Params } from "../utils/eip7702Types";
+import { GetEthCodeFn } from "../utils/interfaces";
+/**
+ * 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.
+ */
+export declare function walletUpgradeAccount(req: JRPCRequest<Eip7702Params>, getEthCode: GetEthCodeFn, processTransaction: IProviderHandlers["processTransaction"]): Promise<string>;

package/dist/lib.cjs/types/Keyring/KeyringController.d.ts

@@ -1,4 +1,5 @@
 import { BaseConfig, BaseKeyringController, IKeyringController, KeyringControllerState } from "@toruslabs/base-controllers";
+import { Authorization, UnsignedAuthorization } from "../utils/eip7702Types";
 import { SignTypedDataMessageV4 } from "../utils/interfaces";
 export declare class KeyringController extends BaseKeyringController<Partial<BaseConfig>, KeyringControllerState> implements IKeyringController {
     constructor({ config, state }: {
@@ -6,6 +7,7 @@ export declare class KeyringController extends BaseKeyringController<Partial<Bas
         state: Partial<KeyringControllerState>;
     });
     signTransaction<T, U>(tx: T, address: string): Promise<U>;
+    signEip7702Authorization(authorization: UnsignedAuthorization, address: string): Promise<Required<Authorization>>;
     getAccounts(): string[];
     importAccount(accountPrivateKey: string): string;
     removeAccount(address: string): void;

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

@@ -1,6 +1,8 @@
 import { type Analytics, InPageWalletProviderState, MessageParams, type ProviderConfig, SwitchChainMessageParams, UserRequestApprovalParams } from "@toruslabs/base-controllers";
 import { JRPCEngineEndCallback, JRPCEngineNextCallback, JRPCMiddleware, JRPCRequest, JRPCResponse } from "@web3auth/auth";
-import { AddChainMessageParams, BlockParams, EthereumTransactionMeta, TransactionParams, TransactionRPCMeta, TypedMessageParams, UserOperationGas } from "../utils/interfaces";
+import { TransactionStateManager } from "../Transaction/TransactionStateManager";
+import { Eip5792SendCallsParams, TransactionBatchRequest } from "../utils/eip5792Types";
+import { AddChainMessageParams, BlockParams, EthereumTransactionMeta, GetEthCodeFn, TransactionParams, TransactionRPCMeta, TypedMessageParams, UserOperationGas } from "../utils/interfaces";
 export interface IProviderHandlers {
     version: string;
     aaConfig?: {
@@ -12,6 +14,7 @@ export interface IProviderHandlers {
     getPrivateKey?: (req: JRPCRequest<unknown>) => Promise<string>;
     getPublicKey?: (req: JRPCRequest<unknown>) => Promise<string>;
     processTransaction?: (txParams: TransactionParams, req: JRPCRequest<TransactionParams> & UserRequestApprovalParams) => Promise<string>;
+    processTransactionBatch?: (batchRequest: TransactionBatchRequest, req: JRPCRequest<Eip5792SendCallsParams>) => Promise<string>;
     processSignTransaction?: (txParams: TransactionParams, req: JRPCRequest<TransactionParams> & UserRequestApprovalParams) => Promise<string>;
     processEthSignMessage?: (msgParams: MessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
     processTypedMessageV4?: (msgParams: TypedMessageParams, req: JRPCRequest<unknown> & UserRequestApprovalParams) => Promise<string>;
@@ -28,7 +31,30 @@ export interface IProviderHandlers {
         blockReference: string;
     }>) => Promise<string>;
     getPendingTransactionByHash?: (hash: string, req: JRPCRequest<string>) => Promise<EthereumTransactionMeta>;
+    getTransactionByBatchId: TransactionStateManager["getTransactionByBatchId"];
     getProviderState: (req: JRPCRequest<[]>, res: JRPCResponse<InPageWalletProviderState>, next: JRPCEngineNextCallback, end: JRPCEngineEndCallback) => void;
+    /**
+     * Query the deployment bytecode of an address. (eth_getCode)
+     */
+    getEthCode?: GetEthCodeFn;
+    /**
+     * EIP-5792 configuration for wallet capabilities and batch calls.
+     */
+    eip5792Config?: {
+        /**
+         * Get the list of supported chain IDs for EIP-5792/EIP-7702.
+         */
+        getSupportedChains: () => `0x${string}`[];
+        /**
+         * Get cached delegation addresses.
+         * Key format: `${walletAddress}-${chainId}`
+         */
+        getCachedDelegations?: () => Record<string, `0x${string}` | null>;
+        /**
+         * Update the delegation cache.
+         */
+        updateDelegationCache?: (walletAddress: `0x${string}`, chainId: `0x${string}`, delegation: `0x${string}` | null) => void;
+    };
 }
 export declare function createGetAccountsMiddleware({ getAccounts }: {
     getAccounts: IProviderHandlers["getAccounts"];
@@ -82,4 +108,30 @@ export declare function createAAMiddleware({ bundlerUrl, paymasterUrl, providerC
     providerConfig: ProviderConfig;
     analytics?: Analytics;
 }): JRPCMiddleware<unknown, unknown>;
+/**
+ * Middleware to handle EIP-7702 methods.
+ *
+ * @param getEthCode - Function to get the deployment bytecode of an address. (eth_getCode)
+ * @param processTransaction - Function to process a transaction.
+ * @returns JRPCMiddleware to handle EIP-7702 methods
+ */
+export declare function createEip7702Middleware({ getEthCode, processTransaction, }: {
+    getEthCode: GetEthCodeFn;
+    processTransaction: IProviderHandlers["processTransaction"];
+}): JRPCMiddleware<unknown, unknown>;
+/**
+ * Middleware to handle EIP-5792 methods.
+ * Supports wallet capabilities and batch call operations for EIP-7702 upgraded accounts.
+ *
+ * @param eip5792Config - Configuration for EIP-5792 handlers.
+ * @param processTransaction - Function to process a transaction.
+ * @returns JRPCMiddleware to handle EIP-5792 methods
+ */
+export declare function createEip5792Middleware({ eip5792Config, processTransaction, processTransactionBatch, getTransactionByBatchId, getEthCode, }: {
+    eip5792Config: IProviderHandlers["eip5792Config"];
+    processTransaction: IProviderHandlers["processTransaction"];
+    processTransactionBatch: IProviderHandlers["processTransactionBatch"];
+    getTransactionByBatchId: TransactionStateManager["getTransactionByBatchId"];
+    getEthCode: GetEthCodeFn;
+}): JRPCMiddleware<unknown, unknown>;
 export declare function createEthereumMiddleware(providerHandlers: IProviderHandlers, providerConfig?: ProviderConfig, analytics?: Analytics): JRPCMiddleware<unknown, unknown>;

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

@@ -5,6 +5,7 @@ import { GasFeeController } from "../Gas/GasFeeController";
 import { KeyringController } from "../Keyring/KeyringController";
 import { NetworkController } from "../Network/NetworkController";
 import { PreferencesController } from "../Preferences/PreferencesController";
+import { Eip5792SendCallsParams, TransactionBatchRequest } from "../utils/eip5792Types";
 import { EthereumTransactionMeta, TransactionParams } from "../utils/interfaces";
 import { NonceTracker } from "./NonceTracker";
 import { PendingTransactionTracker } from "./PendingTransactionTracker";
@@ -19,15 +20,17 @@ export declare class TransactionController extends TransactionStateManager imple
     private _getCurrentNetworkEIP1559Compatibility;
     private _getCurrentAccountEIP1559Compatibility;
     private signEthTx;
+    private signEip7702Authorization;
     private provider;
     private blockTracker;
     private inProcessOfSigning;
-    constructor({ config, state, provider, blockTracker, signEthTx, getCurrentChainId, getCurrentNetworkEIP1559Compatibility, getCurrentAccountEIP1559Compatibility, getSelectedAddress, getEIP1559GasFeeEstimates, }: {
+    constructor({ config, state, provider, blockTracker, signEthTx, signEip7702Authorization, getCurrentChainId, getCurrentNetworkEIP1559Compatibility, getCurrentAccountEIP1559Compatibility, getSelectedAddress, getEIP1559GasFeeEstimates, }: {
         config?: Partial<TransactionConfig>;
         state?: Partial<TransactionState<TransactionParams, EthereumTransactionMeta>>;
         provider: SafeEventEmitterProvider;
         blockTracker: PollingBlockTracker;
         signEthTx: KeyringController["signTransaction"];
+        signEip7702Authorization: KeyringController["signEip7702Authorization"];
         getCurrentChainId: NetworkController["getNetworkIdentifier"];
         getCurrentNetworkEIP1559Compatibility: NetworkController["getEIP1559Compatibility"];
         getCurrentAccountEIP1559Compatibility: (address?: string) => Promise<boolean>;
@@ -39,6 +42,10 @@ export declare class TransactionController extends TransactionStateManager imple
         origin: string;
         isUserOperation?: boolean;
     }): Promise<string>;
+    addNewUnapprovedTransactionsBatch(batchRequest: TransactionBatchRequest, req: JRPCRequest<Eip5792SendCallsParams> & UserRequestApprovalParams & {
+        origin: string;
+        isUserOperation?: boolean;
+    }): Promise<string>;
     processApproval(txMeta: EthereumTransactionMeta): Promise<string>;
     approveTransaction(transactionID: string): Promise<void>;
     signTransaction(txId: string, isSignOnly?: boolean): Promise<string>;
@@ -62,4 +69,5 @@ export declare class TransactionController extends TransactionStateManager imple
     private setupBlockTrackerListener;
     private onLatestBlock;
     private markNonceDuplicatesDropped;
+    private getTransactionType;
 }

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

@@ -20,6 +20,7 @@ export declare class TransactionStateManager extends BaseTransactionStateManager
         filterToCurrentNetwork?: boolean;
         limit?: number;
     }): EthereumTransactionMeta[];
+    getTransactionByBatchId(batchId: string): EthereumTransactionMeta;
     getApprovedTransactions(address?: string): EthereumTransactionMeta[];
     getSubmittedTransactions(address?: string): EthereumTransactionMeta[];
     getPendingTransactions(address?: string): EthereumTransactionMeta[];

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

@@ -1,5 +1,6 @@
 import { TransactionStatus } from "@toruslabs/base-controllers";
 import { SafeEventEmitterProvider } from "@web3auth/auth";
+import { NestedTransactionMetadata, TransactionBatchSingleRequest } from "../utils/eip5792Types";
 import { EthereumTransactionMeta, TransactionParams } from "../utils/interfaces";
 type NormalizableTransactionParams = keyof Omit<TransactionParams, "accessList">;
 /**
@@ -61,10 +62,46 @@ export declare const readAddressAsContract: (provider: SafeEventEmitterProvider,
     contractCode: string;
     isContractAddress: boolean;
 }>;
-export declare function determineTransactionType(txParams: TransactionParams, provider: SafeEventEmitterProvider): Promise<{
+export declare function determineTransactionType(txParams: TransactionParams, provider: SafeEventEmitterProvider, overrideTxMeta?: Partial<EthereumTransactionMeta>): Promise<{
     type: string;
     category: string;
     methodParams: any[];
     getCodeResponse: string;
 }>;
+/**
+ * Create the nested transaction metadata for a batch transaction.
+ *
+ * Reference: {@link https://github.com/MetaMask/core/blob/main/packages/transaction-controller/src/utils/batch.ts#L253}
+ *
+ * @param from - The sender address.
+ * @param batchTxParam - The batch transaction parameter.
+ * @param provider - The provider.
+ * @returns The nested transaction metadata.
+ */
+export declare function createNestedTransactionMeta(from: `0x${string}`, batchTxParam: TransactionBatchSingleRequest, provider: SafeEventEmitterProvider): Promise<NestedTransactionMetadata>;
+export declare function isEip7702SetCodeTx(txMeta: EthereumTransactionMeta): boolean;
+/**
+ * Check if a transaction is a EIP-7702 upgrade with data to self transaction.
+ * Example: batch transactions with EIP5792 `wallet_sendCalls` method with EIP-7702 upgrade.
+ *
+ * @example
+ * ```json
+ * {
+ *   "from": "0x1234567890123456789012345678901234567890",
+ *   "to": "0x1234567890123456789012345678901234567890",
+ *   "data": "0xdeadbeef", // ERC7821 execute batch function data
+ *   "type": "0x04",
+ *   "authorizationList": [
+ *     {
+ *       "address": "0x1234567890123456789012345678901234567890",
+ *       "chainId": "0x1",
+ *       "nonce": "0x1"
+ *     }
+ *   ]
+ * }
+ * ```
+ * @param txMeta - The transaction metadata
+ * @returns true if it's a EIP-7702 upgrade with data to self transaction
+ */
+export declare function isEip7702UpgradeWithDataToSelfTransaction(txMeta: EthereumTransactionMeta): boolean;
 export {};

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

@@ -3,6 +3,8 @@ export * from "./AccountAbstraction/AccountAbstractionController";
 export * from "./AccountAbstraction/smartAccounts";
 export { PollingBlockTracker } from "./Block/PollingBlockTracker";
 export { CurrencyController } from "./Currency/CurrencyController";
+export * from "./Eip5792";
+export * from "./Eip7702/eip7702Utils";
 export { GasFeeController } from "./Gas/GasFeeController";
 export * from "./Gas/IGasFeeController";
 export { KeyringController } from "./Keyring/KeyringController";
@@ -35,6 +37,8 @@ export * from "./Transaction/TransactionUtils";
 export * from "./utils/abis";
 export * from "./utils/constants";
 export * from "./utils/conversionUtils";
+export * from "./utils/eip5792Types";
+export * from "./utils/eip7702Types";
 export * from "./utils/helpers";
 export * from "./utils/interfaces";
 /**

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

@@ -82,3 +82,18 @@ export declare const singleBalanceCheckerAbi: ({
     stateMutability: string;
     type: string;
 })[];
+export declare const erc7821Abi: {
+    type: string;
+    name: string;
+    inputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    stateMutability: string;
+}[];

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

@@ -4,6 +4,7 @@ export declare const CONTRACT_TYPE_ETH = "eth";
 export declare const CONTRACT_TYPE_ERC20 = "erc20";
 export declare const CONTRACT_TYPE_ERC721 = "erc721";
 export declare const CONTRACT_TYPE_ERC1155 = "erc1155";
+export declare const CONTRACT_TYPE_ERC7821 = "erc7821";
 export declare const ERC1155_INTERFACE_ID = "0xd9b67a26";
 export declare const ERC721_INTERFACE_ID = "0x80ac58cd";
 export declare const ERC721_METADATA_INTERFACE_ID = "0x5b5e139f";
@@ -72,6 +73,7 @@ export declare const TRANSACTION_ENVELOPE_TYPES: {
     readonly LEGACY: "0x0";
     readonly ACCESS_LIST: "0x1";
     readonly FEE_MARKET: "0x2";
+    readonly SET_CODE: "0x4";
 };
 export declare const GAS_ESTIMATE_TYPES: {
     readonly FEE_MARKET: "fee-market";

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

@@ -0,0 +1,155 @@
+import { BaseRequestParams, TransactionReceipt } from "./interfaces";
+export declare const EIP_5792_METHODS: {
+    readonly WALLET_GET_CAPABILITIES: "wallet_getCapabilities";
+    readonly WALLET_SEND_CALLS: "wallet_sendCalls";
+    readonly WALLET_GET_CALLS_STATUS: "wallet_getCallsStatus";
+    readonly WALLET_SHOW_CALLS_STATUS: "wallet_showCallsStatus";
+};
+export declare const SUPPORTED_EIP_5792_VERSIONS: readonly ["1.0", "2.0"];
+/**
+ * A single call in a batch (EIP-5792)
+ */
+export interface Eip5792Call {
+    to: `0x${string}`;
+    value?: `0x${string}`;
+    data?: `0x${string}`;
+    capabilities?: Record<string, unknown>;
+}
+/**
+ * Parameters for wallet_sendCalls (EIP-5792)
+ */
+export interface Eip5792SendCallsParams extends BaseRequestParams {
+    version: string;
+    chainId: `0x${string}`;
+    calls: Eip5792Call[];
+    capabilities?: Record<string, unknown>;
+}
+/**
+ * Parameters for wallet_getCallsStatus (EIP-5792)
+ */
+export type Eip5792GetCallsStatusParams = `0x${string}`;
+/**
+ * Parameters for wallet_showCallsStatus (EIP-5792)
+ */
+export type Eip5792ShowCallsStatusParams = string;
+/**
+ * Parameters for wallet_getCapabilities (EIP-5792)
+ */
+export type Eip5792GetCapabilitiesParams = [`0x${string}`, `0x${string}`[]];
+export declare const EIP5792ErrorCode: {
+    UnsupportedNonOptionalCapability: number;
+    UnsupportedChainId: number;
+    UnknownBundleId: number;
+    RejectedUpgrade: number;
+};
+export declare const GetCallsStatusCode: {
+    PENDING: number;
+    CONFIRMED: number;
+    FAILED_OFFCHAIN: number;
+    REVERTED: number;
+    REVERTED_PARTIAL: number;
+};
+/**
+ * Response for wallet_getCallsStatus (EIP-5792)
+ */
+export interface Eip5792GetCallsStatusResponse {
+    id: string;
+    chainId: `0x${string}`;
+    atomic: boolean;
+    status: (typeof GetCallsStatusCode)[keyof typeof GetCallsStatusCode];
+    receipts?: TransactionReceipt[];
+}
+/**
+ * EIP-5792 atomic status (EIP-5792)
+ *
+ * Reference: https://eips.ethereum.org/EIPS/eip-5792#wallet_getcapabilities
+ */
+export declare const Eip5792AtomicStatus: {
+    readonly SUPPORTED: "supported";
+    readonly READY: "ready";
+    readonly UNSUPPORTED: "unsupported";
+};
+/**
+ * Capabilities for a chain (EIP-5792)
+ */
+export interface Eip5792ChainCapabilities {
+    atomic?: {
+        status: "supported" | "ready" | "unsupported";
+    };
+    paymasterService?: {
+        supported: boolean;
+        url?: string;
+    };
+    sessionKeys?: {
+        supported: boolean;
+    };
+}
+/**
+ * Response for wallet_getCapabilities (EIP-5792)
+ */
+export type Eip5792GetCapabilitiesResponse = Record<`0x${string}`, Eip5792ChainCapabilities>;
+/**
+ * Internal representation of a batch of calls
+ */
+export interface Eip5792CallBatch {
+    id: string;
+    chainId: `0x${string}`;
+    from: `0x${string}`;
+    calls: Eip5792Call[];
+}
+/**
+ * Function type for getting supported chains
+ */
+export type GetSupportedChainsFn = () => `0x${string}`[];
+/**
+ * Function type for getting cached delegations
+ */
+export type GetCachedDelegationsFn = () => Record<string, `0x${string}` | null>;
+/**
+ * The parameters of a transaction within an atomic batch.
+ */
+export type BatchTransactionParams = {
+    /** Data used to invoke a function on the target smart contract or EOA. */
+    data?: `0x${string}`;
+    /**
+     * Maximum number of units of gas to use for the transaction.
+     * Not supported in EIP-7702 batches.
+     */
+    gas?: `0x${string}`;
+    /**
+     * Maximum amount per gas to pay for the transaction, including the priority fee.
+     * Not supported in EIP-7702 batches.
+     */
+    maxFeePerGas?: `0x${string}`;
+    /**
+     * Maximum amount per gas to give to validator as incentive.
+     * Not supported in EIP-7702 batches.
+     */
+    maxPriorityFeePerGas?: `0x${string}`;
+    /** Address of the target contract or EOA. */
+    to?: `0x${string}`;
+    /** Native balance to transfer with the transaction. */
+    value?: `0x${string}`;
+};
+/** Metadata for a nested transaction within a standard transaction. */
+export type NestedTransactionMetadata = BatchTransactionParams & {
+    /** Type of the nested transaction. */
+    type?: string;
+};
+export type TransactionBatchSingleRequest = {
+    params: BatchTransactionParams;
+    type?: string;
+};
+/**
+ * Request to submit a batch of transactions.
+ * Currently only atomic batches are supported via EIP-7702.
+ */
+export type TransactionBatchRequest = {
+    batchId?: `0x${string}`;
+    /** Transactions to be submitted as part of the batch. */
+    transactions: TransactionBatchSingleRequest[];
+    /** Whether EIP-7702 upgrade is required for the batch. */
+    requiredEip7702Upgrade?: boolean;
+    /** Delegation address for EIP-7702 upgrade. */
+    eip7702UpgradeContractAddress?: `0x${string}`;
+};