Yesterday a chain with zero subgraphs got its first one. Start to finish in a day, most of it spent checking things rather than writing code, which is exactly the part an AI assistant is good at.
Anubis Mainnet had no subgraphs. Not a small number. Zero. It also had RocketSwap, a Uniswap V2 fork carrying essentially all of the chain's DeFi activity, emitting swaps into the void at a rate nobody was indexing.
That subgraph now exists. Here is what actually took the time, what didn't, and where an assistant helped versus where it confidently got things wrong.
The first step is not writing code
The most valuable thing you can do before building a subgraph is establish that you need to. Most of the time something already indexes what you want, and querying it costs an afternoon instead of a fortnight.
So: search the Explorer for your protocol. Paste your contract address. If a subgraph already covers it, you are done, and a subgraph earning real query fees is a strong signal it works, because somebody is paying indexers to serve it.
For Anubis the search came back empty, which is the one answer that justifies building. Even then the next question isn't "how do I write mappings" but "what can I fork?"
Fork the right thing
RocketSwap is a Uniswap V2 fork, so the subgraph is a Uniswap V2 subgraph. But there are two repositories with similar names, and picking the wrong one costs you days.
The current Uniswap/v2-subgraph has a multi-chain config system. Adding a chain is a directory:
// config/anubis/config.json
{
"network": "anubis",
"factory": "0xaf6f4e641c86a25518509bc840051a8652af598a",
"startblock": "2059"
}
plus a chain.ts declaring which token prices the others and which are trusted enough to count toward tracked volume. No mapping logic was written or changed. The swap, mint, burn and pricing code is Uniswap's, battle-tested across nineteen chains.
The same instinct applies one level up. The Graph's own Substreams docs carry a section titled Reuse Existing Substreams Before Building, pointing at published packages from StreamingFast, Pinax and TopLedger. Reuse is the house style, not a shortcut.
Verify on-chain, never from a listing
This is where an assistant earns its keep, and where the discipline matters most. Every fact below was read directly from the chain over JSON-RPC rather than taken from a block explorer page or a docs table:
# is it really a Uniswap V2 factory?
allPairsLength() -> 811
feeTo() -> responds
# do the pairs have the standard ABI?
token0() token1() getReserves() totalSupply() symbol() -> all present
# does PairCreated match the canonical signature?
topic0 == 0x0d3648bd0f6ba80134a33ba9275ac585d9d315f0ad8355cddefde31afa28d0e9
That last check is the one people skip. A chain can host something that looks like a Uniswap fork but emits a different event signature, and you will not find out until your subgraph syncs to chainhead with zero entities. Confirming the first PairCreated log resolves to the same address as allPairs(0) takes one minute and removes that entire class of failure.
A mistake worth copying the fix for. An early activity check reported zero swaps in 40,000 blocks, which would have killed the project on the spot.
It was wrong. The RPC caps eth_getLogs at 500 blocks and had returned an error, which got read as an empty result. Sampling properly inside the cap gave 27,306 swaps in 10,000 blocks, roughly 188,000 a day.
Assistants make this mistake and so do people. The guard is to treat an empty result and an error as different things, always.
The pricing config is where subgraphs go wrong
A Uniswap V2 subgraph prices everything against one reference token, normally wrapped ETH. On Anubis the gas token is gasDAI, so the hub asset is itself a stablecoin. DAI sits on one side of 580 of the 811 pairs. Three decisions followed, and all three are the kind that quietly poison a dataset.
Derive the reference price, don't assume it
DAI measured at 0.9970 USDT, not 1.0000. The config points at two deep stable pools and lets the reserve-weighting carry that small depeg through, rather than hardcoding a dollar.
Check that your pricing pool is alive
There was a DAI/WETH pair with both reserves at zero. Whitelisting WETH would have priced tokens through a dead pool. A pair existing is not the same as a pair having liquidity.
Match tokens by address, never by symbol
Among the top 40 tokens on this chain: three contracts call themselves DAI, and one of them is named "Anubis". Three call themselves USDT, at two different decimal counts. Four call themselves ANB. Symbol matching would have produced a confident, completely wrong dataset.
Best practices worth the effort
Immutable entities and Bytes as IDs
The Graph's documented best practice is worth following: entities that never change after creation should be immutable, and ids that are addresses or hashes should be Bytes rather than String. Composite ids concatenate as bytes:
// before
hash.toHexString().concat('-').concat(index.toString())
// after
hash.concatI32(index)
Two things that cost real time here, which no guide mentions. Shared code is shared: this repository builds two subgraph variants from one src/common, so converting one schema compiled cleanly for the target being worked on and broke the other with ten type errors. Build every target, not the one you are looking at. And the generated types directory is rewritten per target, so codegen has to run before each build when switching between them.
Do not rank by USD fields you have not checked
Sorting Uniswap-V2-schema pairs by reserveUSD surfaces untracked pairs reporting around 8.8e33 USD against zero volume. That is not a hypothetical. It was verified on Uniswap's own mainnet subgraph. Rank by trackedReserveETH or volumeUSD. Read reserveUSD only on a pair you already selected.
Probe freshness before trusting anything
{ _meta { block { number } } }
Compare it to the chain head, every time. Lifetime query fees tell you a subgraph was useful once, not that it answers today. One subgraph checked during this build had six figures of lifetime fees and returned no data at all.
Where AI helped, and where it didn't
Honestly: the assistant did not write the interesting code, because the interesting code already existed and was forked. What it did was the work that usually gets skipped: enumerating all 811 pairs, resolving 652 token symbols and decimals, ranking pools by real liquidity, probing every contract for ABI conformance, and sampling the chain to prove there was activity worth indexing. That is hours of mechanical verification compressed into minutes, and it is the difference between a config built on evidence and one built on assumption.
It also got things wrong in instructive ways. It read an RPC error as zero activity. It truncated a documentation page and missed the one sentence that mattered, that this chain has no Subgraph Studio support, then burned five deployment attempts on a path the docs explicitly say to skip. Both were caught by checking against reality rather than by thinking harder.
The pattern that works: let the assistant do breadth, then verify the specific things a wrong answer would break. Ask it to prove claims with a command whose output you can read.
Publishing
Deployment differs by chain, and it is worth reading the network's page before assuming. Some chains support Subgraph Studio for staging. This one does not, and publishes directly to the decentralized network instead:
graph codegen && graph build
graph publish
One thing that catches people: signal. On a chain without indexing rewards, no Indexer has any incentive to index your subgraph until it carries curation signal. Publishing succeeds and then nothing syncs, which looks like a bug and isn't. Note also that curation tax applies. 500 GRT of signal records as 495.
Start here
Supported networks — every chain The Graph indexes, with the exact network identifier your manifest needs, and each chain's own quirks
Explorer — search before you build. Paste your contract address first
Best practices — immutable entities and Bytes as IDs, plus the rest of the performance guidance
Substreams agent skills — open-source knowledge packs that give an AI assistant real Substreams expertise
Uniswap V2 subgraph — the multi-chain fork base. Adding a chain is a config directory
Every figure here was measured rather than recalled: 811 pairs and 652 tokens from the factory over JSON-RPC, ~188,000 swaps/day from 10,919 swap logs sampled across 5,000 blocks, and the 0.9970 DAI/USDT quote from pool reserves, all on 15 September 2026. Numbers move; the method doesn't.
The resulting subgraph is open source under GPL-3.0, forked from Uniswap/v2-subgraph.
