Date: August 7, 2026
Chain: Arbitrum
Loss: 29,984.27 USDC
Class: a reusable manager signature, plus LP exits priced off a pool anyone could move
Atomic Green's position manager only burned a Uniswap V3 liquidity position when a privileged manager address had signed off on it. On August 7, 2026, an attacker took one legitimately issued manager signature and presented it against 21 different positions, and the contract accepted it every time.
Each acceptance force-burned a liquidity position, and a flash loan had already pushed the pool's price where the attacker wanted it, so every burn settled in the attacker's favor. Together they pulled 29,984.27 USDC out of the protocol on Arbitrum. The signature carried no position ID, no caller, no nonce, no deadline and no chain ID, so nothing in it tied the approval to the single operation it was meant for.
Atomic Green describes itself as a non-custodial leveraged trading protocol on Arbitrum. Its first product routes leveraged exposure through Uniswap V3 concentrated liquidity pools and borrows trading margin from its own lending pools. In that setup, the LP positions the protocol manages are both collateral and settlement, so the authority to burn them is the authority to move the money inside them.
The position manager handled that authority. Before it burned a position, it required a signature from the manager address over a hash of the request, so everything depended on what that hash covered.
According to SlowMist's alert, the signed digest left out every field that would have pinned it to one operation: the position ID being burned, the caller submitting it, a nonce that gets used up, a deadline after which it expires, and the chain ID. A signature built that way works like a signed blank check that never clears. The bank confirms the signature is genuine, cashes it, and has no way to notice it's already been cashed 20 times for 20 different amounts.
The safer pattern is well established. EIP-712, the standard for structured signed messages, folds the chain ID and the verifying contract's address into a domain separator automatically, and a nonce stored per signer makes each signature usable once. A digest with no chain ID is a strong sign that it was hand-rolled with keccak256(abi.encode(...)) instead of built through that standard, and a hand-rolled digest only carries what its author put in.
A signature should authorize exactly one action, and the only way to guarantee that is to sign the action's identity (which position, which caller, which contract, which chain, which use and until when) and to record each signature as spent.
Force-burning someone else's position doesn't pay by itself, since a burn returns tokens at the pool's current ratio. Atomic Green's second defect closed that gap. The burn priced its exit off the pool's instantaneous state, with no time-weighted average price (TWAP) to smooth out manipulation and no slippage bound to reject a settlement far from a reference price.
The attacker used a flash loan, a loan borrowed and repaid within one transaction, to skew the pool first, then replayed the one manager signature across 21 position IDs, force-burning each at the distorted price, according to SlowMist and the Nominis August 2026 report. With the loan repaid, the attacker kept 29,984.27 USDC.
The two flaws were independent, and either one fixed would have capped the attack. The replay opened access to positions the attacker had no right to touch, and the missing price guard made walking through that door worth $30,000.
Atomic Green's security page lists a Halborn audit covering the trading contract, the lending pool and position state. The final report, hosted in the Atomicgreen GitHub organization, dates the engagement to July 1 through August 1, 2022, and scopes it to the atomic-controller, atomic-storage and atomic-lending repositories. That organization holds the report and no Solidity source, so the contracts SlowMist named in its alert, a position manager proxy and a business-logic contract behind a second proxy, can't be matched against that scope from public material.
Audits cover the code they're given in the time they have, and contracts written or changed after an engagement closes sit outside it unless someone brings them back in. A signing scheme in a contract like this one is exactly the kind of code that needs a check every time it changes.
Atomic Green hasn't published its contract source on GitHub, so what follows applies the engine to the mechanism SlowMist's alert describes. Olympix reads a contract the way an attacker does, as states, transitions and entry points, and takes in the context around it to infer the rules the system depends on. In a position manager, the state that matters is which positions exist and who's allowed to burn them, and every function that can burn one is a path worth mapping. The engine reads signals to decide which paths to attack first. Olympix's static analysis surfaces the one behind the first defect directly: a state-changing function that builds a keccak256(abi.encode(...)) digest, recovers a signer from it, never increments a nonce and never binds the contract's own address, which is the signature of a hand-rolled scheme that can be replayed.
A pattern match can't see the second defect, because pricing an exit off the pool isn't wrong in itself. What makes it wrong here is a rule about the whole system, and that's where BugPoCer comes in. Looking at the burn path together with the pool it reads from, it infers that the value a position returns on exit can't be moved in the burner's favor by changing the pool's state earlier in the same transaction. Counterexample-Guided Invariant Refutation then has it execute paths outward from that rule, through every sequence that can touch the pool before a burn, until one breaks it, and a flash loan that skews the pool ahead of a burn priced off spot does.
BugPoCer's output is a counterexample: a flash loan that shifts the pool and a burn that settles at the shifted price, with the minimal conditions that trigger it and a generated Forge test that replays it. Put next to the static analysis finding on the replayable digest, that's the August 7 attack laid out in development, before the contract holds a single position.
Because Olympix runs automatically in development, at every merge and before release, a new contract or a change to a signing scheme gets checked the day it lands, whether or not it falls inside a past audit's scope.
Atomic Green's loss was small, but it carried two lessons that apply to any protocol that acts on signed approvals or prices exits off a pool: bind every signature to one action and mark it spent, and never let a settlement read a price the caller can move in the same transaction. Both rules can be written down and tested against every path before deployment. To see how Olympix checks the signed-approval and pricing paths in your own contracts, book a technical walkthrough.
Protocol: Atomic Green (position manager)
Chain: Arbitrum One
Date: August 7, 2026, 16:18:12 UTC
Loss: 29,984.27 USDC
Attacker EOA: 0xf880...6C7E
Attack contract: 0x44d2...7255
Position manager proxy (victim): 0xf617...69d9
Business contract proxy (vulnerable): 0x51ff...42a8
Business logic implementation: 0x62cc...4a0a
Exploit tx: 0xbd4a...3e9a
Block: 492104035
SlowMist: Atomic Green exploit alert
Nominis: Monthly Report, Crypto Exploits and Attacks in August 2026