Share on XShare on LinkedInShare on Telegram
Security Decisions/ Before launchWeb3 Security

ERC-7579 Explained: Modular Smart Account Security Risks

ERC-7579 lets smart accounts install validators, executors, fallback handlers, and hooks like apps, but every module is also an attack surface. This guide explains the four module types, reentrancy in onInstall callbacks, hook-based uninstall griefing, and how ERC-7484 registries and guardians help, plus a security checklist to run before you call installModule.

Author
QuillAudits Team
•October 19, 2026
ERC-7579 Explained: Modular Smart Account Security Risks
Share on XShare on LinkedInShare on Telegram

The decision · answer in brief

ERC-7579 lets smart accounts install validators, executors, fallback handlers, and hooks like apps, but every module is also an attack surface. This guide explains the four module types, reentrancy in onInstall callbacks, hook-based uninstall griefing, and how ERC-7484 registries and guardians help, plus a security checklist to run before you call installModule.

Here's ERC-7579 explained in one line: it's the standard that lets your smart account plug in validators, executors, fallback handlers, and hooks the same way your phone installs apps. That same plug-in interface is also a new attack surface. If you adopt ERC-7579, you're trusting that any module your account installs, including a malicious one, gets exactly the privileges its type ID implies, no more and no less. This post walks you through how ERC-7579 modularity works, where the standard's own security considerations flag real risk, and how an ERC-7484 module registry closes most of the gap before you ever call installModule.

ERC-7579 Explained: What Makes a Smart Account "Modular"

ERC-7579 defines a minimal, common interface so your smart account can install, uninstall, and query third-party modules without your wallet vendor inventing its own plumbing from scratch. The core functions are installModule, uninstallModule, and isModuleInstalled, and any module that implements them can, in theory, move between accounts built by different teams, as specified in ERC-7579: Minimal Modular Smart Accounts.

Before ERC-7579, modularity existed, but it was proprietary. Safe had its own module and guard system, Biconomy had its own, and a module written for one account rarely worked on another. ERC-7579 standardizes the interface so you, your auditor, and the tooling you rely on only need to understand one pattern instead of five.

The Four Module Types - Validators, Executors, Fallback Handlers, Hooks

The standard fixes the module taxonomy at four types, each with a numeric type ID that your account checks before installing anything, per ERC-7579's module type definitions:

Type IDModule typeRole
1ValidatorVerifies signatures and authorizes UserOperations before execution
2ExecutorExecutes transactions on behalf of the account
3Fallback handlerExtends the account's function selectors beyond its core interface
4HookRuns logic before and after execution (preCheck / postCheck)

Each type ID exists so your account can enforce separation of duties. A validator should only validate; it should never also be able to move funds. That distinction matters more than it sounds like it should, which is exactly what the next section gets into.

Why Does ERC-7579 Still Depend on ERC-4337 for Validation?

ERC-7579 doesn't replace account abstraction, it sits on top of it. The validation flow your modular account uses to accept a UserOperation is the one defined by ERC-4337, and ERC-7579's own spec notes this is a strict dependency today, one the authors expect to migrate to an optional extension as other account abstraction implementations mature.

Practically, that means a validator module you install under ERC-7579 gets handed the same trust ERC-4337's validateUserOp already carries. If that module is compromised or malicious, it inherits the authority to approve or reject every transaction your account tries to send. QuillAudits has covered the EOA side of account abstraction separately: EIP-7702 lets an externally owned account temporarily delegate execution to a smart contract through a new 0x04 transaction type. It solves a different problem (upgrading an EOA in place) than ERC-7579 does (standardizing modularity for accounts that are already smart contracts), and you'll see the two confused often since both ship under the account abstraction umbrella.

ERC-7579 Explained: Where Malicious Validators, Executors, and Hooks Get In

Your account's module interface doesn't distinguish good actors from bad ones, it only checks that a contract implements the right function signatures for its declared type. Anything that passes that check gets installed with the trust your account grants to that module type, which is exactly the opening ERC-7579's own Security Considerations section calls out.

When a Validator Behaves Like an Executor

The clearest warning in the spec is also the simplest to miss. ERC-7579's Security Considerations state that treating validators and executors as the same module type could let a validator execute arbitrary transactions on behalf of the account, according to the ERC-7579 specification on GitHub.

