ci, db/state: matrix-test serial vs parallel commitment across the test workflows

.claude/skills/erigon-ci/SKILL.md

@@ -22,7 +22,7 @@ Each test group has its own dedicated skill for drill-down on failures. Use thos
 | unit | `erigon-test-unit` | `make test-short` | ~5 min | Pre-push gate |
 | all | `erigon-test-all` | `GOGC=80 make test-all` | ~30 min | Before PR review |
 | race | `erigon-test-race` | `make test-all-race` | ~60 min | Concurrency changes |
-| eest-spec | *(inline)* | `make eest-spec-<suite>-<fixtures>[-{sequential,parallel}]` | varies | EEST state/blockchain/engine-x changes (most shards split into `-sequential` / `-parallel` pairs that pin `ERIGON_EXEC3_PARALLEL`; see `tools/eest-spec-shards.yml`) |
+| eest-spec | *(inline)* | `make eest-spec-<shard>` | varies | EEST state/blockchain/engine-x changes (paired shards pin `ERIGON_COMMITMENT_PARALLEL`; execution remains parallel; see `tools/eest-spec-shards.yml`) |
 | caplin spec | *(inline)* | `cd cl/spectest && make tests && make mainnet` | ~15 min | CL/consensus changes |
 | hive | `erigon-test-hive` | `make test-hive` | ~20 min | EL/CL interop changes |
 | rpc | `erigon-test-rpc` | *(requires synced DB)* | ~10 min | RPC API changes |

.claude/skills/erigon-implement-eip/SKILL.md

@@ -115,16 +115,13 @@ Run local tests using the `/erigon-test-all` skill. Analyse and fix any failures
 
 The most important tests when implementing a new EIP for the EL are the EEST spec test shards, exercised by the `cmd/evm` runners (`statetest`, `blocktest`, `enginextest`) via the Makefile targets:
 
-- `make eest-spec-statetests-stable` / `…-devnet` — state-tests against the stable/devnet EEST fixtures
-- `make eest-spec-blocktests-stable-sequential` / `…-devnet` — blockchain-tests against the stable/devnet EEST fixtures. The devnet shard always runs under `ERIGON_EXEC3_PARALLEL=true` (the in-development hardfork requires it); the `…-sequential` shard pins `ERIGON_EXEC3_PARALLEL=false`.
-- `make eest-spec-blocktests-stable-parallel` — same fixtures as `…-stable-sequential` but with `ERIGON_EXEC3_PARALLEL=true`; useful for catching parallel-only regressions on stable fixtures.
-- `make eest-spec-enginextests-stable-sequential` — engine-x tests against the stable EEST fixtures with `ERIGON_EXEC3_PARALLEL=false`.
-- `make eest-spec-enginextests-stable-parallel` — same fixtures as `…-stable-sequential` but with `ERIGON_EXEC3_PARALLEL=true`; useful for catching parallel-only regressions on engine-x stable fixtures.
-- `make eest-spec-enginextests-devnet` — engine-x tests against the devnet EEST fixtures with `ERIGON_EXEC3_PARALLEL=true`.
-- `make eest-spec-enginextests-benchmark-{1m,5m,10m,30m,60m,100m,150m}-{sequential,parallel}` — engine-x tests against the per-gas-target benchmark fixtures, with `--time` per-test stats. Each gas target has a `-sequential` (`ERIGON_EXEC3_PARALLEL=false`) and `-parallel` (`ERIGON_EXEC3_PARALLEL=true`) variant.
-- `make eest-spec-blocktests-stable-race-{pre-cancun,cancun,prague,osaka}-{sequential,parallel}` and `make eest-spec-blocktests-devnet-race-amsterdam` — race-detector variants split by fork. Each stable-race sub-shard has a `-sequential` / `-parallel` pair; the `-parallel` siblings exercise parallel exec3 under the race detector. The `blocktests-devnet-race-amsterdam` shard is always parallel (matches the non-race devnet behaviour).
-
-The shard list / failure budgets / `exec3-parallel` flags are defined in `tools/eest-spec-shards.yml` (single source of truth shared with the CI workflow and the local runner script). See `EEST_SPEC_SHARDS` / `EEST_SPEC_RACE_SHARDS` in the root `Makefile` for the partition into non-race vs race targets.
+- `make eest-spec-statetests-{stable,devnet}-{sequential,parallel}` — state tests against the stable/devnet EEST fixtures in both commitment modes.
+- `make eest-spec-blocktests-{stable,devnet}-{sequential,parallel}` — blockchain tests against the stable/devnet EEST fixtures in both commitment modes.
+- `make eest-spec-enginextests-{stable,devnet}-{sequential,parallel}` — engine-x tests against the stable/devnet EEST fixtures in both commitment modes.
+- `make eest-spec-enginextests-benchmark-{1m,5m,10m,30m,60m,100m,150m}-{sequential,parallel}` — engine-x tests against the per-gas-target benchmark fixtures, with `--time` per-test stats and both commitment modes.
+- `make eest-spec-blocktests-stable-race-{pre-cancun,cancun,prague,osaka}-{sequential,parallel}` and `make eest-spec-blocktests-devnet-race-amsterdam-{sequential,parallel}` — race-detector variants split by fork and commitment mode.
+
+The shard list, failure budgets, and `commitment-parallel` flags are defined in `tools/eest-spec-shards.yml` (single source of truth shared with the CI workflow and the local runner script). Execution remains parallel in every paired shard. See `EEST_SPEC_SHARDS` / `EEST_SPEC_RACE_SHARDS` in the root `Makefile` for the partition into non-race vs race targets.
 
 **Pitfall: stale `evm` / `evm.race` binary.** When iterating on an EIP implementation, always invoke shards via `make eest-spec-<shard>` rather than `bash tools/run-eest-spec-test.sh <shard>` — the make target lists `evm` (or `evm.race`) as a prereq and `go build` is cache-aware, so a fresh binary is built before each run. The script invoked directly **bypasses** that rebuild, so the runners exercise whatever `build/bin/evm{,.race}` happens to be on disk against current fixtures — silently inflating failures (e.g. devnet shards "regressing" by thousands of tests) or hiding regressions when comparing budgets before/after a change.
 

