temp commit with some commentary. revert this commit later

testing/endtoend/BUILD.bazel

@@ -107,5 +107,7 @@ go_test(
         "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
         "@org_golang_x_sync//errgroup:go_default_library",
+        "//cmd:go_default_library",
+        "//cmd/beacon-chain/flags:go_default_library",
     ],
 )

testing/endtoend/components/beacon_node.go

@@ -49,9 +49,9 @@ func NewBeaconNodes(config *e2etypes.E2EConfig) *BeaconNodeSet {
 
 // Start starts all the beacon nodes in set.
 func (s *BeaconNodeSet) Start(ctx context.Context) error {
-	if s.enr == "" {
-		return errors.New("empty ENR")
-	}
+	// if s.enr == "" {
+	// 	return errors.New("empty ENR")
+	// }
 
 	// Create beacon nodes.
 	nodes := make([]e2etypes.ComponentRunner, e2e.TestParams.BeaconNodeCount)
@@ -141,6 +141,12 @@ func (node *BeaconNode) Start(ctx context.Context) error {
 	args = append(args, features.E2EBeaconChainFlags...)
 	args = append(args, config.BeaconFlags...)
 
+	if config.NoModifyBeaconFlags {
+		log.Warn("Using config.BeaconFlags with no modifications")
+		args = config.BeaconFlags
+		args = append(args, fmt.Sprintf("--%s=%s", cmdshared.LogFileName.Name, stdOutFile.Name()))
+	}
+
 	cmd := exec.CommandContext(ctx, binaryPath, args...) // #nosec G204 -- Safe
 	// Write stdout and stderr to log files.
 	stdout, err := os.Create(path.Join(e2e.TestParams.LogPath, fmt.Sprintf("beacon_node_%d_stdout.log", index)))
@@ -161,14 +167,15 @@ func (node *BeaconNode) Start(ctx context.Context) error {
 	}()
 	cmd.Stdout = stdout
 	cmd.Stderr = stderr
-	log.Infof("Starting beacon chain %d with flags: %s", index, strings.Join(args[2:], " "))
+	log.Infof("Starting beacon chain %d with flags: %s", index, strings.Join(args, " "))
 	if err = cmd.Start(); err != nil {
 		return fmt.Errorf("failed to start beacon node: %w", err)
 	}
-
+	log.Info("Beacon chain node started, waiting for gRPC server log message")
 	if err = helpers.WaitForTextInFile(stdOutFile, "gRPC server listening on port"); err != nil {
 		return fmt.Errorf("could not find multiaddr for node %d, this means the node had issues starting: %w", index, err)
 	}
+	log.Info("Found gRPC server log message, beacon chain node is ready")
 
 	if config.UseFixedPeerIDs {
 		peerId, err := helpers.FindFollowingTextInFile(stdOutFile, "Running node with peer id of ")

testing/endtoend/components/lighthouse_beacon.go

@@ -11,7 +11,7 @@ import (
 	"strings"
 
 	"github.com/bazelbuild/rules_go/go/tools/bazel"
-	"github.com/prysmaticlabs/prysm/config/params"
+	// "github.com/prysmaticlabs/prysm/config/params"
 	"github.com/prysmaticlabs/prysm/io/file"
 	"github.com/prysmaticlabs/prysm/testing/endtoend/helpers"
 	e2e "github.com/prysmaticlabs/prysm/testing/endtoend/params"
@@ -167,7 +167,8 @@ func (node *LighthouseBeaconNode) Started() <-chan struct{} {
 func (node *LighthouseBeaconNode) createTestnetDir(index int) (string, error) {
 	testNetDir := e2e.TestParams.TestPath + fmt.Sprintf("/lighthouse-testnet-%d", index)
 	configPath := filepath.Join(testNetDir, "config.yaml")
-	rawYaml := params.E2EMainnetConfigYaml()
+	//rawYaml := params.E2EMainnetConfigYaml()
+	rawYaml := []byte{}
 	// Add in deposit contract in yaml
 	depContractStr := fmt.Sprintf("\nDEPOSIT_CONTRACT_ADDRESS: %#x", e2e.TestParams.ContractAddress)
 	rawYaml = append(rawYaml, []byte(depContractStr)...)

testing/endtoend/components/validator.go

@@ -150,7 +150,7 @@ func (v *ValidatorNode) Start(ctx context.Context) error {
 		args = append(args, features.E2EValidatorFlags...)
 	}
 	if v.config.UseWeb3RemoteSigner {
-		args = append(args, fmt.Sprintf("--%s=localhost:%d", flags.Web3SignerURLFlag.Name, Web3RemoteSignerPort))
+		// args = append(args, fmt.Sprintf("--%s=localhost:%d", flags.Web3SignerURLFlag.Name, Web3RemoteSignerPort))
 		// Write the pubkeys as comma seperated hex strings with 0x prefix.
 		// See: https://docs.teku.consensys.net/en/latest/HowTo/External-Signer/Use-External-Signer/
 		_, pubs, err := interop.DeterministicallyGenerateKeys(uint64(offset), uint64(validatorNum))
@@ -161,7 +161,7 @@ func (v *ValidatorNode) Start(ctx context.Context) error {
 		for _, pub := range pubs {
 			hexPubs = append(hexPubs, "0x"+hex.EncodeToString(pub.Marshal()))
 		}
-		args = append(args, fmt.Sprintf("--%s=%s", flags.Web3SignerPublicValidatorKeysFlag.Name, strings.Join(hexPubs, ",")))
+		// args = append(args, fmt.Sprintf("--%s=%s", flags.Web3SignerPublicValidatorKeysFlag.Name, strings.Join(hexPubs, ",")))
 	} else {
 		// When not using remote key signer, use interop keys.
 		args = append(args,

testing/endtoend/endtoend_test.go

@@ -66,7 +66,7 @@ func (r *testRunner) run() {
 	t.Logf("Starting time: %s\n", time.Now().String())
 	t.Logf("Log Path: %s\n", e2e.TestParams.LogPath)
 
-	minGenesisActiveCount := int(params.BeaconConfig().MinGenesisActiveValidatorCount)
+	// minGenesisActiveCount := int(params.BeaconConfig().MinGenesisActiveValidatorCount)
 	multiClientActive := e2e.TestParams.LighthouseBeaconNodeCount > 0
 	var keyGen, lighthouseValidatorNodes e2etypes.ComponentRunner
 	var lighthouseNodes *components.LighthouseBeaconNodeSet
@@ -74,10 +74,10 @@ func (r *testRunner) run() {
 	ctx, done := context.WithCancel(context.Background())
 	g, ctx := errgroup.WithContext(ctx)
 
-	tracingSink := components.NewTracingSink(config.TracingSinkEndpoint)
-	g.Go(func() error {
-		return tracingSink.Start(ctx)
-	})
+	// tracingSink := components.NewTracingSink(config.TracingSinkEndpoint)
+	// g.Go(func() error {
+	// 	return tracingSink.Start(ctx)
+	// })
 
 	if multiClientActive {
 		keyGen = components.NewKeystoreGenerator()
@@ -89,38 +89,38 @@ func (r *testRunner) run() {
 	}
 
 	// ETH1 node.
-	eth1Node := components.NewEth1Node()
-	g.Go(func() error {
-		if err := eth1Node.Start(ctx); err != nil {
-			return errors.Wrap(err, "failed to start eth1node")
-		}
-		return nil
-	})
-	g.Go(func() error {
-		if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{eth1Node}); err != nil {
-			return errors.Wrap(err, "sending and mining deposits require ETH1 node to run")
-		}
-		if err := components.SendAndMineDeposits(eth1Node.KeystorePath(), minGenesisActiveCount, 0, true /* partial */); err != nil {
-			return errors.Wrap(err, "failed to send and mine deposits")
-		}
-		return nil
-	})
+	// eth1Node := components.NewEth1Node()
+	// g.Go(func() error {
+	// 	if err := eth1Node.Start(ctx); err != nil {
+	// 		return errors.Wrap(err, "failed to start eth1node")
+	// 	}
+	// 	return nil
+	// })
+	// g.Go(func() error {
+	// 	if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{eth1Node}); err != nil {
+	// 		return errors.Wrap(err, "sending and mining deposits require ETH1 node to run")
+	// 	}
+	// 	if err := components.SendAndMineDeposits(eth1Node.KeystorePath(), minGenesisActiveCount, 0, true /* partial */); err != nil {
+	// 		return errors.Wrap(err, "failed to send and mine deposits")
+	// 	}
+	// 	return nil
+	// })
 
 	// Boot node.
-	bootNode := components.NewBootNode()
-	g.Go(func() error {
-		if err := bootNode.Start(ctx); err != nil {
-			return errors.Wrap(err, "failed to start bootnode")
-		}
-		return nil
-	})
+	// bootNode := components.NewBootNode()
+	// g.Go(func() error {
+	// 	if err := bootNode.Start(ctx); err != nil {
+	// 		return errors.Wrap(err, "failed to start bootnode")
+	// 	}
+	// 	return nil
+	// })
 	// Beacon nodes.
 	beaconNodes := components.NewBeaconNodes(config)
 	g.Go(func() error {
-		if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{eth1Node, bootNode}); err != nil {
+		if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{ /*eth1Node, bootNode*/ }); err != nil {
 			return errors.Wrap(err, "beacon nodes require ETH1 and boot node to run")
 		}
-		beaconNodes.SetENR(bootNode.ENR())
+		//:beaconNodes.SetENR(bootNode.ENR())
 		if err := beaconNodes.Start(ctx); err != nil {
 			return errors.Wrap(err, "failed to start beacon nodes")
 		}
@@ -139,48 +139,48 @@ func (r *testRunner) run() {
 		})
 	}
 
-	if multiClientActive {
-		lighthouseNodes = components.NewLighthouseBeaconNodes(config)
-		g.Go(func() error {
-			if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{eth1Node, bootNode, beaconNodes}); err != nil {
-				return errors.Wrap(err, "lighthouse beacon nodes require ETH1 and boot node to run")
-			}
-			lighthouseNodes.SetENR(bootNode.ENR())
-			if err := lighthouseNodes.Start(ctx); err != nil {
-				return errors.Wrap(err, "failed to start lighthouse beacon nodes")
-			}
-			return nil
-		})
-	}
+	// if multiClientActive {
+	// 	lighthouseNodes = components.NewLighthouseBeaconNodes(config)
+	// 	g.Go(func() error {
+	// 		if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{eth1Node, bootNode, beaconNodes}); err != nil {
+	// 			return errors.Wrap(err, "lighthouse beacon nodes require ETH1 and boot node to run")
+	// 		}
+	// 		lighthouseNodes.SetENR(bootNode.ENR())
+	// 		if err := lighthouseNodes.Start(ctx); err != nil {
+	// 			return errors.Wrap(err, "failed to start lighthouse beacon nodes")
+	// 		}
+	// 		return nil
+	// 	})
+	// }
 	// Validator nodes.
-	validatorNodes := components.NewValidatorNodeSet(config)
-	g.Go(func() error {
-		comps := []e2etypes.ComponentRunner{beaconNodes}
-		if config.UseWeb3RemoteSigner {
-			comps = append(comps, web3RemoteSigner)
-		}
-		if err := helpers.ComponentsStarted(ctx, comps); err != nil {
-			return errors.Wrap(err, "validator nodes require beacon nodes to run")
-		}
-		if err := validatorNodes.Start(ctx); err != nil {
-			return errors.Wrap(err, "failed to start validator nodes")
-		}
-		return nil
-	})
+	// validatorNodes := components.NewValidatorNodeSet(config)
+	// g.Go(func() error {
+	// 	comps := []e2etypes.ComponentRunner{beaconNodes}
+	// 	if config.UseWeb3RemoteSigner {
+	// 		comps = append(comps, web3RemoteSigner)
+	// 	}
+	// 	if err := helpers.ComponentsStarted(ctx, comps); err != nil {
+	// 		return errors.Wrap(err, "validator nodes require beacon nodes to run")
+	// 	}
+	// 	if err := validatorNodes.Start(ctx); err != nil {
+	// 		return errors.Wrap(err, "failed to start validator nodes")
+	// 	}
+	// 	return nil
+	// })
 
-	if multiClientActive {
-		// Lighthouse Validator nodes.
-		lighthouseValidatorNodes = components.NewLighthouseValidatorNodeSet(config)
-		g.Go(func() error {
-			if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{keyGen, lighthouseNodes}); err != nil {
-				return errors.Wrap(err, "validator nodes require beacon nodes to run")
-			}
-			if err := lighthouseValidatorNodes.Start(ctx); err != nil {
-				return errors.Wrap(err, "failed to start validator nodes")
-			}
-			return nil
-		})
-	}
+	// if multiClientActive {
+	// 	// Lighthouse Validator nodes.
+	// 	lighthouseValidatorNodes = components.NewLighthouseValidatorNodeSet(config)
+	// 	g.Go(func() error {
+	// 		if err := helpers.ComponentsStarted(ctx, []e2etypes.ComponentRunner{keyGen, lighthouseNodes}); err != nil {
+	// 			return errors.Wrap(err, "validator nodes require beacon nodes to run")
+	// 		}
+	// 		if err := lighthouseValidatorNodes.Start(ctx); err != nil {
+	// 			return errors.Wrap(err, "failed to start validator nodes")
+	// 		}
+	// 		return nil
+	// 	})
+	// }
 
 	// Run E2E evaluators and tests.
 	g.Go(func() error {
@@ -192,7 +192,8 @@ func (r *testRunner) run() {
 
 		// Wait for all required nodes to start.
 		requiredComponents := []e2etypes.ComponentRunner{
-			tracingSink, eth1Node, bootNode, beaconNodes, validatorNodes,
+			beaconNodes,
+			// tracingSink, eth1Node, bootNode, beaconNodes, validatorNodes,
 		}
 		if multiClientActive {
 			requiredComponents = append(requiredComponents, []e2etypes.ComponentRunner{keyGen, lighthouseNodes, lighthouseValidatorNodes}...)
@@ -224,7 +225,8 @@ func (r *testRunner) run() {
 
 		if config.TestDeposits {
 			log.Info("Running deposit tests")
-			r.testDeposits(ctx, g, eth1Node, []e2etypes.ComponentRunner{beaconNodes})
+			panic("bad")
+			// r.testDeposits(ctx, g, eth1Node, []e2etypes.ComponentRunner{beaconNodes})
 		}
 
 		// Create GRPC connection to beacon nodes.
@@ -247,12 +249,12 @@ func (r *testRunner) run() {
 		if !config.TestSync {
 			return nil
 		}
-		if err := r.testBeaconChainSync(ctx, g, conns, tickingStartTime, bootNode.ENR()); err != nil {
-			return errors.Wrap(err, "beacon chain sync test failed")
-		}
-		if err := r.testDoppelGangerProtection(ctx); err != nil {
-			return errors.Wrap(err, "doppel ganger protection check failed")
-		}
+		// if err := r.testBeaconChainSync(ctx, g, conns, tickingStartTime, bootNode.ENR()); err != nil {
+		// 	return errors.Wrap(err, "beacon chain sync test failed")
+		// }
+		// if err := r.testDoppelGangerProtection(ctx); err != nil {
+		// 	return errors.Wrap(err, "doppel ganger protection check failed")
+		// }
 		return nil
 	})
 
@@ -268,12 +270,12 @@ func (r *testRunner) run() {
 // waitForChainStart allows to wait up until beacon nodes are started.
 func (r *testRunner) waitForChainStart() {
 	// Sleep depending on the count of validators, as generating the genesis state could take some time.
-	time.Sleep(time.Duration(params.BeaconConfig().GenesisDelay) * time.Second)
+	// time.Sleep(time.Duration(params.BeaconConfig().GenesisDelay) * time.Second)
 	beaconLogFile, err := os.Open(path.Join(e2e.TestParams.LogPath, fmt.Sprintf(e2e.BeaconNodeLogFileName, 0)))
 	require.NoError(r.t, err)
 
-	r.t.Run("chain started", func(t *testing.T) {
-		require.NoError(t, helpers.WaitForTextInFile(beaconLogFile, "Chain started in sync service"), "Chain did not start")
+	r.t.Run("chain synced", func(t *testing.T) {
+		require.NoError(t, helpers.WaitForTextInFile(beaconLogFile, "Synced up to slot "), "Chain did not sync")
 	})
 }
 

testing/endtoend/helpers/helpers.go

@@ -60,7 +60,7 @@ func DeleteAndCreateFile(tmpPath, fileName string) (*os.File, error) {
 
 // WaitForTextInFile checks a file every polling interval for the text requested.
 func WaitForTextInFile(file *os.File, text string) error {
-	d := time.Now().Add(maxPollingWaitTime)
+	d := time.Now().Add(30 * time.Minute)
 	ctx, cancel := context.WithDeadline(context.Background(), d)
 	defer cancel()
 
@@ -168,11 +168,11 @@ func LogOutput(t *testing.T) {
 		}
 		LogErrorOutput(t, beaconLogFile, "beacon chain node", i)
 
-		validatorLogFile, err := os.Open(path.Join(e2e.TestParams.LogPath, fmt.Sprintf(e2e.ValidatorLogFileName, i)))
-		if err != nil {
-			t.Fatal(err)
-		}
-		LogErrorOutput(t, validatorLogFile, "validator client", i)
+		// validatorLogFile, err := os.Open(path.Join(e2e.TestParams.LogPath, fmt.Sprintf(e2e.ValidatorLogFileName, i)))
+		// if err != nil {
+		// 	t.Fatal(err)
+		// }
+		// LogErrorOutput(t, validatorLogFile, "validator client", i)
 	}
 
 	t.Logf("Ending time: %s\n", time.Now().String())

testing/endtoend/mainnet_e2e_test.go

@@ -6,9 +6,12 @@ import (
 	"strconv"
 	"testing"
 
+	cmdshared "github.com/prysmaticlabs/prysm/cmd"
+	"github.com/prysmaticlabs/prysm/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/config/params"
 	ev "github.com/prysmaticlabs/prysm/testing/endtoend/evaluators"
 	"github.com/prysmaticlabs/prysm/testing/endtoend/helpers"
+	e2e "github.com/prysmaticlabs/prysm/testing/endtoend/params"
 	e2eParams "github.com/prysmaticlabs/prysm/testing/endtoend/params"
 	"github.com/prysmaticlabs/prysm/testing/endtoend/types"
 	"github.com/prysmaticlabs/prysm/testing/require"
@@ -18,8 +21,78 @@ func TestEndToEnd_MainnetConfig(t *testing.T) {
 	e2eMainnet(t, false /*usePrysmSh*/)
 }
 
+func TestEndToeNd_MainnetConfig_Prater(t *testing.T) {
+	// params.UseE2EMainnetConfig()
+	require.NoError(t, e2eParams.Init(1))
+
+	// Run for 10 epochs if not in long-running to confirm long-running has no issues.
+	var err error
+	epochsToRun := 10
+	epochStr, longRunning := os.LookupEnv("E2E_EPOCHS")
+	if longRunning {
+		epochsToRun, err = strconv.Atoi(epochStr)
+		require.NoError(t, err)
+	}
+	evals := []types.Evaluator{
+		// ev.PeersConnect,
+		// ev.HealthzCheck,
+		// ev.MetricsCheck,
+		// ev.ValidatorsAreActive,
+		// ev.ValidatorsParticipatingAtEpoch(2),
+		// ev.FinalizationOccurs(3),
+		// ev.ProposeVoluntaryExit,
+		// ev.ValidatorHasExited,
+		// ev.ColdStateCheckpoint,
+		// ev.ForkTransition,
+		// ev.APIMiddlewareVerifyIntegrity,
+		// ev.APIGatewayV1Alpha1VerifyIntegrity,
+		ev.FinishedSyncing,
+		// ev.AllNodesHaveSameHead,
+	}
+	index := 0
+	testConfig := &types.E2EConfig{
+		BeaconFlags: []string{
+			"--" + cmdshared.DataDirFlag.Name + "=/tmp/beacon-chain-data",
+			// fmt.Sprintf("--%s=%s/eth2-beacon-node-%d", cmdshared.DataDirFlag.Name, e2e.TestParams.TestPath, index),
+			// fmt.Sprintf("--%s=%s", cmdshared.LogFileName.Name, stdOutFile.Name()),
+			// fmt.Sprintf("--%s=%s", flags.DepositContractFlag.Name, e2e.TestParams.ContractAddress.Hex()),
+			fmt.Sprintf("--%s=%d", flags.RPCPort.Name, e2e.TestParams.BeaconNodeRPCPort+index),
+			fmt.Sprintf("--%s=https://goerli.infura.io/v3/c0c32ccb156047038de5b28f343313bd", flags.HTTPWeb3ProviderFlag.Name),
+			fmt.Sprintf("--%s=%d", flags.MinSyncPeers.Name, e2e.TestParams.BeaconNodeCount-1),
+			fmt.Sprintf("--%s=%d", cmdshared.P2PUDPPort.Name, e2e.TestParams.BeaconNodeRPCPort+index+e2e.PrysmBeaconUDPOffset),
+			fmt.Sprintf("--%s=%d", cmdshared.P2PTCPPort.Name, e2e.TestParams.BeaconNodeRPCPort+index+e2e.PrysmBeaconTCPOffset),
+			// fmt.Sprintf("--%s=%d", cmdshared.P2PMaxPeers.Name, expectedNumOfPeers),
+			fmt.Sprintf("--%s=%d", flags.MonitoringPortFlag.Name, e2e.TestParams.BeaconNodeMetricsPort+index),
+			fmt.Sprintf("--%s=%d", flags.GRPCGatewayPort.Name, e2e.TestParams.BeaconNodeRPCPort+index+e2e.PrysmBeaconGatewayOffset),
+			// fmt.Sprintf("--%s=%d", flags.ContractDeploymentBlock.Name, 0),
+			// fmt.Sprintf("--%s=%d", flags.MinPeersPerSubnet.Name, 0),
+			fmt.Sprintf("--%s=%d", cmdshared.RPCMaxPageSizeFlag.Name, params.BeaconConfig().MinGenesisActiveValidatorCount),
+			// fmt.Sprintf("--%s=%s", cmdshared.BootstrapNode.Name, enr),
+			fmt.Sprintf("--%s=%s", cmdshared.VerbosityFlag.Name, "debug"),
+			// "--" + cmdshared.ForceClearDB.Name,
+			// "--" + cmdshared.E2EConfigFlag.Name,
+			"--" + cmdshared.AcceptTosFlag.Name,
+			"--" + flags.EnableDebugRPCEndpoints.Name,
+			"--prater",
+			"--dev",
+		},
+		ValidatorFlags:          []string{},
+		EpochsToRun:             uint64(epochsToRun),
+		TestSync:                true,
+		TestDeposits:            false,
+		UseFixedPeerIDs:         false,
+		UseValidatorCrossClient: false,
+		UsePrysmShValidator:     false,
+		UsePprof:                false,
+		NoModifyBeaconFlags:     true,
+		Evaluators:              evals,
+	}
+
+	newTestRunner(t, testConfig).run()
+}
+
 func e2eMainnet(t *testing.T, usePrysmSh bool) {
-	params.UseE2EMainnetConfig()
+	// params.UseE2EMainnetConfig()
 	require.NoError(t, e2eParams.InitMultiClient(e2eParams.StandardBeaconCount, e2eParams.StandardLighthouseNodeCount))
 
 	// Run for 10 epochs if not in long-running to confirm long-running has no issues.

testing/endtoend/types/types.go

@@ -14,6 +14,7 @@ type E2EConfig struct {
 	TestSync                bool
 	UsePrysmShValidator     bool
 	UsePprof                bool
+	NoModifyBeaconFlags     bool
 	UseWeb3RemoteSigner     bool
 	TestDeposits            bool
 	UseFixedPeerIDs         bool