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

4.17

/src/lib/zkapp_command_builder/zkapp_command_builder.ml

(* zkapp_command_builder.ml -- combinators to build Zkapp_command.t for tests *)

open Core_kernel
open Mina_base

let mk_forest ps :
    (Account_update.Body.Simple.t, unit, unit) Zkapp_command.Call_forest.t =
  List.map ps ~f:(fun p -> { With_stack_hash.elt = p; stack_hash = () })

let mk_node account_update calls : _ Zkapp_command.Call_forest.Tree.t =
  { account_update; account_update_digest = (); calls = mk_forest calls }

let mk_account_update_body ?preconditions ?(increment_nonce = false)
    ?(update = Account_update.Update.noop) authorization_kind may_use_token kp
    token_id balance_change : Account_update.Body.Simple.t =
  let open Signature_lib in
  let preconditions =
    Option.value preconditions
      ~default:
        Account_update.Preconditions.
          { network = Zkapp_precondition.Protocol_state.accept
          ; account = Zkapp_precondition.Account.accept
          ; valid_while = Ignore
          }
  in
  { update
  ; public_key = Public_key.compress kp.Keypair.public_key
  ; token_id
  ; balance_change =
      Currency.Amount.Signed.create
        ~magnitude:
          (Currency.Amount.of_nanomina_int_exn (Int.abs balance_change))
        ~sgn:(if Int.is_negative balance_change then Sgn.Neg else Pos)
  ; increment_nonce
  ; events = []
  ; actions = []
  ; call_data = Pickles.Impls.Step.Field.Constant.zero
  ; call_depth = 0
  ; preconditions
  ; use_full_commitment = true
  ; implicit_account_creation_fee = false
  ; may_use_token
  ; authorization_kind
  }

let mk_zkapp_command ?memo ~fee ~fee_payer_pk ~fee_payer_nonce account_updates :
    Zkapp_command.t =
  let fee_payer : Account_update.Fee_payer.t =
    { body =
        { public_key = fee_payer_pk
        ; fee = Currency.Fee.of_nanomina_int_exn fee
        ; valid_until = None
        ; nonce = fee_payer_nonce
        }
    ; authorization = Signature.dummy
    }
  in
  let memo =
    Option.value_map memo ~default:Signed_command_memo.dummy
      ~f:Signed_command_memo.create_from_string_exn
  in
  { fee_payer
  ; memo
  ; account_updates =
      account_updates
      |> Zkapp_command.Call_forest.map
           ~f:(fun (p : Account_update.Body.Simple.t) : Account_update.t ->
             let authorization =
               match p.authorization_kind with
               | None_given ->
                   Control.None_given
               | Proof _ ->
                   Control.Proof (Lazy.force Mina_base.Proof.blockchain_dummy)
               | Signature ->
                   Control.Signature Signature.dummy
             in
             { body = Account_update.Body.of_simple p; authorization } )
      |> Zkapp_command.Call_forest.accumulate_hashes_predicated
  }

