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

57.69

/src/lib/mina_base/zkapp_basic.ml

open Core_kernel

let field_of_bool = Mina_base_util.field_of_bool

open Snark_params.Tick
open Signature_lib

let int_to_bits ~length x = List.init length ~f:(fun i -> (x lsr i) land 1 = 1)

let int_of_bits =
  List.foldi ~init:0 ~f:(fun i acc b -> if b then acc lor (1 lsl i) else acc)

module Transition = struct
  [%%versioned
  module Stable = struct
    module V1 = struct
      type 'a t = { prev : 'a; next : 'a }
      [@@deriving hlist, sexp, equal, yojson, hash, compare]
    end
  end]

  let to_input { prev; next } ~f =
    Random_oracle_input.Chunked.append (f prev) (f next)

  let typ t =
    Typ.of_hlistable [ t; t ] ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist
      ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist
end

module Flagged_data = struct
  type ('flag, 'a) t = { flag : 'flag; data : 'a } [@@deriving hlist, fields]

  let typ flag t =
    Typ.of_hlistable [ flag; t ] ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist
      ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist

  let to_input' { flag; data } ~flag:f ~data:d =
    Random_oracle_input.Chunked.(append (f flag) (d data))
end

module Flagged_option = struct
  type ('bool, 'a) t = { is_some : 'bool; data : 'a } [@@deriving hlist, fields]

  let to_input' ~field_of_bool { is_some; data } ~f =
    Random_oracle_input.Chunked.(
      append (packed (field_of_bool is_some, 1)) (f data))

  let to_input { is_some; data } ~default ~f =
    let data = if is_some then data else default in
    to_input' { is_some; data } ~f

  let of_option t ~default =
    match t with
    | None ->
        { is_some = false; data = default }
    | Some data ->
        { is_some = true; data }

  let to_option { is_some; data } = Option.some_if is_some data

  let map ~f { is_some; data } = { is_some; data = f data }

  let if_ ~(if_ : 'b -> then_:'var -> else_:'var -> 'var) b ~then_ ~else_ =
    { is_some =
        Run.run_checked
          (Boolean.if_ b ~then_:then_.is_some ~else_:else_.is_some)
    ; data = if_ b ~then_:then_.data ~else_:else_.data
    }

  let typ t =
    Typ.of_hlistable [ Boolean.typ; t ] ~var_to_hlist:to_hlist
      ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist

  let option_typ ~default t =
    Typ.transport (typ t) ~there:(of_option ~default) ~back:to_option

  let lazy_option_typ ~default t =
    Typ.transport (typ t)
      ~there:(fun t -> of_option t ~default:(Lazy.force default))
      ~back:to_option
end

