Merge pull request #1026 from subspace/fraud-proof-submit

Submit core domain fraud proof to the system domain through the ParentChainInterface trait

Author: liuchengxu

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

@@ -1,4 +1,5 @@
 use crate::domain_block_processor::DomainBlockProcessor;
+use crate::parent_chain::{CoreDomainParentChain, ParentChainInterface};
 use crate::utils::{translate_number_type, DomainBundles};
 use crate::TransactionFor;
 use domain_runtime_primitives::{AccountId, DomainCoreApi};
@@ -29,6 +30,7 @@ where
     domain_id: DomainId,
     primary_chain_client: Arc<PClient>,
     system_domain_client: Arc<SClient>,
+    parent_chain: CoreDomainParentChain<SClient, SBlock, PBlock>,
     client: Arc<Client>,
     backend: Arc<Backend>,
     keystore: SyncCryptoStorePtr,
@@ -48,6 +50,7 @@ where
             domain_id: self.domain_id,
             primary_chain_client: self.primary_chain_client.clone(),
             system_domain_client: self.system_domain_client.clone(),
+            parent_chain: self.parent_chain.clone(),
             client: self.client.clone(),
             backend: self.backend.clone(),
             keystore: self.keystore.clone(),
@@ -91,10 +94,15 @@ where
         keystore: SyncCryptoStorePtr,
         domain_block_processor: DomainBlockProcessor<Block, PBlock, Client, PClient, Backend, E>,
     ) -> Self {
+        let parent_chain = CoreDomainParentChain::<SClient, SBlock, PBlock>::new(
+            system_domain_client.clone(),
+            domain_id,
+        );
         Self {
             domain_id,
             primary_chain_client,
             system_domain_client,
+            parent_chain,
             client,
             backend,
             keystore,
@@ -175,13 +183,7 @@ where
             head_receipt_number,
             oldest_receipt_number,
         )? {
-            // TODO: self.system_domain_client.runtime_api().submit_fraud_proof_unsigned()
-            self.primary_chain_client
-                .runtime_api()
-                .submit_fraud_proof_unsigned(
-                    &BlockId::Hash(self.primary_chain_client.info().best_hash),
-                    fraud_proof,
-                )?;
+            self.parent_chain.submit_fraud_proof_unsigned(fraud_proof)?;
         }
 
         Ok(())

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

@@ -1,6 +1,7 @@
 use crate::bundle_election_solver::BundleElectionSolver;
-use crate::domain_bundle_producer::{sign_new_bundle, ReceiptInterface};
+use crate::domain_bundle_producer::sign_new_bundle;
 use crate::domain_bundle_proposer::DomainBundleProposer;
+use crate::parent_chain::CoreDomainParentChain;
 use crate::utils::{to_number_primitive, ExecutorSlotInfo};
 use crate::BundleSender;
 use codec::{Decode, Encode};
@@ -15,7 +16,6 @@ use sp_runtime::generic::BlockId;
 use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
 use std::marker::PhantomData;
 use std::sync::Arc;
-use subspace_core_primitives::BlockNumber;
 use system_runtime_primitives::SystemDomainApi;
 
 pub(super) struct CoreBundleProducer<Block, SBlock, PBlock, Client, SClient, TransactionPool>
@@ -27,6 +27,7 @@ where
     domain_id: DomainId,
     system_domain_client: Arc<SClient>,
     client: Arc<Client>,
+    parent_chain: CoreDomainParentChain<SClient, SBlock, PBlock>,
     bundle_sender: Arc<BundleSender<Block, PBlock>>,
     is_authority: bool,
     keystore: SyncCryptoStorePtr,
@@ -47,6 +48,7 @@ where
             domain_id: self.domain_id,
             system_domain_client: self.system_domain_client.clone(),
             client: self.client.clone(),
+            parent_chain: self.parent_chain.clone(),
             bundle_sender: self.bundle_sender.clone(),
             is_authority: self.is_authority,
             keystore: self.keystore.clone(),
@@ -57,32 +59,6 @@ where
     }
 }
 
