Merge pull request #941 from subspace/core-domain-prototype-refactoring-part-2

Core domain prototype refactoring (part 2)

Author: liuchengxu

crates/pallet-domains/src/lib.rs

@@ -492,7 +492,7 @@ mod pallet {
 
 impl<T: Config> Pallet<T> {
     /// Returns the block number of the latest receipt.
-    pub fn best_execution_chain_number() -> T::BlockNumber {
+    pub fn head_receipt_number() -> T::BlockNumber {
         let (_, best_number) = <ReceiptHead<T>>::get();
         best_number
     }

crates/pallet-domains/src/tests.rs

@@ -328,7 +328,7 @@ fn submit_bundle_with_many_reeipts_should_work() {
         assert!(!frame_system::BlockHash::<Test>::contains_key(1));
         assert!(!frame_system::BlockHash::<Test>::contains_key(255));
         assert_ok!(Domains::submit_bundle(RuntimeOrigin::none(), bundle1));
-        assert_eq!(Domains::best_execution_chain_number(), 255);
+        assert_eq!(Domains::head_receipt_number(), 255);
 
         // Reaching the receipts pruning depth, block hash mapping will be pruned as well.
         assert!(BlockHash::<Test>::contains_key(0));
@@ -346,7 +346,7 @@ fn submit_bundle_with_many_reeipts_should_work() {
         assert!(!BlockHash::<Test>::contains_key(2));
         assert_eq!(OldestReceiptNumber::<Test>::get(), 3);
         assert_eq!(Domains::finalized_receipt_number(), 2);
-        assert_eq!(Domains::best_execution_chain_number(), 258);
+        assert_eq!(Domains::head_receipt_number(), 258);
     });
 }
 
@@ -390,7 +390,7 @@ fn submit_fraud_proof_should_work() {
             RuntimeOrigin::none(),
             dummy_proof
         ));
-        assert_eq!(Domains::best_execution_chain_number(), 99);
+        assert_eq!(Domains::head_receipt_number(), 99);
         let receipt_hash = dummy_bundles[98].clone().bundle.receipts[0].hash();
         assert!(Receipts::<Test>::get(receipt_hash).is_some());
         // Receipts for block [100, 256] should be removed as being invalid.

crates/sp-domains/src/lib.rs

@@ -409,7 +409,7 @@ sp_api::decl_runtime_apis! {
         fn execution_wasm_bundle() -> Cow<'static, [u8]>;
 
         /// Returns the best execution chain number.
-        fn best_execution_chain_number() -> NumberFor<Block>;
+        fn head_receipt_number() -> NumberFor<Block>;
 
         /// Returns the block number of oldest execution receipt.
         fn oldest_receipt_number() -> NumberFor<Block>;

crates/subspace-runtime/src/lib.rs

@@ -863,8 +863,8 @@ impl_runtime_apis! {
             EXECUTION_WASM_BUNDLE.into()
         }
 
-        fn best_execution_chain_number() -> NumberFor<Block> {
-            Domains::best_execution_chain_number()
+        fn head_receipt_number() -> NumberFor<Block> {
+            Domains::head_receipt_number()
         }
 
         fn oldest_receipt_number() -> NumberFor<Block> {

domains/client/domain-executor/src/aux_schema.rs

@@ -55,7 +55,7 @@ fn load_decode<Backend: AuxStore, T: Decode>(
 pub(super) fn write_execution_receipt<Backend: AuxStore, Block: BlockT, PBlock: BlockT>(
     backend: &Backend,
     (block_hash, block_number): (Block::Hash, NumberFor<Block>),
-    best_execution_chain_number: NumberFor<Block>,
+    head_receipt_number: NumberFor<Block>,
     execution_receipt: &ExecutionReceipt<NumberFor<PBlock>, PBlock::Hash, Block::Hash>,
 ) -> Result<(), sp_blockchain::Error> {
     let block_number_key = (EXECUTION_RECEIPT_BLOCK_NUMBER, block_number).encode();
@@ -71,7 +71,7 @@ pub(super) fn write_execution_receipt<Backend: AuxStore, Block: BlockT, PBlock:
 
     let mut keys_to_delete = vec![];
 
-    if let Some(delete_receipts_to) = best_execution_chain_number
+    if let Some(delete_receipts_to) = head_receipt_number
         .saturated_into::<BlockNumber>()
         .checked_sub(PRUNING_DEPTH)
     {
@@ -130,10 +130,10 @@ where
 }
 
 pub(super) fn target_receipt_is_pruned(
-    best_execution_chain_number: BlockNumber,
+    head_receipt_number: BlockNumber,
     target_block: BlockNumber,
 ) -> bool {
-    best_execution_chain_number.saturating_sub(target_block) >= PRUNING_DEPTH
+    head_receipt_number.saturating_sub(target_block) >= PRUNING_DEPTH
 }
 
 /// Writes a bad execution receipt to aux storage.
@@ -464,7 +464,7 @@ mod tests {
 
         assert!(!target_receipt_is_pruned(PRUNING_DEPTH, 1));
 
-        // Create PRUNING_DEPTH + 1 receipt, best_execution_chain_number is PRUNING_DEPTH.
+        // Create PRUNING_DEPTH + 1 receipt, head_receipt_number is PRUNING_DEPTH.
         let block_hash = Hash::random();
         assert!(receipt_at(block_hash).is_none());
         write_receipt_at(
@@ -474,7 +474,7 @@ mod tests {
         );
         assert!(receipt_at(block_hash).is_some());
 
-        // Create PRUNING_DEPTH + 2 receipt, best_execution_chain_number is PRUNING_DEPTH + 1.
+        // Create PRUNING_DEPTH + 2 receipt, head_receipt_number is PRUNING_DEPTH + 1.
         let block_hash = Hash::random();
         write_receipt_at(
             block_hash,
@@ -490,7 +490,7 @@ mod tests {
         assert!(target_receipt_is_pruned(PRUNING_DEPTH + 1, 1));
         assert_eq!(receipt_start(), Some(2));
 
-        // Create PRUNING_DEPTH + 3 receipt, best_execution_chain_number is PRUNING_DEPTH + 2.
+        // Create PRUNING_DEPTH + 3 receipt, head_receipt_number is PRUNING_DEPTH + 2.
         let block_hash = Hash::random();
         write_receipt_at(
             block_hash,
@@ -519,7 +519,7 @@ mod tests {
     }
 
     #[test]
-    fn execution_receipts_should_be_kept_against_best_execution_chain_number() {
+    fn execution_receipts_should_be_kept_against_head_receipt_number() {
         let client = substrate_test_runtime_client::new();
 
         let receipt_start = || {
@@ -538,20 +538,20 @@ mod tests {
         let receipt_at = |block_hash: Hash| load_execution_receipt(&client, block_hash).unwrap();
 
         let write_receipt_at = |(hash, number): (Hash, BlockNumber),
-                                best_execution_chain_number: BlockNumber,
+                                head_receipt_number: BlockNumber,
                                 receipt: &ExecutionReceipt| {
             write_execution_receipt::<_, Block, PBlock>(
                 &client,
                 (hash, number),
-                best_execution_chain_number,
+                head_receipt_number,
                 receipt,
             )
             .unwrap()
         };
 
         assert_eq!(receipt_start(), None);
 
-        // Create PRUNING_DEPTH receipts, best_execution_chain_number is 0, i.e., no receipt
+        // Create PRUNING_DEPTH receipts, head_receipt_number is 0, i.e., no receipt
         // has ever been included on primary chain.
         let block_hash_list = (1..=PRUNING_DEPTH)
             .map(|block_number| {
@@ -567,7 +567,7 @@ mod tests {
 
         assert!(!target_receipt_is_pruned(PRUNING_DEPTH, 1));
 
-        // Create PRUNING_DEPTH + 1 receipt, best_execution_chain_number is 0.
+        // Create PRUNING_DEPTH + 1 receipt, head_receipt_number is 0.
         let block_hash = Hash::random();
         assert!(receipt_at(block_hash).is_none());
         write_receipt_at(
@@ -576,7 +576,7 @@ mod tests {
             &create_execution_receipt(PRUNING_DEPTH + 1),
         );
 
-        // Create PRUNING_DEPTH + 2 receipt, best_execution_chain_number is 0.
+        // Create PRUNING_DEPTH + 2 receipt, head_receipt_number is 0.
         let block_hash = Hash::random();
         write_receipt_at(
             (block_hash, PRUNING_DEPTH + 2),
@@ -591,15 +591,15 @@ mod tests {
         assert!(!target_receipt_is_pruned(0, 1));
         assert_eq!(receipt_start(), Some(1));
 
-        // Create PRUNING_DEPTH + 3 receipt, best_execution_chain_number is 0.
+        // Create PRUNING_DEPTH + 3 receipt, head_receipt_number is 0.
         let block_hash = Hash::random();
         write_receipt_at(
             (block_hash, PRUNING_DEPTH + 3),
             0,
             &create_execution_receipt(PRUNING_DEPTH + 3),
         );
 
-        // Create PRUNING_DEPTH + 4 receipt, best_execution_chain_number is PRUNING_DEPTH + 3.
+        // Create PRUNING_DEPTH + 4 receipt, head_receipt_number is PRUNING_DEPTH + 3.
         let block_hash = Hash::random();
         write_receipt_at(
             (block_hash, PRUNING_DEPTH + 4),

domains/client/domain-executor/src/bundle_election_solver.rs

@@ -16,56 +16,56 @@ use std::sync::Arc;
 use subspace_core_primitives::{Blake2b256Hash, BlockNumber};
 use system_runtime_primitives::SystemDomainApi;
 
-pub(super) struct BundleElectionSolver<Block, PBlock, Client> {
-    client: Arc<Client>,
+pub(super) struct BundleElectionSolver<SBlock, PBlock, SClient> {
+    system_domain_client: Arc<SClient>,
     keystore: SyncCryptoStorePtr,
-    _phantom_data: PhantomData<(Block, PBlock)>,
+    _phantom_data: PhantomData<(SBlock, PBlock)>,
 }
 
-impl<Block, PBlock, Client> Clone for BundleElectionSolver<Block, PBlock, Client>
+impl<SBlock, PBlock, SClient> Clone for BundleElectionSolver<SBlock, PBlock, SClient>
 where
-    Block: BlockT,
+    SBlock: BlockT,
     PBlock: BlockT,
 {
     fn clone(&self) -> Self {
         Self {
-            client: self.client.clone(),
+            system_domain_client: self.system_domain_client.clone(),
             keystore: self.keystore.clone(),
             _phantom_data: self._phantom_data,
         }
     }
 }
 
-impl<Block, PBlock, Client> BundleElectionSolver<Block, PBlock, Client>
+impl<SBlock, PBlock, SClient> BundleElectionSolver<SBlock, PBlock, SClient>
 where
-    Block: BlockT,
+    SBlock: BlockT,
     PBlock: BlockT,
-    Client: HeaderBackend<Block> + ProvideRuntimeApi<Block> + ProofProvider<Block>,
-    Client::Api: SystemDomainApi<Block, NumberFor<PBlock>, PBlock::Hash>,
+    SClient: HeaderBackend<SBlock> + ProvideRuntimeApi<SBlock> + ProofProvider<SBlock>,
+    SClient::Api: SystemDomainApi<SBlock, NumberFor<PBlock>, PBlock::Hash>,
 {
-    pub(super) fn new(client: Arc<Client>, keystore: SyncCryptoStorePtr) -> Self {
+    pub(super) fn new(system_domain_client: Arc<SClient>, keystore: SyncCryptoStorePtr) -> Self {
         Self {
-            client,
+            system_domain_client,
             keystore,
             _phantom_data: PhantomData::default(),
         }
     }
 
     pub(super) fn solve_bundle_election_challenge(
         &self,
-        best_hash: Block::Hash,
-        best_number: NumberFor<Block>,
+        best_hash: SBlock::Hash,
+        best_number: NumberFor<SBlock>,
         domain_id: DomainId,
         global_challenge: Blake2b256Hash,
-    ) -> sp_blockchain::Result<Option<ProofOfElection<Block::Hash>>> {
+    ) -> sp_blockchain::Result<Option<ProofOfElection<SBlock::Hash>>> {
         let best_block_id = BlockId::Hash(best_hash);
 
         let BundleElectionParams {
             authorities,
             total_stake_weight,
             slot_probability,
         } = self
-            .client
+            .system_domain_client
             .runtime_api()
             .bundle_elections_params(&best_block_id, domain_id)?;
 
@@ -110,11 +110,11 @@ where
                     // electioned executor storage instead of the whole authority set.
                     let storage_proof = if domain_id.is_system() {
                         let storage_keys = well_known_keys::bundle_election_storage_keys(domain_id);
-                        self.client
+                        self.system_domain_client
                             .read_proof(best_hash, &mut storage_keys.iter().map(|s| s.as_slice()))?
                     } else if domain_id.is_core() {
                         let storage_keys = self
-                            .client
+                            .system_domain_client
                             .runtime_api()
                             .core_bundle_election_storage_keys(
                                 &best_block_id,
@@ -126,7 +126,7 @@ where
                                     "Empty core bundle election storage keys".to_string(),
                                 )
                             })?;
-                        self.client
+                        self.system_domain_client
                             .read_proof(best_hash, &mut storage_keys.iter().map(|s| s.as_slice()))?
                     } else {
                         return Err(sp_blockchain::Error::Application(Box::from(
@@ -135,7 +135,7 @@ where
                     };
 
                     let state_root = *self
-                        .client
+                        .system_domain_client
                         .header(best_block_id)?
                         .expect("Best block header must exist; qed")
                         .state_root();

domains/client/domain-executor/src/core_bundle_processor.rs

@@ -165,17 +165,15 @@ where
         // TODO: just make it compile for now, likely wrong, rethink about it.
         let system_domain_hash = self.system_domain_client.info().best_hash;
 
-        let best_execution_chain_number = self
+        let head_receipt_number = self
             .system_domain_client
             .runtime_api()
-            .best_execution_chain_number(&BlockId::Hash(system_domain_hash), self.domain_id)?;
-        let best_execution_chain_number = translate_number_type::<
-            NumberFor<SBlock>,
-            NumberFor<Block>,
-        >(best_execution_chain_number);
+            .head_receipt_number(&BlockId::Hash(system_domain_hash), self.domain_id)?;
+        let head_receipt_number =
+            translate_number_type::<NumberFor<SBlock>, NumberFor<Block>>(head_receipt_number);
 
         assert!(
-            domain_block_result.header_number > best_execution_chain_number,
+            domain_block_result.header_number > head_receipt_number,
             "Consensus chain number must larger than execution chain number by at least 1"
         );
 
@@ -189,7 +187,7 @@ where
         if let Some(fraud_proof) = self.domain_block_processor.on_domain_block_processed(
             primary_hash,
             domain_block_result,
-            best_execution_chain_number,
+            head_receipt_number,
             oldest_receipt_number,
         )? {
             // TODO: self.system_domain_client.runtime_api().submit_fraud_proof_unsigned()