Catalog
fauziyasin-s2m4qw/erigon-ci

Run Erigon CI checks locally and/or trigger them remotely on a branch via GitHub Actions workflow_dispatch. Use this when you need to verify a branch passes all CI before or after pushing — especially for branches like bal-devnet-2 that don't auto-trigger on push/PR events.

v1.0LATEST
NewUpdated Aug 20, 2026

Erigon CI Skill

Orchestrates CI verification: run test groups locally and/or dispatch GitHub Actions on any branch.

Each test group has its own dedicated skill for drill-down on failures. Use those when a specific group fails and you need to re-run individual tests.


Local Test Groups

Group Skill Command Speed Use When
lint (inline) make lint ~1 min Before every push
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-<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
assertoor (remote only) dispatch only — Kurtosis network test

make test-all no longer covers the EEST spec tests or the cl/spectest consensus spec test — run those via their dedicated targets above when relevant.

Pitfall: prefer make eest-spec-<shard> over bash tools/run-eest-spec-test.sh <shard>. The make target lists evm / evm.race as a prereq so stale binaries get rebuilt; the script invoked directly does not, and a stale binary against current fixtures will inflate failures or hide regressions.

Lint (run first — non-deterministic, may need multiple runs)

make lint

Quick gate (before pushing a fix)

make lint && make test-short

Full gate (before marking PR ready for review)

make lint && make erigon integration && GOGC=80 make test-all

Race check (for concurrency-sensitive changes)

make lint && make test-all-race

Part 2: Remote Dispatch (trigger CI on any branch)

Use gh workflow run to trigger workflows on a branch. Required for branches not targeting main (e.g. bal-devnet-2).

Dispatch all workflows on a branch

BRANCH=$(git branch --show-current)  # or set explicitly: BRANCH="bal-devnet-2"

for wf in \
  "Unit tests" \
  "All tests" \
  "EEST spec tests" \
  "Lint" \
  "Test Hive" \
  "Kurtosis Assertoor GitHub Action" \
  "QA - RPC Integration Tests" \
  "QA - RPC Integration Tests Remote" \
  "QA - RPC Integration Tests (Gnosis)" \
  "Windows downloader tests"; do
  echo "Dispatching: $wf"
  gh workflow run "$wf" --ref $BRANCH
done

Workflow dispatch support

Workflow name (GitHub) dispatch? Local skill File
Unit tests yes erigon-test-unit ci.yml
All tests yes erigon-test-all test-all-erigon.yml
EEST spec tests yes (make eest-spec-…) test-eest-spec.yml
Lint yes (make lint) lint.yml
Test Hive yes erigon-test-hive test-hive.yml
Kurtosis Assertoor GitHub Action yes (remote only) test-kurtosis-assertoor.yml
QA - RPC Integration Tests yes erigon-test-rpc qa-rpc-integration-tests.yml
QA - RPC Integration Tests Remote yes erigon-test-rpc qa-rpc-integration-tests-remote.yml
QA - RPC Integration Tests (Gnosis) yes erigon-test-rpc qa-rpc-integration-tests-gnosis.yml
Windows downloader tests yes (remote) test-win-downloader.yml
Consensus spec no (PR-only) test-integration-caplin.yml

Note: Consensus spec has no workflow_dispatch — only fires on pull_request events targeting main/release.

Monitor runs

BRANCH=$(git branch --show-current)
gh run list --branch $BRANCH --limit 15

Check for failures:

gh run list --branch $BRANCH --limit 20 | grep -E "failure|cancelled"

Watch a specific run:

gh run watch <run-id>

Part 3: Full CI Gate (local + remote)

When preparing a devnet/feature branch for review:

  1. Local gate — fast feedback before pushing:

    make lint && make erigon integration && make test-short
    
  2. Push branch:

    git push origin <branch>
    
  3. Dispatch all remote workflows (use the loop from Part 2).

  4. Monitor until all pass:

    gh run list --branch $(git branch --show-current) --limit 15
    
  5. Race check (for concurrency-heavy changes):

    make test-all-race
    

Overall Score

77/100

Grade

B

Good

Grades are signals, not a certification. Always review a skill yourself before use.

Safety

80

Quality

75

Clarity

82

Completeness

68

Summary

Erigon CI orchestration skill that guides agents to run local test groups (lint, unit, integration, race conditions, EEST spec, consensus spec, hive, RPC) and dispatch GitHub Actions workflows remotely on any branch. The skill provides test selection tables, command patterns for local execution, workflow dispatch loops, and monitoring instructions.

Detected Capabilities

shell command executiongit operationsGitHub CLI (gh) usagemake targets invocationenvironment variable substitutionworkflow dispatch triggerlog monitoring

Trigger Keywords

Phrases that agents use to match this skill to user intent.

run erigon cidispatch github workflowsverify branch citest before pusherigon lint checkci gate check

Risk Signals

INFO

Use of `gh workflow run` to trigger CI — requires GitHub authentication and write permissions to the repository

Part 2: Remote Dispatch section
WARNING

Environment variable substitution in shell loop (`$BRANCH`, `$wf`) — no validation of branch name before dispatch

Part 2: Dispatch all workflows code block
INFO

Git command assumes current branch context (`git branch --show-current`) — will fail in detached HEAD state

Part 2 and Part 3 monitoring sections
INFO

GOGC=80 environment variable set for garbage collection tuning — non-standard JVM-style flag for Go

Local Test Groups table and Part 3 Full CI Gate

Use Cases

  • Verify a feature branch passes lint and unit tests before pushing
  • Dispatch all CI workflows on branches that don't auto-trigger (e.g., bal-devnet-2)
  • Run full test gates (lint + integration + test-all) before marking a PR ready for review
  • Check for race condition regressions in concurrency-sensitive changes
  • Monitor GitHub Actions workflow runs and watch specific CI jobs
  • Run specialized test groups (EEST spec shards, consensus spec, Hive, RPC) for targeted domains

Quality Notes

  • Clear, well-structured skill with explicit test group taxonomy (lint, unit, all, race, eest-spec, caplin spec, hive, rpc, assertoor)
  • Excellent use of tables to map test groups to skills, commands, execution time, and decision criteria
  • Helpful pitfall note about `make eest-spec-<shard>` vs. direct script invocation — shows domain knowledge
  • Good operational guidance: Part 3 sequences local gate → push → remote dispatch → monitor, which is a realistic workflow
  • Skill clearly documents that Consensus spec has no workflow_dispatch support (PR-only)
  • Some instructions are Bash-specific (BRANCH variable, for loop) — no mention of shell compatibility or cross-platform concerns
  • Error handling is not addressed: what to do if `gh workflow run` fails, or if a test group hangs/times out
  • No discussion of debugging failures — agent is directed to specialist skills but not told how to interpret test output or logs
  • Missing context on prerequisites: assumes Go toolchain, Make, GitHub CLI installed and authenticated; synced DB for RPC tests not clearly called out upfront
Model: claude-haiku-4-5-20251001Analyzed: Aug 20, 2026

Reviews

Add this skill to your library to leave a review.

No reviews yet

Be the first to share your experience.

Use fauziyasin-s2m4qw/erigon-ci in your dev environment

Command Palette

Search for a command to run...