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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use injective_test_tube::{
    injective_std::{
        shim::Any,
        types::{
            cosmos::{
                base::v1beta1::Coin as BaseCoin,
                gov::{v1::MsgVote, v1beta1::MsgSubmitProposal as MsgSubmitProposalV1Beta1},
            },
            injective::oracle::v1beta1::{
                GrantPriceFeederPrivilegeProposal, MsgRelayPriceFeedPrice, QueryOraclePriceRequest, QueryOraclePriceResponse,
            },
        },
    },
    Account, Gov, InjectiveTestApp, Module, Oracle, SigningAccount,
};
use prost::Message;
use std::str::FromStr;

pub fn launch_price_feed_oracle(
    app: &InjectiveTestApp,
    signer: &SigningAccount,
    validator: &SigningAccount,
    base: &str,
    quote: &str,
    dec_price: String,
) {
    let gov = Gov::new(app);
    let oracle = Oracle::new(app);

    let mut buf = vec![];
    GrantPriceFeederPrivilegeProposal::encode(
        &GrantPriceFeederPrivilegeProposal {
            title: "test-proposal".to_string(),
            description: "test-proposal".to_string(),
            base: base.to_string(),
            quote: quote.to_string(),
            relayers: vec![signer.address()],
        },
        &mut buf,
    )
    .unwrap();

    let res = gov
        .submit_proposal_v1beta1(
            MsgSubmitProposalV1Beta1 {
                content: Some(Any {
                    type_url: "/injective.oracle.v1beta1.GrantPriceFeederPrivilegeProposal".to_string(),
                    value: buf,
                }),
                initial_deposit: vec![BaseCoin {
                    amount: "100000000000000000000".to_string(),
                    denom: "inj".to_string(),
                }],
                proposer: validator.address(),
            },
            validator,
        )
        .unwrap();

    let proposal_id = res.events.iter().find(|e| e.ty == "submit_proposal").unwrap().attributes[0]
        .value
        .to_owned();

    gov.vote(
        MsgVote {
            proposal_id: u64::from_str(&proposal_id).unwrap(),
            voter: validator.address(),
            option: 1i32,
            metadata: "".to_string(),
        },
        validator,
    )
    .unwrap();

    // NOTE: increase the block time in order to move past the voting period
    app.increase_time(10u64);

    oracle
        .relay_price_feed(
            MsgRelayPriceFeedPrice {
                sender: signer.address(),
                base: vec![base.to_string()],
                quote: vec![quote.to_string()],
                price: vec![dec_price], // 1.2@18dp
            },
            signer,
        )
        .unwrap();
}

pub fn relay_price_feed_price(oracle: &Oracle<InjectiveTestApp>, relayer: &SigningAccount, base_denom: &str, quote_denom: &str, price: &str) {
    oracle
        .relay_price_feed(
            MsgRelayPriceFeedPrice {
                sender: relayer.address(),
                base: vec![base_denom.to_string()],
                quote: vec![quote_denom.to_string()],
                price: vec![price.to_string()],
            },
            relayer,
        )
        .unwrap();
}

pub fn query_oracle_mark_price(app: &InjectiveTestApp, base_denom: &str, quote_denom: &str) -> QueryOraclePriceResponse {
    let oracle = Oracle::new(app);

    oracle
        .query_oracle_price(&QueryOraclePriceRequest {
            oracle_type: 2,
            base: base_denom.to_string(),
            quote: quote_denom.to_string(),
            scaling_options: None,
        })
        .unwrap()
}