---
name: Defi Overview
slug: defi-overview
category: Data
description: Defi Overview reads tracked DeFi positions and broader crypto context in one pass. Use it to check position health, yield changes, market regime, fees, and macro indicators like Fear & Greed and prediction markets.
github: "https://github.com/aeonfun/aeon/tree/main/skills/defi-overview"
language: TypeScript
stars: 679
forks: 242
install: "npx degit https://github.com/aeonfun/aeon/tree/main/skills/defi-overview ~/.claude/skills/defi-overview"
installs_to: ~/.claude/skills/defi-overview
source_path: skills/defi-overview/SKILL.md
collection_size: 25
category_size: 668
collection_url: "https://dirskills.com/collections/aeonfun/aeon"
added: 2026-08-24T05:16:29.867Z
last_synced: 2026-08-24T05:16:29.867Z
canonical_url: "https://dirskills.com/skills/defi-overview"
---

# Defi Overview

Defi Overview reads tracked DeFi positions and broader crypto context in one pass. Use it to check position health, yield changes, market regime, fees, and macro indicators like Fear & Greed and prediction markets.

**Install:**

```bash
npx degit https://github.com/aeonfun/aeon/tree/main/skills/defi-overview ~/.claude/skills/defi-overview
```

## README

<!-- autoresearch: variation B — sharper output via regime verdict + Market Take + sustainable-vs-incentive yield split + fees fundamentals + per-mover "why it matters". Consolidated: folds in defi-monitor (tracked-protocol positions/health) and market-context (broad crypto macro + memory/topics/market-context.md refresh) so one run covers positions + macro in a single pass. -->

> **${var}** — Scope selector. **Empty → full combined overview** (tracked-protocol positions + macro context). `positions` → positions facet only (all watched positions); `positions:<label>` → a single tracked position by label. `macro` → macro facet only. **Any other value** → treat as a chain or protocol focus (e.g. `solana`, `aave`, `arbitrum`) applied to the macro read; positions are filtered to that chain when applicable.

Read `memory/MEMORY.md` for context. Read the last 2 days of `memory/logs/` to avoid repeating numbers, to diff position values over time, and to cite yesterday's figure when flagging today's change. Read `memory/on-chain-watches.yml` (tracked positions) and the existing `memory/topics/market-context.md` (prior macro snapshot) — both are inputs below.

## Thesis

The original produced a table of numbers. This version produces a **read of the market**: one verdict line at the top, then only items that *changed* or *matter*, each with a one-line reason a reader should care. TVL alone is lagging and emission-subsidized — we pair it with fees/revenue (real fundamentals) and split yields into sustainable (`apyBase`) vs incentive-driven (`apyReward`) so readers stop chasing scam-tier APYs. On top of the market read this skill also (a) checks the operator's **tracked-protocol positions** for health/liquidation/yield-drift risk, and (b) refreshes the **decision-ready macro context** file that downstream skills (token-pick, narrative-tracker) consume — all in one pass.

## Facets & var routing

The skill has two facets. `${var}` selects which run and how to scope them:

- **Empty** → run **both** facets: Positions **and** Macro. This is the comprehensive default.
- `positions` → **Positions facet only**, all watched positions.
- `positions:<label>` → Positions facet only, restricted to the position whose `label` matches `<label>`.
- `macro` → **Macro facet only** (DeFi market read + broad crypto context + `market-context.md` refresh).
- **Any other value** → Macro facet, run in **focus mode**:
  - matches a chain name in `/v2/chains` (case-insensitive) → chain focus: scope DEX volume, fees, and yields to that chain; keep a 2-line market header for context; filter positions (if the Positions facet also runs) to that chain.
  - matches a protocol slug in `/protocols` → protocol focus: pull `/protocol/{slug}`, `/summary/fees/{slug}`, `/summary/dexs/{slug}` if it is a DEX; compare against its chain and its 30-day self.
  - matches neither → proceed as a full macro overview and note `var unresolved: ${var}` in the footer.

When both facets run (empty var), send **one** combined notification (Take → position alerts if any → DeFi read → macro snapshot) and still write `memory/topics/market-context.md`.

---

# FACET A — Positions (tracked-protocol health)

*(Runs when `${var}` is empty, `positions`, `positions:<label>`, or a chain focus. Skip entirely for `macro`.)*

## Position config

Watched contracts and positions live **entirely** in `memory/on-chain-watches.yml` — no protocols are hardcoded in this skill. If the file is missing or has no `type: pool` / `type: position` entries, log `DEFI_MONITOR_NO_CONFIG` for this facet and skip it cleanly (no notification — an empty config is not an error; the Macro facet still runs when applicable).

