ligo/vendors/ligo-utils/tezos-protocol-alpha/test/transfer.ml

(*****************************************************************************)
(*                                                                           *)
(* Open Source License                                                       *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com>     *)
(*                                                                           *)
(* Permission is hereby granted, free of charge, to any person obtaining a   *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense,  *)
(* and/or sell copies of the Software, and to permit persons to whom the     *)
(* Software is furnished to do so, subject to the following conditions:      *)
(*                                                                           *)
(* The above copyright notice and this permission notice shall be included   *)
(* in all copies or substantial portions of the Software.                    *)
(*                                                                           *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL   *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING   *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER       *)
(* DEALINGS IN THE SOFTWARE.                                                 *)
(*                                                                           *)
(*****************************************************************************)

open Protocol
open Alpha_context
open Test_utils
open Test_tez

(*********************************************************************)
(* Utility functions                                                 *)
(*********************************************************************)

(**
   [transfer_and_check_balances b fee src dst amount]
   this function takes a block, an optional parameter fee if fee does not
   given it will be set to zero tez, a source contract, a destination contract
   and the amount that one wants to transfer.

   1- Transfer the amount of tez (w/wo fee) from a source contract to a
       destination contract.

    2- Check the equivalent of the balance of the source/destination
       contract before and after transfer is valided.

   This function returns a pair:
   - A block that added a valid operation
   - a valid operation
*)
let transfer_and_check_balances ?(with_burn = false) ~loc b ?(fee=Tez.zero) ?expect_failure src dst amount =
  Tez.(+?) fee amount >>?= fun amount_fee ->
  Context.Contract.balance (I b) src >>=? fun bal_src ->
  Context.Contract.balance (I b) dst >>=? fun bal_dst ->
  Op.transaction (I b) ~fee src dst amount >>=? fun op ->
  Incremental.add_operation ?expect_failure b op >>=? fun b ->
  Context.get_constants (I b) >>=? fun { parametric = { origination_size ; cost_per_byte ; _ } ; _ } ->
  Tez.(cost_per_byte *? Int64.of_int origination_size) >>?= fun origination_burn ->
  let amount_fee_maybe_burn =
    if with_burn then
      match Tez.(amount_fee +? origination_burn) with
      | Ok r -> r
      | Error _ -> assert false
    else
      amount_fee in
  Assert.balance_was_debited  ~loc (I b) src bal_src amount_fee_maybe_burn >>=? fun () ->
  Assert.balance_was_credited ~loc (I b) dst bal_dst amount >>=? fun () ->
  return (b, op)

(**
   [transfer_to_itself_and_check_balances b fee contract amount]
   this function takes a block, an optional parameter fee,
   a contract that is a source and a destination contract,
   and an amount of tez that one wants to transfer.

   1- Transfer the amount of tez (w/wo transfer fee) from/to a contract itself.

   2- Check the equivalent of the balance of the contract before
       and after transfer.

   This function returns a pair:
   - a block that added the valid transaction
   - an valid transaction
*)
let transfer_to_itself_and_check_balances ~loc b ?(fee=Tez.zero) contract amount =
  Context.Contract.balance (I b) contract >>=? fun bal ->
  Op.transaction (I b) ~fee contract contract amount >>=? fun op ->
  Incremental.add_operation b op >>=? fun b ->
  Assert.balance_was_debited ~loc (I b) contract bal fee >>=? fun () ->
  return (b, op)

(**
   [n_transactions n b fee source dest amount]
   this function takes a number of "n" that one wish to transfer,
   a block, an optional parameter fee, a source contract,
   a destination contract and an amount one wants to transfer.

   This function will do a transaction from a source contract to
   a destination contract with the amount "n" times.
*)
let n_transactions n b ?fee source dest amount =
  fold_left_s (fun b _ ->
      transfer_and_check_balances ~loc:__LOC__ b ?fee source dest amount >>=? fun (b,_) ->
      return b)
    b (1 -- n)

let ten_tez = Tez.of_int 10

(*********************************************************************)
(* Tests                                                             *)
(*********************************************************************)

let register_two_contracts () =
  Context.init 2 >>=? fun (b, contracts) ->
  let contract_1 = List.nth contracts 0 in
  let contract_2 = List.nth contracts 1 in
  return (b, contract_1, contract_2)


(** compute half of the balance and divided by nth
    times *)