.claude/skills/erigon-test-all/SKILL.md

@@ -14,32 +14,40 @@ Runs the complete test suite with 60-minute timeout and coverage output. Takes ~
 To exercise the EEST suites locally, see `erigon-eest-spec` (or run a specific shard directly):
 
 ```bash
-make eest-spec-statetests-stable             # state tests vs eest_stable fixtures
-make eest-spec-blocktests-stable-sequential  # blockchain tests vs eest_stable fixtures (ERIGON_EXEC3_PARALLEL=false)
-make eest-spec-blocktests-stable-parallel    # same, but with ERIGON_EXEC3_PARALLEL=true
-make eest-spec-enginextests-stable-sequential # engine-x tests vs eest_stable (ERIGON_EXEC3_PARALLEL=false)
-make eest-spec-enginextests-stable-parallel  # same, but with ERIGON_EXEC3_PARALLEL=true
-make eest-spec-statetests-devnet             # …vs eest_devnet fixtures
-make eest-spec-blocktests-devnet             # devnet blocktests (always parallel exec3)
-make eest-spec-enginextests-devnet           # devnet engine-x tests (always parallel exec3)
-make eest-spec-statetests-legacy             # pinned legacy Cancun state-test archive
+make eest-spec-statetests-stable-{sequential,parallel}
+                                             # state tests vs eest_stable fixtures
+make eest-spec-blocktests-stable-sequential  # blockchain tests vs eest_stable fixtures (serial commitment)
+make eest-spec-blocktests-stable-parallel    # same, but with parallel commitment
+make eest-spec-enginextests-stable-sequential # engine-x tests vs eest_stable (serial commitment)
+make eest-spec-enginextests-stable-parallel  # same, but with parallel commitment
+make eest-spec-enginextests-devnet-{sequential,parallel}
+                                             # devnet engine-x tests in both commitment modes
+make eest-spec-statetests-devnet-{sequential,parallel}
+                                             # state tests vs eest_devnet fixtures
+make eest-spec-blocktests-devnet-{sequential,parallel}
+                                             # devnet blocktests in both commitment modes
+make eest-spec-statetests-legacy-{sequential,parallel}
+                                             # pinned legacy Cancun state-test archive
 make eest-spec-rlptests-legacy-race          # complete pinned legacy RLP suite
 make eest-spec-transactiontests-legacy-race  # complete pinned legacy transaction suite
 make eest-spec-difficultytests-legacy-race   # complete pinned legacy difficulty suite
 make eest-spec-blocktests-legacy-consensus-sequential
                                              # Hive consensus fixture selection;
-                                             # -parallel and -race variants too
+                                             # -parallel and
+                                             # -race-{sequential,parallel} variants too
 make eest-spec-blocktests-legacy-constantinople-sequential
                                              # Hive legacy fixture selection;
                                              # -parallel plus three race partitions:
                                              # ...-race-constantinople,
                                              # ...-race-constantinople-fix, and
-                                             # ...-race-other-forks
+                                             # ...-race-other-forks; each race
+                                             # partition has sequential/parallel variants
 make eest-spec-blocktests-legacy-cancun-sequential
                                              # Hive legacy-cancun selection;
                                              # -parallel plus six race partitions:
                                              # ...-race-{berlin,shanghai,cancun,
-                                             # london,paris,other-forks}
+                                             # london,paris,other-forks}; each race
+                                             # partition has sequential/parallel variants
 make eest-spec-enginextests-benchmark-1m-sequential
                                              # engine-x benchmark fixtures @ 1M gas target
                                              # (with per-test --time stats);
@@ -48,13 +56,14 @@ make eest-spec-enginextests-benchmark-1m-sequential
 make eest-spec-blocktests-stable-race-cancun-sequential
                                              # race-detector variant, sharded per fork:
                                              # -pre-cancun/-cancun/-prague/-osaka, plus
-                                             # eest-spec-blocktests-devnet-race-amsterdam.
-                                             # Each stable-race sub-shard has a
+                                             # eest-spec-blocktests-devnet-race-amsterdam-
+                                             # {sequential,parallel}. Each stable-race
+                                             # and devnet-race sub-shard has a
                                              # "-sequential" / "-parallel" pair
                                              # (e.g. ...-race-cancun-{sequential,parallel})
 ```
 
