MinaProtocol / mina / 236

open Mina_base

module At_most_two = struct

  [%%versioned

  module Stable = struct

    [@@@no_toplevel_latest_type]

    module V1 = struct

    end

  end]

  let increase t ws =

        Ok (One None)

        Ok (One (Some a))

        Ok (Two None)

        Ok (Two (Some (a, None)))

        Ok (Two (Some (a', Some a)))

        Or_error.error_string "Error incrementing coinbase parts"

end

module At_most_one = struct

  [%%versioned

  module Stable = struct

    [@@@no_toplevel_latest_type]

    module V1 = struct

    end

  end]

  [@@deriving equal, compare, sexp, yojson]

  let increase t ws =

        Ok (One None)

        Ok (One (Some a))

        Or_error.error_string "Error incrementing coinbase parts"

end

module Ft = struct

  [%%versioned

  module Stable = struct

    [@@@no_toplevel_latest_type]

    module V1 = struct

      let to_latest = Fn.id

    end

  end]

end

module Pre_diff_two = struct

  [%%versioned

  module Stable = struct

    [@@@no_toplevel_latest_type]

    module V2 = struct

        }

    end

  end]

    }

  let map t ~f1 ~f2 =

    ; coinbase = t.coinbase

    ; internal_command_statuses = t.internal_command_statuses

    }

end

module Pre_diff_one = struct

  [%%versioned

  module Stable = struct

    [@@@no_toplevel_latest_type]

    module V2 = struct

        }

    end

  end]

    }

  let map t ~f1 ~f2 =

    ; coinbase = t.coinbase

    ; internal_command_statuses = t.internal_command_statuses

    }

end

module Pre_diff_with_at_most_two_coinbase = struct

  [%%versioned

  module Stable = struct

    [@@@no_toplevel_latest_type]

    module V2 = struct

      let to_latest = Fn.id

    end

  end]

  type t =

    (Transaction_snark_work.t, User_command.t With_status.t) Pre_diff_two.t

  let write_all_proofs_to_disk ~proof_cache_db : Stable.Latest.t -> t =

      ~f1:(Transaction_snark_work.write_all_proofs_to_disk ~proof_cache_db)

      ~f2:

        (With_status.map

           ~f:(User_command.write_all_proofs_to_disk ~proof_cache_db) )

  let read_all_proofs_from_disk : t -> Stable.Latest.t =

    Pre_diff_two.map ~f1:Transaction_snark_work.read_all_proofs_from_disk

      ~f2:(With_status.map ~f:User_command.read_all_proofs_from_disk)

end

module Pre_diff_with_at_most_one_coinbase = struct

  [%%versioned

  module Stable = struct

    [@@@no_toplevel_latest_type]

    module V2 = struct

      let to_latest = Fn.id

    end

  end]

  type t =

    (Transaction_snark_work.t, User_command.t With_status.t) Pre_diff_one.t

  let write_all_proofs_to_disk ~proof_cache_db : Stable.Latest.t -> t =

      ~f1:(Transaction_snark_work.write_all_proofs_to_disk ~proof_cache_db)

      ~f2:

        (With_status.map

           ~f:(User_command.write_all_proofs_to_disk ~proof_cache_db) )

  let read_all_proofs_from_disk : t -> Stable.Latest.t =

    Pre_diff_one.map ~f1:Transaction_snark_work.read_all_proofs_from_disk

      ~f2:(With_status.map ~f:User_command.read_all_proofs_from_disk)

end

module Diff = struct

  let coinbase_amount

      ~(constraint_constants : Genesis_constants.Constraint_constants.t)

      ~supercharge_coinbase =

        constraint_constants.supercharged_coinbase_factor

  let coinbase

      ~(constraint_constants : Genesis_constants.Constraint_constants.t)

      ~supercharge_coinbase (first_pre_diff, second_pre_diff_opt) =

      coinbase_amount ~constraint_constants ~supercharge_coinbase

    in

    match

      ( first_pre_diff.Pre_diff_two.coinbase

    with

        Some Currency.Amount.zero

        coinbase_amount

  [%%versioned

  module Stable = struct

    [@@@no_toplevel_latest_type]

    module V2 = struct

      let to_latest = Fn.id

      let coinbase = coinbase

    end

  end]

  type t =

    Pre_diff_with_at_most_two_coinbase.t

    * Pre_diff_with_at_most_one_coinbase.t option

  let write_all_proofs_to_disk ~proof_cache_db

      (( pre_diff_with_at_most_two_coinbase

       , pre_diff_with_at_most_one_coinbase_opt ) :

        Stable.Latest.t ) : t =

        ~proof_cache_db pre_diff_with_at_most_two_coinbase

        ~f:

          (Pre_diff_with_at_most_one_coinbase.write_all_proofs_to_disk

             ~proof_cache_db ) )

  let read_all_proofs_from_disk

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

        ~f:Pre_diff_with_at_most_one_coinbase.read_all_proofs_from_disk )

end

