cmd

var RunCmd = &cobra.Command{
	Use:     "start",
	Aliases: []string{"node", "run"},
	Short:   "Run the evolve node with EVM execution client",
	RunE: func(cmd *cobra.Command, args []string) error {
		nodeConfig, err := rollcmd.ParseConfig(cmd)
		if err != nil {
			return err
		}

		logger := rollcmd.SetupLogger(nodeConfig.Log)

		datastore, err := store.NewDefaultKVStore(nodeConfig.RootDir, nodeConfig.DBPath, evmDbName)
		if err != nil {
			return err
		}

		tracingEnabled := nodeConfig.Instrumentation.IsTracingEnabled()
		executor, err := createExecutionClient(cmd, datastore, tracingEnabled)
		if err != nil {
			return err
		}

		blobClient, err := blobrpc.NewClient(context.Background(), nodeConfig.DA.Address, nodeConfig.DA.AuthToken, "")
		if err != nil {
			return fmt.Errorf("failed to create blob client: %w", err)
		}

		daClient := block.NewDAClient(blobClient, nodeConfig, logger)

		if ec, ok := executor.(*evm.EngineClient); ok {
			ec.SetLogger(logger.With().Str("module", "engine_client").Logger())
		}

		headerNamespace := da.NamespaceFromString(nodeConfig.DA.GetNamespace())
		dataNamespace := da.NamespaceFromString(nodeConfig.DA.GetDataNamespace())

		logger.Info().Str("headerNamespace", headerNamespace.HexString()).Str("dataNamespace", dataNamespace.HexString()).Msg("namespaces")

		genesisPath := filepath.Join(filepath.Dir(nodeConfig.ConfigPath()), "genesis.json")
		genesis, err := genesispkg.LoadGenesis(genesisPath)
		if err != nil {
			return fmt.Errorf("failed to load genesis: %w", err)
		}

		if genesis.DAStartHeight == 0 && !nodeConfig.Node.Aggregator {
			logger.Warn().Msg("da_start_height is not set in genesis.json, ask your chain developer")
		}

		sequencer, err := createSequencer(logger, datastore, nodeConfig, genesis, daClient)
		if err != nil {
			return err
		}

		nodeKey, err := key.LoadNodeKey(filepath.Dir(nodeConfig.ConfigPath()))
		if err != nil {
			return err
		}

		p2pClient, err := p2p.NewClient(nodeConfig.P2P, nodeKey.PrivKey, datastore, genesis.ChainID, logger, nil)
		if err != nil {
			return err
		}

		forceInclusionAddr, err := cmd.Flags().GetString(flagForceInclusionServer)
		if err != nil {
			return fmt.Errorf("failed to get '%s' flag: %w", flagForceInclusionServer, err)
		}

		if forceInclusionAddr != "" {
			ethURL, err := cmd.Flags().GetString(evm.FlagEvmEthURL)
			if err != nil {
				return fmt.Errorf("failed to get '%s' flag: %w", evm.FlagEvmEthURL, err)
			}

			forceInclusionServer, err := server.NewForceInclusionServer(
				forceInclusionAddr,
				daClient,
				nodeConfig,
				genesis,
				logger,
				ethURL,
			)
			if err != nil {
				return fmt.Errorf("failed to create force inclusion server: %w", err)
			}

			if err := forceInclusionServer.Start(cmd.Context()); err != nil {
				return fmt.Errorf("failed to start force inclusion API server: %w", err)
			}

			defer func() {
				shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
				defer cancel()
				if err := forceInclusionServer.Stop(shutdownCtx); err != nil {
					logger.Error().Err(err).Msg("failed to stop force inclusion API server")
				}
			}()
		}

		return rollcmd.StartNode(logger, cmd, executor, sequencer, p2pClient, datastore, nodeConfig, genesis, node.NodeOptions{})
	},
}