-The shard list / failure budgets / `exec3-parallel` flags live in `tools/eest-spec-shards.yml` (single source of truth for both this workflow and `tools/run-eest-spec-test.sh`). See `EEST_SPEC_SHARDS` / `EEST_SPEC_RACE_SHARDS` in the root `Makefile` for the partition into race vs non-race targets.
+The shard list / failure budgets / `commitment-parallel` flags live in `tools/eest-spec-shards.yml` (single source of truth for both this workflow and `tools/run-eest-spec-test.sh`). See `EEST_SPEC_SHARDS` / `EEST_SPEC_RACE_SHARDS` in the root `Makefile` for the partition into race vs non-race targets.
 
 **Pitfall: stale `evm` / `evm.race` binary.** Always invoke shards via `make eest-spec-<shard>` — the Makefile lists `evm` (or `evm.race`) as a prereq and `go build` is cache-aware, so a stale binary gets rebuilt automatically. Calling `bash tools/run-eest-spec-test.sh <shard>` directly **bypasses** the rebuild and silently exercises whatever `build/bin/evm{,.race}` happens to be on disk against current fixtures, inflating failures or hiding regressions. After pulling code, switching branches, or any time you suspect the binary is older than HEAD: `rm -f build/bin/evm build/bin/evm.race && make evm evm.race` before re-running.
 

.claude/skills/erigon-test-race/SKILL.md

@@ -16,13 +16,13 @@ Use the dedicated EEST race shards:
 ```bash
 make eest-spec-{rlptests,transactiontests,difficultytests}-legacy-race
 make eest-spec-blocktests-stable-race-{pre-cancun,cancun,prague,osaka}-{sequential,parallel}
-make eest-spec-blocktests-devnet-race-amsterdam
-make eest-spec-blocktests-legacy-consensus-race
-make eest-spec-blocktests-legacy-constantinople-race-{constantinople,constantinople-fix,other-forks}
-make eest-spec-blocktests-legacy-cancun-race-{berlin,shanghai,cancun,london,paris,other-forks}
+make eest-spec-blocktests-devnet-race-amsterdam-{sequential,parallel}
+make eest-spec-blocktests-legacy-consensus-race-{sequential,parallel}
+make eest-spec-blocktests-legacy-constantinople-race-{constantinople,constantinople-fix,other-forks}-{sequential,parallel}
+make eest-spec-blocktests-legacy-cancun-race-{berlin,shanghai,cancun,london,paris,other-forks}-{sequential,parallel}
 ```
 
