Merge pull request #3546 from autonomys/fp-validation-benchmark

Add fraud proof validation benchmark and weights

Author: vedhavyas

Cargo.lock

@@ -1036,6 +1036,60 @@ mod benchmarks {
         }
     }
 
+    #[benchmark]
+    fn fraud_proof_pre_check() {
+        let domain_id = register_domain::<T>();
+        let (_, operator_id) =
+            register_helper_operator::<T>(domain_id, T::MinNominatorStake::get());
+
+        let mut target_receipt_hash = None;
+        let mut receipt =
+            BlockTree::<T>::get::<_, DomainBlockNumberFor<T>>(domain_id, Zero::zero())
+                .and_then(BlockTreeNodes::<T>::get)
+                .expect("genesis receipt must exist")
+                .execution_receipt;
+        for i in 1u32..=4u32 {
+            let consensus_block_number = i.into();
+            let domain_block_number = i.into();
+
+            // Run to `block_number`
+            run_to_block::<T>(
+                consensus_block_number,
+                frame_system::Pallet::<T>::block_hash(consensus_block_number - One::one()),
+            );
+
+            // Submit a bundle with the receipt of the last block
+            let bundle = dummy_opaque_bundle(domain_id, operator_id, receipt);
+            assert_ok!(Domains::<T>::submit_bundle(
+                DomainOrigin::ValidatedUnsigned.into(),
+                bundle
+            ));
+
+            // Create ER for the above bundle
+            let head_receipt_number = HeadReceiptNumber::<T>::get(domain_id);
+            let parent_domain_block_receipt = BlockTree::<T>::get(domain_id, head_receipt_number)
+                .expect("parent receipt must exist");
+            receipt = ExecutionReceipt::dummy::<DomainHashingFor<T>>(
+                consensus_block_number,
+                frame_system::Pallet::<T>::block_hash(consensus_block_number),
+                domain_block_number,
+                parent_domain_block_receipt,
+            );
+            if i == 3 {
+                target_receipt_hash.replace(receipt.hash::<DomainHashingFor<T>>());
+            }
+        }
+        assert_eq!(Domains::<T>::head_receipt_number(domain_id), 3u32.into());
+
+        // Construct fraud proof that target the ER at block #3
+        let fraud_proof = FraudProof::dummy_fraud_proof(domain_id, target_receipt_hash.unwrap());
+
+        #[block]
+        {
+            assert_ok!(Domains::<T>::validate_fraud_proof(&fraud_proof));
+        }
+    }
+
     fn register_runtime<T: Config>() -> RuntimeId {
         let genesis_storage = include_bytes!("../res/evm-domain-genesis-storage").to_vec();
         let runtime_id = NextRuntimeId::<T>::get();

crates/pallet-domains/src/benchmarking.rs

@@ -8,6 +8,7 @@ use frame_support::weights::Weight;
 use frame_system::pallet_prelude::RuntimeCallFor;
 use parity_scale_codec::{Decode, Encode};
 use scale_info::prelude::fmt;
+use sp_domains_fraud_proof::weights::fraud_proof_verification_weights;
 use sp_domains_fraud_proof::InvalidTransactionCode;
 use sp_runtime::impl_tx_ext_default;
 use sp_runtime::traits::{
@@ -183,9 +184,9 @@ where
             Some(DomainsCall::submit_bundle { .. }) => {
                 <Runtime as Config>::WeightInfo::validate_submit_bundle()
             }
-            Some(DomainsCall::submit_fraud_proof { .. }) => {
-                // FIXME: proper weight
-                Weight::zero()
+            Some(DomainsCall::submit_fraud_proof { fraud_proof }) => {
+                <Runtime as Config>::WeightInfo::fraud_proof_pre_check()
+                    .saturating_add(fraud_proof_verification_weights::<_, _, _, _>(fraud_proof))
             }
             Some(DomainsCall::submit_receipt { .. }) => {
                 <Runtime as Config>::WeightInfo::validate_singleton_receipt()

crates/pallet-domains/src/extensions.rs

@@ -2647,7 +2647,19 @@ impl<T: Config> Pallet<T> {
                 })?
             }
             #[cfg(any(feature = "std", feature = "runtime-benchmarks"))]
-            FraudProofVariant::Dummy => {}
+            FraudProofVariant::Dummy => {
+                // Almost every fraud proof (except `InvalidDomainBlockHash` fraud proof) need to call
+                // `get_domain_runtime_code_for_receipt` thus we include this part in the benchmark of
+                // the dummy fraud proof.
+                //
+                // NOTE: the dummy fraud proof's `maybe_domain_runtime_code_proof` is `None` thus
+                // this proof's verification is not included in the benchmark here.
+                let _ = Self::get_domain_runtime_code_for_receipt(
+                    domain_id,
+                    &bad_receipt,
+                    fraud_proof.maybe_domain_runtime_code_proof.clone(),
+                )?;
+            }
         }
 
         // The priority of fraud proof is determined by how many blocks left before the bad ER

crates/pallet-domains/src/lib.rs

@@ -52,6 +52,7 @@ pub trait WeightInfo {
 	fn submit_receipt() -> Weight;
 	fn validate_submit_bundle() -> Weight;
 	fn validate_singleton_receipt() -> Weight;
+	fn fraud_proof_pre_check() -> Weight;
 }
 
 /// Weights for pallet_domains using the Substrate node and recommended hardware.
@@ -626,6 +627,25 @@ impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
 			.saturating_add(T::DbWeight::get().reads(22))
 			.saturating_add(T::DbWeight::get().writes(2))
 	}
