From b46a51008ff5adf3b7384aba77a28850835cd0c5 Mon Sep 17 00:00:00 2001 From: Svyatoslav Nikolsky Date: Fri, 4 Mar 2022 15:41:31 +0300 Subject: [PATCH 1/5] ignore errors when dumping logs and container is missing --- scripts/dump-logs.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) mode change 100644 => 100755 scripts/dump-logs.sh diff --git a/scripts/dump-logs.sh b/scripts/dump-logs.sh old mode 100644 new mode 100755 index 02aa4af2f7..e5a3a403ad --- a/scripts/dump-logs.sh +++ b/scripts/dump-logs.sh @@ -28,7 +28,7 @@ SERVICES=(\ for SVC in ${SERVICES[*]} do SHORT_NAME="${SVC//deployments_/}" - docker logs $SVC &> $SHORT_NAME.log + docker logs $SVC &> $SHORT_NAME.log | true done cd - From 654ce5fbcafdd60c952bd189860ad6d60911117a Mon Sep 17 00:00:00 2001 From: Svyatoslav Nikolsky Date: Fri, 4 Mar 2022 15:41:41 +0300 Subject: [PATCH 2/5] fixed typo --- relays/bin-substrate/src/cli/swap_tokens.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/relays/bin-substrate/src/cli/swap_tokens.rs b/relays/bin-substrate/src/cli/swap_tokens.rs index 625e3197f8..0758deddfd 100644 --- a/relays/bin-substrate/src/cli/swap_tokens.rs +++ b/relays/bin-substrate/src/cli/swap_tokens.rs @@ -363,7 +363,7 @@ impl SwapTokens { // if is_transfer_succeeded { - log::info!(target: "bridge", "Claiming the swap swap"); + log::info!(target: "bridge", "Claiming the swap"); // prepare `claim_swap` message that will be sent over the bridge let claim_swap_call: CallOf = From 813de4fa5a22716d654f5a7216a7ca47f6924ad3 Mon Sep 17 00:00:00 2001 From: Svyatoslav Nikolsky Date: Fri, 4 Mar 2022 15:42:01 +0300 Subject: [PATCH 3/5] print correct payload length --- relays/bin-substrate/src/cli/send_message.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/relays/bin-substrate/src/cli/send_message.rs b/relays/bin-substrate/src/cli/send_message.rs index b1f9ac7a42..ddb1ff59b5 100644 --- a/relays/bin-substrate/src/cli/send_message.rs +++ b/relays/bin-substrate/src/cli/send_message.rs @@ -190,6 +190,7 @@ impl SendMessage { ), }; let dispatch_weight = payload.weight; + let payload_len = payload.encode().len(); let send_message_call = Source::encode_call(&encode_call::Call::BridgeSendMessage { bridge_instance_index: self.bridge.bridge_instance_index(), lane: self.lane, @@ -230,7 +231,7 @@ impl SendMessage { "Sending message to {}. Lane: {:?}. Size: {}. Dispatch weight: {}. Fee: {}", Target::NAME, lane, - signed_source_call.len(), + payload_len, dispatch_weight, fee, ); From 1362d7aa9470e21f8e1b7b0ab76be1833931cec8 Mon Sep 17 00:00:00 2001 From: Svyatoslav Nikolsky Date: Fri, 4 Mar 2022 15:42:56 +0300 Subject: [PATCH 4/5] increase conversion rate a bit when estimating fee (to avoid message rejects when rate update tx is active) --- relays/bin-substrate/src/cli/estimate_fee.rs | 83 +++++++++++++------ .../src/cli/relay_headers_and_messages.rs | 2 +- 2 files changed, 60 insertions(+), 25 deletions(-) diff --git a/relays/bin-substrate/src/cli/estimate_fee.rs b/relays/bin-substrate/src/cli/estimate_fee.rs index 1f3e560fc0..cdba2d6efe 100644 --- a/relays/bin-substrate/src/cli/estimate_fee.rs +++ b/relays/bin-substrate/src/cli/estimate_fee.rs @@ -15,7 +15,11 @@ // along with Parity Bridges Common. If not, see . use crate::{ - cli::{bridge::FullBridge, Balance, CliChain, HexBytes, HexLaneId, SourceConnectionParams}, + cli::{ + bridge::FullBridge, + relay_headers_and_messages::CONVERSION_RATE_ALLOWED_DIFFERENCE_RATIO, + Balance, CliChain, HexBytes, HexLaneId, SourceConnectionParams, + }, select_full_bridge, }; use bp_runtime::BalanceOf; @@ -123,37 +127,68 @@ pub(crate) async fn estimate_message_delivery_and_dispatch_fee< ) { (Some(ConversionRateOverride::Explicit(v)), _, _) => { let conversion_rate_override = FixedU128::from_float(v); - log::info!(target: "bridge", "{} -> {} conversion rate override: {:?} (explicit)", Target::NAME, Source::NAME, conversion_rate_override.to_float()); + log::info!( + target: "bridge", + "{} -> {} conversion rate override: {:?} (explicit)", + Target::NAME, + Source::NAME, + conversion_rate_override.to_float(), + ); Some(conversion_rate_override) }, (Some(ConversionRateOverride::Metric), Some(source_token_id), Some(target_token_id)) => { - let conversion_rate_override = FixedU128::from_float( - tokens_conversion_rate_from_metrics(target_token_id, source_token_id).await?, + let conversion_rate_override = tokens_conversion_rate_from_metrics(target_token_id, source_token_id).await?; + // So we have current actual conversion rate and rate that is stored in the runtime. + // And we may simply choose the maximal of these. But what if right now there's + // rate update transaction on the way, that is updating rate to 10 seconds old actual + // rate, which is bigger than the current rate? Then our message will be rejected. + // + // So let's increase the actual rate by the same value that the conversion rate updater + // is using. + let increased_conversion_rate_override = FixedU128::from_float( + conversion_rate_override * (1.0 + CONVERSION_RATE_ALLOWED_DIFFERENCE_RATIO) ); - log::info!(target: "bridge", "{} -> {} conversion rate override: {:?} (from metric)", Target::NAME, Source::NAME, conversion_rate_override.to_float()); - Some(conversion_rate_override) + log::info!( + target: "bridge", + "{} -> {} conversion rate override: {} (value from metric - {})", + Target::NAME, + Source::NAME, + increased_conversion_rate_override.to_float(), + conversion_rate_override, + ); + Some(increased_conversion_rate_override) }, _ => None, }; - Ok(std::cmp::max( - do_estimate_message_delivery_and_dispatch_fee( - client, - estimate_fee_method, - lane, - payload.clone(), - None, - ) - .await?, - do_estimate_message_delivery_and_dispatch_fee( - client, - estimate_fee_method, - lane, - payload.clone(), - conversion_rate_override, - ) - .await?, - )) + let without_override = do_estimate_message_delivery_and_dispatch_fee( + client, + estimate_fee_method, + lane, + payload.clone(), + None, + ) + .await?; + let with_override = do_estimate_message_delivery_and_dispatch_fee( + client, + estimate_fee_method, + lane, + payload.clone(), + conversion_rate_override, + ) + .await?; + let maximal_fee = std::cmp::max(without_override, with_override); + + log::info!( + target: "bridge", + "Estimated message fee: {:?} = max of {:?} (without rate override) and {:?} (with override to {:?})", + maximal_fee, + without_override, + with_override, + conversion_rate_override, + ); + + Ok(maximal_fee) } /// Estimate message delivery and dispatch fee with given conversion rate override. diff --git a/relays/bin-substrate/src/cli/relay_headers_and_messages.rs b/relays/bin-substrate/src/cli/relay_headers_and_messages.rs index 86b6da3977..9f19d82bdd 100644 --- a/relays/bin-substrate/src/cli/relay_headers_and_messages.rs +++ b/relays/bin-substrate/src/cli/relay_headers_and_messages.rs @@ -50,7 +50,7 @@ use crate::{ /// stored and real conversion rates. If it is large enough (e.g. > than 10 percents, which is 0.1), /// then rational relayers may stop relaying messages because they were submitted using /// lesser conversion rate. -const CONVERSION_RATE_ALLOWED_DIFFERENCE_RATIO: f64 = 0.05; +pub(crate) const CONVERSION_RATE_ALLOWED_DIFFERENCE_RATIO: f64 = 0.05; /// Start headers+messages relayer process. #[derive(StructOpt)] From 2afb2d38d5da1ab21d27874e82ab149e2b1737c5 Mon Sep 17 00:00:00 2001 From: Svyatoslav Nikolsky Date: Fri, 4 Mar 2022 15:44:34 +0300 Subject: [PATCH 5/5] fmt --- relays/bin-substrate/src/cli/estimate_fee.rs | 86 ++++++++++---------- 1 file changed, 44 insertions(+), 42 deletions(-) diff --git a/relays/bin-substrate/src/cli/estimate_fee.rs b/relays/bin-substrate/src/cli/estimate_fee.rs index cdba2d6efe..bab625314e 100644 --- a/relays/bin-substrate/src/cli/estimate_fee.rs +++ b/relays/bin-substrate/src/cli/estimate_fee.rs @@ -16,8 +16,7 @@ use crate::{ cli::{ - bridge::FullBridge, - relay_headers_and_messages::CONVERSION_RATE_ALLOWED_DIFFERENCE_RATIO, + bridge::FullBridge, relay_headers_and_messages::CONVERSION_RATE_ALLOWED_DIFFERENCE_RATIO, Balance, CliChain, HexBytes, HexLaneId, SourceConnectionParams, }, select_full_bridge, @@ -120,46 +119,49 @@ pub(crate) async fn estimate_message_delivery_and_dispatch_fee< // lane. So we MUST use the larger of two fees - one computed with stored fee and the one // computed with actual fee. - let conversion_rate_override = match ( - conversion_rate_override, - Source::TOKEN_ID, - Target::TOKEN_ID, - ) { - (Some(ConversionRateOverride::Explicit(v)), _, _) => { - let conversion_rate_override = FixedU128::from_float(v); - log::info!( - target: "bridge", - "{} -> {} conversion rate override: {:?} (explicit)", - Target::NAME, - Source::NAME, - conversion_rate_override.to_float(), - ); - Some(conversion_rate_override) - }, - (Some(ConversionRateOverride::Metric), Some(source_token_id), Some(target_token_id)) => { - let conversion_rate_override = tokens_conversion_rate_from_metrics(target_token_id, source_token_id).await?; - // So we have current actual conversion rate and rate that is stored in the runtime. - // And we may simply choose the maximal of these. But what if right now there's - // rate update transaction on the way, that is updating rate to 10 seconds old actual - // rate, which is bigger than the current rate? Then our message will be rejected. - // - // So let's increase the actual rate by the same value that the conversion rate updater - // is using. - let increased_conversion_rate_override = FixedU128::from_float( - conversion_rate_override * (1.0 + CONVERSION_RATE_ALLOWED_DIFFERENCE_RATIO) - ); - log::info!( - target: "bridge", - "{} -> {} conversion rate override: {} (value from metric - {})", - Target::NAME, - Source::NAME, - increased_conversion_rate_override.to_float(), - conversion_rate_override, - ); - Some(increased_conversion_rate_override) - }, - _ => None, - }; + let conversion_rate_override = + match (conversion_rate_override, Source::TOKEN_ID, Target::TOKEN_ID) { + (Some(ConversionRateOverride::Explicit(v)), _, _) => { + let conversion_rate_override = FixedU128::from_float(v); + log::info!( + target: "bridge", + "{} -> {} conversion rate override: {:?} (explicit)", + Target::NAME, + Source::NAME, + conversion_rate_override.to_float(), + ); + Some(conversion_rate_override) + }, + ( + Some(ConversionRateOverride::Metric), + Some(source_token_id), + Some(target_token_id), + ) => { + let conversion_rate_override = + tokens_conversion_rate_from_metrics(target_token_id, source_token_id).await?; + // So we have current actual conversion rate and rate that is stored in the runtime. + // And we may simply choose the maximal of these. But what if right now there's + // rate update transaction on the way, that is updating rate to 10 seconds old + // actual rate, which is bigger than the current rate? Then our message will be + // rejected. + // + // So let's increase the actual rate by the same value that the conversion rate + // updater is using. + let increased_conversion_rate_override = FixedU128::from_float( + conversion_rate_override * (1.0 + CONVERSION_RATE_ALLOWED_DIFFERENCE_RATIO), + ); + log::info!( + target: "bridge", + "{} -> {} conversion rate override: {} (value from metric - {})", + Target::NAME, + Source::NAME, + increased_conversion_rate_override.to_float(), + conversion_rate_override, + ); + Some(increased_conversion_rate_override) + }, + _ => None, + }; let without_override = do_estimate_message_delivery_and_dispatch_fee( client,