module Set_or_keep = struct
  [%%versioned
  module Stable = struct
    module V1 = struct
      type 'a t = 'a Mina_wire_types.Mina_base.Zkapp_basic.Set_or_keep.V1.t =
        | Set of 'a
        | Keep
      [@@deriving sexp, equal, compare, hash, yojson]
    end
  end]

  let map t ~f = match t with Keep -> Keep | Set x -> Set (f x)

  let to_option = function Set x -> Some x | Keep -> None

  let of_option = function Some x -> Set x | None -> Keep

  let set_or_keep t x = match t with Keep -> x | Set y -> y

  let is_set = function Set _ -> true | _ -> false

  let is_keep = function Keep -> true | _ -> false

  let deriver inner obj =
    let open Fields_derivers_zkapps.Derivers in
    iso ~map:of_option ~contramap:to_option
      ((option ~js_type:Flagged_option @@ inner @@ o ()) (o ()))
      obj

  let gen gen_a =
    let open Quickcheck.Let_syntax in
    (* with equal probability, return a Set or a Keep *)
    let%bind b = Quickcheck.Generator.bool in
    if b then
      let%bind a = gen_a in
      return (Set a)
    else return Keep

  module Checked : sig
    type 'a t

    val is_keep : _ t -> Boolean.var

    val is_set : _ t -> Boolean.var

    val set_or_keep :
      if_:(Boolean.var -> then_:'a -> else_:'a -> 'a) -> 'a t -> 'a -> 'a

    val data : 'a t -> 'a

    val typ :
      dummy:'a -> ('a_var, 'a) Typ.t -> ('a_var t, 'a Stable.Latest.t) Typ.t

    val optional_typ :
         to_option:('new_value -> 'value option)
      -> of_option:('value option -> 'new_value)
      -> ('var, 'new_value) Typ.t
      -> ('var t, 'value Stable.Latest.t) Typ.t

    val map : f:('a -> 'b) -> 'a t -> 'b t

    val to_input :
         'a t
      -> f:('a -> Field.Var.t Random_oracle_input.Chunked.t)
      -> Field.Var.t Random_oracle_input.Chunked.t

    val set : 'a -> 'a t

    val keep : dummy:'a -> 'a t

    val make_unsafe : Boolean.var -> 'a -> 'a t
  end = struct
    type 'a t = (Boolean.var, 'a) Flagged_option.t

    let set_or_keep ~if_ ({ is_some; data } : _ t) x =
      if_ is_some ~then_:data ~else_:x

    let data = Flagged_option.data

    let is_set = Flagged_option.is_some

    let is_keep x = Boolean.not (Flagged_option.is_some x)

    let map = Flagged_option.map

    let typ ~dummy t =
      Typ.transport
        (Flagged_option.option_typ ~default:dummy t)
        ~there:to_option ~back:of_option

    let optional_typ (type new_value value var) :
           to_option:(new_value -> value option)
        -> of_option:(value option -> new_value)
        -> (var, new_value) Typ.t
        -> (var t, value Stable.Latest.t) Typ.t =
     fun ~to_option ~of_option t ->
      Typ.transport (Flagged_option.typ t)
        ~there:(function
          | Set x ->
              { Flagged_option.is_some = true; data = of_option (Some x) }
          | Keep ->
              { Flagged_option.is_some = false; data = of_option None } )
        ~back:(function
          | { Flagged_option.is_some = true; data = x } ->
              Set (Option.value_exn (to_option x))
          | { Flagged_option.is_some = false; data = _ } ->
              Keep )

    let to_input (t : _ t) ~f =
      Flagged_option.to_input' t ~f ~field_of_bool:(fun (b : Boolean.var) ->
          (b :> Field.Var.t) )

    let make_unsafe is_keep data = { Flagged_option.is_some = is_keep; data }

    let set data = { Flagged_option.is_some = Boolean.true_; data }

    let keep ~dummy = { Flagged_option.is_some = Boolean.false_; data = dummy }
  end

  let typ = Checked.typ

  let optional_typ = Checked.optional_typ

  let to_input t ~dummy:default ~f =
    Flagged_option.to_input ~default ~f ~field_of_bool
      (Flagged_option.of_option ~default (to_option t))
end

module Or_ignore = struct
  [%%versioned
  module Stable = struct
    module V1 = struct
      type 'a t = 'a Mina_wire_types.Mina_base.Zkapp_basic.Or_ignore.V1.t =
        | Check of 'a
        | Ignore
      [@@deriving sexp, equal, compare, hash, yojson]
    end
  end]

  let gen gen_a =
    let open Quickcheck.Let_syntax in
    (* choose constructor *)
    let%bind b = Quickcheck.Generator.bool in
    if b then
      let%map a = gen_a in
      Check a
    else return Ignore

  let to_option = function Ignore -> None | Check x -> Some x

  let of_option = function None -> Ignore | Some x -> Check x

  let deriver_base ~js_type inner obj =
    let open Fields_derivers_zkapps.Derivers in
    iso ~map:of_option ~contramap:to_option
      ((option ~js_type @@ inner @@ o ()) (o ()))
      obj

  let deriver inner obj = deriver_base ~js_type:Flagged_option inner obj

  let deriver_interval inner obj ~range_max =
    deriver_base ~js_type:(Closed_interval range_max) inner obj

  module Checked : sig
    type 'a t

    val typ :
      ignore:'a -> ('a_var, 'a) Typ.t -> ('a_var t, 'a Stable.Latest.t) Typ.t

    val to_input :
         'a t
      -> f:('a -> Field.Var.t Random_oracle_input.Chunked.t)
      -> Field.Var.t Random_oracle_input.Chunked.t

    val check : 'a t -> f:('a -> Boolean.var) -> Boolean.var

    val map : f:('a -> 'b) -> 'a t -> 'b t

    val data : 'a t -> 'a

    val is_check : 'a t -> Boolean.var

    val make_unsafe : Boolean.var -> 'a -> 'a t
  end = struct
    type 'a t = (Boolean.var, 'a) Flagged_option.t

    let to_input t ~f =
      Flagged_option.to_input' t ~f ~field_of_bool:(fun (b : Boolean.var) ->
          (b :> Field.Var.t) )

    let check { Flagged_option.is_some; data } ~f =
      Pickles.Impls.Step.Boolean.(any [ not is_some; f data ])

    let map = Flagged_option.map

    let data = Flagged_option.data

    let is_check = Flagged_option.is_some

    let typ (type a_var a) ~ignore (t : (a_var, a) Typ.t) =
      Typ.transport
        (Flagged_option.option_typ ~default:ignore t)
        ~there:to_option ~back:of_option

    let make_unsafe is_ignore data =
      { Flagged_option.is_some = is_ignore; data }
  end

  let typ = Checked.typ