let two_nth_of_balance incr contract nth =
  Context.Contract.balance (I incr) contract >>=? fun balance ->
  Tez.(/?) balance nth >>?= fun res ->
  Tez.( *?) res 2L >>?= fun balance ->
  return balance

(********************)
(** Single transfer *)
(********************)

let single_transfer ?fee ?expect_failure amount =
  register_two_contracts () >>=? fun (b, contract_1, contract_2) ->
  Incremental.begin_construction b >>=? fun b ->
  transfer_and_check_balances ~loc:__LOC__ ?fee ?expect_failure
    b contract_1 contract_2 amount >>=? fun (b,_) ->
  Incremental.finalize_block b >>=? fun _ ->
  return_unit

(** single transfer without fee *)
let block_with_a_single_transfer () =
  single_transfer Tez.one

(** single transfer with fee *)
let block_with_a_single_transfer_with_fee () =
  single_transfer ~fee:Tez.one Tez.one

(** single transfer without fee *)

let transfer_zero_tez () =
  single_transfer ~expect_failure:(
    function
    | Environment.Ecoproto_error (Contract_storage.Empty_transaction _) :: _ ->
        return_unit
    | _ ->
        failwith "Empty transaction should fail")
    Tez.zero

(********************)
(** Transfer zero tez from an implicit contract *)
(********************)

let transfer_zero_implicit () =
  Context.init 1 >>=? fun (b, contracts) ->
  let dest = List.nth contracts 0 in
  let account = Account.new_account () in
  Incremental.begin_construction b >>=? fun i ->
  let src = Contract.implicit_contract account.Account.pkh in
  Op.transaction (I i) src dest Tez.zero >>=? fun op ->
  Incremental.add_operation i op >>= fun res ->
  Assert.proto_error ~loc:__LOC__ res begin function
    | Contract_storage.Empty_implicit_contract _ -> true
    | _ -> false
  end

(********************)
(** Transfer to originted contract *)
(********************)

let transfer_to_originate_with_fee () =
  Context.init 1 >>=? fun (b, contracts) ->
  let contract = List.nth contracts 0 in
  Incremental.begin_construction b >>=? fun b ->
  two_nth_of_balance b contract 10L >>=? fun fee ->
  (* originated contract, paying a fee to originated this contract *)
  Op.origination (I b) ~fee:ten_tez contract ~script:Op.dummy_script >>=? fun (operation, new_contract) ->
  Incremental.add_operation b operation >>=? fun b ->
  two_nth_of_balance b contract 3L >>=? fun amount ->
  transfer_and_check_balances ~loc:__LOC__ b ~fee:fee contract
    new_contract amount >>=? fun (b, _) ->
  Incremental.finalize_block b >>=? fun _ ->
  return_unit

(********************)
(** Transfer from balance *)
(********************)

let transfer_amount_of_contract_balance () =
  register_two_contracts () >>=? fun (b, contract_1, contract_2) ->
  Context.Contract.pkh contract_1 >>=? fun pkh1 ->
  (* given that contract_1 no longer has a sufficient balance to bake,
     make sure it cannot be chosen as baker *)
  Incremental.begin_construction b ~policy:(Block.Excluding [pkh1]) >>=? fun b ->
  (* get the balance of the source contract *)
  Context.Contract.balance (I b) contract_1 >>=? fun balance ->
  (* transfer all the tez inside contract 1 *)
  transfer_and_check_balances ~loc:__LOC__
    b contract_1 contract_2 balance >>=? fun (b,_) ->
  Incremental.finalize_block b >>=? fun _ ->
  return_unit

(********************)
(** Transfer to itself *)
(********************)

let transfers_to_self () =
  Context.init 1 >>=? fun (b, contracts) ->
  let contract = List.nth contracts 0 in
  Incremental.begin_construction b >>=? fun b ->
  two_nth_of_balance b contract 3L >>=? fun amount ->
  transfer_to_itself_and_check_balances ~loc:__LOC__ b contract amount
  >>=? fun (b, _) ->
  two_nth_of_balance b contract 5L >>=? fun fee ->
  transfer_to_itself_and_check_balances ~loc:__LOC__ b ~fee:fee contract ten_tez
  >>=? fun (b, _) ->
  Incremental.finalize_block b >>=? fun _ ->
  return_unit

