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

42.86

/src/lib/mina_base/signed_command_payload.ml

(* user_command_payload.ml *)

open Core_kernel
open Snark_params.Tick
open Signature_lib
module Memo = Signed_command_memo
module Account_nonce = Mina_numbers.Account_nonce
module Global_slot_since_genesis = Mina_numbers.Global_slot_since_genesis
module Global_slot_legacy = Mina_numbers.Global_slot_legacy

(* This represents the random oracle input corresponding to the old form of the token
   ID, which was a 64-bit integer. The default token id was the number 1.

   The corresponding random oracle input is still needed for signing non-snapp
   transactions to maintain compatibility with the old transaction format.
*)
module Legacy_token_id = struct
  let default : (Field.t, bool) Random_oracle_input.Legacy.t =
    let one = true :: List.init 63 ~f:(fun _ -> false) in
    Random_oracle_input.Legacy.bitstring one

  let default_checked : (Field.Var.t, Boolean.var) Random_oracle_input.Legacy.t
      =
    { field_elements = Array.map default.field_elements ~f:Field.Var.constant
    ; bitstrings =
        Array.map default.bitstrings ~f:(List.map ~f:Boolean.var_of_value)
    }
end

module Common = struct
  module Poly = struct
    [%%versioned
    module Stable = struct
      module V2 = struct
        type ('fee, 'public_key, 'nonce, 'global_slot, 'memo) t =
              ( 'fee
              , 'public_key
              , 'nonce
              , 'global_slot
              , 'memo )
              Mina_wire_types.Mina_base.Signed_command_payload.Common.Poly.V2.t =
          { fee : 'fee
          ; fee_payer_pk : 'public_key
          ; nonce : 'nonce
          ; valid_until : 'global_slot
          ; memo : 'memo
          }
        [@@deriving compare, equal, sexp, hash, yojson, hlist]
      end

      module V1 = struct
        [@@@with_all_version_tags]

        type ('fee, 'public_key, 'token_id, 'nonce, 'global_slot, 'memo) t =
          { fee : 'fee
          ; fee_token : 'token_id
          ; fee_payer_pk : 'public_key
          ; nonce : 'nonce
          ; valid_until : 'global_slot
          ; memo : 'memo
          }
        [@@deriving compare, equal, sexp, hash, yojson, hlist]
      end
    end]
  end

  [%%versioned
  module Stable = struct
    module V2 = struct
      type t =
        ( Currency.Fee.Stable.V1.t
        , Public_key.Compressed.Stable.V1.t
        , Account_nonce.Stable.V1.t
        , Global_slot_since_genesis.Stable.V1.t
        , Memo.Stable.V1.t )
        Poly.Stable.V2.t
      [@@deriving compare, equal, sexp, hash, yojson]

      let to_latest = Fn.id
    end

    module V1 = struct
      [@@@with_all_version_tags]

      type t =
        ( Currency.Fee.Stable.V1.t
        , Public_key.Compressed.Stable.V1.t
        , Token_id.Stable.V1.t
        , Account_nonce.Stable.V1.t
        , Global_slot_legacy.Stable.V1.t
        , Memo.Stable.V1.t )
        Poly.Stable.V1.t
      [@@deriving compare, equal, sexp, hash, yojson]

      let to_latest _ = failwith "Not implemented"
    end
  end]

  let to_input_legacy ({ fee; fee_payer_pk; nonce; valid_until; memo } : t) =
    let bitstring = Random_oracle.Input.Legacy.bitstring in
    Array.reduce_exn ~f:Random_oracle.Input.Legacy.append
      [| Currency.Fee.to_input_legacy fee
       ; Legacy_token_id.default
       ; Public_key.Compressed.to_input_legacy fee_payer_pk
       ; Account_nonce.to_input_legacy nonce
       ; Global_slot_since_genesis.to_input_legacy valid_until
       ; bitstring (Memo.to_bits memo)
      |]

  let gen : t Quickcheck.Generator.t =
    let open Quickcheck.Generator.Let_syntax in
    let%map fee = Currency.Fee.gen
    and fee_payer_pk = Public_key.Compressed.gen
    and nonce = Account_nonce.gen
    and valid_until = Global_slot_since_genesis.gen
    and memo =
      let%bind is_digest = Bool.quickcheck_generator in
      if is_digest then
        String.gen_with_length Memo.max_digestible_string_length
          Char.quickcheck_generator
        >>| Memo.create_by_digesting_string_exn
      else
        String.gen_with_length Memo.max_input_length Char.quickcheck_generator
        >>| Memo.create_from_string_exn
    in
    Poly.{ fee; fee_payer_pk; nonce; valid_until; memo }

  type var =
    ( Currency.Fee.var
    , Public_key.Compressed.var
    , Account_nonce.Checked.t
    , Global_slot_since_genesis.Checked.t
    , Memo.Checked.t )
    Poly.t

  let typ =
    Typ.of_hlistable
      [ Currency.Fee.typ
      ; Public_key.Compressed.typ
      ; Account_nonce.typ
      ; Global_slot_since_genesis.typ
      ; Memo.typ
      ]
      ~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist
      ~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist

  module Checked = struct
    let constant ({ fee; fee_payer_pk; nonce; valid_until; memo } : t) : var =
      { fee = Currency.Fee.var_of_t fee
      ; fee_payer_pk = Public_key.Compressed.var_of_t fee_payer_pk
      ; nonce = Account_nonce.Checked.constant nonce
      ; memo = Memo.Checked.constant memo
      ; valid_until = Global_slot_since_genesis.Checked.constant valid_until
      }

    let to_input_legacy ({ fee; fee_payer_pk; nonce; valid_until; memo } : var)
        =
      let%map nonce = Account_nonce.Checked.to_input_legacy nonce
      and valid_until =
        Global_slot_since_genesis.Checked.to_input_legacy valid_until
      and fee = Currency.Fee.var_to_input_legacy fee in
      let fee_token = Legacy_token_id.default_checked in
      Array.reduce_exn ~f:Random_oracle.Input.Legacy.append
        [| fee
         ; fee_token
         ; Public_key.Compressed.Checked.to_input_legacy fee_payer_pk
         ; nonce
         ; valid_until
         ; Random_oracle.Input.Legacy.bitstring
             (Array.to_list (memo :> Boolean.var array))
        |]
  end
end

module Body = struct
  [%%versioned
  module Stable = struct
    module V2 = struct
      type t = Mina_wire_types.Mina_base.Signed_command_payload.Body.V2.t =
        | Payment of Payment_payload.Stable.V2.t
        | Stake_delegation of Stake_delegation.Stable.V2.t
      [@@deriving sexp, compare, equal, sexp, hash, yojson]

      let to_latest = Fn.id
    end

    module V1 = struct
      [@@@with_all_version_tags]

      type t =
        | Payment of Payment_payload.Stable.V1.t
        | Stake_delegation of Stake_delegation.Stable.V1.t
      (* omitting token commands, none were ever created
         such omission doesn't affect serialization/Base58Check of payments, delegations
      *)
      [@@deriving sexp, compare, equal, sexp, hash, yojson]

      let to_latest _ = failwith "Not implemented"
    end
  end]

  module Tag = Transaction_union_tag

  let gen max_amount =
    let open Quickcheck.Generator in
    map
      (variant2 (Payment_payload.gen max_amount) Stake_delegation.gen)
      ~f:(function `A p -> Payment p | `B d -> Stake_delegation d)

  let receiver_pk (t : t) =
    match t with
    | Payment payload ->
        payload.receiver_pk
    | Stake_delegation payload ->
        Stake_delegation.receiver_pk payload

  let token (_ : t) = Token_id.default

  let receiver t =
    match t with
    | Payment payload ->
        Account_id.create payload.receiver_pk Token_id.default
    | Stake_delegation payload ->
        Stake_delegation.receiver payload

  let tag = function
    | Payment _ ->
        Transaction_union_tag.Payment
    | Stake_delegation _ ->
        Transaction_union_tag.Stake_delegation
end

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

      type ('common, 'body) t =
            ( 'common
            , 'body )
            Mina_wire_types.Mina_base.Signed_command_payload.Poly.V1.t =
        { common : 'common; body : 'body }
      [@@deriving equal, sexp, hash, yojson, compare, hlist]

      let of_latest common_latest body_latest { common; body } =
        let open Result.Let_syntax in
        let%map common = common_latest common and body = body_latest body in
        { common; body }
    end
  end]
end

[%%versioned
module Stable = struct
  module V2 = struct
    type t = (Common.Stable.V2.t, Body.Stable.V2.t) Poly.Stable.V1.t
    [@@deriving compare, equal, sexp, hash, yojson]

    let to_latest = Fn.id
  end

  module V1 = struct
    [@@@with_all_version_tags]

    type t = (Common.Stable.V1.t, Body.Stable.V1.t) Poly.Stable.V1.t
    [@@deriving compare, equal, sexp, hash, yojson]

    (* don't need to coerce old transactions to newer version *)
    let to_latest _ = failwith "Not implemented"
  end
end]

let create ~fee ~fee_payer_pk ~nonce ~valid_until ~memo ~body : t =
  { common =
      { fee
      ; fee_payer_pk
      ; nonce
      ; valid_until =
          Option.value valid_until ~default:Global_slot_since_genesis.max_value
      ; memo
      }
  ; body
  }

let fee (t : t) = t.common.fee

let fee_token (_ : t) = Token_id.default

let fee_payer_pk (t : t) = t.common.fee_payer_pk

let fee_payer (t : t) = Account_id.create t.common.fee_payer_pk Token_id.default

let nonce (t : t) = t.common.nonce

let valid_until (t : t) = t.common.valid_until

let memo (t : t) = t.common.memo

let body (t : t) = t.body

let receiver_pk (t : t) = Body.receiver_pk t.body

let receiver (t : t) = Body.receiver t.body

let token (t : t) = Body.token t.body

let tag (t : t) = Body.tag t.body

let amount (t : t) =
  match t.body with
  | Payment payload ->
      Some payload.Payment_payload.Poly.amount
  | Stake_delegation _ ->
      None

let fee_excess (t : t) =
  Fee_excess.of_single (fee_token t, Currency.Fee.Signed.of_unsigned (fee t))

let account_access_statuses (t : t) (status : Transaction_status.t) =
  match status with
  | Applied ->
      List.map
        [ fee_payer t; receiver t ]
        ~f:(fun acct_id -> (acct_id, `Accessed))
  | Failed _ ->
      (fee_payer t, `Accessed)
      :: List.map [ receiver t ] ~f:(fun acct_id -> (acct_id, `Not_accessed))

let dummy : t =
  { common =
      { fee = Currency.Fee.zero
      ; fee_payer_pk = Public_key.Compressed.empty
      ; nonce = Account_nonce.zero
      ; valid_until = Global_slot_since_genesis.max_value
      ; memo = Memo.dummy
      }
  ; body = Payment Payment_payload.dummy
  }

let gen =
  let open Quickcheck.Generator.Let_syntax in
  let%bind common = Common.gen in
  let max_amount =
    Currency.Amount.(sub max_int (of_fee common.fee))
    |> Option.value_exn ?here:None ?error:None ?message:None
  in
  let%map body = Body.gen max_amount in
  Poly.{ common; body }

(** This module defines a weight for each payload component *)
module Weight = struct
  let payment (_payment_payload : Payment_payload.t) : int = 1

  let stake_delegation (_stake_delegation : Stake_delegation.t) : int = 1

  let of_body : Body.t -> int = function
    | Payment payment_payload ->
        payment payment_payload
    | Stake_delegation stake_delegation_payload ->
        stake_delegation stake_delegation_payload
end

let weight (signed_command_payload : t) : int =
  body signed_command_payload |> Weight.of_body

1	(* user_command_payload.ml *)
2		9✔
3	open Core_kernel
4	open Snark_params.Tick
5	open Signature_lib
6	module Memo = Signed_command_memo
7	module Account_nonce = Mina_numbers.Account_nonce
8	module Global_slot_since_genesis = Mina_numbers.Global_slot_since_genesis
9	module Global_slot_legacy = Mina_numbers.Global_slot_legacy
10
11	(* This represents the random oracle input corresponding to the old form of the token
12	ID, which was a 64-bit integer. The default token id was the number 1.
13
14	The corresponding random oracle input is still needed for signing non-snapp
15	transactions to maintain compatibility with the old transaction format.
16	*)
17	module Legacy_token_id = struct
18	let default : (Field.t, bool) Random_oracle_input.Legacy.t =
19	let one = true :: List.init 63 ~f:(fun _ -> false) in	9✔
20	Random_oracle_input.Legacy.bitstring one	9✔
21
22	let default_checked : (Field.Var.t, Boolean.var) Random_oracle_input.Legacy.t
23	=
24	{ field_elements = Array.map default.field_elements ~f:Field.Var.constant	9✔
25	; bitstrings =
26	Array.map default.bitstrings ~f:(List.map ~f:Boolean.var_of_value)	9✔
27	}
28	end
29
30	module Common = struct
31	module Poly = struct
32	[%%versioned
33	module Stable = struct
34	module V2 = struct
35	type ('fee, 'public_key, 'nonce, 'global_slot, 'memo) t =	17✔
36	( 'fee
37	, 'public_key
38	, 'nonce
39	, 'global_slot
40	, 'memo )
41	Mina_wire_types.Mina_base.Signed_command_payload.Common.Poly.V2.t =
42	{ fee : 'fee	×
43	; fee_payer_pk : 'public_key	×
44	; nonce : 'nonce	×
45	; valid_until : 'global_slot	×
46	; memo : 'memo	×
47	}
48	[@@deriving compare, equal, sexp, hash, yojson, hlist]	29✔
49	end
50
51	module V1 = struct
52	[@@@with_all_version_tags]
53
54	type ('fee, 'public_key, 'token_id, 'nonce, 'global_slot, 'memo) t =	36✔
55	{ fee : 'fee	×
56	; fee_token : 'token_id	×
57	; fee_payer_pk : 'public_key	×
58	; nonce : 'nonce	×
59	; valid_until : 'global_slot	×
60	; memo : 'memo	×
61	}
62	[@@deriving compare, equal, sexp, hash, yojson, hlist]	153✔
63	end
64	end]
65	end
66
67	[%%versioned
68	module Stable = struct	×
69	module V2 = struct
70	type t =	9✔
71	( Currency.Fee.Stable.V1.t	×
72	, Public_key.Compressed.Stable.V1.t	×
73	, Account_nonce.Stable.V1.t	×
74	, Global_slot_since_genesis.Stable.V1.t	×
75	, Memo.Stable.V1.t )	×
76	Poly.Stable.V2.t	×
77	[@@deriving compare, equal, sexp, hash, yojson]	45✔
78
79	let to_latest = Fn.id
80	end
81
82	module V1 = struct
83	[@@@with_all_version_tags]
84
85	type t =	18✔
86	( Currency.Fee.Stable.V1.t	×
87	, Public_key.Compressed.Stable.V1.t	×
88	, Token_id.Stable.V1.t	×
89	, Account_nonce.Stable.V1.t	×
90	, Global_slot_legacy.Stable.V1.t	×
91	, Memo.Stable.V1.t )	×
92	Poly.Stable.V1.t	×
93	[@@deriving compare, equal, sexp, hash, yojson]	135✔
94
95	let to_latest _ = failwith "Not implemented"	×
96	end
97	end]	×
98
99	let to_input_legacy ({ fee; fee_payer_pk; nonce; valid_until; memo } : t) =
100	let bitstring = Random_oracle.Input.Legacy.bitstring in	5,320✔
101	Array.reduce_exn ~f:Random_oracle.Input.Legacy.append
102	[\| Currency.Fee.to_input_legacy fee	5,320✔
103	; Legacy_token_id.default
104	; Public_key.Compressed.to_input_legacy fee_payer_pk	5,320✔
105	; Account_nonce.to_input_legacy nonce	5,320✔
106	; Global_slot_since_genesis.to_input_legacy valid_until	5,320✔
107	; bitstring (Memo.to_bits memo)	5,320✔
108	\|]
109
110	let gen : t Quickcheck.Generator.t =
111	let open Quickcheck.Generator.Let_syntax in
112	let%map fee = Currency.Fee.gen
113	and fee_payer_pk = Public_key.Compressed.gen
114	and nonce = Account_nonce.gen
115	and valid_until = Global_slot_since_genesis.gen
116	and memo =
117	let%bind is_digest = Bool.quickcheck_generator in
118	if is_digest then	×
119	String.gen_with_length Memo.max_digestible_string_length	×
120	Char.quickcheck_generator
121	>>\| Memo.create_by_digesting_string_exn
122	else
123	String.gen_with_length Memo.max_input_length Char.quickcheck_generator	×
124	>>\| Memo.create_from_string_exn
125	in
126	Poly.{ fee; fee_payer_pk; nonce; valid_until; memo }	×
127
128	type var =
129	( Currency.Fee.var
130	, Public_key.Compressed.var
131	, Account_nonce.Checked.t
132	, Global_slot_since_genesis.Checked.t
133	, Memo.Checked.t )
134	Poly.t
135
136	let typ =
137	Typ.of_hlistable	9✔
138	[ Currency.Fee.typ
139	; Public_key.Compressed.typ
140	; Account_nonce.typ
141	; Global_slot_since_genesis.typ
142	; Memo.typ
143	]
144	~var_to_hlist:Poly.to_hlist ~var_of_hlist:Poly.of_hlist
145	~value_to_hlist:Poly.to_hlist ~value_of_hlist:Poly.of_hlist
146
147	module Checked = struct
148	let constant ({ fee; fee_payer_pk; nonce; valid_until; memo } : t) : var =
149	{ fee = Currency.Fee.var_of_t fee	×
150	; fee_payer_pk = Public_key.Compressed.var_of_t fee_payer_pk	×
151	; nonce = Account_nonce.Checked.constant nonce	×
152	; memo = Memo.Checked.constant memo	×
153	; valid_until = Global_slot_since_genesis.Checked.constant valid_until	×
154	}
155
156	let to_input_legacy ({ fee; fee_payer_pk; nonce; valid_until; memo } : var)
157	=
158	let%map nonce = Account_nonce.Checked.to_input_legacy nonce	16✔
159	and valid_until =
160	Global_slot_since_genesis.Checked.to_input_legacy valid_until	16✔
161	and fee = Currency.Fee.var_to_input_legacy fee in	16✔
162	let fee_token = Legacy_token_id.default_checked in	16✔
163	Array.reduce_exn ~f:Random_oracle.Input.Legacy.append
164	[\| fee
165	; fee_token
166	; Public_key.Compressed.Checked.to_input_legacy fee_payer_pk	16✔
167	; nonce
168	; valid_until
169	; Random_oracle.Input.Legacy.bitstring	16✔
170	(Array.to_list (memo :> Boolean.var array))	16✔
171	\|]
172	end
173	end
174
175	module Body = struct
176	[%%versioned
177	module Stable = struct	×
178	module V2 = struct
179	type t = Mina_wire_types.Mina_base.Signed_command_payload.Body.V2.t =	18✔
180	\| Payment of Payment_payload.Stable.V2.t	×
181	\| Stake_delegation of Stake_delegation.Stable.V2.t	×
182	[@@deriving sexp, compare, equal, sexp, hash, yojson]	45✔
183
184	let to_latest = Fn.id
185	end
186
187	module V1 = struct
188	[@@@with_all_version_tags]
189
190	type t =	36✔
191	\| Payment of Payment_payload.Stable.V1.t	×
192	\| Stake_delegation of Stake_delegation.Stable.V1.t	×
193	(* omitting token commands, none were ever created
194	such omission doesn't affect serialization/Base58Check of payments, delegations
195	*)
196	[@@deriving sexp, compare, equal, sexp, hash, yojson]	135✔
197
198	let to_latest _ = failwith "Not implemented"	×
199	end
200	end]	×
201
202	module Tag = Transaction_union_tag
203
204	let gen max_amount =
205	let open Quickcheck.Generator in	×
206	map
207	(variant2 (Payment_payload.gen max_amount) Stake_delegation.gen)	×
208	~f:(function `A p -> Payment p \| `B d -> Stake_delegation d)	×
209
210	let receiver_pk (t : t) =
211	match t with	10,767✔
212	\| Payment payload ->	10,767✔
213	payload.receiver_pk
214	\| Stake_delegation payload ->	×
215	Stake_delegation.receiver_pk payload
216
217	let token (_ : t) = Token_id.default	×
218
219	let receiver t =
220	match t with	6,400✔
221	\| Payment payload ->	6,400✔
222	Account_id.create payload.receiver_pk Token_id.default
223	\| Stake_delegation payload ->	×
224	Stake_delegation.receiver payload
225
226	let tag = function
227	\| Payment _ ->	×
228	Transaction_union_tag.Payment
229	\| Stake_delegation _ ->	×
230	Transaction_union_tag.Stake_delegation
231	end
232
233	module Poly = struct
234	[%%versioned
235	module Stable = struct
236	module V1 = struct
237	[@@@with_all_version_tags]
238
239	type ('common, 'body) t =	63✔
240	( 'common
241	, 'body )
242	Mina_wire_types.Mina_base.Signed_command_payload.Poly.V1.t =
243	{ common : 'common; body : 'body }	×
244	[@@deriving equal, sexp, hash, yojson, compare, hlist]	137✔
245
246	let of_latest common_latest body_latest { common; body } =
247	let open Result.Let_syntax in	×
248	let%map common = common_latest common and body = body_latest body in	×
249	{ common; body }	×
250	end
251	end]
252	end
253
254	[%%versioned
255	module Stable = struct	×
256	module V2 = struct
257	type t = (Common.Stable.V2.t, Body.Stable.V2.t) Poly.Stable.V1.t	×
258	[@@deriving compare, equal, sexp, hash, yojson]	45✔
259
260	let to_latest = Fn.id
261	end
262
263	module V1 = struct
264	[@@@with_all_version_tags]
265
266	type t = (Common.Stable.V1.t, Body.Stable.V1.t) Poly.Stable.V1.t	×
267	[@@deriving compare, equal, sexp, hash, yojson]	135✔
268
269	(* don't need to coerce old transactions to newer version *)
270	let to_latest _ = failwith "Not implemented"	×
271	end
272	end]	×
273
274	let create ~fee ~fee_payer_pk ~nonce ~valid_until ~memo ~body : t =
275	{ common =	11,800✔
276	{ fee
277	; fee_payer_pk
278	; nonce
279	; valid_until =
280	Option.value valid_until ~default:Global_slot_since_genesis.max_value	11,800✔
281	; memo
282	}
283	; body
284	}
285
286	let fee (t : t) = t.common.fee	35,247✔
287
288	let fee_token (_ : t) = Token_id.default	1,920✔
289
290	let fee_payer_pk (t : t) = t.common.fee_payer_pk	10,767✔
291
292	let fee_payer (t : t) = Account_id.create t.common.fee_payer_pk Token_id.default	9,920✔
293
294	let nonce (t : t) = t.common.nonce	13,327✔
295
296	let valid_until (t : t) = t.common.valid_until	13,327✔
297
298	let memo (t : t) = t.common.memo	10,287✔
299
300	let body (t : t) = t.body	×
301
302	let receiver_pk (t : t) = Body.receiver_pk t.body	10,767✔
303
304	let receiver (t : t) = Body.receiver t.body	6,400✔
305
306	let token (t : t) = Body.token t.body	×
307
308	let tag (t : t) = Body.tag t.body	×
309
310	let amount (t : t) =
311	match t.body with	10,287✔
312	\| Payment payload ->	10,287✔
313	Some payload.Payment_payload.Poly.amount
314	\| Stake_delegation _ ->	×
315	None
316
317	let fee_excess (t : t) =
318	Fee_excess.of_single (fee_token t, Currency.Fee.Signed.of_unsigned (fee t))	1,920✔
319
320	let account_access_statuses (t : t) (status : Transaction_status.t) =
321	match status with	3,360✔
322	\| Applied ->	3,360✔
323	List.map
324	[ fee_payer t; receiver t ]	3,360✔
325	~f:(fun acct_id -> (acct_id, `Accessed))	6,720✔
326	\| Failed _ ->	×
327	(fee_payer t, `Accessed)	×
328	:: List.map [ receiver t ] ~f:(fun acct_id -> (acct_id, `Not_accessed))	×
329
330	let dummy : t =
331	{ common =
332	{ fee = Currency.Fee.zero
333	; fee_payer_pk = Public_key.Compressed.empty
334	; nonce = Account_nonce.zero
335	; valid_until = Global_slot_since_genesis.max_value
336	; memo = Memo.dummy
337	}
338	; body = Payment Payment_payload.dummy
339	}
340
341	let gen =
342	let open Quickcheck.Generator.Let_syntax in
343	let%bind common = Common.gen in
344	let max_amount =	×
345	Currency.Amount.(sub max_int (of_fee common.fee))	×
346	\|> Option.value_exn ?here:None ?error:None ?message:None
347	in
348	let%map body = Body.gen max_amount in	×
349	Poly.{ common; body }	×
350
351	(** This module defines a weight for each payload component *)
352	module Weight = struct
353	let payment (_payment_payload : Payment_payload.t) : int = 1	×
354
355	let stake_delegation (_stake_delegation : Stake_delegation.t) : int = 1	×
356
357	let of_body : Body.t -> int = function
358	\| Payment payment_payload ->	×
359	payment payment_payload
360	\| Stake_delegation stake_delegation_payload ->	×
361	stake_delegation stake_delegation_payload
362	end
363
364	let weight (signed_command_payload : t) : int =
365	body signed_command_payload \|> Weight.of_body	×

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