From 93431210f4e759759eb0638376bfdc36f9b92417 Mon Sep 17 00:00:00 2001 From: bear Date: Wed, 14 Sep 2022 14:47:50 +0800 Subject: [PATCH 1/3] Companion for parity-briddges-common/1379 --- modules/messages/src/instant_payments.rs | 350 ----------------------- modules/messages/src/lib.rs | 1 - 2 files changed, 351 deletions(-) delete mode 100644 modules/messages/src/instant_payments.rs diff --git a/modules/messages/src/instant_payments.rs b/modules/messages/src/instant_payments.rs deleted file mode 100644 index fca54dfd1..000000000 --- a/modules/messages/src/instant_payments.rs +++ /dev/null @@ -1,350 +0,0 @@ -// Copyright 2019-2021 Parity Technologies (UK) Ltd. -// This file is part of Parity Bridges Common. - -// Parity Bridges Common is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// Parity Bridges Common is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with Parity Bridges Common. If not, see . - -//! Implementation of `MessageDeliveryAndDispatchPayment` trait on top of `Currency` trait. -//! -//! The payment is first transferred to a special `relayers-fund` account and only transferred -//! to the actual relayer in case confirmation is received. - -use crate::OutboundMessages; - -use bp_messages::{ - source_chain::{MessageDeliveryAndDispatchPayment, RelayersRewards, SenderOrigin}, - LaneId, MessageKey, MessageNonce, UnrewardedRelayer, -}; -use codec::Encode; -use frame_support::traits::{Currency as CurrencyT, ExistenceRequirement, Get}; -use num_traits::{SaturatingAdd, Zero}; -use sp_runtime::traits::Saturating; -use sp_std::{collections::vec_deque::VecDeque, fmt::Debug, ops::RangeInclusive}; - -/// Error that occurs when message fee is non-zero, but payer is not defined. -const NON_ZERO_MESSAGE_FEE_CANT_BE_PAID_BY_NONE: &str = - "Non-zero message fee can't be paid by "; - -/// Instant message payments made in given currency. -/// -/// The balance is initially reserved in a special `relayers-fund` account, and transferred -/// to the relayer when message delivery is confirmed. -/// -/// Additionally, confirmation transaction submitter (`confirmation_relayer`) is reimbursed -/// with the confirmation rewards (part of message fee, reserved to pay for delivery confirmation). -/// -/// NOTE The `relayers-fund` account must always exist i.e. be over Existential Deposit (ED; the -/// pallet enforces that) to make sure that even if the message cost is below ED it is still paid -/// to the relayer account. -/// NOTE It's within relayer's interest to keep their balance above ED as well, to make sure they -/// can receive the payment. -pub struct InstantCurrencyPayments { - _phantom: sp_std::marker::PhantomData<(T, I, Currency, GetConfirmationFee)>, -} - -impl - MessageDeliveryAndDispatchPayment - for InstantCurrencyPayments -where - T: frame_system::Config + crate::Config, - I: 'static, - T::Origin: SenderOrigin, - Currency: CurrencyT, - Currency::Balance: From, - GetConfirmationFee: Get, -{ - type Error = &'static str; - - fn pay_delivery_and_dispatch_fee( - submitter: &T::Origin, - fee: &Currency::Balance, - relayer_fund_account: &T::AccountId, - ) -> Result<(), Self::Error> { - let submitter_account = match submitter.linked_account() { - Some(submitter_account) => submitter_account, - None if !fee.is_zero() => { - // if we'll accept some message that has declared that the `fee` has been paid but - // it isn't actually paid, then it'll lead to problems with delivery confirmation - // payments (see `pay_relayer_rewards` && `confirmation_relayer` in particular) - return Err(NON_ZERO_MESSAGE_FEE_CANT_BE_PAID_BY_NONE); - }, - None => { - // message lane verifier has accepted the message before, so this message - // is unpaid **by design** - // => let's just do nothing - return Ok(()); - }, - }; - - if !frame_system::Pallet::::account_exists(relayer_fund_account) { - return Err("The relayer fund account must exist for the message lanes pallet to work correctly."); - } - - Currency::transfer( - &submitter_account, - relayer_fund_account, - *fee, - // it's fine for the submitter to go below Existential Deposit and die. - ExistenceRequirement::AllowDeath, - ) - .map_err(Into::into) - } - - fn pay_relayers_rewards( - lane_id: LaneId, - messages_relayers: VecDeque>, - confirmation_relayer: &T::AccountId, - received_range: &RangeInclusive, - relayer_fund_account: &T::AccountId, - ) { - let relayers_rewards = - cal_relayers_rewards::(lane_id, messages_relayers, received_range); - if !relayers_rewards.is_empty() { - pay_relayers_rewards::( - confirmation_relayer, - relayers_rewards, - relayer_fund_account, - GetConfirmationFee::get(), - ); - } - } -} - -/// Calculate the relayers rewards -pub(crate) fn cal_relayers_rewards( - lane_id: LaneId, - messages_relayers: VecDeque>, - received_range: &RangeInclusive, -) -> RelayersRewards -where - T: frame_system::Config + crate::Config, - I: 'static, -{ - // remember to reward relayers that have delivered messages - // this loop is bounded by `T::MaxUnrewardedRelayerEntriesAtInboundLane` on the bridged chain - let mut relayers_rewards: RelayersRewards<_, T::OutboundMessageFee> = RelayersRewards::new(); - for entry in messages_relayers { - let nonce_begin = sp_std::cmp::max(entry.messages.begin, *received_range.start()); - let nonce_end = sp_std::cmp::min(entry.messages.end, *received_range.end()); - - // loop won't proceed if current entry is ahead of received range (begin > end). - // this loop is bound by `T::MaxUnconfirmedMessagesAtInboundLane` on the bridged chain - let mut relayer_reward = relayers_rewards.entry(entry.relayer).or_default(); - for nonce in nonce_begin..nonce_end + 1 { - let message_data = OutboundMessages::::get(MessageKey { lane_id, nonce }) - .expect("message was just confirmed; we never prune unconfirmed messages; qed"); - relayer_reward.reward = relayer_reward.reward.saturating_add(&message_data.fee); - relayer_reward.messages += 1; - } - } - relayers_rewards -} - -/// Pay rewards to given relayers, optionally rewarding confirmation relayer. -fn pay_relayers_rewards( - confirmation_relayer: &AccountId, - relayers_rewards: RelayersRewards, - relayer_fund_account: &AccountId, - confirmation_fee: Currency::Balance, -) where - AccountId: Debug + Encode + PartialEq, - Currency: CurrencyT, - Currency::Balance: From, -{ - // reward every relayer except `confirmation_relayer` - let mut confirmation_relayer_reward = Currency::Balance::zero(); - for (relayer, reward) in relayers_rewards { - let mut relayer_reward = reward.reward; - - if relayer != *confirmation_relayer { - // If delivery confirmation is submitted by other relayer, let's deduct confirmation fee - // from relayer reward. - // - // If confirmation fee has been increased (or if it was the only component of message - // fee), then messages relayer may receive zero reward. - let mut confirmation_reward = confirmation_fee.saturating_mul(reward.messages.into()); - if confirmation_reward > relayer_reward { - confirmation_reward = relayer_reward; - } - relayer_reward = relayer_reward.saturating_sub(confirmation_reward); - confirmation_relayer_reward = - confirmation_relayer_reward.saturating_add(confirmation_reward); - } else { - // If delivery confirmation is submitted by this relayer, let's add confirmation fee - // from other relayers to this relayer reward. - confirmation_relayer_reward = confirmation_relayer_reward.saturating_add(reward.reward); - continue; - } - - pay_relayer_reward::(relayer_fund_account, &relayer, relayer_reward); - } - - // finally - pay reward to confirmation relayer - pay_relayer_reward::( - relayer_fund_account, - confirmation_relayer, - confirmation_relayer_reward, - ); -} - -/// Transfer funds from relayers fund account to given relayer. -fn pay_relayer_reward( - relayer_fund_account: &AccountId, - relayer_account: &AccountId, - reward: Currency::Balance, -) where - AccountId: Debug, - Currency: CurrencyT, -{ - if reward.is_zero() { - return; - } - - let pay_result = Currency::transfer( - relayer_fund_account, - relayer_account, - reward, - // the relayer fund account must stay above ED (needs to be pre-funded) - ExistenceRequirement::KeepAlive, - ); - - match pay_result { - Ok(_) => log::trace!( - target: "runtime::bridge-messages", - "Rewarded relayer {:?} with {:?}", - relayer_account, - reward, - ), - Err(error) => log::trace!( - target: "runtime::bridge-messages", - "Failed to pay relayer {:?} reward {:?}: {:?}", - relayer_account, - reward, - error, - ), - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::mock::{ - run_test, AccountId as TestAccountId, Balance as TestBalance, Origin, TestRuntime, - }; - use bp_messages::source_chain::RelayerRewards; - - type Balances = pallet_balances::Pallet; - - const RELAYER_1: TestAccountId = 1; - const RELAYER_2: TestAccountId = 2; - const RELAYER_3: TestAccountId = 3; - const RELAYERS_FUND_ACCOUNT: TestAccountId = crate::mock::ENDOWED_ACCOUNT; - - fn relayers_rewards() -> RelayersRewards { - vec![ - (RELAYER_1, RelayerRewards { reward: 100, messages: 2 }), - (RELAYER_2, RelayerRewards { reward: 100, messages: 3 }), - ] - .into_iter() - .collect() - } - - #[test] - fn pay_delivery_and_dispatch_fee_fails_on_non_zero_fee_and_unknown_payer() { - frame_support::parameter_types! { - const GetConfirmationFee: TestBalance = 0; - }; - - run_test(|| { - let result = InstantCurrencyPayments::< - TestRuntime, - (), - Balances, - GetConfirmationFee, - >::pay_delivery_and_dispatch_fee( - &Origin::root(), - &100, - &RELAYERS_FUND_ACCOUNT, - ); - assert_eq!(result, Err(NON_ZERO_MESSAGE_FEE_CANT_BE_PAID_BY_NONE)); - }); - } - - #[test] - fn pay_delivery_and_dispatch_succeeds_on_zero_fee_and_unknown_payer() { - frame_support::parameter_types! { - const GetConfirmationFee: TestBalance = 0; - }; - - run_test(|| { - let result = InstantCurrencyPayments::< - TestRuntime, - (), - Balances, - GetConfirmationFee, - >::pay_delivery_and_dispatch_fee( - &Origin::root(), - &0, - &RELAYERS_FUND_ACCOUNT, - ); - assert!(result.is_ok()); - }); - } - - #[test] - fn confirmation_relayer_is_rewarded_if_it_has_also_delivered_messages() { - run_test(|| { - pay_relayers_rewards::( - &RELAYER_2, - relayers_rewards(), - &RELAYERS_FUND_ACCOUNT, - 10, - ); - - assert_eq!(Balances::free_balance(&RELAYER_1), 80); - assert_eq!(Balances::free_balance(&RELAYER_2), 120); - }); - } - - #[test] - fn confirmation_relayer_is_rewarded_if_it_has_not_delivered_any_delivered_messages() { - run_test(|| { - pay_relayers_rewards::( - &RELAYER_3, - relayers_rewards(), - &RELAYERS_FUND_ACCOUNT, - 10, - ); - - assert_eq!(Balances::free_balance(&RELAYER_1), 80); - assert_eq!(Balances::free_balance(&RELAYER_2), 70); - assert_eq!(Balances::free_balance(&RELAYER_3), 50); - }); - } - - #[test] - fn only_confirmation_relayer_is_rewarded_if_confirmation_fee_has_significantly_increased() { - run_test(|| { - pay_relayers_rewards::( - &RELAYER_3, - relayers_rewards(), - &RELAYERS_FUND_ACCOUNT, - 1000, - ); - - assert_eq!(Balances::free_balance(&RELAYER_1), 0); - assert_eq!(Balances::free_balance(&RELAYER_2), 0); - assert_eq!(Balances::free_balance(&RELAYER_3), 200); - }); - } -} diff --git a/modules/messages/src/lib.rs b/modules/messages/src/lib.rs index 418f62bed..939554bf1 100644 --- a/modules/messages/src/lib.rs +++ b/modules/messages/src/lib.rs @@ -82,7 +82,6 @@ mod inbound_lane; mod outbound_lane; mod weights_ext; -pub mod instant_payments; pub mod weights; #[cfg(feature = "runtime-benchmarks")] From 771d2849eb06d2033a44dfe644858b3218dae3dd Mon Sep 17 00:00:00 2001 From: bear Date: Wed, 14 Sep 2022 16:14:04 +0800 Subject: [PATCH 2/3] Remove unused mod --- bin/runtime-common/src/lib.rs | 3 --- 1 file changed, 3 deletions(-) diff --git a/bin/runtime-common/src/lib.rs b/bin/runtime-common/src/lib.rs index 6659825cb..9f77a6155 100644 --- a/bin/runtime-common/src/lib.rs +++ b/bin/runtime-common/src/lib.rs @@ -26,9 +26,6 @@ pub mod messages_benchmarking; pub mod messages_extension; pub mod parachains_benchmarking; -#[cfg(feature = "integrity-test")] -pub mod integrity; - /// A duplication of the `FilterCall` trait. /// /// We need this trait in order to be able to implement it for the messages pallet, From 94c75f3024b7b8703b0cbf7df1497982a3eec5d2 Mon Sep 17 00:00:00 2001 From: bear Date: Wed, 14 Sep 2022 16:15:39 +0800 Subject: [PATCH 3/3] Format --- bin/runtime-common/src/lib.rs | 6 ++--- bin/runtime-common/src/messages.rs | 15 ++++++----- bin/runtime-common/src/messages_extension.rs | 6 ++--- modules/fee-market/src/tests.rs | 2 +- modules/grandpa/src/extension.rs | 2 +- modules/grandpa/src/lib.rs | 5 ++-- modules/messages/src/lib.rs | 23 +++++++---------- modules/messages/src/mock.rs | 25 +++++++++---------- modules/messages/src/weights.rs | 26 ++++++++++++++++++++ modules/parachains/src/lib.rs | 9 ++++--- modules/parachains/src/mock.rs | 4 +-- modules/parachains/src/weights.rs | 4 +++ modules/parachains/src/weights_ext.rs | 6 ++--- primitives/parachains/src/lib.rs | 6 ++--- primitives/runtime/src/lib.rs | 8 +++--- primitives/runtime/src/storage_proof.rs | 3 +-- 16 files changed, 88 insertions(+), 62 deletions(-) diff --git a/bin/runtime-common/src/lib.rs b/bin/runtime-common/src/lib.rs index 9f77a6155..88e1e6d9c 100644 --- a/bin/runtime-common/src/lib.rs +++ b/bin/runtime-common/src/lib.rs @@ -129,9 +129,9 @@ mod tests { } impl sp_runtime::traits::Dispatchable for MockCall { - type Origin = (); type Config = (); type Info = (); + type Origin = (); type PostInfo = (); fn dispatch( @@ -146,7 +146,7 @@ mod tests { impl BridgeRuntimeFilterCall for FirstFilterCall { fn validate(call: &MockCall) -> TransactionValidity { if call.data <= 1 { - return InvalidTransaction::Custom(1).into() + return InvalidTransaction::Custom(1).into(); } Ok(ValidTransaction { priority: 1, ..Default::default() }) @@ -157,7 +157,7 @@ mod tests { impl BridgeRuntimeFilterCall for SecondFilterCall { fn validate(call: &MockCall) -> TransactionValidity { if call.data <= 2 { - return InvalidTransaction::Custom(2).into() + return InvalidTransaction::Custom(2).into(); } Ok(ValidTransaction { priority: 2, ..Default::default() }) diff --git a/bin/runtime-common/src/messages.rs b/bin/runtime-common/src/messages.rs index 6b5525221..d78e10278 100644 --- a/bin/runtime-common/src/messages.rs +++ b/bin/runtime-common/src/messages.rs @@ -26,21 +26,24 @@ use bp_messages::{ target_chain::{DispatchMessage, MessageDispatch, ProvedLaneMessages, ProvedMessages}, InboundLaneData, LaneId, Message, MessageData, MessageKey, MessageNonce, OutboundLaneData, }; +use bp_polkadot_core::parachains::{ParaHash, ParaHasher, ParaId}; use bp_runtime::{ messages::{DispatchFeePayment, MessageDispatchResult}, ChainId, Size, StorageProofChecker, }; -use bp_polkadot_core::parachains::{ParaHash, ParaHasher, ParaId}; use codec::{Decode, DecodeLimit, Encode, MaxEncodedLen}; -use frame_support::{traits::Get, - traits::{Currency, ExistenceRequirement}, +use frame_support::{ + traits::{Currency, ExistenceRequirement, Get}, weights::{Weight, WeightToFee}, RuntimeDebug, }; use hash_db::Hasher; use scale_info::TypeInfo; use sp_runtime::{ - traits::{AtLeast32BitUnsigned, CheckedAdd, CheckedDiv, CheckedMul, Saturating, Zero, Header as HeaderT}, + traits::{ + AtLeast32BitUnsigned, CheckedAdd, CheckedDiv, CheckedMul, Header as HeaderT, Saturating, + Zero, + }, FixedPointNumber, FixedPointOperand, FixedU128, }; use sp_std::{ @@ -1152,13 +1155,13 @@ mod tests { impl ThisChainWithMessages for ThisChain { type Call = ThisChainCall; - type Origin = ThisChainOrigin; type ConfirmationTransactionEstimation = BasicConfirmationTransactionEstimation< ::AccountId, { DELIVERY_CONFIRMATION_TRANSACTION_WEIGHT }, 0, 0, >; + type Origin = ThisChainOrigin; fn is_message_accepted(_send_origin: &Self::Origin, lane: &LaneId) -> bool { lane == TEST_LANE_ID @@ -1212,13 +1215,13 @@ mod tests { impl ThisChainWithMessages for BridgedChain { type Call = BridgedChainCall; - type Origin = BridgedChainOrigin; type ConfirmationTransactionEstimation = BasicConfirmationTransactionEstimation< ::AccountId, 0, 0, 0, >; + type Origin = BridgedChainOrigin; fn is_message_accepted(_send_origin: &Self::Origin, _lane: &LaneId) -> bool { unreachable!() diff --git a/bin/runtime-common/src/messages_extension.rs b/bin/runtime-common/src/messages_extension.rs index 60237c0fa..c4a97087f 100644 --- a/bin/runtime-common/src/messages_extension.rs +++ b/bin/runtime-common/src/messages_extension.rs @@ -63,7 +63,7 @@ impl< inbound_lane_data.last_delivered_nonce(), ); - return sp_runtime::transaction_validity::InvalidTransaction::Stale.into() + return sp_runtime::transaction_validity::InvalidTransaction::Stale.into(); } }, Some(pallet_bridge_messages::Call::::receive_messages_delivery_proof { @@ -85,7 +85,7 @@ impl< outbound_lane_data.latest_received_nonce, ); - return sp_runtime::transaction_validity::InvalidTransaction::Stale.into() + return sp_runtime::transaction_validity::InvalidTransaction::Stale.into(); } }, _ => {}, @@ -93,4 +93,4 @@ impl< Ok(sp_runtime::transaction_validity::ValidTransaction::default()) } -} \ No newline at end of file +} diff --git a/modules/fee-market/src/tests.rs b/modules/fee-market/src/tests.rs index 8dd83668e..ac79a5040 100644 --- a/modules/fee-market/src/tests.rs +++ b/modules/fee-market/src/tests.rs @@ -424,6 +424,7 @@ impl pallet_bridge_messages::Config for Test { type MaxMessagesToPruneAtOnce = MaxMessagesToPruneAtOnce; type MaxUnconfirmedMessagesAtInboundLane = MaxUnconfirmedMessagesAtInboundLane; type MaxUnrewardedRelayerEntriesAtInboundLane = MaxUnrewardedRelayerEntriesAtInboundLane; + type MaximalOutboundPayloadSize = frame_support::traits::ConstU32; type MessageDeliveryAndDispatchPayment = TestMessageDeliveryAndDispatchPayment; type MessageDispatch = TestMessageDispatch; type OnDeliveryConfirmed = FeeMarketMessageConfirmedHandler; @@ -434,7 +435,6 @@ impl pallet_bridge_messages::Config for Test { type SourceHeaderChain = TestSourceHeaderChain; type TargetHeaderChain = TestTargetHeaderChain; type WeightInfo = (); - type MaximalOutboundPayloadSize = frame_support::traits::ConstU32; } impl SenderOrigin for Origin { diff --git a/modules/grandpa/src/extension.rs b/modules/grandpa/src/extension.rs index a724b6518..3f5e66292 100644 --- a/modules/grandpa/src/extension.rs +++ b/modules/grandpa/src/extension.rs @@ -52,7 +52,7 @@ impl< best_finalized_number, ); - return InvalidTransaction::Stale.into() + return InvalidTransaction::Stale.into(); } Ok(ValidTransaction::default()) diff --git a/modules/grandpa/src/lib.rs b/modules/grandpa/src/lib.rs index 4074421fc..f9600243e 100644 --- a/modules/grandpa/src/lib.rs +++ b/modules/grandpa/src/lib.rs @@ -122,10 +122,11 @@ pub mod pallet { } impl, I: 'static> OwnedBridgeModule for Pallet { - const LOG_TARGET: &'static str = LOG_TARGET; - type OwnerStorage = PalletOwner; type OperatingMode = BasicOperatingMode; type OperatingModeStorage = PalletOperatingMode; + type OwnerStorage = PalletOwner; + + const LOG_TARGET: &'static str = LOG_TARGET; } #[pallet::call] diff --git a/modules/messages/src/lib.rs b/modules/messages/src/lib.rs index 939554bf1..e87c70640 100644 --- a/modules/messages/src/lib.rs +++ b/modules/messages/src/lib.rs @@ -60,8 +60,7 @@ use bp_messages::{ }, total_unrewarded_messages, DeliveredMessages, InboundLaneData, InboundMessageDetails, LaneId, MessageData, MessageKey, MessageNonce, MessagePayload, MessagesOperatingMode, OutboundLaneData, - OutboundMessageDetails, Parameter as MessagesParameter, - UnrewardedRelayersState, + OutboundMessageDetails, Parameter as MessagesParameter, UnrewardedRelayersState, }; use bp_runtime::{BasicOperatingMode, ChainId, OwnedBridgeModule, Size}; use codec::{Decode, Encode, MaxEncodedLen}; @@ -73,10 +72,7 @@ use frame_support::{ use num_traits::{SaturatingAdd, Zero}; use sp_core::H256; use sp_runtime::traits::Convert; -use sp_std::{ - cell::RefCell, cmp::PartialOrd, marker::PhantomData, - prelude::*, -}; +use sp_std::{cell::RefCell, cmp::PartialOrd, marker::PhantomData, prelude::*}; mod inbound_lane; mod outbound_lane; @@ -225,10 +221,11 @@ pub mod pallet { pub struct Pallet(PhantomData<(T, I)>); impl, I: 'static> OwnedBridgeModule for Pallet { - const LOG_TARGET: &'static str = LOG_TARGET; - type OwnerStorage = PalletOwner; type OperatingMode = MessagesOperatingMode; type OperatingModeStorage = PalletOperatingMode; + type OwnerStorage = PalletOwner; + + const LOG_TARGET: &'static str = LOG_TARGET; } #[pallet::call] @@ -954,10 +951,10 @@ fn send_message, I: 'static>( /// Ensure that the pallet is in normal operational mode. fn ensure_normal_operating_mode, I: 'static>() -> Result<(), Error> { - if PalletOperatingMode::::get() == - MessagesOperatingMode::Basic(BasicOperatingMode::Normal) + if PalletOperatingMode::::get() + == MessagesOperatingMode::Basic(BasicOperatingMode::Normal) { - return Ok(()) + return Ok(()); } Err(Error::::NotOperatingNormally) @@ -1443,9 +1440,7 @@ mod tests { let mut message_payload = message_payload(1, 0); // the payload isn't simply extra, so it'll definitely overflow // `MAX_OUTBOUND_PAYLOAD_SIZE` if we add `MAX_OUTBOUND_PAYLOAD_SIZE` bytes to extra - message_payload - .extra - .extend_from_slice(&[0u8; MAX_OUTBOUND_PAYLOAD_SIZE as usize]); + message_payload.extra.extend_from_slice(&[0u8; MAX_OUTBOUND_PAYLOAD_SIZE as usize]); assert_noop!( Pallet::::send_message( Origin::signed(1), diff --git a/modules/messages/src/mock.rs b/modules/messages/src/mock.rs index ed5234116..9bbc180a8 100644 --- a/modules/messages/src/mock.rs +++ b/modules/messages/src/mock.rs @@ -167,30 +167,27 @@ impl MessagesParameter for TestMessagesParameter { } impl Config for TestRuntime { + type AccountIdConverter = AccountIdConverter; + type BridgedChainId = TestBridgedChainId; type Event = Event; - type WeightInfo = (); - type Parameter = TestMessagesParameter; - type MaxMessagesToPruneAtOnce = MaxMessagesToPruneAtOnce; - type MaxUnrewardedRelayerEntriesAtInboundLane = MaxUnrewardedRelayerEntriesAtInboundLane; - type MaxUnconfirmedMessagesAtInboundLane = MaxUnconfirmedMessagesAtInboundLane; - - type MaximalOutboundPayloadSize = frame_support::traits::ConstU32; - type OutboundPayload = TestPayload; - type OutboundMessageFee = TestMessageFee; - - type InboundPayload = TestPayload; type InboundMessageFee = TestMessageFee; + type InboundPayload = TestPayload; type InboundRelayer = TestRelayer; - - type AccountIdConverter = AccountIdConverter; - type BridgedChainId = TestBridgedChainId; type LaneMessageVerifier = TestLaneMessageVerifier; + type MaxMessagesToPruneAtOnce = MaxMessagesToPruneAtOnce; + type MaxUnconfirmedMessagesAtInboundLane = MaxUnconfirmedMessagesAtInboundLane; + type MaxUnrewardedRelayerEntriesAtInboundLane = MaxUnrewardedRelayerEntriesAtInboundLane; + type MaximalOutboundPayloadSize = frame_support::traits::ConstU32; type MessageDeliveryAndDispatchPayment = TestMessageDeliveryAndDispatchPayment; type MessageDispatch = TestMessageDispatch; type OnDeliveryConfirmed = (TestOnDeliveryConfirmed1, TestOnDeliveryConfirmed2); type OnMessageAccepted = TestOnMessageAccepted; + type OutboundMessageFee = TestMessageFee; + type OutboundPayload = TestPayload; + type Parameter = TestMessagesParameter; type SourceHeaderChain = TestSourceHeaderChain; type TargetHeaderChain = TestTargetHeaderChain; + type WeightInfo = (); } impl SenderOrigin for Origin { diff --git a/modules/messages/src/weights.rs b/modules/messages/src/weights.rs index 6db9ad5c4..916000ef3 100644 --- a/modules/messages/src/weights.rs +++ b/modules/messages/src/weights.rs @@ -73,67 +73,80 @@ impl WeightInfo for MillauWeight { .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(10 as Weight)) } + fn send_1_kb_message_worst_case() -> Weight { (39_158_000 as Weight) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(10 as Weight)) } + fn send_16_kb_message_worst_case() -> Weight { (48_698_000 as Weight) .saturating_add(T::DbWeight::get().reads(5 as Weight)) .saturating_add(T::DbWeight::get().writes(10 as Weight)) } + fn maximal_increase_message_fee() -> Weight { (2_919_864_000 as Weight) .saturating_add(T::DbWeight::get().reads(3 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } + fn increase_message_fee(i: u32) -> Weight { (0 as Weight) .saturating_add((1_000 as Weight).saturating_mul(i as Weight)) .saturating_add(T::DbWeight::get().reads(3 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } + fn receive_single_message_proof() -> Weight { (25_992_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(2 as Weight)) } + fn receive_two_messages_proof() -> Weight { (37_016_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(2 as Weight)) } + fn receive_single_message_proof_with_outbound_lane_state() -> Weight { (31_589_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(2 as Weight)) } + fn receive_single_message_proof_1_kb() -> Weight { (25_962_000 as Weight) .saturating_add(T::DbWeight::get().reads(3 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } + fn receive_single_message_proof_16_kb() -> Weight { (74_385_000 as Weight) .saturating_add(T::DbWeight::get().reads(3 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } + fn receive_single_prepaid_message_proof() -> Weight { (26_159_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(2 as Weight)) } + fn receive_delivery_proof_for_single_message() -> Weight { (27_590_000 as Weight) .saturating_add(T::DbWeight::get().reads(3 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } + fn receive_delivery_proof_for_two_messages_by_single_relayer() -> Weight { (27_354_000 as Weight) .saturating_add(T::DbWeight::get().reads(3 as Weight)) .saturating_add(T::DbWeight::get().writes(1 as Weight)) } + fn receive_delivery_proof_for_two_messages_by_two_relayers() -> Weight { (27_652_000 as Weight) .saturating_add(T::DbWeight::get().reads(3 as Weight)) @@ -148,67 +161,80 @@ impl WeightInfo for () { .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(10 as Weight)) } + fn send_1_kb_message_worst_case() -> Weight { (39_158_000 as Weight) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(10 as Weight)) } + fn send_16_kb_message_worst_case() -> Weight { (48_698_000 as Weight) .saturating_add(RocksDbWeight::get().reads(5 as Weight)) .saturating_add(RocksDbWeight::get().writes(10 as Weight)) } + fn maximal_increase_message_fee() -> Weight { (2_919_864_000 as Weight) .saturating_add(RocksDbWeight::get().reads(3 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } + fn increase_message_fee(i: u32) -> Weight { (0 as Weight) .saturating_add((1_000 as Weight).saturating_mul(i as Weight)) .saturating_add(RocksDbWeight::get().reads(3 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } + fn receive_single_message_proof() -> Weight { (25_992_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) } + fn receive_two_messages_proof() -> Weight { (37_016_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) } + fn receive_single_message_proof_with_outbound_lane_state() -> Weight { (31_589_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) } + fn receive_single_message_proof_1_kb() -> Weight { (25_962_000 as Weight) .saturating_add(RocksDbWeight::get().reads(3 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } + fn receive_single_message_proof_16_kb() -> Weight { (74_385_000 as Weight) .saturating_add(RocksDbWeight::get().reads(3 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } + fn receive_single_prepaid_message_proof() -> Weight { (26_159_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(2 as Weight)) } + fn receive_delivery_proof_for_single_message() -> Weight { (27_590_000 as Weight) .saturating_add(RocksDbWeight::get().reads(3 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } + fn receive_delivery_proof_for_two_messages_by_single_relayer() -> Weight { (27_354_000 as Weight) .saturating_add(RocksDbWeight::get().reads(3 as Weight)) .saturating_add(RocksDbWeight::get().writes(1 as Weight)) } + fn receive_delivery_proof_for_two_messages_by_two_relayers() -> Weight { (27_652_000 as Weight) .saturating_add(RocksDbWeight::get().reads(3 as Weight)) diff --git a/modules/parachains/src/lib.rs b/modules/parachains/src/lib.rs index b5c1fb0b8..55f16129f 100644 --- a/modules/parachains/src/lib.rs +++ b/modules/parachains/src/lib.rs @@ -186,10 +186,11 @@ pub mod pallet { pub struct Pallet(PhantomData<(T, I)>); impl, I: 'static> OwnedBridgeModule for Pallet { - const LOG_TARGET: &'static str = LOG_TARGET; - type OwnerStorage = PalletOwner; type OperatingMode = BasicOperatingMode; type OperatingModeStorage = PalletOperatingMode; + type OwnerStorage = PalletOwner; + + const LOG_TARGET: &'static str = LOG_TARGET; } #[pallet::call] @@ -403,7 +404,7 @@ pub mod pallet { stored_best_head.at_relay_block_number, updated_at_relay_block_number ); - return InvalidTransaction::Stale.into() + return InvalidTransaction::Stale.into(); } if stored_best_head.head_hash == updated_head_hash { @@ -416,7 +417,7 @@ pub mod pallet { stored_best_head.at_relay_block_number, updated_at_relay_block_number ); - return InvalidTransaction::Stale.into() + return InvalidTransaction::Stale.into(); } Ok(ValidTransaction::default()) diff --git a/modules/parachains/src/mock.rs b/modules/parachains/src/mock.rs index ec781c775..2341c829c 100644 --- a/modules/parachains/src/mock.rs +++ b/modules/parachains/src/mock.rs @@ -112,11 +112,11 @@ parameter_types! { } impl pallet_bridge_parachains::Config for TestRuntime { - type WeightInfo = (); type BridgesGrandpaPalletInstance = pallet_bridge_grandpa::Instance1; + type HeadsToKeep = HeadsToKeep; type ParasPalletName = ParasPalletName; type TrackedParachains = IsInVec; - type HeadsToKeep = HeadsToKeep; + type WeightInfo = (); } #[derive(Debug)] diff --git a/modules/parachains/src/weights.rs b/modules/parachains/src/weights.rs index bf7384b81..34cc23195 100644 --- a/modules/parachains/src/weights.rs +++ b/modules/parachains/src/weights.rs @@ -64,11 +64,13 @@ impl WeightInfo for MillauWeight { .saturating_add(T::DbWeight::get().reads((2 as Weight).saturating_mul(p as Weight))) .saturating_add(T::DbWeight::get().writes((3 as Weight).saturating_mul(p as Weight))) } + fn submit_parachain_heads_with_1kb_proof() -> Weight { (27_549_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) .saturating_add(T::DbWeight::get().writes(3 as Weight)) } + fn submit_parachain_heads_with_16kb_proof() -> Weight { (80_792_000 as Weight) .saturating_add(T::DbWeight::get().reads(4 as Weight)) @@ -85,11 +87,13 @@ impl WeightInfo for () { .saturating_add(RocksDbWeight::get().reads((2 as Weight).saturating_mul(p as Weight))) .saturating_add(RocksDbWeight::get().writes((3 as Weight).saturating_mul(p as Weight))) } + fn submit_parachain_heads_with_1kb_proof() -> Weight { (27_549_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) .saturating_add(RocksDbWeight::get().writes(3 as Weight)) } + fn submit_parachain_heads_with_16kb_proof() -> Weight { (80_792_000 as Weight) .saturating_add(RocksDbWeight::get().reads(4 as Weight)) diff --git a/modules/parachains/src/weights_ext.rs b/modules/parachains/src/weights_ext.rs index f345762da..38c001d74 100644 --- a/modules/parachains/src/weights_ext.rs +++ b/modules/parachains/src/weights_ext.rs @@ -77,9 +77,9 @@ pub trait WeightInfoExt: WeightInfo { /// Returns weight that needs to be accounted when storage proof of given size is received. fn storage_proof_size_overhead(extra_proof_bytes: u32) -> Weight { let extra_proof_bytes_in_bytes = extra_proof_bytes as Weight; - let extra_byte_weight = (Self::submit_parachain_heads_with_16kb_proof() - - Self::submit_parachain_heads_with_1kb_proof()) / - (15 * 1024); + let extra_byte_weight = (Self::submit_parachain_heads_with_16kb_proof() + - Self::submit_parachain_heads_with_1kb_proof()) + / (15 * 1024); extra_proof_bytes_in_bytes.saturating_mul(extra_byte_weight) } } diff --git a/primitives/parachains/src/lib.rs b/primitives/parachains/src/lib.rs index e6c9360d5..be1dcb179 100644 --- a/primitives/parachains/src/lib.rs +++ b/primitives/parachains/src/lib.rs @@ -73,11 +73,11 @@ pub fn best_parachain_head_hash_storage_key_at_target( /// The head is stored by the `pallet-bridge-parachains` pallet in the `ImportedParaHeads` map. pub struct ImportedParaHeadsKeyProvider; impl StorageDoubleMapKeyProvider for ImportedParaHeadsKeyProvider { - const MAP_NAME: &'static str = "ImportedParaHeads"; - type Hasher1 = Blake2_128Concat; - type Key1 = ParaId; type Hasher2 = Blake2_128Concat; + type Key1 = ParaId; type Key2 = ParaHash; type Value = ParaHead; + + const MAP_NAME: &'static str = "ImportedParaHeads"; } diff --git a/primitives/runtime/src/lib.rs b/primitives/runtime/src/lib.rs index 2e3e95cb8..c3e6b45ab 100644 --- a/primitives/runtime/src/lib.rs +++ b/primitives/runtime/src/lib.rs @@ -288,10 +288,10 @@ pub trait StorageDoubleMapKeyProvider { let storage_prefix_hashed = frame_support::Twox128::hash(Self::MAP_NAME.as_bytes()); let mut final_key = Vec::with_capacity( - pallet_prefix_hashed.len() + - storage_prefix_hashed.len() + - key1_hashed.as_ref().len() + - key2_hashed.as_ref().len(), + pallet_prefix_hashed.len() + + storage_prefix_hashed.len() + + key1_hashed.as_ref().len() + + key2_hashed.as_ref().len(), ); final_key.extend_from_slice(&pallet_prefix_hashed[..]); diff --git a/primitives/runtime/src/storage_proof.rs b/primitives/runtime/src/storage_proof.rs index b71996020..0b77bc004 100644 --- a/primitives/runtime/src/storage_proof.rs +++ b/primitives/runtime/src/storage_proof.rs @@ -79,8 +79,7 @@ where /// read, but decoding fails, this function returns an error. pub fn read_and_decode_value(&self, key: &[u8]) -> Result, Error> { self.read_value(key).and_then(|v| { - v.map(|v| T::decode(&mut &v[..]).map_err(Error::StorageValueDecodeFailed)) - .transpose() + v.map(|v| T::decode(&mut &v[..]).map_err(Error::StorageValueDecodeFailed)).transpose() }) } }