(********************)
(** Forgot to add the valid transaction into the block *)
(********************)

let missing_transaction () =
  register_two_contracts () >>=? fun (b, contract_1, contract_2) ->
  (* given that contract_1 no longer has a sufficient balance to bake,
     make sure it cannot be chosen as baker *)
  Context.Contract.pkh contract_1 >>=? fun pkh1 ->
  Incremental.begin_construction b ~policy:(Block.Excluding [pkh1]) >>=? fun b ->
  two_nth_of_balance b contract_1 6L >>=? fun amount ->
  (* do the transfer 3 times from source contract to destination contract *)
  n_transactions 3 b contract_1 contract_2 amount >>=? fun b ->
  (* do the fourth transfer from source contract to destination contract *)
  Op.transaction (I b) contract_1 contract_2 amount >>=? fun _ ->
  Incremental.finalize_block b >>=? fun _ ->
  return_unit

(********************)
(** These following tests are for different kind of contracts:
    - implicit to implicit
    - implicit to originated
    - originated to implicit
    - originted to originted *)
(********************)

(** Implicit to Implicit *)

let transfer_from_implicit_to_implicit_contract () =
  Context.init 1 >>=? fun (b, contracts) ->
  let bootstrap_contract = List.nth contracts 0 in
  let account_a = Account.new_account () in
  let account_b = Account.new_account () in
  Incremental.begin_construction b >>=? fun b ->
  let src = Contract.implicit_contract account_a.Account.pkh in
  two_nth_of_balance b bootstrap_contract 3L >>=? fun amount1 ->
  two_nth_of_balance b bootstrap_contract 10L >>=? fun fee1 ->
  transfer_and_check_balances ~with_burn:true ~loc:__LOC__ ~fee:fee1 b
    bootstrap_contract src amount1 >>=? fun (b, _) ->
  (* create an implicit contract as a destination contract *)
  let dest = Contract.implicit_contract account_b.pkh in
  two_nth_of_balance b bootstrap_contract 4L >>=? fun amount2 ->
  two_nth_of_balance b bootstrap_contract 10L >>=? fun fee2 ->
  (* transfer from implicit contract to another implicit contract *)
  transfer_and_check_balances ~with_burn:true ~loc:__LOC__ ~fee:fee2 b
    src dest amount2 >>=? fun (b, _) ->
  Incremental.finalize_block b >>=? fun _ ->
  return_unit

(** Implicit to originated *)

let transfer_from_implicit_to_originated_contract () =
  Context.init 1 >>=? fun (b, contracts) ->
  let bootstrap_contract = List.nth contracts 0 in
  let contract = List.nth contracts 0 in
  let account = Account.new_account () in
  let src = Contract.implicit_contract account.Account.pkh in
  Incremental.begin_construction b >>=? fun b ->
  two_nth_of_balance b bootstrap_contract 3L >>=? fun amount1 ->
  (* transfer the money to implicit contract *)
  transfer_and_check_balances ~with_burn:true ~loc:__LOC__ b bootstrap_contract src amount1
  >>=? fun (b, _) ->
  (* originated contract *)
  Op.origination (I b) contract ~script:Op.dummy_script >>=? fun (operation, new_contract) ->
  Incremental.add_operation b operation >>=? fun b ->
  two_nth_of_balance b bootstrap_contract 4L >>=? fun amount2 ->
  (* transfer from implicit contract to originated contract *)
  transfer_and_check_balances ~loc:__LOC__ b src new_contract amount2
  >>=? fun (b, _) ->
  Incremental.finalize_block b >>=? fun _ ->
  return_unit

(********************)
(** Slow tests case *)
(********************)

let multiple_transfer n ?fee amount =
  register_two_contracts () >>=? fun (b, contract_1, contract_2) ->
  Incremental.begin_construction b >>=? fun b ->
  n_transactions n b ?fee contract_1 contract_2 amount >>=? fun b ->
  Incremental.finalize_block b >>=? fun _ ->
  return_unit

(** 1- Create a block with two contracts;
    2- Apply 100 transfers. *)
let block_with_multiple_transfers () =
  multiple_transfer 99 (Tez.of_int 1000)

(** 1- Create a block with two contracts;
    2- Apply 100 transfers with 10tz fee. *)
let block_with_multiple_transfers_pay_fee () =
  multiple_transfer 10 ~fee:ten_tez (Tez.of_int 1000)

