feat(minor-interchain-token-service): all chains with optional filter query message

contracts/interchain-token-service/src/contract.rs

@@ -49,6 +49,8 @@ pub enum Error {
     QueryTokenConfig,
     #[error("failed to query the status of contract")]
     QueryContractStatus,
+    #[error("failed to query chain configs")]
+    QueryAllChainConfigs,
 }
 
 #[cfg_attr(not(feature = "library"), entry_point)]
@@ -137,6 +139,9 @@ pub fn query(deps: Deps, _: Env, msg: QueryMsg) -> Result<Binary, ContractError>
         QueryMsg::AllItsContracts => {
             query::all_its_contracts(deps).change_context(Error::QueryAllItsContracts)
         }
+        QueryMsg::ItsChains { filter } => {
+            query::its_chains(deps, filter).change_context(Error::QueryAllChainConfigs)
+        }
         QueryMsg::TokenInstance { chain, token_id } => {
             query::token_instance(deps, chain, token_id).change_context(Error::QueryTokenInstance)
         }

contracts/interchain-token-service/src/contract/query.rs

@@ -34,6 +34,12 @@ pub fn all_its_contracts(deps: Deps) -> Result<Binary, Error> {
     to_json_binary(&contract_addresses).change_context(Error::JsonSerialization)
 }
 
