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

30.0

/src/lib/mina_base/fee_transfer.ml

open Core_kernel
open Mina_base_import

(** See documentation of the {!Mina_wire_types} library *)
module Wire_types = Mina_wire_types.Mina_base.Fee_transfer

module Make_sig (A : Wire_types.Types.S) = struct
  module type S =
    Fee_transfer_intf.Full
      with type Single.Stable.V2.t = A.Single.V2.t
       and type Stable.V2.t = A.V2.t
end

module Make_str (A : Wire_types.Concrete) = struct
  module Single = struct
    [%%versioned
    module Stable = struct
      module V2 = struct
        type t = A.Single.V2.t =
          { receiver_pk : Public_key.Compressed.Stable.V1.t
          ; fee : Currency.Fee.Stable.V1.t
          ; fee_token : Token_id.Stable.V2.t
          }
        [@@deriving sexp, compare, equal, yojson, hash]

        let to_latest = Fn.id

        let description = "Fee transfer Single"

        let version_byte = Base58_check.Version_bytes.fee_transfer_single
      end
    end]

    include Comparable.Make (Stable.Latest)
    module Base58_check = Codable.Make_base58_check (Stable.Latest)

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

    let create ~receiver_pk ~fee ~fee_token = { receiver_pk; fee; fee_token }

    let receiver_pk { receiver_pk; _ } = receiver_pk

    let receiver { receiver_pk; fee_token; _ } =
      Account_id.create receiver_pk fee_token

    let fee { fee; _ } = fee

    let fee_token { fee_token; _ } = fee_token

    module Gen = struct
      let with_random_receivers ?(min_fee = 0) ~max_fee ~token keys :
          t Quickcheck.Generator.t =
        let open Quickcheck.Generator.Let_syntax in
        let%map receiver_pk =
          let open Signature_lib in
          Quickcheck_lib.of_array keys
          >>| fun keypair -> Public_key.compress keypair.Keypair.public_key
        and fee =
          Int.gen_incl min_fee max_fee >>| Currency.Fee.of_nanomina_int_exn
        and fee_token = token in
        { receiver_pk; fee; fee_token }
    end
  end

  [%%versioned
  module Stable = struct
    module V2 = struct
      type t = Single.Stable.V2.t One_or_two.Stable.V1.t
      [@@deriving sexp, compare, equal, yojson, hash]

      let to_latest = Fn.id
    end
  end]

  type single = Single.t =
    { receiver_pk : Public_key.Compressed.t
    ; fee : Currency.Fee.t
    ; fee_token : Token_id.t
    }
  [@@deriving sexp, compare, yojson, hash]

  let to_singles = Fn.id

  let of_singles = function
    | `One _ as t ->
        Or_error.return t
    | `Two (one, two) as t ->
        if Token_id.equal one.fee_token two.fee_token then Or_error.return t
        else
          (* Necessary invariant for the transaction snark: we should never have
             fee excesses in multiple tokens simultaneously.
          *)
          Or_error.errorf
            !"Cannot combine single fee transfers with incompatible tokens: \
              %{sexp: Token_id.t} <> %{sexp: Token_id.t}"
            one.fee_token two.fee_token

  let create one two =
    let singles =
      match two with None -> `One one | Some two -> `Two (one, two)
    in
    of_singles singles

  let create_single ~receiver_pk ~fee ~fee_token =
    `One (Single.create ~receiver_pk ~fee ~fee_token)

  include Comparable.Make (Stable.Latest)

  let fee_excess ft =
    ft
    |> One_or_two.map ~f:(fun { fee_token; fee; _ } ->
           (fee_token, Currency.Fee.Signed.(negate (of_unsigned fee))) )
    |> Fee_excess.of_one_or_two

  let receiver_pks t =
    One_or_two.to_list (One_or_two.map ~f:Single.receiver_pk t)

  let receivers t = One_or_two.to_list (One_or_two.map ~f:Single.receiver t)

  (* This must match [Transaction_union].
     TODO: enforce this.
  *)
  let fee_payer_pk ft =
    match ft with
    | `One ft ->
        Single.receiver_pk ft
    | `Two (_, ft) ->
        Single.receiver_pk ft

  let fee_token = Single.fee_token

  let fee_tokens = One_or_two.map ~f:Single.fee_token

  let map = One_or_two.map

  let fold = One_or_two.fold

  let to_list = One_or_two.to_list

  let to_numbered_list = One_or_two.to_numbered_list
end

include Wire_types.Make (Make_sig) (Make_str)

1	open Core_kernel	9✔
2	open Mina_base_import
3
4	(** See documentation of the {!Mina_wire_types} library *)
5	module Wire_types = Mina_wire_types.Mina_base.Fee_transfer
6
7	module Make_sig (A : Wire_types.Types.S) = struct
8	module type S =
9	Fee_transfer_intf.Full
10	with type Single.Stable.V2.t = A.Single.V2.t
11	and type Stable.V2.t = A.V2.t
12	end
13
14	module Make_str (A : Wire_types.Concrete) = struct
15	module Single = struct
16	[%%versioned
17	module Stable = struct
18	module V2 = struct
19	type t = A.Single.V2.t =	18✔
20	{ receiver_pk : Public_key.Compressed.Stable.V1.t	×
21	; fee : Currency.Fee.Stable.V1.t	×
22	; fee_token : Token_id.Stable.V2.t	×
23	}
24	[@@deriving sexp, compare, equal, yojson, hash]	45✔
25
26	let to_latest = Fn.id
27
28	let description = "Fee transfer Single"
29
30	let version_byte = Base58_check.Version_bytes.fee_transfer_single
31	end
32	end]
33
34	include Comparable.Make (Stable.Latest)
35	module Base58_check = Codable.Make_base58_check (Stable.Latest)
36
37	[%%define_locally
38	Base58_check.(to_base58_check, of_base58_check, of_base58_check_exn)]
39
40	let create ~receiver_pk ~fee ~fee_token = { receiver_pk; fee; fee_token }	×
41
42	let receiver_pk { receiver_pk; _ } = receiver_pk	110✔
43
44	let receiver { receiver_pk; fee_token; _ } =
45	Account_id.create receiver_pk fee_token	×
46
47	let fee { fee; _ } = fee	110✔
48
49	let fee_token { fee_token; _ } = fee_token	×
50
51	module Gen = struct
52	let with_random_receivers ?(min_fee = 0) ~max_fee ~token keys :	×
53	t Quickcheck.Generator.t =
54	let open Quickcheck.Generator.Let_syntax in	1✔
55	let%map receiver_pk =
56	let open Signature_lib in
57	Quickcheck_lib.of_array keys	1✔
58	>>\| fun keypair -> Public_key.compress keypair.Keypair.public_key	1✔
59	and fee =
60	Int.gen_incl min_fee max_fee >>\| Currency.Fee.of_nanomina_int_exn	1✔
61	and fee_token = token in
62	{ receiver_pk; fee; fee_token }	10,000✔
63	end
64	end
65
66	[%%versioned
67	module Stable = struct
68	module V2 = struct
69	type t = Single.Stable.V2.t One_or_two.Stable.V1.t	×
70	[@@deriving sexp, compare, equal, yojson, hash]	45✔
71
72	let to_latest = Fn.id
73	end
74	end]
75
76	type single = Single.t =	×
77	{ receiver_pk : Public_key.Compressed.t	×
78	; fee : Currency.Fee.t	×
79	; fee_token : Token_id.t	×
80	}
81	[@@deriving sexp, compare, yojson, hash]
82
83	let to_singles = Fn.id
84
85	let of_singles = function
86	\| `One _ as t ->	×
87	Or_error.return t
88	\| `Two (one, two) as t ->	×
89	if Token_id.equal one.fee_token two.fee_token then Or_error.return t	×
90	else
91	(* Necessary invariant for the transaction snark: we should never have
92	fee excesses in multiple tokens simultaneously.
93	*)
94	Or_error.errorf	×
95	!"Cannot combine single fee transfers with incompatible tokens: \	×
96	%{sexp: Token_id.t} <> %{sexp: Token_id.t}"
97	one.fee_token two.fee_token
98
99	let create one two =
100	let singles =	×
101	match two with None -> `One one \| Some two -> `Two (one, two)	×
102	in
103	of_singles singles
104
105	let create_single ~receiver_pk ~fee ~fee_token =
106	`One (Single.create ~receiver_pk ~fee ~fee_token)	×
107
108	include Comparable.Make (Stable.Latest)
109
110	let fee_excess ft =
111	ft	×
112	\|> One_or_two.map ~f:(fun { fee_token; fee; _ } ->	×
113	(fee_token, Currency.Fee.Signed.(negate (of_unsigned fee))) )	×
114	\|> Fee_excess.of_one_or_two
115
116	let receiver_pks t =
117	One_or_two.to_list (One_or_two.map ~f:Single.receiver_pk t)	×
118
119	let receivers t = One_or_two.to_list (One_or_two.map ~f:Single.receiver t)	×
120
121	(* This must match [Transaction_union].
122	TODO: enforce this.
123	*)
124	let fee_payer_pk ft =
125	match ft with	×
126	\| `One ft ->	×
127	Single.receiver_pk ft
128	\| `Two (_, ft) ->	×
129	Single.receiver_pk ft
130
131	let fee_token = Single.fee_token
132
133	let fee_tokens = One_or_two.map ~f:Single.fee_token
134
135	let map = One_or_two.map
136
137	let fold = One_or_two.fold
138
139	let to_list = One_or_two.to_list
140
141	let to_numbered_list = One_or_two.to_numbered_list
142	end
143
144	include Wire_types.Make (Make_sig) (Make_str)	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