```yaml
# memory/on-chain-watches.yml
watches:
  - label: My Wallet
    address: "0x1234...abcd"
    chain: ethereum
    rpc_url: https://eth.llamarpc.com
    type: wallet
    threshold: 0.1  # ETH — alert on balance changes above this

  - label: Uniswap Pool
    address: "0xabcd...5678"
    chain: ethereum
    rpc_url: https://eth.llamarpc.com
    type: contract
```

## Steps — Positions

### A1. Query each DeFi position

For each DeFi position in `memory/on-chain-watches.yml` (`type: pool` or `type: position`), filtered by `${var}` if a label (`positions:<label>`) or chain focus is set:

- Query the contract for current state using `eth_call`:
  ```bash
  # Example: read slot0 from a Uniswap-style pool
  curl -s -X POST "${rpc_url}" \
    -H "Content-Type: application/json" \
    -d '{"jsonrpc":"2.0","method":"eth_call","params":[{"to":"'"$address"'","data":"'"$calldata"'"},"latest"],"id":1}'
  ```
- For known protocols, query standard view functions:
  - Liquidity pools: `totalSupply`, reserves, current tick/price
  - Lending: `supplyRate`, `borrowRate`, utilization
  - Staking: earned rewards, APR

### A2. Compare against last logged values

Compare current values against the last logged values for each position (grep prior runs in `memory/logs/`).

### A3. Flag anything noteworthy

- Yield rate change > 20%
- Pool TVL drop > 10%
- Position approaching liquidation
- Impermanent loss exceeding threshold

### A4. Positions output

- **`positions` / `positions:<label>` run:** notify via `./notify` (under 4000 chars) **only if** at least one position produced a noteworthy flag; otherwise log `DEFI_MONITOR_OK` and end (no notification on a quiet run).
- **Combined (empty var) run:** the positions block is included in the single combined notification **only when there is at least one flag**; a quiet positions check contributes nothing to the message (but still logs its per-position values).

Positions block template:

```
*DeFi Monitor — ${today}*

*Pool/Protocol Label* (chain)
TVL: $X | APR: Y%
Your position: details
Change since last check: summary
```

---

# FACET B — Macro (DeFi market read + crypto context)

*(Runs when `${var}` is empty, `macro`, or a chain/protocol focus. Skip entirely for `positions` / `positions:<label>`.)*

## Steps — Macro

### B0. Load prior macro snapshot (for deltas + preserve-on-failure)

Read the existing `memory/topics/market-context.md` if present. Extract, for delta computation later:
- BTC price, ETH price, Total mcap, BTC dominance, Total TVL, Fear & Greed value, and the prior DEX 24h volume.
- The full **Token Picks Made** table (never truncate — you will rebuild the new file with this table intact).

If the file doesn't exist, treat all deltas as `n/a` on the first run.

### B1. Fetch (public, no auth — use WebFetch if curl fails)

```bash
mkdir -p .tmp

# --- DeFiLlama (shared by the DeFi read and the macro snapshot) ---
# TVL
curl -fsS "https://api.llama.fi/v2/chains"                        > .tmp/chains.json
curl -fsS "https://api.llama.fi/protocols"                        > .tmp/protocols.json
# Volumes & fundamentals
curl -fsS "https://api.llama.fi/overview/dexs?excludeTotalDataChart=true&excludeTotalDataChartBreakdown=true"  > .tmp/dexs.json
curl -fsS "https://api.llama.fi/overview/fees?excludeTotalDataChart=true&excludeTotalDataChartBreakdown=true"  > .tmp/fees.json
# Stablecoins — includePrices=true (superset; supply totals feed the DeFi read, prices feed the macro snapshot)
curl -fsS "https://stablecoins.llama.fi/stablecoins?includePrices=true"  > .tmp/stables.json
# Yields
curl -fsS "https://yields.llama.fi/pools"                         > .tmp/pools.json

# --- CoinGecko (macro majors, breadth, global, trending) ---
# Send the demo key via ./secretcurl's {ENV_NAME} placeholder only when set — a bare
# $COINGECKO_API_KEY is refused by the Bash permission analyzer; keyless-public works
# without one (lower rate limit). Build the header array once, reuse for all four.
CG_HDR=(); [ -n "${COINGECKO_API_KEY:+x}" ] && CG_HDR=(-H "x-cg-demo-api-key: {COINGECKO_API_KEY}")
# Simple price for BTC, ETH, SOL + 24h change + mcap
./secretcurl -s "${CG_HDR[@]}" "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin,ethereum,solana&vs_currencies=usd&include_24hr_change=true&include_market_cap=true"  > .tmp/cg_price.json
# Top 20 by mcap (movers + trend, 24h & 7d)
./secretcurl -s "${CG_HDR[@]}" "https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=20&page=1&sparkline=false&price_change_percentage=24h,7d"  > .tmp/cg_markets.json
# Global stats (total mcap, volume, dominance)
./secretcurl -s "${CG_HDR[@]}" "https://api.coingecko.com/api/v3/global"  > .tmp/cg_global.json
# Trending coins
./secretcurl -s "${CG_HDR[@]}" "https://api.coingecko.com/api/v3/search/trending"  > .tmp/cg_trending.json

# --- Fear & Greed ---
curl -s "https://api.alternative.me/fng/?limit=2"                > .tmp/fng.json

# --- Polymarket Gamma (prediction markets) ---
curl -s "https://gamma-api.polymarket.com/markets?closed=false&order=volume24hr&ascending=false&limit=10"  > .tmp/poly_vol.json
curl -s "https://gamma-api.polymarket.com/markets?closed=false&order=liquidity&ascending=false&limit=10"   > .tmp/poly_liq.json
```

