Resp/Req support for Deneb

cl/clparams/config.go

@@ -502,6 +502,7 @@ func configForkSchedule(b *BeaconChainConfig) map[[VersionLength]byte]uint64 {
 	fvs[utils.Uint32ToBytes4(b.AltairForkVersion)] = b.AltairForkEpoch
 	fvs[utils.Uint32ToBytes4(b.BellatrixForkVersion)] = b.BellatrixForkEpoch
 	fvs[utils.Uint32ToBytes4(b.CapellaForkVersion)] = b.CapellaForkEpoch
+	fvs[utils.Uint32ToBytes4(b.DenebForkVersion)] = b.DenebForkEpoch
 	return fvs
 }
 
@@ -511,6 +512,7 @@ func configForkNames(b *BeaconChainConfig) map[[VersionLength]byte]string {
 	fvn[utils.Uint32ToBytes4(b.AltairForkVersion)] = "altair"
 	fvn[utils.Uint32ToBytes4(b.BellatrixForkVersion)] = "bellatrix"
 	fvn[utils.Uint32ToBytes4(b.CapellaForkVersion)] = "capella"
+	fvn[utils.Uint32ToBytes4(b.DenebForkVersion)] = "deneb"
 	return fvn
 }
 
@@ -732,16 +734,16 @@ func CustomConfig(configFile string) (BeaconChainConfig, error) {
 	return cfg, err
 }
 