(* replace dummy signatures, proofs with valid ones for fee payer, other zkapp_command
   [keymap] maps compressed public keys to private keys
*)
let replace_authorizations ?prover ~keymap (zkapp_command : Zkapp_command.t) :
    Zkapp_command.t Async_kernel.Deferred.t =
  let txn_commitment, full_txn_commitment =
    Zkapp_command.get_transaction_commitments zkapp_command
  in
  let sign_for_account_update ~use_full_commitment sk =
    let commitment =
      if use_full_commitment then full_txn_commitment else txn_commitment
    in
    Signature_lib.Schnorr.Chunked.sign sk
      (Random_oracle.Input.Chunked.field commitment)
  in
  let fee_payer_sk =
    Signature_lib.Public_key.Compressed.Map.find_exn keymap
      zkapp_command.fee_payer.body.public_key
  in
  let fee_payer_signature =
    sign_for_account_update ~use_full_commitment:true fee_payer_sk
  in
  let fee_payer_with_valid_signature =
    { zkapp_command.fee_payer with authorization = fee_payer_signature }
  in
  let open Async_kernel.Deferred.Let_syntax in
  let%map account_updates_with_valid_authorizations =
    Zkapp_command.Call_forest.deferred_mapi zkapp_command.account_updates
      ~f:(fun _ndx ({ body; authorization } : Account_update.t) tree ->
        let%map valid_authorization =
          match authorization with
          | Control.Signature _dummy ->
              let pk = body.public_key in
              let sk =
                match
                  Signature_lib.Public_key.Compressed.Map.find keymap pk
                with
                | Some sk ->
                    sk
                | None ->
                    failwithf
                      "Could not find private key for public key %s in keymap"
                      (Signature_lib.Public_key.Compressed.to_base58_check pk)
                      ()
              in
              let use_full_commitment = body.use_full_commitment in
              let signature = sign_for_account_update ~use_full_commitment sk in
              return (Control.Signature signature)
          | Proof _proof -> (
              match prover with
              | None ->
                  return authorization
              | Some prover ->
                  let txn_stmt = Zkapp_statement.of_tree tree in
                  let handler
                      (Snarky_backendless.Request.With { request; respond }) =
                    match request with _ -> respond Unhandled
                  in
                  let%map (), (), proof =
                    prover ?handler:(Some handler) txn_stmt
                  in
                  Control.Proof proof )
          | None_given ->
              return authorization
        in
        { Account_update.body; authorization = valid_authorization } )
  in
  { zkapp_command with
    fee_payer = fee_payer_with_valid_signature
  ; account_updates = account_updates_with_valid_authorizations
  }