[%%versioned

module Stable = struct

  [@@@no_toplevel_latest_type]

  module V2 = struct

    let to_latest = Fn.id

    let empty_diff : t =

      { diff =

          ( { completed_works = []

            ; commands = []

            ; coinbase = At_most_two.Zero

            ; internal_command_statuses = []

            }

          , None )

      }

    let completed_works (t : t) =

  end

end]

let write_all_proofs_to_disk ~proof_cache_db t =

let read_all_proofs_from_disk t =

module With_valid_signatures_and_proofs = struct

  type pre_diff_with_at_most_two_coinbase =

    ( Transaction_snark_work.Checked.t

    , User_command.Valid.t With_status.t )

    Pre_diff_two.t

  type pre_diff_with_at_most_one_coinbase =

    ( Transaction_snark_work.Checked.t

    , User_command.Valid.t With_status.t )

    Pre_diff_one.t

  type diff =

    pre_diff_with_at_most_two_coinbase

    * pre_diff_with_at_most_one_coinbase option

  type t = { diff : diff }

  let empty_diff : t =

    { diff =

        ( { completed_works = []

          ; commands = []

          ; coinbase = At_most_two.Zero

          ; internal_command_statuses = []

          }

        , None )

    }

  let commands t =

end

module With_valid_signatures = struct

  type pre_diff_with_at_most_two_coinbase =

    ( Transaction_snark_work.t

    , User_command.Valid.t With_status.t )

    Pre_diff_two.t

  type pre_diff_with_at_most_one_coinbase =

    ( Transaction_snark_work.t

    , User_command.Valid.t With_status.t )

    Pre_diff_one.t

  type diff =

    pre_diff_with_at_most_two_coinbase

    * pre_diff_with_at_most_one_coinbase option

  type t = { diff : diff }

  let coinbase

      ~(constraint_constants : Genesis_constants.Constraint_constants.t)

      ~supercharge_coinbase (t : t) =

    let coinbase_amount =

      Diff.coinbase_amount ~constraint_constants ~supercharge_coinbase

    in

    match

      ( first_pre_diff.coinbase

    with

        Some Currency.Amount.zero

        coinbase_amount

end

let validate_commands (t : t)

    ~(check :

          User_command.t With_status.t list

       -> (User_command.Valid.t list, 'e) Result.t Async.Deferred.Or_error.t ) :

    (With_valid_signatures.t, 'e) Result.t Async.Deferred.Or_error.t =

  let validate cs =

      ~f:

  in

  let d1, d2 = t.diff in

  map

    ~f:(fun commands_all ->

      in

        { completed_works = d1.completed_works

        ; commands = commands1

        ; coinbase = d1.coinbase

        ; internal_command_statuses = d1.internal_command_statuses

        }

      in

      let p2 =

        Option.value_map ~default:None d2 ~f:(fun d2 ->

              { Pre_diff_one.completed_works = d2.completed_works

              ; commands = commands2

              ; coinbase = d2.coinbase

              ; internal_command_statuses = d2.internal_command_statuses

              } )

      in

let forget_proof_checks (d : With_valid_signatures_and_proofs.t) :

    With_valid_signatures.t =

    ; commands = d1.commands

    ; coinbase = d1.coinbase

    ; internal_command_statuses = d1.internal_command_statuses

    }

  in

  let p2 =

      ~f:(fun d2 : With_valid_signatures.pre_diff_with_at_most_one_coinbase ->

        ; commands = d2.commands

        ; coinbase = d2.coinbase

        ; internal_command_statuses = d2.internal_command_statuses

        } )

  in

let forget_pre_diff_with_at_most_two

    (pre_diff :

      With_valid_signatures_and_proofs.pre_diff_with_at_most_two_coinbase ) :

    Pre_diff_with_at_most_two_coinbase.t =

  ; commands =

        ~f:(With_status.map ~f:User_command.forget_check)

        pre_diff.commands

  ; coinbase = pre_diff.coinbase

  ; internal_command_statuses = pre_diff.internal_command_statuses

  }

let forget_pre_diff_with_at_most_one

    (pre_diff :

      With_valid_signatures_and_proofs.pre_diff_with_at_most_one_coinbase ) =

  ; commands =

        ~f:(With_status.map ~f:User_command.forget_check)

        pre_diff.commands

  ; coinbase = pre_diff.coinbase

  ; internal_command_statuses = pre_diff.internal_command_statuses

  }

let forget (t : With_valid_signatures_and_proofs.t) =

  }

let commands (t : t) =

let completed_works (t : t) =

let net_return

    ~(constraint_constants : Genesis_constants.Constraint_constants.t)

    ~supercharge_coinbase (t : t) =

  let open Option.Let_syntax in

  let%bind coinbase =

  in

  let%bind total_reward =

      ~f:(fun sum cmd ->

        let%bind sum = sum in

  in

  let%bind completed_works_fees =

        let%bind sum = sum in

  in

let empty_diff : t =

  { diff =

      ( { completed_works = []

        ; commands = []

        ; coinbase = At_most_two.Zero

        ; internal_command_statuses = []

        }

      , None )

  }

let is_empty = function

        ( { completed_works = []

          ; commands = []

          ; coinbase = At_most_two.Zero

          ; internal_command_statuses = []

          }

        , None )

    } ->

      true