+	/// Storage: `Domains::BlockTreeNodes` (r:2 w:0)
+	/// Proof: `Domains::BlockTreeNodes` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Domains::HeadReceiptNumber` (r:1 w:0)
+	/// Proof: `Domains::HeadReceiptNumber` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Domains::DomainRegistry` (r:1 w:0)
+	/// Proof: `Domains::DomainRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Domains::RuntimeRegistry` (r:1 w:0)
+	/// Proof: `Domains::RuntimeRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Domains::LatestConfirmedDomainExecutionReceipt` (r:1 w:0)
+	/// Proof: `Domains::LatestConfirmedDomainExecutionReceipt` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn fraud_proof_pre_check() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2483056`
+		//  Estimated: `2488996`
+		// Minimum execution time: 931_000_000 picoseconds.
+		Weight::from_parts(976_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 2488996))
+			.saturating_add(T::DbWeight::get().reads(6))
+	}
 }
 
 // For backwards compatibility and tests
@@ -1199,4 +1219,23 @@ impl WeightInfo for () {
 			.saturating_add(ParityDbWeight::get().reads(22))
 			.saturating_add(ParityDbWeight::get().writes(2))
 	}
+	/// Storage: `Domains::BlockTreeNodes` (r:2 w:0)
+	/// Proof: `Domains::BlockTreeNodes` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Domains::HeadReceiptNumber` (r:1 w:0)
+	/// Proof: `Domains::HeadReceiptNumber` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Domains::DomainRegistry` (r:1 w:0)
+	/// Proof: `Domains::DomainRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Domains::RuntimeRegistry` (r:1 w:0)
+	/// Proof: `Domains::RuntimeRegistry` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	/// Storage: `Domains::LatestConfirmedDomainExecutionReceipt` (r:1 w:0)
+	/// Proof: `Domains::LatestConfirmedDomainExecutionReceipt` (`max_values`: None, `max_size`: None, mode: `Measured`)
+	fn fraud_proof_pre_check() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `2483056`
+		//  Estimated: `2488996`
+		// Minimum execution time: 931_000_000 picoseconds.
+		Weight::from_parts(976_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 2488996))
+			.saturating_add(ParityDbWeight::get().reads(6))
+	}
 }

crates/pallet-domains/src/weights.rs

@@ -38,10 +38,12 @@ sp-trie.workspace = true
 sp-weights.workspace = true
 subspace-core-primitives.workspace = true
 subspace-runtime-primitives.workspace = true
+tracing.workspace = true
 trie-db.workspace = true
 thiserror.workspace = true
 
 [dev-dependencies]
+criterion.workspace = true
 domain-block-preprocessor.workspace = true
 domain-test-service.workspace = true
 ethereum.workspace = true
@@ -52,13 +54,18 @@ frame-system.workspace = true
 futures.workspace = true
 libsecp256k1 = { workspace = true, features = ["static-context", "hmac"] }
 pallet-balances.workspace = true
+pallet-domains.workspace = true
 pallet-ethereum.workspace = true
 rand = { workspace = true, features = ["min_const_gen"] }
 rlp.workspace = true
 sp-core.workspace = true
+sp-externalities.workspace = true
+sp-weights.workspace = true
 sc-cli.workspace = true
 sp-domains = { workspace = true, features = ["test-ethereum"] }
+sc-domains.workspace = true
 sc-service.workspace = true
+subspace-test-runtime.workspace = true
 subspace-test-service.workspace = true
 subspace-runtime-primitives.workspace = true
 tempfile.workspace = true
@@ -98,3 +105,7 @@ std = [
     "thiserror/std",
 ]
 runtime-benchmarks = []
+
+[[bench]]
+name = "fraud_proof_verification"
+harness = false