end

module Account_state = struct
  [%%versioned
  module Stable = struct
    module V1 = struct
      type t = Empty | Non_empty | Any
      [@@deriving sexp, equal, yojson, hash, compare, enum]

      let to_latest = Fn.id
    end
  end]

  module Encoding = struct
    type 'b t = { any : 'b; empty : 'b } [@@deriving hlist]

    let to_input ~field_of_bool { any; empty } =
      Random_oracle_input.Chunked.packeds
        [| (field_of_bool any, 1); (field_of_bool empty, 1) |]
  end

  let encode : t -> bool Encoding.t = function
    | Empty ->
        { any = false; empty = true }
    | Non_empty ->
        { any = false; empty = false }
    | Any ->
        { any = true; empty = false }

  let decode : bool Encoding.t -> t = function
    | { any = false; empty = true } ->
        Empty
    | { any = false; empty = false } ->
        Non_empty
    | { any = true; empty = false } | { any = true; empty = true } ->
        Any

  let to_input (x : t) = Encoding.to_input ~field_of_bool (encode x)

  let check (t : t) (x : [ `Empty | `Non_empty ]) =
    match (t, x) with
    | Any, _ | Non_empty, `Non_empty | Empty, `Empty ->
        Ok ()
    | _ ->
        Or_error.error_string "Bad account_type"

  module Checked = struct
    open Pickles.Impls.Step

    type t = Boolean.var Encoding.t

    let to_input (t : t) =
      Encoding.to_input t ~field_of_bool:(fun (b : Boolean.var) ->
          (b :> Field.t) )

    let check (t : t) ~is_empty =
      Boolean.(
        any [ t.any; t.empty && is_empty; (not t.empty) && not is_empty ])
  end

  let typ : (Checked.t, t) Typ.t =
    let open Encoding in
    Typ.of_hlistable
      [ Boolean.typ; Boolean.typ ]
      ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist
      ~value_of_hlist:of_hlist
    |> Typ.transport ~there:encode ~back:decode
end

module F = Pickles.Backend.Tick.Field

module F_map = struct
  include Hashable.Make (F)
  include Comparable.Make (F)
end

let invalid_public_key : Public_key.Compressed.t =
  { x = F.zero; is_odd = false }

let%test "invalid_public_key is invalid" =
  Option.is_none (Public_key.decompress invalid_public_key)

