Merge branch 'main' into snap-sync-refactoring

Author: shamil-gadelshin

Cargo.lock

@@ -28,8 +28,8 @@ use frame_system::{Pallet as System, RawOrigin};
 use sp_core::crypto::{Ss58Codec, UncheckedFrom};
 use sp_core::ByteArray;
 use sp_domains::{
-    dummy_opaque_bundle, ConfirmedDomainBlock, DomainId, ExecutionReceipt, OperatorAllowList,
-    OperatorId, OperatorPublicKey, OperatorSignature, PermissionedActionAllowedBy, RuntimeType,
+    dummy_opaque_bundle, BlockFees, DomainId, ExecutionReceipt, OperatorAllowList, OperatorId,
+    OperatorPublicKey, OperatorSignature, PermissionedActionAllowedBy, RuntimeType, Transfers,
 };
 use sp_domains_fraud_proof::fraud_proof::FraudProof;
 use sp_runtime::traits::{CheckedAdd, One, Zero};
@@ -189,7 +189,7 @@ mod benchmarks {
 
     /// Benchmark prune bad ER and slash the submitter based on the number of submitter
     #[benchmark]
-    fn handle_bad_receipt(n: Linear<1, MAX_BUNLDE_PER_BLOCK>) {
+    fn handle_bad_receipt(n: Linear<1, MAX_BUNDLE_PER_BLOCK>) {
         let minimum_nominator_stake = T::MinNominatorStake::get();
         let domain_id = register_domain::<T>();
         let mut operator_ids = Vec::new();
@@ -246,8 +246,8 @@ mod benchmarks {
     /// in this block
     #[benchmark]
     fn confirm_domain_block(
-        n: Linear<1, MAX_BUNLDE_PER_BLOCK>,
-        s: Linear<0, MAX_BUNLDE_PER_BLOCK>,
+        n: Linear<1, MAX_BUNDLE_PER_BLOCK>,
+        s: Linear<0, MAX_BUNDLE_PER_BLOCK>,
     ) {
         let minimum_nominator_stake = T::MinNominatorStake::get();
         let operator_rewards =
@@ -314,7 +314,7 @@ mod benchmarks {
     /// Benchmark `operator_take_reward_tax_and_stake` based on the number of operator who has reward
     /// in the current epoch
     #[benchmark]
-    fn operator_reward_tax_and_restake(n: Linear<1, MAX_BUNLDE_PER_BLOCK>) {
+    fn operator_reward_tax_and_restake(n: Linear<1, MAX_BUNDLE_PER_BLOCK>) {
         let minimum_nominator_stake = T::MinNominatorStake::get();
         let operator_rewards =
             T::Currency::minimum_balance().saturating_mul(BalanceOf::<T>::from(1000u32));
@@ -753,19 +753,26 @@ mod benchmarks {
         do_finalize_domain_epoch_staking::<T>(domain_id)
             .expect("finalize domain staking should success");
 
-        // Update the `LatestConfirmedDomainBlock` so unlock can success
+        // Update the `LatestConfirmedDomainExecutionReceipt` so unlock can success
         let confirmed_domain_block_number =
             Pallet::<T>::latest_confirmed_domain_block_number(domain_id)
                 + T::StakeWithdrawalLockingPeriod::get()
                 + One::one();
-        LatestConfirmedDomainBlock::<T>::insert(
+        LatestConfirmedDomainExecutionReceipt::<T>::insert(
             domain_id,
-            ConfirmedDomainBlock {
-                block_number: confirmed_domain_block_number,
-                block_hash: Default::default(),
-                parent_block_receipt_hash: Default::default(),
-                state_root: Default::default(),
-                extrinsics_root: Default::default(),
+            ExecutionReceiptOf::<T> {
+                domain_block_number: confirmed_domain_block_number,
+                domain_block_hash: Default::default(),
+                domain_block_extrinsic_root: Default::default(),
+                parent_domain_block_receipt_hash: Default::default(),
+                consensus_block_number: Default::default(),
+                consensus_block_hash: Default::default(),
+                inboxed_bundles: vec![],
+                final_state_root: Default::default(),
+                execution_trace: vec![],
+                execution_trace_root: Default::default(),
+                block_fees: BlockFees::default(),
+                transfers: Transfers::default(),
             },
         );
 
@@ -797,19 +804,26 @@ mod benchmarks {
             operator_id,
         ));
 
-        // Update the `LatestConfirmedDomainBlock` so unlock can success
+        // Update the `LatestConfirmedDomainExecutionReceipt` so unlock can success
         let confirmed_domain_block_number =
             Pallet::<T>::latest_confirmed_domain_block_number(domain_id)
                 + T::StakeWithdrawalLockingPeriod::get()
                 + One::one();
-        LatestConfirmedDomainBlock::<T>::insert(
+        LatestConfirmedDomainExecutionReceipt::<T>::insert(
             domain_id,
-            ConfirmedDomainBlock {
-                block_number: confirmed_domain_block_number,
-                block_hash: Default::default(),
-                parent_block_receipt_hash: Default::default(),
-                state_root: Default::default(),
-                extrinsics_root: Default::default(),
+            ExecutionReceiptOf::<T> {
+                domain_block_number: confirmed_domain_block_number,
+                domain_block_hash: Default::default(),
+                domain_block_extrinsic_root: Default::default(),
+                parent_domain_block_receipt_hash: Default::default(),
+                consensus_block_number: Default::default(),
+                consensus_block_hash: Default::default(),
+                inboxed_bundles: vec![],
+                final_state_root: Default::default(),
+                execution_trace: vec![],
+                execution_trace_root: Default::default(),
+                block_fees: BlockFees::default(),
+                transfers: Transfers::default(),
             },
         );
 

crates/pallet-domains/src/benchmarking.rs

@@ -7,7 +7,7 @@ use crate::{
     BalanceOf, BlockTree, BlockTreeNodeFor, BlockTreeNodes, Config, ConsensusBlockHash,
     DomainBlockNumberFor, DomainHashingFor, DomainRuntimeUpgradeRecords, ExecutionInbox,
     ExecutionReceiptOf, HeadReceiptExtended, HeadReceiptNumber, InboxedBundleAuthor,
-    LatestConfirmedDomainBlock, LatestSubmittedER, Pallet, ReceiptHashFor,
+    LatestConfirmedDomainExecutionReceipt, LatestSubmittedER, Pallet, ReceiptHashFor,
 };
 #[cfg(not(feature = "std"))]
 use alloc::vec::Vec;
@@ -18,8 +18,8 @@ use scale_info::TypeInfo;
 use sp_core::Get;
 use sp_domains::merkle_tree::MerkleTree;
 use sp_domains::{
-    ChainId, ConfirmedDomainBlock, DomainId, DomainsTransfersTracker, ExecutionReceipt,
-    OnChainRewards, OperatorId, Transfers,
+    ChainId, DomainId, DomainsTransfersTracker, ExecutionReceipt, OnChainRewards, OperatorId,
+    Transfers,
 };
 use sp_runtime::traits::{BlockNumberProvider, CheckedSub, One, Saturating, Zero};
 use sp_std::cmp::Ordering;
@@ -371,6 +371,11 @@ pub(crate) fn process_execution_receipt<T: Config>(
                 // its receipt's `extrinsics_root` anymore.
                 let _ = ExecutionInbox::<T>::clear_prefix((domain_id, to_prune), u32::MAX, None);
 
+                LatestConfirmedDomainExecutionReceipt::<T>::insert(
+                    domain_id,
+                    execution_receipt.clone(),
+                );
+
                 ConsensusBlockHash::<T>::remove(
                     domain_id,
                     execution_receipt.consensus_block_number,
@@ -405,18 +410,6 @@ pub(crate) fn process_execution_receipt<T: Config>(
                         T::OnChainRewards::on_chain_rewards(chain_id, reward)
                     });
 
-                LatestConfirmedDomainBlock::<T>::insert(
-                    domain_id,
-                    ConfirmedDomainBlock {
-                        block_number: to_prune,
-                        block_hash: execution_receipt.domain_block_hash,
-                        parent_block_receipt_hash: execution_receipt
-                            .parent_domain_block_receipt_hash,
-                        state_root: execution_receipt.final_state_root,
-                        extrinsics_root: execution_receipt.domain_block_extrinsic_root,
-                    },
-                );
-
                 return Ok(Some(ConfirmedDomainBlockInfo {
                     domain_block_number: to_prune,
                     operator_ids,
@@ -559,16 +552,7 @@ pub(crate) fn import_genesis_receipt<T: Config>(
     let er_hash = genesis_receipt.hash::<DomainHashingFor<T>>();
     let domain_block_number = genesis_receipt.domain_block_number;
 
-    LatestConfirmedDomainBlock::<T>::insert(
-        domain_id,
-        ConfirmedDomainBlock {
-            block_number: domain_block_number,
-            block_hash: genesis_receipt.domain_block_hash,
-            parent_block_receipt_hash: Default::default(),
-            state_root: genesis_receipt.final_state_root,
-            extrinsics_root: genesis_receipt.domain_block_extrinsic_root,
-        },
-    );
+    LatestConfirmedDomainExecutionReceipt::<T>::insert(domain_id, genesis_receipt.clone());
 
     let block_tree_node = BlockTreeNode {
         execution_receipt: genesis_receipt,
@@ -616,10 +600,12 @@ mod tests {
     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, Test,
+        register_genesis_domain, run_to_block, BlockTreePruningDepth, Domains, Test,
     };
+    use crate::FrozenDomains;
     use frame_support::dispatch::RawOrigin;
     use frame_support::{assert_err, assert_ok};
+    use frame_system::Origin;
     use sp_core::H256;
     use sp_domains::{BundleDigest, InboxedBundle, InvalidBundleType};
 
@@ -971,6 +957,40 @@ mod tests {
         });
     }
 
+    #[test]
+    fn test_prune_domain_execution_receipt() {
+        let creator = 0u128;
+        let operator_id = 1u64;
+        let mut ext = new_test_ext_with_extensions();
+        ext.execute_with(|| {
+            let domain_id = register_genesis_domain(creator, vec![operator_id]);
+            let _next_receipt = extend_block_tree_from_zero(domain_id, operator_id, 3);
+            let head_receipt_number = HeadReceiptNumber::<Test>::get(domain_id);
+
+            // freeze domain
+            assert!(!FrozenDomains::<Test>::get().contains(&domain_id));
+            Domains::freeze_domain(Origin::<Test>::Root.into(), domain_id).unwrap();
+            assert!(FrozenDomains::<Test>::get().contains(&domain_id));
+
+            // prune execution recept
+            let head_receipt_hash = BlockTree::<Test>::get(domain_id, head_receipt_number).unwrap();
+            Domains::prune_domain_execution_receipt(
+                Origin::<Test>::Root.into(),
+                domain_id,
+                head_receipt_hash,
+            )
+            .unwrap();
+            assert_eq!(
+                HeadReceiptNumber::<Test>::get(domain_id),
+                head_receipt_number - 1
+            );
+
+            // unfreeze domain
+            Domains::unfreeze_domain(Origin::<Test>::Root.into(), domain_id).unwrap();
+            assert!(!FrozenDomains::<Test>::get().contains(&domain_id));
+        })
+    }
+
     #[test]
     fn test_invalid_receipt() {
         let creator = 0u128;