From 395fcd3d7309430503b5f6772e3cf80ed2c6231a Mon Sep 17 00:00:00 2001 From: Giulio Date: Mon, 15 May 2023 16:57:28 +0200 Subject: [PATCH] fixed eip4844 network --- cl/clparams/config.go | 8 +++++--- cl/fork/fork.go | 15 ++++++++++++--- cl/phase1/network/beacon_downloader.go | 2 +- cl/phase1/stages/stage_fork_choice.go | 8 +++++++- cmd/caplin-phase1/main.go | 15 +++++++++++---- cmd/sentinel/cli/cliSettings.go | 18 ++++++++++++++++-- cmd/sentinel/cli/flags/defaultFlags.go | 19 +------------------ cmd/sentinel/cli/flags/flags.go | 5 +++++ cmd/sentinel/sentinel/config.go | 2 +- cmd/sentinel/sentinel/discovery.go | 10 ++++++++-- cmd/sentinel/sentinel/handshake/handshake.go | 1 - cmd/sentinel/sentinel/sentinel.go | 6 +++--- 12 files changed, 70 insertions(+), 39 deletions(-) diff --git a/cl/clparams/config.go b/cl/clparams/config.go index 4b188151df8..81313ae96dd 100644 --- a/cl/clparams/config.go +++ b/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 { diff --git a/cl/fork/fork.go b/cl/fork/fork.go index d0e5146eaa3..94d6db9901d 100644 --- a/cl/fork/fork.go +++ b/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) } diff --git a/cl/phase1/network/beacon_downloader.go b/cl/phase1/network/beacon_downloader.go index 83f88ae3d09..3e50215890a 100644 --- a/cl/phase1/network/beacon_downloader.go +++ b/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) diff --git a/cl/phase1/stages/stage_fork_choice.go b/cl/phase1/stages/stage_fork_choice.go index d9de2048c5f..462ccf981cc 100644 --- a/cl/phase1/stages/stage_fork_choice.go +++ b/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") diff --git a/cmd/caplin-phase1/main.go b/cmd/caplin-phase1/main.go index 7c066ae120c..54a91021ec7 100644 --- a/cmd/caplin-phase1/main.go +++ b/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) diff --git a/cmd/sentinel/cli/cliSettings.go b/cmd/sentinel/cli/cliSettings.go index 5d82071669e..74cc52eaf2a 100644 --- a/cmd/sentinel/cli/cliSettings.go +++ b/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 } diff --git a/cmd/sentinel/cli/flags/defaultFlags.go b/cmd/sentinel/cli/flags/defaultFlags.go index 578d33d73b3..244c9045a50 100644 --- a/cmd/sentinel/cli/flags/defaultFlags.go +++ b/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, } diff --git a/cmd/sentinel/cli/flags/flags.go b/cmd/sentinel/cli/flags/flags.go index 3b6fd9087da..6e1b9614cad 100644 --- a/cmd/sentinel/cli/flags/flags.go +++ b/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", + } ) diff --git a/cmd/sentinel/sentinel/config.go b/cmd/sentinel/sentinel/config.go index 5f3f8a840a5..dece3552b47 100644 --- a/cmd/sentinel/sentinel/config.go +++ b/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, diff --git a/cmd/sentinel/sentinel/discovery.go b/cmd/sentinel/sentinel/discovery.go index 9cbf42b840c..9fc24892240 100644 --- a/cmd/sentinel/sentinel/discovery.go +++ b/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() diff --git a/cmd/sentinel/sentinel/handshake/handshake.go b/cmd/sentinel/sentinel/handshake/handshake.go index 8d9f9f61c52..f38a1fe0ab6 100644 --- a/cmd/sentinel/sentinel/handshake/handshake.go +++ b/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 diff --git a/cmd/sentinel/sentinel/sentinel.go b/cmd/sentinel/sentinel/sentinel.go index d121c0c7b00..c0257370e55 100644 --- a/cmd/sentinel/sentinel/sentinel.go +++ b/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 }