2863

Committed 05 Nov 2024 06:20PM UTC coverage: 30.754% (-16.6%) from 47.311%

Build # 2863

Build Type

push

buildkite

Committed by

web-flow

Commit Message

Merge pull request #16296 from MinaProtocol/dkijania/more_multi_jobs

more multi jobs in CI

Run Details

20276 of 65930 relevant lines covered (30.75%)

8631.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.9

/src/lib/data_hash_lib/data_hash.ml

(* data_hash.ml *)
open Core_kernel
open Snark_params.Tick
open Bitstring_lib

module type Full_size = Data_hash_intf.Full_size

module Make_basic (M : sig
  val length_in_bits : int
end) =
struct
  type t = Field.t [@@deriving sexp, compare, hash]

  let to_decimal_string (t : Field.t) = Field.to_string t

  let of_decimal_string (s : string) = Field.of_string s

  let to_bytes t =
    Fold_lib.(Fold.bool_t_to_string (Fold.of_list (Field.unpack t)))

  let length_in_bits = M.length_in_bits

  let () = assert (Int.(length_in_bits <= Field.size_in_bits))

  let to_input t = Random_oracle.Input.Chunked.field t

  (* this is in consensus code, because Bigint comes
     from snarky functors
  *)
  let gen : t Quickcheck.Generator.t =
    let m =
      if Int.(length_in_bits = Field.size_in_bits) then
        Bignum_bigint.(Field.size - one)
      else Bignum_bigint.(pow (of_int 2) (of_int length_in_bits) - one)
    in
    Quickcheck.Generator.map
      Bignum_bigint.(gen_incl zero m)
      ~f:(fun x -> Bigint.(to_field (of_bignum_bigint x)))

  type var =
    { digest : Random_oracle.Checked.Digest.t
    ; mutable bits : Boolean.var Bitstring.Lsb_first.t option
    }

  let var_of_t t =
    let n = Bigint.of_field t in
    { digest = Field.Var.constant t
    ; bits =
        Some
          (Bitstring.Lsb_first.of_list
             (List.init M.length_in_bits ~f:(fun i ->
                  Boolean.var_of_value (Bigint.test_bit n i) ) ) )
    }

  open Let_syntax

  let var_to_hash_packed { digest; _ } = digest

  (* TODO: Audit this usage of choose_preimage *)
  let unpack =
    if Int.( = ) length_in_bits Field.size_in_bits then fun x ->
      Field.Checked.choose_preimage_var x ~length:length_in_bits
      >>| fun x -> (x :> Boolean.var list)
    else Field.Checked.unpack ~length:length_in_bits

  let%snarkydef_ var_to_bits t =
    match t.bits with
    | Some bits ->
        return (bits :> Boolean.var list)
    | None ->
        let%map bits = unpack t.digest in
        t.bits <- Some (Bitstring.Lsb_first.of_list bits) ;
        bits

  let var_to_input (t : var) = Random_oracle.Input.Chunked.field t.digest

  (* TODO : use Random oracle.Digest to satisfy Bits_intf.S, move out of
     consensus_mechanism guard
  *)
  module Bs =
    Snark_bits.Bits.Make_field
      (Snark_params.Tick.Field)
      (Snark_params.Tick.Bigint)

  include (Bs : module type of Bs with type t := t)

  let assert_equal x y = Field.Checked.Assert.equal x.digest y.digest

  let equal_var x y = Field.Checked.equal x.digest y.digest

  let typ : (var, t) Typ.t =
    Typ.transport_var Typ.field
      ~there:(fun { digest; bits = _ } -> digest)
      ~back:(fun digest -> { digest; bits = None })
end

module T0 = struct
  [%%versioned
  module Stable = struct
    module V1 = struct
      [@@@with_all_version_tags]

      type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]

      let to_latest = Fn.id
    end
  end]
end

