Skip to main content

bolt_cw_sdk/oracle/
remove_asset_pairs.rs

1use crate::oracle::add_asset_pairs::AssetPair;
2use crate::oracle::client::OracleAdminClient;
3use crate::oracle::error::OracleError;
4use crate::tx_builder::TxBuilder;
5use cosmrs::cosmwasm::MsgExecuteContract;
6use cosmrs::tx::Msg;
7use serde::Serialize;
8
9impl OracleAdminClient {
10    pub fn append_remove_asset_pairs_msg(
11        &self,
12        tx_builder: &mut TxBuilder,
13        asset_pairs: Vec<AssetPair>,
14    ) -> Result<(), OracleError> {
15        let msg = ExecuteMsg {
16            remove_asset_pairs: RemoveAssetPairsMsg { asset_pairs },
17        };
18        let contract_msg = serde_json::to_vec(&msg).map_err(OracleError::SerdeJsonError)?;
19        let msg = MsgExecuteContract {
20            sender: tx_builder.account_id.clone(),
21            contract: self.chain_config.oracle_contract_address.clone(),
22            msg: contract_msg,
23            funds: vec![],
24        };
25        let msg = msg.to_any().map_err(OracleError::EyreError)?;
26        tx_builder.add_msg(msg);
27        Ok(())
28    }
29}
30
31#[derive(Serialize)]
32struct ExecuteMsg {
33    pub remove_asset_pairs: RemoveAssetPairsMsg,
34}
35
36#[derive(Serialize)]
37struct RemoveAssetPairsMsg {
38    pub asset_pairs: Vec<AssetPair>,
39}
40
41#[cfg(test)]
42mod tests {
43    use super::*;
44    use crate::oracle::add_asset_pairs::Asset;
45    use crate::test_utils::helpers::{
46        TEST_ASSET_ARCH_NAME, TEST_ASSET_ARCH_PRECISION, TEST_ASSET_ARCH_SYMBOL,
47        TEST_ASSET_USDT_NAME, TEST_ASSET_USDT_PRECISION, TEST_ASSET_USDT_SYMBOL,
48    };
49    use crate::test_utils::test_scenario::TestScenario;
50    use cosmrs::tendermint::abci::Code;
51    use cosmwasm_std::Decimal256;
52    use serial_test::serial;
53    use std::str::FromStr;
54
55    #[tokio::test]
56    #[serial]
57    async fn test_remove_asset_pairs() {
58        let test_scenario = TestScenario::new_from_config("config.json".to_string()).await;
59
60        let oracle_contract_address = test_scenario
61            .instantiate_oracle_contract(Decimal256::from_str("0.5").unwrap(), Some(1000))
62            .await;
63        let client = OracleAdminClient::from_scenario(&test_scenario, &oracle_contract_address)
64            .expect("Failed to create oracle admin client");
65        test_scenario.set_default_assets(&client).await;
66
67        let account = client
68            .public_oracle_client
69            .account(test_scenario.admin_address.clone())
70            .await
71            .expect("Failed to get account from public oracle client");
72        let mut tx_builder = TxBuilder::new(
73            test_scenario.admin_mnemonic.clone(),
74            test_scenario.chain_prefix.clone(),
75            test_scenario.chain_id.clone(),
76            test_scenario.derivation_path,
77            account.sequence,
78            account.account_number,
79        )
80        .expect("Failed to create TxBuilder");
81
82        let asset_pairs = vec![AssetPair {
83            base: Asset {
84                name: TEST_ASSET_ARCH_NAME.to_string(),
85                symbol: TEST_ASSET_ARCH_SYMBOL.to_string(),
86                precision: TEST_ASSET_ARCH_PRECISION,
87            },
88            quote: Asset {
89                name: TEST_ASSET_USDT_NAME.to_string(),
90                symbol: TEST_ASSET_USDT_SYMBOL.to_string(),
91                precision: TEST_ASSET_USDT_PRECISION,
92            },
93        }];
94
95        client
96            .append_remove_asset_pairs_msg(&mut tx_builder, asset_pairs)
97            .expect("Failed to append remove asset pairs message");
98
99        tx_builder.set_memo("From test_remove_asset_pairs".to_string());
100        let gas = 500_000u64;
101        tx_builder.set_fee(70_000_000_000_000_000u128, &test_scenario.chain_denom, gas);
102        let signed_bytes = tx_builder
103            .get_signed_bytes()
104            .expect("Failed to get signed bytes");
105        let response = client
106            .broadcast_tx(signed_bytes)
107            .await
108            .expect("Failed to broadcast tx");
109        match response.tx_result.code {
110            Code::Ok => {
111                println!("Transaction successful: {:?}", response.hash);
112            }
113            Code::Err(code) => {
114                panic!(
115                    "Transaction failed with code: {:?} response: {:?}",
116                    code, response
117                );
118            }
119        }
120    }
121}