Guide for App Developers: Leveraging EIP-7702 Enabled Wallets in Your dApp

EIP-7702 enables Externally Owned Accounts (EOAs) to temporarily delegate authority to smart contracts, unlocking smart account features like transaction batching, gas sponsorship, and session keys without permanent changes to the account.

This guide provides a concise, actionable roadmap for integrating EIP-7702 enabled wallets into your decentralized application (dApp), focusing on detecting support, wallet interactions, transaction batching (with EIP-7821), permissions (with EIP-7715), and transaction history.

Detecting EIP-7702 Support
Integrating with EIP-5792 for Wallet Interactions
Implementing Transaction Batching with EIP-7821
Managing Permissions with EIP-7715
Enhancing Transaction History

Detecting EIP-7702 Support

Before enabling EIP-7702 features, your dApp must confirm that the connected wallet supports this proposal to ensure compatibility and a seamless user experience.

Methods to Detect Support

Wallet Capabilities Check (Recommended): Use the wallet_getCapabilities method from EIP-5792 to query wallet features securely.

_10async function check7702Support(provider) { _10 try { _10 const capabilities = await provider.request({ method: 'wallet_getCapabilities' }); _10 return capabilities.includes('eip7702'); _10 } catch (error) { _10 console.error('Error checking EIP-7702 support:', error); _10 return false; _10 } _10}
On-Chain Verification (Alternative): Check for temporary smart contract code, though less reliable due to delegation’s transient nature.

