Remove unused polygon sync flags

cmd/devnet/args/node_args.go

@@ -68,7 +68,6 @@ type NodeArgs struct {
 	StaticPeers               string `arg:"--staticpeers" json:"staticpeers,omitempty"`
 	WithoutHeimdall           bool   `arg:"--bor.withoutheimdall" flag:"" default:"false" json:"bor.withoutheimdall,omitempty"`
 	HeimdallURL               string `arg:"--bor.heimdall" json:"bor.heimdall,omitempty"`
-	WithHeimdallMilestones    bool   `arg:"--bor.milestone" json:"bor.milestone"`
 	VMDebug                   bool   `arg:"--vmdebug" flag:"" default:"false" json:"dmdebug"`
 
 	NodeKey    *ecdsa.PrivateKey `arg:"-"`
@@ -118,8 +117,6 @@ func (node *NodeArgs) Configure(base NodeArgs, nodeNumber int) error {
 
 	node.Port = base.Port + nodeNumber
 
-	node.WithHeimdallMilestones = base.WithHeimdallMilestones
-
 	return nil
 }
 

cmd/devnet/args/node_args_test.go

@@ -179,7 +179,6 @@ func producingNodeArgs(dataDir string, nodeNumber int) []string {
 	authrpcPortArg, _ := parameterFromArgument("--authrpc.port", "8551")
 	natArg, _ := parameterFromArgument("--nat", "none")
 	accountSlotsArg, _ := parameterFromArgument("--txpool.accountslots", "16")
-	withHeimdallMilestonesArg, _ := parameterFromArgument("--bor.milestone", "false")
 
 	return []string{
 		buildDirArg,
@@ -198,7 +197,6 @@ func producingNodeArgs(dataDir string, nodeNumber int) []string {
 		p2pProtocol,
 		downloaderArg,
 		accountSlotsArg,
-		withHeimdallMilestonesArg,
 	}
 }
 
@@ -219,7 +217,6 @@ func nonProducingNodeArgs(dataDir string, nodeNumber int, enode string) []string
 	authrpcPortArg, _ := parameterFromArgument("--authrpc.port", "8551")
 	natArg, _ := parameterFromArgument("--nat", "none")
 	ws := wsArg
-	withHeimdallMilestonesArg, _ := parameterFromArgument("--bor.milestone", "false")
 
 	return []string{
 		buildDirArg,
@@ -238,6 +235,5 @@ func nonProducingNodeArgs(dataDir string, nodeNumber int, enode string) []string
 		torrentPort,
 		p2pProtocol,
 		downloaderArg,
-		withHeimdallMilestonesArg,
 	}
 }

cmd/devnet/devnet/network.go

@@ -33,7 +33,6 @@ import (
 	"github.com/erigontech/erigon-lib/log/v3"
 	"github.com/erigontech/erigon-lib/types"
 	devnet_args "github.com/erigontech/erigon/cmd/devnet/args"
-	"github.com/erigontech/erigon/cmd/utils"
 	"github.com/erigontech/erigon/rpc/requests"
 	erigonapp "github.com/erigontech/erigon/turbo/app"
 	erigoncli "github.com/erigontech/erigon/turbo/cli"
@@ -54,7 +53,6 @@ type Network struct {
 	BorStateSyncDelay  time.Duration
 	BorPeriod          time.Duration
 	BorMinBlockSize    int
-	BorWithMilestones  *bool
 	wg                 sync.WaitGroup
 	peers              []string
 	namedNodes         map[string]Node
@@ -89,12 +87,6 @@ func (nw *Network) Start(ctx context.Context) error {
 		Snapshots:      nw.Snapshots,
 	}
 
-	if nw.BorWithMilestones != nil {
-		baseNode.WithHeimdallMilestones = *nw.BorWithMilestones
-	} else {
-		baseNode.WithHeimdallMilestones = utils.WithHeimdallMilestones.Value
-	}
-
 	nw.namedNodes = map[string]Node{}
 
 	for i, nodeArgs := range nw.Nodes {

cmd/devnet/networks/devnet_bor.go

@@ -31,7 +31,6 @@ import (
 	"github.com/erigontech/erigon/cmd/devnet/devnet"
 	account_services "github.com/erigontech/erigon/cmd/devnet/services/accounts"
 	"github.com/erigontech/erigon/cmd/devnet/services/polygon"
-	"github.com/erigontech/erigon/cmd/utils"
 	"github.com/erigontech/erigon/polygon/bor/borcfg"
 	polychain "github.com/erigontech/erigon/polygon/chain"
 )
@@ -96,7 +95,6 @@ func NewBorDevnetWithHeimdall(
 	checkpointOwner *accounts.Account,
 	producerCount int,
 	gasLimit uint64,
-	withMilestones bool,
 	logger log.Logger,
 	consoleLogLevel log.Lvl,
 	dirLogLevel log.Lvl,
@@ -134,7 +132,6 @@ func NewBorDevnetWithHeimdall(
 		BaseRPCHost:        baseRpcHost,
 		BaseRPCPort:        baseRpcPort,
 		BorStateSyncDelay:  5 * time.Second,
-		BorWithMilestones:  &withMilestones,
 		Services:           append(services, account_services.NewFaucet(networkname.BorDevnet, faucetSource)),
 		Genesis: &types.Genesis{
 			Alloc: types.GenesisAlloc{
@@ -205,7 +202,6 @@ func NewBorDevnetWithRemoteHeimdall(
 ) devnet.Devnet {
 	heimdallURL := ""
 	checkpointOwner := accounts.NewAccount("checkpoint-owner")
-	withMilestones := utils.WithHeimdallMilestones.Value
 	return NewBorDevnetWithHeimdall(
 		dataDir,
 		baseRpcHost,
@@ -215,7 +211,6 @@ func NewBorDevnetWithRemoteHeimdall(
 		checkpointOwner,
 		producerCount,
 		gasLimit,
-		withMilestones,
 		logger,
 		consoleLogLevel,
 		dirLogLevel)
@@ -260,7 +255,5 @@ func NewBorDevnetWithLocalHeimdall(
 		checkpointOwner,
 		producerCount,
 		gasLimit,
-		// milestones are not supported yet on the local heimdall
-		false,
 		logger, consoleLogLevel, dirLogLevel)
 }

cmd/rpcdaemon/cli/config.go

@@ -102,7 +102,6 @@ var rootCmd = &cobra.Command{
 
 var (
 	stateCacheStr string
-	polygonSync   bool
 )
 
 type HeimdallReader interface {
@@ -125,7 +124,6 @@ func RootCommand() (*cobra.Command, *httpcfg.HttpCfg) {
 	rootCmd.PersistentFlags().BoolVar(&cfg.GraphQLEnabled, "graphql", false, "enables graphql endpoint (disabled by default)")
 	rootCmd.PersistentFlags().Uint64Var(&cfg.Gascap, "rpc.gascap", 50_000_000, "Sets a cap on gas that can be used in eth_call/estimateGas")
 	rootCmd.PersistentFlags().Uint64Var(&cfg.MaxTraces, "trace.maxtraces", 200, "Sets a limit on traces that can be returned in trace_filter")
-	rootCmd.PersistentFlags().BoolVar(&polygonSync, "polygon.sync", true, "Enable if Erigon has been synced using the new polygon sync component")
 
 	rootCmd.PersistentFlags().StringVar(&cfg.RpcAllowListFilePath, utils.RpcAccessListFlag.Name, "", "Specify granular (method-by-method) API allowlist")
 	rootCmd.PersistentFlags().UintVar(&cfg.RpcBatchConcurrency, utils.RpcBatchConcurrencyFlag.Name, 2, utils.RpcBatchConcurrencyFlag.Usage)
@@ -434,14 +432,8 @@ func RemoteServices(ctx context.Context, cfg *httpcfg.HttpCfg, logger log.Logger
 		allSnapshots = freezeblocks.NewRoSnapshots(cfg.Snap, cfg.Dirs.Snap, 0, logger)
 		allBorSnapshots = heimdall.NewRoSnapshots(cfg.Snap, cfg.Dirs.Snap, 0, logger)
 
-		if polygonSync {
-			heimdallStore = heimdall.NewSnapshotStore(heimdall.NewMdbxStore(logger, cfg.Dirs.DataDir, true, roTxLimit), allBorSnapshots)
-			bridgeStore = bridge.NewSnapshotStore(bridge.NewMdbxStore(cfg.Dirs.DataDir, logger, true, roTxLimit), allBorSnapshots, cc.Bor)
-		} else {
-			bridgeStore = bridge.NewSnapshotStore(bridge.NewDbStore(rawDB), allBorSnapshots, cc.Bor)
-			heimdallStore = heimdall.NewSnapshotStore(heimdall.NewDbStore(rawDB), allBorSnapshots)
-		}
-
+		heimdallStore = heimdall.NewSnapshotStore(heimdall.NewMdbxStore(logger, cfg.Dirs.DataDir, true, roTxLimit), allBorSnapshots)
+		bridgeStore = bridge.NewSnapshotStore(bridge.NewMdbxStore(cfg.Dirs.DataDir, logger, true, roTxLimit), allBorSnapshots, cc.Bor)
 		blockReader = freezeblocks.NewBlockReader(allSnapshots, allBorSnapshots, heimdallStore, bridgeStore)
 		txNumsReader := blockReader.TxnumReader(ctx)
 
@@ -574,29 +566,27 @@ func RemoteServices(ctx context.Context, cfg *httpcfg.HttpCfg, logger log.Logger
 
 	if cfg.WithDatadir {
 		if cc != nil && cc.Bor != nil {
-			if polygonSync {
-				stateReceiverContractAddress := cc.Bor.StateReceiverContractAddress()
-
-				bridgeConfig := bridge.ReaderConfig{
-					Store:                        bridgeStore,
-					Logger:                       logger,
-					StateReceiverContractAddress: stateReceiverContractAddress,
-					RoTxLimit:                    roTxLimit,
-				}
-				bridgeReader, err = bridge.AssembleReader(ctx, bridgeConfig)
-				if err != nil {
-					return nil, nil, nil, nil, nil, nil, nil, ff, nil, nil, err
-				}
+			stateReceiverContractAddress := cc.Bor.StateReceiverContractAddress()
 
-				heimdallConfig := heimdall.ReaderConfig{
-					Store:     heimdallStore,
-					BorConfig: cc.Bor.(*borcfg.BorConfig),
-					Logger:    logger,
-				}
-				heimdallReader, err = heimdall.AssembleReader(ctx, heimdallConfig)
-				if err != nil {
-					return nil, nil, nil, nil, nil, nil, nil, ff, nil, nil, err
-				}
+			bridgeConfig := bridge.ReaderConfig{
+				Store:                        bridgeStore,
+				Logger:                       logger,
+				StateReceiverContractAddress: stateReceiverContractAddress,
+				RoTxLimit:                    roTxLimit,
+			}
+			bridgeReader, err = bridge.AssembleReader(ctx, bridgeConfig)
+			if err != nil {
+				return nil, nil, nil, nil, nil, nil, nil, ff, nil, nil, err
+			}
+
+			heimdallConfig := heimdall.ReaderConfig{
+				Store:     heimdallStore,
+				BorConfig: cc.Bor.(*borcfg.BorConfig),
+				Logger:    logger,
+			}
+			heimdallReader, err = heimdall.AssembleReader(ctx, heimdallConfig)
+			if err != nil {
+				return nil, nil, nil, nil, nil, nil, nil, ff, nil, nil, err
 			}
 
 			// NOTE: bor_* RPCs are not fully supported when using polygon.sync (https://github.com/erigontech/erigon/issues/11171)
@@ -630,13 +620,10 @@ func RemoteServices(ctx context.Context, cfg *httpcfg.HttpCfg, logger log.Logger
 			}
 		}
 	} else {
-		if polygonSync {
-			remoteBridgeReader = bridge.NewRemoteReader(remoteBridgeClient)
-			bridgeReader = remoteBridgeReader
-
-			remoteHeimdallReader = heimdall.NewRemoteReader(remoteHeimdallClient)
-			heimdallReader = remoteHeimdallReader
-		}
+		remoteBridgeReader = bridge.NewRemoteReader(remoteBridgeClient)
+		bridgeReader = remoteBridgeReader
+		remoteHeimdallReader = heimdall.NewRemoteReader(remoteHeimdallClient)
+		heimdallReader = remoteHeimdallReader
 
 		remoteCE = &remoteConsensusEngine{}
 		engine = remoteCE

cmd/utils/flags.go

@@ -798,26 +798,6 @@ var (
 		Usage: "Ignore the bor block period and wait for 'blocksize' transactions (for testing purposes)",
 	}
 
-	// TODO - this is a depricated flag - should be removed
-	WithHeimdallMilestones = cli.BoolFlag{
-		Name:  "bor.milestone",
-		Usage: "Enabling bor milestone processing",
-		Value: true,
-	}
-
-	// TODO - this is a depricated flag - should be removed
-	WithHeimdallWaypoints = cli.BoolFlag{
-		Name:  "bor.waypoints",
-		Usage: "Enabling bor waypont recording",
-		Value: false,
-	}
-
-	PolygonSyncFlag = cli.BoolFlag{
-		Name:  "polygon.sync",
-		Usage: "Enabling syncing using the new polygon sync component",
-		Value: true,
-	}
-
 	AAFlag = cli.BoolFlag{
 		Name:  "aa",
 		Usage: "Enable AA transactions",
@@ -1720,16 +1700,8 @@ func setClique(ctx *cli.Context, cfg *chainspec.ConsensusSnapshotConfig, datadir
 func setBorConfig(ctx *cli.Context, cfg *ethconfig.Config, nodeConfig *nodecfg.Config, logger log.Logger) {
 	cfg.HeimdallURL = ctx.String(HeimdallURLFlag.Name)
 	cfg.WithoutHeimdall = ctx.Bool(WithoutHeimdallFlag.Name)
-	cfg.WithHeimdallMilestones = ctx.Bool(WithHeimdallMilestones.Name)
-	cfg.WithHeimdallWaypointRecording = ctx.Bool(WithHeimdallWaypoints.Name)
-	cfg.PolygonSync = ctx.Bool(PolygonSyncFlag.Name)
-
-	if cfg.PolygonSync {
-		cfg.WithHeimdallMilestones = false
-		cfg.WithHeimdallWaypointRecording = true
-	}
 
-	heimdall.RecordWayPoints(cfg.WithHeimdallWaypointRecording || cfg.PolygonSync)
+	heimdall.RecordWayPoints(true)
 
 	chainConfig := chainspec.ChainConfigByChainName(ctx.String(ChainFlag.Name))
 	if chainConfig != nil && chainConfig.Bor != nil && !ctx.IsSet(MaxPeersFlag.Name) {

eth/backend.go

@@ -624,40 +624,38 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger
 			heimdallClient = heimdall.NewIdleClient(config.Miner)
 		}
 
-		if config.PolygonSync {
-			borConfig := consensusConfig.(*borcfg.BorConfig)
-
-			polygonBridge = bridge.NewService(bridge.ServiceConfig{
-				Store:        bridgeStore,
-				Logger:       logger,
-				BorConfig:    borConfig,
-				EventFetcher: heimdallClient,
-			})
+		borConfig := consensusConfig.(*borcfg.BorConfig)
 
-			if err := heimdallStore.Milestones().Prepare(ctx); err != nil {
-				return nil, err
-			}
+		polygonBridge = bridge.NewService(bridge.ServiceConfig{
+			Store:        bridgeStore,
+			Logger:       logger,
+			BorConfig:    borConfig,
+			EventFetcher: heimdallClient,
+		})
 
-			_, err := heimdallStore.Milestones().DeleteFromBlockNum(ctx, 0)
-			if err != nil {
-				return nil, err
-			}
+		if err := heimdallStore.Milestones().Prepare(ctx); err != nil {
+			return nil, err
+		}
 
-			heimdallService = heimdall.NewService(heimdall.ServiceConfig{
-				Store:     heimdallStore,
-				BorConfig: borConfig,
-				Client:    heimdallClient,
-				Logger:    logger,
-			})
+		_, err := heimdallStore.Milestones().DeleteFromBlockNum(ctx, 0)
+		if err != nil {
+			return nil, err
+		}
 
-			bridgeRPC = bridge.NewBackendServer(ctx, polygonBridge)
-			heimdallRPC = heimdall.NewBackendServer(ctx, heimdallService)
+		heimdallService = heimdall.NewService(heimdall.ServiceConfig{
+			Store:     heimdallStore,
+			BorConfig: borConfig,
+			Client:    heimdallClient,
+			Logger:    logger,
+		})
 
-			backend.polygonBridge = polygonBridge
-			backend.heimdallService = heimdallService
-		}
+		bridgeRPC = bridge.NewBackendServer(ctx, polygonBridge)
+		heimdallRPC = heimdall.NewBackendServer(ctx, heimdallService)
 
-		flags.Milestone = config.WithHeimdallMilestones
+		backend.polygonBridge = polygonBridge
+		backend.heimdallService = heimdallService
+
+		flags.Milestone = false
 	}
 
 	backend.engine = ethconsensusconfig.CreateConsensusEngine(ctx, stack.Config(), chainConfig, consensusConfig, config.Miner.Notify, config.Miner.Noverify, heimdallClient, config.WithoutHeimdall, blockReader, false /* readonly */, logger, polygonBridge, heimdallService)
@@ -715,7 +713,7 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger
 		}
 	}
 
-	sentryMcDisableBlockDownload := chainConfig.Bor != nil && (config.PolygonSync)
+	sentryMcDisableBlockDownload := chainConfig.Bor != nil
 	backend.sentriesClient, err = sentry_multi_client.NewMultiClient(
 		backend.chainDB,
 		chainConfig,
@@ -865,7 +863,7 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger
 		signatures = bor.Signatures
 	}
 
-	astridEnabled := chainConfig.Bor != nil && config.PolygonSync
+	astridEnabled := chainConfig.Bor != nil
 
 	// proof-of-work mining
 	mining := stagedsync.New(
@@ -1076,7 +1074,7 @@ func New(ctx context.Context, stack *node.Node, config *ethconfig.Config, logger
 		}()
 	}
 
-	if chainConfig.Bor != nil && config.PolygonSync {
+	if chainConfig.Bor != nil {
 		backend.polygonSyncService = polygonsync.NewService(
 			config,
 			logger,
@@ -1553,14 +1551,8 @@ func setUpBlockReader(ctx context.Context, db kv.RwDB, dirs datadir.Dirs, snConf
 
 	if chainConfig.Bor != nil {
 		allBorSnapshots = heimdall.NewRoSnapshots(snConfig.Snapshot, dirs.Snap, minFrozenBlock, logger)
-
-		if snConfig.PolygonSync {
-			bridgeStore = bridge.NewSnapshotStore(bridge.NewMdbxStore(dirs.DataDir, logger, false, int64(nodeConfig.Http.DBReadConcurrency)), allBorSnapshots, chainConfig.Bor)
-			heimdallStore = heimdall.NewSnapshotStore(heimdall.NewMdbxStore(logger, dirs.DataDir, false, int64(nodeConfig.Http.DBReadConcurrency)), allBorSnapshots)
-		} else {
-			bridgeStore = bridge.NewSnapshotStore(bridge.NewDbStore(db), allBorSnapshots, chainConfig.Bor)
-			heimdallStore = heimdall.NewSnapshotStore(heimdall.NewDbStore(db), allBorSnapshots)
-		}
+		bridgeStore = bridge.NewSnapshotStore(bridge.NewMdbxStore(dirs.DataDir, logger, false, int64(nodeConfig.Http.DBReadConcurrency)), allBorSnapshots, chainConfig.Bor)
+		heimdallStore = heimdall.NewSnapshotStore(heimdall.NewMdbxStore(logger, dirs.DataDir, false, int64(nodeConfig.Http.DBReadConcurrency)), allBorSnapshots)
 	}
 	blockReader := freezeblocks.NewBlockReader(allSnapshots, allBorSnapshots, heimdallStore, bridgeStore)
 
@@ -1648,7 +1640,7 @@ func (s *Ethereum) Start() error {
 		diagnostics.Send(diagnostics.SyncStageList{StagesList: diagnostics.InitStagesFromList(s.pipelineStagedSync.StagesIdsList())})
 		s.waitForStageLoopStop = nil // TODO: Ethereum.Stop should wait for execution_server shutdown
 		go s.eth1ExecutionServer.Start(s.sentryCtx)
-	} else if s.chainConfig.Bor != nil && s.config.PolygonSync {
+	} else if s.chainConfig.Bor != nil {
 		diagnostics.Send(diagnostics.SyncStageList{StagesList: diagnostics.InitStagesFromList(s.stagedSync.StagesIdsList())})
 		s.waitForStageLoopStop = nil // Shutdown is handled by context
 		s.bgComponentsEg.Go(func() error {