Decouple Staged_ledger_diff.{Stable.Latest.t, t}

Remove `Stable.Latest.t = t` from interfaces. This is a preparation step
for removing the equality in the implementation as well.

src/app/archive/lib/processor.ml

@@ -3305,8 +3305,9 @@ module Block = struct
       ~hash ~v1_transaction_hash:false
 
   let add_from_precomputed conn ~constraint_constants (t : Precomputed.t) =
+    let staged_ledger_diff = Staged_ledger_diff.generate t.staged_ledger_diff in
     add_parts_if_doesn't_exist conn ~constraint_constants
-      ~protocol_state:t.protocol_state ~staged_ledger_diff:t.staged_ledger_diff
+      ~protocol_state:t.protocol_state ~staged_ledger_diff
       ~protocol_version:t.protocol_version
       ~proposed_protocol_version:t.proposed_protocol_version
       ~hash:(Protocol_state.hashes t.protocol_state).state_hash

src/lib/block_producer/block_producer.ml

@@ -313,6 +313,7 @@ let generate_next_state ~commit_id ~zkapp_cmd_limit ~constraint_constants
                             (Staged_ledger.Staged_ledger_error.to_string e) )
                       ; ( "diff"
                         , Staged_ledger_diff.Stable.Latest.to_yojson
+                          @@ Staged_ledger_diff.unwrap
                           @@ Staged_ledger_diff.forget diff )
                       ]
                     "Error applying the diff $diff: $error"
@@ -335,6 +336,9 @@ let generate_next_state ~commit_id ~zkapp_cmd_limit ~constraint_constants
           , ledger_proof_opt
           , is_new_stack
           , pending_coinbase_update ) ->
+          let diff_unwrapped =
+            Staged_ledger_diff.unwrap @@ Staged_ledger_diff.forget diff
+          in
           let%bind protocol_state, consensus_transition_data =
             lift_sync (fun () ->
                 let previous_ledger_hash =
@@ -365,7 +369,7 @@ let generate_next_state ~commit_id ~zkapp_cmd_limit ~constraint_constants
                 let body_reference =
                   Staged_ledger_diff.Body.compute_reference
                     ~tag:Mina_net2.Bitswap_tag.(to_enum Body)
-                    (Body.create @@ Staged_ledger_diff.forget diff)
+                    (Body.Stable.Latest.create diff_unwrapped)
                 in
                 let blockchain_state =
                   (* We use the time of the beginning of the slot because if things
@@ -913,7 +917,8 @@ let produce ~genesis_breadcrumb ~context:(module Context : CONTEXT) ~prover
                       ~transition_receipt_time () )
                 |> Deferred.Result.map_error ~f:(function
                      | `Invalid_staged_ledger_diff e ->
-                         `Invalid_staged_ledger_diff (e, staged_ledger_diff)
+                         `Invalid_staged_ledger_diff
+                           (e, Staged_ledger_diff.unwrap staged_ledger_diff)
                      | ( `Fatal_error _
                        | `Invalid_genesis_protocol_state
                        | `Invalid_staged_ledger_hash _
@@ -1435,7 +1440,9 @@ let run_precomputed ~context:(module Context : CONTEXT) ~verifier ~trust_system
             Header.create ~protocol_state ~protocol_state_proof
               ~delta_block_chain_proof ()
           in
-          let body = Body.create staged_ledger_diff in
+          let body =
+            Body.create (Staged_ledger_diff.generate staged_ledger_diff)
+          in
           let%bind transition =
             let open Result.Let_syntax in
             Validation.wrap_header

src/lib/mina_block/block.ml

@@ -43,8 +43,7 @@ module Stable = struct
   end
 end]
 
-type t = Stable.Latest.t =
-  { header : Header.t; body : Staged_ledger_diff.Body.t }
+type t = { header : Header.t; body : Staged_ledger_diff.Body.t }
 [@@deriving fields]
 
 type with_hash = t State_hash.With_state_hashes.t
@@ -105,6 +104,8 @@ let account_ids_accessed ~constraint_constants t =
   |> List.dedup_and_sort
        ~compare:[%compare: Account_id.t * [ `Accessed | `Not_accessed ]]
 
-let generate = Fn.id
+let generate { Stable.Latest.header; body } =
+  { header; body = Staged_ledger_diff.Body.generate body }
 
-let unwrap = Fn.id
+let unwrap { header; body } =
+  { Stable.Latest.header; body = Staged_ledger_diff.Body.unwrap body }

src/lib/mina_block/internal_transition.ml

@@ -46,7 +46,7 @@ module Stable = struct
 end]
 
 (* bin_io, version omitted *)
