TL;DR

Web3 security has shifted beyond code bugs to economic vulnerabilities, as record 2025 losses showed that even flawless code can’t save a protocol with broken incentives.
Front-running and MEV exploits let attackers reorder transactions for profit, and flash loan attacks manipulate on-chain markets and governance, all while contracts execute exactly as intended. These incentive-based attacks act as an invisible “tax” on users and protocols.
New safeguards focus on economics, rigorous game-theory audits to catch design flaws, slashing mechanisms to financially punish misbehavior, and carefully tested token models (e.g. bonding curves) to ensure adversaries can’t game the system.
A case in point, the Sui/Cetus DEX exploit (~$224M) where a minor math oversight let an attacker deposit 1 token and withdraw an entire treasury. This heist, one of the largest ever, succeeded without “hacking” code, underscoring how simple incentive bugs can be catastrophic.

From Code Bugs to Incentive Exploits

In early DeFi, security was about finding reentrancy and overflow bugs. By 2025, the game had changed. Illicit actors extracted over $4 billion from Web3 that year, with a growing share from business logic failures and incentive design flaws rather than code errors. In these exploits, smart contracts do exactly what they’re programmed to do, but clever adversaries twist the economic assumptions to their advantage. In other words, the code runs perfectly, yet the protocol loses money because its tokenomics or game rules are misaligned with security.

Front-running bots, oracle manipulations, flash loan-fueled attacks, these don’t typically involve writing malicious code to break a contract. Instead, they exploit the rules of the system. Security is no longer a checklist item achieved after an audit. It has become an emergent property of incentives and design. The rules governing token distribution, pricing, and governance can decide whether a protocol withstands an attack or hands its treasury to a predator.

The new battleground is economic, to protect a protocol, one must ask, “What would a rational attacker do given these rules?”

Front-Running and MEV: When Ordering = Opportunity

On public blockchains, the mempool exposes everyone’s pending transactions. This transparency, meant to foster trust, also enables front-running.

“A predatory market strategy where bots monitor pending transactions and exploit ordering to execute trades before a victim, profiting off the price impact”.

If you submit a large DEX trade, a bot can see it and instantly place its own buy first (with a higher fee), then sell right after your trade pushes the price up. The bot risk-free pockets the difference, while you get a worse price.

This behavior is a subset of Maximal Extractable Value (MEV). The total value block producers (miners/validators) can extract by arbitrarily reordering or inserting transactions in a block. Predatory front-running and sandwich attacks act as an invisible tax on DeFi users, often costing traders more in slippage and lost value than the explicit fees they pay. Beyond hurting users, MEV races ( Priority Gas Auctions) also spam the network with bot traffic and drive up gas costs for everyone.

Real-world impact: In the DeFi summer era, these practices were largely unchecked, leading to user frustration and unfair markets. By 2026, solutions like private transaction relays and batch auctions are emerging to level the playing field, but the cat-and-mouse game continues. Front-running shows that simply following the protocol rules (paying a higher gas fee) can still undermine a system’s fairness and security. A well-designed protocol now must assume that transaction ordering is up for sale to the highest bidder.

Flash Loans: Exploits at the Speed of Capital

Flash loans are one of DeFi’s most innovative, and infamous inventions. They are uncollateralized loans taken out and repaid within a single transaction. In effect, anyone can borrow millions of dollars worth of crypto for a few seconds as long as they return it immediately. This is useful for arbitrage and liquidation bots, but as the industry learned, attackers can weaponize flash loans as free capital to supercharge exploits.

The numbers are telling.

By late 2025, crypto hacks and scams had exceeded $1.7 billion for the year, already more than all of 2024, and flash loan-fueled attacks made up a significant chunk of those losses.

Why? Because flash loans let an attacker bypass the usual constraints of capital. With no skin in the game, they can momentarily amass a huge position to manipulate markets or governance, then vanish.

Oracle Manipulation: The most common flash loan attack vector is messing with price feeds. Many DeFi protocols rely on on-chain DEX prices as oracles. An attacker can borrow a large sum via flash loan, use it to buy up a thinly traded token in one exchange (pushing the price way up), and then immediately borrow against that artificial price on another platform. By the time the price corrects, the attacker has walked away with the loot.

In the Mango Markets exploit, the perpetrator famously pumped the price of Mango’s token by 2,300% within minutes. Using two funded accounts, they inflated MNGO’s value from $0.03 to $0.91, generated an unrealized profit of ~$423 million on paper, then borrowed $116 million in real assets against that phantom collateral, draining Mango’s pools.

All of it happened in one chain of transactions. The contracts didn’t fail — they faithfully read a manipulated price as truth.

