The curve on the USDS/DAI pool didn't break gradually. It snapped. Over 72 hours, the exchange rate slipped from 1.00 to 0.97. No hack. No panic. No tweet. The code doesn't lie โ but the data was hiding in plain sight.
When I first saw the divergence, I assumed a routine market imbalance. A few large traders selling USDS for DAI, chasing a slight premium elsewhere. But the numbers didn't add up. The volume spike was concentrated within a single block cluster. That's not normal. That's a signature.
Context: The USDS Reserve Model
USDS is a partially collateralized stablecoin launched in Q1 2026. Its peg is maintained by a combination of on-chain reserves (USDC, ETH, and a basket of blue-chip NFTs) and an off-chain redemption mechanism. The primary liquidity pool on Curve Finance holds $50M in total value locked across the USDS/DAI pair. The design relies on arbitrageurs to keep the peg tight. The protocol's whitepaper claims a 1% deviation threshold before automatic circuit breakers trigger.
But the circuit breakers never fired. The deviation was 3% before anyone noticed. Why? Because the attack vector wasn't brute force. It was latency.
Core: The On-Chain Evidence Chain
I pulled the data from Dune Analytics using a query I've refined since my DeFi Summer liquidity analysis days. The goal: trace every trade that touched the pool during the 72-hour window.
WITH trades AS (
SELECT
block_time,
tx_hash,
amount_usd,
token_in,
token_out,
from_address
FROM curve.pool_trades
WHERE pool = 'USDS/DAI'
AND block_time >= NOW() - INTERVAL '3 days'
),
aggregated AS (
SELECT
date_trunc('hour', block_time) AS hour,
COUNT(*) AS trade_count,
SUM(amount_usd) AS volume,
COUNT(DISTINCT from_address) AS unique_traders
FROM trades
GROUP BY 1
ORDER BY 1
)
SELECT * FROM aggregated WHERE volume > 1000000;The output showed a single hour with 40% of the total volume โ but only 2 unique traders. That's a red flag. Market makers operate with dozens of wallets; a single address dominating the flow is a man-in-the-middle attack candidate.
I traced the dominant address: 0x7f3...a1b. This wallet was created three days before the depeg, funded from a centralized exchange via a Tornado Cash-like mixer. It then executed a series of swaps: first, it bought USDS at a slight premium (1.002) in small batches, accumulating $2M worth. Then, in a single block, it swapped the entire $2M USDS for DAI, crashing the price to 0.97. The liquidity pool had only $5M of DAI in the reserve; the trade was large enough to move the price permanently.
But the real story is the oracle. The attacker used a flash loan from Aave to borrow $10M USDC, then swapped it for USDS on a different exchange (Uniswap V3) to temporarily inflate the USDS price there. The Curve pool's oracle, which uses a TWAP from the previous hour, failed to account for the sudden divergence. The attacker then swapped the inflated USDS back into the Curve pool at the old pegged rate, netting a profit of $300,000. The oracle lag was 12 minutes โ enough time to execute the entire attack.
Based on my experience auditing ICO contracts in 2017, I know that smart contracts execute exactly as coded. The flaw here wasn't in the Curve pool or the USDS smart contract. It was in the oracle dependency. The code doesn't lie, but the oracle's TWAP is a lie detector that only works if the noise is filtered.
Liquidity is just trust with a price tag. The attacker exploited that trust by using a time-delayed price feed. The pool's liquidity was real, but the price wasn't. The market maker who provided the liquidity โ a large institutional LP โ lost $500,000 in impermanent loss because they couldn't react fast enough.
Contrarian: Correlation โ Causation
The common narrative will blame market panic or a whale selling USDS due to regulatory fears. The headlines will read: "USDS Depegs as Confidence Wanes." That's lazy. The data shows a single actor, a scripted attack, a premeditated exploit. The correlation between the price drop and any macro event is zero. The causation is a precise oracle manipulation.
Let me be clear: the attacker didn't need to break the peg. They needed to break the oracle's perception of the peg. The real price of USDS on the open market was still near $1.00 โ the Uniswap pool they manipulated was only $10M deep. But the Curve pool's oracle acted as if the entire market had shifted. That's a design flaw, not a market failure.
Data is the only witness that never sleeps. But data can be fooled by bad inputs. The on-chain evidence shows a clean execution, but the underlying assumption โ that TWAPs from shallow pools are safe โ is the real culprit.
Takeaway: The Next Signal
Keep an eye on the USDS pool today. The attacker left a residue: the same wallet address is now funding a new contract on Arbitrum. The pattern repeats. If you're a liquidity provider, reconsider your exposure to oracle-dependent pools with shallow secondaries. The code doesn't lie, but we need to ask the right questions. The next block will tell us if the attacker is greedy or smart.
In the ashes of Terra, we found the pattern: algorithmic stablecoins fail when the oracle is the only guardrail. This time, the mechanism was different, but the root cause is the same. The code doesn't lie โ but the oracle does.