-type t = Stable.Latest.t =
+type t =
   { snark_transition : Snark_transition.Value.t
   ; ledger_proof : Ledger_proof.t option
   ; prover_state : Consensus.Data.Prover_state.t
@@ -55,8 +55,4 @@ type t = Stable.Latest.t =
 [@@deriving fields]
 
 let create ~snark_transition ~ledger_proof ~prover_state ~staged_ledger_diff =
-  { Stable.Latest.snark_transition
-  ; ledger_proof
-  ; staged_ledger_diff
-  ; prover_state
-  }
+  { snark_transition; ledger_proof; staged_ledger_diff; prover_state }

src/lib/mina_block/precomputed_block.ml

@@ -53,7 +53,7 @@ module T = struct
     { scheduled_time : Block_time.t
     ; protocol_state : Protocol_state.value
     ; protocol_state_proof : Proof.t
-    ; staged_ledger_diff : Staged_ledger_diff.t
+    ; staged_ledger_diff : Staged_ledger_diff.Stable.Latest.t
     ; delta_transition_chain_proof :
         Frozen_ledger_hash.t * Frozen_ledger_hash.t list
     ; protocol_version : Protocol_version.t
@@ -181,6 +181,7 @@ let of_block ~logger
   ; protocol_state_proof = Header.protocol_state_proof header
   ; staged_ledger_diff =
       Staged_ledger_diff.Body.staged_ledger_diff (Block.body block)
+      |> Staged_ledger_diff.unwrap
   ; delta_transition_chain_proof = Header.delta_block_chain_proof header
   ; protocol_version
   ; proposed_protocol_version

src/lib/mina_block/precomputed_block.mli

@@ -40,7 +40,7 @@ type t = Stable.Latest.t =
   { scheduled_time : Block_time.Time.t
   ; protocol_state : Protocol_state.value
   ; protocol_state_proof : Proof.t
-  ; staged_ledger_diff : Staged_ledger_diff.t
+  ; staged_ledger_diff : Staged_ledger_diff.Stable.Latest.t
   ; delta_transition_chain_proof :
       Frozen_ledger_hash.t * Frozen_ledger_hash.t list
   ; protocol_version : Protocol_version.t

src/lib/mina_block/validation.ml

@@ -488,7 +488,7 @@ let validate_staged_ledger_diff ?skip_staged_ledger_verification ~logger
   let body_ref_computed =
     Staged_ledger_diff.Body.compute_reference
       ~tag:Mina_net2.Bitswap_tag.(to_enum Body)
-      body
+    @@ Staged_ledger_diff.Body.unwrap body
   in
   let%bind.Deferred.Result () =
     if Blake2.equal body_ref_computed body_ref_from_header then

src/lib/staged_ledger/staged_ledger.ml

@@ -3778,7 +3778,8 @@ let%test_module "staged ledger tests" =
                       assert_same_fee single work.fee )
               | _ ->
                   failwith @@ "Incorrect coinbase in the diff "
-                  ^ ( Staged_ledger_diff.Stable.Latest.to_yojson diff
+                  ^ ( Staged_ledger_diff.unwrap diff
+                    |> Staged_ledger_diff.Stable.Latest.to_yojson
                     |> Yojson.Safe.to_string )
             in
             (diff, List.tl_exn proofs_available_left) )
@@ -4730,9 +4731,7 @@ let%test_module "staged ledger tests" =
             *)
               let diff : Staged_ledger_diff.t =
                 let pre_diff :
-                    Staged_ledger_diff.Pre_diff_with_at_most_two_coinbase.Stable
-                    .V2
-                    .t =
+                    Staged_ledger_diff.Pre_diff_with_at_most_two_coinbase.t =
                   { completed_works = []
                   ; commands = cmds
                   ; coinbase = Zero

src/lib/staged_ledger_diff/body.ml

@@ -8,6 +8,8 @@ end
 module Make_str (A : Wire_types.Concrete) = struct
   [%%versioned
   module Stable = struct
+    [@@@no_toplevel_latest_type]
+
     module V1 = struct
       type t = A.V1.t = { staged_ledger_diff : Diff.Stable.V2.t }
       [@@deriving fields]
@@ -35,9 +37,9 @@ module Make_str (A : Wire_types.Concrete) = struct
     end
   end]
 
-  type t = Stable.Latest.t
+  type t = { staged_ledger_diff : Diff.t } [@@deriving fields]
 
-  [%%define_locally Stable.Latest.(create, staged_ledger_diff)]
+  let create staged_ledger_diff = { staged_ledger_diff }
 
   let to_binio_bigstring b =
     let sz = Stable.V1.bin_size_t b in
@@ -58,6 +60,12 @@ module Make_str (A : Wire_types.Concrete) = struct
     @@ Fn.compose
          (Bitswap_block.blocks_of_data ~max_block_size:262144)
          (serialize_with_len_and_tag ~tag)
+
+  let generate t =
+    { staged_ledger_diff = Diff.generate t.Stable.Latest.staged_ledger_diff }
+
+  let unwrap t =
+    { Stable.Latest.staged_ledger_diff = Diff.unwrap t.staged_ledger_diff }
 end
 
 include Wire_types.Make (Make_sig) (Make_str)

src/lib/staged_ledger_diff/body_intf.ml

@@ -5,16 +5,24 @@ module type Full = sig
 
     module V1 : sig
       type t
+
+      val create : Diff.Stable.V2.t -> t
+
+      val staged_ledger_diff : t -> Diff.Stable.V2.t
     end
   end]
 
-  type t = Stable.Latest.t
+  type t
 
   val create : Diff.t -> t
 
   val staged_ledger_diff : t -> Diff.t
 
-  val to_binio_bigstring : t -> Core_kernel.Bigstring.t
+  val to_binio_bigstring : Stable.V1.t -> Core_kernel.Bigstring.t
+
+  val compute_reference : tag:int -> Stable.V1.t -> Consensus.Body_reference.t
+
+  val generate : Stable.Latest.t -> t
 
-  val compute_reference : tag:int -> t -> Consensus.Body_reference.t
+  val unwrap : t -> Stable.Latest.t
 end

src/lib/staged_ledger_diff/diff.ml

@@ -14,7 +14,7 @@ module Make_sig (A : Wire_types.Types.S) = struct
        and type ('a, 'b) Pre_diff_one.Stable.V2.t = ('a, 'b) A.Pre_diff_one.V2.t
        and type Pre_diff_with_at_most_one_coinbase.Stable.V2.t =
         A.Pre_diff_with_at_most_one_coinbase.V2.t
-       and type t = A.V2.t
+       and type Diff.Stable.V2.t = A.Diff.V2.t
        and type Stable.V2.t = A.V2.t
 end
 
@@ -175,7 +175,12 @@ module Make_str (A : Wire_types.Concrete) = struct
       end
     end]
 