module Make_full_size (B58_data : Data_hash_intf.Data_hash_descriptor) = struct
  module Basic = Make_basic (struct
    let length_in_bits = Field.size_in_bits
  end)

  include Basic

  module Base58_check = Codable.Make_base58_check (struct
    (* for compatibility with legacy Base58Check serializations *)
    include T0.Stable.Latest.With_all_version_tags

    (* the serialization here is only used for the hash impl which is only
       used for hashtbl, it's ok to disagree with the "real" serialization *)
    include Hashable.Make_binable (T0.Stable.Latest)
    include B58_data
  end)

  [%%define_locally
  Base58_check.
    (to_base58_check, of_base58_check, of_base58_check_exn, to_yojson, of_yojson)]

  module T = struct
    type t = Field.t [@@deriving sexp, compare, hash]
  end

  include Comparable.Make (T)
  include Hashable.Make (T)

  let of_hash = Fn.id

  let to_field = Fn.id

  let var_of_hash_packed digest = { digest; bits = None }

  let var_to_field { digest; _ } = digest

  let if_ cond ~then_ ~else_ =
    let%map digest =
      Field.Checked.if_ cond ~then_:then_.digest ~else_:else_.digest
    in
    { digest; bits = None }
end

1	(* data_hash.ml *)	9✔
2	open Core_kernel
3	open Snark_params.Tick
4	open Bitstring_lib
5
6	module type Full_size = Data_hash_intf.Full_size
7
8	module Make_basic (M : sig
9	val length_in_bits : int
10	end) =
11	struct
12	type t = Field.t [@@deriving sexp, compare, hash]	×
13
14	let to_decimal_string (t : Field.t) = Field.to_string t	×
15
16	let of_decimal_string (s : string) = Field.of_string s	×
17
18	let to_bytes t =
19	Fold_lib.(Fold.bool_t_to_string (Fold.of_list (Field.unpack t)))	806✔
20
21	let length_in_bits = M.length_in_bits
22
23	let () = assert (Int.(length_in_bits <= Field.size_in_bits))	72✔
24
25	let to_input t = Random_oracle.Input.Chunked.field t	33,273✔
26
27	(* this is in consensus code, because Bigint comes
28	from snarky functors
29	*)
30	let gen : t Quickcheck.Generator.t =
31	let m =
32	if Int.(length_in_bits = Field.size_in_bits) then
33	Bignum_bigint.(Field.size - one)	72✔
34	else Bignum_bigint.(pow (of_int 2) (of_int length_in_bits) - one)	×
35	in
36	Quickcheck.Generator.map	72✔
37	Bignum_bigint.(gen_incl zero m)	72✔
38	~f:(fun x -> Bigint.(to_field (of_bignum_bigint x)))	×
39
40	type var =
41	{ digest : Random_oracle.Checked.Digest.t
42	; mutable bits : Boolean.var Bitstring.Lsb_first.t option
43	}
44
45	let var_of_t t =
46	let n = Bigint.of_field t in	66✔
47	{ digest = Field.Var.constant t	66✔
48	; bits =
49	Some
50	(Bitstring.Lsb_first.of_list	66✔
51	(List.init M.length_in_bits ~f:(fun i ->	66✔
52	Boolean.var_of_value (Bigint.test_bit n i) ) ) )	16,830✔
53	}
54
55	open Let_syntax
56
57	let var_to_hash_packed { digest; _ } = digest	718✔
58
59	(* TODO: Audit this usage of choose_preimage *)
60	let unpack =
61	if Int.( = ) length_in_bits Field.size_in_bits then fun x ->	72✔
62	Field.Checked.choose_preimage_var x ~length:length_in_bits	×
63	>>\| fun x -> (x :> Boolean.var list)	×
64	else Field.Checked.unpack ~length:length_in_bits	×
65
66	let%snarkydef_ var_to_bits t =
67	match t.bits with	×
68	\| Some bits ->	×
69	return (bits :> Boolean.var list)
70	\| None ->	×
71	let%map bits = unpack t.digest in	×
72	t.bits <- Some (Bitstring.Lsb_first.of_list bits) ;	×
73	bits
74
75	let var_to_input (t : var) = Random_oracle.Input.Chunked.field t.digest	1,435✔
76
77	(* TODO : use Random oracle.Digest to satisfy Bits_intf.S, move out of
78	consensus_mechanism guard
79	*)
80	module Bs =
81	Snark_bits.Bits.Make_field
82	(Snark_params.Tick.Field)
83	(Snark_params.Tick.Bigint)
84
85	include (Bs : module type of Bs with type t := t)
86
87	let assert_equal x y = Field.Checked.Assert.equal x.digest y.digest	199✔
88
89	let equal_var x y = Field.Checked.equal x.digest y.digest	824✔
90
91	let typ : (var, t) Typ.t =
92	Typ.transport_var Typ.field	72✔
93	~there:(fun { digest; bits = _ } -> digest)	3,509✔
94	~back:(fun digest -> { digest; bits = None })	2,627✔
95	end
96
97	module T0 = struct
98	[%%versioned
99	module Stable = struct	×
100	module V1 = struct
101	[@@@with_all_version_tags]
102
103	type t = (Field.t[@version_asserted]) [@@deriving sexp, compare, hash]	18✔
104
105	let to_latest = Fn.id
106	end
107	end]	×
108	end
109
110	module Make_full_size (B58_data : Data_hash_intf.Data_hash_descriptor) = struct
111	module Basic = Make_basic (struct
112	let length_in_bits = Field.size_in_bits
113	end)
114
115	include Basic
116
117	module Base58_check = Codable.Make_base58_check (struct
118	(* for compatibility with legacy Base58Check serializations *)
119	include T0.Stable.Latest.With_all_version_tags
120
121	(* the serialization here is only used for the hash impl which is only
122	used for hashtbl, it's ok to disagree with the "real" serialization *)
123	include Hashable.Make_binable (T0.Stable.Latest)
124	include B58_data
125	end)
126
127	[%%define_locally
128	Base58_check.
129	(to_base58_check, of_base58_check, of_base58_check_exn, to_yojson, of_yojson)]
130
131	module T = struct
132	type t = Field.t [@@deriving sexp, compare, hash]	×
133	end
134
135	include Comparable.Make (T)
136	include Hashable.Make (T)
137
138	let of_hash = Fn.id
139
140	let to_field = Fn.id
141
142	let var_of_hash_packed digest = { digest; bits = None }	259✔
143
144	let var_to_field { digest; _ } = digest	7✔
145
146	let if_ cond ~then_ ~else_ =
147	let%map digest =
148	Field.Checked.if_ cond ~then_:then_.digest ~else_:else_.digest	505✔
149	in
150	{ digest; bits = None }	505✔
151	end	9✔

MinaProtocol / mina / 2863

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous