-
Subgraphs
-
- {checkmark}
- {t('index.supportedNetworks.tableLegend.subgraphs.basic')}
-
-
- {checkmarks}
-
{t('index.supportedNetworks.tableLegend.subgraphs.full')}
+
Subgraphs
+
+
+
+ {t('index.supportedNetworks.tableLegend.subgraphs.studio')}
+
+
+
+ {t('index.supportedNetworks.tableLegend.subgraphs.network')}
+
+
+
+ {t('index.supportedNetworks.tableLegend.subgraphs.rewards')}
+
-
Firehose/Substreams
-
- {checkmark}
- {t('index.supportedNetworks.tableLegend.substreams.basic')}
-
-
- {checkmarks}
-
{t('index.supportedNetworks.tableLegend.substreams.full')}
+
Firehose/Substreams
+
+
+
+ {t('index.supportedNetworks.tableLegend.substreams.base')}
+
+
+
+ {t('index.supportedNetworks.tableLegend.substreams.extended')}
+
+
+
+ {t('index.supportedNetworks.tableLegend.substreams.other')}
+
@@ -147,10 +205,7 @@ export function NetworksTable({ networks }: { networks: SupportedNetwork[] }) {
{t('index.supportedNetworks.tableHeaders.subgraphs')}
- {t('index.supportedNetworks.tableHeaders.substreams')}
- |
-
- {t('index.supportedNetworks.tableHeaders.firehose')}
+ {t('index.supportedNetworks.tableHeaders.firehoseSubstreams')}
|
{filteredNetworks.map((network) => (
@@ -160,7 +215,10 @@ export function NetworksTable({ networks }: { networks: SupportedNetwork[] }) {
>
-
+
@@ -176,27 +234,12 @@ export function NetworksTable({ networks }: { networks: SupportedNetwork[] }) {
|
- {network.subgraphsSupportLevel === 'full' ? (
- checkmarks
- ) : network.subgraphsSupportLevel === 'basic' ? (
-
- {checkmark}
-
- ) : null}
+ {network.subgraphsTier !== 'none' ? : null}
|
- {network.substreamsSupportLevel === 'full'
- ? checkmarks
- : network.substreamsSupportLevel === 'basic'
- ? checkmark
- : null}
- |
-
- {network.firehoseSupportLevel === 'full'
- ? checkmarks
- : network.firehoseSupportLevel === 'basic'
- ? checkmark
- : null}
+ {network.substreamsTier !== 'none' ? (
+
+ ) : null}
|
))}
diff --git a/website/src/supportedNetworks/ResourceCards.tsx b/website/src/supportedNetworks/ResourceCards.tsx
index af973e6d7574..590981c9a8c2 100644
--- a/website/src/supportedNetworks/ResourceCards.tsx
+++ b/website/src/supportedNetworks/ResourceCards.tsx
@@ -8,7 +8,9 @@ type Resource = {
icon?: React.ReactNode
}
-export const evmCards = [
+// EVM networks that support BOTH Subgraphs and Substreams. Subgraph guides fill the top
+// row; Substreams guides fill the bottom row (see the 3x3 grid in NetworkDetailsPage).
+export const subgraphsAndSubstreamsCards = [
{
href: 'https://thegraph.com/docs/en/subgraphs/quick-start/',
titleKey: 'index.networkGuides.evm.subgraphQuickStart.title' as const,
@@ -17,34 +19,43 @@ export const evmCards = [
icon:
,
},
{
- href: 'https://thegraph.com/docs/en/substreams/quick-start/',
- titleKey: 'index.networkGuides.evm.substreamsQuickStart.title' as const,
- descriptionKey: 'index.networkGuides.evm.substreamsQuickStart.description' as const,
- minutes: 15,
- icon:
,
+ href: 'https://thegraph.com/docs/en/subgraphs/existing-subgraphs/explorer/',
+ titleKey: 'index.networkGuides.evm.graphExplorer.title' as const,
+ descriptionKey: 'index.networkGuides.evm.graphExplorer.description' as const,
+ minutes: 12,
+ icon:
,
},
{
href: 'https://thegraph.com/docs/en/subgraphs/providers/subgraph-studio/introduction/',
- titleKey: 'index.networkGuides.evm.billing.title' as const,
- descriptionKey: 'index.networkGuides.evm.billing.description' as const,
+ titleKey: 'index.networkGuides.evm.studioBilling.title' as const,
+ descriptionKey: 'index.networkGuides.evm.studioBilling.description' as const,
minutes: 5,
- icon:
, // TODO: Is this really the right icon for this?
+ icon:
,
},
{
- href: 'https://thegraph.com/docs/en/subgraphs/existing-subgraphs/explorer/',
- titleKey: 'index.networkGuides.evm.graphExplorer.title' as const,
- descriptionKey: 'index.networkGuides.evm.graphExplorer.description' as const,
- minutes: 12,
+ href: 'https://thegraph.com/docs/en/substreams/quick-start/',
+ titleKey: 'index.networkGuides.evm.substreamsQuickStart.title' as const,
+ descriptionKey: 'index.networkGuides.evm.substreamsQuickStart.description' as const,
+ minutes: 15,
+ icon:
,
},
{
href: 'https://substreams.dev/',
titleKey: 'index.networkGuides.evm.substreamsDev.title' as const,
descriptionKey: 'index.networkGuides.evm.substreamsDev.description' as const,
minutes: 5,
+ icon:
,
+ },
+ {
+ href: 'https://thegraph.com/docs/en/substreams/providers/the-graph-market/',
+ titleKey: 'index.networkGuides.evm.substreamsPricing.title' as const,
+ descriptionKey: 'index.networkGuides.evm.substreamsPricing.description' as const,
+ minutes: 5,
+ icon:
,
},
]
-export const evmSubgraphsOnlyCards = [
+export const subgraphsOnlyCards = [
{
href: 'https://thegraph.com/docs/en/subgraphs/quick-start/',
titleKey: 'index.networkGuides.evm.subgraphQuickStart.title' as const,
@@ -80,7 +91,7 @@ export const evmSubgraphsOnlyCards = [
},
]
-export const nonEvmCards = [
+export const substreamsOnlyCards = [
{
href: 'https://thegraph.com/docs/en/substreams/quick-start/',
titleKey: 'index.networkGuides.evm.substreamsQuickStart.title' as const,
diff --git a/website/src/supportedNetworks/customContent/README.md b/website/src/supportedNetworks/customContent/README.md
index 611225e0cd4c..eef6e9a086f7 100644
--- a/website/src/supportedNetworks/customContent/README.md
+++ b/website/src/supportedNetworks/customContent/README.md
@@ -31,3 +31,30 @@ Networks not listed in `index.ts` render the default templated page, unchanged.
- The `.mdx` is compiled by Nextra's loader as a non-page import, so the same remark plugins (callouts, etc.) and MDX component styling used across the docs apply automatically — the content looks native to the site.
- The page only exists if the network is present in the **published** registry that the build fetches. Custom content here does not create the page; it only enriches a page that the registry already generates.
+
+## Reusable content blocks
+
+Common, repeated sections live in shared MDX partials (prefixed `_`) so a single edit updates every network that uses them. Import a partial and render it with the network-specific values as props.
+
+### Substreams section
+
+Two partials cover the standard "Indexing _{Chain}_ with Substreams" section for EVM networks, differing only by the block model the network is served with:
+
+- `_substreams-extended.mdx` — **extended** EVM block model (full transaction, call, and event data). Used by chains like BSC, Polygon, Monad, Ink.
+- `_substreams-base.mdx` — **base** EVM block model (block, transaction, and event/log data). Used by chains like Blast, MegaETH, TRON EVM.
+
+```mdx
+import SubstreamsExtended from './_substreams-extended.mdx'
+
+
+```
+
+Props:
+
+- `chainName` (required) — short name used throughout the body copy (e.g. `BSC`).
+- `title` (optional) — heading display name; defaults to `chainName` (e.g. `BNB Smart Chain` when `chainName` is `BSC`).
+- `keyProvider` (optional) — set to `"pinax"` when the network has no The Graph Market Substreams endpoint, so step 1 sends readers to [Pinax Network](https://app.pinax.network/) for an API key instead of thegraph.market.
+
+The provider sentence on each network page ("… via [The Graph Market] and [Pinax Network]") should list only the providers in that network's `services.substreams` entries in the registry: `streamingfast.io` → The Graph Market, `pinax.network` → Pinax Network, `data.nexus` → Data Nexus.
+
+Non-EVM networks (Solana, Bitcoin, Injective, Stellar, etc.) use bespoke Substreams wording and keep their section inline rather than using these blocks.
diff --git a/website/src/supportedNetworks/customContent/_subgraph-community.mdx b/website/src/supportedNetworks/customContent/_subgraph-community.mdx
new file mode 100644
index 000000000000..cac6638e03b1
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/_subgraph-community.mdx
@@ -0,0 +1,162 @@
+{/* Reusable "community" Subgraph section.
+
+The community model: publish Subgraphs directly to The Graph Network and add curation signal so select Indexers on the network pick them up (a curation backstop). Renders "### Indexing {Chain} with Subgraphs" + the Quick Start (Steps 1-4). Each network page keeps its own intro and any chain-specific "Find Existing Subgraphs" card grid inline.
+
+Props: - chainName (required) short name in body copy, e.g. "BSC", "Polygon" - title (optional) heading name; defaults to chainName (e.g. "BNB Smart Chain") - networkId (required) `graph init` / manifest network id, e.g. "bsc", "matic" - slug (required) example Subgraph slug base, e.g. "bsc", "polygon" - explorerUrl (required) block explorer URL, e.g. "https://bscscan.com" - explorerName (required) explorer brand for the ABI hint, e.g. "BscScan", "Blockscout" - rpcUrl (required) RPC endpoint used for local verification - customNetwork (optional) network not in `graph init`'s list; enter it manually - noStudio (optional) no Subgraph Studio staging; publish direct / verify locally */}
+
+import { Callout, CodeBlock } from '@/components'
+import { ExperimentalCodeInline as Code } from '@edgeandnode/gds'
+
+### Indexing {props?.title ?? props?.chainName} with Subgraphs [#indexing-with-subgraphs]
+
+Getting smart contract data is hard. You write your own indexer, run your own database, and handle chain reorganizations yourself. The Graph removes that work, giving you an open API, called a [Subgraph](/subgraphs/overview/), that you query with GraphQL.
+
+{props.chainName} is EVM-compatible, so the Subgraph workflow is the same as on most EVM chains. You point a Subgraph at your {props.chainName} contract, define the entities you want, and Indexers on The Graph Network keep those entities current and queryable.
+
+#### Quick Start: Build Your Own Subgraph
+
+Building a Subgraph for {props.chainName} takes three steps:
+
+1. Initialize a Subgraph project from your {props.chainName} contract.
+2. Publish it to The Graph Network for decentralized indexing.
+3. Query it over GraphQL with an API key.
+
+See the [Subgraph pricing page](https://thegraph.com/studio-pricing/) for current query rates and free-tier limits.
+
+{props.noStudio && (
+
+
+ {props.chainName} is supported on The Graph Network, but does not currently have Subgraph Studio testing/staging support. Skip the standard graph deploy and Studio playground path. Instead, you can validate your Subgraph locally (see below) or publish directly to The Graph Network, where a decentralized Indexer that supports {props.chainName} indexes it.
+
+)}
+
+##### Step 1: Initialize your Subgraph project
+
+Install the Graph CLI with the package manager you prefer:
+
+```sh
+# npm
+npm install -g @graphprotocol/graph-cli@latest
+
+# or yarn
+yarn global add @graphprotocol/graph-cli
+```
+
+Verify the install:
+
+```sh
+graph --version
+```
+
+Initialize from your {props.chainName} contract:
+
+```sh
+graph init
+```
+
+The CLI walks you through a set of prompts{props.customNetwork ? `. ${props.chainName} is a custom EVM network, so provide the network details manually when asked` : ''}:
+
+- **Protocol**: choose `ethereum`. {props.chainName} is EVM-compatible.
+- **Subgraph slug**: an identifier for your Subgraph, for example
{`my-${props.slug}-subgraph`}.
+- **Directory**: where the project is scaffolded.
+- **Ethereum network**: {props.customNetwork ? <>enter
{props.networkId} as the network identifier. : <>select
{props.networkId} from the list of supported networks.}
+- **Contract address**: the address of the contract you want to index. Find it on
{props.explorerUrl.replace(/^https?:\/\//, '')}.
+- **ABI**: if the CLI cannot fetch the ABI, export it from your build artifacts or the {props.explorerName} contract page. Supply it as a JSON file.
+- **Start block**: the block your contract was deployed at. Set this so indexing does not scan from genesis. The explorer shows the deployment block.
+- **Contract name**: the name of your contract.
+- **Index contract events as entities**: set this to `true`. The CLI then scaffolds entities and mappings for every emitted event.
+
+
+ {props.customNetwork ? (
+ <>
+ The network value you enter ({props.networkId}) must match the network identifier that
+ The Graph has registered for {props.chainName}. If graph init does not recognize the network,
+ scaffold with any EVM network and set the network field manually in subgraph.yaml (next
+ step).
+
+ ) : (
+ <>
+ The network value for {props.chainName} is {props.networkId}. graph init{' '}
+ recognizes it directly, so you can select it from the list of supported networks. You can also set the{' '}
+ network field manually in subgraph.yaml (next step).
+
+ )}
+
+
+##### Step 2: Write and build your Subgraph
+
+You work with three files:
+
+- **Manifest:** `subgraph.yaml` defines which data sources your Subgraph indexes.
+- **Schema:** `schema.graphql` defines the entities you want to query.
+- **Mappings:** `src/mapping.ts` uses AssemblyScript that translates on-chain events into your entities.
+
+Point the manifest at {props.chainName}:
+
+
+ {`dataSources:
+ - kind: ethereum
+ name: MyContract
+ network: ${props.networkId}
+ source:
+ address: '0xYour${props.slug
+ .split('-')
+ .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+ .join('')}ContractAddress'
+ abi: MyContract
+ startBlock: 123456 # your contract's deployment block`}
+
+
+For a full walkthrough of schema and mapping authoring, see [Creating a Subgraph](/subgraphs/developing/creating/starting-your-subgraph/).
+
+Generate types and build:
+
+```sh
+graph codegen && graph build
+```
+
+**Optional: verify locally before publishing.** {props.noStudio ? `The Studio playground cannot index ${props.chainName}, so test` : 'You can test'} indexing with a local [Graph Node](https://github.com/graphprotocol/graph-node) pointed at an RPC endpoint for {props.chainName}. In your `docker-compose.yml`, set the Ethereum environment to {props.customNetwork ? `your ${props.chainName} network` : props.chainName}:
+
+
+ {`environment:
+ ethereum: '${props.networkId}:${props.rpcUrl}'`}
+
+
+Create and deploy to your local node:
+
+
+ {`graph create --node http://localhost:8020/ my-${props.slug}-subgraph
+graph deploy --node http://localhost:8020/ --ipfs http://localhost:5001 my-${props.slug}-subgraph`}
+
+
+Query the local endpoint until your entities look right, then publish.
+
+##### Step 3: Publish & Curate on The Graph Network
+
+{props.noStudio ? `This is the recommended path for ${props.chainName}.` : ''}
+
+Publishing is an on-chain action that:
+
+- makes your Subgraph available for decentralized [Indexers](/indexing/overview/){props.noStudio ? ` that support ${props.chainName}` : ''} to index,
+- makes it publicly searchable and queryable in [Graph Explorer](https://thegraph.com/explorer/),
+- and makes it available for [Curators](/resources/roles/curating/) to add signal.
+
+Build, then publish from the Graph CLI:
+
+```sh
+graph codegen && graph build
+graph publish
+```
+
+A browser window opens. Connect your wallet, add metadata (name, description, image), and publish your Subgraph. The `--protocol-network` flag refers to where The Graph's protocol contracts live (Arbitrum One), not to {props.chainName}.
+
+> [!TIP] During the publish transaction, you can add 500 GRT in curation signal to save on gas fees. Signal tells Indexers that your Subgraph is worth indexing. Any Subgraph with 500 GRT or more signal will automatically be indexed; without signal, no Indexer is incentivized to pick up your Subgraph.
+
+##### Step 4: Query your Subgraph
+
+After you publish, open your Subgraph in [Graph Explorer](https://thegraph.com/explorer/) and copy its query URL from the **Query** button.
+
+1. Create an API key from the API Keys dashboard at [thegraph.com/studio](https://thegraph.com/studio/). This dashboard handles {props.noStudio ? 'keys and billing for The Graph Network on Arbitrum, independent of which chains Studio can index' : 'API keys and billing for The Graph Network'}.
+2. Send GraphQL queries to the query URL with your API key.
+
+See the [Subgraph pricing page](https://thegraph.com/studio-pricing/) for query rates, and [Querying The Graph](/subgraphs/querying/introduction/) for the full query API.
diff --git a/website/src/supportedNetworks/customContent/_subgraph-studio.mdx b/website/src/supportedNetworks/customContent/_subgraph-studio.mdx
new file mode 100644
index 000000000000..f42af2b70844
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/_subgraph-studio.mdx
@@ -0,0 +1,115 @@
+{/* Reusable "studio" Subgraph section.
+
+For chains where Subgraph publishing is ENABLED but there is no guaranteed indexing on The Graph Network yet: develop, test, and query through Subgraph Studio (https://thegraph.com/docs/en/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Renders "### Indexing {Chain} with Subgraphs" + a prominent no-guaranteed-indexing callout + the Studio Quick Start (Steps 1-4). Each network page keeps its own intro inline.
+
+Props: - chainName (required) short name in body copy, e.g. "Sei", "Chiliz" - title (optional) heading name; defaults to chainName - networkId (required) `graph init` / manifest network id, e.g. "sei-mainnet" - slug (required) example Subgraph slug base, e.g. "sei" - explorerUrl (required) block explorer URL, e.g. "https://seitrace.com" - explorerName (required) explorer brand for the ABI hint, e.g. "Seitrace", "Blockscout" */}
+
+import { Callout, CodeBlock } from '@/components'
+import { ExperimentalCodeInline as Code } from '@edgeandnode/gds'
+
+### Indexing {props?.title ?? props?.chainName} with Subgraphs [#indexing-with-subgraphs]
+
+Getting smart contract data is hard. You write your own indexer, run your own database, and handle chain reorganizations yourself. The Graph removes that work, giving you an open API, called a [Subgraph](/subgraphs/overview/), that you query with GraphQL.
+
+{props.chainName} is EVM-compatible, so the Subgraph workflow is the same as on most EVM chains. You develop and test your Subgraph in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/), then query it through the development endpoint.
+
+
+ Subgraph publishing is enabled for {props.chainName}, but no guaranteed indexing is available via The Graph Network at
+ this time. You can develop, test, and publish your Subgraph in [Subgraph
+ Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/), but Indexers on the decentralized network
+ are not guaranteed to index and serve it yet.
+
+
+#### Quick Start: Build Your Own Subgraph
+
+Building a Subgraph for {props.chainName} takes four steps:
+
+1. Create your Subgraph in Subgraph Studio.
+2. Initialize a Subgraph project from your {props.chainName} contract.
+3. Deploy it to Subgraph Studio and test it in the playground.
+4. Query it over GraphQL with the development endpoint.
+
+See the [Subgraph pricing page](https://thegraph.com/studio-pricing/) for current query rates and free-tier limits.
+
+##### Step 1: Create your Subgraph in Subgraph Studio
+
+Open [Subgraph Studio](https://thegraph.com/studio/) and connect your wallet (MetaMask, Coinbase Wallet, WalletConnect, or Safe). Create a Subgraph, then copy its **slug** and your **deploy key** from the Subgraph details page — you use both from the CLI. For a full walkthrough, see [Using Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/).
+
+##### Step 2: Initialize your Subgraph project
+
+Install the Graph CLI with the package manager you prefer:
+
+```sh
+# npm
+npm install -g @graphprotocol/graph-cli@latest
+
+# or yarn
+yarn global add @graphprotocol/graph-cli
+```
+
+Initialize from your {props.chainName} contract:
+
+```sh
+graph init
+```
+
+The CLI walks you through a set of prompts:
+
+- **Protocol**: choose `ethereum`. {props.chainName} is EVM-compatible.
+- **Subgraph slug**: use the slug of the Subgraph you created in Subgraph Studio, for example
{`my-${props.slug}-subgraph`}.
+- **Directory**: where the project is scaffolded.
+- **Ethereum network**: select
{props.networkId} from the list of supported networks.
+- **Contract address**: the address of the contract you want to index. Find it on
{props.explorerUrl.replace(/^https?:\/\//, '')}.
+- **ABI**: if the CLI cannot fetch the ABI, export it from your build artifacts or the {props.explorerName} contract page. Supply it as a JSON file.
+- **Start block**: the block your contract was deployed at. Set this so indexing does not scan from genesis. The explorer shows the deployment block.
+- **Contract name**: the name of your contract.
+- **Index contract events as entities**: set this to `true`. The CLI then scaffolds entities and mappings for every emitted event.
+
+Point the manifest at {props.chainName}:
+
+
+ {`dataSources:
+ - kind: ethereum
+ name: MyContract
+ network: ${props.networkId}
+ source:
+ address: '0xYour${props.slug
+ .split('-')
+ .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+ .join('')}ContractAddress'
+ abi: MyContract
+ startBlock: 123456 # your contract's deployment block`}
+
+
+For a full walkthrough of schema and mapping authoring, see [Creating a Subgraph](/subgraphs/developing/creating/starting-your-subgraph/). Then generate types and build:
+
+```sh
+graph codegen && graph build
+```
+
+##### Step 3: Deploy to Subgraph Studio
+
+Authenticate the CLI with the deploy key from your Subgraph details page:
+
+```sh
+graph auth
+```
+
+Then deploy your Subgraph to Subgraph Studio (the CLI asks for a version label such as `0.0.1`):
+
+```sh
+graph deploy
+```
+
+Deploying pushes your Subgraph to Subgraph Studio, where you can test it in the playground and check indexing logs. It does not publish it to the decentralized network — see [Using Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) for details.
+
+##### Step 4: Query your Subgraph
+
+Once your Subgraph is syncing in Studio, test your queries against the **development query URL** shown on the Subgraph details page.
+
+1. Create an API key from the API Keys dashboard at [thegraph.com/studio](https://thegraph.com/studio/).
+2. Send GraphQL queries to the development query URL with your API key. The development endpoint is rate-limited (currently 3,000 queries per day).
+
+You can [publish your Subgraph to The Graph Network](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) at any time, but Indexers are not guaranteed to serve {props.chainName} Subgraphs yet, so the Subgraph Studio development endpoint is the reliable way to query today.
+
+See [Querying The Graph](/subgraphs/querying/introduction/) for the full query API.
diff --git a/website/src/supportedNetworks/customContent/_substreams-base.mdx b/website/src/supportedNetworks/customContent/_substreams-base.mdx
new file mode 100644
index 000000000000..93dfe6224e24
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/_substreams-base.mdx
@@ -0,0 +1,20 @@
+{/* Reusable Substreams section for EVM networks served with the BASE EVM block model (block, transaction, and event/log data).
+
+Props: - chainName (required): short name used in the body copy, e.g. "Blast", "MegaETH". - title (optional): heading display name; defaults to chainName. - keyProvider (optional): set to "pinax" when the network has no The Graph Market endpoint, so step 1 points to Pinax Network for the API key. */}
+
+### Indexing {props?.title ?? props?.chainName} with Substreams [#indexing-with-substreams]
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). {props?.chainName} is served with the base EVM block model, so Substreams modules have access to block, transaction, and event (log) data. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on {props?.chainName}; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and {props?.keyProvider === 'pinax' ? <>get an API key from [Pinax Network](https://app.pinax.network/) : <>get a key at [thegraph.market](https://thegraph.market/) (no personal information required)}.
+2. Scaffold a project with `substreams init` and choose the EVM path, pointing it at your {props?.chainName} contract.
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/_substreams-extended.mdx b/website/src/supportedNetworks/customContent/_substreams-extended.mdx
new file mode 100644
index 000000000000..2bbdfad14bc9
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/_substreams-extended.mdx
@@ -0,0 +1,20 @@
+{/* Reusable Substreams section for EVM networks served with the EXTENDED EVM block model (full transaction, call, and event data).
+
+Props: - chainName (required): short name used in the body copy, e.g. "BSC", "Polygon". - title (optional): heading display name; defaults to chainName (e.g. "BNB Smart Chain" when chainName is "BSC"). - keyProvider (optional): set to "pinax" when the network has no The Graph Market endpoint, so step 1 points to Pinax Network for the API key. */}
+
+### Indexing {props?.title ?? props?.chainName} with Substreams [#indexing-with-substreams]
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). {props?.chainName} is served with the extended EVM block model, so Substreams modules have access to full transaction, call, and event data. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules — DEX trades, token transfers, contract events, and more — that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on {props?.chainName}; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and {props?.keyProvider === 'pinax' ? <>get an API key from [Pinax Network](https://app.pinax.network/) : <>get a key at [thegraph.market](https://thegraph.market/) (no personal information required)}.
+2. Scaffold a project with `substreams init` and choose the EVM path, pointing it at your {props?.chainName} contract.
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/anubis.mdx b/website/src/supportedNetworks/customContent/anubis.mdx
index 0b52a4f84cd5..093cc29deded 100644
--- a/website/src/supportedNetworks/customContent/anubis.mdx
+++ b/website/src/supportedNetworks/customContent/anubis.mdx
@@ -1,175 +1,18 @@
+import SubgraphCommunity from './_subgraph-community.mdx'
+
### Getting Started on Anubis
Anubis Chain is a privacy-focused, EVM-compatible Layer 1 that pairs base-layer privacy (PLONK ZK proofs and selective disclosure) with publicly verifiable onchain data, live on mainnet since April 2026 and already running 1M+ transactions a day across a growing DeFi ecosystem (RocketSwap, AWAKE). A subgraph could index that onchain activity — DEX swaps, pools, and liquidity; lending and RWA positions; token transfers and holder balances; and contract events — and serve it via GraphQL. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
Importantly, Anubis is a selective-privacy chain. A Subgraph can only index data that is public on-chain. Transparent transactions, and the events they emit, are fully indexable. Data inside shielded (PLONK ZK) transactions is not visible on-chain, so it cannot be indexed. Design your contract's public events with this in mind if you want that data to be queryable.
-### Indexing Anubis with Subgraphs
-
-Getting historical data off a smart contract is hard. You write your own indexer, run your own database, and handle chain reorganizations yourself. The Graph removes that work. It gives you an open API, called a Subgraph, that you query with GraphQL.
-
-Anubis is EVM-compatible, so the Subgraph workflow is the same as on most EVM chains. You point a Subgraph at your Anubis contract, define the entities you want, and Indexers on The Graph Network keep those entities current and queryable.
-
-### Quick Start
-
-Building a Subgraph for Anubis takes three steps:
-
-1. Initialize a Subgraph project from your Anubis contract.
-2. Publish it to The Graph Network for decentralized indexing.
-3. Query it over GraphQL with an API key.
-
-See the [Subgraph pricing page](https://thegraph.com/studio-pricing/) for current query rates and free-tier limits.
-
-> [!NOTE] Anubis is supported on The Graph Network, but does not currently have Subgraph Studio testing/staging support. Skip the standard `graph deploy` and Studio playground path. Instead, you can validate your Subgraph locally (see below) or publish directly to The Graph Network, where a decentralized Indexer that supports Anubis indexes it.
-
-#### Step 1: Initialize your Subgraph project
-
-Install the Graph CLI with the package manager you prefer:
-
-```sh
-# npm
-npm install -g @graphprotocol/graph-cli@latest
-
-# or yarn
-yarn global add @graphprotocol/graph-cli
-```
-
-Verify the install:
-
-```sh
-graph --version
-```
-
-Initialize from your Anubis contract:
-
-```sh
-graph init
-```
-
-The CLI walks you through a set of prompts. Anubis is a custom EVM network, so provide the network details manually when asked:
-
-- **Protocol**: choose `ethereum`. Anubis is EVM-compatible.
-- **Subgraph slug**: an identifier for your Subgraph, for example `my-anubis-subgraph`.
-- **Directory**: where the project is scaffolded.
-- **Ethereum network**: enter `anubis` as the network identifier.
-- **Contract address**: the address of the contract you want to index. Find it on [browser.anubispace.org](https://browser.anubispace.org).
-- **ABI**: if the CLI cannot fetch the ABI, export it from your build artifacts or the Blockscout contract page. Supply it as a JSON file.
-- **Start block**: the block your contract was deployed at. Set this so indexing does not scan from genesis. The explorer shows the deployment block.
-- **Contract name**: the name of your contract.
-- **Index contract events as entities**: set this to `true`. The CLI then scaffolds entities and mappings for every emitted event.
-
-> [!NOTE] The `network` value you enter (`anubis`) must match the network identifier that The Graph has registered for Anubis. If `graph init` does not recognize the network, scaffold with any EVM network and set the `network` field manually in `subgraph.yaml` (next step).
-
-#### Step 2: Write and build your Subgraph
-
-You work with three files:
-
-- **Manifest** (`subgraph.yaml`): defines which data sources your Subgraph indexes.
-- **Schema** (`schema.graphql`): defines the entities you want to query.
-- **Mappings** (`src/mapping.ts`): AssemblyScript that translates on-chain events into your entities.
-
-Point the manifest at Anubis:
-
-```yaml
-dataSources:
- - kind: ethereum
- name: MyContract
- network: anubis # must match The Graph's Anubis network identifier
- source:
- address: '0xYourAnubisContractAddress'
- abi: MyContract
- startBlock: 123456 # your contract's deployment block
-```
-
-For a full walkthrough of schema and mapping authoring, see [Creating a Subgraph](/subgraphs/developing/creating/starting-your-subgraph/).
-
-Generate types and build:
-
-```sh
-graph codegen && graph build
-```
-
-**Optional: verify locally before publishing.** The Studio playground cannot index Anubis, so test indexing with a local [Graph Node](https://github.com/graphprotocol/graph-node) pointed at an Anubis RPC endpoint. In your `docker-compose.yml`, set the Ethereum environment to your Anubis network:
-
-```yaml
-environment:
- ethereum: 'anubis:https://rpc.anubispace.org'
-```
-
-Create and deploy to your local node:
-
-```sh
-graph create --node http://localhost:8020/ my-anubis-subgraph
-graph deploy --node http://localhost:8020/ --ipfs http://localhost:5001 my-anubis-subgraph
-```
-
-Query the local endpoint until your entities look right, then publish.
-
-#### Step 3: Publish to The Graph Network
-
-This is the recommended path for Anubis. Publishing is an on-chain action that:
-
-- makes your Subgraph available for decentralized [Indexers](/indexing/overview/) that support Anubis to index,
-- makes it publicly searchable and queryable in [Graph Explorer](https://thegraph.com/explorer/),
-- and makes it available for [Curators](/resources/roles/curating/) to add signal.
-
-Build, then publish from the Graph CLI:
-
-```sh
-graph codegen && graph build
-graph publish
-```
-
-A browser window opens. Connect your wallet, add metadata (name, description, image), and publish your Subgraph. The `--protocol-network` flag refers to where The Graph's protocol contracts live (Arbitrum One), not to Anubis.
-
-> [!TIP] During the publish transaction, you can add 500 GRT in curation signal to save on gas fees. Signal tells Indexers that your Subgraph is worth indexing. Any Subgraph with 500 GRT or more signal will automatically be indexed; without signal, no Indexer is incentivized to pick up your Subgraph.
-
-#### Step 4: Query your Subgraph
-
-After you publish, open your Subgraph in [Graph Explorer](https://thegraph.com/explorer/) and copy its query URL from the **Query** button.
-
-1. Create an API key from the API Keys dashboard at [thegraph.com/studio](https://thegraph.com/studio/). This dashboard handles keys and billing for The Graph Network on Arbitrum, independent of which chains Studio can index.
-2. Send GraphQL queries to the query URL with your API key.
-
-See the [Subgraph pricing page](https://thegraph.com/studio-pricing/) for query rates, and [Querying The Graph](/subgraphs/querying/introduction/) for the full query API.
-
-### Appendix
-
-#### Sample GraphQL query
-
-```graphql
-{
- transfers(first: 5, orderBy: blockNumber, orderDirection: desc) {
- id
- from
- to
- value
- blockNumber
- }
-}
-```
-
-#### Querying from JavaScript
-
-```js
-const query = `
- {
- transfers(first: 5, orderBy: blockNumber, orderDirection: desc) {
- id
- from
- to
- value
- blockNumber
- }
- }
-`
-
-const res = await fetch('https://gateway.thegraph.com/api//subgraphs/id/', {
- method: 'POST',
- headers: { 'Content-Type': 'application/json' },
- body: JSON.stringify({ query }),
-})
-
-const { data } = await res.json()
-console.log(data.transfers)
-```
+
diff --git a/website/src/supportedNetworks/customContent/arbitrum-one.mdx b/website/src/supportedNetworks/customContent/arbitrum-one.mdx
new file mode 100644
index 000000000000..e7c16758c8e6
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/arbitrum-one.mdx
@@ -0,0 +1,22 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Arbitrum One
+
+Arbitrum One is an Ethereum Layer 2 built by Offchain Labs using optimistic-rollup technology, and one of the largest L2s by total value locked, with a deep DeFi, perps, and gaming ecosystem. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Arbitrum One is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/arbitrum-sepolia.mdx b/website/src/supportedNetworks/customContent/arbitrum-sepolia.mdx
new file mode 100644
index 000000000000..227f30303807
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/arbitrum-sepolia.mdx
@@ -0,0 +1,22 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Arbitrum Sepolia Testnet
+
+Arbitrum Sepolia Testnet is the primary public test network for Arbitrum One, the Offchain Labs Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Arbitrum Sepolia Testnet is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/arc-testnet.mdx b/website/src/supportedNetworks/customContent/arc-testnet.mdx
new file mode 100644
index 000000000000..16257a0d14b0
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/arc-testnet.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Arc Testnet
+
+Arc Testnet is the public test network for Arc, Circle's EVM-compatible Layer 1 for stablecoin finance, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Arc Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Arc Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/arc.mdx b/website/src/supportedNetworks/customContent/arc.mdx
new file mode 100644
index 000000000000..d5869613955e
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/arc.mdx
@@ -0,0 +1,15 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Arc
+
+Arc is an EVM-compatible Layer 1 built by Circle for stablecoin finance, using USDC as its native gas token and designed for payments, FX, and institutional settlement. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Arc is supported by The Graph in two ways:
+
+- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/avalanche.mdx b/website/src/supportedNetworks/customContent/avalanche.mdx
new file mode 100644
index 000000000000..14780b28a05c
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/avalanche.mdx
@@ -0,0 +1,22 @@
+import SubstreamsBase from './_substreams-base.mdx'
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Avalanche
+
+Avalanche C-Chain is the EVM-compatible contract chain of the Avalanche network, a high-throughput Layer 1 with sub-second finality and a broad DeFi, gaming, and institutional ecosystem, with AVAX as its native token. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Avalanche is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/base-sepolia.mdx b/website/src/supportedNetworks/customContent/base-sepolia.mdx
new file mode 100644
index 000000000000..ba42c7d4e929
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/base-sepolia.mdx
@@ -0,0 +1,9 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+
+### Indexing Data on Base Sepolia Testnet
+
+Base Sepolia Testnet is the primary public test network for Base, Coinbase's OP Stack Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+Base Sepolia Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
diff --git a/website/src/supportedNetworks/customContent/base.mdx b/website/src/supportedNetworks/customContent/base.mdx
new file mode 100644
index 000000000000..0b21301ca49d
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/base.mdx
@@ -0,0 +1,22 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Base
+
+Base is an Ethereum Layer 2 built on the OP Stack and part of the Optimism Superchain, incubated by Coinbase, with one of the fastest-growing DeFi, consumer, and onchain-social ecosystems in crypto. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Base is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/blast-mainnet.mdx b/website/src/supportedNetworks/customContent/blast-mainnet.mdx
new file mode 100644
index 000000000000..27d5f97836ed
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/blast-mainnet.mdx
@@ -0,0 +1,9 @@
+import SubstreamsBase from './_substreams-base.mdx'
+
+### Indexing Data on Blast
+
+Blast is an Ethereum Layer 2 built on the OP Stack that offers native yield on ETH and stablecoins for its DeFi and dApp ecosystem. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+Blast is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
diff --git a/website/src/supportedNetworks/customContent/boba-testnet.mdx b/website/src/supportedNetworks/customContent/boba-testnet.mdx
new file mode 100644
index 000000000000..787fd161fd55
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/boba-testnet.mdx
@@ -0,0 +1,16 @@
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Boba Sepolia Testnet
+
+Boba Sepolia Testnet is the public test network for Boba Network, an Ethereum Layer 2 optimistic rollup, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Boba Sepolia Testnet is supported by The Graph with Subgraphs — open APIs you publish to The Graph Network, where Indexers sync and serve the data while you manage your service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+
+
diff --git a/website/src/supportedNetworks/customContent/boba.mdx b/website/src/supportedNetworks/customContent/boba.mdx
new file mode 100644
index 000000000000..3b7db709058d
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/boba.mdx
@@ -0,0 +1,16 @@
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Boba
+
+Boba Network is an Ethereum Layer 2 optimistic rollup that adds hybrid compute for calling external APIs from smart contracts, supporting DeFi and consumer applications. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Boba is supported by The Graph with Subgraphs — open APIs you publish to The Graph Network, where Indexers sync and serve the data while you manage your service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+
+
diff --git a/website/src/supportedNetworks/customContent/bsc.mdx b/website/src/supportedNetworks/customContent/bsc.mdx
new file mode 100644
index 000000000000..1856f0427740
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/bsc.mdx
@@ -0,0 +1,72 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import { Card } from '@/components'
+import SubgraphCommunity from './_subgraph-community.mdx'
+import { Subgraph } from '@edgeandnode/gds/icons'
+
+### Indexing Data on BNB Smart Chain
+
+BNB Smart Chain (BSC) is a high-performance, EVM-compatible Layer 1 that has run in production since September 2020, with sub-second block times and transaction fees of a fraction of a cent. It hosts one of the largest DeFi ecosystems in crypto — tens of billions of dollars in total value locked across protocols like PancakeSwap (DEX), Venus (lending), and 1,500+ live dApps spanning trading, gaming, and payments.
+
+The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+BSC is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Find Existing Subgraphs on BNB Smart Chain
+
+Before you build, check whether the data you need is already live. Many of the most-used protocols on BSC publish Subgraphs on The Graph that you can query today:
+
+
+ }
+ href="https://thegraph.com/explorer/subgraphs/EAq1nJKgjnuKH6Gj4RFjCW7LcL7E2uipbncdwV7TTWkX"
+ />
+ }
+ href="https://thegraph.com/explorer/subgraphs/7XgdLW3bts4HktCYsu9dy8bEnuiNeZuftcuK3Aj4JXYV"
+ />
+ }
+ href="https://thegraph.com/explorer/subgraphs/ChmxqA9bX71cB2cQTRRULbWUBKoMRk7oh3JnpZShDQ2V"
+ />
+ }
+ href="https://thegraph.com/explorer/subgraphs/7Jk85XgkV1MQ7u56hD8rr65rfASbayJXopugWkUoBMnZ"
+ />
+ }
+ href="https://thegraph.com/explorer/subgraphs/7h65Zf3pXXPmf8g8yZjjj2bqYiypVxems5d8riLK1DyR"
+ />
+ }
+ href="https://thegraph.com/explorer/subgraphs/2TVoLeQK4uSASrpoHkQga4wkdpDxoUAerajauzhuSNFq"
+ />
+
+
+Browse [Graph Explorer](https://thegraph.com/explorer/) to search all published Subgraphs on BSC by protocol, signal, and query volume before deciding to build your own.
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/btc.mdx b/website/src/supportedNetworks/customContent/btc.mdx
new file mode 100644
index 000000000000..1beed5e3d7f9
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/btc.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Bitcoin
+
+Bitcoin is the original and largest proof-of-work blockchain, securing the BTC asset and a growing ecosystem of layers and protocols built on top of it. The Graph can stream that onchain activity — blocks and transactions, inputs and outputs, and address activity — as real-time data with Substreams.
+
+Bitcoin is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Indexing Bitcoin with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Bitcoin's blocks, transactions, and their inputs and outputs. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Bitcoin; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+2. `substreams init` does not have a template for Bitcoin yet, so set up the project by hand: write a [`substreams.yaml` manifest](https://docs.substreams.dev/reference-material/manifest-and-components/manifests) with `network: btc` and a Rust map module that takes `sf.bitcoin.type.v1.Block` as its input (the protobuf definitions are published on [Buf](https://buf.build/streamingfast/firehose-bitcoin)).
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/celo-sepolia.mdx b/website/src/supportedNetworks/customContent/celo-sepolia.mdx
new file mode 100644
index 000000000000..ebc2c46bd6fe
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/celo-sepolia.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Celo Sepolia Testnet
+
+Celo Sepolia Testnet is the public test network for Celo, an Ethereum Layer 2 focused on mobile-first payments and stablecoins, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Celo Sepolia Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Celo Sepolia Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/celo.mdx b/website/src/supportedNetworks/customContent/celo.mdx
new file mode 100644
index 000000000000..9a6544051ce4
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/celo.mdx
@@ -0,0 +1,22 @@
+import SubstreamsBase from './_substreams-base.mdx'
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Celo
+
+Celo is an Ethereum Layer 2 (formerly a standalone Layer 1) focused on mobile-first payments, stablecoins, and real-world assets, with low fees and CELO as its native token. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Celo is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/chapel.mdx b/website/src/supportedNetworks/customContent/chapel.mdx
new file mode 100644
index 000000000000..1f88cd278b58
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/chapel.mdx
@@ -0,0 +1,22 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on BNB Smart Chain Chapel Testnet
+
+BNB Smart Chain Chapel Testnet is the public test network for BNB Smart Chain, the EVM-compatible Layer 1, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+BNB Smart Chain Chapel Testnet is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/chiliz-testnet.mdx b/website/src/supportedNetworks/customContent/chiliz-testnet.mdx
new file mode 100644
index 000000000000..3ec4be4326f2
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/chiliz-testnet.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Chiliz Spicy Testnet
+
+Chiliz Spicy Testnet is the public test network for Chiliz, the sports and entertainment EVM Layer 1, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Chiliz Spicy Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Chiliz Spicy Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/chiliz.mdx b/website/src/supportedNetworks/customContent/chiliz.mdx
new file mode 100644
index 000000000000..a56ec506d6ad
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/chiliz.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Chiliz
+
+Chiliz is an EVM-compatible Layer 1 built for sports and entertainment, powering fan tokens and fan-engagement apps, with CHZ as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Chiliz is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Chiliz.
+
+
diff --git a/website/src/supportedNetworks/customContent/eos.mdx b/website/src/supportedNetworks/customContent/eos.mdx
new file mode 100644
index 000000000000..a1aa661eb4d5
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/eos.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Vaulta
+
+Vaulta (formerly EOS) is a high-performance Antelope-based Layer 1, repositioned around Web3 banking and financial applications. The Graph can stream that onchain activity — transactions and actions, token transfers and balances, and smart-contract activity — as real-time data with Substreams.
+
+Vaulta is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Indexing Vaulta with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Vaulta's blocks, transactions, and actions. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Vaulta; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get an API key from [Pinax Network](https://app.pinax.network/).
+2. `substreams init` does not have a template for Antelope chains yet, so set up the project by hand: write a [`substreams.yaml` manifest](https://docs.substreams.dev/reference-material/manifest-and-components/manifests) with `network: eos` and a Rust map module that takes `sf.antelope.type.v1.Block` as its input (the protobuf definitions are published on [Buf](https://buf.build/pinax/firehose-antelope)).
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/etherlink-mainnet.mdx b/website/src/supportedNetworks/customContent/etherlink-mainnet.mdx
new file mode 100644
index 000000000000..fa940e7f3e08
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/etherlink-mainnet.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Etherlink
+
+Etherlink is an EVM-compatible Layer 2 built on Tezos Smart Rollups, offering low fees and fast confirmations with XTZ for gas. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Etherlink is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Etherlink.
+
+
diff --git a/website/src/supportedNetworks/customContent/etherlink-shadownet.mdx b/website/src/supportedNetworks/customContent/etherlink-shadownet.mdx
new file mode 100644
index 000000000000..25c138820cde
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/etherlink-shadownet.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Etherlink Shadownet Testnet
+
+Etherlink Shadownet is a public test network for Etherlink, the EVM Layer 2 built on Tezos Smart Rollups, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Etherlink Shadownet Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Etherlink Shadownet Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/fraxtal.mdx b/website/src/supportedNetworks/customContent/fraxtal.mdx
new file mode 100644
index 000000000000..cc306b4052e0
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/fraxtal.mdx
@@ -0,0 +1,16 @@
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Fraxtal
+
+Fraxtal is an Ethereum Layer 2 built on the OP Stack by Frax Finance, designed around the Frax stablecoin and staking ecosystem. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Fraxtal is supported by The Graph with Subgraphs — open APIs you publish to The Graph Network, where Indexers sync and serve the data while you manage your service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+
+
diff --git a/website/src/supportedNetworks/customContent/fuji.mdx b/website/src/supportedNetworks/customContent/fuji.mdx
new file mode 100644
index 000000000000..746ef53c688b
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/fuji.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Avalanche Fuji Testnet
+
+Avalanche Fuji Testnet is the primary public test network for the Avalanche C-Chain, the EVM contract chain of the Avalanche network, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Avalanche Fuji Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Avalanche Fuji Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/fuse-testnet.mdx b/website/src/supportedNetworks/customContent/fuse-testnet.mdx
new file mode 100644
index 000000000000..82c4570e3864
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/fuse-testnet.mdx
@@ -0,0 +1,16 @@
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Fuse Testnet
+
+Fuse Testnet is the public test network for Fuse, an EVM-compatible chain for payments and business use cases, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Fuse Testnet is supported by The Graph with Subgraphs — open APIs you publish to The Graph Network, where Indexers sync and serve the data while you manage your service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+
+
diff --git a/website/src/supportedNetworks/customContent/fuse.mdx b/website/src/supportedNetworks/customContent/fuse.mdx
new file mode 100644
index 000000000000..9390ddabb378
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/fuse.mdx
@@ -0,0 +1,16 @@
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Fuse
+
+Fuse is an EVM-compatible chain focused on payments and real-world business use cases, with fast, low-cost transactions and FUSE as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Fuse is supported by The Graph with Subgraphs — open APIs you publish to The Graph Network, where Indexers sync and serve the data while you manage your service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+
+
diff --git a/website/src/supportedNetworks/customContent/gnosis-chiado.mdx b/website/src/supportedNetworks/customContent/gnosis-chiado.mdx
new file mode 100644
index 000000000000..d9223776e9f2
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/gnosis-chiado.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Gnosis Chiado Testnet
+
+Gnosis Chiado Testnet is the public test network for Gnosis Chain, the EVM-compatible Layer 1 (formerly xDai), where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Gnosis Chiado Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Gnosis Chiado Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/gnosis-cl.mdx b/website/src/supportedNetworks/customContent/gnosis-cl.mdx
new file mode 100644
index 000000000000..89308847e52f
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/gnosis-cl.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Gnosis Beacon Chain
+
+Gnosis Chain is an Ethereum-compatible network secured by its own proof-of-stake validator set, and the Gnosis Beacon Chain is its consensus layer. The Graph can stream that consensus-layer activity — blocks and epochs, validator activity, attestations, deposits, and slashings — as real-time data with Substreams.
+
+Gnosis Beacon Chain is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Indexing Gnosis Beacon Chain with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Gnosis Beacon Chain's consensus-layer blocks — validators, attestations, deposits, and slashings. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Gnosis Beacon Chain; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get an API key from [Pinax Network](https://app.pinax.network/).
+2. `substreams init` does not have a template for the Beacon Chain yet, so set up the project by hand: write a [`substreams.yaml` manifest](https://docs.substreams.dev/reference-material/manifest-and-components/manifests) with `network: gnosis-cl` and a Rust map module that takes `sf.beacon.type.v1.Block` as its input (the protobuf definitions are published on [Buf](https://buf.build/pinax/firehose-beacon)).
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/gnosis.mdx b/website/src/supportedNetworks/customContent/gnosis.mdx
new file mode 100644
index 000000000000..c14ea8a96032
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/gnosis.mdx
@@ -0,0 +1,18 @@
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Gnosis
+
+Gnosis Chain is an EVM-compatible Layer 1 (formerly xDai) secured by the GNO token and a large community validator set, focused on stability, payments, and public-goods infrastructure, with xDAI — a stable native gas token — for fees. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Gnosis is supported by The Graph with Subgraphs — open APIs you publish to The Graph Network, where Indexers sync and serve the data while you manage your service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+
+> [!NOTE] Subgraphs previously deployed or published for Gnosis Chain may have used the `xdai` network identifier. All Subgraphs indexing Gnosis Chain can now be deployed or published with the `gnosis` network identifier.
+
+
diff --git a/website/src/supportedNetworks/customContent/hemi-sepolia.mdx b/website/src/supportedNetworks/customContent/hemi-sepolia.mdx
new file mode 100644
index 000000000000..755ec60d605f
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/hemi-sepolia.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Hemi Sepolia Testnet
+
+Hemi Sepolia Testnet is the public test network for Hemi, the modular Bitcoin-and-Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Hemi Sepolia Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Hemi Sepolia Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/hemi.mdx b/website/src/supportedNetworks/customContent/hemi.mdx
new file mode 100644
index 000000000000..eb1093697081
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/hemi.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Hemi
+
+Hemi is a modular Layer 2 that combines Bitcoin and Ethereum into a single supernetwork, exposing Bitcoin state to EVM smart contracts through its hVM, with ETH for gas. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Hemi is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Hemi.
+
+
diff --git a/website/src/supportedNetworks/customContent/hoodi-cl.mdx b/website/src/supportedNetworks/customContent/hoodi-cl.mdx
new file mode 100644
index 000000000000..20f64c5730fd
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/hoodi-cl.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Hoodi Beacon Chain
+
+Hoodi is an Ethereum proof-of-stake testnet, and its Beacon Chain is the consensus layer that coordinates validators on the test network. The Graph can stream that consensus-layer activity — blocks and epochs, validator activity, attestations, deposits, and slashings — as real-time data with Substreams.
+
+Hoodi Beacon Chain is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Indexing Hoodi Beacon Chain with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Hoodi Beacon Chain's consensus-layer blocks — validators, attestations, deposits, and slashings. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Hoodi Beacon Chain; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get an API key from [Pinax Network](https://app.pinax.network/).
+2. `substreams init` does not have a template for the Beacon Chain yet, so set up the project by hand: write a [`substreams.yaml` manifest](https://docs.substreams.dev/reference-material/manifest-and-components/manifests) with `network: hoodi-cl` and a Rust map module that takes `sf.beacon.type.v1.Block` as its input (the protobuf definitions are published on [Buf](https://buf.build/pinax/firehose-beacon)).
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/hoodi.mdx b/website/src/supportedNetworks/customContent/hoodi.mdx
new file mode 100644
index 000000000000..97d30d3857ce
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/hoodi.mdx
@@ -0,0 +1,21 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Ethereum Hoodi Testnet
+
+Ethereum Hoodi Testnet is a public Ethereum test network used by validators and application developers to test protocol upgrades and contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Ethereum Hoodi Testnet is supported by The Graph in two ways:
+
+- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/hyper-evm.mdx b/website/src/supportedNetworks/customContent/hyper-evm.mdx
new file mode 100644
index 000000000000..28e1f6c8a815
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/hyper-evm.mdx
@@ -0,0 +1,9 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+
+### Indexing Data on HyperEVM
+
+HyperEVM is the general-purpose EVM layer of Hyperliquid, the high-performance L1 best known for its onchain perpetuals exchange. It brings EVM smart contracts to the Hyperliquid ecosystem, with native token HYPE and tight integration with HyperCore, Hyperliquid's order-book and perps layer. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+HyperEVM is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
diff --git a/website/src/supportedNetworks/customContent/index.ts b/website/src/supportedNetworks/customContent/index.ts
index bc70acafa89d..5d360ea01dc0 100644
--- a/website/src/supportedNetworks/customContent/index.ts
+++ b/website/src/supportedNetworks/customContent/index.ts
@@ -1,6 +1,104 @@
import type { ComponentType } from 'react'
import Anubis from './anubis.mdx'
+import ArbitrumOne from './arbitrum-one.mdx'
+import ArbitrumSepolia from './arbitrum-sepolia.mdx'
+import Arc from './arc.mdx'
+import ArcTestnet from './arc-testnet.mdx'
+import Avalanche from './avalanche.mdx'
+import Base from './base.mdx'
+import BaseSepolia from './base-sepolia.mdx'
+import Blast from './blast-mainnet.mdx'
+import Boba from './boba.mdx'
+import BobaTestnet from './boba-testnet.mdx'
+import Bsc from './bsc.mdx'
+import Btc from './btc.mdx'
+import Celo from './celo.mdx'
+import CeloSepolia from './celo-sepolia.mdx'
+import Chapel from './chapel.mdx'
+import Chiliz from './chiliz.mdx'
+import ChilizTestnet from './chiliz-testnet.mdx'
+import Vaulta from './eos.mdx'
+import Etherlink from './etherlink-mainnet.mdx'
+import EtherlinkShadownet from './etherlink-shadownet.mdx'
+import Fraxtal from './fraxtal.mdx'
+import Fuji from './fuji.mdx'
+import Fuse from './fuse.mdx'
+import FuseTestnet from './fuse-testnet.mdx'
+import Gnosis from './gnosis.mdx'
+import GnosisChiado from './gnosis-chiado.mdx'
+import GnosisBeacon from './gnosis-cl.mdx'
+import Hemi from './hemi.mdx'
+import HemiSepolia from './hemi-sepolia.mdx'
+import Hoodi from './hoodi.mdx'
+import HoodiBeacon from './hoodi-cl.mdx'
+import HyperEvm from './hyper-evm.mdx'
+import InjectiveEvm from './injective-evm.mdx'
+import InjectiveEvmTestnet from './injective-evm-testnet.mdx'
+import Injective from './injective-mainnet.mdx'
+import InjectiveTestnet from './injective-testnet.mdx'
+import Ink from './ink.mdx'
+import Joc from './joc.mdx'
+import JocTestnet from './joc-testnet.mdx'
+import Jungle4 from './jungle4.mdx'
+import Kaia from './kaia.mdx'
+import KaiaTestnet from './kaia-testnet.mdx'
+import Linea from './linea.mdx'
+import LineaSepolia from './linea-sepolia.mdx'
+import Litecoin from './litecoin.mdx'
+import Ethereum from './mainnet.mdx'
+import EthereumBeacon from './mainnet-cl.mdx'
+import Polygon from './matic.mdx'
+import MegaEth from './megaeth.mdx'
+import Monad from './monad.mdx'
+import Near from './near-mainnet.mdx'
+import NearTestnet from './near-testnet.mdx'
+import NeoX from './neox.mdx'
+import NeoXTestnet from './neox-testnet.mdx'
+import Optimism from './optimism.mdx'
+import OptimismSepolia from './optimism-sepolia.mdx'
+import Peaq from './peaq.mdx'
+import PolygonAmoy from './polygon-amoy.mdx'
+import Robinhood from './robinhood.mdx'
+import RobinhoodSepolia from './robinhood-sepolia.mdx'
+import Rootstock from './rootstock.mdx'
+import RootstockTestnet from './rootstock-testnet.mdx'
+import Scroll from './scroll.mdx'
+import ScrollSepolia from './scroll-sepolia.mdx'
+import SeiAtlantic from './sei-atlantic.mdx'
+import SeiMainnet from './sei-mainnet.mdx'
+import Sepolia from './sepolia.mdx'
+import SepoliaBeacon from './sepolia-cl.mdx'
+import SolanaAccounts from './solana-accounts.mdx'
+import SolanaDevnet from './solana-devnet.mdx'
+import Solana from './solana-mainnet-beta.mdx'
+import Soneium from './soneium.mdx'
+import SoneiumTestnet from './soneium-testnet.mdx'
+import Sonic from './sonic.mdx'
+import SonicTestnet from './sonic-testnet.mdx'
+import Stable from './stable.mdx'
+import Starknet from './starknet-mainnet.mdx'
+import StarknetTestnet from './starknet-testnet.mdx'
+import Stellar from './stellar.mdx'
+import StellarTestnet from './stellar-testnet.mdx'
+import Tempo from './tempo.mdx'
+import TempoModerato from './tempo-moderato.mdx'
+import Tron from './tron.mdx'
+import TronEvm from './tron-evm.mdx'
+import Unichain from './unichain.mdx'
+import UnichainTestnet from './unichain-testnet.mdx'
+import Viction from './viction.mdx'
+import Wax from './wax.mdx'
+import WaxTestnet from './wax-testnet.mdx'
+import WorldChain from './worldchain.mdx'
+import XLayer from './xlayer-mainnet.mdx'
+import XLayerSepolia from './xlayer-sepolia.mdx'
+import Zetachain from './zetachain.mdx'
+import Zilliqa from './zilliqa.mdx'
+import ZilliqaTestnet from './zilliqa-testnet.mdx'
+import ZksyncEra from './zksync-era.mdx'
+import ZksyncEraSepolia from './zksync-era-sepolia.mdx'
+import Zora from './zora.mdx'
/**
* Per-network custom content for Supported Networks landing pages.
@@ -17,4 +115,106 @@ import Anubis from './anubis.mdx'
*/
export const customNetworkContent: Record = {
anubis: Anubis,
+ bsc: Bsc,
+ matic: Polygon,
+ ink: Ink,
+ 'hyper-evm': HyperEvm,
+ robinhood: Robinhood,
+ monad: Monad,
+ worldchain: WorldChain,
+ zora: Zora,
+ btc: Btc,
+ 'blast-mainnet': Blast,
+ 'mainnet-cl': EthereumBeacon,
+ 'hoodi-cl': HoodiBeacon,
+ 'sepolia-cl': SepoliaBeacon,
+ 'gnosis-cl': GnosisBeacon,
+ 'injective-mainnet': Injective,
+ litecoin: Litecoin,
+ megaeth: MegaEth,
+ 'solana-devnet': SolanaDevnet,
+ 'solana-mainnet-beta': Solana,
+ 'solana-accounts': SolanaAccounts,
+ 'starknet-mainnet': Starknet,
+ stellar: Stellar,
+ 'tron-evm': TronEvm,
+ tron: Tron,
+ eos: Vaulta,
+ wax: Wax,
+ // Substreams-only custom content (subgraph sections to be added later)
+ 'arbitrum-one': ArbitrumOne,
+ arc: Arc,
+ base: Base,
+ 'injective-evm': InjectiveEvm,
+ linea: Linea,
+ mainnet: Ethereum,
+ optimism: Optimism,
+ soneium: Soneium,
+ unichain: Unichain,
+ 'arbitrum-sepolia': ArbitrumSepolia,
+ 'base-sepolia': BaseSepolia,
+ chapel: Chapel,
+ hoodi: Hoodi,
+ 'injective-evm-testnet': InjectiveEvmTestnet,
+ 'linea-sepolia': LineaSepolia,
+ 'optimism-sepolia': OptimismSepolia,
+ 'polygon-amoy': PolygonAmoy,
+ 'robinhood-sepolia': RobinhoodSepolia,
+ sepolia: Sepolia,
+ 'soneium-testnet': SoneiumTestnet,
+ 'unichain-testnet': UnichainTestnet,
+ avalanche: Avalanche,
+ celo: Celo,
+ tempo: Tempo,
+ 'xlayer-mainnet': XLayer,
+ 'near-mainnet': Near,
+ 'near-testnet': NearTestnet,
+ 'starknet-testnet': StarknetTestnet,
+ 'stellar-testnet': StellarTestnet,
+ 'injective-testnet': InjectiveTestnet,
+ jungle4: Jungle4,
+ 'wax-testnet': WaxTestnet,
+ // Community Subgraph custom content
+ boba: Boba,
+ 'boba-testnet': BobaTestnet,
+ fuse: Fuse,
+ 'fuse-testnet': FuseTestnet,
+ fraxtal: Fraxtal,
+ rootstock: Rootstock,
+ 'rootstock-testnet': RootstockTestnet,
+ // Community Subgraph — additional EVM chains
+ gnosis: Gnosis,
+ scroll: Scroll,
+ sonic: Sonic,
+ 'zksync-era': ZksyncEra,
+ // Studio Subgraph (publishing enabled, no guaranteed indexing yet)
+ 'arc-testnet': ArcTestnet,
+ fuji: Fuji,
+ 'celo-sepolia': CeloSepolia,
+ chiliz: Chiliz,
+ 'chiliz-testnet': ChilizTestnet,
+ 'etherlink-mainnet': Etherlink,
+ 'etherlink-shadownet': EtherlinkShadownet,
+ 'gnosis-chiado': GnosisChiado,
+ hemi: Hemi,
+ 'hemi-sepolia': HemiSepolia,
+ joc: Joc,
+ 'joc-testnet': JocTestnet,
+ peaq: Peaq,
+ 'scroll-sepolia': ScrollSepolia,
+ 'sei-atlantic': SeiAtlantic,
+ 'sei-mainnet': SeiMainnet,
+ 'sonic-testnet': SonicTestnet,
+ stable: Stable,
+ 'tempo-moderato': TempoModerato,
+ 'xlayer-sepolia': XLayerSepolia,
+ zilliqa: Zilliqa,
+ 'zilliqa-testnet': ZilliqaTestnet,
+ 'zksync-era-sepolia': ZksyncEraSepolia,
+ kaia: Kaia,
+ 'kaia-testnet': KaiaTestnet,
+ neox: NeoX,
+ 'neox-testnet': NeoXTestnet,
+ viction: Viction,
+ zetachain: Zetachain,
}
diff --git a/website/src/supportedNetworks/customContent/injective-evm-testnet.mdx b/website/src/supportedNetworks/customContent/injective-evm-testnet.mdx
new file mode 100644
index 000000000000..b7855998b520
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/injective-evm-testnet.mdx
@@ -0,0 +1,9 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+
+### Indexing Data on Injective EVM Testnet
+
+Injective EVM Testnet is the public test network for Injective's EVM environment, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+Injective EVM Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+
diff --git a/website/src/supportedNetworks/customContent/injective-evm.mdx b/website/src/supportedNetworks/customContent/injective-evm.mdx
new file mode 100644
index 000000000000..3912e72a5927
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/injective-evm.mdx
@@ -0,0 +1,22 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Injective EVM
+
+Injective EVM is the EVM environment of Injective, a Layer 1 blockchain optimized for finance and DeFi, bringing Ethereum smart contracts to the Injective ecosystem with INJ as its native token. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Injective EVM is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/injective-mainnet.mdx b/website/src/supportedNetworks/customContent/injective-mainnet.mdx
new file mode 100644
index 000000000000..6d1a59284d86
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/injective-mainnet.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Injective
+
+Injective is a Cosmos-based Layer 1 optimized for finance, with a focus on onchain trading, derivatives, and DeFi. The Graph can stream that onchain activity — transactions and messages, DEX and derivatives activity, token transfers and balances, and smart-contract events — as real-time data with Substreams.
+
+Injective is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+### Indexing Injective with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Injective's Cosmos blocks, transactions, and events. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Injective; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+2. Scaffold a project with `substreams init` and follow the prompts for Injective.
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/injective-testnet.mdx b/website/src/supportedNetworks/customContent/injective-testnet.mdx
new file mode 100644
index 000000000000..669e00979da2
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/injective-testnet.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Injective Testnet
+
+Injective Testnet is the public test network for Injective, a Cosmos-based Layer 1 optimized for finance and DeFi, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — transactions and messages, DEX and derivatives activity, token transfers and balances, and smart-contract events — as real-time data with Substreams.
+
+Injective Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+### Indexing Injective Testnet with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Injective Testnet's Cosmos blocks, transactions, and events. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Injective Testnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+2. Scaffold a project with `substreams init` and follow the prompts for Injective.
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/ink.mdx b/website/src/supportedNetworks/customContent/ink.mdx
new file mode 100644
index 000000000000..57f39da7a3c7
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/ink.mdx
@@ -0,0 +1,9 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+
+### Indexing Data on Ink
+
+Ink is an Ethereum Layer 2 built on the OP Stack and part of the Optimism Superchain, incubated by Kraken with a focus on DeFi — bringing low fees and fast, Ethereum-secured settlement to onchain finance. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+Ink is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
diff --git a/website/src/supportedNetworks/customContent/joc-testnet.mdx b/website/src/supportedNetworks/customContent/joc-testnet.mdx
new file mode 100644
index 000000000000..e29e6062ea8c
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/joc-testnet.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Japan Open Chain Testnet
+
+Japan Open Chain Testnet is the public test network for Japan Open Chain, the enterprise EVM Layer 1, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Japan Open Chain Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Japan Open Chain Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/joc.mdx b/website/src/supportedNetworks/customContent/joc.mdx
new file mode 100644
index 000000000000..16a9496ce921
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/joc.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Japan Open Chain
+
+Japan Open Chain is an EVM-compatible Layer 1 operated by trusted Japanese enterprises and designed for compliant, business-grade applications, with JOC as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Japan Open Chain is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Japan Open Chain.
+
+
diff --git a/website/src/supportedNetworks/customContent/jungle4.mdx b/website/src/supportedNetworks/customContent/jungle4.mdx
new file mode 100644
index 000000000000..aeef3cc78693
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/jungle4.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Vaulta Jungle4 Testnet
+
+Vaulta Jungle4 Testnet is a public test network for Vaulta (formerly EOS), an Antelope-based Layer 1, where teams deploy and validate contracts and applications before mainnet. The Graph can stream that onchain activity — transactions and actions, token transfers and balances, and smart-contract activity — as real-time data with Substreams.
+
+Vaulta Jungle4 Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Indexing Vaulta Jungle4 Testnet with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Vaulta Jungle4 Testnet's blocks, transactions, and actions. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Vaulta Jungle4 Testnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get an API key from [Pinax Network](https://app.pinax.network/).
+2. `substreams init` does not have a template for Antelope chains yet, so set up the project by hand: write a [`substreams.yaml` manifest](https://docs.substreams.dev/reference-material/manifest-and-components/manifests) with `network: jungle4` and a Rust map module that takes `sf.antelope.type.v1.Block` as its input (the protobuf definitions are published on [Buf](https://buf.build/pinax/firehose-antelope)).
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/kaia-testnet.mdx b/website/src/supportedNetworks/customContent/kaia-testnet.mdx
new file mode 100644
index 000000000000..82233059bf9d
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/kaia-testnet.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Kaia Kairos Testnet
+
+Kaia Kairos Testnet is the public test network for Kaia, the EVM-compatible Layer 1 formed by the merger of Klaytn and Finschia, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Kaia Kairos Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Kaia Kairos Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/kaia.mdx b/website/src/supportedNetworks/customContent/kaia.mdx
new file mode 100644
index 000000000000..cdca3f8474ab
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/kaia.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Kaia
+
+Kaia is an EVM-compatible Layer 1 formed by the merger of Klaytn and Finschia, built for large-scale Web3 and mini-dApp adoption across Asia, with KAIA as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Kaia is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Kaia.
+
+
diff --git a/website/src/supportedNetworks/customContent/linea-sepolia.mdx b/website/src/supportedNetworks/customContent/linea-sepolia.mdx
new file mode 100644
index 000000000000..cebda3d60888
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/linea-sepolia.mdx
@@ -0,0 +1,21 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Linea Sepolia Testnet
+
+Linea Sepolia Testnet is the public test network for Linea, the Consensys zkEVM Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Linea Sepolia Testnet is supported by The Graph in two ways:
+
+- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/linea.mdx b/website/src/supportedNetworks/customContent/linea.mdx
new file mode 100644
index 000000000000..02947d756d13
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/linea.mdx
@@ -0,0 +1,22 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Linea
+
+Linea is an Ethereum Layer 2 zkEVM rollup developed by Consensys, combining full EVM equivalence with the security of zero-knowledge proofs and a growing DeFi ecosystem. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Linea is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/litecoin.mdx b/website/src/supportedNetworks/customContent/litecoin.mdx
new file mode 100644
index 000000000000..2ee04f1dd734
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/litecoin.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Litecoin
+
+Litecoin is a long-running proof-of-work blockchain and one of the earliest peer-to-peer digital currencies, securing the LTC asset. The Graph can stream that onchain activity — blocks and transactions, inputs and outputs, and address activity — as real-time data with Substreams.
+
+Litecoin is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Indexing Litecoin with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Litecoin's blocks, transactions, and their inputs and outputs. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Litecoin; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get an API key from [Pinax Network](https://app.pinax.network/).
+2. `substreams init` does not have a template for Litecoin yet, so set up the project by hand: write a [`substreams.yaml` manifest](https://docs.substreams.dev/reference-material/manifest-and-components/manifests) with `network: litecoin` and a Rust map module that takes `sf.bitcoin.type.v1.Block` as its input (the protobuf definitions are published on [Buf](https://buf.build/streamingfast/firehose-bitcoin)).
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/mainnet-cl.mdx b/website/src/supportedNetworks/customContent/mainnet-cl.mdx
new file mode 100644
index 000000000000..de0330debb4e
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/mainnet-cl.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Ethereum Beacon Chain
+
+The Ethereum Beacon Chain is Ethereum's consensus layer, coordinating the proof-of-stake validators that secure the network. The Graph can stream that consensus-layer activity — blocks and epochs, validator activity, attestations, deposits, and slashings — as real-time data with Substreams.
+
+Ethereum Beacon Chain is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Indexing Ethereum Beacon Chain with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Ethereum Beacon Chain's consensus-layer blocks — validators, attestations, deposits, and slashings. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Ethereum Beacon Chain; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get an API key from [Pinax Network](https://app.pinax.network/).
+2. `substreams init` does not have a template for the Beacon Chain yet, so set up the project by hand: write a [`substreams.yaml` manifest](https://docs.substreams.dev/reference-material/manifest-and-components/manifests) with `network: mainnet-cl` and a Rust map module that takes `sf.beacon.type.v1.Block` as its input (the protobuf definitions are published on [Buf](https://buf.build/pinax/firehose-beacon)).
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/mainnet.mdx b/website/src/supportedNetworks/customContent/mainnet.mdx
new file mode 100644
index 000000000000..e3571d1ffcbb
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/mainnet.mdx
@@ -0,0 +1,22 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Ethereum
+
+Ethereum is the original programmable, EVM Layer 1 and the largest smart-contract network by developer activity, total value locked, and application diversity, secured by proof-of-stake with ETH as its native token. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Ethereum is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/), [Pinax Network](https://app.pinax.network/docs?from=nav), and [Data Nexus](https://data.nexus/).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/matic.mdx b/website/src/supportedNetworks/customContent/matic.mdx
new file mode 100644
index 000000000000..2d80f2f807a0
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/matic.mdx
@@ -0,0 +1,71 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import { Card } from '@/components'
+import SubgraphCommunity from './_subgraph-community.mdx'
+import { Subgraph } from '@edgeandnode/gds/icons'
+
+### Indexing Data on Polygon
+
+Polygon PoS is an EVM-compatible, Ethereum-scaling network built for high throughput and near-zero fees. Following the 2025 Rio upgrade it targets thousands of transactions per second with roughly two-second finality and fees of a fraction of a cent, and it settles more stablecoin payment volume than almost any other chain — powering apps like Polymarket alongside a deep DeFi ecosystem (Aave, QuickSwap, Uniswap), gaming, and real-world-asset projects. Its native token is POL.
+
+The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; stablecoin and token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Polygon is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Find Existing Subgraphs on Polygon
+
+Before you build, check whether the data you need is already live. Many of the most-used protocols on Polygon publish Subgraphs on The Graph that you can query today:
+
+
+ }
+ href="https://thegraph.com/explorer/subgraphs/4A3fq2YYzT5poS9TW4ky9YjPnsBdh1pHGCRKD1UQBvhJ"
+ />
+ }
+ href="https://thegraph.com/explorer/subgraphs/Co2URyXjnxaw8WqxKyVHdirq9Ahhm5vcTs4dMedAq211"
+ />
+ }
+ href="https://thegraph.com/explorer/subgraphs/FqsRcH1XqSjqVx9GRTvEJe959aCbKrcyGgDWBrUkG24g"
+ />
+ }
+ href="https://thegraph.com/explorer/subgraphs/78nZMyM9yD77KG6pFaYap31kJvj8eUWLEntbiVzh8ZKN"
+ />
+ }
+ href="https://thegraph.com/explorer/subgraphs/81Dm16JjuFSrqz813HysXoUPvzTwE7fsfPk2RTf66nyC"
+ />
+ }
+ href="https://thegraph.com/explorer/subgraphs/4ngshgumX4LgFPSN4XHnbo2c4wbEdMDBwuLLSjvpERCh"
+ />
+
+
+Browse [Graph Explorer](https://thegraph.com/explorer/) to search all published Subgraphs on Polygon by protocol, signal, and query volume before deciding to build your own.
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/megaeth.mdx b/website/src/supportedNetworks/customContent/megaeth.mdx
new file mode 100644
index 000000000000..0f071e981fe0
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/megaeth.mdx
@@ -0,0 +1,9 @@
+import SubstreamsBase from './_substreams-base.mdx'
+
+### Indexing Data on MegaETH
+
+MegaETH is a high-performance, EVM-compatible Ethereum Layer 2 built for real-time applications with very high throughput and low latency. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+MegaETH is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
diff --git a/website/src/supportedNetworks/customContent/monad.mdx b/website/src/supportedNetworks/customContent/monad.mdx
new file mode 100644
index 000000000000..4ab01cef2227
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/monad.mdx
@@ -0,0 +1,9 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+
+### Indexing Data on Monad
+
+Monad is a high-performance, EVM-compatible Layer 1 that uses parallel execution to reach high throughput while staying fully compatible with Ethereum tooling. Its native token is MON. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+Monad is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+
diff --git a/website/src/supportedNetworks/customContent/near-mainnet.mdx b/website/src/supportedNetworks/customContent/near-mainnet.mdx
new file mode 100644
index 000000000000..42588047148e
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/near-mainnet.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on NEAR
+
+NEAR is a high-performance, sharded Layer 1 blockchain with a human-readable account model and Nightshade consensus, designed for scalable consumer and AI applications, with NEAR as its native token. The Graph can stream that onchain activity — blocks, transactions, and receipts; token transfers and balances; and smart-contract activity — as real-time data with Substreams.
+
+NEAR is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+### Indexing NEAR with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams NEAR's blocks, transactions, and receipts. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on NEAR; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+2. Scaffold a project with `substreams init` and follow the prompts for NEAR.
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/near-testnet.mdx b/website/src/supportedNetworks/customContent/near-testnet.mdx
new file mode 100644
index 000000000000..62e72870d3c2
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/near-testnet.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on NEAR Testnet
+
+NEAR Testnet is the public test network for NEAR, a sharded Layer 1 with a human-readable account model, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — blocks, transactions, and receipts; token transfers and balances; and smart-contract activity — as real-time data with Substreams.
+
+NEAR Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+### Indexing NEAR Testnet with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams NEAR Testnet's blocks, transactions, and receipts. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on NEAR Testnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+2. Scaffold a project with `substreams init` and follow the prompts for NEAR.
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/neox-testnet.mdx b/website/src/supportedNetworks/customContent/neox-testnet.mdx
new file mode 100644
index 000000000000..8cd6ba6c2111
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/neox-testnet.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Neo X Testnet
+
+Neo X Testnet is the public test network for Neo X, the EVM-compatible sidechain of the Neo blockchain, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Neo X Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Neo X Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/neox.mdx b/website/src/supportedNetworks/customContent/neox.mdx
new file mode 100644
index 000000000000..7a15ca627b14
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/neox.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Neo X
+
+Neo X is an EVM-compatible sidechain of the Neo blockchain secured by a dBFT consensus, extending Neo's Smart Economy to EVM developers, with GAS as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Neo X is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Neo X.
+
+
diff --git a/website/src/supportedNetworks/customContent/optimism-sepolia.mdx b/website/src/supportedNetworks/customContent/optimism-sepolia.mdx
new file mode 100644
index 000000000000..9580087005a4
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/optimism-sepolia.mdx
@@ -0,0 +1,22 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on OP Sepolia Testnet
+
+OP Sepolia Testnet is the public test network for Optimism (OP Mainnet), the OP Stack Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+OP Sepolia Testnet is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/optimism.mdx b/website/src/supportedNetworks/customContent/optimism.mdx
new file mode 100644
index 000000000000..c37fde0ef3ff
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/optimism.mdx
@@ -0,0 +1,22 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Optimism
+
+Optimism (OP Mainnet) is an Ethereum Layer 2 built on the OP Stack and the flagship chain of the Optimism Superchain, with a large DeFi and infrastructure ecosystem and OP as its governance token. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Optimism is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/), [Pinax Network](https://app.pinax.network/docs?from=nav), and [Data Nexus](https://data.nexus/).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/peaq.mdx b/website/src/supportedNetworks/customContent/peaq.mdx
new file mode 100644
index 000000000000..b14de73069b9
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/peaq.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on peaq
+
+peaq is an EVM-compatible Layer 1 built for DePIN — decentralized physical infrastructure networks and machine economies — with PEAQ as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+peaq is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for peaq.
+
+
diff --git a/website/src/supportedNetworks/customContent/polygon-amoy.mdx b/website/src/supportedNetworks/customContent/polygon-amoy.mdx
new file mode 100644
index 000000000000..67924ef5cc3e
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/polygon-amoy.mdx
@@ -0,0 +1,21 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Polygon Amoy Testnet
+
+Polygon Amoy Testnet is the public test network for Polygon PoS, the EVM-compatible Ethereum scaling network, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Polygon Amoy Testnet is supported by The Graph in two ways:
+
+- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/robinhood-sepolia.mdx b/website/src/supportedNetworks/customContent/robinhood-sepolia.mdx
new file mode 100644
index 000000000000..724225d2182a
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/robinhood-sepolia.mdx
@@ -0,0 +1,9 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+
+### Indexing Data on Robinhood Chain Testnet
+
+Robinhood Chain Testnet is the public test network for Robinhood Chain, an Arbitrum-based Ethereum Layer 2 for tokenized real-world assets, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+Robinhood Chain Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
diff --git a/website/src/supportedNetworks/customContent/robinhood.mdx b/website/src/supportedNetworks/customContent/robinhood.mdx
new file mode 100644
index 000000000000..ecd1dd832c6d
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/robinhood.mdx
@@ -0,0 +1,9 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+
+### Indexing Data on Robinhood Chain
+
+Robinhood Chain is an Ethereum Layer 2 built on Arbitrum technology, created by Robinhood to bring tokenized real-world assets — including tokenized stocks — onchain. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+Robinhood Chain is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/), [Pinax Network](https://app.pinax.network/docs?from=nav), and [Data Nexus](https://data.nexus/).
+
+
diff --git a/website/src/supportedNetworks/customContent/rootstock-testnet.mdx b/website/src/supportedNetworks/customContent/rootstock-testnet.mdx
new file mode 100644
index 000000000000..36a19ea0ec12
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/rootstock-testnet.mdx
@@ -0,0 +1,16 @@
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Rootstock Testnet
+
+Rootstock Testnet is the public test network for Rootstock, the Bitcoin-secured EVM sidechain, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Rootstock Testnet is supported by The Graph with Subgraphs — open APIs you publish to The Graph Network, where Indexers sync and serve the data while you manage your service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+
+
diff --git a/website/src/supportedNetworks/customContent/rootstock.mdx b/website/src/supportedNetworks/customContent/rootstock.mdx
new file mode 100644
index 000000000000..2755b0dcc2b4
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/rootstock.mdx
@@ -0,0 +1,16 @@
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Rootstock
+
+Rootstock (RSK) is a Bitcoin sidechain that brings EVM-compatible smart contracts to Bitcoin, secured by merge-mining with the Bitcoin network and using RBTC, a Bitcoin-pegged token, for gas. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Rootstock is supported by The Graph with Subgraphs — open APIs you publish to The Graph Network, where Indexers sync and serve the data while you manage your service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+
+
diff --git a/website/src/supportedNetworks/customContent/scroll-sepolia.mdx b/website/src/supportedNetworks/customContent/scroll-sepolia.mdx
new file mode 100644
index 000000000000..4eac5f64194d
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/scroll-sepolia.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Scroll Sepolia Testnet
+
+Scroll Sepolia Testnet is the public test network for Scroll, the Ethereum Layer 2 zkEVM rollup, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Scroll Sepolia Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Scroll Sepolia Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/scroll.mdx b/website/src/supportedNetworks/customContent/scroll.mdx
new file mode 100644
index 000000000000..f67ba4f28d4f
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/scroll.mdx
@@ -0,0 +1,16 @@
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Scroll
+
+Scroll is an Ethereum Layer 2 zkEVM rollup offering bytecode-level EVM equivalence backed by zero-knowledge proofs, focused on security and seamless developer compatibility. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Scroll is supported by The Graph with Subgraphs — open APIs you publish to The Graph Network, where Indexers sync and serve the data while you manage your service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+
+
diff --git a/website/src/supportedNetworks/customContent/sei-atlantic.mdx b/website/src/supportedNetworks/customContent/sei-atlantic.mdx
new file mode 100644
index 000000000000..7e255290e201
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/sei-atlantic.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Sei Atlantic Testnet
+
+Sei Atlantic Testnet is the public test network for Sei, a high-performance EVM Layer 1 with parallelized execution, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Sei Atlantic Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Sei Atlantic Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/sei-mainnet.mdx b/website/src/supportedNetworks/customContent/sei-mainnet.mdx
new file mode 100644
index 000000000000..3e93b4aafde8
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/sei-mainnet.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Sei
+
+Sei is a high-performance, EVM-compatible Layer 1 built for trading and DeFi, using parallelized execution for fast finality and high throughput, with SEI as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Sei is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Sei.
+
+
diff --git a/website/src/supportedNetworks/customContent/sepolia-cl.mdx b/website/src/supportedNetworks/customContent/sepolia-cl.mdx
new file mode 100644
index 000000000000..92e6be621d0e
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/sepolia-cl.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Sepolia Beacon Chain
+
+Sepolia is a widely used Ethereum testnet, and its Beacon Chain is the consensus layer that coordinates validators on the test network. The Graph can stream that consensus-layer activity — blocks and epochs, validator activity, attestations, deposits, and slashings — as real-time data with Substreams.
+
+Sepolia Beacon Chain is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Indexing Sepolia Beacon Chain with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Sepolia Beacon Chain's consensus-layer blocks — validators, attestations, deposits, and slashings. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Sepolia Beacon Chain; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get an API key from [Pinax Network](https://app.pinax.network/).
+2. `substreams init` does not have a template for the Beacon Chain yet, so set up the project by hand: write a [`substreams.yaml` manifest](https://docs.substreams.dev/reference-material/manifest-and-components/manifests) with `network: sepolia-cl` and a Rust map module that takes `sf.beacon.type.v1.Block` as its input (the protobuf definitions are published on [Buf](https://buf.build/pinax/firehose-beacon)).
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/sepolia.mdx b/website/src/supportedNetworks/customContent/sepolia.mdx
new file mode 100644
index 000000000000..d7fd8778d7ca
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/sepolia.mdx
@@ -0,0 +1,22 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Ethereum Sepolia Testnet
+
+Ethereum Sepolia Testnet is the primary Ethereum test network for application developers, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Ethereum Sepolia Testnet is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/solana-accounts.mdx b/website/src/supportedNetworks/customContent/solana-accounts.mdx
new file mode 100644
index 000000000000..b96192b4c07c
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/solana-accounts.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Solana Accounts
+
+Solana Accounts is a Substreams data source for Solana that streams account state changes — how program, token, and other accounts are created and updated over time — rather than transactions or instructions. The Graph can stream that onchain activity — account creations and updates, token account and balance changes, and program-owned account state — as real-time data with Substreams.
+
+Solana Accounts is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+### Indexing Solana Accounts with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Solana Accounts streams Solana's account block model, so modules have access to full account snapshots and updates as they change. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Solana Accounts; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+2. `substreams init`'s Solana templates stream Solana blocks, not account blocks, so set up the project by hand: write a [`substreams.yaml` manifest](https://docs.substreams.dev/reference-material/manifest-and-components/manifests) with `network: solana-accounts` and a Rust map module that takes `sf.solana.type.v1.AccountBlock` as its input (the protobuf definitions are published on [Buf](https://buf.build/streamingfast/firehose-solana)).
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/solana-devnet.mdx b/website/src/supportedNetworks/customContent/solana-devnet.mdx
new file mode 100644
index 000000000000..81e99690935c
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/solana-devnet.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Solana Devnet
+
+Solana Devnet is the development network for Solana, a high-throughput Layer 1 known for fast, low-cost transactions. The Graph can stream that onchain activity — program interactions, DEX swaps, token transfers and balances, and account updates — as real-time data with Substreams.
+
+Solana Devnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Indexing Solana Devnet with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Solana Devnet is available through Substreams' Solana block model, so modules have access to blocks, transactions, and instructions. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Solana Devnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+2. Scaffold a project with `substreams init` and choose the Solana path.
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/solana-mainnet-beta.mdx b/website/src/supportedNetworks/customContent/solana-mainnet-beta.mdx
new file mode 100644
index 000000000000..50bef70bc359
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/solana-mainnet-beta.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Solana
+
+Solana is a high-throughput Layer 1 known for fast, low-cost transactions and a large DeFi, NFT, and payments ecosystem. The Graph can stream that onchain activity — program interactions, DEX swaps, token transfers and balances, and account updates — as real-time data with Substreams.
+
+Solana is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/) and [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Indexing Solana with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Solana is available through Substreams' Solana block model, so modules have access to blocks, transactions, and instructions. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Solana; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+2. Scaffold a project with `substreams init` and choose the Solana path.
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/soneium-testnet.mdx b/website/src/supportedNetworks/customContent/soneium-testnet.mdx
new file mode 100644
index 000000000000..b317dc1b2f53
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/soneium-testnet.mdx
@@ -0,0 +1,9 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+
+### Indexing Data on Soneium Minato Testnet
+
+Soneium Minato Testnet is the public test network for Soneium, Sony's OP Stack Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+Soneium Minato Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
diff --git a/website/src/supportedNetworks/customContent/soneium.mdx b/website/src/supportedNetworks/customContent/soneium.mdx
new file mode 100644
index 000000000000..8e3c865382bb
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/soneium.mdx
@@ -0,0 +1,9 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+
+### Indexing Data on Soneium
+
+Soneium is an Ethereum Layer 2 built on the OP Stack and part of the Optimism Superchain, developed by Sony Block Solutions Labs to bring creators, entertainment, and consumer apps onchain. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+Soneium is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav) and [Data Nexus](https://data.nexus/).
+
+
diff --git a/website/src/supportedNetworks/customContent/sonic-testnet.mdx b/website/src/supportedNetworks/customContent/sonic-testnet.mdx
new file mode 100644
index 000000000000..fb8ad7c8f277
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/sonic-testnet.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Sonic Testnet
+
+Sonic Testnet is the public test network for Sonic, the high-performance EVM Layer 1 from the team behind Fantom, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Sonic Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Sonic Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/sonic.mdx b/website/src/supportedNetworks/customContent/sonic.mdx
new file mode 100644
index 000000000000..dcb805114322
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/sonic.mdx
@@ -0,0 +1,16 @@
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Sonic
+
+Sonic is a high-performance, EVM-compatible Layer 1 from the team behind Fantom, built for speed with sub-second finality and high throughput, with S as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Sonic is supported by The Graph with Subgraphs — open APIs you publish to The Graph Network, where Indexers sync and serve the data while you manage your service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+
+
diff --git a/website/src/supportedNetworks/customContent/stable.mdx b/website/src/supportedNetworks/customContent/stable.mdx
new file mode 100644
index 000000000000..b8ee1264b98f
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/stable.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Stable
+
+Stable is an EVM-compatible Layer 1 built for stablecoin payments, using USDT as its native gas token for fast, low-cost transfers. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Stable is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Stable.
+
+
diff --git a/website/src/supportedNetworks/customContent/starknet-mainnet.mdx b/website/src/supportedNetworks/customContent/starknet-mainnet.mdx
new file mode 100644
index 000000000000..df2bf7cb986f
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/starknet-mainnet.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Starknet
+
+Starknet is an Ethereum Layer 2 validity rollup powered by STARK proofs, using the Cairo programming model for scalable, low-cost execution. The Graph can stream that onchain activity — transactions, DEX swaps, token transfers and balances, and contract events — as real-time data with Substreams.
+
+Starknet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+### Indexing Starknet with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Starknet's blocks, transactions, and events. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Starknet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+2. Scaffold a project with `substreams init` and follow the prompts for Starknet.
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/starknet-testnet.mdx b/website/src/supportedNetworks/customContent/starknet-testnet.mdx
new file mode 100644
index 000000000000..4e70d0b26c4d
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/starknet-testnet.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Starknet Sepolia Testnet
+
+Starknet Sepolia Testnet is the public test network for Starknet, an Ethereum Layer 2 validity rollup powered by STARK proofs and the Cairo programming model, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — transactions, DEX swaps, token transfers and balances, and contract events — as real-time data with Substreams.
+
+Starknet Sepolia Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+### Indexing Starknet Sepolia Testnet with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Starknet Sepolia Testnet's blocks, transactions, and events. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Starknet Sepolia Testnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+2. Scaffold a project with `substreams init` and follow the prompts for Starknet.
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/stellar-testnet.mdx b/website/src/supportedNetworks/customContent/stellar-testnet.mdx
new file mode 100644
index 000000000000..efc9317e1981
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/stellar-testnet.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Stellar Testnet
+
+Stellar Testnet is the public test network for Stellar, a Layer 1 built for payments and asset issuance, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — payments and transactions, asset transfers and balances, DEX trades, and ledger changes — as real-time data with Substreams.
+
+Stellar Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+### Indexing Stellar Testnet with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Stellar Testnet's ledgers, transactions, and operations. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Stellar Testnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+2. Scaffold a project with `substreams init` and follow the prompts for Stellar.
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/stellar.mdx b/website/src/supportedNetworks/customContent/stellar.mdx
new file mode 100644
index 000000000000..7bd9a684e68a
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/stellar.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on Stellar
+
+Stellar is a Layer 1 blockchain built for payments and asset issuance, with fast settlement and low fees. The Graph can stream that onchain activity — payments and transactions, asset transfers and balances, DEX trades, and ledger changes — as real-time data with Substreams.
+
+Stellar is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+### Indexing Stellar with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams Stellar's ledgers, transactions, and operations. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on Stellar; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+2. Scaffold a project with `substreams init` and follow the prompts for Stellar.
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/tempo-moderato.mdx b/website/src/supportedNetworks/customContent/tempo-moderato.mdx
new file mode 100644
index 000000000000..ac2b7813c4be
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/tempo-moderato.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Tempo Moderato Testnet
+
+Tempo Moderato Testnet is the public test network for Tempo, the Stripe- and Paradigm-built Layer 1 for stablecoin payments, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Tempo Moderato Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Tempo Moderato Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/tempo.mdx b/website/src/supportedNetworks/customContent/tempo.mdx
new file mode 100644
index 000000000000..e23a860fa542
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/tempo.mdx
@@ -0,0 +1,21 @@
+import SubstreamsBase from './_substreams-base.mdx'
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Tempo
+
+Tempo is an EVM-compatible Layer 1 built by Stripe and Paradigm for stablecoin payments, designed for high-throughput, low-cost enterprise payment flows. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Tempo is supported by The Graph in two ways:
+
+- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/tron-evm.mdx b/website/src/supportedNetworks/customContent/tron-evm.mdx
new file mode 100644
index 000000000000..68b5c082187a
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/tron-evm.mdx
@@ -0,0 +1,9 @@
+import SubstreamsBase from './_substreams-base.mdx'
+
+### Indexing Data on TRON EVM
+
+TRON EVM is the EVM-compatible environment on TRON, a high-throughput Layer 1 widely used for stablecoin transfers and payments. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+TRON EVM is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+
diff --git a/website/src/supportedNetworks/customContent/tron.mdx b/website/src/supportedNetworks/customContent/tron.mdx
new file mode 100644
index 000000000000..5f63def8d71b
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/tron.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on TRON
+
+TRON is a high-throughput Layer 1 widely used for stablecoin transfers and payments, with a large DeFi and token ecosystem. The Graph can stream that onchain activity — transactions, stablecoin and token transfers, DEX swaps, and contract events — as real-time data with Substreams.
+
+TRON is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+### Indexing TRON with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams TRON's blocks, transactions, and events. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on TRON; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get a key at [thegraph.market](https://thegraph.market/) (no personal information required).
+2. Scaffold a project with `substreams init` and follow the prompts for TRON.
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/unichain-testnet.mdx b/website/src/supportedNetworks/customContent/unichain-testnet.mdx
new file mode 100644
index 000000000000..b06eac5c090c
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/unichain-testnet.mdx
@@ -0,0 +1,21 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Unichain Sepolia Testnet
+
+Unichain Sepolia Testnet is the public test network for Unichain, Uniswap's OP Stack Ethereum Layer 2, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Unichain Sepolia Testnet is supported by The Graph in two ways:
+
+- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/unichain.mdx b/website/src/supportedNetworks/customContent/unichain.mdx
new file mode 100644
index 000000000000..910071f5d856
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/unichain.mdx
@@ -0,0 +1,22 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on Unichain
+
+Unichain is an Ethereum Layer 2 built on the OP Stack by Uniswap Labs, optimized for DeFi with fast, low-cost swaps and cross-chain liquidity. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+Unichain is supported by The Graph in two ways:
+
+- You can [publish Subgraphs](/subgraphs/developing/deploying-publishing/publishing-a-subgraph/) to The Graph Network — where Indexers sync and serve data while consumers manage their service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [The Graph Market](https://thegraph.market/), [Pinax Network](https://app.pinax.network/docs?from=nav), and [Data Nexus](https://data.nexus/).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/viction.mdx b/website/src/supportedNetworks/customContent/viction.mdx
new file mode 100644
index 000000000000..65fe5b834989
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/viction.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Viction
+
+Viction (formerly TomoChain) is an EVM-compatible Layer 1 focused on zero-gas transactions and account abstraction for consumer-facing dApps, with VIC as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Viction is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Viction.
+
+
diff --git a/website/src/supportedNetworks/customContent/wax-testnet.mdx b/website/src/supportedNetworks/customContent/wax-testnet.mdx
new file mode 100644
index 000000000000..b1f6ead95e2e
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/wax-testnet.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on WAX Testnet
+
+WAX Testnet is the public test network for WAX, an Antelope-based Layer 1 for NFTs, gaming, and collectibles, where teams deploy and validate contracts before mainnet. The Graph can stream that onchain activity — transactions and actions, token transfers and balances, and smart-contract activity — as real-time data with Substreams.
+
+WAX Testnet is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Indexing WAX Testnet with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams WAX Testnet's blocks, transactions, and actions. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on WAX Testnet; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get an API key from [Pinax Network](https://app.pinax.network/).
+2. `substreams init` does not have a template for Antelope chains yet, so set up the project by hand: write a [`substreams.yaml` manifest](https://docs.substreams.dev/reference-material/manifest-and-components/manifests) with `network: wax-testnet` and a Rust map module that takes `sf.antelope.type.v1.Block` as its input (the protobuf definitions are published on [Buf](https://buf.build/pinax/firehose-antelope)).
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/wax.mdx b/website/src/supportedNetworks/customContent/wax.mdx
new file mode 100644
index 000000000000..4bc5229805c7
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/wax.mdx
@@ -0,0 +1,22 @@
+### Indexing Data on WAX
+
+WAX is an Antelope-based Layer 1 purpose-built for NFTs, gaming, and digital collectibles. The Graph can stream that onchain activity — transactions and actions, token transfers and balances, and smart-contract activity — as real-time data with Substreams.
+
+WAX is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+### Indexing WAX with Substreams
+
+[Substreams](/substreams/overview/) is a parallelized, real-time streaming engine for extracting and transforming blockchain data. Where a Subgraph indexes into a hosted GraphQL API, Substreams lets you consume high-throughput data directly or via [10+ supported sinks](/substreams/developing/sinks/). Substreams streams WAX's blocks, transactions, and actions. Modules are written in Rust and composed into reusable packages.
+
+#### Find an Existing Module on Substreams.dev
+
+Before writing any code, check the [Substreams Registry](https://substreams.dev/) for a package that already does what you need. The registry hosts community- and team-built modules covering common onchain data that you can run as-is or compose into your own pipeline. Search for the protocol or data you want on WAX; if a module fits, you can consume its output directly or import it as a dependency in your own project.
+
+#### Develop Your Own Substreams Module
+
+If no existing module fits, you can build one. The [Substreams Quick Start](/substreams/overview/) is the full walkthrough. In short:
+
+1. Install the Substreams CLI and get an API key from [Pinax Network](https://app.pinax.network/).
+2. `substreams init` does not have a template for Antelope chains yet, so set up the project by hand: write a [`substreams.yaml` manifest](https://docs.substreams.dev/reference-material/manifest-and-components/manifests) with `network: wax` and a Rust map module that takes `sf.antelope.type.v1.Block` as its input (the protobuf definitions are published on [Buf](https://buf.build/pinax/firehose-antelope)).
+3. Write your extraction and transformation logic in Rust, then run `substreams build`.
+4. Stream the output with `substreams gui` (or `substreams run`) to iterate, then publish your package to the [Substreams Registry](https://substreams.dev/) to reuse or share it.
diff --git a/website/src/supportedNetworks/customContent/worldchain.mdx b/website/src/supportedNetworks/customContent/worldchain.mdx
new file mode 100644
index 000000000000..476fb3c23224
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/worldchain.mdx
@@ -0,0 +1,9 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+
+### Indexing Data on World Chain
+
+World Chain is an Ethereum Layer 2 built on the OP Stack and part of the Optimism Superchain, created by the team behind World ID to give verified humans priority access to blockspace. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+World Chain is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [The Graph Market](https://thegraph.market/).
+
+
diff --git a/website/src/supportedNetworks/customContent/xlayer-mainnet.mdx b/website/src/supportedNetworks/customContent/xlayer-mainnet.mdx
new file mode 100644
index 000000000000..2d7c861fb948
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/xlayer-mainnet.mdx
@@ -0,0 +1,21 @@
+import SubstreamsBase from './_substreams-base.mdx'
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on X Layer
+
+X Layer is an Ethereum Layer 2 zkEVM built by OKX on the Polygon CDK, connecting the OKX ecosystem to onchain DeFi, with OKB as its gas token. The Graph can index that onchain activity, including DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events. That powers DeFi frontends, analytics dashboards, block explorers, portfolio trackers, and onchain agents without teams having to run their own indexing infrastructure.
+
+X Layer is supported by The Graph in two ways:
+
+- You can [develop and publish Subgraphs](/subgraphs/developing/deploying-publishing/using-subgraph-studio/) in Subgraph Studio — publishing is enabled, though guaranteed indexing via The Graph Network is not yet available.
+- You can also [consume Substreams](/substreams/quick-start/) — a real-time streaming engine for high-throughput use cases via [Pinax Network](https://app.pinax.network/docs?from=nav).
+
+
+
+
diff --git a/website/src/supportedNetworks/customContent/xlayer-sepolia.mdx b/website/src/supportedNetworks/customContent/xlayer-sepolia.mdx
new file mode 100644
index 000000000000..6078cf355237
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/xlayer-sepolia.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on X Layer Sepolia Testnet
+
+X Layer Sepolia Testnet is the public test network for X Layer, OKX's Ethereum Layer 2 zkEVM on the Polygon CDK, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+X Layer Sepolia Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for X Layer Sepolia Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/zetachain.mdx b/website/src/supportedNetworks/customContent/zetachain.mdx
new file mode 100644
index 000000000000..57281072d82d
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/zetachain.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on ZetaChain
+
+ZetaChain is an EVM-compatible Layer 1 built for omnichain applications, letting smart contracts read and write assets and data across connected blockchains, with ZETA as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+ZetaChain is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for ZetaChain.
+
+
diff --git a/website/src/supportedNetworks/customContent/zilliqa-testnet.mdx b/website/src/supportedNetworks/customContent/zilliqa-testnet.mdx
new file mode 100644
index 000000000000..a4323c206081
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/zilliqa-testnet.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Zilliqa Testnet
+
+Zilliqa 2.0 Testnet is the public test network for Zilliqa 2.0, the EVM-compatible sharded Layer 1, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Zilliqa Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Zilliqa Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/zilliqa.mdx b/website/src/supportedNetworks/customContent/zilliqa.mdx
new file mode 100644
index 000000000000..180e60127bdf
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/zilliqa.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on Zilliqa
+
+Zilliqa 2.0 is an EVM-compatible, sharded Layer 1 designed for high throughput, with ZIL as its native token. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+Zilliqa is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for Zilliqa.
+
+
diff --git a/website/src/supportedNetworks/customContent/zksync-era-sepolia.mdx b/website/src/supportedNetworks/customContent/zksync-era-sepolia.mdx
new file mode 100644
index 000000000000..328ce8af6f27
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/zksync-era-sepolia.mdx
@@ -0,0 +1,15 @@
+import SubgraphStudio from './_subgraph-studio.mdx'
+
+### Indexing Data on zkSync Sepolia Testnet
+
+zkSync Sepolia Testnet is the public test network for zkSync Era, the Matter Labs Ethereum Layer 2 zkEVM, where teams deploy and validate contracts before mainnet. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+zkSync Sepolia Testnet is supported by The Graph with Subgraphs — develop, test, and publish them in [Subgraph Studio](/subgraphs/developing/deploying-publishing/using-subgraph-studio/). Publishing is enabled, though guaranteed indexing via The Graph Network is not yet available for zkSync Sepolia Testnet.
+
+
diff --git a/website/src/supportedNetworks/customContent/zksync-era.mdx b/website/src/supportedNetworks/customContent/zksync-era.mdx
new file mode 100644
index 000000000000..a954957edc32
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/zksync-era.mdx
@@ -0,0 +1,16 @@
+import SubgraphCommunity from './_subgraph-community.mdx'
+
+### Indexing Data on zkSync Era
+
+zkSync Era is an Ethereum Layer 2 zkEVM rollup built by Matter Labs, using zero-knowledge proofs for scalable, low-cost execution with full EVM compatibility. The Graph can index that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — and serve it over GraphQL with Subgraphs.
+
+zkSync Era is supported by The Graph with Subgraphs — open APIs you publish to The Graph Network, where Indexers sync and serve the data while you manage your service in [Subgraph Studio](/subgraphs/providers/subgraph-studio/introduction/).
+
+
diff --git a/website/src/supportedNetworks/customContent/zora.mdx b/website/src/supportedNetworks/customContent/zora.mdx
new file mode 100644
index 000000000000..68e860654cfe
--- /dev/null
+++ b/website/src/supportedNetworks/customContent/zora.mdx
@@ -0,0 +1,9 @@
+import SubstreamsExtended from './_substreams-extended.mdx'
+
+### Indexing Data on Zora
+
+Zora is an Ethereum Layer 2 built on the OP Stack and part of the Optimism Superchain, focused on the onchain creator economy — NFTs, creator coins, and media. The Graph can stream that onchain activity — DEX swaps, pools, and liquidity; lending and borrowing positions; token transfers and holder balances; and contract events — as real-time data with Substreams.
+
+Zora is supported by The Graph with Substreams — a parallelized, real-time streaming engine for high-throughput use cases — via [Pinax Network](https://app.pinax.network/docs?from=nav) and [Data Nexus](https://data.nexus/).
+
+
diff --git a/website/src/supportedNetworks/index.ts b/website/src/supportedNetworks/index.ts
index 538545e9a757..6c9ac42b0fb8 100644
--- a/website/src/supportedNetworks/index.ts
+++ b/website/src/supportedNetworks/index.ts
@@ -1,3 +1,4 @@
export * from './NetworkDetailsPage'
export * from './NetworksTable'
+export * from './slugs'
export * from './utils'
diff --git a/website/src/supportedNetworks/slugs.ts b/website/src/supportedNetworks/slugs.ts
new file mode 100644
index 000000000000..68e57c810cf3
--- /dev/null
+++ b/website/src/supportedNetworks/slugs.ts
@@ -0,0 +1,34 @@
+// Friendly URL slugs for specific Supported Networks pages.
+//
+// Keyed by the registry network `id`; any network not listed here uses its `id` as
+// its slug. If several ids ever share one slug, `slugCanonicalId` names the network
+// whose page and metadata render for that slug.
+export const networkSlugs: Record = {
+ btc: 'bitcoin',
+ 'blast-mainnet': 'blast',
+ 'mainnet-cl': 'ethereum-beacon',
+ 'hoodi-cl': 'ethereum-hoodi',
+ 'sepolia-cl': 'ethereum-sepolia',
+ eos: 'vaulta',
+ 'injective-mainnet': 'injective',
+ 'solana-mainnet-beta': 'solana',
+}
+
+// For slugs shared by multiple networks, the registry `id` whose page and metadata render.
+export const slugCanonicalId: Record = {
+ solana: 'solana-mainnet-beta',
+}
+
+/** The URL slug for a network's Supported Networks page. */
+export function getNetworkSlug(id: string): string {
+ return networkSlugs[id] ?? id
+}
+
+/** Resolve a URL slug back to the registry network `id` that should render. */
+export function resolveSlugToNetworkId(slug: string): string {
+ if (slugCanonicalId[slug]) return slugCanonicalId[slug]
+ for (const [id, mapped] of Object.entries(networkSlugs)) {
+ if (mapped === slug) return id
+ }
+ return slug
+}
diff --git a/website/src/supportedNetworks/utils.ts b/website/src/supportedNetworks/utils.ts
index 953fd7461767..39e4b0a5f2fc 100644
--- a/website/src/supportedNetworks/utils.ts
+++ b/website/src/supportedNetworks/utils.ts
@@ -1,93 +1,138 @@
-import { type Network, NetworksRegistry } from '@pinax/graph-networks-registry'
+import { type Network as PinaxNetwork } from '@pinax/graph-networks-registry'
-// Networks that should use the "mono" icon variant (TODO: add this feature to web3icons?)
-const MONO_ICON_NETWORKS = [
- 'arweave-mainnet',
- 'autonomys-taurus',
- 'expchain-testnet',
- 'fraxtal',
- 'lens',
- 'lens-testnet',
- 'linea',
- 'linea-sepolia',
- 'lumia',
- 'mbase',
- 'megaeth-testnet',
- 'soneium',
- 'soneium-testnet',
- 'sonic',
- 'stellar',
- 'vana',
- 'vana-moksha',
- 'xlayer-mainnet',
- 'xlayer-sepolia',
- 'zksync-era',
- 'zksync-era-sepolia',
+// The networks registry is read straight from its published v0.8.x JSON rather than through
+// `@pinax/graph-networks-registry`. That library (latest 0.7.1) only fetches the v0.7.x feed,
+// which strips the structured `services.subgraphs` entries (gateway/studio/backstop) that the
+// Subgraphs tiers below depend on, and its parser types `subgraphs` as `string[]`.
+// The v0.8.x file is otherwise identical to v0.7.x. When a registry v0.9 ships, update these
+// URLs, or switch back to the library once a matching version is published.
+const REGISTRY_URLS = [
+ 'https://networks-registry.thegraph.com/TheGraphNetworksRegistry_v0_8_x.json',
+ // Same file on GitHub, used if the primary host is unreachable (mirrors the library's fallback).
+ 'https://raw.githubusercontent.com/graphprotocol/networks-registry/refs/heads/main/public/TheGraphNetworksRegistry_v0_8_x.json',
]
+// v0.8 `services.subgraphs` entries: bare deployment URL strings and/or structured
+// `{ kind, provider, description }` entries, where `kind` is 'gateway', 'studio' or 'backstop'
+// (e.g. `{ kind: 'backstop', provider: 'infradao' }`). The legacy `{ backstopSupport }` shape
+// is still accepted.
+type SubgraphsServiceEntry =
+ | string
+ | { kind?: 'gateway' | 'studio' | 'backstop'; provider?: string; description?: string; backstopSupport?: string }
+
+// The library's `Network` type, with `services.subgraphs` widened to the v0.8 entry shape.
+type Network = Omit & {
+ services: Omit & { subgraphs?: SubgraphsServiceEntry[] }
+}
+
+async function fetchRegistryNetworks(): Promise {
+ const errors: string[] = []
+ for (const url of REGISTRY_URLS) {
+ try {
+ const response = await fetch(url)
+ if (!response.ok) throw new Error(`HTTP ${response.status}`)
+ const registry = (await response.json()) as { networks?: Network[] }
+ if (!Array.isArray(registry.networks)) throw new Error('missing `networks` array')
+ return registry.networks
+ } catch (error) {
+ errors.push(`${url}: ${error instanceof Error ? error.message : String(error)}`)
+ }
+ }
+ throw new Error(`Failed to fetch the networks registry:\n${errors.join('\n')}`)
+}
+
+function getSubgraphsEntries(network: Network): SubgraphsServiceEntry[] {
+ return network.services.subgraphs ?? []
+}
+
+// Deployable via Subgraph Studio: a bare Studio deploy URL or a `kind: 'studio'` entry.
+function hasStudioSupport(network: Network): boolean {
+ return getSubgraphsEntries(network).some((entry) =>
+ typeof entry === 'string'
+ ? entry.includes('studio.thegraph.com')
+ : entry.kind === 'studio' || Boolean(entry.provider?.includes('studio.thegraph.com')),
+ )
+}
+
+// Community backstop indexing: a `kind: 'backstop'` entry (or the legacy `backstopSupport` field).
+function hasBackstopSupport(network: Network): boolean {
+ return getSubgraphsEntries(network).some(
+ (entry) => typeof entry !== 'string' && (entry.kind === 'backstop' || Boolean(entry.backstopSupport)),
+ )
+}
+
+export type SubgraphsTier = 'none' | 'studio' | 'network' | 'rewards'
+export type SubstreamsTier = 'none' | 'other' | 'base' | 'extended'
+
export async function getSupportedNetworks() {
- const registry = await NetworksRegistry.fromLatestVersion()
- return registry.networks
+ const networks = await fetchRegistryNetworks()
+ return networks
.flatMap((network) => {
- const [subgraphsSupportLevel, subgraphsProvider] = getSubgraphsSupportLevelAndProvider(network)
- // Substreams and Firehose share one combined signal (see getFirehoseSubstreamsSupportLevel);
- // both columns render the same mark.
- const firehoseSubstreamsSupportLevel = getFirehoseSubstreamsSupportLevel(network)
- const substreamsSupportLevel = firehoseSubstreamsSupportLevel
- const firehoseSupportLevel = firehoseSubstreamsSupportLevel
- if (subgraphsSupportLevel === 'none' && substreamsSupportLevel === 'none' && firehoseSupportLevel === 'none') {
+ const subgraphsStudio = hasStudioSupport(network)
+ const subgraphsBackstop = hasBackstopSupport(network)
+ const subgraphsTier = getSubgraphsTier(network, subgraphsStudio, subgraphsBackstop)
+ const substreamsTier = getSubstreamsTier(network)
+ // Drop networks that would show no chip in either product column.
+ if (subgraphsTier === 'none' && substreamsTier === 'none') {
return []
}
+ // Coarse support flags kept for the network details page, which only branches on
+ // whether each product is supported at all.
+ const subgraphsSupportLevel = subgraphsTier === 'none' ? 'none' : network.issuanceRewards ? 'full' : 'basic'
+ const substreamsSupportLevel =
+ substreamsTier === 'none' ? 'none' : substreamsTier === 'extended' ? 'full' : 'basic'
return [
{
...network,
evm: isEvm(network),
iconVariant: getIconVariant(network),
+ subgraphsTier,
+ subgraphsStudio,
+ subgraphsBackstop,
+ substreamsTier,
subgraphsSupportLevel,
- subgraphsProvider,
substreamsSupportLevel,
- firehoseSupportLevel,
},
]
})
.sort((a, b) => a.fullName.localeCompare(b.fullName))
}
-function isEvm(network: Network) {
- return network.caip2Id.startsWith('eip155:')
+// Networks render with mono icons, except those the registry lists without a mono variant
+// (`icon.web3Icons.variants`, e.g. Zora), which fall back to their branded icon for now.
+function getIconVariant(network: Network): 'mono' | 'branded' {
+ const variants = network.icon?.web3Icons?.variants
+ return variants && !variants.includes('mono') && variants.includes('branded') ? 'branded' : 'mono'
}
-function getIconVariant(network: Network): 'mono' | 'branded' {
- return MONO_ICON_NETWORKS.includes(network.id) ? 'mono' : 'branded'
+function isEvm(network: Network) {
+ return network.caip2Id.startsWith('eip155:')
}
-function getSubgraphsSupportLevelAndProvider(network: Network): ['none' | 'basic' | 'full', string | null] {
- const providers = [...new Set([...(network.services.subgraphs || []), ...(network.services.sps || [])])]
- if (providers.length > 0) {
- let provider = providers[0]!
- if (providers.some((provider) => /^((https?:)?\/\/)?api\.studio\.thegraph\.com(\/|$)/.test(provider))) {
- provider = 'Subgraph Studio'
- } else if (providers.some((provider) => /^((https?:)?\/\/)?(www\.)?streamingfast\.io(\/|$)/.test(provider))) {
- provider = 'StreamingFast'
- }
- if (network.issuanceRewards) {
- return ['full', provider]
- }
- return ['basic', provider]
- }
- return ['none', null]
+// Subgraphs support has three tiers, in priority order (only the highest one applies):
+// - 'rewards' -> the network earns indexing rewards (`issuanceRewards: true`)
+// - 'network' -> community backstop support (a `kind: 'backstop'` entry in
+// `services.subgraphs`, e.g. InfraDAO or StreamingFast) but no issuance rewards
+// - 'studio' -> deployable via Subgraph Studio (a Studio deploy URL or `kind: 'studio'` entry
+// in `services.subgraphs`) but neither of the above
+// A bare `kind: 'gateway'` entry on its own does not earn a tier.
+function getSubgraphsTier(network: Network, studio: boolean, backstop: boolean): SubgraphsTier {
+ if (network.issuanceRewards) return 'rewards'
+ if (backstop) return 'network'
+ if (studio) return 'studio'
+ return 'none'
}
-// Substreams and Firehose share a single support signal. Both are powered by the same
-// Firehose block data, so the table's "Base" vs "Extended (EVM only)" mark reflects the
-// network's block model, not how many providers serve the data.
-// - 'none' -> no Firehose or Substreams provider is serving the network
-// - 'basic' -> base blocks + at least one Firehose or Substreams provider (renders as a single check)
-// - 'full' -> extended (EVM) blocks + at least one Firehose or Substreams provider (renders as a double check)
-function getFirehoseSubstreamsSupportLevel(network: Network): 'none' | 'basic' | 'full' {
- const hasProvider = (network.services.substreams?.length || 0) > 0 || (network.services.firehose?.length || 0) > 0
+// Substreams/Firehose support has three tiers. A network needs at least one Firehose or
+// Substreams provider to show any of them; the tier then reflects the block model:
+// - 'other' -> non-EVM network (the block-model tiers below are EVM-only)
+// - 'extended' -> EVM network serving the extended block model
+// - 'base' -> EVM network serving the base block model
+function getSubstreamsTier(network: Network): SubstreamsTier {
+ const hasProvider = (network.services.substreams?.length ?? 0) > 0 || (network.services.firehose?.length ?? 0) > 0
if (!hasProvider) return 'none'
- return network.firehose?.evmExtendedModel ? 'full' : 'basic'
+ if (!isEvm(network)) return 'other'
+ return network.firehose?.evmExtendedModel ? 'extended' : 'base'
}
export type SupportedNetwork = Awaited>[number]