-    type t = Stable.Latest.t
+    type t =
+      (Transaction_snark_work.t, User_command.t With_status.t) Pre_diff_two.t
+
+    let generate : Stable.Latest.t -> t = Fn.id
+
+    let unwrap : t -> Stable.Latest.t = Fn.id
   end
 
   module Pre_diff_with_at_most_one_coinbase = struct
@@ -194,7 +199,12 @@ module Make_str (A : Wire_types.Concrete) = struct
       end
     end]
 
-    type t = Stable.Latest.t
+    type t =
+      (Transaction_snark_work.t, User_command.t With_status.t) Pre_diff_one.t
+
+    let generate : Stable.Latest.t -> t = Fn.id
+
+    let unwrap : t -> Stable.Latest.t = Fn.id
   end
 
   module Diff = struct
@@ -212,7 +222,27 @@ module Make_str (A : Wire_types.Concrete) = struct
       end
     end]
 
-    type t = Stable.Latest.t
+    type t =
+      Pre_diff_with_at_most_two_coinbase.t
+      * Pre_diff_with_at_most_one_coinbase.t option
+
+    let generate
+        (( pre_diff_with_at_most_two_coinbase
+         , pre_diff_with_at_most_one_coinbase_opt ) :
+          Stable.Latest.t ) : t =
+      ( Pre_diff_with_at_most_two_coinbase.generate
+          pre_diff_with_at_most_two_coinbase
+      , Option.map pre_diff_with_at_most_one_coinbase_opt
+          ~f:Pre_diff_with_at_most_one_coinbase.generate )
+
+    let unwrap
+        (( pre_diff_with_at_most_two_coinbase
+         , pre_diff_with_at_most_one_coinbase_opt ) :
+          t ) : Stable.Latest.t =
+      ( Pre_diff_with_at_most_two_coinbase.unwrap
+          pre_diff_with_at_most_two_coinbase
+      , Option.map pre_diff_with_at_most_one_coinbase_opt
+          ~f:Pre_diff_with_at_most_one_coinbase.unwrap )
   end
 
   [%%versioned
@@ -223,10 +253,24 @@ module Make_str (A : Wire_types.Concrete) = struct
       type t = A.V2.t = { diff : Diff.Stable.V2.t } [@@deriving yojson]
 
       let to_latest = Fn.id
+
+      let empty_diff : t =
+        { diff =
+            ( { completed_works = []
+              ; commands = []
+              ; coinbase = At_most_two.Zero
+              ; internal_command_statuses = []
+              }
+            , None )
+        }
     end
   end]
 
