ghostchain/ghost-node
30
0
Fork 3
Code Issues 5 Pull Requests 25 Actions Packages Projects Releases Wiki Activity

optimize pallet hashing to eliminate dynamic memory allocations

Browse Source 
Signed-off-by: Uncle Stinky <uncle.stinky@ghostchain.io>
This commit is contained in:
Uncle Stinky 2026-10-02 15:35:38 +03:00
parent 0162da4604
commit 5f39a7d9b1
Signed by: st1nky
GPG Key ID: 016064BD97603B40
6 changed files with 214 additions and 248 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pallets/helpers/Cargo.toml
View File

@ -1,6 +1,6 @@
[package] [package]
name = "ghost-helpers" name = "ghost-helpers"
version = "0.0.11" version = "0.0.12"
description = "Cryptographic utility suite for custom runtimes: optimized Bitmaps, UTXO parsing, Merkle Tree proofs, and Hash Chain components." description = "Cryptographic utility suite for custom runtimes: optimized Bitmaps, UTXO parsing, Merkle Tree proofs, and Hash Chain components."
license.workspace = true license.workspace = true
authors.workspace = true authors.workspace = true

109
pallets/helpers/src/hash_chain.rs
View File

@ -1,19 +1,5 @@
use ghost_traits::hashing::GhostHasher; use ghost_traits::hashing::GhostHasher;
fn combine_values<H, V>(left: V, right: V) -> H::Hash
where
H: GhostHasher,
V: AsRef<[u8]>,
{
let hash_len = H::hash_len();
let mut combined = sp_std::vec![0u8; hash_len * 2];
combined[..hash_len].copy_from_slice(left.as_ref());
combined[hash_len..].copy_from_slice(right.as_ref());
H::hash(&combined)
}
pub fn cumulative_hash<H, S>(raw_values: S) -> H::Hash pub fn cumulative_hash<H, S>(raw_values: S) -> H::Hash
where where
H: GhostHasher, H: GhostHasher,
@ -24,7 +10,7 @@ where
.into_iter() .into_iter()
.fold(H::empty(), |acc_hash, raw_value| { .fold(H::empty(), |acc_hash, raw_value| {
let hashed_value = H::hash(raw_value.as_ref()); let hashed_value = H::hash(raw_value.as_ref());
combine_values::<H, _>(acc_hash, hashed_value) H::combine_hashes(acc_hash, hashed_value)
}) })
} }
@ -47,7 +33,7 @@ where
iter.fold(current_hash, |acc_hash, raw_value| { iter.fold(current_hash, |acc_hash, raw_value| {
let next_hash = H::from_slice(raw_value.as_ref()); let next_hash = H::from_slice(raw_value.as_ref());
combine_values::<H, _>(acc_hash, next_hash) H::combine_hashes(acc_hash, next_hash)
}) })
} }
@ -94,45 +80,14 @@ where
mod tests { mod tests {
use super::*; use super::*;
use sp_core::H256; use sp_core::H256;
use sp_io::hashing::{blake2_256, sha2_256};
use sp_std::vec::Vec; use sp_std::vec::Vec;
pub struct TestBlake2Hasher; use crate::{
impl GhostHasher for TestBlake2Hasher { SubstrateBlake2Hasher, SubstrateKeccakHasher, UtxoSha2Hasher,
type Hash = H256; };
type HashBytes = [u8; 32];
fn hash(data: &[u8]) -> Self::Hash {
H256::from(blake2_256(data))
}
fn empty() -> Self::Hash {
H256::zero()
}
fn hash_len() -> usize {
H256::len_bytes()
}
}
pub struct TestSha2Hasher;
impl GhostHasher for TestSha2Hasher {
type Hash = H256;
type HashBytes = [u8; 32];
fn hash(data: &[u8]) -> Self::Hash {
let first_pass: [u8; 32] = sha2_256(data);
let second_pass: [u8; 32] = sha2_256(&first_pass);
H256::from(second_pass)
}
fn hash_len() -> usize {
H256::len_bytes()
}
fn empty() -> Self::Hash {
H256::zero()
}
}
fn mock_sequential_hash(header: &[u8; 80]) -> H256 { fn mock_sequential_hash(header: &[u8; 80]) -> H256 {
sequential_hash::<TestSha2Hasher, _>(core::iter::once(header)) sequential_hash::<UtxoSha2Hasher, _>(core::iter::once(header))
} }
fn create_header(prev_hash: [u8; 32]) -> [u8; 80] { fn create_header(prev_hash: [u8; 32]) -> [u8; 80] {
@ -141,10 +96,15 @@ mod tests {
header header
} }
macro_rules! run_hasher_tests {
($hasher_type:ty, $mod_name:ident) => {
mod $mod_name {
use super::*;
#[test] #[test]
fn test_generate_empty_values() { fn test_generate_empty_values() {
let empty_list: Vec<Vec<u8>> = sp_std::vec![]; let empty_list: Vec<Vec<u8>> = sp_std::vec![];
let result = cumulative_hash::<TestBlake2Hasher, _>(empty_list); let result = cumulative_hash::<$hasher_type, _>(empty_list);
assert_eq!(H256::zero(), result); assert_eq!(H256::zero(), result);
} }
@ -154,9 +114,9 @@ mod tests {
let dataset_2 = sp_std::vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]]; let dataset_2 = sp_std::vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]];
let dataset_3 = sp_std::vec![vec![9, 2, 3], vec![4, 5, 6], vec![7, 8, 9]]; let dataset_3 = sp_std::vec![vec![9, 2, 3], vec![4, 5, 6], vec![7, 8, 9]];
let hash_1 = cumulative_hash::<TestBlake2Hasher, _>(dataset_1); let hash_1 = cumulative_hash::<$hasher_type, _>(dataset_1);
let hash_2 = cumulative_hash::<TestBlake2Hasher, _>(dataset_2); let hash_2 = cumulative_hash::<$hasher_type, _>(dataset_2);
let hash_3 = cumulative_hash::<TestBlake2Hasher, _>(dataset_3); let hash_3 = cumulative_hash::<$hasher_type, _>(dataset_3);
assert_eq!(hash_1, hash_2); assert_eq!(hash_1, hash_2);
assert_ne!(hash_1, hash_3); assert_ne!(hash_1, hash_3);
@ -168,8 +128,8 @@ mod tests {
let dataset_forward = sp_std::vec![sp_std::vec![1, 1, 1], sp_std::vec![2, 2, 2]]; let dataset_forward = sp_std::vec![sp_std::vec![1, 1, 1], sp_std::vec![2, 2, 2]];
let dataset_reversed = sp_std::vec![sp_std::vec![2, 2, 2], sp_std::vec![1, 1, 1]]; let dataset_reversed = sp_std::vec![sp_std::vec![2, 2, 2], sp_std::vec![1, 1, 1]];
let hash_forward = cumulative_hash::<TestBlake2Hasher, _>(dataset_forward); let hash_forward = cumulative_hash::<$hasher_type, _>(dataset_forward);
let hash_reversed = cumulative_hash::<TestBlake2Hasher, _>(dataset_reversed); let hash_reversed = cumulative_hash::<$hasher_type, _>(dataset_reversed);
assert_ne!(hash_forward, hash_reversed); assert_ne!(hash_forward, hash_reversed);
} }
@ -177,22 +137,22 @@ mod tests {
#[test] #[test]
fn test_cumulative_hash_with_slices() { fn test_cumulative_hash_with_slices() {
let slice_data: &[&[u8]] = &[&[1, 2, 3], &[4, 5, 6]]; let slice_data: &[&[u8]] = &[&[1, 2, 3], &[4, 5, 6]];
let hash_from_slice = cumulative_hash::<TestBlake2Hasher, _>(slice_data.iter()); let hash_from_slice = cumulative_hash::<$hasher_type, _>(slice_data.iter());
assert_ne!(hash_from_slice, H256::zero()); assert_ne!(hash_from_slice, H256::zero());
} }
#[test] #[test]
fn test_sequential_hash_empty() { fn test_sequential_hash_empty() {
let empty_list: Vec<Vec<u8>> = sp_std::vec![]; let empty_list: Vec<Vec<u8>> = sp_std::vec![];
let result = sequential_hash::<TestBlake2Hasher, _>(empty_list); let result = sequential_hash::<$hasher_type, _>(empty_list);
assert_eq!(H256::zero(), result); assert_eq!(H256::zero(), result);
} }
#[test] #[test]
fn test_sequential_hash_single_element() { fn test_sequential_hash_single_element() {
let single_item = sp_std::vec![sp_std::vec![1, 2, 3]]; let single_item = sp_std::vec![sp_std::vec![1, 2, 3]];
let result = sequential_hash::<TestBlake2Hasher, _>(single_item); let result = sequential_hash::<$hasher_type, _>(single_item);
let expected = TestBlake2Hasher::hash(&[1, 2, 3]); let expected = <$hasher_type>::hash(&[1, 2, 3]);
assert_eq!(result, expected); assert_eq!(result, expected);
} }
@ -202,9 +162,9 @@ mod tests {
let data_2 = sp_std::vec![sp_std::vec![1], sp_std::vec![2], sp_std::vec![3]]; let data_2 = sp_std::vec![sp_std::vec![1], sp_std::vec![2], sp_std::vec![3]];
let data_reversed = sp_std::vec![sp_std::vec![3], sp_std::vec![2], sp_std::vec![1]]; let data_reversed = sp_std::vec![sp_std::vec![3], sp_std::vec![2], sp_std::vec![1]];
let hash_1 = sequential_hash::<TestBlake2Hasher, _>(data_1); let hash_1 = sequential_hash::<$hasher_type, _>(data_1);
let hash_2 = sequential_hash::<TestBlake2Hasher, _>(data_2); let hash_2 = sequential_hash::<$hasher_type, _>(data_2);
let hash_reversed = sequential_hash::<TestBlake2Hasher, _>(data_reversed); let hash_reversed = sequential_hash::<$hasher_type, _>(data_reversed);
assert_eq!(hash_1, hash_2); assert_eq!(hash_1, hash_2);
assert_ne!(hash_1, hash_reversed); assert_ne!(hash_1, hash_reversed);
@ -213,17 +173,24 @@ mod tests {
#[test] #[test]
fn test_sequential_vs_cumulative_hash() { fn test_sequential_vs_cumulative_hash() {
let dataset = sp_std::vec![sp_std::vec![1, 2, 3], sp_std::vec![4, 5, 6]]; let dataset = sp_std::vec![sp_std::vec![1, 2, 3], sp_std::vec![4, 5, 6]];
let seq_hash = sequential_hash::<TestBlake2Hasher, _>(dataset.clone()); let seq_hash = sequential_hash::<$hasher_type, _>(dataset.clone());
let cum_hash = cumulative_hash::<TestBlake2Hasher, _>(dataset); let cum_hash = cumulative_hash::<$hasher_type, _>(dataset);
assert_ne!(seq_hash, cum_hash); assert_ne!(seq_hash, cum_hash);
} }
#[test] #[test]
fn test_sequential_hash_with_slices() { fn test_sequential_hash_with_slices() {
let slice_data: &[&[u8]] = &[&[10, 20], &[30, 40]]; let slice_data: &[&[u8]] = &[&[10, 20], &[30, 40]];
let result = sequential_hash::<TestBlake2Hasher, _>(slice_data.iter()); let result = sequential_hash::<$hasher_type, _>(slice_data.iter());
assert_ne!(result, H256::zero()); assert_ne!(result, H256::zero());
} }
}
}
}
run_hasher_tests!(SubstrateBlake2Hasher, blake2_tests);
run_hasher_tests!(SubstrateKeccakHasher, keccak_tests);
run_hasher_tests!(UtxoSha2Hasher, sha2_tests);
#[test] #[test]
fn test_verify_in_current_block_with_empty_ancestry() { fn test_verify_in_current_block_with_empty_ancestry() {
@ -234,7 +201,7 @@ mod tests {
trusted_bytes.reverse(); trusted_bytes.reverse();
let trusted_top_block_hash = H256::from(trusted_bytes); let trusted_top_block_hash = H256::from(trusted_bytes);
let result = verify_hash_ancestry::<TestSha2Hasher, &[[u8; 80]]>( let result = verify_hash_ancestry::<UtxoSha2Hasher, &[[u8; 80]]>(
&tx_header, &tx_header,
&[], &[],
trusted_top_block_hash, trusted_top_block_hash,
@ -256,7 +223,7 @@ mod tests {
let trusted_top_block_hash = H256::from(trusted_bytes); let trusted_top_block_hash = H256::from(trusted_bytes);
let ancestry = [header_101]; let ancestry = [header_101];
let result = verify_hash_ancestry::<TestSha2Hasher, &[[u8; 80]]>( let result = verify_hash_ancestry::<UtxoSha2Hasher, &[[u8; 80]]>(
&tx_header_100, &tx_header_100,
&ancestry, &ancestry,
trusted_top_block_hash, trusted_top_block_hash,
@ -284,7 +251,7 @@ mod tests {
let trusted_top_block_hash = H256::from(trusted_bytes); let trusted_top_block_hash = H256::from(trusted_bytes);
let ancestry = [header_101, header_102, header_103]; let ancestry = [header_101, header_102, header_103];
let result = verify_hash_ancestry::<TestSha2Hasher, &[[u8; 80]]>( let result = verify_hash_ancestry::<UtxoSha2Hasher, &[[u8; 80]]>(
&header_100, &header_100,
&ancestry, &ancestry,
trusted_top_block_hash, trusted_top_block_hash,
@ -305,7 +272,7 @@ mod tests {
let trusted_top_block_hash = H256::from(trusted_bytes); let trusted_top_block_hash = H256::from(trusted_bytes);
let ancestry = [broken_header_101]; let ancestry = [broken_header_101];
let result = verify_hash_ancestry::<TestSha2Hasher, &[[u8; 80]]>( let result = verify_hash_ancestry::<UtxoSha2Hasher, &[[u8; 80]]>(
&header_100, &header_100,
&ancestry, &ancestry,
trusted_top_block_hash, trusted_top_block_hash,

81
pallets/helpers/src/lib.rs
View File

@ -48,53 +48,66 @@ where
value - f value - f
} }
pub struct SubstrateBlake2Hasher; macro_rules! impl_ghost_hasher {
impl GhostHasher for SubstrateBlake2Hasher { (
type Hash = H256; struct $name:ident;
type HashBytes = [u8; 32]; hash_type: $hash_type:ty;
fn hash(data: &[u8]) -> Self::Hash { hash_bytes_len: $hash_bytes_len:expr;
H256::from(blake2_256(data)) fn hash($data:ident) -> $hash_res:expr
) => {
pub struct $name;
impl GhostHasher for $name {
type Hash = $hash_type;
type HashBytes = [u8; $hash_bytes_len];
fn hash($data: &[u8]) -> Self::Hash {
$hash_res
} }
fn hash_len() -> usize { fn hash_len() -> usize {
H256::len_bytes() $hash_bytes_len
} }
fn empty() -> Self::Hash { fn empty() -> Self::Hash {
H256::zero() <$hash_type>::zero()
} }
fn combine_hashes(left: Self::Hash, right: Self::Hash) -> Self::Hash {
let mut combined = [0u8; $hash_bytes_len * 2];
combined[..$hash_bytes_len].copy_from_slice(left.as_ref());
combined[$hash_bytes_len..].copy_from_slice(right.as_ref());
Self::hash(&combined)
}
}
};
} }
pub struct SubstrateKeccakHasher; impl_ghost_hasher!(
impl GhostHasher for SubstrateKeccakHasher { struct SubstrateBlake2Hasher;
type Hash = H256; hash_type: H256;
type HashBytes = [u8; 32]; hash_bytes_len: 32;
fn hash(data: &[u8]) -> Self::Hash { fn hash(data) -> H256::from(blake2_256(data))
H256::from(keccak_256(data)) );
}
fn hash_len() -> usize {
H256::len_bytes()
}
fn empty() -> Self::Hash {
H256::zero()
}
}
pub struct UtxoSha2Hasher; impl_ghost_hasher!(
impl GhostHasher for UtxoSha2Hasher { struct SubstrateKeccakHasher;
type Hash = H256; hash_type: H256;
type HashBytes = [u8; 32]; hash_bytes_len: 32;
fn hash(data: &[u8]) -> Self::Hash { fn hash(data) -> H256::from(keccak_256(data))
);
impl_ghost_hasher!(
struct UtxoSha2Hasher;
hash_type: H256;
hash_bytes_len: 32;
fn hash(data) -> {
let first_pass: [u8; 32] = sha2_256(data); let first_pass: [u8; 32] = sha2_256(data);
let second_pass: [u8; 32] = sha2_256(&first_pass); let second_pass: [u8; 32] = sha2_256(&first_pass);
H256::from(second_pass) H256::from(second_pass)
} }
fn hash_len() -> usize { );
H256::len_bytes()
}
fn empty() -> Self::Hash {
H256::zero()
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {

127
pallets/helpers/src/merkle_tree.rs
View File

@ -139,23 +139,8 @@ where
mod tests { mod tests {
use super::*; use super::*;
use sp_core::H256; use sp_core::H256;
use sp_io::hashing::blake2_256;
pub struct TestBlake2Hasher; use crate::SubstrateBlake2Hasher;
impl GhostHasher for TestBlake2Hasher {
type Hash = H256;
type HashBytes = [u8; 32];
fn hash(data: &[u8]) -> Self::Hash {
H256::from(blake2_256(data))
}
fn empty() -> Self::Hash {
H256::zero()
}
fn hash_len() -> usize {
H256::len_bytes()
}
}
#[test] #[test]
fn test_generate_tree_perfect_power_of_two() { fn test_generate_tree_perfect_power_of_two() {
@ -167,7 +152,7 @@ mod tests {
(3, sp_std::vec![4]), (3, sp_std::vec![4]),
]; ];
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>( let tree = generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(
max_index, max_index,
raw_data, raw_data,
|(index, bytes)| Ok((index, bytes)), |(index, bytes)| Ok((index, bytes)),
@ -176,28 +161,28 @@ mod tests {
assert_eq!(tree.len(), 7); assert_eq!(tree.len(), 7);
let h0 = TestBlake2Hasher::hash(&[ &[0u8], [1].as_slice() ].concat()); let h0 = SubstrateBlake2Hasher::hash(&[ &[0u8], [1].as_slice() ].concat());
let h1 = TestBlake2Hasher::hash(&[ &[0u8], [2].as_slice() ].concat()); let h1 = SubstrateBlake2Hasher::hash(&[ &[0u8], [2].as_slice() ].concat());
let h2 = TestBlake2Hasher::hash(&[ &[0u8], [3].as_slice() ].concat()); let h2 = SubstrateBlake2Hasher::hash(&[ &[0u8], [3].as_slice() ].concat());
let h3 = TestBlake2Hasher::hash(&[ &[0u8], [4].as_slice() ].concat()); let h3 = SubstrateBlake2Hasher::hash(&[ &[0u8], [4].as_slice() ].concat());
let mut c1 = [0u8; 65]; let mut c1 = [0u8; 65];
c1[0] = NODE_PREFIX; c1[0] = NODE_PREFIX;
c1[1..33].copy_from_slice(h0.as_ref()); c1[1..33].copy_from_slice(h0.as_ref());
c1[33..].copy_from_slice(h1.as_ref()); c1[33..].copy_from_slice(h1.as_ref());
let parent_left = TestBlake2Hasher::hash(&c1); let parent_left = SubstrateBlake2Hasher::hash(&c1);
let mut c2 = [0u8; 65]; let mut c2 = [0u8; 65];
c2[0] = NODE_PREFIX; c2[0] = NODE_PREFIX;
c2[1..33].copy_from_slice(h2.as_ref()); c2[1..33].copy_from_slice(h2.as_ref());
c2[33..].copy_from_slice(h3.as_ref()); c2[33..].copy_from_slice(h3.as_ref());
let parent_right = TestBlake2Hasher::hash(&c2); let parent_right = SubstrateBlake2Hasher::hash(&c2);
let mut c_root = [0u8; 65]; let mut c_root = [0u8; 65];
c_root[0] = NODE_PREFIX; c_root[0] = NODE_PREFIX;
c_root[1..33].copy_from_slice(parent_left.as_ref()); c_root[1..33].copy_from_slice(parent_left.as_ref());
c_root[33..].copy_from_slice(parent_right.as_ref()); c_root[33..].copy_from_slice(parent_right.as_ref());
let expected_root = TestBlake2Hasher::hash(&c_root); let expected_root = SubstrateBlake2Hasher::hash(&c_root);
assert_eq!(tree.last().unwrap(), &expected_root); assert_eq!(tree.last().unwrap(), &expected_root);
} }
@ -211,7 +196,7 @@ mod tests {
(2, sp_std::vec![3]), (2, sp_std::vec![3]),
]; ];
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>( let tree = generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(
max_index, max_index,
raw_data, raw_data,
|(index, bytes)| Ok((index, bytes)), |(index, bytes)| Ok((index, bytes)),
@ -220,21 +205,21 @@ mod tests {
let mut empty_data = sp_std::vec![LEAF_PREFIX]; let mut empty_data = sp_std::vec![LEAF_PREFIX];
empty_data.extend_from_slice(&H256::zero().to_fixed_bytes()); empty_data.extend_from_slice(&H256::zero().to_fixed_bytes());
let empty_hash = TestBlake2Hasher::hash(&empty_data); let empty_hash = SubstrateBlake2Hasher::hash(&empty_data);
assert_eq!(tree.len(), 7); assert_eq!(tree.len(), 7);
assert_eq!(tree[3], empty_hash); assert_eq!(tree[3], empty_hash);
let mut leaf2_data = sp_std::vec![LEAF_PREFIX]; let mut leaf2_data = sp_std::vec![LEAF_PREFIX];
leaf2_data.extend_from_slice(&[3]); leaf2_data.extend_from_slice(&[3]);
let h2 = TestBlake2Hasher::hash(&leaf2_data); let h2 = SubstrateBlake2Hasher::hash(&leaf2_data);
let mut combined_right = [0u8; 65]; let mut combined_right = [0u8; 65];
combined_right[0] = NODE_PREFIX; combined_right[0] = NODE_PREFIX;
combined_right[1..33].copy_from_slice(h2.as_ref()); combined_right[1..33].copy_from_slice(h2.as_ref());
combined_right[33..].copy_from_slice(empty_hash.as_ref()); combined_right[33..].copy_from_slice(empty_hash.as_ref());
let expected_parent_right = TestBlake2Hasher::hash(&combined_right); let expected_parent_right = SubstrateBlake2Hasher::hash(&combined_right);
assert_eq!(tree[5], expected_parent_right); assert_eq!(tree[5], expected_parent_right);
} }
@ -247,17 +232,17 @@ mod tests {
let data_3 = sp_std::vec![(0, sp_std::vec![101]), (1, sp_std::vec![200])]; let data_3 = sp_std::vec![(0, sp_std::vec![101]), (1, sp_std::vec![200])];
let tree_1 = let tree_1 =
generate_tree::<TestBlake2Hasher, u32, _, _, ()>(max_index, data_1, |(i, b)| { generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(max_index, data_1, |(i, b)| {
Ok((i, b)) Ok((i, b))
}) })
.unwrap(); .unwrap();
let tree_2 = let tree_2 =
generate_tree::<TestBlake2Hasher, u32, _, _, ()>(max_index, data_2, |(i, b)| { generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(max_index, data_2, |(i, b)| {
Ok((i, b)) Ok((i, b))
}) })
.unwrap(); .unwrap();
let tree_3 = let tree_3 =
generate_tree::<TestBlake2Hasher, u32, _, _, ()>(max_index, data_3, |(i, b)| { generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(max_index, data_3, |(i, b)| {
Ok((i, b)) Ok((i, b))
}) })
.unwrap(); .unwrap();
@ -271,7 +256,7 @@ mod tests {
let max_index = 0u32; let max_index = 0u32;
let raw_data = sp_std::vec![(0, sp_std::vec![42])]; let raw_data = sp_std::vec![(0, sp_std::vec![42])];
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>( let tree = generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(
max_index, max_index,
raw_data, raw_data,
|(index, bytes)| Ok((index, bytes)), |(index, bytes)| Ok((index, bytes)),
@ -279,7 +264,7 @@ mod tests {
.unwrap(); .unwrap();
assert_eq!(tree.len(), 1); assert_eq!(tree.len(), 1);
assert_eq!(tree[0], TestBlake2Hasher::hash(&vec![LEAF_PREFIX, 42])); assert_eq!(tree[0], SubstrateBlake2Hasher::hash(&vec![LEAF_PREFIX, 42]));
} }
#[test] #[test]
@ -292,7 +277,7 @@ mod tests {
(3, sp_std::vec![4]), (3, sp_std::vec![4]),
]; ];
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>( let tree = generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(
max_index, max_index,
raw_data, raw_data,
|(index, bytes)| Ok((index, bytes)), |(index, bytes)| Ok((index, bytes)),
@ -302,13 +287,13 @@ mod tests {
let root = *tree.last().unwrap(); let root = *tree.last().unwrap();
let target_index = 2u32; let target_index = 2u32;
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, target_index); let proof = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, target_index);
assert_eq!(proof.len(), 2); assert_eq!(proof.len(), 2);
let preimage = sp_std::vec![3]; let preimage = sp_std::vec![3];
let is_valid = let is_valid =
verify_tree_proof::<TestBlake2Hasher, u32>(&preimage, &proof, root, target_index); verify_tree_proof::<SubstrateBlake2Hasher, u32>(&preimage, &proof, root, target_index);
assert!(is_valid); assert!(is_valid);
} }
@ -323,7 +308,7 @@ mod tests {
(3, sp_std::vec![4]), (3, sp_std::vec![4]),
]; ];
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>( let tree = generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(
max_index, max_index,
raw_data, raw_data,
|(index, bytes)| Ok((index, bytes)), |(index, bytes)| Ok((index, bytes)),
@ -333,13 +318,13 @@ mod tests {
let root = *tree.last().unwrap(); let root = *tree.last().unwrap();
let target_index = 2u32; let target_index = 2u32;
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, target_index); let proof = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, target_index);
assert_eq!(proof.len(), 2); assert_eq!(proof.len(), 2);
let preimage = sp_std::vec![3]; let preimage = sp_std::vec![3];
let is_valid = let is_valid =
verify_tree_proof::<TestBlake2Hasher, u32>(&preimage, &proof, root, target_index + 1); verify_tree_proof::<SubstrateBlake2Hasher, u32>(&preimage, &proof, root, target_index + 1);
assert!(!is_valid); assert!(!is_valid);
} }
@ -354,7 +339,7 @@ mod tests {
(3, sp_std::vec![40]), (3, sp_std::vec![40]),
]; ];
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>( let tree = generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(
max_index, max_index,
raw_data, raw_data,
|(index, bytes)| Ok((index, bytes)), |(index, bytes)| Ok((index, bytes)),
@ -369,19 +354,19 @@ mod tests {
let parent_left = tree[4]; // hash(h0 + h1) let parent_left = tree[4]; // hash(h0 + h1)
let parent_right = tree[5]; // hash(h2 + h3) let parent_right = tree[5]; // hash(h2 + h3)
let proof_for_0 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 0); let proof_for_0 = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, 0);
assert_eq!(proof_for_0[0], h1); assert_eq!(proof_for_0[0], h1);
assert_eq!(proof_for_0[1], parent_right); assert_eq!(proof_for_0[1], parent_right);
let proof_for_1 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 1); let proof_for_1 = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, 1);
assert_eq!(proof_for_1[0], h0); assert_eq!(proof_for_1[0], h0);
assert_eq!(proof_for_1[1], parent_right); assert_eq!(proof_for_1[1], parent_right);
let proof_for_2 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 2); let proof_for_2 = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, 2);
assert_eq!(proof_for_2[0], h3); assert_eq!(proof_for_2[0], h3);
assert_eq!(proof_for_2[1], parent_left); assert_eq!(proof_for_2[1], parent_left);
let proof_for_3 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 3); let proof_for_3 = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, 3);
assert_eq!(proof_for_3[0], h2); assert_eq!(proof_for_3[0], h2);
assert_eq!(proof_for_3[1], parent_left); assert_eq!(proof_for_3[1], parent_left);
} }
@ -395,23 +380,23 @@ mod tests {
(2, sp_std::vec![3]), (2, sp_std::vec![3]),
]; ];
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>( let tree = generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(
max_index, max_index,
raw_data, raw_data,
|(index, bytes)| Ok((index, bytes)), |(index, bytes)| Ok((index, bytes)),
) )
.unwrap(); .unwrap();
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 2); let proof = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, 2);
let mut empty_data = sp_std::vec![LEAF_PREFIX]; let mut empty_data = sp_std::vec![LEAF_PREFIX];
empty_data.extend_from_slice(&H256::zero().to_fixed_bytes()); empty_data.extend_from_slice(&H256::zero().to_fixed_bytes());
let empty_hash = TestBlake2Hasher::hash(&empty_data); let empty_hash = SubstrateBlake2Hasher::hash(&empty_data);
assert_eq!(proof[0], empty_hash); assert_eq!(proof[0], empty_hash);
let root = *tree.last().unwrap(); let root = *tree.last().unwrap();
let is_valid = let is_valid =
verify_tree_proof::<TestBlake2Hasher, u32>(&sp_std::vec![3], &proof, root, 2); verify_tree_proof::<SubstrateBlake2Hasher, u32>(&sp_std::vec![3], &proof, root, 2);
assert!(is_valid); assert!(is_valid);
} }
@ -420,14 +405,14 @@ mod tests {
let max_index = 0u32; let max_index = 0u32;
let raw_data = sp_std::vec![(0, sp_std::vec![99])]; let raw_data = sp_std::vec![(0, sp_std::vec![99])];
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>( let tree = generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(
max_index, max_index,
raw_data, raw_data,
|(index, bytes)| Ok((index, bytes)), |(index, bytes)| Ok((index, bytes)),
) )
.unwrap(); .unwrap();
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 0); let proof = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, 0);
assert!(proof.is_empty()); assert!(proof.is_empty());
} }
@ -446,7 +431,7 @@ mod tests {
(3, leaf_3.clone()) (3, leaf_3.clone())
]; ];
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>( let tree = generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(
max_index, max_index,
raw_data, raw_data,
|(index, bytes)| Ok((index, bytes)), |(index, bytes)| Ok((index, bytes)),
@ -460,30 +445,30 @@ mod tests {
let h2 = tree[2]; let h2 = tree[2];
let h3 = tree[3]; let h3 = tree[3];
let proof_for_1 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 1); let proof_for_1 = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, 1);
assert_eq!(proof_for_1[0], h0); assert_eq!(proof_for_1[0], h0);
let is_valid_1 = verify_tree_proof::<TestBlake2Hasher, u32>(&leaf_1, &proof_for_1, root, 1); let is_valid_1 = verify_tree_proof::<SubstrateBlake2Hasher, u32>(&leaf_1, &proof_for_1, root, 1);
assert!(is_valid_1); assert!(is_valid_1);
let proof_for_2 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 2); let proof_for_2 = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, 2);
assert_eq!(proof_for_2[0], h3); assert_eq!(proof_for_2[0], h3);
let is_valid_2 = verify_tree_proof::<TestBlake2Hasher, u32>(&leaf_2, &proof_for_2, root, 2); let is_valid_2 = verify_tree_proof::<SubstrateBlake2Hasher, u32>(&leaf_2, &proof_for_2, root, 2);
assert!(is_valid_2); assert!(is_valid_2);
let proof_for_0 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 0); let proof_for_0 = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, 0);
assert_eq!(proof_for_0[0], h1); assert_eq!(proof_for_0[0], h1);
assert!(verify_tree_proof::<TestBlake2Hasher, u32>( assert!(verify_tree_proof::<SubstrateBlake2Hasher, u32>(
&leaf_0, &leaf_0,
&proof_for_0, &proof_for_0,
root, root,
0 0
)); ));
let proof_for_3 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 3); let proof_for_3 = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, 3);
assert_eq!(proof_for_3[0], h2); assert_eq!(proof_for_3[0], h2);
assert!(verify_tree_proof::<TestBlake2Hasher, u32>( assert!(verify_tree_proof::<SubstrateBlake2Hasher, u32>(
&leaf_3, &leaf_3,
&proof_for_3, &proof_for_3,
root, root,
@ -493,12 +478,12 @@ mod tests {
let mut bad_proof = proof_for_1.clone(); let mut bad_proof = proof_for_1.clone();
bad_proof[0] = H256::random(); bad_proof[0] = H256::random();
let is_valid_bad_proof = let is_valid_bad_proof =
verify_tree_proof::<TestBlake2Hasher, u32>(&leaf_1, &bad_proof, root, 1); verify_tree_proof::<SubstrateBlake2Hasher, u32>(&leaf_1, &bad_proof, root, 1);
assert!(!is_valid_bad_proof); assert!(!is_valid_bad_proof);
let bad_preimage = vec![99u8]; let bad_preimage = vec![99u8];
let is_valid_bad_preimage = let is_valid_bad_preimage =
verify_tree_proof::<TestBlake2Hasher, u32>(&bad_preimage, &proof_for_1, root, 1); verify_tree_proof::<SubstrateBlake2Hasher, u32>(&bad_preimage, &proof_for_1, root, 1);
assert!(!is_valid_bad_preimage); assert!(!is_valid_bad_preimage);
} }
@ -511,7 +496,7 @@ mod tests {
raw_data.push((i, sp_std::vec![i as u8])); raw_data.push((i, sp_std::vec![i as u8]));
} }
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>( let tree = generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(
max_index, max_index,
raw_data, raw_data,
|(index, bytes)| Ok((index, bytes)), |(index, bytes)| Ok((index, bytes)),
@ -525,18 +510,18 @@ mod tests {
let target_index = 11u32; let target_index = 11u32;
let preimage = vec![target_index as u8]; let preimage = vec![target_index as u8];
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, target_index); let proof = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, target_index);
assert_eq!(proof.len(), 4); assert_eq!(proof.len(), 4);
let h10 = tree[10]; let h10 = tree[10];
assert_eq!(proof[0], h10); assert_eq!(proof[0], h10);
let is_valid = let is_valid =
verify_tree_proof::<TestBlake2Hasher, u32>(&preimage, &proof, root, target_index); verify_tree_proof::<SubstrateBlake2Hasher, u32>(&preimage, &proof, root, target_index);
assert!(is_valid); assert!(is_valid);
let is_valid_wrong_index = let is_valid_wrong_index =
verify_tree_proof::<TestBlake2Hasher, u32>(&preimage, &proof, root, 4); verify_tree_proof::<SubstrateBlake2Hasher, u32>(&preimage, &proof, root, 4);
assert!(!is_valid_wrong_index); assert!(!is_valid_wrong_index);
} }
@ -550,7 +535,7 @@ mod tests {
(3, sp_std::vec![4]), (3, sp_std::vec![4]),
]; ];
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>( let tree = generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(
max_index, max_index,
raw_data, raw_data,
|(index, bytes)| Ok((index, bytes)), |(index, bytes)| Ok((index, bytes)),
@ -560,13 +545,13 @@ mod tests {
let root = *tree.last().unwrap(); let root = *tree.last().unwrap();
let target_index = 3u32; let target_index = 3u32;
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, target_index); let proof = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, target_index);
assert_eq!(proof.len(), 2); assert_eq!(proof.len(), 2);
let preimage = sp_std::vec![4]; let preimage = sp_std::vec![4];
let is_valid = let is_valid =
verify_tree_proof::<TestBlake2Hasher, u32>(&preimage, &proof, root, target_index); verify_tree_proof::<SubstrateBlake2Hasher, u32>(&preimage, &proof, root, target_index);
assert!(is_valid); assert!(is_valid);
} }
@ -581,7 +566,7 @@ mod tests {
(3, sp_std::vec![4]), (3, sp_std::vec![4]),
]; ];
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>( let tree = generate_tree::<SubstrateBlake2Hasher, u32, _, _, ()>(
max_index, max_index,
raw_data, raw_data,
|(index, bytes)| Ok((index, bytes)), |(index, bytes)| Ok((index, bytes)),
@ -590,13 +575,13 @@ mod tests {
let root = *tree.last().unwrap(); let root = *tree.last().unwrap();
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 3u32); let proof = generate_proof::<SubstrateBlake2Hasher, u32>(&tree, max_index, 3u32);
let target_index = 4u32; let target_index = 4u32;
let preimage = sp_std::vec![4]; let preimage = sp_std::vec![4];
let is_valid = let is_valid =
verify_tree_proof::<TestBlake2Hasher, u32>(&preimage, &proof, root, target_index); verify_tree_proof::<SubstrateBlake2Hasher, u32>(&preimage, &proof, root, target_index);
assert!(!is_valid); assert!(!is_valid);
} }

2
pallets/traits/Cargo.toml
View File

@ -1,6 +1,6 @@
[package] [package]
name = "ghost-traits" name = "ghost-traits"
version = "0.4.6" version = "0.4.7"
description = "Shared traits including `GhostHasher`, `NetworkDataBasicHandler`, `BoundedBTreeMap`, `MerkleTree` and more." description = "Shared traits including `GhostHasher`, `NetworkDataBasicHandler`, `BoundedBTreeMap`, `MerkleTree` and more."
license.workspace = true license.workspace = true
authors.workspace = true authors.workspace = true

1
pallets/traits/src/hashing.rs
View File

@ -21,6 +21,7 @@ pub trait GhostHasher {
bytes bytes
} }
fn combine_hashes(left: Self::Hash, right: Self::Hash) -> Self::Hash;
fn hash(data: &[u8]) -> Self::Hash; fn hash(data: &[u8]) -> Self::Hash;
fn empty() -> Self::Hash; fn empty() -> Self::Hash;
fn hash_len() -> usize; fn hash_len() -> usize;