From 32b9a1b312301836fa594cb0ce8759aef3eb3c4a Mon Sep 17 00:00:00 2001 From: Marco Granelli Date: Fri, 17 Jan 2025 15:24:07 +0100 Subject: [PATCH 01/11] Adds an ibc rate limit query --- crates/apps_lib/src/client/rpc.rs | 13 +++++++++++++ crates/sdk/src/rpc.rs | 28 +++++++++++++++++++++++++++- 2 files changed, 40 insertions(+), 1 deletion(-) diff --git a/crates/apps_lib/src/client/rpc.rs b/crates/apps_lib/src/client/rpc.rs index dab886c22e..e8938466b0 100644 --- a/crates/apps_lib/src/client/rpc.rs +++ b/crates/apps_lib/src/client/rpc.rs @@ -2446,3 +2446,16 @@ pub async fn compute_proposal_votes( delegator_voting_power, } } + +// FIXME: I need a new cli command to call this function and print the result +// (mention that the limit is for epoch) FIXME: shuld we display line directly +// from here? No do that in the caller +/// Query the IBC rate limit for the provided token +pub async fn query_ibc_rate_limit( + client: &C, + token: &Address, +) -> token::Amount { + unwrap_sdk_result::( + rpc::query_ibc_rate_limit(client, token).await, + ) +} diff --git a/crates/sdk/src/rpc.rs b/crates/sdk/src/rpc.rs index eac8e2159e..cd694b9547 100644 --- a/crates/sdk/src/rpc.rs +++ b/crates/sdk/src/rpc.rs @@ -41,8 +41,9 @@ use namada_governance::utils::{ compute_proposal_result, ProposalResult, ProposalVotes, Vote, }; use namada_ibc::core::host::types::identifiers::PortId; +use namada_ibc::parameters::IbcParameters; use namada_ibc::storage::{ - ibc_trace_key, ibc_trace_key_prefix, is_ibc_trace_key, + ibc_trace_key, ibc_trace_key_prefix, is_ibc_trace_key, throughput_limit_key, }; use namada_ibc::trace::calc_ibc_token_hash; use namada_io::{display_line, edisplay_line, Client, Io}; @@ -1489,6 +1490,7 @@ pub async fn query_ibc_tokens( /// Look up the IBC denomination from a IbcToken. pub async fn query_ibc_denom( context: &N, + // FIXME: look here in case I needed to use a string token: impl AsRef, owner: Option<&Address>, ) -> String { @@ -1898,3 +1900,27 @@ pub async fn query_osmosis_pool_routes( .map(|r| r.pools.into_iter().map(OsmosisPoolHop::from).collect()) .collect()) } + +// FIXME: the other functions rely on the rpc macro, should do the same in here? +// In case remove this function from here and move it there +/// Query the IBC rate limit for the provided token +pub async fn query_ibc_rate_limit( + client: &C, + token: &Address, +) -> Result { + match query_storage_value::<_, Amount>(client, &throughput_limit_key(token)) + .await + { + Ok(limit) => Ok(limit), + Err(_) => { + // If no custom limit has been set for this token fallback to the + // default param + query_storage_value::<_, IbcParameters>( + client, + &namada_ibc::storage::params_key(), + ) + .await + .map(|params| params.default_per_epoch_throughput_limit) + } + } +} From d06eefec648167b2b2b0de4947fda1bc057e08b7 Mon Sep 17 00:00:00 2001 From: Marco Granelli Date: Fri, 17 Jan 2025 17:10:41 +0100 Subject: [PATCH 02/11] Exposes ibc rate limit query to the cli --- crates/apps_lib/src/cli.rs | 57 +++++++++++++++++++++++++++++++ crates/apps_lib/src/cli/client.rs | 12 +++++++ crates/apps_lib/src/client/rpc.rs | 25 ++++++++------ crates/sdk/src/args.rs | 11 ++++++ 4 files changed, 94 insertions(+), 11 deletions(-) diff --git a/crates/apps_lib/src/cli.rs b/crates/apps_lib/src/cli.rs index 6e715b86d5..ac4a653177 100644 --- a/crates/apps_lib/src/cli.rs +++ b/crates/apps_lib/src/cli.rs @@ -287,6 +287,7 @@ pub mod cmds { .subcommand(QuerySlashes::def().display_order(5)) .subcommand(QueryDelegations::def().display_order(5)) .subcommand(QueryFindValidator::def().display_order(5)) + .subcommand(QueryIbcRateLimit::def().display_order(5)) .subcommand(QueryResult::def().display_order(5)) .subcommand(QueryRawBytes::def().display_order(5)) .subcommand(QueryProposal::def().display_order(5)) @@ -554,6 +555,7 @@ pub mod cmds { QueryPgf(QueryPgf), QueryValidatorState(QueryValidatorState), QueryRewards(QueryRewards), + QueryIbcRateLimit(QueryIbcRateLimit), ShieldedSync(ShieldedSync), GenIbcShieldingTransfer(GenIbcShieldingTransfer), } @@ -2186,6 +2188,27 @@ pub mod cmds { } } + #[derive(Clone, Debug)] + pub struct QueryIbcRateLimit(pub args::QueryIbcRateLimit); + + impl SubCmd for QueryIbcRateLimit { + const CMD: &'static str = "query-ibc-rate-limit"; + + fn parse(matches: &ArgMatches) -> Option { + matches.subcommand_matches(Self::CMD).map(|matches| { + QueryIbcRateLimit(args::QueryIbcRateLimit::parse(matches)) + }) + } + + fn def() -> App { + App::new(Self::CMD) + .about(wrap!( + "Query the IBC rate limit for the provided token." + )) + .add_args::>() + } + } + #[derive(Clone, Debug)] pub struct QueryRawBytes(pub args::QueryRawBytes); @@ -3639,6 +3662,7 @@ pub mod args { pub const TOKEN_OPT: ArgOpt = TOKEN.opt(); pub const TOKEN_STR_OPT: ArgOpt = TOKEN_STR.opt(); pub const TOKEN: Arg = arg("token"); + // FIXME: I could use this if I can't use a normal address pub const TOKEN_STR: Arg = arg("token"); pub const TRANSFER_SOURCE: Arg = arg("source"); pub const TRANSFER_TARGET: Arg = arg("target"); @@ -7102,6 +7126,7 @@ pub mod args { let query = Query::parse(matches); let output_folder = OUTPUT_FOLDER_PATH.parse(matches); let target = TRANSFER_TARGET.parse(matches); + // FIXME: here we use the string for the token let token = TOKEN_STR.parse(matches); let amount = InputAmount::Unvalidated(AMOUNT.parse(matches)); let expiration = EXPIRATION_OPT.parse(matches); @@ -7472,6 +7497,38 @@ pub mod args { } } + impl Args for QueryIbcRateLimit { + fn parse(matches: &ArgMatches) -> Self { + let query = Query::parse(matches); + let token = TOKEN.parse(matches); + + Self { query, token } + } + + fn def(app: App) -> App { + app.add_args::>().arg( + TOKEN + .def() + .help(wrap!("The IBC token.")) + .conflicts_with(TOKEN.name), + ) + } + } + + impl CliToSdk> for QueryIbcRateLimit { + type Error = std::convert::Infallible; + + fn to_sdk( + self, + ctx: &mut Context, + ) -> Result, Self::Error> { + Ok(QueryIbcRateLimit:: { + query: self.query.to_sdk(ctx)?, + token: ctx.borrow_chain_or_exit().get(&self.token), + }) + } + } + impl CliToSdk> for QueryRawBytes { type Error = std::convert::Infallible; diff --git a/crates/apps_lib/src/cli/client.rs b/crates/apps_lib/src/cli/client.rs index 7899bdcc5d..c00922b328 100644 --- a/crates/apps_lib/src/cli/client.rs +++ b/crates/apps_lib/src/cli/client.rs @@ -822,6 +822,18 @@ impl CliApi { let namada = ctx.to_sdk(client, io); rpc::query_account(&namada, args).await; } + Sub::QueryIbcRateLimit(QueryIbcRateLimit(args)) => { + let chain_ctx = ctx.borrow_mut_chain_or_exit(); + let ledger_address = + chain_ctx.get(&args.query.ledger_address); + let client = client.unwrap_or_else(|| { + C::from_tendermint_address(&ledger_address) + }); + client.wait_until_node_is_synced(&io).await?; + let args = args.to_sdk(&mut ctx)?; + let namada = ctx.to_sdk(client, io); + rpc::query_ibc_rate_limit(&namada, args).await; + } } } cli::NamadaClient::WithoutContext(cmd_box) => { diff --git a/crates/apps_lib/src/client/rpc.rs b/crates/apps_lib/src/client/rpc.rs index e8938466b0..61a53089f7 100644 --- a/crates/apps_lib/src/client/rpc.rs +++ b/crates/apps_lib/src/client/rpc.rs @@ -2447,15 +2447,18 @@ pub async fn compute_proposal_votes( } } -// FIXME: I need a new cli command to call this function and print the result -// (mention that the limit is for epoch) FIXME: shuld we display line directly -// from here? No do that in the caller -/// Query the IBC rate limit for the provided token -pub async fn query_ibc_rate_limit( - client: &C, - token: &Address, -) -> token::Amount { - unwrap_sdk_result::( - rpc::query_ibc_rate_limit(client, token).await, - ) +/// Query and display the IBC rate limit for the provided token +pub async fn query_ibc_rate_limit( + context: &impl Namada, + args: args::QueryIbcRateLimit, +) { + let limit = unwrap_sdk_result::( + rpc::query_ibc_rate_limit(context.client(), &args.token).await, + ); + display_line!( + context.io(), + "IBC rate limit for token {}: {}/epoch", + args.token, + limit + ); } diff --git a/crates/sdk/src/args.rs b/crates/sdk/src/args.rs index 24168c7b78..b00eec079e 100644 --- a/crates/sdk/src/args.rs +++ b/crates/sdk/src/args.rs @@ -2597,6 +2597,17 @@ pub struct QueryRawBytes { pub query: Query, } +/// Query the IBC rate limit for the specified token +#[derive(Clone, Debug)] +pub struct QueryIbcRateLimit { + /// Common query args + pub query: Query, + /// Token address + // FIXME: actually, can we express an ibc address as an address or should + // we use a string? + pub token: C::Address, +} + /// The possible values for the tx expiration #[derive(Clone, Debug, Default)] pub enum TxExpiration { From 88f72c27acc58236b4517905e23dea2dc409364b Mon Sep 17 00:00:00 2001 From: Marco Granelli Date: Fri, 17 Jan 2025 19:33:23 +0100 Subject: [PATCH 03/11] Display ibc rate limit using token alias. Adds query to e2e test. --- crates/apps_lib/src/cli.rs | 13 +++++-------- crates/apps_lib/src/client/rpc.rs | 13 +++++++------ crates/sdk/src/args.rs | 2 -- crates/sdk/src/rpc.rs | 3 --- crates/tests/src/e2e/ibc_tests.rs | 23 ++++++++++++++++++++--- 5 files changed, 32 insertions(+), 22 deletions(-) diff --git a/crates/apps_lib/src/cli.rs b/crates/apps_lib/src/cli.rs index ac4a653177..3730e7c909 100644 --- a/crates/apps_lib/src/cli.rs +++ b/crates/apps_lib/src/cli.rs @@ -398,6 +398,8 @@ pub mod cmds { let query_commission = Self::parse_with_ctx(matches, QueryCommissionRate); let query_metadata = Self::parse_with_ctx(matches, QueryMetaData); + let query_ibc_rate_limit = + Self::parse_with_ctx(matches, QueryIbcRateLimit); let add_to_eth_bridge_pool = Self::parse_with_ctx(matches, AddToEthBridgePool); let shielded_sync = Self::parse_with_ctx(matches, ShieldedSync); @@ -460,6 +462,7 @@ pub mod cmds { .or(query_native_supply) .or(query_staking_rewards_rate) .or(query_account) + .or(query_ibc_rate_limit) .or(shielded_sync) .or(gen_ibc_shielding) .or(utils) @@ -3662,7 +3665,6 @@ pub mod args { pub const TOKEN_OPT: ArgOpt = TOKEN.opt(); pub const TOKEN_STR_OPT: ArgOpt = TOKEN_STR.opt(); pub const TOKEN: Arg = arg("token"); - // FIXME: I could use this if I can't use a normal address pub const TOKEN_STR: Arg = arg("token"); pub const TRANSFER_SOURCE: Arg = arg("source"); pub const TRANSFER_TARGET: Arg = arg("target"); @@ -7126,7 +7128,6 @@ pub mod args { let query = Query::parse(matches); let output_folder = OUTPUT_FOLDER_PATH.parse(matches); let target = TRANSFER_TARGET.parse(matches); - // FIXME: here we use the string for the token let token = TOKEN_STR.parse(matches); let amount = InputAmount::Unvalidated(AMOUNT.parse(matches)); let expiration = EXPIRATION_OPT.parse(matches); @@ -7506,12 +7507,8 @@ pub mod args { } fn def(app: App) -> App { - app.add_args::>().arg( - TOKEN - .def() - .help(wrap!("The IBC token.")) - .conflicts_with(TOKEN.name), - ) + app.add_args::>() + .arg(TOKEN.def().help(wrap!("The IBC token."))) } } diff --git a/crates/apps_lib/src/client/rpc.rs b/crates/apps_lib/src/client/rpc.rs index 61a53089f7..b5f6c5ab45 100644 --- a/crates/apps_lib/src/client/rpc.rs +++ b/crates/apps_lib/src/client/rpc.rs @@ -263,7 +263,7 @@ async fn query_transparent_balance( .address() .expect("Balance owner should have been a transparent address"); - let token_alias = lookup_token_alias(context, &token, &owner).await; + let token_alias = lookup_token_alias(context, &token, Some(&owner)).await; let token_balance_result = namada_sdk::rpc::get_token_balance( context.client(), &token, @@ -290,7 +290,7 @@ async fn query_transparent_balance( async fn lookup_token_alias( context: &impl Namada, token: &Address, - owner: &Address, + owner: Option<&Address>, ) -> String { match token { Address::Internal(InternalAddress::Erc20(eth_addr)) => { @@ -298,8 +298,7 @@ async fn lookup_token_alias( } Address::Internal(InternalAddress::IbcToken(_)) => { let ibc_denom = - rpc::query_ibc_denom(context, token.to_string(), Some(owner)) - .await; + rpc::query_ibc_denom(context, token.to_string(), owner).await; context.wallet().await.lookup_ibc_token_alias(ibc_denom) } @@ -499,7 +498,7 @@ async fn query_shielded_balance( let masp_epoch = query_and_print_masp_epoch(context).await; // Query the token alias in the wallet for pretty printing token balances - let token_alias = lookup_token_alias(context, &token, &MASP).await; + let token_alias = lookup_token_alias(context, &token, Some(&MASP)).await; // Query the multi-asset balance at the given spending key let mut shielded = context.shielded_mut().await; @@ -2455,10 +2454,12 @@ pub async fn query_ibc_rate_limit( let limit = unwrap_sdk_result::( rpc::query_ibc_rate_limit(context.client(), &args.token).await, ); + let token_alias = lookup_token_alias(context, &args.token, None).await; + display_line!( context.io(), "IBC rate limit for token {}: {}/epoch", - args.token, + token_alias, limit ); } diff --git a/crates/sdk/src/args.rs b/crates/sdk/src/args.rs index b00eec079e..7a719ff89e 100644 --- a/crates/sdk/src/args.rs +++ b/crates/sdk/src/args.rs @@ -2603,8 +2603,6 @@ pub struct QueryIbcRateLimit { /// Common query args pub query: Query, /// Token address - // FIXME: actually, can we express an ibc address as an address or should - // we use a string? pub token: C::Address, } diff --git a/crates/sdk/src/rpc.rs b/crates/sdk/src/rpc.rs index cd694b9547..a99b1c446d 100644 --- a/crates/sdk/src/rpc.rs +++ b/crates/sdk/src/rpc.rs @@ -1490,7 +1490,6 @@ pub async fn query_ibc_tokens( /// Look up the IBC denomination from a IbcToken. pub async fn query_ibc_denom( context: &N, - // FIXME: look here in case I needed to use a string token: impl AsRef, owner: Option<&Address>, ) -> String { @@ -1901,8 +1900,6 @@ pub async fn query_osmosis_pool_routes( .collect()) } -// FIXME: the other functions rely on the rpc macro, should do the same in here? -// In case remove this function from here and move it there /// Query the IBC rate limit for the provided token pub async fn query_ibc_rate_limit( client: &C, diff --git a/crates/tests/src/e2e/ibc_tests.rs b/crates/tests/src/e2e/ibc_tests.rs index e2698db993..f21e8140c0 100644 --- a/crates/tests/src/e2e/ibc_tests.rs +++ b/crates/tests/src/e2e/ibc_tests.rs @@ -1097,11 +1097,30 @@ fn ibc_rate_limit() -> Result<()> { )?; // Start relaying + let rpc = get_actor_rpc(&test, Who::Validator(0)); let hermes = run_hermes(&hermes_dir)?; let _bg_hermes = hermes.background(); + // Query the IBC rate limits + let ibc_denom = + format!("{port_id_namada}/{channel_id_namada}/{COSMOS_COIN}"); + for token in [NAM, &ibc_denom] { + let tx_args = apply_use_device(vec![ + "query-ibc-rate-limit", + "--token", + token, + "--node", + &rpc, + ]); + let mut client = run!(test, Bin::Client, tx_args, Some(40))?; + client.exp_string(&format!( + "IBC rate limit for token {}: 1000000/epoch", + token.to_lowercase() + ))?; + client.assert_success(); + } + // wait for the next epoch - let rpc = get_actor_rpc(&test, Who::Validator(0)); let mut epoch = get_epoch(&test, &rpc).unwrap(); let next_epoch = epoch.next(); while epoch <= next_epoch { @@ -1195,8 +1214,6 @@ fn ibc_rate_limit() -> Result<()> { wait_for_packet_relay(&hermes_dir, &port_id_gaia, &channel_id_gaia, &test)?; // Check if Namada hasn't receive it - let ibc_denom = - format!("{port_id_namada}/{channel_id_namada}/{COSMOS_COIN}"); // Need the raw address to check the balance because the token shouldn't be // received let token_addr = ibc_token(ibc_denom).to_string(); From a7bfe81bd7f852d2eaa9baf38268d48458d53783 Mon Sep 17 00:00:00 2001 From: Marco Granelli Date: Fri, 17 Jan 2025 21:21:45 +0100 Subject: [PATCH 04/11] Fixes token alias in ibc rate limit test --- crates/tests/src/e2e/ibc_tests.rs | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/crates/tests/src/e2e/ibc_tests.rs b/crates/tests/src/e2e/ibc_tests.rs index f21e8140c0..badc38a3e9 100644 --- a/crates/tests/src/e2e/ibc_tests.rs +++ b/crates/tests/src/e2e/ibc_tests.rs @@ -1104,7 +1104,12 @@ fn ibc_rate_limit() -> Result<()> { // Query the IBC rate limits let ibc_denom = format!("{port_id_namada}/{channel_id_namada}/{COSMOS_COIN}"); - for token in [NAM, &ibc_denom] { + // Need the raw address because the token won't be received later in this + // test + let cosmos_token_addr = ibc_token(&ibc_denom).to_string(); + for (token, token_alias) in + [(NAM, &NAM.to_lowercase()), (&ibc_denom, &cosmos_token_addr)] + { let tx_args = apply_use_device(vec![ "query-ibc-rate-limit", "--token", @@ -1115,7 +1120,7 @@ fn ibc_rate_limit() -> Result<()> { let mut client = run!(test, Bin::Client, tx_args, Some(40))?; client.exp_string(&format!( "IBC rate limit for token {}: 1000000/epoch", - token.to_lowercase() + token_alias ))?; client.assert_success(); } @@ -1214,10 +1219,7 @@ fn ibc_rate_limit() -> Result<()> { wait_for_packet_relay(&hermes_dir, &port_id_gaia, &channel_id_gaia, &test)?; // Check if Namada hasn't receive it - // Need the raw address to check the balance because the token shouldn't be - // received - let token_addr = ibc_token(ibc_denom).to_string(); - check_balance(&test, ALBERT, token_addr, 0)?; + check_balance(&test, ALBERT, cosmos_token_addr, 0)?; Ok(()) } From 84b827ee0966d64873e79b766a2ed5bf6f98ad07 Mon Sep 17 00:00:00 2001 From: brentstone Date: Sat, 18 Jan 2025 16:54:22 +0900 Subject: [PATCH 05/11] add both rate limits to fns and default ibc params to protocol params query --- crates/apps_lib/src/cli/client.rs | 2 +- crates/apps_lib/src/client/rpc.rs | 38 ++++++++++++++++---- crates/ibc/src/parameters.rs | 9 +++++ crates/sdk/src/rpc.rs | 58 ++++++++++++++++++++++--------- 4 files changed, 83 insertions(+), 24 deletions(-) diff --git a/crates/apps_lib/src/cli/client.rs b/crates/apps_lib/src/cli/client.rs index c00922b328..5ae97d3747 100644 --- a/crates/apps_lib/src/cli/client.rs +++ b/crates/apps_lib/src/cli/client.rs @@ -832,7 +832,7 @@ impl CliApi { client.wait_until_node_is_synced(&io).await?; let args = args.to_sdk(&mut ctx)?; let namada = ctx.to_sdk(client, io); - rpc::query_ibc_rate_limit(&namada, args).await; + rpc::query_ibc_rate_limits(&namada, args).await; } } } diff --git a/crates/apps_lib/src/client/rpc.rs b/crates/apps_lib/src/client/rpc.rs index b5f6c5ab45..0fafa2245a 100644 --- a/crates/apps_lib/src/client/rpc.rs +++ b/crates/apps_lib/src/client/rpc.rs @@ -30,6 +30,7 @@ use namada_sdk::governance::storage::proposal::{ use namada_sdk::governance::utils::{ProposalVotes, VotePower}; use namada_sdk::governance::ProposalVote; use namada_sdk::hash::Hash; +use namada_sdk::ibc::parameters::{IbcParameters, IbcTokenRateLimits}; use namada_sdk::io::{display, display_line, edisplay_line, Client, Io}; use namada_sdk::key::*; use namada_sdk::masp::shielded_wallet::ShieldedApi; @@ -46,7 +47,7 @@ use namada_sdk::proof_of_stake::{self, OwnedPosParams, PosParams}; use namada_sdk::queries::RPC; use namada_sdk::rpc::{ self, enriched_bonds_and_unbonds, format_denominated_amount, query_epoch, - TxResponse, + query_ibc_params, TxResponse, }; use namada_sdk::state::LastBlock; use namada_sdk::storage::BlockResults; @@ -1088,6 +1089,26 @@ pub async fn query_protocol_parameters( "", tm_votes_per_token ); + + display_line!(context.io(), "\nIBC parameters"); + let IbcParameters { + default_mint_limit, + default_per_epoch_throughput_limit, + } = query_ibc_params(context.client()) + .await + .expect("Failed to query the IBC parameters"); + display_line!( + context.io(), + "{:4}Default mint limit: {}", + "", + default_mint_limit + ); + display_line!( + context.io(), + "{:4}Default per epoch throughput limit: {}", + "", + default_per_epoch_throughput_limit + ); } pub async fn query_bond( @@ -2447,19 +2468,24 @@ pub async fn compute_proposal_votes( } /// Query and display the IBC rate limit for the provided token -pub async fn query_ibc_rate_limit( +pub async fn query_ibc_rate_limits( context: &impl Namada, args: args::QueryIbcRateLimit, ) { - let limit = unwrap_sdk_result::( - rpc::query_ibc_rate_limit(context.client(), &args.token).await, + let IbcTokenRateLimits { + mint_limit, + throughput_per_epoch_limit, + } = unwrap_sdk_result::( + rpc::query_ibc_rate_limits(context.client(), &args.token).await, ); let token_alias = lookup_token_alias(context, &args.token, None).await; display_line!( context.io(), - "IBC rate limit for token {}: {}/epoch", + "IBC rate limits for token {}:\nGlobal mint limit: {}\nThroughput \ + limit: {} per epoch", token_alias, - limit + mint_limit, + throughput_per_epoch_limit ); } diff --git a/crates/ibc/src/parameters.rs b/crates/ibc/src/parameters.rs index 811516eddd..2e22f5b3c5 100644 --- a/crates/ibc/src/parameters.rs +++ b/crates/ibc/src/parameters.rs @@ -13,6 +13,15 @@ pub struct IbcParameters { pub default_per_epoch_throughput_limit: Amount, } +#[derive(Clone, Debug, BorshSerialize, BorshDeserialize)] +/// IBC rate limits for a token +pub struct IbcTokenRateLimits { + /// Global mint limit for the token + pub mint_limit: Amount, + /// Throughput limit per epoch + pub throughput_per_epoch_limit: Amount, +} + impl Default for IbcParameters { fn default() -> Self { Self { diff --git a/crates/sdk/src/rpc.rs b/crates/sdk/src/rpc.rs index a99b1c446d..99f032e202 100644 --- a/crates/sdk/src/rpc.rs +++ b/crates/sdk/src/rpc.rs @@ -41,9 +41,10 @@ use namada_governance::utils::{ compute_proposal_result, ProposalResult, ProposalVotes, Vote, }; use namada_ibc::core::host::types::identifiers::PortId; -use namada_ibc::parameters::IbcParameters; +use namada_ibc::parameters::{IbcParameters, IbcTokenRateLimits}; use namada_ibc::storage::{ - ibc_trace_key, ibc_trace_key_prefix, is_ibc_trace_key, throughput_limit_key, + ibc_trace_key, ibc_trace_key_prefix, is_ibc_trace_key, mint_limit_key, + throughput_limit_key, }; use namada_ibc::trace::calc_ibc_token_hash; use namada_io::{display_line, edisplay_line, Client, Io}; @@ -1901,23 +1902,46 @@ pub async fn query_osmosis_pool_routes( } /// Query the IBC rate limit for the provided token -pub async fn query_ibc_rate_limit( +pub async fn query_ibc_rate_limits( client: &C, token: &Address, -) -> Result { - match query_storage_value::<_, Amount>(client, &throughput_limit_key(token)) - .await - { - Ok(limit) => Ok(limit), - Err(_) => { - // If no custom limit has been set for this token fallback to the - // default param - query_storage_value::<_, IbcParameters>( - client, - &namada_ibc::storage::params_key(), - ) - .await - .map(|params| params.default_per_epoch_throughput_limit) +) -> Result { + let throughput_limit = + query_storage_value::<_, Amount>(client, &throughput_limit_key(token)) + .await; + let mint_limit = + query_storage_value::<_, Amount>(client, &mint_limit_key(token)).await; + + match (mint_limit, throughput_limit) { + (Ok(mint_limit), Ok(throughput_per_epoch_limit)) => { + Ok(IbcTokenRateLimits { + mint_limit, + throughput_per_epoch_limit, + }) + } + (Ok(_mint_limit), Err(_)) => Err(QueryError::NoSuchKey( + throughput_limit_key(token).to_string(), + ) + .into()), + (Err(_), Ok(_throughput_limit)) => { + Err(QueryError::NoSuchKey(mint_limit_key(token).to_string()).into()) } + _ => Err(QueryError::General(format!( + "Error querying IBC rate limits for the token {} - no rate limits \ + found", + token + )) + .into()), } } + +/// Query the global IBC parameters +pub async fn query_ibc_params( + client: &C, +) -> Result { + query_storage_value::<_, IbcParameters>( + client, + &namada_ibc::storage::params_key(), + ) + .await +} From e1c26a84026390504ab2b469829b777ca210bb35 Mon Sep 17 00:00:00 2001 From: brentstone Date: Sat, 18 Jan 2025 17:32:00 +0900 Subject: [PATCH 06/11] improve outputs and fix tests --- crates/apps_lib/src/cli.rs | 2 +- crates/apps_lib/src/client/rpc.rs | 70 ++++++++++++++++++++++++------- crates/tests/src/e2e/ibc_tests.rs | 5 ++- 3 files changed, 60 insertions(+), 17 deletions(-) diff --git a/crates/apps_lib/src/cli.rs b/crates/apps_lib/src/cli.rs index 3730e7c909..6e8f567204 100644 --- a/crates/apps_lib/src/cli.rs +++ b/crates/apps_lib/src/cli.rs @@ -2195,7 +2195,7 @@ pub mod cmds { pub struct QueryIbcRateLimit(pub args::QueryIbcRateLimit); impl SubCmd for QueryIbcRateLimit { - const CMD: &'static str = "query-ibc-rate-limit"; + const CMD: &'static str = "query-ibc-rate-limits"; fn parse(matches: &ArgMatches) -> Option { matches.subcommand_matches(Self::CMD).map(|matches| { diff --git a/crates/apps_lib/src/client/rpc.rs b/crates/apps_lib/src/client/rpc.rs index 0fafa2245a..593bb34a0d 100644 --- a/crates/apps_lib/src/client/rpc.rs +++ b/crates/apps_lib/src/client/rpc.rs @@ -2472,20 +2472,62 @@ pub async fn query_ibc_rate_limits( context: &impl Namada, args: args::QueryIbcRateLimit, ) { - let IbcTokenRateLimits { - mint_limit, - throughput_per_epoch_limit, - } = unwrap_sdk_result::( - rpc::query_ibc_rate_limits(context.client(), &args.token).await, - ); let token_alias = lookup_token_alias(context, &args.token, None).await; + let native_token = context.native_token(); - display_line!( - context.io(), - "IBC rate limits for token {}:\nGlobal mint limit: {}\nThroughput \ - limit: {} per epoch", - token_alias, - mint_limit, - throughput_per_epoch_limit - ); + match rpc::query_ibc_rate_limits(context.client(), &args.token).await { + Ok(IbcTokenRateLimits { + mint_limit, + throughput_per_epoch_limit, + }) => { + let (mint_str, throughput_str) = if args.token == native_token { + ( + mint_limit.to_string_native(), + throughput_per_epoch_limit.to_string_native(), + ) + } else { + ( + mint_limit.to_string(), + throughput_per_epoch_limit.to_string(), + ) + }; + display_line!( + context.io(), + "IBC rate limits for token {}:\nGlobal mint limit: \ + {}\nThroughput limit: {} per epoch", + token_alias, + mint_str, + throughput_str + ); + } + Err(_) => { + let IbcParameters { + default_mint_limit, + default_per_epoch_throughput_limit, + } = query_ibc_params(context.client()) + .await + .expect("Error querying the global IBC parameters"); + + let (mint_str, throughput_str) = if args.token == native_token { + ( + default_mint_limit.to_string_native(), + default_per_epoch_throughput_limit.to_string_native(), + ) + } else { + ( + default_mint_limit.to_string(), + default_per_epoch_throughput_limit.to_string(), + ) + }; + display_line!( + context.io(), + "Could not find IBC rate limits for token {}, returning \ + default IBC rate limits instead:\nDefault global mint limit: \ + {}\nDefault throughput limit: {} per epoch", + token_alias, + mint_str, + throughput_str + ); + } + } } diff --git a/crates/tests/src/e2e/ibc_tests.rs b/crates/tests/src/e2e/ibc_tests.rs index badc38a3e9..13f7728f10 100644 --- a/crates/tests/src/e2e/ibc_tests.rs +++ b/crates/tests/src/e2e/ibc_tests.rs @@ -1111,7 +1111,7 @@ fn ibc_rate_limit() -> Result<()> { [(NAM, &NAM.to_lowercase()), (&ibc_denom, &cosmos_token_addr)] { let tx_args = apply_use_device(vec![ - "query-ibc-rate-limit", + "query-ibc-rate-limits", "--token", token, "--node", @@ -1119,7 +1119,8 @@ fn ibc_rate_limit() -> Result<()> { ]); let mut client = run!(test, Bin::Client, tx_args, Some(40))?; client.exp_string(&format!( - "IBC rate limit for token {}: 1000000/epoch", + "IBC rate limits for token {}:\nGlobal mint limit: \ + 1000000\nThroughput limit: 1000000 per epoch", token_alias ))?; client.assert_success(); From e29b312c2c5d52544cb9e6bf91b85a595ae71e6d Mon Sep 17 00:00:00 2001 From: Marco Granelli Date: Mon, 20 Jan 2025 11:21:12 +0100 Subject: [PATCH 07/11] Updates ibc rate limits assertion --- crates/tests/src/e2e/ibc_tests.rs | 66 +++++++++++++++++++------------ 1 file changed, 41 insertions(+), 25 deletions(-) diff --git a/crates/tests/src/e2e/ibc_tests.rs b/crates/tests/src/e2e/ibc_tests.rs index 13f7728f10..7cf3f36d23 100644 --- a/crates/tests/src/e2e/ibc_tests.rs +++ b/crates/tests/src/e2e/ibc_tests.rs @@ -1066,20 +1066,22 @@ fn ibc_upgrade_client() -> Result<()> { /// - Receiving 2 samoleans from Gaia will fail #[test] fn ibc_rate_limit() -> Result<()> { + const DEFAULT_RATE_LIMIT: Amount = Amount::from_u64(1_000_000); + const DEFAULT_MINT_LIMIT: Amount = Amount::from_u64(1); + // Mint limit 2 transfer/channel-0/nam, per-epoch throughput limit 1 NAM - let update_genesis = |mut genesis: templates::All< - templates::Unvalidated, - >, - base_dir: &_| { - genesis.parameters.parameters.epochs_per_year = - epochs_per_year_from_min_duration(50); - genesis.parameters.ibc_params.default_mint_limit = Amount::from_u64(1); - genesis - .parameters - .ibc_params - .default_per_epoch_throughput_limit = Amount::from_u64(1_000_000); - setup::set_validators(1, genesis, base_dir, |_| 0, vec![]) - }; + let update_genesis = + |mut genesis: templates::All, base_dir: &_| { + genesis.parameters.parameters.epochs_per_year = + epochs_per_year_from_min_duration(50); + genesis.parameters.ibc_params.default_mint_limit = + DEFAULT_MINT_LIMIT; + genesis + .parameters + .ibc_params + .default_per_epoch_throughput_limit = DEFAULT_RATE_LIMIT; + setup::set_validators(1, genesis, base_dir, |_| 0, vec![]) + }; let (ledger, gaia, test, test_gaia) = run_namada_cosmos(CosmosChainType::Gaia(None), update_genesis)?; let _bg_ledger = ledger.background(); @@ -1107,22 +1109,36 @@ fn ibc_rate_limit() -> Result<()> { // Need the raw address because the token won't be received later in this // test let cosmos_token_addr = ibc_token(&ibc_denom).to_string(); - for (token, token_alias) in - [(NAM, &NAM.to_lowercase()), (&ibc_denom, &cosmos_token_addr)] - { - let tx_args = apply_use_device(vec![ - "query-ibc-rate-limits", - "--token", - token, - "--node", - &rpc, - ]); + for (token, token_alias, mint_limit, rate_limit) in [ + ( + NAM, + &NAM.to_lowercase(), + DEFAULT_MINT_LIMIT.to_string_native(), + DEFAULT_RATE_LIMIT.to_string_native(), + ), + ( + &ibc_denom, + &cosmos_token_addr, + DEFAULT_MINT_LIMIT.to_string(), + DEFAULT_RATE_LIMIT.to_string(), + ), + ] { + let tx_args = + vec!["query-ibc-rate-limits", "--token", token, "--node", &rpc]; let mut client = run!(test, Bin::Client, tx_args, Some(40))?; client.exp_string(&format!( - "IBC rate limits for token {}:\nGlobal mint limit: \ - 1000000\nThroughput limit: 1000000 per epoch", + "Could not find IBC rate limits for token {}, returning default \ + IBC rate limits instead:", token_alias ))?; + client.exp_string(&format!( + "Default global mint limit: {}", + mint_limit + ))?; + client.exp_string(&format!( + "Default throughput limit: {} per epoch", + rate_limit + ))?; client.assert_success(); } From 96569c7e9904f559c7622e506f5dbd3dec49141d Mon Sep 17 00:00:00 2001 From: Marco Granelli Date: Mon, 20 Jan 2025 21:05:27 +0100 Subject: [PATCH 08/11] Aligns the ibc rate limit query logic with the ibc vp one --- crates/apps_lib/src/client/rpc.rs | 79 ++++++++++--------------------- crates/sdk/src/rpc.rs | 36 +++++++------- crates/tests/src/e2e/ibc_tests.rs | 10 ++-- 3 files changed, 45 insertions(+), 80 deletions(-) diff --git a/crates/apps_lib/src/client/rpc.rs b/crates/apps_lib/src/client/rpc.rs index 593bb34a0d..e45b0bb326 100644 --- a/crates/apps_lib/src/client/rpc.rs +++ b/crates/apps_lib/src/client/rpc.rs @@ -2475,59 +2475,30 @@ pub async fn query_ibc_rate_limits( let token_alias = lookup_token_alias(context, &args.token, None).await; let native_token = context.native_token(); - match rpc::query_ibc_rate_limits(context.client(), &args.token).await { - Ok(IbcTokenRateLimits { - mint_limit, - throughput_per_epoch_limit, - }) => { - let (mint_str, throughput_str) = if args.token == native_token { - ( - mint_limit.to_string_native(), - throughput_per_epoch_limit.to_string_native(), - ) - } else { - ( - mint_limit.to_string(), - throughput_per_epoch_limit.to_string(), - ) - }; - display_line!( - context.io(), - "IBC rate limits for token {}:\nGlobal mint limit: \ - {}\nThroughput limit: {} per epoch", - token_alias, - mint_str, - throughput_str - ); - } - Err(_) => { - let IbcParameters { - default_mint_limit, - default_per_epoch_throughput_limit, - } = query_ibc_params(context.client()) - .await - .expect("Error querying the global IBC parameters"); + let IbcTokenRateLimits { + mint_limit, + throughput_per_epoch_limit, + } = unwrap_sdk_result( + rpc::query_ibc_rate_limits(context.client(), &args.token).await, + ); - let (mint_str, throughput_str) = if args.token == native_token { - ( - default_mint_limit.to_string_native(), - default_per_epoch_throughput_limit.to_string_native(), - ) - } else { - ( - default_mint_limit.to_string(), - default_per_epoch_throughput_limit.to_string(), - ) - }; - display_line!( - context.io(), - "Could not find IBC rate limits for token {}, returning \ - default IBC rate limits instead:\nDefault global mint limit: \ - {}\nDefault throughput limit: {} per epoch", - token_alias, - mint_str, - throughput_str - ); - } - } + let (mint_str, throughput_str) = if args.token == native_token { + ( + mint_limit.to_string_native(), + throughput_per_epoch_limit.to_string_native(), + ) + } else { + ( + mint_limit.to_string(), + throughput_per_epoch_limit.to_string(), + ) + }; + display_line!( + context.io(), + "IBC rate limits for token {}:\nGlobal mint limit: {}\nThroughput \ + limit: {} per epoch", + token_alias, + mint_str, + throughput_str + ); } diff --git a/crates/sdk/src/rpc.rs b/crates/sdk/src/rpc.rs index 99f032e202..53aa753b7c 100644 --- a/crates/sdk/src/rpc.rs +++ b/crates/sdk/src/rpc.rs @@ -1908,31 +1908,29 @@ pub async fn query_ibc_rate_limits( ) -> Result { let throughput_limit = query_storage_value::<_, Amount>(client, &throughput_limit_key(token)) - .await; + .await + .ok(); let mint_limit = - query_storage_value::<_, Amount>(client, &mint_limit_key(token)).await; + query_storage_value::<_, Amount>(client, &mint_limit_key(token)) + .await + .ok(); - match (mint_limit, throughput_limit) { - (Ok(mint_limit), Ok(throughput_per_epoch_limit)) => { - Ok(IbcTokenRateLimits { + Ok(match (mint_limit, throughput_limit) { + (Some(mint_limit), Some(throughput_per_epoch_limit)) => { + IbcTokenRateLimits { mint_limit, throughput_per_epoch_limit, - }) + } } - (Ok(_mint_limit), Err(_)) => Err(QueryError::NoSuchKey( - throughput_limit_key(token).to_string(), - ) - .into()), - (Err(_), Ok(_throughput_limit)) => { - Err(QueryError::NoSuchKey(mint_limit_key(token).to_string()).into()) + _ => { + let params = query_ibc_params(client).await?; + IbcTokenRateLimits { + mint_limit: mint_limit.unwrap_or(params.default_mint_limit), + throughput_per_epoch_limit: throughput_limit + .unwrap_or(params.default_per_epoch_throughput_limit), + } } - _ => Err(QueryError::General(format!( - "Error querying IBC rate limits for the token {} - no rate limits \ - found", - token - )) - .into()), - } + }) } /// Query the global IBC parameters diff --git a/crates/tests/src/e2e/ibc_tests.rs b/crates/tests/src/e2e/ibc_tests.rs index 7cf3f36d23..bf51ccb3f4 100644 --- a/crates/tests/src/e2e/ibc_tests.rs +++ b/crates/tests/src/e2e/ibc_tests.rs @@ -1127,16 +1127,12 @@ fn ibc_rate_limit() -> Result<()> { vec!["query-ibc-rate-limits", "--token", token, "--node", &rpc]; let mut client = run!(test, Bin::Client, tx_args, Some(40))?; client.exp_string(&format!( - "Could not find IBC rate limits for token {}, returning default \ - IBC rate limits instead:", + "IBC rate limits for token {}:", token_alias ))?; + client.exp_string(&format!("Global mint limit: {}", mint_limit))?; client.exp_string(&format!( - "Default global mint limit: {}", - mint_limit - ))?; - client.exp_string(&format!( - "Default throughput limit: {} per epoch", + "Throughput limit: {} per epoch", rate_limit ))?; client.assert_success(); From 8f01af3c086c0feb877f8848b4f944312675373e Mon Sep 17 00:00:00 2001 From: Marco Granelli Date: Fri, 17 Jan 2025 19:52:54 +0100 Subject: [PATCH 09/11] Changelog #4246 --- .../unreleased/improvements/4246-query-ibc-rate-limits.md | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 .changelog/unreleased/improvements/4246-query-ibc-rate-limits.md diff --git a/.changelog/unreleased/improvements/4246-query-ibc-rate-limits.md b/.changelog/unreleased/improvements/4246-query-ibc-rate-limits.md new file mode 100644 index 0000000000..2fe7eb9c8f --- /dev/null +++ b/.changelog/unreleased/improvements/4246-query-ibc-rate-limits.md @@ -0,0 +1,2 @@ +- Added the possibility to query the IBC rate limit of a specified token. + ([\#4246](https://github.com/anoma/namada/pull/4246)) \ No newline at end of file From 96d24aa1d8d3cf13de91ab831af06491d21f62ab Mon Sep 17 00:00:00 2001 From: brentstone Date: Thu, 23 Jan 2025 00:43:43 +0900 Subject: [PATCH 10/11] optimize Ibc params struct definitions --- crates/apps_lib/src/client/rpc.rs | 16 +++++++--------- crates/apps_lib/src/config/genesis/chain.rs | 8 +++++--- crates/ibc/src/parameters.rs | 14 ++++++-------- crates/ibc/src/storage.rs | 7 ++++--- crates/ibc/src/vp/mod.rs | 8 +++++--- crates/sdk/src/rpc.rs | 8 +++++--- 6 files changed, 32 insertions(+), 29 deletions(-) diff --git a/crates/apps_lib/src/client/rpc.rs b/crates/apps_lib/src/client/rpc.rs index e45b0bb326..22e1cafd62 100644 --- a/crates/apps_lib/src/client/rpc.rs +++ b/crates/apps_lib/src/client/rpc.rs @@ -1092,22 +1092,20 @@ pub async fn query_protocol_parameters( display_line!(context.io(), "\nIBC parameters"); let IbcParameters { - default_mint_limit, - default_per_epoch_throughput_limit, + default_rate_limits: + IbcTokenRateLimits { + mint_limit, + throughput_per_epoch_limit, + }, } = query_ibc_params(context.client()) .await .expect("Failed to query the IBC parameters"); - display_line!( - context.io(), - "{:4}Default mint limit: {}", - "", - default_mint_limit - ); + display_line!(context.io(), "{:4}Default mint limit: {}", "", mint_limit); display_line!( context.io(), "{:4}Default per epoch throughput limit: {}", "", - default_per_epoch_throughput_limit + throughput_per_epoch_limit ); } diff --git a/crates/apps_lib/src/config/genesis/chain.rs b/crates/apps_lib/src/config/genesis/chain.rs index c1f2002f8d..b24ae82f43 100644 --- a/crates/apps_lib/src/config/genesis/chain.rs +++ b/crates/apps_lib/src/config/genesis/chain.rs @@ -14,7 +14,7 @@ use namada_sdk::chain::{ChainId, ChainIdPrefix}; use namada_sdk::eth_bridge::EthereumBridgeParams; use namada_sdk::governance::pgf::parameters::PgfParameters; use namada_sdk::hash::Hash; -use namada_sdk::ibc::parameters::IbcParameters; +use namada_sdk::ibc::parameters::{IbcParameters, IbcTokenRateLimits}; use namada_sdk::key::{common, RefTo}; use namada_sdk::parameters::EpochDuration; use namada_sdk::time::{DateTimeUtc, DurationNanos, Rfc3339String}; @@ -485,8 +485,10 @@ impl Finalized { default_per_epoch_throughput_limit, } = self.parameters.ibc_params.clone(); IbcParameters { - default_mint_limit, - default_per_epoch_throughput_limit, + default_rate_limits: IbcTokenRateLimits { + mint_limit: default_mint_limit, + throughput_per_epoch_limit: default_per_epoch_throughput_limit, + }, } } diff --git a/crates/ibc/src/parameters.rs b/crates/ibc/src/parameters.rs index 2e22f5b3c5..22f342df5e 100644 --- a/crates/ibc/src/parameters.rs +++ b/crates/ibc/src/parameters.rs @@ -4,13 +4,11 @@ use namada_core::borsh::{BorshDeserialize, BorshSerialize}; use namada_core::token::Amount; use namada_state::{Result, StorageWrite}; -#[derive(Clone, Debug, BorshSerialize, BorshDeserialize)] +#[derive(Clone, Debug, Default, BorshSerialize, BorshDeserialize)] /// Governance parameter structure pub struct IbcParameters { - /// Default supply limit of each token - pub default_mint_limit: Amount, - /// Default per-epoch throughput limit of each token - pub default_per_epoch_throughput_limit: Amount, + /// Default rate limits for IBC tokens + pub default_rate_limits: IbcTokenRateLimits, } #[derive(Clone, Debug, BorshSerialize, BorshDeserialize)] @@ -22,11 +20,11 @@ pub struct IbcTokenRateLimits { pub throughput_per_epoch_limit: Amount, } -impl Default for IbcParameters { +impl Default for IbcTokenRateLimits { fn default() -> Self { Self { - default_mint_limit: Amount::zero(), - default_per_epoch_throughput_limit: Amount::zero(), + mint_limit: Amount::zero(), + throughput_per_epoch_limit: Amount::zero(), } } } diff --git a/crates/ibc/src/storage.rs b/crates/ibc/src/storage.rs index 37754320ce..2392111af5 100644 --- a/crates/ibc/src/storage.rs +++ b/crates/ibc/src/storage.rs @@ -591,9 +591,10 @@ pub fn get_limits( .read(¶ms_key())? .expect("Parameters should be stored"); ( - mint_limit.unwrap_or(params.default_mint_limit), - throughput_limit - .unwrap_or(params.default_per_epoch_throughput_limit), + mint_limit.unwrap_or(params.default_rate_limits.mint_limit), + throughput_limit.unwrap_or( + params.default_rate_limits.throughput_per_epoch_limit, + ), ) } }) diff --git a/crates/ibc/src/vp/mod.rs b/crates/ibc/src/vp/mod.rs index 410fd75f83..df59ded878 100644 --- a/crates/ibc/src/vp/mod.rs +++ b/crates/ibc/src/vp/mod.rs @@ -563,7 +563,7 @@ mod tests { }; use crate::core::router::types::event::ModuleEvent; use crate::event::IbcEventType; - use crate::parameters::IbcParameters; + use crate::parameters::{IbcParameters, IbcTokenRateLimits}; use crate::primitives::proto::{Any, Protobuf}; use crate::primitives::{Timestamp, ToProto}; use crate::storage::{ @@ -630,8 +630,10 @@ mod tests { let gov_params = GovernanceParameters::default(); gov_params.init_storage(&mut state).unwrap(); let ibc_params = IbcParameters { - default_mint_limit: Amount::native_whole(100), - default_per_epoch_throughput_limit: Amount::native_whole(100), + default_rate_limits: IbcTokenRateLimits { + mint_limit: Amount::native_whole(100), + throughput_per_epoch_limit: Amount::native_whole(100), + }, }; ibc_params.init_storage(&mut state).unwrap(); namada_proof_of_stake::test_utils::test_init_genesis::< diff --git a/crates/sdk/src/rpc.rs b/crates/sdk/src/rpc.rs index 53aa753b7c..362048a564 100644 --- a/crates/sdk/src/rpc.rs +++ b/crates/sdk/src/rpc.rs @@ -1925,9 +1925,11 @@ pub async fn query_ibc_rate_limits( _ => { let params = query_ibc_params(client).await?; IbcTokenRateLimits { - mint_limit: mint_limit.unwrap_or(params.default_mint_limit), - throughput_per_epoch_limit: throughput_limit - .unwrap_or(params.default_per_epoch_throughput_limit), + mint_limit: mint_limit + .unwrap_or(params.default_rate_limits.mint_limit), + throughput_per_epoch_limit: throughput_limit.unwrap_or( + params.default_rate_limits.throughput_per_epoch_limit, + ), } } }) From 3859e51b136f2fd5b631a5abe0fe2203d6e4da5e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Zemanovi=C4=8D?= Date: Wed, 22 Jan 2025 17:31:43 +0000 Subject: [PATCH 11/11] test: update IBC init storage --- crates/tests/src/vm_host_env/ibc.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/crates/tests/src/vm_host_env/ibc.rs b/crates/tests/src/vm_host_env/ibc.rs index 69d18a45df..0d32f4a0fe 100644 --- a/crates/tests/src/vm_host_env/ibc.rs +++ b/crates/tests/src/vm_host_env/ibc.rs @@ -52,7 +52,7 @@ use namada_sdk::ibc::core::connection::types::{ pub use namada_sdk::ibc::core::host::types::identifiers::{ ChannelId, ClientId, ConnectionId, PortId, Sequence, }; -use namada_sdk::ibc::parameters::IbcParameters; +use namada_sdk::ibc::parameters::{IbcParameters, IbcTokenRateLimits}; use namada_sdk::ibc::primitives::proto::{Any, Protobuf}; use namada_sdk::ibc::primitives::Timestamp; pub use namada_sdk::ibc::storage::{ @@ -189,10 +189,10 @@ pub fn init_storage() -> (Address, Address) { let gov_params = GovernanceParameters::default(); gov_params.init_storage(&mut env.state).unwrap(); let ibc_params = IbcParameters { - default_mint_limit: token::Amount::native_whole(100), - default_per_epoch_throughput_limit: token::Amount::native_whole( - 100, - ), + default_rate_limits: IbcTokenRateLimits { + mint_limit: token::Amount::native_whole(100), + throughput_per_epoch_limit: token::Amount::native_whole(100), + }, }; ibc_params.init_storage(&mut env.state).unwrap();