The catalogue
Everything held here.
64 entries across 8 collections, 42 dated dispatches, 12 hours end to end, plus 66 glossary terms and 28 sourced protocol parameters. Read a collection through, or arrive at one entry from a search and leave through a cross-reference. Both are intended.
- The problem The Graph solves A blockchain is a ledger, not a database. Answering an ordinary product question against one directly is slow, and that gap is the whole reason this protocol exists.
- Straight answers to the common questions The questions newcomers actually ask, answered without hedging, with a pointer to the entry that does the work properly.
- The roles, and the loop that pays for them Four roles, two sources of money, and one loop. Once you can draw the loop from memory, most of the protocol stops being surprising.
- Subgraphs, Substreams, Firehose and the Token API Four names people use interchangeably and should not. Two are data services you consume, one is the extraction layer underneath, and one is a hosted convenience.
- Where GRT lives now The protocol runs on Arbitrum One. A great deal of writing about The Graph still assumes it runs on Ethereum mainnet, and that writing will cost you money.
- Seeing it on the real network Prove to yourself that the shape of the protocol has stuck, then pick the role you actually came here for.
- What delegation actually is You are not staking, and you are not lending. You are buying a share of one operator's future earnings, and choosing which operators the network should have more of.
- Rewards, cuts, and what you actually take home The cut is what the indexer keeps, not what you get. Work the arithmetic once with real numbers and the advertised rates stop being persuasive.
- Choosing an indexer The headline rate is the least informative number on the page. Here is what to look at instead, and the specific trap that makes a bad indexer look excellent.
- Undelegation and the thawing period The constraint that dominates delegation economics, expressed as a number that never appears in an advertised return.
- What Horizon changed for delegators Delegation is now per data service rather than per indexer, the tax is gone, and slashing of delegated stake exists in the code with the switch off.
- Reading an indexer yourself Evaluate a real indexer against the criteria in this collection, and compute what you would actually take home.
- What curation is for Signal is the protocol's answer to a scheduling problem: which of thousands of subgraphs should scarce indexing capacity be pointed at, before anyone has queried them?
- Signal, shares, and the deposit that is burned What you actually hold when you signal, how your claim is calculated, and where the deposit charge goes.
- The flat curve on Arbitrum Curation on L1 rewarded arriving early. On Arbitrum it does not. An entire genre of curation strategy became obsolete, and it is still being taught.
- Strategy, and the risk nobody names Curation cannot be slashed, which leads people to describe it as low risk. Losing capital slowly to a forecast that was wrong is still losing capital.
- Making a forecast yourself Find a real subgraph, judge whether it will be queried, and check whether anything is actually serving it.
- What an indexer actually does Four services, one obligation, and a set of decisions the software will not make for you. The job is not running a node.
- Should you index, or just delegate? An honest decision guide, written to talk you out of it if the honest answer is no. Most people asking this question should delegate.
- Exponential rebates, and why Cobb-Douglas had to go Your rebate now depends only on your own stake and your own fees. Under the old mechanism it depended on what everyone else did, and over half of query fees were burned.
- Getting paid: receipts, RAVs and GraphTally Every query carries a signed receipt. Receipts aggregate into vouchers, vouchers settle on chain, and one configuration value decides how much you are prepared to lose if it goes wrong.
- Provisions: staking against a service Horizon turned one staking pool into stake provisioned to named data services, each with its own rules, its own thawing, and its own slashing.
- Allocations, POIs, and the gap between protocol and practice The protocol now permits allocations that stay open indefinitely. The shipped stack still recycles them. Both facts are true and you need both to plan capacity.
- Running the stack, conceptually What each component needs, how they fail, and which failures are silent. Not an installation guide, because the docs maintain that and it changes.
- Cost models and indexing rules Two configuration surfaces that decide most of your revenue: what you charge for a query, and what you agree to index at all.
- Disputes, arbitration and flexible slashing What can actually get you slashed, who decides, how much it costs, and the cheap habits that keep you out of it.
- Rewards eligibility: the gate nobody told you about Since GIP-0079 indexing rewards are gated on serving real gateway traffic. The criterion is smaller than people assume, and it is measured somewhere you cannot see.
- Before you commit stake Test the economics rather than the trivia, then plan the monitoring you would need before you allocate anything real.
- What a subgraph actually is Three files that together define a deterministic function from chain events to queryable rows. Getting the mental model right saves you from most subgraph bugs.
- Building and publishing, and what each step commits you to Studio for development, the network for production. The decisions that are hard to undo, and the one that determines whether anyone indexes your work at all.
- Querying from an application An API key, a gateway endpoint, and a set of assumptions about latency and freshness that will bite you if you leave them implicit.
- Why your subgraph is slow Three modelling decisions account for most of the difference between a subgraph that syncs in hours and one that takes days. None of them is about how clever your handler code is.
- Pruning, and what history costs A subgraph's database grows forever unless you tell it not to. Pruning is the switch, and it trades away two features you may be relying on without realising.
- Grafting, and shipping a fix without a resync It reuses an existing subgraph's data and carries on from a chosen block, turning a multi-day resync into a deploy. The docs advise against it exactly where you will want it most.
- Substreams Composable WASM modules over a Firehose stream. Reach for it when backfill time, throughput or a non-GraphQL destination is your actual problem.
- Firehose The extraction layer everything else stands on. You will probably never touch it, and knowing what it does explains why the layers above behave as they do.
- The Token API Balances, transfers, prices and NFTs over REST, across several chains, with no subgraph to author. The right first answer more often than developers expect.
- Choosing a data service A decision matrix that admits where each option loses, and a default that is right more often than the interesting answer.
- The alternatives, honestly The Graph is one of several ways to get indexed chain data, and it is the right answer less often than a site like this usually admits. Here is what the others are for.
- Designing an integration Pick the right service for a real requirement, then design a schema before writing any handler.
- Getting an endpoint that works You are not writing a subgraph. You need a key, an endpoint, and a clear view of what can go wrong between your application and the data.
- Integrating it properly Caching, timeouts, degradation and the health check that turns a silent wrong answer into a visible warning.
- Paying for queries Where the money goes, how to budget it, and why your query fee is not merely a cost line.
- Auditing an integration Audit one real integration against the failure modes that do not raise errors.
- The core stack Five repositories carry the protocol: the indexing engine, the indexer components, the contracts, the developer tooling and the client library. Everything else sits on top of them.
- Where the code lives Four organisations hold nearly everything, and which one a repository sits in tells you who is on the hook when it breaks.
- Indexing it yourself A second lane has grown up beside graph-node: single-binary indexers you run yourself, with no gateway, no network and no third party in the path.
- Gateways, and why there is more than one Every query reaches an indexer through a gateway, which picks who serves you and handles the payment. A protocol with one gateway has a single point of control it was designed to avoid.
- Authoring tools beyond AssemblyScript Subgraphs have been written in AssemblyScript since the beginning. Three projects argue that the language, and in one case the file format, was never the interesting part.
- Data services being built on Horizon Horizon made the protocol a substrate for services other than subgraph serving. Here is what people are actually building on it, and the shared machinery underneath.
- Tools for running an indexer The gap between the official stack and a well-run indexer is filled by community tooling: preflight checks, POI comparison, API guards and payment agreements.
- The oracles the protocol runs on Several things the protocol treats as facts are produced by oracles rather than derived on chain. Knowing which is which tells you where the trust actually sits.
- Reading the ecosystem yourself Nothing here is a test. Go and look at the repositories, and form your own view of what is maintained and what is somebody's weekend.
- How a change to the protocol actually ships A GIP is a proposal. A GGP is a vote. Knowing the difference lets you tell a discussion from a decision, which is most of reading this ecosystem accurately.
- The road to Horizon, and the fork not taken Horizon took almost two years and began three years before it shipped. The most consequential decision in it was not what to build but how to get there, and the Council chose the harder option.
- The proposal that would have abolished curation GIP-0058 proposed replacing curation entirely with indexing fees. It was written, amended, argued over and withdrawn. Reading a rejected proposal tells you more than reading an accepted one.
- How to read a GIP There are 85 of them and they are the best documentation this protocol has. Four fields and one section tell you most of what you need before reading a word of the specification.
- The Council, the Foundation, and grants Two distinct bodies with distinct jobs, which people conflate constantly. One votes on protocol changes. The other holds and deploys money.
- What the governance record does and does not show Two routes a decision can take, and only one of them leaves something you can read afterwards. Which route is chosen before anybody knows the outcome.
- Arbitration and disputes The part of the protocol where correctness is enforced by people rather than by code, why it has to be, and what that costs.
- Tokenomics: issuance, burns, and where it just moved Three percent issuance, several burns, and a twenty percent redirect that is now flowing. The arithmetic of who pays for the network to exist.
- The new mandate, and what the issuance buys A fifth of protocol issuance is being redirected to fund a change in what the Foundation does. What was published, what was only presented, and how to tell.
- Project Catalyst: the eight workstreams The work the redirected issuance is meant to fund, item by item, and the pattern in what is actually blocking each one.
- Following a proposal end to end Follow one real proposal from written argument to deployed behaviour, and form your own view on it.
- The Performance Charts Are Back, and Now They Add Up Query Performance, the QoS Quality panel and the directory's QoS column are back on Lodestar, read from Edge & Node's QoS oracle postings on Gnosis through a nest anyone can run. Rebuilding them showed the old charts averaged averages, hid outages and sat on a subgraph that had dropped whole buckets. Getting the new ones live took three days of faults, most of them silent and several of them ours. This is every figure, every fault, and how we checked.
- Dune for Lodestar: What Graph Data Is Actually There, and the Horizon-Shaped Hole We are wiring Dune into Lodestar as a second data source, alongside the indexing we run ourselves. Nothing is live yet. But the survey done to get there is useful on its own: 830 decoded Graph tables already exist, HorizonStaking is decoded under the legacy ABI so provisions and thaw requests are absent, and seven Horizon contracts are not decoded at all. Verified by address on 14 September 2026.
- The P&L Panel Was Wrong, and Daily Trends Is Back Rebuilding Lodestar's Daily Trends chart meant defining an indexer's daily rewards carefully, and doing that showed the P&L panel had been getting them wrong. Over the 30 days to 13 September it misstated 54 of the 58 indexers that were paid. Both are fixed today. Here is exactly what was wrong, how we checked the new figures, and what is still to come.
- Lodestar Is a Frontend Now Ninety-three API route files became none. Thirty-eight thousand lines came out of the frontend, six credentials left Vercel, and the migration kept finding bugs that had been live for months, not because anyone audited the code but because two implementations were forced to agree on the same answer. The last one went the same day, once a question about a signing key was settled by answering it rather than by working around it.
- The Rewrite We Didn't Do Lodestar's frontend rewrite was planned in two stages: tidy the Next.js app first, then move it to Vite. The first stage is finished and the second is not happening, on the plan's own terms. Getting there found two dashboard pages that errored for everyone who had a position, a badge reading NaN%, and a permit leak in the backend that had been waiting since the day it was written.
- Lodestar Now Reads No Graph Subgraph At All In July we moved two panels off The Graph and said the rest was a long road. On 6 September the last of it landed: there is no gateway client in the Lodestar repo, no GRAPH_API_KEY, and no fallback. Every protocol number on the dashboard now comes from a nest we run ourselves. Here is what moved, what we deleted instead of moving, and what still talks to a gateway on purpose.
Also held
References that cut across every collection.
66 terms Glossary
Every term the protocol uses, including the obsolete ones, labelled as obsolete so you know
what you are reading when you meet them elsewhere.
28 parameters The registry
Every protocol number with its source, a verbatim quote, and the date somebody read it.
Including the places where two official pages disagree.