chore: update rust toolchain, migrate to 2024 edition

Author: tediou5

crates/pallet-domains/Cargo.toml

@@ -2,7 +2,7 @@
 name = "pallet-domains"
 version = "0.1.0"
 authors = ["Subspace Labs <https://subspace.network>"]
-edition = "2021"
+edition = "2024"
 license = "0BSD"
 homepage = "https://subspace.network"
 repository = "https://github.com/autonomys/subspace"

crates/pallet-domains/src/benchmarking.rs

@@ -3,34 +3,34 @@
 extern crate alloc;
 
 use super::*;
-use crate::block_tree::{prune_receipt, BlockTreeNode};
+use crate::block_tree::{BlockTreeNode, prune_receipt};
 use crate::bundle_storage_fund::refund_storage_fee;
-use crate::domain_registry::{into_domain_config, DomainConfigParams};
+use crate::domain_registry::{DomainConfigParams, into_domain_config};
 use crate::staking::{
-    do_convert_previous_epoch_withdrawal, do_mark_operators_as_slashed, do_reward_operators,
     Error as StakingError, OperatorConfig, OperatorStatus, WithdrawStake,
+    do_convert_previous_epoch_withdrawal, do_mark_operators_as_slashed, do_reward_operators,
 };
 use crate::staking_epoch::{
     do_finalize_domain_current_epoch, do_finalize_domain_epoch_staking, do_slash_operator,
     operator_take_reward_tax_and_stake,
 };
 use crate::{
-    DomainBlockNumberFor, Pallet as Domains, RawOrigin as DomainOrigin, MAX_NOMINATORS_TO_SLASH,
+    DomainBlockNumberFor, MAX_NOMINATORS_TO_SLASH, Pallet as Domains, RawOrigin as DomainOrigin,
 };
 #[cfg(not(feature = "std"))]
 use alloc::borrow::ToOwned;
 #[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 use frame_benchmarking::v2::*;
 use frame_support::assert_ok;
-use frame_support::traits::fungible::{Inspect, Mutate};
 use frame_support::traits::Hooks;
+use frame_support::traits::fungible::{Inspect, Mutate};
 use frame_system::{Pallet as System, RawOrigin};
 use sp_core::crypto::{Ss58Codec, UncheckedFrom};
 use sp_domains::{
-    dummy_opaque_bundle, DomainId, ExecutionReceipt, OperatorAllowList, OperatorId,
-    OperatorPublicKey, OperatorRewardSource, OperatorSignature, PermissionedActionAllowedBy,
-    ProofOfElection, RuntimeType, SealedSingletonReceipt, SingletonReceipt,
+    DomainId, ExecutionReceipt, OperatorAllowList, OperatorId, OperatorPublicKey,
+    OperatorRewardSource, OperatorSignature, PermissionedActionAllowedBy, ProofOfElection,
+    RuntimeType, SealedSingletonReceipt, SingletonReceipt, dummy_opaque_bundle,
 };
 use sp_domains_fraud_proof::fraud_proof::FraudProof;
 use sp_runtime::traits::{CheckedAdd, One, Zero};

crates/pallet-domains/src/block_tree.rs

@@ -12,7 +12,7 @@ use crate::{
 };
 #[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
-use frame_support::{ensure, PalletError};
+use frame_support::{PalletError, ensure};
 use frame_system::pallet_prelude::BlockNumberFor;
 use parity_scale_codec::{Decode, Encode};
 use scale_info::TypeInfo;