-impl<Block, SBlock, PBlock, Client, SClient, TransactionPool> ReceiptInterface<SBlock::Hash>
-    for CoreBundleProducer<Block, SBlock, PBlock, Client, SClient, TransactionPool>
-where
-    Block: BlockT,
-    SBlock: BlockT,
-    PBlock: BlockT,
-    SClient: ProvideRuntimeApi<SBlock>,
-    SClient::Api: SystemDomainApi<SBlock, NumberFor<PBlock>, PBlock::Hash>,
-{
-    fn head_receipt_number(&self, at: SBlock::Hash) -> Result<BlockNumber, sp_api::ApiError> {
-        let head_receipt_number = self
-            .system_domain_client
-            .runtime_api()
-            .head_receipt_number(&BlockId::Hash(at), self.domain_id)?;
-        Ok(to_number_primitive(head_receipt_number))
-    }
-
-    fn maximum_receipt_drift(&self, at: SBlock::Hash) -> Result<BlockNumber, sp_api::ApiError> {
-        let max_drift = self
-            .system_domain_client
-            .runtime_api()
-            .maximum_receipt_drift(&BlockId::Hash(at))?;
-        Ok(to_number_primitive(max_drift))
-    }
-}
-
 impl<Block, SBlock, PBlock, Client, SClient, TransactionPool>
     CoreBundleProducer<Block, SBlock, PBlock, Client, SClient, TransactionPool>
 where
@@ -110,10 +86,15 @@ where
             keystore.clone(),
         );
         let domain_bundle_proposer = DomainBundleProposer::new(client.clone(), transaction_pool);
+        let parent_chain = CoreDomainParentChain::<SClient, SBlock, PBlock>::new(
+            system_domain_client.clone(),
+            domain_id,
+        );
         Self {
             domain_id,
             system_domain_client,
             client,
+            parent_chain,
             bundle_sender,
             is_authority,
             keystore,
@@ -123,18 +104,14 @@ where
         }
     }
 