Governance Takeover: Flash loans can hijack on-chain voting. In April 2022, Beanstalk, a credit-based stablecoin protocol, suffered a $181 million attack when an exploiter flashloaned over $1 billion in tokens to instantly gain 67% voting power. In a single block, the attacker passed a governance proposal sending all protocol funds to their own wallet. Since the loan was paid back immediately, the attacker’s “vote” effectively cost nothing.
Incentive Loops: Some attacks exploit flawed reward logic. For example,

A DeFi project in 2025 (BetterBank) had a mechanism to mint bonus tokens whenever a swap resulted in the protocol’s primary asset, as a user reward. The fatal mistake, it did not verify where the swap happened.

An attacker created a fake liquidity pool involving the asset and a junk token they controlled. By performing swaps in this spoofed pool, they repeatedly triggered the reward function, minting millions of “bonus” tokens out of thin air, which they then converted into real assets, draining reserves. Below is a simplified snippet illustrating this kind of flawed incentive logic,

function onSwap(address tokenOut, uint256 amountOut) internal {
 // If a swap yields the primary token, reward the user
 if (tokenOut == PRIMARY_TOKEN) {
 uint256 bonus = amountOut * BONUS_RATE;
 _mint(msg.sender, bonus); // Vulnerable: no check on origin of swap
 }
 }

In a secure design, the contract would restrict rewards to approved pools or legitimate economic activity. Absent that, the attacker essentially printed money by cycling funds in a circle. This example underscores a key principle, incentives must be tied to verifiable, productive actions, and the cost to trigger a reward should always exceed the reward’s value.

Case Study: The $224M Sui/Cetus Overflow

Not all economic exploits require sophisticated strategy, some are shockingly simple.

In May 2025, Cetus, the largest DEX on the Sui network, was robbed of ~$223 million because of one bad integer check.

The protocol’s code included a helper function intended to prevent overflow in a math operation (a left bit shift on a 256-bit number). However, the developers set the threshold wrong, allowing certain large values to pass the check that would overflow when used. An attacker spotted this and effectively tricked the exchange’s math into a critical mistake.

Here’s how it played out. The attacker took out a flash loan for massive capital and opened an extremely high-liquidity position in Cetus, but confined to an absurdly narrow price range. This combination of huge liquidity + tiny price interval produced a number so large that when the contract tried to scale it (shift it left by 64 bits for fixed-point math), it overflowed silently, wrapping around to a near-zero value. Cetus’s flawed overflow check didn’t catch it. The DEX calculated that the attacker only needed to deposit 1 token to cover this astronomical liquidity position. So they deposited a single SUI token, and the protocol gave them credit for a liquidity amount worth $223 million. The attacker then withdrew actual assets against that liquidity, in a series of swaps that emptied the entire pool essentially.

“$223 million was stolen in what might be one of the simplest hacks the crypto space has seen. All the attacker needed to do was come knocking at the door with a high liquidity position, and they were handed the entire Cetus treasury.”

Cetus had even been audited multiple times, but the audits missed this edge case. The incident drives home a blunt lesson.

Economic security is only as strong as its weakest assumption.

In this case, a single hard-coded constant and a false sense that “overflow can’t happen in our language” led to a historic theft.

Who We Are at Exploitless

Exploitless is a Web3 security auditing firm that lives at the intersection of code and economics. Our team doesn’t stop at finding bugs in Solidity. We dive deep into how your protocol actually operates in the wild, the game theory, the external dependencies, and the “unknown unknowns” that connect them. In an audit, we map out not only the contract logic but the broader context. Who are the actors and what are their incentives? Which contracts or oracles control real value? Where could a clever attacker chain together seemingly innocuous actions into a catastrophic outcome? We’ve seen time and again that a single overlooked assumption can become someone else’s attack story.

At Exploitless, our philosophy is that security is a layered challenge. We scrutinize the Solidity code for vulnerabilities and scrutinize the protocol’s design for incentive misalignments. Our reports reflect that dual approach, from low-level overflow bugs to high-level economic flaws. We help teams implement not just fixes, but financial guardrails like circuit-breakers.

In the end, audits can’t change human nature or patch a fundamentally unstable economic design. But they can illuminate the blind spots before attackers find them. If you’re building or upgrading a Web3 protocol and want a comprehensive review that covers all three layers, technical, economic, and human, that’s exactly what we do every day at Exploitless.

Learn more at Exploitless

References

Chainlink: Front-Running in DeFi
Stakin: Understanding Slashing in Proof-of-Stake: Key Risks for Validators and Delegators
Solu Lab: Importance of Economic & Game Theory Audits in Smart Contracts
Halborn: Explained: The Cetus Hack (May 2025)
InstaTunnel: Flash Loan Attacks: Borrowing Millions to Drain Protocols | Medium
Immunefi: Hack Analysis: Beanstalk Governance Attack, April 2022 | Medium

Econ Security Spotlight: Incentive Attacks and Economic Safeguards