Set auto fork config slot and timestamp properly

The hard fork global slot since genesis and the hard fork timestamp are
now set according to the stop slots and the hard fork genesis slot
delta, if those components of the daemon config have been set. If they
have not, then the slot and timestamp of the hard fork block itself are
used as a fallback.

Author: cjjdespres

src/lib/mina_graphql/mina_graphql.ml

@@ -2614,11 +2614,11 @@ module Queries = struct
         in
         let%bind { source_ledgers
                  ; global_slot_since_genesis
+                 ; genesis_state_timestamp = _
                  ; state_hash
                  ; staking_epoch_seed
                  ; next_epoch_seed
                  ; blockchain_length
-                 ; block_timestamp = _
                  } =
           Mina_lib.Hardfork_config.prepare_inputs ~breadcrumb_spec mina
         in

src/lib/mina_lib/mina_lib.ml

@@ -453,6 +453,21 @@ let get_node_state t =
   ; uptime_of_node
   }
 
+(** Compute the hard fork genesis slot from the runtime config, if all the stop
+    slots and the genesis slot delta have been set *)
+let scheduled_hard_fork_genesis_slot t :
+    Mina_numbers.Global_slot_since_hard_fork.t option =
+  let open Option.Let_syntax in
+  let runtime_config = t.config.precomputed_values.runtime_config in
+  let%bind slot_chain_end_since_hard_fork =
+    Runtime_config.slot_chain_end runtime_config
+  in
+  let%map hard_fork_genesis_slot_delta =
+    Runtime_config.hard_fork_genesis_slot_delta runtime_config
+  in
+  Mina_numbers.Global_slot_since_hard_fork.add slot_chain_end_since_hard_fork
+    hard_fork_genesis_slot_delta
+
 (* This is a hack put in place to deal with nodes getting stuck
    in Offline states, that is, not receiving blocks for an extended period,
    or stuck in Bootstrap for too long
@@ -2829,24 +2844,83 @@ module Hardfork_config = struct
   type inputs =
     { source_ledgers : genesis_source_ledgers
     ; global_slot_since_genesis : Mina_numbers.Global_slot_since_genesis.t
+    ; genesis_state_timestamp : string
     ; state_hash : State_hash.t
     ; staking_epoch_seed : Epoch_seed.t
     ; next_epoch_seed : Epoch_seed.t
     ; blockchain_length : Mina_numbers.Length.t
-    ; block_timestamp : Block_time.t
     }
 
+  (** The genesis state timestamp string is the timestamp of the start of the
+      [global_slot] of the hard fork, relative to the current chain *)
+  let genesis_timestamp_str ~consensus_constants global_slot =
+    Consensus.Data.Consensus_time.(
+      start_time ~constants:consensus_constants
+        (of_global_slot ~constants:consensus_constants global_slot))
+    |> Block_time.to_time_exn
+    |> Time.to_string_iso8601_basic ~zone:Time.Zone.utc
+
+  (** Compute the hard fork slot. This will be derived from the stop slots and
+      hard fork genesis slot delta in the runtime config, if those have been set
+      and the [breadcrum_spec] was [`Stop_slot]. Otherwise, it will be the
+      global slot since genesis of the hard fork block. *)
+  let hard_fork_global_slot ~breadcrumb_spec ~block mina :
+      Mina_numbers.Global_slot_since_hard_fork.t =
+    let block_global_slot =
+      Mina_block.consensus_state block
+      |> Consensus.Data.Consensus_state.curr_global_slot
+    in
+    let configured_slot =
+      match breadcrumb_spec with
+      | `Stop_slot ->
+          scheduled_hard_fork_genesis_slot mina
+      | `State_hash _state_hash_base58 ->
+          None
+      | `Block_height _block_height ->
+          None
+    in
+    Option.value ~default:block_global_slot configured_slot
+
+  (** Helper to convert a global slot since hard fork to a global slot since genesis *)
+  let global_slot_since_hard_fork_to_genesis
+      ~(constraint_constants : Genesis_constants.Constraint_constants.t)
+      global_slot =
+    (* Convert the global slot to a span of slots since the current hard fork *)
+    let global_slot_span =
+      global_slot |> Mina_numbers.Global_slot_since_hard_fork.to_uint32
+      |> Mina_numbers.Global_slot_span.of_uint32
+    in
+    (* Retrieve the global slot since genesis of the genesis of the current
+       chain *)
+    let current_genesis_global_slot =
+      constraint_constants.fork
+      |> Option.value_map ~default:Mina_numbers.Global_slot_since_genesis.zero
+           ~f:(fun fork -> fork.global_slot_since_genesis)
+    in
+    (* Add the slot span to the current chain's genesis slot to get the desired quantity *)
+    Mina_numbers.Global_slot_since_genesis.add current_genesis_global_slot
+      global_slot_span
+
   let prepare_inputs ~breadcrumb_spec mina =
     let open Deferred.Result.Let_syntax in
     let%bind breadcrumb = breadcrumb ~breadcrumb_spec mina in
     let block = Transition_frontier.Breadcrumb.block breadcrumb in
     let blockchain_length = Mina_block.blockchain_length block in
+    let global_slot_since_hard_fork =
+      hard_fork_global_slot ~breadcrumb_spec ~block mina
+    in
     let global_slot_since_genesis =
-      Mina_block.consensus_state block
-      |> Consensus.Data.Consensus_state.global_slot_since_genesis
+      global_slot_since_hard_fork_to_genesis
+        ~constraint_constants:
+          mina.config.precomputed_values.constraint_constants
+        global_slot_since_hard_fork
+    in
+    let genesis_state_timestamp =
+      genesis_timestamp_str
+        ~consensus_constants:mina.config.precomputed_values.consensus_constants
+        global_slot_since_hard_fork
     in
     let state_hash = Transition_frontier.Breadcrumb.state_hash breadcrumb in
-    let block_timestamp = block |> Mina_block.timestamp in
     let protocol_state =
       Transition_frontier.Breadcrumb.protocol_state breadcrumb
     in
@@ -2862,11 +2936,11 @@ module Hardfork_config = struct
     let%map source_ledgers = source_ledgers ~breadcrumb mina in
     { source_ledgers
     ; global_slot_since_genesis
+    ; genesis_state_timestamp
     ; state_hash
     ; staking_epoch_seed
     ; next_epoch_seed
     ; blockchain_length
-    ; block_timestamp
     }
 
   (** Copy the roots of the [source_ledgers] and gather the stable ledger
@@ -3041,20 +3115,15 @@ module Hardfork_config = struct
          ~state_hash ~blockchain_length ~staking_epoch_seed ~next_epoch_seed
          genesis_config )
 
-  let genesis_timestamp_str ~hardfork_genesis_timestamp_offset block_timestamp =
-    block_timestamp |> Block_time.to_time_exn
-    |> Fn.flip Time.add hardfork_genesis_timestamp_offset
-    |> Time.to_string_iso8601_basic ~zone:Time.Zone.utc
-
   let generate_hardfork_configs ~logger
       ~inputs:
         { source_ledgers
         ; global_slot_since_genesis
+        ; genesis_state_timestamp
         ; state_hash
         ; staking_epoch_seed
         ; next_epoch_seed
         ; blockchain_length
-        ; block_timestamp
         } ~build_dir directory_name =
     let open Deferred.Or_error.Let_syntax in
     let migrate_and_apply (root, diff) =
@@ -3094,12 +3163,6 @@ module Hardfork_config = struct
                       , genesis_next_epoch_ledger_migrated ) =
       migrate_and_apply genesis_next_epoch_ledger_data
     in
-    (* TODO: the correct timestamp is actually the timestamp of the slot_tx_end plus the hardfork genesis offset *)
-    let genesis_state_timestamp =
-      genesis_timestamp_str
-        ~hardfork_genesis_timestamp_offset:(Time.Span.of_int_sec 0)
-        block_timestamp
-    in
     [%log debug] "Writing hard fork config directories" ;
     let%bind () =
       write_stable_config_directory ~logger ~genesis_state_timestamp

src/lib/mina_lib/mina_lib.mli

@@ -278,9 +278,6 @@ val best_chain_block_by_height :
 val best_chain_block_by_state_hash :
   t -> State_hash.t -> Transition_frontier.Breadcrumb.t Or_error.t
 
-val best_chain_block_before_stop_slot :
-  t -> Transition_frontier.Breadcrumb.t Deferred.Or_error.t
-
 module Hardfork_config : sig
   type mina_lib = t
 
@@ -325,11 +322,11 @@ module Hardfork_config : sig
   type inputs =
     { source_ledgers : genesis_source_ledgers
     ; global_slot_since_genesis : Mina_numbers.Global_slot_since_genesis.t
+    ; genesis_state_timestamp : string
     ; state_hash : State_hash.t
     ; staking_epoch_seed : Epoch_seed.t
     ; next_epoch_seed : Epoch_seed.t
     ; blockchain_length : Mina_numbers.Length.t
-    ; block_timestamp : Block_time.t
     }
 
   val prepare_inputs :

src/lib/runtime_config/runtime_config.ml

@@ -1686,6 +1686,12 @@ let slot_tx_end, slot_chain_end =
   in
   (f (fun d -> d.slot_tx_end), f (fun d -> d.slot_chain_end))
 
+let hard_fork_genesis_slot_delta t =
+  let open Option.Let_syntax in
+  let%bind daemon = t.daemon in
+  let%map delta = daemon.hard_fork_genesis_slot_delta in
+  Mina_numbers.Global_slot_span.of_int delta
+
 (** This method creates a runtime daemon config for a hard fork, containing the
     data that can't necessarily be computed in advance of the hard fork. This
     ends up being data that's computed based on the last block produced before