TVL is an operational metric of a DeFi protocol, not a marketing one. We've encountered monitoring tasks for protocols with TVL ranging from $1M to $500M. A sudden 30% drop in an hour—either a hack or a large LP's rug pull. A 500% surge in a day without a corresponding increase in transactions—suspicious manipulation for a DeFiLlama listing. Both scenarios require a system that sees changes in real time and can interpret them. With 10+ years in DeFi and 50+ implemented projects, our expertise guarantees accuracy and reliability. Request a consultation to discuss your monitoring architecture.
How to Calculate TVL Correctly
The Problem of Multi-Currency Accounting
The naive approach: sum balanceOf of all tokens in the protocol's contracts in USD at current prices. That works until you hit these scenarios:
- The protocol accepts Uniswap V2 LP tokens as collateral.
balanceOf(LP_token)is the number of LP tokens, not USD. You need to compute underlying assets viagetReserves()of the pool. - Synthetic tokens (sUSD, stETH): their price ≠ base asset price during a depeg. A separate price feed is needed, not always available.
- Concentrated liquidity positions (Uniswap V3 NFT): the value depends on the current price and the position's range—you need off-chain tick/sqrtPrice math.
Correct architecture: each asset type gets a separate adapter with the logic resolveToUSD(address asset, uint256 amount) → uint256. This is the pattern used by DeFiLlama in their adapters.
Chainlink vs AMM Prices
Chainlink Data Feeds are the gold standard for major assets (ETH, BTC, USDC, major ERC-20s). Heartbeat: 1 hour for stablecoins, 1 hour for large assets. The problem: no Chainlink feed for long-tail tokens.
Fallback: Uniswap V3 TWAP via IUniswapV3Pool.observe() with periodSecond = 1800 (30 minutes). TWAP protects against flash loan manipulation, but at low liquidity pools it's inaccurate.
Important: Chainlink feeds can return stale data. Always check answeredInRound >= roundId and updatedAt > block.timestamp - staleness_threshold.
Why Off-Chain Calculation Is More Efficient Than On-Chain?
Calculating TVL entirely on-chain via a smart contract getTVL() is attractive for transparency, but:
- Gas-expensive for complex computations
- Limited by the call stack size
- LP tokens from Uniswap require external calls, increasing gas exponentially
Better approach: an off-chain service with access to an archive node. Algorithm:
- Get balances via
eth_callin batches (Multicall3 for efficiency) - Request prices from Chainlink + DeFiLlama API + CoinGecko Pro
- Calculate TVL with decimals normalization
- Write a snapshot to the database with block number and timestamp
- Serve via API and dashboard
Frequency: every block for critical alerts (~12 sec on Ethereum), every 5 minutes for historical data.
An off-chain service is 10x faster than Dune Analytics in latency and saves up to 60% on infrastructure costs. For example, at $100M TVL, savings could be up to $5,000 per month. Contact us for an exact estimate.
The Graph Subgraph for TVL
The Graph allows subscribing to smart contract events and aggregating data in GraphQL. For TVL monitoring, the subgraph processes events:
-
Deposit(address user, address asset, uint256 amount)— TVL increase -
Withdraw(address user, address asset, uint256 amount)— TVL decrease -
Liquidation(...)— collateral changes
The subgraph problem: prices are not stored on-chain; you need oracle integration via a @priceOracle handler. This slows down indexing and adds dependency.
A faster-to-deploy alternative: Dune Analytics with SQL queries on top of indexed Ethereum data. Works without development, but latency is higher (5-15 minutes).
How to Set Up Alerts for Sharp TVL Changes?
Anomaly detection pattern:
currentTVL < previousTVL * (1 - threshold) → CRITICAL alert currentTVL > previousTVL * (1 + spike_threshold) → WARNING (possible manipulation) Threshold for critical: 10% in one block is a clear anomaly. 30% in 5 minutes is a critical incident.
Alert channels: Telegram Bot API for instant notifications, PagerDuty for on-call rotation, Slack webhooks for team notifications. For DeFi protocols with TVL > $1M, 24/7 monitoring is mandatory.
| Method | Latency | Cost (range) | Complexity |
|---|---|---|---|
| Custom off-chain service | ~block (12s) | High (node) | High |
| The Graph subgraph | 1-5 min | Medium (hosting) | Medium |
| Dune Analytics | 5-15 min | Low (SQL) | Low |
| DeFiLlama API | 5-15 min | Zero | Low |
Detailed TVL calculation for LP tokens
For Uniswap V2 LP tokens: get pool reserves via getReserves(), then the LP token's share in the pool: (balanceOf(LP) / totalSupply) * (reserve0 * price0 + reserve1 * price1). For Uniswap V3 NFTs: an off-chain library that calculates the position's value based on tick, sqrtPrice, and range.
Integration with Dashboards
Grafana + InfluxDB is the standard stack for TVL time series. Metrics: tvl_total, tvl_by_asset, tvl_by_chain, tvl_change_1h, tvl_change_24h.
DeFiLlama adapter: if a protocol wants to appear on DeFiLlama, it needs a PR with an adapter in their repository. The adapter is a JavaScript function tvl(api) that uses their api.add(token, balance) interface. We write and maintain these adapters.
Custom dashboard: React + recharts or Dune Analytics embedded charts for the protocol's public-facing page. Data via your own API endpoint or directly from the subgraph via Apollo Client.
| Asset type | Adapter | Price source |
|---|---|---|
| ERC-20 | Direct balance | Chainlink |
| Uniswap V2 LP tokens | getReserves() + share |
Chainlink / TWAP |
| Uniswap V3 NFT | Off-chain tick math | TWAP |
What's Included
- Inventory of protocol contracts and asset types
- Development of adapters for each asset type
- Selection and setup of the stack (off-chain service, subgraph, Dune)
- Alert configuration (Telegram, PagerDuty, Slack)
- Dashboard creation (Grafana or custom React)
- DeFiLlama integration (adapter + PR)
- Documentation and team training
- Support for adding new pools or migrations
Process
Analytics (1 day). Inventory of protocol contracts, types of accepted assets, events to track, latency requirements for alerts.
Development (1-3 days). Choose stack based on requirements → implement → configure alerts → deploy dashboard.
Support. When new pools or assets are added, update adapters. Upon network fork or contract migration, update addresses.
Timeline Estimates
Basic monitoring via The Graph + Telegram alerts: 1-2 days. Full system with custom service, Grafana dashboard, and DeFiLlama integration: 3-5 days.
Pricing is calculated individually based on the number of contracts, asset types, and latency requirements. Get a consultation and preliminary estimate in 1 day—contact us.