Grcov report - authz

1

use crate::{

2

    msg::ExecuteMsg,

3

    testing::test_utils::{

4

        create_contract_authorization, create_realistic_atom_usdt_sell_orders_from_spreadsheet,

5

        create_realistic_eth_usdt_buy_orders_from_spreadsheet, init_rich_account, init_self_relaying_contract_and_get_address,

6

        launch_realistic_atom_usdt_spot_market, launch_realistic_weth_usdt_spot_market, must_init_account_with_funds, str_coin, Decimals, ATOM, ETH,

7

        INJ, USDT,

8

},

9

};

10

11

use injective_std::{

12

    shim::Any,

13

    types::{cosmos::authz::v1beta1::MsgExec, cosmwasm::wasm::v1::MsgExecuteContract},

14

};

15

use injective_test_tube::{Account, Authz, Bank, Exchange, InjectiveTestApp, Module, Wasm};

16

use injective_testing::test_tube::{bank::send, exchange::add_denom_notional_and_decimal};

17

use prost::Message;

18

19

#[test]

20

2

pub fn set_route_for_third_party_test() {

21

2

    let app = InjectiveTestApp::new();

22

2

    let wasm = Wasm::new(&app);

23

2

    let authz = Authz::new(&app);

24

2

    let exchange = Exchange::new(&app);

25

2

26

2

    let owner = must_init_account_with_funds(

27

2

        &app,

28

2

&[

29

2

            str_coin("1", ETH, Decimals::Eighteen),

30

2

            str_coin("1", ATOM, Decimals::Six),

31

2

            str_coin("1_000", USDT, Decimals::Six),

32

2

            str_coin("10_000", INJ, Decimals::Eighteen),

33

2

],

34

2

);

35

2

36

2

    let validator = app.get_first_validator_signing_account(INJ.to_string(), 1.2f64).unwrap();

37

2

    send(&Bank::new(&app), "1000000000000000000000", "inj", &owner, &validator);

38

2

    add_denom_notional_and_decimal(&app, &validator, INJ.to_string(), "1".to_string(), 18);

39

2

    add_denom_notional_and_decimal(&app, &validator, ETH.to_string(), "1".to_string(), 18);

40

2

    add_denom_notional_and_decimal(&app, &validator, ATOM.to_string(), "1".to_string(), 6);

41

2

    add_denom_notional_and_decimal(&app, &validator, USDT.to_string(), "1".to_string(), 6);

42

2

43

2

    let spot_market_1_id = launch_realistic_weth_usdt_spot_market(&exchange, &owner);

44

2

    let spot_market_2_id = launch_realistic_atom_usdt_spot_market(&exchange, &owner);

45

2

46

2

    let contr_addr = init_self_relaying_contract_and_get_address(&wasm, &owner, &[str_coin("1_000", USDT, Decimals::Six)]);

47

2

48

2

    let trader1 = init_rich_account(&app);

49

2

    let trader2 = init_rich_account(&app);

50

2

    let trader3 = init_rich_account(&app);

51

2

52

2

    create_contract_authorization(

53

2

        &app,

54

2

        contr_addr.clone(),

55

2

        &owner,

56

2

        trader1.address().to_string(),

57

2

        "set_route".to_string(),

58

2

1,

59

2

        None,

60

2

);

61

2

62

2

    create_realistic_eth_usdt_buy_orders_from_spreadsheet(&app, &spot_market_1_id, &trader1, &trader2);

63

2

    create_realistic_atom_usdt_sell_orders_from_spreadsheet(&app, &spot_market_2_id, &trader1, &trader2, &trader3);

64

2

65

2

    app.increase_time(1);

66

2

67

2

    let set_route_msg = ExecuteMsg::SetRoute {

68

2

        source_denom: ETH.to_string(),

69

2

        target_denom: ATOM.to_string(),

70

2

        route: vec![spot_market_1_id.as_str().into(), spot_market_2_id.as_str().into()],

71

2

};

72

2

73

2

    let execute_msg = MsgExecuteContract {

74

2

        contract: contr_addr.clone(),

75

2

        sender: owner.address().to_string(),

76

2

        msg: serde_json_wasm::to_vec(&set_route_msg).unwrap(),

77

2

        funds: vec![],

78

2

};

79

2

80

2

    let msg = MsgExec {

81

2

        grantee: trader1.address().to_string(),

82

2

        msgs: vec![Any {

83

2

            type_url: "/cosmwasm.wasm.v1.MsgExecuteContract".to_string(),

84

2

            value: execute_msg.encode_to_vec(),

85

2

}],

86

2

};

87

2

88

2

    let _res = authz.exec(msg, &trader1).unwrap();

89

2

90

2

    // execute on more time to excercise account sequence

91

2

    let msg = MsgExec {

92

2

        grantee: trader1.address().to_string(),

93

2

        msgs: vec![Any {

94

2

            type_url: "/cosmwasm.wasm.v1.MsgExecuteContract".to_string(),

95

2

            value: execute_msg.encode_to_vec(),

96

2

}],

97

2

};

98

2

99

2

    let err = authz.exec(msg, &trader1).unwrap_err();

100

2

    assert!(err.to_string().contains("failed to get grant with given granter"));

101

2