DV Setup: Charon Integration with Sedge

.gitignore

@@ -24,4 +24,11 @@ internal/lido/contracts/csfeedistributor/CSFeeDistributor.go
 
 internal/lido/contracts/csmodule/CSModule.go
 
-internal/lido/contracts/mevboostrelaylist/MEVBoostRelayAllowedList.go
+internal/lido/contracts/mevboostrelaylist/MEVBoostRelayAllowedList.go
+cluster/
+
+.charon/
+node*/
+
+keystore*
+!cli/actions/testdata/charon/validator_keys/keystore*

cli/actions/generation_test.go

@@ -95,6 +95,13 @@ func TestGenerateDockerCompose(t *testing.T) {
 		if err != nil {
 			t.Errorf("SupportedClients(\"validator\") failed: %v", err)
 		}
+		var distributedValidatorClients []string
+		if network == "holesky" {
+			distributedValidatorClients, err = c.SupportedClients("distributedValidator")
+			if err != nil {
+				t.Errorf("SupportedClients(\"distributedValidator\") failed: %v", err)
+			}
+		}
 
 		rNum, err := rand.Int(rand.Reader, big.NewInt(int64(100)))
 		if err != nil {
@@ -265,6 +272,25 @@ func TestGenerateDockerCompose(t *testing.T) {
 						},
 					)
 				}
+
+				// For distributedValidator
+				if utils.Contains(distributedValidatorClients, "charon") {
+					tests = append(tests,
+						genTestData{
+							name: fmt.Sprintf("execution: %s, consensus: %s, validator: %s,distributedValidator: %s, network: %s,  all, with distributedValidator", executionCl, consensusCl, consensusCl, distributedValidatorClients, network),
+							genData: generate.GenData{
+								Distributed:                true,
+								DistributedValidatorClient: &clients.Client{Name: "charon", Type: "distributedValidator"},
+								ExecutionClient:            &clients.Client{Name: executionCl, Type: "execution"},
+								ConsensusClient:            &clients.Client{Name: consensusCl, Type: "consensus"},
+								ValidatorClient:            &clients.Client{Name: consensusCl, Type: "validator"},
+								Services:                   []string{"execution", "consensus", "validator", "distributedValidator"},
+								Network:                    network,
+							},
+						},
+					)
+				}
+
 			}
 		}
 	}
