An attacker drained approximately $7.73 million in rsETH from a Gnosis Safe wallet on Ethereum around 04:38 UTC on September 15, exploiting a flawed authorization check that let attacker-controlled calls execute through a trusted executor contract. Blockaid confirmed the incident within hours.
🚨Blockaid exploit detection system detected an exploit on an unidentified user's Safe on Ethereum.
— Blockaid (@blockaid_) September 15, 2026
~$7.73M confirmed rsETH loss so far.
An attacker used a public keeper multicall to drive a custom Uni V4 LP Safe module into an attacker-created hooked pool; the hook unwrapped…
The victim wallet, address 0x40E93a52F6Af9fCD3b476aeDADD7FeABD9f7AbA8, lost roughly 2,900 aEthrsETH, Aave's interest-bearing representation of restaked ETH. The attack moved those funds into a Uniswap V4 pool paired against a token the attacker had created called the "Permissionless Attacker Token," which left the Safe holding a worthless LP NFT instead of its original collateral.
How a single parameter broke the entire permission system
SlowMist identified the precise mechanism. In the multicall function of the router contract at address 0x4f0055926c839d1d960a82cbf84e2ee933958ebc, the _contract parameter could be set to address(this). When that happened, the internal _isAuthorized function used for permission checks would unconditionally return true regardless of who was calling it.
🚨SlowMist TI Alert🚨
— SlowMist (@SlowMist_Team) September 15, 2026
💸 Unknown Gnosis Safe wallet Loss: ~$7.73M
🔍 Root Cause: In the `multicall(address, bytes[])` function of the Router contract (address `0x4f005592…`), the `_contract` parameter could be set to `address(this)`. Consequently, the `_isAuthorized`…
That single flaw let the victim's own Safe module execute attacker-crafted call data through DelegateCall, a low-level Ethereum function that runs external code in the context of the calling contract's storage and permissions. BlockSec Phalcon described the same root cause independently:
"Setting the supplied contract parameter to address(this) passed validation, allowing attacker-controlled calls to execute from the trusted executor through an enabled Safe module."
DelegateCall vulnerabilities have a long and costly history in Ethereum smart contracts. The 2017 Parity multisig wallet freeze, which locked approximately $280 million worth of ETH permanently, stemmed from a related class of issue where a library contract could be manipulated through delegate calls to change ownership and then self-destruct. The mechanism differs from the Gnosis Safe exploit in its specifics, but both cases share a common root: DelegateCall executes code in the caller's storage context, which means any flaw in how a contract validates the target or parameters of that call can grant an attacker the same permissions as the legitimate contract owner. This is precisely why the authorization check bypass in the router contract had such severe consequences: once _isAuthorized returned true unconditionally, the attacker inherited the full trust the Safe module had already been granted.
The Uniswap V4 hook that made the theft possible
The attacker used what Blockaid described as "a custom Uni V4 LP Safe module into an attacker-created hooked pool; the hook unwrapped aEthrsETH to rsETH." Uniswap V4, which introduced a hooks architecture which allowed developers to customize pool behavior at specific points in a swap or liquidity event, gave the attacker a mechanism to convert the Safe's aEthrsETH holdings into transferable rsETH at the moment liquidity entered the malicious pool.
Uniswap V4's hooks system launched in early 2025 as a significant architectural departure from V3, making it possible for external contracts to inject custom logic before and after swaps, liquidity additions, and liquidity removals. The flexibility that makes hooks powerful for legitimate use cases, such as custom fee structures or automated rebalancing, is the same flexibility that let this attacker design a pool specifically engineered to unwrap a Safe's yield-bearing collateral into a liquid, transferable asset the moment it entered the pool. Security researchers have flagged hooks as an expanding attack surface since V4's launch, precisely because a pool's hook contract can execute arbitrary logic that liquidity providers may not fully audit before depositing.
The MEV bot that beat the attacker to the payout
In an unusual twist, the attacker did not keep the proceeds. An MEV bot called "yoink" front-ran the original attack transaction within the same block, extracting approximately 2,882 rsETH, worth roughly $7.8 million, and routing it to a separate address: 0xC70f00CD7E461686b04B0E912E309becA8b80ea0.
MEV, or maximal extractable value, refers to profit that can be captured by reordering, inserting, or censoring transactions within a block before it is finalized. Searchers running MEV bots continuously scan the public mempool for profitable opportunities, including, in this case, an exploit transaction whose outcome could be intercepted and redirected before the original attacker's transaction settled. This is not the first instance of an MEV bot capturing the proceeds of someone else's exploit; similar front-running of hack transactions has occurred repeatedly across DeFi, since an exploit transaction sitting in the public mempool is visible to anyone monitoring it, including bots designed specifically to extract value from exactly this kind of opportunity. The practical effect here is that the original attacker likely walked away with nothing, while a separate, unidentified MEV operator now holds the stolen funds.
BlockSec Phalcon published both transaction hashes for verification: the original attack transaction and the front-running transaction that redirected the funds. Kelp DAO, the protocol behind rsETH, paused the receiving address for 24 hours while security teams continued their investigation.
What this means for modular Safe wallets going forward
The exploit exposes a specific risk category tied to Gnosis Safe's modular architecture. Safe modules extend a wallet's functionality beyond the base multisig logic, which allows integrations like automated liquidity management or yield strategies to operate with delegated permissions. When a module's own authorization logic contains a flaw, the module's trusted status within the Safe becomes the attack vector rather than a protection.
Gnosis Safe, now operating under the Safe ecosystem brand, secures a substantial share of DeFi's total value locked as the dominant multisig standard across Ethereum and EVM-compatible chains. Its module system was designed to let sophisticated users and DAOs add custom functionality without redeploying their core wallet contract, but each module represents an independent trust boundary that must be audited on its own terms. This incident demonstrates that a vulnerability in a third-party module, rather than in Safe's core contracts, can still result in complete loss of the assets a Safe holds, since the module inherits meaningful execution authority once it is enabled.
Neither the identity of the original attacker nor the operator of the yoink MEV bot has been publicly confirmed. Security researchers continue to trace the flow of funds following the front-run transaction.
Tanya Petrusenko
Disclaimer: All materials on this site are for informational purposes only. None of the material should be interpreted as investment advice. Please note that, despite the nature of much of the material created and hosted on this website, HODL FM operates as a media and informational platform, not a provider of financial advisory services. The opinions of authors and other contributors are their own and should not be taken as financial advice. If you require advice, HODL FM strongly recommends contacting a qualified industry professional.