@@ -629,9 +629,10 @@ pub(crate) fn prune_receipt<T: Config>(
 mod tests {
     use super::*;
     use crate::tests::{
-        create_dummy_bundle_with_receipts, create_dummy_receipt, extend_block_tree,
-        extend_block_tree_from_zero, get_block_tree_node_at, new_test_ext_with_extensions,
-        register_genesis_domain, run_to_block, BlockTreePruningDepth, Domains, Test,
+        BlockTreePruningDepth, Domains, Test, create_dummy_bundle_with_receipts,
+        create_dummy_receipt, extend_block_tree, extend_block_tree_from_zero,
+        get_block_tree_node_at, new_test_ext_with_extensions, register_genesis_domain,
+        run_to_block,
     };
     use crate::{FrozenDomains, RawOrigin as DomainOrigin};
     use frame_support::dispatch::RawOrigin;
@@ -781,11 +782,10 @@ mod tests {
                 verify_execution_receipt::<Test>(domain_id, &pruned_receipt),
                 Error::PrunedReceipt
             );
-            assert!(ConsensusBlockHash::<Test>::get(
-                domain_id,
-                pruned_receipt.consensus_block_number,
-            )
-            .is_none());
+            assert!(
+                ConsensusBlockHash::<Test>::get(domain_id, pruned_receipt.consensus_block_number,)
+                    .is_none()
+            );
         });
     }
 