@@ -287,6 +313,9 @@ func TestGenerateDockerCompose(t *testing.T) {
 			if tc.genData.ValidatorClient != nil {
 				tc.genData.ValidatorClient.SetImageOrDefault("")
 			}
+			if tc.genData.DistributedValidatorClient != nil {
+				tc.genData.DistributedValidatorClient.SetImageOrDefault("")
+			}
 
 			_, err := sedgeAction.Generate(actions.GenerateOptions{
 				GenerationData: tc.genData,
@@ -470,6 +499,14 @@ func TestGenerateDockerCompose(t *testing.T) {
 				}
 			}
 
+			// Validate that Distributed Validator Client info matches the sample data
+			if tc.genData.DistributedValidatorClient != nil {
+				// Check that the distributed-validator service is set.
+				assert.NotNil(t, cmpData.Services.DistributedValidator)
+				// Check that the distributed-validator container Volume is set.
+				assert.Equal(t, "${DV_DATA_DIR}:/opt/charon/.charon", cmpData.Services.DistributedValidator.Volumes[0])
+			}
+
 			if tc.genData.ValidatorClient == nil {
 				// Check validator blocker is not set if validator is not set
 				assert.Nil(t, cmpData.Services.ValidatorBlocker)

cli/actions/importKeys.go

@@ -25,6 +25,7 @@ import (
 
 	"github.com/NethermindEth/sedge/configs"
 	"github.com/NethermindEth/sedge/internal/images/validator-import/lighthouse"
+	"github.com/NethermindEth/sedge/internal/images/validator-import/prysm"
 	"github.com/NethermindEth/sedge/internal/images/validator-import/teku"
 	"github.com/NethermindEth/sedge/internal/pkg/commands"
 	"github.com/NethermindEth/sedge/internal/pkg/services"
@@ -48,6 +49,7 @@ type ImportValidatorKeysOptions struct {
 	GenerationPath  string
 	ContainerTag    string
 	CustomConfig    ImportValidatorKeysCustomOptions
+	Distributed     bool
 }
 type ImportValidatorKeysCustomOptions struct {
 	NetworkConfigPath string
@@ -97,19 +99,95 @@ func (s *sedgeActions) ImportValidatorKeys(options ImportValidatorKeysOptions) e
 	options.GenerationPath = absGenerationPath
 
 	if !isDefaultKeysPath(options.GenerationPath, options.From) {
-		defaultKeystorePath := filepath.Join(options.GenerationPath, "keystore")
-		log.Warnf("The keys path is not the default one, copying the keys to the default path %s", defaultKeystorePath)
-		copy.Copy(options.From, defaultKeystorePath)
+		if !options.Distributed {
+			defaultKeystorePath := filepath.Join(options.GenerationPath, "keystore")
+			log.Warnf("The keys path is not the default one, copying the keys to the default path %s", defaultKeystorePath)
+			copy.Copy(options.From, defaultKeystorePath)
+		}
+	}
+
+	if options.Distributed {
+		cwd, _ := os.Getwd()
+		charonPath := filepath.Join(cwd, ".charon")
+
+		if !isDefaultKeysPath(options.GenerationPath, options.From) {
+			charonPath = options.From
+			log.Infof("Copying the keys from %s", charonPath)
+			options.From = filepath.Join(options.GenerationPath, "keystore")
+		}
+		defaultCharonPath := filepath.Join(configs.DefaultAbsSedgeDataPath, ".charon")
+		// Copy the folder from charonPath to defaultCharonPath
+		log.Infof("Copying Charon contents to the default path %s", defaultCharonPath)
+		if err := os.MkdirAll(defaultCharonPath, 0o755); err != nil {
+			return err
+		}
+		if err := copy.Copy(charonPath, defaultCharonPath); err != nil {
+			return err
+		}
+		charonValidatorKeysPath := filepath.Join(charonPath, "validator_keys")
+		defaultKeystorePath := filepath.Join(configs.DefaultAbsSedgeDataPath, "keystore")
+		log.Infof("Copying the keys to the default path %s", defaultKeystorePath)
+		if err := os.MkdirAll(defaultKeystorePath, 0o755); err != nil {
+			return err
+		}
+
+		validatorKeysPath := filepath.Join(defaultKeystorePath, "validator_keys")
+		if err := os.MkdirAll(validatorKeysPath, 0o755); err != nil {
+			return err
+		}
+
+		depositDataPath := filepath.Join(charonPath, "deposit-data.json")
+		depositDataPathDest := filepath.Join(defaultKeystorePath, "deposit-data.json")
+		if err := copy.Copy(depositDataPath, depositDataPathDest); err != nil {
+			return err
+		}
+
+		files, err := os.ReadDir(charonValidatorKeysPath)
+		if err != nil {
+			log.Fatal(err)
+		}
+		len := len(files)
+		for i := 0; i < len/2; i++ {
+			keystorePath := filepath.Join(charonValidatorKeysPath, fmt.Sprintf("keystore-%d.json", i))
+			validatorPath := filepath.Join(validatorKeysPath, fmt.Sprintf("keystore-%d.json", i))
+			if err := copy.Copy(keystorePath, validatorPath); err != nil {
+				return err
+			}
+
+			keystoreTxtPath := filepath.Join(charonValidatorKeysPath, fmt.Sprintf("keystore-%d.txt", i))
+			keystorePasswordPath := filepath.Join(defaultKeystorePath, fmt.Sprintf("keystore-%d.txt", i))
+			if err := copy.Copy(keystoreTxtPath, keystorePasswordPath); err != nil {
+				return err
+			}
+		}
+		if options.ValidatorClient == "prysm" {
+			keystorePasswordPath := filepath.Join(defaultKeystorePath, "keystore_password.txt")
+			f, err := os.Create(keystorePasswordPath)
+			if err != nil {
+				return err
+			}
+			f.WriteString("prysm-validator-secret")
+			defer f.Close()
+		}
 	}
 
 	var ctID string
 	switch options.ValidatorClient {
 	case "prysm":
-		prysmCtID, err := setupPrysmValidatorImportContainer(s.dockerClient, s.dockerServiceManager, options)
-		if err != nil {
-			return err
+		prysmCtID := ""
+		if options.Distributed {
+			prysmCtID, err = setupPrysmValidatorImportContainerDV(s.dockerClient, s.commandRunner, s.dockerServiceManager, options)
+			if err != nil {
+				return err
+			}
+			ctID = prysmCtID
+		} else {
+			prysmCtID, err := setupPrysmValidatorImportContainer(s.dockerClient, s.dockerServiceManager, options)
+			if err != nil {
+				return err
+			}
+			ctID = prysmCtID
 		}
-		ctID = prysmCtID
 	case "lodestar":
 		lodestarCtID, err := setupLodestarValidatorImport(s.dockerClient, s.dockerServiceManager, options)
 		if err != nil {
@@ -253,11 +331,33 @@ func setupLodestarValidatorImport(dockerClient client.APIClient, dockerServiceMa
 		cmd = append(cmd, "--preset", preset)
 	}
 	log.Debugf("Creating %s container", validatorImportCtName)
-	ct, err := dockerClient.ContainerCreate(context.Background(),
-		&container.Config{
+	containerConfig := &container.Config{
+		Image: validatorImage,
+		Cmd:   cmd,
+	}
+	if options.Distributed {
+		containerConfig = &container.Config{
 			Image: validatorImage,
-			Cmd:   cmd,
-		},
+			Entrypoint: []string{
+				"sh", "-c", `
+				#!/bin/sh
+				set -e
+				for f in /keystore/validator_keys/keystore-*.json; do
+					echo "Importing key ${f}"
+					pwdfile="/keystore/$(basename "$f" .json).txt"
+					echo "Using password file ${pwdfile}"
+					# Import keystore with password.
+					node /usr/app/packages/cli/bin/lodestar validator import \
+						--dataDir="/data" \
+						--importKeystores="$f" \
+						--importKeystoresPassword="${pwdfile}"
+				done
+			`,
+			},
+		}
+	}
+	ct, err := dockerClient.ContainerCreate(context.Background(),
+		containerConfig,
 		&container.HostConfig{
 			Mounts:      mounts,
 			VolumesFrom: []string{validatorCtName},
@@ -437,3 +537,54 @@ func runAndWaitImportKeys(dockerClient client.APIClient, dockerServiceManager Do
 		}
 	}
 }
+
+func setupPrysmValidatorImportContainerDV(dockerClient client.APIClient, commandRunner commands.CommandRunner, serviceManager DockerServiceManager, options ImportValidatorKeysOptions) (string, error) {
+	var (
+		validatorCtName       = services.ContainerNameWithTag(services.DefaultSedgeValidatorClient, options.ContainerTag)
+		validatorImportCtName = services.ContainerNameWithTag(services.ServiceCtValidatorImport, options.ContainerTag)
+	)
+	// Init build context
+	contextDir, err := prysm.InitContext()
+	if err != nil {
+		return "", err
+	}
+	// Build image
+	buildCmd := commandRunner.BuildDockerBuildCMD(commands.DockerBuildOptions{
+		Path: contextDir,
+		Tag:  "sedge/prysm-import-teku",
+		Args: map[string]string{
+			"NETWORK":       options.Network,
+			"PRYSM_VERSION": configs.ClientImages.Validator.Prysm.String(),
+		},
+	})
+	log.Infof(configs.RunningCommand, buildCmd.Cmd)
+	if _, _, err := commandRunner.RunCMD(buildCmd); err != nil {
+		return "", err
+	}
+	// Mounts
+	mounts := []mount.Mount{
+		{
+			Type:   mount.TypeBind,
+			Source: options.From,
+			Target: "/keystore",
+		},
+	}
+	log.Debugf("Creating %s container", validatorImportCtName)
+	containerConfig := &container.Config{
+		Image: "sedge/prysm-import-teku",
+	}
+	ct, err := dockerClient.ContainerCreate(context.Background(),
+		containerConfig,
+		&container.HostConfig{
+			Mounts:      mounts,
+			VolumesFrom: []string{validatorCtName},
+		},
+		&network.NetworkingConfig{},
+		&v1.Platform{},
+		validatorImportCtName,
+	)
+	if err != nil {
+		return "", err
+	}
+	return ct.ID, nil
+}