Date: October 9, 2026
Chain: Ethereum
Loss: about $18,600 in WETH and VISTA
Class: integer overflow in a pool's constant-product check
The check at the heart of every constant-product pool asks one thing after a swap: is the product of the two reserves at least as large as it was before. On October 9, 2026, an EtherVista pool answered yes to that question twice while its WETH and VISTA were being drained, and about $18,600 left the pool.
The multiplication behind the check was the problem. EtherVistaPair stores its reserves as uint112 numbers, and multiplying two of them produced a result too big to hold, so it wrapped around to a small number and the comparison passed when it should have reverted.
EtherVista launched on Ethereum in 2024 as an AMM and token launch platform. It collects swap fees in ETH and uses part of that revenue to buy and burn its VISTA token, and it offered token creators a liquidity lock meant to stop rug pulls in a launch's first days. Its pair contracts follow the constant-product model Uniswap V2 made standard.
In that model, a pool holds two tokens and the product of the two reserves, called K, must never fall after a swap. If someone takes tokens out, they have to put enough of the other token in to keep K at least where it was. The swap function enforces that with a final multiplication and comparison, and if the comparison fails the whole transaction reverts. That one check is what stands between the pool's liquidity and anyone who asks for more than they paid for.
A uint112 is an unsigned integer with 112 bits, which tops out at about 5.19 times 10 to the 33rd. Two uint112 values multiplied together can need up to 224 bits. If the result is held in a type too small for it and the arithmetic isn't checked, the extra high bits are simply dropped, the way a car's odometer rolls back to zero after its last digit.
SlowMist's alert identifies exactly that in EtherVistaPair.swap(): multiplying the two uint112 reserves inside the K check caused the product to wrap around, so the check passed even with the reserves drained. A rolled-over odometer reads low, and here a wrapped product read as small enough to satisfy the comparison.
Etherscan shows the VISTA/WETH pair's verified source was compiled with Solidity 0.5.16. Solidity only started reverting on overflow by default in version 0.8, so in a 0.5 contract a multiplication wraps silently unless the developer routes it through a checked math library. The fix for this class is to widen before multiplying, casting each operand to uint256 so the product always fits, and to keep the arithmetic checked so an overflow reverts instead of wrapping. A guard is only as reliable as the arithmetic inside it, and a K check that can overflow can be made to say anything.
EtherVista's pairs let an authorized router call swap(). According to SlowMist, as reported by Crypto Times, the attacker registered a contract under their own control as an authorized router, then used it to send two crafted swaps to the pair. The amounts were chosen so the post-swap reserve product overflowed, the wrapped result cleared the K comparison, and the pool released WETH and VISTA.
Both swaps ran inside one transaction, which the attacker's address 0xbbf8...18fa sent to the router contract 0x4694...b120 at 03:47:59 UTC on October 9, in block 26,152,259. Its token transfers show the pair, 0xfdd0...2041, which Etherscan labels Ethervista: Ether Vista Pair, sending about 21.37 WETH to the router and about 43,855.90 VISTA to the attacker, with about 7.48 WETH passed on from the router to the attacker by the end of the transaction. SlowMist flagged the attack at 05:20 UTC and estimated the loss at about $18,600 in WETH and VISTA, the same figure the SlowMist Hacked database records. As of October 19, 2026, no EtherVista statement on recovery, negotiations with the attacker or compensation had turned up, and the @ethervista handle SlowMist tagged showed a protected account with a single post.
Olympix reads a pair contract the way an attacker does, as states, transitions and entry points, and takes in the context around it, here a pool built on the constant-product model. The state that matters is the two reserves, and swap() is the entry point that changes them. A signal is a pattern in the code that marks a path as dangerous, and Olympix's static analysis surfaces this one: a multiplication of two narrow uint112 operands, never widened, whose result guards the critical path that releases tokens. That narrows the search from every path through the pair to the ones where the product can reach the edge of its type. Olympix has flagged this class of intermediate multiplication overflow before in other codebases.
The overflow only matters at reserve sizes someone can actually reach, which is the question BugPoCer settles. It doesn't take the contract's own K check at its word. Starting from the pool as a whole, it infers the rule that check was supposed to enforce, that after any swap the true product of the reserves is never lower than before, computed without the wrap. Counterexample-Guided Invariant Refutation then has it execute swap sequences outward from that rule, through the router path as well as direct calls, until one breaks it, and two swaps sized so the computed product wraps do it while the pair's own check reports success.
The counterexample shows the exact reserve values at which the multiplication wraps, the swap amounts that land the wrapped product above the old one, and the tokens that leave the pool, together with the minimal conditions and a generated Forge test that replays it. That's the October 9 drain, produced in development, and it hands the developer the boundary the fix has to cover. Because Olympix runs automatically in development, at every merge and before release, a change to a pair's math gets the same treatment the day it's written.
EtherVista's loss was small, but it came from the one line every AMM relies on most. Safety checks deserve the same scrutiny as the logic they protect, because a check that can be made to pass is worse than none, since it tells everyone the pool is fine. If your contracts fork or reimplement AMM math, book a technical walkthrough.
Protocol: EtherVista (EtherVistaPair)
Chain: Ethereum
Date: October 9, 2026, 03:47:59 UTC (SlowMist alert at 05:20 UTC)
Loss: about $18,600 in WETH and VISTA
Attacker: 0xbbf8...18fa
Attack contract, registered as router: 0x4694...b120
Vulnerable pair contract (VISTA/WETH): 0xfdd0...2041
Exploit tx (both swaps): 0xb2c7...4930
Block: 26152259
SlowMist: EtherVista exploit alert
Crypto Times: SlowMist Flags BitBay and EtherVista Hacks as Attackers Drain $32,600
CryptoRank: Ethervista launches on Ethereum with secure liquidity locks