diff --git a/crates/pallet-domains/src/block_tree.rs b/crates/pallet-domains/src/block_tree.rs index 675a3bbf4d..c87f335e8c 100644 --- a/crates/pallet-domains/src/block_tree.rs +++ b/crates/pallet-domains/src/block_tree.rs @@ -1,17 +1,16 @@ //! Domain block tree -use crate::pallet::StateRoots; use crate::{ BalanceOf, BlockTree, BlockTreeNodes, Config, ConsensusBlockHash, DomainBlockNumberFor, DomainHashingFor, ExecutionInbox, ExecutionReceiptOf, HeadReceiptExtended, HeadReceiptNumber, - InboxedBundleAuthor, LatestConfirmedDomainBlockNumber, ReceiptHashFor, + InboxedBundleAuthor, LatestConfirmedDomainBlock, Pallet, ReceiptHashFor, }; use codec::{Decode, Encode}; use frame_support::{ensure, PalletError}; use scale_info::TypeInfo; use sp_core::Get; use sp_domains::merkle_tree::MerkleTree; -use sp_domains::{DomainId, ExecutionReceipt, OperatorId}; +use sp_domains::{ConfirmedDomainBlock, DomainId, ExecutionReceipt, OperatorId}; use sp_runtime::traits::{BlockNumberProvider, CheckedSub, One, Saturating, Zero}; use sp_std::cmp::Ordering; use sp_std::collections::btree_map::BTreeMap; @@ -109,7 +108,7 @@ pub(crate) fn execution_receipt_type( let head_receipt_number = HeadReceiptNumber::::get(domain_id); let next_receipt_number = head_receipt_number.saturating_add(One::one()); let latest_confirmed_domain_block_number = - LatestConfirmedDomainBlockNumber::::get(domain_id); + Pallet::::latest_confirmed_domain_block_number(domain_id); match receipt_number.cmp(&next_receipt_number) { Ordering::Greater => ReceiptType::Rejected(RejectedReceiptType::InFuture), @@ -313,12 +312,6 @@ pub(crate) fn process_execution_receipt( operator_ids, } = BlockTreeNodes::::take(receipt_hash).ok_or(Error::MissingDomainBlock)?; - _ = StateRoots::::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(); @@ -351,6 +344,18 @@ pub(crate) fn process_execution_receipt( execution_receipt.consensus_block_number, ); + LatestConfirmedDomainBlock::::insert( + domain_id, + ConfirmedDomainBlock { + block_number: to_prune, + block_hash: execution_receipt.domain_block_hash, + parent_block_receipt_hash: execution_receipt + .parent_domain_block_receipt_hash, + state_root: execution_receipt.final_state_root, + extrinsics_root: execution_receipt.domain_block_extrinsic_root, + }, + ); + return Ok(Some(ConfirmedDomainBlockInfo { domain_block_number: to_prune, operator_ids, @@ -383,14 +388,6 @@ fn add_new_receipt_to_block_tree( // Construct and add a new domain block to the block tree let er_hash = execution_receipt.hash::>(); let domain_block_number = execution_receipt.domain_block_number; - StateRoots::::insert( - ( - domain_id, - domain_block_number, - execution_receipt.domain_block_hash, - ), - execution_receipt.final_state_root, - ); BlockTree::::insert(domain_id, domain_block_number, er_hash); let block_tree_node = BlockTreeNode { @@ -407,20 +404,24 @@ pub(crate) fn import_genesis_receipt( ) { let er_hash = genesis_receipt.hash::>(); let domain_block_number = genesis_receipt.domain_block_number; + + LatestConfirmedDomainBlock::::insert( + domain_id, + ConfirmedDomainBlock { + block_number: domain_block_number, + block_hash: genesis_receipt.domain_block_hash, + parent_block_receipt_hash: Default::default(), + state_root: genesis_receipt.final_state_root, + extrinsics_root: genesis_receipt.domain_block_extrinsic_root, + }, + ); + let block_tree_node = BlockTreeNode { execution_receipt: genesis_receipt, operator_ids: sp_std::vec![], }; // NOTE: no need to update the head receipt number as `HeadReceiptNumber` is using `ValueQuery` BlockTree::::insert(domain_id, domain_block_number, er_hash); - StateRoots::::insert( - ( - domain_id, - domain_block_number, - block_tree_node.execution_receipt.domain_block_hash, - ), - block_tree_node.execution_receipt.final_state_root, - ); BlockTreeNodes::::insert(er_hash, block_tree_node); } diff --git a/crates/pallet-domains/src/lib.rs b/crates/pallet-domains/src/lib.rs index 25e5bc1288..ae6463d733 100644 --- a/crates/pallet-domains/src/lib.rs +++ b/crates/pallet-domains/src/lib.rs @@ -159,8 +159,8 @@ mod pallet { use sp_core::H256; use sp_domains::bundle_producer_election::ProofOfElectionError; use sp_domains::{ - BundleDigest, DomainId, EpochIndex, GenesisDomain, OperatorAllowList, OperatorId, - OperatorPublicKey, RuntimeId, RuntimeType, + BundleDigest, ConfirmedDomainBlock, DomainId, EpochIndex, GenesisDomain, OperatorAllowList, + OperatorId, OperatorPublicKey, RuntimeId, RuntimeType, }; use sp_domains_fraud_proof::fraud_proof::FraudProof; use sp_domains_fraud_proof::InvalidTransactionCode; @@ -495,11 +495,6 @@ mod pallet { pub(super) type HeadReceiptNumber = StorageMap<_, Identity, DomainId, DomainBlockNumberFor, ValueQuery>; - /// The latest confirmed block number of each domain. - #[pallet::storage] - pub(super) type LatestConfirmedDomainBlockNumber = - StorageMap<_, Identity, DomainId, DomainBlockNumberFor, ValueQuery>; - /// Whether the head receipt have extended in the current consensus block /// /// Temporary storage only exist during block execution @@ -507,17 +502,6 @@ mod pallet { pub(super) type HeadReceiptExtended = 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 = StorageMap< - _, - Identity, - (DomainId, DomainBlockNumberFor, 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 @@ -571,6 +555,16 @@ mod pallet { pub(super) type LastEpochStakingDistribution = StorageMap<_, Identity, DomainId, ElectionVerificationParams>, OptionQuery>; + /// Storage to hold all the domain's latest confirmed block. + #[pallet::storage] + pub(super) type LatestConfirmedDomainBlock = StorageMap< + _, + Identity, + DomainId, + ConfirmedDomainBlock, T::DomainHash>, + OptionQuery, + >; + #[derive(TypeInfo, Encode, Decode, PalletError, Debug, PartialEq)] pub enum BundleError { /// Can not find the operator for given operator id. @@ -897,11 +891,6 @@ mod pallet { ) .map_err(Error::::from)?; - LatestConfirmedDomainBlockNumber::::insert( - domain_id, - confirmed_block_info.domain_block_number, - ); - if confirmed_block_info.domain_block_number % T::StakeEpochDuration::get() == Zero::zero() { @@ -996,17 +985,9 @@ mod pallet { let receipt_hash = BlockTree::::take(domain_id, to_prune) .ok_or::>(FraudProofError::BadReceiptNotFound.into())?; - let BlockTreeNode { - execution_receipt, - operator_ids, - } = BlockTreeNodes::::take(receipt_hash) - .ok_or::>(FraudProofError::BadReceiptNotFound.into())?; - - let _ = StateRoots::::take(( - domain_id, - execution_receipt.domain_block_number, - execution_receipt.domain_block_hash, - )); + let BlockTreeNode { operator_ids, .. } = + BlockTreeNodes::::take(receipt_hash) + .ok_or::>(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 Pallet { Some(HeadDomainNumber::::get(domain_id)) } - pub fn domain_state_root( - domain_id: DomainId, - domain_block_number: DomainBlockNumberFor, - domain_block_hash: T::DomainHash, - ) -> Option { - StateRoots::::get((domain_id, domain_block_number, domain_block_hash)) - } - pub fn runtime_id(domain_id: DomainId) -> Option { DomainRegistry::::get(domain_id) .map(|domain_object| domain_object.domain_config.runtime_id) @@ -1911,7 +1884,7 @@ impl Pallet { domain_id: DomainId, ) -> Option> { let oldest_nonconfirmed_er_number = - LatestConfirmedDomainBlockNumber::::get(domain_id).saturating_add(One::one()); + Self::latest_confirmed_domain_block_number(domain_id).saturating_add(One::one()); if BlockTree::::get(domain_id, oldest_nonconfirmed_er_number).is_some() { Some(oldest_nonconfirmed_er_number) @@ -1924,6 +1897,14 @@ impl Pallet { } } + /// 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 { + LatestConfirmedDomainBlock::::get(domain_id) + .map(|block| block.block_number) + .unwrap_or_default() + } + /// Returns the domain block limit of the given domain. pub fn domain_block_limit(domain_id: DomainId) -> Option { DomainRegistry::::get(domain_id).map(|domain_obj| DomainBlockLimit { @@ -1941,7 +1922,7 @@ impl Pallet { // Start from the oldest non-confirmed ER to the head domain number let mut to_check = - LatestConfirmedDomainBlockNumber::::get(domain_id).saturating_add(One::one()); + Self::latest_confirmed_domain_block_number(domain_id).saturating_add(One::one()); let head_number = HeadDomainNumber::::get(domain_id); while to_check <= head_number { diff --git a/crates/pallet-domains/src/staking.rs b/crates/pallet-domains/src/staking.rs index 159ecca005..11f7aba14f 100644 --- a/crates/pallet-domains/src/staking.rs +++ b/crates/pallet-domains/src/staking.rs @@ -2,9 +2,9 @@ use crate::bundle_storage_fund::{self, deposit_reserve_for_storage_fund}; use crate::pallet::{ - Deposits, DomainRegistry, DomainStakingSummary, LatestConfirmedDomainBlockNumber, - NextOperatorId, NominatorCount, OperatorIdOwner, OperatorSigningKey, Operators, - PendingOperatorSwitches, PendingSlashes, PendingStakingOperationCount, Withdrawals, + Deposits, DomainRegistry, DomainStakingSummary, NextOperatorId, NominatorCount, + OperatorIdOwner, OperatorSigningKey, Operators, PendingOperatorSwitches, PendingSlashes, + PendingStakingOperationCount, Withdrawals, }; use crate::staking_epoch::mint_funds; use crate::{ @@ -685,7 +685,7 @@ pub(crate) fn do_deregister_operator( .ok_or(Error::DomainNotInitialized)?; let latest_confirmed_domain_block_number = - LatestConfirmedDomainBlockNumber::::get(operator.current_domain_id); + Pallet::::latest_confirmed_domain_block_number(operator.current_domain_id); let unlock_operator_at_domain_block_number = latest_confirmed_domain_block_number .checked_add(&T::StakeWithdrawalLockingPeriod::get()) .ok_or(Error::BlockNumberOverflow)?; @@ -859,7 +859,7 @@ pub(crate) fn do_withdraw_stake( } let latest_confirmed_domain_block_number = - LatestConfirmedDomainBlockNumber::::get(operator.current_domain_id); + Pallet::::latest_confirmed_domain_block_number(operator.current_domain_id); let unlock_at_confirmed_domain_block_number = latest_confirmed_domain_block_number .checked_add(&T::StakeWithdrawalLockingPeriod::get()) .ok_or(Error::BlockNumberOverflow)?; @@ -924,7 +924,8 @@ pub(crate) fn do_unlock_funds( .pop_front() .ok_or(Error::MissingWithdrawal)?; - let latest_confirmed_block_number = LatestConfirmedDomainBlockNumber::::get(domain_id); + let latest_confirmed_block_number = + Pallet::::latest_confirmed_domain_block_number(domain_id); ensure!( unlock_at_confirmed_domain_block_number <= latest_confirmed_block_number, Error::UnlockPeriodNotComplete @@ -1001,7 +1002,8 @@ pub(crate) fn do_unlock_operator(operator_id: OperatorId) -> Result<( }; let (domain_id, _) = domain_epoch.deconstruct(); - let latest_confirmed_block_number = LatestConfirmedDomainBlockNumber::::get(domain_id); + let latest_confirmed_block_number = + Pallet::::latest_confirmed_domain_block_number(domain_id); ensure!( unlock_at_confirmed_domain_block_number <= latest_confirmed_block_number, Error::UnlockPeriodNotComplete @@ -1233,7 +1235,7 @@ where pub(crate) mod tests { use crate::domain_registry::{DomainConfig, DomainObject}; use crate::pallet::{ - Config, Deposits, DomainRegistry, DomainStakingSummary, LatestConfirmedDomainBlockNumber, + Config, Deposits, DomainRegistry, DomainStakingSummary, LatestConfirmedDomainBlock, NextOperatorId, NominatorCount, OperatorIdOwner, Operators, PendingOperatorSwitches, PendingSlashes, Withdrawals, }; @@ -1251,8 +1253,8 @@ pub(crate) mod tests { use frame_support::{assert_err, assert_ok}; use sp_core::{Pair, U256}; use sp_domains::{ - DomainId, OperatorAllowList, OperatorId, OperatorPair, OperatorPublicKey, - ZERO_OPERATOR_SIGNING_KEY, + ConfirmedDomainBlock, DomainId, OperatorAllowList, OperatorId, OperatorPair, + OperatorPublicKey, ZERO_OPERATOR_SIGNING_KEY, }; use sp_runtime::traits::Zero; use sp_runtime::{PerThing, Perbill}; @@ -1920,7 +1922,16 @@ pub(crate) mod tests { let nominator_count = NominatorCount::::get(operator_id); let confirmed_domain_block = 100; - LatestConfirmedDomainBlockNumber::::insert(domain_id, confirmed_domain_block); + LatestConfirmedDomainBlock::::insert( + domain_id, + ConfirmedDomainBlock { + block_number: confirmed_domain_block, + block_hash: Default::default(), + parent_block_receipt_hash: Default::default(), + state_root: Default::default(), + extrinsics_root: Default::default(), + }, + ); if let Some(deposit_amount) = maybe_deposit { Balances::mint_into(&nominator_id, deposit_amount).unwrap(); @@ -1979,7 +1990,16 @@ pub(crate) mod tests { // staking withdrawal is 5 blocks // to unlock funds, confirmed block should be atleast 105 let confirmed_domain_block = 105; - LatestConfirmedDomainBlockNumber::::insert(domain_id, confirmed_domain_block); + LatestConfirmedDomainBlock::::insert( + domain_id, + ConfirmedDomainBlock { + block_number: confirmed_domain_block, + block_hash: Default::default(), + parent_block_receipt_hash: Default::default(), + state_root: Default::default(), + extrinsics_root: Default::default(), + }, + ); assert_ok!(do_unlock_funds::(operator_id, nominator_id)); let expected_balance = if include_ed { diff --git a/crates/pallet-domains/src/staking_epoch.rs b/crates/pallet-domains/src/staking_epoch.rs index 034bb3e8b1..c6cda6a8a9 100644 --- a/crates/pallet-domains/src/staking_epoch.rs +++ b/crates/pallet-domains/src/staking_epoch.rs @@ -481,8 +481,8 @@ mod tests { use crate::domain_registry::{DomainConfig, DomainObject}; use crate::pallet::{ Deposits, DomainRegistry, DomainStakingSummary, LastEpochStakingDistribution, - LatestConfirmedDomainBlockNumber, NominatorCount, OperatorIdOwner, OperatorSigningKey, - Operators, PendingOperatorSwitches, Withdrawals, + LatestConfirmedDomainBlock, NominatorCount, OperatorIdOwner, OperatorSigningKey, Operators, + PendingOperatorSwitches, Withdrawals, }; use crate::staking::tests::{register_operator, Share}; use crate::staking::{ @@ -499,7 +499,7 @@ mod tests { use frame_support::traits::fungible::InspectHold; use frame_support::weights::Weight; use sp_core::{Pair, U256}; - use sp_domains::{DomainId, OperatorAllowList, OperatorPair}; + use sp_domains::{ConfirmedDomainBlock, DomainId, OperatorAllowList, OperatorPair}; use sp_runtime::traits::Zero; use sp_runtime::{PerThing, Percent}; use std::collections::{BTreeMap, BTreeSet}; @@ -638,7 +638,16 @@ mod tests { // de-register operator let domain_block_number = 100; - LatestConfirmedDomainBlockNumber::::insert(domain_id, domain_block_number); + LatestConfirmedDomainBlock::::insert( + domain_id, + ConfirmedDomainBlock { + block_number: domain_block_number, + block_hash: Default::default(), + parent_block_receipt_hash: Default::default(), + state_root: Default::default(), + extrinsics_root: Default::default(), + }, + ); do_deregister_operator::(operator_account, operator_id).unwrap(); // finalize and add to pending operator unlocks @@ -647,7 +656,16 @@ mod tests { // staking withdrawal is 5 blocks, // to unlock funds, confirmed block should be atleast 105 let domain_block_number = 105; - LatestConfirmedDomainBlockNumber::::insert(domain_id, domain_block_number); + LatestConfirmedDomainBlock::::insert( + domain_id, + ConfirmedDomainBlock { + block_number: domain_block_number, + block_hash: Default::default(), + parent_block_receipt_hash: Default::default(), + state_root: Default::default(), + extrinsics_root: Default::default(), + }, + ); assert_ok!(do_unlock_operator::(operator_id)); diff --git a/crates/pallet-domains/src/tests.rs b/crates/pallet-domains/src/tests.rs index b2b000d4a0..8bd5b18ef1 100644 --- a/crates/pallet-domains/src/tests.rs +++ b/crates/pallet-domains/src/tests.rs @@ -453,6 +453,7 @@ pub(crate) fn create_dummy_receipt( execution_trace, execution_trace_root, block_fees: Default::default(), + transfers: Default::default(), } } diff --git a/crates/sp-domains-fraud-proof/src/bundle_equivocation.rs b/crates/sp-domains-fraud-proof/src/bundle_equivocation.rs index 0b2ac0ec83..8bba0768e1 100644 --- a/crates/sp-domains-fraud-proof/src/bundle_equivocation.rs +++ b/crates/sp-domains-fraud-proof/src/bundle_equivocation.rs @@ -191,6 +191,7 @@ mod test { execution_trace: vec![], execution_trace_root: Default::default(), block_fees: Default::default(), + transfers: Default::default(), }, estimated_bundle_weight: Default::default(), bundle_extrinsics_root: Default::default(), diff --git a/crates/sp-domains/src/lib.rs b/crates/sp-domains/src/lib.rs index 7613223463..4b9d4cbed7 100644 --- a/crates/sp-domains/src/lib.rs +++ b/crates/sp-domains/src/lib.rs @@ -36,7 +36,7 @@ use core::ops::{Add, Sub}; use core::str::FromStr; use domain_runtime_primitives::BlockFees; use hexlit::hex; -use parity_scale_codec::{Decode, Encode, MaxEncodedLen}; +use parity_scale_codec::{Codec, Decode, Encode, MaxEncodedLen}; use scale_info::TypeInfo; use serde::{Deserialize, Serialize}; use sp_application_crypto::sr25519; @@ -195,6 +195,57 @@ impl PassBy for DomainId { type PassBy = pass_by::Codec; } +/// Identifier of a chain. +#[derive( + Clone, + Copy, + Debug, + Hash, + Eq, + PartialEq, + Ord, + PartialOrd, + Encode, + Decode, + TypeInfo, + Serialize, + Deserialize, + MaxEncodedLen, +)] +pub enum ChainId { + Consensus, + Domain(DomainId), +} + +impl ChainId { + #[inline] + pub fn consensus_chain_id() -> Self { + Self::Consensus + } + + #[inline] + pub fn is_consensus_chain(&self) -> bool { + match self { + ChainId::Consensus => true, + ChainId::Domain(_) => false, + } + } +} + +impl From for ChainId { + #[inline] + fn from(x: u32) -> Self { + Self::Domain(DomainId::new(x)) + } +} + +impl From for ChainId { + #[inline] + fn from(x: DomainId) -> Self { + Self::Domain(x) + } +} + #[derive(Debug, Decode, Encode, TypeInfo, PartialEq, Eq, Clone)] pub struct BundleHeader { /// Proof of bundle producer election. @@ -433,6 +484,8 @@ pub struct ExecutionReceipt { /// Compute and Domain storage fees are shared across operators and Consensus /// storage fees are given to the consensus block author. pub block_fees: BlockFees, + /// List of transfers from this Domain to other chains + pub transfers: BTreeMap, } impl @@ -510,6 +563,7 @@ impl< execution_trace: sp_std::vec![genesis_state_root], execution_trace_root: Default::default(), block_fees: Default::default(), + transfers: Default::default(), } } @@ -546,6 +600,7 @@ impl< execution_trace, execution_trace_root, block_fees: Default::default(), + transfers: Default::default(), } } } @@ -610,6 +665,21 @@ impl ProofOfElection { } } +/// Type holding the block details of confirmed domain block. +#[derive(TypeInfo, Encode, Decode, Debug, Clone, PartialEq, Eq)] +pub struct ConfirmedDomainBlock { + /// Block number of the confirmed domain block. + pub block_number: DomainBlockNumber, + /// Block hash of the confirmed domain block. + pub block_hash: DomainHash, + /// Parent block hash of the confirmed domain block. + pub parent_block_receipt_hash: DomainHash, + /// State root of the domain block. + pub state_root: DomainHash, + /// Extrinsic root of the domain block. + pub extrinsics_root: DomainHash, +} + /// Type that represents an operator allow list for Domains. #[derive(TypeInfo, Debug, Encode, Decode, Clone, PartialEq, Eq, Serialize, Deserialize)] pub enum OperatorAllowList { diff --git a/crates/subspace-runtime/src/lib.rs b/crates/subspace-runtime/src/lib.rs index ecded75f80..d65a8f5974 100644 --- a/crates/subspace-runtime/src/lib.rs +++ b/crates/subspace-runtime/src/lib.rs @@ -477,8 +477,8 @@ impl sp_messenger::endpoint::DomainInfo for DomainInfo Domains::domain_best_number(domain_id) } - fn domain_state_root(domain_id: DomainId, number: BlockNumber, hash: Hash) -> Option { - Domains::domain_state_root(domain_id, number, hash) + fn domain_state_root(_domain_id: DomainId, _number: BlockNumber, _hash: Hash) -> Option { + None } } @@ -1061,8 +1061,8 @@ impl_runtime_apis! { Domains::domain_best_number(domain_id) } - fn domain_state_root(domain_id: DomainId, number: DomainNumber, hash: DomainHash) -> Option{ - Domains::domain_state_root(domain_id, number, hash) + fn domain_state_root(_domain_id: DomainId, _number: DomainNumber, _hash: DomainHash) -> Option{ + None } fn execution_receipt(receipt_hash: DomainHash) -> Option> { diff --git a/domains/client/domain-operator/src/aux_schema.rs b/domains/client/domain-operator/src/aux_schema.rs index cc82755393..95c0a98825 100644 --- a/domains/client/domain-operator/src/aux_schema.rs +++ b/domains/client/domain-operator/src/aux_schema.rs @@ -254,6 +254,7 @@ mod tests { execution_trace: Default::default(), execution_trace_root: Default::default(), block_fees: Default::default(), + transfers: Default::default(), } } diff --git a/domains/client/domain-operator/src/domain_block_processor.rs b/domains/client/domain-operator/src/domain_block_processor.rs index 0f7b1e6e33..ea222854e6 100644 --- a/domains/client/domain-operator/src/domain_block_processor.rs +++ b/domains/client/domain-operator/src/domain_block_processor.rs @@ -396,6 +396,8 @@ where execution_trace: trace, execution_trace_root: sp_core::H256(trace_root), block_fees, + // TODO: Fetch transfers from the runtime + transfers: Default::default(), }; Ok(DomainBlockResult { @@ -973,6 +975,7 @@ mod tests { execution_trace: sp_std::vec![], execution_trace_root: Default::default(), block_fees: Default::default(), + transfers: Default::default(), } } diff --git a/domains/primitives/messenger/src/messages.rs b/domains/primitives/messenger/src/messages.rs index 8159db3f9a..77e510be8b 100644 --- a/domains/primitives/messenger/src/messages.rs +++ b/domains/primitives/messenger/src/messages.rs @@ -1,12 +1,12 @@ use crate::endpoint::{Endpoint, EndpointRequest, EndpointResponse}; -use codec::{Decode, Encode, FullCodec, MaxEncodedLen}; +use codec::{Decode, Encode, FullCodec}; use frame_support::storage::generator::StorageMap; use frame_support::storage::storage_prefix; use frame_support::Identity; use scale_info::TypeInfo; -use serde::{Deserialize, Serialize}; use sp_core::storage::StorageKey; use sp_domains::proof_provider_and_verifier::StorageProofVerifier; +pub use sp_domains::ChainId; use sp_domains::DomainId; use sp_runtime::app_crypto::sp_core::U256; use sp_runtime::{sp_std, DispatchError}; @@ -120,57 +120,6 @@ impl MessageWeightTag { } } -/// Identifier of a chain. -#[derive( - Clone, - Copy, - Debug, - Hash, - Eq, - PartialEq, - Ord, - PartialOrd, - Encode, - Decode, - TypeInfo, - Serialize, - Deserialize, - MaxEncodedLen, -)] -pub enum ChainId { - Consensus, - Domain(DomainId), -} - -impl ChainId { - #[inline] - pub fn consensus_chain_id() -> Self { - Self::Consensus - } - - #[inline] - pub fn is_consensus_chain(&self) -> bool { - match self { - ChainId::Consensus => true, - ChainId::Domain(_) => false, - } - } -} - -impl From for ChainId { - #[inline] - fn from(x: u32) -> Self { - Self::Domain(DomainId::new(x)) - } -} - -impl From for ChainId { - #[inline] - fn from(x: DomainId) -> Self { - Self::Domain(x) - } -} - /// Message contains information to be sent to or received from another chain. #[derive(Debug, Encode, Decode, Clone, Eq, PartialEq, TypeInfo)] pub struct Message { diff --git a/test/subspace-test-runtime/src/lib.rs b/test/subspace-test-runtime/src/lib.rs index d43f02c183..d8708b9719 100644 --- a/test/subspace-test-runtime/src/lib.rs +++ b/test/subspace-test-runtime/src/lib.rs @@ -532,8 +532,8 @@ impl sp_messenger::endpoint::DomainInfo for DomainInfo Domains::domain_best_number(domain_id) } - fn domain_state_root(domain_id: DomainId, number: BlockNumber, hash: Hash) -> Option { - Domains::domain_state_root(domain_id, number, hash) + fn domain_state_root(_domain_id: DomainId, _number: BlockNumber, _hash: Hash) -> Option { + None } } @@ -1253,8 +1253,8 @@ impl_runtime_apis! { Domains::domain_best_number(domain_id) } - fn domain_state_root(domain_id: DomainId, number: DomainNumber, hash: DomainHash) -> Option{ - Domains::domain_state_root(domain_id, number, hash) + fn domain_state_root(_domain_id: DomainId, _number: DomainNumber, _hash: DomainHash) -> Option{ + None } fn execution_receipt(receipt_hash: DomainHash) -> Option> {