diff --git a/grandpa/src/consensus.rs b/grandpa/src/consensus.rs
index 1790faa..fdaa260 100644
--- a/grandpa/src/consensus.rs
+++ b/grandpa/src/consensus.rs
@@ -61,6 +61,7 @@ where
     T: pallet_ismp::Config + super::Config,
     T::BlockNumber: Into<u32>,
     T::Hash: From<H256>,
+    H256: From<T::Hash>,
 {
     fn verify_consensus(
         &self,
diff --git a/grandpa/src/lib.rs b/grandpa/src/lib.rs
index abd26cf..63cd96c 100644
--- a/grandpa/src/lib.rs
+++ b/grandpa/src/lib.rs
@@ -65,6 +65,7 @@ pub mod pallet {
     impl<T: Config> Pallet<T>
     where
         <T as frame_system::Config>::Hash: From<H256>,
+        H256: From<<T as frame_system::Config>::Hash>,
     {
         /// Add some new parachains to the list of parachains in the relay chain consensus state
         #[pallet::call_index(0)]
diff --git a/pallet-ismp/evm/src/precompiles.rs b/pallet-ismp/evm/src/precompiles.rs
index a745a59..da80048 100644
--- a/pallet-ismp/evm/src/precompiles.rs
+++ b/pallet-ismp/evm/src/precompiles.rs
@@ -38,6 +38,7 @@ impl<T> Precompile for IsmpPostDispatcher<T>
 where
     T: pallet_ismp::Config + pallet_evm::Config,
     <T as frame_system::Config>::Hash: From<H256>,
+    H256: From<<T as frame_system::Config>::Hash>,
 {
     fn execute(handle: &mut impl PrecompileHandle) -> PrecompileResult {
         let input = handle.input();
@@ -82,6 +83,7 @@ impl<T> Precompile for IsmpGetDispatcher<T>
 where
     T: pallet_ismp::Config + pallet_evm::Config,
     <T as frame_system::Config>::Hash: From<H256>,
+    H256: From<<T as frame_system::Config>::Hash>,
 {
     fn execute(handle: &mut impl PrecompileHandle) -> PrecompileResult {
         let input = handle.input();
@@ -129,6 +131,7 @@ impl<T> Precompile for IsmpResponseDispatcher<T>
 where
     T: pallet_ismp::Config + pallet_evm::Config,
     <T as frame_system::Config>::Hash: From<H256>,
+    H256: From<<T as frame_system::Config>::Hash>,
 {
     fn execute(handle: &mut impl PrecompileHandle) -> PrecompileResult {
         let input = handle.input();
diff --git a/pallet-ismp/primitives/src/mmr.rs b/pallet-ismp/primitives/src/mmr.rs
index e9b52cb..20ae5d6 100644
--- a/pallet-ismp/primitives/src/mmr.rs
+++ b/pallet-ismp/primitives/src/mmr.rs
@@ -19,9 +19,8 @@ use core::fmt::Formatter;
 
 use codec::{Decode, Encode};
 use ismp::{
-    host::IsmpHost,
     router::{Request, Response},
-    util::{hash_request, hash_response},
+    util::{hash_request, hash_response, Keccak256},
 };
 use primitive_types::H256;
 use sp_runtime::traits;
@@ -42,7 +41,7 @@ pub enum Leaf {
 
 impl Leaf {
     /// Returns the hash of a leaf
-    fn hash<H: IsmpHost>(&self) -> H256 {
+    fn hash<H: Keccak256>(&self) -> H256 {
         match self {
             Leaf::Request(req) => hash_request::<H>(req),
             Leaf::Response(res) => hash_response::<H>(res),
@@ -52,14 +51,14 @@ impl Leaf {
 
 /// An element representing either full data or its hash.
 #[derive(Clone, PartialEq, Eq, Encode, Decode, scale_info::TypeInfo)]
-pub enum DataOrHash<T: frame_system::Config> {
+pub enum DataOrHash {
     /// Arbitrary data in its full form.
     Data(Leaf),
     /// A hash of some data.
-    Hash(<<T as frame_system::Config>::Hashing as traits::Hash>::Output),
+    Hash(H256),
 }
 
-impl<T: frame_system::Config> core::fmt::Debug for DataOrHash<T> {
+impl core::fmt::Debug for DataOrHash {
     fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
         match self {
             DataOrHash::Data(leaf) => f.debug_struct("DataOrHash").field("Data", leaf).finish(),
@@ -68,26 +67,20 @@ impl<T: frame_system::Config> core::fmt::Debug for DataOrHash<T> {
     }
 }
 
-impl<T: frame_system::Config> From<Leaf> for DataOrHash<T> {
+impl From<Leaf> for DataOrHash {
     fn from(l: Leaf) -> Self {
         Self::Data(l)
     }
 }
 
-impl<T> DataOrHash<T>
-where
-    T: frame_system::Config,
-    T::Hash: From<H256>,
-{
+impl DataOrHash {
     /// Retrieve a hash of this item.
     ///
     /// Depending on the node type it's going to either be a contained value for [DataOrHash::Hash]
     /// node, or a hash of SCALE-encoded [DataOrHash::Data] data.
-    pub fn hash<H: IsmpHost>(
-        &self,
-    ) -> <<T as frame_system::Config>::Hashing as traits::Hash>::Output {
+    pub fn hash<H: Keccak256>(&self) -> H256 {
         match *self {
-            Self::Data(ref leaf) => <T::Hash>::from(leaf.hash::<H>()),
+            Self::Data(ref leaf) => leaf.hash::<H>(),
             Self::Hash(ref hash) => *hash,
         }
     }
@@ -100,14 +93,17 @@ impl<T, H> merkle_mountain_range::Merge for MmrHasher<T, H>
 where
     T: frame_system::Config,
     T::Hash: From<H256>,
-    H: IsmpHost,
+    H256: From<T::Hash>,
+    H: Keccak256,
 {
-    type Item = DataOrHash<T>;
+    type Item = DataOrHash;
 
     fn merge(left: &Self::Item, right: &Self::Item) -> merkle_mountain_range::Result<Self::Item> {
         let mut concat = left.hash::<H>().as_ref().to_vec();
         concat.extend_from_slice(right.hash::<H>().as_ref());
 
-        Ok(DataOrHash::Hash(<<T as frame_system::Config>::Hashing as traits::Hash>::hash(&concat)))
+        Ok(DataOrHash::Hash(
+            <<T as frame_system::Config>::Hashing as traits::Hash>::hash(&concat).into(),
+        ))
     }
 }
diff --git a/pallet-ismp/primitives/state-machine/src/lib.rs b/pallet-ismp/primitives/state-machine/src/lib.rs
index 714d291..596f099 100644
--- a/pallet-ismp/primitives/state-machine/src/lib.rs
+++ b/pallet-ismp/primitives/state-machine/src/lib.rs
@@ -55,6 +55,7 @@ where
     T: pallet_ismp::Config,
     T::BlockNumber: Into<u32>,
     T::Hash: From<H256>,
+    H256: From<T::Hash>,
 {
     fn verify_membership(
         &self,
@@ -68,8 +69,8 @@ where
         })?;
         let nodes = membership.proof.into_iter().map(|h| DataOrHash::Hash(h.into())).collect();
         let proof =
-            MerkleProof::<DataOrHash<T>, MmrHasher<T, Host<T>>>::new(membership.mmr_size, nodes);
-        let leaves: Vec<(u64, DataOrHash<T>)> = match item {
+            MerkleProof::<DataOrHash, MmrHasher<T, Host<T>>>::new(membership.mmr_size, nodes);
+        let leaves: Vec<(u64, DataOrHash)> = match item {
             RequestResponse::Request(req) => membership
                 .leaf_indices
                 .into_iter()
diff --git a/pallet-ismp/src/benchmarking.rs b/pallet-ismp/src/benchmarking.rs
index 91b7338..9cc6c1e 100644
--- a/pallet-ismp/src/benchmarking.rs
+++ b/pallet-ismp/src/benchmarking.rs
@@ -29,6 +29,7 @@ use frame_system::RawOrigin;
 #[benchmarks(
 where
 <T as frame_system::Config>::Hash: From<H256>,
+H256: From<<T as frame_system::Config>::Hash>,
 T: pallet_timestamp::Config,
 <T as pallet_timestamp::Config>::Moment: From<u64>
 )]
diff --git a/pallet-ismp/src/dispatcher.rs b/pallet-ismp/src/dispatcher.rs
index 2a6e4d3..d2d6186 100644
--- a/pallet-ismp/src/dispatcher.rs
+++ b/pallet-ismp/src/dispatcher.rs
@@ -44,6 +44,7 @@ impl<T> IsmpDispatcher for Dispatcher<T>
 where
     T: Config,
     <T as frame_system::Config>::Hash: From<H256>,
+    H256: From<<T as frame_system::Config>::Hash>,
 {
     fn dispatch_request(&self, request: DispatchRequest) -> Result<(), IsmpError> {
         let host = Host::<T>::default();
diff --git a/pallet-ismp/src/handlers.rs b/pallet-ismp/src/handlers.rs
index d38d151..43f8428 100644
--- a/pallet-ismp/src/handlers.rs
+++ b/pallet-ismp/src/handlers.rs
@@ -15,6 +15,7 @@ use sp_core::H256;
 impl<T: Config> Pallet<T>
 where
     <T as frame_system::Config>::Hash: From<H256>,
+    H256: From<<T as frame_system::Config>::Hash>,
 {
     /// Dispatch an outgoing request
     pub fn dispatch_request(request: Request) -> Result<(), IsmpError> {
diff --git a/pallet-ismp/src/host.rs b/pallet-ismp/src/host.rs
index 27e9466..358d730 100644
--- a/pallet-ismp/src/host.rs
+++ b/pallet-ismp/src/host.rs
@@ -50,6 +50,7 @@ impl<T: Config> Default for Host<T> {
 impl<T: Config> IsmpHost for Host<T>
 where
     <T as frame_system::Config>::Hash: From<H256>,
+    H256: From<<T as frame_system::Config>::Hash>,
 {
     fn host_state_machine(&self) -> StateMachine {
         T::StateMachine::get()
@@ -155,13 +156,6 @@ where
         <T as Config>::ConsensusClientProvider::consensus_client(id)
     }
 
-    fn keccak256(bytes: &[u8]) -> H256
-    where
-        Self: Sized,
-    {
-        sp_io::hashing::keccak_256(bytes).into()
-    }
-
     fn challenge_period(&self, id: ConsensusStateId) -> Option<Duration> {
         ChallengePeriod::<T>::get(&id).map(Duration::from_secs)
     }
@@ -259,3 +253,12 @@ where
         AllowedProxies::<T>::set(allowed);
     }
 }
+
+impl<T: Config> ismp_rs::util::Keccak256 for Host<T> {
+    fn keccak256(bytes: &[u8]) -> H256
+    where
+        Self: Sized,
+    {
+        sp_io::hashing::keccak_256(bytes).into()
+    }
+}
diff --git a/pallet-ismp/src/lib.rs b/pallet-ismp/src/lib.rs
index ce0b5b1..322c60e 100644
--- a/pallet-ismp/src/lib.rs
+++ b/pallet-ismp/src/lib.rs
@@ -147,7 +147,7 @@ pub mod pallet {
     /// Latest MMR Root hash
     #[pallet::storage]
     #[pallet::getter(fn mmr_root_hash)]
-    pub type RootHash<T: Config> = StorageValue<_, <T as frame_system::Config>::Hash, ValueQuery>;
+    pub type RootHash<T: Config> = StorageValue<_, H256, ValueQuery>;
 
     /// Current size of the MMR (number of leaves) for requests.
     #[pallet::storage]
@@ -160,8 +160,7 @@ pub mod pallet {
     /// are pruned and only stored in the Offchain DB.
     #[pallet::storage]
     #[pallet::getter(fn request_peaks)]
-    pub type Nodes<T: Config> =
-        StorageMap<_, Identity, NodeIndex, <T as frame_system::Config>::Hash, OptionQuery>;
+    pub type Nodes<T: Config> = StorageMap<_, Identity, NodeIndex, H256, OptionQuery>;
 
     /// Holds a map of state machine heights to their verified state commitments
     #[pallet::storage]
@@ -275,6 +274,7 @@ pub mod pallet {
     impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T>
     where
         <T as frame_system::Config>::Hash: From<H256>,
+        H256: From<<T as frame_system::Config>::Hash>,
     {
         fn on_initialize(_n: T::BlockNumber) -> Weight {
             // return Mmr finalization weight here
@@ -299,7 +299,7 @@ pub mod pallet {
 
                 root
             } else {
-                H256::default().into()
+                H256::default()
             };
 
             let digest = sp_runtime::generic::DigestItem::Consensus(ISMP_ID, root.encode());
@@ -324,6 +324,7 @@ pub mod pallet {
     impl<T: Config> Pallet<T>
     where
         <T as frame_system::Config>::Hash: From<H256>,
+        H256: From<<T as frame_system::Config>::Hash>,
     {
         /// Handles ismp messages
         #[pallet::weight(get_weight::<T>(&messages))]
@@ -456,6 +457,7 @@ pub mod pallet {
 impl<T: Config> Pallet<T>
 where
     <T as frame_system::Config>::Hash: From<H256>,
+    H256: From<<T as frame_system::Config>::Hash>,
 {
     /// Generate an MMR proof for the given `leaf_indices`.
     /// Note this method can only be used from an off-chain context
@@ -464,8 +466,7 @@ where
     /// It may return an error or panic if used incorrectly.
     pub fn generate_proof(
         leaf_indices: Vec<LeafIndex>,
-    ) -> Result<(Vec<Leaf>, primitives::Proof<<T as frame_system::Config>::Hash>), primitives::Error>
-    {
+    ) -> Result<(Vec<Leaf>, primitives::Proof<H256>), primitives::Error> {
         let leaves_count = NumberOfLeaves::<T>::get();
         let mmr = Mmr::<mmr::storage::OffchainStorage, T>::new(leaves_count);
         mmr.generate_proof(leaf_indices)
@@ -549,7 +550,7 @@ where
     }
 
     /// Return the on-chain MMR root hash.
-    pub fn mmr_root() -> <T as frame_system::Config>::Hash {
+    pub fn mmr_root() -> H256 {
         Self::mmr_root_hash()
     }
 
@@ -569,6 +570,7 @@ pub struct RequestResponseLog<T: Config> {
 impl<T: Config> Pallet<T>
 where
     <T as frame_system::Config>::Hash: From<H256>,
+    H256: From<<T as frame_system::Config>::Hash>,
 {
     /// Returns the offchain key for a request leaf index
     pub fn request_leaf_index_offchain_key(
@@ -597,7 +599,7 @@ where
     pub fn get_request(leaf_index: LeafIndex) -> Option<Request> {
         let key = Pallet::<T>::offchain_key(leaf_index);
         if let Some(elem) = sp_io::offchain::local_storage_get(StorageKind::PERSISTENT, &key) {
-            let data_or_hash = DataOrHash::<T>::decode(&mut &*elem).ok()?;
+            let data_or_hash = DataOrHash::decode(&mut &*elem).ok()?;
             return match data_or_hash {
                 DataOrHash::Data(leaf) => match leaf {
                     Leaf::Request(req) => Some(req),
@@ -613,7 +615,7 @@ where
     pub fn get_response(leaf_index: LeafIndex) -> Option<Response> {
         let key = Pallet::<T>::offchain_key(leaf_index);
         if let Some(elem) = sp_io::offchain::local_storage_get(StorageKind::PERSISTENT, &key) {
-            let data_or_hash = DataOrHash::<T>::decode(&mut &*elem).ok()?;
+            let data_or_hash = DataOrHash::decode(&mut &*elem).ok()?;
             return match data_or_hash {
                 DataOrHash::Data(leaf) => match leaf {
                     Leaf::Response(res) => Some(res),
@@ -736,7 +738,7 @@ where
 
 impl<T: Config> Pallet<T> {
     /// Get a node from runtime storage
-    fn get_node(pos: NodeIndex) -> Option<DataOrHash<T>> {
+    fn get_node(pos: NodeIndex) -> Option<DataOrHash> {
         Nodes::<T>::get(pos).map(DataOrHash::Hash)
     }
 
@@ -746,7 +748,7 @@ impl<T: Config> Pallet<T> {
     }
 
     /// Insert a node into storage
-    fn insert_node(pos: NodeIndex, node: <T as frame_system::Config>::Hash) {
+    fn insert_node(pos: NodeIndex, node: H256) {
         Nodes::<T>::insert(pos, node)
     }
 
diff --git a/pallet-ismp/src/mmr/mmr.rs b/pallet-ismp/src/mmr/mmr.rs
index d3249c4..9ceee61 100644
--- a/pallet-ismp/src/mmr/mmr.rs
+++ b/pallet-ismp/src/mmr/mmr.rs
@@ -33,18 +33,20 @@ use sp_std::prelude::*;
 pub struct Mmr<StorageType, T>
 where
     T: Config,
-    Storage<StorageType, T>: mmr_lib::MMRStore<DataOrHash<T>>,
+    Storage<StorageType, T>: mmr_lib::MMRStore<DataOrHash>,
     <T as frame_system::Config>::Hash: From<H256>,
+    H256: From<<T as frame_system::Config>::Hash>,
 {
-    mmr: mmr_lib::MMR<DataOrHash<T>, MmrHasher<T, Host<T>>, Storage<StorageType, T>>,
+    mmr: mmr_lib::MMR<DataOrHash, MmrHasher<T, Host<T>>, Storage<StorageType, T>>,
     leaves: NodeIndex,
 }
 
 impl<StorageType, T> Mmr<StorageType, T>
 where
     T: Config,
-    Storage<StorageType, T>: mmr_lib::MMRStore<DataOrHash<T>>,
+    Storage<StorageType, T>: mmr_lib::MMRStore<DataOrHash>,
     <T as frame_system::Config>::Hash: From<H256>,
+    H256: From<<T as frame_system::Config>::Hash>,
 {
     /// Create a pointer to an existing MMR with given number of leaves.
     pub fn new(leaves: NodeIndex) -> Self {
@@ -58,6 +60,7 @@ impl<T> Mmr<RuntimeStorage, T>
 where
     T: Config,
     <T as frame_system::Config>::Hash: From<H256>,
+    H256: From<<T as frame_system::Config>::Hash>,
 {
     /// Push another item to the MMR and commit
     ///
@@ -71,7 +74,7 @@ where
     }
 
     /// Calculate the new MMR's root hash.
-    pub fn finalize(self) -> Result<<T as frame_system::Config>::Hash, Error> {
+    pub fn finalize(self) -> Result<H256, Error> {
         let root = self.mmr.get_root().map_err(|_| Error::GetRoot)?;
         Ok(root.hash::<Host<T>>())
     }
@@ -82,6 +85,7 @@ impl<T> Mmr<OffchainStorage, T>
 where
     T: Config,
     <T as frame_system::Config>::Hash: From<H256>,
+    H256: From<<T as frame_system::Config>::Hash>,
 {
     /// Generate a proof for given leaf indices.
     ///
@@ -90,7 +94,7 @@ where
     pub fn generate_proof(
         &self,
         positions: Vec<NodeIndex>,
-    ) -> Result<(Vec<Leaf>, Proof<<T as frame_system::Config>::Hash>), Error> {
+    ) -> Result<(Vec<Leaf>, Proof<H256>), Error> {
         let store = <Storage<OffchainStorage, T>>::default();
         let leaves = positions
             .iter()
diff --git a/pallet-ismp/src/mmr/storage.rs b/pallet-ismp/src/mmr/storage.rs
index 34433b9..1b376a4 100644
--- a/pallet-ismp/src/mmr/storage.rs
+++ b/pallet-ismp/src/mmr/storage.rs
@@ -53,11 +53,11 @@ impl<StorageType, T> Default for Storage<StorageType, T> {
     }
 }
 
-impl<T> mmr_lib::MMRStore<DataOrHash<T>> for Storage<OffchainStorage, T>
+impl<T> mmr_lib::MMRStore<DataOrHash> for Storage<OffchainStorage, T>
 where
     T: Config,
 {
-    fn get_elem(&self, pos: NodeIndex) -> mmr_lib::Result<Option<DataOrHash<T>>> {
+    fn get_elem(&self, pos: NodeIndex) -> mmr_lib::Result<Option<DataOrHash>> {
         let key = Pallet::<T>::offchain_key(pos);
         debug!(
             target: "runtime::mmr::offchain", "offchain db get {}: key {:?}",
@@ -71,21 +71,21 @@ where
         Ok(None)
     }
 
-    fn append(&mut self, _: NodeIndex, _: Vec<DataOrHash<T>>) -> mmr_lib::Result<()> {
+    fn append(&mut self, _: NodeIndex, _: Vec<DataOrHash>) -> mmr_lib::Result<()> {
         panic!("MMR must not be altered in the off-chain context.")
     }
 }
 
-impl<T> mmr_lib::MMRStore<DataOrHash<T>> for Storage<RuntimeStorage, T>
+impl<T> mmr_lib::MMRStore<DataOrHash> for Storage<RuntimeStorage, T>
 where
     T: Config,
     <T as frame_system::Config>::Hash: From<H256>,
 {
-    fn get_elem(&self, pos: NodeIndex) -> mmr_lib::Result<Option<DataOrHash<T>>> {
+    fn get_elem(&self, pos: NodeIndex) -> mmr_lib::Result<Option<DataOrHash>> {
         Ok(Pallet::<T>::get_node(pos))
     }
 
-    fn append(&mut self, pos: NodeIndex, elems: Vec<DataOrHash<T>>) -> mmr_lib::Result<()> {
+    fn append(&mut self, pos: NodeIndex, elems: Vec<DataOrHash>) -> mmr_lib::Result<()> {
         if elems.is_empty() {
             return Ok(())
         }
@@ -144,7 +144,7 @@ where
     T: Config,
 {
     /// Store a node in the offchain db
-    fn store_to_offchain(pos: NodeIndex, node: &DataOrHash<T>) {
+    fn store_to_offchain(pos: NodeIndex, node: &DataOrHash) {
         let encoded_node = node.encode();
 
         let key = Pallet::<T>::offchain_key(pos);
diff --git a/pallet-ismp/src/tests.rs b/pallet-ismp/src/tests.rs
index c14d516..f292368 100644
--- a/pallet-ismp/src/tests.rs
+++ b/pallet-ismp/src/tests.rs
@@ -107,8 +107,7 @@ fn should_generate_proofs_correctly_for_single_leaf_mmr() {
 
         let mmr_size = NodesUtils::new(proof.leaf_count).size();
         let nodes = proof.items.into_iter().map(|h| DataOrHash::Hash(h.into())).collect();
-        let proof =
-            MerkleProof::<DataOrHash<Test>, MmrHasher<Test, Host<Test>>>::new(mmr_size, nodes);
+        let proof = MerkleProof::<DataOrHash, MmrHasher<Test, Host<Test>>>::new(mmr_size, nodes);
         let calculated_root = proof
             .calculate_root(vec![(positions[0], DataOrHash::Data(leaves[0].clone()))])
             .unwrap();
@@ -139,8 +138,7 @@ fn should_generate_and_verify_batch_proof_correctly() {
 
         let mmr_size = NodesUtils::new(proof.leaf_count).size();
         let nodes = proof.items.into_iter().map(|h| DataOrHash::Hash(h.into())).collect();
-        let proof =
-            MerkleProof::<DataOrHash<Test>, MmrHasher<Test, Host<Test>>>::new(mmr_size, nodes);
+        let proof = MerkleProof::<DataOrHash, MmrHasher<Test, Host<Test>>>::new(mmr_size, nodes);
         let calculated_root = proof
             .calculate_root(
                 indices
@@ -179,8 +177,7 @@ fn should_generate_and_verify_batch_proof_for_leaves_inserted_across_multiple_bl
 
         let mmr_size = NodesUtils::new(proof.leaf_count).size();
         let nodes = proof.items.into_iter().map(|h| DataOrHash::Hash(h.into())).collect();
-        let proof =
-            MerkleProof::<DataOrHash<Test>, MmrHasher<Test, Host<Test>>>::new(mmr_size, nodes);
+        let proof = MerkleProof::<DataOrHash, MmrHasher<Test, Host<Test>>>::new(mmr_size, nodes);
         let calculated_root = proof
             .calculate_root(
                 indices
diff --git a/parachain/src/consensus.rs b/parachain/src/consensus.rs
index 5383516..4cacab5 100644
--- a/parachain/src/consensus.rs
+++ b/parachain/src/consensus.rs
@@ -77,6 +77,7 @@ where
     T: pallet_ismp::Config + super::Config,
     T::BlockNumber: Into<u32>,
     T::Hash: From<H256>,
+    H256: From<T::Hash>,
 {
     fn verify_consensus(
         &self,
diff --git a/parachain/src/lib.rs b/parachain/src/lib.rs
index 1e5acde..8edfe92 100644
--- a/parachain/src/lib.rs
+++ b/parachain/src/lib.rs
@@ -78,6 +78,7 @@ pub mod pallet {
     impl<T: Config> Pallet<T>
     where
         <T as frame_system::Config>::Hash: From<H256>,
+        H256: From<<T as frame_system::Config>::Hash>,
     {
         /// Rather than users manually submitting consensus updates for sibling parachains, we
         /// instead make it the responsibility of the block builder to insert the consensus
@@ -135,6 +136,7 @@ pub mod pallet {
     impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T>
     where
         <T as frame_system::Config>::Hash: From<H256>,
+        H256: From<<T as frame_system::Config>::Hash>,
     {
         fn on_finalize(_n: T::BlockNumber) {
             let state = RelaychainDataProvider::<T>::current_relay_chain_state();
@@ -170,6 +172,7 @@ pub mod pallet {
     impl<T: Config> ProvideInherent for Pallet<T>
     where
         <T as frame_system::Config>::Hash: From<H256>,
+        H256: From<<T as frame_system::Config>::Hash>,
     {
         type Call = Call<T>;
         type Error = sp_inherents::MakeFatalError<()>;
@@ -205,6 +208,7 @@ pub mod pallet {
     impl<T: Config> GenesisBuild<T> for GenesisConfig
     where
         <T as frame_system::Config>::Hash: From<H256>,
+        H256: From<<T as frame_system::Config>::Hash>,
     {
         fn build(&self) {
             let host = Host::<T>::default();
@@ -221,6 +225,7 @@ pub mod pallet {
 impl<T: Config> Pallet<T>
 where
     <T as frame_system::Config>::Hash: From<H256>,
+    H256: From<<T as frame_system::Config>::Hash>,
 {
     /// Returns the list of parachains who's consensus updates will be inserted by the inherent
     /// data provider