ERC-7579 — Modular Smart Accounts

Back to Infrastructure & Patterns

ERC-7579: Minimal Modular Smart Accounts

ERC-7579 standardises a module interface for smart-contract accounts (built on ERC-4337). Modules plug into accounts to add features: validators (validate user ops), executors (perform transactions), fallback handlers, hooks. The goal is to let users mix-and-match modules from different vendors without rebuilding their account.

Module Types

Type	Purpose	Methods
Validator	Authorize user ops	validateUserOp, isValidSignature
Executor	Execute transactions	execute, executeFromExecutor
Fallback handler	Handle unknown calls	fallback
Hook	Pre/post call hooks	preCheck, postCheck

Neo Equivalent

Neo C# port: a programmable account contract whose Verify method delegates to a list of "validator" contracts, and whose Execute method optionally runs through "hook" contracts. Modules are themselves Neo contracts; the account stores their script hashes and dispatches.

Live on Neo TestNet

Both implementations are deployed on Neo N3 TestNet (network magic 894710606).

Implementation	Contract Hash	Deploy Tx
Solidity (neo-solc)	0x5e6edfc08e536f6d8891af968a52f7d56c11a528	(reused — see 0x5e6edfc08e536f6d8891af968a52f7d56c11a528)
Neo C# (nccs)	0xcbd2e64f3ef5d5c9069fadf9c7d72ffcb8664f86	(reused — see 0xcbd2e64f3ef5d5c9069fadf9c7d72ffcb8664f86)

Cross-implementation invocations match on moduleCount. Source pairs under docs/standards-mirror/deployments/erc-7579/.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IValidator {
    function validateUserOp(bytes32 hash, bytes calldata data) external view returns (uint256);
    function isValidSignature(bytes32 hash, bytes calldata data) external view returns (bytes4);
}

interface IExecutor {
    function execute(address account, bytes calldata data) external;
}

contract ModularAccount {
    mapping(address => bool) public installedValidators;
    mapping(address => bool) public installedExecutors;

    function installModule(uint256 moduleType, address module, bytes calldata initData) external {
        // ... auth check (only owner) ...
        if (moduleType == 1) {
            installedValidators[module] = true;
            (bool ok, ) = module.call(initData);
            require(ok);
        } else if (moduleType == 2) {
            installedExecutors[module] = true;
            (bool ok, ) = module.call(initData);
            require(ok);
        }
    }

    function uninstallModule(uint256 moduleType, address module) external {
        // ... auth check ...
        if (moduleType == 1) installedValidators[module] = false;
        if (moduleType == 2) installedExecutors[module] = false;
    }

    function executeFromExecutor(bytes calldata data) external {
        require(installedExecutors[msg.sender], "not installed");
        // ... dispatch ...
    }
}

using System;
using System.ComponentModel;
using System.Numerics;
using Neo;
using Neo.SmartContract.Framework;
using Neo.SmartContract.Framework.Attributes;
using Neo.SmartContract.Framework.Native;
using Neo.SmartContract.Framework.Services;

namespace R3E.Examples;

public enum ModuleType : byte { Validator = 1, Executor = 2, Hook = 3 }

[DisplayName("ModularAccount")]
[ContractPermission("*", "*")]
[SupportedStandards(NepStandard.Nep30)]
public class ModularAccount : SmartContract
{
    private const byte Prefix_Module = 0x01;  // type+addr -> 1 if installed
    private const byte Prefix_Hook   = 0x02;  // ordered list of hook contracts
    private static readonly byte[] OwnerKey = { 0xff };

    [DisplayName("ModuleInstalled")]
    public static event Action<byte, UInt160> OnInstalled;

    public static void InstallModule(byte moduleType, UInt160 module, object initData)
    {
        var owner = (UInt160)Storage.Get(Storage.CurrentContext, OwnerKey);
        if (!Runtime.CheckWitness(owner)) throw new Exception("owner only");

        Storage.Put(Storage.CurrentContext,
                    new byte[] { Prefix_Module, moduleType }.Concat(module), 1);
        // Initialise the module with its module-specific data
        Contract.Call(module, "onInstall", CallFlags.All, new object[] { initData });
        OnInstalled(moduleType, module);
    }

    /// <summary>
    /// NEP-30 verify dispatched through any installed validator. Any single
    /// validator returning true authorises the transaction.
    /// </summary>
    public static bool Verify(object opHash, object signature)
    {
        var iter = Storage.Find(Storage.CurrentContext,
                                new byte[] { Prefix_Module, (byte)ModuleType.Validator },
                                FindOptions.KeysOnly | FindOptions.RemovePrefix);
        while (iter.Next())
        {
            var validator = (UInt160)iter.Value;
            try
            {
                var ok = (bool)Contract.Call(validator, "validateUserOp",
                                             CallFlags.ReadOnly,
                                             new object[] { opHash, signature });
                if (ok) return true;
            }
            catch { /* try next validator */ }
        }
        return false;
    }

    public static object Execute(UInt160 target, string method, object[] args)
    {
        if (!Verify(null, null)) throw new Exception("verify failed");

        // Run pre-hooks
        var hookIter = Storage.Find(Storage.CurrentContext,
                                    new byte[] { Prefix_Module, (byte)ModuleType.Hook },
                                    FindOptions.KeysOnly | FindOptions.RemovePrefix);
        while (hookIter.Next())
            Contract.Call((UInt160)hookIter.Value, "preCheck", CallFlags.All,
                          new object[] { target, method, args });

        var result = Contract.Call(target, method, CallFlags.All, args);

        // Run post-hooks (re-iterate; iterator is one-shot)
        hookIter = Storage.Find(Storage.CurrentContext,
                                new byte[] { Prefix_Module, (byte)ModuleType.Hook },
                                FindOptions.KeysOnly | FindOptions.RemovePrefix);
        while (hookIter.Next())
            Contract.Call((UInt160)hookIter.Value, "postCheck", CallFlags.All,
                          new object[] { target, method, result });

        return result;
    }

    public static void _deploy(object data, bool update)
    {
        if (update) return;
        Storage.Put(Storage.CurrentContext, OwnerKey, (UInt160)data);
    }
}