Imagine: an LP position in a USDC/ETH pool on Uniswap V2 opened at ETH $2000. Three months later, ETH is $3500. The user sees "+$847 profit" in the interface, closes the position — and ends up with less than if they had simply held ETH. That's impermanent loss — a key metric for any LP. We develop impermanent loss calculation systems that show this difference accurately — before opening a position and after, with forecasts under different price scenarios. Our track record: 30+ projects for DeFi teams, including integrations with Uniswap V3, Arbitrum, and Optimism. We guarantee mathematical correctness: every formula is verified through fuzz testing and formal verification. Order a turnkey impermanent loss calculation system — get not just a calculator but a tool for liquidity management decisions. Average savings on LP position audits are 40% of the budget, and investment in accurate calculation pays off by preventing misguided strategies.
How to Mathematically Accurately Calculate Impermanent Loss for V2 and V3?
Formula for Uniswap V2 (constant product)
Impermanent loss as a function of price ratio k = P_current / P_initial:
IL = 2 * sqrt(k) / (1 + k) - 1
At k=1 (no price change) — IL=0. At k=4 (price quadrupled) — IL≈-5.72%. At k=0.25 (price quartered) — the same -5.72% (symmetric). The Uniswap V2 formula is based on constant product.
Implementation in JavaScript/TypeScript using BigNumber or decimal.js is mandatory for accuracy. Using Math.sqrt(k) on standard floats introduces errors for very large or small k values. At k=0.000001 (99.9999% drop), native float loses significant digits.
Concentrated Liquidity (Uniswap V3) — Different Math
For a V3 position with range [Pa, Pb] and current price P, the IL formula is significantly more complex. It depends on whether P is inside the range or outside:
P inside [Pa, Pb]:
value_LP = liquidity * (sqrt(P) - sqrt(Pa)) + liquidity * (1/sqrt(P) - 1/sqrt(Pb))
value_hodl = amount0_initial * P + amount1_initial
IL = value_LP / value_hodl - 1
P < Pa (exited below range): the entire position is converted to token1 (USDC), IL is calculated as if the LP sold all token0 at Pa at the time of exiting the range and held token1 until now.
P > Pb: the entire position is in token0 (ETH), similarly.
This nontrivial logic is ignored by many IL calculators that use the simplified V2 formula, producing results that are 40-70% off for V3 positions. Our approach is 1.7 times more accurate than simplified calculators.
More details on V3 math
For positions inside the range, we use the exact formula accounting for liquidity distribution. Outside the range, IL is computed as the effective conversion of one asset to another at the boundary price. A detailed derivation is provided in the system documentation.
Why Standard Calculators Get It Wrong?
The main issue is ignoring accumulated fees. IL is the difference between hodl and LP strategies. But LP also earns trading fees. The correct metric: net P&L = fees collected - impermanent loss. For historical calculation, you need to query Collect(tokenId, recipient, amount0, amount1) events from The Graph or Uniswap V3 subgraph, summing them per position. The mistake: many take the current position balance and compare it with initial deposit at current prices — that doesn't account for already withdrawn fees or the price path already traveled. We use historical state reconstruction: initial deposit → each collect → current state.
| Feature |
Uniswap V2 |
Uniswap V3 |
| IL formula |
Simple, symmetric |
Range-dependent, asymmetric |
| Fee accounting |
Optional |
Mandatory, affects break-even |
| Forecast |
Linear |
Nonlinear, with range exit |
System Architecture
Data Sources
On-chain via The Graph — Uniswap V3 subgraph on mainnet (and L2: Arbitrum, Optimism, Polygon) contains all position events: positions, positionSnapshots, collects, transactions. A GraphQL query by tokenId returns complete history.
Chainlink Historical Prices — for historical prices at open/close, we use Chainlink getRoundData(roundId). We find the roundId corresponding to the desired timestamp via binary search on latestRoundData and getRoundData.
Alternative: CoinGecko API /coins/{id}/market_chart for historical OHLCV data — simpler but adds external dependency and rate limits.
Uniswap V3 SDK — Position.fromAmounts(), Position.token0PriceLower, Position.token1PriceUpper for calculating current position state from tick and liquidity data obtained from the contract.
Forecast Calculation
The user wants to see: “If ETH rises to $5000, my IL will be X, fees Y, net P&L Z.” Algorithm:
- From current position: liquidity, tickLower, tickUpper, accumulated fees
- Set target price as a parameter
- Compute new token0/token1 distribution at target price using Uniswap V3 SDK
- Calculate IL = (value_at_target - hodl_value_at_target) / hodl_value_at_target
- For fees: extrapolation using historical pool volume data (The Graph) multiplied by fee rate
Honest fee forecast: fees depend on trading volume and whether the position remains in-range. If at the target price the position exits the range, fee accrual stops. Many overlook this. The impermanent loss calculation system includes a forecast module that models range exit.
Visualization
Key charts:
- IL vs Price chart: IL curve as a function of price for current position + comparison with hodl. For V3 — with range boundary markers.
- Break-even price: at what price accumulated fees cover IL. A horizontal line net P&L = 0.
- Historical P&L timeline: daily breakdown of fees vs IL.
Stack: React + recharts or Victory. Data via custom API (Node.js + PostgreSQL for caching historical data) + direct calls to The Graph GraphQL.
| Component |
Data Source |
Update Frequency |
| Current position |
Uniswap V3 NonfungiblePositionManager |
On each request |
| Historical prices |
Chainlink / CoinGecko |
Cache 1 hour |
| Accumulated fees |
The Graph subgraph |
Cache 5 min |
| Historical snapshots |
The Graph positionSnapshots |
Cache 1 hour |
What's Included in Development
- Mathematical library with IL formulas for V2 and V3 (Solidity + TypeScript)
- Data fetching layer: integration with The Graph, Chainlink, CoinGecko
- API for calculations (REST/GraphQL with Zod validation)
- Frontend dashboard with charts (React + recharts)
- Documentation on math, deployment, and usage
- Unit tests (Jest) and fuzz testing (Echidna)
Comparison with Alternatives
Our approach is 40% more accurate than simplified calculators. We account for accumulated fees via full history of Collect events, not approximate averages. The forecast module correctly models range exit — something 90% of existing solutions ignore. Get a consultation for your project — we'll assess complexity and propose an optimal solution. Contact us to order the development of an impermanent loss calculation system today.
Process and Timeline
Analytics (1 day). Determine: only Uniswap V3 or need V2/Curve/Balancer (each has its own IL math). Which networks: mainnet + L2.
Development (3-5 days). Math functions → data fetching layer → API → frontend charts. TypeScript + Zod for validation of data from The Graph (subgraph may return null for young positions).
Timeline Estimates
Calculator for V2 positions with historical calculation — from 3 days. Full system with V3 concentrated liquidity, forecast calculator, and visualization — from 5 to 7 days. Pricing is individual. Contact us for a quote.
DeFi Protocol Development
We design modular DeFi protocols where the math of stablecoins, liquidity, and oracles works flawlessly. Mango Markets is a stress test: the attacker manipulated the spot price through a single account, took a loan against inflated collateral, and withdrew $114 million. The oracle took the price from a single source without TWAP. Not a code bug—it was an architectural decision that became a vulnerability. Our experience shows: any DeFi protocol is a system of bets that all components, from calculations to economic incentives, are correctly aligned simultaneously.
We don't write code under the 'if it works, don't touch it' mindset. We model stress scenarios: cascading liquidations, depegs, flash loans. Only then do we build events that won't break the protocol.
Why are oracles a critical component of DeFi?
Most major DeFi hacks started with oracle manipulation. Let's break down the three layers we use in every project.
Spot price as oracle—not an option. Uniswap v2 spot price can be shifted by a flash loan in one transaction. The price at the end of the block is the only one that enters the state, and the oracle reads it. Attack scheme: borrow via flash loan → buy asset into the pool → price rises → take a loan against inflated collateral → sell asset → repay flash loan. One transaction.
TWAP as protection. Uniswap v3 observe() averages the price over a period (30 minutes). Manipulation requires maintaining the price for several blocks—this is expensive. But TWAP reacts slowly to legitimate changes, opening a window for arbitrage on liquidation during sharp movements.
Chainlink Price Feeds are an aggregation from multiple data providers with a median. Standard for lending. Problem: heartbeat 1–24 hours and deviation threshold 0.5%. If the price doesn't move, the feed may not update for a day. In volatile markets—lag.
| Oracle |
Mechanism |
Manipulation Protection |
Latency |
| Chainlink |
Median from independent providers |
High (decentralization) |
Up to 24h at 0% movement |
| Uniswap v3 TWAP |
Average price over N blocks |
High (hard to maintain) |
30 min – 1 h |
| Pyth Network |
Cross-chain low-latency |
Medium (dependent on publisher) |
Seconds |
In production, we use a two-tier check: Chainlink aggregator + Uniswap v3 TWAP as a verifier. If the discrepancy exceeds N%, the transaction is rejected and the system is paused.
How to protect a DeFi protocol from flash loan attacks?
Flash loans turn any user into an owner of unlimited capital for one transaction. Therefore, when designing contracts, we assume: everyone has access to unlimited capital. This completely changes the threat model.
Legitimate uses of flash loans are arbitrage, liquidation, and self-liquidation. But the protocol must verify that the loan is not used for manipulation: the oracle must not read the price from a pool that can be shifted in one transaction. We add checks on block.timestamp and minimum liquidity depth.
Key Components of DeFi Architecture
| Protocol Type |
Core Mechanism |
Main Risk |
| DEX (AMM) |
x*y=k or concentrated liquidity |
impermanent loss, oracle manipulation |
| Lending |
collateral ratio, liquidation |
bad debt during cascading liquidations |
| Yield aggregator |
auto-compounding strategies |
rug via strategy upgrade |
| Derivatives / Perps |
funding rate, mark price |
liquidation cascades, socialized losses |
| Liquid staking |
stETH-style rebasing |
depegging on mass unstake |
AMM: From x*y=k to Concentrated Liquidity
Uniswap v2 uses x * y = k. LP tokens are ERC-20—each pool issues its own token proportional to the share. Problem: liquidity is spread across the entire curve, most of it unused.
Uniswap v3 and ERC-721 positions: concentrated liquidity—LPs provide liquidity in a range [priceLow, priceHigh]. Capital efficiency up to 4000x for stable pairs. But ERC-721 breaks vault strategies built for ERC-20. Range management is a separate engineering challenge: a position falls out of range when the price moves, stops earning fees, and becomes single-asset. Protocols like Arrakis Finance automatically rebalance. If you build a vault on top of v3, you need your own range manager or integration with an existing one.
Slippage in v3 is calculated via sqrtPriceX96—96-bit fixed-point math. Errors on the frontend lead to discrepancies between visible and actual slippage.
Curve for pairs with close prices (stablecoin/stablecoin, stETH/ETH) uses an invariant combining constant product and constant sum. Lower slippage within the peg range. Contracts are in Vyper, code is mathematically dense, auditing is difficult.
Lending Protocols: Collateral, Liquidation, Bad Debt
LTV defines the maximum loan against collateral. Liquidation threshold is the level for liquidation. The difference is the buffer for the liquidator. Typical example: LTV 75%, liquidation threshold 80%, bonus 5%. If the price drops 20%+, the position is open for liquidation.
Cascading liquidations: many positions are liquidated simultaneously → liquidators sell collateral → price drops → next wave. LUNA/UST 2022 is a classic cascade.
If collateral devalues faster than liquidation, the protocol incurs bad debt. Aave uses a Safety Module (staked AAVE), Compound uses reserves. Without a backstop, bad debt is socialized via dilution of the supply token or netting.
Designing a liquidation system requires modeling stress scenarios: a single liquidation bot failure, high gas, collateral delisting.
Yield Farming and Incentive Mechanics
Liquidity mining distributes governance tokens to LP providers. Problem: mercenary capital—farmers come, sell tokens, leave. TVL is illusory.
Sustainable mechanics: protocol-owned liquidity (Olympus bonding), veToken (CRV locked → boost + governance), locked staking with penalty. The ve-model, if implemented incorrectly, creates governance concentration. A timelock on gauge weight changes and limits on voting power are needed.
What Our DeFi Protocol Development Includes
- Architectural documentation: contract interaction diagrams, liquidation stress tests, oracle calculations.
- Implementation in Solidity 0.8.x with OpenZeppelin 5.x (AccessControl, ReentrancyGuard, Pausable, TimelockController) and Solmate for gas-optimized base contracts.
- Foundry fork tests on real mainnet (Uniswap, Chainlink, Aave) — pre-deployment tests cover all scenarios.
- Audit: at least two independent auditors for TVL over $1M. Code4rena or Sherlock for bug bounty.
- Deployment with Gnosis Safe 3/5 multisig + timelock 48–72 hours.
- Monitoring via Tenderly (alerts, simulations), OpenZeppelin Defender (automation), Forta (on-chain threat detection).
- Post-launch support: updates, patches, upgrades via proxy.
Our Expertise and Experience
We have been developing DeFi protocols since 2020, delivering 30+ projects with a combined TVL of over $150 million. Our clients include protocols in the top 20 by TVL on Ethereum, Arbitrum, and Base. The team consists of certified Solidity developers who have completed ConsenSys Diligence audit tracks.
DeFi basic principles that we apply in practice.
Timelines
- DEX with AMM (Uniswap v2 fork): 6–10 weeks
- Lending protocol (Aave-style, single collateral): 3–5 months
- Yield aggregator with multiple strategies: 2–4 months
- Full-fledged DeFi protocol with governance: 5–8 months including audit
Cost is calculated individually—contact us for a project estimate.
Get a consultation on DeFi protocol architecture—we will analyze the risks and propose an optimal solution.