For each endpoint, if curl fails or returns non-JSON, retry once with **WebFetch** against the same URL (for CoinGecko, WebFetch without the API-key header — free tiers work). Mark each source `ok` or `fail` and carry it into the footer / Source Status line. Never block the whole run on a single source.

Notes on fields:
- `/protocols` and `/v2/chains` already include `change_1d` / `change_7d` / `tvl` — use these directly, do not diff manually. `/overview/dexs` and `/overview/fees` return `total24h`, `total7d`, `change_1d`, `change_7d`, `change_1m`, `protocols[]`.
- If `${var}` is a **chain** focus, additionally fetch `/overview/dexs/{chain}` and `/overview/fees/{chain}` and filter pools by `chain == var`.
- If `${var}` is a **protocol** focus, additionally fetch `/protocol/{slug}`, `/summary/fees/{slug}`, and `/summary/dexs/{slug}` (if a DEX).
- From `/coins/markets` compute **breadth**: how many of the top 20 are green on 24h vs 7d. Breadth is a regime signal — 18/20 green = risk-on, 4/20 green = risk-off.

### B2. WebSearch — macro catalysts (2 queries only; noise is expensive)

Use the built-in **WebSearch** tool for exactly:
- `crypto market today ${today} macro catalyst`
- `BTC ETF flows ${today}` (institutional flow signal)

Keep only items that would change a trader's positioning **today**. Discard recap/explainer articles. Mark `websearch=ok|fail`.

### B3. Compute the DeFi regime verdict (ONE line)

Score three dimensions from the last 24h:
- `tvl_d = overall TVL change_1d` (sum across `/v2/chains`)
- `vol_d = DEX volume change_1d` (from `/overview/dexs`)
- `stable_d = stablecoin supply change_1d` (sum from `/stablecoins`)

Verdict rules (pick the first that matches):
- All three > +2% → **Risk-on** — capital flowing in across TVL, volume, and stables.
- Two of three < −2% → **Risk-off** — capital unwinding.
- `|tvl_d| < 1% AND |vol_d| < 5%` → **Sideways** — no conviction; grind day.
- Otherwise → **Mixed** — describe the split in ≤12 words (e.g. "TVL drifting up on steady volume, stables flat").

### B4. Compute the Market Take (the macro headline)

The Take is the core macro output — everything else is input to it.

**Market Take format (exactly 3 lines):**
```
Take: <regime> — <one-sentence why, citing 2 concrete numbers>.
Conviction: <high | medium | low> — <which signals agree; which disagree>.
Evidence: <one sentence naming the single strongest datum behind this call>.
```
Example:
```
Take: risk-on — BTC +3.1% 24h with 17/20 top-cap majors green.
Conviction: high — F&G, breadth, and 7d TVL all point up; only BTC dominance disagrees (flat).
Evidence: DEX 24h volume $7.8B, highest since March and +42% vs 7d avg.
```

Score the regime using these inputs:
- **BTC 24h%** (±2% threshold)
- **Breadth** (top-20 green count)
- **Fear & Greed** (today vs yesterday; buckets: 0-24 Extreme Fear, 25-49 Fear, 50-74 Greed, 75-100 Extreme Greed)
- **BTC dominance 24h change** (from `/global`)
- **TVL 7d delta** (DeFiLlama)
- **DEX volume** vs the prior snapshot's DEX volume

