# NetNet Intel

> Independent, on-chain intelligence for NetNet ($NET) on Robinhood Chain (chain ID 4663): the treasury, NAV (core and incl. the RWA sleeve), supply, holders and whale moves, bonds and credit, read straight from the chain, with every on-chain figure's exact contract call published and a live verifier; plus a model and live race for NetNet's weekly Treasury prediction market, and Shift Run, a points-only arcade. Fan-made: not affiliated with NetNet Capital. Read-only analysis, not financial advice.

The site is a single-page app: its pages need JavaScript. For data, use the JSON read API or the MCP server below. All figures come from public chain reads unless a field says otherwise; each response carries the chain `block` and `asOf` time it was read at. Official figures: NetNet Capital's own app at https://app.netnet.capital.

## Start here (agents)

- Connect the MCP server `https://netnetintel.com/mcp` (no auth; its `instructions` carry this guide) or `GET https://netnetintel.com/api/v1/<area>`. No key.
- Most questions take one call with the tool's filters; stop as soon as the question is answered (rarely more than three calls). Common chains: daily report → `get_desk`; whale check → `get_holders` { kind: "sell", days: 7, minUsd } → `get_whale`; liquidation watch → `get_loop` { status: "at-risk,wind-down" } → `get_loop_liquidations`; why the number moved → `get_growth` → `get_history`; the weekly print → `get_predict` → `get_predict_intel`; a figure that drives a decision → its call → `verify_figures`. Full table: **Common chains** below.
- Quote each figure with its `block`/`asOf`. `stale`, `lastGood`, `complete: false` mean not fully live: say so. Errors (`bad_request`, `not_found`, `rate_limited`, `unavailable`) and what to do: **Errors and partial answers** below. Never fill a gap from memory.
- Every list has a cap; narrow with filters (limits per tool: **Answer sizes** below). Client code: [Python](https://netnetintel.com/examples/netnet_client.py), [TypeScript](https://netnetintel.com/examples/netnet-client.ts). Agent skill: https://netnetintel.com/skills/netnet-intel/SKILL.md

## Verify, don't trust

Every figure that is a direct chain read can be checked independently:

- [Sources](https://netnetintel.com/api/v1/sources): the contract registry and, for every verifiable figure, the exact `eth_call` (address, function, 4-byte selector, decimals), its formula and a ready `curl` against the chain's public RPC (https://rpc.mainnet.chain.robinhood.com, no key).
- [Verify](https://netnetintel.com/api/v1/verify?figures=nav_core,rfv,supply): NetNet Intel re-reads the named figures (or all of them) from the public RPC, independent of the provider the site reads with, at the block they were served from, and reports `exact`, `match` (within a stated tolerance) or `mismatch`, with the raw results. The public node keeps about the last thousand blocks of state; older blocks are re-checked at the chain head.
- [Verify in your browser](https://netnetintel.com/verify): the same check run by a person's own browser straight against the public RPC; `/api/v1/verify?local=1` returns only the served values and calls, for verifiers that run elsewhere. The public node rate-limits shared server addresses: when it refuses NetNet Intel's edge server, the same calls go to the same public node from NetNet Intel's backend; if that is refused too, they are re-read at the same block from the site's archive provider and the report says `independent: false`. `checkedBy` always says which path answered. For a fully independent check, use /verify or run the calls yourself.
- [Second opinion](https://netnetintel.com/api/v1/peer): the core figures beside Netstack's (https://netnet.exe.xyz, an independent NetNet reader with its own code and chain reads), each row with both blocks and exact / match / differs; MCP `get_peer_check`.
- Figure ids: `nav_core`, `nav_core_check`, `rfv`, `rfv_liquid_usdg`, `rfv_morpho_counted`, `rfv_pol`, `supply`, `price_twap`, `premium_core`, `staked`, `staked_share`, `dividend_index`, `sleeve_wallet`.
- To check by hand: run each call at the response's `block` (or `latest`), take the first 32-byte word as an unsigned integer ÷ 10^decimals, apply the formula.
- Calculated figures (NAV incl. the RWA sleeve, the model's odds) are labelled as such, with their inputs listed part by part. Whale moves carry their transaction hash: check them in the receipt's Transfer logs on https://robin.etherscan.io.
- [Methodology in full](https://netnetintel.com/llms-full.txt)

## Build it yourself (open recipes)

Every figure NetNet Intel shows can be rebuilt from Robinhood Chain alone, without this API or any NetNet Intel server: 73 recipes across the treasury, growth, buybacks, liquidity, bonds, NET Advance, Loop, holders, Predict, the arcade games and Turbo. MIT licensed.

- [Recipes catalog](https://netnetintel.com/api/v1/recipes): each recipe's contract calls (address, calldata, decimals), event filters (address, topic0, fromBlock), formula, steps, caveats and what it `needs` (`eth_call`, `eth_getLogs`, `archive`, or an off-chain input such as address labels). `/api/v1/recipes/{id}` adds the figure NetNet Intel serves for it; `?run=1` adds a worked example pinned to a block with every raw request and result (contract-read recipes).
- [The code](https://netnetintel.com/kit/netnet-recipes.mjs): one dependency-free ES module (browser, Node 18+, Workers): `import { RECIPES, makeCtx, run } from "https://netnetintel.com/kit/netnet-recipes.mjs"; await run(RECIPES.find((r) => r.id === "nav_core"), makeCtx())`. Point `makeCtx({ rpc })` at any node; `ctx.trail` lists every request as proof. Sources per area: https://netnetintel.com/kit/src/
- [Recipes page](https://netnetintel.com/recipes): run any recipe in your own browser and compare with the served figure.
- [Desk in one call](https://netnetintel.com/api/v1/desk): every tile of the community desk with each figure's value, block, asOf, source endpoint and field, and recipe; MCP `get_desk`. Start here for broad questions.
- [Community desk](https://netnetintel.com/kit/): the whole ecosystem on one screen, read by the visitor's browser straight from the chain; [one-file version](https://netnetintel.com/kit/netnet-desk.html) to host anywhere. The site's version with side-by-side checks: https://netnetintel.com/desk
- Limits of the public RPC: contract state is kept for about 10 minutes (a pinned-block read re-checks there for a few minutes, on an archive node forever); event history (eth_getLogs, up to 10M blocks a request) always re-checks; it rate-limits busy addresses, so heavy recipes (full holder or loan books) take minutes. Recipes marked `archive` need an archive node.

## Read API (JSON, GET, no key, any origin)

120 requests a minute per address (20 for `/api/v1/verify`); a 429 carries `Retry-After`. Formats, limits and examples: "Usage, limits and formats" below.

- [API index](https://netnetintel.com/api/v1) · [OpenAPI spec](https://netnetintel.com/openapi.json)
- [Live $NET figures](https://netnetintel.com/api/v1/net): price (pair-oracle TWAP), NAV per token, premium, reserves, supply, staked, DEX market; `liquidity`: TVL, 24h volume and ±2% depth summed over every NET pool against USDG, WETH or ETH. About 15 s fresh (liquidity about 2 min).
- [NAV](https://netnetintel.com/api/v1/nav): NAV per NET two ways, core (Treasury.backingPerToken(), on-chain) and incl. the RWA sleeve ((Treasury.rfv() + the sleeve) ÷ NET in issue, calculated), the RFV parts, the sleeve's breakdown, both premiums and the recipes.
- [Treasury](https://netnetintel.com/api/v1/treasury): RFV and its parts, holdings, LP positions and pools, the sleeve's directly held assets.
- [Supply & staking](https://netnetintel.com/api/v1/supply): NET in issue, staked, circulating and its exclusions, burned, NET held per protocol contract, index, epoch, rate.
- [Holders](https://netnetintel.com/api/v1/holders?moves=50): the top 50 holders' own wallets (contracts that hold for others, such as pools and Pendle's SY, and the protocol's Safes are listed apart, in `held`; balance, stance, 7- and 30-day flows), their latest decoded moves with tx hashes, `flowTotals` (the whale flow over 24 hours, 7 and 30 days, as the Holders page shows it: holders' own wallets, linked-wallet reshuffles and the protocol's Safes left out), and wallet clusters (wallets linked by two-way transfers: likely one owner, with the evidence). Each whale carries its `history` (`avgEntry`, `pnl` at the board's price). Filters: `address` (one wallet's moves), `kind` (comma list: buy, sell, bond, stake, unstake, lp-add, lp-remove, deposit, withdraw, transfer-in, transfer-out), `days`, `minUsd`, and `stance` for whales; `movesByKind` totals the matched moves. `priceSource` / `priceAsOf` say which price the board used (it rebuilds about hourly). Example: `?moves=50&kind=sell&days=7&minUsd=10000`.
- [One whale](https://netnetintel.com/api/v1/whale/0x72f273312b253d301b593ca1bbcb740aa500a242): balances, history (entry, P&L, rebase earned), loan, moves and its linked wallets with live balances.
- [Bonds](https://netnetintel.com/api/v1/bonds?epochs=21&trend=24h): the bond desk by 8-hour epoch (NET sold against the cap, `fill`, `soldAfter1h` / `2h` / `4h`, sell-out time, buyers, `paidVsMarket` and `afterVest`), the `live` epoch, and `demandByTrend`: sell-outs grouped by NET's price trend going in (`trend=8h|24h|3d`, last 30 days).
- [Credit](https://netnetintel.com/api/v1/credit): the USDG vault, the Loopback wsNET market and how it marks collateral, the stock markets, liquidations.
- [Buybacks](https://netnetintel.com/api/v1/buybacks?days=7): the team's NET buybacks from the RWA sleeve's Safes: 24-hour, 7-day, 30-day and all-time totals and their `shareOfSupply`, a `window` of `days` (1-90) against the window before it, buys per UTC day (average, low and high price), `bySafe`, venues, the latest buys with tx hashes, the `otcDesk`, the loan that funds them, and the Treasury's inverse bond (NAV × 0.985, burned).
- [Predict market](https://netnetintel.com/api/v1/predict): the open weekly series, the live number it grades, NetNet Intel's model odds, every past series.
- [Loop loans](https://netnetintel.com/api/v1/loop?status=at-risk,wind-down&sort=risk): every Loopback loan (wsNET/USDG on Morpho Blue) with its status (AT RISK, WIND DOWN, WATCH, SAFE: the closer of health < 1.05 / 1.10 / 1.20 and a 5 / 15 / 30% TWAP fall), the TWAP fall to liquidation, the USDG to repay (or wsNET to add) to get back to health 1.20 or survive a 15% or 30% fall, and for a liquidatable loan the full-liquidation repay, seize and profit; filter by `status`, `account`, `minDebt`; sort by `risk` (lowest health first), `debt`, `health`, `collateral`. No transaction data.
- [Predict intel](https://netnetintel.com/api/v1/predict/intel?above=29000000): ask the model: its odds that the print lands above any numbers (`above`, comma list, up to 20), its 68% and 90% ranges, the gap to the line per day, the drivers (incl. the NET TWAP the line implies), each side's value against its break-even, and its graded record.
- [Number history](https://netnetintel.com/api/v1/history?days=7): 1 to 90 days, every 30 minutes up to 7 days, every 4 hours up to 30 and daily beyond (`detail=full` or `interval=30m|1h|4h|1d` to choose): Core RFV, the sleeve mark, `memoHoldings` and `trueRfv`, backing, TWAP, supply, staked (`NET.balanceOf(staking)`), and `trueRfvByClass` at each day's close.
- [What grows NET](https://netnetintel.com/api/v1/grows?days=30): the treasury's change over `days` (1-90, or `all`): money in by source (bonds, the trading fee, premium sales, desks…), money out, value changes, the sleeve by asset class, and the per-NET effect (reserves vs new NET).
- [Liquidator release](https://netnetintel.com/api/v1/liquidator): the self-run Loop liquidator's latest version, whether it is urgent, what's new, and the command that updates it.
- [LP](https://netnetintel.com/api/v1/lp): the NET/USDG v2 pool: reserves, TVL, the week's volume, swaps and fees by day, and who holds the LP (protocol, wallets, contracts, locked) with each holder's fees; `allPools`: every NET pool against USDG, WETH or ETH with TVL, 24h volume, turnover flags and ±2% depth.
- [Sleeve memo holdings](https://netnetintel.com/api/v1/sleeve): the RWA sleeve's holdings beyond its Safe, line by line (NET held, the Loopback position, NET Advance receivables, THE BOOK's pot, the asset desk, v4 LP).
- [Sleeve loan](https://netnetintel.com/api/v1/sleeve/loan): the sleeve's Loopback loan: wsNET posted, USDG owed, LTV, the NET mark at which it could be liquidated, and what the borrowed USDG bought.
- [Pendle](https://netnetintel.com/api/v1/pendle): Pendle's sNET market: the implied APY against what sNET's rebase pays now, by day.
- [NET Advance](https://netnetintel.com/api/v1/advance): lock NET for 30 days and take 40% of its value in USDG now (the lock's rebase pays it back): `howItWorks` in plain words, a worked `example` on today's rate, `capacity` (USDG open for new locks now, every refill and how fast holders used it up), the terms, the book (outstanding, coverage, shortfall, break-even mark), maturities, the positions most at risk.
- [House Vault](https://netnetintel.com/api/v1/vault): the vault behind Predict: share price, capital, queued exits, settles, depositors.
- [THE BOOK](https://netnetintel.com/api/v1/book): the sportsbook: house pot, open markets, results, weekly totals.
- [Presser card](https://netnetintel.com/api/v1/presser/1): one Button Presser card, No. 1 to 4,999, with its OpenSea ask (`market`) and `opensea` link.
- [Presser search](https://netnetintel.com/api/v1/pressers?plate=brass&character=none&sort=price): Brass and Steel cards by `plate`, `faction` (none, bluechips, frontier, chosen), `character` (none, created), `race`, `listed`, `minPrice` / `maxPrice`, `combine` (and, or), `sort` (price, -price, id, -id), `limit`; cheapest first with OpenSea links, plus each plate's census.
- [Presser census & market](https://netnetintel.com/api/v1/presser): sides, races and plates, the Brass and Steel floors (NetNet Intel tracks those two plates; `market.collectionFloor` is OpenSea's floor for the whole collection, which holds other items too, so it is not a card's price; full collection: https://opensea.io/collection/button-presser), how many are listed, the cheapest asks.
- [Gear search](https://netnetintel.com/api/v1/gear?tier=artifact&sort=price): NetNet Gear by `item`, `tier`, `slot`, `table`, `wearable`, `plate`, `earnedBy`, `listed`, `minPrice` / `maxPrice`, `sort` (price, -price, id, scarcity), `limit`; plus per item its supply, minted, listed and floor ask.
- [Games](https://netnetintel.com/api/v1/games): NetNet's arcade (play.netnet.capital) from NetNet Intel's own index of the games' events: per game (DIAL-UP.EXE, COINflip, SpaceX Invaders, MSFT Flight Simulator; WinNET, the prize draw, on its own row) and window (24h, 7d, 30d, all) plays, players, `wagered`, `paidOut`, `houseResult` and `houseEdge`, `fees` (and the share swept to the manager and to the RWA sleeve), bankroll funding, `netBought` through DIAL-UP's zaps, and `daily`; `?game=dialup` for one. Token amounts exact, USD at today's marks. The games send nothing to the Core Treasury.
- [Where the money goes](https://netnetintel.com/api/v1/value?days=7): the Core Treasury's USDG in by source (`coreTreasury.moneyIn.bySource`: bonds, fees, premium, pteam, desks, …) and out, stated zeros for what the arcade, Turbo and THE BOOK send it, and the RWA sleeve by source (`sleeve.bySource`: games, turbo, book, stocks, netBuybacks). `days`: 1, 7 or 30. MCP: `get_value_capture`.
- [Loop liquidations](https://netnetintel.com/api/v1/loop/liquidations): every Loop (Loopback) liquidation from NetNet Intel's own index, the newest merged from the live feed: `windows` for 30m, 12h, 24h, 7d and 30d (`n`, `repaid`, `seized`, `valueOracle`, `valueMarket`, `profitOracle`, `profitMarket`, `badDebt`), a time `series` (`?window=24h`), who liquidates (`leaders`, `&leaders=7d`) and the latest 20. MCP: `get_loop_liquidations`.
- [Turbo](https://netnetintel.com/api/v1/turbo): Turbo, NetNet Capital's knock-out card desk on tokenized stocks (NVDA, AAPL, SPCX), from NetNet Intel's own index of the desk's events: per window (24h, 7d, 30d, all) cards bought, buyers, `paidUsdg`, opening and performance fees, `payoutUsd`, `deskResultUsd`, `sweptToSleeve`; the series board (`series[]`: strike, leverage, expiry, sold, outstanding, state) and the house's stock pots. `?series=17`, `&days=7`. MCP: `get_turbo`.
- [Official docs](https://netnetintel.com/api/v1/docs?q=knock-out%20card): NetNet Capital's own documentation (docs.netnet.capital), searched: `results[]` with `page`, `heading`, `excerpt` and the `url` to cite. Without `q`, the list of pages; `/api/v1/docs/{page}` for one page (e.g. `/api/v1/docs/turbo`). MCP: `search_docs`, `get_doc`. For what a term means and how a desk works; live figures come from the data endpoints.
- [Shift Run](https://netnetintel.com/api/v1/shiftrun?scope=all): the leaderboard (points only); `scope=all|today`.

Numbers are plain JSON numbers in their natural unit (USD, NET or USDG; not wei). Times are ISO 8601 UTC. OpenSea asks are read by NetNet Intel every 2 minutes for Button Presser cards (every 10 for NetNet Gear) and are not sale prices; give their age and check the link before acting.

### Ask it anything

| Question | Call |
|---|---|
| Cheapest Brass presser with no character, with OpenSea links? | `/api/v1/pressers?plate=brass&character=none&sort=price` (`search_pressers`) |
| Brass pressers with no side or no character, cheapest first? | `/api/v1/pressers?plate=brass&faction=none&character=none&combine=or` |
| Cheapest ARTIFACT gear, and how scarce is each item? | `/api/v1/gear?tier=artifact&sort=price` (`search_gear`; `items[]` has supply, minted, floor) |
| Which Loop loans need to wind down, and how much should they repay? | `/api/v1/loop?status=at-risk,wind-down` (`get_loop`) |
| Is there USDG to take on NET Advance, and how fast do refills go? | `/api/v1/advance` (`get_advance`): `capacity` |
| What are the odds the print is above 29M? | `/api/v1/predict/intel?above=29000000` (`get_predict_intel`) |
| How much did the team buy back this week vs last? | `/api/v1/buybacks?days=7` (`get_buybacks`): `window` and `window.previous` |
| What grew the treasury this month? | `/api/v1/grows?days=30` (`get_growth`): `answer`, `moneyIn.bySource` |
| Do bonds sell slower when NET falls? | `/api/v1/bonds?trend=24h` (`get_bonds`): `demandByTrend` |
| Which whales are selling this week? | `/api/v1/holders?kind=sell&days=7` (`get_holders`): `moves`, `movesByKind` |
| Who holds the LP? | `/api/v1/lp` (`get_lp`): `byClass`, `holders` |
| Total liquidity and volume? | `/api/v1/net` (`get_net`): `liquidity`; per pool in `/api/v1/lp` `allPools` |
| Are the arcade games making money? How many players? | `/api/v1/games` (`get_games`): `totals.d7`, `games[].windows.d7.houseResult` |
| Where does the money go? What feeds the sleeve? Do the games pay the treasury? | `/api/v1/value?days=7` (`get_value_capture`): `coreTreasury.moneyIn.bySource`, `coreTreasury.fromGames`, `sleeve.bySource` |
| How many Loop liquidations in the last 24 hours, and who took them? | `/api/v1/loop/liquidations` (`get_loop_liquidations`): `windows.h24.n`, `windows.h24.repaid`, `leaders.rows` |
| How is Turbo doing? What does the sleeve get from it? | `/api/v1/turbo` (`get_turbo`): `windows.d7.paidUsdg`, `windows.d7.deskResultUsd`, `windows.all.sweptToSleeve` |
| What is X? How does a desk work? What are its rules or fees? | `/api/v1/docs?q=...` (`search_docs`), then `/api/v1/docs/{page}` (`get_doc`): quote and cite `url` |
| What does the sleeve hold beyond its Safe? | `/api/v1/sleeve` (`get_sleeve_memo`) |

## Usage, limits and formats

**Connect.** MCP: `https://netnetintel.com/mcp` (Streamable HTTP; plain JSON replies, no sessions, no auth; protocol versions 2024-11-05 to 2025-11-25). REST: `GET https://netnetintel.com/api/v1/<area>` from any HTTP client and any origin. No key, no account.

**Limits, per minute**

| Surface | Limit | Counted per |
| --- | --- | --- |
| MCP tool calls | 240 | client (address + User-Agent) |
| MCP messages, `initialize`, `ping` and `tools/list` included | 1,500 | address |
| Read API | 120 | address |
| `/api/v1/verify` | 20 | address |
| A2A | 60 | address |

Over a limit: HTTP 429 with `Retry-After` (seconds). The read API answers `{ "error": "rate_limited", "retryAfter": N }`; MCP answers a JSON-RPC error with the request's id, `{ "code": -32029, "message": "Rate limited: retry in N s", "data": { "retryAfter": N } }` (one per message in a batch). Wait N seconds, then retry once.

**Calling it well**

- One call per question: the narrowest tool or endpoint, with its filters (`days`, `kind`, `minUsd`, `status`, `sort`, `limit`). `get_desk` (`/api/v1/desk`) for a broad overview in one call.
- How often the data moves: prices about every 15 s; OpenSea asks every 2 minutes; the indexes (games, Turbo, Loop liquidations) every 5 minutes; holders and bonds every 1-2 minutes. Polling faster returns the same answer.
- Dashboards and scheduled jobs: read `/api/v1/desk` once per run, or the few areas the dashboard shows, every few minutes at most; a daily sync needs one call per area a day.
- Send a `User-Agent` that names your app (no key needed; it shows us what is used).
- Bodies are compact JSON; `?pretty=1` indents them. `?summary=1` gives the compact shape of `/api/v1/holders`, `/advance` and `/buybacks`; over MCP those are compact unless `detail: true`.

**Common chains** (stop as soon as the question is answered: most take one call, few need more than three)

| Question | Calls, in order |
| --- | --- |
| Daily report, dashboard | `get_desk` (`/api/v1/desk`) once; `get_alerts` only for "anything I should know?" |
| Whale check | `get_holders` { kind: "sell", days: 7, minUsd: 10000 } → `get_whale` { address } for the 1-3 that matter; outside the top 50, `get_wallet` |
| Liquidation watch | `get_loop` { status: "at-risk,wind-down" } → `get_loop_liquidations` { window: "24h" } |
| Why did the number move | `get_growth` { days: 7 } → `get_history` { days: 7 } if the path matters; `get_value_capture` for where the money went |
| The weekly print | `get_predict` → `get_predict_intel` { above: [the line] } |
| A figure that drives a decision | its area call → `verify_figures` (core figures) or `get_recipes` { id } to rebuild it |
| A term or rule | `search_docs` { query } → `get_doc` { page } only if the snippet isn't enough |

Don't repeat a call within its refresh time, and don't walk every wallet or loan: use the filters.

**Answer sizes.** Most answers are 1-30 KB. Every list has a cap, so there is no paging: narrow with the filters. On the API, `/api/v1/holders`, `/advance` and `/buybacks` are full unless `?summary=1`; `/api/v1/history` follows the same spacing as `get_history` (`&detail=full` for every 30-minute row).

<!-- sizes:start -->
| Tool | Size controls (MCP arguments; most are query parameters of the same name on the API) | Notes |
| --- | --- | --- |
| `get_history` | `days` 1-90 (default 7); `interval` 30m / 1h / 4h / 1d; `detail` (default false) | 30-minute rows up to 7 days, then 4-hourly (to 30) and daily; `detail: true` is every row (90 days about 1.2 MB) |
| `get_holders` | `moves` 0-500 (default 50); `days`; `detail` (default false) | compact: the decision fields and a detail URL; filter moves with `kind`, `days`, `minUsd`, `address` |
| `get_bonds` | `epochs` 1-90 (default 21) |  |
| `get_buybacks` | `days` 1-90 (default 7); `detail` (default false) | compact unless `detail: true` |
| `get_desk` | none | one call for every area (about 25 KB): the dashboard read |
| `get_games` | `days` 1-30; `detail` (default false) | totals; `detail: true` adds the day-by-day series |
| `get_value_capture` | `days` 1 / 7 / 30 (default 7) |  |
| `search_docs` | `limit` 1-10 (default 5) | the best sections, not whole pages; `get_doc` for one page |
| `get_loop_liquidations` | `window` 30m / 12h / 24h / 7d / 30d (default 24h) |  |
| `get_turbo` | `days` 1-30; `detail` (default false) | totals and the board; `detail: true` adds the series |
| `get_recipes` | none | the catalog without `id`; one full recipe with it |
| `search_pressers` | `limit` 1-200 (default 25) | cheapest first; narrow with `plate`, `faction`, `character`, `maxPrice` |
| `search_gear` | `limit` 1-200 (default 25) | cheapest first; narrow with `tier`, `slot`, `item`, `maxPrice` |
| `get_growth` | `days` | `days` 1-90 or "all" (default 30) |
| `get_loop` | `limit` 1-200 (default 25) | riskiest first; filter with `status`, `minDebt`, `account` |
| `get_advance` | `detail` (default false) | compact unless `detail: true` |
| `get_shiftrun` | `scope` all / today (default all) |  |
<!-- sizes:end -->

**What comes back**

- JSON with the figures in plain units (USD, NET, USDG; never wei) and UTC times. Every body with an `asOf` carries `freshness` { asOf, block, ageSec, maxAgeSec, stale }: quote the block or time with each figure.
- Uptime and what is failing now: https://netnetintel.com/status (`/status.json`, MCP `get_status`).

**Errors and partial answers**

| You get | Meaning | Do |
| --- | --- | --- |
| 400 `{ "error": "bad_request", "message", "allowed"? }` | the arguments are wrong: a bad id or address, or a filter value that doesn't exist (an unknown `kind`, `stance`, `status`, `sort`, `trend`…; never silently ignored) | fix them from `message` / `allowed`; don't retry as is |
| 404 `{ "error": "not_found" }` | no such card, wallet, page or recipe | say so |
| 429 `{ "error": "rate_limited", "retryAfter": N }`; MCP: JSON-RPC error `{ "code": -32029, "message", "data": { "retryAfter": N } }` with the request's id (one per message in a batch) | over a limit | wait N seconds (`Retry-After`), retry once, never in a loop |
| 503 `{ "error": "unavailable", "message", "retryAfter": 30, "fallback": "<recipe URL>" }`; MCP: the same body with `isError: true` | the source is down and nothing is saved | retry once after `retryAfter`; then follow `fallback` (it rebuilds the figure from the chain) or say it is unavailable |
| 200 with `lastGood` { savedAt, reason }, `stale: true`; REST header `x-fallback: last_good` | the source was slow (over 8 s) or down; this is the last good answer | use it, quote its `asOf`, say it may be behind |
| `complete: false`, `unread`, a `note` | part of the answer is missing | say which part |

Never fill a gap from memory. OpenSea asks, the verifier and the status are always live (no last good answers).

**Client code.** Ready-made, dependency-free clients for the read API and MCP that send a User-Agent, wait once on 429/503 and flag answers that aren't live: [Python](https://netnetintel.com/examples/netnet_client.py) (standard library) and [TypeScript](https://netnetintel.com/examples/netnet-client.ts) (fetch: Node 18+, Deno, Bun, browsers, Workers). MIT.

MCP over HTTP:

```sh
curl -s https://netnetintel.com/mcp -H 'content-type: application/json' -H 'accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"get_net","arguments":{}}}'
```

Python:

```python
from netnet_client import NetNet          # https://netnetintel.com/examples/netnet_client.py
nn = NetNet("my-dashboard/1.0")
desk = nn.get("/api/v1/desk")             # everything once
loans = nn.tool("get_loop", status="at-risk,wind-down")
print(nn.warnings(loans) or "live")       # e.g. ["stale: 640 s old (fresh within 600 s)"]
```

TypeScript:

```ts
import { NetNet } from "./netnet-client.ts";   // https://netnetintel.com/examples/netnet-client.ts
const nn = new NetNet("my-bot/1.0");
const sells = await nn.get("/api/v1/holders", { kind: "sell", days: 7, minUsd: 10000 });
const net = await nn.tool("get_net");
console.log(net.price, net.freshness?.block, NetNet.warnings(net));
```

**MCP clients.** Claude (web and desktop): Customize → Connectors → Add custom connector, paste `https://netnetintel.com/mcp`. Claude Desktop from its config file (`claude_desktop_config.json`): `{ "mcpServers": { "netnet-intel": { "command": "npx", "args": ["-y", "mcp-remote", "https://netnetintel.com/mcp"] } } }`. Claude Code: `claude mcp add --transport http netnet-intel https://netnetintel.com/mcp`. Cursor (`.cursor/mcp.json`): `{ "mcpServers": { "netnet-intel": { "url": "https://netnetintel.com/mcp" } } }`. VS Code (`.vscode/mcp.json`): `{ "servers": { "netnet-intel": { "type": "http", "url": "https://netnetintel.com/mcp" } } }`. ChatGPT: Settings → Apps & Connectors → Developer mode → Create, no authentication, paste the URL.

## For agents

- [MCP server](https://netnetintel.com/mcp): remote MCP (Streamable HTTP, no auth); add it by URL in Claude, Cursor or any MCP client. Tools: `get_net`, `get_nav`, `get_treasury`, `get_supply`, `get_holders` (`moves`, `address`, `kind`, `days`, `minUsd`, `stance`), `get_whale`, `get_bonds` (`epochs`, `trend`), `get_credit`, `get_buybacks` (`days`), `get_predict`, `get_predict_intel` (`above`), `get_loop` (`status`, `account`, `minDebt`, `sort`, `limit`), `get_history`, `get_growth` (`days`), `get_lp`, `get_sleeve_memo`, `get_sleeve_loan`, `get_pendle`, `get_advance`, `get_house_vault`, `get_book`, `get_presser`, `search_pressers`, `get_presser_market`, `search_gear`, `get_shiftrun`, `get_sources`, `verify_figures`, `get_recipes` (`id`, `run`), `get_desk`, `get_peer_check`, `get_alerts` (`minUsd`), `get_wallet` (`address`), `get_games` (`game`, `days`, `detail`), `get_turbo` (`series`, `days`, `detail`), `get_loop_liquidations` (`window`, `leaders`), `get_value_capture` (`days`), `search_docs` (`query`), `get_doc` (`page`), `report_gap` (`question`: when nothing here answers it), `get_status` (uptime: checked about every 5 minutes, every tool in turn about every 35 minutes). Same shapes as the read API, with three differences for agents: `get_holders`, `get_advance` and `get_buybacks` answer compactly unless `detail: true`; every result carries `freshness` { asOf, block, ageSec, maxAgeSec, stale }; when a source is slow (over 8 s) or down, the answer is its last good one, with a `lastGood` note (`savedAt`, `reason`), its own asOf and `freshness.stale: true`; a failure with nothing saved is `{ error, retryAfter, fallback }` (fallback: the recipe that rebuilds the figure from the chain). Uptime: https://netnetintel.com/status. Server card: https://netnetintel.com/.well-known/mcp.json
- [API catalog](https://netnetintel.com/.well-known/api-catalog) (RFC 9727): the read API and the MCP server with their specs, docs and status ([status](https://netnetintel.com/api/v1/status)). Every page also sends `Link` headers to it.
- Markdown pages: request any page (for example https://netnetintel.com/buybacks) with `Accept: text/markdown` for a short live summary of it: what it shows, its current figures with the block, and where to check them.
- [A2A agent](https://netnetintel.com/.well-known/agent-card.json): an Agent2Agent JSON-RPC endpoint at https://netnetintel.com/a2a; `SendMessage` with a question (or a data part `{"skill": "buybacks"}`, or a 0x address) answers with a Markdown summary and the area's JSON.
- [Agent Skills index](https://netnetintel.com/.well-known/agent-skills/index.json): the published skills with their SHA-256 digests. In a browser, the site also registers WebMCP tools (`open_page`, `get_page_summary`, `get_live_data`, `lookup_wallet`).
- [auth.md](https://netnetintel.com/auth.md): no registration, no keys; everything is public, read-only and rate-limited.
- [Agent Skill](https://netnetintel.com/skills/netnet-intel/SKILL.md): which call answers what, how to read the figures, how to verify them.
- When you report a NetNet figure, give the block it was read at; verify it when accuracy matters.
- Not covered yet? Say so rather than estimating, and send the question with the MCP tool `report_gap` (plain words, no personal details). Usage: NetNet Intel counts calls per tool and endpoint to improve the service; it stores no IP addresses, and keeps the questions sent to `report_gap` (and A2A questions it couldn't route) for 90 days.
- [Alerts](https://netnetintel.com/api/v1/alerts?minUsd=10000): what needs attention now (NET Advance open, Loop AT RISK / WIND DOWN, a buyback after a quiet stretch, whale sells over minUsd in 24 h), each with a level (act / watch / info) and its source.
- Every read-API body with an `asOf` carries `freshness` { asOf, block, ageSec, maxAgeSec, stale }; `?summary=1` on /api/v1/holders, /advance and /buybacks gives the compact shape. Bodies are compact JSON (no indentation); add `?pretty=1` to any /api/v1 path or to /openapi.json for an indented copy. If your fetcher caches by URL, add any query (e.g. `?t=<now>`) to get a fresh read.
- [Status](https://netnetintel.com/api/v1/status): the newest successful core read (block, asOf, ageSec) and `stale` when it is older than 10 minutes, plus `mcp`: the heartbeat's view (about every 5 minutes, every MCP tool in turn about every 35 minutes: status, last check, uptime over 24 h, 7 d and 30 d, tools failing now). The page: https://netnetintel.com/status; JSON: /status.json; MCP: `get_status`.
- Last good answers: a read API call (GET) or MCP tool whose source fails, or takes over 8 s, answers with its last good body: HTTP 200, header `x-fallback: last_good`, a `lastGood` field (`savedAt`, `reason`), `stale: true` and its own asOf. Treat it as stale data: quote its time. OpenSea asks, the verifier and the status are always live.
- Errors are small and typed: see **Errors and partial answers** above for each shape and what to do.
- Building on this data: call one endpoint or tool per question (the **Common chains** above for multi-step questions) and quote its `block`/`asOf`; use the filters (`days`, `kind`, `minUsd`, `status`, `sort`, `limit`) rather than fetching everything; treat `stale: true`, `complete: false` or a `note` as part of the answer; on a 429 wait for `retry-after`, and on a 502/503 retry once, then fall back to the recipe (`/api/v1/recipes/{id}`) and read the chain directly. A verify report's `checkedBy` and `independent` say who re-read the chain. The A2A skills (17) route a plain question to the right area; the read API and MCP cover everything with filters.

## Alerts

- [@netnetintel_bot](https://t.me/netnetintel_bot) on Telegram: follow any top-50 wallet and get a message on each of its buys, sells, stakes and transfers of 10 NET or more (the moves NetNet Intel decodes). Connecting a wallet is optional. Deep link to follow one: `https://t.me/netnetintel_bot?start=w_<address without 0x, lowercase>`.

## Key terms

- NAV per NET (core): Treasury.backingPerToken() = Treasury.rfv() ÷ NET.totalSupply(), what the contracts back each NET with.
- RFV: Treasury.rfv(): liquid USDG + the Morpho position after a 2% haircut + protocol-owned liquidity.
- RWA sleeve: tokenized equities, hOHM and positions held by a team-custodied Safe, disclosed and counted by the official Reports, outside RFV and not a guaranteed backstop.
- NAV incl. RWA sleeve: (RFV + the sleeve) ÷ NET in issue, the Reports' "NAV incl. RWAs". True RFV = RFV + the sleeve.
- The number: True RFV in USD. The weekly Predict series asks whether it will be above (HIGHER) or below (LOWER) a fixed line at the print time; a series opens Wednesdays 14:00 UTC.
- HIGHER / LOWER tokens pay 1 USDG if their side is right, so a token's price is the market's implied probability. The model's odds are NetNet Intel's inference, not the desk's price.
- Premium: the TWAP price ÷ NAV per NET (core). The distribution rate follows it: 0.45% per 8-hour epoch at 1.75× and above, zero at 1×.

## Pages

- [Overview](https://netnetintel.com/): price, both NAVs, the treasury at a glance, the live Predict series
- [What grows NET](https://netnetintel.com/grows): how much the treasury grew and from where: money in by source, the sleeve by asset class, the effect per NET
- [NAV](https://netnetintel.com/nav): NAV per NET core and incl. the RWA sleeve, side by side, with each figure's source
- [Treasury](https://netnetintel.com/treasury): every holding read on-chain
- [Holders & whales](https://netnetintel.com/holders): the top 50 wallets, their moves decoded, follow any on Telegram
- [Supply & Staking](https://netnetintel.com/supply): supply decomposition, sNET emissions and known holders
- [Predict](https://netnetintel.com/predict): the model's call on the weekly print, its graded record, the book and past prints
- [Liquidity](https://netnetintel.com/liquidity): NET/USDG LP pools
- [Bonds](https://netnetintel.com/bonds): the BondDepository's bonds and offering board
- [Credit](https://netnetintel.com/credit): NetNet Credit, Loopback and Pendle loans
- [Advance](https://netnetintel.com/advance): NET Advance positions
- [The Book](https://netnetintel.com/book): sports spreads settled in wsNET
- [Buybacks](https://netnetintel.com/buybacks): what the team buys back from the RWA sleeve's Safe, at what price against NAV, through which venues and paid from what; the Treasury's inverse-bond floor bid; the fee schedule; the treasury's inflows by source are charted on NAV
- [Contracts](https://netnetintel.com/contracts): the discovered NetNet contract registry
- [Risks](https://netnetintel.com/risks): smart-contract, admin and economic risk map
- [Claims](https://netnetintel.com/claims): what NetNet claims, checked on-chain
- [Report Reconciliation](https://netnetintel.com/reconciliation): the official terminal's figures against a reconstruction from raw balances
- [Sources](https://netnetintel.com/sources): data hierarchy, methodology and audit trail
- [Verify](https://netnetintel.com/verify): your browser re-reads the on-chain figures from the public RPC at the served block and compares
- [Recipes](https://netnetintel.com/recipes): how every figure is built, with a Run button that rebuilds it in your browser
- [Community desk](https://netnetintel.com/desk): the ecosystem on one screen, each figure checkable from the chain
- [Button Presser](https://netnetintel.com/presser): faction, race and plate census, card and gear lookup, OpenSea asks
- [Shift Run](https://netnetintel.com/shiftrun): the arcade; beat the number to the print line. Points only, nothing to wager.

## Optional

- [Trade](https://netnetintel.com/trade): Predict trades signed by the visitor's own wallet; the site holds no keys or funds
- [Wallet](https://netnetintel.com/wallet): look up any address's NET holdings
- [NAV Lab](https://netnetintel.com/nav-lab): scenario calculator from the live figures
- [Research](https://netnetintel.com/research)

---

# Methodology in full

How NetNet Intel obtains each figure, so that any of them can be reproduced from the chain. Everything below is generated from the code the verifier runs.

## Chain

- Robinhood Chain, chain ID 4663. Public RPC (no key): https://rpc.mainnet.chain.robinhood.com. Explorer: https://robin.etherscan.io.
- The public node keeps roughly the last thousand blocks of state; `eth_call` at an older block returns "historical state … not available". Use `latest` then, and expect slowly moving figures (interest, rebases, the TWAP window) to have drifted slightly.
- The site reads the chain with its own provider every 15 to 60 seconds and caches the result at the edge for 15 seconds, so every visitor and every API caller sees the same read; each response states its block.

## Contracts

- NET: 0xCA9c78Dd337A67F6e0077F65F5E9218719d30eDf (the NET token (9 decimals))
- sNET: 0xb773ec2C326B7f98a5a83fc098825492F020a4c7 (staked NET, rebasing (9 decimals))
- Staking: 0xB078cc304A0B264C5F3680DC0488954ACcd02E87 (the staking contract)
- Treasury: 0x04822Ea321A0DEE6F40656172F29312104855d66 (the protocol treasury: rfv(), backingPerToken() and its parts)
- PairOracle: 0x929631b33F4070D6f54477fba3FD27566567dAca (the NET/USDG TWAP the protocol prices with)
- USDG: 0x5fc5360d0400a0fd4f2af552add042d716f1d168 (the USDG stablecoin (6 decimals))
- RwaSleeve: 0x498752D5fa0600CBd613074C151Abe15B3FeC7CB (the RWA sleeve: a team-custodied Safe, disclosed, outside RFV)
- hOHM: 0x76Cf788606F3d968B93B8A243D0e185C974EE407 (hOHM (18 decimals))
- hOHMOracle: 0x32ca7363c45212d119deeb11d02ce638234729d6 (hOHM price oracle)
- NVDA: token 0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec, price oracle 0xed29d310cfa91778a5850538da28ed42234cb78c (price(), 24 decimals)
- SPCX: token 0x4a0e65a3eccec6dbe60ae065f2e7bb85fae35eea, price oracle 0x872f9d8955b34e841227a92de755cd63042ab7a5 (price(), 24 decimals)
- AAPL: token 0xaf3d76f1834a1d425780943c99ea8a608f8a93f9, price oracle 0xd625d488d552775d2867194c618b945e5ddfe097 (price(), 24 decimals)
- GOOGL: token 0x2e0847e8910a9732eb3fb1bb4b70a580adad4fe3, price oracle 0x12ec3474d1e321e0aab065278b97fbc7eda5f424 (price(), 24 decimals)
- MSFT: token 0xe93237c50d904957cf27e7b1133b510c669c2e74, price oracle 0xcb9a035fe0e8f321e36286405febc70de42db34e (price(), 24 decimals)
- COIN: token 0x6330d8c3178a418788df01a47479c0ce7ccf450b, price oracle 0x3ebd3088b69a5eec3bdf03b82ccf19c3bc1fa894 (price(), 24 decimals)

## Verifiable figures

Each call: `eth_call` with `{to, data}` at the block; decode the first 32-byte word as an unsigned integer ÷ 10^decimals; then apply the formula.

### nav_core: NAV per NET (core) (USD per NET)

Formula: Treasury.backingPerToken() = Treasury.rfv() ÷ NET.totalSupply(): what the contracts back each NET with

- backingPerToken: Treasury 0x04822Ea321A0DEE6F40656172F29312104855d66 · backingPerToken() · data 0x1521843e · 18 decimals (USD per NET)

### nav_core_check: NAV per NET (core), recomputed from its parts (USD per NET)

Formula: Treasury.rfv() ÷ NET.totalSupply(): must equal backingPerToken()

- rfv: Treasury 0x04822Ea321A0DEE6F40656172F29312104855d66 · rfv() · data 0x4dc8d6df · 18 decimals (USD)
- netSupply: NET 0xCA9c78Dd337A67F6e0077F65F5E9218719d30eDf · totalSupply() · data 0x18160ddd · 9 decimals (NET)

### rfv: RFV (core reserves) (USD)

Formula: Treasury.rfv(): liquid USDG + the Morpho position after a 2% haircut + protocol-owned liquidity

- rfv: Treasury 0x04822Ea321A0DEE6F40656172F29312104855d66 · rfv() · data 0x4dc8d6df · 18 decimals (USD)

### rfv_liquid_usdg: RFV part: liquid USDG (USDG)

Formula: Treasury.liquidUsdg()

- liquidUsdg: Treasury 0x04822Ea321A0DEE6F40656172F29312104855d66 · liquidUsdg() · data 0x51f858fe · 18 decimals (USDG)

### rfv_morpho_counted: RFV part: Morpho position, counted (USDG)

Formula: Treasury.morphoAssets() × (1 − 2%): the official terminal counts the Morpho position after a 2% haircut

- morphoAssets: Treasury 0x04822Ea321A0DEE6F40656172F29312104855d66 · morphoAssets() · data 0xae0fab7c · 18 decimals (USDG)

### rfv_pol: RFV part: protocol-owned liquidity (USD)

Formula: Treasury.rfv() − liquidUsdg() − morphoAssets() × 0.98

- rfv: Treasury 0x04822Ea321A0DEE6F40656172F29312104855d66 · rfv() · data 0x4dc8d6df · 18 decimals (USD)
- liquidUsdg: Treasury 0x04822Ea321A0DEE6F40656172F29312104855d66 · liquidUsdg() · data 0x51f858fe · 18 decimals (USDG)
- morphoAssets: Treasury 0x04822Ea321A0DEE6F40656172F29312104855d66 · morphoAssets() · data 0xae0fab7c · 18 decimals (USDG)

### supply: NET in issue (NET)

Formula: NET.totalSupply()

- netSupply: NET 0xCA9c78Dd337A67F6e0077F65F5E9218719d30eDf · totalSupply() · data 0x18160ddd · 9 decimals (NET)

### price_twap: Price (TWAP) (USD per NET)

Formula: PairOracle.twapNetUsdg(): the time-weighted NET/USDG price the protocol uses

- twap: PairOracle 0x929631b33F4070D6f54477fba3FD27566567dAca · twapNetUsdg() · data 0x10aa790e · 18 decimals (USD per NET)

### premium_core: Premium to NAV (core) (×)

Formula: PairOracle.twapNetUsdg() ÷ Treasury.backingPerToken()

- twap: PairOracle 0x929631b33F4070D6f54477fba3FD27566567dAca · twapNetUsdg() · data 0x10aa790e · 18 decimals (USD per NET)
- backingPerToken: Treasury 0x04822Ea321A0DEE6F40656172F29312104855d66 · backingPerToken() · data 0x1521843e · 18 decimals (USD per NET)

### staked: NET staked (NET)

Formula: Staking.totalStaked()

- totalStaked: Staking 0xB078cc304A0B264C5F3680DC0488954ACcd02E87 · totalStaked() · data 0x817b1cd2 · 9 decimals (NET)

### staked_share: Share of NET staked (fraction)

Formula: Staking.totalStaked() ÷ NET.totalSupply()

- totalStaked: Staking 0xB078cc304A0B264C5F3680DC0488954ACcd02E87 · totalStaked() · data 0x817b1cd2 · 9 decimals (NET)
- netSupply: NET 0xCA9c78Dd337A67F6e0077F65F5E9218719d30eDf · totalSupply() · data 0x18160ddd · 9 decimals (NET)

### dividend_index: Staking index (NET per sNET)

Formula: sNET.index()

- index: sNET 0xb773ec2C326B7f98a5a83fc098825492F020a4c7 · index() · data 0x2986c0e5 · 9 decimals (NET per sNET)

### sleeve_wallet: RWA sleeve: what its Safe holds directly (USD)

Formula: USDG.balanceOf(sleeve) + hOHM.balanceOf(sleeve) × hOHM price + Σ equity.balanceOf(sleeve) × its oracle price(). The sleeve's positions held elsewhere (lending books, desk pots, a vault) are in the sleeve breakdown of /api/v1/nav, not here.

- sleeveUsdg: USDG 0x5fc5360d0400a0fd4f2af552add042d716f1d168 · balanceOf(0x498752D5fa0600CBd613074C151Abe15B3FeC7CB) · data 0x70a08231000000000000000000000000498752d5fa0600cbd613074c151abe15b3fec7cb · 6 decimals (USDG)
- sleeveHohm: hOHM 0x76Cf788606F3d968B93B8A243D0e185C974EE407 · balanceOf(0x498752D5fa0600CBd613074C151Abe15B3FeC7CB) · data 0x70a08231000000000000000000000000498752d5fa0600cbd613074c151abe15b3fec7cb · 18 decimals (hOHM)
- hohmPrice: hOHMOracle 0x32ca7363c45212d119deeb11d02ce638234729d6 · price (0xbb47b68a) · data 0xbb47b68a · 18 decimals (USD per hOHM)
- sleeveNVDA: NVDA token 0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec · balanceOf(0x498752D5fa0600CBd613074C151Abe15B3FeC7CB) · data 0x70a08231000000000000000000000000498752d5fa0600cbd613074c151abe15b3fec7cb · 18 decimals (NVDA)
- priceNVDA: NVDA oracle 0xed29d310cfa91778a5850538da28ed42234cb78c · price() · data 0xa035b1fe · 24 decimals (USD per NVDA)
- sleeveSPCX: SPCX token 0x4a0e65a3eccec6dbe60ae065f2e7bb85fae35eea · balanceOf(0x498752D5fa0600CBd613074C151Abe15B3FeC7CB) · data 0x70a08231000000000000000000000000498752d5fa0600cbd613074c151abe15b3fec7cb · 18 decimals (SPCX)
- priceSPCX: SPCX oracle 0x872f9d8955b34e841227a92de755cd63042ab7a5 · price() · data 0xa035b1fe · 24 decimals (USD per SPCX)
- sleeveAAPL: AAPL token 0xaf3d76f1834a1d425780943c99ea8a608f8a93f9 · balanceOf(0x498752D5fa0600CBd613074C151Abe15B3FeC7CB) · data 0x70a08231000000000000000000000000498752d5fa0600cbd613074c151abe15b3fec7cb · 18 decimals (AAPL)
- priceAAPL: AAPL oracle 0xd625d488d552775d2867194c618b945e5ddfe097 · price() · data 0xa035b1fe · 24 decimals (USD per AAPL)
- sleeveGOOGL: GOOGL token 0x2e0847e8910a9732eb3fb1bb4b70a580adad4fe3 · balanceOf(0x498752D5fa0600CBd613074C151Abe15B3FeC7CB) · data 0x70a08231000000000000000000000000498752d5fa0600cbd613074c151abe15b3fec7cb · 18 decimals (GOOGL)
- priceGOOGL: GOOGL oracle 0x12ec3474d1e321e0aab065278b97fbc7eda5f424 · price() · data 0xa035b1fe · 24 decimals (USD per GOOGL)
- sleeveMSFT: MSFT token 0xe93237c50d904957cf27e7b1133b510c669c2e74 · balanceOf(0x498752D5fa0600CBd613074C151Abe15B3FeC7CB) · data 0x70a08231000000000000000000000000498752d5fa0600cbd613074c151abe15b3fec7cb · 18 decimals (MSFT)
- priceMSFT: MSFT oracle 0xcb9a035fe0e8f321e36286405febc70de42db34e · price() · data 0xa035b1fe · 24 decimals (USD per MSFT)
- sleeveCOIN: COIN token 0x6330d8c3178a418788df01a47479c0ce7ccf450b · balanceOf(0x498752D5fa0600CBd613074C151Abe15B3FeC7CB) · data 0x70a08231000000000000000000000000498752d5fa0600cbd613074c151abe15b3fec7cb · 18 decimals (COIN)
- priceCOIN: COIN oracle 0x3ebd3088b69a5eec3bdf03b82ccf19c3bc1fa894 · price() · data 0xa035b1fe · 24 decimals (USD per COIN)

## Calculated figures

- NAV per NET incl. the RWA sleeve = (Treasury.rfv() + the RWA sleeve) ÷ NET.totalSupply(): the official Reports' "NAV incl. RWAs". True RFV = RFV + the sleeve.
- The RWA sleeve = its core mark + the memo holdings the Reports count. The core mark: what the sleeve's Safe holds directly (USDG, hOHM and tokenized equities at the protocol's oracle prices: the figure `sleeve_wallet`), plus its lending book (collateral at the oracle price less debt), the desk pots it is owed, and its vault shares. The memo holdings: NET and hOHM priced at the TWAP, the desk and pool positions, The Book's house pot, NET Advance receivables and the Loopback position net of its debt. /api/v1/nav lists every part with its value; the sleeve is team-custodied in a disclosed Safe, outside RFV, and not a guaranteed backstop.
- RFV parts: Treasury.liquidUsdg(); Treasury.morphoAssets() counted at 98% (the official terminal's 2% haircut); protocol-owned liquidity = rfv() − the two.
- Premium incl. the sleeve = TWAP ÷ NAV incl. the sleeve. The distribution rate follows the core premium only.
- Circulating NET = NET.totalSupply() − staked − the genesis bond − the tax collector − the bond depository − the sleeve and pack desks, as the official terminal counts it.

## History

- A 30-minute grid of chain reads since 17 Jul 2026: Treasury.rfv(), the sleeve mark, backingPerToken(), the TWAP, NET.totalSupply(), staked and the staking index, read at each grid block. NET supply on the grid matches the token's mint and burn events exactly.
- The memo holdings are recorded from 19 Sep 2026; before that, the incl.-sleeve history counts the sleeve mark only and reads a little low (the site draws it dashed). The newest rows get their memo holdings a little after they are written; until then they have no incl.-sleeve value rather than a low one.
- /api/v1/history fields: `number` = rfv + sleeve (the basis series #1 was graded on); `trueRfv` = rfv + sleeve + `memoHoldings`, the official Reports' True RFV (the basis Predict grades from series #2), null where the memo holdings were not recorded. `staked` on the grid is NET.balanceOf(staking), which includes the NET queued for the next rebase, so it reads a few hundred NET above Staking.totalStaked() (the figure `staked`).
- `trueRfvByClass`: at each UTC day's close, core (Treasury.rfv()), cash & claims, stocks, ownToken ($NET held by the sleeve at the TWAP: the protocol's own token, not outside backing), otherTokens (hOHM), debt (negative); total = True RFV.

## Holders and whale moves

- The top 50: every NET, sNET and wsNET holder ranked by NET-equivalent (sNET and wsNET at the staking index), plus collateral posted in lending markets. Exchange, pool and protocol contracts are labelled.
- A move is one transaction's net change for a top-50 wallet across NET, sNET and wsNET, classified by its counterparty (a DEX router = buy or sell, staking = stake or unstake, an LP zap = LP add, otherwise a transfer). Moves of 10 NET-equivalent or more are decoded and listed (and sent to wallet followers on Telegram). Each move carries its tx hash; the receipt's Transfer logs are the evidence.
- Wallet clusters: two ordinary wallets are linked as likely one owner when NET, sNET or wsNET went both ways between them, 3 or more transfers each way, or one each way with the smaller side at least half the larger; links join transitively. Each link keeps its counts, sizes and transactions. Moves between linked wallets are marked internal (reshuffles) and left out of flows, stances, the daily totals and the headline; ranking stays per wallet. Following one wallet on Telegram covers its linked wallets.
- The holders headline weighs the last 24 hours' net flow against what the top 50 hold and counts how many wallets moved: "Whales are buying" needs a net inflow and 3 or more buying wallets ("buying big" over 2% of holdings); one or two wallets are named as such ("One whale bought 320 NET"); a net outflow under 2% leads with the majority who sold nothing; "Some whales trimmed" needs over 2% out and 3 or more sellers. It never assigns a motive.
- Filters on /api/v1/holders: `kind`, `days`, `minUsd` and `address` select moves (`movesByKind` totals what matched: count, NET-equivalent, USD); `stance` selects whales. `history.avgEntry` is an estimate of USD paid per NET; `history.pnl` is USD at the board's price. The board's price is the NET TWAP when the board was built (`priceSource`, `priceAsOf`; it rebuilds about hourly); for the live price use /api/v1/net.

## Predict model

- NetNet Intel's model projects the number at the print from its verified history (RFV pace, the sleeve's drift, rebases) and gives P(HIGHER). It is an inference, not a chain value and not the desk's price; it is graded against every print on /predict.
- /api/v1/loop: every Loopback position from the Loop page's book (Morpho Blue, wsNET collateral, USDG debt, 62.5% LLTV). Status, whichever test is closer (`statusBy` says which): health (credited collateral × LLTV ÷ debt) under 1.05 AT RISK, under 1.10 WIND DOWN, under 1.20 WATCH; or the TWAP fall before the oracle mark liquidates it: now or ≤ 5% AT RISK, ≤ 15% WIND DOWN, ≤ 30% WATCH; else SAFE. The NAV floor stops price falls, not interest accrual or NAV and staking-index moves, so health decides for floored loans. `sort=risk` is lowest health first, liquidatable on top, ties by debt. `windDown`: the USDG to repay or wsNET to add to get back to health 1.20 at today's mark (`toHealth120`), or to survive a 15% or 30% fall (floored at the NAV floor). `liquidation` (liquidatable loans only): a full liquidation repays the debt and seizes debt × 1.1268 ÷ the oracle price in wsNET (Morpho's incentive min(1.15, 1/(1 − 0.3 × (1 − LLTV)))), with the profit at the oracle and market marks before swap costs; first come, first served. The API never builds transactions; the Loop page can send one from the visitor's own wallet.
- /api/v1/predict/intel: the model's distribution for the print is a Student-t (4 degrees of freedom) around `projectedMean` with `projectedSd`; P(above X) for any `above` number and the 68% and 90% ranges come from it. `gap`: the growth per day the number needs to reach the line against what the model expects and what has been observed. `drivers`: Core RFV, the sleeve and the memo holdings per day, bond capacity left, and NET price sensitivity (each $1 on NET's TWAP moves the number by `usdPerOneDollarOfNet`, because the sleeve holds NET at the TWAP; `netTwapForTheLine` is the TWAP that alone would take the projection to the line).
- `sides`: `edgeVsBreakEven` = the model's probability − the price at which a buy breaks even after the fee; `expectedPayoutPerUsdg` = the model's probability ÷ the average quoted buy price (1 = break-even). An estimate, not advice.
- `record`: each past series' call re-run on the data that existed at its trading close, on the formula that graded it, scored by hit and Brier score (0 perfect, 0.25 a coin flip). The model has been wrong; read `recordSummary` before leaning on it.

## What grows NET

- /api/v1/grows (page /grows) splits the Core treasury's change (Treasury.rfv()) over a window into money in, money out and value changes. Money in: every USDG transfer into the Treasury, classified by sender (BondDepository, the TaxCollector's trading fee, PremiumSeller, the RWA and asset desks, pTEAM, the genesis bond); Treasury <-> Morpho moves are internal and left out. Money in is not profit: a bond payment is new capital that issues NET.
- Money out: the buybacks. Value change: the Core change no transfer explains (Morpho interest and LP value, less the 2% haircut Treasury.rfv() applies to USDG moved into Morpho).
- Per NET: NAV growth = reserve effect + supply effect, with reserve effect = ΔR/R0 × S0/S1 and supply effect = S0/S1 − 1; `perNetWithSleeve` repeats it with the sleeve. The sleeve by asset class is recorded from 19 Sep 2026. A window starts at a UTC day boundary; `days=all` is since launch.

## Bonds

- From BondDepository purchase events, grouped by 8-hour epoch; pool prices from hourly snapshots. `fill` = netSold ÷ capNet (sold out at 98%); `soldAfter1h` / `2h` / `4h` are cumulative NET sold that far into the epoch; `paidVsMarket` = avgPrice ÷ the pool price during the epoch − 1 (negative = a discount); `afterVest` = the pool price when the NET fully vested (2 days after the epoch) ÷ avgPrice − 1.
- `demandByTrend`: each epoch's pool price at open against the price 8 hours, 24 hours or 3 days before (`trend`), grouped into buckets with the sell-out rate, median hours to sell out, average fill and median price paid against the pool. `rankCorrelation` is the Spearman correlation of that change with the time to sell out (an epoch that missed its cap ranks slowest; positive = slower sell-outs after rises). It covers the last 90 epochs (30 days) and describes that month; it is not a rule.

## Buybacks

- A buy: a transaction where USDG left one of the RWA sleeve's Safes and NET came in from a router or pool; price = (USDG out − USDG refunded) ÷ NET in. The NET bought is kept as desk inventory, not burned.
- `window`: the last `days` UTC days (1-90) against the same number of days before; `changeUsd` = this window ÷ the previous − 1. `shareOfSupply` = NET bought ÷ NET in issue now. `bySafe` splits the buys by Safe; `otcDesk` is NET the sleeve offered off-market (fills = NET it sold); `fundedBy` is the sleeve's NetNet Credit loan against its tokenized stocks. The inverse bond is separate: the Treasury's own buyback at NAV × 0.985, burned.

## The RWA sleeve: memo holdings and loan

- /api/v1/sleeve lists, line by line, what the official Reports add beyond the Safe's own wallet: NET, sNET and wsNET held (at the TWAP), the Loopback position net of its debt, NET Advance receivables, THE BOOK's house pot, the asset desk and v4 LP. True RFV = Treasury.rfv() + the sleeve mark + these memo holdings. `netPricedUsd` is the part that moves with NET's TWAP: the protocol's own token, not outside backing.
- The sleeve is team-custodied in a disclosed Safe, outside RFV; no contract backs NET with it and it is not a guaranteed backstop.
- /api/v1/sleeve/loan: the sleeve's Safe posted wsNET on Loopback (NetNet Credit) and borrowed USDG. `pricePerNet` is the market's collateral mark per NET (not the TWAP); `liqPerNet` is the NET mark at which the position could be liquidated; `usesOfBorrowedUsdg` traces what the USDG bought.

## LP, Pendle, NET Advance, House Vault, THE BOOK

- /api/v1/lp: the NET/USDG v2 pool. `byClass` says who holds its LP tokens (treasury = protocol-owned liquidity, wallet, contract, locked); `fees7d` is each holder's share of the week's 0.3% swap fees; `price` is spot from the reserves, not the TWAP. `allPools`: every NET pool against USDG, WETH or ETH (TVL at least $1K; pairs against other tokens left out and counted in `excluded`). Pool list and 24h volume from DexPaprika (Dexscreener where DexPaprika lacks a pool); TVL from the pool's balances on chain for V2/V3 and from the listing for V4 (the PoolManager holds every V4 pool together); `depth2pct` from the chain: the USDG a seller receives before the price falls 2% (`sellUsd`) and a buyer spends before it rises 2% (`buyUsd`), V2 by reserves, V3/V4 by walking initialized ticks, before fees. A pool trading more than 5× its TVL a day carries a `flag` (market making); its volume counts in full. `/api/v1/net` `liquidity` has the totals the home page shows.
- /api/v1/pendle: `impliedApy` is the fixed APY Pendle's market prices for sNET to expiry, `underlyingApy` what sNET's rebase pays now; implied below underlying means the market expects the rate to fall (or prices risk). `checkedOnChain` re-reads the implied rate on Robinhood Chain.
- /api/v1/advance `capacity`: the USDG open for new locks is replayed from every USDG transfer into the desk (a refill from the RWA sleeve) and out of it (an advance, or the Treasury escrow paid at close); each lock uses its advance plus the 5% escrow kept back at open. The replay ends at the desk's unallocated() (`replayDriftUsdg` reports any gap). Each refill lists when it opened, how much, how many locks and wallets took it, and how long until it was used up.
- /api/v1/advance: coverage = locked value at today's wsNET mark ÷ outstanding; `shortfall` = what positions under water owe beyond their lock; `bookBreakEven` = the wsNET mark at which the book's locks cover what is owed.
- /api/v1/vault: the House Vault takes the other side of Predict; its share price is struck at each settle (below 1 = depositors are down). /api/v1/book: THE BOOK's amounts are in wsNET unless named; its pot belongs to the RWA sleeve, not the Treasury.

## Button Presser and NetNet Gear

- Cards: Brass No. 1-999, Steel No. 1,000-4,999. In /api/v1/pressers, faction `none` = PresserFaction.factionOf(card) is 0 (no side chosen) and character `none` = PresserCharacter.characterOf(card).race is 0. A character carries its side, so a card without a side has no character; a card can have a side and no character yet.
- The roster is NetNet Intel's cached read of every card (`roster.asOf`, `stale`) and may be up to a few minutes behind the chain; a card it has not read yet is never counted as blank by a side or character filter. For one card, /api/v1/presser/{id} carries its own read time (`asOf`).
- Gear traits come from each piece's on-chain tokenURI (Table, Slot, Tier, Supply, Wearable By, Plate, Earned By); `edition` is the piece's order within its item; `sort=scarcity` puts the smallest item supply first. `items[]` gives each item's supply, minted count, how many are listed and its floor ask.
- Asks are OpenSea's best listing per token, read by NetNet Intel about every 10 minutes (not by NetNet Capital). An ask is not a sale price and can be filled or pulled at any time; check the OpenSea link. `listed` defaults to true when sorting by price. NetNet Intel is read-only and does not trade.

## Differences you may see elsewhere

- Sites that reconstruct history by interpolation can disagree with this history in the past while agreeing today; compare against NET.totalSupply() and Treasury.rfv() at the block in question.
- The official terminal (https://app.netnet.capital) is the reference; NetNet Intel mirrors its getters and reports where it differs.