+pub fn its_chains(deps: Deps, filter: Option<msg::ChainConfigFilter>) -> Result<Binary, Error> {
+    let chain_configs =
+        state::load_filtered_chain_configs(deps.storage, filter).change_context(Error::State)?;
+    to_json_binary(&chain_configs).change_context(Error::JsonSerialization)
+}
+
 pub fn token_instance(deps: Deps, chain: ChainNameRaw, token_id: TokenId) -> Result<Binary, Error> {
     let token_instance = state::may_load_token_instance(deps.storage, chain, token_id)
         .change_context(Error::State)?;

contracts/interchain-token-service/src/msg.rs

@@ -53,6 +53,17 @@ pub enum ExecuteMsg {
     EnableExecution,
 }
 
+#[cw_serde]
+pub enum ChainStatusFilter {
+    Frozen,
+    Active,
+}
+
+#[cw_serde]
+pub struct ChainConfigFilter {
+    pub status: Option<ChainStatusFilter>,
+}
+
 #[cw_serde]
 pub struct ChainConfig {
     pub chain: ChainNameRaw,
@@ -85,6 +96,10 @@ pub enum QueryMsg {
     #[returns(HashMap<ChainNameRaw, Address>)]
     AllItsContracts,
 
+    /// Query all chain configs with optional frozen filter
+    #[returns(Vec<ChainConfigResponse>)]
+    ItsChains { filter: Option<ChainConfigFilter> },
+
     /// Query a token instance on a specific chain
     #[returns(Option<TokenInstance>)]
     TokenInstance {

contracts/interchain-token-service/src/state.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use axelar_wasm_std::{nonempty, FnExt, IntoContractError};
 use cosmwasm_schema::cw_serde;
-use cosmwasm_std::{Addr, OverflowError, StdError, Storage, Uint256};
+use cosmwasm_std::{Addr, Order, OverflowError, StdError, Storage, Uint256};
 use cw_storage_plus::{Item, Map};
 use error_stack::{report, Result, ResultExt};
 use router_api::{Address, ChainNameRaw};
@@ -170,6 +170,48 @@ pub fn load_chain_config(
         .ok_or_else(|| report!(Error::ChainNotFound(chain.to_owned())))
 }
 
+pub fn load_filtered_chain_configs(
+    storage: &dyn Storage,
+    filter: Option<msg::ChainConfigFilter>,
+) -> Result<Vec<msg::ChainConfigResponse>, Error> {
+    let configs = CHAIN_CONFIGS
+        .range(storage, None, None, Order::Ascending)
+        .map(|res| {
+            res.change_context(Error::Storage)
+                .map(|(chain, config)| msg::ChainConfigResponse {
+                    chain,
+                    its_edge_contract: config.its_address,
+                    truncation: msg::TruncationConfig {
+                        max_uint: config.truncation.max_uint,
+                        max_decimals_when_truncating: config
+                            .truncation
+                            .max_decimals_when_truncating,
+                    },
+                    frozen: config.frozen,
+                })
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+
+    Ok(match filter {
+        Some(filter) if filter.status.is_some() => configs
+            .into_iter()
+            .filter(|config| matches_filter(config, filter.status.as_ref()))
+            .collect(),
+        _ => configs,
+    })
+}
+
+fn matches_filter(
+    config: &msg::ChainConfigResponse,
+    status: Option<&msg::ChainStatusFilter>,
+) -> bool {
+    match status {
+        Some(msg::ChainStatusFilter::Frozen) => config.frozen,
+        Some(msg::ChainStatusFilter::Active) => !config.frozen,
+        None => true,
+    }
+}
+
 pub fn save_chain_config(
     storage: &mut dyn Storage,
     chain: &ChainNameRaw,

contracts/interchain-token-service/tests/query.rs

@@ -3,7 +3,9 @@ use std::collections::HashMap;
 use assert_ok::assert_ok;
 use cosmwasm_std::testing::mock_dependencies;
 use cosmwasm_std::Uint256;
-use interchain_token_service::msg::{ChainConfigResponse, TruncationConfig};
+use interchain_token_service::msg::{
+    ChainConfigFilter, ChainConfigResponse, ChainStatusFilter, TruncationConfig,
+};
 use interchain_token_service::TokenId;
 use router_api::{Address, ChainNameRaw};
 
@@ -127,3 +129,116 @@ fn query_contract_enable_disable_lifecycle() {
     let enabled = utils::query_is_contract_enabled(deps.as_ref()).unwrap();
     assert!(!enabled);
 }
+
+#[test]
+fn query_chains_config() {
+    let mut deps = mock_dependencies();
+    utils::instantiate_contract(deps.as_mut()).unwrap();
+
+    let eth_chain: ChainNameRaw = "Ethereum".parse().unwrap();
+    let eth_address: Address = "0x1234567890123456789012345678901234567890"
+        .parse()
+        .unwrap();
+
+    utils::register_chain(
+        deps.as_mut(),
+        eth_chain.clone(),
+        eth_address.clone(),
+        Uint256::MAX.try_into().unwrap(),
+        u8::MAX,
+    )
+    .unwrap();
+
+    let poly_chain: ChainNameRaw = "Polygon".parse().unwrap();
+    let poly_address: Address = "0x1234567890123456789012345678901234567890"
+        .parse()
+        .unwrap();
+
+    utils::register_chain(
+        deps.as_mut(),
+        poly_chain.clone(),
+        poly_address.clone(),
+        Uint256::MAX.try_into().unwrap(),
+        u8::MAX,
+    )
+    .unwrap();
+
+    // no filtering
+    let all_chain_configs = assert_ok!(utils::query_its_chains(deps.as_ref(), None));
+    let expected_chain_configs = vec![
+        utils::create_expected_chain_config(
+            eth_chain.clone(),
+            eth_address.clone(),
+            Uint256::MAX.try_into().unwrap(),
+            u8::MAX,
+            false,
+        ),
+        utils::create_expected_chain_config(
+            poly_chain.clone(),
+            poly_address.clone(),
+            Uint256::MAX.try_into().unwrap(),
+            u8::MAX,
+            false,
+        ),
+    ];
+
+    for (a, e) in all_chain_configs.iter().zip(expected_chain_configs.iter()) {
+        assert_eq!(a, e);
+    }
+
+    // filter active chains, should be the same as all chains
+    let active_chain_configs = assert_ok!(utils::query_its_chains(
+        deps.as_ref(),
+        Some(ChainConfigFilter {
+            status: Some(ChainStatusFilter::Active),
+        })
+    ));
+    for (a, e) in active_chain_configs
+        .iter()
+        .zip(expected_chain_configs.iter())
+    {
+        assert_eq!(a, e);
+    }
+
+    // filter frozen chains, should be empty
+    let frozen_chain_configs = assert_ok!(utils::query_its_chains(
+        deps.as_ref(),
+        Some(ChainConfigFilter {
+            status: Some(ChainStatusFilter::Frozen),
+        })
+    ));
+    assert_eq!(frozen_chain_configs, vec![]);
+
+    // freeze a chain and query again
+    utils::freeze_chain(deps.as_mut(), eth_chain.clone()).unwrap();
+    let frozen_chain_configs = assert_ok!(utils::query_its_chains(
+        deps.as_ref(),
+        Some(ChainConfigFilter {
+            status: Some(ChainStatusFilter::Frozen),
+        })
+    ));
+    let expected_frozen_chain_configs = vec![utils::create_expected_chain_config(
+        eth_chain,
+        eth_address,
+        Uint256::MAX.try_into().unwrap(),
+        u8::MAX,
+        true,
+    )];
+    assert_eq!(frozen_chain_configs, expected_frozen_chain_configs);
+
+    // filter for active chains after freeze
+    let active_chain_configs = assert_ok!(utils::query_its_chains(
+        deps.as_ref(),
+        Some(ChainConfigFilter {
+            status: Some(ChainStatusFilter::Active),
+        })
+    ));
+    let expected_active_chain_configs = vec![utils::create_expected_chain_config(
+        poly_chain,
+        poly_address,
+        Uint256::MAX.try_into().unwrap(),
+        u8::MAX,
+        false,
+    )];
+    assert_eq!(active_chain_configs, expected_active_chain_configs);
+}

contracts/interchain-token-service/tests/utils/execute.rs

@@ -131,6 +131,15 @@ pub fn update_chain(
     )
 }
 
+pub fn freeze_chain(deps: DepsMut, chain: ChainNameRaw) -> Result<Response, ContractError> {
+    contract::execute(
+        deps,
+        mock_env(),
+        message_info(&MockApi::default().addr_make(params::GOVERNANCE), &[]),
+        ExecuteMsg::FreezeChain { chain },
+    )
+}
+
 pub fn disable_contract_execution(deps: DepsMut) -> Result<Response, ContractError> {
     contract::execute(
         deps,

contracts/interchain-token-service/tests/utils/query.rs

@@ -1,10 +1,12 @@
 use std::collections::HashMap;
 
-use axelar_wasm_std::error::ContractError;
+use axelar_wasm_std::{error::ContractError, nonempty};
 use cosmwasm_std::testing::mock_env;
 use cosmwasm_std::{from_json, Deps};
 use interchain_token_service::contract::query;
-use interchain_token_service::msg::{ChainConfigResponse, QueryMsg};
+use interchain_token_service::msg::{
+    ChainConfigFilter, ChainConfigResponse, QueryMsg, TruncationConfig,
+};
 use interchain_token_service::{TokenConfig, TokenId, TokenInstance};
 use router_api::{Address, ChainNameRaw};
 
@@ -48,3 +50,29 @@ pub fn query_is_contract_enabled(deps: Deps) -> Result<bool, ContractError> {
     let bin = query(deps, mock_env(), QueryMsg::IsEnabled {})?;
     Ok(from_json(bin)?)
 }
+
+pub fn query_its_chains(
+    deps: Deps,
+    filter: Option<ChainConfigFilter>,
+) -> Result<Vec<ChainConfigResponse>, ContractError> {
+    let bin = query(deps, mock_env(), QueryMsg::ItsChains { filter })?;
+    Ok(from_json(bin)?)
+}
+
+pub fn create_expected_chain_config(
+    chain: ChainNameRaw,
+    address: Address,
+    max_uint: nonempty::Uint256,
+    max_decimals: u8,
+    frozen: bool,
+) -> ChainConfigResponse {
+    ChainConfigResponse {
+        chain,
+        its_edge_contract: address,
+        truncation: TruncationConfig {
+            max_uint,
+            max_decimals_when_truncating: max_decimals,
+        },
+        frozen,
+    }
+}