diff --git a/website/src/pages/en/subgraphs/guides/_meta.js b/website/src/pages/en/subgraphs/guides/_meta.js index 37e18bc51651..a1bb04fb6d3f 100644 --- a/website/src/pages/en/subgraphs/guides/_meta.js +++ b/website/src/pages/en/subgraphs/guides/_meta.js @@ -1,4 +1,5 @@ export default { + 'subgraph-composition': '', 'subgraph-debug-forking': '', near: '', arweave: '', diff --git a/website/src/pages/en/subgraphs/guides/subgraph-composition.mdx b/website/src/pages/en/subgraphs/guides/subgraph-composition.mdx new file mode 100644 index 000000000000..88ebf9d97dca --- /dev/null +++ b/website/src/pages/en/subgraphs/guides/subgraph-composition.mdx @@ -0,0 +1,132 @@ +--- +title: Aggregate Data Using Subgraph Composition +sidebarTitle: 'Build a Composable Subgraph with Multiple Subgraphs' +--- + +Leverage Subgraph composition to speed up development time. Create a base Subgraph with essential data, then build additional Subgraphs on top of it. + +Optimize your Subgraph by merging data from independent, source Subgraphs into a single composable Subgraph to enhance data aggregation. + +## Introduction + +Composable Subgraphs enable you to combine multiple Subgraphs' data sources into a new Subgraph, facilitating faster and more flexible Subgraph development. Subgraph composition empowers you to create and maintain smaller, focused Subgraphs that collectively form a larger, interconnected dataset. + +### Benefits of Composition + +Subgraph composition is a powerful feature for scaling, allowing you to: + +- Reuse, mix, and combine existing data +- Streamline development and queries +- Use multiple data sources (up to five source Subgraphs) +- Speed up your Subgraph's syncing speed +- Handle errors and optimize the resync + +## Architecture Overview + +The setup for this example involves two Subgraphs: + +1. **Source Subgraph**: Tracks event data as entities. +2. **Dependent Subgraph**: Uses the source Subgraph as a data source. + +You can find these in the `source` and `dependent` directories. + +- The **source Subgraph** is a basic event-tracking Subgraph that records events emitted by relevant contracts. +- The **dependent Subgraph** references the source Subgraph as a data source, using the entities from the source as triggers. + +While the source Subgraph is a standard Subgraph, the dependent Subgraph uses the Subgraph composition feature. + +## Prerequisites + +### Source Subgraphs + +- All Subgraphs need to be published with a **specVersion 1.3.0 or later** (Use the latest graph-cli version to be able to deploy composable Subgraphs) +- See notes here: https://github.com/graphprotocol/graph-node/releases/tag/v0.37.0 +- Immutable entities only: All Subgraphs must have [immutable entities](https://thegraph.com/docs/en/subgraphs/best-practices/immutable-entities-bytes-as-ids/#immutable-entities) when the Subgraph is deployed +- Pruning can be used in the source Subgraphs, but only entities that are immutable can be composed on top of +- Source Subgraphs cannot use grafting on top of existing entities +- Aggregated entities can be used in composition, but entities that are composed from them cannot performed additional aggregations directly + +### Composed Subgraphs + +- You can only compose up to a **maximum of 5 source Subgraphs** +- Composed Subgraphs can only use **datasources from the same chain** +- **Nested composition is not yet supported**: Composing on top of another composed Subgraph isn’t allowed at this time +- Aggregated entities can be used in composition, but the composed entities on them cannot also use aggregations directly +- Developers cannot compose an onchain datasource with a Subgraph datasource (i.e. you can’t do normal event handlers and call handlers and block handlers in a composed Subgraph) + +Additionally, you can explore the [example-composable-subgraph](https://github.com/graphprotocol/example-composable-subgraph) repository for a working implementation of composable Subgraphs + +## Get Started + +The following guide provides examples for defining 3 source Subgraphs to create one powerful composed Subgraph. + +### Specifics + +- To keep this example simple, all source Subgraphs use only block handlers. However, in a real environment, each source Subgraph will use data from different smart contracts. +- The examples below show how to import and extend the schema of another Subgraph to enhance its functionality. +- Each source Subgraph is optimized with a specific entity. +- All the commands listed install the necessary dependencies, generate code based on the GraphQL schema, build the Subgraph, and deploy it to your local Graph Node instance. + +### Step 1. Deploy Block Time Source Subgraph + +This first source Subgraph calculates the block time for each block. + +- It imports schemas from other Subgraphs and adds a `block` entity with a `timestamp` field, representing the time each block was mined. +- It listens to time-related blockchain events (e.g., block timestamps) and processes this data to update the Subgraph's entities accordingly. + +To deploy this Subgraph locally, run the following commands: + +```bash +npm install +npm run codegen +npm run build +npm run create-local +npm run deploy-local +``` + +### Step 2. Deploy Block Cost Source Subgraph + +This second source Subgraph indexes the cost of each block. + +#### Key Functions + +- It imports schemas from other Subgraphs and adds a `block` entity with cost-related fields. +- It listens to blockchain events related to costs (e.g. gas fees, transaction costs) and processes this data to update the Subgraph's entities accordingly. + +To deploy this Subgraph locally, run the same commands as above. + +### Step 3. Define Block Size in Source Subgraph + +This third source Subgraph indexes the size of each block. To deploy this Subgraph locally, run the same commands as above. + +#### Key Functions + +- It imports existing schemas from other Subgraphs and adds a `block` entity with a `size` field representing each block's size. +- It listens to blockchain events related to block sizes (e.g., storage or volume) and processes this data to update the Subgraph's entities accordingly. + +### Step 4. Combine Into Block Stats Subgraph + +This composed Subgraph combines and aggregates the information from the source Subgraphs above, providing a unified view of block statistics. To deploy this Subgraph locally, run the same commands as above. + +> Note: +> +> - Any change to a source Subgraph will likely generate a new deployment ID. +> - Be sure to update the deployment ID in the data source address of the Subgraph manifest to take advantage of the latest changes. +> - All source Subgraphs should be deployed before the composed Subgraph is deployed. + +#### Key Functions + +- It provides a consolidated data model that encompasses all relevant block metrics. +- It combines data from 3 source Subgraphs, and provides a comprehensive view of block statistics, enabling more complex queries and analyses. + +## Key Takeaways + +- This powerful tool will scale your Subgraph development and allow you to combine multiple Subgraphs. +- The setup includes the deployment of 3 source Subgraphs and one final deployment of the composed Subgraph. +- This feature unlocks scalability, simplifying both development and maintenance efficiency. + +## Additional Resources + +- Check out all the code for this example in [this GitHub repo](https://github.com/graphprotocol/example-composable-subgraph). +- To add advanced features to your Subgraph, check out [Subgraph advanced features](/developing/creating/advanced/). +- To learn more about aggregations, check out [Timeseries and Aggregations](/subgraphs/developing/creating/advanced/#timeseries-and-aggregations).