bolt-cw-sdk 1.0.0

use crate::oracle::add_asset_pairs::AssetPair;
use crate::oracle::client::OracleAdminClient;
use crate::oracle::error::OracleError;
use crate::tx_builder::TxBuilder;
use cosmrs::cosmwasm::MsgExecuteContract;
use cosmrs::tx::Msg;
use serde::Serialize;

impl OracleAdminClient {
    pub fn append_remove_asset_pairs_msg(
        &self,
        tx_builder: &mut TxBuilder,
        asset_pairs: Vec<AssetPair>,
    ) -> Result<(), OracleError> {
        let msg = ExecuteMsg {
            remove_asset_pairs: RemoveAssetPairsMsg { asset_pairs },
        };
        let contract_msg = serde_json::to_vec(&msg).map_err(OracleError::SerdeJsonError)?;
        let msg = MsgExecuteContract {
            sender: tx_builder.account_id.clone(),
            contract: self.chain_config.oracle_contract_address.clone(),
            msg: contract_msg,
            funds: vec![],
        };
        let msg = msg.to_any().map_err(OracleError::EyreError)?;
        tx_builder.add_msg(msg);
        Ok(())
    }
}

#[derive(Serialize)]
struct ExecuteMsg {
    pub remove_asset_pairs: RemoveAssetPairsMsg,
}

#[derive(Serialize)]
struct RemoveAssetPairsMsg {
    pub asset_pairs: Vec<AssetPair>,
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::oracle::add_asset_pairs::Asset;
    use crate::test_utils::helpers::{
        TEST_ASSET_ARCH_NAME, TEST_ASSET_ARCH_PRECISION, TEST_ASSET_ARCH_SYMBOL,
        TEST_ASSET_USDT_NAME, TEST_ASSET_USDT_PRECISION, TEST_ASSET_USDT_SYMBOL,
    };
    use crate::test_utils::test_scenario::TestScenario;
    use cosmrs::tendermint::abci::Code;
    use cosmwasm_std::Decimal256;
    use serial_test::serial;
    use std::str::FromStr;

    #[tokio::test]
    #[serial]
    async fn test_remove_asset_pairs() {
        let test_scenario = TestScenario::new_from_config("config.json".to_string()).await;

        let oracle_contract_address = test_scenario
            .instantiate_oracle_contract(Decimal256::from_str("0.5").unwrap(), Some(1000))
            .await;
        let client = OracleAdminClient::from_scenario(&test_scenario, &oracle_contract_address)
            .expect("Failed to create oracle admin client");
        test_scenario.set_default_assets(&client).await;

        let account = client
            .public_oracle_client
            .account(test_scenario.admin_address.clone())
            .await
            .expect("Failed to get account from public oracle client");
        let mut tx_builder = TxBuilder::new(
            test_scenario.admin_mnemonic.clone(),
            test_scenario.chain_prefix.clone(),
            test_scenario.chain_id.clone(),
            test_scenario.derivation_path,
            account.sequence,
            account.account_number,
        )
        .expect("Failed to create TxBuilder");

        let asset_pairs = vec![AssetPair {
            base: Asset {
                name: TEST_ASSET_ARCH_NAME.to_string(),
                symbol: TEST_ASSET_ARCH_SYMBOL.to_string(),
                precision: TEST_ASSET_ARCH_PRECISION,
            },
            quote: Asset {
                name: TEST_ASSET_USDT_NAME.to_string(),
                symbol: TEST_ASSET_USDT_SYMBOL.to_string(),
                precision: TEST_ASSET_USDT_PRECISION,
            },
        }];

        client
            .append_remove_asset_pairs_msg(&mut tx_builder, asset_pairs)
            .expect("Failed to append remove asset pairs message");

        tx_builder.set_memo("From test_remove_asset_pairs".to_string());
        let gas = 500_000u64;
        tx_builder.set_fee(70_000_000_000_000_000u128, &test_scenario.chain_denom, gas);
        let signed_bytes = tx_builder
            .get_signed_bytes()
            .expect("Failed to get signed bytes");
        let response = client
            .broadcast_tx(signed_bytes)
            .await
            .expect("Failed to broadcast tx");
        match response.tx_result.code {
            Code::Ok => {
                println!("Transaction successful: {:?}", response.hash);
            }
            Code::Err(code) => {
                panic!(
                    "Transaction failed with code: {:?} response: {:?}",
                    code, response
                );
            }
        }
    }
}