MinaProtocol / mina / 3207

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 with_itn_logger ~itn_features ~(compile_config : Mina_compile_config.t)

    ~logger =

      Logger.make_itn_logger_config

        ~rpc_handshake_timeout:compile_config.rpc_handshake_timeout

        ~rpc_heartbeat_timeout:compile_config.rpc_heartbeat_timeout

        ~rpc_heartbeat_send_every:compile_config.rpc_heartbeat_send_every

    in

    Logger.with_itn conf logger

let setup_daemon logger ~itn_features =

  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" )

  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 no_super_catchup =

      ~doc:"Don't use super-catchup" 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

  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

          Block_time.Controller.create @@ Block_time.Controller.basic ~logger

        in

          let%bind precomputed_values, config =

            Genesis_ledger_helper.Config_loader.load_config_files ~logger

              ~conf_dir ?genesis_dir ?cli_proof_level ~itn_features config_files

          in

          let compile_config = precomputed_values.compile_config in

          let logger = with_itn_logger ~itn_features ~compile_config ~logger in

          constraint_constants.block_window_duration_ms |> Block_time.Span.to_ms

          (* The explicit typing here is necessary to prevent type inference from specializing according

             to the first usage.

          *)

          let maybe_from_config (type a) :

              getter:(DC.t -> a option) -> preferred_value:a option -> a option

              =

           fun ~getter ~preferred_value ->

          in

          let or_from_config (type a) :

                 getter:(DC.t -> a option)

              -> preferred_value:a option

              -> default:a

              -> a =

           fun ~getter ~preferred_value ~default ->

          in

          let libp2p_port =

            or_from_config ~getter:DC.libp2p_port

              ~preferred_value:libp2p_port.value ~default:libp2p_port.default

          in

          let rest_server_port =

            or_from_config ~getter:DC.rest_port

              ~preferred_value:rest_server_port.value

              ~default:rest_server_port.default

          in

          let limited_graphql_port =

            maybe_from_config ~getter:DC.graphql_port

              ~preferred_value:limited_graphql_port.value

          in

          let client_port =

            or_from_config ~getter:DC.client_port

              ~preferred_value:client_port.value ~default:client_port.default

          in

          let snark_work_fee =

            or_from_config

              ~getter:(fun x ->

              ~preferred_value:snark_work_fee

              ~default:compile_config.default_snark_worker_fee

          in

          let node_status_url =

            maybe_from_config ~getter:DC.node_status_url

              ~preferred_value:node_status_url

          in

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

          let _max_concurrent_connections =

            (*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

              ~getter:(fun x ->

              ~preferred_value:work_selection_method_flag

              ~default:Cli_lib.Arg_type.Work_selection_method.Random

          in

          let work_reassignment_wait =

            or_from_config ~getter:DC.work_reassignment_wait

              ~preferred_value:work_reassignment_wait

              ~default:Cli_lib.Default.work_reassignment_wait

          in

          let log_received_snark_pool_diff =

            or_from_config ~getter:DC.log_snark_work_gossip

              ~preferred_value:log_received_snark_pool_diff ~default:false

          in

          let log_transaction_pool_diff =

            or_from_config ~getter:DC.log_txn_pool_gossip

              ~preferred_value:log_transaction_pool_diff ~default:false

          in

          let log_block_creation =

            or_from_config ~getter:DC.log_block_creation

              ~preferred_value:log_block_creation ~default:true

          in

          let log_gossip_heard =

            { Mina_networking.Config.snark_pool_diff =

                log_received_snark_pool_diff

            ; transaction_pool_diff = log_transaction_pool_diff

            ; new_state = true

            }

          in

          let to_publickey_compressed_option which pk_str =

                match Public_key.decompress key with

                    Mina_user_error.raisef ~where:"decompressing a public key"

                      "The %s public key %s could not be decompressed." which

                      pk_str

                    Some key )

                Mina_user_error.raisef ~where:"decoding a public key"

                  "The %s public key %s could not be decoded." which pk_str

          in

          let run_snark_worker_flag =

            maybe_from_config

              ~getter:

                Option.(

                  fun x ->

              ~preferred_value:run_snark_worker_flag

          in

          let run_snark_coordinator_flag =

            maybe_from_config

              ~getter:

                Option.(

                  fun x ->

              ~preferred_value:run_snark_coordinator_flag

          in

          let snark_worker_parallelism_flag =

            maybe_from_config ~getter:DC.snark_worker_parallelism

              ~preferred_value:snark_worker_parallelism_flag

          in

          let coinbase_receiver_flag =

            maybe_from_config

              ~getter:

                Option.(

                  fun x ->

              ~preferred_value:coinbase_receiver_flag

          in

          let%bind external_ip =

            match external_ip_opt with

                Find_ip.find ~logger

          in

            Option.value bind_ip_opt ~default:"0.0.0.0"

          in

            { external_ip; bind_ip; peer = None; client_port; libp2p_port }

          in

          let block_production_key =

            maybe_from_config ~getter:DC.block_producer_key

              ~preferred_value:block_production_key

          in

          let block_production_pubkey =

            maybe_from_config

              ~getter:

                Option.(

                  fun x ->

              ~preferred_value:block_production_pubkey

          in

          let block_production_password =

            maybe_from_config ~getter:DC.block_producer_password

              ~preferred_value:block_production_password

          in

          Option.iter

            ~f:(fun password ->

                    "$envkey environment variable doesn't match value provided \

                     on command-line or daemon.json. Using value from $envkey"

                    ~metadata:[ ("envkey", `String Secrets.Keypair.env) ]

                  Unix.putenv ~key:Secrets.Keypair.env ~data:password )

            block_production_password ;

          let%bind block_production_keypair =

            match

              ( block_production_key

              , block_production_pubkey

            with

                  "You cannot provide both `block-producer-key` and \

                   `block_production_pubkey`"

                  "You cannot provide both `MINA_BP_PRIVKEY` and \

                   `block_production_pubkey`"

                let kp =

                  Private_key.of_base58_check_exn base58_privkey

                in

            (* CLI argument takes precedence over env variable *)

                  "`block-producer-key` is deprecated. Please set \

                   `MINA_BP_PRIVKEY` environment variable instead." ;

                let%map kp =

                    ~should_prompt_user:false ~which:"block producer keypair"

                    sk_file

                in

                let%map kp =

                    ~which:"block producer keypair"

                    ~read_from_env_exn:

                      (Secrets.Keypair.Terminal_stdin.read_exn

                         ~should_prompt_user:false ~should_reask:false )

                    ~conf_dir tracked_pubkey

                in

          in

          let%bind client_trustlist =

              [%of_sexp: Unix.Cidr.t list]

          in

            let mina_client_trustlist = "MINA_CLIENT_TRUSTLIST" in

            let cidrs_of_env_str env_str env_var =