In other words, the type ID boundary is a trust boundary. A validator is supposed to answer one question: is this signature valid? If your account's implementation lets a type-1 module reach execution-level functions, a "validator" that looks benign during review can quietly act like a type-2 executor, moving assets instead of just checking who's allowed to move them. If you're auditing a modular account implementation, confirm that boundary is enforced in code, not just assumed from the type ID the module declares.

Reentrancy in onInstall/onUninstall Callbacks

Every module implements onInstall and onUninstall callbacks so it can set up or tear down its own state when you add or remove it from your account. Those callbacks execute arbitrary code supplied by the module, and the ERC-7579 spec warns they may lead to unexpected reentrancy, per the same Security Considerations section.

This is the same category of bug QuillAudits has documented elsewhere in a general form: reentrancy lets untrusted external code call back into a contract before its state finishes updating, a pattern behind incidents like The DAO and Grim Finance. In the module context, a malicious onInstall can call back into your account mid-installation, before your account has finished recording that the module exists, potentially letting the module act while your account's bookkeeping is still inconsistent.

Hooks That Break the Checks-Effects-Interactions Pattern

The checks-effects-interactions pattern says a function should validate its conditions, update its own state, and only then call out to another contract. Hooks invert that by design: a preCheck hook runs before your account's intended action, and a postCheck hook runs after it, which means hook logic sits on both sides of your account's state changes rather than cleanly before or after them.

The ERC-7579 spec is explicit that hook modules break the standard checks-effects-interactions pattern, and that a malicious hook can revert on preCheck or postCheck specifically to deny service to the account, according to the ERC-7579 GitHub specification. If you install a hook, you're accepting that every single transaction now routes through code you don't control at two points instead of zero.

What Is the Uninstall Griefing Problem?

Installing a module is reversible in theory, but removing one depends on the module behaving correctly when you ask it to leave. A hook, executor, or validator that was written, or later upgraded, to resist removal can turn a one-line uninstallModule call into a permanent fixture on your account.

How a Hook Can Revert on preCheck/postCheck to Trap Your Account

The same spec language that describes a hook denying service during normal operation applies to removal. A malicious module can revert specifically on onUninstall to block its own removal, as stated in ERC-7579's Security Considerations. Combine that with a hook's preCheck/postCheck position around every account action, and a single bad module install can leave you unable to execute transactions and unable to remove the thing causing it.

Picture how this plays out on an actual account. Say you install a spending-limit hook that's supposed to cap outgoing transfers at a daily ceiling you set. It works fine for weeks. Then the module's own upstream contract gets upgraded (hooks are often thin proxies pointing at logic the module author controls, not you), and the new postCheck implementation has a bug that makes it revert unconditionally, on every call, with no way to disable it from inside the hook itself. Every transaction you send now fails at the postCheck step. You call uninstallModule to remove it, and that triggers the hook's onUninstall, which also reverts, because the same broken logic sits behind both entry points. Your funds are still there. You just can't move any of them until you fall back to whatever recovery path you set up before this happened, which is the entire reason that path needs to exist before you need it, not after.

This is griefing, not theft: the attacker, or in the scenario above, just a bad upgrade, doesn't necessarily take funds, it takes your account's ability to function. QuillAudits' broader coverage of denial-of-service patterns in smart contracts describes the same family of attack (an unexpected revert that locks legitimate users out) in the context of auction refunds and gas griefing; the uninstall-blocking hook is that pattern applied to account infrastructure instead of a single contract function.

Guardian and Timelock Mitigations

Two mitigations recur across modular account implementations, and neither is part of the ERC-7579 interface itself, so you have to add them yourself:

  • Guardian-based recovery. A separate, pre-authorized key or multisig that can force-remove a module or migrate your account to a new implementation, bypassing the stuck module's own onUninstall logic.
  • Timelocks on module installation. A delay between requesting a module install and the install taking effect, giving you or a monitoring service a window to catch a malicious module before it gains any execution rights.

Neither guarantees recovery on its own. A guardian key is a new trust assumption, and a timelock only helps if someone's actually watching during the delay. Together, they reduce the uninstall-griefing problem from unrecoverable to recoverable-with-friction, which is the realistic bar for most production accounts today.

Using an ERC-7484 Registry to Gate Module Installation

If the risk is that any contract implementing the right function signatures can be installed, the fix is to check who vouches for that contract before you install it, not just what it claims to be. That's what ERC-7484 adds on top of ERC-7579.

ERC-7484 Attestations and Threshold Checks

