Merge allow list storage proof, and cleanup old struct

crates/pallet-domains/src/lib.rs

@@ -64,9 +64,10 @@ use sp_consensus_subspace::WrappedPotOutput;
 use sp_core::H256;
 use sp_domains::bundle_producer_election::BundleProducerElectionParams;
 use sp_domains::{
-    DomainBundleLimit, DomainId, DomainInstanceData, ExecutionReceipt, OpaqueBundle, OperatorId,
-    OperatorPublicKey, OperatorRewardSource, OperatorSignature, ProofOfElection, RuntimeId,
-    SealedSingletonReceipt, DOMAIN_EXTRINSICS_SHUFFLING_SEED_SUBJECT, EMPTY_EXTRINSIC_ROOT,
+    DomainAllowlistUpdates, DomainBundleLimit, DomainId, DomainInstanceData, ExecutionReceipt,
+    OpaqueBundle, OperatorId, OperatorPublicKey, OperatorRewardSource, OperatorSignature,
+    ProofOfElection, RuntimeId, SealedSingletonReceipt, DOMAIN_EXTRINSICS_SHUFFLING_SEED_SUBJECT,
+    EMPTY_EXTRINSIC_ROOT,
 };
 use sp_domains_fraud_proof::fraud_proof::{
     DomainRuntimeCodeAt, FraudProof, FraudProofVariant, InvalidBlockFeesProof,
@@ -208,9 +209,10 @@ mod pallet {
     #[cfg(not(feature = "runtime-benchmarks"))]
     use crate::MAX_NOMINATORS_TO_SLASH;
     use crate::{
-        BalanceOf, BlockSlot, BlockTreeNodeFor, DomainBlockNumberFor, ElectionVerificationParams,
-        ExecutionReceiptOf, FraudProofFor, HoldIdentifier, NominatorId, OpaqueBundleOf,
-        ReceiptHashFor, SingletonReceiptOf, StateRootOf, MAX_BUNDLE_PER_BLOCK, STORAGE_VERSION,
+        BalanceOf, BlockSlot, BlockTreeNodeFor, DomainAllowlistUpdatesProvider,
+        DomainBlockNumberFor, ElectionVerificationParams, ExecutionReceiptOf, FraudProofFor,
+        HoldIdentifier, NominatorId, OpaqueBundleOf, ReceiptHashFor, SingletonReceiptOf,
+        StateRootOf, MAX_BUNDLE_PER_BLOCK, STORAGE_VERSION,
     };
     #[cfg(not(feature = "std"))]
     use alloc::string::String;
@@ -415,6 +417,9 @@ mod pallet {
         /// A hook to call after a domain is instantiated
         type OnDomainInstantiated: OnDomainInstantiated;
 
+        /// Domain allow list update source
+        type DomainAllowlistUpdates: DomainAllowlistUpdatesProvider;
+
         /// Hash type of MMR
         type MmrHash: Parameter + Member + Default + Clone;
 
@@ -1856,7 +1861,8 @@ mod pallet {
 
     /// Combined fraud proof data for the InvalidInherentExtrinsic fraud proof
     #[pallet::storage]
-    pub type BlockInvalidInherentExtrinsicData<T> = StorageValue<_, InvalidInherentExtrinsicData>;
+    pub type BlockInvalidInherentExtrinsicData<T> =
+        StorageMap<_, Identity, DomainId, InvalidInherentExtrinsicData, ValueQuery>;
 
     #[pallet::hooks]
     // TODO: proper benchmark
@@ -1902,7 +1908,7 @@ mod pallet {
                 }
             }
 
-            BlockInvalidInherentExtrinsicData::<T>::kill();
+            let _ = BlockInvalidInherentExtrinsicData::<T>::clear(u32::MAX, None);
 
             Weight::zero()
         }
@@ -1931,13 +1937,23 @@ mod pallet {
                 let consensus_transaction_byte_fee =
                     sp_domains::DOMAIN_STORAGE_FEE_MULTIPLIER * transaction_byte_fee;
 
-                let invalid_inherent_extrinsic_data = InvalidInherentExtrinsicData {
-                    extrinsics_shuffling_seed,
-                    timestamp,
-                    consensus_transaction_byte_fee,
-                };
+                for domain_id in SuccessfulBundles::<T>::iter_keys() {
+                    let domain_chain_allowlist =
+                        T::DomainAllowlistUpdates::domain_allowlist_updates(domain_id)
+                            .unwrap_or_default();
+
+                    let invalid_inherent_extrinsic_data = InvalidInherentExtrinsicData {
+                        extrinsics_shuffling_seed,
+                        timestamp,
+                        consensus_transaction_byte_fee,
+                        domain_chain_allowlist,
+                    };
 
-                BlockInvalidInherentExtrinsicData::<T>::set(Some(invalid_inherent_extrinsic_data));
+                    BlockInvalidInherentExtrinsicData::<T>::insert(
+                        domain_id,
+                        invalid_inherent_extrinsic_data,
+                    );
+                }
             }
 
             let _ = LastEpochStakingDistribution::<T>::clear(u32::MAX, None);
@@ -3120,3 +3136,8 @@ pub fn calculate_tx_range(
     };
     new_tx_range.clamp(lower_bound, upper_bound)
 }
+
+/// An abstraction that gets domain allow list updates from pallet-messenger.
+pub trait DomainAllowlistUpdatesProvider {
+    fn domain_allowlist_updates(domain_id: DomainId) -> Option<DomainAllowlistUpdates>;
+}

crates/pallet-domains/src/tests.rs

@@ -5,10 +5,11 @@ use crate::runtime_registry::ScheduledRuntimeUpgrade;
 use crate::staking::Operator;
 use crate::{
     self as pallet_domains, BalanceOf, BlockSlot, BlockTree, BlockTreeNodes, BundleError, Config,
-    ConsensusBlockHash, DomainBlockNumberFor, DomainHashingFor, DomainRegistry,
-    DomainRuntimeUpgradeRecords, DomainRuntimeUpgrades, ExecutionInbox, ExecutionReceiptOf,
-    FraudProofError, FungibleHoldId, HeadDomainNumber, HeadReceiptNumber, NextDomainId, Operators,
-    RuntimeRegistry, ScheduledRuntimeUpgrades,
+    ConsensusBlockHash, DomainAllowlistUpdates, DomainAllowlistUpdatesProvider,
+    DomainBlockNumberFor, DomainHashingFor, DomainRegistry, DomainRuntimeUpgradeRecords,
+    DomainRuntimeUpgrades, ExecutionInbox, ExecutionReceiptOf, FraudProofError, FungibleHoldId,
+    HeadDomainNumber, HeadReceiptNumber, NextDomainId, Operators, RuntimeRegistry,
+    ScheduledRuntimeUpgrades,
 };
 use codec::{Decode, Encode, MaxEncodedLen};
 use core::mem;
@@ -237,6 +238,12 @@ impl sp_domains::DomainsTransfersTracker<Balance> for MockDomainsTransfersTracke
     }
 }
 
