injective-testing 1.18.0

Testing utils for Injective Cosmwasm and core modules
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use injective_test_tube::{
    injective_std::{
        shim::{Any, Timestamp},
        types::cosmos::{
            authz::v1beta1::{GenericAuthorization, Grant, MsgGrant, MsgRevoke, MsgRevokeResponse},
            bank::v1beta1::SendAuthorization,
            base::v1beta1::Coin as BaseCoin,
        },
    },
    Account, Authz, ExecuteResponse, InjectiveTestApp, Module, Runner, SigningAccount,
};
use prost::Message;

pub fn create_generic_authorization(app: &InjectiveTestApp, granter: &SigningAccount, grantee: String, msg: String, expiration: Option<Timestamp>) {
    let authz = Authz::new(app);

    let mut buf = vec![];
    GenericAuthorization::encode(&GenericAuthorization { msg }, &mut buf).unwrap();

    authz
        .grant(
            MsgGrant {
                granter: granter.address(),
                grantee,
                grant: Some(Grant {
                    authorization: Some(Any {
                        type_url: GenericAuthorization::TYPE_URL.to_string(),
                        value: buf.clone(),
                    }),
                    expiration,
                }),
            },
            granter,
        )
        .unwrap();
}

pub fn revoke_authorization(app: &InjectiveTestApp, granter: &SigningAccount, grantee: String, msg_type_url: String) {
    let _res: ExecuteResponse<MsgRevokeResponse> = app
        .execute_multiple(
            &[(
                MsgRevoke {
                    granter: granter.address(),
                    grantee,
                    msg_type_url,
                },
                MsgRevoke::TYPE_URL,
            )],
            granter,
        )
        .unwrap();
}

pub fn create_send_authorization(app: &InjectiveTestApp, granter: &SigningAccount, grantee: String, amount: BaseCoin, expiration: Option<Timestamp>) {
    let authz = Authz::new(app);

    let mut buf = vec![];
    SendAuthorization::encode(
        &SendAuthorization {
            spend_limit: vec![amount],
            allow_list: vec![],
        },
        &mut buf,
    )
    .unwrap();

    authz
        .grant(
            MsgGrant {
                granter: granter.address(),
                grantee,
                grant: Some(Grant {
                    authorization: Some(Any {
                        type_url: SendAuthorization::TYPE_URL.to_string(),
                        value: buf.clone(),
                    }),
                    expiration,
                }),
            },
            granter,
        )
        .unwrap();
}

pub fn execute_generic_authorizations(app: &InjectiveTestApp, granter: &SigningAccount, grantee: String, msgs: Vec<String>) {
    for msg in msgs {
        create_generic_authorization(app, granter, grantee.clone(), msg, None);
    }
}