> For the complete documentation index, see [llms.txt](https://www.ankitavirani.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://www.ankitavirani.com/experience/protocols/ercs-and-eips/erc-7715.md).

# ERC-7715

## 📜 ERC-7715: Modular Smart Contract Accounts

ERC-7715 introduces a standard for modular smart contract accounts, providing a flexible and extensible framework for account abstraction on the Ethereum blockchain.

### 🏗️ Architecture

The ERC-7715 standard defines a modular architecture for smart contract accounts, consisting of several key components:

<figure><img src="/files/f0cDr95H8N5qR4KDCOI9" alt=""><figcaption></figcaption></figure>

### 🧠 Core Concepts

#### 1. Account 👤

The main smart contract that represents the user's account. It manages modules and delegates calls to them.

#### 2. AccountRegistry 📚

A central registry that keeps track of all accounts and their associated modules.

#### 3. Modules 🧩

Interchangeable components that provide specific functionalities to the account:

* ExecutionModule: Handles the execution of transactions
* ValidationModule: Validates transactions before execution
* HookModule: Provides pre and post-execution hooks

#### 4. Fallback ↩️

A mechanism to handle calls to undefined functions, providing flexibility for future extensions.

### 🚶 User Flow

Here's a typical user flow for interacting with an ERC-7715 account:

<figure><img src="/files/bJdDqtGWHZDtMOkPUzfh" alt=""><figcaption></figcaption></figure>

### 💻 Implementation Details

#### Account Interface

```solidity
interface IERC7715Account {
    function execute(bytes calldata _data) external payable returns (bytes memory);
    function isValidSignature(bytes32 _hash, bytes memory _signature) external view returns (bytes4);
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
    // ... additional functions
}
```

#### Module Interface

```solidity
interface IERC7715Module {
    function isInitialized(address _account) external view returns (bool);
    function initialize(bytes calldata _data) external returns (bytes memory);
    // ... additional functions
}
```

#### AccountRegistry Interface

```solidity
interface IERC7715AccountRegistry {
    function registerAccount(address _account, address _owner) external;
    function isRegistered(address _account) external view returns (bool);
    function getAccountOwner(address _account) external view returns (address);
    // ... additional functions
}
```

### 🚀 Example Implementation

Here's a basic implementation of an ERC-7715 Account:

```solidity
pragma solidity ^0.8.0;

import "./IERC7715Account.sol";
import "./IERC7715Module.sol";

contract ERC7715Account is IERC7715Account {
    mapping(bytes4 => address) private modules;

    function execute(bytes calldata _data) external payable override returns (bytes memory) {
        address module = modules[bytes4(keccak256("execute(bytes)"))];
        require(module != address(0), "Execution module not set");
        return IERC7715Module(module).execute(_data);
    }

    function isValidSignature(bytes32 _hash, bytes memory _signature) external view override returns (bytes4) {
        address module = modules[bytes4(keccak256("isValidSignature(bytes32,bytes)"))];
        require(module != address(0), "Validation module not set");
        return IERC7715Module(module).isValidSignature(_hash, _signature);
    }

    function setModule(bytes4 _selector, address _module) external {
        // Add access control here
        modules[_selector] = _module;
    }

    function supportsInterface(bytes4 interfaceId) external view override returns (bool) {
        return interfaceId == type(IERC7715Account).interfaceId;
    }

    // Fallback function to handle undefined calls
    fallback() external payable {
        address fallbackModule = modules[bytes4(0)];
        if (fallbackModule != address(0)) {
            (bool success, ) = fallbackModule.delegatecall(msg.data);
            require(success, "Fallback call failed");
        }
    }
}
```

### 🔑 Key Features

* 🧩 Modular design for flexible functionality
* 🔄 Easy upgradeability of account features
* 🔒 Enhanced security through separate validation modules
* 🎣 Extensible with pre and post-execution hooks
* 🔌 Interoperability with existing Ethereum infrastructure

ERC-7715 provides a powerful framework for creating modular smart contract accounts, enabling developers to build sophisticated and adaptable account systems. This standard paves the way for more user-friendly and feature-rich blockchain applications while maintaining high levels of security and flexibility.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://www.ankitavirani.com/experience/protocols/ercs-and-eips/erc-7715.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.