@@ -1091,11 +1091,13 @@ mod tests {
             let mut invalid_execution_trace_receipt = next_receipt;
 
             // Receipt with only one element in execution trace vector
-            invalid_execution_trace_receipt.execution_trace = vec![invalid_execution_trace_receipt
-                .execution_trace
-                .first()
-                .cloned()
-                .expect("First element should be there; qed")];
+            invalid_execution_trace_receipt.execution_trace = vec![
+                invalid_execution_trace_receipt
+                    .execution_trace
+                    .first()
+                    .cloned()
+                    .expect("First element should be there; qed"),
+            ];
             assert_err!(
                 verify_execution_receipt::<Test>(domain_id, &invalid_execution_trace_receipt),
                 Error::InvalidExecutionTrace

crates/pallet-domains/src/bundle_storage_fund.rs

@@ -3,15 +3,15 @@
 use crate::staking::NewDeposit;
 use crate::staking_epoch::mint_into_treasury;
 use crate::{BalanceOf, Config, Event, HoldIdentifier, Operators, Pallet};
+use frame_support::PalletError;
+use frame_support::traits::Get;
 use frame_support::traits::fungible::{Inspect, Mutate, MutateHold};
 use frame_support::traits::tokens::{Fortitude, Precision, Preservation};
-use frame_support::traits::Get;
-use frame_support::PalletError;
 use parity_scale_codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use sp_domains::OperatorId;
-use sp_runtime::traits::{AccountIdConversion, CheckedSub, Zero};
 use sp_runtime::Perbill;
+use sp_runtime::traits::{AccountIdConversion, CheckedSub, Zero};
 use sp_std::collections::btree_map::BTreeMap;
 use subspace_runtime_primitives::StorageFee;
 

crates/pallet-domains/src/domain_registry.rs

@@ -8,8 +8,8 @@ use crate::pallet::{DomainStakingSummary, NextEVMChainId};
 use crate::runtime_registry::DomainRuntimeInfo;
 use crate::staking::StakingSummary;
 use crate::{
-    into_complete_raw_genesis, BalanceOf, Config, DomainHashingFor, DomainRegistry,
-    DomainSudoCalls, ExecutionReceiptOf, HoldIdentifier, NextDomainId, RuntimeRegistry,
+    BalanceOf, Config, DomainHashingFor, DomainRegistry, DomainSudoCalls, ExecutionReceiptOf,
+    HoldIdentifier, NextDomainId, RuntimeRegistry, into_complete_raw_genesis,
 };
 #[cfg(not(feature = "std"))]
 use alloc::string::String;
@@ -19,18 +19,18 @@ use domain_runtime_primitives::MultiAccountId;
 use frame_support::traits::fungible::{Inspect, Mutate, MutateHold};
 use frame_support::traits::tokens::{Fortitude, Precision, Preservation};
 use frame_support::weights::Weight;
-use frame_support::{ensure, PalletError};
+use frame_support::{PalletError, ensure};
 use frame_system::pallet_prelude::*;
 use parity_scale_codec::{Decode, Encode};
 use scale_info::TypeInfo;
 use sp_core::Get;
 use sp_domains::{
-    calculate_max_bundle_weight_and_size, derive_domain_block_hash, DomainBundleLimit, DomainId,
-    DomainRuntimeConfig, DomainSudoCall, DomainsDigestItem, DomainsTransfersTracker,
-    OnDomainInstantiated, OperatorAllowList, RuntimeId, RuntimeType,
+    DomainBundleLimit, DomainId, DomainRuntimeConfig, DomainSudoCall, DomainsDigestItem,
+    DomainsTransfersTracker, OnDomainInstantiated, OperatorAllowList, RuntimeId, RuntimeType,
+    calculate_max_bundle_weight_and_size, derive_domain_block_hash,
 };
-use sp_runtime::traits::{CheckedAdd, Zero};
 use sp_runtime::DigestItem;
+use sp_runtime::traits::{CheckedAdd, Zero};
 use sp_std::collections::btree_map::BTreeMap;
 use sp_std::collections::btree_set::BTreeSet;
 
@@ -384,7 +384,7 @@ pub(crate) fn do_update_domain_allow_list<T: Config>(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::tests::{new_test_ext, Test};
+    use crate::tests::{Test, new_test_ext};
     use domain_runtime_primitives::{AccountId20, AccountId20Converter};
     use frame_support::traits::Currency;
     use frame_support::{assert_err, assert_ok};

crates/pallet-domains/src/lib.rs

@@ -1,7 +1,7 @@
 //! Pallet Domains
 
 #![cfg_attr(not(feature = "std"), no_std)]
-#![feature(array_windows, let_chains, variant_count)]
+#![feature(array_windows, variant_count)]
 
 #[cfg(feature = "runtime-benchmarks")]
 mod benchmarking;
@@ -21,13 +21,13 @@ pub mod weights;
 
 extern crate alloc;
 
-use crate::block_tree::{verify_execution_receipt, Error as BlockTreeError};
+use crate::block_tree::{Error as BlockTreeError, verify_execution_receipt};
 use crate::bundle_storage_fund::{charge_bundle_storage_fee, storage_fund_account};
 use crate::domain_registry::{DomainConfig, Error as DomainRegistryError};
 use crate::runtime_registry::into_complete_raw_genesis;
 #[cfg(feature = "runtime-benchmarks")]
 pub use crate::staking::do_register_operator;
-use crate::staking::{do_reward_operators, OperatorStatus};
+use crate::staking::{OperatorStatus, do_reward_operators};
 use crate::staking_epoch::EpochTransitionResult;
 use crate::weights::WeightInfo;
 #[cfg(not(feature = "std"))]
@@ -48,15 +48,15 @@ use frame_system::pallet_prelude::*;
 pub use pallet::*;
 use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
-use sp_consensus_subspace::consensus::is_proof_of_time_valid;
 use sp_consensus_subspace::WrappedPotOutput;
+use sp_consensus_subspace::consensus::is_proof_of_time_valid;
 use sp_core::H256;
 use sp_domains::bundle_producer_election::BundleProducerElectionParams;
 use sp_domains::{
-    ChainId, DomainBundleLimit, DomainId, DomainInstanceData, ExecutionReceipt, OpaqueBundle,
-    OperatorId, OperatorPublicKey, OperatorRewardSource, OperatorSignature, ProofOfElection,
-    RuntimeId, SealedSingletonReceipt, DOMAIN_EXTRINSICS_SHUFFLING_SEED_SUBJECT,
-    EMPTY_EXTRINSIC_ROOT,
+    ChainId, DOMAIN_EXTRINSICS_SHUFFLING_SEED_SUBJECT, DomainBundleLimit, DomainId,
+    DomainInstanceData, EMPTY_EXTRINSIC_ROOT, ExecutionReceipt, OpaqueBundle, OperatorId,
+    OperatorPublicKey, OperatorRewardSource, OperatorSignature, ProofOfElection, RuntimeId,
+    SealedSingletonReceipt,
 };
 use sp_domains_fraud_proof::fraud_proof::{
     DomainRuntimeCodeAt, FraudProof, FraudProofVariant, InvalidBlockFeesProof,
@@ -200,45 +200,46 @@ pub(crate) type StateRootOf<T> = <<T as frame_system::Config>::Hashing as Hash>:
 #[expect(clippy::useless_conversion, reason = "Macro-generated")]
 #[frame_support::pallet]
 mod pallet {
+    #[cfg(not(feature = "runtime-benchmarks"))]
+    use crate::DomainHashingFor;
+    #[cfg(not(feature = "runtime-benchmarks"))]
+    use crate::MAX_NOMINATORS_TO_SLASH;
     #[cfg(not(feature = "runtime-benchmarks"))]
     use crate::block_tree::AcceptedReceiptType;
     use crate::block_tree::{
-        execution_receipt_type, process_execution_receipt, prune_receipt, Error as BlockTreeError,
-        ReceiptType,
+        Error as BlockTreeError, ReceiptType, execution_receipt_type, process_execution_receipt,
+        prune_receipt,
     };
+    use crate::bundle_storage_fund::Error as BundleStorageFundError;
     #[cfg(not(feature = "runtime-benchmarks"))]
     use crate::bundle_storage_fund::refund_storage_fee;
-    use crate::bundle_storage_fund::Error as BundleStorageFundError;
     use crate::domain_registry::{
-        do_instantiate_domain, do_update_domain_allow_list, DomainConfigParams, DomainObject,
-        Error as DomainRegistryError,
+        DomainConfigParams, DomainObject, Error as DomainRegistryError, do_instantiate_domain,
+        do_update_domain_allow_list,
     };
     use crate::runtime_registry::{
+        DomainRuntimeUpgradeEntry, Error as RuntimeRegistryError, ScheduledRuntimeUpgrade,
         do_register_runtime, do_schedule_runtime_upgrade, do_upgrade_runtimes,
-        register_runtime_at_genesis, DomainRuntimeUpgradeEntry, Error as RuntimeRegistryError,
-        ScheduledRuntimeUpgrade,
+        register_runtime_at_genesis,
     };
     #[cfg(not(feature = "runtime-benchmarks"))]
     use crate::staking::do_reward_operators;
     use crate::staking::{
-        do_deregister_operator, do_mark_operators_as_slashed, do_nominate_operator,
-        do_register_operator, do_unlock_funds, do_unlock_nominator, do_withdraw_stake, Deposit,
-        DomainEpoch, Error as StakingError, Operator, OperatorConfig, SharePrice, StakingSummary,
-        WithdrawStake, Withdrawal,
+        Deposit, DomainEpoch, Error as StakingError, Operator, OperatorConfig, SharePrice,
+        StakingSummary, WithdrawStake, Withdrawal, do_deregister_operator,
+        do_mark_operators_as_slashed, do_nominate_operator, do_register_operator, do_unlock_funds,
+        do_unlock_nominator, do_withdraw_stake,
     };
     #[cfg(not(feature = "runtime-benchmarks"))]
     use crate::staking_epoch::do_slash_operator;
-    use crate::staking_epoch::{do_finalize_domain_current_epoch, Error as StakingEpochError};
+    use crate::staking_epoch::{Error as StakingEpochError, do_finalize_domain_current_epoch};
     use crate::storage_proof::InherentExtrinsicData;
     use crate::weights::WeightInfo;
-    #[cfg(not(feature = "runtime-benchmarks"))]
-    use crate::DomainHashingFor;
-    #[cfg(not(feature = "runtime-benchmarks"))]
-    use crate::MAX_NOMINATORS_TO_SLASH;
     use crate::{
         BalanceOf, BlockSlot, BlockTreeNodeFor, DomainBlockNumberFor, ElectionVerificationParams,
-        ExecutionReceiptOf, FraudProofFor, HoldIdentifier, NominatorId, OpaqueBundleOf, RawOrigin,
-        ReceiptHashFor, SingletonReceiptOf, StateRootOf, MAX_BUNDLE_PER_BLOCK, STORAGE_VERSION,
+        ExecutionReceiptOf, FraudProofFor, HoldIdentifier, MAX_BUNDLE_PER_BLOCK, NominatorId,
+        OpaqueBundleOf, RawOrigin, ReceiptHashFor, STORAGE_VERSION, SingletonReceiptOf,
+        StateRootOf,
     };
     #[cfg(not(feature = "std"))]
     use alloc::string::String;
@@ -266,11 +267,11 @@ mod pallet {
     use sp_domains_fraud_proof::fraud_proof_runtime_interface::domain_runtime_call;
     use sp_domains_fraud_proof::storage_proof::{self, FraudProofStorageKeyProvider};
     use sp_domains_fraud_proof::{InvalidTransactionCode, StatelessDomainRuntimeCall};
+    use sp_runtime::Saturating;
     use sp_runtime::traits::{
         AtLeast32BitUnsigned, BlockNumberProvider, CheckEqual, CheckedAdd, Header as HeaderT,
         MaybeDisplay, One, SimpleBitOps, Zero,
     };
-    use sp_runtime::Saturating;
     use sp_std::boxed::Box;
     use sp_std::collections::btree_map::BTreeMap;
     use sp_std::collections::btree_set::BTreeSet;
@@ -447,11 +448,7 @@ mod pallet {
         type MmrHash: Parameter + Member + Default + Clone;
 
         /// MMR proof verifier
-        type MmrProofVerifier: MmrProofVerifier<
-            Self::MmrHash,
-            BlockNumberFor<Self>,
-            StateRootOf<Self>,
-        >;
+        type MmrProofVerifier: MmrProofVerifier<Self::MmrHash, BlockNumberFor<Self>, StateRootOf<Self>>;
 
         /// Fraud proof storage key provider
         type FraudProofStorageKeyProvider: FraudProofStorageKeyProvider<BlockNumberFor<Self>>;

crates/pallet-domains/src/runtime_registry.rs

@@ -12,20 +12,20 @@ use alloc::string::String;
 #[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
 use domain_runtime_primitives::{AccountId20, EVMChainId, MultiAccountId, TryConvertBack};
-use frame_support::{ensure, PalletError};
-use frame_system::pallet_prelude::*;
+use frame_support::{PalletError, ensure};
 use frame_system::AccountInfo;
+use frame_system::pallet_prelude::*;
 use parity_scale_codec::{Decode, Encode};
 use scale_info::TypeInfo;
-use sp_core::crypto::AccountId32;
 use sp_core::Hasher;
+use sp_core::crypto::AccountId32;
 use sp_domains::storage::{RawGenesis, StorageData, StorageKey};
 use sp_domains::{
     AutoIdDomainRuntimeConfig, DomainId, DomainRuntimeConfig, DomainsDigestItem,
     EvmDomainRuntimeConfig, RuntimeId, RuntimeObject, RuntimeType,
 };
-use sp_runtime::traits::{CheckedAdd, Zero};
 use sp_runtime::DigestItem;
+use sp_runtime::traits::{CheckedAdd, Zero};
 use sp_std::vec;
 use sp_version::RuntimeVersion;
 
@@ -393,10 +393,10 @@ pub(crate) fn do_upgrade_runtimes<T: Config>(at: BlockNumberFor<T>) {
 
 #[cfg(test)]
 mod tests {
+    use crate::Error;
     use crate::pallet::{NextRuntimeId, RuntimeRegistry, ScheduledRuntimeUpgrades};
     use crate::runtime_registry::Error as RuntimeRegistryError;
-    use crate::tests::{new_test_ext, Domains, ReadRuntimeVersion, System, Test};
-    use crate::Error;
+    use crate::tests::{Domains, ReadRuntimeVersion, System, Test, new_test_ext};
     use frame_support::dispatch::RawOrigin;
     use frame_support::traits::OnInitialize;
     use frame_support::{assert_err, assert_ok};