Flamincome $346K Exploit Analysis: Curve Virtual Price Manipulation and Share Price Inflation | PandaSecurity
PandaSecurity
Web3 Security

Flamincome $346K Exploit Analysis: Curve Virtual Price Manipulation and Share Price Inflation

PandaSecurity Team •
#DeFi Exploit#Oracle Manipulation#Curve Security
DeFi oracle manipulation attack analysis illustration

On September 16, 2026, Flamincome’s USDT Strategy suffered a DeFi exploit resulting in approximately $346K of attacker profit.

The attack was not caused by a traditional smart contract vulnerability such as reentrancy or access control failure.

Instead, the attacker exploited an economic design flaw in the strategy’s asset valuation mechanism.

The protocol trusted Curve and Convex accounting data to calculate the value of its strategy position. By temporarily inflating the perceived value of the Curve LP position, the attacker was able to increase the vault share price and withdraw more assets than the strategy actually controlled.

This incident highlights an important DeFi security lesson:

A calculation can be technically correct while still being economically unsafe.

Attack Overview

Affected Protocol:

Affected Strategy:

Flamincome USDT Strategy

Contract:

0xb8d6471ca573c92c7096ab8600347f6a9fe268a5

The strategy calculated its total assets based on:

The critical issue was that the protocol assumed these values always represented the real economic value of the underlying assets.

The attacker discovered a way to temporarily manipulate this accounting.

Root Cause Analysis

Unsafe Reliance on Curve Virtual Price

Curve virtual price is designed to represent the underlying value of LP tokens.

However, virtual price should not automatically be treated as a manipulation-resistant oracle.

The vulnerable assumption was:

LP token balance × Curve virtual price = Strategy value

The strategy assumed that an increase in LP token accounting value represented genuine asset growth.

However, an attacker could influence the underlying Curve pool state and create an inflated valuation.

The protocol verified the calculation result but failed to verify whether the value itself could be manipulated.

Attack Flow

Step 1: Obtain Temporary Liquidity Through Flash Loan

The attacker first borrowed a large amount of USDT through a Morpho flash loan.

Flash loans allowed the attacker to control significant liquidity within a single transaction without requiring large initial capital.

The goal was not to keep the borrowed funds but to create a temporary market condition.

Step 2: Manipulate Curve USDP Metapool

The attacker purchased USDP and changed the balance of the Curve USDP metapool.

Because of the pool imbalance, the attacker was able to mint a large amount of Curve LP tokens.

The important point:

The attacker did not need to provide real long-term liquidity.

The objective was to create an artificial increase in the accounting value used by the strategy.

Step 3: Deposit Manipulated LP Tokens Into Convex

The attacker deposited the manipulated Curve LP tokens into Convex.

The important operation was:

stakeFor(strategy)

This increased:

BaseRewardPool.balanceOf(strategy)

From the strategy’s perspective, the Convex position suddenly became larger.

However, this increase was caused by manipulated pool conditions rather than real economic value.

Step 4: Inflate Strategy Share Price

The strategy calculated its assets using:

Convex LP balance × Curve virtual price

After manipulation, the reported strategy value increased significantly.

The vault incorrectly believed:

Each vault share represented more USDT

than the strategy actually held.

This caused an incorrect exchange rate between vault shares and underlying assets.

Step 5: Withdraw Inflated Value

The attacker redeemed YUSDT shares through:

VaultYUSDT.withdrawAll()

Because the share price was artificially increased, the vault released excessive underlying assets.

The strategy was forced to withdraw approximately:

~544K aUSDT

from Aave to process the withdrawal.

The attacker finally extracted approximately:

~346K USDT

in profit.

Why Existing Security Checks Failed

This exploit was not caused by missing access control or a simple coding mistake.

The contracts behaved according to their intended logic.

The failure was caused by an unsafe assumption:

“External protocol accounting values always represent fair market value.”

In DeFi, this assumption is dangerous.

External dependencies can introduce risks such as:

When a protocol builds financial logic on top of another protocol, every external value source becomes part of the attack surface.

Security Lessons for DeFi Developers

1. Do Not Use AMM Accounting Values as Trusted Oracles

Developers should carefully evaluate values such as:

before using them for asset valuation.

Important questions:

2. Protect Against Sudden Asset Inflation

Strategies should monitor abnormal changes in:

totalAssets()

Possible protections include:

A sudden increase in strategy value should not automatically be trusted.

3. Review Cross-Protocol Dependencies

Modern DeFi systems are built from multiple components:

Vault → Strategy → Convex → Curve → AMM Pool

Each individual component may work correctly.

However, the interaction between multiple protocols can introduce unexpected attack paths.

Security reviews must analyze the complete economic system, not only individual contracts.

4. Test Flash Loan Attack Scenarios

Flash loans allow attackers to create temporary states that normal users cannot create.

Security testing should include:

PandaSecurity Perspective

At PandaSecurity, we believe DeFi security requires more than automated vulnerability scanning.

Many high-impact exploits are caused by incorrect assumptions rather than obvious code errors.

Attackers search for questions such as:

The Flamincome exploit is a typical example of economic security failure.

The code executed as designed, but the underlying valuation assumption was unsafe.

Conclusion

The Flamincome exploit demonstrates a recurring pattern in DeFi security:

Attackers do not always break smart contracts.

Sometimes they manipulate the assumptions behind them.

For protocols managing user funds, every price source, accounting mechanism, and external dependency should be treated as a potential attack surface.

A secure DeFi protocol must not only ask:

“Does this calculation work?”

It must also ask:

“Can an attacker make this calculation produce the wrong result?”

This attacker-focused security mindset is essential for building safer Web3 infrastructure.

PandaSecurity helps Web3 teams identify hidden economic risks, analyze smart contract vulnerabilities, and build stronger decentralized applications.

Related articles

← Back to Blog