Assign one regime label:
- **risk-on** — BTC up, breadth >14/20, F&G ≥55 and rising, TVL up 7d
- **risk-off** — BTC down, breadth <7/20, F&G ≤45 and falling
- **rotation** — BTC flat or dominance falling while breadth high (alts outperforming)
- **chop** — no single signal dominates; small moves, flat F&G
- **capitulation / squeeze** — only if BTC ±5%+ in 24h with F&G extreme

Also emit **conviction** in {high, medium, low} based on how many signals agree.

### B5. Pick what goes in the DeFi read

Each section caps at 3 items. **Drop any section whose best item fails its inclusion rule** — don't pad.

- **Top chains** (3): rank by TVL; show `change_1d` only if `|change_1d| >= 1%`, otherwise suppress the delta.
- **Movers — chains** (1 up, 1 down): filter `|change_1d| >= 5% AND tvl >= $500M`. Require a ≤15-word "why" grounded in observed data (unlock, points program, bridge activity, depeg, exploit, launch). If you can't name a cause from data or memory, write `"no obvious catalyst"` — do not invent one.
- **Movers — protocols** (1 up, 1 down): filter `|change_1d| >= 10% AND tvl >= $100M`. Same "why" rule.
- **Fundamentals — fees leaders** (top 3 by 24h fees from `/overview/fees`): include `change_1d` in fees vs 7d average. Fees > TVL for real demand.
- **Fundamentals — fees-beating-TVL** (up to 2): protocols where `fees change_7d > +20% AND TVL change_7d < +5%`. Skip section if none.
- **DEX volume**: 24h total + top 3 DEXes with `change_1d`.
- **Stablecoins**: total supply + any single stablecoin with `|change_1d| >= 1%` (usually only notable shifts survive).
- **Yields** — split into two sub-sections, each with a hard filter:
  - **Real yield (sustainable)** — 3 pools max. Filter: `apyBase > 0 AND apyReward_share < 0.5 AND outlier == false AND predictions.binnedConfidence >= 2 AND apyMean30d >= apy * 0.5 AND tvlUsd >= $10M`. Rank by `apyBase` descending.
  - **Incentive yield (points / emissions)** — 2 pools max. Filter: `apyReward > 0 AND outlier == false AND tvlUsd >= $25M`. Tag with the reward token symbol. Rank by `apy` descending.
  - If zero pools survive either filter, omit that sub-section and note it in the footer (`real_yield=0` etc.) — this is itself a signal.

### B6. Compare against yesterday's log

Read `memory/logs/${yesterday}.md`. If a mover appears today whose direction flipped (e.g. chain was top gainer yesterday, now top loser), prepend `↔` and note the reversal in its "why" line. If a yield pool from yesterday's Real-yield list is missing today, check whether it failed a filter (outlier flipped, APY collapsed) — worth one line under Yields.

### B7. Classify active narratives (phase + evidence)

For each of 3-5 current meta-narratives (derived from trending coins + top movers + macro catalyst scan), assign a phase and a one-line evidence anchor:
- **emerging** — new mentions, early accumulation (e.g. "3 of top trending, no mcap leader yet")
- **rising** — strong 7d momentum, growing breadth (e.g. "sector +X% 7d, N tokens in top-20 movers")
- **peak** — saturated attention, funding hot, breadth topping (e.g. "every feed hit, 24h volume 3x 7d avg")
- **fading** — mindshare dropping, 7d red (e.g. "was 5 top movers last week, now 1")

No narrative without an evidence anchor. If you cannot point to a number or concrete signal, drop it.

### B8. Polymarket parsing

For each market: `outcomes` and `outcomePrices` are JSON-encoded arrays that map 1:1. `YES% = parseFloat(outcomePrices[0]) * 100` (first element is always YES). Skip any market where YES% is <3% or >97% (effectively settled — no signal). Take the top few by 24h volume and by liquidity.

### B9. Write the updated `memory/topics/market-context.md`

Overwrite `memory/topics/market-context.md` with this **exact** structure. Lead with the Take so downstream skills get the conclusion in the first ~150 chars:

