Subgraph Testing with Matchstick: Unit Test Guide for The Graph

This video demonstrates how to configure GitHub Actions to automatically run Jest unit tests whenever pull requests are made to a repository, ensuring code quality by verifying that new changes don't break existing functionality; the setup involves creating a `.github/workflows/testing.yaml` file that defines when the workflow runs (on pull requests), specifies the runner environment (such as Ubuntu latest), sets the Node.js version, and outlines sequential steps including checking out the code, installing dependencies with npm install, and executing the Jest test suite, with exit codes determining whether the workflow succeeds or fails.

This section demonstrates GitHub Actions for automated testing and continuous integration. Workflows are YAML files in the .github/workflows directory. A typical workflow checks out the repository, builds the Docker image, and runs tests. The presenter shows creating a workflow that runs on every push to the repository. Test failures cause the workflow to fail, providing immediate feedback to developers. The presenter demonstrates running the workflow and viewing the results in the Actions tab. The section concludes by demonstrating fixing a bug in the average function (handling empty arrays) and running tests again. The presenter emphasizes that CI/CD automates testing so every code change is automatically tested, catching bugs early and ensuring code quality.

GitHub Actions enables automated CI/CD pipelines by creating YAML workflow files in the .github/workflows directory, where workflows can be triggered by events like pull requests or main branch pushes to automatically test code using actions like npm ci and Jest, and deploy code to production servers using SCP with SSH keys stored as GitHub secrets, thereby eliminating manual deployment errors and accelerating the development cycle.

Continuous Integration (CI) involves frequent merges to a main branch with automatic unit tests on every push, preventing integration conflicts and catching regressions early. Continuous Delivery (CD) enables shorter release cycles, deploying changes incrementally rather than waiting for major releases. GitHub Actions implements CI/CD using YAML configuration files defining workflows triggered by repository events. Workflows run jobs on virtual machines with specified steps (installing dependencies, running tests). Failed commits show red indicators, while passing commits show green checks. This enforces testing requirements automatically, ensuring no untested code reaches production. Teams can add rules requiring tests to pass before merging code into main branches.

Implementing a CI pipeline with GitHub Actions requires creating a workflow YAML file defining triggers (push to main or pull request) and jobs. The workflow checks out code and runs the Qodana scan action using appropriate linter images for your programming language. Qodana Cloud provides visualization for viewing code issues discovered by scans. Connect your project by creating a team and project in Qodana Cloud and providing the repository URL. Configure GitHub Actions to send results by setting a secret token in repository secrets. This enables centralized visualization of issues across all pipeline runs, showing issues by severity level with details about each problem including affected files and suggested fixes.

Polymer developed a reorg protection protocol for sub-finality communication across Ethereum layer 2s that builds a dependency graph of transactions based on historical layer 1 data. Once Ethereum finalizes, the protocol commits all dependent transactions; if the layer 1 history does not finalize, it reverts the entire dependency graph. This approach brings reorg risk handling from the application level down to the protocol level while maintaining extremely low latencies (targeting under 10 seconds), allowing rollups producing blocks at 100ms intervals to communicate at similar speeds. No protocol can guarantee finality on behalf of Ethereum since Ethereum has its own finality mechanism.

It was agreed that as of Amsterdam, EL clients should be able to reorg back 38 days (the inactivity leak period with 70% of nodes offline). This doesn't require a hard fork but represents a goal to move toward. The EIP currently has the week subjectivity period and would be updated to reflect this 38-day maximum. The decision is to aim for this capability by Amsterdam, with flexibility if it's not achievable. Testing is needed to verify client behavior in real environments with deep reorgs.

Matchstick is a unit testing framework developed by LimeChain that enables subgraph developers to test their mapping logic in a sandboxed environment before deployment, allowing them to verify that their event handlers and smart contract interactions work correctly without waiting for the entire subgraph to sync on-chain, which can take days or even months for large subgraphs like Uniswap v2.

Cardano demonstrated unprecedented resilience when it encountered the worst possible scenario for a proof-of-stake blockchain: a hard fork resulting in a long-chain reorganization. Unlike typical proof-of-stake protocols which would require shutting down, manually reconstructing, and hard-forking every client under centralized control, both chains operated simultaneously and eventually converged in a completely decentralized manner. This achievement proved that proof-of-stake protocols could achieve what was previously thought impossible, demonstrating superior engineering and community coordination.

This section covers displaying indexed data and deployment preparation. Displaying data from The Graph involves querying the GraphQL API and rendering results in tables or lists. Apollo Client's useQuery hook fetches data from the GraphQL endpoint, with queries optimized to fetch only needed fields. The Apollo client handles caching and refetching. Performance comparison shows that querying The Graph is significantly faster than direct blockchain queries, especially for large datasets. The Graph can retrieve hundreds of records in milliseconds compared to seconds when querying the blockchain directly. Deploying to testnets requires generating a deployer account using 'yarn generate' which creates a unique wallet stored in environment variables. Unlike shared Hardhat accounts, deployer accounts can be funded by transferring test ETH from another wallet.

This segment demonstrates using the GraphQL playground to query indexed data. The playground provides autocomplete and a builder interface for constructing queries. Developers can query specific data like NFTs, their owners, transfer history, and timestamps. The playground shows the actual data that has been indexed, allowing developers to verify that indexing is working correctly. The segment also covers the inefficiency of direct blockchain queries, where getting information about 10,000 NFTs might require 30,000 requests. The Subquery indexer solves this by providing a single query endpoint that returns all necessary data, dramatically reducing requests.

The Graph is a decentralized infrastructure protocol that indexes and organizes blockchain data to make it usable for developers, solving the problem of reading, organizing, and making on-chain data accessible in a scalable way; it enables developers to create open APIs called subgraphs that power most web3 applications including DEXs, NFT marketplaces, and data analytics platforms, with the protocol currently integrated with 39 blockchains and processing over a billion queries daily.

Blockchains like Ethereum lack built-in data indexing capabilities, forcing dApps to rely on centralized servers that index data and expose it through APIs. This contradicts Ethereum's goal of a fully decentralized 'world computer.' Web2 companies run vertical stacks creating data silos where companies control access. REST APIs evolved with one endpoint per resource, requiring multiple round-trip calls, creating performance issues. Facebook invented GraphQL to address this by providing a query language where clients specify schemas upfront and request exactly needed data in single responses. Blockchains lack built-in databases or SQL capabilities, making data querying difficult. Most dApps (90%+) built custom proprietary indexing servers syncing data to SQL databases, creating centralized choke points. The Graph is an indexing and query protocol for blockchains and storage networks. It indexes data from Web3 sources and makes it available over GraphQL through 'subgraphs'—units defining data sources, mapping scripts, and GraphQL schemas. This standardization enables consistent indexing across different nodes, with the long-term vision being a decentralized network where any graph node can choose which subgraphs to index.