remove state root storage since relayer would not use it anymore but …

…instead rely on on Confirmed domain blocks

crates/pallet-domains/src/block_tree.rs

@@ -1,6 +1,5 @@
 //! Domain block tree
 
-use crate::pallet::StateRoots;
 use crate::{
     BalanceOf, BlockTree, BlockTreeNodes, Config, ConsensusBlockHash, DomainBlockNumberFor,
     DomainHashingFor, ExecutionInbox, ExecutionReceiptOf, HeadReceiptExtended, HeadReceiptNumber,
@@ -313,12 +312,6 @@ pub(crate) fn process_execution_receipt<T: Config>(
                     operator_ids,
                 } = BlockTreeNodes::<T>::take(receipt_hash).ok_or(Error::MissingDomainBlock)?;
 
-                _ = StateRoots::<T>::take((
-                    domain_id,
-                    to_prune,
-                    execution_receipt.domain_block_hash,
-                ));
-
                 // Collect the paid bundle storage fees and the invalid bundle author
                 let mut paid_bundle_storage_fees = BTreeMap::new();
                 let mut invalid_bundle_authors = Vec::new();
@@ -395,14 +388,6 @@ fn add_new_receipt_to_block_tree<T: Config>(
     // Construct and add a new domain block to the block tree
     let er_hash = execution_receipt.hash::<DomainHashingFor<T>>();
     let domain_block_number = execution_receipt.domain_block_number;
-    StateRoots::<T>::insert(
-        (
-            domain_id,
-            domain_block_number,
-            execution_receipt.domain_block_hash,
-        ),
-        execution_receipt.final_state_root,
-    );
 
     BlockTree::<T>::insert(domain_id, domain_block_number, er_hash);
     let block_tree_node = BlockTreeNode {
@@ -425,14 +410,6 @@ pub(crate) fn import_genesis_receipt<T: Config>(
     };
     // NOTE: no need to update the head receipt number as `HeadReceiptNumber` is using `ValueQuery`
     BlockTree::<T>::insert(domain_id, domain_block_number, er_hash);
-    StateRoots::<T>::insert(
-        (
-            domain_id,
-            domain_block_number,
-            block_tree_node.execution_receipt.domain_block_hash,
-        ),
-        block_tree_node.execution_receipt.final_state_root,
-    );
     BlockTreeNodes::<T>::insert(er_hash, block_tree_node);
 }
 

crates/pallet-domains/src/lib.rs

@@ -502,17 +502,6 @@ mod pallet {
     pub(super) type HeadReceiptExtended<T: Config> =
         StorageMap<_, Identity, DomainId, bool, ValueQuery>;
 
-    /// State root mapped again each domain (block, hash)
-    /// This acts as an index for other protocols like XDM to fetch state roots faster.
-    #[pallet::storage]
-    pub(super) type StateRoots<T: Config> = StorageMap<
-        _,
-        Identity,
-        (DomainId, DomainBlockNumberFor<T>, T::DomainHash),
-        T::DomainHash,
-        OptionQuery,
-    >;
-
     /// The consensus block hash used to verify ER,
     /// only store the consensus block hash for a domain
     /// if that consensus block contains bundle of the domain, the hash will be pruned when the ER
@@ -996,17 +985,9 @@ mod pallet {
                     let receipt_hash = BlockTree::<T>::take(domain_id, to_prune)
                         .ok_or::<Error<T>>(FraudProofError::BadReceiptNotFound.into())?;
 
-                    let BlockTreeNode {
-                        execution_receipt,
-                        operator_ids,
-                    } = BlockTreeNodes::<T>::take(receipt_hash)
-                        .ok_or::<Error<T>>(FraudProofError::BadReceiptNotFound.into())?;
-
-                    let _ = StateRoots::<T>::take((
-                        domain_id,
-                        execution_receipt.domain_block_number,
-                        execution_receipt.domain_block_hash,
-                    ));
+                    let BlockTreeNode { operator_ids, .. } =
+                        BlockTreeNodes::<T>::take(receipt_hash)
+                            .ok_or::<Error<T>>(FraudProofError::BadReceiptNotFound.into())?;
 
                     // NOTE: the operator id will be deduplicated since we are using `BTreeMap`
                     // and slashed reason will hold earliest bad execution receipt hash which this
@@ -1506,14 +1487,6 @@ impl<T: Config> Pallet<T> {
         Some(HeadDomainNumber::<T>::get(domain_id))
     }
 
-    pub fn domain_state_root(
-        domain_id: DomainId,
-        domain_block_number: DomainBlockNumberFor<T>,
-        domain_block_hash: T::DomainHash,
-    ) -> Option<T::DomainHash> {
-        StateRoots::<T>::get((domain_id, domain_block_number, domain_block_hash))
-    }
-
     pub fn runtime_id(domain_id: DomainId) -> Option<RuntimeId> {
         DomainRegistry::<T>::get(domain_id)
             .map(|domain_object| domain_object.domain_config.runtime_id)

crates/sp-domains/src/lib.rs

@@ -1044,12 +1044,6 @@ sp_api::decl_runtime_apis! {
         /// Returns the current best number of the domain.
         fn domain_best_number(domain_id: DomainId) -> Option<HeaderNumberFor<DomainHeader>>;
 
-        /// Returns the chain state root at the given block.
-        fn domain_state_root(
-            domain_id: DomainId,
-            number: HeaderNumberFor<DomainHeader>,
-            hash: HeaderHashFor<DomainHeader>) -> Option<HeaderHashFor<DomainHeader>>;
-
         /// Returns the execution receipt
         fn execution_receipt(receipt_hash: HeaderHashFor<DomainHeader>) -> Option<ExecutionReceiptFor<DomainHeader, Block, Balance>>;
 

crates/subspace-runtime/src/lib.rs

@@ -1076,10 +1076,6 @@ impl_runtime_apis! {
             Domains::domain_best_number(domain_id)
         }
 
-        fn domain_state_root(domain_id: DomainId, number: DomainNumber, hash: DomainHash) -> Option<DomainHash>{
-            Domains::domain_state_root(domain_id, number, hash)
-        }
-
         fn execution_receipt(receipt_hash: DomainHash) -> Option<ExecutionReceiptFor<DomainHeader, Block, Balance>> {
             Domains::execution_receipt(receipt_hash)
         }

domains/client/relayer/src/lib.rs

@@ -53,8 +53,6 @@ pub enum Error {
     ApiError(sp_api::ApiError),
     /// Emits when the core domain block is not yet confirmed on the system domain.
     DomainNonConfirmedOnConsensusChain,
-    /// Emits when the core domain block state root is invalid.
-    DomainStateRootInvalid,
     /// Failed to submit a cross domain message
     UnableToSubmitCrossDomainMessage(TrySendError<GossipMessage>),
     /// Invalid ChainId
@@ -321,36 +319,11 @@ where
             return Ok(());
         }
 
-        // verify if the state root is matching.
-        let domain_number = *domain_block_header.number();
-        if !consensus_chain_api
-            .domain_state_root(
-                best_consensus_chain_hash,
-                domain_id,
-                domain_number,
-                confirmed_block_hash,
-            )?
-            .map(|state_root| state_root == (*domain_block_header.state_root()))
-            .unwrap_or_else(|| {
-                // if this is genesis block, ignore as state root of genesis for domain is not tracked on runtime
-                domain_number.is_zero()
-            })
-        {
-            tracing::error!(
-                target: LOG_TARGET,
-                "Domain state root mismatch at: Number: {:?}, Hash: {:?}",
-                domain_number,
-                confirmed_block_hash
-            );
-            return Err(Error::DomainStateRootInvalid);
-        }
-
-        // generate domain proof that points to the state root of the domain block on Consensus chain.
+        // generate domain proof that points to the confirmed domain block on consensus chain
         let storage_key = consensus_chain_api
             .confirmed_domain_block_storage_key(best_consensus_chain_hash, domain_id)?;
 
-        // construct storage proof for the core domain state root using system domain backend.
-        let domain_state_root_proof = consensus_chain_client.read_proof(
+        let domain_proof = consensus_chain_client.read_proof(
             best_consensus_chain_hash,
             &mut [storage_key.as_ref()].into_iter(),
         )?;
@@ -365,7 +338,7 @@ where
                     block_hash,
                     key,
                     *best_consensus_chain_block_header.state_root(),
-                    domain_state_root_proof.clone(),
+                    domain_proof.clone(),
                 )
             },
             |msg| Self::gossip_outbox_message(domain_client, msg, gossip_message_sink),
@@ -381,7 +354,7 @@ where
                     block_id,
                     key,
                     *best_consensus_chain_block_header.state_root(),
-                    domain_state_root_proof.clone(),
+                    domain_proof.clone(),
                 )
             },
             |msg| Self::gossip_inbox_message_response(domain_client, msg, gossip_message_sink),

domains/primitives/messenger-host-functions/Cargo.toml

@@ -46,4 +46,4 @@ std = [
     "sp-std/std",
 ]
 
-runtime-benchmarks = []
+runtime-benchmarks = []

test/subspace-test-runtime/src/lib.rs

@@ -1268,10 +1268,6 @@ impl_runtime_apis! {
             Domains::domain_best_number(domain_id)
         }
 
-        fn domain_state_root(domain_id: DomainId, number: DomainNumber, hash: DomainHash) -> Option<DomainHash>{
-            Domains::domain_state_root(domain_id, number, hash)
-        }
-
         fn execution_receipt(receipt_hash: DomainHash) -> Option<ExecutionReceiptFor<DomainHeader, Block, Balance>> {
             Domains::execution_receipt(receipt_hash)
         }