-func ParseGenesisSSZToGenesisConfig(genesisFile string) (GenesisConfig, error) {
+func ParseGenesisSSZToGenesisConfig(genesisFile string, genesisVersion StateVersion) (GenesisConfig, []byte, error) {
 	cfg := GenesisConfig{}
 	b, err := os.ReadFile(genesisFile) // just pass the file name
 	if err != nil {
-		return GenesisConfig{}, nil
+		return GenesisConfig{}, nil, err
 	}
 	// Read first 2 fields of SSZ
 	cfg.GenesisTime = ssz.UnmarshalUint64SSZ(b)
 	copy(cfg.GenesisValidatorRoot[:], b[8:])
-	return cfg, nil
+	return cfg, b, nil
 }
 
 func sepoliaConfig() BeaconChainConfig {

cl/fork/fork.go

@@ -31,8 +31,8 @@ import (
 
 func ForkDigestVersion(digest [4]byte, b *clparams.BeaconChainConfig, genesisValidatorRoot libcommon.Hash) (clparams.StateVersion, error) {
 	var (
-		phase0ForkDigest, altairForkDigest, bellatrixForkDigest, capellaForkDigest [4]byte
-		err                                                                        error
+		phase0ForkDigest, altairForkDigest, bellatrixForkDigest, capellaForkDigest, denebForkDigest [4]byte
+		err                                                                                         error
 	)
 	phase0ForkDigest, err = ComputeForkDigestForVersion(
 		utils.Uint32ToBytes4(b.GenesisForkVersion),
@@ -65,6 +65,14 @@ func ForkDigestVersion(digest [4]byte, b *clparams.BeaconChainConfig, genesisVal
 	if err != nil {
 		return 0, err
 	}
+
+	denebForkDigest, err = ComputeForkDigestForVersion(
+		utils.Uint32ToBytes4(b.DenebForkVersion),
+		genesisValidatorRoot,
+	)
+	if err != nil {
+		return 0, err
+	}
 	switch digest {
 	case phase0ForkDigest:
 		return clparams.Phase0Version, nil
@@ -74,6 +82,8 @@ func ForkDigestVersion(digest [4]byte, b *clparams.BeaconChainConfig, genesisVal
 		return clparams.BellatrixVersion, nil
 	case capellaForkDigest:
 		return clparams.CapellaVersion, nil
+	case denebForkDigest:
+		return clparams.DenebVersion, nil
 	}
 	return 0, fmt.Errorf("invalid state version")
 }
@@ -99,7 +109,6 @@ func ComputeForkDigest(
 		}
 		break
 	}
-
 	return ComputeForkDigestForVersion(currentForkVersion, genesisConfig.GenesisValidatorRoot)
 }
 

cl/phase1/network/beacon_downloader.go

@@ -67,7 +67,7 @@ func (f *ForwardBeaconDownloader) HighestProcessedRoot() libcommon.Hash {
 }
 
 func (f *ForwardBeaconDownloader) RequestMore() {
-	count := uint64(4) // dont need many
+	count := uint64(16) // dont need many
 	responses, pid, err := f.rpc.SendBeaconBlocksByRangeReq(f.highestSlotProcessed+1, count)
 	if err != nil {
 		f.rpc.BanPeer(pid)

cl/phase1/stages/stage_fork_choice.go

@@ -160,10 +160,16 @@ MainLoop:
 			time.Sleep(waitWhenNotEnoughPeers)
 			continue
 		}
+		highestSeen := cfg.forkChoice.HighestSeen()
+		startDownloadSlot := highestSeen - uint64(maxBlockBehindBeforeDownload)
+		// Detect underflow
+		if startDownloadSlot > highestSeen {
+			startDownloadSlot = 0
+		}
 
 		cfg.downloader.SetHighestProcessedRoot(libcommon.Hash{})
 		cfg.downloader.SetHighestProcessedSlot(
-			utils.Max64(cfg.forkChoice.HighestSeen()-uint64(maxBlockBehindBeforeDownload), cfg.forkChoice.AnchorSlot()))
+			utils.Max64(startDownloadSlot, cfg.forkChoice.AnchorSlot()))
 
 		// Wait small time
 		log.Debug("Caplin may have missed some slots, started downloading chain")

cmd/caplin-phase1/main.go

@@ -19,6 +19,7 @@ import (
 	"os"
 
 	"github.com/ledgerwatch/erigon/cl/phase1/core"
+	"github.com/ledgerwatch/erigon/cl/phase1/core/state"
 	"github.com/ledgerwatch/erigon/cl/phase1/execution_client"
 
 	"github.com/ledgerwatch/erigon-lib/gointerfaces/remote"
@@ -38,7 +39,7 @@ import (
 )
 
 func main() {
-	app := lightclientapp.MakeApp("caplin-phase1", runCaplinNode, flags.LCDefaultFlags)
+	app := lightclientapp.MakeApp("caplin-phase1", runCaplinNode, flags.CLDefaultFlags)
 	if err := app.Run(os.Args); err != nil {
 		_, printErr := fmt.Fprintln(os.Stderr, err)
 		if printErr != nil {
@@ -60,9 +61,15 @@ func runCaplinNode(cliCtx *cli.Context) error {
 	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(cfg.LogLvl), log.StderrHandler))
 	log.Info("[Phase1]", "chain", cliCtx.String(flags.Chain.Name))
 	log.Info("[Phase1] Running Caplin", "cfg", cfg)
-	state, err := core.RetrieveBeaconState(ctx, cfg.BeaconCfg, cfg.GenesisCfg, cfg.CheckpointUri)
-	if err != nil {
-		return err
+	// Either start from genesis or a checkpoint
+	var state *state.BeaconState
+	if cfg.InitialSync {
+		state = cfg.InitalState
+	} else {
+		state, err = core.RetrieveBeaconState(ctx, cfg.BeaconCfg, cfg.GenesisCfg, cfg.CheckpointUri)
+		if err != nil {
+			return err
+		}
 	}
 
 	forkDigest, err := fork.ComputeForkDigest(cfg.BeaconCfg, cfg.GenesisCfg)

cmd/sentinel/cli/cliSettings.go

@@ -2,7 +2,9 @@ package cli
 
 import (
 	"fmt"
+
 	"github.com/ledgerwatch/erigon/cl/phase1/core/rawdb"
+	"github.com/ledgerwatch/erigon/cl/phase1/core/state"
 
 	"github.com/ledgerwatch/erigon/cmd/utils"
 	"github.com/urfave/cli/v2"
@@ -30,7 +32,10 @@ type ConsensusClientCliCfg struct {
 	Chaindata        string                      `json:"chaindata"`
 	ErigonPrivateApi string                      `json:"erigonPrivateApi"`
 	TransitionChain  bool                        `json:"transitionChain"`
-	NetworkType      clparams.NetworkType
+	NetworkType      clparams.NetworkType        `json:"networkType"`
+	InitialSync      bool                        `json:"initialSync"`
+
+	InitalState *state.BeaconState
 }
 
 func SetupConsensusClientCfg(ctx *cli.Context) (*ConsensusClientCliCfg, error) {
@@ -51,8 +56,15 @@ func SetupConsensusClientCfg(ctx *cli.Context) (*ConsensusClientCliCfg, error) {
 			return nil, fmt.Errorf("no genesis file provided")
 		}
 		cfg.GenesisCfg = new(clparams.GenesisConfig)
+		var stateByte []byte
 		// Now parse genesis time and genesis fork
-		if *cfg.GenesisCfg, err = clparams.ParseGenesisSSZToGenesisConfig(ctx.String(flags.GenesisSSZFlag.Name)); err != nil {
+		if *cfg.GenesisCfg, stateByte, err = clparams.ParseGenesisSSZToGenesisConfig(
+			ctx.String(flags.GenesisSSZFlag.Name),
+			cfg.BeaconCfg.GetCurrentStateVersion(0)); err != nil {
+			return nil, err
+		}
+		cfg.InitalState = state.New(cfg.BeaconCfg)
+		if cfg.InitalState.DecodeSSZ(stateByte, int(cfg.BeaconCfg.GetCurrentStateVersion(0))); err != nil {
 			return nil, err
 		}
 	}
@@ -82,7 +94,9 @@ func SetupConsensusClientCfg(ctx *cli.Context) (*ConsensusClientCliCfg, error) {
 	}
 	if ctx.String(flags.SentinelStaticPeersFlag.Name) != "" {
 		cfg.NetworkCfg.StaticPeers = utils.SplitAndTrim(ctx.String(flags.SentinelStaticPeersFlag.Name))
+		fmt.Println(cfg.NetworkCfg.StaticPeers)
 	}
 	cfg.TransitionChain = ctx.Bool(flags.TransitionChainFlag.Name)
+	cfg.InitialSync = ctx.Bool(flags.InitSyncFlag.Name)
 	return cfg, nil
 }

cmd/sentinel/cli/flags/defaultFlags.go

@@ -18,22 +18,5 @@ var CLDefaultFlags = []cli.Flag{
 	&CheckpointSyncUrlFlag,
 	&SentinelStaticPeersFlag,
 	&TransitionChainFlag,
-}
-
-var LCDefaultFlags = []cli.Flag{
-	&SentinelDiscoveryPort,
-	&SentinelDiscoveryAddr,
-	&SentinelServerPort,
-	&SentinelServerAddr,
-	&Chain,
-	&SentinelTcpPort,
-	&NoDiscovery,
-	&ChaindataFlag,
-	&BeaconDBModeFlag,
-	&BootnodesFlag,
-	&BeaconConfigFlag,
-	&GenesisSSZFlag,
-	&CheckpointSyncUrlFlag,
-	&SentinelStaticPeersFlag,
-	&ErigonPrivateApiFlag,
+	&InitSyncFlag,
 }

cmd/sentinel/cli/flags/flags.go

@@ -82,4 +82,9 @@ var (
 		Name:  "transition-chain",
 		Usage: "enable chain transition",
 	}
+	InitSyncFlag = cli.BoolFlag{
+		Value: false,
+		Name:  "initial-sync",
+		Usage: "use initial-sync",
+	}
 )

cmd/sentinel/sentinel/config.go

@@ -96,7 +96,7 @@ func buildOptions(cfg *SentinelConfig, s *Sentinel) ([]libp2p.Option, error) {
 	options := []libp2p.Option{
 		privKeyOption(priKey),
 		libp2p.ListenAddrs(listen),
-		libp2p.UserAgent("erigon/lightclient"),
+		libp2p.UserAgent("erigon/caplin"),
 		libp2p.Transport(tcp.NewTCPTransport),
 		libp2p.Muxer("/mplex/6.7.0", mplex.DefaultTransport),
 		libp2p.DefaultMuxers,

cmd/sentinel/sentinel/discovery.go

@@ -72,9 +72,15 @@ func (s *Sentinel) listenForPeers() {
 			log.Warn("Could not connect to static peer", "peer", node, "reason", err)
 		}
 	}
-
+	log.Info("Static peers", "len", len(enodes))
+	if s.cfg.NoDiscovery {
+		return
+	}
 	multiAddresses := convertToMultiAddr(enodes)
-	s.connectWithAllPeers(multiAddresses)
+	if err := s.connectWithAllPeers(multiAddresses); err != nil {
+		log.Warn("Could not connect to static peers", "reason", err)
+
+	}
 
 	iterator := s.listener.RandomNodes()
 	defer iterator.Close()

cmd/sentinel/sentinel/handshake/handshake.go

@@ -75,7 +75,6 @@ func (h *HandShaker) ValidatePeer(id peer.ID) bool {
 	}
 
 	data := common.CopyBytes(buffer.Bytes())
-
 	response, errResponse, err := communication.SendRequestRawToPeer(h.ctx, h.host, data, communication.StatusProtocolV1, id)
 	if err != nil || errResponse {
 		return false

cmd/sentinel/sentinel/sentinel.go

@@ -315,9 +315,9 @@ func (s *Sentinel) Start() error {
 		ConnectedF: s.onConnection,
 	})
 	s.subManager = NewGossipManager(s.ctx)
-	if !s.cfg.NoDiscovery {
-		go s.listenForPeers()
-	}
+
+	go s.listenForPeers()
+
 	return nil
 }