3131//! efficient by removing the need to track which side each intermediate hash is concatenated on.
3232//!
3333//! If the number of leaves is not even, last leaf (hash of) is promoted to the upper layer.
34+ #[ cfg( not( feature = "std" ) ) ]
35+ extern crate alloc;
36+ #[ cfg( not( feature = "std" ) ) ]
37+ use alloc:: vec;
38+ #[ cfg( not( feature = "std" ) ) ]
39+ use alloc:: vec:: Vec ;
3440
35- pub use sp_runtime:: traits:: Keccak256 ;
36- use sp_runtime:: { app_crypto:: sp_core, sp_std, traits:: Hash as HashT } ;
37- use sp_std:: { vec, vec:: Vec } ;
38-
39- use beefy_primitives:: mmr:: { BeefyAuthoritySet , BeefyNextAuthoritySet } ;
41+ use hash_db:: Hasher ;
4042
4143/// Construct a root hash of a Binary Merkle Tree created from given leaves.
4244///
4345/// See crate-level docs for details about Merkle Tree construction.
4446///
4547/// In case an empty list of leaves is passed the function returns a 0-filled hash.
46- pub fn merkle_root < H , I > ( leaves : I ) -> H :: Output
48+ pub fn merkle_root < H , I > ( leaves : I ) -> H :: Out
4749where
48- H : HashT ,
49- H :: Output : Default + AsRef < [ u8 ] > + PartialOrd ,
50+ H : Hasher ,
51+ H :: Out : Default + AsRef < [ u8 ] > + PartialOrd ,
5052 I : IntoIterator ,
5153 I :: Item : AsRef < [ u8 ] > ,
5254{
53- let iter = leaves. into_iter ( ) . map ( |l| <H as HashT >:: hash ( l. as_ref ( ) ) ) ;
55+ let iter = leaves. into_iter ( ) . map ( |l| <H as Hasher >:: hash ( l. as_ref ( ) ) ) ;
5456 merkelize :: < H , _ , _ > ( iter, & mut ( ) ) . into ( )
5557}
5658
57- fn merkelize < H , V , I > ( leaves : I , visitor : & mut V ) -> H :: Output
59+ fn merkelize < H , V , I > ( leaves : I , visitor : & mut V ) -> H :: Out
5860where
59- H : HashT ,
60- H :: Output : Default + AsRef < [ u8 ] > + PartialOrd ,
61- V : Visitor < H :: Output > ,
62- I : Iterator < Item = H :: Output > ,
61+ H : Hasher ,
62+ H :: Out : Default + AsRef < [ u8 ] > + PartialOrd ,
63+ V : Visitor < H :: Out > ,
64+ I : Iterator < Item = H :: Out > ,
6365{
6466 let upper = Vec :: with_capacity ( ( leaves. size_hint ( ) . 1 . unwrap_or ( 0 ) . saturating_add ( 1 ) ) / 2 ) ;
6567 let mut next = match merkelize_row :: < H , _ , _ > ( leaves, upper, visitor) {
6668 Ok ( root) => return root,
67- Err ( next) if next. is_empty ( ) => return H :: Output :: default ( ) ,
69+ Err ( next) if next. is_empty ( ) => return H :: Out :: default ( ) ,
6870 Err ( next) => next,
6971 } ;
7072
@@ -139,17 +141,17 @@ impl<T> Visitor<T> for () {
139141/// # Panic
140142///
141143/// The function will panic if given `leaf_index` is greater than the number of leaves.
142- pub fn merkle_proof < H , I , T > ( leaves : I , leaf_index : usize ) -> MerkleProof < H :: Output , T >
144+ pub fn merkle_proof < H , I , T > ( leaves : I , leaf_index : usize ) -> MerkleProof < H :: Out , T >
143145where
144- H : HashT ,
145- H :: Output : Default + Copy + AsRef < [ u8 ] > + PartialOrd ,
146+ H : Hasher ,
147+ H :: Out : Default + Copy + AsRef < [ u8 ] > + PartialOrd ,
146148 I : IntoIterator < Item = T > ,
147149 I :: IntoIter : ExactSizeIterator ,
148150 T : AsRef < [ u8 ] > ,
149151{
150152 let mut leaf = None ;
151153 let iter = leaves. into_iter ( ) . enumerate ( ) . map ( |( idx, l) | {
152- let hash = <H as HashT >:: hash ( l. as_ref ( ) ) ;
154+ let hash = <H as Hasher >:: hash ( l. as_ref ( ) ) ;
153155 if idx == leaf_index {
154156 leaf = Some ( l) ;
155157 }
@@ -234,28 +236,28 @@ impl<'a, H, T: AsRef<[u8]>> From<&'a T> for Leaf<'a, H> {
234236///
235237/// The proof must not contain the root hash.
236238pub fn verify_proof < ' a , H , P , L > (
237- root : & ' a H :: Output ,
239+ root : & ' a H :: Out ,
238240 proof : P ,
239241 number_of_leaves : usize ,
240242 leaf_index : usize ,
241243 leaf : L ,
242244) -> bool
243245where
244- H : HashT ,
245- H :: Output : PartialEq + AsRef < [ u8 ] > + PartialOrd ,
246- P : IntoIterator < Item = H :: Output > ,
247- L : Into < Leaf < ' a , H :: Output > > ,
246+ H : Hasher ,
247+ H :: Out : PartialEq + AsRef < [ u8 ] > + PartialOrd ,
248+ P : IntoIterator < Item = H :: Out > ,
249+ L : Into < Leaf < ' a , H :: Out > > ,
248250{
249251 if leaf_index >= number_of_leaves {
250252 return false
251253 }
252254
253255 let leaf_hash = match leaf. into ( ) {
254- Leaf :: Value ( content) => <H as HashT >:: hash ( content) ,
256+ Leaf :: Value ( content) => <H as Hasher >:: hash ( content) ,
255257 Leaf :: Hash ( hash) => hash,
256258 } ;
257259
258- let hash_len = <H as sp_core :: Hasher >:: LENGTH ;
260+ let hash_len = <H as Hasher >:: LENGTH ;
259261 let mut combined = vec ! [ 0_u8 ; hash_len * 2 ] ;
260262 let computed = proof. into_iter ( ) . fold ( leaf_hash, |a, b| {
261263 if a < b {
@@ -265,7 +267,7 @@ where
265267 combined[ ..hash_len] . copy_from_slice ( & b. as_ref ( ) ) ;
266268 combined[ hash_len..] . copy_from_slice ( & a. as_ref ( ) ) ;
267269 }
268- let hash = <H as HashT >:: hash ( & combined) ;
270+ let hash = <H as Hasher >:: hash ( & combined) ;
269271 #[ cfg( feature = "debug" ) ]
270272 log:: debug!(
271273 "[verify_proof]: (a, b) {:?}, {:?} => {:?} ({:?}) hash" ,
@@ -287,20 +289,20 @@ where
287289/// empty iterator) an `Err` with the inner nodes of upper layer is returned.
288290fn merkelize_row < H , V , I > (
289291 mut iter : I ,
290- mut next : Vec < H :: Output > ,
292+ mut next : Vec < H :: Out > ,
291293 visitor : & mut V ,
292- ) -> Result < H :: Output , Vec < H :: Output > >
294+ ) -> Result < H :: Out , Vec < H :: Out > >
293295where
294- H : HashT ,
295- H :: Output : AsRef < [ u8 ] > + PartialOrd ,
296- V : Visitor < H :: Output > ,
297- I : Iterator < Item = H :: Output > ,
296+ H : Hasher ,
297+ H :: Out : AsRef < [ u8 ] > + PartialOrd ,
298+ V : Visitor < H :: Out > ,
299+ I : Iterator < Item = H :: Out > ,
298300{
299301 #[ cfg( feature = "debug" ) ]
300302 log:: debug!( "[merkelize_row]" ) ;
301303 next. clear ( ) ;
302304
303- let hash_len = <H as sp_core :: Hasher >:: LENGTH ;
305+ let hash_len = <H as Hasher >:: LENGTH ;
304306 let mut index = 0 ;
305307 let mut combined = vec ! [ 0_u8 ; hash_len * 2 ] ;
306308 loop {
@@ -326,7 +328,7 @@ where
326328 combined[ hash_len..] . copy_from_slice ( a. as_ref ( ) ) ;
327329 }
328330
329- next. push ( <H as HashT >:: hash ( & combined) ) ;
331+ next. push ( <H as Hasher >:: hash ( & combined) ) ;
330332 } ,
331333 // Odd number of items. Promote the item to the upper layer.
332334 ( Some ( a) , None ) if !next. is_empty ( ) => {
@@ -347,24 +349,11 @@ where
347349 }
348350}
349351
350- sp_api:: decl_runtime_apis! {
351- /// API useful for BEEFY light clients.
352- pub trait BeefyMmrApi <H >
353- where
354- BeefyAuthoritySet <H >: sp_api:: Decode ,
355- {
356- /// Return the currently active BEEFY authority set proof.
357- fn authority_set_proof( ) -> BeefyAuthoritySet <H >;
358-
359- /// Return the next/queued BEEFY authority set proof.
360- fn next_authority_set_proof( ) -> BeefyNextAuthoritySet <H >;
361- }
362- }
363-
364352#[ cfg( test) ]
365353mod tests {
366354 use super :: * ;
367- use crate :: sp_core:: H256 ;
355+ use sp_core:: H256 ;
356+ use sp_runtime:: traits:: Keccak256 ;
368357
369358 #[ test]
370359 fn should_generate_empty_root ( ) {
0 commit comments