# Self-Compute Benchmark — Methodology

Every free lookup on Tereno returns a payoff matrix: the price of a discovery
and what it would cost you to compute the same answer yourself. This document
explains how that second number is built, what it includes, what it
deliberately excludes — and how you can verify every number yourself.

## The two numbers

The lookup response carries both, decomposed under `economics.selfCompute`:

| Field | What it is | How it is produced |
|---|---|---|
| `marginalRpcUsd` | The RPC-only cost of one scan | **Measured**: rolling average of RPC calls over the last real (non-simulated, rpc-source) scans of this type, times a retail unit price per call |
| `benchmarkUsd` | The full cost of self-computing | **Declared**: our estimate of what running this yourself actually costs, assumptions below |

`marginalRpcUsd` is the number to compare against if you already run indexing
infrastructure, keep an RPC plan warm, and have implemented and maintain these
heuristics yourself. In that case it is your real cost — fractions of a cent —
and we hand it to you on every lookup, so your decision is always made with
full information. An honest payoff matrix is the foundation of this market:
you buy because the math wins, not because you take our word for it.

`benchmarkUsd` is what self-computing costs when you do **not** already have
that machinery. It prices in:

1. **RPC access** — paid plans have monthly minimums; casual per-call pricing
   is higher than the bulk unit rate we use for `marginalRpcUsd`.
2. **Implementation** — writing the scan (balance reads, paginated transfer
   logs over the scan window for multiple tokens) and the scoring heuristics,
   correctly, once per discovery type.
3. **Maintenance** — routers change, tokens migrate, RPC providers deprecate
   methods, edge cases appear. Heuristics need upkeep to stay correct.
4. **Freshness bookkeeping** — knowing when a cached answer is stale and
   recomputing at the right time.

Amortize (2)–(4) over the number of subjects a typical bot actually queries
and you get the per-answer benchmark. The current declared values are
$0.05 (smart_money), $0.03 (wallet_reputation), $0.02 (whale_classification).
If your amortization is better than that — you query millions of subjects
from infra you already own — then the marginal number is your real cost, and
the lookup gives you exactly what you need to decide. Either way, both
numbers are yours on every call.

## Where the platform's edge comes from

One scan is the same work for us and for you. The difference is structural:

- **One scan, three products.** A single subject scan feeds all three
  discovery types. A solo bot computing one answer pays the full scan for it.
- **Cache across buyers.** Within a discovery's freshness window (TTL), every
  additional buyer pays cents against a scan that already happened. A solo
  bot amortizes across exactly one consumer: itself.

That amortization — shared across the whole network — is why the price can
sit below the benchmark while staying above our measured production cost
(`productionCostUsd`, also stored per discovery). The margin is structural,
and it is in the open.

## Verify it yourself

Every payload carries `network`, `fromBlock`, `computedAtBlock`,
`windowBlocks` and `methodologyVersion`. The heuristics are deterministic:
the same address and the same block window reproduce the same result. You are
welcome to re-run any scan against a public RPC and check the answer — the
market is designed to be audited.

## Measured in public

The benchmark is not self-graded. The project's public traction gate (THESIS)
tracks a live **buy-rate when cheaper**: when the lookup says buying is
rational, do independent agents actually buy? That metric keeps the numbers
above honest — if the market's behaviour ever disagrees with them, they get
revised in public. You are never asked to take the math on faith.

## Scope and limitations

- Coverage is USDC/WETH transfer activity on Base within the scan window;
  `smart_money` only sees known routers.
- `smart_money` is a heuristic over swap activity — the payload says so
  explicitly (`methodology` field). It measures activity patterns, not
  verified PnL.
- `whale_classification` confidence drops for silent wallets; the payload
  carries a `confidence` field.

*Config notes: unit price via `RETAIL_RPC_COST_PER_CALL_USD` (defaults to the
platform's own bulk rate — conservative, since buyers rarely pay less);
declared benchmarks via `REPRODUCTION_COST_<TYPE>_USD`; measured averages use
the last 25 real scans per type.*