The discovery flywheel

DeFi has tens of thousands of contracts and no central registry. You cannot hardcode the map — it changes daily. So the indexer doesn't try. It starts from a few seeds and grows the graph by following the chain itself: every contract it enriches reveals the addresses it depends on, those get queued, and the loop repeats. That self-expanding loop is the discovery flywheel — the subsystem that turns "watch these 5 tokens" into "watch the entire dependency cone around them."

1 · The loop

L2 gave you the node lifecycle (bare → enriched). L5 gave you the 15-stage worker. The piece those left implicit is that stage 1 and stage 15 form a cycle:

The worker polls Memgraph for pending_enrichment=true nodes (a pull loop), runs the pipeline, and at the end (stage 15) adds every discovered RelatedAddrs to the monitored set. Those become new bare nodes, get polled, and the cycle continues until it reaches a fixpoint — no new addresses. The graph discovers its own boundary.

2 · Where related addresses come from (the RPC probes)

Stage 1 is pure on-chain interrogation — and every probe that succeeds appends to RelatedAddrs. Here's the proxy resolver, reading the three canonical EIP-1967 storage slots directly:

// enricher.go — resolveProxy (slots from rpc_calls.go)
implBytes, _ := telemetry.StorageAt(ctx, rpc, addr, implSlot, nil)   // 0x360894…382bbc
implAddr := common.BytesToAddress(implBytes)
if implAddr != zeroAddr {
    c.IsProxy = true
    c.Implementation = &implAddr
    c.RelatedAddrs = append(c.RelatedAddrs, implAddr)        // ← follow the impl
}
// then adminSlot (0xb531…6103) → ProxyAdmin, beaconSlot (0xa3f0…3d50) → ProxyBeacon, both appended too

3 · Two engines flank the loop: seeders and refreshers

The pull-loop discovers structure, but two other mechanisms run alongside it.

Seeders — push known structure in

Some structure is too cheap to rediscover by crawling. A seeder bootstraps a protocol's known shape directly. Discovery keeps a static map of knownFactories — Uniswap V2/V3/V4, Curve, Balancer, Aerodrome, PancakeSwap, etc. — so when a pool's factory() resolves to one, the protocol is inferred instantly, and the factory's PairCreated/PoolCreated events can be walked to enumerate every pool it ever made:

var knownFactories = map[string]string{
    "0x5c69bee701ef814a2b6a3edd4b1652cb9cc5aa6f": "uniswap",   // V2
    "0xba12222222228d8ba445958a75a0704d566bf2c8": "balancer",  // V2 Vault
    "0xb9fc157394af804a3578134a6585c0dc9cc990d4": "curve",     // StableSwap Factory
    // …Aerodrome, Velodrome, Camelot, Maverick, Trader Joe
}

Protocol-specific seeders (curve_lending_seeder.go, balancer_seeder.go, bridge_seeder.go) go further, encoding each protocol's particular topology.

Refreshers — keep the numbers true over time

Discovery finds that a vault holds an asset; the dollar value of that holding drifts every block. A refresher periodically re-reads on-chain state to keep edge USD values current — and this is the part that feeds straight into everything you learned about at_risk:

4 · Why it doesn't explode

A self-expanding crawl over a fully-connected financial graph could, in principle, swallow the whole chain. It doesn't, because expansion is value-gated — the same bounded-traversal discipline you met in L2:

• Discovery follows structural dependencies (impl, owner, underlying, asset), not arbitrary transfers — it grows along the dependency cone, not the social graph.
• New tokens only enter the monitored set via the ≥ $1M focus-token transfer promotion (L2) — a value threshold, so the flywheel grows toward where real money is, not into dust.
• It runs to a fixpoint: once no probe yields an unseen address, the loop quiesces for that cone.

What you can now do

• Explain the discovery flywheel: bare node → RPC classify → RelatedAddrs → monitored set → repeat to a fixpoint.
• Name the RPC probes (EIP-1967 slots, asset()/underlying(), getOwners(), curator) and what each discovers.
• Distinguish seeders (push known structure) from refreshers (keep USD values fresh) and the pull worker (poll pending_enrichment).
• Connect discovery to the subsystems it feeds: WRAP_UNWRAP (L21), multisig signers (L22), ORACLE_DEP eligibility (L20), and the dollar values across L19–L23.
• Explain why expansion is bounded (structural deps, ≥$1M promotion, fixpoint) and the coverage-vs-RPC-budget trade-off.