(** 1- Create a block with 8 contracts;
    2- Apply multiple transfers without fees;
    3- Apply multiple transfers with fees. *)
(* TODO : increase the number of operations and add a `Slow tag to it in `tests` *)
let block_with_multiple_transfers_with_without_fee () =
  Context.init 8 >>=? fun (b, contracts) ->
  let contracts = Array.of_list contracts in
  Incremental.begin_construction b >>=? fun b ->
  let hundred = Tez.of_int 100 in
  let ten = Tez.of_int 10 in
  let twenty = Tez.of_int 20 in
  n_transactions 10 b contracts.(0) contracts.(1) Tez.one >>=? fun b ->
  n_transactions 30 b contracts.(1) contracts.(2) hundred >>=? fun b ->
  n_transactions 30 b contracts.(1) contracts.(3) hundred >>=? fun b ->
  n_transactions 30 b contracts.(4) contracts.(3) hundred >>=? fun b ->
  n_transactions 20 b contracts.(0) contracts.(1) hundred >>=? fun b ->
  n_transactions 10 b contracts.(1) contracts.(3) hundred >>=? fun b ->
  n_transactions 10 b contracts.(1) contracts.(3) hundred >>=? fun b ->

  n_transactions 20  ~fee:ten b contracts.(3) contracts.(4) ten >>=? fun b ->
  n_transactions 10  ~fee:twenty b contracts.(4) contracts.(5) ten >>=? fun b ->
  n_transactions 70  ~fee:twenty b contracts.(6) contracts.(0) twenty >>=? fun b ->
  n_transactions 550 ~fee:twenty b contracts.(6) contracts.(4) twenty >>=? fun b ->
  n_transactions 50  ~fee:ten b contracts.(7) contracts.(5) twenty >>=? fun b ->
  n_transactions 30  ~fee:ten b contracts.(0) contracts.(7) hundred >>=? fun b ->
  n_transactions 20  ~fee:ten b contracts.(1) contracts.(0) twenty >>=? fun b ->

  Incremental.finalize_block b >>=? fun _ ->
  return_unit

(********************)
(** Build a chain that has 10 blocks. *)
(********************)

let build_a_chain () =
  register_two_contracts () >>=? fun (b, contract_1, contract_2) ->
  let ten = Tez.of_int 10 in
  fold_left_s (fun b _ ->
      Incremental.begin_construction b >>=? fun b ->
      transfer_and_check_balances ~loc:__LOC__ b contract_1 contract_2 ten
      >>=? fun (b, _) ->
      Incremental.finalize_block b
    ) b (1 -- 10) >>=? fun _ ->
  return_unit

(*********************************************************************)
(* Expected error test cases                                         *)
(*********************************************************************)

(********************)
(** transfer zero tez is forbidden in implicit contract *)
(********************)

let empty_implicit () =
  Context.init 1 >>=? fun (b, contracts) ->
  let dest = List.nth contracts 0 in
  let account = Account.new_account () in
  Incremental.begin_construction b >>=? fun incr ->
  let src = Contract.implicit_contract account.Account.pkh in
  two_nth_of_balance incr dest 3L >>=? fun amount ->
  (* transfer zero tez from an implicit contract *)
  Op.transaction (I incr) src dest amount >>=? fun op ->
  Incremental.add_operation incr op >>= fun res ->
  Assert.proto_error ~loc:__LOC__ res begin function
    | Contract_storage.Empty_implicit_contract _ -> true
    | _ -> false
  end

(********************)
(** Balance is too low to transfer *)
(********************)

let balance_too_low fee () =
  register_two_contracts () >>=? fun (b, contract_1, contract_2) ->
  Incremental.begin_construction b >>=? fun i ->
  Context.Contract.balance (I i) contract_1 >>=? fun balance1 ->
  Context.Contract.balance (I i) contract_2 >>=? fun balance2 ->
  (* transfer the amount of tez that is bigger than the balance in the source contract *)
  Op.transaction ~fee (I i) contract_1 contract_2 Tez.max_tez >>=? fun op ->
  let expect_failure = function
    | Environment.Ecoproto_error (Contract_storage.Balance_too_low _) :: _ ->
        return_unit
    | _ ->
        failwith "balance too low should fail"
  in
  (* the fee is higher than the balance then raise an error "Balance_too_low" *)
  if fee > balance1 then begin
    Incremental.add_operation ~expect_failure i op >>= fun _res ->
    return_unit
  end
  (* the fee is smaller than the balance, then the transfer is accepted
     but it is not processed, and fees are taken *)
  else begin
    Incremental.add_operation ~expect_failure i op >>=? fun i ->
    (* contract_1 loses the fees *)
    Assert.balance_was_debited ~loc:__LOC__ (I i) contract_1 balance1 fee >>=? fun () ->
    (* contract_2 is not credited *)
    Assert.balance_was_credited ~loc:__LOC__ (I i) contract_2 balance2 Tez.zero
  end

(** 1- Create a block, and three contracts;
    2- Add a transfer that at the end the balance of a contract is
       zero into this block;
    3- Add another transfer that send tez from a zero balance contract;
    4- Catch the expected error: Balance_too_low. *)
let balance_too_low_two_transfers fee () =
  Context.init 3 >>=? fun (b, contracts) ->
  let contract_1 = List.nth contracts 0 in
  let contract_2 = List.nth contracts 1 in
  let contract_3 = List.nth contracts 2 in
  Incremental.begin_construction b >>=? fun i ->
  Context.Contract.balance (I i) contract_1 >>=? fun balance ->
  Tez.(/?) balance  3L >>?= fun res ->
  Tez.( *?) res 2L >>?= fun two_third_of_balance ->
  transfer_and_check_balances ~loc:__LOC__ i
    contract_1 contract_2 two_third_of_balance >>=? fun (i, _) ->
  Context.Contract.balance (I i) contract_1 >>=? fun balance1 ->
  Context.Contract.balance (I i) contract_3 >>=? fun balance3 ->
  Op.transaction ~fee (I i) contract_1 contract_3
    two_third_of_balance >>=? fun operation ->
  let expect_failure = function
    | Environment.Ecoproto_error (Contract_storage.Balance_too_low _) :: _ ->
        return_unit
    | _ ->
        failwith "balance too low should fail"
  in
  Incremental.add_operation ~expect_failure i operation >>=? fun i ->
  (* contract_1 loses the fees *)
  Assert.balance_was_debited ~loc:__LOC__ (I i) contract_1 balance1 fee >>=? fun () ->
  (* contract_3 is not credited *)
  Assert.balance_was_credited ~loc:__LOC__ (I i) contract_3 balance3 Tez.zero

(********************)
(** The counter is already used for the previous operation *)
(********************)

let invalid_counter () =
  register_two_contracts () >>=? fun (b, contract_1, contract_2) ->
  Incremental.begin_construction b >>=? fun b ->
  Op.transaction (I b) contract_1 contract_2
    Tez.one >>=? fun op1 ->
  Op.transaction (I b) contract_1 contract_2
    Tez.one >>=? fun op2 ->
  Incremental.add_operation b op1 >>=? fun b ->
  Incremental.add_operation b op2 >>= fun b ->
  Assert.proto_error ~loc:__LOC__ b begin function
    | Contract_storage.Counter_in_the_past _ -> true
    | _ -> false
  end

(* same as before but different way to perform this error *)

let add_the_same_operation_twice () =
  register_two_contracts () >>=? fun (b, contract_1, contract_2) ->
  Incremental.begin_construction b >>=? fun b ->
  transfer_and_check_balances ~loc:__LOC__ b contract_1 contract_2 ten_tez
  >>=? fun (b, op_transfer) ->
  Op.transaction (I b) contract_1 contract_2 ten_tez >>=? fun _ ->
  Incremental.add_operation b op_transfer >>= fun b ->
  Assert.proto_error ~loc:__LOC__ b begin function
    | Contract_storage.Counter_in_the_past _ -> true
    | _ -> false
  end

(********************)
(** check ownership *)
(********************)

let ownership_sender () =
  register_two_contracts () >>=? fun (b, contract_1, contract_2) ->
  Incremental.begin_construction b >>=? fun b ->
  (* get the manager of the contract_1 as a sender *)
  Context.Contract.manager (I b) contract_1 >>=? fun manager ->
  (* create an implicit_contract *)
  let imcontract_1 = Alpha_context.Contract.implicit_contract manager.pkh in
  transfer_and_check_balances ~loc:__LOC__ b imcontract_1 contract_2 Tez.one
  >>=? fun (b,_) ->
  Incremental.finalize_block b >>=? fun _ ->
  return_unit

(*********************************************************************)
(** Random transfer *)

(** Return a pair of minimum and maximum random number *)
let random_range (min, max) =
  let interv = max - min + 1 in
  let init =
    Random.self_init ();
    (Random.int interv) + min
  in init

(** Return a random contract *)
let random_contract contract_array =
  let i = Random.int (Array.length contract_array) in
  contract_array.(i)

(** Transfer by randomly choose amount 10 contracts, and randomly
    choose the amount in the source contract *)
let random_transfer () =
  Context.init 10 >>=? fun (b, contracts) ->
  let contracts = Array.of_list contracts in
  let source = random_contract contracts in
  let dest = random_contract contracts in
  Context.Contract.pkh source >>=? fun source_pkh ->
  (* given that source may not have a sufficient balance for the transfer + to bake,
     make sure it cannot be chosen as baker *)
  Incremental.begin_construction b ~policy:(Block.Excluding [source_pkh]) >>=? fun b ->
  Context.Contract.balance (I b) source >>=? fun amount ->
  begin
    if source = dest
    then
      transfer_to_itself_and_check_balances ~loc:__LOC__ b source amount
    else
      transfer_and_check_balances ~loc:__LOC__ b source dest amount
  end >>=? fun (b,_) ->
  Incremental.finalize_block b >>=? fun _ ->
  return_unit

(** Transfer random transactions *)
let random_multi_transactions () =
  let n = random_range (1, 100) in
  multiple_transfer n (Tez.of_int 100)

(*********************************************************************)

let tests = [
  (* single transfer *)
  Test.tztest "single transfer" `Quick block_with_a_single_transfer ;
  Test.tztest "single transfer with fee" `Quick block_with_a_single_transfer_with_fee ;

  (* transfer zero tez *)
  Test.tztest "single transfer zero tez" `Quick transfer_zero_tez ;
  Test.tztest "transfer zero tez from implicit contract" `Quick transfer_zero_implicit;

  (* transfer to originated contract *)
  Test.tztest "transfer to originated contract paying transaction fee" `Quick transfer_to_originate_with_fee ;

  (* transfer by the balance of contract *)
  Test.tztest "transfer the amount from source contract balance" `Quick transfer_amount_of_contract_balance ;

  (* transfer to itself *)
  Test.tztest "transfers to itself" `Quick transfers_to_self ;

  (* missing operation *)

  Test.tztest "missing transaction" `Quick missing_transaction ;

  (* transfer from/to implicit/originted contracts*)
  Test.tztest "transfer from an implicit to implicit contract " `Quick transfer_from_implicit_to_implicit_contract ;
  Test.tztest "transfer from an implicit to an originated contract" `Quick transfer_from_implicit_to_originated_contract ;

  (* Slow tests *)
  Test.tztest "block with multiple transfers" `Slow block_with_multiple_transfers ;
  (* TODO increase the number of transaction times *)
  Test.tztest "block with multiple transfer paying fee" `Slow block_with_multiple_transfers_pay_fee ;
  Test.tztest "block with multiple transfer without paying fee" `Slow block_with_multiple_transfers_with_without_fee ;

  (* build the chain *)
  Test.tztest "build a chain" `Quick build_a_chain ;

  (* Erroneous *)
  Test.tztest "empty implicit" `Quick empty_implicit;
  Test.tztest "balance too low - transfer zero" `Quick (balance_too_low Tez.zero);
  Test.tztest "balance too low" `Quick (balance_too_low Tez.one);
  Test.tztest "balance too low (max fee)" `Quick (balance_too_low Tez.max_tez);
  Test.tztest "balance too low with two transfers - transfer zero" `Quick (balance_too_low_two_transfers Tez.zero);
  Test.tztest "balance too low with two transfers" `Quick (balance_too_low_two_transfers Tez.one);
  Test.tztest "invalid_counter" `Quick invalid_counter ;
  Test.tztest "add the same operation twice" `Quick  add_the_same_operation_twice ;

  Test.tztest "ownership sender" `Quick  ownership_sender ;
  (* Random tests *)
  Test.tztest "random transfer" `Quick random_transfer ;
  Test.tztest "random multi transfer" `Quick  random_multi_transactions ;
]