Merge branch 'main' of github.com:subspace/subspace into pallet-domains-extension-benchmark

Author: NingLin-P

Cargo.lock

@@ -21,6 +21,7 @@ hexlit.workspace = true
 hex-literal = { workspace = true, optional = true }
 log.workspace = true
 pallet-balances.workspace = true
+pallet-subspace = { workspace = true, optional = true }
 scale-info = { workspace = true, features = ["derive"] }
 schnorrkel = { workspace = true, optional = true }
 sp-consensus-slots.workspace = true
@@ -39,6 +40,7 @@ subspace-runtime-primitives.workspace = true
 [dev-dependencies]
 domain-pallet-executive.workspace = true
 hex-literal.workspace = true
+pallet-subspace.workspace = true
 pallet-timestamp.workspace = true
 pallet-block-fees.workspace = true
 sp-externalities.workspace = true
@@ -53,6 +55,7 @@ std = [
     "frame-system/std",
     "log/std",
     "pallet-balances/std",
+    "pallet-subspace/std",
     "scale-info/std",
     "sp-consensus-slots/std",
     "sp-consensus-subspace/std",
@@ -73,6 +76,7 @@ runtime-benchmarks = [
     "frame-benchmarking",
     "frame-benchmarking/runtime-benchmarks",
     "sp-consensus-subspace/runtime-benchmarks",
+    "pallet-subspace/runtime-benchmarks",
     "sp-domains/runtime-benchmarks",
     "sp-domains-fraud-proof/runtime-benchmarks",
     "sp-runtime/runtime-benchmarks",

crates/pallet-domains/Cargo.toml

@@ -29,6 +29,7 @@ use frame_support::traits::fungible::{Inspect, Mutate};
 use frame_support::traits::Hooks;
 use frame_system::{Pallet as System, RawOrigin};
 use hex_literal::hex;
+use pallet_subspace::BlockRandomness;
 use sp_consensus_slots::Slot;
 use sp_core::crypto::{Ss58Codec, UncheckedFrom};
 use sp_core::sr25519::vrf::{VrfPreOutput, VrfProof, VrfSignature};
@@ -44,11 +45,16 @@ use sp_domains_fraud_proof::fraud_proof::FraudProof;
 use sp_runtime::traits::{CheckedAdd, One, Zero};
 use sp_std::collections::btree_set::BTreeSet;
 use subspace_core_primitives::pot::PotOutput;
+use subspace_core_primitives::Randomness;
 
 const SEED: u32 = 0;
 const MAX_NOMINATORS_TO_SLASH_WITHOUT_OPERATOR: u32 = MAX_NOMINATORS_TO_SLASH - 1;
 
-#[benchmarks(where <RuntimeCallFor<T> as sp_runtime::traits::Dispatchable>::RuntimeOrigin: From<DomainOrigin>)]
+#[allow(clippy::multiple_bound_locations)]
+#[benchmarks(where
+    T: pallet_subspace::Config,
+    <RuntimeCallFor<T> as sp_runtime::traits::Dispatchable>::RuntimeOrigin: From<DomainOrigin>,
+)]
 mod benchmarks {
     use super::*;
     use sp_std::vec;
@@ -859,8 +865,8 @@ mod benchmarks {
     #[benchmark]
     fn transfer_treasury_funds() {
         // Ensure the treasury account has balance
-        let treasury_amount = 5000u32.into();
-        let transfer_amount = 500u32.into();
+        let transfer_amount = T::Currency::minimum_balance();
+        let treasury_amount = T::Currency::minimum_balance() + transfer_amount;
         let account = account("slashed_account", 1, SEED);
         assert_eq!(T::Currency::balance(&account), 0u32.into());
         T::Currency::set_balance(&T::TreasuryAccount::get(), treasury_amount);
@@ -1234,12 +1240,16 @@ mod benchmarks {
         }
     }
 
-    fn run_to_block<T: Config>(block_number: BlockNumberFor<T>, parent_hash: T::Hash) {
+    fn run_to_block<T: Config + pallet_subspace::Config>(
+        block_number: BlockNumberFor<T>,
+        parent_hash: T::Hash,
+    ) {
         if let Some(parent_block_number) = block_number.checked_sub(&One::one()) {
             Domains::<T>::on_finalize(parent_block_number);
         }
         System::<T>::set_block_number(block_number);
         System::<T>::initialize(&block_number, &parent_hash, &Default::default());
+        BlockRandomness::<T>::put(Randomness::default());
         Domains::<T>::on_initialize(block_number);
         System::<T>::finalize();
     }

crates/pallet-domains/src/benchmarking.rs

@@ -20,6 +20,7 @@ use frame_support::weights::{IdentityFee, Weight};
 use frame_support::{assert_err, assert_ok, derive_impl, parameter_types, PalletId};
 use frame_system::mocking::MockUncheckedExtrinsic;
 use frame_system::pallet_prelude::*;
+use pallet_subspace::NormalEraChange;
 use parity_scale_codec::{Decode, Encode, MaxEncodedLen};
 use scale_info::TypeInfo;
 use sp_core::crypto::Pair;
@@ -34,14 +35,18 @@ use sp_domains::{
 use sp_domains_fraud_proof::fraud_proof::FraudProof;
 use sp_runtime::generic::{Preamble, EXTRINSIC_FORMAT_VERSION};
 use sp_runtime::traits::{
-    AccountIdConversion, BlakeTwo256, BlockNumberProvider, Bounded, Hash as HashT, IdentityLookup,
-    One, Zero,
+    AccountIdConversion, BlakeTwo256, BlockNumberProvider, Bounded, ConstU16, Hash as HashT,
+    IdentityLookup, One, Zero,
 };
 use sp_runtime::transaction_validity::TransactionValidityError;
 use sp_runtime::type_with_default::TypeWithDefault;
 use sp_runtime::{BuildStorage, OpaqueExtrinsic};
 use sp_version::RuntimeVersion;
-use subspace_core_primitives::U256 as P256;
+use std::num::NonZeroU64;
+use subspace_core_primitives::pieces::Piece;
+use subspace_core_primitives::segments::HistorySize;
+use subspace_core_primitives::solutions::SolutionRange;
+use subspace_core_primitives::{SlotNumber, U256 as P256};
 use subspace_runtime_primitives::{
     ConsensusEventSegmentSize, HoldIdentifier, Moment, Nonce, StorageFee, SSC,
 };
@@ -61,6 +66,7 @@ frame_support::construct_runtime!(
         System: frame_system,
         Timestamp: pallet_timestamp,
         Balances: pallet_balances,
+        Subspace: pallet_subspace,
         Domains: pallet_domains,
         DomainExecutive: domain_pallet_executive,
         BlockFees: pallet_block_fees,
@@ -313,6 +319,54 @@ impl pallet_block_fees::Config for Test {
     type DomainChainByteFee = DomainChainByteFee;
 }
 
+pub const INITIAL_SOLUTION_RANGE: SolutionRange =
+    u64::MAX / (1024 * 1024 * 1024 / Piece::SIZE as u64) * 3 / 10;
+
+parameter_types! {
+    pub const BlockAuthoringDelay: SlotNumber = 2;
+    pub const PotEntropyInjectionInterval: BlockNumber = 5;
+    pub const PotEntropyInjectionLookbackDepth: u8 = 2;
+    pub const PotEntropyInjectionDelay: SlotNumber = 4;
+    pub const EraDuration: u32 = 4;
+    // 1GB
+    pub const InitialSolutionRange: SolutionRange = INITIAL_SOLUTION_RANGE;
+    pub const RecentSegments: HistorySize = HistorySize::new(NonZeroU64::new(5).unwrap());
+    pub const RecentHistoryFraction: (HistorySize, HistorySize) = (
+        HistorySize::new(NonZeroU64::new(1).unwrap()),
+        HistorySize::new(NonZeroU64::new(10).unwrap()),
+    );
+    pub const MinSectorLifetime: HistorySize = HistorySize::new(NonZeroU64::new(4).unwrap());
+    pub const RecordSize: u32 = 3840;
+    pub const ExpectedVotesPerBlock: u32 = 9;
+    pub const ReplicationFactor: u16 = 1;
+    pub const ReportLongevity: u64 = 34;
+    pub const ShouldAdjustSolutionRange: bool = false;
+    pub const BlockSlotCount: u32 = 6;
+}
+
+impl pallet_subspace::Config for Test {
+    type RuntimeEvent = RuntimeEvent;
+    type SubspaceOrigin = pallet_subspace::EnsureSubspaceOrigin;
+    type BlockAuthoringDelay = BlockAuthoringDelay;
+    type PotEntropyInjectionInterval = PotEntropyInjectionInterval;
+    type PotEntropyInjectionLookbackDepth = PotEntropyInjectionLookbackDepth;
+    type PotEntropyInjectionDelay = PotEntropyInjectionDelay;
+    type EraDuration = EraDuration;
+    type InitialSolutionRange = InitialSolutionRange;
+    type SlotProbability = SlotProbability;
+    type ConfirmationDepthK = ConfirmationDepthK;
+    type RecentSegments = RecentSegments;
+    type RecentHistoryFraction = RecentHistoryFraction;
+    type MinSectorLifetime = MinSectorLifetime;
+    type ExpectedVotesPerBlock = ExpectedVotesPerBlock;
+    type MaxPiecesInSector = ConstU16<1>;
+    type ShouldAdjustSolutionRange = ShouldAdjustSolutionRange;
+    type EraChangeTrigger = NormalEraChange;
+    type WeightInfo = ();
+    type BlockSlotCount = BlockSlotCount;
+    type ExtensionWeightInfo = pallet_subspace::extensions::weights::SubstrateWeight<Self>;
+}
+
 pub(crate) fn new_test_ext() -> sp_io::TestExternalities {
     let t = frame_system::GenesisConfig::<Test>::default()
         .build_storage()

crates/pallet-domains/src/tests.rs

@@ -155,5 +155,6 @@ runtime-benchmarks = [
     "pallet-transporter/runtime-benchmarks",
     "pallet-utility/runtime-benchmarks",
     "sp-consensus-subspace/runtime-benchmarks",
+    "sp-messenger/runtime-benchmarks",
     "sp-runtime/runtime-benchmarks",
 ]

crates/subspace-runtime/Cargo.toml

@@ -754,6 +754,9 @@ impl pallet_messenger::Config for Runtime {
     type OnXDMRewards = OnXDMRewards;
     type MmrHash = mmr::Hash;
     type MmrProofVerifier = MmrProofVerifier;
+    #[cfg(feature = "runtime-benchmarks")]
+    type StorageKeys = sp_messenger::BenchmarkStorageKeys;
+    #[cfg(not(feature = "runtime-benchmarks"))]
     type StorageKeys = StorageKeys;
     type DomainOwner = Domains;
     type HoldIdentifier = HoldIdentifierWrapper;
@@ -763,6 +766,7 @@ impl pallet_messenger::Config for Runtime {
     type MaxOutgoingMessages = MaxOutgoingMessages;
     type MessengerOrigin = pallet_messenger::EnsureMessengerOrigin;
     type NoteChainTransfer = Transporter;
+    type ExtensionWeightInfo = pallet_messenger::extensions::weights::SubstrateWeight<Runtime>;
 }
 
 impl<C> frame_system::offchain::CreateTransactionBase<C> for Runtime
@@ -1259,6 +1263,7 @@ mod benches {
         [pallet_messenger, Messenger]
         [pallet_transporter, Transporter]
         [pallet_subspace_extension, SubspaceExtensionBench::<Runtime>]
+        [pallet_messenger_from_domains_extension, MessengerFromDomainsExtensionBench::<Runtime>]
     );
 }
 
@@ -1781,6 +1786,7 @@ impl_runtime_apis! {
             use frame_system_benchmarking::Pallet as SystemBench;
             use baseline::Pallet as BaselineBench;
             use pallet_subspace::extensions::benchmarking::Pallet as SubspaceExtensionBench;
+            use pallet_messenger::extensions::benchmarking_from_domains::Pallet as MessengerFromDomainsExtensionBench;
 
             let mut list = Vec::<BenchmarkList>::new();
             list_benchmarks!(list, extra);
@@ -1799,6 +1805,7 @@ impl_runtime_apis! {
             use frame_system_benchmarking::Pallet as SystemBench;
             use baseline::Pallet as BaselineBench;
             use pallet_subspace::extensions::benchmarking::Pallet as SubspaceExtensionBench;
+            use pallet_messenger::extensions::benchmarking_from_domains::Pallet as MessengerFromDomainsExtensionBench;
 
             use frame_support::traits::WhitelistedStorageKeys;
             let whitelist: Vec<TrackedStorageKey> = AllPalletsWithSystem::whitelisted_storage_keys();

crates/subspace-runtime/src/lib.rs

@@ -501,6 +501,11 @@ where
         let bundle_estimated_weight = bundle.estimated_weight();
         let mut maybe_invalid_bundle_type = None;
 
+        // Note: It is okay to use stateless here since all the bundle checks currently do not
+        // require state. But of any checks in the future requires a state read that was part of the
+        // genesis ex: `SelfChainId`, stateless runtime will panic.
+        // So ideal to set the genesis storage as fraud proof already have access to that and would be
+        // no different in terms of verification on both the sides
         let stateless_runtime_api = self.stateless_runtime_api(parent_domain_hash)?;
         let consensus_runtime_api = self.consensus_client.runtime_api();