2903

Committed 15 Nov 2024 01:59PM UTC coverage: 36.723% (-25.0%) from 61.682%

Build # 2903

Build Type

Pull #16342

buildkite

Committed by

dkijania

Commit Message

Merge branch 'dkijania/remove_publish_job_from_pr_comp' into dkijania/remove_publish_job_from_pr_dev

Pull Request Pull Request #16342: [DEV] Publish debians only on nightly and stable

Run Details

15 of 40 new or added lines in 14 files covered. (37.5%)

15175 existing lines in 340 files now uncovered.

24554 of 66863 relevant lines covered (36.72%)

20704.91 hits per line

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

44.32

/src/lib/pickles/types_map.ml

open Core_kernel
open Pickles_types
open Import
open Backend

(* We maintain a global hash table which stores for each inductive proof system some
   data.
*)
type inner_curve_var =
  Tick.Field.t Snarky_backendless.Cvar.t
  * Tick.Field.t Snarky_backendless.Cvar.t

module Basic = struct
  type ('var, 'value, 'n1, 'n2) t =
    { max_proofs_verified : (module Nat.Add.Intf with type n = 'n1)
    ; public_input : ('var, 'value) Impls.Step.Typ.t
    ; branches : 'n2 Nat.t
    ; wrap_domains : Domains.t
    ; wrap_key : Tick.Inner_curve.Affine.t array Plonk_verification_key_evals.t
    ; wrap_vk : Impls.Wrap.Verification_key.t
    ; feature_flags : Opt.Flag.t Plonk_types.Features.Full.t
    ; num_chunks : int
    ; zk_rows : int
    }
end

module Side_loaded = struct
  module Ephemeral = struct
    type t =
      { index :
          [ `In_circuit of Side_loaded_verification_key.Checked.t
          | `In_prover of Side_loaded_verification_key.t
          | `In_both of
            Side_loaded_verification_key.t
            * Side_loaded_verification_key.Checked.t ]
      }
  end

  module Permanent = struct
    type ('var, 'value, 'n1, 'n2) t =
      { max_proofs_verified : (module Nat.Add.Intf with type n = 'n1)
      ; public_input : ('var, 'value) Impls.Step.Typ.t
      ; feature_flags : Opt.Flag.t Plonk_types.Features.Full.t
      ; branches : 'n2 Nat.t
      ; num_chunks : int
      ; zk_rows : int
      }
  end

  type ('var, 'value, 'n1, 'n2) t =
    { ephemeral : Ephemeral.t option
    ; permanent : ('var, 'value, 'n1, 'n2) Permanent.t
    }

  type packed =
    | T : ('var, 'value, 'n1, 'n2) Tag.id * ('var, 'value, 'n1, 'n2) t -> packed

  let to_basic
      { permanent =
          { max_proofs_verified
          ; public_input
          ; branches
          ; feature_flags
          ; num_chunks
          ; zk_rows
          }
      ; ephemeral
      } =
    let wrap_key, wrap_vk =
      match ephemeral with
      | Some { index = `In_prover i | `In_both (i, _) } ->
          let wrap_index =
            Plonk_verification_key_evals.map i.wrap_index ~f:(fun x -> [| x |])
          in
          (wrap_index, i.wrap_vk)
      | _ ->
          failwithf "Side_loaded.to_basic: Expected `In_prover (%s)" __LOC__ ()
    in
    let proofs_verified = Nat.to_int (Nat.Add.n max_proofs_verified) in
    let wrap_vk = Option.value_exn ~here:[%here] wrap_vk in
    { Basic.max_proofs_verified
    ; wrap_vk
    ; public_input
    ; branches
    ; wrap_domains = Common.wrap_domains ~proofs_verified
    ; wrap_key
    ; feature_flags
    ; num_chunks
    ; zk_rows
    }
end

module Compiled = struct
  type ('a_var, 'a_value, 'max_proofs_verified, 'branches) basic =
    { public_input : ('a_var, 'a_value) Impls.Step.Typ.t
    ; proofs_verifieds : (int, 'branches) Vector.t
          (* For each branch in this rule, how many predecessor proofs does it have? *)
    ; wrap_domains : Domains.t
    ; step_domains : (Domains.t, 'branches) Vector.t
    ; feature_flags : Opt.Flag.t Plonk_types.Features.Full.t
    ; num_chunks : int
    ; zk_rows : int
    }

  (* This is the data associated to an inductive proof system with statement type
     ['a_var], which has ['branches] many "variants" each of which depends on at most
     ['max_proofs_verified] many previous statements. *)
  type ('a_var, 'a_value, 'max_proofs_verified, 'branches) t =
    { branches : 'branches Nat.t
    ; max_proofs_verified :
        (module Nat.Add.Intf with type n = 'max_proofs_verified)
    ; proofs_verifieds : (int, 'branches) Vector.t
          (* For each branch in this rule, how many predecessor proofs does it have? *)
    ; public_input : ('a_var, 'a_value) Impls.Step.Typ.t
    ; wrap_key :
        Tick.Inner_curve.Affine.t array Plonk_verification_key_evals.t Promise.t
        Lazy.t
    ; wrap_vk : Impls.Wrap.Verification_key.t Promise.t Lazy.t
    ; wrap_domains : Domains.t
    ; step_domains : (Domains.t Promise.t, 'branches) Vector.t
    ; feature_flags : Opt.Flag.t Plonk_types.Features.Full.t
    ; num_chunks : int
    ; zk_rows : int
    }

  type packed =
    | T : ('var, 'value, 'n1, 'n2) Tag.id * ('var, 'value, 'n1, 'n2) t -> packed

  let to_basic
      { branches = _
      ; max_proofs_verified
      ; proofs_verifieds = _
      ; public_input
      ; wrap_vk
      ; wrap_domains
      ; step_domains
      ; wrap_key
      ; feature_flags
      ; num_chunks
      ; zk_rows
      } =
    let%bind.Promise wrap_key = Lazy.force wrap_key in
    let%map.Promise wrap_vk = Lazy.force wrap_vk in
    { Basic.max_proofs_verified
    ; wrap_domains
    ; public_input
    ; branches = Vector.length step_domains
    ; wrap_key
    ; wrap_vk
    ; feature_flags
    ; num_chunks
    ; zk_rows
    }
end

module For_step = struct
  type ('a_var, 'a_value, 'max_proofs_verified, 'branches) t =
    { branches : 'branches Nat.t
    ; max_proofs_verified :
        (module Nat.Add.Intf with type n = 'max_proofs_verified)
    ; proofs_verifieds :
        [ `Known of (Impls.Step.Field.t, 'branches) Vector.t | `Side_loaded ]
    ; public_input : ('a_var, 'a_value) Impls.Step.Typ.t
    ; wrap_key : inner_curve_var array Plonk_verification_key_evals.t
    ; wrap_domain :
        [ `Known of Domain.t
        | `Side_loaded of
          Impls.Step.field Pickles_base.Proofs_verified.One_hot.Checked.t ]
    ; step_domains : [ `Known of (Domains.t, 'branches) Vector.t | `Side_loaded ]
    ; feature_flags : Opt.Flag.t Plonk_types.Features.Full.t
    ; num_chunks : int
    ; zk_rows : int
    }

  let of_side_loaded (type a b c d)
      ({ ephemeral
       ; permanent =
           { branches
           ; max_proofs_verified
           ; public_input
           ; feature_flags
           ; num_chunks
           ; zk_rows
           }
       } :
        (a, b, c, d) Side_loaded.t ) : (a, b, c, d) t =
    let index =
      match ephemeral with
      | Some { index = `In_circuit i | `In_both (_, i) } ->
          i
      | _ ->
          failwithf "For_step.side_loaded: Expected `In_circuit (%s)" __LOC__ ()
    in
    let T = Nat.eq_exn branches Side_loaded_verification_key.Max_branches.n in
    let wrap_key =
      Plonk_verification_key_evals.map index.wrap_index ~f:(fun x -> [| x |])
    in
    { branches
    ; max_proofs_verified
    ; public_input
    ; proofs_verifieds = `Side_loaded
    ; wrap_key
    ; wrap_domain = `Side_loaded index.actual_wrap_domain_size
    ; step_domains = `Side_loaded
    ; feature_flags
    ; num_chunks
    ; zk_rows
    }

  module Optional_wrap_key = struct
    type 'branches known =
      { wrap_key :
          Tick.Inner_curve.Affine.t array Plonk_verification_key_evals.t
      ; step_domains : (Domains.t, 'branches) Vector.t
      }

    type 'branches t = 'branches known option
  end

  let of_compiled_with_known_wrap_key
      ({ wrap_key; step_domains } : _ Optional_wrap_key.known)
      ({ branches
       ; max_proofs_verified
       ; proofs_verifieds
       ; public_input
       ; wrap_key = _
       ; wrap_domains
       ; step_domains = _
       ; feature_flags
       ; wrap_vk = _
       ; num_chunks
       ; zk_rows
       } :
        _ Compiled.t ) =
    { branches
    ; max_proofs_verified
    ; proofs_verifieds =
        `Known (Vector.map proofs_verifieds ~f:Impls.Step.Field.of_int)
    ; public_input
    ; wrap_key =
        Plonk_verification_key_evals.map wrap_key
          ~f:(Array.map ~f:Step_main_inputs.Inner_curve.constant)
    ; wrap_domain = `Known wrap_domains.h
    ; step_domains = `Known step_domains
    ; feature_flags
    ; num_chunks
    ; zk_rows
    }

  let of_compiled ({ wrap_key; step_domains; _ } as t : _ Compiled.t) =
    let%map.Promise wrap_key = Lazy.force wrap_key
    and step_domains =
      let%map.Promise () =
        (* Wait for promises to resolve. *)
        Vector.fold ~init:(Promise.return ()) step_domains
          ~f:(fun acc step_domain ->
            let%bind.Promise _ = step_domain in
            acc )
      in
      Vector.map ~f:(fun x -> Option.value_exn @@ Promise.peek x) step_domains
    in
    of_compiled_with_known_wrap_key { wrap_key; step_domains } t
end

type t =
  { compiled : Compiled.packed Type_equal.Id.Uid.Table.t
  ; side_loaded : Side_loaded.packed Type_equal.Id.Uid.Table.t
  }

let univ : t =
  { compiled = Type_equal.Id.Uid.Table.create ()
  ; side_loaded = Type_equal.Id.Uid.Table.create ()
  }

let find t k =
  match Hashtbl.find t k with None -> failwith "key not found" | Some x -> x

let lookup_compiled :
    type var value n m.
    (var, value, n, m) Tag.id -> (var, value, n, m) Compiled.t =
 fun t ->
  let (T (other_id, d)) = find univ.compiled (Type_equal.Id.uid t) in
  let T = Type_equal.Id.same_witness_exn t other_id in
  d

let lookup_side_loaded :
    type var value n m.
    (var, value, n, m) Tag.id -> (var, value, n, m) Side_loaded.t =
 fun t ->
  let (T (other_id, d)) = find univ.side_loaded (Type_equal.Id.uid t) in
  let T = Type_equal.Id.same_witness_exn t other_id in
  d

let lookup_basic :
    type var value n m.
    (var, value, n, m) Tag.t -> (var, value, n, m) Basic.t Promise.t =
 fun t ->
  match t.kind with
  | Compiled ->
      Compiled.to_basic (lookup_compiled t.id)
  | Side_loaded ->
      Promise.return @@ Side_loaded.to_basic (lookup_side_loaded t.id)

let max_proofs_verified :
    type n1. (_, _, n1, _) Tag.t -> (module Nat.Add.Intf with type n = n1) =
 fun tag ->
  match tag.kind with
  | Compiled ->
      (lookup_compiled tag.id).max_proofs_verified
  | Side_loaded ->
      (lookup_side_loaded tag.id).permanent.max_proofs_verified

let public_input :
    type var value. (var, value, _, _) Tag.t -> (var, value) Impls.Step.Typ.t =
 fun tag ->
  match tag.kind with
  | Compiled ->
      (lookup_compiled tag.id).public_input
  | Side_loaded ->
      (lookup_side_loaded tag.id).permanent.public_input

let feature_flags :
    type var value.
    (var, value, _, _) Tag.t -> Opt.Flag.t Plonk_types.Features.Full.t =
 fun tag ->
  match tag.kind with
  | Compiled ->
      (lookup_compiled tag.id).feature_flags
  | Side_loaded ->
      (lookup_side_loaded tag.id).permanent.feature_flags

let num_chunks : type var value. (var, value, _, _) Tag.t -> int =
 fun tag ->
  match tag.kind with
  | Compiled ->
      (lookup_compiled tag.id).num_chunks
  | Side_loaded ->
      (lookup_side_loaded tag.id).permanent.num_chunks

let _value_to_field_elements :
    type a. (_, a, _, _) Tag.t -> a -> Backend.Tick.Field.t array =
 fun t ->
  let (Typ typ) = public_input t in
  fun x -> fst (typ.value_to_fields x)

let _lookup_map (type var value c d) (t : (var, value, c, d) Tag.t) ~self
    ~default
    ~(f :
          [ `Compiled of (var, value, c, d) Compiled.t
          | `Side_loaded of (var, value, c, d) Side_loaded.t ]
       -> _ ) =
  match Type_equal.Id.same_witness t.id self with
  | Some _ ->
      default
  | None -> (
      match t.kind with
      | Compiled ->
          let (T (other_id, d)) = find univ.compiled (Type_equal.Id.uid t.id) in
          let T = Type_equal.Id.same_witness_exn t.id other_id in
          f (`Compiled d)
      | Side_loaded ->
          let (T (other_id, d)) =
            find univ.side_loaded (Type_equal.Id.uid t.id)
          in
          let T = Type_equal.Id.same_witness_exn t.id other_id in
          f (`Side_loaded d) )

let add_side_loaded ~name permanent =
  let (Tag.{ id; _ } as tag) = Tag.(create ~kind:Side_loaded name) in
  Hashtbl.add_exn univ.side_loaded ~key:(Type_equal.Id.uid id)
    ~data:(T (id, { ephemeral = None; permanent })) ;
  tag

let set_ephemeral { Tag.kind; id } (eph : Side_loaded.Ephemeral.t) =
  assert (match kind with Side_loaded -> true | Compiled -> false) ;
  Hashtbl.update univ.side_loaded (Type_equal.Id.uid id) ~f:(function
    | None ->
        assert false
    | Some (T (id, d)) ->
        let ephemeral =
          match (d.ephemeral, eph.index) with
          | None, _ | Some _, `In_prover _ ->
              (* Giving prover only always resets. *)
              Some eph
          | Some { index = `In_prover prover }, `In_circuit circuit
          | Some { index = `In_both (prover, _) }, `In_circuit circuit ->
              (* In-circuit extends prover if one was given. *)
              Some { index = `In_both (prover, circuit) }
          | _ ->
              (* Otherwise, just use the given value. *)
              Some eph
        in
        T (id, { d with ephemeral }) )

let add_exn (type var value c d) (tag : (var, value, c, d) Tag.t)
    (data : (var, value, c, d) Compiled.t) =
  Hashtbl.add_exn univ.compiled ~key:(Type_equal.Id.uid tag.id)
    ~data:(Compiled.T (tag.id, data))

1	open Core_kernel	22✔
2	open Pickles_types
3	open Import
4	open Backend
5
6	(* We maintain a global hash table which stores for each inductive proof system some
7	data.
8	*)
9	type inner_curve_var =
10	Tick.Field.t Snarky_backendless.Cvar.t
11	* Tick.Field.t Snarky_backendless.Cvar.t
12
13	module Basic = struct
14	type ('var, 'value, 'n1, 'n2) t =
15	{ max_proofs_verified : (module Nat.Add.Intf with type n = 'n1)
16	; public_input : ('var, 'value) Impls.Step.Typ.t
17	; branches : 'n2 Nat.t
18	; wrap_domains : Domains.t
19	; wrap_key : Tick.Inner_curve.Affine.t array Plonk_verification_key_evals.t
20	; wrap_vk : Impls.Wrap.Verification_key.t
21	; feature_flags : Opt.Flag.t Plonk_types.Features.Full.t
22	; num_chunks : int
23	; zk_rows : int
24	}
25	end
26
27	module Side_loaded = struct
28	module Ephemeral = struct
29	type t =
30	{ index :
31	[ `In_circuit of Side_loaded_verification_key.Checked.t
32	\| `In_prover of Side_loaded_verification_key.t
33	\| `In_both of
34	Side_loaded_verification_key.t
35	* Side_loaded_verification_key.Checked.t ]
36	}
37	end
38
39	module Permanent = struct
40	type ('var, 'value, 'n1, 'n2) t =
41	{ max_proofs_verified : (module Nat.Add.Intf with type n = 'n1)
42	; public_input : ('var, 'value) Impls.Step.Typ.t
43	; feature_flags : Opt.Flag.t Plonk_types.Features.Full.t
44	; branches : 'n2 Nat.t
45	; num_chunks : int
46	; zk_rows : int
47	}
48	end
49
50	type ('var, 'value, 'n1, 'n2) t =
51	{ ephemeral : Ephemeral.t option
52	; permanent : ('var, 'value, 'n1, 'n2) Permanent.t
53	}
54
55	type packed =
56	\| T : ('var, 'value, 'n1, 'n2) Tag.id * ('var, 'value, 'n1, 'n2) t -> packed
57
58	let to_basic
59	{ permanent =
60	{ max_proofs_verified
61	; public_input
62	; branches
63	; feature_flags
64	; num_chunks
65	; zk_rows
66	}
67	; ephemeral
68	} =
UNCOV 69	let wrap_key, wrap_vk =	×
70	match ephemeral with
71	\| Some { index = `In_prover i \| `In_both (i, _) } ->	×
72	let wrap_index =
UNCOV 73	Plonk_verification_key_evals.map i.wrap_index ~f:(fun x -> [\| x \|])	×
74	in
UNCOV 75	(wrap_index, i.wrap_vk)	×
76	\| _ ->	×
77	failwithf "Side_loaded.to_basic: Expected `In_prover (%s)" __LOC__ ()	×
78	in
UNCOV 79	let proofs_verified = Nat.to_int (Nat.Add.n max_proofs_verified) in	×
UNCOV 80	let wrap_vk = Option.value_exn ~here:[%here] wrap_vk in	×
UNCOV 81	{ Basic.max_proofs_verified	×
82	; wrap_vk
83	; public_input
84	; branches
85	; wrap_domains = Common.wrap_domains ~proofs_verified
86	; wrap_key
87	; feature_flags
88	; num_chunks
89	; zk_rows
90	}
91	end
92
93	module Compiled = struct
94	type ('a_var, 'a_value, 'max_proofs_verified, 'branches) basic =
95	{ public_input : ('a_var, 'a_value) Impls.Step.Typ.t
96	; proofs_verifieds : (int, 'branches) Vector.t
97	(* For each branch in this rule, how many predecessor proofs does it have? *)
98	; wrap_domains : Domains.t
99	; step_domains : (Domains.t, 'branches) Vector.t
100	; feature_flags : Opt.Flag.t Plonk_types.Features.Full.t
101	; num_chunks : int
102	; zk_rows : int
103	}
104
105	(* This is the data associated to an inductive proof system with statement type
106	['a_var], which has ['branches] many "variants" each of which depends on at most
107	['max_proofs_verified] many previous statements. *)
108	type ('a_var, 'a_value, 'max_proofs_verified, 'branches) t =
109	{ branches : 'branches Nat.t
110	; max_proofs_verified :
111	(module Nat.Add.Intf with type n = 'max_proofs_verified)
112	; proofs_verifieds : (int, 'branches) Vector.t
113	(* For each branch in this rule, how many predecessor proofs does it have? *)
114	; public_input : ('a_var, 'a_value) Impls.Step.Typ.t
115	; wrap_key :
116	Tick.Inner_curve.Affine.t array Plonk_verification_key_evals.t Promise.t
117	Lazy.t
118	; wrap_vk : Impls.Wrap.Verification_key.t Promise.t Lazy.t
119	; wrap_domains : Domains.t
120	; step_domains : (Domains.t Promise.t, 'branches) Vector.t
121	; feature_flags : Opt.Flag.t Plonk_types.Features.Full.t
122	; num_chunks : int
123	; zk_rows : int
124	}
125
126	type packed =
127	\| T : ('var, 'value, 'n1, 'n2) Tag.id * ('var, 'value, 'n1, 'n2) t -> packed
128
129	let to_basic
130	{ branches = _
131	; max_proofs_verified
132	; proofs_verifieds = _
133	; public_input
134	; wrap_vk
135	; wrap_domains
136	; step_domains
137	; wrap_key
138	; feature_flags
139	; num_chunks
140	; zk_rows
141	} =
UNCOV 142	let%bind.Promise wrap_key = Lazy.force wrap_key in	×
UNCOV 143	let%map.Promise wrap_vk = Lazy.force wrap_vk in	×
UNCOV 144	{ Basic.max_proofs_verified	×
145	; wrap_domains
146	; public_input
UNCOV 147	; branches = Vector.length step_domains	×
148	; wrap_key
149	; wrap_vk
150	; feature_flags
151	; num_chunks
152	; zk_rows
153	}
154	end
155
156	module For_step = struct
157	type ('a_var, 'a_value, 'max_proofs_verified, 'branches) t =
158	{ branches : 'branches Nat.t
159	; max_proofs_verified :
160	(module Nat.Add.Intf with type n = 'max_proofs_verified)
161	; proofs_verifieds :
162	[ `Known of (Impls.Step.Field.t, 'branches) Vector.t \| `Side_loaded ]
163	; public_input : ('a_var, 'a_value) Impls.Step.Typ.t
164	; wrap_key : inner_curve_var array Plonk_verification_key_evals.t
165	; wrap_domain :
166	[ `Known of Domain.t
167	\| `Side_loaded of
168	Impls.Step.field Pickles_base.Proofs_verified.One_hot.Checked.t ]
169	; step_domains : [ `Known of (Domains.t, 'branches) Vector.t \| `Side_loaded ]
170	; feature_flags : Opt.Flag.t Plonk_types.Features.Full.t
171	; num_chunks : int
172	; zk_rows : int
173	}
174
175	let of_side_loaded (type a b c d)
176	({ ephemeral
177	; permanent =
178	{ branches
179	; max_proofs_verified
180	; public_input
181	; feature_flags
182	; num_chunks
183	; zk_rows
184	}
185	} :
186	(a, b, c, d) Side_loaded.t ) : (a, b, c, d) t =
187	let index =	20✔
188	match ephemeral with
UNCOV 189	\| Some { index = `In_circuit i \| `In_both (_, i) } ->	×
190	i
191	\| _ ->	×
192	failwithf "For_step.side_loaded: Expected `In_circuit (%s)" __LOC__ ()	×
193	in
194	let T = Nat.eq_exn branches Side_loaded_verification_key.Max_branches.n in
195	let wrap_key =	20✔
196	Plonk_verification_key_evals.map index.wrap_index ~f:(fun x -> [\| x \|])	560✔
197	in
198	{ branches	20✔
199	; max_proofs_verified
200	; public_input
201	; proofs_verifieds = `Side_loaded
202	; wrap_key
203	; wrap_domain = `Side_loaded index.actual_wrap_domain_size
204	; step_domains = `Side_loaded
205	; feature_flags
206	; num_chunks
207	; zk_rows
208	}
209
210	module Optional_wrap_key = struct
211	type 'branches known =
212	{ wrap_key :
213	Tick.Inner_curve.Affine.t array Plonk_verification_key_evals.t
214	; step_domains : (Domains.t, 'branches) Vector.t
215	}
216
217	type 'branches t = 'branches known option
218	end
219
220	let of_compiled_with_known_wrap_key
221	({ wrap_key; step_domains } : _ Optional_wrap_key.known)
222	({ branches
223	; max_proofs_verified
224	; proofs_verifieds
225	; public_input
226	; wrap_key = _
227	; wrap_domains
228	; step_domains = _
229	; feature_flags
230	; wrap_vk = _
231	; num_chunks
232	; zk_rows
233	} :
234	_ Compiled.t ) =
235	{ branches	20✔
236	; max_proofs_verified
237	; proofs_verifieds =
238	`Known (Vector.map proofs_verifieds ~f:Impls.Step.Field.of_int)	20✔
239	; public_input
240	; wrap_key =
241	Plonk_verification_key_evals.map wrap_key	20✔
242	~f:(Array.map ~f:Step_main_inputs.Inner_curve.constant)
243	; wrap_domain = `Known wrap_domains.h
244	; step_domains = `Known step_domains
245	; feature_flags
246	; num_chunks
247	; zk_rows
248	}
249
250	let of_compiled ({ wrap_key; step_domains; _ } as t : _ Compiled.t) =
251	let%map.Promise wrap_key = Lazy.force wrap_key	×
252	and step_domains =
253	let%map.Promise () =
254	(* Wait for promises to resolve. *)
255	Vector.fold ~init:(Promise.return ()) step_domains	×
256	~f:(fun acc step_domain ->
257	let%bind.Promise _ = step_domain in
258	acc )	×
259	in
260	Vector.map ~f:(fun x -> Option.value_exn @@ Promise.peek x) step_domains	×
261	in
262	of_compiled_with_known_wrap_key { wrap_key; step_domains } t	×
263	end
264
265	type t =
266	{ compiled : Compiled.packed Type_equal.Id.Uid.Table.t
267	; side_loaded : Side_loaded.packed Type_equal.Id.Uid.Table.t
268	}
269
270	let univ : t =
271	{ compiled = Type_equal.Id.Uid.Table.create ()	22✔
272	; side_loaded = Type_equal.Id.Uid.Table.create ()	22✔
273	}
274
275	let find t k =
276	match Hashtbl.find t k with None -> failwith "key not found" \| Some x -> x	×
277
278	let lookup_compiled :
279	type var value n m.
280	(var, value, n, m) Tag.id -> (var, value, n, m) Compiled.t =
281	fun t ->
282	let (T (other_id, d)) = find univ.compiled (Type_equal.Id.uid t) in	90✔
283	let T = Type_equal.Id.same_witness_exn t other_id in	90✔
284	d	90✔
285
286	let lookup_side_loaded :
287	type var value n m.
288	(var, value, n, m) Tag.id -> (var, value, n, m) Side_loaded.t =
289	fun t ->
290	let (T (other_id, d)) = find univ.side_loaded (Type_equal.Id.uid t) in	80✔
291	let T = Type_equal.Id.same_witness_exn t other_id in	80✔
292	d	80✔
293
294	let lookup_basic :
295	type var value n m.
296	(var, value, n, m) Tag.t -> (var, value, n, m) Basic.t Promise.t =
297	fun t ->
UNCOV 298	match t.kind with	×
UNCOV 299	\| Compiled ->	×
UNCOV 300	Compiled.to_basic (lookup_compiled t.id)	×
UNCOV 301	\| Side_loaded ->	×
UNCOV 302	Promise.return @@ Side_loaded.to_basic (lookup_side_loaded t.id)	×
303
304	let max_proofs_verified :
305	type n1. (_, _, n1, _) Tag.t -> (module Nat.Add.Intf with type n = n1) =
306	fun tag ->
307	match tag.kind with	20✔
308	\| Compiled ->	10✔
309	(lookup_compiled tag.id).max_proofs_verified	10✔
310	\| Side_loaded ->	10✔
311	(lookup_side_loaded tag.id).permanent.max_proofs_verified	10✔
312
313	let public_input :
314	type var value. (var, value, _, _) Tag.t -> (var, value) Impls.Step.Typ.t =
315	fun tag ->
UNCOV 316	match tag.kind with	×
UNCOV 317	\| Compiled ->	×
UNCOV 318	(lookup_compiled tag.id).public_input	×
UNCOV 319	\| Side_loaded ->	×
UNCOV 320	(lookup_side_loaded tag.id).permanent.public_input	×
321
322	let feature_flags :
323	type var value.
324	(var, value, _, _) Tag.t -> Opt.Flag.t Plonk_types.Features.Full.t =
325	fun tag ->
326	match tag.kind with	40✔
327	\| Compiled ->	20✔
328	(lookup_compiled tag.id).feature_flags	20✔
329	\| Side_loaded ->	20✔
330	(lookup_side_loaded tag.id).permanent.feature_flags	20✔
331
332	let num_chunks : type var value. (var, value, _, _) Tag.t -> int =
333	fun tag ->
334	match tag.kind with	40✔
335	\| Compiled ->	20✔
336	(lookup_compiled tag.id).num_chunks	20✔
337	\| Side_loaded ->	20✔
338	(lookup_side_loaded tag.id).permanent.num_chunks	20✔
339
340	let _value_to_field_elements :
341	type a. (_, a, _, _) Tag.t -> a -> Backend.Tick.Field.t array =
342	fun t ->
343	let (Typ typ) = public_input t in	×
344	fun x -> fst (typ.value_to_fields x)	×
345
346	let _lookup_map (type var value c d) (t : (var, value, c, d) Tag.t) ~self
347	~default
348	~(f :
349	[ `Compiled of (var, value, c, d) Compiled.t
350	\| `Side_loaded of (var, value, c, d) Side_loaded.t ]
351	-> _ ) =
352	match Type_equal.Id.same_witness t.id self with	×
353	\| Some _ ->	×
354	default
355	\| None -> (	×
356	match t.kind with
357	\| Compiled ->	×
358	let (T (other_id, d)) = find univ.compiled (Type_equal.Id.uid t.id) in	×
359	let T = Type_equal.Id.same_witness_exn t.id other_id in	×
360	f (`Compiled d)	×
361	\| Side_loaded ->	×
362	let (T (other_id, d)) =
363	find univ.side_loaded (Type_equal.Id.uid t.id)	×
364	in
365	let T = Type_equal.Id.same_witness_exn t.id other_id in	×
366	f (`Side_loaded d) )	×
367
368	let add_side_loaded ~name permanent =
369	let (Tag.{ id; _ } as tag) = Tag.(create ~kind:Side_loaded name) in	5✔
370	Hashtbl.add_exn univ.side_loaded ~key:(Type_equal.Id.uid id)	5✔
371	~data:(T (id, { ephemeral = None; permanent })) ;
372	tag	5✔
373
374	let set_ephemeral { Tag.kind; id } (eph : Side_loaded.Ephemeral.t) =
375	assert (match kind with Side_loaded -> true \| Compiled -> false) ;	×
376	Hashtbl.update univ.side_loaded (Type_equal.Id.uid id) ~f:(function	20✔
377	\| None ->
378	assert false
379	\| Some (T (id, d)) ->	20✔
380	let ephemeral =
381	match (d.ephemeral, eph.index) with
UNCOV 382	\| None, _ \| Some _, `In_prover _ ->	×
383	(* Giving prover only always resets. *)
384	Some eph
UNCOV 385	\| Some { index = `In_prover prover }, `In_circuit circuit	×
386	\| Some { index = `In_both (prover, _) }, `In_circuit circuit ->	×
387	(* In-circuit extends prover if one was given. *)
388	Some { index = `In_both (prover, circuit) }
389	\| _ ->	15✔
390	(* Otherwise, just use the given value. *)
391	Some eph
392	in
393	T (id, { d with ephemeral }) )
394
395	let add_exn (type var value c d) (tag : (var, value, c, d) Tag.t)
396	(data : (var, value, c, d) Compiled.t) =
397	Hashtbl.add_exn univ.compiled ~key:(Type_equal.Id.uid tag.id)	20✔
398	~data:(Compiled.T (tag.id, data))	44✔

MinaProtocol / mina / 2903

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