-    pub(super) async fn produce_bundle<R>(
+    pub(super) async fn produce_bundle(
         self,
         primary_info: (PBlock::Hash, NumberFor<PBlock>),
         slot_info: ExecutorSlotInfo,
-        receipt_interface: R,
     ) -> Result<
         Option<SignedOpaqueBundle<NumberFor<PBlock>, PBlock::Hash, Block::Hash>>,
         sp_blockchain::Error,
-    >
-    where
-        R: ReceiptInterface<SBlock::Hash>,
-    {
+    > {
         if !self.is_authority {
             return Ok(None);
         }
@@ -160,7 +137,7 @@ where
 
             let bundle = self
                 .domain_bundle_proposer
-                .propose_bundle_at::<PBlock, _, _>(slot, primary_info, receipt_interface, best_hash)
+                .propose_bundle_at::<PBlock, _, _>(slot, primary_info, self.parent_chain, best_hash)
                 .await?;
 
             let core_block_number = to_number_primitive(self.client.info().best_number);

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

@@ -133,10 +133,9 @@ pub(super) async fn start_worker<
     let handle_slot_notifications_fut = handle_slot_notifications::<Block, PBlock, _, _>(
         primary_chain_client.as_ref(),
         move |primary_info, slot_info| {
-            let receipt_interface = bundle_producer.clone();
             bundle_producer
                 .clone()
-                .produce_bundle(primary_info, slot_info, receipt_interface)
+                .produce_bundle(primary_info, slot_info)
                 .instrument(span.clone())
                 .unwrap_or_else(move |error| {
                     tracing::error!(?primary_info, ?error, "Error at producing bundle.");

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

@@ -3,17 +3,6 @@ use sp_domains::{Bundle, BundleSolution, ExecutorPublicKey, ExecutorSignature, S
 use sp_keystore::{SyncCryptoStore, SyncCryptoStorePtr};
 use sp_runtime::traits::{Block as BlockT, NumberFor};
 use sp_runtime::RuntimeAppPublic;
-use subspace_core_primitives::BlockNumber;
-
-// TODO: this may be extended into ParentChainInterface due to the relative relation between the
-// chains regarding the settlement aspect.
-// - Primary Chain => System Domain
-// - System Domain => Core Domain
-/// Trait for retrieving the necessary info for collecting the receipts in a new domain bundle.
-pub(crate) trait ReceiptInterface<Hash> {
-    fn head_receipt_number(&self, at: Hash) -> Result<BlockNumber, sp_api::ApiError>;
-    fn maximum_receipt_drift(&self, at: Hash) -> Result<BlockNumber, sp_api::ApiError>;
-}
 
 type SignedOpaqueBundle<Block, PBlock> = sp_domains::SignedOpaqueBundle<
     NumberFor<PBlock>,

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

@@ -1,4 +1,4 @@
-use crate::domain_bundle_producer::ReceiptInterface;
+use crate::parent_chain::ParentChainInterface;
 use crate::utils::to_number_primitive;
 use crate::ExecutionReceiptFor;
 use codec::Encode;
@@ -52,12 +52,12 @@ where
         &self,
         slot: Slot,
         primary_info: (PBlock::Hash, NumberFor<PBlock>),
-        receipt_interface: R,
-        receipt_interface_block_hash: RHash,
+        parent_chain: R,
+        parent_chain_block_hash: RHash,
     ) -> sp_blockchain::Result<Bundle<Block::Extrinsic, NumberFor<PBlock>, PBlock::Hash, Block::Hash>>
     where
         PBlock: BlockT,
-        R: ReceiptInterface<RHash>,
+        R: ParentChainInterface<RHash>,
         RHash: Copy,
     {
         let parent_number = self.client.info().best_number;
@@ -109,8 +109,8 @@ where
         } else {
             self.collect_bundle_receipts::<PBlock, _, _>(
                 parent_number,
-                receipt_interface,
-                receipt_interface_block_hash,
+                parent_chain,
+                parent_chain_block_hash,
             )?
         };
 
@@ -131,17 +131,16 @@ where
     fn collect_bundle_receipts<PBlock, R, RHash>(
         &self,
         header_number: NumberFor<Block>,
-        receipt_interface: R,
-        receipt_interface_block_hash: RHash,
+        parent_chain: R,
+        parent_chain_block_hash: RHash,
     ) -> sp_blockchain::Result<Vec<ExecutionReceiptFor<PBlock, Block::Hash>>>
     where
         PBlock: BlockT,
-        R: ReceiptInterface<RHash>,
+        R: ParentChainInterface<RHash>,
         RHash: Copy,
     {
-        let head_receipt_number =
-            receipt_interface.head_receipt_number(receipt_interface_block_hash)?;
-        let max_drift = receipt_interface.maximum_receipt_drift(receipt_interface_block_hash)?;
+        let head_receipt_number = parent_chain.head_receipt_number(parent_chain_block_hash)?;
+        let max_drift = parent_chain.maximum_receipt_drift(parent_chain_block_hash)?;
 
         let load_receipt = |block_hash| {
             crate::aux_schema::load_execution_receipt::<

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

@@ -74,6 +74,7 @@ mod domain_worker;
 mod fraud_proof;
 mod gossip_message_validator;
 mod merkle_tree;
+mod parent_chain;
 mod system_bundle_processor;
 mod system_bundle_producer;
 mod system_domain_worker;

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

@@ -0,0 +1,140 @@
+use crate::utils::to_number_primitive;
+use sp_api::{NumberFor, ProvideRuntimeApi};
+use sp_blockchain::HeaderBackend;
+use sp_domains::fraud_proof::FraudProof;
+use sp_domains::{DomainId, ExecutorApi};
+use sp_runtime::generic::BlockId;
+use sp_runtime::traits::Block as BlockT;
+use std::marker::PhantomData;
+use std::sync::Arc;
+use subspace_core_primitives::BlockNumber;
+use system_runtime_primitives::SystemDomainApi;
+
+/// Trait for interacting between the domain and its corresponding parent chain, i.e. retrieving
+/// the necessary info from the parent chain or submit extrinsics to the parent chain.
+///
+/// - The parent chain of System Domain => Primary Chain
+/// - The parent chain of Core Domain => System Domain
+pub(crate) trait ParentChainInterface<Hash> {
+    fn head_receipt_number(&self, at: Hash) -> Result<BlockNumber, sp_api::ApiError>;
+    fn maximum_receipt_drift(&self, at: Hash) -> Result<BlockNumber, sp_api::ApiError>;
+    fn submit_fraud_proof_unsigned(&self, fraud_proof: FraudProof) -> Result<(), sp_api::ApiError>;
+}
+
+/// The parent chain of the core domain
+pub struct CoreDomainParentChain<SClient, SBlock, PBlock> {
+    system_domain_client: Arc<SClient>,
+    // Core domain id
+    domain_id: DomainId,
+    _phantom: PhantomData<(SBlock, PBlock)>,
+}
+
+impl<SClient, SBlock, PBlock> Clone for CoreDomainParentChain<SClient, SBlock, PBlock> {
+    fn clone(&self) -> Self {
+        CoreDomainParentChain {
+            system_domain_client: self.system_domain_client.clone(),
+            domain_id: self.domain_id,
+            _phantom: self._phantom,
+        }
+    }
+}
+
+impl<SBlock, PBlock, SClient> CoreDomainParentChain<SClient, SBlock, PBlock> {
+    pub fn new(system_domain_client: Arc<SClient>, domain_id: DomainId) -> Self {
+        CoreDomainParentChain {
+            system_domain_client,
+            domain_id,
+            _phantom: PhantomData::default(),
+        }
+    }
+}
+
+impl<SBlock, PBlock, SClient> ParentChainInterface<SBlock::Hash>
+    for CoreDomainParentChain<SClient, SBlock, PBlock>
+where
+    SBlock: BlockT,
+    PBlock: BlockT,
+    SClient: HeaderBackend<SBlock> + ProvideRuntimeApi<SBlock>,
+    SClient::Api: SystemDomainApi<SBlock, NumberFor<PBlock>, PBlock::Hash>,
+{
+    fn head_receipt_number(&self, at: SBlock::Hash) -> Result<BlockNumber, sp_api::ApiError> {
+        let head_receipt_number = self
+            .system_domain_client
+            .runtime_api()
+            .head_receipt_number(&BlockId::Hash(at), self.domain_id)?;
+        Ok(to_number_primitive(head_receipt_number))
+    }
+
+    fn maximum_receipt_drift(&self, at: SBlock::Hash) -> Result<BlockNumber, sp_api::ApiError> {
+        let max_drift = self
+            .system_domain_client
+            .runtime_api()
+            .maximum_receipt_drift(&BlockId::Hash(at))?;
+        Ok(to_number_primitive(max_drift))
+    }
+
+    fn submit_fraud_proof_unsigned(&self, fraud_proof: FraudProof) -> Result<(), sp_api::ApiError> {
+        let at = self.system_domain_client.info().best_hash;
+        self.system_domain_client
+            .runtime_api()
+            .submit_fraud_proof_unsigned(&BlockId::Hash(at), fraud_proof)?;
+        Ok(())
+    }
+}
+
+/// The parent chain of the system domain
+pub struct SystemDomainParentChain<PClient, Block, PBlock> {
+    primary_chain_client: Arc<PClient>,
+    _phantom: PhantomData<(Block, PBlock)>,
+}
+
+impl<PClient, Block, PBlock> Clone for SystemDomainParentChain<PClient, Block, PBlock> {
+    fn clone(&self) -> Self {
+        SystemDomainParentChain {
+            primary_chain_client: self.primary_chain_client.clone(),
+            _phantom: self._phantom,
+        }
+    }
+}
+
+impl<PClient, Block, PBlock> SystemDomainParentChain<PClient, Block, PBlock> {
+    pub fn new(primary_chain_client: Arc<PClient>) -> Self {
+        SystemDomainParentChain {
+            primary_chain_client,
+            _phantom: PhantomData::default(),
+        }
+    }
+}
+
+impl<Block, PBlock, PClient> ParentChainInterface<PBlock::Hash>
+    for SystemDomainParentChain<PClient, Block, PBlock>
+where
+    Block: BlockT,
+    PBlock: BlockT,
+    PClient: HeaderBackend<PBlock> + ProvideRuntimeApi<PBlock>,
+    PClient::Api: ExecutorApi<PBlock, Block::Hash>,
+{
+    fn head_receipt_number(&self, at: PBlock::Hash) -> Result<BlockNumber, sp_api::ApiError> {
+        let head_receipt_number = self
+            .primary_chain_client
+            .runtime_api()
+            .head_receipt_number(&BlockId::Hash(at))?;
+        Ok(to_number_primitive(head_receipt_number))
+    }
+
+    fn maximum_receipt_drift(&self, at: PBlock::Hash) -> Result<BlockNumber, sp_api::ApiError> {
+        let max_drift = self
+            .primary_chain_client
+            .runtime_api()
+            .maximum_receipt_drift(&BlockId::Hash(at))?;
+        Ok(to_number_primitive(max_drift))
+    }
+
+    fn submit_fraud_proof_unsigned(&self, fraud_proof: FraudProof) -> Result<(), sp_api::ApiError> {
+        let at = self.primary_chain_client.info().best_hash;
+        self.primary_chain_client
+            .runtime_api()
+            .submit_fraud_proof_unsigned(&BlockId::Hash(at), fraud_proof)?;
+        Ok(())
+    }
+}