1	open Core_kernel	9✔
2
3	let field_of_bool = Mina_base_util.field_of_bool
4
5	open Snark_params.Tick
6	open Signature_lib
7
8	let int_to_bits ~length x = List.init length ~f:(fun i -> (x lsr i) land 1 = 1)	×
9
10	let int_of_bits =
11	List.foldi ~init:0 ~f:(fun i acc b -> if b then acc lor (1 lsl i) else acc)	×
12
13	module Transition = struct
14	[%%versioned
15	module Stable = struct
16	module V1 = struct
17	type 'a t = { prev : 'a; next : 'a }	×
18	[@@deriving hlist, sexp, equal, yojson, hash, compare]	27✔
19	end
20	end]
21
22	let to_input { prev; next } ~f =
23	Random_oracle_input.Chunked.append (f prev) (f next)	×
24
25	let typ t =
26	Typ.of_hlistable [ t; t ] ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist	×
27	~value_to_hlist:to_hlist ~value_of_hlist:of_hlist
28	end
29
30	module Flagged_data = struct
31	type ('flag, 'a) t = { flag : 'flag; data : 'a } [@@deriving hlist, fields]	×
32
33	let typ flag t =
34	Typ.of_hlistable [ flag; t ] ~var_to_hlist:to_hlist ~var_of_hlist:of_hlist	×
35	~value_to_hlist:to_hlist ~value_of_hlist:of_hlist
36
37	let to_input' { flag; data } ~flag:f ~data:d =
38	Random_oracle_input.Chunked.(append (f flag) (d data))	×
39	end
40
41	module Flagged_option = struct
42	type ('bool, 'a) t = { is_some : 'bool; data : 'a } [@@deriving hlist, fields]	×
43
44	let to_input' ~field_of_bool { is_some; data } ~f =
45	Random_oracle_input.Chunked.(	22,176✔
46	append (packed (field_of_bool is_some, 1)) (f data))	22,176✔
47
48	let to_input { is_some; data } ~default ~f =
49	let data = if is_some then data else default in	2,783✔
50	to_input' { is_some; data } ~f
51
52	let of_option t ~default =
53	match t with	6,450✔
54	\| None ->	3,667✔
55	{ is_some = false; data = default }
56	\| Some data ->	2,783✔
57	{ is_some = true; data }
58
59	let to_option { is_some; data } = Option.some_if is_some data	×
60
61	let map ~f { is_some; data } = { is_some; data = f data }	224✔
62
63	let if_ ~(if_ : 'b -> then_:'var -> else_:'var -> 'var) b ~then_ ~else_ =
64	{ is_some =	32✔
65	Run.run_checked	32✔
66	(Boolean.if_ b ~then_:then_.is_some ~else_:else_.is_some)	32✔
67	; data = if_ b ~then_:then_.data ~else_:else_.data	32✔
68	}
69
70	let typ t =
71	Typ.of_hlistable [ Boolean.typ; t ] ~var_to_hlist:to_hlist	587✔
72	~var_of_hlist:of_hlist ~value_to_hlist:to_hlist ~value_of_hlist:of_hlist
73
74	let option_typ ~default t =
75	Typ.transport (typ t) ~there:(of_option ~default) ~back:to_option	514✔
76
77	let lazy_option_typ ~default t =
78	Typ.transport (typ t)	9✔
79	~there:(fun t -> of_option t ~default:(Lazy.force default))	×
80	~back:to_option
81	end
82
83	module Set_or_keep = struct
84	[%%versioned
85	module Stable = struct
86	module V1 = struct
87	type 'a t = 'a Mina_wire_types.Mina_base.Zkapp_basic.Set_or_keep.V1.t =	36✔
88	\| Set of 'a	×
89	\| Keep	3,756✔
90	[@@deriving sexp, equal, compare, hash, yojson]	153✔
91	end
92	end]
93
94	let map t ~f = match t with Keep -> Keep \| Set x -> Set (f x)	368✔
95
96	let to_option = function Set x -> Some x \| Keep -> None	4,620✔
97
98	let of_option = function Some x -> Set x \| None -> Keep	946✔
99
100	let set_or_keep t x = match t with Keep -> x \| Set y -> y	×
101
102	let is_set = function Set _ -> true \| _ -> false	393✔
103
104	let is_keep = function Keep -> true \| _ -> false	393✔
105
106	let deriver inner obj =
107	let open Fields_derivers_zkapps.Derivers in	184✔
108	iso ~map:of_option ~contramap:to_option
109	((option ~js_type:Flagged_option @@ inner @@ o ()) (o ()))	184✔
110	obj
111
112	let gen gen_a =
113	let open Quickcheck.Let_syntax in	1,473✔
114	(* with equal probability, return a Set or a Keep *)
115	let%bind b = Quickcheck.Generator.bool in
116	if b then	3,527✔
117	let%bind a = gen_a in
118	return (Set a)	1,749✔
119	else return Keep	1,778✔
120
121	module Checked : sig
122	type 'a t
123
124	val is_keep : _ t -> Boolean.var
125
126	val is_set : _ t -> Boolean.var
127
128	val set_or_keep :
129	if_:(Boolean.var -> then_:'a -> else_:'a -> 'a) -> 'a t -> 'a -> 'a
130
131	val data : 'a t -> 'a
132
133	val typ :
134	dummy:'a -> ('a_var, 'a) Typ.t -> ('a_var t, 'a Stable.Latest.t) Typ.t
135
136	val optional_typ :
137	to_option:('new_value -> 'value option)
138	-> of_option:('value option -> 'new_value)
139	-> ('var, 'new_value) Typ.t
140	-> ('var t, 'value Stable.Latest.t) Typ.t
141
142	val map : f:('a -> 'b) -> 'a t -> 'b t
143
144	val to_input :
145	'a t
146	-> f:('a -> Field.Var.t Random_oracle_input.Chunked.t)
147	-> Field.Var.t Random_oracle_input.Chunked.t
148
149	val set : 'a -> 'a t
150
151	val keep : dummy:'a -> 'a t
152
153	val make_unsafe : Boolean.var -> 'a -> 'a t
154	end = struct
155	type 'a t = (Boolean.var, 'a) Flagged_option.t
156
157	let set_or_keep ~if_ ({ is_some; data } : _ t) x =
158	if_ is_some ~then_:data ~else_:x	480✔
159
160	let data = Flagged_option.data
161
162	let is_set = Flagged_option.is_some
163
164	let is_keep x = Boolean.not (Flagged_option.is_some x)	480✔
165
166	let map = Flagged_option.map
167
168	let typ ~dummy t =
169	Typ.transport	192✔
170	(Flagged_option.option_typ ~default:dummy t)	192✔
171	~there:to_option ~back:of_option
172
173	let optional_typ (type new_value value var) :
174	to_option:(new_value -> value option)
175	-> of_option:(value option -> new_value)
176	-> (var, new_value) Typ.t
177	-> (var t, value Stable.Latest.t) Typ.t =
178	fun ~to_option ~of_option t ->
179	Typ.transport (Flagged_option.typ t)	64✔
180	~there:(function
181	\| Set x ->	×
182	{ Flagged_option.is_some = true; data = of_option (Some x) }	×
183	\| Keep ->	×
184	{ Flagged_option.is_some = false; data = of_option None } )	×
185	~back:(function
186	\| { Flagged_option.is_some = true; data = x } ->	×
187	Set (Option.value_exn (to_option x))	×
188	\| { Flagged_option.is_some = false; data = _ } ->	×
189	Keep )
190
191	let to_input (t : _ t) ~f =
192	Flagged_option.to_input' t ~f ~field_of_bool:(fun (b : Boolean.var) ->	480✔
193	(b :> Field.Var.t) )	480✔
194
195	let make_unsafe is_keep data = { Flagged_option.is_some = is_keep; data }	×
196
197	let set data = { Flagged_option.is_some = Boolean.true_; data }	×
198
199	let keep ~dummy = { Flagged_option.is_some = Boolean.false_; data = dummy }	×
200	end
201
202	let typ = Checked.typ
203
204	let optional_typ = Checked.optional_typ
205
206	let to_input t ~dummy:default ~f =
207	Flagged_option.to_input ~default ~f ~field_of_bool	6,450✔
208	(Flagged_option.of_option ~default (to_option t))	6,450✔
209	end
210
211	module Or_ignore = struct
212	[%%versioned
213	module Stable = struct
214	module V1 = struct
215	type 'a t = 'a Mina_wire_types.Mina_base.Zkapp_basic.Or_ignore.V1.t =	36✔
216	\| Check of 'a	×
217	\| Ignore	10,992✔
218	[@@deriving sexp, equal, compare, hash, yojson]	261✔
219	end
220	end]
221
222	let gen gen_a =
223	let open Quickcheck.Let_syntax in	2,839✔
224	(* choose constructor *)
225	let%bind b = Quickcheck.Generator.bool in
226	if b then	2,803✔
227	let%map a = gen_a in
228	Check a	1,197✔
229	else return Ignore	1,606✔
230
231	let to_option = function Ignore -> None \| Check x -> Some x	1,558✔
232
233	let of_option = function None -> Ignore \| Some x -> Check x	280✔
234
235	let deriver_base ~js_type inner obj =
236	let open Fields_derivers_zkapps.Derivers in	598✔
237	iso ~map:of_option ~contramap:to_option
238	((option ~js_type @@ inner @@ o ()) (o ()))	598✔
239	obj
240
241	let deriver inner obj = deriver_base ~js_type:Flagged_option inner obj	345✔
242
243	let deriver_interval inner obj ~range_max =
244	deriver_base ~js_type:(Closed_interval range_max) inner obj	253✔
245
246	module Checked : sig
247	type 'a t
248
249	val typ :
250	ignore:'a -> ('a_var, 'a) Typ.t -> ('a_var t, 'a Stable.Latest.t) Typ.t
251
252	val to_input :
253	'a t
254	-> f:('a -> Field.Var.t Random_oracle_input.Chunked.t)
255	-> Field.Var.t Random_oracle_input.Chunked.t
256
257	val check : 'a t -> f:('a -> Boolean.var) -> Boolean.var
258
259	val map : f:('a -> 'b) -> 'a t -> 'b t
260
261	val data : 'a t -> 'a
262
263	val is_check : 'a t -> Boolean.var
264
265	val make_unsafe : Boolean.var -> 'a -> 'a t
266	end = struct
267	type 'a t = (Boolean.var, 'a) Flagged_option.t
268
269	let to_input t ~f =
270	Flagged_option.to_input' t ~f ~field_of_bool:(fun (b : Boolean.var) ->	1,056✔
271	(b :> Field.Var.t) )	1,056✔
272
273	let check { Flagged_option.is_some; data } ~f =
274	Pickles.Impls.Step.Boolean.(any [ not is_some; f data ])	1,120✔
275
276	let map = Flagged_option.map
277
278	let data = Flagged_option.data
279
280	let is_check = Flagged_option.is_some
281
282	let typ (type a_var a) ~ignore (t : (a_var, a) Typ.t) =
283	Typ.transport	322✔
284	(Flagged_option.option_typ ~default:ignore t)	322✔
285	~there:to_option ~back:of_option
286
287	let make_unsafe is_ignore data =
288	{ Flagged_option.is_some = is_ignore; data }	×
289	end
290
291	let typ = Checked.typ
292	end
293
294	module Account_state = struct
295	[%%versioned
296	module Stable = struct
297	module V1 = struct
298	type t = Empty \| Non_empty \| Any	×
299	[@@deriving sexp, equal, yojson, hash, compare, enum]	45✔
300
301	let to_latest = Fn.id
302	end
303	end]
304
305	module Encoding = struct
306	type 'b t = { any : 'b; empty : 'b } [@@deriving hlist]	×
307
308	let to_input ~field_of_bool { any; empty } =
309	Random_oracle_input.Chunked.packeds	×
310	[\| (field_of_bool any, 1); (field_of_bool empty, 1) \|]	×
311	end
312
313	let encode : t -> bool Encoding.t = function
314	\| Empty ->	×
315	{ any = false; empty = true }
316	\| Non_empty ->	×
317	{ any = false; empty = false }
318	\| Any ->	×
319	{ any = true; empty = false }
320
321	let decode : bool Encoding.t -> t = function
322	\| { any = false; empty = true } ->	×
323	Empty
324	\| { any = false; empty = false } ->	×
325	Non_empty
326	\| { any = true; empty = false } \| { any = true; empty = true } ->	×
327	Any
328
329	let to_input (x : t) = Encoding.to_input ~field_of_bool (encode x)	×
330
331	let check (t : t) (x : [ `Empty \| `Non_empty ]) =
332	match (t, x) with	×
333	\| Any, _ \| Non_empty, `Non_empty \| Empty, `Empty ->	×
334	Ok ()
335	\| _ ->	×
336	Or_error.error_string "Bad account_type"
337
338	module Checked = struct
339	open Pickles.Impls.Step
340
341	type t = Boolean.var Encoding.t
342
343	let to_input (t : t) =
344	Encoding.to_input t ~field_of_bool:(fun (b : Boolean.var) ->	×
345	(b :> Field.t) )	×
346
347	let check (t : t) ~is_empty =
348	Boolean.(	×
349	any [ t.any; t.empty && is_empty; (not t.empty) && not is_empty ])	×
350	end
351
352	let typ : (Checked.t, t) Typ.t =
353	let open Encoding in
354	Typ.of_hlistable	9✔
355	[ Boolean.typ; Boolean.typ ]
356	~var_to_hlist:to_hlist ~var_of_hlist:of_hlist ~value_to_hlist:to_hlist
357	~value_of_hlist:of_hlist
358	\|> Typ.transport ~there:encode ~back:decode	9✔
359	end
360
361	module F = Pickles.Backend.Tick.Field
362
363	module F_map = struct
364	include Hashable.Make (F)
365	include Comparable.Make (F)
366	end
367
368	let invalid_public_key : Public_key.Compressed.t =
369	{ x = F.zero; is_odd = false }
370
371	let%test "invalid_public_key is invalid" =
372	Option.is_none (Public_key.decompress invalid_public_key)	×

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