> 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-7739.md).

# ERC-7739

## 📜 ERC-7739: Modular Programmable Authorization

ERC-7739 introduces a standard for modular programmable authorization in smart contracts, providing a flexible and extensible framework for access control and permission management on the Ethereum blockchain.

### 🏗️ Architecture

The ERC-7739 standard defines a modular architecture for programmable authorization, consisting of several key components:

### 🧠 Core Concepts

#### 1. AuthorizationManager 🎛️

The main contract that manages authorization modules and policies. It acts as the central hub for all authorization-related operations.

#### 2. AuthorizationModule 🧩

Interchangeable components that implement specific authorization logic. Examples include:

* RoleBasedModule: Implements role-based access control
* TokenGatedModule: Implements token-gated access
* MultiSigModule: Implements multi-signature authorization

#### 3. PolicyEngine 🚦

Manages and evaluates authorization policies. It consists of:

* PolicyRegistry: Stores and manages authorization policies
* PolicyEvaluator: Evaluates policies against authorization requests

### 🚶 User Flow

Here's a typical user flow for interacting with an ERC-7739 system:

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

### 💻 Implementation Details

#### AuthorizationManager Interface

```solidity
interface IAuthorizationManager {
    function isAuthorized(address user, bytes4 functionSelector, bytes calldata data) external view returns (bool);
    function addModule(address module) external;
    function removeModule(address module) external;
    function setPolicy(bytes32 policyId, bytes calldata policyData) external;
    // ... additional functions
}
```

#### AuthorizationModule Interface

```solidity
interface IAuthorizationModule {
    function checkAuthorization(address user, bytes4 functionSelector, bytes calldata data) external view returns (bool);
    function initialize(bytes calldata data) external;
    // ... additional functions
}
```

#### PolicyEngine Interface

```solidity
interface IPolicyEngine {
    function evaluatePolicy(bytes32 policyId, address user, bytes4 functionSelector, bytes calldata data) external view returns (bool);
    function setPolicy(bytes32 policyId, bytes calldata policyData) external;
    // ... additional functions
}
```

### 🚀 Example Implementation

Here's a basic implementation of an ERC-7739 AuthorizationManager:

```solidity
pragma solidity ^0.8.0;

import "./IAuthorizationManager.sol";
import "./IAuthorizationModule.sol";
import "./IPolicyEngine.sol";

contract AuthorizationManager is IAuthorizationManager {
    mapping(address => bool) private modules;
    IPolicyEngine public policyEngine;

    constructor(address _policyEngine) {
        policyEngine = IPolicyEngine(_policyEngine);
    }

    function isAuthorized(address user, bytes4 functionSelector, bytes calldata data) external view override returns (bool) {
        bool moduleAuthorized = false;
        for (address module in modules) {
            if (IAuthorizationModule(module).checkAuthorization(user, functionSelector, data)) {
                moduleAuthorized = true;
                break;
            }
        }
        
        if (!moduleAuthorized) {
            return false;
        }

        return policyEngine.evaluatePolicy(keccak256(abi.encodePacked(user, functionSelector)), user, functionSelector, data);
    }

    function addModule(address module) external override {
        // Add access control here
        modules[module] = true;
    }

    function removeModule(address module) external override {
        // Add access control here
        delete modules[module];
    }

    function setPolicy(bytes32 policyId, bytes calldata policyData) external override {
        // Add access control here
        policyEngine.setPolicy(policyId, policyData);
    }
}
```

### 🔑 Key Features

* 🧩 Modular design for flexible authorization logic
* 🔄 Easy upgradeability of authorization mechanisms
* 🔒 Enhanced security through separate authorization modules
* 📜 Programmable policies for fine-grained access control
* 🔌 Interoperability with existing Ethereum smart contracts

ERC-7739 provides a powerful framework for creating modular and programmable authorization systems, enabling developers to build sophisticated and adaptable access control mechanisms. This standard paves the way for more secure and flexible smart contract interactions while maintaining high levels of customizability and extensibility.


---

# 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-7739.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.