add runtime compatibility code in decoding ER and BlockTreeNode and remove unnecessary clone

vedhavyas · vedhavyas · commit 5e66e75fbb90 · 2025-07-09T15:25:33.000+05:30
diff --git a/crates/pallet-domains/src/block_tree.rs b/crates/pallet-domains/src/block_tree.rs
@@ -3,6 +3,7 @@
 #[cfg(not(feature = "std"))]
 extern crate alloc;
 
+use crate::migrations::execution_receipt::{get_block_tree_node, take_block_tree_node};
 use crate::{
     BalanceOf, BlockTree, BlockTreeNodeFor, BlockTreeNodes, Config, ConsensusBlockHash,
     DomainBlockNumberFor, DomainGenesisBlockExecutionReceipt, DomainHashingFor,
@@ -54,7 +55,6 @@ pub enum Error {
 }
 
 #[derive(TypeInfo, Debug, Encode, Decode, Clone, PartialEq, Eq)]
-// TODO: migrate
 pub struct BlockTreeNode<Number, Hash, DomainNumber, DomainHash, Balance> {
     /// The full ER for this block.
     pub execution_receipt: ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>,
@@ -458,12 +458,10 @@ pub(crate) fn process_execution_receipt<T: Config>(
         }
         AcceptedReceiptType::CurrentHead => {
             // Add confirmation to the current head receipt
-            BlockTreeNodes::<T>::mutate(er_hash, |maybe_node| {
-                let node = maybe_node.as_mut().expect(
-                    "The domain block of `CurrentHead` receipt is checked to be exist in `execution_receipt_type`; qed"
-                );
-                node.operator_ids.push(submitter);
-            });
+            let mut node = get_block_tree_node::<T>(er_hash)
+                .expect("The domain block of `CurrentHead` receipt is checked to be exist in `execution_receipt_type`; qed");
+            node.operator_ids.push(submitter);
+            BlockTreeNodes::<T>::insert(er_hash, node);
         }
     }
 
@@ -608,7 +606,7 @@ pub(crate) fn prune_receipt<T: Config>(
         None => return Ok(None),
     };
     let block_tree_node =
-        BlockTreeNodes::<T>::take(receipt_hash).ok_or(Error::MissingDomainBlock)?;
+        take_block_tree_node::<T>(receipt_hash).ok_or(Error::MissingDomainBlock)?;
 
     // If the pruned ER is the operator's `latest_submitted_er` for this domain, it means either:
     //
diff --git a/crates/pallet-domains/src/lib.rs b/crates/pallet-domains/src/lib.rs
@@ -24,6 +24,7 @@ extern crate alloc;
 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::migrations::execution_receipt::get_block_tree_node;
 use crate::runtime_registry::into_complete_raw_genesis;
 use crate::staking::OperatorStatus;
 #[cfg(feature = "runtime-benchmarks")]
@@ -227,6 +228,7 @@ mod pallet {
         DomainConfigParams, DomainObject, Error as DomainRegistryError, do_instantiate_domain,
         do_update_domain_allow_list,
     };
+    use crate::migrations::execution_receipt::get_block_tree_node;
     use crate::runtime_registry::{
         DomainRuntimeUpgradeEntry, Error as RuntimeRegistryError, ScheduledRuntimeUpgrade,
         do_register_runtime, do_schedule_runtime_upgrade, do_upgrade_runtimes,
@@ -704,15 +706,11 @@ mod pallet {
 
     /// Storage to hold all the domain's latest confirmed block.
     #[pallet::storage]
-    #[pallet::getter(fn latest_confirmed_domain_execution_receipt)]
-    // TODO: migration
     pub type LatestConfirmedDomainExecutionReceipt<T: Config> =
         StorageMap<_, Identity, DomainId, ExecutionReceiptOf<T>, OptionQuery>;
 
     /// Storage to hold all the domain's genesis execution receipt.
     #[pallet::storage]
-    #[pallet::getter(fn domain_genesis_block_execution_receipt)]
-    // TODO: migration
     pub type DomainGenesisBlockExecutionReceipt<T: Config> =
         StorageMap<_, Identity, DomainId, ExecutionReceiptOf<T>, OptionQuery>;
 
@@ -1345,7 +1343,7 @@ mod pallet {
             let domain_id = fraud_proof.domain_id();
             let bad_receipt_hash = fraud_proof.targeted_bad_receipt_hash();
             let head_receipt_number = HeadReceiptNumber::<T>::get(domain_id);
-            let bad_receipt_number = *BlockTreeNodes::<T>::get(bad_receipt_hash)
+            let bad_receipt_number = *get_block_tree_node::<T>(bad_receipt_hash)
                 .ok_or::<Error<T>>(FraudProofError::BadReceiptNotFound.into())?
                 .execution_receipt
                 .domain_block_number();
@@ -1720,7 +1718,7 @@ mod pallet {
             );
 
             let head_receipt_number = HeadReceiptNumber::<T>::get(domain_id);
-            let bad_receipt_number = *BlockTreeNodes::<T>::get(bad_receipt_hash)
+            let bad_receipt_number = *get_block_tree_node::<T>(bad_receipt_hash)
                 .ok_or::<Error<T>>(FraudProofError::BadReceiptNotFound.into())?
                 .execution_receipt
                 .domain_block_number();
@@ -2200,7 +2198,7 @@ impl<T: Config> Pallet<T> {
     }
 
     pub fn genesis_state_root(domain_id: DomainId) -> Option<H256> {
-        DomainGenesisBlockExecutionReceipt::<T>::get(domain_id)
+        crate::migrations::execution_receipt::domain_genesis_block_execution_receipt::<T>(domain_id)
             .map(|er| (*er.final_state_root()).into())
     }
 
@@ -2486,7 +2484,7 @@ impl<T: Config> Pallet<T> {
     ) -> Result<(DomainId, TransactionPriority), FraudProofError> {
         let domain_id = fraud_proof.domain_id();
         let bad_receipt_hash = fraud_proof.targeted_bad_receipt_hash();
-        let bad_receipt = BlockTreeNodes::<T>::get(bad_receipt_hash)
+        let bad_receipt = get_block_tree_node::<T>(bad_receipt_hash)
             .ok_or(FraudProofError::BadReceiptNotFound)?
             .execution_receipt;
         let bad_receipt_domain_block_number = *bad_receipt.domain_block_number();
@@ -2562,7 +2560,7 @@ impl<T: Config> Pallet<T> {
                 digest_storage_proof,
             }) => {
                 let parent_receipt =
-                    BlockTreeNodes::<T>::get(bad_receipt.parent_domain_block_receipt_hash())
+                    get_block_tree_node::<T>(*bad_receipt.parent_domain_block_receipt_hash())
                         .ok_or(FraudProofError::ParentReceiptNotFound)?
                         .execution_receipt;
                 verify_invalid_domain_block_hash_fraud_proof::<
@@ -2615,7 +2613,7 @@ impl<T: Config> Pallet<T> {
                     fraud_proof.maybe_domain_runtime_code_proof.clone(),
                 )?;
                 let bad_receipt_parent =
-                    BlockTreeNodes::<T>::get(bad_receipt.parent_domain_block_receipt_hash())
+                    get_block_tree_node::<T>(*bad_receipt.parent_domain_block_receipt_hash())
                         .ok_or(FraudProofError::ParentReceiptNotFound)?
                         .execution_receipt;
 
@@ -2638,7 +2636,7 @@ impl<T: Config> Pallet<T> {
                 )?;
 
                 let bad_receipt_parent =
-                    BlockTreeNodes::<T>::get(bad_receipt.parent_domain_block_receipt_hash())
+                    get_block_tree_node::<T>(*bad_receipt.parent_domain_block_receipt_hash())
                         .ok_or(FraudProofError::ParentReceiptNotFound)?
                         .execution_receipt;
 
@@ -2775,16 +2773,20 @@ impl<T: Config> Pallet<T> {
     /// Returns the latest confirmed domain block number for a given domain
     /// Zero block is always a default confirmed block.
     pub fn latest_confirmed_domain_block_number(domain_id: DomainId) -> DomainBlockNumberFor<T> {
-        LatestConfirmedDomainExecutionReceipt::<T>::get(domain_id)
-            .map(|er| *er.domain_block_number())
-            .unwrap_or_default()
+        crate::migrations::execution_receipt::latest_confirmed_domain_execution_receipt::<T>(
+            domain_id,
+        )
+        .map(|er| *er.domain_block_number())
+        .unwrap_or_default()
     }
 
     pub fn latest_confirmed_domain_block(
         domain_id: DomainId,
     ) -> Option<(DomainBlockNumberFor<T>, T::DomainHash)> {
-        LatestConfirmedDomainExecutionReceipt::<T>::get(domain_id)
-            .map(|er| (*er.domain_block_number(), *er.domain_block_hash()))
+        crate::migrations::execution_receipt::latest_confirmed_domain_execution_receipt::<T>(
+            domain_id,
+        )
+        .map(|er| (*er.domain_block_number(), *er.domain_block_hash()))
     }
 
     /// Returns the domain bundle limit of the given domain
@@ -2895,7 +2897,7 @@ impl<T: Config> Pallet<T> {
     }
 
     pub fn execution_receipt(receipt_hash: ReceiptHashFor<T>) -> Option<ExecutionReceiptOf<T>> {
-        BlockTreeNodes::<T>::get(receipt_hash).map(|db| db.execution_receipt)
+        get_block_tree_node::<T>(receipt_hash).map(|db| db.execution_receipt)
     }
 
     pub fn receipt_hash(
@@ -3047,7 +3049,7 @@ impl<T: Config> Pallet<T> {
         // that used to derive `receipt` we need to use runtime code at `parent_receipt.consensus_block_number`
         let at = {
             let parent_receipt =
-                BlockTreeNodes::<T>::get(receipt.parent_domain_block_receipt_hash())
+                get_block_tree_node::<T>(*receipt.parent_domain_block_receipt_hash())
                     .ok_or(FraudProofError::ParentReceiptNotFound)?
                     .execution_receipt;
             *parent_receipt.consensus_block_number()
@@ -3172,6 +3174,14 @@ impl<T: Config> Pallet<T> {
     ) -> Option<sp_domains::PermissionedActionAllowedBy<EthereumAccountId>> {
         EvmDomainContractCreationAllowedByCalls::<T>::get(domain_id).maybe_call
     }
+
+    pub fn latest_confirmed_domain_execution_receipt(
+        domain_id: DomainId,
+    ) -> Option<ExecutionReceiptOf<T>> {
+        crate::migrations::execution_receipt::latest_confirmed_domain_execution_receipt::<T>(
+            domain_id,
+        )
+    }
 }
 
 impl<T: Config> sp_domains::DomainOwner<T::AccountId> for Pallet<T> {
diff --git a/crates/pallet-domains/src/migrations.rs b/crates/pallet-domains/src/migrations.rs
@@ -1,3 +1,4 @@
+pub(crate) mod execution_receipt;
 mod v1_to_v5;
 
 pub use v1_to_v5::VersionCheckedMigrateDomainsV1ToV5;
diff --git a/crates/pallet-domains/src/migrations/execution_receipt.rs b/crates/pallet-domains/src/migrations/execution_receipt.rs
@@ -0,0 +1,103 @@
+#[cfg(not(feature = "std"))]
+extern crate alloc;
+
+use crate::pallet::BlockTreeNodes;
+use crate::{
+    BalanceOf, BlockTreeNodeFor, Config, DomainBlockNumberFor, DomainGenesisBlockExecutionReceipt,
+    ExecutionReceiptOf, LatestConfirmedDomainExecutionReceipt, ReceiptHashFor,
+};
+#[cfg(not(feature = "std"))]
+use alloc::vec::Vec;
+use frame_support::pallet_prelude::{Encode, TypeInfo};
+use frame_support::storage::generator::StorageMap;
+use frame_system::pallet_prelude::BlockNumberFor;
+use parity_scale_codec::Decode;
+use sp_domains::execution_receipt::execution_receipt_v0::ExecutionReceiptV0;
+use sp_domains::{DomainId, OperatorId};
+
+pub(crate) type ExecutionReceiptV0Of<T> = ExecutionReceiptV0<
+    BlockNumberFor<T>,
+    <T as frame_system::Config>::Hash,
+    DomainBlockNumberFor<T>,
+    <T as Config>::DomainHash,
+    BalanceOf<T>,
+>;
+
+pub fn latest_confirmed_domain_execution_receipt<T: Config>(
+    domain_id: DomainId,
+) -> Option<ExecutionReceiptOf<T>> {
+    let key = LatestConfirmedDomainExecutionReceipt::<T>::storage_map_final_key(domain_id);
+    decode_execution_receipt::<T>(key)
+}
+
+fn decode_execution_receipt<T: Config>(key: Vec<u8>) -> Option<ExecutionReceiptOf<T>> {
+    let raw_value = sp_io::storage::get(key.as_slice())?;
+    match ExecutionReceiptOf::<T>::decode(&mut &raw_value[..]) {
+        Ok(er) => Some(er),
+        Err(_) => ExecutionReceiptV0Of::<T>::decode(&mut &raw_value[..])
+            .ok()
+            .map(ExecutionReceiptOf::<T>::V0),
+    }
+}
+
+pub fn domain_genesis_block_execution_receipt<T: Config>(
+    domain_id: DomainId,
+) -> Option<ExecutionReceiptOf<T>> {
+    let key = DomainGenesisBlockExecutionReceipt::<T>::storage_map_final_key(domain_id);
+    decode_execution_receipt::<T>(key)
+}
+
+#[derive(TypeInfo, Debug, Encode, Decode, Clone, PartialEq, Eq)]
+struct BlockTreeNodeV0<Number, Hash, DomainNumber, DomainHash, Balance> {
+    /// The full ER for this block.
+    execution_receipt: ExecutionReceiptV0<Number, Hash, DomainNumber, DomainHash, Balance>,
+    /// A set of all operators who have committed to this ER within a bundle. Used to determine who to
+    /// slash if a fraudulent branch of the `block_tree` is pruned.
+    ///
+    /// NOTE: there may be duplicated operator id as an operator can submit multiple bundles with the
+    /// same head receipt to a consensus block.
+    operator_ids: Vec<OperatorId>,
+}
+
+type BlockTreeNodeV0For<T> = BlockTreeNodeV0<
+    BlockNumberFor<T>,
+    <T as frame_system::Config>::Hash,
+    DomainBlockNumberFor<T>,
+    <T as Config>::DomainHash,
+    BalanceOf<T>,
+>;
+
+fn decode_block_tree_node<T: Config>(raw_value: Vec<u8>) -> Option<BlockTreeNodeFor<T>> {
+    match BlockTreeNodeFor::<T>::decode(&mut &raw_value[..]) {
+        Ok(er) => Some(er),
+        Err(_) => BlockTreeNodeV0For::<T>::decode(&mut &raw_value[..])
+            .ok()
+            .map(|node| {
+                let BlockTreeNodeV0 {
+                    execution_receipt,
+                    operator_ids,
+                } = node;
+                BlockTreeNodeFor::<T> {
+                    execution_receipt: ExecutionReceiptOf::<T>::V0(execution_receipt),
+                    operator_ids,
+                }
+            }),
+    }
+}
+
+pub(crate) fn get_block_tree_node<T: Config>(
+    receipt_hash: ReceiptHashFor<T>,
+) -> Option<BlockTreeNodeFor<T>> {
+    let key = BlockTreeNodes::<T>::storage_map_final_key(receipt_hash);
+    let raw_value = sp_io::storage::get(key.as_slice())?;
+    decode_block_tree_node::<T>(raw_value.to_vec())
+}
+
+pub(crate) fn take_block_tree_node<T: Config>(
+    receipt_hash: ReceiptHashFor<T>,
+) -> Option<BlockTreeNodeFor<T>> {
+    let key = BlockTreeNodes::<T>::storage_map_final_key(receipt_hash);
+    let raw_value = sp_io::storage::get(key.as_slice())?;
+    sp_io::storage::clear(key.as_slice());
+    decode_block_tree_node::<T>(raw_value.to_vec())
+}
diff --git a/crates/sc-domains/src/domain_block_er/receipt_receiver.rs b/crates/sc-domains/src/domain_block_er/receipt_receiver.rs
@@ -265,7 +265,7 @@ async fn send_request<NR: NetworkRequest, Block: BlockT, DomainHeader: Header>(
                 return Err(DomainBlockERResponseError::InvalidProtocol);
             }
 
-            let response = match DomainBlockERResponse::decode(&mut data.clone().as_slice()) {
+            let response = match DomainBlockERResponse::decode(&mut data.as_slice()) {
                 Ok(response) => Ok(response),
                 Err(_) => DomainBlockERResponseV0::decode(&mut data.as_slice()).map(Into::into),
             }
diff --git a/domains/pallets/messenger/src/lib.rs b/domains/pallets/messenger/src/lib.rs
@@ -1356,7 +1356,7 @@ mod pallet {
                         BlockNumberFor<T>,
                         T::Hash,
                         BalanceOf<T>,
-                    >::decode(&mut &bare_value.clone()[..])
+                    >::decode(&mut &bare_value[..])
                     {
                         Ok(receipt) => Some(receipt),
                         Err(_) => ExecutionReceiptV0::<
@@ -1365,7 +1365,7 @@ mod pallet {
                             BlockNumberFor<T>,
                             T::Hash,
                             BalanceOf<T>,
-                        >::decode(&mut &bare_value.clone()[..])
+                        >::decode(&mut &bare_value[..])
                         .map(ExecutionReceipt::V0)
                         .ok(),
                     }

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+pub(crate) mod execution_receipt;`
`1`	`2`	`mod v1_to_v5;`
`2`	`3`
`3`	`4`	`pub use v1_to_v5::VersionCheckedMigrateDomainsV1ToV5;`
Original file line number	Diff line number	Diff line change
`@@ -265,7 +265,7 @@ async fn send_request<NR: NetworkRequest, Block: BlockT, DomainHeader: Header>(`
`265`	`265`	`return Err(DomainBlockERResponseError::InvalidProtocol);`
`266`	`266`	`}`
`267`	`267`
`268`		`- let response = match DomainBlockERResponse::decode(&mut data.clone().as_slice()) {`
	`268`	`+ let response = match DomainBlockERResponse::decode(&mut data.as_slice()) {`
`269`	`269`	`Ok(response) => Ok(response),`
`270`	`270`	`Err(_) => DomainBlockERResponseV0::decode(&mut data.as_slice()).map(Into::into),`
`271`	`271`	`}`