ERC-7484 defines a registry extension with three check functions your account can call before trusting a module: check(address module), check(address module, uint256 moduleType), and check(address module, address[] attesters, uint256 threshold), as specified in ERC-7484: Registry Extension for ERC-7579. The threshold variant is the interesting one: you can require that at least N of a named list of attesters (auditors, security firms, or other trusted parties) have vouched for a module's code before installation proceeds.

Konrad Kopp and zeroknots, who authored ERC-7484, put the motivating problem plainly: "Adding third-party modules into Smart Accounts unchecked opens up a wide range of attack vectors," according to the ERC-7484 specification. A registry doesn't make a module safe, it makes your account's trust decision explicit and checkable instead of implicit and blind.

How Rhinestone's Module Registry Works in Practice

Rhinestone runs a module registry that puts the ERC-7484 pattern into production. It lists ERC-7579 modules only once they carry onchain attestations from named auditors, including Spearbit, ChainSecurity, OpenZeppelin, and Trail of Bits, according to Rhinestone's own documentation. When your account queries the registry at install time, you're effectively asking "which of these auditors signed off on this specific module code," not just "does this contract compile against the interface."

Rhinestone also built the Safe7579 adapter together with Safe, which makes existing Safe Smart Accounts compliant with ERC-7579 without requiring you to migrate to a new account contract, per the safe7579 repository. That adapter has been through third-party review in its own right: Ackee Blockchain Security's audit of the Rhinestone and Safe ERC-7579 adapter ran 16 engineering days from June 3 to June 14, 2024, with a 3-day follow-up review from July 2 to July 5, 2024, according to Ackee's audit summary. That tells you the adapter layer connecting an existing, widely used account (Safe) to the modular standard is itself reviewed infrastructure, not a thin shim you're trusting on faith.

Safe isn't the only account that implements ERC-7579. Kernel, built by ZeroDev, was the first account to ship native support, and Biconomy's Nexus and Etherspot's Modular Account have also implemented the standard, according to an explainer on ERC-7579 adoption. If you're comparing these implementations, ask the same question of each one: does the account check a registry before installing a module, or does it trust any contract that matches the interface?

If you're coming from Safe's original, pre-standard module system, the comparison is worth making directly. Safe's legacy modules and guards can execute transactions directly from a Safe with no signature threshold once enabled, and a malicious guard can freeze a Safe by rejecting every transaction. ERC-7579 doesn't eliminate those risks, it standardizes the interface they run through, which is exactly why a registry check at install time matters as much for a modular Safe as it did for the original module system.

A Module Security Checklist for Your ERC-7579 Account

Before you enable any module in production, work through this list:

  1. Confirm type ID enforcement. Verify your account implementation actually restricts validators to validation-only calls and doesn't let a type-1 module reach execution paths reserved for type-2 executors.
  2. Check attestations through an ERC-7484 registry before calling installModule, using threshold checks against named attesters rather than trusting an unverified contract address.
  3. Review onInstall/onUninstall for reentrancy and confirm your account's state updates finish before any external call back into module code.
  4. Test uninstall under adversarial conditions, including a module that reverts intentionally on onUninstall, preCheck, or postCheck, the way the scenario above played out.
  5. Put a guardian or timelock in place for module installation and removal so a stuck or malicious module has a recovery path that doesn't depend on the module's own cooperation.
  6. Treat hooks as your highest-risk module type by default, since they sit on both sides of every transaction rather than being invoked once.

Final Thoughts

None of this replaces a dedicated review. The interactions between module types, reentrancy across callbacks, and registry trust assumptions are exactly the kind of cross-cutting logic that's hard to catch by reading one module in isolation. A Smart Contract Audit that specifically covers your module install and uninstall paths, not just the modules themselves, can catch the griefing and privilege-escalation patterns described above before they reach mainnet. For more insights on securing Web3 projects, visit QuillAudits' research hub.

Explore more Security Decisions

Contents

Tell Us About Your Project
Subscribe to Newsletter
hashing bits image
Loading...

WE SECURE EVERYTHING YOU BUILD.

From day-zero risk mapping to exchange-ready audits, QuillAudits helps projects grow with confidence. Smart contracts, dApps, infrastructure, compliance: secured end to end.

QuillAudits Logo


ISO 27001Circle Alliance Program
Uniswap FoundationAethiropt-collectivePolygon SPNBNB Chain Kickstart

All Rights Reserved. © 2026. QuillAudits - LLC