-These targets build a race-instrumented `evm.race` binary automatically (see `EEST_SPEC_RACE_SHARDS` in the root `Makefile`). The stable `-sequential` / `-parallel` pairs pin both execution modes; the devnet and legacy race shards pin parallel execution to match their fixture topology. For the consensus spec suite or other Go packages, pass `GOFLAGS='-race'` or invoke `go test -race` against the relevant package directly.
+These targets build a race-instrumented `evm.race` binary automatically (see `EEST_SPEC_RACE_SHARDS` in the root `Makefile`). The stable, devnet, and legacy blocktest `-sequential` / `-parallel` pairs pin both commitment modes; execution remains parallel in every pair. For the consensus spec suite or other Go packages, pass `GOFLAGS='-race'` or invoke `go test -race` against the relevant package directly.
 
 **Pitfall: stale `evm.race` binary.** `make eest-spec-<race-shard>` lists `evm.race` as a prereq and `go build` is cache-aware, so a stale binary gets rebuilt. Calling `bash tools/run-eest-spec-test.sh <shard>` directly with `EVM_BIN=build/bin/evm.race` **bypasses** the rebuild and silently runs an old race-instrumented binary against current fixtures — race reports against code that no longer exists, missed races against code that does. After pulling or switching branches: `rm -f build/bin/evm.race && make evm.race` before re-running.
 

.github/workflows/qa-rpc-integration-tests-latest.yml

@@ -26,7 +26,7 @@ permissions:
 
 jobs:
   mainnet-rpc-integ-tests-latest:
-    name: mainnet-rpc-integ-tests-latest (${{ matrix.exec_mode }})
+    name: mainnet-rpc-integ-tests-latest (${{ matrix.commitment_mode }})
     concurrency:
       group: >-
         ${{
@@ -45,7 +45,7 @@ jobs:
       # just one after the other (~2× wall-clock).
       max-parallel: 1
       matrix:
-        exec_mode:
+        commitment_mode:
           - serial
           - parallel
     env:
@@ -56,10 +56,10 @@ jobs:
       ERIGON_ASSERT: true
       RPC_PAST_TEST_DIR: /opt/rpc-past-tests
       CHAIN: mainnet
-      # Toggle dbg.Exec3Parallel from CI without code changes. envLookup
-      # in common/dbg/dbg_env.go auto-prepends ERIGON_, so this maps to
-      # the EXEC3_PARALLEL flag declared in common/dbg/experiments.go.
-      ERIGON_EXEC3_PARALLEL: ${{ matrix.exec_mode == 'parallel' && 'true' || 'false' }}
+      # Toggle statecfg.ExperimentalParallelCommitment from CI without code
+      # changes. envLookup in common/dbg/dbg_env.go auto-prepends ERIGON_, so
+      # this maps to the COMMITMENT_PARALLEL flag read in db/state/statecfg.
+      ERIGON_COMMITMENT_PARALLEL: ${{ matrix.commitment_mode == 'parallel' && 'true' || 'false' }}
 
     steps:
       - name: Check out repository
@@ -128,7 +128,7 @@ jobs:
         if: failure() && steps.preparing_step.outcome == 'failure'
         uses: actions/upload-artifact@v7
         with:
-          name: preparing-step-logs-${{ matrix.exec_mode }}
+          name: preparing-step-logs-${{ matrix.commitment_mode }}
           path: ${{ env.ERIGON_REFERENCE_DATA_DIR }}/logs/
 
       - name: Pause the Erigon instance dedicated to db maintenance
@@ -185,7 +185,7 @@ jobs:
         if: failure() && steps.pre_test_step.outcome == 'failure'
         uses: actions/upload-artifact@v7
         with:
-          name: pre-test-logs-${{ matrix.exec_mode }}
+          name: pre-test-logs-${{ matrix.commitment_mode }}
           path: ${{ env.ERIGON_TESTBED_DATA_DIR }}/logs/
 
       - name: Run RPC Integration Tests
@@ -257,7 +257,7 @@ jobs:
         if: always() && steps.test_step.outputs.test_executed == 'true'
         uses: actions/upload-artifact@v7
         with:
-          name: test-results-${{ matrix.exec_mode }}
+          name: test-results-${{ matrix.commitment_mode }}
           path: |
             ${{ env.TEST_RESULT_DIR }}
             ${{ env.ERIGON_TESTBED_DATA_DIR }}/logs/
@@ -277,7 +277,7 @@ jobs:
             --repo erigon \
             --commit $(git rev-parse HEAD) \
             --branch "$GITHUB_REF_NAME" \
-            --test_name rpc-integration-tests-latest${{ matrix.exec_mode == 'parallel' && '-parallel' || '' }} \
+            --test_name rpc-integration-tests-latest-commitment-${{ matrix.commitment_mode }} \
             --chain $CHAIN \
             --runner "$RUNNER_NAME" \
             --db_version $db_version \