MinaProtocol / mina / 499

open Core

open Async

open Mina_base

open Cli_lib

open Signature_lib

open Init

module YJ = Yojson.Safe

type mina_initialization =

  { mina : Mina_lib.t

  ; client_trustlist : Unix.Cidr.t list option

  ; rest_server_port : int

  ; limited_graphql_port : int option

  ; itn_graphql_port : int option

  }

(* keep this code in sync with Client.chain_id_inputs, Mina_commands.chain_id_inputs, and

   Daemon_rpcs.Chain_id_inputs

*)

let chain_id ~constraint_system_digests ~genesis_state_hash ~genesis_constants

    ~protocol_transaction_version ~protocol_network_version =

  (* if this changes, also change Mina_commands.chain_id_inputs *)

  in

  let protocol_transaction_version_digest =

    version_digest protocol_transaction_version

  in

    version_digest protocol_network_version

  in

    Blake2.digest_string

      ( genesis_state_hash ^ all_snark_keys ^ genesis_constants_hash

      ^ protocol_transaction_version_digest ^ protocol_network_version_digest )

  in

let plugin_flag =

  if Node_config.plugins then

      ~doc:

        "PATH The path to load a .cmxs plugin from. May be passed multiple \

         times"

let load_config_files ~logger ~genesis_constants ~constraint_constants ~conf_dir

    ~genesis_dir ~cli_proof_level ~proof_level config_files =

  let%bind config_jsons =

    let config_files_paths =

    in

      ~metadata:[ ("config_files", `List config_files_paths) ] ;

      ~f:(fun (config_file, handle_missing) ->

            let%map config_json =

                config_json

            in

            match handle_missing with

                Mina_stdlib.Mina_user_error.raisef

                  ~where:"reading configuration file"

                  "The configuration file %s could not be read:\n%s" config_file

                  ~metadata:

                    [ ("config_file", `String config_file)

                    ] ;

  in

    List.fold ~init:Runtime_config.default config_jsons

      ~f:(fun config (config_file, config_json) ->

            Runtime_config.combine config loaded_config

              "Could not parse configuration from $config_file: $error"

              ~metadata:

                [ ("config_file", `String config_file)

                ; ("config_json", config_json)

                ; ("error", `String err)

                ] ;

  in

  let%bind precomputed_values =

    match%map

        ~logger ~genesis_constants ~constraint_constants ~proof_level config

    with

        precomputed_values

        let ( json_config

            , `Accounts_omitted

                ( `Genesis genesis_accounts_omitted

                , `Staking staking_accounts_omitted

                , `Next next_accounts_omitted ) ) =

          Runtime_config.to_yojson_without_accounts config

        in

            ~default:Fn.id

        in

        let metadata =

          append_accounts_omitted "genesis" genesis_accounts_omitted

          @ [ ("config", json_config)

            ; ( "name"

              , `String

                     (let%bind.Option ledger = config.ledger in

            ]

        in

          "Initializing with runtime configuration. Ledger source: $name"

          ~metadata ;

  in

let setup_daemon logger ~itn_features ~default_snark_worker_fee =

  let open Cli_lib.Arg_type in

  let receiver_key_warning = Cli_lib.Default.receiver_key_warning in

  let%map_open conf_dir = Cli_lib.Flag.conf_dir

  and block_production_key =

      ~doc:

           "DEPRECATED: Use environment variable `MINA_BP_PRIVKEY` instead. \

            Private key file for the block producer. Providing this flag or \

            the environment variable will enable block production. You cannot \

            provide both `block-producer-key` and `block-producer-pubkey`. \

            (default: use environment variable `MINA_BP_PRIVKEY`, if provided, \

            or else don't produce any blocks) %s"

           receiver_key_warning )

  and block_production_pubkey =

      ~aliases:[ "block-producer-pubkey" ]

      ~doc:

           "PUBLICKEY Public key for the associated private key that is being \

            tracked by this daemon. You cannot provide both \

            `block-producer-key` (or `MINA_BP_PRIVKEY`) and \

            `block-producer-pubkey`. (default: don't produce blocks) %s"

           receiver_key_warning )

  and block_production_password =

      ~aliases:[ "block-producer-password" ]

      ~doc:

        "PASSWORD Password associated with the block-producer key. Setting \

         this is equivalent to setting the MINA_PRIVKEY_PASS environment \

         variable. Be careful when setting it in the commandline as it will \

         likely get tracked in your history. Mainly to be used from the \

         daemon.json config file"

  and itn_keys =

    if itn_features then

        ~doc:

          "PUBLICKEYS A comma-delimited list of Ed25519 public keys that are \

           permitted to send signed requests to the incentivized testnet \

           GraphQL server"

  and itn_max_logs =

    if itn_features then

        ~doc:

          "NN Maximum number of logs to store to be made available via GraphQL \

           for incentivized testnet"

  and demo_mode =

      ~doc:

        "Run the daemon in demo-mode -- assume we're \"synced\" to the network \

         instantly"

  and coinbase_receiver_flag =

      ~doc:

           "PUBLICKEY Address to send coinbase rewards to (if this node is \

            producing blocks). If not provided, coinbase rewards will be sent \

            to the producer of a block. %s"

           receiver_key_warning )

  and genesis_dir =

      ~doc:

        "DIR Directory that contains the genesis ledger and the genesis \

         blockchain proof (default: <config-dir>)"

  and run_snark_worker_flag =

      ~doc:

           receiver_key_warning )

  and run_snark_coordinator_flag =

      ~aliases:[ "run-snark-coordinator" ]

      ~doc:

           "PUBLICKEY Run a SNARK coordinator with this public key (ignored if \

            the run-snark-worker is set). %s"

           receiver_key_warning )

  and snark_worker_parallelism_flag =

      ~aliases:[ "snark-worker-parallelism" ]

      ~doc:

        "NUM Run the SNARK worker using this many threads. Equivalent to \

         setting OMP_NUM_THREADS, but doesn't affect block production."

  and work_selection_method_flag =

      ~doc:

        "seq|rand|roffset Choose work sequentially (seq), randomly (rand), or \

         sequentially with a random offset (roffset) (default: rand)"

  and libp2p_port = Flag.Port.Daemon.external_

  and client_port = Flag.Port.Daemon.client

  and rest_server_port = Flag.Port.Daemon.rest_server

  and limited_graphql_port = Flag.Port.Daemon.limited_graphql_server

  and itn_graphql_port =

    if itn_features then

        ~doc:"PORT GraphQL-server for incentivized testnet interaction"

  and open_limited_graphql_port =

      ~aliases:[ "open-limited-graphql-port" ]

      no_arg

      ~doc:

        "Have the limited GraphQL server listen on all addresses, not just \

         localhost (this is INSECURE, make sure your firewall is configured \

         correctly!)"

  and archive_process_location = Flag.Host_and_port.Daemon.archive

  and metrics_server_port =

      ~doc:

        "PORT metrics server for scraping via Prometheus (default no \

         metrics-server)"

  and gc_stat_interval =

      ~doc:

           "INTERVAL in mins for collecting GC stats for metrics (Default: %f)"

           !Mina_metrics.Runtime.gc_stat_interval_mins )

  and libp2p_metrics_port =

      ~doc:

        "PORT libp2p metrics server for scraping via Prometheus (default no \

         libp2p-metrics-server)"

  and external_ip_opt =

      ~doc:

        "IP External IP address for other nodes to connect to. You only need \

         to set this if auto-discovery fails for some reason."

  and bind_ip_opt =

      ~doc:"IP IP of network interface to use for peer connections"

  and working_dir =

      ~doc:

        "PATH path to chdir into before starting (useful for background mode, \

         defaults to cwd, or / if -background)"

  and is_background =

      ~doc:"Run process on the background"

  and is_archive_rocksdb =

      ~doc:"Stores all the blocks heard in RocksDB"

  and log_json = Flag.Log.json

  and log_level = Flag.Log.level

  and file_log_level = Flag.Log.file_log_level

  and file_log_rotations = Flag.Log.file_log_rotations

  and snark_work_fee =

      ~doc:

           "FEE Amount a worker wants to get compensated for generating a \

            snark proof (default: %d)"

  and work_reassignment_wait =

      ~aliases:[ "work-reassignment-wait" ]

      ~doc:

           "WAIT-TIME in ms before a snark-work is reassigned (default: %dms)"

           Cli_lib.Default.work_reassignment_wait )

  and enable_tracing =

      ~doc:"Trace into $config-directory/trace/$pid.trace"

  and enable_internal_tracing =

      ~doc:

        "Enables internal tracing into \

         $config-directory/internal-tracing/internal-trace.jsonl"

  and insecure_rest_server =

      ~doc:

        "Have REST server listen on all addresses, not just localhost (this is \

         INSECURE, make sure your firewall is configured correctly!)"

  (* FIXME #4095

     and limit_connections =

       flag "--limit-concurrent-connections"

         ~aliases:[ "limit-concurrent-connections"]

         ~doc:

           "true|false Limit the number of concurrent connections per IP \

            address (default: true)"

         (optional bool)*)

  (*TODO: This is being added to log all the snark works received for the

     beta-testnet challenge. We might want to remove this later?*)

  and log_received_snark_pool_diff =

      ~aliases:[ "log-snark-work-gossip" ]

      ~doc:"true|false Log snark-pool diff received from peers (default: false)"

  and log_transaction_pool_diff =

      ~doc:

        "true|false Log transaction-pool diff received from peers (default: \

         false)"

  and log_block_creation =

      ~doc:

        "true|false Log the steps involved in including transactions and snark \

         work in a block (default: true)"

  and libp2p_keypair =

      ~doc:

        "KEYFILE Keypair (generated from `mina libp2p generate-keypair`) to \

         use with libp2p discovery"

  and is_seed =

      no_arg

  and enable_flooding =

      ~doc:

        "true|false Publish our own blocks/transactions to every peer we can \

         find (default: false)"

  and peer_exchange =

      ~doc:

        "true|false Help keep the mesh connected when closing connections \

         (default: false)"

  and peer_protection_ratio =

      ~doc:"float Proportion of peers to be marked as protected (default: 0.2)"

  and min_connections =

      ~doc:

           "NN min number of connections that this peer will have to neighbors \

            in the gossip network (default: %d)"

           Cli_lib.Default.min_connections )

  and max_connections =

      ~doc:

           "NN max number of connections that this peer will have to neighbors \

            in the gossip network. Tuning this higher will strengthen your \

            connection to the network in exchange for using more RAM (default: \

            %d)"

           Cli_lib.Default.max_connections )

  and validation_queue_size =

      ~aliases:[ "validation-queue-size" ]

      ~doc:

           "NN size of the validation queue in the p2p network used to buffer \

            messages (like blocks and transactions received on the gossip \

            network) while validation is pending. If a transaction, for \

            example, is invalid, we don't forward the message on the gossip \

            net. If this queue is too small, we will drop messages without \

            validating them. If it is too large, we are susceptible to DoS \

            attacks on memory. (default: %d)"

           Cli_lib.Default.validation_queue_size )

  and direct_peers_raw =

      ~doc:

        "/ip4/IPADDR/tcp/PORT/p2p/PEERID Peers to always send new messages \

         to/from. These peers should also have you configured as a direct \

         peer, the relationship is intended to be symmetric"

  and isolate =

      ~doc:

        "true|false Only allow connections to the peers passed on the command \

         line or configured through GraphQL. (default: false)"

  and libp2p_peers_raw =

      ~doc:

        "/ip4/IPADDR/tcp/PORT/p2p/PEERID initial \"bootstrap\" peers for \

         discovery"

  and libp2p_peer_list_file =

      ~doc:

        "PATH path to a file containing \"bootstrap\" peers for discovery, one \

         multiaddress per line"

  and seed_peer_list_url =

      ~doc:"URL URL of seed peer list file. Will be polled periodically."

  and proposed_protocol_version =

      ~aliases:[ "proposed-protocol-version" ]

      ~doc:"NN.NN.NN Proposed protocol version to signal other nodes"

  and config_files =

      ~doc:

        "PATH path to a configuration file (overrides MINA_CONFIG_FILE, \

         default: <config_dir>/daemon.json). Pass multiple times to override \

         fields from earlier config files"

  and _may_generate =

      ~aliases:[ "generate-genesis-proof" ]

      ~doc:"true|false Deprecated. Passing this flag has no effect"

  and disable_node_status =

      ~doc:"Disable reporting node status to other nodes (default: enabled)"

  and cli_proof_level =

      ~doc:

        "full|check|none Internal, for testing. Start or connect to a network \

         with full proving (full), snark-testing with dummy proofs (check), or \

         dummy proofs (none)"

  and plugins = plugin_flag

  and precomputed_blocks_path =

      ~aliases:[ "precomputed-blocks-file" ]

      ~doc:"PATH Path to write precomputed blocks to, for replay or archiving"

  and log_precomputed_blocks =

      ~aliases:[ "log-precomputed-blocks" ]

      ~doc:"true|false Include precomputed blocks in the log (default: false)"

  and start_filtered_logs =

      ~doc:

        "LOG-FILTER Include filtered logs for the given filter. May be passed \

         multiple times"

  and block_reward_threshold =

      ~doc:

        "AMOUNT Minimum reward a block produced by the node should have. Empty \

         blocks are created if the rewards are lower than the specified \

         threshold (default: No threshold, transactions and coinbase will be \

         included as long as the required snark work is available and can be \

         paid for)"

  and stop_time =

      ~doc:

           "UPTIME in hours after which the daemon stops itself (only if there \

            were no slots won within an hour after the stop time) (Default: \

            %d)"

           Cli_lib.Default.stop_time )

  and upload_blocks_to_gcloud =

      ~aliases:[ "upload-blocks-to-gcloud" ]

      ~doc:

        "true|false upload blocks to gcloud storage. Requires the environment \

         variables GCLOUD_KEYFILE, NETWORK_NAME, and \

         GCLOUD_BLOCK_UPLOAD_BUCKET"

  and all_peers_seen_metric =

      ~aliases:[ "all-peers-seen-metric" ]

      ~doc:

        "true|false whether to track the set of all peers ever seen for the \

         all_peers metric (default: false)"

  and node_status_url =

      ~doc:"URL of the node status collection service"

  and node_error_url =

      ~doc:"URL of the node error collection service"

  and simplified_node_stats =

      ~aliases:[ "simplified-node-stats" ]

      ~doc:"whether to report simplified node stats (default: true)"

  and contact_info =

      ~doc:

        "contact info used in node error report service (it could be either \

         email address or discord username), it should be less than 200 \

         characters"

               else

                   "The length of contact info exceeds 200 characters:\n %s" s ) )

  and uptime_url_string =

      ~doc:"URL URL of the uptime service of the Mina delegation program"

  and uptime_submitter_key =

      ~doc:

        "KEYFILE Private key file for the uptime submitter. You cannot provide \

         both `uptime-submitter-key` and `uptime-submitter-pubkey`."

  and uptime_submitter_pubkey =

      ~aliases:[ "uptime-submitter-pubkey" ]

      ~doc:

        "PUBLICKEY Public key of the submitter to the Mina delegation program, \

         for the associated private key that is being tracked by this daemon. \

         You cannot provide both `uptime-submitter-key` and \

         `uptime-submitter-pubkey`."

  and uptime_send_node_commit =

      ~aliases:[ "uptime-send-node-commit-sha" ]

      ~doc:

        "true|false Whether to send the commit SHA used to build the node to \

         the uptime service. (default: false)"

      no_arg

  in

    let open Gossip_net.Libp2p in

    function

        Some RO

        Some RW

        Some N

        None

  in

  fun () ->

        let conf_dir = Mina_lib.Conf_dir.compute_conf_dir conf_dir in

            Core.printf "Starting background mina daemon. (Log Dir: %s)\n%!"

              conf_dir ;

              ~redirect_stdout:`Dev_null ?cd:working_dir

              ~redirect_stderr:`Dev_null () )

        in

        Stdout_log.setup log_json log_level ;

        (* 512MB logrotate max size = 1GB max filesystem usage *)

        Logger.Consumer_registry.register ~commit_id:Mina_version.commit_id

          ~id:Logger.Logger_id.mina

          ~transport:

            (Logger_file_system.dumb_logrotate ~directory:conf_dir

               ~log_filename:"mina.log" ~max_size:logrotate_max_size

               ~num_rotate:file_log_rotations )

          () ;

        Logger.Consumer_registry.register ~commit_id:Mina_version.commit_id

          ~id:Logger.Logger_id.best_tip_diff

          ~transport:

            (Logger_file_system.dumb_logrotate ~directory:conf_dir

               ~log_filename:"mina-best-tip.log"

               ~max_size:best_tip_diff_log_size ~num_rotate:1 )

          () ;

        Logger.Consumer_registry.register ~commit_id:Mina_version.commit_id

          ~id:Logger.Logger_id.rejected_blocks

          ~transport:

            (Logger_file_system.dumb_logrotate ~directory:conf_dir

               ~log_filename:"mina-rejected-blocks.log"

               ~max_size:rejected_blocks_log_size ~num_rotate:50 )

          () ;

          ~id:Logger.Logger_id.oversized_logs

          ~transport:

            (Logger_file_system.dumb_logrotate ~directory:conf_dir

               ~log_filename:"mina-oversized-logs.log"

               ~max_size:logrotate_max_size ~num_rotate:20 )

          () ;

        (* Consumer for `[%log internal]` logging used for internal tracing *)

          Internal_tracing.For_itn_logger.post_process_message ;

          ~id:Logger.Logger_id.mina

          ~processor:Internal_tracing.For_logger.processor

          ~transport:

               ~directory:(conf_dir ^ "/internal-tracing")

               () )

          () ;

          ~metadata:version_metadata ;

        let%bind () =

        in

        let%bind wallets =

          (* Load wallets early, to give user errors before expensive

             initialization starts.

          *)

          Secrets.Wallets.load ~logger ~disk_location:wallets_disk_location

        in

        let%bind libp2p_keypair =

          let libp2p_keypair_old_format =

            Option.bind libp2p_keypair ~f:(fun libp2p_keypair ->

                    Some kp

                    if String.contains libp2p_keypair ',' then

                        "I think -libp2p-keypair is in the old format, but I \

                         failed to parse it! Using it as a path..." ;

          in

              match libp2p_keypair with

                  Secrets.Libp2p_keypair.Terminal_stdin.read_exn

                    ~should_prompt_user:false ~which:"libp2p keypair" s

        in

        let%bind () =

          let version_filename = conf_dir ^/ "mina.version" in

            let%map () =

              (*Delete any trace files if version changes. TODO: Implement rotate logic similar to log files*)

            in

          in

          match

            Or_error.try_with_join (fun () ->

                        Ok commit

                        Or_error.errorf "commit not found in version file %s"

                          version_filename )

                    Or_error.errorf "Unexpected value in %s" version_filename )

          with

                  "Different version of Mina detected in config directory \

                   $config_directory, removing existing configuration"

                  ~metadata:[ ("config_directory", `String conf_dir) ] ;

                "Error reading $file: $error. Cleaning up the config directory \

                 $config_directory"

                ~metadata:

                  ; ("config_directory", `String conf_dir)

                  ; ("file", `String version_filename)

                  ] ;

        in

        let pids = Child_processes.Termination.create_pid_table () in

            (* Search for config files installed as part of a deb/brew package.

               These files are commit-dependent, to ensure that we don't clobber

               configuration for dev builds or use incompatible configs.

            *)

            let config_file_installed =

              let json = "config_" ^ Mina_version.commit_id_short ^ ".json" in

                ~f:(fun _acc f ->

                      Stop (Some f)

                      Continue None )

                ~finish:Fn.id

            in

            match config_file_installed with

                Some (config_file, `Must_exist)

                None

          in

          let config_file_configdir =

          in

          let config_file_envvar =

            match Sys.getenv "MINA_CONFIG_FILE" with

                Some (config_file, `Must_exist)

                None

          in

          let config_files =

          in

          let genesis_constants =

            Genesis_constants.Compiled.genesis_constants

          in

          let constraint_constants =

            Genesis_constants.Compiled.constraint_constants

          in

          let compile_config = Mina_compile_config.Compiled.t in

          let%bind precomputed_values, config_jsons, config =

              ~proof_level:Genesis_constants.Compiled.proof_level config_files

              ~genesis_constants ~constraint_constants ~cli_proof_level

          in

            List.rev_filter_map config_jsons

              ~f:(fun (config_file, config_json) ->

                  YJ.Util.(

          in

              (keyname : string) (actual_value : a option) : a option =

            let open YJ.Util in

            match actual_value with

                Some v

                (* Load value from the latest config file that both

                   * has the key we are looking for, and

                   * has the key in a format that [f] can parse.

                *)

                let%map config_file, data =

                    ~f:(fun (config_file, daemon_config) ->

                      let%bind json_val =

                      in

                in

                  ~metadata:

                    [ ("key", `String keyname)

                    ; ("config_file", `String config_file)

                    ] ;

          in

          let or_from_config map keyname actual_value ~default =

                x

                  "Key '$key' not found in the config file, using default"

                  ~metadata:[ ("key", `String keyname) ] ;

          in

          let get_port { Flag.Types.value; default; name } =

          in

          let libp2p_port = get_port libp2p_port in

            let ({ value; name } : int option Flag.Types.with_name) =

              limited_graphql_port

            in

          in

          let client_port = get_port client_port in

            let json_to_currency_fee_option json =

            in

              ~default:compile_config.default_snark_worker_fee snark_work_fee

          in

          let node_status_url =

            maybe_from_config YJ.Util.to_string_option "node-status-url"

              node_status_url

          in

          (* FIXME #4095: pass this through to Gossip_net.Libp2p *)

            (*if

                 or_from_config YJ.Util.to_bool_option "max-concurrent-connections"

                   ~default:true limit_connections

               then Some 40

               else *)

            None

          in

          let work_selection_method =

            or_from_config

              "work-selection"

              ~default:Cli_lib.Arg_type.Work_selection_method.Random

              work_selection_method_flag

          in

            or_from_config YJ.Util.to_int_option "work-reassignment-wait"

              ~default:Cli_lib.Default.work_reassignment_wait

              work_reassignment_wait

          in