tests: Switch integration tests to mine-on-demand

Instead of mining a block every 2s, mine blocks only on demand, simplifying
the setup and making it much nicer to keep anvil state for future runs

Author: lutter

.github/workflows/ci.yml

@@ -171,7 +171,7 @@ jobs:
         run: pnpm install
 
       - name: Start anvil
-        run: anvil --gas-limit 100000000000 --base-fee 1 --block-time 2 --timestamp 1743944919 --port 3021 &
+        run: anvil --gas-limit 100000000000 --base-fee 1 --timestamp 1743944919 --port 3021 &
 
       - name: Build graph-node
         run: just build --test integration_tests

flake.nix

@@ -197,7 +197,7 @@
               timestamp = 1743944919;
               gasLimit = 100000000000;
               baseFee = 1;
-              blockTime = 2;
+              blockTime = null;
               state = "./.data/integration/anvil/state.json";
               stateInterval = 30;
               preserveHistoricalStates = true;

tests/docker-compose.yml

@@ -25,7 +25,7 @@ services:
     image: ghcr.io/foundry-rs/foundry:v1.4.0
     ports:
       - '3021:8545'
-    command: "'anvil --host 0.0.0.0 --gas-limit 100000000000 --base-fee 1 --block-time 2 --timestamp 1743944919 --mnemonic \"test test test test test test test test test test test junk\"'"
+    command: "'anvil --host 0.0.0.0 --gas-limit 100000000000 --base-fee 1 --timestamp 1743944919 --mnemonic \"test test test test test test test test test test test junk\"'"
 
 # graph-node ports:
 #   json-rpc: 8020

tests/src/contract.rs

@@ -5,7 +5,7 @@ use graph::prelude::{
         json_abi::JsonAbi,
         network::{Ethereum, TransactionBuilder},
         primitives::{Address, Bytes, U256},
-        providers::{Provider, ProviderBuilder, WalletProvider},
+        providers::{ext::AnvilApi, Provider, ProviderBuilder, WalletProvider},
         rpc::types::{Block, TransactionReceipt, TransactionRequest},
         signers::local::PrivateKeySigner,
     },
@@ -280,4 +280,40 @@ impl Contract {
             .ok()
             .flatten()
     }
+
+    /// Mine the specified number of empty blocks using Anvil's evm_mine RPC.
+    pub async fn mine_blocks(count: u64) -> anyhow::Result<u64> {
+        let provider = Self::provider();
+
+        for _ in 0..count {
+            provider
+                .evm_mine(None)
+                .await
+                .map_err(|e| anyhow::anyhow!("Failed to mine block: {}", e))?;
+        }
+
+        let block = provider
+            .get_block_number()
+            .await
+            .map_err(|e| anyhow::anyhow!("Failed to get block number: {}", e))?;
+
+        Ok(block)
+    }
+
+    /// Ensure the blockchain has reached at least the specified block number.
+    /// Mines empty blocks if needed.
+    pub async fn ensure_block(target_block: u64) -> anyhow::Result<()> {
+        let provider = Self::provider();
+        let current = provider
+            .get_block_number()
+            .await
+            .map_err(|e| anyhow::anyhow!("Failed to get block number: {}", e))?;
+
+        if current < target_block {
+            let blocks_needed = target_block - current;
+            Self::mine_blocks(blocks_needed).await?;
+        }
+
+        Ok(())
+    }
 }

tests/tests/integration_tests.rs

@@ -12,7 +12,7 @@
 use std::collections::HashMap;
 use std::future::Future;
 use std::pin::Pin;
-use std::time::{self, Duration, Instant};
+use std::time::{Duration, Instant};
 
 use anyhow::{anyhow, bail, Context, Result};
 use graph::components::subgraph::{
@@ -1388,24 +1388,6 @@ async fn test_declared_calls_struct_fields(ctx: TestContext) -> anyhow::Result<(
     Ok(())
 }
 
-async fn wait_for_blockchain_block(block_number: i32) -> bool {
-    // Wait up to 5 minutes for the expected block to appear
-    const STATUS_WAIT: Duration = Duration::from_secs(300);
-    const REQUEST_REPEATING: Duration = time::Duration::from_secs(1);
-    let start = Instant::now();
-    while start.elapsed() < STATUS_WAIT {
-        let latest_block = Contract::latest_block().await;
-        if let Some(latest_block) = latest_block {
-            let number = latest_block.header.number;
-            if number >= block_number as u64 {
-                return true;
-            }
-        }
-        tokio::time::sleep(REQUEST_REPEATING).await;
-    }
-    false
-}
-
 /// The main test entrypoint.
 #[graph::test]
 async fn integration_tests() -> anyhow::Result<()> {
@@ -1452,10 +1434,17 @@ async fn integration_tests() -> anyhow::Result<()> {
         cases
     };
 
-    // Here we wait for a block in the blockchain in order not to influence
-    // block hashes for all the blocks until the end of the grafting tests.
-    // Currently the last used block for grafting test is the block 3.
-    assert!(wait_for_blockchain_block(SUBGRAPH_LAST_GRAFTING_BLOCK).await);
+    // Mine empty blocks to reach the required block number for grafting tests.
+    // This ensures deterministic block hashes for blocks 1-3 before any
+    // contract deployments occur.
+    status!(
+        "setup",
+        "Mining blocks to reach block {}",
+        SUBGRAPH_LAST_GRAFTING_BLOCK
+    );
+    Contract::ensure_block(SUBGRAPH_LAST_GRAFTING_BLOCK as u64)
+        .await
+        .context("Failed to mine initial blocks for grafting test")?;
 
     let contracts = Contract::deploy_all().await?;