-  type t = Stable.Latest.t = { diff : Diff.t } [@@deriving fields]
+  type t = { diff : Diff.t } [@@deriving fields]
+
+  let generate t = { diff = Diff.generate t.Stable.Latest.diff }
+
+  let unwrap t = { Stable.Latest.diff = Diff.unwrap t.diff }
 
   module With_valid_signatures_and_proofs = struct
     type pre_diff_with_at_most_two_coinbase =

src/lib/staged_ledger_diff/diff.mli

@@ -14,5 +14,5 @@ include
       ('a, 'b) Mina_wire_types.Staged_ledger_diff.Pre_diff_one.V2.t
      and type Pre_diff_with_at_most_one_coinbase.Stable.V2.t =
       Mina_wire_types.Staged_ledger_diff.Pre_diff_with_at_most_one_coinbase.V2.t
-     and type t = Mina_wire_types.Staged_ledger_diff.V2.t
+     and type Diff.Stable.V2.t = Mina_wire_types.Staged_ledger_diff.Diff.V2.t
      and type Stable.V2.t = Mina_wire_types.Staged_ledger_diff.V2.t

src/lib/staged_ledger_diff/diff_intf.ml

@@ -71,9 +71,12 @@ module type Full = sig
     module Stable : sig
       module V2 : sig
         type t
+
+        val to_latest : t -> t
       end
+
+      module Latest = V2
     end
-    with type V2.t = t
   end
 
   module Pre_diff_with_at_most_one_coinbase : sig
@@ -83,9 +86,12 @@ module type Full = sig
     module Stable : sig
       module V2 : sig
         type t
+
+        val to_latest : t -> t
       end
+
+      module Latest = V2
     end
-    with type V2.t = t
   end
 
   module Diff : sig
@@ -96,23 +102,31 @@ module type Full = sig
     module Stable : sig
       module V2 : sig
         type t
+
+        val to_latest : t -> t
       end
+
+      module Latest = V2
     end
-    with type V2.t = t
   end
 
   type t = { diff : Diff.t } [@@deriving fields]
 
   module Stable : sig
     module V2 : sig
-      type t = { diff : Diff.Stable.V2.t } [@@deriving bin_io, version, yojson]
+      type t [@@deriving bin_io, version, yojson]
 
       val to_latest : t -> t
+
+      val empty_diff : t
     end
 
     module Latest = V2
   end
-  with type V2.t = t
+
+  val generate : Stable.Latest.t -> t
+
+  val unwrap : t -> Stable.Latest.t
 
   module With_valid_signatures_and_proofs : sig
     type pre_diff_with_at_most_two_coinbase =

src/lib/staged_ledger_diff/staged_ledger_diff.ml

@@ -4,4 +4,4 @@ module Bitswap_block = Bitswap_block
 
 let genesis_body_reference =
   (* Tag Body is fixed to integer value 0 *)
-  Body.compute_reference ~tag:0 (Body.create empty_diff)
+  Body.compute_reference ~tag:0 (Body.Stable.V1.create Stable.V2.empty_diff)

src/lib/transition_frontier/frontier_base/breadcrumb.ml

@@ -438,9 +438,8 @@ module For_tests = struct
           ~timestamp:(Block_time.now @@ Block_time.Controller.basic ~logger)
           ~staged_ledger_hash:next_staged_ledger_hash ~genesis_ledger_hash
           ~body_reference:
-            (Body.compute_reference
-               ~tag:Mina_net2.Bitswap_tag.(to_enum Body)
-               body )
+            ( Body.compute_reference ~tag:Mina_net2.Bitswap_tag.(to_enum Body)
+            @@ Body.unwrap body )
           ~ledger_proof_statement
       in
       let previous_state_hashes =