diff --git a/pallets/collator-selection/src/benchmarking.rs b/pallets/collator-selection/src/benchmarking.rs index ce26c020ff8..a08b2c7a43d 100644 --- a/pallets/collator-selection/src/benchmarking.rs +++ b/pallets/collator-selection/src/benchmarking.rs @@ -117,7 +117,7 @@ benchmarks! { ); } verify { - assert_last_event::(Event::NewInvulnerables(new_invulnerables).into()); + assert_last_event::(Event::NewInvulnerables{invulnerables: new_invulnerables}.into()); } set_desired_candidates { @@ -129,19 +129,19 @@ benchmarks! { ); } verify { - assert_last_event::(Event::NewDesiredCandidates(max).into()); + assert_last_event::(Event::NewDesiredCandidates{desired_candidates: max}.into()); } set_candidacy_bond { - let bond: BalanceOf = T::Currency::minimum_balance() * 10u32.into(); + let bond_amount: BalanceOf = T::Currency::minimum_balance() * 10u32.into(); let origin = T::UpdateOrigin::successful_origin(); }: { assert_ok!( - >::set_candidacy_bond(origin, bond.clone()) + >::set_candidacy_bond(origin, bond_amount.clone()) ); } verify { - assert_last_event::(Event::NewCandidacyBond(bond).into()); + assert_last_event::(Event::NewCandidacyBond{bond_amount}.into()); } // worse case is when we have all the max-candidate slots filled except one, and we fill that @@ -167,7 +167,7 @@ benchmarks! { }: _(RawOrigin::Signed(caller.clone())) verify { - assert_last_event::(Event::CandidateAdded(caller, bond / 2u32.into()).into()); + assert_last_event::(Event::CandidateAdded{account_id: caller, deposit: bond / 2u32.into()}.into()); } // worse case is the last candidate leaving. @@ -183,7 +183,7 @@ benchmarks! { whitelist!(leaving); }: _(RawOrigin::Signed(leaving.clone())) verify { - assert_last_event::(Event::CandidateRemoved(leaving).into()); + assert_last_event::(Event::CandidateRemoved{account_id: leaving}.into()); } // worse case is paying a non-existing candidate account. diff --git a/pallets/collator-selection/src/lib.rs b/pallets/collator-selection/src/lib.rs index 717fbc2ddae..0aeb44dc68e 100644 --- a/pallets/collator-selection/src/lib.rs +++ b/pallets/collator-selection/src/lib.rs @@ -248,11 +248,11 @@ pub mod pallet { #[pallet::event] #[pallet::generate_deposit(pub(super) fn deposit_event)] pub enum Event { - NewInvulnerables(Vec), - NewDesiredCandidates(u32), - NewCandidacyBond(BalanceOf), - CandidateAdded(T::AccountId, BalanceOf), - CandidateRemoved(T::AccountId), + NewInvulnerables { invulnerables: Vec }, + NewDesiredCandidates { desired_candidates: u32 }, + NewCandidacyBond { bond_amount: BalanceOf }, + CandidateAdded { account_id: T::AccountId, deposit: BalanceOf }, + CandidateRemoved { account_id: T::AccountId }, } // Errors inform users that something went wrong. @@ -308,7 +308,7 @@ pub mod pallet { } >::put(&new); - Self::deposit_event(Event::NewInvulnerables(new)); + Self::deposit_event(Event::NewInvulnerables { invulnerables: new }); Ok(().into()) } @@ -326,7 +326,7 @@ pub mod pallet { log::warn!("max > T::MaxCandidates; you might need to run benchmarks again"); } >::put(&max); - Self::deposit_event(Event::NewDesiredCandidates(max)); + Self::deposit_event(Event::NewDesiredCandidates { desired_candidates: max }); Ok(().into()) } @@ -338,7 +338,7 @@ pub mod pallet { ) -> DispatchResultWithPostInfo { T::UpdateOrigin::ensure_origin(origin)?; >::put(&bond); - Self::deposit_event(Event::NewCandidacyBond(bond)); + Self::deposit_event(Event::NewCandidacyBond { bond_amount: bond }); Ok(().into()) } @@ -381,7 +381,7 @@ pub mod pallet { } })?; - Self::deposit_event(Event::CandidateAdded(who, deposit)); + Self::deposit_event(Event::CandidateAdded { account_id: who, deposit }); Ok(Some(T::WeightInfo::register_as_candidate(current_count as u32)).into()) } @@ -423,7 +423,7 @@ pub mod pallet { >::remove(who.clone()); Ok(candidates.len()) })?; - Self::deposit_event(Event::CandidateRemoved(who.clone())); + Self::deposit_event(Event::CandidateRemoved { account_id: who.clone() }); Ok(current_count) } diff --git a/pallets/dmp-queue/src/lib.rs b/pallets/dmp-queue/src/lib.rs index c0c151b0ab0..a811bf54054 100644 --- a/pallets/dmp-queue/src/lib.rs +++ b/pallets/dmp-queue/src/lib.rs @@ -149,11 +149,11 @@ pub mod pallet { T::ExecuteOverweightOrigin::ensure_origin(origin)?; let (sent_at, data) = Overweight::::get(index).ok_or(Error::::Unknown)?; - let used = Self::try_service_message(weight_limit, sent_at, &data[..]) + let weight_used = Self::try_service_message(weight_limit, sent_at, &data[..]) .map_err(|_| Error::::OverLimit)?; Overweight::::remove(index); - Self::deposit_event(Event::OverweightServiced(index, used)); - Ok(Some(used.saturating_add(1_000_000)).into()) + Self::deposit_event(Event::OverweightServiced { overweight_index: index, weight_used }); + Ok(Some(weight_used.saturating_add(1_000_000)).into()) } } @@ -161,23 +161,21 @@ pub mod pallet { #[pallet::generate_deposit(pub(super) fn deposit_event)] pub enum Event { /// Downward message is invalid XCM. - /// \[ id \] - InvalidFormat(MessageId), + InvalidFormat { message_id: MessageId }, /// Downward message is unsupported version of XCM. - /// \[ id \] - UnsupportedVersion(MessageId), + UnsupportedVersion { message_id: MessageId }, /// Downward message executed with the given outcome. - /// \[ id, outcome \] - ExecutedDownward(MessageId, Outcome), + ExecutedDownward { message_id: MessageId, outcome: Outcome }, /// The weight limit for handling downward messages was reached. - /// \[ id, remaining, required \] - WeightExhausted(MessageId, Weight, Weight), + WeightExhausted { message_id: MessageId, remaining_weight: Weight, required_weight: Weight }, /// Downward message is overweight and was placed in the overweight queue. - /// \[ id, index, required \] - OverweightEnqueued(MessageId, OverweightIndex, Weight), + OverweightEnqueued { + message_id: MessageId, + overweight_index: OverweightIndex, + required_weight: Weight, + }, /// Downward message from the overweight queue was executed. - /// \[ index, used \] - OverweightServiced(OverweightIndex, Weight), + OverweightServiced { overweight_index: OverweightIndex, weight_used: Weight }, } impl Pallet { @@ -225,7 +223,7 @@ pub mod pallet { _sent_at: RelayBlockNumber, mut data: &[u8], ) -> Result { - let id = sp_io::hashing::blake2_256(data); + let message_id = sp_io::hashing::blake2_256(data); let maybe_msg = VersionedXcm::::decode_all_with_depth_limit( MAX_XCM_DECODE_DEPTH, &mut data, @@ -233,21 +231,21 @@ pub mod pallet { .map(Xcm::::try_from); match maybe_msg { Err(_) => { - Self::deposit_event(Event::InvalidFormat(id)); + Self::deposit_event(Event::InvalidFormat { message_id }); Ok(0) }, Ok(Err(())) => { - Self::deposit_event(Event::UnsupportedVersion(id)); + Self::deposit_event(Event::UnsupportedVersion { message_id }); Ok(0) }, Ok(Ok(x)) => { let outcome = T::XcmExecutor::execute_xcm(Parent, x, limit); match outcome { Outcome::Error(XcmError::WeightLimitReached(required)) => - Err((id, required)), + Err((message_id, required)), outcome => { let weight_used = outcome.weight_used(); - Self::deposit_event(Event::ExecutedDownward(id, outcome)); + Self::deposit_event(Event::ExecutedDownward { message_id, outcome }); Ok(weight_used) }, } @@ -283,18 +281,22 @@ pub mod pallet { for (i, (sent_at, data)) in iter.enumerate() { if maybe_enqueue_page.is_none() { // We're not currently enqueuing - try to execute inline. - let remaining = limit.saturating_sub(used); - match Self::try_service_message(remaining, sent_at, &data[..]) { + let remaining_weight = limit.saturating_sub(used); + match Self::try_service_message(remaining_weight, sent_at, &data[..]) { Ok(consumed) => used += consumed, - Err((id, required)) => + Err((message_id, required_weight)) => // Too much weight required right now. { - if required > config.max_individual { + if required_weight > config.max_individual { // overweight - add to overweight queue and continue with // message execution. - let index = page_index.overweight_count; - Overweight::::insert(index, (sent_at, data)); - Self::deposit_event(Event::OverweightEnqueued(id, index, required)); + let overweight_index = page_index.overweight_count; + Overweight::::insert(overweight_index, (sent_at, data)); + Self::deposit_event(Event::OverweightEnqueued { + message_id, + overweight_index, + required_weight, + }); page_index.overweight_count += 1; // Not needed for control flow, but only to ensure that the compiler // understands that we won't attempt to re-use `data` later. @@ -304,9 +306,11 @@ pub mod pallet { // from here on. let item_count_left = item_count.saturating_sub(i); maybe_enqueue_page = Some(Vec::with_capacity(item_count_left)); - Self::deposit_event(Event::WeightExhausted( - id, remaining, required, - )); + Self::deposit_event(Event::WeightExhausted { + message_id, + remaining_weight, + required_weight, + }); } }, } diff --git a/pallets/parachain-system/src/lib.rs b/pallets/parachain-system/src/lib.rs index a9d1446f466..abb78adbf7b 100644 --- a/pallets/parachain-system/src/lib.rs +++ b/pallets/parachain-system/src/lib.rs @@ -330,7 +330,9 @@ pub mod pallet { Self::put_parachain_code(&validation_code); ::on_validation_code_applied(); - Self::deposit_event(Event::ValidationFunctionApplied(vfp.relay_parent_number)); + Self::deposit_event(Event::ValidationFunctionApplied { + relay_chain_block_num: vfp.relay_parent_number, + }); }, Some(relay_chain::v2::UpgradeGoAhead::Abort) => { >::kill(); @@ -389,7 +391,7 @@ pub mod pallet { AuthorizedUpgrade::::put(&code_hash); - Self::deposit_event(Event::UpgradeAuthorized(code_hash)); + Self::deposit_event(Event::UpgradeAuthorized { code_hash }); Ok(()) } @@ -411,17 +413,15 @@ pub mod pallet { /// The validation function has been scheduled to apply. ValidationFunctionStored, /// The validation function was applied as of the contained relay chain block number. - ValidationFunctionApplied(RelayChainBlockNumber), + ValidationFunctionApplied { relay_chain_block_num: RelayChainBlockNumber }, /// The relay-chain aborted the upgrade process. ValidationFunctionDiscarded, /// An upgrade has been authorized. - UpgradeAuthorized(T::Hash), + UpgradeAuthorized { code_hash: T::Hash }, /// Some downward messages have been received and will be processed. - /// \[ count \] - DownwardMessagesReceived(u32), + DownwardMessagesReceived { count: u32 }, /// Downward messages were processed using the given weight. - /// \[ weight_used, result_mqc_head \] - DownwardMessagesProcessed(Weight, relay_chain::Hash), + DownwardMessagesProcessed { weight_used: Weight, dmq_head: relay_chain::Hash }, } #[pallet::error] @@ -750,7 +750,7 @@ impl Pallet { let mut weight_used = 0; if dm_count != 0 { - Self::deposit_event(Event::DownwardMessagesReceived(dm_count)); + Self::deposit_event(Event::DownwardMessagesReceived { count: dm_count }); let max_weight = >::get().unwrap_or_else(T::ReservedDmpWeight::get); @@ -763,7 +763,10 @@ impl Pallet { weight_used += T::DmpMessageHandler::handle_dmp_messages(message_iter, max_weight); >::put(&dmq_head); - Self::deposit_event(Event::DownwardMessagesProcessed(weight_used, dmq_head.head())); + Self::deposit_event(Event::DownwardMessagesProcessed { + weight_used, + dmq_head: dmq_head.head(), + }); } // After hashing each message in the message queue chain submitted by the collator, we diff --git a/pallets/parachain-system/src/tests.rs b/pallets/parachain-system/src/tests.rs index 652cfd3d78c..0f7ac4b1984 100755 --- a/pallets/parachain-system/src/tests.rs +++ b/pallets/parachain-system/src/tests.rs @@ -415,7 +415,10 @@ fn events() { let events = System::events(); assert_eq!( events[0].event, - Event::ParachainSystem(crate::Event::ValidationFunctionApplied(1234).into()) + Event::ParachainSystem( + crate::Event::ValidationFunctionApplied { relay_chain_block_num: 1234 } + .into() + ) ); }, );