1	(* zkapp_command_builder.ml -- combinators to build Zkapp_command.t for tests *)
2		7✔
3	open Core_kernel
4	open Mina_base
5
6	let mk_forest ps :
7	(Account_update.Body.Simple.t, unit, unit) Zkapp_command.Call_forest.t =
8	List.map ps ~f:(fun p -> { With_stack_hash.elt = p; stack_hash = () })	×
9
10	let mk_node account_update calls : _ Zkapp_command.Call_forest.Tree.t =
11	{ account_update; account_update_digest = (); calls = mk_forest calls }	×
12
13	let mk_account_update_body ?preconditions ?(increment_nonce = false)	×
14	?(update = Account_update.Update.noop) authorization_kind may_use_token kp	×
15	token_id balance_change : Account_update.Body.Simple.t =
16	let open Signature_lib in	×
17	let preconditions =
18	Option.value preconditions
19	~default:
20	Account_update.Preconditions.
21	{ network = Zkapp_precondition.Protocol_state.accept
22	; account = Zkapp_precondition.Account.accept
23	; valid_while = Ignore
24	}
25	in
26	{ update	×
27	; public_key = Public_key.compress kp.Keypair.public_key	×
28	; token_id
29	; balance_change =
30	Currency.Amount.Signed.create
31	~magnitude:
32	(Currency.Amount.of_nanomina_int_exn (Int.abs balance_change))	×
33	~sgn:(if Int.is_negative balance_change then Sgn.Neg else Pos)	×
34	; increment_nonce
35	; events = []
36	; actions = []
37	; call_data = Pickles.Impls.Step.Field.Constant.zero
38	; call_depth = 0
39	; preconditions
40	; use_full_commitment = true
41	; implicit_account_creation_fee = false
42	; may_use_token
43	; authorization_kind
44	}
45
46	let mk_zkapp_command ?memo ~fee ~fee_payer_pk ~fee_payer_nonce account_updates :
47	Zkapp_command.t =
48	let fee_payer : Account_update.Fee_payer.t =	×
49	{ body =
50	{ public_key = fee_payer_pk
51	; fee = Currency.Fee.of_nanomina_int_exn fee	×
52	; valid_until = None
53	; nonce = fee_payer_nonce
54	}
55	; authorization = Signature.dummy
56	}
57	in
58	let memo =
59	Option.value_map memo ~default:Signed_command_memo.dummy
60	~f:Signed_command_memo.create_from_string_exn
61	in
62	{ fee_payer	×
63	; memo
64	; account_updates =
65	account_updates
66	\|> Zkapp_command.Call_forest.map	×
67	~f:(fun (p : Account_update.Body.Simple.t) : Account_update.t ->
68	let authorization =	×
69	match p.authorization_kind with
70	\| None_given ->	×
71	Control.None_given
72	\| Proof _ ->	×
73	Control.Proof (Lazy.force Mina_base.Proof.blockchain_dummy)	×
74	\| Signature ->	×
75	Control.Signature Signature.dummy
76	in
77	{ body = Account_update.Body.of_simple p; authorization } )	×
78	\|> Zkapp_command.Call_forest.accumulate_hashes_predicated	×
79	}
80
81	(* replace dummy signatures, proofs with valid ones for fee payer, other zkapp_command
82	[keymap] maps compressed public keys to private keys
83	*)
84	let replace_authorizations ?prover ~keymap (zkapp_command : Zkapp_command.t) :
85	Zkapp_command.t Async_kernel.Deferred.t =
86	let txn_commitment, full_txn_commitment =	×
87	Zkapp_command.get_transaction_commitments zkapp_command
88	in
89	let sign_for_account_update ~use_full_commitment sk =	×
90	let commitment =	×
91	if use_full_commitment then full_txn_commitment else txn_commitment	×
92	in
93	Signature_lib.Schnorr.Chunked.sign sk
94	(Random_oracle.Input.Chunked.field commitment)	×
95	in
96	let fee_payer_sk =
97	Signature_lib.Public_key.Compressed.Map.find_exn keymap
98	zkapp_command.fee_payer.body.public_key
99	in
100	let fee_payer_signature =	×
101	sign_for_account_update ~use_full_commitment:true fee_payer_sk
102	in
103	let fee_payer_with_valid_signature =	×
104	{ zkapp_command.fee_payer with authorization = fee_payer_signature }
105	in
106	let open Async_kernel.Deferred.Let_syntax in
107	let%map account_updates_with_valid_authorizations =
108	Zkapp_command.Call_forest.deferred_mapi zkapp_command.account_updates	×
109	~f:(fun _ndx ({ body; authorization } : Account_update.t) tree ->
110	let%map valid_authorization =
111	match authorization with
112	\| Control.Signature _dummy ->	×
113	let pk = body.public_key in
114	let sk =
115	match
116	Signature_lib.Public_key.Compressed.Map.find keymap pk
117	with
118	\| Some sk ->	×
119	sk
120	\| None ->	×
121	failwithf	×
122	"Could not find private key for public key %s in keymap"
123	(Signature_lib.Public_key.Compressed.to_base58_check pk)	×
124	()
125	in
126	let use_full_commitment = body.use_full_commitment in
127	let signature = sign_for_account_update ~use_full_commitment sk in
128	return (Control.Signature signature)	×
129	\| Proof _proof -> (	×
130	match prover with
131	\| None ->	×
132	return authorization	×
133	\| Some prover ->	×
134	let txn_stmt = Zkapp_statement.of_tree tree in
135	let handler	×
136	(Snarky_backendless.Request.With { request; respond }) =
137	match request with _ -> respond Unhandled	×
138	in
139	let%map (), (), proof =
140	prover ?handler:(Some handler) txn_stmt	×
141	in
142	Control.Proof proof )	×
143	\| None_given ->	×
144	return authorization	×
145	in
146	{ Account_update.body; authorization = valid_authorization } )	×
147	in
148	{ zkapp_command with	×
149	fee_payer = fee_payer_with_valid_signature
150	; account_updates = account_updates_with_valid_authorizations
151	}	14✔

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