+impl DomainAllowlistUpdatesProvider for () {
+    fn domain_allowlist_updates(_domain_id: DomainId) -> Option<DomainAllowlistUpdates> {
+        None
+    }
+}
+
 impl pallet_domains::Config for Test {
     type RuntimeEvent = RuntimeEvent;
     type DomainHash = sp_core::H256;
@@ -272,6 +279,7 @@ impl pallet_domains::Config for Test {
     type ConsensusSlotProbability = SlotProbability;
     type DomainBundleSubmitted = ();
     type OnDomainInstantiated = ();
+    type DomainAllowlistUpdates = ();
     type Balance = Balance;
     type MmrHash = H256;
     type MmrProofVerifier = ();

crates/pallet-transaction-fees/src/lib.rs

@@ -21,11 +21,6 @@
 
 pub mod weights;
 
-#[cfg(not(feature = "std"))]
-extern crate alloc;
-
-#[cfg(not(feature = "std"))]
-use alloc::vec::Vec;
 use codec::{Codec, Decode, Encode};
 use frame_support::sp_runtime::traits::Zero;
 use frame_support::sp_runtime::SaturatedConversion;

crates/sp-domains-fraud-proof/src/fraud_proof.rs

@@ -497,10 +497,6 @@ pub struct InvalidExtrinsicsRootProof {
     /// The combined storage proofs used during verification
     pub invalid_inherent_extrinsic_proofs: InvalidInherentExtrinsicDataProof,
 
-    /// The individual storage proofs used during verification
-    // TODO: combine these proofs into `InvalidInherentExtrinsicDataProof`
-    pub invalid_inherent_extrinsic_proof: InvalidInherentExtrinsicProof,
-
     /// Optional domain runtime code upgrade storage proof
     pub maybe_domain_runtime_upgrade_proof: MaybeDomainRuntimeUpgradedProof,
 

crates/sp-domains-fraud-proof/src/storage_proof.rs

@@ -37,7 +37,6 @@ pub enum VerificationError {
     UnexpectedDomainRuntimeUpgrade,
     InvalidInherentExtrinsicStorageProof(StorageProofVerificationError),
     SuccessfulBundlesStorageProof(StorageProofVerificationError),
-    DomainAllowlistUpdatesStorageProof(StorageProofVerificationError),
     DomainRuntimeUpgradesStorageProof(StorageProofVerificationError),
     RuntimeRegistryStorageProof(StorageProofVerificationError),
     DigestStorageProof(StorageProofVerificationError),
@@ -50,9 +49,8 @@ pub enum VerificationError {
 
 #[derive(Clone, Debug, Decode, Encode, Eq, PartialEq, TypeInfo)]
 pub enum FraudProofStorageKeyRequest<Number> {
-    InvalidInherentExtrinsicData,
+    InvalidInherentExtrinsicData(DomainId),
     SuccessfulBundles(DomainId),
-    DomainAllowlistUpdates(DomainId),
     DomainRuntimeUpgrades,
     RuntimeRegistry(RuntimeId),
     DomainSudoCall(DomainId),
@@ -62,13 +60,10 @@ pub enum FraudProofStorageKeyRequest<Number> {
 impl<Number> FraudProofStorageKeyRequest<Number> {
     fn into_error(self, err: StorageProofVerificationError) -> VerificationError {
         match self {
-            Self::InvalidInherentExtrinsicData => {
+            Self::InvalidInherentExtrinsicData(_) => {
                 VerificationError::InvalidInherentExtrinsicStorageProof(err)
             }
             Self::SuccessfulBundles(_) => VerificationError::SuccessfulBundlesStorageProof(err),
-            Self::DomainAllowlistUpdates(_) => {
-                VerificationError::DomainAllowlistUpdatesStorageProof(err)
-            }
             Self::DomainRuntimeUpgrades => {
                 VerificationError::DomainRuntimeUpgradesStorageProof(err)
             }
@@ -167,18 +162,6 @@ impl<Block: BlockT> BasicStorageProof<Block> for SuccessfulBundlesProof {
     }
 }
 
-#[derive(Clone, Debug, Decode, Encode, Eq, PartialEq, TypeInfo)]
-pub struct DomainChainsAllowlistUpdateStorageProof(StorageProof);
-
-impl_storage_proof!(DomainChainsAllowlistUpdateStorageProof);
-impl<Block: BlockT> BasicStorageProof<Block> for DomainChainsAllowlistUpdateStorageProof {
-    type StorageValue = DomainAllowlistUpdates;
-    type Key = DomainId;
-    fn storage_key_request(key: Self::Key) -> FraudProofStorageKeyRequest<NumberFor<Block>> {
-        FraudProofStorageKeyRequest::DomainAllowlistUpdates(key)
-    }
-}
-
 #[derive(Clone, Debug, Decode, Encode, Eq, PartialEq, TypeInfo)]
 pub struct DomainSudoCallStorageProof(StorageProof);
 
@@ -366,7 +349,7 @@ impl MaybeDomainRuntimeUpgradedProof {
     }
 }
 
-#[derive(Clone, Debug, Decode, Encode, Eq, PartialEq, TypeInfo)]
+#[derive(Clone, Debug, Default, Decode, Encode, Eq, PartialEq, TypeInfo)]
 pub struct InvalidInherentExtrinsicData {
     /// Extrinsics shuffling seed, derived from block randomness
     pub extrinsics_shuffling_seed: Randomness,
@@ -376,6 +359,9 @@ pub struct InvalidInherentExtrinsicData {
 
     /// Transaction byte fee, derived from dynamic cost of storage and the consensus chain byte fee
     pub consensus_transaction_byte_fee: Balance,
+
+    /// Changes in the chains that are allowed to open a channel with each domain
+    pub domain_chain_allowlist: DomainAllowlistUpdates,
 }
 
 impl PassBy for InvalidInherentExtrinsicData {
@@ -388,63 +374,9 @@ pub struct InvalidInherentExtrinsicDataProof(StorageProof);
 impl_storage_proof!(InvalidInherentExtrinsicDataProof);
 impl<Block: BlockT> BasicStorageProof<Block> for InvalidInherentExtrinsicDataProof {
     type StorageValue = InvalidInherentExtrinsicData;
-    fn storage_key_request(_key: Self::Key) -> FraudProofStorageKeyRequest<NumberFor<Block>> {
-        FraudProofStorageKeyRequest::InvalidInherentExtrinsicData
-    }
-}
-
-#[derive(Clone, Debug, Decode, Encode, Eq, PartialEq, TypeInfo)]
-pub struct InvalidInherentExtrinsicProof {
-    /// Change in the allowed chains storage proof
-    pub domain_chain_allowlist_proof: DomainChainsAllowlistUpdateStorageProof,
-}
-
-/// The verified data from an `InvalidInherentExtrinsicProof`
-#[derive(Clone, Debug, Decode, Encode, Eq, PartialEq, TypeInfo)]
-pub struct InvalidInherentExtrinsicVerified {
-    pub domain_chain_allowlist: DomainAllowlistUpdates,
-}
-
-impl InvalidInherentExtrinsicProof {
-    #[cfg(feature = "std")]
-    #[allow(clippy::let_and_return)]
-    pub fn generate<
-        Block: BlockT,
-        PP: ProofProvider<Block>,
-        SKP: FraudProofStorageKeyProviderInstance<NumberFor<Block>>,
-    >(
-        storage_key_provider: &SKP,
-        proof_provider: &PP,
-        domain_id: DomainId,
-        block_hash: Block::Hash,
-    ) -> Result<Self, GenerationError> {
-        let domain_chain_allowlist_proof = DomainChainsAllowlistUpdateStorageProof::generate(
-            proof_provider,
-            block_hash,
-            domain_id,
-            storage_key_provider,
-        )?;
-
-        Ok(Self {
-            domain_chain_allowlist_proof,
-        })
-    }
-
-    pub fn verify<Block: BlockT, SKP: FraudProofStorageKeyProvider<NumberFor<Block>>>(
-        &self,
-        domain_id: DomainId,
-        state_root: &Block::Hash,
-    ) -> Result<InvalidInherentExtrinsicVerified, VerificationError> {
-        let domain_chain_allowlist =
-            <DomainChainsAllowlistUpdateStorageProof as BasicStorageProof<Block>>::verify::<SKP>(
-                self.domain_chain_allowlist_proof.clone(),
-                domain_id,
-                state_root,
-            )?;
-
-        Ok(InvalidInherentExtrinsicVerified {
-            domain_chain_allowlist,
-        })
+    type Key = DomainId;
+    fn storage_key_request(key: Self::Key) -> FraudProofStorageKeyRequest<NumberFor<Block>> {
+        FraudProofStorageKeyRequest::InvalidInherentExtrinsicData(key)
     }
 }
 

crates/sp-domains-fraud-proof/src/verification.rs

@@ -66,21 +66,17 @@ where
     let InvalidExtrinsicsRootProof {
         valid_bundle_digests,
         invalid_inherent_extrinsic_proofs,
-        invalid_inherent_extrinsic_proof,
         maybe_domain_runtime_upgrade_proof,
         domain_sudo_call_proof,
     } = fraud_proof;
 
     let invalid_inherent_extrinsic_data =
         <InvalidInherentExtrinsicDataProof as BasicStorageProof<CBlock>>::verify::<SKP>(
             invalid_inherent_extrinsic_proofs.clone(),
-            (),
+            domain_id,
             &state_root,
         )?;
 
-    let inherent_extrinsic_verified =
-        invalid_inherent_extrinsic_proof.verify::<CBlock, SKP>(domain_id, &state_root)?;
-
     let maybe_domain_runtime_upgrade =
         maybe_domain_runtime_upgrade_proof.verify::<CBlock, SKP>(runtime_id, &state_root)?;
 
@@ -97,7 +93,7 @@ where
         maybe_domain_runtime_upgrade,
         consensus_transaction_byte_fee: invalid_inherent_extrinsic_data
             .consensus_transaction_byte_fee,
-        domain_chain_allowlist: inherent_extrinsic_verified.domain_chain_allowlist,
+        domain_chain_allowlist: invalid_inherent_extrinsic_data.domain_chain_allowlist,
         maybe_sudo_runtime_call: domain_sudo_call.maybe_call,
     };
 

crates/subspace-runtime/src/lib.rs

@@ -790,6 +790,14 @@ impl pallet_domains::BlockSlot<Runtime> for BlockSlot {
     }
 }
 
+pub struct DomainAllowlistUpdatesSource;
+
+impl pallet_domains::DomainAllowlistUpdatesProvider for DomainAllowlistUpdatesSource {
+    fn domain_allowlist_updates(domain_id: DomainId) -> Option<DomainAllowlistUpdates> {
+        Messenger::domain_chains_allowlist_update(domain_id)
+    }
+}
+
 pub struct OnChainRewards;
 
 impl sp_domains::OnChainRewards<Balance> for OnChainRewards {
@@ -844,6 +852,7 @@ impl pallet_domains::Config for Runtime {
     type MinInitialDomainAccountBalance = MinInitialDomainAccountBalance;
     type DomainBundleSubmitted = Messenger;
     type OnDomainInstantiated = Messenger;
+    type DomainAllowlistUpdates = DomainAllowlistUpdatesSource;
     type Balance = Balance;
     type MmrHash = mmr::Hash;
     type MmrProofVerifier = MmrProofVerifier;
@@ -1039,15 +1048,14 @@ pub struct StorageKeyProvider;
 impl FraudProofStorageKeyProvider<NumberFor<Block>> for StorageKeyProvider {
     fn storage_key(req: FraudProofStorageKeyRequest<NumberFor<Block>>) -> Vec<u8> {
         match req {
-            FraudProofStorageKeyRequest::InvalidInherentExtrinsicData => {
-                pallet_domains::BlockInvalidInherentExtrinsicData::<Runtime>::hashed_key().to_vec()
+            FraudProofStorageKeyRequest::InvalidInherentExtrinsicData(domain_id) => {
+                pallet_domains::BlockInvalidInherentExtrinsicData::<Runtime>::hashed_key_for(
+                    domain_id,
+                )
             }
             FraudProofStorageKeyRequest::SuccessfulBundles(domain_id) => {
                 pallet_domains::SuccessfulBundles::<Runtime>::hashed_key_for(domain_id)
             }
-            FraudProofStorageKeyRequest::DomainAllowlistUpdates(domain_id) => {
-                Messenger::domain_allow_list_update_storage_key(domain_id)
-            }
             FraudProofStorageKeyRequest::DomainRuntimeUpgrades => {
                 pallet_domains::DomainRuntimeUpgrades::<Runtime>::hashed_key().to_vec()
             }

domains/client/domain-operator/src/fraud_proof.rs

@@ -385,15 +385,8 @@ where
         let invalid_inherent_extrinsic_proofs = InvalidInherentExtrinsicDataProof::generate(
             self.consensus_client.as_ref(),
             consensus_block_hash,
-            (),
-            &self.storage_key_provider,
-        )?;
-
-        let invalid_inherent_extrinsic_proof = InvalidInherentExtrinsicProof::generate(
-            &self.storage_key_provider,
-            self.consensus_client.as_ref(),
             domain_id,
-            consensus_block_hash,
+            &self.storage_key_provider,
         )?;
 
         let maybe_domain_runtime_upgrade_proof = MaybeDomainRuntimeUpgradedProof::generate(
@@ -418,7 +411,6 @@ where
             proof: FraudProofVariant::InvalidExtrinsicsRoot(InvalidExtrinsicsRootProof {
                 valid_bundle_digests,
                 invalid_inherent_extrinsic_proofs,
-                invalid_inherent_extrinsic_proof,
                 maybe_domain_runtime_upgrade_proof,
                 domain_sudo_call_proof,
             }),