From 18545b99867239463c80c24284c6dc2bee498474 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 16 Jan 2026 12:15:42 +0100
Subject: [PATCH 01/42] Refactor to integrate SnapshotsAdapter and streamline
 environment management

---
 cmd/main.go                                   |  28 ++--
 .../apis/snapshots/snapshots_adapter.go       | 136 ++++++++++++++++++
 .../adapters/composite/cleaner/cleaner.go     |  45 ++----
 internal/adapters/composite/composite.go      |  18 ++-
 .../adapters/composite/ensurer/ensurer.go     |  45 +++---
 internal/application/domain/stakers.go        |  41 +++---
 internal/application/ports/ports.go           |   4 +-
 internal/application/services/test_runner.go  |   8 +-
 8 files changed, 216 insertions(+), 109 deletions(-)
 create mode 100644 internal/adapters/apis/snapshots/snapshots_adapter.go

diff --git a/cmd/main.go b/cmd/main.go
index 4fbcbe6..30b392d 100644
--- a/cmd/main.go
+++ b/cmd/main.go
@@ -7,9 +7,8 @@ import (
 	"clients-test/internal/adapters/apis/docker"
 	"clients-test/internal/adapters/apis/execution"
 	"clients-test/internal/adapters/apis/ipfs"
-	"clients-test/internal/adapters/apis/tropidatooor"
+	"clients-test/internal/adapters/apis/snapshots"
 	"clients-test/internal/adapters/composite"
-	"clients-test/internal/adapters/system/mount"
 	"clients-test/internal/application/domain"
 	"clients-test/internal/application/services"
 	"clients-test/internal/logger"
@@ -33,12 +32,11 @@ func main() {
 
 	// CLI flags
 	ipfsGatewayUrl := flag.String("ipfs-gateway-url", "", "IPFS gateway URL (required)")
-	tropidatooorUrl := flag.String("tropidatooor-url", "", "Tropidatooor API URL (required)")
 	ipfsHash := flag.String("ipfs-hash", "", "IPFS hash for the test package (required)")
 	flag.Parse()
 
-	if *ipfsGatewayUrl == "" || *tropidatooorUrl == "" || *ipfsHash == "" {
-		logger.FatalWithPrefix(logPrefix, "All flags --ipfs-gateway-url, --tropidatooor-url, and --ipfs-hash are required.")
+	if *ipfsGatewayUrl == "" || *ipfsHash == "" {
+		logger.FatalWithPrefix(logPrefix, "All flags --ipfs-gateway-url and --ipfs-hash are required.")
 	}
 
 	ctx := context.Background()
@@ -56,15 +54,8 @@ func main() {
 	// print the staker config for debugging with each item on a new line
 	printStakerConfig(logPrefix, stakerConfig)
 
-	// Get mount path
-	tropidatooorAdapter := tropidatooor.NewTropidatooorAdapter(*tropidatooorUrl)
-	mountConfig, err := tropidatooorAdapter.DataRequest(ctx, stakerConfig.DataBackendName)
-	if err != nil {
-		logger.FatalWithPrefix(logPrefix, "Failed to get mount path: %v", err)
-	}
-
 	// Initialize API adapters
-	mountAdapter := mount.NewMountAdapter()
+	snapshotsAdapter := snapshots.NewSnapshotsAdapter()
 	dappManagerAdapter := dappmanager.NewDappManagerAdapter()
 	brainAdapter := brain.NewBrainAdapter(stakerConfig.Urls.BrainURL)
 	beaconchainAdapter := beaconchain.NewBeaconchainAdapter(stakerConfig.Urls.BeaconchainURL)
@@ -78,9 +69,8 @@ func main() {
 	compositeAdapter := composite.NewCompositeAdapter(
 		dappManagerAdapter,
 		brainAdapter,
-		tropidatooorAdapter,
 		dockerAdapter,
-		mountAdapter,
+		snapshotsAdapter,
 		beaconchainAdapter,
 		executionAdapter,
 		ipfsAdapter,
@@ -90,7 +80,7 @@ func main() {
 	go func() {
 		sig := <-sigs
 		logger.InfoWithPrefix(logPrefix, "Received signal: %v, running cleanup...", sig)
-		err := compositeAdapter.CleanEnvironment(ctx, stakerConfig, *mountConfig)
+		err := compositeAdapter.CleanEnvironment(ctx, stakerConfig)
 		if err != nil {
 			logger.ErrorWithPrefix(logPrefix, "Cleanup failed: %v", err)
 		} else {
@@ -103,7 +93,7 @@ func main() {
 	// Initialize and run the service
 	testRunner := services.NewTestRunner(compositeAdapter)
 
-	if err := testRunner.RunTest(ctx, *mountConfig, stakerConfig, pkg); err != nil {
+	if err := testRunner.RunTest(ctx, stakerConfig, pkg); err != nil {
 		logger.FatalWithPrefix(logPrefix, "Test run failed: %v", err)
 	}
 
@@ -120,7 +110,7 @@ func printStakerConfig(prefix string, sc domain.StakerConfig) {
   MevBoostDnpName: %s
   Network: %s
   ExecutionContainerName: %s
-  DataBackendName: %s
+  ExecutionClientShortName: %s
   Urls:
     ExecutionURL: %s
     BrainURL: %s
@@ -133,7 +123,7 @@ func printStakerConfig(prefix string, sc domain.StakerConfig) {
 		sc.MevBoostDnpName,
 		sc.Network,
 		sc.ExecutionContainerName,
-		sc.DataBackendName,
+		sc.ExecutionClientShortName,
 		sc.Urls.ExecutionURL,
 		sc.Urls.BrainURL,
 		sc.Urls.BeaconchainURL,
diff --git a/internal/adapters/apis/snapshots/snapshots_adapter.go b/internal/adapters/apis/snapshots/snapshots_adapter.go
new file mode 100644
index 0000000..af6470e
--- /dev/null
+++ b/internal/adapters/apis/snapshots/snapshots_adapter.go
@@ -0,0 +1,136 @@
+package snapshots
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"os/exec"
+	"strings"
+
+	"clients-test/internal/logger"
+)
+
+const (
+	defaultBaseURL = "https://snapshots.ethpandaops.io"
+	alpineImage    = "alpine:latest"
+)
+
+type SnapshotsAdapter struct {
+	baseURL   string
+	logPrefix string
+}
+
+func NewSnapshotsAdapter() *SnapshotsAdapter {
+	return &SnapshotsAdapter{
+		baseURL:   defaultBaseURL,
+		logPrefix: "SnapshotsAdapter",
+	}
+}
+
+func NewSnapshotsAdapterWithURL(baseURL string) *SnapshotsAdapter {
+	return &SnapshotsAdapter{
+		baseURL:   baseURL,
+		logPrefix: "SnapshotsAdapter",
+	}
+}
+
+// GetLatestBlockNumber fetches the latest available block number for a given network and client
+func (s *SnapshotsAdapter) GetLatestBlockNumber(ctx context.Context, network, client string) (string, error) {
+	url := fmt.Sprintf("%s/%s/%s/latest", s.baseURL, network, client)
+	logger.DebugWithPrefix(s.logPrefix, "Fetching latest block number from %s", url)
+
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to create request: %w", err)
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("failed to fetch latest block number: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("failed to fetch latest block number: status %s", resp.Status)
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	blockNumber := strings.TrimSpace(string(body))
+	logger.DebugWithPrefix(s.logPrefix, "Latest block number for %s/%s: %s", network, client, blockNumber)
+	return blockNumber, nil
+}
+
+// DownloadAndExtract downloads the snapshot for the given network/client and extracts it to targetPath
+// It uses a Docker container with alpine to handle the download and extraction
+func (s *SnapshotsAdapter) DownloadAndExtract(ctx context.Context, network, client, targetPath string) error {
+	logger.InfoWithPrefix(s.logPrefix, "Starting snapshot download for %s/%s to %s", network, client, targetPath)
+
+	// Get the latest block number first
+	blockNumber, err := s.GetLatestBlockNumber(ctx, network, client)
+	if err != nil {
+		return fmt.Errorf("failed to get latest block number: %w", err)
+	}
+
+	snapshotURL := fmt.Sprintf("%s/%s/%s/%s/snapshot.tar.zst", s.baseURL, network, client, blockNumber)
+	logger.InfoWithPrefix(s.logPrefix, "Downloading snapshot from %s", snapshotURL)
+
+	// Build the shell command to run inside the alpine container
+	// This installs necessary tools, downloads the snapshot, and extracts it
+	shellScript := fmt.Sprintf(`
+set -e
+apk add --no-cache wget curl tar zstd
+echo "Downloading snapshot for block number: %s"
+wget --tries=0 --retry-connrefused -O - %s | tar -I zstd -xvf - -C /data
+echo "Snapshot extraction complete"
+`, blockNumber, snapshotURL)
+
+	// Run docker command
+	// docker run --rm -v <targetPath>:/data alpine /bin/sh -c '<script>'
+	dockerArgs := []string{
+		"run", "--rm",
+		"-v", fmt.Sprintf("%s:/data", targetPath),
+		"--entrypoint", "/bin/sh",
+		alpineImage,
+		"-c", shellScript,
+	}
+
+	logger.DebugWithPrefix(s.logPrefix, "Running docker command: docker %s", strings.Join(dockerArgs, " "))
+
+	cmd := exec.CommandContext(ctx, "docker", dockerArgs...)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		logger.ErrorWithPrefix(s.logPrefix, "Failed to download/extract snapshot: %v\n%s", err, string(output))
+		return fmt.Errorf("failed to download/extract snapshot: %w\n%s", err, string(output))
+	}
+
+	logger.InfoWithPrefix(s.logPrefix, "Successfully downloaded and extracted snapshot to %s", targetPath)
+	logger.DebugWithPrefix(s.logPrefix, "Docker output:\n%s", string(output))
+	return nil
+}
+
+// GetSnapshotInfo returns information about the available snapshot for a network/client
+type SnapshotInfo struct {
+	Network     string
+	Client      string
+	BlockNumber string
+	URL         string
+}
+
+func (s *SnapshotsAdapter) GetSnapshotInfo(ctx context.Context, network, client string) (*SnapshotInfo, error) {
+	blockNumber, err := s.GetLatestBlockNumber(ctx, network, client)
+	if err != nil {
+		return nil, err
+	}
+
+	return &SnapshotInfo{
+		Network:     network,
+		Client:      client,
+		BlockNumber: blockNumber,
+		URL:         fmt.Sprintf("%s/%s/%s/%s/snapshot.tar.zst", s.baseURL, network, client, blockNumber),
+	}, nil
+}
diff --git a/internal/adapters/composite/cleaner/cleaner.go b/internal/adapters/composite/cleaner/cleaner.go
index b704e09..2a92cd7 100644
--- a/internal/adapters/composite/cleaner/cleaner.go
+++ b/internal/adapters/composite/cleaner/cleaner.go
@@ -6,52 +6,37 @@ import (
 	"clients-test/internal/adapters/apis/dappmanager"
 	"clients-test/internal/adapters/apis/docker"
 	"clients-test/internal/adapters/apis/execution"
-	"clients-test/internal/adapters/apis/tropidatooor"
-	"clients-test/internal/adapters/system/mount"
 	"clients-test/internal/application/domain"
 	"context"
 	"fmt"
 )
 
 type CleanerAdapter struct {
-	Dappmanager  *dappmanager.DappManagerAdapter
-	Execution    *execution.ExecutionAdapter
-	Brain        *brain.BrainAdapter
-	Beaconchain  *beaconchain.BeaconchainAdapter
-	Docker       *docker.DockerAdapter
-	Mount        *mount.MountAdapter
-	Tropidatooor *tropidatooor.TropidatooorAdapter
+	Dappmanager *dappmanager.DappManagerAdapter
+	Execution   *execution.ExecutionAdapter
+	Brain       *brain.BrainAdapter
+	Beaconchain *beaconchain.BeaconchainAdapter
+	Docker      *docker.DockerAdapter
 }
 
-func NewCleanerAdapter(dappmanager *dappmanager.DappManagerAdapter, execution *execution.ExecutionAdapter, brain *brain.BrainAdapter, beaconchain *beaconchain.BeaconchainAdapter, docker *docker.DockerAdapter, mount *mount.MountAdapter, tropidatooor *tropidatooor.TropidatooorAdapter) *CleanerAdapter {
+func NewCleanerAdapter(dappmanager *dappmanager.DappManagerAdapter, execution *execution.ExecutionAdapter, brain *brain.BrainAdapter, beaconchain *beaconchain.BeaconchainAdapter, docker *docker.DockerAdapter) *CleanerAdapter {
 	return &CleanerAdapter{
-		Dappmanager:  dappmanager,
-		Execution:    execution,
-		Brain:        brain,
-		Beaconchain:  beaconchain,
-		Docker:       docker,
-		Mount:        mount,
-		Tropidatooor: tropidatooor,
+		Dappmanager: dappmanager,
+		Execution:   execution,
+		Brain:       brain,
+		Beaconchain: beaconchain,
+		Docker:      docker,
 	}
 }
 
-// CleanEnvironment release the mounted volume and remove non-core packages
-func (e *CleanerAdapter) CleanEnvironment(ctx context.Context, stakerConfig domain.StakerConfig, mountConfig domain.Mount) error {
+// CleanEnvironment stops containers and removes non-core packages
+func (e *CleanerAdapter) CleanEnvironment(ctx context.Context, stakerConfig domain.StakerConfig) error {
 	var errs []error
 
-	// Attempt to stop container and release mounted volume
-	volumeTarget, err := e.Docker.StopAndGetVolumeTarget(ctx, stakerConfig.ExecutionContainerName, stakerConfig.ExecutionVolumeName)
+	// Attempt to stop container
+	_, err := e.Docker.StopAndGetVolumeTarget(ctx, stakerConfig.ExecutionContainerName, stakerConfig.ExecutionVolumeName)
 	if err != nil {
 		errs = append(errs, fmt.Errorf("stop container failed: %w", err))
-	} else {
-		if err := e.Mount.UnmountNFS(ctx, volumeTarget); err != nil {
-			errs = append(errs, fmt.Errorf("failed to unmount NFS: %w", err))
-		}
-	}
-
-	// Attempt to release data
-	if err := e.Tropidatooor.DataRelease(ctx, mountConfig.Id); err != nil {
-		errs = append(errs, fmt.Errorf("failed to release data for uniqueId %s: %w", mountConfig.Id, err))
 	}
 
 	// Attempt to remove non-core packages
diff --git a/internal/adapters/composite/composite.go b/internal/adapters/composite/composite.go
index cfb46be..9d41f5d 100644
--- a/internal/adapters/composite/composite.go
+++ b/internal/adapters/composite/composite.go
@@ -7,11 +7,10 @@ import (
 	"clients-test/internal/adapters/apis/docker"
 	"clients-test/internal/adapters/apis/execution"
 	"clients-test/internal/adapters/apis/ipfs"
-	"clients-test/internal/adapters/apis/tropidatooor"
+	"clients-test/internal/adapters/apis/snapshots"
 	"clients-test/internal/adapters/composite/cleaner"
 	"clients-test/internal/adapters/composite/ensurer"
 	"clients-test/internal/adapters/composite/executor"
-	"clients-test/internal/adapters/system/mount"
 	"clients-test/internal/application/domain"
 	"context"
 )
@@ -25,27 +24,26 @@ type CompositeAdapter struct {
 func NewCompositeAdapter(
 	dappManagerAdapter *dappmanager.DappManagerAdapter,
 	brainAdapter *brain.BrainAdapter,
-	tropidatooorAdapter *tropidatooor.TropidatooorAdapter,
 	dockerAdapter *docker.DockerAdapter,
-	mountAdapter *mount.MountAdapter,
+	snapshotsAdapter *snapshots.SnapshotsAdapter,
 	beaconchainAdapter *beaconchain.BeaconchainAdapter,
 	executionAdapter *execution.ExecutionAdapter,
 	ipfsAdapter *ipfs.IPFSAdapter,
 ) *CompositeAdapter {
-	ensurer := ensurer.NewEnsurerAdapter(dappManagerAdapter, brainAdapter, tropidatooorAdapter, dockerAdapter, mountAdapter, beaconchainAdapter, executionAdapter, ipfsAdapter)
+	ensurer := ensurer.NewEnsurerAdapter(dappManagerAdapter, brainAdapter, dockerAdapter, snapshotsAdapter, beaconchainAdapter, executionAdapter, ipfsAdapter)
 	executor := executor.NewExecutorAdapter(executionAdapter, brainAdapter, beaconchainAdapter)
-	cleaner := cleaner.NewCleanerAdapter(dappManagerAdapter, executionAdapter, brainAdapter, beaconchainAdapter, dockerAdapter, mountAdapter, tropidatooorAdapter)
+	cleaner := cleaner.NewCleanerAdapter(dappManagerAdapter, executionAdapter, brainAdapter, beaconchainAdapter, dockerAdapter)
 	return &CompositeAdapter{ensurer, executor, cleaner}
 }
 
-func (t *CompositeAdapter) EnsureEnvironment(ctx context.Context, mountConfig domain.Mount, stakerConfig domain.StakerConfig, pkg domain.Pkg) error {
-	return t.ensurer.EnsureEnvironment(ctx, mountConfig, stakerConfig, pkg)
+func (t *CompositeAdapter) EnsureEnvironment(ctx context.Context, stakerConfig domain.StakerConfig, pkg domain.Pkg) error {
+	return t.ensurer.EnsureEnvironment(ctx, stakerConfig, pkg)
 }
 
 func (t *CompositeAdapter) ExecuteTest(ctx context.Context) error {
 	return t.executor.ExecuteTest(ctx)
 }
 
-func (t *CompositeAdapter) CleanEnvironment(ctx context.Context, stakerConfig domain.StakerConfig, mountConfig domain.Mount) error {
-	return t.cleaner.CleanEnvironment(ctx, stakerConfig, mountConfig)
+func (t *CompositeAdapter) CleanEnvironment(ctx context.Context, stakerConfig domain.StakerConfig) error {
+	return t.cleaner.CleanEnvironment(ctx, stakerConfig)
 }
diff --git a/internal/adapters/composite/ensurer/ensurer.go b/internal/adapters/composite/ensurer/ensurer.go
index aadf4f0..fdc46b4 100644
--- a/internal/adapters/composite/ensurer/ensurer.go
+++ b/internal/adapters/composite/ensurer/ensurer.go
@@ -10,38 +10,35 @@ import (
 	"clients-test/internal/adapters/apis/docker"
 	"clients-test/internal/adapters/apis/execution"
 	"clients-test/internal/adapters/apis/ipfs"
-	"clients-test/internal/adapters/apis/tropidatooor"
-	"clients-test/internal/adapters/system/mount"
+	"clients-test/internal/adapters/apis/snapshots"
 	"clients-test/internal/application/domain"
 )
 
 type EnsurerAdapter struct {
-	DappManager  *dappmanager.DappManagerAdapter
-	Brain        *brain.BrainAdapter
-	Tropidatooor *tropidatooor.TropidatooorAdapter
-	Docker       *docker.DockerAdapter
-	Mount        *mount.MountAdapter
-	Beaconchain  *beaconchain.BeaconchainAdapter
-	Execution    *execution.ExecutionAdapter
-	Ipfs         *ipfs.IPFSAdapter
+	DappManager *dappmanager.DappManagerAdapter
+	Brain       *brain.BrainAdapter
+	Docker      *docker.DockerAdapter
+	Snapshots   *snapshots.SnapshotsAdapter
+	Beaconchain *beaconchain.BeaconchainAdapter
+	Execution   *execution.ExecutionAdapter
+	Ipfs        *ipfs.IPFSAdapter
 }
 
-func NewEnsurerAdapter(dappManager *dappmanager.DappManagerAdapter, brain *brain.BrainAdapter, tropidatooor *tropidatooor.TropidatooorAdapter, docker *docker.DockerAdapter, mountAdapter *mount.MountAdapter, beaconchain *beaconchain.BeaconchainAdapter, execution *execution.ExecutionAdapter, ipfs *ipfs.IPFSAdapter) *EnsurerAdapter {
+func NewEnsurerAdapter(dappManager *dappmanager.DappManagerAdapter, brain *brain.BrainAdapter, docker *docker.DockerAdapter, snapshotsAdapter *snapshots.SnapshotsAdapter, beaconchain *beaconchain.BeaconchainAdapter, execution *execution.ExecutionAdapter, ipfs *ipfs.IPFSAdapter) *EnsurerAdapter {
 	return &EnsurerAdapter{
-		DappManager:  dappManager,
-		Brain:        brain,
-		Tropidatooor: tropidatooor,
-		Docker:       docker,
-		Mount:        mountAdapter,
-		Beaconchain:  beaconchain,
-		Execution:    execution,
-		Ipfs:         ipfs,
+		DappManager: dappManager,
+		Brain:       brain,
+		Docker:      docker,
+		Snapshots:   snapshotsAdapter,
+		Beaconchain: beaconchain,
+		Execution:   execution,
+		Ipfs:        ipfs,
 	}
 }
 
 // EnsureEnvironment validates the environment and prepares it for testing.
-// It sets the staker config, installs the package, stops the container, mounts the NFS, and starts the container.
-func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, mountConfig domain.Mount, stakerConfig domain.StakerConfig, pkg domain.Pkg) error {
+// It sets the staker config, installs the package, stops the container, downloads the snapshot, and starts the container.
+func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig domain.StakerConfig, pkg domain.Pkg) error {
 	if err := e.DappManager.SetStakerConfig(ctx, stakerConfig); err != nil {
 		return fmt.Errorf("failed to set staker config for DNP: %w", err)
 	}
@@ -53,9 +50,11 @@ func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, mountConfig doma
 		return fmt.Errorf("failed to stop container and get volume: %w", err)
 	}
 
-	if err := e.Mount.MountNFS(ctx, mountConfig.Path, volumeTarget); err != nil {
-		return fmt.Errorf("failed to mount NFS: %w", err)
+	// Download and extract snapshot directly into the volume
+	if err := e.Snapshots.DownloadAndExtract(ctx, stakerConfig.Network, stakerConfig.ExecutionClientShortName, volumeTarget); err != nil {
+		return fmt.Errorf("failed to download and extract snapshot: %w", err)
 	}
+
 	if err := e.Docker.StartContainer(ctx, stakerConfig.ExecutionContainerName); err != nil {
 		return fmt.Errorf("failed to start container: %w", err)
 	}
diff --git a/internal/application/domain/stakers.go b/internal/application/domain/stakers.go
index 29b4206..b08313e 100644
--- a/internal/application/domain/stakers.go
+++ b/internal/application/domain/stakers.go
@@ -8,16 +8,16 @@ import (
 )
 
 type StakerConfig struct {
-	ExecutionDnpName       string   `json:"executionDnpName"`
-	ConsensusDnpName       string   `json:"consensusDnpName"`
-	Web3SignerDnpName      string   `json:"web3signerDnpName"`
-	MevBoostDnpName        string   `json:"mevBoostDnpName"`
-	Relays                 []string `json:"relays,omitempty"` // Optional, can be empty
-	Network                string   `json:"network"`          // The network this config is for (e.g., mainnet, gnosis, hoodi, lukso)
-	Urls                   Urls
-	ExecutionContainerName string // The name of the container to mount the NFS volume to
-	ExecutionVolumeName    string // The name of the volume to mount for execution client data
-	DataBackendName        string // The name of the backend to use for data requests
+	ExecutionDnpName         string   `json:"executionDnpName"`
+	ConsensusDnpName         string   `json:"consensusDnpName"`
+	Web3SignerDnpName        string   `json:"web3signerDnpName"`
+	MevBoostDnpName          string   `json:"mevBoostDnpName"`
+	Relays                   []string `json:"relays,omitempty"` // Optional, can be empty
+	Network                  string   `json:"network"`          // The network this config is for (e.g., mainnet, gnosis, hoodi, lukso)
+	Urls                     Urls
+	ExecutionContainerName   string // The name of the container to mount the NFS volume to
+	ExecutionVolumeName      string // The name of the volume to mount for execution client data
+	ExecutionClientShortName string // Short name of the execution client (e.g., geth, nethermind, reth)
 }
 
 type Urls struct {
@@ -97,19 +97,18 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 			break
 		}
 	}
-	dataBackend := execShort + "-" + network
 
 	return StakerConfig{
-		ExecutionDnpName:       exec,
-		ConsensusDnpName:       cons,
-		Web3SignerDnpName:      web3signer,
-		MevBoostDnpName:        mevboost,
-		Relays:                 relays,
-		Network:                network,
-		Urls:                   urls,
-		ExecutionContainerName: executionContainerName(pkg.ServiceName, pkg.DnpName),
-		ExecutionVolumeName:    composeVolumeName(pkg.DnpName, pkg.ComposeVolumeName),
-		DataBackendName:        dataBackend,
+		ExecutionDnpName:         exec,
+		ConsensusDnpName:         cons,
+		Web3SignerDnpName:        web3signer,
+		MevBoostDnpName:          mevboost,
+		Relays:                   relays,
+		Network:                  network,
+		Urls:                     urls,
+		ExecutionContainerName:   executionContainerName(pkg.ServiceName, pkg.DnpName),
+		ExecutionVolumeName:      composeVolumeName(pkg.DnpName, pkg.ComposeVolumeName),
+		ExecutionClientShortName: execShort,
 	}
 }
 
diff --git a/internal/application/ports/ports.go b/internal/application/ports/ports.go
index 23a5d2b..9da1d9f 100644
--- a/internal/application/ports/ports.go
+++ b/internal/application/ports/ports.go
@@ -6,7 +6,7 @@ import (
 )
 
 type TestRunner interface {
-	EnsureEnvironment(ctx context.Context, mountConfig domain.Mount, stakerConfig domain.StakerConfig, pkg domain.Pkg) error
+	EnsureEnvironment(ctx context.Context, stakerConfig domain.StakerConfig, pkg domain.Pkg) error
 	ExecuteTest(ctx context.Context) error
-	CleanEnvironment(context.Context, domain.StakerConfig, domain.Mount) error
+	CleanEnvironment(context.Context, domain.StakerConfig) error
 }
diff --git a/internal/application/services/test_runner.go b/internal/application/services/test_runner.go
index 13b1339..0961ca8 100644
--- a/internal/application/services/test_runner.go
+++ b/internal/application/services/test_runner.go
@@ -17,9 +17,9 @@ func NewTestRunner(runner ports.TestRunner) *TestRunnerService {
 
 // RunTest wires up the three steps in sequence.
 // It ensures the environment, executes the test, and cleans up.
-func (s *TestRunnerService) RunTest(ctx context.Context, mountConfig domain.Mount, stakerConfig domain.StakerConfig, pkg domain.Pkg) error {
+func (s *TestRunnerService) RunTest(ctx context.Context, stakerConfig domain.StakerConfig, pkg domain.Pkg) error {
 	// 1) ensure environment
-	if err := s.Runner.EnsureEnvironment(ctx, mountConfig, stakerConfig, pkg); err != nil {
+	if err := s.Runner.EnsureEnvironment(ctx, stakerConfig, pkg); err != nil {
 		return fmt.Errorf("setup failed: %w", err)
 	}
 
@@ -27,14 +27,14 @@ func (s *TestRunnerService) RunTest(ctx context.Context, mountConfig domain.Moun
 	execErr := s.Runner.ExecuteTest(ctx)
 	if execErr != nil {
 		// even on test failure we want cleanup
-		if cleanupErr := s.Runner.CleanEnvironment(ctx, stakerConfig, mountConfig); cleanupErr != nil {
+		if cleanupErr := s.Runner.CleanEnvironment(ctx, stakerConfig); cleanupErr != nil {
 			return fmt.Errorf("test failed: %v; cleanup also failed: %w", execErr, cleanupErr)
 		}
 		return fmt.Errorf("test failed: %w", execErr)
 	}
 
 	// 3) cleanup
-	if err := s.Runner.CleanEnvironment(ctx, stakerConfig, mountConfig); err != nil {
+	if err := s.Runner.CleanEnvironment(ctx, stakerConfig); err != nil {
 		return fmt.Errorf("cleanup failed: %w", err)
 	}
 

From b5d4ad8e34539896b80901cdb303c1ddea56a7e9 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 10:27:07 +0100
Subject: [PATCH 02/42] allow setting envs instead of flags

---
 cmd/main.go | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/cmd/main.go b/cmd/main.go
index 30b392d..522f83a 100644
--- a/cmd/main.go
+++ b/cmd/main.go
@@ -30,13 +30,21 @@ func main() {
 	sigs := make(chan os.Signal, 1)
 	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
 
-	// CLI flags
-	ipfsGatewayUrl := flag.String("ipfs-gateway-url", "", "IPFS gateway URL (required)")
-	ipfsHash := flag.String("ipfs-hash", "", "IPFS hash for the test package (required)")
+	// CLI flags (fallback to environment variables if not set)
+	ipfsGatewayUrl := flag.String("ipfs-gateway-url", "", "IPFS gateway URL (required, or set IPFS_GATEWAY_URL env)")
+	ipfsHash := flag.String("ipfs-hash", "", "IPFS hash for the test package (required, or set IPFS_HASH env)")
 	flag.Parse()
 
+	// Fallback to environment variables if flags are not set
+	if *ipfsGatewayUrl == "" {
+		*ipfsGatewayUrl = os.Getenv("IPFS_GATEWAY_URL")
+	}
+	if *ipfsHash == "" {
+		*ipfsHash = os.Getenv("IPFS_HASH")
+	}
+
 	if *ipfsGatewayUrl == "" || *ipfsHash == "" {
-		logger.FatalWithPrefix(logPrefix, "All flags --ipfs-gateway-url and --ipfs-hash are required.")
+		logger.FatalWithPrefix(logPrefix, "IPFS gateway URL and hash are required. Set via --ipfs-gateway-url/--ipfs-hash flags or IPFS_GATEWAY_URL/IPFS_HASH environment variables.")
 	}
 
 	ctx := context.Background()

From 7848f74dcbdb623a84c058ec9b7e19a1d934ea9c Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 10:27:21 +0100
Subject: [PATCH 03/42] implemnet docker

---
 Dockerfile         | 43 ++++++++++++++++---------------------------
 docker-compose.yml | 19 +++++++++++++++++++
 2 files changed, 35 insertions(+), 27 deletions(-)
 create mode 100644 docker-compose.yml

diff --git a/Dockerfile b/Dockerfile
index 6c07cee..6da1b6f 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,41 +1,30 @@
-# ===== STAGE 1: Build Stage =====
-FROM golang:1.24 AS builder
+# Build stage
+FROM golang:1.24-alpine AS builder
 
-# Set environment variables
-ENV CGO_ENABLED=1 \
-  GOOS=linux \
-  GOARCH=amd64
-
-# Install necessary build dependencies
-RUN apt-get update && apt-get install -y gcc libc-dev
-
-# Set working directory inside the container
 WORKDIR /app
 
-# Copy Go modules manifests first (for better caching)
+# Install git for fetching dependencies
+RUN apk add --no-cache git
+
+# Copy go mod files first for better caching
 COPY go.mod go.sum ./
 RUN go mod download
 
-# Copy the entire source code
+# Copy source code
 COPY . .
 
-# Build the Go binary
-RUN go build -o /app/server ./cmd/main.go
-
-# ===== STAGE 2: Runtime Stage =====
-FROM debian:stable-slim
+# Build the application
+RUN CGO_ENABLED=0 GOOS=linux go build -o /app/staker-test-util ./cmd/main.go
 
-# Install required runtime dependencies (for CGO)
-RUN apt-get update && apt-get install -y ca-certificates libc6 && rm -rf /var/lib/apt/lists/*
+# Final stage
+FROM alpine:latest
 
-# Set working directory
 WORKDIR /app
 
-# Copy the compiled binary from builder stage
-COPY --from=builder /app/server .
+# Install ca-certificates for HTTPS requests and docker-cli for snapshot operations
+RUN apk add --no-cache ca-certificates docker-cli
 
-# Expose the application port
-EXPOSE 8080
+# Copy binary from builder
+COPY --from=builder /app/staker-test-util /app/staker-test-util
 
-# Run the application
-CMD ["./server"]
+ENTRYPOINT ["/app/staker-test-util"]
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000..1e610eb
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,19 @@
+services:
+  staker-test-util:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: staker-test-util
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+    environment:
+      - LOG_LEVEL=DEBUG
+      - IPFS_GATEWAY_URL=http://ipfs.dappnode:8080
+      - IPFS_HASH=QmSfPFSauovbMzEcvf2a2csoHtfqpViShwEYpuX3fPR8zv
+    # command: ["--ipfs-gateway-url", "${IPFS_GATEWAY_URL}", "--ipfs-hash", "${IPFS_HASH}"]
+    networks:
+      - dncore_network
+
+networks:
+  dncore_network:
+    external: true

From 88b007a2d31cbff3975b58bcd324236ca5b15351 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 10:43:15 +0100
Subject: [PATCH 04/42] implement time check

---
 internal/adapters/apis/snapshots/snapshots_adapter.go | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/internal/adapters/apis/snapshots/snapshots_adapter.go b/internal/adapters/apis/snapshots/snapshots_adapter.go
index af6470e..7345a0c 100644
--- a/internal/adapters/apis/snapshots/snapshots_adapter.go
+++ b/internal/adapters/apis/snapshots/snapshots_adapter.go
@@ -7,6 +7,7 @@ import (
 	"net/http"
 	"os/exec"
 	"strings"
+	"time"
 
 	"clients-test/internal/logger"
 )
@@ -101,14 +102,16 @@ echo "Snapshot extraction complete"
 
 	logger.DebugWithPrefix(s.logPrefix, "Running docker command: docker %s", strings.Join(dockerArgs, " "))
 
+	start := time.Now()
 	cmd := exec.CommandContext(ctx, "docker", dockerArgs...)
 	output, err := cmd.CombinedOutput()
 	if err != nil {
 		logger.ErrorWithPrefix(s.logPrefix, "Failed to download/extract snapshot: %v\n%s", err, string(output))
 		return fmt.Errorf("failed to download/extract snapshot: %w\n%s", err, string(output))
 	}
+	elapsed := time.Since(start)
 
-	logger.InfoWithPrefix(s.logPrefix, "Successfully downloaded and extracted snapshot to %s", targetPath)
+	logger.InfoWithPrefix(s.logPrefix, "Successfully downloaded and extracted snapshot to %s in %s", targetPath, elapsed)
 	logger.DebugWithPrefix(s.logPrefix, "Docker output:\n%s", string(output))
 	return nil
 }

From a78156c00a79e8f41d7395eb562bde543014f80a Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 10:43:27 +0100
Subject: [PATCH 05/42] use same dappmanager url always

---
 internal/application/domain/stakers.go | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/internal/application/domain/stakers.go b/internal/application/domain/stakers.go
index b08313e..0bd4083 100644
--- a/internal/application/domain/stakers.go
+++ b/internal/application/domain/stakers.go
@@ -27,6 +27,8 @@ type Urls struct {
 	DappmanagerURL string
 }
 
+const dappmanagerURL = "http://dappmanager.dappnode:7000"
+
 func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 	network := getNetworkFromDnpName(pkg.DnpName)
 	var execClients, consClients []string
@@ -45,7 +47,7 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 			ExecutionURL:   "http://execution.gnosis.dncore.dappnode:8545",
 			BrainURL:       "http://brain.web3signer-gnosis.dappnode:5000",
 			BeaconchainURL: "http://beacon-chain.gnosis.dncore.dappnode:3500",
-			DappmanagerURL: "http://dappmanager.dappnode:7000",
+			DappmanagerURL: dappmanagerURL,
 		}
 	case "mainnet":
 		execClients = []string{"nethermind.public.dappnode.eth", "geth.dnp.dappnode.eth", "erigon.dnp.dappnode.eth", "reth.dnp.dappnode.eth", "besu.public.dappnode.eth"}
@@ -57,7 +59,7 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 			ExecutionURL:   "http://execution.mainnet.dncore.dappnode:8545",
 			BrainURL:       "http://brain.web3signer.dappnode:5000",
 			BeaconchainURL: "http://beacon-chain.mainnet.dncore.dappnode:3500",
-			DappmanagerURL: "http://dappmanager.dappnode:7000",
+			DappmanagerURL: dappmanagerURL,
 		}
 	case "lukso":
 		execClients = []string{"lukso-geth.dnp.dappnode.eth"}
@@ -69,7 +71,7 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 			ExecutionURL:   "http://execution.lukso.dncore.dappnode:8545",
 			BrainURL:       "http://brain.web3signer-lukso.dappnode:5000",
 			BeaconchainURL: "http://beacon-chain.lukso.dncore.dappnode:3500",
-			DappmanagerURL: "http://dappmanager.dappnode:7000",
+			DappmanagerURL: dappmanagerURL,
 		}
 	case "hoodi":
 		execClients = []string{"hoodi-reth.dnp.dappnode.eth", "hoodi-geth.dnp.dappnode.eth", "hoodi-besu.dnp.dappnode.eth", "hoodi-erigon.dnp.dappnode.eth", "hoodi-nethermind.dnp.dappnode.eth"}
@@ -81,7 +83,7 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 			ExecutionURL:   "http://execution.hoodi.dncore.dappnode:8545",
 			BrainURL:       "http://brain.web3signer-hoodi.dappnode:5000",
 			BeaconchainURL: "http://beacon-chain.hoodi.dncore.dappnode:3500",
-			DappmanagerURL: "http://dappmanager.dappnode:8080",
+			DappmanagerURL: dappmanagerURL,
 		}
 	}
 

From 4261a894219f4e72516913d2a524147db0f0996a Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 16:10:34 +0100
Subject: [PATCH 06/42] implement github adapter

---
 README.md                                     | 125 ++++++++-
 cmd/main.go                                   |  39 ++-
 docker-compose.yml                            |   6 +
 .../adapters/apis/docker/docker_adapter.go    | 137 +++++++++
 .../adapters/apis/github/github_adapter.go    | 249 +++++++++++++++++
 .../adapters/composite/cleaner/cleaner.go     |  16 +-
 internal/adapters/composite/composite.go      |  81 +++++-
 .../adapters/composite/ensurer/ensurer.go     |  60 +++-
 .../adapters/composite/executor/executor.go   |  41 ++-
 internal/application/domain/report.go         | 263 ++++++++++++++++++
 internal/application/domain/stakers.go        |  14 +-
 internal/application/ports/ports.go           |   3 +-
 internal/application/services/test_runner.go  |   9 +-
 internal/config/config.go                     |  86 ++++++
 14 files changed, 1075 insertions(+), 54 deletions(-)
 create mode 100644 internal/adapters/apis/github/github_adapter.go
 create mode 100644 internal/application/domain/report.go
 create mode 100644 internal/config/config.go

diff --git a/README.md b/README.md
index 650afc2..4ea3181 100644
--- a/README.md
+++ b/README.md
@@ -1,9 +1,126 @@
 # Dappnode ethereum clients test SDK
 
+A testing utility for Dappnode staker packages that runs in GitHub self-hosted runners. It can execute tests either manually or automatically on GitHub pull requests, with automatic PR commenting for test reports.
+
+## Features
+
+- **Automated Testing**: Tests staker packages (execution, consensus, web3signer, etc.)
+- **GitHub Integration**: Automatically comments test reports on pull requests
+- **Timing Measurements**: Measures duration of all test phases (setup, execution, cleanup)
+- **Container Log Collection**: Captures error logs from all relevant containers during test execution
+- **Detailed Reports**: Generates comprehensive reports with clients used, timings, and error logs
+
+## Configuration
+
+### Required Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `IPFS_GATEWAY_URL` | IPFS gateway URL for fetching packages |
+| `IPFS_HASH` | IPFS hash of the test package |
+
+### GitHub Integration (Optional)
+
+These environment variables enable automatic PR commenting. When running in GitHub Actions, most of these are set automatically.
+
+| Variable | Description | GitHub Actions Auto-set |
+|----------|-------------|------------------------|
+| `GITHUB_TOKEN` | GitHub token with PR comment permissions | ✅ (via `${{ secrets.GITHUB_TOKEN }}`) |
+| `GITHUB_REPOSITORY` | Repository in `owner/repo` format | ✅ |
+| `GITHUB_PR_NUMBER` | Pull request number | ❌ (extract from event) |
+| `GITHUB_RUN_ID` | GitHub Actions run ID (for linking to logs) | ✅ |
+| `GITHUB_SERVER_URL` | GitHub server URL (default: `https://github.com`) | ✅ |
+
+### CLI Flags
+
+All environment variables can also be set via CLI flags:
+
+```bash
+./staker-test-util \
+  --ipfs-gateway-url="http://ipfs.dappnode:8080" \
+  --ipfs-hash="QmSfPFSauovbMzEcvf2a2csoHtfqpViShwEYpuX3fPR8zv" \
+  --github-token="ghp_xxxx" \
+  --github-repository="dappnode/staker-test-util" \
+  --github-pr-number="123" \
+  --github-run-id="12345678" \
+  --github-server-url="https://github.com"
+```
+
+## GitHub Actions Workflow Example
+
+```yaml
+name: Staker Test
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+jobs:
+  test:
+    runs-on: self-hosted
+    steps:
+      - name: Run Staker Test
+        env:
+          IPFS_GATEWAY_URL: http://ipfs.dappnode:8080
+          IPFS_HASH: ${{ github.event.inputs.ipfs_hash }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          GITHUB_PR_NUMBER: ${{ github.event.pull_request.number }}
+          GITHUB_RUN_ID: ${{ github.run_id }}
+          GITHUB_SERVER_URL: ${{ github.server_url }}
+        run: |
+          docker-compose up --build
+```
+
+## Test Report
+
+The test report includes:
+
+### Clients Used
+- Execution client DNP name
+- Consensus client DNP name
+- Web3Signer DNP name
+- MEV Boost DNP name
+- Network
+
+### Timing Measurements
+
+#### Environment Setup
+- SetStakerConfig
+- PackageInstall
+- StopAndGetVolumeTarget
+- DownloadAndExtractSnapshot
+- StartContainer
+
+#### Test Execution
+- WaitForBeaconchainSync
+- WaitForExecutionSync
+- WaitForValidatorLiveness
+
+### Container Error Logs
+Captures error lines from:
+- Brain container
+- Signer container
+- Beaconchain container
+- Validator container
+- Execution container
+
+> Shows up to 3 error lines per container. Full logs available in CI.
+
+## Docker Compose
+
+```bash
+# With GitHub integration
+GITHUB_TOKEN=ghp_xxxx \
+GITHUB_REPOSITORY=dappnode/staker-test-util \
+GITHUB_PR_NUMBER=123 \
+docker-compose up --build
+```
+
 ## TODO's
-- [ ] Collect logs from containers and create a report
-- [ ] Add to the report the clients used
-- [x] Add to ensurer wait for consensus sync.
+- [x] Implement a github adapter to interact with issues and PRs so we can automate report creation as well as the testing process.
+- [x] Measure the time it takes every process in the test and add it to the report
+- [x] Collect logs from containers and create a report
+- [x] Add to the report the clients used
 - [ ] Consider adding to report beaconcha validator url
-- [x] Add a handle signal to stop the test gracefully: release mount data if any, remove packages if any installed. -> run cleaner
 - [ ] Consider setting keystore and password through github secrets.
\ No newline at end of file
diff --git a/cmd/main.go b/cmd/main.go
index 522f83a..9a9561b 100644
--- a/cmd/main.go
+++ b/cmd/main.go
@@ -6,14 +6,15 @@ import (
 	"clients-test/internal/adapters/apis/dappmanager"
 	"clients-test/internal/adapters/apis/docker"
 	"clients-test/internal/adapters/apis/execution"
+	"clients-test/internal/adapters/apis/github"
 	"clients-test/internal/adapters/apis/ipfs"
 	"clients-test/internal/adapters/apis/snapshots"
 	"clients-test/internal/adapters/composite"
 	"clients-test/internal/application/domain"
 	"clients-test/internal/application/services"
+	"clients-test/internal/config"
 	"clients-test/internal/logger"
 	"context"
-	"flag"
 	"fmt"
 	"os"
 	"os/signal"
@@ -25,33 +26,20 @@ var logPrefix = "MAIN"
 func main() {
 	logger.InfoWithPrefix(logPrefix, "Starting Notifications service")
 
+	// Parse and validate configuration
+	cfg := config.ParseConfig()
+	cfg.Validate()
+
 	// Set up Ctrl+C (SIGINT) handler to call composite cleaner
 	cleanupDone := make(chan struct{})
 	sigs := make(chan os.Signal, 1)
 	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
 
-	// CLI flags (fallback to environment variables if not set)
-	ipfsGatewayUrl := flag.String("ipfs-gateway-url", "", "IPFS gateway URL (required, or set IPFS_GATEWAY_URL env)")
-	ipfsHash := flag.String("ipfs-hash", "", "IPFS hash for the test package (required, or set IPFS_HASH env)")
-	flag.Parse()
-
-	// Fallback to environment variables if flags are not set
-	if *ipfsGatewayUrl == "" {
-		*ipfsGatewayUrl = os.Getenv("IPFS_GATEWAY_URL")
-	}
-	if *ipfsHash == "" {
-		*ipfsHash = os.Getenv("IPFS_HASH")
-	}
-
-	if *ipfsGatewayUrl == "" || *ipfsHash == "" {
-		logger.FatalWithPrefix(logPrefix, "IPFS gateway URL and hash are required. Set via --ipfs-gateway-url/--ipfs-hash flags or IPFS_GATEWAY_URL/IPFS_HASH environment variables.")
-	}
-
 	ctx := context.Background()
 
 	// Fetch dnpName from ipfs hash
-	ipfsAdapter := ipfs.NewIPFSAdapter(ipfsGatewayUrl)
-	pkg, err := ipfsAdapter.GetDnpNameAndServiceName(ctx, *ipfsHash)
+	ipfsAdapter := ipfs.NewIPFSAdapter(&cfg.IPFSGatewayURL)
+	pkg, err := ipfsAdapter.GetDnpNameAndServiceName(ctx, cfg.IPFSHash)
 	if err != nil {
 		logger.FatalWithPrefix(logPrefix, "Failed to get dnpName from IPFS hash: %v", err)
 	}
@@ -73,6 +61,16 @@ func main() {
 		logger.FatalWithPrefix(logPrefix, "Failed to init DockerAdapter: %v", err)
 	}
 
+	// Initialize GitHub adapter for PR commenting
+	githubAdapter := github.NewGitHubAdapter(cfg.GitHub)
+
+	// Log GitHub configuration status
+	if githubAdapter.IsEnabled() {
+		logger.InfoWithPrefix(logPrefix, "GitHub integration enabled - will comment on PR #%d", cfg.GitHub.PRNumber)
+	} else {
+		logger.InfoWithPrefix(logPrefix, "GitHub integration not enabled (missing token, repository, or PR number)")
+	}
+
 	// Initialize the unified test adapter (now also initializes composites internally)
 	compositeAdapter := composite.NewCompositeAdapter(
 		dappManagerAdapter,
@@ -82,6 +80,7 @@ func main() {
 		beaconchainAdapter,
 		executionAdapter,
 		ipfsAdapter,
+		githubAdapter,
 	)
 
 	// Ctrl+C handler: call CleanEnvironment on composite
diff --git a/docker-compose.yml b/docker-compose.yml
index 1e610eb..990c855 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -10,6 +10,12 @@ services:
       - LOG_LEVEL=DEBUG
       - IPFS_GATEWAY_URL=http://ipfs.dappnode:8080
       - IPFS_HASH=QmSfPFSauovbMzEcvf2a2csoHtfqpViShwEYpuX3fPR8zv
+      # GitHub integration (optional - for PR commenting)
+      - GITHUB_TOKEN=${GITHUB_TOKEN:-}
+      - GITHUB_REPOSITORY=${GITHUB_REPOSITORY:-}
+      - GITHUB_PR_NUMBER=${GITHUB_PR_NUMBER:-}
+      - GITHUB_RUN_ID=${GITHUB_RUN_ID:-}
+      - GITHUB_SERVER_URL=${GITHUB_SERVER_URL:-https://github.com}
     # command: ["--ipfs-gateway-url", "${IPFS_GATEWAY_URL}", "--ipfs-hash", "${IPFS_HASH}"]
     networks:
       - dncore_network
diff --git a/internal/adapters/apis/docker/docker_adapter.go b/internal/adapters/apis/docker/docker_adapter.go
index b437e44..0ffa605 100644
--- a/internal/adapters/apis/docker/docker_adapter.go
+++ b/internal/adapters/apis/docker/docker_adapter.go
@@ -1,8 +1,12 @@
 package docker
 
 import (
+	"bufio"
 	"context"
 	"fmt"
+	"io"
+	"strings"
+	"time"
 
 	"clients-test/internal/logger"
 
@@ -67,3 +71,136 @@ func (d *DockerAdapter) StartContainer(ctx context.Context, containerName string
 	logger.DebugWithPrefix(d.logPrefix, "StartContainer: started container %s", containerName)
 	return nil
 }
+
+// GetContainerErrorLogs retrieves error logs from a container within a time range
+// Returns up to maxLines error lines (lines containing "error", "err", "fatal", "panic", etc.)
+func (d *DockerAdapter) GetContainerErrorLogs(ctx context.Context, containerName string, since, until time.Time, maxLines int) ([]string, error) {
+	logger.DebugWithPrefix(d.logPrefix, "GetContainerErrorLogs: fetching logs for container %s from %v to %v", containerName, since, until)
+
+	// Check if container exists first
+	_, err := d.cli.ContainerInspect(ctx, containerName)
+	if err != nil {
+		logger.WarnWithPrefix(d.logPrefix, "GetContainerErrorLogs: container %s not found or not accessible: %v", containerName, err)
+		return nil, nil // Return nil instead of error - container might not exist yet
+	}
+
+	options := container.LogsOptions{
+		ShowStdout: true,
+		ShowStderr: true,
+		Since:      since.Format(time.RFC3339),
+		Until:      until.Format(time.RFC3339),
+		Timestamps: true,
+	}
+
+	reader, err := d.cli.ContainerLogs(ctx, containerName, options)
+	if err != nil {
+		logger.WarnWithPrefix(d.logPrefix, "GetContainerErrorLogs: failed to get logs for %s: %v", containerName, err)
+		return nil, nil // Return nil instead of error - might be transient
+	}
+	defer reader.Close()
+
+	errorLines := make([]string, 0)
+	errorKeywords := []string{"error", "err:", "fatal", "panic", "exception", "failed", "failure"}
+
+	// Docker logs have an 8-byte header for multiplexed streams
+	// We need to handle this properly
+	buf := make([]byte, 8)
+	for {
+		// Read the header
+		_, err := io.ReadFull(reader, buf)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			// Try reading as plain text if header read fails
+			break
+		}
+
+		// Get the size of the log line from header bytes 4-7
+		size := int(buf[4])<<24 | int(buf[5])<<16 | int(buf[6])<<8 | int(buf[7])
+
+		// Read the actual log line
+		line := make([]byte, size)
+		_, err = io.ReadFull(reader, line)
+		if err != nil {
+			break
+		}
+
+		lineStr := strings.TrimSpace(string(line))
+		if lineStr == "" {
+			continue
+		}
+
+		// Check if line contains error keywords (case-insensitive)
+		lineLower := strings.ToLower(lineStr)
+		for _, keyword := range errorKeywords {
+			if strings.Contains(lineLower, keyword) {
+				// Truncate very long lines
+				if len(lineStr) > 500 {
+					lineStr = lineStr[:500] + "..."
+				}
+				errorLines = append(errorLines, lineStr)
+				if len(errorLines) >= maxLines {
+					logger.DebugWithPrefix(d.logPrefix, "GetContainerErrorLogs: found %d error lines for %s (max reached)", len(errorLines), containerName)
+					return errorLines, nil
+				}
+				break
+			}
+		}
+	}
+
+	// If the multiplexed read failed, try reading as plain text
+	if len(errorLines) == 0 {
+		reader2, err := d.cli.ContainerLogs(ctx, containerName, options)
+		if err != nil {
+			return nil, nil
+		}
+		defer reader2.Close()
+
+		scanner := bufio.NewScanner(reader2)
+		for scanner.Scan() {
+			lineStr := strings.TrimSpace(scanner.Text())
+			if lineStr == "" {
+				continue
+			}
+
+			lineLower := strings.ToLower(lineStr)
+			for _, keyword := range errorKeywords {
+				if strings.Contains(lineLower, keyword) {
+					if len(lineStr) > 500 {
+						lineStr = lineStr[:500] + "..."
+					}
+					errorLines = append(errorLines, lineStr)
+					if len(errorLines) >= maxLines {
+						return errorLines, nil
+					}
+					break
+				}
+			}
+		}
+	}
+
+	logger.DebugWithPrefix(d.logPrefix, "GetContainerErrorLogs: found %d error lines for %s", len(errorLines), containerName)
+	return errorLines, nil
+}
+
+// CollectAllContainerErrorLogs collects error logs from multiple containers
+func (d *DockerAdapter) CollectAllContainerErrorLogs(ctx context.Context, containerNames []string, since, until time.Time, maxLinesPerContainer int) map[string][]string {
+	result := make(map[string][]string)
+
+	for _, name := range containerNames {
+		if name == "" {
+			continue
+		}
+		lines, err := d.GetContainerErrorLogs(ctx, name, since, until, maxLinesPerContainer)
+		if err != nil {
+			logger.WarnWithPrefix(d.logPrefix, "CollectAllContainerErrorLogs: error collecting logs for %s: %v", name, err)
+			continue
+		}
+		if len(lines) > 0 {
+			result[name] = lines
+		}
+	}
+
+	return result
+}
diff --git a/internal/adapters/apis/github/github_adapter.go b/internal/adapters/apis/github/github_adapter.go
new file mode 100644
index 0000000..d0afe39
--- /dev/null
+++ b/internal/adapters/apis/github/github_adapter.go
@@ -0,0 +1,249 @@
+package github
+
+import (
+	"bytes"
+	"clients-test/internal/application/domain"
+	"clients-test/internal/logger"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+// GitHubConfig holds the configuration for GitHub API interactions
+type GitHubConfig struct {
+	Token      string // GitHub token (PAT or GITHUB_TOKEN from Actions)
+	Owner      string // Repository owner (e.g., "dappnode")
+	Repo       string // Repository name (e.g., "staker-test-util")
+	PRNumber   int    // Pull request number (0 if not in PR context)
+	RunID      string // GitHub Actions run ID for linking to CI logs
+	RunURL     string // Full URL to the GitHub Actions run
+	ServerURL  string // GitHub server URL (for GitHub Enterprise)
+	Repository string // Full repository name (owner/repo)
+}
+
+// GitHubAdapter handles interactions with the GitHub API
+type GitHubAdapter struct {
+	config    GitHubConfig
+	client    *http.Client
+	logPrefix string
+	baseURL   string
+}
+
+// NewGitHubAdapter creates a new GitHub adapter
+func NewGitHubAdapter(config GitHubConfig) *GitHubAdapter {
+	baseURL := "https://api.github.com"
+	if config.ServerURL != "" && config.ServerURL != "https://github.com" {
+		// For GitHub Enterprise
+		baseURL = strings.TrimSuffix(config.ServerURL, "/") + "/api/v3"
+	}
+
+	return &GitHubAdapter{
+		config:    config,
+		client:    &http.Client{},
+		logPrefix: "GitHubAdapter",
+		baseURL:   baseURL,
+	}
+}
+
+// IsEnabled returns true if the GitHub adapter is properly configured
+func (g *GitHubAdapter) IsEnabled() bool {
+	return g.config.Token != "" && g.config.Owner != "" && g.config.Repo != "" && g.config.PRNumber > 0
+}
+
+// IssueComment represents a GitHub issue/PR comment
+type IssueComment struct {
+	ID   int64  `json:"id"`
+	Body string `json:"body"`
+}
+
+// CommentOnPR creates or updates a comment on a pull request with the test report
+func (g *GitHubAdapter) CommentOnPR(ctx context.Context, report *domain.TestReport) error {
+	if !g.IsEnabled() {
+		logger.InfoWithPrefix(g.logPrefix, "GitHub integration not enabled (missing token, repo info, or PR number), skipping PR comment")
+		return nil
+	}
+
+	// Generate markdown report
+	markdown := report.ToMarkdown()
+
+	// Add CI logs link if available
+	if g.config.RunURL != "" {
+		markdown += fmt.Sprintf("\n---\n📋 [View full CI logs](%s)\n", g.config.RunURL)
+	}
+
+	// Add a signature to identify our comments for updates
+	signature := "\n\n<!-- staker-test-report -->"
+	markdown += signature
+
+	// Check for existing comment to update
+	existingCommentID, err := g.findExistingComment(ctx, signature)
+	if err != nil {
+		logger.WarnWithPrefix(g.logPrefix, "Failed to find existing comment, will create new: %v", err)
+	}
+
+	if existingCommentID > 0 {
+		// Update existing comment
+		err = g.updateComment(ctx, existingCommentID, markdown)
+		if err != nil {
+			return fmt.Errorf("failed to update PR comment: %w", err)
+		}
+		logger.InfoWithPrefix(g.logPrefix, "Updated existing comment on PR #%d", g.config.PRNumber)
+	} else {
+		// Create new comment
+		err = g.createComment(ctx, markdown)
+		if err != nil {
+			return fmt.Errorf("failed to create PR comment: %w", err)
+		}
+		logger.InfoWithPrefix(g.logPrefix, "Created new comment on PR #%d", g.config.PRNumber)
+	}
+
+	return nil
+}
+
+// findExistingComment looks for an existing comment with our signature
+func (g *GitHubAdapter) findExistingComment(ctx context.Context, signature string) (int64, error) {
+	url := fmt.Sprintf("%s/repos/%s/%s/issues/%d/comments",
+		g.baseURL, g.config.Owner, g.config.Repo, g.config.PRNumber)
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return 0, err
+	}
+
+	g.setHeaders(req)
+
+	resp, err := g.client.Do(req)
+	if err != nil {
+		return 0, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return 0, fmt.Errorf("failed to list comments: %s - %s", resp.Status, string(body))
+	}
+
+	var comments []IssueComment
+	if err := json.NewDecoder(resp.Body).Decode(&comments); err != nil {
+		return 0, err
+	}
+
+	for _, comment := range comments {
+		if strings.Contains(comment.Body, signature) {
+			return comment.ID, nil
+		}
+	}
+
+	return 0, nil
+}
+
+// createComment creates a new comment on the PR
+func (g *GitHubAdapter) createComment(ctx context.Context, body string) error {
+	url := fmt.Sprintf("%s/repos/%s/%s/issues/%d/comments",
+		g.baseURL, g.config.Owner, g.config.Repo, g.config.PRNumber)
+
+	payload := map[string]string{"body": body}
+	jsonPayload, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewBuffer(jsonPayload))
+	if err != nil {
+		return err
+	}
+
+	g.setHeaders(req)
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := g.client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusCreated {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("failed to create comment: %s - %s", resp.Status, string(body))
+	}
+
+	return nil
+}
+
+// updateComment updates an existing comment
+func (g *GitHubAdapter) updateComment(ctx context.Context, commentID int64, body string) error {
+	url := fmt.Sprintf("%s/repos/%s/%s/issues/comments/%d",
+		g.baseURL, g.config.Owner, g.config.Repo, commentID)
+
+	payload := map[string]string{"body": body}
+	jsonPayload, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPatch, url, bytes.NewBuffer(jsonPayload))
+	if err != nil {
+		return err
+	}
+
+	g.setHeaders(req)
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := g.client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("failed to update comment: %s - %s", resp.Status, string(body))
+	}
+
+	return nil
+}
+
+// setHeaders sets common headers for GitHub API requests
+func (g *GitHubAdapter) setHeaders(req *http.Request) {
+	req.Header.Set("Authorization", "Bearer "+g.config.Token)
+	req.Header.Set("Accept", "application/vnd.github+json")
+	req.Header.Set("X-GitHub-Api-Version", "2022-11-28")
+}
+
+// ParseGitHubConfigFromEnv creates a GitHubConfig from environment variables
+// This is typically used in GitHub Actions context
+func ParseGitHubConfigFromEnv(token, repository, prNumber, runID, serverURL string) GitHubConfig {
+	config := GitHubConfig{
+		Token:      token,
+		Repository: repository,
+		RunID:      runID,
+		ServerURL:  serverURL,
+	}
+
+	// Parse repository into owner/repo
+	if repository != "" {
+		parts := strings.SplitN(repository, "/", 2)
+		if len(parts) == 2 {
+			config.Owner = parts[0]
+			config.Repo = parts[1]
+		}
+	}
+
+	// Parse PR number
+	if prNumber != "" {
+		if num, err := strconv.Atoi(prNumber); err == nil {
+			config.PRNumber = num
+		}
+	}
+
+	// Build run URL
+	if serverURL != "" && repository != "" && runID != "" {
+		config.RunURL = fmt.Sprintf("%s/%s/actions/runs/%s", serverURL, repository, runID)
+	}
+
+	return config
+}
diff --git a/internal/adapters/composite/cleaner/cleaner.go b/internal/adapters/composite/cleaner/cleaner.go
index 2a92cd7..7d24116 100644
--- a/internal/adapters/composite/cleaner/cleaner.go
+++ b/internal/adapters/composite/cleaner/cleaner.go
@@ -34,16 +34,16 @@ func (e *CleanerAdapter) CleanEnvironment(ctx context.Context, stakerConfig doma
 	var errs []error
 
 	// Attempt to stop container
-	_, err := e.Docker.StopAndGetVolumeTarget(ctx, stakerConfig.ExecutionContainerName, stakerConfig.ExecutionVolumeName)
-	if err != nil {
-		errs = append(errs, fmt.Errorf("stop container failed: %w", err))
-	}
+	// _, err := e.Docker.StopAndGetVolumeTarget(ctx, stakerConfig.ExecutionContainerName, stakerConfig.ExecutionVolumeName)
+	// if err != nil {
+	// 	errs = append(errs, fmt.Errorf("stop container failed: %w", err))
+	// }
 
 	// Attempt to remove non-core packages
-	pkgErrs := e.Dappmanager.RemoveNonCorePackages(ctx)
-	for _, pkgErr := range pkgErrs {
-		errs = append(errs, fmt.Errorf("remove non-core package failed: %w", pkgErr))
-	}
+	// pkgErrs := e.Dappmanager.RemoveNonCorePackages(ctx)
+	// for _, pkgErr := range pkgErrs {
+	// 	errs = append(errs, fmt.Errorf("remove non-core package failed: %w", pkgErr))
+	// }
 
 	// Return combined error if any step failed
 	if len(errs) > 0 {
diff --git a/internal/adapters/composite/composite.go b/internal/adapters/composite/composite.go
index 9d41f5d..5d6c8f2 100644
--- a/internal/adapters/composite/composite.go
+++ b/internal/adapters/composite/composite.go
@@ -6,19 +6,27 @@ import (
 	"clients-test/internal/adapters/apis/dappmanager"
 	"clients-test/internal/adapters/apis/docker"
 	"clients-test/internal/adapters/apis/execution"
+	"clients-test/internal/adapters/apis/github"
 	"clients-test/internal/adapters/apis/ipfs"
 	"clients-test/internal/adapters/apis/snapshots"
 	"clients-test/internal/adapters/composite/cleaner"
 	"clients-test/internal/adapters/composite/ensurer"
 	"clients-test/internal/adapters/composite/executor"
 	"clients-test/internal/application/domain"
+	"clients-test/internal/logger"
 	"context"
+	"time"
 )
 
+var logPrefix = "Composite"
+
 type CompositeAdapter struct {
 	ensurer  *ensurer.EnsurerAdapter
 	executor *executor.ExecutorAdapter
 	cleaner  *cleaner.CleanerAdapter
+	docker   *docker.DockerAdapter
+	github   *github.GitHubAdapter
+	report   *domain.TestReport
 }
 
 func NewCompositeAdapter(
@@ -29,21 +37,86 @@ func NewCompositeAdapter(
 	beaconchainAdapter *beaconchain.BeaconchainAdapter,
 	executionAdapter *execution.ExecutionAdapter,
 	ipfsAdapter *ipfs.IPFSAdapter,
+	githubAdapter *github.GitHubAdapter,
 ) *CompositeAdapter {
 	ensurer := ensurer.NewEnsurerAdapter(dappManagerAdapter, brainAdapter, dockerAdapter, snapshotsAdapter, beaconchainAdapter, executionAdapter, ipfsAdapter)
 	executor := executor.NewExecutorAdapter(executionAdapter, brainAdapter, beaconchainAdapter)
 	cleaner := cleaner.NewCleanerAdapter(dappManagerAdapter, executionAdapter, brainAdapter, beaconchainAdapter, dockerAdapter)
-	return &CompositeAdapter{ensurer, executor, cleaner}
+	return &CompositeAdapter{
+		ensurer:  ensurer,
+		executor: executor,
+		cleaner:  cleaner,
+		docker:   dockerAdapter,
+		github:   githubAdapter,
+	}
 }
 
 func (t *CompositeAdapter) EnsureEnvironment(ctx context.Context, stakerConfig domain.StakerConfig, pkg domain.Pkg) error {
-	return t.ensurer.EnsureEnvironment(ctx, stakerConfig, pkg)
+	// Initialize the report
+	t.report = domain.NewTestReport(stakerConfig)
+
+	return t.ensurer.EnsureEnvironment(ctx, stakerConfig, pkg, t.report)
 }
 
-func (t *CompositeAdapter) ExecuteTest(ctx context.Context) error {
-	return t.executor.ExecuteTest(ctx)
+func (t *CompositeAdapter) ExecuteTest(ctx context.Context, stakerConfig domain.StakerConfig) error {
+	// Record test start time for log collection
+	testStartTime := time.Now()
+
+	// Run the actual test
+	testErr := t.executor.ExecuteTest(ctx, t.report)
+
+	// Record test end time
+	testEndTime := time.Now()
+
+	// Collect container error logs from all relevant containers
+	t.collectContainerErrorLogs(ctx, stakerConfig, testStartTime, testEndTime)
+
+	// Set the final result
+	t.report.SetResult(testErr == nil, testErr)
+
+	// Print console report
+	logger.Info("%s", t.report.ToConsoleString())
+
+	// Comment on PR if GitHub integration is enabled
+	if err := t.github.CommentOnPR(ctx, t.report); err != nil {
+		logger.ErrorWithPrefix(logPrefix, "Failed to comment on PR: %v", err)
+		// Don't fail the test because of PR comment failure
+	}
+
+	return testErr
 }
 
 func (t *CompositeAdapter) CleanEnvironment(ctx context.Context, stakerConfig domain.StakerConfig) error {
 	return t.cleaner.CleanEnvironment(ctx, stakerConfig)
 }
+
+// GetReport returns the current test report
+func (t *CompositeAdapter) GetReport() *domain.TestReport {
+	return t.report
+}
+
+// collectContainerErrorLogs collects error logs from all relevant containers
+func (t *CompositeAdapter) collectContainerErrorLogs(ctx context.Context, stakerConfig domain.StakerConfig, since, until time.Time) {
+	const maxLinesPerContainer = 3
+
+	containerNames := []string{
+		stakerConfig.BrainContainerName,
+		stakerConfig.SignerContainerName,
+		stakerConfig.BeaconchainContainerName,
+		stakerConfig.ValidatorContainerName,
+		stakerConfig.ExecutionContainerName,
+	}
+
+	logger.DebugWithPrefix(logPrefix, "Collecting error logs from containers: %v", containerNames)
+	logger.DebugWithPrefix(logPrefix, "Time range: %v to %v", since, until)
+
+	errorLogs := t.docker.CollectAllContainerErrorLogs(ctx, containerNames, since, until, maxLinesPerContainer)
+
+	for containerName, lines := range errorLogs {
+		t.report.AddContainerErrors(containerName, lines)
+		logger.WarnWithPrefix(logPrefix, "Found %d error lines in %s", len(lines), containerName)
+		for _, line := range lines {
+			logger.ErrorWithPrefix(logPrefix, "[%s] %s", containerName, line)
+		}
+	}
+}
diff --git a/internal/adapters/composite/ensurer/ensurer.go b/internal/adapters/composite/ensurer/ensurer.go
index fdc46b4..8ea877e 100644
--- a/internal/adapters/composite/ensurer/ensurer.go
+++ b/internal/adapters/composite/ensurer/ensurer.go
@@ -3,6 +3,7 @@ package ensurer
 import (
 	"context"
 	"fmt"
+	"time"
 
 	"clients-test/internal/adapters/apis/beaconchain"
 	"clients-test/internal/adapters/apis/brain"
@@ -12,8 +13,11 @@ import (
 	"clients-test/internal/adapters/apis/ipfs"
 	"clients-test/internal/adapters/apis/snapshots"
 	"clients-test/internal/application/domain"
+	"clients-test/internal/logger"
 )
 
+var logPrefix = "Ensurer"
+
 type EnsurerAdapter struct {
 	DappManager *dappmanager.DappManagerAdapter
 	Brain       *brain.BrainAdapter
@@ -36,27 +40,67 @@ func NewEnsurerAdapter(dappManager *dappmanager.DappManagerAdapter, brain *brain
 	}
 }
 
+// timeOperation measures the duration of an operation and records it in the report
+func timeOperation(report *domain.TestReport, operationName string, fn func() error) error {
+	start := time.Now()
+	err := fn()
+	duration := time.Since(start)
+
+	success := err == nil
+	report.AddEnsureTiming(operationName, duration, success, err)
+
+	// Log the timing
+	if success {
+		logger.InfoWithPrefix(logPrefix, "%s completed in %s", operationName, duration.Round(time.Millisecond))
+	} else {
+		logger.ErrorWithPrefix(logPrefix, "%s failed after %s: %v", operationName, duration.Round(time.Millisecond), err)
+	}
+
+	return err
+}
+
 // EnsureEnvironment validates the environment and prepares it for testing.
 // It sets the staker config, installs the package, stops the container, downloads the snapshot, and starts the container.
-func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig domain.StakerConfig, pkg domain.Pkg) error {
-	if err := e.DappManager.SetStakerConfig(ctx, stakerConfig); err != nil {
+// All operations are timed and recorded in the report.
+func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig domain.StakerConfig, pkg domain.Pkg, report *domain.TestReport) error {
+	var volumeTarget string
+
+	// SetStakerConfig
+	if err := timeOperation(report, "SetStakerConfig", func() error {
+		return e.DappManager.SetStakerConfig(ctx, stakerConfig)
+	}); err != nil {
 		return fmt.Errorf("failed to set staker config for DNP: %w", err)
 	}
-	if err := e.DappManager.PackageInstall(ctx, pkg); err != nil {
+
+	// PackageInstall
+	if err := timeOperation(report, "PackageInstall", func() error {
+		return e.DappManager.PackageInstall(ctx, pkg)
+	}); err != nil {
 		return fmt.Errorf("failed to install package: %w", err)
 	}
-	volumeTarget, err := e.Docker.StopAndGetVolumeTarget(ctx, stakerConfig.ExecutionContainerName, stakerConfig.ExecutionVolumeName)
-	if err != nil {
+
+	// StopAndGetVolumeTarget
+	if err := timeOperation(report, "StopAndGetVolumeTarget", func() error {
+		var err error
+		volumeTarget, err = e.Docker.StopAndGetVolumeTarget(ctx, stakerConfig.ExecutionContainerName, stakerConfig.ExecutionVolumeName)
+		return err
+	}); err != nil {
 		return fmt.Errorf("failed to stop container and get volume: %w", err)
 	}
 
-	// Download and extract snapshot directly into the volume
-	if err := e.Snapshots.DownloadAndExtract(ctx, stakerConfig.Network, stakerConfig.ExecutionClientShortName, volumeTarget); err != nil {
+	// DownloadAndExtractSnapshot
+	if err := timeOperation(report, "DownloadAndExtractSnapshot", func() error {
+		return e.Snapshots.DownloadAndExtract(ctx, stakerConfig.Network, stakerConfig.ExecutionClientShortName, volumeTarget)
+	}); err != nil {
 		return fmt.Errorf("failed to download and extract snapshot: %w", err)
 	}
 
-	if err := e.Docker.StartContainer(ctx, stakerConfig.ExecutionContainerName); err != nil {
+	// StartContainer
+	if err := timeOperation(report, "StartContainer", func() error {
+		return e.Docker.StartContainer(ctx, stakerConfig.ExecutionContainerName)
+	}); err != nil {
 		return fmt.Errorf("failed to start container: %w", err)
 	}
+
 	return nil
 }
diff --git a/internal/adapters/composite/executor/executor.go b/internal/adapters/composite/executor/executor.go
index 746f561..3fef43f 100644
--- a/internal/adapters/composite/executor/executor.go
+++ b/internal/adapters/composite/executor/executor.go
@@ -8,8 +8,12 @@ import (
 	"clients-test/internal/adapters/apis/beaconchain"
 	"clients-test/internal/adapters/apis/brain"
 	"clients-test/internal/adapters/apis/execution"
+	"clients-test/internal/application/domain"
+	"clients-test/internal/logger"
 )
 
+var logPrefix = "Executor"
+
 type ExecutorAdapter struct {
 	Execution   *execution.ExecutionAdapter
 	Brain       *brain.BrainAdapter
@@ -24,6 +28,25 @@ func NewExecutorAdapter(execution *execution.ExecutionAdapter, brain *brain.Brai
 	}
 }
 
+// timeOperation measures the duration of an operation and records it in the report
+func timeOperation(report *domain.TestReport, operationName string, fn func() error) error {
+	start := time.Now()
+	err := fn()
+	duration := time.Since(start)
+
+	success := err == nil
+	report.AddExecuteTiming(operationName, duration, success, err)
+
+	// Log the timing
+	if success {
+		logger.InfoWithPrefix(logPrefix, "%s completed in %s", operationName, duration.Round(time.Millisecond))
+	} else {
+		logger.ErrorWithPrefix(logPrefix, "%s failed after %s: %v", operationName, duration.Round(time.Millisecond), err)
+	}
+
+	return err
+}
+
 // waitForExecutionSync waits until the execution client is synced or times out,
 // returning only after maxTries with the most recent error (if any).
 func (t *ExecutorAdapter) waitForExecutionSync(ctx context.Context) error {
@@ -162,15 +185,25 @@ func (t *ExecutorAdapter) waitForValidatorLiveness(ctx context.Context) error {
 }
 
 // ExecuteTest runs both sync and liveness checks in sequence
-func (t *ExecutorAdapter) ExecuteTest(ctx context.Context) error {
-	if err := t.waitForBeaconchainSync(ctx); err != nil {
+// All operations are timed and recorded in the report.
+func (t *ExecutorAdapter) ExecuteTest(ctx context.Context, report *domain.TestReport) error {
+	if err := timeOperation(report, "WaitForBeaconchainSync", func() error {
+		return t.waitForBeaconchainSync(ctx)
+	}); err != nil {
 		return err
 	}
-	if err := t.waitForExecutionSync(ctx); err != nil {
+
+	if err := timeOperation(report, "WaitForExecutionSync", func() error {
+		return t.waitForExecutionSync(ctx)
+	}); err != nil {
 		return err
 	}
-	if err := t.waitForValidatorLiveness(ctx); err != nil {
+
+	if err := timeOperation(report, "WaitForValidatorLiveness", func() error {
+		return t.waitForValidatorLiveness(ctx)
+	}); err != nil {
 		return err
 	}
+
 	return nil
 }
diff --git a/internal/application/domain/report.go b/internal/application/domain/report.go
new file mode 100644
index 0000000..5f9e3b1
--- /dev/null
+++ b/internal/application/domain/report.go
@@ -0,0 +1,263 @@
+package domain
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+// TimingEntry represents a single timed operation
+type TimingEntry struct {
+	Operation string        `json:"operation"`
+	Duration  time.Duration `json:"duration"`
+	Success   bool          `json:"success"`
+	Error     string        `json:"error,omitempty"`
+}
+
+// ContainerErrorLog represents error logs from a container
+type ContainerErrorLog struct {
+	ContainerName string   `json:"containerName"`
+	ErrorLines    []string `json:"errorLines"`
+}
+
+// TestReport holds all information for the test report
+type TestReport struct {
+	// Client configuration
+	ExecutionDnpName  string `json:"executionDnpName"`
+	ConsensusDnpName  string `json:"consensusDnpName"`
+	Web3SignerDnpName string `json:"web3signerDnpName"`
+	MevBoostDnpName   string `json:"mevBoostDnpName"`
+	Network           string `json:"network"`
+
+	// Test execution info
+	StartTime time.Time `json:"startTime"`
+	EndTime   time.Time `json:"endTime"`
+
+	// Timing measurements
+	EnsureTimings  []TimingEntry `json:"ensureTimings"`
+	ExecuteTimings []TimingEntry `json:"executeTimings"`
+
+	// Container error logs
+	ContainerErrors []ContainerErrorLog `json:"containerErrors"`
+
+	// Final result
+	Success      bool   `json:"success"`
+	ErrorMessage string `json:"errorMessage,omitempty"`
+}
+
+// NewTestReport creates a new TestReport from StakerConfig
+func NewTestReport(config StakerConfig) *TestReport {
+	return &TestReport{
+		ExecutionDnpName:  config.ExecutionDnpName,
+		ConsensusDnpName:  config.ConsensusDnpName,
+		Web3SignerDnpName: config.Web3SignerDnpName,
+		MevBoostDnpName:   config.MevBoostDnpName,
+		Network:           config.Network,
+		StartTime:         time.Now(),
+		EnsureTimings:     make([]TimingEntry, 0),
+		ExecuteTimings:    make([]TimingEntry, 0),
+		ContainerErrors:   make([]ContainerErrorLog, 0),
+		Success:           true,
+	}
+}
+
+// AddEnsureTiming adds a timing entry for an ensure operation
+func (r *TestReport) AddEnsureTiming(operation string, duration time.Duration, success bool, err error) {
+	entry := TimingEntry{
+		Operation: operation,
+		Duration:  duration,
+		Success:   success,
+	}
+	if err != nil {
+		entry.Error = err.Error()
+	}
+	r.EnsureTimings = append(r.EnsureTimings, entry)
+}
+
+// AddExecuteTiming adds a timing entry for an execute operation
+func (r *TestReport) AddExecuteTiming(operation string, duration time.Duration, success bool, err error) {
+	entry := TimingEntry{
+		Operation: operation,
+		Duration:  duration,
+		Success:   success,
+	}
+	if err != nil {
+		entry.Error = err.Error()
+	}
+	r.ExecuteTimings = append(r.ExecuteTimings, entry)
+}
+
+// AddContainerErrors adds error logs for a container
+func (r *TestReport) AddContainerErrors(containerName string, errorLines []string) {
+	if len(errorLines) > 0 {
+		r.ContainerErrors = append(r.ContainerErrors, ContainerErrorLog{
+			ContainerName: containerName,
+			ErrorLines:    errorLines,
+		})
+	}
+}
+
+// SetResult sets the final test result
+func (r *TestReport) SetResult(success bool, err error) {
+	r.EndTime = time.Now()
+	r.Success = success
+	if err != nil {
+		r.ErrorMessage = err.Error()
+	}
+}
+
+// TotalDuration returns the total test duration
+func (r *TestReport) TotalDuration() time.Duration {
+	return r.EndTime.Sub(r.StartTime)
+}
+
+// ToMarkdown generates a markdown report for GitHub PR comment
+func (r *TestReport) ToMarkdown() string {
+	var sb strings.Builder
+
+	// Header with result emoji
+	if r.Success {
+		sb.WriteString("## ✅ Staker Test Report - PASSED\n\n")
+	} else {
+		sb.WriteString("## ❌ Staker Test Report - FAILED\n\n")
+	}
+
+	// Clients Used section
+	sb.WriteString("### 📦 Clients Used\n\n")
+	sb.WriteString("| Component | DNP Name |\n")
+	sb.WriteString("|-----------|----------|\n")
+	sb.WriteString(fmt.Sprintf("| Execution | `%s` |\n", r.ExecutionDnpName))
+	sb.WriteString(fmt.Sprintf("| Consensus | `%s` |\n", r.ConsensusDnpName))
+	sb.WriteString(fmt.Sprintf("| Web3Signer | `%s` |\n", r.Web3SignerDnpName))
+	sb.WriteString(fmt.Sprintf("| MEV Boost | `%s` |\n", r.MevBoostDnpName))
+	sb.WriteString(fmt.Sprintf("| Network | `%s` |\n", r.Network))
+	sb.WriteString("\n")
+
+	// Timing section
+	sb.WriteString("### ⏱️ Timing Measurements\n\n")
+
+	if len(r.EnsureTimings) > 0 {
+		sb.WriteString("#### Environment Setup\n\n")
+		sb.WriteString("| Operation | Duration | Status |\n")
+		sb.WriteString("|-----------|----------|--------|\n")
+		for _, t := range r.EnsureTimings {
+			status := "✅"
+			if !t.Success {
+				status = "❌"
+			}
+			sb.WriteString(fmt.Sprintf("| %s | %s | %s |\n", t.Operation, t.Duration.Round(time.Millisecond), status))
+		}
+		sb.WriteString("\n")
+	}
+
+	if len(r.ExecuteTimings) > 0 {
+		sb.WriteString("#### Test Execution\n\n")
+		sb.WriteString("| Operation | Duration | Status |\n")
+		sb.WriteString("|-----------|----------|--------|\n")
+		for _, t := range r.ExecuteTimings {
+			status := "✅"
+			if !t.Success {
+				status = "❌"
+			}
+			sb.WriteString(fmt.Sprintf("| %s | %s | %s |\n", t.Operation, t.Duration.Round(time.Millisecond), status))
+		}
+		sb.WriteString("\n")
+	}
+
+	sb.WriteString(fmt.Sprintf("**Total Duration:** %s\n\n", r.TotalDuration().Round(time.Second)))
+
+	// Error logs section
+	if len(r.ContainerErrors) > 0 {
+		sb.WriteString("### 🔴 Container Error Logs\n\n")
+		sb.WriteString("> ⚠️ Showing up to 3 error lines per container. See CI logs for complete details.\n\n")
+		for _, ce := range r.ContainerErrors {
+			sb.WriteString(fmt.Sprintf("**%s:**\n", ce.ContainerName))
+			sb.WriteString("```\n")
+			for _, line := range ce.ErrorLines {
+				sb.WriteString(line + "\n")
+			}
+			sb.WriteString("```\n\n")
+		}
+	}
+
+	// Error message if failed
+	if !r.Success && r.ErrorMessage != "" {
+		sb.WriteString("### ❌ Error Details\n\n")
+		sb.WriteString("```\n")
+		sb.WriteString(r.ErrorMessage + "\n")
+		sb.WriteString("```\n")
+	}
+
+	return sb.String()
+}
+
+// ToConsoleString generates a console-friendly report
+func (r *TestReport) ToConsoleString() string {
+	var sb strings.Builder
+
+	sb.WriteString("\n")
+	sb.WriteString("========================================\n")
+	if r.Success {
+		sb.WriteString("       STAKER TEST REPORT - PASSED      \n")
+	} else {
+		sb.WriteString("       STAKER TEST REPORT - FAILED      \n")
+	}
+	sb.WriteString("========================================\n\n")
+
+	// Clients Used
+	sb.WriteString("CLIENTS USED:\n")
+	sb.WriteString(fmt.Sprintf("  Execution:   %s\n", r.ExecutionDnpName))
+	sb.WriteString(fmt.Sprintf("  Consensus:   %s\n", r.ConsensusDnpName))
+	sb.WriteString(fmt.Sprintf("  Web3Signer:  %s\n", r.Web3SignerDnpName))
+	sb.WriteString(fmt.Sprintf("  MEV Boost:   %s\n", r.MevBoostDnpName))
+	sb.WriteString(fmt.Sprintf("  Network:     %s\n", r.Network))
+	sb.WriteString("\n")
+
+	// Timing
+	sb.WriteString("TIMING MEASUREMENTS:\n")
+	if len(r.EnsureTimings) > 0 {
+		sb.WriteString("  Environment Setup:\n")
+		for _, t := range r.EnsureTimings {
+			status := "OK"
+			if !t.Success {
+				status = "FAILED"
+			}
+			sb.WriteString(fmt.Sprintf("    - %-30s %12s [%s]\n", t.Operation, t.Duration.Round(time.Millisecond), status))
+		}
+	}
+	if len(r.ExecuteTimings) > 0 {
+		sb.WriteString("  Test Execution:\n")
+		for _, t := range r.ExecuteTimings {
+			status := "OK"
+			if !t.Success {
+				status = "FAILED"
+			}
+			sb.WriteString(fmt.Sprintf("    - %-30s %12s [%s]\n", t.Operation, t.Duration.Round(time.Millisecond), status))
+		}
+	}
+	sb.WriteString(fmt.Sprintf("\n  Total Duration: %s\n", r.TotalDuration().Round(time.Second)))
+	sb.WriteString("\n")
+
+	// Error logs
+	if len(r.ContainerErrors) > 0 {
+		sb.WriteString("CONTAINER ERROR LOGS:\n")
+		sb.WriteString("  (See CI logs for complete details)\n")
+		for _, ce := range r.ContainerErrors {
+			sb.WriteString(fmt.Sprintf("  [%s]:\n", ce.ContainerName))
+			for _, line := range ce.ErrorLines {
+				sb.WriteString(fmt.Sprintf("    %s\n", line))
+			}
+		}
+		sb.WriteString("\n")
+	}
+
+	// Error message
+	if !r.Success && r.ErrorMessage != "" {
+		sb.WriteString("ERROR DETAILS:\n")
+		sb.WriteString(fmt.Sprintf("  %s\n", r.ErrorMessage))
+	}
+
+	sb.WriteString("========================================\n")
+
+	return sb.String()
+}
diff --git a/internal/application/domain/stakers.go b/internal/application/domain/stakers.go
index 0bd4083..295467d 100644
--- a/internal/application/domain/stakers.go
+++ b/internal/application/domain/stakers.go
@@ -15,6 +15,10 @@ type StakerConfig struct {
 	Relays                   []string `json:"relays,omitempty"` // Optional, can be empty
 	Network                  string   `json:"network"`          // The network this config is for (e.g., mainnet, gnosis, hoodi, lukso)
 	Urls                     Urls
+	BrainContainerName       string // The name of the brain container
+	SignerContainerName      string // The name of the web3signer container
+	BeaconchainContainerName string // The name of the beaconchain container
+	ValidatorContainerName   string // The name of the validator container
 	ExecutionContainerName   string // The name of the container to mount the NFS volume to
 	ExecutionVolumeName      string // The name of the volume to mount for execution client data
 	ExecutionClientShortName string // Short name of the execution client (e.g., geth, nethermind, reth)
@@ -108,7 +112,11 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 		Relays:                   relays,
 		Network:                  network,
 		Urls:                     urls,
-		ExecutionContainerName:   executionContainerName(pkg.ServiceName, pkg.DnpName),
+		BrainContainerName:       containerName("brain", web3signer),
+		SignerContainerName:      containerName("web3signer", web3signer),
+		BeaconchainContainerName: containerName("beacon-chain", cons),
+		ValidatorContainerName:   containerName("validator", cons),
+		ExecutionContainerName:   containerName(shortDnpName(exec), exec),
 		ExecutionVolumeName:      composeVolumeName(pkg.DnpName, pkg.ComposeVolumeName),
 		ExecutionClientShortName: execShort,
 	}
@@ -146,8 +154,8 @@ func shortDnpName(dnpName string) string {
 	return strings.TrimSuffix(dnpName, ".dnp.dappnode.eth")
 }
 
-// Utility to get the execution container name from service and dnpName
-func executionContainerName(serviceName, dnpName string) string {
+// Utility to get the container name from service and dnpName
+func containerName(serviceName, dnpName string) string {
 	return fmt.Sprintf("DAppNodePackage-%s.%s.dnp.dappnode.eth", serviceName, shortDnpName(dnpName))
 }
 
diff --git a/internal/application/ports/ports.go b/internal/application/ports/ports.go
index 9da1d9f..115ef0a 100644
--- a/internal/application/ports/ports.go
+++ b/internal/application/ports/ports.go
@@ -7,6 +7,7 @@ import (
 
 type TestRunner interface {
 	EnsureEnvironment(ctx context.Context, stakerConfig domain.StakerConfig, pkg domain.Pkg) error
-	ExecuteTest(ctx context.Context) error
+	ExecuteTest(ctx context.Context, stakerConfig domain.StakerConfig) error
 	CleanEnvironment(context.Context, domain.StakerConfig) error
+	GetReport() *domain.TestReport
 }
diff --git a/internal/application/services/test_runner.go b/internal/application/services/test_runner.go
index 0961ca8..e14b99d 100644
--- a/internal/application/services/test_runner.go
+++ b/internal/application/services/test_runner.go
@@ -23,8 +23,8 @@ func (s *TestRunnerService) RunTest(ctx context.Context, stakerConfig domain.Sta
 		return fmt.Errorf("setup failed: %w", err)
 	}
 
-	// 2) execute test
-	execErr := s.Runner.ExecuteTest(ctx)
+	// 2) execute test (now includes report generation and PR commenting)
+	execErr := s.Runner.ExecuteTest(ctx, stakerConfig)
 	if execErr != nil {
 		// even on test failure we want cleanup
 		if cleanupErr := s.Runner.CleanEnvironment(ctx, stakerConfig); cleanupErr != nil {
@@ -40,3 +40,8 @@ func (s *TestRunnerService) RunTest(ctx context.Context, stakerConfig domain.Sta
 
 	return nil
 }
+
+// GetReport returns the test report from the runner
+func (s *TestRunnerService) GetReport() *domain.TestReport {
+	return s.Runner.GetReport()
+}
diff --git a/internal/config/config.go b/internal/config/config.go
new file mode 100644
index 0000000..4dcec23
--- /dev/null
+++ b/internal/config/config.go
@@ -0,0 +1,86 @@
+package config
+
+import (
+	"clients-test/internal/adapters/apis/github"
+	"clients-test/internal/logger"
+	"flag"
+	"os"
+)
+
+var logPrefix = "Config"
+
+// Config holds all application configuration
+type Config struct {
+	IPFSGatewayURL string
+	IPFSHash       string
+	GitHub         github.GitHubConfig
+}
+
+// ParseConfig parses CLI flags and environment variables into a Config struct
+func ParseConfig() Config {
+	// CLI flags
+	ipfsGatewayUrl := flag.String("ipfs-gateway-url", "", "IPFS gateway URL (required, or set IPFS_GATEWAY_URL env)")
+	ipfsHash := flag.String("ipfs-hash", "", "IPFS hash for the test package (required, or set IPFS_HASH env)")
+
+	// GitHub flags (optional, for PR commenting)
+	githubToken := flag.String("github-token", "", "GitHub token for PR commenting (or set GITHUB_TOKEN env)")
+	githubRepository := flag.String("github-repository", "", "GitHub repository in format owner/repo (or set GITHUB_REPOSITORY env)")
+	githubPRNumber := flag.String("github-pr-number", "", "Pull request number (or set GITHUB_PR_NUMBER env)")
+	githubRunID := flag.String("github-run-id", "", "GitHub Actions run ID (or set GITHUB_RUN_ID env)")
+	githubServerURL := flag.String("github-server-url", "", "GitHub server URL (or set GITHUB_SERVER_URL env)")
+
+	flag.Parse()
+
+	// Build config with flag values, falling back to environment variables
+	config := Config{
+		IPFSGatewayURL: getConfigValue(*ipfsGatewayUrl, "IPFS_GATEWAY_URL"),
+		IPFSHash:       getConfigValue(*ipfsHash, "IPFS_HASH"),
+		GitHub: github.ParseGitHubConfigFromEnv(
+			getConfigValue(*githubToken, "GITHUB_TOKEN"),
+			getConfigValue(*githubRepository, "GITHUB_REPOSITORY"),
+			getGitHubPRNumber(*githubPRNumber),
+			getConfigValue(*githubRunID, "GITHUB_RUN_ID"),
+			getGitHubServerURL(*githubServerURL),
+		),
+	}
+
+	return config
+}
+
+// getConfigValue returns the flag value if set, otherwise falls back to the environment variable
+func getConfigValue(flagValue, envName string) string {
+	if flagValue != "" {
+		return flagValue
+	}
+	return os.Getenv(envName)
+}
+
+// getGitHubPRNumber gets the PR number from flag or environment variables
+func getGitHubPRNumber(flagValue string) string {
+	if flagValue != "" {
+		return flagValue
+	}
+	if prNumber := os.Getenv("GITHUB_PR_NUMBER"); prNumber != "" {
+		return prNumber
+	}
+	// Also check GITHUB_EVENT_NUMBER which is set in PR events
+	return os.Getenv("GITHUB_EVENT_NUMBER")
+}
+
+// getGitHubServerURL gets the server URL with a default fallback
+func getGitHubServerURL(flagValue string) string {
+	if flagValue != "" {
+		return flagValue
+	}
+	if serverURL := os.Getenv("GITHUB_SERVER_URL"); serverURL != "" {
+		return serverURL
+	}
+	return "https://github.com"
+}
+
+// Validate checks that required configuration values are present
+func (c *Config) Validate() {
+	if c.IPFSGatewayURL == "" || c.IPFSHash == "" {
+		logger.FatalWithPrefix(logPrefix, "IPFS gateway URL and hash are required. Set via --ipfs-gateway-url/--ipfs-hash flags or IPFS_GATEWAY_URL/IPFS_HASH environment variables.")
+	}
+}

From 84bb3be64cf3320625f4f43610e764d8a4ebca19 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 16:13:20 +0100
Subject: [PATCH 07/42] increase execution time

---
 internal/adapters/composite/executor/executor.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/adapters/composite/executor/executor.go b/internal/adapters/composite/executor/executor.go
index 3fef43f..36fff85 100644
--- a/internal/adapters/composite/executor/executor.go
+++ b/internal/adapters/composite/executor/executor.go
@@ -51,7 +51,7 @@ func timeOperation(report *domain.TestReport, operationName string, fn func() er
 // returning only after maxTries with the most recent error (if any).
 func (t *ExecutorAdapter) waitForExecutionSync(ctx context.Context) error {
 	const (
-		maxTries = 60
+		maxTries = 180
 		sleepDur = 6 * time.Second
 	)
 	var lastErr error

From 3e1f97d6c7c2583e1bd4d815b18546aff8c1592e Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 16:15:14 +0100
Subject: [PATCH 08/42] add todos

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 4ea3181..945156f 100644
--- a/README.md
+++ b/README.md
@@ -122,5 +122,7 @@ docker-compose up --build
 - [x] Measure the time it takes every process in the test and add it to the report
 - [x] Collect logs from containers and create a report
 - [x] Add to the report the clients used
+- [ ] Research how to release this SDK tool to be run from a github action directly
+- [ ] Implement when manual trigger (`workflow_dispatch`) the clients will be passed as inputs, use them to create the staker config for the test
 - [ ] Consider adding to report beaconcha validator url
 - [ ] Consider setting keystore and password through github secrets.
\ No newline at end of file

From 1f2438de7ae366e92c0b0fce8057c1207d16a132 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 16:26:18 +0100
Subject: [PATCH 09/42] fix get servicename utility

---
 internal/application/domain/stakers.go | 42 ++++++++++++++------------
 1 file changed, 23 insertions(+), 19 deletions(-)

diff --git a/internal/application/domain/stakers.go b/internal/application/domain/stakers.go
index 295467d..c0cf12f 100644
--- a/internal/application/domain/stakers.go
+++ b/internal/application/domain/stakers.go
@@ -79,7 +79,7 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 		}
 	case "hoodi":
 		execClients = []string{"hoodi-reth.dnp.dappnode.eth", "hoodi-geth.dnp.dappnode.eth", "hoodi-besu.dnp.dappnode.eth", "hoodi-erigon.dnp.dappnode.eth", "hoodi-nethermind.dnp.dappnode.eth"}
-		consClients = []string{"prysm-hoodi.dnp.dappnode.eth", "teku-hoodi.dnp.dappnode.eth", "nimbus-hoodi.dnp.dappnode.eth", "lodestar-hoodi.dnp.dappnode.eth", "lighthouse-hoodi.dnp.dappnode.eth"}
+		consClients = []string{"prysm-hoodi.dnp.dappnode.eth", "teku-hoodi.dnp.dappnode.eth", "nimbus-hoodi.dnp.dappnode.eth", "lodestar-hoodi.dnp.dappnode.eth"}
 		web3signer = "web3signer-hoodi.dnp.dappnode.eth"
 		mevboost = "mev-boost-hoodi.dnp.dappnode.eth"
 		relays = []string{}
@@ -91,22 +91,22 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 		}
 	}
 
-	exec := matchOrRandom(pkg.DnpName, execClients)
-	cons := matchOrRandom(pkg.DnpName, consClients)
+	ecDnpName := matchOrRandom(pkg.DnpName, execClients)
+	ccDnpName := matchOrRandom(pkg.DnpName, consClients)
 
 	// List of known execution client short names
-	clientShortNames := []string{"geth", "nethermind", "erigon", "reth", "besu"}
-	execShort := "unknown"
-	for _, short := range clientShortNames {
-		if strings.Contains(exec, short) {
-			execShort = short
+	ecShortNames := []string{"geth", "nethermind", "erigon", "reth", "besu"}
+	ecShortDnpName := "unknown"
+	for _, short := range ecShortNames {
+		if strings.Contains(ecDnpName, short) {
+			ecShortDnpName = short
 			break
 		}
 	}
 
 	return StakerConfig{
-		ExecutionDnpName:         exec,
-		ConsensusDnpName:         cons,
+		ExecutionDnpName:         ecDnpName,
+		ConsensusDnpName:         ccDnpName,
 		Web3SignerDnpName:        web3signer,
 		MevBoostDnpName:          mevboost,
 		Relays:                   relays,
@@ -114,11 +114,11 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 		Urls:                     urls,
 		BrainContainerName:       containerName("brain", web3signer),
 		SignerContainerName:      containerName("web3signer", web3signer),
-		BeaconchainContainerName: containerName("beacon-chain", cons),
-		ValidatorContainerName:   containerName("validator", cons),
-		ExecutionContainerName:   containerName(shortDnpName(exec), exec),
+		BeaconchainContainerName: containerName("beacon-chain", ccDnpName),
+		ValidatorContainerName:   containerName("validator", ccDnpName),
+		ExecutionContainerName:   containerName(serviceNameFromExecutionClient(ecDnpName), ecDnpName),
 		ExecutionVolumeName:      composeVolumeName(pkg.DnpName, pkg.ComposeVolumeName),
-		ExecutionClientShortName: execShort,
+		ExecutionClientShortName: ecShortDnpName,
 	}
 }
 
@@ -149,14 +149,18 @@ func matchOrRandom(dnpName string, candidates []string) string {
 	return candidates[r.Intn(len(candidates))]
 }
 
-// Utility to get the short dnp name (strip .dnp.dappnode.eth)
-func shortDnpName(dnpName string) string {
-	return strings.TrimSuffix(dnpName, ".dnp.dappnode.eth")
+// Utility to get the servicename from a execution client (this utility assumes the service name is the first part of the dnp name)
+func serviceNameFromExecutionClient(dnpName string) string {
+	parts := strings.Split(dnpName, "-")
+	if len(parts) > 0 {
+		return parts[0]
+	}
+	return dnpName
 }
 
-// Utility to get the container name from service and dnpName
+// Utility to get the container name from service and dnpName. append dnp or public suffix depending on original dnpName
 func containerName(serviceName, dnpName string) string {
-	return fmt.Sprintf("DAppNodePackage-%s.%s.dnp.dappnode.eth", serviceName, shortDnpName(dnpName))
+	return fmt.Sprintf("DAppNodePackage-%s.%s", serviceName, dnpName)
 }
 
 // Utility to get the docker volume name from dnpName and compose volume name

From 55ad24a7df814702aa51d27165c9aa1cab53126f Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 16:26:29 +0100
Subject: [PATCH 10/42] add clients versions todos

---
 README.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/README.md b/README.md
index 945156f..b5d56f4 100644
--- a/README.md
+++ b/README.md
@@ -124,5 +124,8 @@ docker-compose up --build
 - [x] Add to the report the clients used
 - [ ] Research how to release this SDK tool to be run from a github action directly
 - [ ] Implement when manual trigger (`workflow_dispatch`) the clients will be passed as inputs, use them to create the staker config for the test
+- [ ] Implement edit of `/usr/src/dappnode/DNCORE/docker-compose.yml` file to add env `TEST=true` and relaunch compose
+- [ ] Print version of the clients 
+    - [ ] For the EC it must be printed
 - [ ] Consider adding to report beaconcha validator url
 - [ ] Consider setting keystore and password through github secrets.
\ No newline at end of file

From 038e98a3b1ac40782471d933bc336e2c580cc0f8 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 16:54:02 +0100
Subject: [PATCH 11/42] add todos

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index b5d56f4..45ed38c 100644
--- a/README.md
+++ b/README.md
@@ -127,5 +127,7 @@ docker-compose up --build
 - [ ] Implement edit of `/usr/src/dappnode/DNCORE/docker-compose.yml` file to add env `TEST=true` and relaunch compose
 - [ ] Print version of the clients 
     - [ ] For the EC it must be printed
+- [ ] Consider always removing beacon volumes to ensure avoiding old states of chain and always start with the checkpoint sync
+- [ ] Implement switch off of dappmanager cron that restarts containers of clients selected in stakers
 - [ ] Consider adding to report beaconcha validator url
 - [ ] Consider setting keystore and password through github secrets.
\ No newline at end of file

From fe7c465ebde0ee8ad25a083d2ebd7fa0359c8a91 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 16:54:14 +0100
Subject: [PATCH 12/42] fix get servicename

---
 internal/application/domain/stakers.go | 28 +++++++++++++++++++++-----
 1 file changed, 23 insertions(+), 5 deletions(-)

diff --git a/internal/application/domain/stakers.go b/internal/application/domain/stakers.go
index c0cf12f..a5e00c7 100644
--- a/internal/application/domain/stakers.go
+++ b/internal/application/domain/stakers.go
@@ -116,7 +116,7 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 		SignerContainerName:      containerName("web3signer", web3signer),
 		BeaconchainContainerName: containerName("beacon-chain", ccDnpName),
 		ValidatorContainerName:   containerName("validator", ccDnpName),
-		ExecutionContainerName:   containerName(serviceNameFromExecutionClient(ecDnpName), ecDnpName),
+		ExecutionContainerName:   containerName(serviceNameFromExecutionClient(ecDnpName, network), ecDnpName),
 		ExecutionVolumeName:      composeVolumeName(pkg.DnpName, pkg.ComposeVolumeName),
 		ExecutionClientShortName: ecShortDnpName,
 	}
@@ -150,12 +150,30 @@ func matchOrRandom(dnpName string, candidates []string) string {
 }
 
 // Utility to get the servicename from a execution client (this utility assumes the service name is the first part of the dnp name)
-func serviceNameFromExecutionClient(dnpName string) string {
-	parts := strings.Split(dnpName, "-")
-	if len(parts) > 0 {
+// e.g hoodi-nethermind.dnp.dappnode.eth -> nethermind
+// e.g nethermind-hoodi.dnp.dappnode.eth -> nethermind
+// e.g nethermind-hoodi.public.dappnode.eth -> nethermind
+// e.g geth.dnp.dappnode.eth -> geth
+// e.g reth-gnosis.dnp.dappnode.eth -> reth
+// e.g gnosis-reth.dnp.dappnode.eth -> reth
+func serviceNameFromExecutionClient(dnpName, network string) string {
+	trimmed := strings.TrimSuffix(dnpName, ".dnp.dappnode.eth")
+	trimmed = strings.TrimSuffix(trimmed, ".public.dappnode.eth")
+	parts := strings.Split(trimmed, "-")
+
+	// If there is only one part, return it
+	if len(parts) == 1 {
 		return parts[0]
 	}
-	return dnpName
+	// If there are multiple parts, find and remove the network part
+	for i, part := range parts {
+		if part == network {
+			parts = append(parts[:i], parts[i+1:]...)
+			break
+		}
+	}
+	// Return the remaining parts joined by "-"
+	return strings.Join(parts, "-")
 }
 
 // Utility to get the container name from service and dnpName. append dnp or public suffix depending on original dnpName

From d3383e2ebec6274308847273d0259071eec57d22 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 16:54:59 +0100
Subject: [PATCH 13/42] add less verbose todo

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 45ed38c..fe1685b 100644
--- a/README.md
+++ b/README.md
@@ -129,5 +129,6 @@ docker-compose up --build
     - [ ] For the EC it must be printed
 - [ ] Consider always removing beacon volumes to ensure avoiding old states of chain and always start with the checkpoint sync
 - [ ] Implement switch off of dappmanager cron that restarts containers of clients selected in stakers
+- [ ] Silent the tar output when extracting snapshots or make it less verbose
 - [ ] Consider adding to report beaconcha validator url
 - [ ] Consider setting keystore and password through github secrets.
\ No newline at end of file

From 2dbc4d9371784d5642363b4046bbb1127234ad8e Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 17:01:29 +0100
Subject: [PATCH 14/42] implement versions getters for execution and
 beaconchain adapters

---
 .../apis/beaconchain/beaconchain_adapter.go   | 38 ++++++++++++++
 .../apis/execution/execution_adapter.go       | 50 +++++++++++++++++++
 2 files changed, 88 insertions(+)

diff --git a/internal/adapters/apis/beaconchain/beaconchain_adapter.go b/internal/adapters/apis/beaconchain/beaconchain_adapter.go
index 7168d55..3dfbf40 100644
--- a/internal/adapters/apis/beaconchain/beaconchain_adapter.go
+++ b/internal/adapters/apis/beaconchain/beaconchain_adapter.go
@@ -168,6 +168,44 @@ func (b *BeaconchainAdapter) GetValidatorLiveness(ctx context.Context, indexes [
 	return liveness, nil
 }
 
+// GetClientVersion retrieves the version of the beacon node client
+// See: https://ethereum.github.io/beacon-APIs/#/Node/getNodeVersion
+func (b *BeaconchainAdapter) GetClientVersion(ctx context.Context) (string, error) {
+	url := fmt.Sprintf("%s/eth/v1/node/version", b.beaconChainUrl)
+	logger.DebugWithPrefix(b.logPrefix, "GetClientVersion: url=%s", url)
+
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		logger.ErrorWithPrefix(b.logPrefix, "GetClientVersion: failed to create request: %v", err)
+		return "", err
+	}
+
+	resp, err := b.client.Do(req)
+	if err != nil {
+		logger.ErrorWithPrefix(b.logPrefix, "GetClientVersion: request failed: %v", err)
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		logger.ErrorWithPrefix(b.logPrefix, "GetClientVersion: non-200 status: %s", resp.Status)
+		return "", fmt.Errorf("beacon node version failed: %s", resp.Status)
+	}
+
+	var result struct {
+		Data struct {
+			Version string `json:"version"`
+		} `json:"data"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		logger.ErrorWithPrefix(b.logPrefix, "GetClientVersion: failed to decode response: %v", err)
+		return "", err
+	}
+
+	logger.DebugWithPrefix(b.logPrefix, "GetClientVersion: version=%s", result.Data.Version)
+	return result.Data.Version, nil
+}
+
 // GetValidatorsIndexes retrieves the validator index for each given pubkey with status active_ongoing
 func (b *BeaconchainAdapter) GetValidatorsIndexes(ctx context.Context, pubkeys []string) ([]string, error) {
 	url := fmt.Sprintf("%s/eth/v1/beacon/states/finalized/validators", b.beaconChainUrl)
diff --git a/internal/adapters/apis/execution/execution_adapter.go b/internal/adapters/apis/execution/execution_adapter.go
index e12e673..efd6e67 100644
--- a/internal/adapters/apis/execution/execution_adapter.go
+++ b/internal/adapters/apis/execution/execution_adapter.go
@@ -27,6 +27,56 @@ func NewExecutionAdapter(baseURL string) *ExecutionAdapter {
 	}
 }
 
+// GetClientVersion retrieves the version of the execution client
+// See: https://ethereum.github.io/execution-apis/api-documentation/ (web3_clientVersion)
+func (e *ExecutionAdapter) GetClientVersion(ctx context.Context) (string, error) {
+	url := e.baseURL
+	logger.DebugWithPrefix(e.logPrefix, "GetClientVersion: url=%s", url)
+
+	// JSON-RPC request body for web3_clientVersion
+	body := map[string]interface{}{
+		"jsonrpc": "2.0",
+		"method":  "web3_clientVersion",
+		"params":  []interface{}{},
+		"id":      1,
+	}
+	jsonBytes, err := json.Marshal(body)
+	if err != nil {
+		logger.ErrorWithPrefix(e.logPrefix, "GetClientVersion: failed to marshal body: %v", err)
+		return "", err
+	}
+
+	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonBytes))
+	if err != nil {
+		logger.ErrorWithPrefix(e.logPrefix, "GetClientVersion: failed to create request: %v", err)
+		return "", err
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := e.client.Do(req)
+	if err != nil {
+		logger.ErrorWithPrefix(e.logPrefix, "GetClientVersion: request failed: %v", err)
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		logger.ErrorWithPrefix(e.logPrefix, "GetClientVersion: non-200 status: %s", resp.Status)
+		return "", fmt.Errorf("web3_clientVersion failed: %s", resp.Status)
+	}
+
+	var rpcResp struct {
+		Result string `json:"result"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&rpcResp); err != nil {
+		logger.ErrorWithPrefix(e.logPrefix, "GetClientVersion: failed to decode response: %v", err)
+		return "", err
+	}
+
+	logger.DebugWithPrefix(e.logPrefix, "GetClientVersion: version=%s", rpcResp.Result)
+	return rpcResp.Result, nil
+}
+
 // GetIsSyncing retrieves the syncing status from the execution client with context
 func (e *ExecutionAdapter) GetIsSyncing(ctx context.Context) (bool, error) {
 	url := e.baseURL

From 1160d55a5072be6760029c47b45a452c7b353e21 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 17:32:10 +0100
Subject: [PATCH 15/42] implement version in snapshot

---
 .../apis/snapshots/snapshots_adapter.go       | 73 +++++++++++++------
 1 file changed, 49 insertions(+), 24 deletions(-)

diff --git a/internal/adapters/apis/snapshots/snapshots_adapter.go b/internal/adapters/apis/snapshots/snapshots_adapter.go
index 7345a0c..13a0489 100644
--- a/internal/adapters/apis/snapshots/snapshots_adapter.go
+++ b/internal/adapters/apis/snapshots/snapshots_adapter.go
@@ -2,6 +2,7 @@ package snapshots
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
@@ -66,6 +67,47 @@ func (s *SnapshotsAdapter) GetLatestBlockNumber(ctx context.Context, network, cl
 	return blockNumber, nil
 }
 
+// GetClientVersion fetches the client version used to generate the snapshot
+// The version is retrieved from the _snapshot_web3_clientVersion.json file
+func (s *SnapshotsAdapter) GetClientVersion(ctx context.Context, network, client, blockNumber string) (string, error) {
+	url := fmt.Sprintf("%s/%s/%s/%s/_snapshot_web3_clientVersion.json", s.baseURL, network, client, blockNumber)
+	logger.DebugWithPrefix(s.logPrefix, "Fetching client version from %s", url)
+
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to create request: %w", err)
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("failed to fetch client version: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("failed to fetch client version: status %s", resp.Status)
+	}
+
+	var result struct {
+		Result string `json:"result"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return "", fmt.Errorf("failed to decode client version response: %w", err)
+	}
+
+	logger.DebugWithPrefix(s.logPrefix, "Client version for %s/%s/%s: %s", network, client, blockNumber, result.Result)
+	return result.Result, nil
+}
+
+// GetLatestClientVersion fetches the client version for the latest available snapshot
+func (s *SnapshotsAdapter) GetLatestClientVersion(ctx context.Context, network, client string) (string, error) {
+	blockNumber, err := s.GetLatestBlockNumber(ctx, network, client)
+	if err != nil {
+		return "", fmt.Errorf("failed to get latest block number: %w", err)
+	}
+	return s.GetClientVersion(ctx, network, client, blockNumber)
+}
+
 // DownloadAndExtract downloads the snapshot for the given network/client and extracts it to targetPath
 // It uses a Docker container with alpine to handle the download and extraction
 func (s *SnapshotsAdapter) DownloadAndExtract(ctx context.Context, network, client, targetPath string) error {
@@ -82,11 +124,16 @@ func (s *SnapshotsAdapter) DownloadAndExtract(ctx context.Context, network, clie
 
 	// Build the shell command to run inside the alpine container
 	// This installs necessary tools, downloads the snapshot, and extracts it
+	// Optimizations:
+	// - zstd -T0: multi-threaded decompression using all CPU cores
+	// - No -v flag on tar: avoid printing every filename (major speedup)
+	// - Streaming: download and extraction happen in parallel via pipe
 	shellScript := fmt.Sprintf(`
 set -e
-apk add --no-cache wget curl tar zstd
+apk add --no-cache wget tar zstd
 echo "Downloading snapshot for block number: %s"
-wget --tries=0 --retry-connrefused -O - %s | tar -I zstd -xvf - -C /data
+echo "Using $(nproc) CPU cores for decompression"
+wget --tries=0 --retry-connrefused -O - %s | zstd -d -T0 | tar -xf - -C /data
 echo "Snapshot extraction complete"
 `, blockNumber, snapshotURL)
 
@@ -115,25 +162,3 @@ echo "Snapshot extraction complete"
 	logger.DebugWithPrefix(s.logPrefix, "Docker output:\n%s", string(output))
 	return nil
 }
-
-// GetSnapshotInfo returns information about the available snapshot for a network/client
-type SnapshotInfo struct {
-	Network     string
-	Client      string
-	BlockNumber string
-	URL         string
-}
-
-func (s *SnapshotsAdapter) GetSnapshotInfo(ctx context.Context, network, client string) (*SnapshotInfo, error) {
-	blockNumber, err := s.GetLatestBlockNumber(ctx, network, client)
-	if err != nil {
-		return nil, err
-	}
-
-	return &SnapshotInfo{
-		Network:     network,
-		Client:      client,
-		BlockNumber: blockNumber,
-		URL:         fmt.Sprintf("%s/%s/%s/%s/snapshot.tar.zst", s.baseURL, network, client, blockNumber),
-	}, nil
-}

From 87be941be073eede860367ee358dc7ecbd8f3deb Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 17:40:28 +0100
Subject: [PATCH 16/42] get versions and add them to therpor

---
 .../adapters/composite/ensurer/ensurer.go     | 54 ++++++++++++++
 internal/application/domain/report.go         | 73 +++++++++++++++++++
 2 files changed, 127 insertions(+)

diff --git a/internal/adapters/composite/ensurer/ensurer.go b/internal/adapters/composite/ensurer/ensurer.go
index 8ea877e..154615f 100644
--- a/internal/adapters/composite/ensurer/ensurer.go
+++ b/internal/adapters/composite/ensurer/ensurer.go
@@ -65,6 +65,18 @@ func timeOperation(report *domain.TestReport, operationName string, fn func() er
 func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig domain.StakerConfig, pkg domain.Pkg, report *domain.TestReport) error {
 	var volumeTarget string
 
+	// Determine what type of client is being tested
+	isExecutionTest := pkg.DnpName == stakerConfig.ExecutionDnpName
+	isConsensusTest := pkg.DnpName == stakerConfig.ConsensusDnpName
+
+	if isExecutionTest {
+		report.TestedClientType = "execution"
+		logger.InfoWithPrefix(logPrefix, "Testing execution client: %s", pkg.DnpName)
+	} else if isConsensusTest {
+		report.TestedClientType = "consensus"
+		logger.InfoWithPrefix(logPrefix, "Testing consensus client: %s", pkg.DnpName)
+	}
+
 	// SetStakerConfig
 	if err := timeOperation(report, "SetStakerConfig", func() error {
 		return e.DappManager.SetStakerConfig(ctx, stakerConfig)
@@ -72,6 +84,23 @@ func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig dom
 		return fmt.Errorf("failed to set staker config for DNP: %w", err)
 	}
 
+	// Capture client version BEFORE install (if client is already running)
+	if isExecutionTest {
+		if version, err := e.Execution.GetClientVersion(ctx); err == nil {
+			report.ExecutionClientVersionBefore = version
+			logger.InfoWithPrefix(logPrefix, "Execution client version before install: %s", version)
+		} else {
+			logger.DebugWithPrefix(logPrefix, "Could not get execution client version before install: %v", err)
+		}
+	} else if isConsensusTest {
+		if version, err := e.Beaconchain.GetClientVersion(ctx); err == nil {
+			report.ConsensusClientVersionBefore = version
+			logger.InfoWithPrefix(logPrefix, "Consensus client version before install: %s", version)
+		} else {
+			logger.DebugWithPrefix(logPrefix, "Could not get consensus client version before install: %v", err)
+		}
+	}
+
 	// PackageInstall
 	if err := timeOperation(report, "PackageInstall", func() error {
 		return e.DappManager.PackageInstall(ctx, pkg)
@@ -79,6 +108,23 @@ func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig dom
 		return fmt.Errorf("failed to install package: %w", err)
 	}
 
+	// Capture client version AFTER install
+	if isExecutionTest {
+		if version, err := e.Execution.GetClientVersion(ctx); err == nil {
+			report.ExecutionClientVersionAfter = version
+			logger.InfoWithPrefix(logPrefix, "Execution client version after install: %s", version)
+		} else {
+			logger.DebugWithPrefix(logPrefix, "Could not get execution client version after install: %v", err)
+		}
+	} else if isConsensusTest {
+		if version, err := e.Beaconchain.GetClientVersion(ctx); err == nil {
+			report.ConsensusClientVersionAfter = version
+			logger.InfoWithPrefix(logPrefix, "Consensus client version after install: %s", version)
+		} else {
+			logger.DebugWithPrefix(logPrefix, "Could not get consensus client version after install: %v", err)
+		}
+	}
+
 	// StopAndGetVolumeTarget
 	if err := timeOperation(report, "StopAndGetVolumeTarget", func() error {
 		var err error
@@ -88,6 +134,14 @@ func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig dom
 		return fmt.Errorf("failed to stop container and get volume: %w", err)
 	}
 
+	// Get snapshot client version before downloading
+	if version, err := e.Snapshots.GetLatestClientVersion(ctx, stakerConfig.Network, stakerConfig.ExecutionClientShortName); err == nil {
+		report.SnapshotClientVersion = version
+		logger.InfoWithPrefix(logPrefix, "Snapshot client version: %s", version)
+	} else {
+		logger.WarnWithPrefix(logPrefix, "Could not get snapshot client version: %v", err)
+	}
+
 	// DownloadAndExtractSnapshot
 	if err := timeOperation(report, "DownloadAndExtractSnapshot", func() error {
 		return e.Snapshots.DownloadAndExtract(ctx, stakerConfig.Network, stakerConfig.ExecutionClientShortName, volumeTarget)
diff --git a/internal/application/domain/report.go b/internal/application/domain/report.go
index 5f9e3b1..ec92335 100644
--- a/internal/application/domain/report.go
+++ b/internal/application/domain/report.go
@@ -29,6 +29,16 @@ type TestReport struct {
 	MevBoostDnpName   string `json:"mevBoostDnpName"`
 	Network           string `json:"network"`
 
+	// Client versions (before/after install)
+	ExecutionClientVersionBefore string `json:"executionClientVersionBefore,omitempty"`
+	ExecutionClientVersionAfter  string `json:"executionClientVersionAfter,omitempty"`
+	ConsensusClientVersionBefore string `json:"consensusClientVersionBefore,omitempty"`
+	ConsensusClientVersionAfter  string `json:"consensusClientVersionAfter,omitempty"`
+	SnapshotClientVersion        string `json:"snapshotClientVersion,omitempty"`
+
+	// What type of client is being tested
+	TestedClientType string `json:"testedClientType,omitempty"` // "execution" or "consensus"
+
 	// Test execution info
 	StartTime time.Time `json:"startTime"`
 	EndTime   time.Time `json:"endTime"`
@@ -133,6 +143,44 @@ func (r *TestReport) ToMarkdown() string {
 	sb.WriteString(fmt.Sprintf("| Network | `%s` |\n", r.Network))
 	sb.WriteString("\n")
 
+	// Version tracking section
+	if r.TestedClientType != "" {
+		sb.WriteString("### 🔖 Version Tracking\n\n")
+		if r.TestedClientType == "execution" {
+			sb.WriteString("**Tested Client:** Execution\n\n")
+			sb.WriteString("| Stage | Version |\n")
+			sb.WriteString("|-------|---------|\n")
+			if r.ExecutionClientVersionBefore != "" {
+				sb.WriteString(fmt.Sprintf("| Before Install | `%s` |\n", r.ExecutionClientVersionBefore))
+			} else {
+				sb.WriteString("| Before Install | _not available_ |\n")
+			}
+			if r.ExecutionClientVersionAfter != "" {
+				sb.WriteString(fmt.Sprintf("| After Install | `%s` |\n", r.ExecutionClientVersionAfter))
+			} else {
+				sb.WriteString("| After Install | _not available_ |\n")
+			}
+			if r.SnapshotClientVersion != "" {
+				sb.WriteString(fmt.Sprintf("| Snapshot | `%s` |\n", r.SnapshotClientVersion))
+			}
+		} else if r.TestedClientType == "consensus" {
+			sb.WriteString("**Tested Client:** Consensus\n\n")
+			sb.WriteString("| Stage | Version |\n")
+			sb.WriteString("|-------|---------|\n")
+			if r.ConsensusClientVersionBefore != "" {
+				sb.WriteString(fmt.Sprintf("| Before Install | `%s` |\n", r.ConsensusClientVersionBefore))
+			} else {
+				sb.WriteString("| Before Install | _not available_ |\n")
+			}
+			if r.ConsensusClientVersionAfter != "" {
+				sb.WriteString(fmt.Sprintf("| After Install | `%s` |\n", r.ConsensusClientVersionAfter))
+			} else {
+				sb.WriteString("| After Install | _not available_ |\n")
+			}
+		}
+		sb.WriteString("\n")
+	}
+
 	// Timing section
 	sb.WriteString("### ⏱️ Timing Measurements\n\n")
 
@@ -213,6 +261,31 @@ func (r *TestReport) ToConsoleString() string {
 	sb.WriteString(fmt.Sprintf("  Network:     %s\n", r.Network))
 	sb.WriteString("\n")
 
+	// Version tracking
+	if r.TestedClientType != "" {
+		sb.WriteString("VERSION TRACKING:\n")
+		sb.WriteString(fmt.Sprintf("  Tested Client Type: %s\n", r.TestedClientType))
+		if r.TestedClientType == "execution" {
+			if r.ExecutionClientVersionBefore != "" {
+				sb.WriteString(fmt.Sprintf("  Before Install:     %s\n", r.ExecutionClientVersionBefore))
+			}
+			if r.ExecutionClientVersionAfter != "" {
+				sb.WriteString(fmt.Sprintf("  After Install:      %s\n", r.ExecutionClientVersionAfter))
+			}
+			if r.SnapshotClientVersion != "" {
+				sb.WriteString(fmt.Sprintf("  Snapshot Version:   %s\n", r.SnapshotClientVersion))
+			}
+		} else if r.TestedClientType == "consensus" {
+			if r.ConsensusClientVersionBefore != "" {
+				sb.WriteString(fmt.Sprintf("  Before Install:     %s\n", r.ConsensusClientVersionBefore))
+			}
+			if r.ConsensusClientVersionAfter != "" {
+				sb.WriteString(fmt.Sprintf("  After Install:      %s\n", r.ConsensusClientVersionAfter))
+			}
+		}
+		sb.WriteString("\n")
+	}
+
 	// Timing
 	sb.WriteString("TIMING MEASUREMENTS:\n")
 	if len(r.EnsureTimings) > 0 {

From 0a6540e709ffa111f6ba0fae49e30b73f9a2407c Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 19 Jan 2026 18:59:50 +0100
Subject: [PATCH 17/42] remove unused getreport

---
 README.md                                    | 1 +
 internal/adapters/composite/composite.go     | 5 -----
 internal/application/ports/ports.go          | 1 -
 internal/application/services/test_runner.go | 5 -----
 4 files changed, 1 insertion(+), 11 deletions(-)

diff --git a/README.md b/README.md
index fe1685b..c454388 100644
--- a/README.md
+++ b/README.md
@@ -122,6 +122,7 @@ docker-compose up --build
 - [x] Measure the time it takes every process in the test and add it to the report
 - [x] Collect logs from containers and create a report
 - [x] Add to the report the clients used
+- [ ] Auto-updates for this dappnode must run much more often than production, so clients are always updated to latest versions
 - [ ] Research how to release this SDK tool to be run from a github action directly
 - [ ] Implement when manual trigger (`workflow_dispatch`) the clients will be passed as inputs, use them to create the staker config for the test
 - [ ] Implement edit of `/usr/src/dappnode/DNCORE/docker-compose.yml` file to add env `TEST=true` and relaunch compose
diff --git a/internal/adapters/composite/composite.go b/internal/adapters/composite/composite.go
index 5d6c8f2..d96bcb6 100644
--- a/internal/adapters/composite/composite.go
+++ b/internal/adapters/composite/composite.go
@@ -90,11 +90,6 @@ func (t *CompositeAdapter) CleanEnvironment(ctx context.Context, stakerConfig do
 	return t.cleaner.CleanEnvironment(ctx, stakerConfig)
 }
 
-// GetReport returns the current test report
-func (t *CompositeAdapter) GetReport() *domain.TestReport {
-	return t.report
-}
-
 // collectContainerErrorLogs collects error logs from all relevant containers
 func (t *CompositeAdapter) collectContainerErrorLogs(ctx context.Context, stakerConfig domain.StakerConfig, since, until time.Time) {
 	const maxLinesPerContainer = 3
diff --git a/internal/application/ports/ports.go b/internal/application/ports/ports.go
index 115ef0a..0b932af 100644
--- a/internal/application/ports/ports.go
+++ b/internal/application/ports/ports.go
@@ -9,5 +9,4 @@ type TestRunner interface {
 	EnsureEnvironment(ctx context.Context, stakerConfig domain.StakerConfig, pkg domain.Pkg) error
 	ExecuteTest(ctx context.Context, stakerConfig domain.StakerConfig) error
 	CleanEnvironment(context.Context, domain.StakerConfig) error
-	GetReport() *domain.TestReport
 }
diff --git a/internal/application/services/test_runner.go b/internal/application/services/test_runner.go
index e14b99d..328ea2f 100644
--- a/internal/application/services/test_runner.go
+++ b/internal/application/services/test_runner.go
@@ -40,8 +40,3 @@ func (s *TestRunnerService) RunTest(ctx context.Context, stakerConfig domain.Sta
 
 	return nil
 }
-
-// GetReport returns the test report from the runner
-func (s *TestRunnerService) GetReport() *domain.TestReport {
-	return s.Runner.GetReport()
-}

From 59e9a3ccd05f98d82db7a6ae1fb627c6d3fd22a2 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Wed, 21 Jan 2026 16:08:51 +0100
Subject: [PATCH 18/42] first implementation of snapshot checker

---
 README.md                                     |  27 +++
 cmd/snapshot-checker/main.go                  | 121 ++++++++++
 cmd/{ => test-runner}/main.go                 |   4 +-
 .../adapters/apis/docker/docker_adapter.go    |  20 ++
 .../apis/snapshots/snapshots_adapter.go       |  88 +++++--
 .../adapters/composite/ensurer/ensurer.go     |  35 +--
 .../shared/blocknumber/blocknumber_adapter.go | 123 ++++++++++
 .../shared/progress/progress_adapter.go       | 112 +++++++++
 internal/application/domain/docker_names.go   |  44 ++++
 internal/application/domain/snapshot.go       |  88 +++++++
 internal/application/domain/stakers.go        | 134 +---------
 .../application/services/snapshot_checker.go  | 228 ++++++++++++++++++
 internal/config/snapshot_checker_config.go    |  99 ++++++++
 .../{config.go => test_runner_config.go}      |  18 +-
 internal/config/utils.go                      |  14 ++
 15 files changed, 966 insertions(+), 189 deletions(-)
 create mode 100644 cmd/snapshot-checker/main.go
 rename cmd/{ => test-runner}/main.go (98%)
 create mode 100644 internal/adapters/shared/blocknumber/blocknumber_adapter.go
 create mode 100644 internal/adapters/shared/progress/progress_adapter.go
 create mode 100644 internal/application/domain/docker_names.go
 create mode 100644 internal/application/domain/snapshot.go
 create mode 100644 internal/application/services/snapshot_checker.go
 create mode 100644 internal/config/snapshot_checker_config.go
 rename internal/config/{config.go => test_runner_config.go} (84%)
 create mode 100644 internal/config/utils.go

diff --git a/README.md b/README.md
index c454388..f661b5d 100644
--- a/README.md
+++ b/README.md
@@ -118,18 +118,45 @@ docker-compose up --build
 ```
 
 ## TODO's
+
+- snapshot checker (cron that runs on startup and every 6h): ensures the Execution clients have the latest snapshots downloaded and mounted to their respective volumes
+  - Checks if snapshots exists for given clients and network
+    - If they dont exist then write temporary file `download_in_progress` to signal other processes that snapshot download is in progress and:
+      1. download snapshots
+      2. extract snapshots
+      3. mount snapshots to respective volumes 
+      4. Write the block number of the snapshot downloaded to a file `snapshot_block_number` inside the respective volume
+      5. remove temporary file `download_in_progress`
+    - If they do exist then check:
+      1. If file `download_in_progress` exists then exit
+      2. If file `snapshot_block_number` exists then check if the latest snapshot available is newer, if so redownload snapshot as above
+      3. If file `snapshot_block_number` does not exist then redownload snapshot as above
+- test runner: executed once per test (manually or on PR) 
+  - ensures environment before running tests
+    - among other things it must check if the file `download_in_progress` exits, if so the test must wait until it is removed
+  - runs tests
+  - cleanup environment after tests
+
 - [x] Implement a github adapter to interact with issues and PRs so we can automate report creation as well as the testing process.
 - [x] Measure the time it takes every process in the test and add it to the report
 - [x] Collect logs from containers and create a report
 - [x] Add to the report the clients used
+- [ ] Implement timer check in the snapshot checker
+- [ ] The test runner must remove the clients or unset the staker config on exit
+- [ ] Implement a composite adapter for the snapshot checker
+- [ ] Implement time tracker in the snapshot checker service to measure time taken for each action, specially download and extraction of snapshots
+- [ ] Implement snapshot cleaner on signal interrupt or termination to avoid corrupted snapshots
 - [ ] Auto-updates for this dappnode must run much more often than production, so clients are always updated to latest versions
 - [ ] Research how to release this SDK tool to be run from a github action directly
 - [ ] Implement when manual trigger (`workflow_dispatch`) the clients will be passed as inputs, use them to create the staker config for the test
 - [ ] Implement edit of `/usr/src/dappnode/DNCORE/docker-compose.yml` file to add env `TEST=true` and relaunch compose
 - [ ] Print version of the clients 
     - [ ] For the EC it must be printed
+- [ ] Add to the report the block of the snapshot used
 - [ ] Consider always removing beacon volumes to ensure avoiding old states of chain and always start with the checkpoint sync
 - [ ] Implement switch off of dappmanager cron that restarts containers of clients selected in stakers
 - [ ] Silent the tar output when extracting snapshots or make it less verbose
+- [ ] Consider adding a DB for reports and a UI to consume them
 - [ ] Consider adding to report beaconcha validator url
+- [ ] Consider adding support for multiple networks (mainnet, prater, etc.)
 - [ ] Consider setting keystore and password through github secrets.
\ No newline at end of file
diff --git a/cmd/snapshot-checker/main.go b/cmd/snapshot-checker/main.go
new file mode 100644
index 0000000..ab85f03
--- /dev/null
+++ b/cmd/snapshot-checker/main.go
@@ -0,0 +1,121 @@
+package main
+
+import (
+	"clients-test/internal/adapters/apis/docker"
+	"clients-test/internal/adapters/apis/snapshots"
+	"clients-test/internal/adapters/shared/blocknumber"
+	"clients-test/internal/adapters/shared/progress"
+	"clients-test/internal/application/domain"
+	"clients-test/internal/application/services"
+	"clients-test/internal/config"
+	"clients-test/internal/logger"
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"sort"
+	"strings"
+	"syscall"
+)
+
+var logPrefix = "SNAPSHOT_CHECKER"
+
+func main() {
+	logger.InfoWithPrefix(logPrefix, "Starting Snapshot Checker service")
+
+	// Parse and validate configuration
+	cfg := config.ParseSnapshotCheckerConfig()
+	cfg.Validate()
+
+	// Initialize domain config directly
+	snapshotConfig := domain.SnapshotCheckerConfig{
+		ExecutionClients: domain.GetExecutionClients(cfg.Network, cfg.ExecutionClients),
+		CronIntervalSec:  cfg.CronIntervalSec,
+		Network:          cfg.Network,
+	}
+
+	// Print configuration
+	printSnapshotCheckerConfig(logPrefix, snapshotConfig)
+
+	// Set up Ctrl+C (SIGINT) handler
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	sigs := make(chan os.Signal, 1)
+	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+
+	// Initialize adapters
+	snapshotsAdapter := snapshots.NewSnapshotsAdapter()
+	dockerAdapter, err := docker.NewDockerAdapter()
+	if err != nil {
+		logger.FatalWithPrefix(logPrefix, "Failed to init DockerAdapter: %v", err)
+	}
+	progressAdapter := progress.NewProgressAdapter()
+	blockNumberAdapter := blocknumber.NewBlockNumberAdapter()
+
+	// If a previous run crashed/was interrupted, the marker file can be left behind and block future runs.
+	// Clear it on startup so the service can recover.
+	if inProgress, err := progressAdapter.IsDownloadInProgress(ctx); err != nil {
+		logger.WarnWithPrefix(logPrefix, "Failed to check %s marker: %v", domain.ProgressFileName, err)
+	} else if inProgress {
+		logger.WarnWithPrefix(logPrefix, "Found stale %s marker; clearing it on startup", domain.ProgressFileName)
+		if err := progressAdapter.ClearDownloadInProgress(context.Background()); err != nil {
+			logger.WarnWithPrefix(logPrefix, "Failed to clear %s marker on startup: %v", domain.ProgressFileName, err)
+		}
+	}
+
+	go func() {
+		sig := <-sigs
+		logger.InfoWithPrefix(logPrefix, "Received signal: %v, shutting down...", sig)
+		// Stop any running download containers
+		snapshotsAdapter.StopAllDownloads(context.Background())
+		// Best-effort cleanup: clear marker file so next run isn't blocked.
+		if err := progressAdapter.ClearDownloadInProgress(context.Background()); err != nil {
+			logger.WarnWithPrefix(logPrefix, "Failed to clear %s marker on shutdown: %v", domain.ProgressFileName, err)
+		}
+		cancel()
+	}()
+
+	// Initialize and run the snapshot checker service
+	service := services.NewSnapshotCheckerService(
+		snapshotsAdapter,
+		dockerAdapter,
+		progressAdapter,
+		blockNumberAdapter,
+		snapshotConfig,
+	)
+
+	if err := service.Start(ctx, cfg.RunOnce); err != nil {
+		if err == context.Canceled {
+			logger.InfoWithPrefix(logPrefix, "Snapshot checker stopped gracefully")
+		} else {
+			logger.FatalWithPrefix(logPrefix, "Snapshot checker failed: %v", err)
+		}
+	}
+
+	logger.InfoWithPrefix(logPrefix, "Snapshot checker service stopped")
+}
+
+// helper to pretty print snapshot checker config
+func printSnapshotCheckerConfig(prefix string, sc domain.SnapshotCheckerConfig) {
+	clients := append([]domain.ExecutionClientInfo(nil), sc.ExecutionClients...)
+	sort.Slice(clients, func(i, j int) bool {
+		return clients[i].ShortName < clients[j].ShortName
+	})
+
+	var b strings.Builder
+	b.WriteString("SnapshotCheckerConfig:\n")
+	b.WriteString(fmt.Sprintf("  Network: %s\n", sc.Network))
+	b.WriteString(fmt.Sprintf("  CronIntervalSec: %d\n", sc.CronIntervalSec))
+	b.WriteString("  ExecutionClients:\n")
+	for _, c := range clients {
+		b.WriteString(fmt.Sprintf("    - ShortName: %s\n", c.ShortName))
+		b.WriteString(fmt.Sprintf("      DnpName: %s\n", c.DnpName))
+		b.WriteString(fmt.Sprintf("      VolumeName: %s\n", c.VolumeName))
+		b.WriteString(fmt.Sprintf("      ContainerName: %s\n", c.ContainerName))
+		b.WriteString(fmt.Sprintf("      VolumeTargetPath: %s\n", c.VolumeTargetPath))
+	}
+
+	msg := b.String()
+	logger.InfoWithPrefix(prefix, "%s", msg)
+}
diff --git a/cmd/main.go b/cmd/test-runner/main.go
similarity index 98%
rename from cmd/main.go
rename to cmd/test-runner/main.go
index 9a9561b..aa25458 100644
--- a/cmd/main.go
+++ b/cmd/test-runner/main.go
@@ -21,7 +21,7 @@ import (
 	"syscall"
 )
 
-var logPrefix = "MAIN"
+var logPrefix = "TEST_RUNNER"
 
 func main() {
 	logger.InfoWithPrefix(logPrefix, "Starting Notifications service")
@@ -117,7 +117,6 @@ func printStakerConfig(prefix string, sc domain.StakerConfig) {
   MevBoostDnpName: %s
   Network: %s
   ExecutionContainerName: %s
-  ExecutionClientShortName: %s
   Urls:
     ExecutionURL: %s
     BrainURL: %s
@@ -130,7 +129,6 @@ func printStakerConfig(prefix string, sc domain.StakerConfig) {
 		sc.MevBoostDnpName,
 		sc.Network,
 		sc.ExecutionContainerName,
-		sc.ExecutionClientShortName,
 		sc.Urls.ExecutionURL,
 		sc.Urls.BrainURL,
 		sc.Urls.BeaconchainURL,
diff --git a/internal/adapters/apis/docker/docker_adapter.go b/internal/adapters/apis/docker/docker_adapter.go
index 0ffa605..6e1eaf5 100644
--- a/internal/adapters/apis/docker/docker_adapter.go
+++ b/internal/adapters/apis/docker/docker_adapter.go
@@ -204,3 +204,23 @@ func (d *DockerAdapter) CollectAllContainerErrorLogs(ctx context.Context, contai
 
 	return result
 }
+
+// StopContainer stops a container by name
+func (d *DockerAdapter) StopContainer(ctx context.Context, containerName string) error {
+	logger.DebugWithPrefix(d.logPrefix, "StopContainer: stopping container %s", containerName)
+
+	// Check if container exists first
+	_, err := d.cli.ContainerInspect(ctx, containerName)
+	if err != nil {
+		logger.WarnWithPrefix(d.logPrefix, "StopContainer: container %s not found or not accessible: %v", containerName, err)
+		return nil // Return nil - container might not exist
+	}
+
+	if err := d.cli.ContainerStop(ctx, containerName, container.StopOptions{}); err != nil {
+		logger.ErrorWithPrefix(d.logPrefix, "StopContainer: failed to stop container: %v", err)
+		return fmt.Errorf("failed to stop container: %w", err)
+	}
+
+	logger.DebugWithPrefix(d.logPrefix, "StopContainer: stopped container %s", containerName)
+	return nil
+}
diff --git a/internal/adapters/apis/snapshots/snapshots_adapter.go b/internal/adapters/apis/snapshots/snapshots_adapter.go
index 13a0489..58feb9a 100644
--- a/internal/adapters/apis/snapshots/snapshots_adapter.go
+++ b/internal/adapters/apis/snapshots/snapshots_adapter.go
@@ -6,16 +6,19 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"os"
 	"os/exec"
 	"strings"
+	"sync"
 	"time"
 
 	"clients-test/internal/logger"
 )
 
 const (
-	defaultBaseURL = "https://snapshots.ethpandaops.io"
-	alpineImage    = "alpine:latest"
+	defaultBaseURL          = "https://snapshots.ethpandaops.io"
+	alpineImage             = "alpine:latest"
+	downloadContainerPrefix = "snapshot-download-"
 )
 
 type SnapshotsAdapter struct {
@@ -120,45 +123,96 @@ func (s *SnapshotsAdapter) DownloadAndExtract(ctx context.Context, network, clie
 	}
 
 	snapshotURL := fmt.Sprintf("%s/%s/%s/%s/snapshot.tar.zst", s.baseURL, network, client, blockNumber)
-	logger.InfoWithPrefix(s.logPrefix, "Downloading snapshot from %s", snapshotURL)
+	logger.InfoWithPrefix(s.logPrefix, "Downloading %s snapshot from %s", client, snapshotURL)
 
 	// Build the shell command to run inside the alpine container
 	// This installs necessary tools, downloads the snapshot, and extracts it
 	// Optimizations:
+	// - aria2c -x16 -s16: 16 parallel connections using HTTP range requests for faster download
 	// - zstd -T0: multi-threaded decompression using all CPU cores
 	// - No -v flag on tar: avoid printing every filename (major speedup)
-	// - Streaming: download and extraction happen in parallel via pipe
+	// Note: aria2c downloads to file first (can't stream with range requests), then we decompress
+	// This requires ~2x disk space temporarily but is significantly faster on high-bandwidth connections
 	shellScript := fmt.Sprintf(`
 set -e
-apk add --no-cache wget tar zstd
-echo "Downloading snapshot for block number: %s"
-echo "Using $(nproc) CPU cores for decompression"
-wget --tries=0 --retry-connrefused -O - %s | zstd -d -T0 | tar -xf - -C /data
-echo "Snapshot extraction complete"
-`, blockNumber, snapshotURL)
+apk add --no-cache aria2 tar zstd pv bash > /dev/null 2>&1
+echo "[%s] Downloading snapshot for block number: %s"
+echo "[%s] Using 16 parallel connections with HTTP range requests"
+aria2c -x16 -s16 --file-allocation=none --console-log-level=warn --summary-interval=30 --show-console-readout=false -d /data -o snapshot.tar.zst "%s" 2>&1 | awk '/^\[#/{print "[%s] " $0; fflush()}'
+echo "[%s] Download complete. Extracting with $(nproc) CPU cores..."
+bash -c 'pv -f -i 30 -N "%s" -ptebar /data/snapshot.tar.zst 2> >(tr "\r" "\n" >&2) | zstd -d -T0 | tar -xf - -C /data'
+rm -f /data/snapshot.tar.zst
+echo "[%s] Snapshot extraction complete"
+`, client, blockNumber, client, snapshotURL, client, client, client, client)
 
 	// Run docker command
-	// docker run --rm -v <targetPath>:/data alpine /bin/sh -c '<script>'
+	// docker run --rm --name <name> -v <targetPath>:/data alpine /bin/sh -c '<script>'
+	// --name allows us to stop the container on shutdown
+	// Note: we don't use -t (TTY) because multiple parallel downloads would overwrite each other's progress
+	// Instead, pv with -f outputs line-based progress that works well in parallel
+	containerName := fmt.Sprintf("%s%s", downloadContainerPrefix, client)
 	dockerArgs := []string{
 		"run", "--rm",
+		"--name", containerName,
 		"-v", fmt.Sprintf("%s:/data", targetPath),
 		"--entrypoint", "/bin/sh",
 		alpineImage,
 		"-c", shellScript,
 	}
 
-	logger.DebugWithPrefix(s.logPrefix, "Running docker command: docker %s", strings.Join(dockerArgs, " "))
-
 	start := time.Now()
 	cmd := exec.CommandContext(ctx, "docker", dockerArgs...)
-	output, err := cmd.CombinedOutput()
+	// Stream output in real-time instead of buffering until completion
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	err = cmd.Run()
 	if err != nil {
-		logger.ErrorWithPrefix(s.logPrefix, "Failed to download/extract snapshot: %v\n%s", err, string(output))
-		return fmt.Errorf("failed to download/extract snapshot: %w\n%s", err, string(output))
+		logger.ErrorWithPrefix(s.logPrefix, "Failed to download/extract snapshot: %v", err)
+		return fmt.Errorf("failed to download/extract snapshot: %w", err)
 	}
 	elapsed := time.Since(start)
 
 	logger.InfoWithPrefix(s.logPrefix, "Successfully downloaded and extracted snapshot to %s in %s", targetPath, elapsed)
-	logger.DebugWithPrefix(s.logPrefix, "Docker output:\n%s", string(output))
 	return nil
 }
+
+// StopAllDownloads stops all running snapshot download containers in parallel
+func (s *SnapshotsAdapter) StopAllDownloads(ctx context.Context) {
+	logger.InfoWithPrefix(s.logPrefix, "Stopping all snapshot download containers...")
+
+	// Find all containers with our prefix
+	listCmd := exec.CommandContext(ctx, "docker", "ps", "-q", "--filter", fmt.Sprintf("name=%s", downloadContainerPrefix))
+	output, err := listCmd.Output()
+	if err != nil {
+		logger.WarnWithPrefix(s.logPrefix, "Failed to list download containers: %v", err)
+		return
+	}
+
+	containerIDs := strings.TrimSpace(string(output))
+	if containerIDs == "" {
+		logger.DebugWithPrefix(s.logPrefix, "No download containers running")
+		return
+	}
+
+	// Stop all containers in parallel
+	ids := strings.Split(containerIDs, "\n")
+	var wg sync.WaitGroup
+	for _, id := range ids {
+		id = strings.TrimSpace(id)
+		if id == "" {
+			continue
+		}
+		wg.Add(1)
+		go func(containerID string) {
+			defer wg.Done()
+			logger.InfoWithPrefix(s.logPrefix, "Stopping download container %s", containerID)
+			stopCmd := exec.Command("docker", "stop", "-t", "5", containerID)
+			if err := stopCmd.Run(); err != nil {
+				logger.WarnWithPrefix(s.logPrefix, "Failed to stop container %s: %v", containerID, err)
+			}
+		}(id)
+	}
+	wg.Wait()
+
+	logger.InfoWithPrefix(s.logPrefix, "All download containers stopped")
+}
diff --git a/internal/adapters/composite/ensurer/ensurer.go b/internal/adapters/composite/ensurer/ensurer.go
index 154615f..e39f57d 100644
--- a/internal/adapters/composite/ensurer/ensurer.go
+++ b/internal/adapters/composite/ensurer/ensurer.go
@@ -60,11 +60,9 @@ func timeOperation(report *domain.TestReport, operationName string, fn func() er
 }
 
 // EnsureEnvironment validates the environment and prepares it for testing.
-// It sets the staker config, installs the package, stops the container, downloads the snapshot, and starts the container.
+// It sets the staker config and installs the package.
 // All operations are timed and recorded in the report.
 func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig domain.StakerConfig, pkg domain.Pkg, report *domain.TestReport) error {
-	var volumeTarget string
-
 	// Determine what type of client is being tested
 	isExecutionTest := pkg.DnpName == stakerConfig.ExecutionDnpName
 	isConsensusTest := pkg.DnpName == stakerConfig.ConsensusDnpName
@@ -125,36 +123,5 @@ func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig dom
 		}
 	}
 
-	// StopAndGetVolumeTarget
-	if err := timeOperation(report, "StopAndGetVolumeTarget", func() error {
-		var err error
-		volumeTarget, err = e.Docker.StopAndGetVolumeTarget(ctx, stakerConfig.ExecutionContainerName, stakerConfig.ExecutionVolumeName)
-		return err
-	}); err != nil {
-		return fmt.Errorf("failed to stop container and get volume: %w", err)
-	}
-
-	// Get snapshot client version before downloading
-	if version, err := e.Snapshots.GetLatestClientVersion(ctx, stakerConfig.Network, stakerConfig.ExecutionClientShortName); err == nil {
-		report.SnapshotClientVersion = version
-		logger.InfoWithPrefix(logPrefix, "Snapshot client version: %s", version)
-	} else {
-		logger.WarnWithPrefix(logPrefix, "Could not get snapshot client version: %v", err)
-	}
-
-	// DownloadAndExtractSnapshot
-	if err := timeOperation(report, "DownloadAndExtractSnapshot", func() error {
-		return e.Snapshots.DownloadAndExtract(ctx, stakerConfig.Network, stakerConfig.ExecutionClientShortName, volumeTarget)
-	}); err != nil {
-		return fmt.Errorf("failed to download and extract snapshot: %w", err)
-	}
-
-	// StartContainer
-	if err := timeOperation(report, "StartContainer", func() error {
-		return e.Docker.StartContainer(ctx, stakerConfig.ExecutionContainerName)
-	}); err != nil {
-		return fmt.Errorf("failed to start container: %w", err)
-	}
-
 	return nil
 }
diff --git a/internal/adapters/shared/blocknumber/blocknumber_adapter.go b/internal/adapters/shared/blocknumber/blocknumber_adapter.go
new file mode 100644
index 0000000..45beb0f
--- /dev/null
+++ b/internal/adapters/shared/blocknumber/blocknumber_adapter.go
@@ -0,0 +1,123 @@
+package blocknumber
+
+import (
+	"clients-test/internal/application/domain"
+	"clients-test/internal/logger"
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+var logPrefix = "BlockNumberAdapter"
+
+// BlockNumberAdapter handles the snapshot_block_number file operations
+type BlockNumberAdapter struct{}
+
+// NewBlockNumberAdapter creates a new BlockNumberAdapter
+func NewBlockNumberAdapter() *BlockNumberAdapter {
+	return &BlockNumberAdapter{}
+}
+
+// blockNumberFilePath returns the full path to the block number file inside a volume
+func (b *BlockNumberAdapter) blockNumberFilePath(volumeTargetPath string) string {
+	return filepath.Join(volumeTargetPath, domain.SnapshotBlockNumberFileName)
+}
+
+// WriteBlockNumber writes the block number to the snapshot_block_number file in the volume
+func (b *BlockNumberAdapter) WriteBlockNumber(ctx context.Context, volumeTargetPath string, blockNumber string) error {
+	filePath := b.blockNumberFilePath(volumeTargetPath)
+	logger.InfoWithPrefix(logPrefix, "Writing block number %s to %s", blockNumber, filePath)
+
+	// Ensure directory exists
+	if err := os.MkdirAll(volumeTargetPath, 0755); err != nil {
+		return fmt.Errorf("failed to create directory %s: %w", volumeTargetPath, err)
+	}
+
+	f, err := os.Create(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to create block number file: %w", err)
+	}
+	defer f.Close()
+
+	_, err = f.WriteString(blockNumber)
+	if err != nil {
+		return fmt.Errorf("failed to write to block number file: %w", err)
+	}
+
+	return nil
+}
+
+// ReadBlockNumber reads the block number from the snapshot_block_number file in the volume
+// Returns empty string if file doesn't exist
+func (b *BlockNumberAdapter) ReadBlockNumber(ctx context.Context, volumeTargetPath string) (string, error) {
+	filePath := b.blockNumberFilePath(volumeTargetPath)
+
+	data, err := os.ReadFile(filePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			logger.DebugWithPrefix(logPrefix, "Block number file does not exist at %s", filePath)
+			return "", nil
+		}
+		return "", fmt.Errorf("failed to read block number file: %w", err)
+	}
+
+	blockNumber := strings.TrimSpace(string(data))
+	logger.DebugWithPrefix(logPrefix, "Read block number %s from %s", blockNumber, filePath)
+	return blockNumber, nil
+}
+
+// BlockNumberExists checks if a block number file exists in the volume
+func (b *BlockNumberAdapter) BlockNumberExists(ctx context.Context, volumeTargetPath string) (bool, error) {
+	filePath := b.blockNumberFilePath(volumeTargetPath)
+	_, err := os.Stat(filePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("failed to check block number file: %w", err)
+	}
+	return true, nil
+}
+
+// CompareBlockNumbers compares two block numbers
+// Returns: -1 if a < b, 0 if a == b, 1 if a > b
+func (b *BlockNumberAdapter) CompareBlockNumbers(a, blockB string) int {
+	aInt, aErr := strconv.ParseInt(a, 10, 64)
+	bInt, bErr := strconv.ParseInt(blockB, 10, 64)
+
+	if aErr != nil || bErr != nil {
+		// Fall back to string comparison if not valid integers
+		if a < blockB {
+			return -1
+		} else if a > blockB {
+			return 1
+		}
+		return 0
+	}
+
+	if aInt < bInt {
+		return -1
+	} else if aInt > bInt {
+		return 1
+	}
+	return 0
+}
+
+// IsNewerSnapshot checks if the latest available block number is newer than the current one
+func (b *BlockNumberAdapter) IsNewerSnapshot(ctx context.Context, volumeTargetPath string, latestBlockNumber string) (bool, error) {
+	currentBlockNumber, err := b.ReadBlockNumber(ctx, volumeTargetPath)
+	if err != nil {
+		return false, err
+	}
+
+	// If no current block number, we need to download
+	if currentBlockNumber == "" {
+		return true, nil
+	}
+
+	// Compare block numbers
+	return b.CompareBlockNumbers(latestBlockNumber, currentBlockNumber) > 0, nil
+}
diff --git a/internal/adapters/shared/progress/progress_adapter.go b/internal/adapters/shared/progress/progress_adapter.go
new file mode 100644
index 0000000..8f3a460
--- /dev/null
+++ b/internal/adapters/shared/progress/progress_adapter.go
@@ -0,0 +1,112 @@
+package progress
+
+import (
+	"clients-test/internal/application/domain"
+	"clients-test/internal/logger"
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+var logPrefix = "ProgressAdapter"
+
+// ProgressAdapter handles the .download_in_progress file operations
+type ProgressAdapter struct {
+	basePath string
+}
+
+// NewProgressAdapter creates a new ProgressAdapter
+func NewProgressAdapter() *ProgressAdapter {
+	return &ProgressAdapter{
+		basePath: domain.SnapshotProgressPath,
+	}
+}
+
+// NewProgressAdapterWithPath creates a new ProgressAdapter with a custom base path (for testing)
+func NewProgressAdapterWithPath(basePath string) *ProgressAdapter {
+	return &ProgressAdapter{
+		basePath: basePath,
+	}
+}
+
+// progressFilePath returns the full path to the progress file
+func (p *ProgressAdapter) progressFilePath() string {
+	return filepath.Join(p.basePath, domain.ProgressFileName)
+}
+
+// SetDownloadInProgress creates the .download_in_progress file
+func (p *ProgressAdapter) SetDownloadInProgress(ctx context.Context) error {
+	filePath := p.progressFilePath()
+	logger.InfoWithPrefix(logPrefix, "Setting download in progress at %s", filePath)
+
+	if err := os.MkdirAll(p.basePath, 0755); err != nil {
+		return fmt.Errorf("failed to create directory %s: %w", p.basePath, err)
+	}
+
+	f, err := os.Create(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to create progress file: %w", err)
+	}
+	defer f.Close()
+
+	_, err = f.WriteString(time.Now().UTC().Format(time.RFC3339))
+	if err != nil {
+		return fmt.Errorf("failed to write to progress file: %w", err)
+	}
+
+	return nil
+}
+
+// ClearDownloadInProgress removes the .download_in_progress file
+func (p *ProgressAdapter) ClearDownloadInProgress(ctx context.Context) error {
+	filePath := p.progressFilePath()
+	logger.InfoWithPrefix(logPrefix, "Clearing download in progress at %s", filePath)
+
+	err := os.Remove(filePath)
+	if err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("failed to remove progress file: %w", err)
+	}
+
+	return nil
+}
+
+// IsDownloadInProgress checks if download is in progress
+func (p *ProgressAdapter) IsDownloadInProgress(ctx context.Context) (bool, error) {
+	filePath := p.progressFilePath()
+	_, err := os.Stat(filePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("failed to check progress file: %w", err)
+	}
+	return true, nil
+}
+
+// WaitForDownloadComplete waits until no download is in progress
+// Returns an error if the context is cancelled or times out
+func (p *ProgressAdapter) WaitForDownloadComplete(ctx context.Context, checkInterval time.Duration) error {
+	logger.InfoWithPrefix(logPrefix, "Waiting for downloads to complete")
+
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+			inProgress, err := p.IsDownloadInProgress(ctx)
+			if err != nil {
+				return fmt.Errorf("error checking download progress: %w", err)
+			}
+
+			if !inProgress {
+				logger.InfoWithPrefix(logPrefix, "No downloads in progress, continuing")
+				return nil
+			}
+
+			logger.InfoWithPrefix(logPrefix, "Download in progress, waiting %v...", checkInterval)
+			time.Sleep(checkInterval)
+		}
+	}
+}
diff --git a/internal/application/domain/docker_names.go b/internal/application/domain/docker_names.go
new file mode 100644
index 0000000..d7f30d2
--- /dev/null
+++ b/internal/application/domain/docker_names.go
@@ -0,0 +1,44 @@
+package domain
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Utility to get the servicename from a execution client (this utility assumes the service name is the first part of the dnp name)
+// e.g hoodi-nethermind.dnp.dappnode.eth -> nethermind
+// e.g nethermind-hoodi.dnp.dappnode.eth -> nethermind
+// e.g nethermind-hoodi.public.dappnode.eth -> nethermind
+// e.g geth.dnp.dappnode.eth -> geth
+// e.g reth-gnosis.dnp.dappnode.eth -> reth
+// e.g gnosis-reth.dnp.dappnode.eth -> reth
+func serviceNameFromExecutionClient(dnpName, network string) string {
+	trimmed := strings.TrimSuffix(dnpName, ".dnp.dappnode.eth")
+	trimmed = strings.TrimSuffix(trimmed, ".public.dappnode.eth")
+	parts := strings.Split(trimmed, "-")
+
+	// If there is only one part, return it
+	if len(parts) == 1 {
+		return parts[0]
+	}
+	// If there are multiple parts, find and remove the network part
+	for i, part := range parts {
+		if part == network {
+			parts = append(parts[:i], parts[i+1:]...)
+			break
+		}
+	}
+	// Return the remaining parts joined by "-"
+	return strings.Join(parts, "-")
+}
+
+// Utility to get the container name from service and dnpName. append dnp or public suffix depending on original dnpName
+func containerName(serviceName, dnpName string) string {
+	return fmt.Sprintf("DAppNodePackage-%s.%s", serviceName, dnpName)
+}
+
+// Utility to get the docker volume name from dnpName and compose volume name
+// i.e hoodi-nethermind.dnp.dappnode.eth -> hoodi-netherminddnpdappnodeeth_<composeVolumeName>
+func composeVolumeName(dnpName, composeVolumeName string) string {
+	return fmt.Sprintf("%s_%s", strings.ReplaceAll(dnpName, ".", ""), composeVolumeName)
+}
diff --git a/internal/application/domain/snapshot.go b/internal/application/domain/snapshot.go
new file mode 100644
index 0000000..4334088
--- /dev/null
+++ b/internal/application/domain/snapshot.go
@@ -0,0 +1,88 @@
+package domain
+
+import (
+	"fmt"
+)
+
+// ExecutionClientInfo contains the information for an execution client
+type ExecutionClientInfo struct {
+	ShortName        string // geth, nethermind, reth, besu, erigon
+	DnpName          string // hoodi-nethermind.dnp.dappnode.eth
+	VolumeName       string // Docker volume name
+	ContainerName    string // Docker container name
+	VolumeTargetPath string // Path to the volume data (/var/lib/docker/volumes/...)
+}
+
+// SnapshotCheckerConfig contains the configuration for the snapshot checker
+type SnapshotCheckerConfig struct {
+	ExecutionClients []ExecutionClientInfo // List of execution clients to manage
+	CronIntervalSec  int                   // Interval between snapshot checks in seconds (default 6 hours)
+	Network          string                // Network name (e.g., hoodi)
+}
+
+// ValidExecutionClients contains all valid execution client short names for hoodi
+var ValidExecutionClients = []string{"geth", "nethermind", "reth", "besu", "erigon"}
+
+// SnapshotProgressPath is the directory for progress files
+const SnapshotProgressPath = "/usr/src/dappnode/DNCORE"
+
+// ProgressFileName is the name of the download in progress file
+const ProgressFileName = ".download_in_progress"
+
+// SnapshotBlockNumberFileName returns the snapshot block number file name
+const SnapshotBlockNumberFileName = "snapshot_block_number"
+
+// GetExecutionClients returns the execution client info for hoodi network
+func GetExecutionClients(network string, selectedClients []string) []ExecutionClientInfo {
+	allClients := map[string]string{
+		"reth": "hoodi-reth.dnp.dappnode.eth",
+		"geth": "hoodi-geth.dnp.dappnode.eth",
+		// "besu":       "hoodi-besu.dnp.dappnode.eth",
+		// "erigon":     "hoodi-erigon.dnp.dappnode.eth",
+		"nethermind": "hoodi-nethermind.dnp.dappnode.eth",
+	}
+
+	// Filter to selected clients or return all
+	var result []ExecutionClientInfo
+	for shortName, dnpName := range allClients {
+		if len(selectedClients) == 0 || containsString(selectedClients, shortName) {
+			serviceName := serviceNameFromExecutionClient(dnpName, network)
+			// reth and geth use different volume names than data
+			// - reth: https://github.com/dappnode/DAppNodePackage-reth-generic/blob/0de584dafd9b07fe24090f7e1cb96aa7f9108769/docker-compose.yml#L18
+			// - geth: https://github.com/dappnode/DAppNodePackage-geth-generic/blob/1b9ed0da445e8599e7182a083cb3ffc98bf6b289/package_variants/hoodi/docker-compose.yml#L16
+			var volumeArg string
+			if shortName == "geth" || shortName == "reth" {
+				volumeArg = shortName
+			} else {
+				volumeArg = "data"
+			}
+			volumeName := composeVolumeName(dnpName, volumeArg)
+			volumeTargetPath := fmt.Sprintf("/var/lib/docker/volumes/%s/_data", volumeName)
+
+			result = append(result, ExecutionClientInfo{
+				ShortName:        shortName,
+				DnpName:          dnpName,
+				VolumeName:       volumeName,
+				ContainerName:    containerName(serviceName, dnpName),
+				VolumeTargetPath: volumeTargetPath,
+			})
+		}
+	}
+
+	return result
+}
+
+// IsValidExecutionClient checks if a client name is valid
+func IsValidExecutionClient(client string) bool {
+	return containsString(ValidExecutionClients, client)
+}
+
+// containsString checks if a string slice contains a value
+func containsString(slice []string, value string) bool {
+	for _, v := range slice {
+		if v == value {
+			return true
+		}
+	}
+	return false
+}
diff --git a/internal/application/domain/stakers.go b/internal/application/domain/stakers.go
index a5e00c7..c592a95 100644
--- a/internal/application/domain/stakers.go
+++ b/internal/application/domain/stakers.go
@@ -1,7 +1,6 @@
 package domain
 
 import (
-	"fmt"
 	"math/rand"
 	"strings"
 	"time"
@@ -20,8 +19,6 @@ type StakerConfig struct {
 	BeaconchainContainerName string // The name of the beaconchain container
 	ValidatorContainerName   string // The name of the validator container
 	ExecutionContainerName   string // The name of the container to mount the NFS volume to
-	ExecutionVolumeName      string // The name of the volume to mount for execution client data
-	ExecutionClientShortName string // Short name of the execution client (e.g., geth, nethermind, reth)
 }
 
 type Urls struct {
@@ -34,76 +31,23 @@ type Urls struct {
 const dappmanagerURL = "http://dappmanager.dappnode:7000"
 
 func StakerConfigForNetwork(pkg Pkg) StakerConfig {
-	network := getNetworkFromDnpName(pkg.DnpName)
-	var execClients, consClients []string
-	var web3signer, mevboost string
-	var relays []string = nil
-	var urls Urls
-
-	switch network {
-	case "gnosis":
-		execClients = []string{"nethermind-xdai.dnp.dappnode.eth", "gnosis-erigon.dnp.dappnode.eth"}
-		consClients = []string{"lighthouse-gnosis.dnp.dappnode.eth", "teku-gnosis.dnp.dappnode.eth", "nimbus-gnosis.dnp.dappnode.eth", "lodestar-gnosis.dnp.dappnode.eth"}
-		web3signer = "web3signer-hoodi.dnp.dappnode.eth"
-		mevboost = "mev-boost-hoodi.dnp.dappnode.eth"
-		relays = []string{}
-		urls = Urls{
-			ExecutionURL:   "http://execution.gnosis.dncore.dappnode:8545",
-			BrainURL:       "http://brain.web3signer-gnosis.dappnode:5000",
-			BeaconchainURL: "http://beacon-chain.gnosis.dncore.dappnode:3500",
-			DappmanagerURL: dappmanagerURL,
-		}
-	case "mainnet":
-		execClients = []string{"nethermind.public.dappnode.eth", "geth.dnp.dappnode.eth", "erigon.dnp.dappnode.eth", "reth.dnp.dappnode.eth", "besu.public.dappnode.eth"}
-		consClients = []string{"lighthouse.dnp.dappnode.eth", "prysm.dnp.dappnode.eth", "lodestar.dnp.dappnode.eth", "nimbus.dnp.dappnode.eth", "teku.dnp.dappnode.eth"}
-		web3signer = "web3signer.dnp.dappnode.eth"
-		mevboost = "mev-boost.dnp.dappnode.eth"
-		relays = []string{}
-		urls = Urls{
-			ExecutionURL:   "http://execution.mainnet.dncore.dappnode:8545",
-			BrainURL:       "http://brain.web3signer.dappnode:5000",
-			BeaconchainURL: "http://beacon-chain.mainnet.dncore.dappnode:3500",
-			DappmanagerURL: dappmanagerURL,
-		}
-	case "lukso":
-		execClients = []string{"lukso-geth.dnp.dappnode.eth"}
-		consClients = []string{"prysm-lukso.dnp.dappnode.eth", "teku-luks.dnp.dappnode.eth"}
-		web3signer = "web3signer-lukso.dnp.dappnode.eth"
-		mevboost = "mev-boost-lukso.dnp.dappnode.eth"
-		relays = []string{}
-		urls = Urls{
-			ExecutionURL:   "http://execution.lukso.dncore.dappnode:8545",
-			BrainURL:       "http://brain.web3signer-lukso.dappnode:5000",
-			BeaconchainURL: "http://beacon-chain.lukso.dncore.dappnode:3500",
-			DappmanagerURL: dappmanagerURL,
-		}
-	case "hoodi":
-		execClients = []string{"hoodi-reth.dnp.dappnode.eth", "hoodi-geth.dnp.dappnode.eth", "hoodi-besu.dnp.dappnode.eth", "hoodi-erigon.dnp.dappnode.eth", "hoodi-nethermind.dnp.dappnode.eth"}
-		consClients = []string{"prysm-hoodi.dnp.dappnode.eth", "teku-hoodi.dnp.dappnode.eth", "nimbus-hoodi.dnp.dappnode.eth", "lodestar-hoodi.dnp.dappnode.eth"}
-		web3signer = "web3signer-hoodi.dnp.dappnode.eth"
-		mevboost = "mev-boost-hoodi.dnp.dappnode.eth"
-		relays = []string{}
-		urls = Urls{
-			ExecutionURL:   "http://execution.hoodi.dncore.dappnode:8545",
-			BrainURL:       "http://brain.web3signer-hoodi.dappnode:5000",
-			BeaconchainURL: "http://beacon-chain.hoodi.dncore.dappnode:3500",
-			DappmanagerURL: dappmanagerURL,
-		}
+	// Only hoodi network is supported
+	network := "hoodi"
+	execClients := []string{"hoodi-reth.dnp.dappnode.eth", "hoodi-geth.dnp.dappnode.eth", "hoodi-besu.dnp.dappnode.eth", "hoodi-erigon.dnp.dappnode.eth", "hoodi-nethermind.dnp.dappnode.eth"}
+	consClients := []string{"prysm-hoodi.dnp.dappnode.eth", "teku-hoodi.dnp.dappnode.eth", "nimbus-hoodi.dnp.dappnode.eth", "lodestar-hoodi.dnp.dappnode.eth"}
+	web3signer := "web3signer-hoodi.dnp.dappnode.eth"
+	mevboost := "mev-boost-hoodi.dnp.dappnode.eth"
+	relays := []string{}
+	urls := Urls{
+		ExecutionURL:   "http://execution.hoodi.dncore.dappnode:8545",
+		BrainURL:       "http://brain.web3signer-hoodi.dappnode:5000",
+		BeaconchainURL: "http://beacon-chain.hoodi.dncore.dappnode:3500",
+		DappmanagerURL: dappmanagerURL,
 	}
 
 	ecDnpName := matchOrRandom(pkg.DnpName, execClients)
 	ccDnpName := matchOrRandom(pkg.DnpName, consClients)
 
-	// List of known execution client short names
-	ecShortNames := []string{"geth", "nethermind", "erigon", "reth", "besu"}
-	ecShortDnpName := "unknown"
-	for _, short := range ecShortNames {
-		if strings.Contains(ecDnpName, short) {
-			ecShortDnpName = short
-			break
-		}
-	}
-
 	return StakerConfig{
 		ExecutionDnpName:         ecDnpName,
 		ConsensusDnpName:         ccDnpName,
@@ -117,22 +61,6 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 		BeaconchainContainerName: containerName("beacon-chain", ccDnpName),
 		ValidatorContainerName:   containerName("validator", ccDnpName),
 		ExecutionContainerName:   containerName(serviceNameFromExecutionClient(ecDnpName, network), ecDnpName),
-		ExecutionVolumeName:      composeVolumeName(pkg.DnpName, pkg.ComposeVolumeName),
-		ExecutionClientShortName: ecShortDnpName,
-	}
-}
-
-func getNetworkFromDnpName(dnpName string) string {
-	name := strings.ToLower(dnpName)
-	switch {
-	case strings.Contains(name, "gnosis"):
-		return "gnosis"
-	case strings.Contains(name, "hoodi"):
-		return "hoodi"
-	case strings.Contains(name, "lukso"):
-		return "lukso"
-	default:
-		return "mainnet"
 	}
 }
 
@@ -148,41 +76,3 @@ func matchOrRandom(dnpName string, candidates []string) string {
 	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	return candidates[r.Intn(len(candidates))]
 }
-
-// Utility to get the servicename from a execution client (this utility assumes the service name is the first part of the dnp name)
-// e.g hoodi-nethermind.dnp.dappnode.eth -> nethermind
-// e.g nethermind-hoodi.dnp.dappnode.eth -> nethermind
-// e.g nethermind-hoodi.public.dappnode.eth -> nethermind
-// e.g geth.dnp.dappnode.eth -> geth
-// e.g reth-gnosis.dnp.dappnode.eth -> reth
-// e.g gnosis-reth.dnp.dappnode.eth -> reth
-func serviceNameFromExecutionClient(dnpName, network string) string {
-	trimmed := strings.TrimSuffix(dnpName, ".dnp.dappnode.eth")
-	trimmed = strings.TrimSuffix(trimmed, ".public.dappnode.eth")
-	parts := strings.Split(trimmed, "-")
-
-	// If there is only one part, return it
-	if len(parts) == 1 {
-		return parts[0]
-	}
-	// If there are multiple parts, find and remove the network part
-	for i, part := range parts {
-		if part == network {
-			parts = append(parts[:i], parts[i+1:]...)
-			break
-		}
-	}
-	// Return the remaining parts joined by "-"
-	return strings.Join(parts, "-")
-}
-
-// Utility to get the container name from service and dnpName. append dnp or public suffix depending on original dnpName
-func containerName(serviceName, dnpName string) string {
-	return fmt.Sprintf("DAppNodePackage-%s.%s", serviceName, dnpName)
-}
-
-// Utility to get the docker volume name from dnpName and compose volume name
-// i.e hoodi-nethermind.dnp.dappnode.eth -> hoodi-netherminddnpdappnodeeth_<composeVolumeName>
-func composeVolumeName(dnpName, composeVolumeName string) string {
-	return fmt.Sprintf("%s_%s", strings.ReplaceAll(dnpName, ".", ""), composeVolumeName)
-}
diff --git a/internal/application/services/snapshot_checker.go b/internal/application/services/snapshot_checker.go
new file mode 100644
index 0000000..2eaa9bc
--- /dev/null
+++ b/internal/application/services/snapshot_checker.go
@@ -0,0 +1,228 @@
+package services
+
+import (
+	"clients-test/internal/adapters/apis/docker"
+	"clients-test/internal/adapters/apis/snapshots"
+	"clients-test/internal/adapters/shared/blocknumber"
+	"clients-test/internal/adapters/shared/progress"
+	"clients-test/internal/application/domain"
+	"clients-test/internal/logger"
+	"context"
+	"fmt"
+	"sync"
+	"time"
+)
+
+var snapshotLogPrefix = "SnapshotChecker"
+
+// SnapshotCheckerService handles snapshot checking and downloading
+type SnapshotCheckerService struct {
+	snapshots   *snapshots.SnapshotsAdapter
+	docker      *docker.DockerAdapter
+	progress    *progress.ProgressAdapter
+	blockNumber *blocknumber.BlockNumberAdapter
+	config      domain.SnapshotCheckerConfig
+}
+
+// NewSnapshotCheckerService creates a new SnapshotCheckerService
+func NewSnapshotCheckerService(
+	snapshotsAdapter *snapshots.SnapshotsAdapter,
+	dockerAdapter *docker.DockerAdapter,
+	progressAdapter *progress.ProgressAdapter,
+	blockNumberAdapter *blocknumber.BlockNumberAdapter,
+	config domain.SnapshotCheckerConfig,
+) *SnapshotCheckerService {
+	return &SnapshotCheckerService{
+		snapshots:   snapshotsAdapter,
+		docker:      dockerAdapter,
+		progress:    progressAdapter,
+		blockNumber: blockNumberAdapter,
+		config:      config,
+	}
+}
+
+// Start starts the snapshot checker cron job
+func (s *SnapshotCheckerService) Start(ctx context.Context, runOnce bool) error {
+	logger.InfoWithPrefix(snapshotLogPrefix, "Starting snapshot checker for network: %s", s.config.Network)
+	logger.InfoWithPrefix(snapshotLogPrefix, "Managing %d execution clients", len(s.config.ExecutionClients))
+
+	// Run immediately on startup
+	if err := s.CheckAndUpdateSnapshots(ctx); err != nil {
+		logger.ErrorWithPrefix(snapshotLogPrefix, "Initial snapshot check failed: %v", err)
+		// Return error on initial failure to avoid waiting the cron interval
+		return err
+	}
+
+	if runOnce {
+		logger.InfoWithPrefix(snapshotLogPrefix, "Run-once mode, exiting after initial check")
+		return nil
+	}
+
+	// Start cron loop
+	ticker := time.NewTicker(time.Duration(s.config.CronIntervalSec) * time.Second)
+	defer ticker.Stop()
+
+	logger.InfoWithPrefix(snapshotLogPrefix, "Cron job scheduled every %d seconds (%s)",
+		s.config.CronIntervalSec, time.Duration(s.config.CronIntervalSec)*time.Second)
+
+	for {
+		select {
+		case <-ctx.Done():
+			logger.InfoWithPrefix(snapshotLogPrefix, "Snapshot checker stopped: %v", ctx.Err())
+			return ctx.Err()
+		case <-ticker.C:
+			logger.InfoWithPrefix(snapshotLogPrefix, "Running scheduled snapshot check")
+			if err := s.CheckAndUpdateSnapshots(ctx); err != nil {
+				logger.ErrorWithPrefix(snapshotLogPrefix, "Scheduled snapshot check failed: %v", err)
+				// Continue running even on failure
+			}
+		}
+	}
+}
+
+// CheckAndUpdateSnapshots checks all configured clients and updates snapshots as needed
+func (s *SnapshotCheckerService) CheckAndUpdateSnapshots(ctx context.Context) error {
+	logger.InfoWithPrefix(snapshotLogPrefix, "Checking snapshots for %d clients", len(s.config.ExecutionClients))
+
+	// Check if a download is already in progress
+	inProgress, err := s.progress.IsDownloadInProgress(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to check download progress: %w", err)
+	}
+	if inProgress {
+		logger.InfoWithPrefix(snapshotLogPrefix, "Download already in progress, skipping this cycle")
+		return nil
+	}
+
+	// Set download in progress for this cycle
+	if err := s.progress.SetDownloadInProgress(ctx); err != nil {
+		return fmt.Errorf("failed to set download in progress: %w", err)
+	}
+
+	// Ensure we clear the progress file on completion (success or failure)
+	defer func() {
+		if err := s.progress.ClearDownloadInProgress(ctx); err != nil {
+			logger.ErrorWithPrefix(snapshotLogPrefix, "Failed to clear download in progress: %v", err)
+		} else {
+			logger.InfoWithPrefix(snapshotLogPrefix, "Cleared download in progress file")
+		}
+	}()
+
+	// Process clients in parallel using goroutines
+	var wg sync.WaitGroup
+	errChan := make(chan error, len(s.config.ExecutionClients))
+
+	for _, client := range s.config.ExecutionClients {
+		wg.Add(1)
+		go func(client domain.ExecutionClientInfo) {
+			defer wg.Done()
+			if err := s.checkAndUpdateClient(ctx, client); err != nil {
+				errChan <- fmt.Errorf("client %s: %w", client.ShortName, err)
+			}
+		}(client)
+	}
+
+	wg.Wait()
+	close(errChan)
+
+	// Collect errors
+	var errors []error
+	for err := range errChan {
+		errors = append(errors, err)
+	}
+
+	if len(errors) > 0 {
+		logger.ErrorWithPrefix(snapshotLogPrefix, "Snapshot check completed with %d errors", len(errors))
+		return fmt.Errorf("snapshot check had %d errors: %v", len(errors), errors)
+	}
+
+	logger.InfoWithPrefix(snapshotLogPrefix, "Snapshot check completed successfully")
+	return nil
+}
+
+// checkAndUpdateClient checks a single client and updates snapshot if needed
+func (s *SnapshotCheckerService) checkAndUpdateClient(ctx context.Context, client domain.ExecutionClientInfo) error {
+	logger.InfoWithPrefix(snapshotLogPrefix, "Checking client: %s (%s)", client.ShortName, client.DnpName)
+
+	// Get latest available block number from ethpandaops
+	latestBlockNumber, err := s.snapshots.GetLatestBlockNumber(ctx, s.config.Network, client.ShortName)
+	if err != nil {
+		return fmt.Errorf("failed to get latest block number: %w", err)
+	}
+	logger.InfoWithPrefix(snapshotLogPrefix, "Latest available snapshot for %s: block %s", client.ShortName, latestBlockNumber)
+
+	// Check if we need to download
+	needsDownload, err := s.needsSnapshotDownload(ctx, client, latestBlockNumber)
+	if err != nil {
+		return fmt.Errorf("failed to check if snapshot needed: %w", err)
+	}
+
+	if !needsDownload {
+		logger.InfoWithPrefix(snapshotLogPrefix, "Snapshot for %s is up to date, skipping", client.ShortName)
+		return nil
+	}
+
+	// Download and mount snapshot
+	if err := s.downloadAndMountSnapshot(ctx, client, latestBlockNumber); err != nil {
+		return fmt.Errorf("failed to download and mount snapshot: %w", err)
+	}
+
+	return nil
+}
+
+// needsSnapshotDownload determines if a snapshot needs to be downloaded
+func (s *SnapshotCheckerService) needsSnapshotDownload(ctx context.Context, client domain.ExecutionClientInfo, latestBlockNumber string) (bool, error) {
+	// Check if block number file exists
+	exists, err := s.blockNumber.BlockNumberExists(ctx, client.VolumeTargetPath)
+	if err != nil {
+		return false, err
+	}
+
+	if !exists {
+		logger.InfoWithPrefix(snapshotLogPrefix, "No existing snapshot for %s, download needed", client.ShortName)
+		return true, nil
+	}
+
+	// Check if newer snapshot is available
+	isNewer, err := s.blockNumber.IsNewerSnapshot(ctx, client.VolumeTargetPath, latestBlockNumber)
+	if err != nil {
+		return false, err
+	}
+
+	if isNewer {
+		currentBlock, _ := s.blockNumber.ReadBlockNumber(ctx, client.VolumeTargetPath)
+		logger.InfoWithPrefix(snapshotLogPrefix, "Newer snapshot available for %s: current=%s, latest=%s",
+			client.ShortName, currentBlock, latestBlockNumber)
+		return true, nil
+	}
+
+	return false, nil
+}
+
+// downloadAndMountSnapshot performs the complete snapshot download and mount process
+func (s *SnapshotCheckerService) downloadAndMountSnapshot(ctx context.Context, client domain.ExecutionClientInfo, blockNumber string) error {
+	logger.InfoWithPrefix(snapshotLogPrefix, "Starting snapshot download for %s (block %s)", client.ShortName, blockNumber)
+
+	// 1. Stop the container (if running)
+	logger.InfoWithPrefix(snapshotLogPrefix, "Stopping container %s", client.ContainerName)
+	if err := s.docker.StopContainer(ctx, client.ContainerName); err != nil {
+		// Log but don't fail - container might not exist or not be running
+		logger.WarnWithPrefix(snapshotLogPrefix, "Could not stop container %s: %v", client.ContainerName, err)
+	}
+
+	// 2. Download and extract snapshot to volume
+	logger.InfoWithPrefix(snapshotLogPrefix, "Downloading and extracting snapshot to %s", client.VolumeTargetPath)
+	if err := s.snapshots.DownloadAndExtract(ctx, s.config.Network, client.ShortName, client.VolumeTargetPath); err != nil {
+		return fmt.Errorf("failed to download and extract snapshot: %w", err)
+	}
+
+	// 3. Write block number file
+	if err := s.blockNumber.WriteBlockNumber(ctx, client.VolumeTargetPath, blockNumber); err != nil {
+		return fmt.Errorf("failed to write block number: %w", err)
+	}
+
+	logger.InfoWithPrefix(snapshotLogPrefix, "Successfully downloaded and mounted snapshot for %s (block %s)",
+		client.ShortName, blockNumber)
+
+	return nil
+}
diff --git a/internal/config/snapshot_checker_config.go b/internal/config/snapshot_checker_config.go
new file mode 100644
index 0000000..529b61c
--- /dev/null
+++ b/internal/config/snapshot_checker_config.go
@@ -0,0 +1,99 @@
+package config
+
+import (
+	"clients-test/internal/application/domain"
+	"clients-test/internal/logger"
+	"flag"
+	"os"
+	"strings"
+)
+
+var snapshotLogPrefix = "SnapshotCheckerConfig"
+
+// SnapshotCheckerAppConfig holds all application configuration for snapshot checker
+type SnapshotCheckerAppConfig struct {
+	ExecutionClients []string
+	Network          string
+	CronIntervalSec  int
+	RunOnce          bool // If true, run once and exit (for testing)
+}
+
+// DefaultCronIntervalSec is 6 hours in seconds
+const DefaultCronIntervalSec = 6 * 60 * 60
+
+// ParseSnapshotCheckerConfig parses CLI flags and environment variables into a SnapshotCheckerAppConfig
+func ParseSnapshotCheckerConfig() SnapshotCheckerAppConfig {
+	// CLI flags
+	executionClients := flag.String("execution-clients", "", "Comma-separated list of execution clients (geth, nethermind, reth, besu, erigon). Default: all")
+	network := flag.String("network", "hoodi", "Network name (e.g., hoodi). Default: hoodi")
+	cronIntervalSec := flag.Int("cron-interval", 0, "Interval between snapshot checks in seconds. Default: 21600 (6 hours)")
+	runOnce := flag.Bool("run-once", false, "Run once and exit (for testing). Default: false")
+
+	flag.Parse()
+
+	config := SnapshotCheckerAppConfig{
+		ExecutionClients: parseExecutionClients(getConfigValue(*executionClients, "EXECUTION_CLIENTS", "")),
+		Network:          getConfigValue(*network, "NETWORK", "hoodi"),
+		CronIntervalSec:  getCronIntervalConfigValueInt(*cronIntervalSec, "CRON_INTERVAL_SEC", DefaultCronIntervalSec),
+		RunOnce:          *runOnce || os.Getenv("RUN_ONCE") == "true",
+	}
+
+	return config
+}
+
+// getCronIntervalConfigValueInt returns the flag value if set, otherwise falls back to the environment variable, then default
+func getCronIntervalConfigValueInt(flagValue int, envName string, defaultValue int) int {
+	if flagValue != 0 {
+		return flagValue
+	}
+	if envValue := os.Getenv(envName); envValue != "" {
+		var result int
+		for _, c := range envValue {
+			if c >= '0' && c <= '9' {
+				result = result*10 + int(c-'0')
+			}
+		}
+		if result > 0 {
+			return result
+		}
+	}
+	return defaultValue
+}
+
+// parseExecutionClients parses the comma-separated list of execution clients
+// Returns empty slice if input is empty (means all clients)
+func parseExecutionClients(input string) []string {
+	if input == "" {
+		return nil // nil means all clients
+	}
+
+	var clients []string
+	for _, client := range strings.Split(input, ",") {
+		client = strings.TrimSpace(strings.ToLower(client))
+		if client != "" {
+			clients = append(clients, client)
+		}
+	}
+	return clients
+}
+
+// Validate checks that required configuration values are present and valid
+func (c *SnapshotCheckerAppConfig) Validate() {
+	// Validate execution clients if specified
+	if len(c.ExecutionClients) > 0 {
+		for _, client := range c.ExecutionClients {
+			if !domain.IsValidExecutionClient(client) {
+				logger.FatalWithPrefix(snapshotLogPrefix, "Invalid execution client '%s'. Valid clients: %v", client, domain.ValidExecutionClients)
+			}
+		}
+	}
+
+	// Validate cron interval
+	if c.CronIntervalSec < 60 {
+		logger.WarnWithPrefix(snapshotLogPrefix, "Cron interval %d seconds is very short, using minimum of 60 seconds", c.CronIntervalSec)
+		c.CronIntervalSec = 60
+	}
+
+	logger.InfoWithPrefix(snapshotLogPrefix, "Configuration validated: network=%s, clients=%v, interval=%ds, runOnce=%v",
+		c.Network, c.ExecutionClients, c.CronIntervalSec, c.RunOnce)
+}
diff --git a/internal/config/config.go b/internal/config/test_runner_config.go
similarity index 84%
rename from internal/config/config.go
rename to internal/config/test_runner_config.go
index 4dcec23..82c3ccf 100644
--- a/internal/config/config.go
+++ b/internal/config/test_runner_config.go
@@ -33,13 +33,13 @@ func ParseConfig() Config {
 
 	// Build config with flag values, falling back to environment variables
 	config := Config{
-		IPFSGatewayURL: getConfigValue(*ipfsGatewayUrl, "IPFS_GATEWAY_URL"),
-		IPFSHash:       getConfigValue(*ipfsHash, "IPFS_HASH"),
+		IPFSGatewayURL: getConfigValue(*ipfsGatewayUrl, "IPFS_GATEWAY_URL", ""),
+		IPFSHash:       getConfigValue(*ipfsHash, "IPFS_HASH", ""),
 		GitHub: github.ParseGitHubConfigFromEnv(
-			getConfigValue(*githubToken, "GITHUB_TOKEN"),
-			getConfigValue(*githubRepository, "GITHUB_REPOSITORY"),
+			getConfigValue(*githubToken, "GITHUB_TOKEN", ""),
+			getConfigValue(*githubRepository, "GITHUB_REPOSITORY", ""),
 			getGitHubPRNumber(*githubPRNumber),
-			getConfigValue(*githubRunID, "GITHUB_RUN_ID"),
+			getConfigValue(*githubRunID, "GITHUB_RUN_ID", ""),
 			getGitHubServerURL(*githubServerURL),
 		),
 	}
@@ -47,14 +47,6 @@ func ParseConfig() Config {
 	return config
 }
 
-// getConfigValue returns the flag value if set, otherwise falls back to the environment variable
-func getConfigValue(flagValue, envName string) string {
-	if flagValue != "" {
-		return flagValue
-	}
-	return os.Getenv(envName)
-}
-
 // getGitHubPRNumber gets the PR number from flag or environment variables
 func getGitHubPRNumber(flagValue string) string {
 	if flagValue != "" {
diff --git a/internal/config/utils.go b/internal/config/utils.go
new file mode 100644
index 0000000..b65d193
--- /dev/null
+++ b/internal/config/utils.go
@@ -0,0 +1,14 @@
+package config
+
+import "os"
+
+// getConfigValue returns the flag value if set, otherwise falls back to the environment variable, then default
+func getConfigValue(flagValue, envName, defaultValue string) string {
+	if flagValue != "" {
+		return flagValue
+	}
+	if envValue := os.Getenv(envName); envValue != "" {
+		return envValue
+	}
+	return defaultValue
+}

From c2597d6ccf7273dc326eec8666ffafbc446f2d1f Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Wed, 21 Jan 2026 16:41:52 +0100
Subject: [PATCH 19/42] implement composite adapter in snapshot checker

---
 cmd/snapshot-checker/main.go                  |  26 +--
 .../adapters/apis/docker/docker_adapter.go    | 163 ++++++++++++++++++
 .../apis/snapshots/snapshots_adapter.go       | 124 ++-----------
 .../snapshotmanager/snapshotmanager.go        | 145 ++++++++++++++++
 .../application/ports/snapshotChecker_port.go |  36 ++++
 .../ports/{ports.go => testRunner_port.go}    |   0
 .../application/services/snapshot_checker.go  |  99 ++---------
 7 files changed, 390 insertions(+), 203 deletions(-)
 create mode 100644 internal/adapters/composite/snapshotmanager/snapshotmanager.go
 create mode 100644 internal/application/ports/snapshotChecker_port.go
 rename internal/application/ports/{ports.go => testRunner_port.go} (100%)

diff --git a/cmd/snapshot-checker/main.go b/cmd/snapshot-checker/main.go
index ab85f03..07e6b0a 100644
--- a/cmd/snapshot-checker/main.go
+++ b/cmd/snapshot-checker/main.go
@@ -3,6 +3,7 @@ package main
 import (
 	"clients-test/internal/adapters/apis/docker"
 	"clients-test/internal/adapters/apis/snapshots"
+	"clients-test/internal/adapters/composite/snapshotmanager"
 	"clients-test/internal/adapters/shared/blocknumber"
 	"clients-test/internal/adapters/shared/progress"
 	"clients-test/internal/application/domain"
@@ -53,6 +54,13 @@ func main() {
 	progressAdapter := progress.NewProgressAdapter()
 	blockNumberAdapter := blocknumber.NewBlockNumberAdapter()
 
+	// Create composite snapshot manager adapter
+	snapshotManagerAdapter := snapshotmanager.NewSnapshotManagerAdapter(
+		snapshotsAdapter,
+		dockerAdapter,
+		blockNumberAdapter,
+	)
+
 	// If a previous run crashed/was interrupted, the marker file can be left behind and block future runs.
 	// Clear it on startup so the service can recover.
 	if inProgress, err := progressAdapter.IsDownloadInProgress(ctx); err != nil {
@@ -64,11 +72,18 @@ func main() {
 		}
 	}
 
+	// Initialize the snapshot checker service
+	service := services.NewSnapshotCheckerService(
+		snapshotManagerAdapter,
+		progressAdapter,
+		snapshotConfig,
+	)
+
 	go func() {
 		sig := <-sigs
 		logger.InfoWithPrefix(logPrefix, "Received signal: %v, shutting down...", sig)
 		// Stop any running download containers
-		snapshotsAdapter.StopAllDownloads(context.Background())
+		service.GetSnapshotManager().StopAllDownloads(context.Background())
 		// Best-effort cleanup: clear marker file so next run isn't blocked.
 		if err := progressAdapter.ClearDownloadInProgress(context.Background()); err != nil {
 			logger.WarnWithPrefix(logPrefix, "Failed to clear %s marker on shutdown: %v", domain.ProgressFileName, err)
@@ -76,15 +91,6 @@ func main() {
 		cancel()
 	}()
 
-	// Initialize and run the snapshot checker service
-	service := services.NewSnapshotCheckerService(
-		snapshotsAdapter,
-		dockerAdapter,
-		progressAdapter,
-		blockNumberAdapter,
-		snapshotConfig,
-	)
-
 	if err := service.Start(ctx, cfg.RunOnce); err != nil {
 		if err == context.Canceled {
 			logger.InfoWithPrefix(logPrefix, "Snapshot checker stopped gracefully")
diff --git a/internal/adapters/apis/docker/docker_adapter.go b/internal/adapters/apis/docker/docker_adapter.go
index 6e1eaf5..a5799b5 100644
--- a/internal/adapters/apis/docker/docker_adapter.go
+++ b/internal/adapters/apis/docker/docker_adapter.go
@@ -5,13 +5,18 @@ import (
 	"context"
 	"fmt"
 	"io"
+	"os"
 	"strings"
 	"time"
 
 	"clients-test/internal/logger"
 
 	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types/filters"
+	"github.com/docker/docker/api/types/image"
+	"github.com/docker/docker/api/types/mount"
 	"github.com/docker/docker/client"
+	"github.com/docker/docker/pkg/stdcopy"
 )
 
 type DockerAdapter struct {
@@ -224,3 +229,161 @@ func (d *DockerAdapter) StopContainer(ctx context.Context, containerName string)
 	logger.DebugWithPrefix(d.logPrefix, "StopContainer: stopped container %s", containerName)
 	return nil
 }
+
+// ListContainersByPrefix returns a list of container IDs that match the given name prefix
+func (d *DockerAdapter) ListContainersByPrefix(ctx context.Context, prefix string) ([]string, error) {
+	logger.DebugWithPrefix(d.logPrefix, "ListContainersByPrefix: listing containers with prefix %s", prefix)
+
+	filterArgs := filters.NewArgs()
+	filterArgs.Add("name", prefix)
+
+	containers, err := d.cli.ContainerList(ctx, container.ListOptions{
+		Filters: filterArgs,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to list containers: %w", err)
+	}
+
+	var ids []string
+	for _, c := range containers {
+		ids = append(ids, c.ID)
+	}
+
+	logger.DebugWithPrefix(d.logPrefix, "ListContainersByPrefix: found %d containers with prefix %s", len(ids), prefix)
+	return ids, nil
+}
+
+// StopContainerWithTimeout stops a container by ID with a specific timeout in seconds
+func (d *DockerAdapter) StopContainerWithTimeout(ctx context.Context, containerID string, timeoutSeconds int) error {
+	logger.DebugWithPrefix(d.logPrefix, "StopContainerWithTimeout: stopping container %s with timeout %ds", containerID, timeoutSeconds)
+
+	timeout := timeoutSeconds
+	if err := d.cli.ContainerStop(ctx, containerID, container.StopOptions{Timeout: &timeout}); err != nil {
+		return fmt.Errorf("failed to stop container: %w", err)
+	}
+
+	logger.DebugWithPrefix(d.logPrefix, "StopContainerWithTimeout: stopped container %s", containerID)
+	return nil
+}
+
+const (
+	alpineImage = "alpine:latest"
+)
+
+// RunSnapshotDownload runs an Alpine container to download and extract a snapshot
+// Uses aria2c for parallel HTTP range request downloads and zstd for decompression
+func (d *DockerAdapter) RunSnapshotDownload(ctx context.Context, containerName, clientName, network, targetPath, baseURL string) error {
+	logger.InfoWithPrefix(d.logPrefix, "RunSnapshotDownload: starting download for %s to %s", clientName, targetPath)
+
+	// Pull alpine image if not present
+	if err := d.ensureImage(ctx, alpineImage); err != nil {
+		return fmt.Errorf("failed to ensure alpine image: %w", err)
+	}
+
+	// Build the shell script for download and extraction
+	// Optimizations:
+	// - aria2c -x16 -s16: 16 parallel connections using HTTP range requests
+	// - zstd -T0: multi-threaded decompression using all CPU cores
+	// - No -v flag on tar: avoid printing every filename (major speedup)
+	shellScript := fmt.Sprintf(`
+set -e
+apk add --no-cache aria2 tar zstd pv bash curl > /dev/null 2>&1
+BLOCK_NUMBER=$(curl -sf %s/%s/%s/latest)
+SNAPSHOT_URL="%s/%s/%s/${BLOCK_NUMBER}/snapshot.tar.zst"
+echo "[%s] Downloading snapshot for block number: ${BLOCK_NUMBER}"
+echo "[%s] Using 16 parallel connections with HTTP range requests"
+aria2c -x16 -s16 --file-allocation=none --console-log-level=warn --summary-interval=30 --show-console-readout=false -d /data -o snapshot.tar.zst "${SNAPSHOT_URL}" 2>&1 | awk '/^\[#/{print "[%s] " $0; fflush()}'
+echo "[%s] Download complete. Extracting with $(nproc) CPU cores..."
+bash -c 'pv -f -i 30 -N "%s" -ptebar /data/snapshot.tar.zst 2> >(tr "\r" "\n" >&2) | zstd -d -T0 | tar -xf - -C /data'
+rm -f /data/snapshot.tar.zst
+echo "[%s] Snapshot extraction complete"
+`, baseURL, network, clientName, baseURL, network, clientName, clientName, clientName, clientName, clientName, clientName, clientName)
+
+	// Create container config
+	config := &container.Config{
+		Image:      alpineImage,
+		Entrypoint: []string{"/bin/sh"},
+		Cmd:        []string{"-c", shellScript},
+		Tty:        false,
+	}
+
+	// Create host config with volume mount
+	hostConfig := &container.HostConfig{
+		Mounts: []mount.Mount{
+			{
+				Type:   mount.TypeBind,
+				Source: targetPath,
+				Target: "/data",
+			},
+		},
+		AutoRemove: true,
+	}
+
+	// Create the container
+	resp, err := d.cli.ContainerCreate(ctx, config, hostConfig, nil, nil, containerName)
+	if err != nil {
+		return fmt.Errorf("failed to create container: %w", err)
+	}
+
+	// Start the container
+	if err := d.cli.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {
+		return fmt.Errorf("failed to start container: %w", err)
+	}
+
+	// Attach to container output for real-time logging
+	attachResp, err := d.cli.ContainerAttach(ctx, resp.ID, container.AttachOptions{
+		Stream: true,
+		Stdout: true,
+		Stderr: true,
+	})
+	if err != nil {
+		logger.WarnWithPrefix(d.logPrefix, "Failed to attach to container: %v", err)
+	} else {
+		defer attachResp.Close()
+		// Copy output to stdout/stderr in a goroutine
+		go func() {
+			_, _ = stdcopy.StdCopy(os.Stdout, os.Stderr, attachResp.Reader)
+		}()
+	}
+
+	// Wait for container to finish
+	start := time.Now()
+	statusCh, errCh := d.cli.ContainerWait(ctx, resp.ID, container.WaitConditionNotRunning)
+
+	select {
+	case err := <-errCh:
+		if err != nil {
+			return fmt.Errorf("error waiting for container: %w", err)
+		}
+	case status := <-statusCh:
+		if status.StatusCode != 0 {
+			return fmt.Errorf("container exited with status %d", status.StatusCode)
+		}
+	}
+
+	elapsed := time.Since(start)
+	logger.InfoWithPrefix(d.logPrefix, "RunSnapshotDownload: completed in %s", elapsed)
+	return nil
+}
+
+// ensureImage pulls an image if it's not already present locally
+func (d *DockerAdapter) ensureImage(ctx context.Context, imageName string) error {
+	// Check if image exists
+	_, err := d.cli.ImageInspect(ctx, imageName)
+	if err == nil {
+		return nil // Image already exists
+	}
+
+	logger.InfoWithPrefix(d.logPrefix, "Pulling image %s", imageName)
+	reader, err := d.cli.ImagePull(ctx, imageName, image.PullOptions{})
+	if err != nil {
+		return fmt.Errorf("failed to pull image: %w", err)
+	}
+	defer reader.Close()
+
+	// Discard the output but wait for pull to complete
+	_, _ = io.Copy(io.Discard, reader)
+
+	logger.InfoWithPrefix(d.logPrefix, "Successfully pulled image %s", imageName)
+	return nil
+}
diff --git a/internal/adapters/apis/snapshots/snapshots_adapter.go b/internal/adapters/apis/snapshots/snapshots_adapter.go
index 58feb9a..b62f899 100644
--- a/internal/adapters/apis/snapshots/snapshots_adapter.go
+++ b/internal/adapters/apis/snapshots/snapshots_adapter.go
@@ -6,19 +6,13 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"os"
-	"os/exec"
 	"strings"
-	"sync"
-	"time"
 
 	"clients-test/internal/logger"
 )
 
 const (
-	defaultBaseURL          = "https://snapshots.ethpandaops.io"
-	alpineImage             = "alpine:latest"
-	downloadContainerPrefix = "snapshot-download-"
+	defaultBaseURL = "https://snapshots.ethpandaops.io"
 )
 
 type SnapshotsAdapter struct {
@@ -40,6 +34,11 @@ func NewSnapshotsAdapterWithURL(baseURL string) *SnapshotsAdapter {
 	}
 }
 
+// GetBaseURL returns the base URL of the snapshots API
+func (s *SnapshotsAdapter) GetBaseURL() string {
+	return s.baseURL
+}
+
 // GetLatestBlockNumber fetches the latest available block number for a given network and client
 func (s *SnapshotsAdapter) GetLatestBlockNumber(ctx context.Context, network, client string) (string, error) {
 	url := fmt.Sprintf("%s/%s/%s/latest", s.baseURL, network, client)
@@ -70,6 +69,11 @@ func (s *SnapshotsAdapter) GetLatestBlockNumber(ctx context.Context, network, cl
 	return blockNumber, nil
 }
 
+// GetSnapshotURL returns the full URL for a snapshot file
+func (s *SnapshotsAdapter) GetSnapshotURL(network, client, blockNumber string) string {
+	return fmt.Sprintf("%s/%s/%s/%s/snapshot.tar.zst", s.baseURL, network, client, blockNumber)
+}
+
 // GetClientVersion fetches the client version used to generate the snapshot
 // The version is retrieved from the _snapshot_web3_clientVersion.json file
 func (s *SnapshotsAdapter) GetClientVersion(ctx context.Context, network, client, blockNumber string) (string, error) {
@@ -110,109 +114,3 @@ func (s *SnapshotsAdapter) GetLatestClientVersion(ctx context.Context, network,
 	}
 	return s.GetClientVersion(ctx, network, client, blockNumber)
 }
-
-// DownloadAndExtract downloads the snapshot for the given network/client and extracts it to targetPath
-// It uses a Docker container with alpine to handle the download and extraction
-func (s *SnapshotsAdapter) DownloadAndExtract(ctx context.Context, network, client, targetPath string) error {
-	logger.InfoWithPrefix(s.logPrefix, "Starting snapshot download for %s/%s to %s", network, client, targetPath)
-
-	// Get the latest block number first
-	blockNumber, err := s.GetLatestBlockNumber(ctx, network, client)
-	if err != nil {
-		return fmt.Errorf("failed to get latest block number: %w", err)
-	}
-
-	snapshotURL := fmt.Sprintf("%s/%s/%s/%s/snapshot.tar.zst", s.baseURL, network, client, blockNumber)
-	logger.InfoWithPrefix(s.logPrefix, "Downloading %s snapshot from %s", client, snapshotURL)
-
-	// Build the shell command to run inside the alpine container
-	// This installs necessary tools, downloads the snapshot, and extracts it
-	// Optimizations:
-	// - aria2c -x16 -s16: 16 parallel connections using HTTP range requests for faster download
-	// - zstd -T0: multi-threaded decompression using all CPU cores
-	// - No -v flag on tar: avoid printing every filename (major speedup)
-	// Note: aria2c downloads to file first (can't stream with range requests), then we decompress
-	// This requires ~2x disk space temporarily but is significantly faster on high-bandwidth connections
-	shellScript := fmt.Sprintf(`
-set -e
-apk add --no-cache aria2 tar zstd pv bash > /dev/null 2>&1
-echo "[%s] Downloading snapshot for block number: %s"
-echo "[%s] Using 16 parallel connections with HTTP range requests"
-aria2c -x16 -s16 --file-allocation=none --console-log-level=warn --summary-interval=30 --show-console-readout=false -d /data -o snapshot.tar.zst "%s" 2>&1 | awk '/^\[#/{print "[%s] " $0; fflush()}'
-echo "[%s] Download complete. Extracting with $(nproc) CPU cores..."
-bash -c 'pv -f -i 30 -N "%s" -ptebar /data/snapshot.tar.zst 2> >(tr "\r" "\n" >&2) | zstd -d -T0 | tar -xf - -C /data'
-rm -f /data/snapshot.tar.zst
-echo "[%s] Snapshot extraction complete"
-`, client, blockNumber, client, snapshotURL, client, client, client, client)
-
-	// Run docker command
-	// docker run --rm --name <name> -v <targetPath>:/data alpine /bin/sh -c '<script>'
-	// --name allows us to stop the container on shutdown
-	// Note: we don't use -t (TTY) because multiple parallel downloads would overwrite each other's progress
-	// Instead, pv with -f outputs line-based progress that works well in parallel
-	containerName := fmt.Sprintf("%s%s", downloadContainerPrefix, client)
-	dockerArgs := []string{
-		"run", "--rm",
-		"--name", containerName,
-		"-v", fmt.Sprintf("%s:/data", targetPath),
-		"--entrypoint", "/bin/sh",
-		alpineImage,
-		"-c", shellScript,
-	}
-
-	start := time.Now()
-	cmd := exec.CommandContext(ctx, "docker", dockerArgs...)
-	// Stream output in real-time instead of buffering until completion
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-	err = cmd.Run()
-	if err != nil {
-		logger.ErrorWithPrefix(s.logPrefix, "Failed to download/extract snapshot: %v", err)
-		return fmt.Errorf("failed to download/extract snapshot: %w", err)
-	}
-	elapsed := time.Since(start)
-
-	logger.InfoWithPrefix(s.logPrefix, "Successfully downloaded and extracted snapshot to %s in %s", targetPath, elapsed)
-	return nil
-}
-
-// StopAllDownloads stops all running snapshot download containers in parallel
-func (s *SnapshotsAdapter) StopAllDownloads(ctx context.Context) {
-	logger.InfoWithPrefix(s.logPrefix, "Stopping all snapshot download containers...")
-
-	// Find all containers with our prefix
-	listCmd := exec.CommandContext(ctx, "docker", "ps", "-q", "--filter", fmt.Sprintf("name=%s", downloadContainerPrefix))
-	output, err := listCmd.Output()
-	if err != nil {
-		logger.WarnWithPrefix(s.logPrefix, "Failed to list download containers: %v", err)
-		return
-	}
-
-	containerIDs := strings.TrimSpace(string(output))
-	if containerIDs == "" {
-		logger.DebugWithPrefix(s.logPrefix, "No download containers running")
-		return
-	}
-
-	// Stop all containers in parallel
-	ids := strings.Split(containerIDs, "\n")
-	var wg sync.WaitGroup
-	for _, id := range ids {
-		id = strings.TrimSpace(id)
-		if id == "" {
-			continue
-		}
-		wg.Add(1)
-		go func(containerID string) {
-			defer wg.Done()
-			logger.InfoWithPrefix(s.logPrefix, "Stopping download container %s", containerID)
-			stopCmd := exec.Command("docker", "stop", "-t", "5", containerID)
-			if err := stopCmd.Run(); err != nil {
-				logger.WarnWithPrefix(s.logPrefix, "Failed to stop container %s: %v", containerID, err)
-			}
-		}(id)
-	}
-	wg.Wait()
-
-	logger.InfoWithPrefix(s.logPrefix, "All download containers stopped")
-}
diff --git a/internal/adapters/composite/snapshotmanager/snapshotmanager.go b/internal/adapters/composite/snapshotmanager/snapshotmanager.go
new file mode 100644
index 0000000..50261c1
--- /dev/null
+++ b/internal/adapters/composite/snapshotmanager/snapshotmanager.go
@@ -0,0 +1,145 @@
+package snapshotmanager
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	"clients-test/internal/adapters/apis/docker"
+	"clients-test/internal/adapters/apis/snapshots"
+	"clients-test/internal/adapters/shared/blocknumber"
+	"clients-test/internal/application/domain"
+	"clients-test/internal/logger"
+)
+
+const (
+	downloadContainerPrefix = "snapshot-download-"
+)
+
+var logPrefix = "SnapshotManager"
+
+// SnapshotManagerAdapter is a composite adapter that combines snapshots, docker, and blocknumber adapters
+// to provide high-level snapshot management operations
+type SnapshotManagerAdapter struct {
+	snapshots   *snapshots.SnapshotsAdapter
+	docker      *docker.DockerAdapter
+	blockNumber *blocknumber.BlockNumberAdapter
+}
+
+// NewSnapshotManagerAdapter creates a new SnapshotManagerAdapter
+func NewSnapshotManagerAdapter(
+	snapshotsAdapter *snapshots.SnapshotsAdapter,
+	dockerAdapter *docker.DockerAdapter,
+	blockNumberAdapter *blocknumber.BlockNumberAdapter,
+) *SnapshotManagerAdapter {
+	return &SnapshotManagerAdapter{
+		snapshots:   snapshotsAdapter,
+		docker:      dockerAdapter,
+		blockNumber: blockNumberAdapter,
+	}
+}
+
+// NeedsSnapshotDownload determines if a snapshot needs to be downloaded for the given client
+// Returns true if no snapshot exists or if a newer snapshot is available
+func (s *SnapshotManagerAdapter) NeedsSnapshotDownload(ctx context.Context, client domain.ExecutionClientInfo, latestBlockNumber string) (bool, error) {
+	// Check if block number file exists
+	exists, err := s.blockNumber.BlockNumberExists(ctx, client.VolumeTargetPath)
+	if err != nil {
+		return false, err
+	}
+
+	if !exists {
+		logger.InfoWithPrefix(logPrefix, "No existing snapshot for %s, download needed", client.ShortName)
+		return true, nil
+	}
+
+	// Check if newer snapshot is available
+	isNewer, err := s.blockNumber.IsNewerSnapshot(ctx, client.VolumeTargetPath, latestBlockNumber)
+	if err != nil {
+		return false, err
+	}
+
+	if isNewer {
+		currentBlock, _ := s.blockNumber.ReadBlockNumber(ctx, client.VolumeTargetPath)
+		logger.InfoWithPrefix(logPrefix, "Newer snapshot available for %s: current=%s, latest=%s",
+			client.ShortName, currentBlock, latestBlockNumber)
+		return true, nil
+	}
+
+	return false, nil
+}
+
+// DownloadAndMountSnapshot performs the complete snapshot download and mount process:
+// 1. Stops the client container (if running)
+// 2. Downloads and extracts the snapshot to the volume
+// 3. Writes the block number file
+func (s *SnapshotManagerAdapter) DownloadAndMountSnapshot(ctx context.Context, network string, client domain.ExecutionClientInfo) error {
+	// Get latest block number first
+	latestBlockNumber, err := s.snapshots.GetLatestBlockNumber(ctx, network, client.ShortName)
+	if err != nil {
+		return fmt.Errorf("failed to get latest block number: %w", err)
+	}
+
+	logger.InfoWithPrefix(logPrefix, "Starting snapshot download for %s (block %s)", client.ShortName, latestBlockNumber)
+
+	// 1. Stop the container (if running)
+	logger.InfoWithPrefix(logPrefix, "Stopping container %s", client.ContainerName)
+	if err := s.docker.StopContainer(ctx, client.ContainerName); err != nil {
+		// Log but don't fail - container might not exist or not be running
+		logger.WarnWithPrefix(logPrefix, "Could not stop container %s: %v", client.ContainerName, err)
+	}
+
+	// 2. Download and extract snapshot to volume using Docker container
+	containerName := fmt.Sprintf("%s%s", downloadContainerPrefix, client.ShortName)
+	logger.InfoWithPrefix(logPrefix, "Downloading and extracting snapshot to %s", client.VolumeTargetPath)
+	if err := s.docker.RunSnapshotDownload(ctx, containerName, client.ShortName, network, client.VolumeTargetPath, s.snapshots.GetBaseURL()); err != nil {
+		return fmt.Errorf("failed to download and extract snapshot: %w", err)
+	}
+
+	// 3. Write block number file
+	if err := s.blockNumber.WriteBlockNumber(ctx, client.VolumeTargetPath, latestBlockNumber); err != nil {
+		return fmt.Errorf("failed to write block number: %w", err)
+	}
+
+	logger.InfoWithPrefix(logPrefix, "Successfully downloaded and mounted snapshot for %s (block %s)",
+		client.ShortName, latestBlockNumber)
+
+	return nil
+}
+
+// GetLatestBlockNumber fetches the latest available block number for a client
+func (s *SnapshotManagerAdapter) GetLatestBlockNumber(ctx context.Context, network, client string) (string, error) {
+	return s.snapshots.GetLatestBlockNumber(ctx, network, client)
+}
+
+// StopAllDownloads stops all running snapshot download containers in parallel
+func (s *SnapshotManagerAdapter) StopAllDownloads(ctx context.Context) {
+	logger.InfoWithPrefix(logPrefix, "Stopping all snapshot download containers...")
+
+	containerIDs, err := s.docker.ListContainersByPrefix(ctx, downloadContainerPrefix)
+	if err != nil {
+		logger.WarnWithPrefix(logPrefix, "Failed to list download containers: %v", err)
+		return
+	}
+
+	if len(containerIDs) == 0 {
+		logger.DebugWithPrefix(logPrefix, "No download containers running")
+		return
+	}
+
+	// Stop all containers in parallel
+	var wg sync.WaitGroup
+	for _, id := range containerIDs {
+		wg.Add(1)
+		go func(containerID string) {
+			defer wg.Done()
+			logger.InfoWithPrefix(logPrefix, "Stopping download container %s", containerID)
+			if err := s.docker.StopContainerWithTimeout(ctx, containerID, 5); err != nil {
+				logger.WarnWithPrefix(logPrefix, "Failed to stop container %s: %v", containerID, err)
+			}
+		}(id)
+	}
+	wg.Wait()
+
+	logger.InfoWithPrefix(logPrefix, "All download containers stopped")
+}
diff --git a/internal/application/ports/snapshotChecker_port.go b/internal/application/ports/snapshotChecker_port.go
new file mode 100644
index 0000000..d9bfd78
--- /dev/null
+++ b/internal/application/ports/snapshotChecker_port.go
@@ -0,0 +1,36 @@
+package ports
+
+import (
+	"clients-test/internal/application/domain"
+	"context"
+)
+
+// SnapshotManager defines the interface for snapshot management operations
+// This is the port that the snapshot checker service uses to interact with snapshot infrastructure
+type SnapshotManager interface {
+	// NeedsSnapshotDownload determines if a snapshot needs to be downloaded for the given client
+	// Returns true if no snapshot exists or if a newer snapshot is available
+	NeedsSnapshotDownload(ctx context.Context, client domain.ExecutionClientInfo, latestBlockNumber string) (bool, error)
+
+	// DownloadAndMountSnapshot performs the complete snapshot download and mount process
+	DownloadAndMountSnapshot(ctx context.Context, network string, client domain.ExecutionClientInfo) error
+
+	// GetLatestBlockNumber fetches the latest available block number for a client
+	GetLatestBlockNumber(ctx context.Context, network, client string) (string, error)
+
+	// StopAllDownloads stops all running snapshot download containers
+	StopAllDownloads(ctx context.Context)
+}
+
+// DownloadProgress defines the interface for tracking download progress state
+// Used to prevent concurrent downloads and recover from interrupted downloads
+type DownloadProgress interface {
+	// IsDownloadInProgress checks if a download is currently in progress
+	IsDownloadInProgress(ctx context.Context) (bool, error)
+
+	// SetDownloadInProgress marks that a download has started
+	SetDownloadInProgress(ctx context.Context) error
+
+	// ClearDownloadInProgress marks that a download has completed (success or failure)
+	ClearDownloadInProgress(ctx context.Context) error
+}
diff --git a/internal/application/ports/ports.go b/internal/application/ports/testRunner_port.go
similarity index 100%
rename from internal/application/ports/ports.go
rename to internal/application/ports/testRunner_port.go
diff --git a/internal/application/services/snapshot_checker.go b/internal/application/services/snapshot_checker.go
index 2eaa9bc..6ef345c 100644
--- a/internal/application/services/snapshot_checker.go
+++ b/internal/application/services/snapshot_checker.go
@@ -1,11 +1,8 @@
 package services
 
 import (
-	"clients-test/internal/adapters/apis/docker"
-	"clients-test/internal/adapters/apis/snapshots"
-	"clients-test/internal/adapters/shared/blocknumber"
-	"clients-test/internal/adapters/shared/progress"
 	"clients-test/internal/application/domain"
+	"clients-test/internal/application/ports"
 	"clients-test/internal/logger"
 	"context"
 	"fmt"
@@ -17,30 +14,29 @@ var snapshotLogPrefix = "SnapshotChecker"
 
 // SnapshotCheckerService handles snapshot checking and downloading
 type SnapshotCheckerService struct {
-	snapshots   *snapshots.SnapshotsAdapter
-	docker      *docker.DockerAdapter
-	progress    *progress.ProgressAdapter
-	blockNumber *blocknumber.BlockNumberAdapter
-	config      domain.SnapshotCheckerConfig
+	snapshotManager ports.SnapshotManager
+	progress        ports.DownloadProgress
+	config          domain.SnapshotCheckerConfig
 }
 
 // NewSnapshotCheckerService creates a new SnapshotCheckerService
 func NewSnapshotCheckerService(
-	snapshotsAdapter *snapshots.SnapshotsAdapter,
-	dockerAdapter *docker.DockerAdapter,
-	progressAdapter *progress.ProgressAdapter,
-	blockNumberAdapter *blocknumber.BlockNumberAdapter,
+	snapshotManager ports.SnapshotManager,
+	progress ports.DownloadProgress,
 	config domain.SnapshotCheckerConfig,
 ) *SnapshotCheckerService {
 	return &SnapshotCheckerService{
-		snapshots:   snapshotsAdapter,
-		docker:      dockerAdapter,
-		progress:    progressAdapter,
-		blockNumber: blockNumberAdapter,
-		config:      config,
+		snapshotManager: snapshotManager,
+		progress:        progress,
+		config:          config,
 	}
 }
 
+// GetSnapshotManager returns the snapshot manager adapter (for shutdown handling)
+func (s *SnapshotCheckerService) GetSnapshotManager() ports.SnapshotManager {
+	return s.snapshotManager
+}
+
 // Start starts the snapshot checker cron job
 func (s *SnapshotCheckerService) Start(ctx context.Context, runOnce bool) error {
 	logger.InfoWithPrefix(snapshotLogPrefix, "Starting snapshot checker for network: %s", s.config.Network)
@@ -145,14 +141,14 @@ func (s *SnapshotCheckerService) checkAndUpdateClient(ctx context.Context, clien
 	logger.InfoWithPrefix(snapshotLogPrefix, "Checking client: %s (%s)", client.ShortName, client.DnpName)
 
 	// Get latest available block number from ethpandaops
-	latestBlockNumber, err := s.snapshots.GetLatestBlockNumber(ctx, s.config.Network, client.ShortName)
+	latestBlockNumber, err := s.snapshotManager.GetLatestBlockNumber(ctx, s.config.Network, client.ShortName)
 	if err != nil {
 		return fmt.Errorf("failed to get latest block number: %w", err)
 	}
 	logger.InfoWithPrefix(snapshotLogPrefix, "Latest available snapshot for %s: block %s", client.ShortName, latestBlockNumber)
 
-	// Check if we need to download
-	needsDownload, err := s.needsSnapshotDownload(ctx, client, latestBlockNumber)
+	// Check if we need to download (delegated to composite adapter)
+	needsDownload, err := s.snapshotManager.NeedsSnapshotDownload(ctx, client, latestBlockNumber)
 	if err != nil {
 		return fmt.Errorf("failed to check if snapshot needed: %w", err)
 	}
@@ -162,67 +158,10 @@ func (s *SnapshotCheckerService) checkAndUpdateClient(ctx context.Context, clien
 		return nil
 	}
 
-	// Download and mount snapshot
-	if err := s.downloadAndMountSnapshot(ctx, client, latestBlockNumber); err != nil {
+	// Download and mount snapshot (delegated to composite adapter)
+	if err := s.snapshotManager.DownloadAndMountSnapshot(ctx, s.config.Network, client); err != nil {
 		return fmt.Errorf("failed to download and mount snapshot: %w", err)
 	}
 
 	return nil
 }
-
-// needsSnapshotDownload determines if a snapshot needs to be downloaded
-func (s *SnapshotCheckerService) needsSnapshotDownload(ctx context.Context, client domain.ExecutionClientInfo, latestBlockNumber string) (bool, error) {
-	// Check if block number file exists
-	exists, err := s.blockNumber.BlockNumberExists(ctx, client.VolumeTargetPath)
-	if err != nil {
-		return false, err
-	}
-
-	if !exists {
-		logger.InfoWithPrefix(snapshotLogPrefix, "No existing snapshot for %s, download needed", client.ShortName)
-		return true, nil
-	}
-
-	// Check if newer snapshot is available
-	isNewer, err := s.blockNumber.IsNewerSnapshot(ctx, client.VolumeTargetPath, latestBlockNumber)
-	if err != nil {
-		return false, err
-	}
-
-	if isNewer {
-		currentBlock, _ := s.blockNumber.ReadBlockNumber(ctx, client.VolumeTargetPath)
-		logger.InfoWithPrefix(snapshotLogPrefix, "Newer snapshot available for %s: current=%s, latest=%s",
-			client.ShortName, currentBlock, latestBlockNumber)
-		return true, nil
-	}
-
-	return false, nil
-}
-
-// downloadAndMountSnapshot performs the complete snapshot download and mount process
-func (s *SnapshotCheckerService) downloadAndMountSnapshot(ctx context.Context, client domain.ExecutionClientInfo, blockNumber string) error {
-	logger.InfoWithPrefix(snapshotLogPrefix, "Starting snapshot download for %s (block %s)", client.ShortName, blockNumber)
-
-	// 1. Stop the container (if running)
-	logger.InfoWithPrefix(snapshotLogPrefix, "Stopping container %s", client.ContainerName)
-	if err := s.docker.StopContainer(ctx, client.ContainerName); err != nil {
-		// Log but don't fail - container might not exist or not be running
-		logger.WarnWithPrefix(snapshotLogPrefix, "Could not stop container %s: %v", client.ContainerName, err)
-	}
-
-	// 2. Download and extract snapshot to volume
-	logger.InfoWithPrefix(snapshotLogPrefix, "Downloading and extracting snapshot to %s", client.VolumeTargetPath)
-	if err := s.snapshots.DownloadAndExtract(ctx, s.config.Network, client.ShortName, client.VolumeTargetPath); err != nil {
-		return fmt.Errorf("failed to download and extract snapshot: %w", err)
-	}
-
-	// 3. Write block number file
-	if err := s.blockNumber.WriteBlockNumber(ctx, client.VolumeTargetPath, blockNumber); err != nil {
-		return fmt.Errorf("failed to write block number: %w", err)
-	}
-
-	logger.InfoWithPrefix(snapshotLogPrefix, "Successfully downloaded and mounted snapshot for %s (block %s)",
-		client.ShortName, blockNumber)
-
-	return nil
-}

From 36ca3674d140e8c24113902ffc4d928958c53c3f Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Wed, 21 Jan 2026 17:08:46 +0100
Subject: [PATCH 20/42] move logging to snapshot checker service

---
 cmd/snapshot-checker/main.go                  |  4 +-
 .../adapters/apis/docker/docker_adapter.go    | 46 ++-----------------
 .../apis/snapshots/snapshots_adapter.go       | 15 ++----
 .../snapshotmanager/snapshotmanager.go        | 38 ++-------------
 .../shared/blocknumber/blocknumber_adapter.go |  6 ---
 .../shared/progress/progress_adapter.go       |  9 ----
 .../application/services/snapshot_checker.go  | 44 +++++++++++++-----
 7 files changed, 46 insertions(+), 116 deletions(-)

diff --git a/cmd/snapshot-checker/main.go b/cmd/snapshot-checker/main.go
index 07e6b0a..28bd9f4 100644
--- a/cmd/snapshot-checker/main.go
+++ b/cmd/snapshot-checker/main.go
@@ -82,8 +82,8 @@ func main() {
 	go func() {
 		sig := <-sigs
 		logger.InfoWithPrefix(logPrefix, "Received signal: %v, shutting down...", sig)
-		// Stop any running download containers
-		service.GetSnapshotManager().StopAllDownloads(context.Background())
+		// Stop any running download containers using the service method
+		service.StopAllDownloads(context.Background())
 		// Best-effort cleanup: clear marker file so next run isn't blocked.
 		if err := progressAdapter.ClearDownloadInProgress(context.Background()); err != nil {
 			logger.WarnWithPrefix(logPrefix, "Failed to clear %s marker on shutdown: %v", domain.ProgressFileName, err)
diff --git a/internal/adapters/apis/docker/docker_adapter.go b/internal/adapters/apis/docker/docker_adapter.go
index a5799b5..75f21f4 100644
--- a/internal/adapters/apis/docker/docker_adapter.go
+++ b/internal/adapters/apis/docker/docker_adapter.go
@@ -9,8 +9,6 @@ import (
 	"strings"
 	"time"
 
-	"clients-test/internal/logger"
-
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/filters"
 	"github.com/docker/docker/api/types/image"
@@ -20,8 +18,7 @@ import (
 )
 
 type DockerAdapter struct {
-	cli       *client.Client
-	logPrefix string
+	cli *client.Client
 }
 
 func NewDockerAdapter() (*DockerAdapter, error) {
@@ -29,15 +26,13 @@ func NewDockerAdapter() (*DockerAdapter, error) {
 	if err != nil {
 		return nil, err
 	}
-	return &DockerAdapter{cli: cli, logPrefix: "DockerAdapter"}, nil
+	return &DockerAdapter{cli: cli}, nil
 }
 
 // StopAndGetVolumeTarget stops the container, checks for a single volume, and returns the volume target path
 func (d *DockerAdapter) StopAndGetVolumeTarget(ctx context.Context, containerName string, containerVolumeName string) (string, error) {
-	logger.DebugWithPrefix(d.logPrefix, "StopAndGetVolumeTarget: inspecting container %s", containerName)
 	containerJSON, err := d.cli.ContainerInspect(ctx, containerName)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "StopAndGetVolumeTarget: failed to inspect container: %v", err)
 		return "", fmt.Errorf("failed to inspect container: %w", err)
 	}
 
@@ -49,15 +44,11 @@ func (d *DockerAdapter) StopAndGetVolumeTarget(ctx context.Context, containerNam
 			volumeName := mount.Name
 
 			volumeTarget := fmt.Sprintf("/var/lib/docker/volumes/%s/_data", volumeName)
-			logger.DebugWithPrefix(d.logPrefix, "StopAndGetVolumeTarget: volumeName=%s volumeTarget=%s", volumeName, volumeTarget)
 
 			// Stop the container
-			logger.DebugWithPrefix(d.logPrefix, "StopAndGetVolumeTarget: stopping container %s", containerName)
 			if err := d.cli.ContainerStop(ctx, containerName, container.StopOptions{}); err != nil {
-				logger.ErrorWithPrefix(d.logPrefix, "StopAndGetVolumeTarget: failed to stop container: %v", err)
 				return "", fmt.Errorf("failed to stop container: %w", err)
 			}
-			logger.DebugWithPrefix(d.logPrefix, "StopAndGetVolumeTarget: stopped container %s", containerName)
 
 			return volumeTarget, nil
 		}
@@ -68,24 +59,18 @@ func (d *DockerAdapter) StopAndGetVolumeTarget(ctx context.Context, containerNam
 
 // StartContainer starts the given container
 func (d *DockerAdapter) StartContainer(ctx context.Context, containerName string) error {
-	logger.DebugWithPrefix(d.logPrefix, "StartContainer: starting container %s", containerName)
 	if err := d.cli.ContainerStart(ctx, containerName, container.StartOptions{}); err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "StartContainer: failed to start container: %v", err)
 		return fmt.Errorf("failed to start container: %w", err)
 	}
-	logger.DebugWithPrefix(d.logPrefix, "StartContainer: started container %s", containerName)
 	return nil
 }
 
 // GetContainerErrorLogs retrieves error logs from a container within a time range
 // Returns up to maxLines error lines (lines containing "error", "err", "fatal", "panic", etc.)
 func (d *DockerAdapter) GetContainerErrorLogs(ctx context.Context, containerName string, since, until time.Time, maxLines int) ([]string, error) {
-	logger.DebugWithPrefix(d.logPrefix, "GetContainerErrorLogs: fetching logs for container %s from %v to %v", containerName, since, until)
-
 	// Check if container exists first
 	_, err := d.cli.ContainerInspect(ctx, containerName)
 	if err != nil {
-		logger.WarnWithPrefix(d.logPrefix, "GetContainerErrorLogs: container %s not found or not accessible: %v", containerName, err)
 		return nil, nil // Return nil instead of error - container might not exist yet
 	}
 
@@ -99,7 +84,6 @@ func (d *DockerAdapter) GetContainerErrorLogs(ctx context.Context, containerName
 
 	reader, err := d.cli.ContainerLogs(ctx, containerName, options)
 	if err != nil {
-		logger.WarnWithPrefix(d.logPrefix, "GetContainerErrorLogs: failed to get logs for %s: %v", containerName, err)
 		return nil, nil // Return nil instead of error - might be transient
 	}
 	defer reader.Close()
@@ -146,7 +130,6 @@ func (d *DockerAdapter) GetContainerErrorLogs(ctx context.Context, containerName
 				}
 				errorLines = append(errorLines, lineStr)
 				if len(errorLines) >= maxLines {
-					logger.DebugWithPrefix(d.logPrefix, "GetContainerErrorLogs: found %d error lines for %s (max reached)", len(errorLines), containerName)
 					return errorLines, nil
 				}
 				break
@@ -185,7 +168,6 @@ func (d *DockerAdapter) GetContainerErrorLogs(ctx context.Context, containerName
 		}
 	}
 
-	logger.DebugWithPrefix(d.logPrefix, "GetContainerErrorLogs: found %d error lines for %s", len(errorLines), containerName)
 	return errorLines, nil
 }
 
@@ -199,7 +181,6 @@ func (d *DockerAdapter) CollectAllContainerErrorLogs(ctx context.Context, contai
 		}
 		lines, err := d.GetContainerErrorLogs(ctx, name, since, until, maxLinesPerContainer)
 		if err != nil {
-			logger.WarnWithPrefix(d.logPrefix, "CollectAllContainerErrorLogs: error collecting logs for %s: %v", name, err)
 			continue
 		}
 		if len(lines) > 0 {
@@ -212,28 +193,21 @@ func (d *DockerAdapter) CollectAllContainerErrorLogs(ctx context.Context, contai
 
 // StopContainer stops a container by name
 func (d *DockerAdapter) StopContainer(ctx context.Context, containerName string) error {
-	logger.DebugWithPrefix(d.logPrefix, "StopContainer: stopping container %s", containerName)
-
 	// Check if container exists first
 	_, err := d.cli.ContainerInspect(ctx, containerName)
 	if err != nil {
-		logger.WarnWithPrefix(d.logPrefix, "StopContainer: container %s not found or not accessible: %v", containerName, err)
 		return nil // Return nil - container might not exist
 	}
 
 	if err := d.cli.ContainerStop(ctx, containerName, container.StopOptions{}); err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "StopContainer: failed to stop container: %v", err)
 		return fmt.Errorf("failed to stop container: %w", err)
 	}
 
-	logger.DebugWithPrefix(d.logPrefix, "StopContainer: stopped container %s", containerName)
 	return nil
 }
 
 // ListContainersByPrefix returns a list of container IDs that match the given name prefix
 func (d *DockerAdapter) ListContainersByPrefix(ctx context.Context, prefix string) ([]string, error) {
-	logger.DebugWithPrefix(d.logPrefix, "ListContainersByPrefix: listing containers with prefix %s", prefix)
-
 	filterArgs := filters.NewArgs()
 	filterArgs.Add("name", prefix)
 
@@ -249,20 +223,16 @@ func (d *DockerAdapter) ListContainersByPrefix(ctx context.Context, prefix strin
 		ids = append(ids, c.ID)
 	}
 
-	logger.DebugWithPrefix(d.logPrefix, "ListContainersByPrefix: found %d containers with prefix %s", len(ids), prefix)
 	return ids, nil
 }
 
 // StopContainerWithTimeout stops a container by ID with a specific timeout in seconds
 func (d *DockerAdapter) StopContainerWithTimeout(ctx context.Context, containerID string, timeoutSeconds int) error {
-	logger.DebugWithPrefix(d.logPrefix, "StopContainerWithTimeout: stopping container %s with timeout %ds", containerID, timeoutSeconds)
-
 	timeout := timeoutSeconds
 	if err := d.cli.ContainerStop(ctx, containerID, container.StopOptions{Timeout: &timeout}); err != nil {
 		return fmt.Errorf("failed to stop container: %w", err)
 	}
 
-	logger.DebugWithPrefix(d.logPrefix, "StopContainerWithTimeout: stopped container %s", containerID)
 	return nil
 }
 
@@ -272,9 +242,8 @@ const (
 
 // RunSnapshotDownload runs an Alpine container to download and extract a snapshot
 // Uses aria2c for parallel HTTP range request downloads and zstd for decompression
+// Returns the duration of the download operation
 func (d *DockerAdapter) RunSnapshotDownload(ctx context.Context, containerName, clientName, network, targetPath, baseURL string) error {
-	logger.InfoWithPrefix(d.logPrefix, "RunSnapshotDownload: starting download for %s to %s", clientName, targetPath)
-
 	// Pull alpine image if not present
 	if err := d.ensureImage(ctx, alpineImage); err != nil {
 		return fmt.Errorf("failed to ensure alpine image: %w", err)
@@ -336,9 +305,7 @@ echo "[%s] Snapshot extraction complete"
 		Stdout: true,
 		Stderr: true,
 	})
-	if err != nil {
-		logger.WarnWithPrefix(d.logPrefix, "Failed to attach to container: %v", err)
-	} else {
+	if err == nil {
 		defer attachResp.Close()
 		// Copy output to stdout/stderr in a goroutine
 		go func() {
@@ -347,7 +314,6 @@ echo "[%s] Snapshot extraction complete"
 	}
 
 	// Wait for container to finish
-	start := time.Now()
 	statusCh, errCh := d.cli.ContainerWait(ctx, resp.ID, container.WaitConditionNotRunning)
 
 	select {
@@ -361,8 +327,6 @@ echo "[%s] Snapshot extraction complete"
 		}
 	}
 
-	elapsed := time.Since(start)
-	logger.InfoWithPrefix(d.logPrefix, "RunSnapshotDownload: completed in %s", elapsed)
 	return nil
 }
 
@@ -374,7 +338,6 @@ func (d *DockerAdapter) ensureImage(ctx context.Context, imageName string) error
 		return nil // Image already exists
 	}
 
-	logger.InfoWithPrefix(d.logPrefix, "Pulling image %s", imageName)
 	reader, err := d.cli.ImagePull(ctx, imageName, image.PullOptions{})
 	if err != nil {
 		return fmt.Errorf("failed to pull image: %w", err)
@@ -384,6 +347,5 @@ func (d *DockerAdapter) ensureImage(ctx context.Context, imageName string) error
 	// Discard the output but wait for pull to complete
 	_, _ = io.Copy(io.Discard, reader)
 
-	logger.InfoWithPrefix(d.logPrefix, "Successfully pulled image %s", imageName)
 	return nil
 }
diff --git a/internal/adapters/apis/snapshots/snapshots_adapter.go b/internal/adapters/apis/snapshots/snapshots_adapter.go
index b62f899..876f17d 100644
--- a/internal/adapters/apis/snapshots/snapshots_adapter.go
+++ b/internal/adapters/apis/snapshots/snapshots_adapter.go
@@ -7,8 +7,6 @@ import (
 	"io"
 	"net/http"
 	"strings"
-
-	"clients-test/internal/logger"
 )
 
 const (
@@ -16,21 +14,18 @@ const (
 )
 
 type SnapshotsAdapter struct {
-	baseURL   string
-	logPrefix string
+	baseURL string
 }
 
 func NewSnapshotsAdapter() *SnapshotsAdapter {
 	return &SnapshotsAdapter{
-		baseURL:   defaultBaseURL,
-		logPrefix: "SnapshotsAdapter",
+		baseURL: defaultBaseURL,
 	}
 }
 
 func NewSnapshotsAdapterWithURL(baseURL string) *SnapshotsAdapter {
 	return &SnapshotsAdapter{
-		baseURL:   baseURL,
-		logPrefix: "SnapshotsAdapter",
+		baseURL: baseURL,
 	}
 }
 
@@ -42,7 +37,6 @@ func (s *SnapshotsAdapter) GetBaseURL() string {
 // GetLatestBlockNumber fetches the latest available block number for a given network and client
 func (s *SnapshotsAdapter) GetLatestBlockNumber(ctx context.Context, network, client string) (string, error) {
 	url := fmt.Sprintf("%s/%s/%s/latest", s.baseURL, network, client)
-	logger.DebugWithPrefix(s.logPrefix, "Fetching latest block number from %s", url)
 
 	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 	if err != nil {
@@ -65,7 +59,6 @@ func (s *SnapshotsAdapter) GetLatestBlockNumber(ctx context.Context, network, cl
 	}
 
 	blockNumber := strings.TrimSpace(string(body))
-	logger.DebugWithPrefix(s.logPrefix, "Latest block number for %s/%s: %s", network, client, blockNumber)
 	return blockNumber, nil
 }
 
@@ -78,7 +71,6 @@ func (s *SnapshotsAdapter) GetSnapshotURL(network, client, blockNumber string) s
 // The version is retrieved from the _snapshot_web3_clientVersion.json file
 func (s *SnapshotsAdapter) GetClientVersion(ctx context.Context, network, client, blockNumber string) (string, error) {
 	url := fmt.Sprintf("%s/%s/%s/%s/_snapshot_web3_clientVersion.json", s.baseURL, network, client, blockNumber)
-	logger.DebugWithPrefix(s.logPrefix, "Fetching client version from %s", url)
 
 	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 	if err != nil {
@@ -102,7 +94,6 @@ func (s *SnapshotsAdapter) GetClientVersion(ctx context.Context, network, client
 		return "", fmt.Errorf("failed to decode client version response: %w", err)
 	}
 
-	logger.DebugWithPrefix(s.logPrefix, "Client version for %s/%s/%s: %s", network, client, blockNumber, result.Result)
 	return result.Result, nil
 }
 
diff --git a/internal/adapters/composite/snapshotmanager/snapshotmanager.go b/internal/adapters/composite/snapshotmanager/snapshotmanager.go
index 50261c1..65641ce 100644
--- a/internal/adapters/composite/snapshotmanager/snapshotmanager.go
+++ b/internal/adapters/composite/snapshotmanager/snapshotmanager.go
@@ -9,15 +9,12 @@ import (
 	"clients-test/internal/adapters/apis/snapshots"
 	"clients-test/internal/adapters/shared/blocknumber"
 	"clients-test/internal/application/domain"
-	"clients-test/internal/logger"
 )
 
 const (
 	downloadContainerPrefix = "snapshot-download-"
 )
 
-var logPrefix = "SnapshotManager"
-
 // SnapshotManagerAdapter is a composite adapter that combines snapshots, docker, and blocknumber adapters
 // to provide high-level snapshot management operations
 type SnapshotManagerAdapter struct {
@@ -49,7 +46,6 @@ func (s *SnapshotManagerAdapter) NeedsSnapshotDownload(ctx context.Context, clie
 	}
 
 	if !exists {
-		logger.InfoWithPrefix(logPrefix, "No existing snapshot for %s, download needed", client.ShortName)
 		return true, nil
 	}
 
@@ -59,14 +55,7 @@ func (s *SnapshotManagerAdapter) NeedsSnapshotDownload(ctx context.Context, clie
 		return false, err
 	}
 
-	if isNewer {
-		currentBlock, _ := s.blockNumber.ReadBlockNumber(ctx, client.VolumeTargetPath)
-		logger.InfoWithPrefix(logPrefix, "Newer snapshot available for %s: current=%s, latest=%s",
-			client.ShortName, currentBlock, latestBlockNumber)
-		return true, nil
-	}
-
-	return false, nil
+	return isNewer, nil
 }
 
 // DownloadAndMountSnapshot performs the complete snapshot download and mount process:
@@ -80,18 +69,11 @@ func (s *SnapshotManagerAdapter) DownloadAndMountSnapshot(ctx context.Context, n
 		return fmt.Errorf("failed to get latest block number: %w", err)
 	}
 
-	logger.InfoWithPrefix(logPrefix, "Starting snapshot download for %s (block %s)", client.ShortName, latestBlockNumber)
-
-	// 1. Stop the container (if running)
-	logger.InfoWithPrefix(logPrefix, "Stopping container %s", client.ContainerName)
-	if err := s.docker.StopContainer(ctx, client.ContainerName); err != nil {
-		// Log but don't fail - container might not exist or not be running
-		logger.WarnWithPrefix(logPrefix, "Could not stop container %s: %v", client.ContainerName, err)
-	}
+	// 1. Stop the container (if running) - ignore errors as container might not exist
+	_ = s.docker.StopContainer(ctx, client.ContainerName)
 
 	// 2. Download and extract snapshot to volume using Docker container
 	containerName := fmt.Sprintf("%s%s", downloadContainerPrefix, client.ShortName)
-	logger.InfoWithPrefix(logPrefix, "Downloading and extracting snapshot to %s", client.VolumeTargetPath)
 	if err := s.docker.RunSnapshotDownload(ctx, containerName, client.ShortName, network, client.VolumeTargetPath, s.snapshots.GetBaseURL()); err != nil {
 		return fmt.Errorf("failed to download and extract snapshot: %w", err)
 	}
@@ -101,9 +83,6 @@ func (s *SnapshotManagerAdapter) DownloadAndMountSnapshot(ctx context.Context, n
 		return fmt.Errorf("failed to write block number: %w", err)
 	}
 
-	logger.InfoWithPrefix(logPrefix, "Successfully downloaded and mounted snapshot for %s (block %s)",
-		client.ShortName, latestBlockNumber)
-
 	return nil
 }
 
@@ -114,16 +93,12 @@ func (s *SnapshotManagerAdapter) GetLatestBlockNumber(ctx context.Context, netwo
 
 // StopAllDownloads stops all running snapshot download containers in parallel
 func (s *SnapshotManagerAdapter) StopAllDownloads(ctx context.Context) {
-	logger.InfoWithPrefix(logPrefix, "Stopping all snapshot download containers...")
-
 	containerIDs, err := s.docker.ListContainersByPrefix(ctx, downloadContainerPrefix)
 	if err != nil {
-		logger.WarnWithPrefix(logPrefix, "Failed to list download containers: %v", err)
 		return
 	}
 
 	if len(containerIDs) == 0 {
-		logger.DebugWithPrefix(logPrefix, "No download containers running")
 		return
 	}
 
@@ -133,13 +108,8 @@ func (s *SnapshotManagerAdapter) StopAllDownloads(ctx context.Context) {
 		wg.Add(1)
 		go func(containerID string) {
 			defer wg.Done()
-			logger.InfoWithPrefix(logPrefix, "Stopping download container %s", containerID)
-			if err := s.docker.StopContainerWithTimeout(ctx, containerID, 5); err != nil {
-				logger.WarnWithPrefix(logPrefix, "Failed to stop container %s: %v", containerID, err)
-			}
+			_ = s.docker.StopContainerWithTimeout(ctx, containerID, 5)
 		}(id)
 	}
 	wg.Wait()
-
-	logger.InfoWithPrefix(logPrefix, "All download containers stopped")
 }
diff --git a/internal/adapters/shared/blocknumber/blocknumber_adapter.go b/internal/adapters/shared/blocknumber/blocknumber_adapter.go
index 45beb0f..7f525d4 100644
--- a/internal/adapters/shared/blocknumber/blocknumber_adapter.go
+++ b/internal/adapters/shared/blocknumber/blocknumber_adapter.go
@@ -2,7 +2,6 @@ package blocknumber
 
 import (
 	"clients-test/internal/application/domain"
-	"clients-test/internal/logger"
 	"context"
 	"fmt"
 	"os"
@@ -11,8 +10,6 @@ import (
 	"strings"
 )
 
-var logPrefix = "BlockNumberAdapter"
-
 // BlockNumberAdapter handles the snapshot_block_number file operations
 type BlockNumberAdapter struct{}
 
@@ -29,7 +26,6 @@ func (b *BlockNumberAdapter) blockNumberFilePath(volumeTargetPath string) string
 // WriteBlockNumber writes the block number to the snapshot_block_number file in the volume
 func (b *BlockNumberAdapter) WriteBlockNumber(ctx context.Context, volumeTargetPath string, blockNumber string) error {
 	filePath := b.blockNumberFilePath(volumeTargetPath)
-	logger.InfoWithPrefix(logPrefix, "Writing block number %s to %s", blockNumber, filePath)
 
 	// Ensure directory exists
 	if err := os.MkdirAll(volumeTargetPath, 0755); err != nil {
@@ -58,14 +54,12 @@ func (b *BlockNumberAdapter) ReadBlockNumber(ctx context.Context, volumeTargetPa
 	data, err := os.ReadFile(filePath)
 	if err != nil {
 		if os.IsNotExist(err) {
-			logger.DebugWithPrefix(logPrefix, "Block number file does not exist at %s", filePath)
 			return "", nil
 		}
 		return "", fmt.Errorf("failed to read block number file: %w", err)
 	}
 
 	blockNumber := strings.TrimSpace(string(data))
-	logger.DebugWithPrefix(logPrefix, "Read block number %s from %s", blockNumber, filePath)
 	return blockNumber, nil
 }
 
diff --git a/internal/adapters/shared/progress/progress_adapter.go b/internal/adapters/shared/progress/progress_adapter.go
index 8f3a460..f041919 100644
--- a/internal/adapters/shared/progress/progress_adapter.go
+++ b/internal/adapters/shared/progress/progress_adapter.go
@@ -2,7 +2,6 @@ package progress
 
 import (
 	"clients-test/internal/application/domain"
-	"clients-test/internal/logger"
 	"context"
 	"fmt"
 	"os"
@@ -10,8 +9,6 @@ import (
 	"time"
 )
 
-var logPrefix = "ProgressAdapter"
-
 // ProgressAdapter handles the .download_in_progress file operations
 type ProgressAdapter struct {
 	basePath string
@@ -39,7 +36,6 @@ func (p *ProgressAdapter) progressFilePath() string {
 // SetDownloadInProgress creates the .download_in_progress file
 func (p *ProgressAdapter) SetDownloadInProgress(ctx context.Context) error {
 	filePath := p.progressFilePath()
-	logger.InfoWithPrefix(logPrefix, "Setting download in progress at %s", filePath)
 
 	if err := os.MkdirAll(p.basePath, 0755); err != nil {
 		return fmt.Errorf("failed to create directory %s: %w", p.basePath, err)
@@ -62,7 +58,6 @@ func (p *ProgressAdapter) SetDownloadInProgress(ctx context.Context) error {
 // ClearDownloadInProgress removes the .download_in_progress file
 func (p *ProgressAdapter) ClearDownloadInProgress(ctx context.Context) error {
 	filePath := p.progressFilePath()
-	logger.InfoWithPrefix(logPrefix, "Clearing download in progress at %s", filePath)
 
 	err := os.Remove(filePath)
 	if err != nil && !os.IsNotExist(err) {
@@ -88,8 +83,6 @@ func (p *ProgressAdapter) IsDownloadInProgress(ctx context.Context) (bool, error
 // WaitForDownloadComplete waits until no download is in progress
 // Returns an error if the context is cancelled or times out
 func (p *ProgressAdapter) WaitForDownloadComplete(ctx context.Context, checkInterval time.Duration) error {
-	logger.InfoWithPrefix(logPrefix, "Waiting for downloads to complete")
-
 	for {
 		select {
 		case <-ctx.Done():
@@ -101,11 +94,9 @@ func (p *ProgressAdapter) WaitForDownloadComplete(ctx context.Context, checkInte
 			}
 
 			if !inProgress {
-				logger.InfoWithPrefix(logPrefix, "No downloads in progress, continuing")
 				return nil
 			}
 
-			logger.InfoWithPrefix(logPrefix, "Download in progress, waiting %v...", checkInterval)
 			time.Sleep(checkInterval)
 		}
 	}
diff --git a/internal/application/services/snapshot_checker.go b/internal/application/services/snapshot_checker.go
index 6ef345c..8945f8a 100644
--- a/internal/application/services/snapshot_checker.go
+++ b/internal/application/services/snapshot_checker.go
@@ -43,14 +43,14 @@ func (s *SnapshotCheckerService) Start(ctx context.Context, runOnce bool) error
 	logger.InfoWithPrefix(snapshotLogPrefix, "Managing %d execution clients", len(s.config.ExecutionClients))
 
 	// Run immediately on startup
+	logger.InfoWithPrefix(snapshotLogPrefix, "Running initial snapshot check...")
 	if err := s.CheckAndUpdateSnapshots(ctx); err != nil {
 		logger.ErrorWithPrefix(snapshotLogPrefix, "Initial snapshot check failed: %v", err)
-		// Return error on initial failure to avoid waiting the cron interval
 		return err
 	}
 
 	if runOnce {
-		logger.InfoWithPrefix(snapshotLogPrefix, "Run-once mode, exiting after initial check")
+		logger.InfoWithPrefix(snapshotLogPrefix, "Run-once mode enabled, exiting after initial check")
 		return nil
 	}
 
@@ -67,7 +67,7 @@ func (s *SnapshotCheckerService) Start(ctx context.Context, runOnce bool) error
 			logger.InfoWithPrefix(snapshotLogPrefix, "Snapshot checker stopped: %v", ctx.Err())
 			return ctx.Err()
 		case <-ticker.C:
-			logger.InfoWithPrefix(snapshotLogPrefix, "Running scheduled snapshot check")
+			logger.InfoWithPrefix(snapshotLogPrefix, "Running scheduled snapshot check...")
 			if err := s.CheckAndUpdateSnapshots(ctx); err != nil {
 				logger.ErrorWithPrefix(snapshotLogPrefix, "Scheduled snapshot check failed: %v", err)
 				// Continue running even on failure
@@ -81,6 +81,7 @@ func (s *SnapshotCheckerService) CheckAndUpdateSnapshots(ctx context.Context) er
 	logger.InfoWithPrefix(snapshotLogPrefix, "Checking snapshots for %d clients", len(s.config.ExecutionClients))
 
 	// Check if a download is already in progress
+	logger.InfoWithPrefix(snapshotLogPrefix, "Checking if download is already in progress...")
 	inProgress, err := s.progress.IsDownloadInProgress(ctx)
 	if err != nil {
 		return fmt.Errorf("failed to check download progress: %w", err)
@@ -91,16 +92,16 @@ func (s *SnapshotCheckerService) CheckAndUpdateSnapshots(ctx context.Context) er
 	}
 
 	// Set download in progress for this cycle
+	logger.InfoWithPrefix(snapshotLogPrefix, "Setting download in progress marker...")
 	if err := s.progress.SetDownloadInProgress(ctx); err != nil {
 		return fmt.Errorf("failed to set download in progress: %w", err)
 	}
 
 	// Ensure we clear the progress file on completion (success or failure)
 	defer func() {
+		logger.InfoWithPrefix(snapshotLogPrefix, "Clearing download in progress marker...")
 		if err := s.progress.ClearDownloadInProgress(ctx); err != nil {
 			logger.ErrorWithPrefix(snapshotLogPrefix, "Failed to clear download in progress: %v", err)
-		} else {
-			logger.InfoWithPrefix(snapshotLogPrefix, "Cleared download in progress file")
 		}
 	}()
 
@@ -138,30 +139,51 @@ func (s *SnapshotCheckerService) CheckAndUpdateSnapshots(ctx context.Context) er
 
 // checkAndUpdateClient checks a single client and updates snapshot if needed
 func (s *SnapshotCheckerService) checkAndUpdateClient(ctx context.Context, client domain.ExecutionClientInfo) error {
-	logger.InfoWithPrefix(snapshotLogPrefix, "Checking client: %s (%s)", client.ShortName, client.DnpName)
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Checking client (%s)", client.ShortName, client.DnpName)
 
 	// Get latest available block number from ethpandaops
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Fetching latest available block number...", client.ShortName)
 	latestBlockNumber, err := s.snapshotManager.GetLatestBlockNumber(ctx, s.config.Network, client.ShortName)
 	if err != nil {
 		return fmt.Errorf("failed to get latest block number: %w", err)
 	}
-	logger.InfoWithPrefix(snapshotLogPrefix, "Latest available snapshot for %s: block %s", client.ShortName, latestBlockNumber)
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Latest available snapshot: block %s", client.ShortName, latestBlockNumber)
 
-	// Check if we need to download (delegated to composite adapter)
+	// Check if we need to download
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Checking if snapshot download is needed...", client.ShortName)
 	needsDownload, err := s.snapshotManager.NeedsSnapshotDownload(ctx, client, latestBlockNumber)
 	if err != nil {
 		return fmt.Errorf("failed to check if snapshot needed: %w", err)
 	}
 
 	if !needsDownload {
-		logger.InfoWithPrefix(snapshotLogPrefix, "Snapshot for %s is up to date, skipping", client.ShortName)
+		logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Snapshot is up to date, skipping", client.ShortName)
 		return nil
 	}
 
-	// Download and mount snapshot (delegated to composite adapter)
-	if err := s.snapshotManager.DownloadAndMountSnapshot(ctx, s.config.Network, client); err != nil {
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Snapshot download needed", client.ShortName)
+
+	// Download and mount snapshot
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Starting snapshot download and extraction...", client.ShortName)
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Target path: %s", client.ShortName, client.VolumeTargetPath)
+
+	start := time.Now()
+	err = s.snapshotManager.DownloadAndMountSnapshot(ctx, s.config.Network, client)
+	elapsed := time.Since(start)
+
+	if err != nil {
 		return fmt.Errorf("failed to download and mount snapshot: %w", err)
 	}
 
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] ✓ Snapshot download completed successfully", client.ShortName)
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Total time: %s", client.ShortName, elapsed.Round(time.Second))
+
 	return nil
 }
+
+// StopAllDownloads stops all running download containers (for graceful shutdown)
+func (s *SnapshotCheckerService) StopAllDownloads(ctx context.Context) {
+	logger.InfoWithPrefix(snapshotLogPrefix, "Stopping all snapshot download containers...")
+	s.snapshotManager.StopAllDownloads(ctx)
+	logger.InfoWithPrefix(snapshotLogPrefix, "All download containers stopped")
+}

From 7d8735d03f40eb3e37f925147e99869856ab1cc4 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Wed, 21 Jan 2026 17:31:04 +0100
Subject: [PATCH 21/42] move all logs from adapters to service test runner

---
 README.md | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index f661b5d..78219b8 100644
--- a/README.md
+++ b/README.md
@@ -141,11 +141,10 @@ docker-compose up --build
 - [x] Measure the time it takes every process in the test and add it to the report
 - [x] Collect logs from containers and create a report
 - [x] Add to the report the clients used
-- [ ] Implement timer check in the snapshot checker
+- [x] Implement timer check in the snapshot checker
 - [ ] The test runner must remove the clients or unset the staker config on exit
-- [ ] Implement a composite adapter for the snapshot checker
-- [ ] Implement time tracker in the snapshot checker service to measure time taken for each action, specially download and extraction of snapshots
-- [ ] Implement snapshot cleaner on signal interrupt or termination to avoid corrupted snapshots
+- [x] Implement a composite adapter for the snapshot checker
+- [x] Implement time tracker in the snapshot checker service to measure time taken for each action, specially download and extraction of snapshots
 - [ ] Auto-updates for this dappnode must run much more often than production, so clients are always updated to latest versions
 - [ ] Research how to release this SDK tool to be run from a github action directly
 - [ ] Implement when manual trigger (`workflow_dispatch`) the clients will be passed as inputs, use them to create the staker config for the test
@@ -159,4 +158,6 @@ docker-compose up --build
 - [ ] Consider adding a DB for reports and a UI to consume them
 - [ ] Consider adding to report beaconcha validator url
 - [ ] Consider adding support for multiple networks (mainnet, prater, etc.)
-- [ ] Consider setting keystore and password through github secrets.
\ No newline at end of file
+- [ ] Consider setting keystore and password through github secrets.
+- [ ] How to ensure IPFS resilience, it must resolve production and dev IPFS hashes!
+- [ ] Pass all the time measured in the ensurer and or runner and or cleaner to the test runner service for printing and report
\ No newline at end of file

From 77c4d2950504b53f7ef8974306234c82987b2eab Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Wed, 21 Jan 2026 17:31:18 +0100
Subject: [PATCH 22/42] move loggin to test runner

---
 .../apis/beaconchain/beaconchain_adapter.go   | 37 -----------
 internal/adapters/apis/brain/brain_adapter.go | 18 ++---
 .../apis/dappmanager/dappmanager_adapter.go   | 66 +++----------------
 .../apis/execution/execution_adapter.go       | 25 ++-----
 .../adapters/apis/github/github_adapter.go    | 35 ++++------
 internal/adapters/apis/ipfs/ipfs_adapter.go   | 35 ++--------
 .../apis/tropidatooor/trpoidatooor_adapter.go | 22 ++-----
 internal/adapters/composite/composite.go      | 20 +-----
 .../adapters/composite/ensurer/ensurer.go     | 24 -------
 .../adapters/composite/executor/executor.go   | 10 ---
 .../adapters/system/mount/mount_adapter.go    | 14 +---
 internal/application/services/test_runner.go  | 16 +++++
 12 files changed, 56 insertions(+), 266 deletions(-)

diff --git a/internal/adapters/apis/beaconchain/beaconchain_adapter.go b/internal/adapters/apis/beaconchain/beaconchain_adapter.go
index 3dfbf40..38d9276 100644
--- a/internal/adapters/apis/beaconchain/beaconchain_adapter.go
+++ b/internal/adapters/apis/beaconchain/beaconchain_adapter.go
@@ -2,7 +2,6 @@ package beaconchain
 
 import (
 	"bytes"
-	"clients-test/internal/logger"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -15,7 +14,6 @@ import (
 type BeaconchainAdapter struct {
 	beaconChainUrl string
 	client         *http.Client
-	logPrefix      string
 }
 
 // NewBeaconchainAdapter creates a new BeaconchainAdapter
@@ -23,27 +21,22 @@ func NewBeaconchainAdapter(beaconChainUrl string) *BeaconchainAdapter {
 	return &BeaconchainAdapter{
 		beaconChainUrl: beaconChainUrl,
 		client:         &http.Client{},
-		logPrefix:      "BeaconchainAdapter",
 	}
 }
 
 // GetIsSyncing retrieves the syncing status from the beacon node with context
 func (b *BeaconchainAdapter) GetIsSyncing(ctx context.Context) (bool, error) {
 	url := fmt.Sprintf("%s/eth/v1/node/syncing", b.beaconChainUrl)
-	logger.DebugWithPrefix(b.logPrefix, "GetIsSyncing: url=%s", url)
 	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetIsSyncing: failed to create request: %v", err)
 		return false, err
 	}
 	resp, err := b.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetIsSyncing: request failed: %v", err)
 		return false, err
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(b.logPrefix, "GetIsSyncing: non-200 status: %s", resp.Status)
 		return false, fmt.Errorf("beacon node syncing failed: %s", resp.Status)
 	}
 	var result struct {
@@ -52,10 +45,8 @@ func (b *BeaconchainAdapter) GetIsSyncing(ctx context.Context) (bool, error) {
 		} `json:"data"`
 	}
 	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetIsSyncing: failed to decode response: %v", err)
 		return false, err
 	}
-	logger.DebugWithPrefix(b.logPrefix, "GetIsSyncing: result=%+v", result.Data.IsSyncing)
 	return result.Data.IsSyncing, nil
 }
 
@@ -73,36 +64,29 @@ type blockHeaderResponse struct {
 // getBlockHeader retrieves the block header for a given block ID
 func (b *BeaconchainAdapter) getBlockHeader(ctx context.Context, blockID string) (*blockHeaderResponse, error) {
 	url := fmt.Sprintf("%s/eth/v1/beacon/headers/%s", b.beaconChainUrl, blockID)
-	logger.DebugWithPrefix(b.logPrefix, "getBlockHeader: url=%s", url)
 	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "getBlockHeader: failed to create request: %v", err)
 		return nil, fmt.Errorf("failed to send request to Beaconchain at %s: %w", url, err)
 	}
 	resp, err := b.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "getBlockHeader: request failed: %v", err)
 		return nil, err
 	}
 	defer resp.Body.Close()
 	var result blockHeaderResponse
 	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "getBlockHeader: failed to decode response: %v", err)
 		return nil, fmt.Errorf("failed to decode response for GetBlockHeader: %w", err)
 	}
-	logger.DebugWithPrefix(b.logPrefix, "getBlockHeader: slot=%s", result.Data.Header.Message.Slot)
 	return &result, nil
 }
 
 func (b *BeaconchainAdapter) getEpochHead(ctx context.Context, blockID string) (uint64, error) {
 	header, err := b.getBlockHeader(ctx, blockID)
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "getEpochHead: failed to get block header for blockID %s: %v", blockID, err)
 		return 0, fmt.Errorf("failed to get block header for blockID %s: %w", blockID, err)
 	}
 	slot := header.Data.Header.Message.Slot
 	epoch := getEpochFromSlot(slot)
-	logger.DebugWithPrefix(b.logPrefix, "getEpochHead: slot=%s epoch=%d", slot, epoch)
 	return epoch, nil
 }
 
@@ -122,32 +106,26 @@ func parseInt(slot string) uint64 {
 func (b *BeaconchainAdapter) GetValidatorLiveness(ctx context.Context, indexes []string) (map[string]bool, error) {
 	epoch, err := b.getEpochHead(ctx, "head")
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorLiveness: failed to get epoch head: %v", err)
 		return nil, err
 	}
 	// Prepare POST request body as JSON array of indices
 	jsonBytes, err := json.Marshal(indexes)
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorLiveness: failed to marshal request body: %v", err)
 		return nil, err
 	}
 	url := fmt.Sprintf("%s/eth/v1/validator/liveness/%d", b.beaconChainUrl, epoch)
-	logger.DebugWithPrefix(b.logPrefix, "GetValidatorLiveness: url=%s body=%v", url, indexes)
 	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonBytes))
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorLiveness: failed to create request: %v", err)
 		return nil, err
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := b.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorLiveness: request failed: %v", err)
 		return nil, err
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorLiveness: non-200 status: %s", resp.Status)
 		return nil, fmt.Errorf("validator liveness failed: %s", resp.Status)
 	}
 	var result struct {
@@ -157,14 +135,12 @@ func (b *BeaconchainAdapter) GetValidatorLiveness(ctx context.Context, indexes [
 		} `json:"data"`
 	}
 	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorLiveness: failed to decode response: %v", err)
 		return nil, err
 	}
 	liveness := make(map[string]bool)
 	for _, v := range result.Data {
 		liveness[v.Index] = v.IsLive
 	}
-	logger.DebugWithPrefix(b.logPrefix, "GetValidatorLiveness: liveness=%+v", liveness)
 	return liveness, nil
 }
 
@@ -172,23 +148,19 @@ func (b *BeaconchainAdapter) GetValidatorLiveness(ctx context.Context, indexes [
 // See: https://ethereum.github.io/beacon-APIs/#/Node/getNodeVersion
 func (b *BeaconchainAdapter) GetClientVersion(ctx context.Context) (string, error) {
 	url := fmt.Sprintf("%s/eth/v1/node/version", b.beaconChainUrl)
-	logger.DebugWithPrefix(b.logPrefix, "GetClientVersion: url=%s", url)
 
 	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetClientVersion: failed to create request: %v", err)
 		return "", err
 	}
 
 	resp, err := b.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetClientVersion: request failed: %v", err)
 		return "", err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(b.logPrefix, "GetClientVersion: non-200 status: %s", resp.Status)
 		return "", fmt.Errorf("beacon node version failed: %s", resp.Status)
 	}
 
@@ -198,18 +170,15 @@ func (b *BeaconchainAdapter) GetClientVersion(ctx context.Context) (string, erro
 		} `json:"data"`
 	}
 	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetClientVersion: failed to decode response: %v", err)
 		return "", err
 	}
 
-	logger.DebugWithPrefix(b.logPrefix, "GetClientVersion: version=%s", result.Data.Version)
 	return result.Data.Version, nil
 }
 
 // GetValidatorsIndexes retrieves the validator index for each given pubkey with status active_ongoing
 func (b *BeaconchainAdapter) GetValidatorsIndexes(ctx context.Context, pubkeys []string) ([]string, error) {
 	url := fmt.Sprintf("%s/eth/v1/beacon/states/finalized/validators", b.beaconChainUrl)
-	logger.DebugWithPrefix(b.logPrefix, "GetValidatorsIndexes: url=%s pubkeys=%+v", url, pubkeys)
 	requestBody := struct {
 		IDs      []string `json:"ids"`
 		Statuses []string `json:"statuses"`
@@ -219,26 +188,22 @@ func (b *BeaconchainAdapter) GetValidatorsIndexes(ctx context.Context, pubkeys [
 	}
 	jsonBytes, err := json.Marshal(requestBody)
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorsIndexes: failed to marshal request body: %v", err)
 		return nil, err
 	}
 
 	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonBytes))
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorsIndexes: failed to create request: %v", err)
 		return nil, err
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := b.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorsIndexes: request failed: %v", err)
 		return nil, err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorsIndexes: non-200 status: %s", resp.Status)
 		return nil, fmt.Errorf("get validators indexes failed: %s", resp.Status)
 	}
 
@@ -251,13 +216,11 @@ func (b *BeaconchainAdapter) GetValidatorsIndexes(ctx context.Context, pubkeys [
 		} `json:"data"`
 	}
 	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorsIndexes: failed to decode response: %v", err)
 		return nil, err
 	}
 	indexes := make([]string, len(result.Data))
 	for i, v := range result.Data {
 		indexes[i] = v.Index
 	}
-	logger.DebugWithPrefix(b.logPrefix, "GetValidatorsIndexes: indexes=%+v", indexes)
 	return indexes, nil
 }
diff --git a/internal/adapters/apis/brain/brain_adapter.go b/internal/adapters/apis/brain/brain_adapter.go
index 6f7021f..407f06e 100644
--- a/internal/adapters/apis/brain/brain_adapter.go
+++ b/internal/adapters/apis/brain/brain_adapter.go
@@ -1,7 +1,6 @@
 package brain
 
 import (
-	"clients-test/internal/logger"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -12,51 +11,42 @@ import (
 // It interacts with the brain service to fetch validator indexes
 // Example endpoint: /api/v0/brain/validators?tag=solo&format=index
 type BrainAdapter struct {
-	brainUrl  string
-	client    *http.Client
-	logPrefix string
+	brainUrl string
+	client   *http.Client
 }
 
 // NewBrainAdapter creates a new BrainAdapter
 func NewBrainAdapter(brainUrl string) *BrainAdapter {
 	return &BrainAdapter{
-		brainUrl:  brainUrl,
-		client:    &http.Client{},
-		logPrefix: "BrainAdapter",
+		brainUrl: brainUrl,
+		client:   &http.Client{},
 	}
 }
 
 // GetValidatorsPubkeys fetches the validator public keys from the brain service with context
 func (b *BrainAdapter) GetValidatorsPubkeys(ctx context.Context) ([]string, error) {
 	url := fmt.Sprintf("%s/api/v0/brain/validators?tag=solo&format=pubkey", b.brainUrl)
-	logger.DebugWithPrefix(b.logPrefix, "GetValidatorsPubkeys: url=%s", url)
 	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorsPubkeys: failed to create request: %v", err)
 		return nil, err
 	}
 	resp, err := b.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorsPubkeys: request failed: %v", err)
 		return nil, err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorsPubkeys: non-200 status: %s", resp.Status)
 		return nil, fmt.Errorf("brain service error: %s", resp.Status)
 	}
 
 	var tagValidators map[string][]string
 	if err := json.NewDecoder(resp.Body).Decode(&tagValidators); err != nil {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorsPubkeys: failed to decode response: %v", err)
 		return nil, err
 	}
 	pubkeys, ok := tagValidators["solo"]
 	if !ok {
-		logger.ErrorWithPrefix(b.logPrefix, "GetValidatorsPubkeys: no 'solo' tag found in response")
 		return nil, fmt.Errorf("no 'solo' tag found in response")
 	}
-	logger.DebugWithPrefix(b.logPrefix, "GetValidatorsPubkeys: pubkeys=%+v", pubkeys)
 	return pubkeys, nil
 }
diff --git a/internal/adapters/apis/dappmanager/dappmanager_adapter.go b/internal/adapters/apis/dappmanager/dappmanager_adapter.go
index 21d9f89..20051b9 100644
--- a/internal/adapters/apis/dappmanager/dappmanager_adapter.go
+++ b/internal/adapters/apis/dappmanager/dappmanager_adapter.go
@@ -3,7 +3,6 @@ package dappmanager
 import (
 	"bytes"
 	"clients-test/internal/application/domain"
-	"clients-test/internal/logger"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -14,40 +13,33 @@ import (
 
 // DappManagerAdapter is the adapter to interact with the DappManager API
 type DappManagerAdapter struct {
-	baseURL   string
-	client    *http.Client
-	logPrefix string
+	baseURL string
+	client  *http.Client
 }
 
 // NewDappManagerAdapter creates a new DappManagerAdapter
 func NewDappManagerAdapter() *DappManagerAdapter {
 	return &DappManagerAdapter{
-		baseURL:   "http://my.dappnode:7000",
-		client:    &http.Client{},
-		logPrefix: "DappManagerAdapter",
+		baseURL: "http://my.dappnode:7000",
+		client:  &http.Client{},
 	}
 }
 
 // Ping sends a ping request to the DappManager API with context
 func (d *DappManagerAdapter) Ping(ctx context.Context) error {
-	logger.DebugWithPrefix(d.logPrefix, "Ping: url=%s", d.baseURL+"/ping")
 	req, err := http.NewRequestWithContext(ctx, "GET", d.baseURL+"/ping", nil)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "Ping: failed to create request: %v", err)
 		return err
 	}
 	resp, err := d.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "Ping: request failed: %v", err)
 		return err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(d.logPrefix, "Ping: non-200 status: %s", resp.Status)
 		return fmt.Errorf("ping failed: %s", resp.Status)
 	}
-	logger.DebugWithPrefix(d.logPrefix, "Ping: success")
 	return nil
 }
 
@@ -55,27 +47,22 @@ func (d *DappManagerAdapter) Ping(ctx context.Context) error {
 func (d *DappManagerAdapter) PackageInstall(ctx context.Context, pkg domain.Pkg) error {
 	url := d.baseURL + "/packageInstall"
 	payload := fmt.Sprintf(`{"name": "%s", "version": "%s", "userSettings": {}, "options": {"BYPASS_CORE_RESTRICTION": true, "BYPASS_SIGNED_RESTRICTION": true}}`, pkg.DnpName, pkg.Version)
-	logger.DebugWithPrefix(d.logPrefix, "PackageInstall: url=%s payload=%s", url, payload)
 
 	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader([]byte(payload)))
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "PackageInstall: failed to create request: %v", err)
 		return err
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := d.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "PackageInstall: request failed: %v", err)
 		return err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(d.logPrefix, "PackageInstall: non-200 status: %s", resp.Status)
 		return fmt.Errorf("package install failed: %s", resp.Status)
 	}
-	logger.DebugWithPrefix(d.logPrefix, "PackageInstall: success for pkg=%+v", pkg)
 	return nil
 }
 
@@ -97,40 +84,33 @@ type StakerConfigGetMinimal struct {
 func (d *DappManagerAdapter) GetStakerConfig(ctx context.Context, network string) (StakerConfigGetMinimal, error) {
 	url := d.baseURL + "/stakerConfigGet"
 	payload := fmt.Sprintf(`{"network": "%s"}`, network)
-	logger.DebugWithPrefix(d.logPrefix, "GetStakerConfig: url=%s payload=%s", url, payload)
 
 	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader([]byte(payload)))
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "GetStakerConfig: failed to create request: %v", err)
 		return StakerConfigGetMinimal{}, err
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := d.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "GetStakerConfig: request failed: %v", err)
 		return StakerConfigGetMinimal{}, err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(d.logPrefix, "GetStakerConfig: non-200 status: %s", resp.Status)
 		return StakerConfigGetMinimal{}, fmt.Errorf("get staker config failed: %s", resp.Status)
 	}
 
 	bodyBytes, err := io.ReadAll(resp.Body)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "GetStakerConfig: failed to read response body: %v", err)
 		return StakerConfigGetMinimal{}, err
 	}
 
 	var result StakerConfigGetMinimal
 	err = json.Unmarshal(bodyBytes, &result)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "GetStakerConfig: failed to unmarshal response: %v", err)
 		return StakerConfigGetMinimal{}, err
 	}
-	logger.DebugWithPrefix(d.logPrefix, "GetStakerConfig: result=%+v", result)
 	return result, nil
 }
 
@@ -149,30 +129,24 @@ func (d *DappManagerAdapter) SetStakerConfig(ctx context.Context, stakerClients
 	}
 	jsonBytes, err := json.Marshal(payload)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "SetStakerConfig: failed to marshal payload: %v", err)
 		return err
 	}
-	logger.DebugWithPrefix(d.logPrefix, "SetStakerConfig: url=%s payload=%s", url, string(jsonBytes))
 
 	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonBytes))
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "SetStakerConfig: failed to create request: %v", err)
 		return err
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := d.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "SetStakerConfig: request failed: %v", err)
 		return err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(d.logPrefix, "SetStakerConfig: non-200 status: %s", resp.Status)
 		return fmt.Errorf("set staker config failed: %s", resp.Status)
 	}
-	logger.DebugWithPrefix(d.logPrefix, "SetStakerConfig: success for stakerClients=%+v", stakerClients)
 	return nil
 }
 
@@ -189,30 +163,24 @@ func (d *DappManagerAdapter) removePackage(ctx context.Context, dnpName string,
 	}
 	jsonBytes, err := json.Marshal(body)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "removePackage: failed to marshal body: %v", err)
 		return err
 	}
-	logger.DebugWithPrefix(d.logPrefix, "removePackage: url=%s body=%s", url, string(jsonBytes))
 
 	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonBytes))
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "removePackage: failed to create request: %v", err)
 		return err
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := d.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "removePackage: request failed: %v", err)
 		return err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(d.logPrefix, "removePackage: non-200 status: %s", resp.Status)
 		return fmt.Errorf("remove package failed: %s", resp.Status)
 	}
-	logger.DebugWithPrefix(d.logPrefix, "removePackage: success for dnpName=%s", dnpName)
 	return nil
 }
 
@@ -225,35 +193,29 @@ type installedPackageMinimal struct {
 // getPackages retrieves the list of installed packages from the DappManager API with context
 func (d *DappManagerAdapter) getPackages(ctx context.Context) ([]installedPackageMinimal, error) {
 	url := d.baseURL + "/packagesGet"
-	logger.DebugWithPrefix(d.logPrefix, "getPackages: url=%s", url)
 
 	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "getPackages: failed to create request: %v", err)
 		return nil, err
 	}
 	resp, err := d.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "getPackages: request failed: %v", err)
 		return nil, err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(d.logPrefix, "getPackages: non-200 status: %s", resp.Status)
 		return nil, fmt.Errorf("get packages failed: %s", resp.Status)
 	}
 
 	bodyBytes, err := io.ReadAll(resp.Body)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "getPackages: failed to read response body: %v", err)
 		return nil, err
 	}
 
 	var allPackages []map[string]interface{}
 	err = json.Unmarshal(bodyBytes, &allPackages)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "getPackages: failed to unmarshal response: %v", err)
 		return nil, err
 	}
 
@@ -266,41 +228,31 @@ func (d *DappManagerAdapter) getPackages(ctx context.Context) ([]installedPackag
 			IsCore:  isCore,
 		})
 	}
-	logger.DebugWithPrefix(d.logPrefix, "getPackages: result=%+v", result)
 	return result, nil
 }
 
 // RemoveNonCorePackages removes all non-core packages from the Dappnode to clean up the system with context
-func (d *DappManagerAdapter) RemoveNonCorePackages(ctx context.Context) []error {
-	logger.DebugWithPrefix(d.logPrefix, "RemoveNonCorePackages: called")
+// Returns a list of packages that were skipped and any errors encountered
+func (d *DappManagerAdapter) RemoveNonCorePackages(ctx context.Context) (skipped []string, errors []error) {
 	packages, err := d.getPackages(ctx)
 	if err != nil {
-		logger.ErrorWithPrefix(d.logPrefix, "RemoveNonCorePackages: failed to get packages: %v", err)
-		return []error{err}
+		return nil, []error{err}
 	}
-	var errors []error
 	for _, pkg := range packages {
 		if !pkg.IsCore {
 			// skip if pkg.DnpName includes web3signer or mev-boost
 			if strings.Contains(pkg.DnpName, "web3signer") || strings.Contains(pkg.DnpName, "mev-boost") {
-				logger.DebugWithPrefix(d.logPrefix, "RemoveNonCorePackages: skipping package %s as it is web3signer or mev-boost", pkg.DnpName)
+				skipped = append(skipped, pkg.DnpName)
 				continue
 			}
 			deleteVolumes := true
 
-			logger.DebugWithPrefix(d.logPrefix, "RemoveNonCorePackages: removing dnpName=%s deleteVolumes=%v", pkg.DnpName, deleteVolumes)
 			err := d.removePackage(ctx, pkg.DnpName, &deleteVolumes)
 			if err != nil {
-				logger.ErrorWithPrefix(d.logPrefix, "RemoveNonCorePackages: failed to remove package %s: %v", pkg.DnpName, err)
 				errors = append(errors, fmt.Errorf("failed to remove package %s: %w", pkg.DnpName, err))
 				continue
 			}
 		}
 	}
-	if len(errors) > 0 {
-		return errors
-	}
-
-	logger.DebugWithPrefix(d.logPrefix, "RemoveNonCorePackages: success")
-	return nil
+	return skipped, errors
 }
diff --git a/internal/adapters/apis/execution/execution_adapter.go b/internal/adapters/apis/execution/execution_adapter.go
index efd6e67..e6f7251 100644
--- a/internal/adapters/apis/execution/execution_adapter.go
+++ b/internal/adapters/apis/execution/execution_adapter.go
@@ -2,7 +2,6 @@ package execution
 
 import (
 	"bytes"
-	"clients-test/internal/logger"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -13,17 +12,15 @@ import (
 // It interacts with an Ethereum execution client via JSON-RPC
 // See: https://ethereum.github.io/execution-apis/api-documentation/
 type ExecutionAdapter struct {
-	baseURL   string
-	client    *http.Client
-	logPrefix string
+	baseURL string
+	client  *http.Client
 }
 
 // NewExecutionAdapter creates a new ExecutionAdapter
 func NewExecutionAdapter(baseURL string) *ExecutionAdapter {
 	return &ExecutionAdapter{
-		baseURL:   baseURL,
-		client:    &http.Client{},
-		logPrefix: "ExecutionAdapter",
+		baseURL: baseURL,
+		client:  &http.Client{},
 	}
 }
 
@@ -31,7 +28,6 @@ func NewExecutionAdapter(baseURL string) *ExecutionAdapter {
 // See: https://ethereum.github.io/execution-apis/api-documentation/ (web3_clientVersion)
 func (e *ExecutionAdapter) GetClientVersion(ctx context.Context) (string, error) {
 	url := e.baseURL
-	logger.DebugWithPrefix(e.logPrefix, "GetClientVersion: url=%s", url)
 
 	// JSON-RPC request body for web3_clientVersion
 	body := map[string]interface{}{
@@ -42,26 +38,22 @@ func (e *ExecutionAdapter) GetClientVersion(ctx context.Context) (string, error)
 	}
 	jsonBytes, err := json.Marshal(body)
 	if err != nil {
-		logger.ErrorWithPrefix(e.logPrefix, "GetClientVersion: failed to marshal body: %v", err)
 		return "", err
 	}
 
 	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonBytes))
 	if err != nil {
-		logger.ErrorWithPrefix(e.logPrefix, "GetClientVersion: failed to create request: %v", err)
 		return "", err
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := e.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(e.logPrefix, "GetClientVersion: request failed: %v", err)
 		return "", err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(e.logPrefix, "GetClientVersion: non-200 status: %s", resp.Status)
 		return "", fmt.Errorf("web3_clientVersion failed: %s", resp.Status)
 	}
 
@@ -69,18 +61,15 @@ func (e *ExecutionAdapter) GetClientVersion(ctx context.Context) (string, error)
 		Result string `json:"result"`
 	}
 	if err := json.NewDecoder(resp.Body).Decode(&rpcResp); err != nil {
-		logger.ErrorWithPrefix(e.logPrefix, "GetClientVersion: failed to decode response: %v", err)
 		return "", err
 	}
 
-	logger.DebugWithPrefix(e.logPrefix, "GetClientVersion: version=%s", rpcResp.Result)
 	return rpcResp.Result, nil
 }
 
 // GetIsSyncing retrieves the syncing status from the execution client with context
 func (e *ExecutionAdapter) GetIsSyncing(ctx context.Context) (bool, error) {
 	url := e.baseURL
-	logger.DebugWithPrefix(e.logPrefix, "GetIsSyncing: url=%s", url)
 	// JSON-RPC request body for eth_syncing
 	body := map[string]interface{}{
 		"jsonrpc": "2.0",
@@ -90,26 +79,22 @@ func (e *ExecutionAdapter) GetIsSyncing(ctx context.Context) (bool, error) {
 	}
 	jsonBytes, err := json.Marshal(body)
 	if err != nil {
-		logger.ErrorWithPrefix(e.logPrefix, "GetIsSyncing: failed to marshal body: %v", err)
 		return false, err
 	}
 
 	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonBytes))
 	if err != nil {
-		logger.ErrorWithPrefix(e.logPrefix, "GetIsSyncing: failed to create request: %v", err)
 		return false, err
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := e.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(e.logPrefix, "GetIsSyncing: request failed: %v", err)
 		return false, err
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(e.logPrefix, "GetIsSyncing: non-200 status: %s", resp.Status)
 		return false, fmt.Errorf("eth_syncing failed: %s", resp.Status)
 	}
 
@@ -117,11 +102,9 @@ func (e *ExecutionAdapter) GetIsSyncing(ctx context.Context) (bool, error) {
 		Result interface{} `json:"result"`
 	}
 	if err := json.NewDecoder(resp.Body).Decode(&rpcResp); err != nil {
-		logger.ErrorWithPrefix(e.logPrefix, "GetIsSyncing: failed to decode response: %v", err)
 		return false, err
 	}
 
-	logger.DebugWithPrefix(e.logPrefix, "GetIsSyncing: result=%+v", rpcResp.Result)
 	// Per spec, result is either false (not syncing) or an object (syncing)
 	if b, ok := rpcResp.Result.(bool); ok {
 		return b, nil
diff --git a/internal/adapters/apis/github/github_adapter.go b/internal/adapters/apis/github/github_adapter.go
index d0afe39..7497fdc 100644
--- a/internal/adapters/apis/github/github_adapter.go
+++ b/internal/adapters/apis/github/github_adapter.go
@@ -3,7 +3,6 @@ package github
 import (
 	"bytes"
 	"clients-test/internal/application/domain"
-	"clients-test/internal/logger"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -27,10 +26,9 @@ type GitHubConfig struct {
 
 // GitHubAdapter handles interactions with the GitHub API
 type GitHubAdapter struct {
-	config    GitHubConfig
-	client    *http.Client
-	logPrefix string
-	baseURL   string
+	config  GitHubConfig
+	client  *http.Client
+	baseURL string
 }
 
 // NewGitHubAdapter creates a new GitHub adapter
@@ -42,10 +40,9 @@ func NewGitHubAdapter(config GitHubConfig) *GitHubAdapter {
 	}
 
 	return &GitHubAdapter{
-		config:    config,
-		client:    &http.Client{},
-		logPrefix: "GitHubAdapter",
-		baseURL:   baseURL,
+		config:  config,
+		client:  &http.Client{},
+		baseURL: baseURL,
 	}
 }
 
@@ -63,7 +60,6 @@ type IssueComment struct {
 // CommentOnPR creates or updates a comment on a pull request with the test report
 func (g *GitHubAdapter) CommentOnPR(ctx context.Context, report *domain.TestReport) error {
 	if !g.IsEnabled() {
-		logger.InfoWithPrefix(g.logPrefix, "GitHub integration not enabled (missing token, repo info, or PR number), skipping PR comment")
 		return nil
 	}
 
@@ -82,26 +78,17 @@ func (g *GitHubAdapter) CommentOnPR(ctx context.Context, report *domain.TestRepo
 	// Check for existing comment to update
 	existingCommentID, err := g.findExistingComment(ctx, signature)
 	if err != nil {
-		logger.WarnWithPrefix(g.logPrefix, "Failed to find existing comment, will create new: %v", err)
+		// Continue with creating new comment if we can't find existing
+		existingCommentID = 0
 	}
 
 	if existingCommentID > 0 {
 		// Update existing comment
-		err = g.updateComment(ctx, existingCommentID, markdown)
-		if err != nil {
-			return fmt.Errorf("failed to update PR comment: %w", err)
-		}
-		logger.InfoWithPrefix(g.logPrefix, "Updated existing comment on PR #%d", g.config.PRNumber)
-	} else {
-		// Create new comment
-		err = g.createComment(ctx, markdown)
-		if err != nil {
-			return fmt.Errorf("failed to create PR comment: %w", err)
-		}
-		logger.InfoWithPrefix(g.logPrefix, "Created new comment on PR #%d", g.config.PRNumber)
+		return g.updateComment(ctx, existingCommentID, markdown)
 	}
 
-	return nil
+	// Create new comment
+	return g.createComment(ctx, markdown)
 }
 
 // findExistingComment looks for an existing comment with our signature
diff --git a/internal/adapters/apis/ipfs/ipfs_adapter.go b/internal/adapters/apis/ipfs/ipfs_adapter.go
index 84dffdb..269e6f9 100644
--- a/internal/adapters/apis/ipfs/ipfs_adapter.go
+++ b/internal/adapters/apis/ipfs/ipfs_adapter.go
@@ -2,7 +2,6 @@ package ipfs
 
 import (
 	"clients-test/internal/application/domain"
-	"clients-test/internal/logger"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -13,16 +12,14 @@ import (
 )
 
 type IPFSAdapter struct {
-	gateway   *string
-	client    *http.Client
-	logPrefix string
+	gateway *string
+	client  *http.Client
 }
 
 func NewIPFSAdapter(gateway *string) *IPFSAdapter {
 	return &IPFSAdapter{
-		gateway:   gateway,
-		client:    &http.Client{},
-		logPrefix: "IPFSAdapter",
+		gateway: gateway,
+		client:  &http.Client{},
 	}
 }
 
@@ -42,24 +39,19 @@ type composeFile struct {
 // GetDnpNameAndServiceName fetches dappnode_package.json and docker-compose.yml from the given IPFS directory hash
 // and returns the dnpName and service name. Use the internal functions
 func (a *IPFSAdapter) GetDnpNameAndServiceName(ctx context.Context, ipfsHash string) (domain.Pkg, error) {
-	logger.DebugWithPrefix(a.logPrefix, "GetDnpNameAndServiceName: ipfsHash=%s", ipfsHash)
 	dnpName, err := a.getDnpNameFromHash(ctx, ipfsHash)
 	if err != nil {
-		logger.ErrorWithPrefix(a.logPrefix, "GetDnpNameAndServiceName: failed to get dnpName: %v", err)
 		return domain.Pkg{}, fmt.Errorf("failed to get dnpName from IPFS hash: %w", err)
 	}
 	serviceName, err := a.getComposeServiceName(ctx, ipfsHash)
 	if err != nil {
-		logger.ErrorWithPrefix(a.logPrefix, "GetDnpNameAndServiceName: failed to get compose service name: %v", err)
 		return domain.Pkg{}, fmt.Errorf("failed to get compose service name: %w", err)
 	}
 	// Fetch the root volume name from compose
 	volumeName, err := a.getComposeVolumeName(ctx, ipfsHash)
 	if err != nil {
-		logger.ErrorWithPrefix(a.logPrefix, "GetDnpNameAndServiceName: failed to get compose volume name: %v", err)
 		return domain.Pkg{}, fmt.Errorf("failed to get compose volume name: %w", err)
 	}
-	logger.DebugWithPrefix(a.logPrefix, "GetDnpNameAndServiceName: dnpName=%s serviceName=%s", dnpName, serviceName)
 	return domain.Pkg{
 		DnpName:           dnpName,
 		ServiceName:       serviceName,
@@ -71,64 +63,51 @@ func (a *IPFSAdapter) GetDnpNameAndServiceName(ctx context.Context, ipfsHash str
 // getDnpNameFromHash fetches dappnode_package.json from the given IPFS directory hash and returns the dnpName value
 func (a *IPFSAdapter) getDnpNameFromHash(ctx context.Context, ipfsHash string) (string, error) {
 	url := fmt.Sprintf("%s/ipfs/%s/dappnode_package.json", *a.gateway, ipfsHash)
-	logger.DebugWithPrefix(a.logPrefix, "getDnpNameFromHash: url=%s", url)
 	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 	if err != nil {
-		logger.ErrorWithPrefix(a.logPrefix, "getDnpNameFromHash: failed to create request: %v", err)
 		return "", err
 	}
 	resp, err := a.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(a.logPrefix, "getDnpNameFromHash: request failed: %v", err)
 		return "", err
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(a.logPrefix, "getDnpNameFromHash: non-200 status: %s", resp.Status)
 		return "", fmt.Errorf("failed to fetch dappnode_package.json: %s", resp.Status)
 	}
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-		logger.ErrorWithPrefix(a.logPrefix, "getDnpNameFromHash: failed to read body: %v", err)
 		return "", err
 	}
 	var pkg struct {
 		DnpName string `json:"name"`
 	}
 	if err := json.Unmarshal(body, &pkg); err != nil {
-		logger.ErrorWithPrefix(a.logPrefix, "getDnpNameFromHash: failed to unmarshal: %v", err)
 		return "", err
 	}
 	if pkg.DnpName == "" {
-		logger.ErrorWithPrefix(a.logPrefix, "getDnpNameFromHash: dnpName not found in dappnode_package.json")
 		return "", fmt.Errorf("dnpName not found in dappnode_package.json")
 	}
-	logger.DebugWithPrefix(a.logPrefix, "getDnpNameFromHash: dnpName=%s", pkg.DnpName)
 	return pkg.DnpName, nil
 }
 
 // fetchComposeFile retrieves and decodes the docker-compose.yml into a composeFile
 func (a *IPFSAdapter) fetchComposeFile(ctx context.Context, ipfsHash string) (*composeFile, error) {
 	url := fmt.Sprintf("%s/ipfs/%s/docker-compose.yml", *a.gateway, ipfsHash)
-	logger.DebugWithPrefix(a.logPrefix, "fetchComposeFile: url=%s", url)
 	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
 	if err != nil {
-		logger.ErrorWithPrefix(a.logPrefix, "fetchComposeFile: failed to create request: %v", err)
 		return nil, err
 	}
 	resp, err := a.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(a.logPrefix, "fetchComposeFile: request failed: %v", err)
 		return nil, err
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(a.logPrefix, "fetchComposeFile: non-200 status: %s", resp.Status)
 		return nil, fmt.Errorf("failed to fetch docker-compose.yml: %s", resp.Status)
 	}
 	var compose composeFile
 	if err := yaml.NewDecoder(resp.Body).Decode(&compose); err != nil {
-		logger.ErrorWithPrefix(a.logPrefix, "fetchComposeFile: failed to decode yaml: %v", err)
 		return nil, err
 	}
 	return &compose, nil
@@ -141,14 +120,11 @@ func (a *IPFSAdapter) getComposeServiceName(ctx context.Context, ipfsHash string
 		return "", err
 	}
 	if len(compose.Services) != 1 {
-		logger.ErrorWithPrefix(a.logPrefix, "getComposeServiceName: expected 1 service, got %d", len(compose.Services))
 		return "", fmt.Errorf("expected exactly one service in docker-compose.yml, got %d", len(compose.Services))
 	}
 	for name := range compose.Services {
-		logger.DebugWithPrefix(a.logPrefix, "getComposeServiceName: serviceName=%s", name)
 		return name, nil
 	}
-	logger.ErrorWithPrefix(a.logPrefix, "getComposeServiceName: no service found in docker-compose.yml")
 	return "", fmt.Errorf("no service found in docker-compose.yml")
 }
 
@@ -159,13 +135,10 @@ func (a *IPFSAdapter) getComposeVolumeName(ctx context.Context, ipfsHash string)
 		return "", err
 	}
 	if len(compose.Volumes) != 1 {
-		logger.ErrorWithPrefix(a.logPrefix, "getComposeVolumeName: expected 1 volume, got %d", len(compose.Volumes))
 		return "", fmt.Errorf("expected exactly one volume in docker-compose.yml, got %d", len(compose.Volumes))
 	}
 	for name := range compose.Volumes {
-		logger.DebugWithPrefix(a.logPrefix, "getComposeVolumeName: volumeName=%s", name)
 		return name, nil
 	}
-	logger.ErrorWithPrefix(a.logPrefix, "getComposeVolumeName: no volume found in docker-compose.yml")
 	return "", fmt.Errorf("no volume found in docker-compose.yml")
 }
diff --git a/internal/adapters/apis/tropidatooor/trpoidatooor_adapter.go b/internal/adapters/apis/tropidatooor/trpoidatooor_adapter.go
index 1c289e2..87100e3 100644
--- a/internal/adapters/apis/tropidatooor/trpoidatooor_adapter.go
+++ b/internal/adapters/apis/tropidatooor/trpoidatooor_adapter.go
@@ -2,7 +2,6 @@ package tropidatooor
 
 import (
 	"clients-test/internal/application/domain"
-	"clients-test/internal/logger"
 	"context"
 	"encoding/json"
 	"fmt"
@@ -11,72 +10,59 @@ import (
 
 // TropidatooorAdapter is the adapter to interact with the Tropidatooor API
 type TropidatooorAdapter struct {
-	baseURL   string
-	client    *http.Client
-	logPrefix string
+	baseURL string
+	client  *http.Client
 }
 
 // NewTropidatooorAdapter creates a new TropidatooorAdapter
 func NewTropidatooorAdapter(baseURL string) *TropidatooorAdapter {
 	return &TropidatooorAdapter{
-		baseURL:   baseURL,
-		client:    &http.Client{},
-		logPrefix: "TropidatooorAdapter",
+		baseURL: baseURL,
+		client:  &http.Client{},
 	}
 }
 
 // DataRequest sends a request to the Tropidatooor API to request data for a specific backend
 func (t *TropidatooorAdapter) DataRequest(ctx context.Context, backendName string) (*domain.Mount, error) {
-	logger.DebugWithPrefix(t.logPrefix, "DataRequest: backendName=%s", backendName)
 	req, err := http.NewRequestWithContext(ctx, "GET", fmt.Sprintf("%s/data/request/%s", t.baseURL, backendName), nil)
 	if err != nil {
-		logger.ErrorWithPrefix(t.logPrefix, "DataRequest: failed to create request: %v", err)
 		return nil, fmt.Errorf("failed to create request: %w", err)
 	}
 
 	resp, err := t.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(t.logPrefix, "DataRequest: failed to send request: %v", err)
 		return nil, fmt.Errorf("failed to send request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(t.logPrefix, "DataRequest: non-200 status: %s", resp.Status)
 		return nil, fmt.Errorf("failed to request data for %s: status %s", backendName, resp.Status)
 	}
 
 	var dataResponse domain.Mount
 	if err := json.NewDecoder(resp.Body).Decode(&dataResponse); err != nil {
-		logger.ErrorWithPrefix(t.logPrefix, "DataRequest: failed to decode response: %v", err)
 		return nil, fmt.Errorf("failed to decode response: %w", err)
 	}
 
-	logger.DebugWithPrefix(t.logPrefix, "DataRequest: success, dataResponse=%+v", dataResponse)
 	return &dataResponse, nil
 }
 
 // DataRelease sends a request to the Tropidatooor API to release data for a specific uniqueId
 func (t *TropidatooorAdapter) DataRelease(ctx context.Context, uniqueId string) error {
-	logger.DebugWithPrefix(t.logPrefix, "DataRelease: uniqueId=%s", uniqueId)
 	req, err := http.NewRequestWithContext(ctx, "GET", fmt.Sprintf("%s/data/release/%s", t.baseURL, uniqueId), nil)
 	if err != nil {
-		logger.ErrorWithPrefix(t.logPrefix, "DataRelease: failed to create request: %v", err)
 		return fmt.Errorf("failed to create request: %w", err)
 	}
 
 	resp, err := t.client.Do(req)
 	if err != nil {
-		logger.ErrorWithPrefix(t.logPrefix, "DataRelease: failed to send request: %v", err)
 		return fmt.Errorf("failed to send request: %w", err)
 	}
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
-		logger.ErrorWithPrefix(t.logPrefix, "DataRelease: non-200 status: %s", resp.Status)
 		return fmt.Errorf("failed to release data for %s: status %s", uniqueId, resp.Status)
 	}
 
-	logger.DebugWithPrefix(t.logPrefix, "DataRelease: success for uniqueId=%s", uniqueId)
 	return nil
 }
diff --git a/internal/adapters/composite/composite.go b/internal/adapters/composite/composite.go
index d96bcb6..9cbfff9 100644
--- a/internal/adapters/composite/composite.go
+++ b/internal/adapters/composite/composite.go
@@ -13,13 +13,10 @@ import (
 	"clients-test/internal/adapters/composite/ensurer"
 	"clients-test/internal/adapters/composite/executor"
 	"clients-test/internal/application/domain"
-	"clients-test/internal/logger"
 	"context"
 	"time"
 )
 
-var logPrefix = "Composite"
-
 type CompositeAdapter struct {
 	ensurer  *ensurer.EnsurerAdapter
 	executor *executor.ExecutorAdapter
@@ -74,14 +71,8 @@ func (t *CompositeAdapter) ExecuteTest(ctx context.Context, stakerConfig domain.
 	// Set the final result
 	t.report.SetResult(testErr == nil, testErr)
 
-	// Print console report
-	logger.Info("%s", t.report.ToConsoleString())
-
-	// Comment on PR if GitHub integration is enabled
-	if err := t.github.CommentOnPR(ctx, t.report); err != nil {
-		logger.ErrorWithPrefix(logPrefix, "Failed to comment on PR: %v", err)
-		// Don't fail the test because of PR comment failure
-	}
+	// Comment on PR if GitHub integration is enabled (ignore errors - don't fail test for PR comment issues)
+	_ = t.github.CommentOnPR(ctx, t.report)
 
 	return testErr
 }
@@ -102,16 +93,9 @@ func (t *CompositeAdapter) collectContainerErrorLogs(ctx context.Context, staker
 		stakerConfig.ExecutionContainerName,
 	}
 
-	logger.DebugWithPrefix(logPrefix, "Collecting error logs from containers: %v", containerNames)
-	logger.DebugWithPrefix(logPrefix, "Time range: %v to %v", since, until)
-
 	errorLogs := t.docker.CollectAllContainerErrorLogs(ctx, containerNames, since, until, maxLinesPerContainer)
 
 	for containerName, lines := range errorLogs {
 		t.report.AddContainerErrors(containerName, lines)
-		logger.WarnWithPrefix(logPrefix, "Found %d error lines in %s", len(lines), containerName)
-		for _, line := range lines {
-			logger.ErrorWithPrefix(logPrefix, "[%s] %s", containerName, line)
-		}
 	}
 }
diff --git a/internal/adapters/composite/ensurer/ensurer.go b/internal/adapters/composite/ensurer/ensurer.go
index e39f57d..f186145 100644
--- a/internal/adapters/composite/ensurer/ensurer.go
+++ b/internal/adapters/composite/ensurer/ensurer.go
@@ -13,11 +13,8 @@ import (
 	"clients-test/internal/adapters/apis/ipfs"
 	"clients-test/internal/adapters/apis/snapshots"
 	"clients-test/internal/application/domain"
-	"clients-test/internal/logger"
 )
 
-var logPrefix = "Ensurer"
-
 type EnsurerAdapter struct {
 	DappManager *dappmanager.DappManagerAdapter
 	Brain       *brain.BrainAdapter
@@ -49,13 +46,6 @@ func timeOperation(report *domain.TestReport, operationName string, fn func() er
 	success := err == nil
 	report.AddEnsureTiming(operationName, duration, success, err)
 
-	// Log the timing
-	if success {
-		logger.InfoWithPrefix(logPrefix, "%s completed in %s", operationName, duration.Round(time.Millisecond))
-	} else {
-		logger.ErrorWithPrefix(logPrefix, "%s failed after %s: %v", operationName, duration.Round(time.Millisecond), err)
-	}
-
 	return err
 }
 
@@ -69,10 +59,8 @@ func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig dom
 
 	if isExecutionTest {
 		report.TestedClientType = "execution"
-		logger.InfoWithPrefix(logPrefix, "Testing execution client: %s", pkg.DnpName)
 	} else if isConsensusTest {
 		report.TestedClientType = "consensus"
-		logger.InfoWithPrefix(logPrefix, "Testing consensus client: %s", pkg.DnpName)
 	}
 
 	// SetStakerConfig
@@ -86,16 +74,10 @@ func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig dom
 	if isExecutionTest {
 		if version, err := e.Execution.GetClientVersion(ctx); err == nil {
 			report.ExecutionClientVersionBefore = version
-			logger.InfoWithPrefix(logPrefix, "Execution client version before install: %s", version)
-		} else {
-			logger.DebugWithPrefix(logPrefix, "Could not get execution client version before install: %v", err)
 		}
 	} else if isConsensusTest {
 		if version, err := e.Beaconchain.GetClientVersion(ctx); err == nil {
 			report.ConsensusClientVersionBefore = version
-			logger.InfoWithPrefix(logPrefix, "Consensus client version before install: %s", version)
-		} else {
-			logger.DebugWithPrefix(logPrefix, "Could not get consensus client version before install: %v", err)
 		}
 	}
 
@@ -110,16 +92,10 @@ func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig dom
 	if isExecutionTest {
 		if version, err := e.Execution.GetClientVersion(ctx); err == nil {
 			report.ExecutionClientVersionAfter = version
-			logger.InfoWithPrefix(logPrefix, "Execution client version after install: %s", version)
-		} else {
-			logger.DebugWithPrefix(logPrefix, "Could not get execution client version after install: %v", err)
 		}
 	} else if isConsensusTest {
 		if version, err := e.Beaconchain.GetClientVersion(ctx); err == nil {
 			report.ConsensusClientVersionAfter = version
-			logger.InfoWithPrefix(logPrefix, "Consensus client version after install: %s", version)
-		} else {
-			logger.DebugWithPrefix(logPrefix, "Could not get consensus client version after install: %v", err)
 		}
 	}
 
diff --git a/internal/adapters/composite/executor/executor.go b/internal/adapters/composite/executor/executor.go
index 36fff85..6e41ef9 100644
--- a/internal/adapters/composite/executor/executor.go
+++ b/internal/adapters/composite/executor/executor.go
@@ -9,11 +9,8 @@ import (
 	"clients-test/internal/adapters/apis/brain"
 	"clients-test/internal/adapters/apis/execution"
 	"clients-test/internal/application/domain"
-	"clients-test/internal/logger"
 )
 
-var logPrefix = "Executor"
-
 type ExecutorAdapter struct {
 	Execution   *execution.ExecutionAdapter
 	Brain       *brain.BrainAdapter
@@ -37,13 +34,6 @@ func timeOperation(report *domain.TestReport, operationName string, fn func() er
 	success := err == nil
 	report.AddExecuteTiming(operationName, duration, success, err)
 
-	// Log the timing
-	if success {
-		logger.InfoWithPrefix(logPrefix, "%s completed in %s", operationName, duration.Round(time.Millisecond))
-	} else {
-		logger.ErrorWithPrefix(logPrefix, "%s failed after %s: %v", operationName, duration.Round(time.Millisecond), err)
-	}
-
 	return err
 }
 
diff --git a/internal/adapters/system/mount/mount_adapter.go b/internal/adapters/system/mount/mount_adapter.go
index f90f85d..7993dbe 100644
--- a/internal/adapters/system/mount/mount_adapter.go
+++ b/internal/adapters/system/mount/mount_adapter.go
@@ -4,40 +4,30 @@ import (
 	"context"
 	"fmt"
 	"os/exec"
-
-	"clients-test/internal/logger"
 )
 
-type MountAdapter struct {
-	logPrefix string
-}
+type MountAdapter struct{}
 
 func NewMountAdapter() *MountAdapter {
-	return &MountAdapter{logPrefix: "MountAdapter"}
+	return &MountAdapter{}
 }
 
 // MountNFS mounts the NFS share at srcPath to the targetPath using sudo mount -t nfs
 func (m *MountAdapter) MountNFS(ctx context.Context, srcPath, targetPath string) error {
-	logger.DebugWithPrefix(m.logPrefix, "MountNFS called with srcPath=%s, targetPath=%s", srcPath, targetPath)
 	mountCmd := exec.CommandContext(ctx, "sudo", "mount", "-t", "nfs", srcPath, targetPath)
 	output, err := mountCmd.CombinedOutput()
 	if err != nil {
-		logger.ErrorWithPrefix(m.logPrefix, "Failed to mount %s onto %s: %v\n%s", srcPath, targetPath, err, string(output))
 		return fmt.Errorf("failed to mount %s onto %s: %v\n%s", srcPath, targetPath, err, string(output))
 	}
-	logger.DebugWithPrefix(m.logPrefix, "Successfully mounted %s onto %s", srcPath, targetPath)
 	return nil
 }
 
 // UnmountNFS unmounts the filesystem at targetPath using sudo umount
 func (m *MountAdapter) UnmountNFS(ctx context.Context, targetPath string) error {
-	logger.DebugWithPrefix(m.logPrefix, "UnmountNFS called with targetPath=%s", targetPath)
 	umountCmd := exec.CommandContext(ctx, "sudo", "umount", targetPath)
 	output, err := umountCmd.CombinedOutput()
 	if err != nil {
-		logger.ErrorWithPrefix(m.logPrefix, "Failed to unmount %s: %v\n%s", targetPath, err, string(output))
 		return fmt.Errorf("failed to unmount %s: %v\n%s", targetPath, err, string(output))
 	}
-	logger.DebugWithPrefix(m.logPrefix, "Successfully unmounted %s", targetPath)
 	return nil
 }
diff --git a/internal/application/services/test_runner.go b/internal/application/services/test_runner.go
index 328ea2f..07c9f00 100644
--- a/internal/application/services/test_runner.go
+++ b/internal/application/services/test_runner.go
@@ -3,10 +3,13 @@ package services
 import (
 	"clients-test/internal/application/domain"
 	"clients-test/internal/application/ports"
+	"clients-test/internal/logger"
 	"context"
 	"fmt"
 )
 
+var logPrefix = "TestRunner"
+
 type TestRunnerService struct {
 	Runner ports.TestRunner
 }
@@ -19,24 +22,37 @@ func NewTestRunner(runner ports.TestRunner) *TestRunnerService {
 // It ensures the environment, executes the test, and cleans up.
 func (s *TestRunnerService) RunTest(ctx context.Context, stakerConfig domain.StakerConfig, pkg domain.Pkg) error {
 	// 1) ensure environment
+	logger.InfoWithPrefix(logPrefix, "Step 1: Ensuring environment for package %s", pkg.DnpName)
 	if err := s.Runner.EnsureEnvironment(ctx, stakerConfig, pkg); err != nil {
+		logger.ErrorWithPrefix(logPrefix, "Setup failed: %v", err)
 		return fmt.Errorf("setup failed: %w", err)
 	}
+	logger.InfoWithPrefix(logPrefix, "Environment setup completed successfully")
 
 	// 2) execute test (now includes report generation and PR commenting)
+	logger.InfoWithPrefix(logPrefix, "Step 2: Executing test")
 	execErr := s.Runner.ExecuteTest(ctx, stakerConfig)
 	if execErr != nil {
+		logger.ErrorWithPrefix(logPrefix, "Test execution failed: %v", execErr)
 		// even on test failure we want cleanup
+		logger.InfoWithPrefix(logPrefix, "Step 3: Running cleanup after test failure")
 		if cleanupErr := s.Runner.CleanEnvironment(ctx, stakerConfig); cleanupErr != nil {
+			logger.ErrorWithPrefix(logPrefix, "Cleanup also failed: %v", cleanupErr)
 			return fmt.Errorf("test failed: %v; cleanup also failed: %w", execErr, cleanupErr)
 		}
+		logger.InfoWithPrefix(logPrefix, "Cleanup completed successfully")
 		return fmt.Errorf("test failed: %w", execErr)
 	}
+	logger.InfoWithPrefix(logPrefix, "Test execution completed successfully")
 
 	// 3) cleanup
+	logger.InfoWithPrefix(logPrefix, "Step 3: Cleaning up environment")
 	if err := s.Runner.CleanEnvironment(ctx, stakerConfig); err != nil {
+		logger.ErrorWithPrefix(logPrefix, "Cleanup failed: %v", err)
 		return fmt.Errorf("cleanup failed: %w", err)
 	}
+	logger.InfoWithPrefix(logPrefix, "Cleanup completed successfully")
 
+	logger.InfoWithPrefix(logPrefix, "Test run completed successfully")
 	return nil
 }

From 34e8340251f9b43ec18c24a1016944710efa34a3 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Thu, 22 Jan 2026 10:51:27 +0100
Subject: [PATCH 23/42] add wait for download in progress

---
 cmd/test-runner/main.go                       |  9 ++++-
 internal/adapters/composite/composite.go      |  4 ++-
 .../adapters/composite/ensurer/ensurer.go     | 27 ++++++++++++++-
 internal/application/domain/report.go         |  9 +++++
 .../ports/downloadProgress_port.go            | 16 +++++++++
 .../application/ports/snapshotChecker_port.go | 13 --------
 internal/application/services/test_runner.go  | 33 +++++++++++++++++--
 7 files changed, 92 insertions(+), 19 deletions(-)
 create mode 100644 internal/application/ports/downloadProgress_port.go

diff --git a/cmd/test-runner/main.go b/cmd/test-runner/main.go
index aa25458..c94a210 100644
--- a/cmd/test-runner/main.go
+++ b/cmd/test-runner/main.go
@@ -10,6 +10,8 @@ import (
 	"clients-test/internal/adapters/apis/ipfs"
 	"clients-test/internal/adapters/apis/snapshots"
 	"clients-test/internal/adapters/composite"
+	"clients-test/internal/adapters/shared/blocknumber"
+	"clients-test/internal/adapters/shared/progress"
 	"clients-test/internal/application/domain"
 	"clients-test/internal/application/services"
 	"clients-test/internal/config"
@@ -64,6 +66,10 @@ func main() {
 	// Initialize GitHub adapter for PR commenting
 	githubAdapter := github.NewGitHubAdapter(cfg.GitHub)
 
+	// Initialize shared adapters
+	progressAdapter := progress.NewProgressAdapter()
+	blockAdapter := blocknumber.NewBlockNumberAdapter()
+
 	// Log GitHub configuration status
 	if githubAdapter.IsEnabled() {
 		logger.InfoWithPrefix(logPrefix, "GitHub integration enabled - will comment on PR #%d", cfg.GitHub.PRNumber)
@@ -81,6 +87,7 @@ func main() {
 		executionAdapter,
 		ipfsAdapter,
 		githubAdapter,
+		blockAdapter,
 	)
 
 	// Ctrl+C handler: call CleanEnvironment on composite
@@ -98,7 +105,7 @@ func main() {
 	}()
 
 	// Initialize and run the service
-	testRunner := services.NewTestRunner(compositeAdapter)
+	testRunner := services.NewTestRunner(compositeAdapter, progressAdapter)
 
 	if err := testRunner.RunTest(ctx, stakerConfig, pkg); err != nil {
 		logger.FatalWithPrefix(logPrefix, "Test run failed: %v", err)
diff --git a/internal/adapters/composite/composite.go b/internal/adapters/composite/composite.go
index 9cbfff9..eca6f3c 100644
--- a/internal/adapters/composite/composite.go
+++ b/internal/adapters/composite/composite.go
@@ -12,6 +12,7 @@ import (
 	"clients-test/internal/adapters/composite/cleaner"
 	"clients-test/internal/adapters/composite/ensurer"
 	"clients-test/internal/adapters/composite/executor"
+	"clients-test/internal/adapters/shared/blocknumber"
 	"clients-test/internal/application/domain"
 	"context"
 	"time"
@@ -35,8 +36,9 @@ func NewCompositeAdapter(
 	executionAdapter *execution.ExecutionAdapter,
 	ipfsAdapter *ipfs.IPFSAdapter,
 	githubAdapter *github.GitHubAdapter,
+	blockNumberAdapter *blocknumber.BlockNumberAdapter,
 ) *CompositeAdapter {
-	ensurer := ensurer.NewEnsurerAdapter(dappManagerAdapter, brainAdapter, dockerAdapter, snapshotsAdapter, beaconchainAdapter, executionAdapter, ipfsAdapter)
+	ensurer := ensurer.NewEnsurerAdapter(dappManagerAdapter, brainAdapter, dockerAdapter, snapshotsAdapter, beaconchainAdapter, executionAdapter, ipfsAdapter, blockNumberAdapter)
 	executor := executor.NewExecutorAdapter(executionAdapter, brainAdapter, beaconchainAdapter)
 	cleaner := cleaner.NewCleanerAdapter(dappManagerAdapter, executionAdapter, brainAdapter, beaconchainAdapter, dockerAdapter)
 	return &CompositeAdapter{
diff --git a/internal/adapters/composite/ensurer/ensurer.go b/internal/adapters/composite/ensurer/ensurer.go
index f186145..c1e356b 100644
--- a/internal/adapters/composite/ensurer/ensurer.go
+++ b/internal/adapters/composite/ensurer/ensurer.go
@@ -3,6 +3,7 @@ package ensurer
 import (
 	"context"
 	"fmt"
+	"strconv"
 	"time"
 
 	"clients-test/internal/adapters/apis/beaconchain"
@@ -12,6 +13,7 @@ import (
 	"clients-test/internal/adapters/apis/execution"
 	"clients-test/internal/adapters/apis/ipfs"
 	"clients-test/internal/adapters/apis/snapshots"
+	"clients-test/internal/adapters/shared/blocknumber"
 	"clients-test/internal/application/domain"
 )
 
@@ -23,9 +25,10 @@ type EnsurerAdapter struct {
 	Beaconchain *beaconchain.BeaconchainAdapter
 	Execution   *execution.ExecutionAdapter
 	Ipfs        *ipfs.IPFSAdapter
+	BlockNumber *blocknumber.BlockNumberAdapter
 }
 
-func NewEnsurerAdapter(dappManager *dappmanager.DappManagerAdapter, brain *brain.BrainAdapter, docker *docker.DockerAdapter, snapshotsAdapter *snapshots.SnapshotsAdapter, beaconchain *beaconchain.BeaconchainAdapter, execution *execution.ExecutionAdapter, ipfs *ipfs.IPFSAdapter) *EnsurerAdapter {
+func NewEnsurerAdapter(dappManager *dappmanager.DappManagerAdapter, brain *brain.BrainAdapter, docker *docker.DockerAdapter, snapshotsAdapter *snapshots.SnapshotsAdapter, beaconchain *beaconchain.BeaconchainAdapter, execution *execution.ExecutionAdapter, ipfs *ipfs.IPFSAdapter, blockNumberAdapter *blocknumber.BlockNumberAdapter) *EnsurerAdapter {
 	return &EnsurerAdapter{
 		DappManager: dappManager,
 		Brain:       brain,
@@ -34,6 +37,7 @@ func NewEnsurerAdapter(dappManager *dappmanager.DappManagerAdapter, brain *brain
 		Beaconchain: beaconchain,
 		Execution:   execution,
 		Ipfs:        ipfs,
+		BlockNumber: blockNumberAdapter,
 	}
 }
 
@@ -63,6 +67,9 @@ func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig dom
 		report.TestedClientType = "consensus"
 	}
 
+	// Read snapshot block number
+	e.readSnapshotBlockNumber(ctx, stakerConfig, report)
+
 	// SetStakerConfig
 	if err := timeOperation(report, "SetStakerConfig", func() error {
 		return e.DappManager.SetStakerConfig(ctx, stakerConfig)
@@ -101,3 +108,21 @@ func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig dom
 
 	return nil
 }
+
+// readSnapshotBlockNumber reads the snapshot block number from the execution client's volume
+// and stores it in the report. Errors are silently ignored as this is informational.
+func (e *EnsurerAdapter) readSnapshotBlockNumber(ctx context.Context, stakerConfig domain.StakerConfig, report *domain.TestReport) {
+	// Get execution client info to find the volume path
+	execClients := domain.GetExecutionClients(stakerConfig.Network, nil)
+	for _, client := range execClients {
+		if client.DnpName == stakerConfig.ExecutionDnpName {
+			blockNumberStr, err := e.BlockNumber.ReadBlockNumber(ctx, client.VolumeTargetPath)
+			if err == nil && blockNumberStr != "" {
+				if blockNumber, parseErr := strconv.ParseUint(blockNumberStr, 10, 64); parseErr == nil {
+					report.SnapshotBlockNumber = blockNumber
+				}
+			}
+			break
+		}
+	}
+}
diff --git a/internal/application/domain/report.go b/internal/application/domain/report.go
index ec92335..6f241f3 100644
--- a/internal/application/domain/report.go
+++ b/internal/application/domain/report.go
@@ -36,6 +36,9 @@ type TestReport struct {
 	ConsensusClientVersionAfter  string `json:"consensusClientVersionAfter,omitempty"`
 	SnapshotClientVersion        string `json:"snapshotClientVersion,omitempty"`
 
+	// blocknumber of the snapshot used
+	SnapshotBlockNumber uint64 `json:"snapshotBlockNumber,omitempty"`
+
 	// What type of client is being tested
 	TestedClientType string `json:"testedClientType,omitempty"` // "execution" or "consensus"
 
@@ -163,6 +166,9 @@ func (r *TestReport) ToMarkdown() string {
 			if r.SnapshotClientVersion != "" {
 				sb.WriteString(fmt.Sprintf("| Snapshot | `%s` |\n", r.SnapshotClientVersion))
 			}
+			if r.SnapshotBlockNumber > 0 {
+				sb.WriteString(fmt.Sprintf("| Snapshot Block | `%d` |\n", r.SnapshotBlockNumber))
+			}
 		} else if r.TestedClientType == "consensus" {
 			sb.WriteString("**Tested Client:** Consensus\n\n")
 			sb.WriteString("| Stage | Version |\n")
@@ -275,6 +281,9 @@ func (r *TestReport) ToConsoleString() string {
 			if r.SnapshotClientVersion != "" {
 				sb.WriteString(fmt.Sprintf("  Snapshot Version:   %s\n", r.SnapshotClientVersion))
 			}
+			if r.SnapshotBlockNumber > 0 {
+				sb.WriteString(fmt.Sprintf("  Snapshot Block:     %d\n", r.SnapshotBlockNumber))
+			}
 		} else if r.TestedClientType == "consensus" {
 			if r.ConsensusClientVersionBefore != "" {
 				sb.WriteString(fmt.Sprintf("  Before Install:     %s\n", r.ConsensusClientVersionBefore))
diff --git a/internal/application/ports/downloadProgress_port.go b/internal/application/ports/downloadProgress_port.go
new file mode 100644
index 0000000..f25f4ff
--- /dev/null
+++ b/internal/application/ports/downloadProgress_port.go
@@ -0,0 +1,16 @@
+package ports
+
+import "context"
+
+// DownloadProgress defines the interface for tracking download progress state
+// Used to prevent concurrent downloads and recover from interrupted downloads
+type DownloadProgress interface {
+	// IsDownloadInProgress checks if a download is currently in progress
+	IsDownloadInProgress(ctx context.Context) (bool, error)
+
+	// SetDownloadInProgress marks that a download has started
+	SetDownloadInProgress(ctx context.Context) error
+
+	// ClearDownloadInProgress marks that a download has completed (success or failure)
+	ClearDownloadInProgress(ctx context.Context) error
+}
diff --git a/internal/application/ports/snapshotChecker_port.go b/internal/application/ports/snapshotChecker_port.go
index d9bfd78..689c77f 100644
--- a/internal/application/ports/snapshotChecker_port.go
+++ b/internal/application/ports/snapshotChecker_port.go
@@ -21,16 +21,3 @@ type SnapshotManager interface {
 	// StopAllDownloads stops all running snapshot download containers
 	StopAllDownloads(ctx context.Context)
 }
-
-// DownloadProgress defines the interface for tracking download progress state
-// Used to prevent concurrent downloads and recover from interrupted downloads
-type DownloadProgress interface {
-	// IsDownloadInProgress checks if a download is currently in progress
-	IsDownloadInProgress(ctx context.Context) (bool, error)
-
-	// SetDownloadInProgress marks that a download has started
-	SetDownloadInProgress(ctx context.Context) error
-
-	// ClearDownloadInProgress marks that a download has completed (success or failure)
-	ClearDownloadInProgress(ctx context.Context) error
-}
diff --git a/internal/application/services/test_runner.go b/internal/application/services/test_runner.go
index 07c9f00..b255319 100644
--- a/internal/application/services/test_runner.go
+++ b/internal/application/services/test_runner.go
@@ -6,16 +6,18 @@ import (
 	"clients-test/internal/logger"
 	"context"
 	"fmt"
+	"time"
 )
 
 var logPrefix = "TestRunner"
 
 type TestRunnerService struct {
-	Runner ports.TestRunner
+	Runner   ports.TestRunner
+	Download ports.DownloadProgress
 }
 
-func NewTestRunner(runner ports.TestRunner) *TestRunnerService {
-	return &TestRunnerService{runner}
+func NewTestRunner(runner ports.TestRunner, download ports.DownloadProgress) *TestRunnerService {
+	return &TestRunnerService{Runner: runner, Download: download}
 }
 
 // RunTest wires up the three steps in sequence.
@@ -56,3 +58,28 @@ func (s *TestRunnerService) RunTest(ctx context.Context, stakerConfig domain.Sta
 	logger.InfoWithPrefix(logPrefix, "Test run completed successfully")
 	return nil
 }
+
+// WaitForDownloadCompleteWithRetry waits until no download is in progress
+// using a fixed 30 second retry interval. This is useful for the test runner
+// to wait for snapshot downloads to complete before proceeding.
+func (s *TestRunnerService) WaitForDownloadCompleteWithRetry(ctx context.Context) error {
+	const retryInterval = 30 * time.Second
+
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+			inProgress, err := s.Download.IsDownloadInProgress(ctx)
+			if err != nil {
+				return fmt.Errorf("error checking download progress: %w", err)
+			}
+
+			if !inProgress {
+				return nil
+			}
+
+			time.Sleep(retryInterval)
+		}
+	}
+}

From 4fa2eb9208ae7e8e857531cfd4cc7789c4c1d107 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Thu, 22 Jan 2026 16:45:57 +0100
Subject: [PATCH 24/42] implement wait for download to complete

---
 internal/application/services/test_runner.go | 22 +++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/internal/application/services/test_runner.go b/internal/application/services/test_runner.go
index b255319..52212dc 100644
--- a/internal/application/services/test_runner.go
+++ b/internal/application/services/test_runner.go
@@ -23,21 +23,29 @@ func NewTestRunner(runner ports.TestRunner, download ports.DownloadProgress) *Te
 // RunTest wires up the three steps in sequence.
 // It ensures the environment, executes the test, and cleans up.
 func (s *TestRunnerService) RunTest(ctx context.Context, stakerConfig domain.StakerConfig, pkg domain.Pkg) error {
-	// 1) ensure environment
-	logger.InfoWithPrefix(logPrefix, "Step 1: Ensuring environment for package %s", pkg.DnpName)
+	// 1) wait for any ongoing downloads to complete
+	logger.InfoWithPrefix(logPrefix, "Waiting for any ongoing downloads to complete...")
+	if err := s.WaitForDownloadCompleteWithRetry(ctx); err != nil {
+		logger.ErrorWithPrefix(logPrefix, "Error while waiting for downloads to complete: %v", err)
+		return fmt.Errorf("error while waiting for downloads to complete: %w", err)
+	}
+	logger.InfoWithPrefix(logPrefix, "No ongoing downloads detected, proceeding with test run")
+
+	// 2) ensure environment
+	logger.InfoWithPrefix(logPrefix, "Step 2: Ensuring environment for package %s", pkg.DnpName)
 	if err := s.Runner.EnsureEnvironment(ctx, stakerConfig, pkg); err != nil {
 		logger.ErrorWithPrefix(logPrefix, "Setup failed: %v", err)
 		return fmt.Errorf("setup failed: %w", err)
 	}
 	logger.InfoWithPrefix(logPrefix, "Environment setup completed successfully")
 
-	// 2) execute test (now includes report generation and PR commenting)
-	logger.InfoWithPrefix(logPrefix, "Step 2: Executing test")
+	// 3) execute test (now includes report generation and PR commenting)
+	logger.InfoWithPrefix(logPrefix, "Step 3: Executing test")
 	execErr := s.Runner.ExecuteTest(ctx, stakerConfig)
 	if execErr != nil {
 		logger.ErrorWithPrefix(logPrefix, "Test execution failed: %v", execErr)
 		// even on test failure we want cleanup
-		logger.InfoWithPrefix(logPrefix, "Step 3: Running cleanup after test failure")
+		logger.InfoWithPrefix(logPrefix, "Step 4: Running cleanup after test failure")
 		if cleanupErr := s.Runner.CleanEnvironment(ctx, stakerConfig); cleanupErr != nil {
 			logger.ErrorWithPrefix(logPrefix, "Cleanup also failed: %v", cleanupErr)
 			return fmt.Errorf("test failed: %v; cleanup also failed: %w", execErr, cleanupErr)
@@ -47,8 +55,8 @@ func (s *TestRunnerService) RunTest(ctx context.Context, stakerConfig domain.Sta
 	}
 	logger.InfoWithPrefix(logPrefix, "Test execution completed successfully")
 
-	// 3) cleanup
-	logger.InfoWithPrefix(logPrefix, "Step 3: Cleaning up environment")
+	// 4) cleanup
+	logger.InfoWithPrefix(logPrefix, "Step 4: Cleaning up environment")
 	if err := s.Runner.CleanEnvironment(ctx, stakerConfig); err != nil {
 		logger.ErrorWithPrefix(logPrefix, "Cleanup failed: %v", err)
 		return fmt.Errorf("cleanup failed: %w", err)

From 3fc7eeeee98eae5bedec6dbb285af3edc4a330b4 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Thu, 22 Jan 2026 16:49:33 +0100
Subject: [PATCH 25/42] rename to download adapter

---
 cmd/snapshot-checker/main.go                  | 12 ++++----
 cmd/test-runner/main.go                       |  6 ++--
 .../download_adapter.go}                      | 28 +++++++++----------
 .../application/ports/testProgress_port.go    |  1 +
 4 files changed, 24 insertions(+), 23 deletions(-)
 rename internal/adapters/shared/{progress/progress_adapter.go => download/download_adapter.go} (73%)
 create mode 100644 internal/application/ports/testProgress_port.go

diff --git a/cmd/snapshot-checker/main.go b/cmd/snapshot-checker/main.go
index 28bd9f4..d609625 100644
--- a/cmd/snapshot-checker/main.go
+++ b/cmd/snapshot-checker/main.go
@@ -5,7 +5,7 @@ import (
 	"clients-test/internal/adapters/apis/snapshots"
 	"clients-test/internal/adapters/composite/snapshotmanager"
 	"clients-test/internal/adapters/shared/blocknumber"
-	"clients-test/internal/adapters/shared/progress"
+	"clients-test/internal/adapters/shared/download"
 	"clients-test/internal/application/domain"
 	"clients-test/internal/application/services"
 	"clients-test/internal/config"
@@ -51,7 +51,7 @@ func main() {
 	if err != nil {
 		logger.FatalWithPrefix(logPrefix, "Failed to init DockerAdapter: %v", err)
 	}
-	progressAdapter := progress.NewProgressAdapter()
+	downloadAdapter := download.NewDownloadAdapter()
 	blockNumberAdapter := blocknumber.NewBlockNumberAdapter()
 
 	// Create composite snapshot manager adapter
@@ -63,11 +63,11 @@ func main() {
 
 	// If a previous run crashed/was interrupted, the marker file can be left behind and block future runs.
 	// Clear it on startup so the service can recover.
-	if inProgress, err := progressAdapter.IsDownloadInProgress(ctx); err != nil {
+	if inProgress, err := downloadAdapter.IsDownloadInProgress(ctx); err != nil {
 		logger.WarnWithPrefix(logPrefix, "Failed to check %s marker: %v", domain.ProgressFileName, err)
 	} else if inProgress {
 		logger.WarnWithPrefix(logPrefix, "Found stale %s marker; clearing it on startup", domain.ProgressFileName)
-		if err := progressAdapter.ClearDownloadInProgress(context.Background()); err != nil {
+		if err := downloadAdapter.ClearDownloadInProgress(context.Background()); err != nil {
 			logger.WarnWithPrefix(logPrefix, "Failed to clear %s marker on startup: %v", domain.ProgressFileName, err)
 		}
 	}
@@ -75,7 +75,7 @@ func main() {
 	// Initialize the snapshot checker service
 	service := services.NewSnapshotCheckerService(
 		snapshotManagerAdapter,
-		progressAdapter,
+		downloadAdapter,
 		snapshotConfig,
 	)
 
@@ -85,7 +85,7 @@ func main() {
 		// Stop any running download containers using the service method
 		service.StopAllDownloads(context.Background())
 		// Best-effort cleanup: clear marker file so next run isn't blocked.
-		if err := progressAdapter.ClearDownloadInProgress(context.Background()); err != nil {
+		if err := downloadAdapter.ClearDownloadInProgress(context.Background()); err != nil {
 			logger.WarnWithPrefix(logPrefix, "Failed to clear %s marker on shutdown: %v", domain.ProgressFileName, err)
 		}
 		cancel()
diff --git a/cmd/test-runner/main.go b/cmd/test-runner/main.go
index c94a210..21f50e1 100644
--- a/cmd/test-runner/main.go
+++ b/cmd/test-runner/main.go
@@ -11,7 +11,7 @@ import (
 	"clients-test/internal/adapters/apis/snapshots"
 	"clients-test/internal/adapters/composite"
 	"clients-test/internal/adapters/shared/blocknumber"
-	"clients-test/internal/adapters/shared/progress"
+	"clients-test/internal/adapters/shared/download"
 	"clients-test/internal/application/domain"
 	"clients-test/internal/application/services"
 	"clients-test/internal/config"
@@ -67,7 +67,7 @@ func main() {
 	githubAdapter := github.NewGitHubAdapter(cfg.GitHub)
 
 	// Initialize shared adapters
-	progressAdapter := progress.NewProgressAdapter()
+	downloadAdapter := download.NewDownloadAdapter()
 	blockAdapter := blocknumber.NewBlockNumberAdapter()
 
 	// Log GitHub configuration status
@@ -105,7 +105,7 @@ func main() {
 	}()
 
 	// Initialize and run the service
-	testRunner := services.NewTestRunner(compositeAdapter, progressAdapter)
+	testRunner := services.NewTestRunner(compositeAdapter, downloadAdapter)
 
 	if err := testRunner.RunTest(ctx, stakerConfig, pkg); err != nil {
 		logger.FatalWithPrefix(logPrefix, "Test run failed: %v", err)
diff --git a/internal/adapters/shared/progress/progress_adapter.go b/internal/adapters/shared/download/download_adapter.go
similarity index 73%
rename from internal/adapters/shared/progress/progress_adapter.go
rename to internal/adapters/shared/download/download_adapter.go
index f041919..2434af1 100644
--- a/internal/adapters/shared/progress/progress_adapter.go
+++ b/internal/adapters/shared/download/download_adapter.go
@@ -1,4 +1,4 @@
-package progress
+package download
 
 import (
 	"clients-test/internal/application/domain"
@@ -9,32 +9,32 @@ import (
 	"time"
 )
 
-// ProgressAdapter handles the .download_in_progress file operations
-type ProgressAdapter struct {
+// DownloadAdapter handles the .download_in_progress file operations
+type DownloadAdapter struct {
 	basePath string
 }
 
-// NewProgressAdapter creates a new ProgressAdapter
-func NewProgressAdapter() *ProgressAdapter {
-	return &ProgressAdapter{
+// NewDownloadAdapter creates a new ProgressAdapter
+func NewDownloadAdapter() *DownloadAdapter {
+	return &DownloadAdapter{
 		basePath: domain.SnapshotProgressPath,
 	}
 }
 
-// NewProgressAdapterWithPath creates a new ProgressAdapter with a custom base path (for testing)
-func NewProgressAdapterWithPath(basePath string) *ProgressAdapter {
-	return &ProgressAdapter{
+// NewDownloadAdapterWithPath creates a new DownloadAdapter with a custom base path (for testing)
+func NewDownloadAdapterWithPath(basePath string) *DownloadAdapter {
+	return &DownloadAdapter{
 		basePath: basePath,
 	}
 }
 
 // progressFilePath returns the full path to the progress file
-func (p *ProgressAdapter) progressFilePath() string {
+func (p *DownloadAdapter) progressFilePath() string {
 	return filepath.Join(p.basePath, domain.ProgressFileName)
 }
 
 // SetDownloadInProgress creates the .download_in_progress file
-func (p *ProgressAdapter) SetDownloadInProgress(ctx context.Context) error {
+func (p *DownloadAdapter) SetDownloadInProgress(ctx context.Context) error {
 	filePath := p.progressFilePath()
 
 	if err := os.MkdirAll(p.basePath, 0755); err != nil {
@@ -56,7 +56,7 @@ func (p *ProgressAdapter) SetDownloadInProgress(ctx context.Context) error {
 }
 
 // ClearDownloadInProgress removes the .download_in_progress file
-func (p *ProgressAdapter) ClearDownloadInProgress(ctx context.Context) error {
+func (p *DownloadAdapter) ClearDownloadInProgress(ctx context.Context) error {
 	filePath := p.progressFilePath()
 
 	err := os.Remove(filePath)
@@ -68,7 +68,7 @@ func (p *ProgressAdapter) ClearDownloadInProgress(ctx context.Context) error {
 }
 
 // IsDownloadInProgress checks if download is in progress
-func (p *ProgressAdapter) IsDownloadInProgress(ctx context.Context) (bool, error) {
+func (p *DownloadAdapter) IsDownloadInProgress(ctx context.Context) (bool, error) {
 	filePath := p.progressFilePath()
 	_, err := os.Stat(filePath)
 	if err != nil {
@@ -82,7 +82,7 @@ func (p *ProgressAdapter) IsDownloadInProgress(ctx context.Context) (bool, error
 
 // WaitForDownloadComplete waits until no download is in progress
 // Returns an error if the context is cancelled or times out
-func (p *ProgressAdapter) WaitForDownloadComplete(ctx context.Context, checkInterval time.Duration) error {
+func (p *DownloadAdapter) WaitForDownloadComplete(ctx context.Context, checkInterval time.Duration) error {
 	for {
 		select {
 		case <-ctx.Done():
diff --git a/internal/application/ports/testProgress_port.go b/internal/application/ports/testProgress_port.go
new file mode 100644
index 0000000..808de88
--- /dev/null
+++ b/internal/application/ports/testProgress_port.go
@@ -0,0 +1 @@
+package ports

From 3bbc820646da7fad8e5fd7d3969ff63d5a64f383 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Thu, 22 Jan 2026 17:05:49 +0100
Subject: [PATCH 26/42] implement testing adapter

---
 cmd/snapshot-checker/main.go                  |   5 +
 cmd/test-runner/main.go                       |   4 +-
 .../shared/testing/testing_adapter.go         | 103 ++++++++++++++++++
 internal/application/domain/snapshot.go       |   3 +
 .../application/ports/testProgress_port.go    |  15 +++
 .../application/services/snapshot_checker.go  |  56 ++++++++--
 internal/application/services/test_runner.go  |  26 ++++-
 7 files changed, 196 insertions(+), 16 deletions(-)
 create mode 100644 internal/adapters/shared/testing/testing_adapter.go

diff --git a/cmd/snapshot-checker/main.go b/cmd/snapshot-checker/main.go
index d609625..74fd13f 100644
--- a/cmd/snapshot-checker/main.go
+++ b/cmd/snapshot-checker/main.go
@@ -6,6 +6,7 @@ import (
 	"clients-test/internal/adapters/composite/snapshotmanager"
 	"clients-test/internal/adapters/shared/blocknumber"
 	"clients-test/internal/adapters/shared/download"
+	"clients-test/internal/adapters/shared/testing"
 	"clients-test/internal/application/domain"
 	"clients-test/internal/application/services"
 	"clients-test/internal/config"
@@ -61,6 +62,9 @@ func main() {
 		blockNumberAdapter,
 	)
 
+	// Initialize test adapter for checking test in progress
+	testAdapter := testing.NewTestAdapter()
+
 	// If a previous run crashed/was interrupted, the marker file can be left behind and block future runs.
 	// Clear it on startup so the service can recover.
 	if inProgress, err := downloadAdapter.IsDownloadInProgress(ctx); err != nil {
@@ -76,6 +80,7 @@ func main() {
 	service := services.NewSnapshotCheckerService(
 		snapshotManagerAdapter,
 		downloadAdapter,
+		testAdapter,
 		snapshotConfig,
 	)
 
diff --git a/cmd/test-runner/main.go b/cmd/test-runner/main.go
index 21f50e1..4560f6d 100644
--- a/cmd/test-runner/main.go
+++ b/cmd/test-runner/main.go
@@ -12,6 +12,7 @@ import (
 	"clients-test/internal/adapters/composite"
 	"clients-test/internal/adapters/shared/blocknumber"
 	"clients-test/internal/adapters/shared/download"
+	"clients-test/internal/adapters/shared/testing"
 	"clients-test/internal/application/domain"
 	"clients-test/internal/application/services"
 	"clients-test/internal/config"
@@ -68,6 +69,7 @@ func main() {
 
 	// Initialize shared adapters
 	downloadAdapter := download.NewDownloadAdapter()
+	testAdapter := testing.NewTestAdapter()
 	blockAdapter := blocknumber.NewBlockNumberAdapter()
 
 	// Log GitHub configuration status
@@ -105,7 +107,7 @@ func main() {
 	}()
 
 	// Initialize and run the service
-	testRunner := services.NewTestRunner(compositeAdapter, downloadAdapter)
+	testRunner := services.NewTestRunner(compositeAdapter, downloadAdapter, testAdapter)
 
 	if err := testRunner.RunTest(ctx, stakerConfig, pkg); err != nil {
 		logger.FatalWithPrefix(logPrefix, "Test run failed: %v", err)
diff --git a/internal/adapters/shared/testing/testing_adapter.go b/internal/adapters/shared/testing/testing_adapter.go
new file mode 100644
index 0000000..5891b42
--- /dev/null
+++ b/internal/adapters/shared/testing/testing_adapter.go
@@ -0,0 +1,103 @@
+package testing
+
+import (
+	"clients-test/internal/application/domain"
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+// TestAdapter handles the .test_in_progress file operations
+type TestAdapter struct {
+	basePath string
+}
+
+// NewTestAdapter creates a new TestAdapter
+func NewTestAdapter() *TestAdapter {
+	return &TestAdapter{
+		basePath: domain.SnapshotProgressPath,
+	}
+}
+
+// NewTestAdapterWithPath creates a new TestAdapter with a custom base path (for testing)
+func NewTestAdapterWithPath(basePath string) *TestAdapter {
+	return &TestAdapter{
+		basePath: basePath,
+	}
+}
+
+// progressFilePath returns the full path to the test progress file
+func (t *TestAdapter) progressFilePath() string {
+	return filepath.Join(t.basePath, domain.TestProgressFileName)
+}
+
+// SetTestInProgress creates the .test_in_progress file
+func (t *TestAdapter) SetTestInProgress(ctx context.Context) error {
+	filePath := t.progressFilePath()
+
+	if err := os.MkdirAll(t.basePath, 0755); err != nil {
+		return fmt.Errorf("failed to create directory %s: %w", t.basePath, err)
+	}
+
+	f, err := os.Create(filePath)
+	if err != nil {
+		return fmt.Errorf("failed to create test progress file: %w", err)
+	}
+	defer f.Close()
+
+	_, err = f.WriteString(time.Now().UTC().Format(time.RFC3339))
+	if err != nil {
+		return fmt.Errorf("failed to write to test progress file: %w", err)
+	}
+
+	return nil
+}
+
+// ClearTestInProgress removes the .test_in_progress file
+func (t *TestAdapter) ClearTestInProgress(ctx context.Context) error {
+	filePath := t.progressFilePath()
+
+	err := os.Remove(filePath)
+	if err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("failed to remove test progress file: %w", err)
+	}
+
+	return nil
+}
+
+// IsTestInProgress checks if a test is in progress
+func (t *TestAdapter) IsTestInProgress(ctx context.Context) (bool, error) {
+	filePath := t.progressFilePath()
+	_, err := os.Stat(filePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return false, nil
+		}
+		return false, fmt.Errorf("failed to check test progress file: %w", err)
+	}
+	return true, nil
+}
+
+// WaitForTestComplete waits until no test is in progress
+// Returns an error if the context is cancelled or times out
+func (t *TestAdapter) WaitForTestComplete(ctx context.Context, checkInterval time.Duration) error {
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+			inProgress, err := t.IsTestInProgress(ctx)
+			if err != nil {
+				return fmt.Errorf("error checking test progress: %w", err)
+			}
+
+			if !inProgress {
+				return nil
+			}
+
+			time.Sleep(checkInterval)
+		}
+	}
+}
diff --git a/internal/application/domain/snapshot.go b/internal/application/domain/snapshot.go
index 4334088..f7cfbd8 100644
--- a/internal/application/domain/snapshot.go
+++ b/internal/application/domain/snapshot.go
@@ -29,6 +29,9 @@ const SnapshotProgressPath = "/usr/src/dappnode/DNCORE"
 // ProgressFileName is the name of the download in progress file
 const ProgressFileName = ".download_in_progress"
 
+// TestProgressFileName is the name of the test in progress file
+const TestProgressFileName = ".test_in_progress"
+
 // SnapshotBlockNumberFileName returns the snapshot block number file name
 const SnapshotBlockNumberFileName = "snapshot_block_number"
 
diff --git a/internal/application/ports/testProgress_port.go b/internal/application/ports/testProgress_port.go
index 808de88..a2708c6 100644
--- a/internal/application/ports/testProgress_port.go
+++ b/internal/application/ports/testProgress_port.go
@@ -1 +1,16 @@
 package ports
+
+import "context"
+
+// TestProgress defines the interface for tracking test progress state
+// Used to prevent snapshot downloads while a test is running
+type TestProgress interface {
+	// IsTestInProgress checks if a test is currently in progress
+	IsTestInProgress(ctx context.Context) (bool, error)
+
+	// SetTestInProgress marks that a test has started
+	SetTestInProgress(ctx context.Context) error
+
+	// ClearTestInProgress marks that a test has completed (success or failure)
+	ClearTestInProgress(ctx context.Context) error
+}
diff --git a/internal/application/services/snapshot_checker.go b/internal/application/services/snapshot_checker.go
index 8945f8a..950bf1b 100644
--- a/internal/application/services/snapshot_checker.go
+++ b/internal/application/services/snapshot_checker.go
@@ -14,21 +14,24 @@ var snapshotLogPrefix = "SnapshotChecker"
 
 // SnapshotCheckerService handles snapshot checking and downloading
 type SnapshotCheckerService struct {
-	snapshotManager ports.SnapshotManager
-	progress        ports.DownloadProgress
-	config          domain.SnapshotCheckerConfig
+	snapshotManager  ports.SnapshotManager
+	downloadProgress ports.DownloadProgress
+	testProgress     ports.TestProgress
+	config           domain.SnapshotCheckerConfig
 }
 
 // NewSnapshotCheckerService creates a new SnapshotCheckerService
 func NewSnapshotCheckerService(
 	snapshotManager ports.SnapshotManager,
-	progress ports.DownloadProgress,
+	downloadProgress ports.DownloadProgress,
+	testProgress ports.TestProgress,
 	config domain.SnapshotCheckerConfig,
 ) *SnapshotCheckerService {
 	return &SnapshotCheckerService{
-		snapshotManager: snapshotManager,
-		progress:        progress,
-		config:          config,
+		snapshotManager:  snapshotManager,
+		downloadProgress: downloadProgress,
+		testProgress:     testProgress,
+		config:           config,
 	}
 }
 
@@ -80,9 +83,16 @@ func (s *SnapshotCheckerService) Start(ctx context.Context, runOnce bool) error
 func (s *SnapshotCheckerService) CheckAndUpdateSnapshots(ctx context.Context) error {
 	logger.InfoWithPrefix(snapshotLogPrefix, "Checking snapshots for %d clients", len(s.config.ExecutionClients))
 
+	// Wait for any ongoing tests to complete before proceeding
+	logger.InfoWithPrefix(snapshotLogPrefix, "Checking if test is in progress...")
+	if err := s.WaitForTestCompleteWithRetry(ctx); err != nil {
+		return fmt.Errorf("error while waiting for test to complete: %w", err)
+	}
+	logger.InfoWithPrefix(snapshotLogPrefix, "No ongoing tests detected, proceeding with snapshot check")
+
 	// Check if a download is already in progress
 	logger.InfoWithPrefix(snapshotLogPrefix, "Checking if download is already in progress...")
-	inProgress, err := s.progress.IsDownloadInProgress(ctx)
+	inProgress, err := s.downloadProgress.IsDownloadInProgress(ctx)
 	if err != nil {
 		return fmt.Errorf("failed to check download progress: %w", err)
 	}
@@ -93,14 +103,14 @@ func (s *SnapshotCheckerService) CheckAndUpdateSnapshots(ctx context.Context) er
 
 	// Set download in progress for this cycle
 	logger.InfoWithPrefix(snapshotLogPrefix, "Setting download in progress marker...")
-	if err := s.progress.SetDownloadInProgress(ctx); err != nil {
+	if err := s.downloadProgress.SetDownloadInProgress(ctx); err != nil {
 		return fmt.Errorf("failed to set download in progress: %w", err)
 	}
 
 	// Ensure we clear the progress file on completion (success or failure)
 	defer func() {
 		logger.InfoWithPrefix(snapshotLogPrefix, "Clearing download in progress marker...")
-		if err := s.progress.ClearDownloadInProgress(ctx); err != nil {
+		if err := s.downloadProgress.ClearDownloadInProgress(ctx); err != nil {
 			logger.ErrorWithPrefix(snapshotLogPrefix, "Failed to clear download in progress: %v", err)
 		}
 	}()
@@ -187,3 +197,29 @@ func (s *SnapshotCheckerService) StopAllDownloads(ctx context.Context) {
 	s.snapshotManager.StopAllDownloads(ctx)
 	logger.InfoWithPrefix(snapshotLogPrefix, "All download containers stopped")
 }
+
+// WaitForTestCompleteWithRetry waits until no test is in progress
+// using a fixed 30 second retry interval. This is useful for the snapshot checker
+// to wait for tests to complete before proceeding with downloads.
+func (s *SnapshotCheckerService) WaitForTestCompleteWithRetry(ctx context.Context) error {
+	const retryInterval = 30 * time.Second
+
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+			inProgress, err := s.testProgress.IsTestInProgress(ctx)
+			if err != nil {
+				return fmt.Errorf("error checking test progress: %w", err)
+			}
+
+			if !inProgress {
+				return nil
+			}
+
+			logger.InfoWithPrefix(snapshotLogPrefix, "Test in progress, waiting %s before retry...", retryInterval)
+			time.Sleep(retryInterval)
+		}
+	}
+}
diff --git a/internal/application/services/test_runner.go b/internal/application/services/test_runner.go
index 52212dc..50de12d 100644
--- a/internal/application/services/test_runner.go
+++ b/internal/application/services/test_runner.go
@@ -12,12 +12,13 @@ import (
 var logPrefix = "TestRunner"
 
 type TestRunnerService struct {
-	Runner   ports.TestRunner
-	Download ports.DownloadProgress
+	Runner           ports.TestRunner
+	DownloadProgress ports.DownloadProgress
+	TestProgress     ports.TestProgress
 }
 
-func NewTestRunner(runner ports.TestRunner, download ports.DownloadProgress) *TestRunnerService {
-	return &TestRunnerService{Runner: runner, Download: download}
+func NewTestRunner(runner ports.TestRunner, downloadProgress ports.DownloadProgress, testProgress ports.TestProgress) *TestRunnerService {
+	return &TestRunnerService{Runner: runner, DownloadProgress: downloadProgress, TestProgress: testProgress}
 }
 
 // RunTest wires up the three steps in sequence.
@@ -31,6 +32,21 @@ func (s *TestRunnerService) RunTest(ctx context.Context, stakerConfig domain.Sta
 	}
 	logger.InfoWithPrefix(logPrefix, "No ongoing downloads detected, proceeding with test run")
 
+	// Set test in progress marker
+	logger.InfoWithPrefix(logPrefix, "Setting test in progress marker...")
+	if err := s.TestProgress.SetTestInProgress(ctx); err != nil {
+		logger.ErrorWithPrefix(logPrefix, "Failed to set test in progress: %v", err)
+		return fmt.Errorf("failed to set test in progress: %w", err)
+	}
+
+	// Ensure we clear the test in progress marker on completion (success or failure)
+	defer func() {
+		logger.InfoWithPrefix(logPrefix, "Clearing test in progress marker...")
+		if err := s.TestProgress.ClearTestInProgress(ctx); err != nil {
+			logger.ErrorWithPrefix(logPrefix, "Failed to clear test in progress: %v", err)
+		}
+	}()
+
 	// 2) ensure environment
 	logger.InfoWithPrefix(logPrefix, "Step 2: Ensuring environment for package %s", pkg.DnpName)
 	if err := s.Runner.EnsureEnvironment(ctx, stakerConfig, pkg); err != nil {
@@ -78,7 +94,7 @@ func (s *TestRunnerService) WaitForDownloadCompleteWithRetry(ctx context.Context
 		case <-ctx.Done():
 			return ctx.Err()
 		default:
-			inProgress, err := s.Download.IsDownloadInProgress(ctx)
+			inProgress, err := s.DownloadProgress.IsDownloadInProgress(ctx)
 			if err != nil {
 				return fmt.Errorf("error checking download progress: %w", err)
 			}

From 062c1df296f0d51e0c443399a28c037060e40ce6 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Thu, 22 Jan 2026 17:09:01 +0100
Subject: [PATCH 27/42] improve cleaner execution

---
 internal/application/services/test_runner.go | 31 +++++++-------------
 1 file changed, 11 insertions(+), 20 deletions(-)

diff --git a/internal/application/services/test_runner.go b/internal/application/services/test_runner.go
index 50de12d..2d14b4e 100644
--- a/internal/application/services/test_runner.go
+++ b/internal/application/services/test_runner.go
@@ -39,8 +39,15 @@ func (s *TestRunnerService) RunTest(ctx context.Context, stakerConfig domain.Sta
 		return fmt.Errorf("failed to set test in progress: %w", err)
 	}
 
-	// Ensure we clear the test in progress marker on completion (success or failure)
+	// Ensure we clean up and clear the test in progress marker on completion (success or failure)
 	defer func() {
+		logger.InfoWithPrefix(logPrefix, "Cleaning up environment...")
+		if cleanupErr := s.Runner.CleanEnvironment(ctx, stakerConfig); cleanupErr != nil {
+			logger.ErrorWithPrefix(logPrefix, "Cleanup failed: %v", cleanupErr)
+		} else {
+			logger.InfoWithPrefix(logPrefix, "Cleanup completed successfully")
+		}
+
 		logger.InfoWithPrefix(logPrefix, "Clearing test in progress marker...")
 		if err := s.TestProgress.ClearTestInProgress(ctx); err != nil {
 			logger.ErrorWithPrefix(logPrefix, "Failed to clear test in progress: %v", err)
@@ -57,28 +64,12 @@ func (s *TestRunnerService) RunTest(ctx context.Context, stakerConfig domain.Sta
 
 	// 3) execute test (now includes report generation and PR commenting)
 	logger.InfoWithPrefix(logPrefix, "Step 3: Executing test")
-	execErr := s.Runner.ExecuteTest(ctx, stakerConfig)
-	if execErr != nil {
-		logger.ErrorWithPrefix(logPrefix, "Test execution failed: %v", execErr)
-		// even on test failure we want cleanup
-		logger.InfoWithPrefix(logPrefix, "Step 4: Running cleanup after test failure")
-		if cleanupErr := s.Runner.CleanEnvironment(ctx, stakerConfig); cleanupErr != nil {
-			logger.ErrorWithPrefix(logPrefix, "Cleanup also failed: %v", cleanupErr)
-			return fmt.Errorf("test failed: %v; cleanup also failed: %w", execErr, cleanupErr)
-		}
-		logger.InfoWithPrefix(logPrefix, "Cleanup completed successfully")
-		return fmt.Errorf("test failed: %w", execErr)
+	if err := s.Runner.ExecuteTest(ctx, stakerConfig); err != nil {
+		logger.ErrorWithPrefix(logPrefix, "Test execution failed: %v", err)
+		return fmt.Errorf("test failed: %w", err)
 	}
 	logger.InfoWithPrefix(logPrefix, "Test execution completed successfully")
 
-	// 4) cleanup
-	logger.InfoWithPrefix(logPrefix, "Step 4: Cleaning up environment")
-	if err := s.Runner.CleanEnvironment(ctx, stakerConfig); err != nil {
-		logger.ErrorWithPrefix(logPrefix, "Cleanup failed: %v", err)
-		return fmt.Errorf("cleanup failed: %w", err)
-	}
-	logger.InfoWithPrefix(logPrefix, "Cleanup completed successfully")
-
 	logger.InfoWithPrefix(logPrefix, "Test run completed successfully")
 	return nil
 }

From 61c80aee420af3a3635753d1e879e4b2d3e48159 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Thu, 22 Jan 2026 17:15:35 +0100
Subject: [PATCH 28/42] improve exit handler testrunner

---
 cmd/snapshot-checker/main.go |  2 +-
 cmd/test-runner/main.go      | 21 +++++++++++----------
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/cmd/snapshot-checker/main.go b/cmd/snapshot-checker/main.go
index 74fd13f..549c466 100644
--- a/cmd/snapshot-checker/main.go
+++ b/cmd/snapshot-checker/main.go
@@ -89,7 +89,7 @@ func main() {
 		logger.InfoWithPrefix(logPrefix, "Received signal: %v, shutting down...", sig)
 		// Stop any running download containers using the service method
 		service.StopAllDownloads(context.Background())
-		// Best-effort cleanup: clear marker file so next run isn't blocked.
+		// Best-effort cleanup: clear marker file `.download_in_progress` so next run isn't blocked.
 		if err := downloadAdapter.ClearDownloadInProgress(context.Background()); err != nil {
 			logger.WarnWithPrefix(logPrefix, "Failed to clear %s marker on shutdown: %v", domain.ProgressFileName, err)
 		}
diff --git a/cmd/test-runner/main.go b/cmd/test-runner/main.go
index 4560f6d..84bcaee 100644
--- a/cmd/test-runner/main.go
+++ b/cmd/test-runner/main.go
@@ -33,13 +33,13 @@ func main() {
 	cfg := config.ParseConfig()
 	cfg.Validate()
 
-	// Set up Ctrl+C (SIGINT) handler to call composite cleaner
-	cleanupDone := make(chan struct{})
+	// Set up Ctrl+C (SIGINT) handler
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
 	sigs := make(chan os.Signal, 1)
 	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
 
-	ctx := context.Background()
-
 	// Fetch dnpName from ipfs hash
 	ipfsAdapter := ipfs.NewIPFSAdapter(&cfg.IPFSGatewayURL)
 	pkg, err := ipfsAdapter.GetDnpNameAndServiceName(ctx, cfg.IPFSHash)
@@ -95,15 +95,16 @@ func main() {
 	// Ctrl+C handler: call CleanEnvironment on composite
 	go func() {
 		sig := <-sigs
-		logger.InfoWithPrefix(logPrefix, "Received signal: %v, running cleanup...", sig)
-		err := compositeAdapter.CleanEnvironment(ctx, stakerConfig)
+		logger.InfoWithPrefix(logPrefix, "Received signal: %v, shutting down...", sig)
+		err := compositeAdapter.CleanEnvironment(context.Background(), stakerConfig)
 		if err != nil {
 			logger.ErrorWithPrefix(logPrefix, "Cleanup failed: %v", err)
-		} else {
-			logger.InfoWithPrefix(logPrefix, "Cleanup completed successfully")
 		}
-		close(cleanupDone)
-		os.Exit(1)
+		// Best-effort cleanup, clear marker file `.test_in_progress` so next run isn't blocked.
+		if err := testAdapter.ClearTestInProgress(context.Background()); err != nil {
+			logger.WarnWithPrefix(logPrefix, "Failed to clear %s marker on shutdown: %v", domain.TestProgressFileName, err)
+		}
+		cancel()
 	}()
 
 	// Initialize and run the service

From e41bd9a56549e8ce7898c95e435d16200b20cb18 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 23 Jan 2026 08:04:29 +0100
Subject: [PATCH 29/42] cleanup flag files adapters

---
 cmd/snapshot-checker/main.go                  |  60 +++++----
 cmd/test-runner/main.go                       |  11 +-
 .../adapters/composite/ensurer/ensurer.go     |  20 ++-
 .../snapshotmanager/snapshotmanager.go        |   6 +-
 .../shared/blocknumber/blocknumber_adapter.go |  49 +++++---
 internal/application/domain/snapshot.go       |  57 +++++----
 internal/application/domain/stakers.go        |  66 ++++++----
 .../application/services/snapshot_checker.go  | 114 ++++++++----------
 internal/config/snapshot_checker_config.go    |  54 +++------
 9 files changed, 212 insertions(+), 225 deletions(-)

diff --git a/cmd/snapshot-checker/main.go b/cmd/snapshot-checker/main.go
index 549c466..0e76488 100644
--- a/cmd/snapshot-checker/main.go
+++ b/cmd/snapshot-checker/main.go
@@ -15,7 +15,6 @@ import (
 	"fmt"
 	"os"
 	"os/signal"
-	"sort"
 	"strings"
 	"syscall"
 )
@@ -29,11 +28,17 @@ func main() {
 	cfg := config.ParseSnapshotCheckerConfig()
 	cfg.Validate()
 
-	// Initialize domain config directly
+	// Get execution client info
+	executionClient, ok := domain.GetExecutionClient(cfg.Network, cfg.ExecutionClient)
+	if !ok {
+		logger.FatalWithPrefix(logPrefix, "Failed to get execution client info for '%s'", cfg.ExecutionClient)
+	}
+
+	// Initialize domain config
 	snapshotConfig := domain.SnapshotCheckerConfig{
-		ExecutionClients: domain.GetExecutionClients(cfg.Network, cfg.ExecutionClients),
-		CronIntervalSec:  cfg.CronIntervalSec,
-		Network:          cfg.Network,
+		ExecutionClient: executionClient,
+		CronIntervalSec: cfg.CronIntervalSec,
+		Network:         cfg.Network,
 	}
 
 	// Print configuration
@@ -52,8 +57,12 @@ func main() {
 	if err != nil {
 		logger.FatalWithPrefix(logPrefix, "Failed to init DockerAdapter: %v", err)
 	}
-	downloadAdapter := download.NewDownloadAdapter()
-	blockNumberAdapter := blocknumber.NewBlockNumberAdapter()
+
+	// Initialize progress adapters with client's volume path
+	logger.InfoWithPrefix(logPrefix, "Using volume path for flag files: %s", executionClient.VolumeTargetPath)
+	downloadAdapter := download.NewDownloadAdapterWithPath(executionClient.VolumeTargetPath)
+	testAdapter := testing.NewTestAdapterWithPath(executionClient.VolumeTargetPath)
+	blockNumberAdapter := blocknumber.NewBlockNumberAdapterWithPath(executionClient.VolumeTargetPath)
 
 	// Create composite snapshot manager adapter
 	snapshotManagerAdapter := snapshotmanager.NewSnapshotManagerAdapter(
@@ -62,17 +71,13 @@ func main() {
 		blockNumberAdapter,
 	)
 
-	// Initialize test adapter for checking test in progress
-	testAdapter := testing.NewTestAdapter()
-
-	// If a previous run crashed/was interrupted, the marker file can be left behind and block future runs.
-	// Clear it on startup so the service can recover.
+	// Clear any stale download marker on startup
 	if inProgress, err := downloadAdapter.IsDownloadInProgress(ctx); err != nil {
-		logger.WarnWithPrefix(logPrefix, "Failed to check %s marker: %v", domain.ProgressFileName, err)
+		logger.WarnWithPrefix(logPrefix, "[%s] Failed to check %s marker: %v", executionClient.ShortName, domain.ProgressFileName, err)
 	} else if inProgress {
-		logger.WarnWithPrefix(logPrefix, "Found stale %s marker; clearing it on startup", domain.ProgressFileName)
+		logger.WarnWithPrefix(logPrefix, "[%s] Found stale %s marker; clearing it on startup", executionClient.ShortName, domain.ProgressFileName)
 		if err := downloadAdapter.ClearDownloadInProgress(context.Background()); err != nil {
-			logger.WarnWithPrefix(logPrefix, "Failed to clear %s marker on startup: %v", domain.ProgressFileName, err)
+			logger.WarnWithPrefix(logPrefix, "[%s] Failed to clear %s marker on startup: %v", executionClient.ShortName, domain.ProgressFileName, err)
 		}
 	}
 
@@ -89,10 +94,8 @@ func main() {
 		logger.InfoWithPrefix(logPrefix, "Received signal: %v, shutting down...", sig)
 		// Stop any running download containers using the service method
 		service.StopAllDownloads(context.Background())
-		// Best-effort cleanup: clear marker file `.download_in_progress` so next run isn't blocked.
-		if err := downloadAdapter.ClearDownloadInProgress(context.Background()); err != nil {
-			logger.WarnWithPrefix(logPrefix, "Failed to clear %s marker on shutdown: %v", domain.ProgressFileName, err)
-		}
+		// Best-effort cleanup: clear marker file so next run isn't blocked.
+		service.ClearDownloadMarker(context.Background())
 		cancel()
 	}()
 
@@ -109,23 +112,18 @@ func main() {
 
 // helper to pretty print snapshot checker config
 func printSnapshotCheckerConfig(prefix string, sc domain.SnapshotCheckerConfig) {
-	clients := append([]domain.ExecutionClientInfo(nil), sc.ExecutionClients...)
-	sort.Slice(clients, func(i, j int) bool {
-		return clients[i].ShortName < clients[j].ShortName
-	})
+	c := sc.ExecutionClient
 
 	var b strings.Builder
 	b.WriteString("SnapshotCheckerConfig:\n")
 	b.WriteString(fmt.Sprintf("  Network: %s\n", sc.Network))
 	b.WriteString(fmt.Sprintf("  CronIntervalSec: %d\n", sc.CronIntervalSec))
-	b.WriteString("  ExecutionClients:\n")
-	for _, c := range clients {
-		b.WriteString(fmt.Sprintf("    - ShortName: %s\n", c.ShortName))
-		b.WriteString(fmt.Sprintf("      DnpName: %s\n", c.DnpName))
-		b.WriteString(fmt.Sprintf("      VolumeName: %s\n", c.VolumeName))
-		b.WriteString(fmt.Sprintf("      ContainerName: %s\n", c.ContainerName))
-		b.WriteString(fmt.Sprintf("      VolumeTargetPath: %s\n", c.VolumeTargetPath))
-	}
+	b.WriteString("  ExecutionClient:\n")
+	b.WriteString(fmt.Sprintf("    ShortName: %s\n", c.ShortName))
+	b.WriteString(fmt.Sprintf("    DnpName: %s\n", c.DnpName))
+	b.WriteString(fmt.Sprintf("    VolumeName: %s\n", c.VolumeName))
+	b.WriteString(fmt.Sprintf("    ContainerName: %s\n", c.ContainerName))
+	b.WriteString(fmt.Sprintf("    VolumeTargetPath: %s\n", c.VolumeTargetPath))
 
 	msg := b.String()
 	logger.InfoWithPrefix(prefix, "%s", msg)
diff --git a/cmd/test-runner/main.go b/cmd/test-runner/main.go
index 84bcaee..ed25f53 100644
--- a/cmd/test-runner/main.go
+++ b/cmd/test-runner/main.go
@@ -67,10 +67,11 @@ func main() {
 	// Initialize GitHub adapter for PR commenting
 	githubAdapter := github.NewGitHubAdapter(cfg.GitHub)
 
-	// Initialize shared adapters
-	downloadAdapter := download.NewDownloadAdapter()
-	testAdapter := testing.NewTestAdapter()
-	blockAdapter := blocknumber.NewBlockNumberAdapter()
+	// Initialize shared adapters with execution client's volume path
+	logger.InfoWithPrefix(logPrefix, "Using volume path for flag files: %s", stakerConfig.ExecutionVolumeTargetPath)
+	downloadAdapter := download.NewDownloadAdapterWithPath(stakerConfig.ExecutionVolumeTargetPath)
+	testAdapter := testing.NewTestAdapterWithPath(stakerConfig.ExecutionVolumeTargetPath)
+	blockAdapter := blocknumber.NewBlockNumberAdapterWithPath(stakerConfig.ExecutionVolumeTargetPath)
 
 	// Log GitHub configuration status
 	if githubAdapter.IsEnabled() {
@@ -127,6 +128,7 @@ func printStakerConfig(prefix string, sc domain.StakerConfig) {
   MevBoostDnpName: %s
   Network: %s
   ExecutionContainerName: %s
+  ExecutionVolumeTargetPath: %s
   Urls:
     ExecutionURL: %s
     BrainURL: %s
@@ -139,6 +141,7 @@ func printStakerConfig(prefix string, sc domain.StakerConfig) {
 		sc.MevBoostDnpName,
 		sc.Network,
 		sc.ExecutionContainerName,
+		sc.ExecutionVolumeTargetPath,
 		sc.Urls.ExecutionURL,
 		sc.Urls.BrainURL,
 		sc.Urls.BeaconchainURL,
diff --git a/internal/adapters/composite/ensurer/ensurer.go b/internal/adapters/composite/ensurer/ensurer.go
index c1e356b..255e023 100644
--- a/internal/adapters/composite/ensurer/ensurer.go
+++ b/internal/adapters/composite/ensurer/ensurer.go
@@ -68,7 +68,7 @@ func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig dom
 	}
 
 	// Read snapshot block number
-	e.readSnapshotBlockNumber(ctx, stakerConfig, report)
+	e.readSnapshotBlockNumber(ctx, report)
 
 	// SetStakerConfig
 	if err := timeOperation(report, "SetStakerConfig", func() error {
@@ -111,18 +111,12 @@ func (e *EnsurerAdapter) EnsureEnvironment(ctx context.Context, stakerConfig dom
 
 // readSnapshotBlockNumber reads the snapshot block number from the execution client's volume
 // and stores it in the report. Errors are silently ignored as this is informational.
-func (e *EnsurerAdapter) readSnapshotBlockNumber(ctx context.Context, stakerConfig domain.StakerConfig, report *domain.TestReport) {
-	// Get execution client info to find the volume path
-	execClients := domain.GetExecutionClients(stakerConfig.Network, nil)
-	for _, client := range execClients {
-		if client.DnpName == stakerConfig.ExecutionDnpName {
-			blockNumberStr, err := e.BlockNumber.ReadBlockNumber(ctx, client.VolumeTargetPath)
-			if err == nil && blockNumberStr != "" {
-				if blockNumber, parseErr := strconv.ParseUint(blockNumberStr, 10, 64); parseErr == nil {
-					report.SnapshotBlockNumber = blockNumber
-				}
-			}
-			break
+func (e *EnsurerAdapter) readSnapshotBlockNumber(ctx context.Context, report *domain.TestReport) {
+	// Use the BlockNumber adapter which is already initialized with the correct path
+	blockNumberStr, err := e.BlockNumber.ReadBlockNumber(ctx)
+	if err == nil && blockNumberStr != "" {
+		if blockNumber, parseErr := strconv.ParseUint(blockNumberStr, 10, 64); parseErr == nil {
+			report.SnapshotBlockNumber = blockNumber
 		}
 	}
 }
diff --git a/internal/adapters/composite/snapshotmanager/snapshotmanager.go b/internal/adapters/composite/snapshotmanager/snapshotmanager.go
index 65641ce..c025032 100644
--- a/internal/adapters/composite/snapshotmanager/snapshotmanager.go
+++ b/internal/adapters/composite/snapshotmanager/snapshotmanager.go
@@ -40,7 +40,7 @@ func NewSnapshotManagerAdapter(
 // Returns true if no snapshot exists or if a newer snapshot is available
 func (s *SnapshotManagerAdapter) NeedsSnapshotDownload(ctx context.Context, client domain.ExecutionClientInfo, latestBlockNumber string) (bool, error) {
 	// Check if block number file exists
-	exists, err := s.blockNumber.BlockNumberExists(ctx, client.VolumeTargetPath)
+	exists, err := s.blockNumber.BlockNumberExists(ctx)
 	if err != nil {
 		return false, err
 	}
@@ -50,7 +50,7 @@ func (s *SnapshotManagerAdapter) NeedsSnapshotDownload(ctx context.Context, clie
 	}
 
 	// Check if newer snapshot is available
-	isNewer, err := s.blockNumber.IsNewerSnapshot(ctx, client.VolumeTargetPath, latestBlockNumber)
+	isNewer, err := s.blockNumber.IsNewerSnapshot(ctx, latestBlockNumber)
 	if err != nil {
 		return false, err
 	}
@@ -79,7 +79,7 @@ func (s *SnapshotManagerAdapter) DownloadAndMountSnapshot(ctx context.Context, n
 	}
 
 	// 3. Write block number file
-	if err := s.blockNumber.WriteBlockNumber(ctx, client.VolumeTargetPath, latestBlockNumber); err != nil {
+	if err := s.blockNumber.WriteBlockNumber(ctx, latestBlockNumber); err != nil {
 		return fmt.Errorf("failed to write block number: %w", err)
 	}
 
diff --git a/internal/adapters/shared/blocknumber/blocknumber_adapter.go b/internal/adapters/shared/blocknumber/blocknumber_adapter.go
index 7f525d4..676a2db 100644
--- a/internal/adapters/shared/blocknumber/blocknumber_adapter.go
+++ b/internal/adapters/shared/blocknumber/blocknumber_adapter.go
@@ -11,25 +11,36 @@ import (
 )
 
 // BlockNumberAdapter handles the snapshot_block_number file operations
-type BlockNumberAdapter struct{}
+type BlockNumberAdapter struct {
+	basePath string
+}
 
-// NewBlockNumberAdapter creates a new BlockNumberAdapter
+// NewBlockNumberAdapter creates a new BlockNumberAdapter with default path
 func NewBlockNumberAdapter() *BlockNumberAdapter {
-	return &BlockNumberAdapter{}
+	return &BlockNumberAdapter{
+		basePath: domain.SnapshotProgressPath,
+	}
+}
+
+// NewBlockNumberAdapterWithPath creates a new BlockNumberAdapter with a custom base path
+func NewBlockNumberAdapterWithPath(basePath string) *BlockNumberAdapter {
+	return &BlockNumberAdapter{
+		basePath: basePath,
+	}
 }
 
-// blockNumberFilePath returns the full path to the block number file inside a volume
-func (b *BlockNumberAdapter) blockNumberFilePath(volumeTargetPath string) string {
-	return filepath.Join(volumeTargetPath, domain.SnapshotBlockNumberFileName)
+// blockNumberFilePath returns the full path to the block number file
+func (b *BlockNumberAdapter) blockNumberFilePath() string {
+	return filepath.Join(b.basePath, domain.SnapshotBlockNumberFileName)
 }
 
-// WriteBlockNumber writes the block number to the snapshot_block_number file in the volume
-func (b *BlockNumberAdapter) WriteBlockNumber(ctx context.Context, volumeTargetPath string, blockNumber string) error {
-	filePath := b.blockNumberFilePath(volumeTargetPath)
+// WriteBlockNumber writes the block number to the snapshot_block_number file
+func (b *BlockNumberAdapter) WriteBlockNumber(ctx context.Context, blockNumber string) error {
+	filePath := b.blockNumberFilePath()
 
 	// Ensure directory exists
-	if err := os.MkdirAll(volumeTargetPath, 0755); err != nil {
-		return fmt.Errorf("failed to create directory %s: %w", volumeTargetPath, err)
+	if err := os.MkdirAll(b.basePath, 0755); err != nil {
+		return fmt.Errorf("failed to create directory %s: %w", b.basePath, err)
 	}
 
 	f, err := os.Create(filePath)
@@ -46,10 +57,10 @@ func (b *BlockNumberAdapter) WriteBlockNumber(ctx context.Context, volumeTargetP
 	return nil
 }
 
-// ReadBlockNumber reads the block number from the snapshot_block_number file in the volume
+// ReadBlockNumber reads the block number from the snapshot_block_number file
 // Returns empty string if file doesn't exist
-func (b *BlockNumberAdapter) ReadBlockNumber(ctx context.Context, volumeTargetPath string) (string, error) {
-	filePath := b.blockNumberFilePath(volumeTargetPath)
+func (b *BlockNumberAdapter) ReadBlockNumber(ctx context.Context) (string, error) {
+	filePath := b.blockNumberFilePath()
 
 	data, err := os.ReadFile(filePath)
 	if err != nil {
@@ -63,9 +74,9 @@ func (b *BlockNumberAdapter) ReadBlockNumber(ctx context.Context, volumeTargetPa
 	return blockNumber, nil
 }
 
-// BlockNumberExists checks if a block number file exists in the volume
-func (b *BlockNumberAdapter) BlockNumberExists(ctx context.Context, volumeTargetPath string) (bool, error) {
-	filePath := b.blockNumberFilePath(volumeTargetPath)
+// BlockNumberExists checks if a block number file exists
+func (b *BlockNumberAdapter) BlockNumberExists(ctx context.Context) (bool, error) {
+	filePath := b.blockNumberFilePath()
 	_, err := os.Stat(filePath)
 	if err != nil {
 		if os.IsNotExist(err) {
@@ -101,8 +112,8 @@ func (b *BlockNumberAdapter) CompareBlockNumbers(a, blockB string) int {
 }
 
 // IsNewerSnapshot checks if the latest available block number is newer than the current one
-func (b *BlockNumberAdapter) IsNewerSnapshot(ctx context.Context, volumeTargetPath string, latestBlockNumber string) (bool, error) {
-	currentBlockNumber, err := b.ReadBlockNumber(ctx, volumeTargetPath)
+func (b *BlockNumberAdapter) IsNewerSnapshot(ctx context.Context, latestBlockNumber string) (bool, error) {
+	currentBlockNumber, err := b.ReadBlockNumber(ctx)
 	if err != nil {
 		return false, err
 	}
diff --git a/internal/application/domain/snapshot.go b/internal/application/domain/snapshot.go
index f7cfbd8..d7b2b51 100644
--- a/internal/application/domain/snapshot.go
+++ b/internal/application/domain/snapshot.go
@@ -15,9 +15,9 @@ type ExecutionClientInfo struct {
 
 // SnapshotCheckerConfig contains the configuration for the snapshot checker
 type SnapshotCheckerConfig struct {
-	ExecutionClients []ExecutionClientInfo // List of execution clients to manage
-	CronIntervalSec  int                   // Interval between snapshot checks in seconds (default 6 hours)
-	Network          string                // Network name (e.g., hoodi)
+	ExecutionClient ExecutionClientInfo // The execution client to manage
+	CronIntervalSec int                 // Interval between snapshot checks in seconds (default 6 hours)
+	Network         string              // Network name (e.g., hoodi)
 }
 
 // ValidExecutionClients contains all valid execution client short names for hoodi
@@ -35,8 +35,8 @@ const TestProgressFileName = ".test_in_progress"
 // SnapshotBlockNumberFileName returns the snapshot block number file name
 const SnapshotBlockNumberFileName = "snapshot_block_number"
 
-// GetExecutionClients returns the execution client info for hoodi network
-func GetExecutionClients(network string, selectedClients []string) []ExecutionClientInfo {
+// GetExecutionClient returns the execution client info for a specific client on hoodi network
+func GetExecutionClient(network string, clientName string) (ExecutionClientInfo, bool) {
 	allClients := map[string]string{
 		"reth": "hoodi-reth.dnp.dappnode.eth",
 		"geth": "hoodi-geth.dnp.dappnode.eth",
@@ -45,34 +45,31 @@ func GetExecutionClients(network string, selectedClients []string) []ExecutionCl
 		"nethermind": "hoodi-nethermind.dnp.dappnode.eth",
 	}
 
-	// Filter to selected clients or return all
-	var result []ExecutionClientInfo
-	for shortName, dnpName := range allClients {
-		if len(selectedClients) == 0 || containsString(selectedClients, shortName) {
-			serviceName := serviceNameFromExecutionClient(dnpName, network)
-			// reth and geth use different volume names than data
-			// - reth: https://github.com/dappnode/DAppNodePackage-reth-generic/blob/0de584dafd9b07fe24090f7e1cb96aa7f9108769/docker-compose.yml#L18
-			// - geth: https://github.com/dappnode/DAppNodePackage-geth-generic/blob/1b9ed0da445e8599e7182a083cb3ffc98bf6b289/package_variants/hoodi/docker-compose.yml#L16
-			var volumeArg string
-			if shortName == "geth" || shortName == "reth" {
-				volumeArg = shortName
-			} else {
-				volumeArg = "data"
-			}
-			volumeName := composeVolumeName(dnpName, volumeArg)
-			volumeTargetPath := fmt.Sprintf("/var/lib/docker/volumes/%s/_data", volumeName)
+	dnpName, exists := allClients[clientName]
+	if !exists {
+		return ExecutionClientInfo{}, false
+	}
 
-			result = append(result, ExecutionClientInfo{
-				ShortName:        shortName,
-				DnpName:          dnpName,
-				VolumeName:       volumeName,
-				ContainerName:    containerName(serviceName, dnpName),
-				VolumeTargetPath: volumeTargetPath,
-			})
-		}
+	serviceName := serviceNameFromExecutionClient(dnpName, network)
+	// reth and geth use different volume names than data
+	// - reth: https://github.com/dappnode/DAppNodePackage-reth-generic/blob/0de584dafd9b07fe24090f7e1cb96aa7f9108769/docker-compose.yml#L18
+	// - geth: https://github.com/dappnode/DAppNodePackage-geth-generic/blob/1b9ed0da445e8599e7182a083cb3ffc98bf6b289/package_variants/hoodi/docker-compose.yml#L16
+	var volumeArg string
+	if clientName == "geth" || clientName == "reth" {
+		volumeArg = clientName
+	} else {
+		volumeArg = "data"
 	}
+	volumeName := composeVolumeName(dnpName, volumeArg)
+	volumeTargetPath := fmt.Sprintf("/var/lib/docker/volumes/%s/_data", volumeName)
 
-	return result
+	return ExecutionClientInfo{
+		ShortName:        clientName,
+		DnpName:          dnpName,
+		VolumeName:       volumeName,
+		ContainerName:    containerName(serviceName, dnpName),
+		VolumeTargetPath: volumeTargetPath,
+	}, true
 }
 
 // IsValidExecutionClient checks if a client name is valid
diff --git a/internal/application/domain/stakers.go b/internal/application/domain/stakers.go
index c592a95..6c11b8a 100644
--- a/internal/application/domain/stakers.go
+++ b/internal/application/domain/stakers.go
@@ -1,24 +1,26 @@
 package domain
 
 import (
+	"fmt"
 	"math/rand"
 	"strings"
 	"time"
 )
 
 type StakerConfig struct {
-	ExecutionDnpName         string   `json:"executionDnpName"`
-	ConsensusDnpName         string   `json:"consensusDnpName"`
-	Web3SignerDnpName        string   `json:"web3signerDnpName"`
-	MevBoostDnpName          string   `json:"mevBoostDnpName"`
-	Relays                   []string `json:"relays,omitempty"` // Optional, can be empty
-	Network                  string   `json:"network"`          // The network this config is for (e.g., mainnet, gnosis, hoodi, lukso)
-	Urls                     Urls
-	BrainContainerName       string // The name of the brain container
-	SignerContainerName      string // The name of the web3signer container
-	BeaconchainContainerName string // The name of the beaconchain container
-	ValidatorContainerName   string // The name of the validator container
-	ExecutionContainerName   string // The name of the container to mount the NFS volume to
+	ExecutionDnpName          string   `json:"executionDnpName"`
+	ConsensusDnpName          string   `json:"consensusDnpName"`
+	Web3SignerDnpName         string   `json:"web3signerDnpName"`
+	MevBoostDnpName           string   `json:"mevBoostDnpName"`
+	Relays                    []string `json:"relays,omitempty"` // Optional, can be empty
+	Network                   string   `json:"network"`          // The network this config is for (e.g., mainnet, gnosis, hoodi, lukso)
+	Urls                      Urls
+	BrainContainerName        string // The name of the brain container
+	SignerContainerName       string // The name of the web3signer container
+	BeaconchainContainerName  string // The name of the beaconchain container
+	ValidatorContainerName    string // The name of the validator container
+	ExecutionContainerName    string // The name of the container to mount the NFS volume to
+	ExecutionVolumeTargetPath string // Path to the execution client's docker volume data
 }
 
 type Urls struct {
@@ -48,20 +50,36 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 	ecDnpName := matchOrRandom(pkg.DnpName, execClients)
 	ccDnpName := matchOrRandom(pkg.DnpName, consClients)
 
+	serviceName := serviceNameFromExecutionClient(ecDnpName, network)
+	volumeName := getExecutionVolumeName(ecDnpName, serviceName)
+
 	return StakerConfig{
-		ExecutionDnpName:         ecDnpName,
-		ConsensusDnpName:         ccDnpName,
-		Web3SignerDnpName:        web3signer,
-		MevBoostDnpName:          mevboost,
-		Relays:                   relays,
-		Network:                  network,
-		Urls:                     urls,
-		BrainContainerName:       containerName("brain", web3signer),
-		SignerContainerName:      containerName("web3signer", web3signer),
-		BeaconchainContainerName: containerName("beacon-chain", ccDnpName),
-		ValidatorContainerName:   containerName("validator", ccDnpName),
-		ExecutionContainerName:   containerName(serviceNameFromExecutionClient(ecDnpName, network), ecDnpName),
+		ExecutionDnpName:          ecDnpName,
+		ConsensusDnpName:          ccDnpName,
+		Web3SignerDnpName:         web3signer,
+		MevBoostDnpName:           mevboost,
+		Relays:                    relays,
+		Network:                   network,
+		Urls:                      urls,
+		BrainContainerName:        containerName("brain", web3signer),
+		SignerContainerName:       containerName("web3signer", web3signer),
+		BeaconchainContainerName:  containerName("beacon-chain", ccDnpName),
+		ValidatorContainerName:    containerName("validator", ccDnpName),
+		ExecutionContainerName:    containerName(serviceName, ecDnpName),
+		ExecutionVolumeTargetPath: fmt.Sprintf("/var/lib/docker/volumes/%s/_data", volumeName),
+	}
+}
+
+// getExecutionVolumeName returns the docker volume name for the execution client
+// reth and geth use their service name as volume name, others use "data"
+func getExecutionVolumeName(dnpName, serviceName string) string {
+	var volumeArg string
+	if serviceName == "geth" || serviceName == "reth" {
+		volumeArg = serviceName
+	} else {
+		volumeArg = "data"
 	}
+	return composeVolumeName(dnpName, volumeArg)
 }
 
 func matchOrRandom(dnpName string, candidates []string) string {
diff --git a/internal/application/services/snapshot_checker.go b/internal/application/services/snapshot_checker.go
index 950bf1b..69ffd28 100644
--- a/internal/application/services/snapshot_checker.go
+++ b/internal/application/services/snapshot_checker.go
@@ -6,7 +6,6 @@ import (
 	"clients-test/internal/logger"
 	"context"
 	"fmt"
-	"sync"
 	"time"
 )
 
@@ -43,7 +42,7 @@ func (s *SnapshotCheckerService) GetSnapshotManager() ports.SnapshotManager {
 // Start starts the snapshot checker cron job
 func (s *SnapshotCheckerService) Start(ctx context.Context, runOnce bool) error {
 	logger.InfoWithPrefix(snapshotLogPrefix, "Starting snapshot checker for network: %s", s.config.Network)
-	logger.InfoWithPrefix(snapshotLogPrefix, "Managing %d execution clients", len(s.config.ExecutionClients))
+	logger.InfoWithPrefix(snapshotLogPrefix, "Managing execution client: %s", s.config.ExecutionClient.ShortName)
 
 	// Run immediately on startup
 	logger.InfoWithPrefix(snapshotLogPrefix, "Running initial snapshot check...")
@@ -79,78 +78,41 @@ func (s *SnapshotCheckerService) Start(ctx context.Context, runOnce bool) error
 	}
 }
 
-// CheckAndUpdateSnapshots checks all configured clients and updates snapshots as needed
+// CheckAndUpdateSnapshots checks the configured client and updates snapshot if needed
 func (s *SnapshotCheckerService) CheckAndUpdateSnapshots(ctx context.Context) error {
-	logger.InfoWithPrefix(snapshotLogPrefix, "Checking snapshots for %d clients", len(s.config.ExecutionClients))
+	client := s.config.ExecutionClient
+	logger.InfoWithPrefix(snapshotLogPrefix, "Checking snapshot for client: %s", client.ShortName)
 
-	// Wait for any ongoing tests to complete before proceeding
-	logger.InfoWithPrefix(snapshotLogPrefix, "Checking if test is in progress...")
-	if err := s.WaitForTestCompleteWithRetry(ctx); err != nil {
+	if err := s.checkAndUpdateClient(ctx, client); err != nil {
+		return fmt.Errorf("client %s: %w", client.ShortName, err)
+	}
+
+	logger.InfoWithPrefix(snapshotLogPrefix, "Snapshot check completed successfully")
+	return nil
+}
+
+// checkAndUpdateClient checks a single client and updates snapshot if needed
+func (s *SnapshotCheckerService) checkAndUpdateClient(ctx context.Context, client domain.ExecutionClientInfo) error {
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Checking client (%s)", client.ShortName, client.DnpName)
+
+	// Wait for any ongoing tests to complete before proceeding with this client
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Checking if test is in progress...", client.ShortName)
+	if err := s.waitForTestCompleteWithRetry(ctx, client.ShortName); err != nil {
 		return fmt.Errorf("error while waiting for test to complete: %w", err)
 	}
-	logger.InfoWithPrefix(snapshotLogPrefix, "No ongoing tests detected, proceeding with snapshot check")
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] No ongoing tests detected", client.ShortName)
 
-	// Check if a download is already in progress
-	logger.InfoWithPrefix(snapshotLogPrefix, "Checking if download is already in progress...")
+	// Check if a download is already in progress for this client
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Checking if download is already in progress...", client.ShortName)
 	inProgress, err := s.downloadProgress.IsDownloadInProgress(ctx)
 	if err != nil {
 		return fmt.Errorf("failed to check download progress: %w", err)
 	}
 	if inProgress {
-		logger.InfoWithPrefix(snapshotLogPrefix, "Download already in progress, skipping this cycle")
+		logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Download already in progress, skipping", client.ShortName)
 		return nil
 	}
 
-	// Set download in progress for this cycle
-	logger.InfoWithPrefix(snapshotLogPrefix, "Setting download in progress marker...")
-	if err := s.downloadProgress.SetDownloadInProgress(ctx); err != nil {
-		return fmt.Errorf("failed to set download in progress: %w", err)
-	}
-
-	// Ensure we clear the progress file on completion (success or failure)
-	defer func() {
-		logger.InfoWithPrefix(snapshotLogPrefix, "Clearing download in progress marker...")
-		if err := s.downloadProgress.ClearDownloadInProgress(ctx); err != nil {
-			logger.ErrorWithPrefix(snapshotLogPrefix, "Failed to clear download in progress: %v", err)
-		}
-	}()
-
-	// Process clients in parallel using goroutines
-	var wg sync.WaitGroup
-	errChan := make(chan error, len(s.config.ExecutionClients))
-
-	for _, client := range s.config.ExecutionClients {
-		wg.Add(1)
-		go func(client domain.ExecutionClientInfo) {
-			defer wg.Done()
-			if err := s.checkAndUpdateClient(ctx, client); err != nil {
-				errChan <- fmt.Errorf("client %s: %w", client.ShortName, err)
-			}
-		}(client)
-	}
-
-	wg.Wait()
-	close(errChan)
-
-	// Collect errors
-	var errors []error
-	for err := range errChan {
-		errors = append(errors, err)
-	}
-
-	if len(errors) > 0 {
-		logger.ErrorWithPrefix(snapshotLogPrefix, "Snapshot check completed with %d errors", len(errors))
-		return fmt.Errorf("snapshot check had %d errors: %v", len(errors), errors)
-	}
-
-	logger.InfoWithPrefix(snapshotLogPrefix, "Snapshot check completed successfully")
-	return nil
-}
-
-// checkAndUpdateClient checks a single client and updates snapshot if needed
-func (s *SnapshotCheckerService) checkAndUpdateClient(ctx context.Context, client domain.ExecutionClientInfo) error {
-	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Checking client (%s)", client.ShortName, client.DnpName)
-
 	// Get latest available block number from ethpandaops
 	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Fetching latest available block number...", client.ShortName)
 	latestBlockNumber, err := s.snapshotManager.GetLatestBlockNumber(ctx, s.config.Network, client.ShortName)
@@ -173,6 +135,20 @@ func (s *SnapshotCheckerService) checkAndUpdateClient(ctx context.Context, clien
 
 	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Snapshot download needed", client.ShortName)
 
+	// Set download in progress for this client
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Setting download in progress marker...", client.ShortName)
+	if err := s.downloadProgress.SetDownloadInProgress(ctx); err != nil {
+		return fmt.Errorf("failed to set download in progress: %w", err)
+	}
+
+	// Ensure we clear the progress file on completion (success or failure)
+	defer func() {
+		logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Clearing download in progress marker...", client.ShortName)
+		if err := s.downloadProgress.ClearDownloadInProgress(ctx); err != nil {
+			logger.ErrorWithPrefix(snapshotLogPrefix, "[%s] Failed to clear download in progress: %v", client.ShortName, err)
+		}
+	}()
+
 	// Download and mount snapshot
 	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Starting snapshot download and extraction...", client.ShortName)
 	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Target path: %s", client.ShortName, client.VolumeTargetPath)
@@ -198,10 +174,16 @@ func (s *SnapshotCheckerService) StopAllDownloads(ctx context.Context) {
 	logger.InfoWithPrefix(snapshotLogPrefix, "All download containers stopped")
 }
 
-// WaitForTestCompleteWithRetry waits until no test is in progress
-// using a fixed 30 second retry interval. This is useful for the snapshot checker
-// to wait for tests to complete before proceeding with downloads.
-func (s *SnapshotCheckerService) WaitForTestCompleteWithRetry(ctx context.Context) error {
+// ClearDownloadMarker clears the download in progress marker
+func (s *SnapshotCheckerService) ClearDownloadMarker(ctx context.Context) {
+	if err := s.downloadProgress.ClearDownloadInProgress(ctx); err != nil {
+		logger.WarnWithPrefix(snapshotLogPrefix, "Failed to clear download marker: %v", err)
+	}
+}
+
+// waitForTestCompleteWithRetry waits until no test is in progress
+// using a fixed 30 second retry interval.
+func (s *SnapshotCheckerService) waitForTestCompleteWithRetry(ctx context.Context, clientName string) error {
 	const retryInterval = 30 * time.Second
 
 	for {
@@ -218,7 +200,7 @@ func (s *SnapshotCheckerService) WaitForTestCompleteWithRetry(ctx context.Contex
 				return nil
 			}
 
-			logger.InfoWithPrefix(snapshotLogPrefix, "Test in progress, waiting %s before retry...", retryInterval)
+			logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Test in progress, waiting %s before retry...", clientName, retryInterval)
 			time.Sleep(retryInterval)
 		}
 	}
diff --git a/internal/config/snapshot_checker_config.go b/internal/config/snapshot_checker_config.go
index 529b61c..a045f15 100644
--- a/internal/config/snapshot_checker_config.go
+++ b/internal/config/snapshot_checker_config.go
@@ -12,10 +12,10 @@ var snapshotLogPrefix = "SnapshotCheckerConfig"
 
 // SnapshotCheckerAppConfig holds all application configuration for snapshot checker
 type SnapshotCheckerAppConfig struct {
-	ExecutionClients []string
-	Network          string
-	CronIntervalSec  int
-	RunOnce          bool // If true, run once and exit (for testing)
+	ExecutionClient string
+	Network         string
+	CronIntervalSec int
+	RunOnce         bool // If true, run once and exit (for testing)
 }
 
 // DefaultCronIntervalSec is 6 hours in seconds
@@ -24,7 +24,7 @@ const DefaultCronIntervalSec = 6 * 60 * 60
 // ParseSnapshotCheckerConfig parses CLI flags and environment variables into a SnapshotCheckerAppConfig
 func ParseSnapshotCheckerConfig() SnapshotCheckerAppConfig {
 	// CLI flags
-	executionClients := flag.String("execution-clients", "", "Comma-separated list of execution clients (geth, nethermind, reth, besu, erigon). Default: all")
+	executionClient := flag.String("execution-client", "", "Execution client name (geth, nethermind, reth, besu, erigon). Required.")
 	network := flag.String("network", "hoodi", "Network name (e.g., hoodi). Default: hoodi")
 	cronIntervalSec := flag.Int("cron-interval", 0, "Interval between snapshot checks in seconds. Default: 21600 (6 hours)")
 	runOnce := flag.Bool("run-once", false, "Run once and exit (for testing). Default: false")
@@ -32,10 +32,10 @@ func ParseSnapshotCheckerConfig() SnapshotCheckerAppConfig {
 	flag.Parse()
 
 	config := SnapshotCheckerAppConfig{
-		ExecutionClients: parseExecutionClients(getConfigValue(*executionClients, "EXECUTION_CLIENTS", "")),
-		Network:          getConfigValue(*network, "NETWORK", "hoodi"),
-		CronIntervalSec:  getCronIntervalConfigValueInt(*cronIntervalSec, "CRON_INTERVAL_SEC", DefaultCronIntervalSec),
-		RunOnce:          *runOnce || os.Getenv("RUN_ONCE") == "true",
+		ExecutionClient: strings.TrimSpace(strings.ToLower(getConfigValue(*executionClient, "EXECUTION_CLIENT", ""))),
+		Network:         getConfigValue(*network, "NETWORK", "hoodi"),
+		CronIntervalSec: getCronIntervalConfigValueInt(*cronIntervalSec, "CRON_INTERVAL_SEC", DefaultCronIntervalSec),
+		RunOnce:         *runOnce || os.Getenv("RUN_ONCE") == "true",
 	}
 
 	return config
@@ -60,32 +60,16 @@ func getCronIntervalConfigValueInt(flagValue int, envName string, defaultValue i
 	return defaultValue
 }
 
-// parseExecutionClients parses the comma-separated list of execution clients
-// Returns empty slice if input is empty (means all clients)
-func parseExecutionClients(input string) []string {
-	if input == "" {
-		return nil // nil means all clients
-	}
-
-	var clients []string
-	for _, client := range strings.Split(input, ",") {
-		client = strings.TrimSpace(strings.ToLower(client))
-		if client != "" {
-			clients = append(clients, client)
-		}
-	}
-	return clients
-}
-
 // Validate checks that required configuration values are present and valid
 func (c *SnapshotCheckerAppConfig) Validate() {
-	// Validate execution clients if specified
-	if len(c.ExecutionClients) > 0 {
-		for _, client := range c.ExecutionClients {
-			if !domain.IsValidExecutionClient(client) {
-				logger.FatalWithPrefix(snapshotLogPrefix, "Invalid execution client '%s'. Valid clients: %v", client, domain.ValidExecutionClients)
-			}
-		}
+	// Validate execution client is specified
+	if c.ExecutionClient == "" {
+		logger.FatalWithPrefix(snapshotLogPrefix, "Execution client is required. Valid clients: %v", domain.ValidExecutionClients)
+	}
+
+	// Validate execution client is valid
+	if !domain.IsValidExecutionClient(c.ExecutionClient) {
+		logger.FatalWithPrefix(snapshotLogPrefix, "Invalid execution client '%s'. Valid clients: %v", c.ExecutionClient, domain.ValidExecutionClients)
 	}
 
 	// Validate cron interval
@@ -94,6 +78,6 @@ func (c *SnapshotCheckerAppConfig) Validate() {
 		c.CronIntervalSec = 60
 	}
 
-	logger.InfoWithPrefix(snapshotLogPrefix, "Configuration validated: network=%s, clients=%v, interval=%ds, runOnce=%v",
-		c.Network, c.ExecutionClients, c.CronIntervalSec, c.RunOnce)
+	logger.InfoWithPrefix(snapshotLogPrefix, "Configuration validated: network=%s, client=%s, interval=%ds, runOnce=%v",
+		c.Network, c.ExecutionClient, c.CronIntervalSec, c.RunOnce)
 }

From 0fb7c9428fed8e9ee93afe9d7e9b372984c392ca Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 23 Jan 2026 08:07:25 +0100
Subject: [PATCH 30/42] implement file locking

---
 .../shared/blocknumber/blocknumber_adapter.go | 34 +++++++++++++++++--
 .../shared/download/download_adapter.go       | 20 +++++++++--
 .../shared/testing/testing_adapter.go         | 20 +++++++++--
 3 files changed, 67 insertions(+), 7 deletions(-)

diff --git a/internal/adapters/shared/blocknumber/blocknumber_adapter.go b/internal/adapters/shared/blocknumber/blocknumber_adapter.go
index 676a2db..f090f2c 100644
--- a/internal/adapters/shared/blocknumber/blocknumber_adapter.go
+++ b/internal/adapters/shared/blocknumber/blocknumber_adapter.go
@@ -8,6 +8,7 @@ import (
 	"path/filepath"
 	"strconv"
 	"strings"
+	"syscall"
 )
 
 // BlockNumberAdapter handles the snapshot_block_number file operations
@@ -49,6 +50,12 @@ func (b *BlockNumberAdapter) WriteBlockNumber(ctx context.Context, blockNumber s
 	}
 	defer f.Close()
 
+	// Acquire exclusive lock for writing
+	if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX); err != nil {
+		return fmt.Errorf("failed to acquire lock on block number file: %w", err)
+	}
+	defer syscall.Flock(int(f.Fd()), syscall.LOCK_UN)
+
 	_, err = f.WriteString(blockNumber)
 	if err != nil {
 		return fmt.Errorf("failed to write to block number file: %w", err)
@@ -62,11 +69,23 @@ func (b *BlockNumberAdapter) WriteBlockNumber(ctx context.Context, blockNumber s
 func (b *BlockNumberAdapter) ReadBlockNumber(ctx context.Context) (string, error) {
 	filePath := b.blockNumberFilePath()
 
-	data, err := os.ReadFile(filePath)
+	f, err := os.Open(filePath)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return "", nil
 		}
+		return "", fmt.Errorf("failed to open block number file: %w", err)
+	}
+	defer f.Close()
+
+	// Acquire shared lock for reading
+	if err := syscall.Flock(int(f.Fd()), syscall.LOCK_SH); err != nil {
+		return "", fmt.Errorf("failed to acquire lock on block number file: %w", err)
+	}
+	defer syscall.Flock(int(f.Fd()), syscall.LOCK_UN)
+
+	data, err := os.ReadFile(filePath)
+	if err != nil {
 		return "", fmt.Errorf("failed to read block number file: %w", err)
 	}
 
@@ -77,13 +96,22 @@ func (b *BlockNumberAdapter) ReadBlockNumber(ctx context.Context) (string, error
 // BlockNumberExists checks if a block number file exists
 func (b *BlockNumberAdapter) BlockNumberExists(ctx context.Context) (bool, error) {
 	filePath := b.blockNumberFilePath()
-	_, err := os.Stat(filePath)
+
+	f, err := os.Open(filePath)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return false, nil
 		}
-		return false, fmt.Errorf("failed to check block number file: %w", err)
+		return false, fmt.Errorf("failed to open block number file: %w", err)
 	}
+	defer f.Close()
+
+	// Acquire shared lock for reading
+	if err := syscall.Flock(int(f.Fd()), syscall.LOCK_SH); err != nil {
+		return false, fmt.Errorf("failed to acquire lock on block number file: %w", err)
+	}
+	defer syscall.Flock(int(f.Fd()), syscall.LOCK_UN)
+
 	return true, nil
 }
 
diff --git a/internal/adapters/shared/download/download_adapter.go b/internal/adapters/shared/download/download_adapter.go
index 2434af1..a141427 100644
--- a/internal/adapters/shared/download/download_adapter.go
+++ b/internal/adapters/shared/download/download_adapter.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"syscall"
 	"time"
 )
 
@@ -47,6 +48,12 @@ func (p *DownloadAdapter) SetDownloadInProgress(ctx context.Context) error {
 	}
 	defer f.Close()
 
+	// Acquire exclusive lock for writing
+	if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX); err != nil {
+		return fmt.Errorf("failed to acquire lock on progress file: %w", err)
+	}
+	defer syscall.Flock(int(f.Fd()), syscall.LOCK_UN)
+
 	_, err = f.WriteString(time.Now().UTC().Format(time.RFC3339))
 	if err != nil {
 		return fmt.Errorf("failed to write to progress file: %w", err)
@@ -70,13 +77,22 @@ func (p *DownloadAdapter) ClearDownloadInProgress(ctx context.Context) error {
 // IsDownloadInProgress checks if download is in progress
 func (p *DownloadAdapter) IsDownloadInProgress(ctx context.Context) (bool, error) {
 	filePath := p.progressFilePath()
-	_, err := os.Stat(filePath)
+
+	f, err := os.Open(filePath)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return false, nil
 		}
-		return false, fmt.Errorf("failed to check progress file: %w", err)
+		return false, fmt.Errorf("failed to open progress file: %w", err)
 	}
+	defer f.Close()
+
+	// Acquire shared lock for reading
+	if err := syscall.Flock(int(f.Fd()), syscall.LOCK_SH); err != nil {
+		return false, fmt.Errorf("failed to acquire lock on progress file: %w", err)
+	}
+	defer syscall.Flock(int(f.Fd()), syscall.LOCK_UN)
+
 	return true, nil
 }
 
diff --git a/internal/adapters/shared/testing/testing_adapter.go b/internal/adapters/shared/testing/testing_adapter.go
index 5891b42..121cba4 100644
--- a/internal/adapters/shared/testing/testing_adapter.go
+++ b/internal/adapters/shared/testing/testing_adapter.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"syscall"
 	"time"
 )
 
@@ -47,6 +48,12 @@ func (t *TestAdapter) SetTestInProgress(ctx context.Context) error {
 	}
 	defer f.Close()
 
+	// Acquire exclusive lock for writing
+	if err := syscall.Flock(int(f.Fd()), syscall.LOCK_EX); err != nil {
+		return fmt.Errorf("failed to acquire lock on test progress file: %w", err)
+	}
+	defer syscall.Flock(int(f.Fd()), syscall.LOCK_UN)
+
 	_, err = f.WriteString(time.Now().UTC().Format(time.RFC3339))
 	if err != nil {
 		return fmt.Errorf("failed to write to test progress file: %w", err)
@@ -70,13 +77,22 @@ func (t *TestAdapter) ClearTestInProgress(ctx context.Context) error {
 // IsTestInProgress checks if a test is in progress
 func (t *TestAdapter) IsTestInProgress(ctx context.Context) (bool, error) {
 	filePath := t.progressFilePath()
-	_, err := os.Stat(filePath)
+
+	f, err := os.Open(filePath)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return false, nil
 		}
-		return false, fmt.Errorf("failed to check test progress file: %w", err)
+		return false, fmt.Errorf("failed to open test progress file: %w", err)
 	}
+	defer f.Close()
+
+	// Acquire shared lock for reading
+	if err := syscall.Flock(int(f.Fd()), syscall.LOCK_SH); err != nil {
+		return false, fmt.Errorf("failed to acquire lock on test progress file: %w", err)
+	}
+	defer syscall.Flock(int(f.Fd()), syscall.LOCK_UN)
+
 	return true, nil
 }
 

From bd442cfc737237d0767b8075e3a9a5f60d633b90 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 23 Jan 2026 08:07:59 +0100
Subject: [PATCH 31/42] fix log tyypo

---
 cmd/test-runner/main.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmd/test-runner/main.go b/cmd/test-runner/main.go
index ed25f53..6c12ed0 100644
--- a/cmd/test-runner/main.go
+++ b/cmd/test-runner/main.go
@@ -27,7 +27,7 @@ import (
 var logPrefix = "TEST_RUNNER"
 
 func main() {
-	logger.InfoWithPrefix(logPrefix, "Starting Notifications service")
+	logger.InfoWithPrefix(logPrefix, "Starting Test Runner service")
 
 	// Parse and validate configuration
 	cfg := config.ParseConfig()

From 2180c9ed60e326387e761eb533837756de82b899 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 23 Jan 2026 08:25:31 +0100
Subject: [PATCH 32/42] relocate blocknumberadapter

---
 cmd/snapshot-checker/main.go                  |  2 +-
 .../snapshotmanager/snapshotmanager.go        | 48 ++--------------
 .../application/ports/blockNumber_port.go     | 20 +++++++
 .../application/ports/snapshotChecker_port.go |  4 --
 .../application/services/snapshot_checker.go  | 57 +++++++++++++++++--
 5 files changed, 79 insertions(+), 52 deletions(-)
 create mode 100644 internal/application/ports/blockNumber_port.go

diff --git a/cmd/snapshot-checker/main.go b/cmd/snapshot-checker/main.go
index 0e76488..bb5625c 100644
--- a/cmd/snapshot-checker/main.go
+++ b/cmd/snapshot-checker/main.go
@@ -68,7 +68,6 @@ func main() {
 	snapshotManagerAdapter := snapshotmanager.NewSnapshotManagerAdapter(
 		snapshotsAdapter,
 		dockerAdapter,
-		blockNumberAdapter,
 	)
 
 	// Clear any stale download marker on startup
@@ -86,6 +85,7 @@ func main() {
 		snapshotManagerAdapter,
 		downloadAdapter,
 		testAdapter,
+		blockNumberAdapter,
 		snapshotConfig,
 	)
 
diff --git a/internal/adapters/composite/snapshotmanager/snapshotmanager.go b/internal/adapters/composite/snapshotmanager/snapshotmanager.go
index c025032..240d85b 100644
--- a/internal/adapters/composite/snapshotmanager/snapshotmanager.go
+++ b/internal/adapters/composite/snapshotmanager/snapshotmanager.go
@@ -7,7 +7,6 @@ import (
 
 	"clients-test/internal/adapters/apis/docker"
 	"clients-test/internal/adapters/apis/snapshots"
-	"clients-test/internal/adapters/shared/blocknumber"
 	"clients-test/internal/application/domain"
 )
 
@@ -15,60 +14,28 @@ const (
 	downloadContainerPrefix = "snapshot-download-"
 )
 
-// SnapshotManagerAdapter is a composite adapter that combines snapshots, docker, and blocknumber adapters
+// SnapshotManagerAdapter is a composite adapter that combines snapshots and docker adapters
 // to provide high-level snapshot management operations
 type SnapshotManagerAdapter struct {
-	snapshots   *snapshots.SnapshotsAdapter
-	docker      *docker.DockerAdapter
-	blockNumber *blocknumber.BlockNumberAdapter
+	snapshots *snapshots.SnapshotsAdapter
+	docker    *docker.DockerAdapter
 }
 
 // NewSnapshotManagerAdapter creates a new SnapshotManagerAdapter
 func NewSnapshotManagerAdapter(
 	snapshotsAdapter *snapshots.SnapshotsAdapter,
 	dockerAdapter *docker.DockerAdapter,
-	blockNumberAdapter *blocknumber.BlockNumberAdapter,
 ) *SnapshotManagerAdapter {
 	return &SnapshotManagerAdapter{
-		snapshots:   snapshotsAdapter,
-		docker:      dockerAdapter,
-		blockNumber: blockNumberAdapter,
+		snapshots: snapshotsAdapter,
+		docker:    dockerAdapter,
 	}
 }
 
-// NeedsSnapshotDownload determines if a snapshot needs to be downloaded for the given client
-// Returns true if no snapshot exists or if a newer snapshot is available
-func (s *SnapshotManagerAdapter) NeedsSnapshotDownload(ctx context.Context, client domain.ExecutionClientInfo, latestBlockNumber string) (bool, error) {
-	// Check if block number file exists
-	exists, err := s.blockNumber.BlockNumberExists(ctx)
-	if err != nil {
-		return false, err
-	}
-
-	if !exists {
-		return true, nil
-	}
-
-	// Check if newer snapshot is available
-	isNewer, err := s.blockNumber.IsNewerSnapshot(ctx, latestBlockNumber)
-	if err != nil {
-		return false, err
-	}
-
-	return isNewer, nil
-}
-
 // DownloadAndMountSnapshot performs the complete snapshot download and mount process:
 // 1. Stops the client container (if running)
 // 2. Downloads and extracts the snapshot to the volume
-// 3. Writes the block number file
 func (s *SnapshotManagerAdapter) DownloadAndMountSnapshot(ctx context.Context, network string, client domain.ExecutionClientInfo) error {
-	// Get latest block number first
-	latestBlockNumber, err := s.snapshots.GetLatestBlockNumber(ctx, network, client.ShortName)
-	if err != nil {
-		return fmt.Errorf("failed to get latest block number: %w", err)
-	}
-
 	// 1. Stop the container (if running) - ignore errors as container might not exist
 	_ = s.docker.StopContainer(ctx, client.ContainerName)
 
@@ -78,11 +45,6 @@ func (s *SnapshotManagerAdapter) DownloadAndMountSnapshot(ctx context.Context, n
 		return fmt.Errorf("failed to download and extract snapshot: %w", err)
 	}
 
-	// 3. Write block number file
-	if err := s.blockNumber.WriteBlockNumber(ctx, latestBlockNumber); err != nil {
-		return fmt.Errorf("failed to write block number: %w", err)
-	}
-
 	return nil
 }
 
diff --git a/internal/application/ports/blockNumber_port.go b/internal/application/ports/blockNumber_port.go
new file mode 100644
index 0000000..979ca8b
--- /dev/null
+++ b/internal/application/ports/blockNumber_port.go
@@ -0,0 +1,20 @@
+package ports
+
+import "context"
+
+// BlockNumber defines the interface for block number tracking operations
+// Used to track the current snapshot block number and compare with available snapshots
+type BlockNumber interface {
+	// ReadBlockNumber reads the current block number from storage
+	// Returns empty string if no block number file exists
+	ReadBlockNumber(ctx context.Context) (string, error)
+
+	// WriteBlockNumber writes the block number to storage
+	WriteBlockNumber(ctx context.Context, blockNumber string) error
+
+	// BlockNumberExists checks if a block number file exists
+	BlockNumberExists(ctx context.Context) (bool, error)
+
+	// IsNewerSnapshot checks if the latest available block number is newer than the current one
+	IsNewerSnapshot(ctx context.Context, latestBlockNumber string) (bool, error)
+}
diff --git a/internal/application/ports/snapshotChecker_port.go b/internal/application/ports/snapshotChecker_port.go
index 689c77f..32cf59b 100644
--- a/internal/application/ports/snapshotChecker_port.go
+++ b/internal/application/ports/snapshotChecker_port.go
@@ -8,10 +8,6 @@ import (
 // SnapshotManager defines the interface for snapshot management operations
 // This is the port that the snapshot checker service uses to interact with snapshot infrastructure
 type SnapshotManager interface {
-	// NeedsSnapshotDownload determines if a snapshot needs to be downloaded for the given client
-	// Returns true if no snapshot exists or if a newer snapshot is available
-	NeedsSnapshotDownload(ctx context.Context, client domain.ExecutionClientInfo, latestBlockNumber string) (bool, error)
-
 	// DownloadAndMountSnapshot performs the complete snapshot download and mount process
 	DownloadAndMountSnapshot(ctx context.Context, network string, client domain.ExecutionClientInfo) error
 
diff --git a/internal/application/services/snapshot_checker.go b/internal/application/services/snapshot_checker.go
index 69ffd28..d0751f8 100644
--- a/internal/application/services/snapshot_checker.go
+++ b/internal/application/services/snapshot_checker.go
@@ -16,6 +16,7 @@ type SnapshotCheckerService struct {
 	snapshotManager  ports.SnapshotManager
 	downloadProgress ports.DownloadProgress
 	testProgress     ports.TestProgress
+	blockNumber      ports.BlockNumber
 	config           domain.SnapshotCheckerConfig
 }
 
@@ -24,12 +25,14 @@ func NewSnapshotCheckerService(
 	snapshotManager ports.SnapshotManager,
 	downloadProgress ports.DownloadProgress,
 	testProgress ports.TestProgress,
+	blockNumber ports.BlockNumber,
 	config domain.SnapshotCheckerConfig,
 ) *SnapshotCheckerService {
 	return &SnapshotCheckerService{
 		snapshotManager:  snapshotManager,
 		downloadProgress: downloadProgress,
 		testProgress:     testProgress,
+		blockNumber:      blockNumber,
 		config:           config,
 	}
 }
@@ -119,11 +122,11 @@ func (s *SnapshotCheckerService) checkAndUpdateClient(ctx context.Context, clien
 	if err != nil {
 		return fmt.Errorf("failed to get latest block number: %w", err)
 	}
-	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Latest available snapshot: block %s", client.ShortName, latestBlockNumber)
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Latest available snapshot block: %s", client.ShortName, latestBlockNumber)
 
-	// Check if we need to download
-	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Checking if snapshot download is needed...", client.ShortName)
-	needsDownload, err := s.snapshotManager.NeedsSnapshotDownload(ctx, client, latestBlockNumber)
+	// Check if we need to download by reading current block number
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Checking current snapshot block number...", client.ShortName)
+	needsDownload, err := s.checkNeedsSnapshotDownload(ctx, client, latestBlockNumber)
 	if err != nil {
 		return fmt.Errorf("failed to check if snapshot needed: %w", err)
 	}
@@ -161,12 +164,58 @@ func (s *SnapshotCheckerService) checkAndUpdateClient(ctx context.Context, clien
 		return fmt.Errorf("failed to download and mount snapshot: %w", err)
 	}
 
+	// Write block number file after successful download
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Writing snapshot block number: %s", client.ShortName, latestBlockNumber)
+	if err := s.blockNumber.WriteBlockNumber(ctx, latestBlockNumber); err != nil {
+		return fmt.Errorf("failed to write block number: %w", err)
+	}
+
 	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] ✓ Snapshot download completed successfully", client.ShortName)
 	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Total time: %s", client.ShortName, elapsed.Round(time.Second))
 
 	return nil
 }
 
+// checkNeedsSnapshotDownload determines if a snapshot needs to be downloaded
+// by reading the current block number and comparing with the latest available
+// Logs clearly the current and latest block numbers for visibility
+func (s *SnapshotCheckerService) checkNeedsSnapshotDownload(ctx context.Context, client domain.ExecutionClientInfo, latestBlockNumber string) (bool, error) {
+	// Check if block number file exists
+	exists, err := s.blockNumber.BlockNumberExists(ctx)
+	if err != nil {
+		return false, fmt.Errorf("failed to check if block number exists: %w", err)
+	}
+
+	if !exists {
+		logger.InfoWithPrefix(snapshotLogPrefix, "[%s] No snapshot block number file found - download required", client.ShortName)
+		return true, nil
+	}
+
+	// Read current block number
+	currentBlockNumber, err := s.blockNumber.ReadBlockNumber(ctx)
+	if err != nil {
+		return false, fmt.Errorf("failed to read current block number: %w", err)
+	}
+
+	// Log both block numbers clearly
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Current snapshot block: %s", client.ShortName, currentBlockNumber)
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Latest available block: %s", client.ShortName, latestBlockNumber)
+
+	// Check if newer snapshot is available
+	isNewer, err := s.blockNumber.IsNewerSnapshot(ctx, latestBlockNumber)
+	if err != nil {
+		return false, fmt.Errorf("failed to compare block numbers: %w", err)
+	}
+
+	if isNewer {
+		logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Newer snapshot available (%s > %s) - download required", client.ShortName, latestBlockNumber, currentBlockNumber)
+	} else {
+		logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Current snapshot is up to date (current: %s, latest: %s)", client.ShortName, currentBlockNumber, latestBlockNumber)
+	}
+
+	return isNewer, nil
+}
+
 // StopAllDownloads stops all running download containers (for graceful shutdown)
 func (s *SnapshotCheckerService) StopAllDownloads(ctx context.Context) {
 	logger.InfoWithPrefix(snapshotLogPrefix, "Stopping all snapshot download containers...")

From d78e4a8677f6de1501ddd9916edbae6928abfda3 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 23 Jan 2026 08:33:12 +0100
Subject: [PATCH 33/42] add docker dev

---
 Dockerfile.snapshot-checker                  | 30 ++++++++++++++++++++
 Dockerfile => Dockerfile.test-runner         |  8 +++---
 docker-compose.yml => docker-compose-dev.yml | 24 ++++++++++++++--
 3 files changed, 55 insertions(+), 7 deletions(-)
 create mode 100644 Dockerfile.snapshot-checker
 rename Dockerfile => Dockerfile.test-runner (69%)
 rename docker-compose.yml => docker-compose-dev.yml (53%)

diff --git a/Dockerfile.snapshot-checker b/Dockerfile.snapshot-checker
new file mode 100644
index 0000000..0f5ee66
--- /dev/null
+++ b/Dockerfile.snapshot-checker
@@ -0,0 +1,30 @@
+# Build stage
+FROM golang:1.24-alpine AS builder
+
+WORKDIR /app
+
+# Install git for fetching dependencies
+RUN apk add --no-cache git
+
+# Copy go mod files first for better caching
+COPY go.mod go.sum ./
+RUN go mod download
+
+# Copy source code
+COPY . .
+
+# Build the snapshot-checker application
+RUN CGO_ENABLED=0 GOOS=linux go build -o /app/snapshot-checker ./cmd/snapshot-checker
+
+# Final stage
+FROM alpine:latest
+
+WORKDIR /app
+
+# Install ca-certificates for HTTPS requests and docker-cli for snapshot operations
+RUN apk add --no-cache ca-certificates docker-cli
+
+# Copy binary from builder
+COPY --from=builder /app/snapshot-checker /app/snapshot-checker
+
+ENTRYPOINT ["/app/snapshot-checker"]
diff --git a/Dockerfile b/Dockerfile.test-runner
similarity index 69%
rename from Dockerfile
rename to Dockerfile.test-runner
index 6da1b6f..1073785 100644
--- a/Dockerfile
+++ b/Dockerfile.test-runner
@@ -13,8 +13,8 @@ RUN go mod download
 # Copy source code
 COPY . .
 
-# Build the application
-RUN CGO_ENABLED=0 GOOS=linux go build -o /app/staker-test-util ./cmd/main.go
+# Build the test-runner application
+RUN CGO_ENABLED=0 GOOS=linux go build -o /app/test-runner ./cmd/test-runner
 
 # Final stage
 FROM alpine:latest
@@ -25,6 +25,6 @@ WORKDIR /app
 RUN apk add --no-cache ca-certificates docker-cli
 
 # Copy binary from builder
-COPY --from=builder /app/staker-test-util /app/staker-test-util
+COPY --from=builder /app/test-runner /app/test-runner
 
-ENTRYPOINT ["/app/staker-test-util"]
+ENTRYPOINT ["/app/test-runner"]
diff --git a/docker-compose.yml b/docker-compose-dev.yml
similarity index 53%
rename from docker-compose.yml
rename to docker-compose-dev.yml
index 990c855..36cf4c3 100644
--- a/docker-compose.yml
+++ b/docker-compose-dev.yml
@@ -1,11 +1,29 @@
 services:
-  staker-test-util:
+  snapshot-checker:
     build:
       context: .
-      dockerfile: Dockerfile
-    container_name: staker-test-util
+      dockerfile: Dockerfile.snapshot-checker
+    container_name: snapshot-checker
     volumes:
       - /var/run/docker.sock:/var/run/docker.sock
+      - /var/lib/docker/volumes:/var/lib/docker/volumes
+    environment:
+      - LOG_LEVEL=DEBUG
+      - EXECUTION_CLIENT=${EXECUTION_CLIENT:-geth}
+      - NETWORK=${NETWORK:-hoodi}
+      - CRON_INTERVAL_SEC=${CRON_INTERVAL_SEC:-21600}
+      - RUN_ONCE=${RUN_ONCE:-false}
+    networks:
+      - dncore_network
+
+  test-runner:
+    build:
+      context: .
+      dockerfile: Dockerfile.test-runner
+    container_name: test-runner
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - /var/lib/docker/volumes:/var/lib/docker/volumes
     environment:
       - LOG_LEVEL=DEBUG
       - IPFS_GATEWAY_URL=http://ipfs.dappnode:8080

From a00c5028894c8824b404eaa039c38292606d182b Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 23 Jan 2026 08:38:12 +0100
Subject: [PATCH 34/42] set tunonce to true

---
 docker-compose-dev.yml                        |  2 +-
 .../application/services/snapshot_checker.go  | 21 +++++--------------
 2 files changed, 6 insertions(+), 17 deletions(-)

diff --git a/docker-compose-dev.yml b/docker-compose-dev.yml
index 36cf4c3..f1ec30f 100644
--- a/docker-compose-dev.yml
+++ b/docker-compose-dev.yml
@@ -12,7 +12,7 @@ services:
       - EXECUTION_CLIENT=${EXECUTION_CLIENT:-geth}
       - NETWORK=${NETWORK:-hoodi}
       - CRON_INTERVAL_SEC=${CRON_INTERVAL_SEC:-21600}
-      - RUN_ONCE=${RUN_ONCE:-false}
+      - RUN_ONCE=${RUN_ONCE:-true}
     networks:
       - dncore_network
 
diff --git a/internal/application/services/snapshot_checker.go b/internal/application/services/snapshot_checker.go
index d0751f8..a33699c 100644
--- a/internal/application/services/snapshot_checker.go
+++ b/internal/application/services/snapshot_checker.go
@@ -49,7 +49,7 @@ func (s *SnapshotCheckerService) Start(ctx context.Context, runOnce bool) error
 
 	// Run immediately on startup
 	logger.InfoWithPrefix(snapshotLogPrefix, "Running initial snapshot check...")
-	if err := s.CheckAndUpdateSnapshots(ctx); err != nil {
+	if err := s.checkAndUpdateSnapshot(ctx); err != nil {
 		logger.ErrorWithPrefix(snapshotLogPrefix, "Initial snapshot check failed: %v", err)
 		return err
 	}
@@ -73,7 +73,7 @@ func (s *SnapshotCheckerService) Start(ctx context.Context, runOnce bool) error
 			return ctx.Err()
 		case <-ticker.C:
 			logger.InfoWithPrefix(snapshotLogPrefix, "Running scheduled snapshot check...")
-			if err := s.CheckAndUpdateSnapshots(ctx); err != nil {
+			if err := s.checkAndUpdateSnapshot(ctx); err != nil {
 				logger.ErrorWithPrefix(snapshotLogPrefix, "Scheduled snapshot check failed: %v", err)
 				// Continue running even on failure
 			}
@@ -81,21 +81,9 @@ func (s *SnapshotCheckerService) Start(ctx context.Context, runOnce bool) error
 	}
 }
 
-// CheckAndUpdateSnapshots checks the configured client and updates snapshot if needed
-func (s *SnapshotCheckerService) CheckAndUpdateSnapshots(ctx context.Context) error {
+// checkAndUpdateSnapshot checks the configured client and updates snapshot if needed
+func (s *SnapshotCheckerService) checkAndUpdateSnapshot(ctx context.Context) error {
 	client := s.config.ExecutionClient
-	logger.InfoWithPrefix(snapshotLogPrefix, "Checking snapshot for client: %s", client.ShortName)
-
-	if err := s.checkAndUpdateClient(ctx, client); err != nil {
-		return fmt.Errorf("client %s: %w", client.ShortName, err)
-	}
-
-	logger.InfoWithPrefix(snapshotLogPrefix, "Snapshot check completed successfully")
-	return nil
-}
-
-// checkAndUpdateClient checks a single client and updates snapshot if needed
-func (s *SnapshotCheckerService) checkAndUpdateClient(ctx context.Context, client domain.ExecutionClientInfo) error {
 	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Checking client (%s)", client.ShortName, client.DnpName)
 
 	// Wait for any ongoing tests to complete before proceeding with this client
@@ -173,6 +161,7 @@ func (s *SnapshotCheckerService) checkAndUpdateClient(ctx context.Context, clien
 	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] ✓ Snapshot download completed successfully", client.ShortName)
 	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Total time: %s", client.ShortName, elapsed.Round(time.Second))
 
+	logger.InfoWithPrefix(snapshotLogPrefix, "Snapshot check completed successfully")
 	return nil
 }
 

From 6217edd84f1183dabefdfd45ae5efa8667192904 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 23 Jan 2026 08:41:34 +0100
Subject: [PATCH 35/42] implement single stop download

---
 cmd/snapshot-checker/main.go                  |  4 +--
 .../snapshotmanager/snapshotmanager.go        | 26 +++----------------
 .../application/ports/snapshotChecker_port.go |  4 +--
 .../application/services/snapshot_checker.go  | 11 ++++----
 4 files changed, 14 insertions(+), 31 deletions(-)

diff --git a/cmd/snapshot-checker/main.go b/cmd/snapshot-checker/main.go
index bb5625c..a4ef6c9 100644
--- a/cmd/snapshot-checker/main.go
+++ b/cmd/snapshot-checker/main.go
@@ -92,8 +92,8 @@ func main() {
 	go func() {
 		sig := <-sigs
 		logger.InfoWithPrefix(logPrefix, "Received signal: %v, shutting down...", sig)
-		// Stop any running download containers using the service method
-		service.StopAllDownloads(context.Background())
+		// Stop any running download container using the service method
+		service.StopDownload(context.Background())
 		// Best-effort cleanup: clear marker file so next run isn't blocked.
 		service.ClearDownloadMarker(context.Background())
 		cancel()
diff --git a/internal/adapters/composite/snapshotmanager/snapshotmanager.go b/internal/adapters/composite/snapshotmanager/snapshotmanager.go
index 240d85b..c192831 100644
--- a/internal/adapters/composite/snapshotmanager/snapshotmanager.go
+++ b/internal/adapters/composite/snapshotmanager/snapshotmanager.go
@@ -3,7 +3,6 @@ package snapshotmanager
 import (
 	"context"
 	"fmt"
-	"sync"
 
 	"clients-test/internal/adapters/apis/docker"
 	"clients-test/internal/adapters/apis/snapshots"
@@ -53,25 +52,8 @@ func (s *SnapshotManagerAdapter) GetLatestBlockNumber(ctx context.Context, netwo
 	return s.snapshots.GetLatestBlockNumber(ctx, network, client)
 }
 
-// StopAllDownloads stops all running snapshot download containers in parallel
-func (s *SnapshotManagerAdapter) StopAllDownloads(ctx context.Context) {
-	containerIDs, err := s.docker.ListContainersByPrefix(ctx, downloadContainerPrefix)
-	if err != nil {
-		return
-	}
-
-	if len(containerIDs) == 0 {
-		return
-	}
-
-	// Stop all containers in parallel
-	var wg sync.WaitGroup
-	for _, id := range containerIDs {
-		wg.Add(1)
-		go func(containerID string) {
-			defer wg.Done()
-			_ = s.docker.StopContainerWithTimeout(ctx, containerID, 5)
-		}(id)
-	}
-	wg.Wait()
+// StopDownload stops the snapshot download container for a specific client
+func (s *SnapshotManagerAdapter) StopDownload(ctx context.Context, clientShortName string) {
+	containerName := fmt.Sprintf("%s%s", downloadContainerPrefix, clientShortName)
+	_ = s.docker.StopContainerWithTimeout(ctx, containerName, 5)
 }
diff --git a/internal/application/ports/snapshotChecker_port.go b/internal/application/ports/snapshotChecker_port.go
index 32cf59b..3c1773b 100644
--- a/internal/application/ports/snapshotChecker_port.go
+++ b/internal/application/ports/snapshotChecker_port.go
@@ -14,6 +14,6 @@ type SnapshotManager interface {
 	// GetLatestBlockNumber fetches the latest available block number for a client
 	GetLatestBlockNumber(ctx context.Context, network, client string) (string, error)
 
-	// StopAllDownloads stops all running snapshot download containers
-	StopAllDownloads(ctx context.Context)
+	// StopDownload stops the snapshot download container for a specific client
+	StopDownload(ctx context.Context, clientShortName string)
 }
diff --git a/internal/application/services/snapshot_checker.go b/internal/application/services/snapshot_checker.go
index a33699c..3ae2616 100644
--- a/internal/application/services/snapshot_checker.go
+++ b/internal/application/services/snapshot_checker.go
@@ -205,11 +205,12 @@ func (s *SnapshotCheckerService) checkNeedsSnapshotDownload(ctx context.Context,
 	return isNewer, nil
 }
 
-// StopAllDownloads stops all running download containers (for graceful shutdown)
-func (s *SnapshotCheckerService) StopAllDownloads(ctx context.Context) {
-	logger.InfoWithPrefix(snapshotLogPrefix, "Stopping all snapshot download containers...")
-	s.snapshotManager.StopAllDownloads(ctx)
-	logger.InfoWithPrefix(snapshotLogPrefix, "All download containers stopped")
+// StopDownload stops the current download container (for graceful shutdown)
+func (s *SnapshotCheckerService) StopDownload(ctx context.Context) {
+	clientName := s.config.ExecutionClient.ShortName
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Stopping snapshot download container...", clientName)
+	s.snapshotManager.StopDownload(ctx, clientName)
+	logger.InfoWithPrefix(snapshotLogPrefix, "[%s] Download container stopped", clientName)
 }
 
 // ClearDownloadMarker clears the download in progress marker

From bf33a0d2b2dcef4e41f9d9ae0acc4ef961baa7bd Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 23 Jan 2026 08:53:26 +0100
Subject: [PATCH 36/42] implement client overrides

---
 cmd/test-runner/main.go                |  13 ++-
 internal/application/domain/stakers.go | 132 ++++++++++++++++++++++---
 internal/config/test_runner_config.go  |  18 +++-
 3 files changed, 140 insertions(+), 23 deletions(-)

diff --git a/cmd/test-runner/main.go b/cmd/test-runner/main.go
index 6c12ed0..43f6631 100644
--- a/cmd/test-runner/main.go
+++ b/cmd/test-runner/main.go
@@ -47,8 +47,17 @@ func main() {
 		logger.FatalWithPrefix(logPrefix, "Failed to get dnpName from IPFS hash: %v", err)
 	}
 
-	// Retrieve staker config based on pkg (dnpName and serviceName)
-	stakerConfig := domain.StakerConfigForNetwork(pkg)
+	// Retrieve staker config based on pkg (dnpName and serviceName) with optional overrides
+	overrides := domain.ClientOverrides{
+		ExecutionClient: cfg.ExecutionClient,
+		ConsensusClient: cfg.ConsensusClient,
+	}
+	stakerConfig, warnings := domain.StakerConfigForNetwork(pkg, overrides)
+
+	// Log any warnings from client resolution
+	for _, warning := range warnings {
+		logger.WarnWithPrefix(logPrefix, "%s", warning)
+	}
 
 	// print the staker config for debugging with each item on a new line
 	printStakerConfig(logPrefix, stakerConfig)
diff --git a/internal/application/domain/stakers.go b/internal/application/domain/stakers.go
index 6c11b8a..531c495 100644
--- a/internal/application/domain/stakers.go
+++ b/internal/application/domain/stakers.go
@@ -30,13 +30,30 @@ type Urls struct {
 	DappmanagerURL string
 }
 
+// ClientOverrides holds optional client override settings
+type ClientOverrides struct {
+	ExecutionClient string // Short name like "geth", "reth", etc.
+	ConsensusClient string // Short name like "prysm", "teku", etc.
+}
+
+// ClientOverrideResult holds the result of applying overrides with any warnings
+type ClientOverrideResult struct {
+	ExecutionDnpName string
+	ConsensusDnpName string
+	Warnings         []string
+}
+
 const dappmanagerURL = "http://dappmanager.dappnode:7000"
 
-func StakerConfigForNetwork(pkg Pkg) StakerConfig {
+// hoodi network client lists
+var (
+	hoodiExecClients = []string{"hoodi-reth.dnp.dappnode.eth", "hoodi-geth.dnp.dappnode.eth", "hoodi-besu.dnp.dappnode.eth", "hoodi-erigon.dnp.dappnode.eth", "hoodi-nethermind.dnp.dappnode.eth"}
+	hoodiConsClients = []string{"prysm-hoodi.dnp.dappnode.eth", "teku-hoodi.dnp.dappnode.eth", "nimbus-hoodi.dnp.dappnode.eth", "lodestar-hoodi.dnp.dappnode.eth"}
+)
+
+func StakerConfigForNetwork(pkg Pkg, overrides ClientOverrides) (StakerConfig, []string) {
 	// Only hoodi network is supported
 	network := "hoodi"
-	execClients := []string{"hoodi-reth.dnp.dappnode.eth", "hoodi-geth.dnp.dappnode.eth", "hoodi-besu.dnp.dappnode.eth", "hoodi-erigon.dnp.dappnode.eth", "hoodi-nethermind.dnp.dappnode.eth"}
-	consClients := []string{"prysm-hoodi.dnp.dappnode.eth", "teku-hoodi.dnp.dappnode.eth", "nimbus-hoodi.dnp.dappnode.eth", "lodestar-hoodi.dnp.dappnode.eth"}
 	web3signer := "web3signer-hoodi.dnp.dappnode.eth"
 	mevboost := "mev-boost-hoodi.dnp.dappnode.eth"
 	relays := []string{}
@@ -47,8 +64,11 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 		DappmanagerURL: dappmanagerURL,
 	}
 
-	ecDnpName := matchOrRandom(pkg.DnpName, execClients)
-	ccDnpName := matchOrRandom(pkg.DnpName, consClients)
+	// Resolve execution and consensus clients with override logic
+	result := resolveClientsWithOverrides(pkg, overrides, hoodiExecClients, hoodiConsClients)
+
+	ecDnpName := result.ExecutionDnpName
+	ccDnpName := result.ConsensusDnpName
 
 	serviceName := serviceNameFromExecutionClient(ecDnpName, network)
 	volumeName := getExecutionVolumeName(ecDnpName, serviceName)
@@ -67,30 +87,110 @@ func StakerConfigForNetwork(pkg Pkg) StakerConfig {
 		ValidatorContainerName:    containerName("validator", ccDnpName),
 		ExecutionContainerName:    containerName(serviceName, ecDnpName),
 		ExecutionVolumeTargetPath: fmt.Sprintf("/var/lib/docker/volumes/%s/_data", volumeName),
-	}
+	}, result.Warnings
 }
 
-// getExecutionVolumeName returns the docker volume name for the execution client
-// reth and geth use their service name as volume name, others use "data"
-func getExecutionVolumeName(dnpName, serviceName string) string {
-	var volumeArg string
-	if serviceName == "geth" || serviceName == "reth" {
-		volumeArg = serviceName
+// resolveClientsWithOverrides determines execution and consensus clients based on:
+// 1. If pkg matches an execution/consensus client, use it (overriding any flag/env with warning)
+// 2. Otherwise, use the override if provided
+// 3. Otherwise, pick a random client
+func resolveClientsWithOverrides(pkg Pkg, overrides ClientOverrides, execClients, consClients []string) ClientOverrideResult {
+	result := ClientOverrideResult{}
+
+	// Check if pkg is an execution client
+	pkgMatchedExec := matchClient(pkg.DnpName, execClients)
+	// Check if pkg is a consensus client
+	pkgMatchedCons := matchClient(pkg.DnpName, consClients)
+
+	// Resolve execution client
+	if pkgMatchedExec != "" {
+		// Pkg is an execution client - use it
+		if overrides.ExecutionClient != "" {
+			result.Warnings = append(result.Warnings,
+				fmt.Sprintf("Package '%s' is an execution client; ignoring --execution-client flag '%s'",
+					pkg.DnpName, overrides.ExecutionClient))
+		}
+		result.ExecutionDnpName = pkgMatchedExec
+	} else if overrides.ExecutionClient != "" {
+		// Use override if provided
+		matched := matchClientByShortName(overrides.ExecutionClient, execClients)
+		if matched != "" {
+			result.ExecutionDnpName = matched
+		} else {
+			result.Warnings = append(result.Warnings,
+				fmt.Sprintf("Unknown execution client '%s'; using random", overrides.ExecutionClient))
+			result.ExecutionDnpName = randomClient(execClients)
+		}
 	} else {
-		volumeArg = "data"
+		// Pick random
+		result.ExecutionDnpName = randomClient(execClients)
 	}
-	return composeVolumeName(dnpName, volumeArg)
+
+	// Resolve consensus client
+	if pkgMatchedCons != "" {
+		// Pkg is a consensus client - use it
+		if overrides.ConsensusClient != "" {
+			result.Warnings = append(result.Warnings,
+				fmt.Sprintf("Package '%s' is a consensus client; ignoring --consensus-client flag '%s'",
+					pkg.DnpName, overrides.ConsensusClient))
+		}
+		result.ConsensusDnpName = pkgMatchedCons
+	} else if overrides.ConsensusClient != "" {
+		// Use override if provided
+		matched := matchClientByShortName(overrides.ConsensusClient, consClients)
+		if matched != "" {
+			result.ConsensusDnpName = matched
+		} else {
+			result.Warnings = append(result.Warnings,
+				fmt.Sprintf("Unknown consensus client '%s'; using random", overrides.ConsensusClient))
+			result.ConsensusDnpName = randomClient(consClients)
+		}
+	} else {
+		// Pick random
+		result.ConsensusDnpName = randomClient(consClients)
+	}
+
+	return result
+}
+
+// matchClient returns the matching client dnpName if found, empty string otherwise
+func matchClient(dnpName string, candidates []string) string {
+	for _, c := range candidates {
+		if strings.Contains(dnpName, c) || strings.Contains(c, dnpName) {
+			return c
+		}
+	}
+	return ""
 }
 
-func matchOrRandom(dnpName string, candidates []string) string {
+// matchClientByShortName matches a short name (e.g., "geth", "prysm") to a full dnpName
+func matchClientByShortName(shortName string, candidates []string) string {
+	shortName = strings.ToLower(shortName)
 	for _, c := range candidates {
-		if strings.Contains(dnpName, c) {
+		if strings.Contains(strings.ToLower(c), shortName) {
 			return c
 		}
 	}
+	return ""
+}
+
+// randomClient picks a random client from the list
+func randomClient(candidates []string) string {
 	if len(candidates) == 0 {
 		return ""
 	}
 	r := rand.New(rand.NewSource(time.Now().UnixNano()))
 	return candidates[r.Intn(len(candidates))]
 }
+
+// getExecutionVolumeName returns the docker volume name for the execution client
+// reth and geth use their service name as volume name, others use "data"
+func getExecutionVolumeName(dnpName, serviceName string) string {
+	var volumeArg string
+	if serviceName == "geth" || serviceName == "reth" {
+		volumeArg = serviceName
+	} else {
+		volumeArg = "data"
+	}
+	return composeVolumeName(dnpName, volumeArg)
+}
diff --git a/internal/config/test_runner_config.go b/internal/config/test_runner_config.go
index 82c3ccf..907ec9f 100644
--- a/internal/config/test_runner_config.go
+++ b/internal/config/test_runner_config.go
@@ -11,9 +11,11 @@ var logPrefix = "Config"
 
 // Config holds all application configuration
 type Config struct {
-	IPFSGatewayURL string
-	IPFSHash       string
-	GitHub         github.GitHubConfig
+	IPFSGatewayURL  string
+	IPFSHash        string
+	ExecutionClient string // Optional: override execution client (e.g., geth, reth, nethermind)
+	ConsensusClient string // Optional: override consensus client (e.g., prysm, teku, nimbus, lodestar)
+	GitHub          github.GitHubConfig
 }
 
 // ParseConfig parses CLI flags and environment variables into a Config struct
@@ -22,6 +24,10 @@ func ParseConfig() Config {
 	ipfsGatewayUrl := flag.String("ipfs-gateway-url", "", "IPFS gateway URL (required, or set IPFS_GATEWAY_URL env)")
 	ipfsHash := flag.String("ipfs-hash", "", "IPFS hash for the test package (required, or set IPFS_HASH env)")
 
+	// Optional client override flags
+	executionClient := flag.String("execution-client", "", "Override execution client (geth, reth, nethermind, besu, erigon) (or set EXECUTION_CLIENT env)")
+	consensusClient := flag.String("consensus-client", "", "Override consensus client (prysm, teku, nimbus, lodestar) (or set CONSENSUS_CLIENT env)")
+
 	// GitHub flags (optional, for PR commenting)
 	githubToken := flag.String("github-token", "", "GitHub token for PR commenting (or set GITHUB_TOKEN env)")
 	githubRepository := flag.String("github-repository", "", "GitHub repository in format owner/repo (or set GITHUB_REPOSITORY env)")
@@ -33,8 +39,10 @@ func ParseConfig() Config {
 
 	// Build config with flag values, falling back to environment variables
 	config := Config{
-		IPFSGatewayURL: getConfigValue(*ipfsGatewayUrl, "IPFS_GATEWAY_URL", ""),
-		IPFSHash:       getConfigValue(*ipfsHash, "IPFS_HASH", ""),
+		IPFSGatewayURL:  getConfigValue(*ipfsGatewayUrl, "IPFS_GATEWAY_URL", ""),
+		IPFSHash:        getConfigValue(*ipfsHash, "IPFS_HASH", ""),
+		ExecutionClient: getConfigValue(*executionClient, "EXECUTION_CLIENT", ""),
+		ConsensusClient: getConfigValue(*consensusClient, "CONSENSUS_CLIENT", ""),
 		GitHub: github.ParseGitHubConfigFromEnv(
 			getConfigValue(*githubToken, "GITHUB_TOKEN", ""),
 			getConfigValue(*githubRepository, "GITHUB_REPOSITORY", ""),

From a417e8d06eedd3d67b92a31d278aa30fda37d686 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 23 Jan 2026 08:55:00 +0100
Subject: [PATCH 37/42] add missin envs to compose dev file

---
 docker-compose-dev.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/docker-compose-dev.yml b/docker-compose-dev.yml
index f1ec30f..d938996 100644
--- a/docker-compose-dev.yml
+++ b/docker-compose-dev.yml
@@ -28,6 +28,8 @@ services:
       - LOG_LEVEL=DEBUG
       - IPFS_GATEWAY_URL=http://ipfs.dappnode:8080
       - IPFS_HASH=QmSfPFSauovbMzEcvf2a2csoHtfqpViShwEYpuX3fPR8zv
+      - EXECUTION_CLIENT=${EXECUTION_CLIENT:-geth}
+      - CONSENSUS_CLIENT=${CONSENSUS_CLIENT:-nimbus}
       # GitHub integration (optional - for PR commenting)
       - GITHUB_TOKEN=${GITHUB_TOKEN:-}
       - GITHUB_REPOSITORY=${GITHUB_REPOSITORY:-}

From db64796c8d7ef41cdc297c2805a13e0783e148a9 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 23 Jan 2026 09:19:42 +0100
Subject: [PATCH 38/42] first implementation of CI

---
 .github/workflows/build-and-push.yml      | 69 +++++++++++++++++
 .github/workflows/release.yml             | 69 +++++++++++++++++
 README.md                                 | 90 ++++++++++++++++++++---
 examples/workflows/complete-staker-ci.yml | 77 +++++++++++++++++++
 examples/workflows/snapshot-checker.yml   | 58 +++++++++++++++
 examples/workflows/staker-test.yml        | 53 +++++++++++++
 6 files changed, 407 insertions(+), 9 deletions(-)
 create mode 100644 .github/workflows/build-and-push.yml
 create mode 100644 .github/workflows/release.yml
 create mode 100644 examples/workflows/complete-staker-ci.yml
 create mode 100644 examples/workflows/snapshot-checker.yml
 create mode 100644 examples/workflows/staker-test.yml

diff --git a/.github/workflows/build-and-push.yml b/.github/workflows/build-and-push.yml
new file mode 100644
index 0000000..fe1fd8e
--- /dev/null
+++ b/.github/workflows/build-and-push.yml
@@ -0,0 +1,69 @@
+name: Build and Push Docker Images
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - 'v*'
+  pull_request:
+    branches:
+      - main
+
+env:
+  REGISTRY: ghcr.io
+  IMAGE_PREFIX: ${{ github.repository }}
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    strategy:
+      matrix:
+        include:
+          - name: test-runner
+            dockerfile: Dockerfile.test-runner
+          - name: snapshot-checker
+            dockerfile: Dockerfile.snapshot-checker
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to Container Registry
+        if: github.event_name != 'pull_request'
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Extract metadata (tags, labels)
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_PREFIX }}/${{ matrix.name }}
+          tags: |
+            type=ref,event=branch
+            type=ref,event=pr
+            type=semver,pattern={{version}}
+            type=semver,pattern={{major}}.{{minor}}
+            type=sha,prefix=
+            type=raw,value=latest,enable={{is_default_branch}}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ${{ matrix.dockerfile }}
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..8119eb5
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,69 @@
+name: Release Binaries
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  build-binaries:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - goos: linux
+            goarch: amd64
+          - goos: linux
+            goarch: arm64
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.24'
+
+      - name: Build test-runner
+        env:
+          GOOS: ${{ matrix.goos }}
+          GOARCH: ${{ matrix.goarch }}
+          CGO_ENABLED: 0
+        run: |
+          go build -o test-runner-${{ matrix.goos }}-${{ matrix.goarch }} ./cmd/test-runner
+
+      - name: Build snapshot-checker
+        env:
+          GOOS: ${{ matrix.goos }}
+          GOARCH: ${{ matrix.goarch }}
+          CGO_ENABLED: 0
+        run: |
+          go build -o snapshot-checker-${{ matrix.goos }}-${{ matrix.goarch }} ./cmd/snapshot-checker
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: binaries-${{ matrix.goos }}-${{ matrix.goarch }}
+          path: |
+            test-runner-${{ matrix.goos }}-${{ matrix.goarch }}
+            snapshot-checker-${{ matrix.goos }}-${{ matrix.goarch }}
+
+  release:
+    needs: build-binaries
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: binaries
+          merge-multiple: true
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v1
+        with:
+          files: binaries/*
+          generate_release_notes: true
diff --git a/README.md b/README.md
index 78219b8..cdf8d6e 100644
--- a/README.md
+++ b/README.md
@@ -9,15 +9,80 @@ A testing utility for Dappnode staker packages that runs in GitHub self-hosted r
 - **Timing Measurements**: Measures duration of all test phases (setup, execution, cleanup)
 - **Container Log Collection**: Captures error logs from all relevant containers during test execution
 - **Detailed Reports**: Generates comprehensive reports with clients used, timings, and error logs
+- **Snapshot Management**: Automatically downloads and manages execution client snapshots
+
+## Quick Start (CI Usage)
+
+### Using Docker Images from GHCR
+
+Docker images are automatically published to GitHub Container Registry on every push to main and on releases.
+
+```bash
+# Test Runner
+ghcr.io/dappnode/staker-test-util/test-runner:latest
+
+# Snapshot Checker
+ghcr.io/dappnode/staker-test-util/snapshot-checker:latest
+```
+
+### Test Runner in GitHub Actions
+
+```yaml
+- name: Run Staker Tests
+  run: |
+    docker run --rm \
+      --network dncore_network \
+      -v /var/run/docker.sock:/var/run/docker.sock \
+      -v /var/lib/docker/volumes:/var/lib/docker/volumes \
+      -e IPFS_GATEWAY_URL=http://ipfs.dappnode:8080 \
+      -e IPFS_HASH=${{ env.IPFS_HASH }} \
+      -e EXECUTION_CLIENT=geth \
+      -e CONSENSUS_CLIENT=nimbus \
+      -e GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }} \
+      -e GITHUB_REPOSITORY=${{ github.repository }} \
+      -e GITHUB_PR_NUMBER=${{ github.event.pull_request.number }} \
+      ghcr.io/dappnode/staker-test-util/test-runner:latest
+```
+
+### Snapshot Checker in GitHub Actions
+
+```yaml
+- name: Ensure Snapshot Available
+  run: |
+    docker run --rm \
+      -v /var/run/docker.sock:/var/run/docker.sock \
+      -v /var/lib/docker/volumes:/var/lib/docker/volumes \
+      -e EXECUTION_CLIENT=geth \
+      -e NETWORK=hoodi \
+      -e RUN_ONCE=true \
+      ghcr.io/dappnode/staker-test-util/snapshot-checker:latest
+```
+
+See [examples/workflows/](examples/workflows/) for complete workflow examples.
 
 ## Configuration
 
-### Required Environment Variables
+### Test Runner Environment Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| `IPFS_GATEWAY_URL` | IPFS gateway URL for fetching packages | Yes |
+| `IPFS_HASH` | IPFS hash of the test package | Yes |
+| `EXECUTION_CLIENT` | Override execution client (geth, reth, nethermind, besu, erigon) | No |
+| `CONSENSUS_CLIENT` | Override consensus client (prysm, teku, nimbus, lodestar) | No |
+| `LOG_LEVEL` | Log level (DEBUG, INFO, WARN, ERROR) | No |
+
+> **Note:** If the package being tested is an execution or consensus client, it will override the respective environment variable with a warning.
 
-| Variable | Description |
-|----------|-------------|
-| `IPFS_GATEWAY_URL` | IPFS gateway URL for fetching packages |
-| `IPFS_HASH` | IPFS hash of the test package |
+### Snapshot Checker Environment Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| `EXECUTION_CLIENT` | Execution client to manage (geth, reth, nethermind, besu, erigon) | Yes |
+| `NETWORK` | Network name (default: hoodi) | No |
+| `CRON_INTERVAL_SEC` | Interval between checks in seconds (default: 21600 = 6h) | No |
+| `RUN_ONCE` | Run once and exit (default: false) | No |
+| `LOG_LEVEL` | Log level (DEBUG, INFO, WARN, ERROR) | No |
 
 ### GitHub Integration (Optional)
 
@@ -36,14 +101,21 @@ These environment variables enable automatic PR commenting. When running in GitH
 All environment variables can also be set via CLI flags:
 
 ```bash
-./staker-test-util \
+# Test Runner
+./test-runner \
   --ipfs-gateway-url="http://ipfs.dappnode:8080" \
   --ipfs-hash="QmSfPFSauovbMzEcvf2a2csoHtfqpViShwEYpuX3fPR8zv" \
+  --execution-client="geth" \
+  --consensus-client="nimbus" \
   --github-token="ghp_xxxx" \
   --github-repository="dappnode/staker-test-util" \
-  --github-pr-number="123" \
-  --github-run-id="12345678" \
-  --github-server-url="https://github.com"
+  --github-pr-number="123"
+
+# Snapshot Checker
+./snapshot-checker \
+  --execution-client="geth" \
+  --cron-interval=21600 \
+  --run-once
 ```
 
 ## GitHub Actions Workflow Example
diff --git a/examples/workflows/complete-staker-ci.yml b/examples/workflows/complete-staker-ci.yml
new file mode 100644
index 0000000..78779ca
--- /dev/null
+++ b/examples/workflows/complete-staker-ci.yml
@@ -0,0 +1,77 @@
+# Example: Complete CI workflow for DAppNode staker packages
+#
+# This workflow:
+# 1. Builds your package
+# 2. Publishes to IPFS
+# 3. Ensures snapshot is available
+# 4. Runs staker tests
+#
+# Copy and adapt for your package repository.
+
+name: Complete Staker CI
+
+on:
+  pull_request:
+    branches:
+      - main
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    outputs:
+      ipfs_hash: ${{ steps.publish.outputs.ipfs_hash }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Build DAppNode Package
+        run: |
+          # Your build steps here
+          # npx @dappnode/dappnodesdk build
+          echo "Building package..."
+
+      - name: Publish to IPFS
+        id: publish
+        run: |
+          # Your IPFS publish steps here
+          # This should output the IPFS hash
+          echo "ipfs_hash=QmYourIPFSHash" >> $GITHUB_OUTPUT
+
+  ensure-snapshot:
+    runs-on: self-hosted
+    needs: build
+    steps:
+      - name: Ensure Snapshot Available
+        run: |
+          docker run --rm \
+            -v /var/run/docker.sock:/var/run/docker.sock \
+            -v /var/lib/docker/volumes:/var/lib/docker/volumes \
+            -e LOG_LEVEL=INFO \
+            -e EXECUTION_CLIENT=geth \
+            -e NETWORK=hoodi \
+            -e RUN_ONCE=true \
+            ghcr.io/dappnode/staker-test-util/snapshot-checker:latest
+
+  test:
+    runs-on: self-hosted
+    needs: [build, ensure-snapshot]
+    steps:
+      - name: Run Staker Tests
+        run: |
+          docker run --rm \
+            --network dncore_network \
+            -v /var/run/docker.sock:/var/run/docker.sock \
+            -v /var/lib/docker/volumes:/var/lib/docker/volumes \
+            -e LOG_LEVEL=DEBUG \
+            -e IPFS_GATEWAY_URL=http://ipfs.dappnode:8080 \
+            -e IPFS_HASH=${{ needs.build.outputs.ipfs_hash }} \
+            -e EXECUTION_CLIENT=geth \
+            -e CONSENSUS_CLIENT=nimbus \
+            -e GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }} \
+            -e GITHUB_REPOSITORY=${{ github.repository }} \
+            -e GITHUB_PR_NUMBER=${{ github.event.pull_request.number }} \
+            -e GITHUB_RUN_ID=${{ github.run_id }} \
+            ghcr.io/dappnode/staker-test-util/test-runner:latest
diff --git a/examples/workflows/snapshot-checker.yml b/examples/workflows/snapshot-checker.yml
new file mode 100644
index 0000000..7f78a71
--- /dev/null
+++ b/examples/workflows/snapshot-checker.yml
@@ -0,0 +1,58 @@
+# Example: Running snapshot-checker as a scheduled job
+#
+# This workflow runs the snapshot-checker to keep execution client snapshots updated.
+# Can run as Docker container or as a binary.
+#
+# Prerequisites:
+# - Self-hosted runner with access to Docker volumes
+
+name: Snapshot Checker
+
+on:
+  schedule:
+    # Run every 6 hours
+    - cron: '0 */6 * * *'
+  workflow_dispatch:
+    inputs:
+      execution_client:
+        description: 'Execution client (geth, reth, nethermind, besu, erigon)'
+        required: true
+        default: 'geth'
+      run_once:
+        description: 'Run once and exit'
+        required: false
+        default: 'true'
+
+jobs:
+  # Option 1: Run as Docker container
+  snapshot-check-docker:
+    runs-on: self-hosted
+    steps:
+      - name: Run Snapshot Checker (Docker)
+        run: |
+          docker run --rm \
+            -v /var/run/docker.sock:/var/run/docker.sock \
+            -v /var/lib/docker/volumes:/var/lib/docker/volumes \
+            -e LOG_LEVEL=INFO \
+            -e EXECUTION_CLIENT=${{ github.event.inputs.execution_client || 'geth' }} \
+            -e NETWORK=hoodi \
+            -e RUN_ONCE=${{ github.event.inputs.run_once || 'true' }} \
+            ghcr.io/dappnode/staker-test-util/snapshot-checker:latest
+
+  # Option 2: Run as binary (alternative approach)
+  # Uncomment to use binary instead of Docker
+  #
+  # snapshot-check-binary:
+  #   runs-on: self-hosted
+  #   steps:
+  #     - name: Download snapshot-checker binary
+  #       run: |
+  #         curl -L -o snapshot-checker \
+  #           https://github.com/dappnode/staker-test-util/releases/latest/download/snapshot-checker-linux-amd64
+  #         chmod +x snapshot-checker
+  #
+  #     - name: Run Snapshot Checker
+  #       run: |
+  #         ./snapshot-checker \
+  #           --execution-client=${{ github.event.inputs.execution_client || 'geth' }} \
+  #           --run-once
diff --git a/examples/workflows/staker-test.yml b/examples/workflows/staker-test.yml
new file mode 100644
index 0000000..53ff62c
--- /dev/null
+++ b/examples/workflows/staker-test.yml
@@ -0,0 +1,53 @@
+# Example: Using test-runner in your DAppNode package CI
+#
+# This workflow runs the staker test-runner against your package.
+# Copy this to your package repo's .github/workflows/ directory.
+#
+# Prerequisites:
+# - Self-hosted runner with Docker and access to dncore_network
+# - IPFS hash of your package available
+
+name: Staker Test
+
+on:
+  pull_request:
+    branches:
+      - main
+  workflow_dispatch:
+    inputs:
+      ipfs_hash:
+        description: 'IPFS hash of the package to test'
+        required: true
+
+jobs:
+  staker-test:
+    runs-on: self-hosted
+    steps:
+      - name: Get IPFS hash
+        id: ipfs
+        run: |
+          # Use input if provided, otherwise you'll need to build/publish your package first
+          if [ -n "${{ github.event.inputs.ipfs_hash }}" ]; then
+            echo "hash=${{ github.event.inputs.ipfs_hash }}" >> $GITHUB_OUTPUT
+          else
+            # Add your logic to get IPFS hash from a previous build step
+            echo "hash=$IPFS_HASH" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Run Staker Test Runner
+        run: |
+          docker run --rm \
+            --network dncore_network \
+            -v /var/run/docker.sock:/var/run/docker.sock \
+            -v /var/lib/docker/volumes:/var/lib/docker/volumes \
+            -e LOG_LEVEL=DEBUG \
+            -e IPFS_GATEWAY_URL=http://ipfs.dappnode:8080 \
+            -e IPFS_HASH=${{ steps.ipfs.outputs.hash }} \
+            -e EXECUTION_CLIENT=geth \
+            -e CONSENSUS_CLIENT=nimbus \
+            -e GITHUB_TOKEN=${{ secrets.GITHUB_TOKEN }} \
+            -e GITHUB_REPOSITORY=${{ github.repository }} \
+            -e GITHUB_PR_NUMBER=${{ github.event.pull_request.number }} \
+            -e GITHUB_RUN_ID=${{ github.run_id }} \
+            -e GITHUB_SERVER_URL=${{ github.server_url }} \
+            ghcr.io/dappnode/staker-test-util/test-runner:latest

From 1319020cd3d06925282f81259b1cbe022da1ce3f Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 23 Jan 2026 09:23:45 +0100
Subject: [PATCH 39/42] implement runonce default to true

---
 internal/config/snapshot_checker_config.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/config/snapshot_checker_config.go b/internal/config/snapshot_checker_config.go
index a045f15..39df813 100644
--- a/internal/config/snapshot_checker_config.go
+++ b/internal/config/snapshot_checker_config.go
@@ -27,7 +27,7 @@ func ParseSnapshotCheckerConfig() SnapshotCheckerAppConfig {
 	executionClient := flag.String("execution-client", "", "Execution client name (geth, nethermind, reth, besu, erigon). Required.")
 	network := flag.String("network", "hoodi", "Network name (e.g., hoodi). Default: hoodi")
 	cronIntervalSec := flag.Int("cron-interval", 0, "Interval between snapshot checks in seconds. Default: 21600 (6 hours)")
-	runOnce := flag.Bool("run-once", false, "Run once and exit (for testing). Default: false")
+	runOnce := flag.Bool("run-once", true, "Run once and exit (for testing). Default: false")
 
 	flag.Parse()
 

From 13969d9129066d7149c8fe29fbb9b5967a5c328e Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 23 Jan 2026 09:24:52 +0100
Subject: [PATCH 40/42] remove runonce from ci example

---
 examples/workflows/snapshot-checker.yml | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/examples/workflows/snapshot-checker.yml b/examples/workflows/snapshot-checker.yml
index 7f78a71..05c492b 100644
--- a/examples/workflows/snapshot-checker.yml
+++ b/examples/workflows/snapshot-checker.yml
@@ -18,10 +18,6 @@ on:
         description: 'Execution client (geth, reth, nethermind, besu, erigon)'
         required: true
         default: 'geth'
-      run_once:
-        description: 'Run once and exit'
-        required: false
-        default: 'true'
 
 jobs:
   # Option 1: Run as Docker container
@@ -36,7 +32,6 @@ jobs:
             -e LOG_LEVEL=INFO \
             -e EXECUTION_CLIENT=${{ github.event.inputs.execution_client || 'geth' }} \
             -e NETWORK=hoodi \
-            -e RUN_ONCE=${{ github.event.inputs.run_once || 'true' }} \
             ghcr.io/dappnode/staker-test-util/snapshot-checker:latest
 
   # Option 2: Run as binary (alternative approach)
@@ -55,4 +50,3 @@ jobs:
   #       run: |
   #         ./snapshot-checker \
   #           --execution-client=${{ github.event.inputs.execution_client || 'geth' }} \
-  #           --run-once

From 4995023946e48e6cebfa7efb848cea65c61dbb43 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Fri, 23 Jan 2026 09:26:02 +0100
Subject: [PATCH 41/42] set default log level debug

---
 examples/workflows/complete-staker-ci.yml | 2 --
 examples/workflows/snapshot-checker.yml   | 1 -
 examples/workflows/staker-test.yml        | 1 -
 internal/logger/logger.go                 | 2 +-
 4 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/examples/workflows/complete-staker-ci.yml b/examples/workflows/complete-staker-ci.yml
index 78779ca..e187e88 100644
--- a/examples/workflows/complete-staker-ci.yml
+++ b/examples/workflows/complete-staker-ci.yml
@@ -49,7 +49,6 @@ jobs:
           docker run --rm \
             -v /var/run/docker.sock:/var/run/docker.sock \
             -v /var/lib/docker/volumes:/var/lib/docker/volumes \
-            -e LOG_LEVEL=INFO \
             -e EXECUTION_CLIENT=geth \
             -e NETWORK=hoodi \
             -e RUN_ONCE=true \
@@ -65,7 +64,6 @@ jobs:
             --network dncore_network \
             -v /var/run/docker.sock:/var/run/docker.sock \
             -v /var/lib/docker/volumes:/var/lib/docker/volumes \
-            -e LOG_LEVEL=DEBUG \
             -e IPFS_GATEWAY_URL=http://ipfs.dappnode:8080 \
             -e IPFS_HASH=${{ needs.build.outputs.ipfs_hash }} \
             -e EXECUTION_CLIENT=geth \
diff --git a/examples/workflows/snapshot-checker.yml b/examples/workflows/snapshot-checker.yml
index 05c492b..399fb0f 100644
--- a/examples/workflows/snapshot-checker.yml
+++ b/examples/workflows/snapshot-checker.yml
@@ -29,7 +29,6 @@ jobs:
           docker run --rm \
             -v /var/run/docker.sock:/var/run/docker.sock \
             -v /var/lib/docker/volumes:/var/lib/docker/volumes \
-            -e LOG_LEVEL=INFO \
             -e EXECUTION_CLIENT=${{ github.event.inputs.execution_client || 'geth' }} \
             -e NETWORK=hoodi \
             ghcr.io/dappnode/staker-test-util/snapshot-checker:latest
diff --git a/examples/workflows/staker-test.yml b/examples/workflows/staker-test.yml
index 53ff62c..31f4040 100644
--- a/examples/workflows/staker-test.yml
+++ b/examples/workflows/staker-test.yml
@@ -40,7 +40,6 @@ jobs:
             --network dncore_network \
             -v /var/run/docker.sock:/var/run/docker.sock \
             -v /var/lib/docker/volumes:/var/lib/docker/volumes \
-            -e LOG_LEVEL=DEBUG \
             -e IPFS_GATEWAY_URL=http://ipfs.dappnode:8080 \
             -e IPFS_HASH=${{ steps.ipfs.outputs.hash }} \
             -e EXECUTION_CLIENT=geth \
diff --git a/internal/logger/logger.go b/internal/logger/logger.go
index b9b35bb..6f5b5e6 100644
--- a/internal/logger/logger.go
+++ b/internal/logger/logger.go
@@ -50,7 +50,7 @@ func parseLogLevelFromEnv() LogLevel {
 	case "FATAL":
 		return FATAL
 	default:
-		return INFO // Default to INFO if LOG_LEVEL is not set or invalid
+		return DEBUG // Default to DEBUG if LOG_LEVEL is not set or invalid
 	}
 }
 

From 30cd0f7197145aee61b1251a666000dcade8ca83 Mon Sep 17 00:00:00 2001
From: Pablo Mendez <pablo@dappnode.io>
Date: Mon, 26 Jan 2026 09:10:26 +0100
Subject: [PATCH 42/42] update CI

---
 .github/workflows/build-and-push.yml | 102 +++++++++++++++++++--------
 .github/workflows/release.yml        |  69 ------------------
 2 files changed, 73 insertions(+), 98 deletions(-)
 delete mode 100644 .github/workflows/release.yml

diff --git a/.github/workflows/build-and-push.yml b/.github/workflows/build-and-push.yml
index fe1fd8e..f813c3c 100644
--- a/.github/workflows/build-and-push.yml
+++ b/.github/workflows/build-and-push.yml
@@ -1,26 +1,67 @@
-name: Build and Push Docker Images
+name: Release and Publish Docker Images
 
 on:
-  push:
-    branches:
-      - main
-    tags:
-      - 'v*'
-  pull_request:
-    branches:
-      - main
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Release version (e.g. v1.2.3)'
+        required: true
+        type: string
 
 env:
   REGISTRY: ghcr.io
   IMAGE_PREFIX: ${{ github.repository }}
+  VERSION: ${{ github.event.inputs.version }}
 
 jobs:
-  build-and-push:
+  build-binaries:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        include:
+          - goos: linux
+            goarch: amd64
+          - goos: linux
+            goarch: arm64
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.24'
+
+      - name: Build test-runner
+        env:
+          GOOS: ${{ matrix.goos }}
+          GOARCH: ${{ matrix.goarch }}
+          CGO_ENABLED: 0
+        run: |
+          go build -o test-runner-${{ matrix.goos }}-${{ matrix.goarch }} ./cmd/test-runner
+
+      - name: Build snapshot-checker
+        env:
+          GOOS: ${{ matrix.goos }}
+          GOARCH: ${{ matrix.goarch }}
+          CGO_ENABLED: 0
+        run: |
+          go build -o snapshot-checker-${{ matrix.goos }}-${{ matrix.goarch }} ./cmd/snapshot-checker
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: binaries-${{ matrix.goos }}-${{ matrix.goarch }}
+          path: |
+            test-runner-${{ matrix.goos }}-${{ matrix.goarch }}
+            snapshot-checker-${{ matrix.goos }}-${{ matrix.goarch }}
+
+  docker:
+    needs: build-binaries
     runs-on: ubuntu-latest
     permissions:
       contents: read
       packages: write
-
     strategy:
       matrix:
         include:
@@ -28,7 +69,6 @@ jobs:
             dockerfile: Dockerfile.test-runner
           - name: snapshot-checker
             dockerfile: Dockerfile.snapshot-checker
-
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -37,33 +77,37 @@ jobs:
         uses: docker/setup-buildx-action@v3
 
       - name: Log in to Container Registry
-        if: github.event_name != 'pull_request'
         uses: docker/login-action@v3
         with:
           registry: ${{ env.REGISTRY }}
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Extract metadata (tags, labels)
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.REGISTRY }}/${{ env.IMAGE_PREFIX }}/${{ matrix.name }}
-          tags: |
-            type=ref,event=branch
-            type=ref,event=pr
-            type=semver,pattern={{version}}
-            type=semver,pattern={{major}}.{{minor}}
-            type=sha,prefix=
-            type=raw,value=latest,enable={{is_default_branch}}
-
       - name: Build and push Docker image
         uses: docker/build-push-action@v5
         with:
           context: .
           file: ${{ matrix.dockerfile }}
-          push: ${{ github.event_name != 'pull_request' }}
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
+          push: true
+          tags: |
+            ${{ env.REGISTRY }}/${{ env.IMAGE_PREFIX }}/${{ matrix.name }}:${{ env.VERSION }}
+            ${{ env.REGISTRY }}/${{ env.IMAGE_PREFIX }}/${{ matrix.name }}:latest
           cache-from: type=gha
           cache-to: type=gha,mode=max
+
+  release:
+    needs: [build-binaries, docker]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: binaries
+          merge-multiple: true
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v1
+        with:
+          tag_name: ${{ env.VERSION }}
+          files: binaries/*
+          generate_release_notes: true
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
deleted file mode 100644
index 8119eb5..0000000
--- a/.github/workflows/release.yml
+++ /dev/null
@@ -1,69 +0,0 @@
-name: Release Binaries
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-permissions:
-  contents: write
-
-jobs:
-  build-binaries:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        include:
-          - goos: linux
-            goarch: amd64
-          - goos: linux
-            goarch: arm64
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.24'
-
-      - name: Build test-runner
-        env:
-          GOOS: ${{ matrix.goos }}
-          GOARCH: ${{ matrix.goarch }}
-          CGO_ENABLED: 0
-        run: |
-          go build -o test-runner-${{ matrix.goos }}-${{ matrix.goarch }} ./cmd/test-runner
-
-      - name: Build snapshot-checker
-        env:
-          GOOS: ${{ matrix.goos }}
-          GOARCH: ${{ matrix.goarch }}
-          CGO_ENABLED: 0
-        run: |
-          go build -o snapshot-checker-${{ matrix.goos }}-${{ matrix.goarch }} ./cmd/snapshot-checker
-
-      - name: Upload artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: binaries-${{ matrix.goos }}-${{ matrix.goarch }}
-          path: |
-            test-runner-${{ matrix.goos }}-${{ matrix.goarch }}
-            snapshot-checker-${{ matrix.goos }}-${{ matrix.goarch }}
-
-  release:
-    needs: build-binaries
-    runs-on: ubuntu-latest
-    steps:
-      - name: Download all artifacts
-        uses: actions/download-artifact@v4
-        with:
-          path: binaries
-          merge-multiple: true
-
-      - name: Create Release
-        uses: softprops/action-gh-release@v1
-        with:
-          files: binaries/*
-          generate_release_notes: true