Discover how the FlashLoopAdapter exploit drained approximately $310,000 from two Safe wallets using leveraged Aave v3 positions. This breakdown explains how a forged isModuleEnabled() check bypassed module authentication, enabled unauthorized collateral withdrawals, and exposed critical access control weaknesses in a third-party adapter. Learn key lessons for Safe multisig security, module reviews, smart contract audits, and protecting DeFi treasuries from similar attacks.

Discover how the FlashLoopAdapter exploit drained approximately $310,000 from two Safe wallets using leveraged Aave v3 positions. This breakdown explains how a forged isModuleEnabled() check bypassed module authentication, enabled unauthorized collateral withdrawals, and exposed critical access control weaknesses in a third-party adapter. Learn key lessons for Safe multisig security, module reviews, smart contract audits, and protecting DeFi treasuries from similar attacks.
On October 1, 2026, an attacker drained roughly $310,000 from two Safe wallets running leveraged Aave v3 positions on Ethereum mainnet by spoofing a single access control check inside a third-party module called FlashLoopAdapter. This FlashLoopAdapter exploit explained walkthrough breaks down how a forged isModuleEnabled() call let the attacker impersonate a trusted module and pull collateral straight out of two Safes in one transaction, and what treasury signers should check before they ever click "enable module" again.
FlashLoopAdapter is a third-party Safe module built to open and close leveraged Aave v3 positions on behalf of a Safe, not a contract maintained by Aave or Safe itself. One Safe lost 1,306.48 weETH and the second lost 6.43 weETH; Cryptobriefing reported the combined loss at up to $310,000.
The attacker pulled this off with a flash loan.
FlashLoopAdapter is the latest entry in a pattern that has been building all year: a Safe multisig module exploit in 2026 rarely targets Safe's core contracts or an audited protocol like Aave v3. It targets the module a treasury enabled to add convenience, because that module inherits the Safe's full execution rights the moment it is turned on.
Safe's module system is intentionally permissive by design. Any address added as a module can call execTransactionFromModule() and move funds or change state without collecting owner signatures, which is exactly why modules exist, to automate recurring actions like leverage management without a manual signing ceremony every time. That convenience is also the attack surface. A module does not need a bug in Safe's code to cause a loss; it only needs a bug in its own code, because the Safe already trusts it completely.
The same structural lesson shows up outside the module context too. QuillAudits' coverage of the Drift Protocol multisig exploit describes a $285 million loss where attackers social-engineered signers into pre-signing malicious transactions, bypassing Drift's audited smart contracts entirely through an operational security gap. Different mechanism, same root lesson: the point of failure sits wherever trust is granted outside the core protocol's own audited logic, whether that trust goes to a module, a signer, or a pre-signed nonce.
FlashLoopAdapter's open() and close() functions decided whether to act on a Safe's behalf by calling isModuleEnabled(msg.sender) back on the caller and trusting whatever answer came back; because any contract can implement that function to return true unconditionally, an attacker could deploy a fake Safe that always confirmed FlashLoopAdapter as "enabled," letting the real module execute privileged withdrawal logic against a victim Safe it had never actually been authorized on.
The function was meant to confirm the reverse relationship, that the Safe had enabled FlashLoopAdapter as a module, before letting it move funds. Instead it asked the caller to vouch for itself. As Verichains put it: "The adapter made that call, so the Safe saw FlashLoopAdapter - its enabled module - as msg.sender and executed the attacker's instructions." Once the attacker's contract satisfied that single check, the module treated every subsequent instruction, including collateral withdrawal from a real, unrelated Safe, as legitimate.
Verichains' analysis traces the exploit through a single atomic transaction:
isModuleEnabled() function always returned true, regardless of which address was actually being checked.No signature from either victim Safe's actual owners was ever requested or needed. The entire sequence ran on FlashLoopAdapter's authority as an enabled module.
The root cause was not a reentrancy bug, an oracle manipulation, or a rounding error, the usual suspects in DeFi hack writeups. It was a single authentication check that trusted the wrong party. FlashLoopAdapter needed to know "has this Safe enabled me as a module," and it asked the caller to answer that question about itself instead of checking the Safe's own module registry directly.
This is a narrower failure than it sounds, but it is also a common one in adapter contracts that sit between a wallet standard and a lending protocol: the integration glue is often written and reviewed with less scrutiny than the core contracts it connects. Aave v3's lending logic was never touched. Safe's module framework worked exactly as designed, it granted execution rights to whatever address the Safe owner enabled, and FlashLoopAdapter was that address. The victims' real mistake, if there was one, was trusting a third-party adapter's internal logic as much as they trusted Safe's own audited core.
Enabling a module is not a convenience setting, it is an unconditional grant of your Safe's execution rights to that contract's code, forever, until someone removes it. Before a treasury signer enables any third-party module, including a leverage adapter like FlashLoopAdapter, the checklist should include:
QuillAudits' Safe Inspector guide walks through pulling a Safe's owners, threshold, modules, and guards directly from chain in under a minute, the exact check that would have surfaced FlashLoopAdapter sitting on a Safe's module list before the exploit. The underlying tool, Multisig Inspector, reads a Safe's current module list, owners, and signature threshold straight from the blockchain and runs read-only with no wallet connection or signature required, so a treasury can check its own configuration without exposing a key. Its companion Transaction Inspector decodes a pending transaction's target, call type, and value before anyone signs, instead of leaving a signer to approve raw calldata blind.
Neither tool would have caught a bug buried inside FlashLoopAdapter's own open() function, that is what a full smart contract audit of the adapter itself is for. And a configuration check only works if someone actually runs it before a module is enabled or a transaction is signed; it cannot undo a withdrawal that already cleared. What it does reliably catch is the setup step that made this exploit possible in the first place: a module sitting enabled on a Safe that nobody had re-examined since the day it was added.
Aave v3's lending markets and Safe's core multisig contracts both came through the FlashLoopAdapter incident unaffected; the $300,000-plus loss sat entirely inside a third-party adapter's authentication logic. For treasury operators, the lesson generalizes past this one module: every address with module rights on a Safe deserves the same scrutiny as the protocols it touches, because the Safe will execute its instructions without asking twice. A comprehensive Blockchain Audit can help identify weaknesses in third-party adapters and modules before they reach a production treasury Safe. For more insights on securing Web3 projects, visit QuillAudits' research hub.
Contents

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