_10function is7702Enabled(address eoa) public view returns (bool) { _10 return eoa.code.length > 0 && eoa.code[0] == 0xEF; // EIP-7702 marker _10}

Implementation Tip

Use the capabilities check to dynamically enable EIP-7702 features in your frontend, falling back to standard flows for unsupported wallets.

Integrating with EIP-5792 for Wallet Interactions

EIP-5792 provides JSON-RPC methods for dApps to interact with wallets, serving as the primary interface for accessing EIP-7702 features like batching and gas sponsorship.

Key Methods

wallet_sendCalls: Sends batched transactions.
wallet_getCapabilities: Queries supported features.
wallet_sponsorTransaction: Requests gas sponsorship.

Steps to Integrate

Study the EIP-5792 specification for method details.
Update wallet connection logic (e.g., ethers.js, Web3.js) to support these methods.
Handle responses and errors gracefully.

Example: Sending a Batch

async function sendBatchedTransactions(provider, transactions) {
    try {
        const result = await provider.request({
            method: 'wallet_sendCalls',
            params: [{ calls: transactions }]
        });
        console.log('Batch sent:', result);
        return result;
    } catch (error) {
        console.error('Error sending batch:', error);
        throw error;
    }
}

Next Steps

Check wallet provider documentation (e.g., Openfort) for EIP-5792 implementation specifics.

Implementing Transaction Batching with EIP-7821

Transaction batching, enabled by EIP-7702, allows multiple actions (e.g., token approval and swap) to be executed in a single transaction, reducing user signatures and improving UX. EIP-7821 complements this by introducing a standard for Call Operation Events, enabling wallets to emit structured events for batched calls, which simplifies tracking and verification.

How It Works

EIP-7702: The wallet delegates execution to a smart contract, which processes multiple calls in one transaction.
EIP-7821: Defines a CallOperation event emitted for each call in a batch, allowing dApps to parse and display individual operations (e.g., on block explorers or transaction histories).

EIP-7821 Event

event CallOperation(
    address indexed caller,
    address indexed target,
    bytes4 selector,
    uint256 value,
    bytes data,
    bool success,
    bytes returnData
);

Steps to Implement

Prepare Transactions: Create an array of transaction objects with to (target address) and data (encoded function call).
Send the Batch: Use EIP-5792’s wallet_sendCalls to execute the batch.
Parse CallOperation Events: Monitor transaction logs for CallOperation events to verify each call’s outcome and update your UI.

Example Code

const transactions = [
    { to: tokenAddress, data: approveData }, // Approve token
    { to: swapAddress, data: swapData }     // Perform swap
];
async function sendAndTrackBatch(provider, transactions) {
    const tx = await sendBatchedTransactions(provider, transactions);
    const receipt = await provider.getTransactionReceipt(tx.transactionHash);
    
    // Parse CallOperation events
    const callEventABI = [
        "event CallOperation(address indexed caller, address indexed target, bytes4 selector, uint256 value, bytes data, bool success, bytes returnData)"
    ];
    const iface = new ethers.utils.Interface(callEventABI);
    receipt juice.forEach(log => {
        try {
            const event = iface.parseLog(log);
            console.log(`Call to ${event.args.target} ${event.args.success ? 'succeeded' : 'failed'}`);
        } catch (e) {}
    });
    return receipt;
}

Benefits

EIP-7702: Fewer signatures, streamlined UX.
EIP-7821: Transparent tracking of batched calls, improving auditability and user trust.

UI Tip

Display batched transactions as a single action (e.g., “Approve + Swap”) with expandable details derived from CallOperation events.

Managing Permissions with EIP-7715

EIP-7702 enables temporary delegations, such as session keys, for restricted actions. EIP-7715 (Permission Tree) complements this by providing a standard for wallets to manage and expose granular permissions, allowing dApps to request specific capabilities (e.g., limited token transfers) without full account control.

Understanding EIP-7715

Defines a Permission Tree, a structured format for wallets to represent permissions (e.g., allowed functions, contracts, or time limits).
Enables dApps to query permissions via a getPermissions method, ensuring compatibility with wallet-managed restrictions.

Key Interface (EIP-7715)

interface IPermissionTree {
    function getPermissions(address account) external view returns (Permission[] memory);
    
    struct Permission {
        address target; // Contract address
        bytes4 selector; // Function selector
        uint256 valueLimit; // Max ETH value
        uint256 expiration; // Permission expiry
        bytes extraData; // Additional constraints
    }
}

Requesting Permissions

Use EIP-5792 or wallet-specific methods to request permissions, then query the wallet’s Permission Tree to verify granted capabilities.

Example Code

async function requestAndVerifyPermissions(provider, requestedPermissions) {
    try {
        // Request permissions (wallet-specific or future EIP-5792 extension)
        await provider.request({
            method: 'wallet_requestPermissions',
            params: [{
                target: tokenAddress,
                selector: '0xa9059cbb', // transfer(address,uint256)
                valueLimit: 0,
                expiration: Math.floor(Date.now() / 1000) + 3600
            }]
        });
        // Query Permission Tree
        const permissionTreeContract = new ethers.Contract(permissionTreeAddress, [
            'function getPermissions(address account) view returns (tuple(address target, bytes4 selector, uint256 valueLimit, uint256 expiration, bytes extraData)[])'
        ], provider);
        const permissions = await permissionTreeContract.getPermissions(await provider.getSigner().getAddress());
        console.log('Granted permissions:', permissions);
        return permissions;
    } catch (error) {
        console.error('Error managing permissions:', error);
        throw error;
    }
}

Note

EIP-7715 adoption may vary; ensure fallback logic for wallets without Permission Tree support.

Enhancing Transaction History

EIP-7702’s batched transactions require tailored handling to display meaningful history, especially with EIP-7821’s event logs.

Fetching On-Chain Data

Fetch ETH transfers directly to avoid third-party APIs:

struct Transfer {
    address from;
    address to;
    uint256 value;
}
function getEthTransfers(address account) public view returns (Transfer[] memory) {
    // Parse logs or traces (implementation-specific)
}

Handling Batched Transactions

Use EIP-7821’s CallOperation events to extract individual actions from a batch.
Display batches as a single entry with expandable details.

Example Code

async function displayTransactionHistory(provider, txHash) {
    const receipt = await provider.getTransactionReceipt(txHash);
    const callEventABI = [
        "event CallOperation(address indexed caller, address indexed target, bytes4 selector, uint256 value, bytes data, bool success, bytes returnData)"
    ];
    const iface = new ethers.utils.Interface(callEventABI);
    const actions = receipt.logs.map(log => {
        try {
            const event = iface.parseLog(log);
            return {
                target: event.args.target,
                success: event.args.success,
                action: event.args.selector
            };
        } catch (e) {
            return null;
        }
    }).filter(action => action);
    console.log('Batch actions:', actions);
    // Update UI with actions
}

Conclusion

This guide equips you to integrate EIP-7702 enabled wallets by:

Detecting support to ensure compatibility.
Using EIP-5792 for seamless wallet interactions.
Implementing transaction batching with EIP-7821 for auditable, streamlined UX.
Managing permissions with EIP-7715 for secure, granular control.
Enhancing transaction history with on-chain data and event parsing.

Guide for App Developers: Leveraging EIP-7702 Enabled Wallets in Your dApp

Table of Contents

Detecting EIP-7702 Support

Methods to Detect Support

Implementation Tip

Integrating with EIP-5792 for Wallet Interactions

Key Methods

Steps to Integrate

Example: Sending a Batch

Next Steps

Implementing Transaction Batching with EIP-7821

How It Works

EIP-7821 Event

Steps to Implement

Example Code

Benefits

UI Tip

Managing Permissions with EIP-7715

Understanding EIP-7715

Key Interface (EIP-7715)

Requesting Permissions

Example Code

Note

Enhancing Transaction History

Fetching On-Chain Data

Handling Batched Transactions

Example Code

Conclusion

Product

Industries

Resources

Company