```markdown
# Market Context (as of ${today})

> **Take:** [regime] — [one-sentence why, citing 2 concrete numbers]. Conviction: [high|medium|low].

## Signal Snapshot
- BTC $X (±X% 24h, ±X% 7d) · dominance X% (±X pp 24h)
- ETH $X (±X% 24h, ±X% 7d) · ETH/BTC X.XXX
- SOL $X (±X% 24h, ±X% 7d)
- Total mcap $XT (±X% 24h) · DEX vol $XB 24h
- Breadth: N/20 green 24h · N/20 green 7d
- Fear & Greed: X (label) — yesterday X

## What Changed Since Last Refresh
- [Delta or event 1 — e.g. "F&G jumped 12 pts into Greed, first time in 14 days"]
- [Delta 2]
- [Delta 3]
Only real deltas. If no material change, write: "Quiet — all majors within ±1%, regime unchanged."

## Active Narratives
- **[Narrative]** — phase: [emerging|rising|peak|fading]. Evidence: [concrete signal].
- **[Narrative]** — phase: [...]. Evidence: [...].
- **[Narrative]** — phase: [...]. Evidence: [...].

## Top DeFi Protocols (TVL, 7d change)
- [Protocol]: $XB ([+/-X%])
- [Protocol]: $XB ([+/-X%])
- [Protocol]: $XB ([+/-X%])
- [Protocol]: $XB ([+/-X%])
- [Protocol]: $XB ([+/-X%])

## Chain Flow (top 3 by TVL, 7d)
- [Chain]: $XB ([+/-X%])
- [Chain]: $XB ([+/-X%])
- [Chain]: $XB ([+/-X%])

## Stablecoins
Total: $XB (±X% 7d). USDT $XB · USDC $XB · [next two] · combined share of mcap X%.

## Trending (CoinGecko)
- [COIN] — [why trending, price + 24h%]
- [COIN] — [...]
- [COIN] — [...]

## Prediction Markets (Polymarket, top by 24h vol)
| Market | YES% | 24h Vol | Liquidity |
|--------|------|---------|-----------|
| [question] | X% | $Xm | $Xm |
| [question] | X% | $Xm | $Xm |
| [question] | X% | $Xm | $Xm |

## Macro Catalysts (next 48h)
- [Catalyst + positioning implication]
- [...]
Omit this section entirely if nothing material. Do not pad with generic headlines.

## Implications for Downstream Skills
- **token-pick:** [e.g. "favor [narrative] exposure; avoid [sector] on weak breadth"]
- **narrative-tracker:** [e.g. "monitor [narrative] for phase transition emerging→rising"]
Keep to 1-2 lines per skill. Only write implications that follow from the Take and deltas — don't generate generic advice.

## Token Picks Made
| Date | Token | Price | Thesis |
|------|-------|-------|--------|
[Rebuild verbatim from the prior file. Do not truncate or reorder. Append any new picks found in the last 7 days of memory/logs/ that aren't already in the table.]

---
*Sources — btc/eth: CoinGecko · defi: DeFiLlama · sentiment: alternative.me · markets: Polymarket*
*Source status: coingecko=[ok|fail] defillama=[ok|fail] fng=[ok|fail] polymarket=[ok|fail] websearch=[ok|fail]*
```

**Preserve-on-failure rule:** If 3+ sources fail, **do not overwrite** `market-context.md`. Instead, append a one-line staleness note to the existing file's Source Status line (`last attempt ${today} failed: sources [...]`) and skip the overwrite. A stale-but-valid file is strictly better than a broken one. Use the last known value from the prior file for any single failed source (do not fabricate).

---

## Notify

Send via `./notify` (single call, plain markdown). Cap the message at **4000 chars** — trim lowest-signal sections first (order: Stablecoins, DEX top-3, Top chains #3, Prediction Markets).

**Combined (empty var):** one notification, leading with the Take, then the positions alert block *only if any position flagged*, then the DeFi read, then the macro snapshot:

```
*Crypto — ${today}* — <Take regime> (conviction <level>) | DeFi <Verdict>: <≤12-word regime read>

<positions alert block — include ONLY if ≥1 position flagged (see Facet A template)>

*TVL:* $X.XXT (+X.X% 24h, +X.X% 7d)

*Top chains*
1. Ethereum — $XXXB (+X.X%)
2. Solana — $XXB (+X.X%)
3. Tron — $XXB

*Movers*
↑ Sui +12% ($1.8B → $2.0B) — <≤15-word why>
↓ Base −7%  ($9.2B → $8.6B) — <≤15-word why>
↑ Pendle +18% ($4.0B → $4.7B) — <≤15-word why>
↓ Ethena −11% ($5.1B → $4.5B) — <≤15-word why>

*Fees leaders (24h)*
1. Tether — $XXM (+X% vs 7d avg)
2. Circle — $XXM (flat)
3. Uniswap — $XXM (−X%)

*Fees beating TVL*
• Hyperliquid — fees +42% / TVL +3% (7d) — demand outrunning deposits

*DEX vol (24h):* $X.XB (+X%)  top: Uniswap $XB, PancakeSwap $XB, Jupiter $XB

*Stables:* $XXXB (+0.X%)  — USDe