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

Compare commits

base: ghostchain:pallet-helpers
Branches Tags
ghostchain:main
ghostchain:pallet-weaver
ghostchain:pallet-exodus
ghostchain:pallet-helpers
ghostchain:pallet-networks
ghostchain:ghost-exodus
ghostchain:doctor-exodus
ghostchain:pallet-slow-clap
ghostchain:main-test
ghostchain:pallet-claims
ghostchain:readme
ghostchain:awakening1
ghostchain:Osiris3
ghostchain:Kitsune2
ghostchain:PR_48
ghostchain:platypus
ghostchain:updatemykeys
ghostchain:valhalla
ghostchain:fujisan-2
ghostchain:lastUpdate
ghostchain:Kermodeii1
ghostchain:apple
ghostchain:happy
ghostchain:proxmio-fix-gran-key
ghostchain:proxmio
ghostchain:flower
ghostchain:Kermodeii2
ghostchain:Fujisan-1
ghostchain:doctor_conf
ghostchain:pietro0hz-final
ghostchain:pietro0hz-new-branch
ghostchain:genesis-meta
ghostchain:metanomad
ghostchain:awakening
ghostchain:tyroneghost
ghostchain:my-feature-branch
ghostchain:Zoom
ghostchain:Kitsune1
ghostchain:Kitsune
ghostchain:youaresparta
ghostchain:mridkwya
ghostchain:GhostBranch
ghostchain:IBN1
ghostchain:starman
ghostchain:scientio
ghostchain:neptune-keys
ghostchain:matrix-one
ghostchain:ghost_7
ghostchain:v0.0.2
..
compare: ghostchain:main
Branches Tags
ghostchain:pallet-weaver
ghostchain:pallet-exodus
ghostchain:pallet-helpers
ghostchain:pallet-networks
ghostchain:main
ghostchain:ghost-exodus
ghostchain:doctor-exodus
ghostchain:pallet-slow-clap
ghostchain:main-test
ghostchain:pallet-claims
ghostchain:readme
ghostchain:awakening1
ghostchain:Osiris3
ghostchain:Kitsune2
ghostchain:PR_48
ghostchain:platypus
ghostchain:updatemykeys
ghostchain:valhalla
ghostchain:fujisan-2
ghostchain:lastUpdate
ghostchain:Kermodeii1
ghostchain:apple
ghostchain:happy
ghostchain:proxmio-fix-gran-key
ghostchain:proxmio
ghostchain:flower
ghostchain:Kermodeii2
ghostchain:Fujisan-1
ghostchain:doctor_conf
ghostchain:pietro0hz-final
ghostchain:pietro0hz-new-branch
ghostchain:genesis-meta
ghostchain:metanomad
ghostchain:awakening
ghostchain:tyroneghost
ghostchain:my-feature-branch
ghostchain:Zoom
ghostchain:Kitsune1
ghostchain:Kitsune
ghostchain:youaresparta
ghostchain:mridkwya
ghostchain:GhostBranch
ghostchain:IBN1
ghostchain:starman
ghostchain:scientio
ghostchain:neptune-keys
ghostchain:matrix-one
ghostchain:ghost_7
ghostchain:v0.0.2

No commits in common. "pallet-helpers" and "main" have entirely different histories.
pallet-hel ... main

17 changed files with 756 additions and 1022 deletions
Show Stats Expand all files Collapse all files

16
pallets/exodus/src/benchmarking.rs
View File

@ -415,16 +415,10 @@ mod benchmarks {
dummy_values.insert(identifier, dummy_value.clone());
}
let identifier_size = network_curve.scalar_bytes_len();
let merkle_tree =
NetworkCurve::build_merkle_tree(
identifier_size + dummy_value.len(),
&dummy_values,
|value, buffer| {
buffer.extend_from_slice(value.as_ref());
Ok(())
}
|value: &Vec<u8>| Ok(value.clone()),
).expect("Merkle tree for verifying shares should be valid");
let merkle_root = merkle_tree.last().copied().unwrap();
@ -703,16 +697,10 @@ mod benchmarks {
dummy_values.insert(identifier, dummy_binding_factor.clone());
}
let identifier_size = network_curve.scalar_bytes_len();
let merkle_tree =
NetworkCurve::build_merkle_tree(
identifier_size + dummy_scalar.len(),
&dummy_values,
|value, buffer| {
buffer.extend_from_slice(value.as_ref());
Ok(())
}
|value: &Vec<u8>| Ok(value.clone()),
).expect("Merkle tree for binding factor should be valid");
let merkle_root = merkle_tree.last().copied().unwrap();

2
pallets/exodus/src/error.rs
View File

@ -43,7 +43,6 @@ pub enum ExodusError {
InvalidMerkleProof,
InvalidIdentityElement,
NoActiveAuthorities,
TreeGenerationFailed,
Unknown,
}
@ -89,7 +88,6 @@ impl core::fmt::Debug for ExodusError {
ExodusError::InvalidMerkleProof => write!(fmt, "Invalid Merkle proof provided."),
ExodusError::InvalidIdentityElement => write!(fmt, "Invalid identity element provided."),
ExodusError::NoActiveAuthorities => write!(fmt, "No active authorities for signing EXODUS transactions."),
ExodusError::TreeGenerationFailed => write!(fmt, "Tree generation failed because of inconsistent indexation."),
ExodusError::Unknown => write!(fmt, "Unknown error."),
}
}

18
pallets/exodus/src/impls/dkg.rs
View File

@ -3,7 +3,6 @@ use rand_chacha::rand_core::{CryptoRng, RngCore};
use ghost_traits::exodus::{
DistributedKeyGeneration, IdentifierConverter, MerkleTreeBuilder,
CiphersuiteSizes,
};
use crate::{AuthIndex, ExodusError, NetworkCurve};
@ -242,8 +241,6 @@ impl DistributedKeyGeneration<AuthIndex, ExodusError> for NetworkCurve {
round2_packages_bytes: &Self::RoundPackages,
) -> Self::Part3Result {
with_ciphersuite!(self, |f| {
type InnerGroup = <Ciphersuite as frost_core::Ciphersuite>::Group;
let round2_secret_package = f::keys::dkg::round2::SecretPackage::deserialize(round2_secret_package_bytes)
.map_err(|_| ExodusError::DeserializationError)?;
@ -294,24 +291,13 @@ impl DistributedKeyGeneration<AuthIndex, ExodusError> for NetworkCurve {
let key_package_bytes = key_package.serialize()
.map_err(|_| ExodusError::SerializationError)?;
let identifier_size = self.scalar_bytes_len();
let verifying_share_size = self.element_bytes_len();
let verifying_shares_merkle_tree =
Self::build_merkle_tree(
identifier_size + verifying_share_size,
pubkey_package.verifying_shares(),
|verifying_share, buffer| {
let serialized = <InnerGroup as frost_core::Group>::serialize(
&verifying_share.to_element()
).map_err(|_| ExodusError::SerializationError)?;
buffer.extend_from_slice(serialized.as_ref());
Ok(())
}
|verifying_share| verifying_share.serialize()
.map_err(|_| ExodusError::SerializationError)
)?;
// TODO: make it better
let (_, merkle_proof) =
Self::generate_merkle_proof_from_tree(
pubkey_package.verifying_shares(),

34
pallets/exodus/src/impls/frost.rs
View File

@ -1,5 +1,5 @@
use ghost_traits::exodus::{
CiphersuiteSizes, IdentifierConverter, MerkleTreeBuilder,
IdentifierConverter, MerkleTreeBuilder,
FlexibleRoundOptimizedSchnorrThresholdSignature,
};
use sp_std::{
@ -15,6 +15,29 @@ impl FlexibleRoundOptimizedSchnorrThresholdSignature<AuthIndex, ExodusError> for
type Packages<'a> = BTreeMap<AuthIndex, &'a [u8]>;
type NoncePackages<'a> = BTreeMap<AuthIndex, (&'a [u8], &'a [u8])>;
fn header_bytes_len(&self) -> usize { 5 }
fn signature_bytes_len(&self) -> usize {
match self {
NetworkCurve::Secp256k1 => 64,
NetworkCurve::Ed25519 => 64,
}
}
fn element_bytes_len(&self) -> usize {
match self {
NetworkCurve::Secp256k1 => 33,
NetworkCurve::Ed25519 => 32,
}
}
fn scalar_bytes_len(&self) -> usize {
match self {
NetworkCurve::Secp256k1 => 32,
NetworkCurve::Ed25519 => 32,
}
}
fn verify_signature_share(
&self,
index: AuthIndex,
@ -307,16 +330,11 @@ impl FlexibleRoundOptimizedSchnorrThresholdSignature<AuthIndex, ExodusError> for
return Err(ExodusError::InvalidParticipantId);
}
let identifier_size = self.scalar_bytes_len();
let binding_factor_size = self.scalar_bytes_len();
let binding_factor_tree = Self::build_merkle_tree(
identifier_size + binding_factor_size,
&binding_factors_list,
|binding_factor, buffer| {
|binding_factor| {
let serialized = <InnerField as frost_core::Field>::serialize(binding_factor);
buffer.extend_from_slice(serialized.as_ref());
Ok(())
Ok(serialized.as_ref().to_vec())
}
)?;

44
pallets/exodus/src/impls/merkle.rs
View File

@ -13,16 +13,15 @@ impl MerkleTreeBuilder<AuthIndex, ExodusError> for NetworkCurve {
type Hash = <SubstrateBlake2Hasher as GhostHasher>::Hash;
fn build_merkle_tree<C, V, F>(
size_hint: usize,
values: &BTreeMap<Identifier<C>, V>,
update_preimage_buffer: F,
serialize_fn: F,
) -> Result<Vec<Self::Hash>, ExodusError>
where
C: frost_core::Ciphersuite,
<<C as Ciphersuite>::Group as Group>::Field: frost_core::Field,
F: Fn(&V, &mut Vec<u8>) -> Result<(), ExodusError>
F: Fn(&V) -> Result<Vec<u8>, ExodusError>
{
use ghost_helpers::merkle_tree::{generate_tree, MerkleTreeError};
use ghost_helpers::merkle_tree::generate_tree;
type CField<C> = <<C as Ciphersuite>::Group as Group>::Field;
@ -35,28 +34,25 @@ impl MerkleTreeBuilder<AuthIndex, ExodusError> for NetworkCurve {
})
.ok_or(ExodusError::IncorrectNumberOfIdentifiers)?;
let maybe_tree = generate_tree::<SubstrateBlake2Hasher, _, _, _, _>(
generate_tree::<SubstrateBlake2Hasher, _, _, _, _>(
max_index,
size_hint,
values.iter(),
|(identifier, value), buffer| {
|(identifier, value)| {
let id_scalar = identifier.to_scalar();
let id_bytes = <CField<C> as frost_core::Field>::serialize(&id_scalar);
let index = Self::convert_identifier_to_index(id_bytes.as_ref())?;
let value_bytes = serialize_fn(value).map_err(|_| ExodusError::SerializationError)?;
buffer.extend_from_slice(id_bytes.as_ref());
update_preimage_buffer(value, buffer)?;
// NOTE: revisit
// Is it possible to use [u8; CONSTANT] where constant is
// purely dependant on provided generic.
let mut preimage = Vec::<u8>::with_capacity(id_bytes.as_ref().len() + value_bytes.len());
preimage.extend_from_slice(id_bytes.as_ref());
preimage.extend_from_slice(value_bytes.as_ref());
Ok(index as usize)
});
match maybe_tree {
Ok(tree) => Ok(tree),
Err(MerkleTreeError::Generate(exodus_err)) => Err(exodus_err),
Err(MerkleTreeError::InvalidIndex) => Err(ExodusError::TreeGenerationFailed),
Err(MerkleTreeError::Empty) => Err(ExodusError::IncorrectNumberOfIdentifiers),
}
Ok((index as usize, preimage))
})
}
fn generate_merkle_proof_from_tree<C, V, F>(
@ -70,7 +66,7 @@ impl MerkleTreeBuilder<AuthIndex, ExodusError> for NetworkCurve {
<<C as Ciphersuite>::Group as Group>::Field: frost_core::Field,
F: Fn(&V) -> Result<Vec<u8>, ExodusError>
{
use ghost_helpers::merkle_tree::{generate_proof, MerkleTreeError};
use ghost_helpers::merkle_tree::generate_proof;
type CField<C> = <<C as Ciphersuite>::Group as Group>::Field;
@ -79,7 +75,7 @@ impl MerkleTreeBuilder<AuthIndex, ExodusError> for NetworkCurve {
.map_err(|_| ExodusError::InvalidParticipantId)?;
let value = values.get(&identifier).ok_or(ExodusError::InvalidParticipantId)?;
let value_bytes = serialize_fn(&value)?;
let value_bytes = serialize_fn(&value).map_err(|_| ExodusError::SerializationError)?;
let max_index = values.keys()
.next_back()
@ -90,15 +86,11 @@ impl MerkleTreeBuilder<AuthIndex, ExodusError> for NetworkCurve {
})
.ok_or(ExodusError::IncorrectNumberOfIdentifiers)?;
let proof = generate_proof::<SubstrateBlake2Hasher, _, _>(
let proof = generate_proof::<SubstrateBlake2Hasher, _>(
merkle_tree,
max_index,
authority_index,
).map_err(|err| match err {
MerkleTreeError::Generate(exodus_err) => exodus_err,
MerkleTreeError::InvalidIndex => ExodusError::TreeGenerationFailed,
MerkleTreeError::Empty => ExodusError::IncorrectNumberOfIdentifiers,
})?;
);
Ok((value_bytes, proof))
}

3
pallets/exodus/src/impls/mod.rs
View File

@ -72,6 +72,3 @@ mod ecdh;
#[macro_use]
mod frost;
#[macro_use]
mod sizes;

29
pallets/exodus/src/impls/sizes.rs
View File

@ -1,29 +0,0 @@
use ghost_helpers::networks::NetworkCurve;
use ghost_traits::exodus::CiphersuiteSizes;
use crate::{AuthIndex, ExodusError};
impl CiphersuiteSizes<AuthIndex, ExodusError> for NetworkCurve {
fn header_bytes_len(&self) -> usize { 5 }
fn signature_bytes_len(&self) -> usize {
match self {
NetworkCurve::Secp256k1 => 64,
NetworkCurve::Ed25519 => 64,
}
}
fn element_bytes_len(&self) -> usize {
match self {
NetworkCurve::Secp256k1 => 33,
NetworkCurve::Ed25519 => 32,
}
}
fn scalar_bytes_len(&self) -> usize {
match self {
NetworkCurve::Secp256k1 => 32,
NetworkCurve::Ed25519 => 32,
}
}
}

1
pallets/exodus/src/lib.rs
View File

@ -48,7 +48,6 @@ use ghost_traits::{
exodus::{
MerkleTreeBuilder, DistributedKeyGeneration, EllipticCurveDiffieHellman,
FlexibleRoundOptimizedSchnorrThresholdSignature, EvmGovernanceRegistrar,
CiphersuiteSizes,
},
networks::{
NetworkDataBasicHandler, NetworkDataInspectHandler,

99
pallets/exodus/src/tests.rs
View File

@ -1571,17 +1571,9 @@ fn test_merkle_tree_success_power_of_two_for_shares() {
let indices = (1..=32).collect::<Vec<AuthIndex>>();
let shares = generate_mock_secp256k1_shares(&indices);
let identifier_len = network_curve.scalar_bytes_len();
let secret_share_len = network_curve.element_bytes_len();
let tree = NetworkCurve::build_merkle_tree::<Secp256K1Sha256TR, _, _>(
identifier_len + secret_share_len,
&shares,
|share, buffer| {
let serialized = share.serialize().map_err(|_| ExodusError::SerializationError)?;
buffer.extend_from_slice(serialized.as_ref());
Ok(())
}
|share| share.serialize().map_err(|_| ExodusError::SerializationError),
).unwrap();
let root = *tree.last().unwrap();
@ -1616,16 +1608,11 @@ fn test_merkle_tree_success_power_of_two_for_scalar() {
let indices = (1..=32).collect::<Vec<AuthIndex>>();
let scalars = generate_mock_secp256k1_scalars(&indices);
let identifier_len = network_curve.scalar_bytes_len();
let secret_scalar_len = network_curve.scalar_bytes_len();
let tree = NetworkCurve::build_merkle_tree::<Secp256K1Sha256TR, _, _>(
identifier_len + secret_scalar_len,
&scalars,
|scalar, buffer| {
|scalar| {
let serialized = <Secp256K1ScalarField as Field>::serialize(scalar);
buffer.extend_from_slice(serialized.as_ref());
Ok(())
Ok(serialized.as_ref().to_vec())
}
).unwrap();
@ -1636,7 +1623,7 @@ fn test_merkle_tree_success_power_of_two_for_scalar() {
&identifier.serialize(),
).unwrap();
let (scalar_bytes, proof) =
let (shares_bytes, proof) =
NetworkCurve::generate_merkle_proof_from_tree::<Secp256K1Sha256TR, _, _>(
&scalars,
&tree,
@ -1648,7 +1635,7 @@ fn test_merkle_tree_success_power_of_two_for_scalar() {
).unwrap();
let result = network_curve.verify_merkle_proof(
&scalar_bytes,
&shares_bytes,
&proof,
root,
auth_index,
@ -1670,17 +1657,9 @@ fn test_random_sparse_combinations_stress_for_shares() {
let indices: Vec<AuthIndex> = unique_indices.into_iter().collect();
let shares = generate_mock_secp256k1_shares(&indices);
let identifier_len = network_curve.scalar_bytes_len();
let secret_share_len = network_curve.element_bytes_len();
let tree = NetworkCurve::build_merkle_tree::<Secp256K1Sha256TR, _, _>(
identifier_len + secret_share_len,
&shares,
|share, buffer| {
let serialized = share.serialize().map_err(|_| ExodusError::SerializationError)?;
buffer.extend_from_slice(serialized.as_ref());
Ok(())
}
|share| share.serialize().map_err(|_| ExodusError::SerializationError),
).unwrap();
let root = *tree.last().unwrap();
@ -1716,16 +1695,11 @@ fn test_random_sparse_combinations_stress_for_scalars() {
let indices: Vec<AuthIndex> = unique_indices.into_iter().collect();
let scalars = generate_mock_secp256k1_scalars(&indices);
let identifier_len = network_curve.scalar_bytes_len();
let secret_scalar_len = network_curve.scalar_bytes_len();
let tree = NetworkCurve::build_merkle_tree::<Secp256K1Sha256TR, _, _>(
identifier_len + secret_scalar_len,
&scalars,
|scalar, buffer| {
|scalar| {
let serialized = <Secp256K1ScalarField as Field>::serialize(scalar);
buffer.extend_from_slice(serialized.as_ref());
Ok(())
Ok(serialized.as_ref().to_vec())
}
).unwrap();
@ -1759,17 +1733,9 @@ fn test_participants_with_high_index_gap_for_shares() {
let indices = vec![1, 1023];
let shares = generate_mock_secp256k1_shares(&indices);
let identifier_len = network_curve.scalar_bytes_len();
let secret_share_len = network_curve.element_bytes_len();
let tree = NetworkCurve::build_merkle_tree::<Secp256K1Sha256TR, _, _>(
identifier_len + secret_share_len,
&shares,
|share, buffer| {
let serialized = share.serialize().map_err(|_| ExodusError::SerializationError)?;
buffer.extend_from_slice(serialized.as_ref());
Ok(())
}
|share| share.serialize().map_err(|_| ExodusError::SerializationError),
).unwrap();
let root = *tree.last().unwrap();
@ -1799,16 +1765,11 @@ fn test_participants_with_high_index_gap_for_scalars() {
let indices = vec![1, 1023];
let scalars = generate_mock_secp256k1_scalars(&indices);
let identifier_len = network_curve.scalar_bytes_len();
let secret_scalar_len = network_curve.scalar_bytes_len();
let tree = NetworkCurve::build_merkle_tree::<Secp256K1Sha256TR, _, _>(
identifier_len + secret_scalar_len,
&scalars,
|scalar, buffer| {
|scalar| {
let serialized = <Secp256K1ScalarField as Field>::serialize(scalar);
buffer.extend_from_slice(serialized.as_ref());
Ok(())
Ok(serialized.as_ref().to_vec())
}
).unwrap();
@ -1842,17 +1803,9 @@ fn test_regression_consecutive_vs_position_for_shares() {
let custom_indices = vec![2, 3];
let shares = generate_mock_secp256k1_shares(&custom_indices);
let identifier_len = network_curve.scalar_bytes_len();
let secret_share_len = network_curve.element_bytes_len();
let tree = NetworkCurve::build_merkle_tree::<Secp256K1Sha256TR, _, _>(
identifier_len + secret_share_len,
&shares,
|share, buffer| {
let serialized = share.serialize().map_err(|_| ExodusError::SerializationError)?;
buffer.extend_from_slice(serialized.as_ref());
Ok(())
}
|scalar| scalar.serialize().map_err(|_| ExodusError::SerializationError),
).unwrap();
let root = *tree.last().unwrap();
@ -1875,16 +1828,11 @@ fn test_regression_consecutive_vs_position_for_scalars() {
let custom_indices = vec![2, 3];
let scalars = generate_mock_secp256k1_scalars(&custom_indices);
let identifier_len = network_curve.scalar_bytes_len();
let secret_scalar_len = network_curve.scalar_bytes_len();
let tree = NetworkCurve::build_merkle_tree::<Secp256K1Sha256TR, _, _>(
identifier_len + secret_scalar_len,
&scalars,
|scalar, buffer| {
|scalar| {
let serialized = <Secp256K1ScalarField as Field>::serialize(scalar);
buffer.extend_from_slice(serialized.as_ref());
Ok(())
Ok(serialized.as_ref().to_vec())
}
).unwrap();
@ -1911,17 +1859,9 @@ fn test_attack_with_unknown_authority_index_for_shares() {
let custom_indices = vec![1, 2, 3];
let shares = generate_mock_secp256k1_shares(&custom_indices);
let identifier_len = network_curve.scalar_bytes_len();
let secret_share_len = network_curve.element_bytes_len();
let tree = NetworkCurve::build_merkle_tree::<Secp256K1Sha256TR, _, _>(
identifier_len + secret_share_len,
&shares,
|share, buffer| {
let serialized = share.serialize().map_err(|_| ExodusError::SerializationError)?;
buffer.extend_from_slice(serialized.as_ref());
Ok(())
}
|scalar| scalar.serialize().map_err(|_| ExodusError::SerializationError),
).unwrap();
let root = *tree.last().unwrap();
@ -1944,16 +1884,11 @@ fn test_attack_with_unknown_authority_index_for_scalars() {
let custom_indices = vec![1, 2, 3];
let scalars = generate_mock_secp256k1_scalars(&custom_indices);
let identifier_len = network_curve.scalar_bytes_len();
let secret_scalar_len = network_curve.scalar_bytes_len();
let tree = NetworkCurve::build_merkle_tree::<Secp256K1Sha256TR, _, _>(
identifier_len + secret_scalar_len,
&scalars,
|scalar, buffer| {
|scalar| {
let serialized = <Secp256K1ScalarField as Field>::serialize(scalar);
buffer.extend_from_slice(serialized.as_ref());
Ok(())
Ok(serialized.as_ref().to_vec())
}
).unwrap();

53
pallets/governance/src/tests.rs
View File

@ -79,21 +79,14 @@ fn claim_happy_path() {
let users = vec![user_1.clone(), user_2.clone(), user_3.clone()];
let max_index = 2u8;
let tmp_package_probe = ClaimPackage::<Test> {
shares: user_1.allowed_shares,
merkle_proof: Default::default(),
token_id: user_1.token_id,
index: 0u32,
};
let size_hint = tmp_package_probe.get_preimage(&user_1.evm_address, network_id).as_ref().len();
let raw_values_complex = vec![(0u8, &user_1), (1u8, &user_2), (2u8, &user_3)];
let merkle_tree = generate_tree::<SubstrateKeccakHasher, u8, _, _, ()>(
let merkle_tree = generate_tree::<SubstrateKeccakHasher, u8, _, _, _>(
max_index,
size_hint,
raw_values_complex,
|(index, u), buffer| {
|item: (u8, &NewTestUser)| -> Result<(usize, Vec<u8>), ()> {
let (index, u) = item;
let tmp_package = ClaimPackage::<Test> {
shares: u.allowed_shares,
merkle_proof: Default::default(),
@ -101,12 +94,9 @@ fn claim_happy_path() {
index: index as u32
};
let preimage_bytes = tmp_package.get_preimage(&u.evm_address, network_id);
buffer.extend_from_slice(preimage_bytes.as_ref());
Ok(index as usize)
Ok((index as usize, tmp_package.get_preimage(&u.evm_address, network_id).to_vec()))
}
).ok().unwrap();
).unwrap();
let merkle_root = *merkle_tree.last().unwrap();
@ -126,9 +116,7 @@ fn claim_happy_path() {
activated_shares: 0,
});
let proof = generate_proof::<SubstrateKeccakHasher, u8, ()>(&merkle_tree, max_index, slot_index as u8)
.ok()
.unwrap();
let proof = generate_proof::<SubstrateKeccakHasher, u8>(&merkle_tree, max_index, slot_index as u8);
let claim_package = ClaimPackage::<Test> {
shares: current_user.allowed_shares,
@ -217,33 +205,21 @@ fn partial_claims_happy_path() {
let max_index = 0u8;
let raw_values_complex = vec![(0u8, &current_user)];
let tmp_package_probe = ClaimPackage::<Test> {
shares: current_user.allowed_shares,
merkle_proof: Default::default(),
token_id: current_user.token_id,
index: 0u32,
};
let size_hint = tmp_package_probe.get_preimage(&current_user.evm_address, network_id).as_ref().len();
let merkle_tree = generate_tree::<SubstrateKeccakHasher, u8, _, _, ()>(
let merkle_tree = generate_tree::<SubstrateKeccakHasher, u8, _, _, _>(
max_index,
size_hint,
raw_values_complex,
|(index, u), buffer| {
|item: (u8, &NewTestUser)| -> Result<(usize, Vec<u8>), ()> {
let (index, u) = item;
let tmp_package = ClaimPackage::<Test> {
shares: u.allowed_shares,
merkle_proof: Default::default(),
token_id: u.token_id,
index: index as u32
};
let preimage_bytes = tmp_package.get_preimage(&u.evm_address, network_id);
buffer.extend_from_slice(preimage_bytes.as_ref());
Ok(index as usize)
Ok((index as usize, tmp_package.get_preimage(&u.evm_address, network_id).to_vec()))
}
).ok().unwrap();
).unwrap();
let total_shares = 1_000_000;
let merkle_root = *merkle_tree.last().unwrap();
@ -264,10 +240,7 @@ fn partial_claims_happy_path() {
setup_governor(&substrate_account_b);
setup_governor(&substrate_account_c);
let proof = generate_proof::<SubstrateKeccakHasher, u8, ()>(&merkle_tree, max_index, 0u8)
.ok()
.unwrap();
let proof = generate_proof::<SubstrateKeccakHasher, u8>(&merkle_tree, max_index, 0u8);
let claim_package = ClaimPackage {
shares: current_user.allowed_shares,
merkle_proof: BoundedVec::try_from(proof).unwrap(),

2
pallets/helpers/Cargo.toml
View File

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

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

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

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

@ -48,73 +48,53 @@ where
value - f
}
macro_rules! impl_ghost_hasher {
(
struct $name:ident;
hash_type: $hash_type:ty;
hash_bytes_len: $hash_bytes_len:expr;
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
pub struct SubstrateBlake2Hasher;
impl GhostHasher for SubstrateBlake2Hasher {
type Hash = H256;
type HashBytes = [u8; 32];
fn hash(data: &[u8]) -> Self::Hash {
H256::from(blake2_256(data))
}
fn hash_len() -> usize {
$hash_bytes_len
H256::len_bytes()
}
fn empty() -> Self::Hash {
<$hash_type>::zero()
H256::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)
}
fn combine_hashes_prefixed(p: u8, l: Self::Hash, r: Self::Hash) -> Self::Hash {
let mut combined = [p; $hash_bytes_len * 2 + 1];
combined[1..1 + $hash_bytes_len].copy_from_slice(l.as_ref());
combined[1 + $hash_bytes_len..].copy_from_slice(r.as_ref());
Self::hash(&combined)
}
}
};
}
impl_ghost_hasher!(
struct SubstrateBlake2Hasher;
hash_type: H256;
hash_bytes_len: 32;
fn hash(data) -> H256::from(blake2_256(data))
);
pub struct SubstrateKeccakHasher;
impl GhostHasher for SubstrateKeccakHasher {
type Hash = H256;
type HashBytes = [u8; 32];
fn hash(data: &[u8]) -> Self::Hash {
H256::from(keccak_256(data))
}
fn hash_len() -> usize {
H256::len_bytes()
}
fn empty() -> Self::Hash {
H256::zero()
}
}
impl_ghost_hasher!(
struct SubstrateKeccakHasher;
hash_type: H256;
hash_bytes_len: 32;
fn hash(data) -> H256::from(keccak_256(data))
);
impl_ghost_hasher!(
struct UtxoSha2Hasher;
hash_type: H256;
hash_bytes_len: 32;
fn hash(data) -> {
pub struct UtxoSha2Hasher;
impl GhostHasher for UtxoSha2Hasher {
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()
}
}
#[cfg(test)]
mod tests {

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

@ -6,57 +6,49 @@ use sp_std::vec::Vec;
const LEAF_PREFIX: u8 = 0;
const NODE_PREFIX: u8 = 1;
pub enum MerkleTreeError<E> {
Generate(E),
InvalidIndex,
Empty,
}
fn leaf_prefixed<H>(preimage: &[u8]) -> H::Hash
where
H: GhostHasher,
{
let mut buffer = Vec::with_capacity(preimage.len() + 1);
buffer.push(LEAF_PREFIX);
buffer.extend_from_slice(preimage);
let mut prefixed_data = sp_std::vec![LEAF_PREFIX; 1 + preimage.len()];
prefixed_data[1..].copy_from_slice(preimage);
H::hash(&prefixed_data)
}
H::hash(&buffer)
fn node_prefixed<H>(preimage1: &[u8], preimage2: &[u8]) -> H::Hash
where
H: GhostHasher,
{
let total_len = preimage1.len() + preimage2.len();
let mut prefixed_data = sp_std::vec![NODE_PREFIX; 1 + total_len];
prefixed_data[1..1 + preimage1.len()].copy_from_slice(preimage1);
prefixed_data[1 + preimage1.len()..].copy_from_slice(preimage2);
H::hash(&prefixed_data)
}
pub fn generate_tree<H, I, S, F, E>(
max_index: I,
size_hint: usize,
raw_values: S,
update_preimage_buffer: F,
) -> Result<Vec<H::Hash>, MerkleTreeError<E>>
generate_preimage: F,
) -> Result<Vec<H::Hash>, E>
where
H: GhostHasher,
S: IntoIterator,
I: AtLeast8BitUnsigned + UniqueSaturatedInto<usize>,
F: Fn(S::Item, &mut Vec<u8>) -> Result<usize, E>,
F: Fn(S::Item) -> Result<(usize, Vec<u8>), E>,
{
let num_of_leaves: usize = (max_index + I::one()).unique_saturated_into();
let padded_leaves = num_of_leaves.next_power_of_two();
let total_capacity = (2 * padded_leaves) - 1;
if total_capacity == 0 { return Err(MerkleTreeError::Empty); }
let empty_hash = H::empty();
let empty_leaf_hash = leaf_prefixed::<H>(empty_hash.as_ref());
let mut merkle_tree = sp_std::vec![empty_leaf_hash; total_capacity];
let mut buffer = Vec::with_capacity(size_hint + 1);
for item in raw_values.into_iter() {
buffer.clear();
buffer.push(LEAF_PREFIX);
let index = update_preimage_buffer(item, &mut buffer)
.map_err(|err| MerkleTreeError::Generate(err))?;
if index >= padded_leaves { return Err(MerkleTreeError::InvalidIndex); }
merkle_tree[index] = H::hash(&buffer);
let (index, preimage) = generate_preimage(item)?;
if index >= padded_leaves { return Ok(sp_std::vec![]); }
merkle_tree[index] = leaf_prefixed::<H>(&preimage)
}
let mut layer_start = 0;
@ -66,15 +58,10 @@ where
while current_layer_len > 1 {
for i in (0..current_layer_len).step_by(2) {
let layer_index = layer_start + i;
let left_bytes = merkle_tree[layer_index];
let right_bytes = merkle_tree[layer_index | 1];
let left_bytes = merkle_tree[layer_index].as_ref();
let right_bytes = merkle_tree[layer_index | 1].as_ref();
let combined_hash = H::combine_hashes_prefixed(
NODE_PREFIX,
left_bytes,
right_bytes,
);
merkle_tree[write_ptr] = combined_hash;
merkle_tree[write_ptr] = node_prefixed::<H>(left_bytes, right_bytes);
write_ptr += 1;
}
layer_start += current_layer_len;
@ -84,16 +71,16 @@ where
Ok(merkle_tree)
}
pub fn generate_proof<H, I, E>(
pub fn generate_proof<H, I>(
merkle_tree: &[H::Hash],
max_index: I,
index: I,
) -> Result<Vec<H::Hash>, MerkleTreeError<E>>
) -> Vec<H::Hash>
where
H: GhostHasher,
I: AtLeast8BitUnsigned + UniqueSaturatedInto<usize>,
{
if index > max_index { return Err(MerkleTreeError::InvalidIndex); }
if index > max_index { return sp_std::vec![]; }
let num_of_leaves: usize = (max_index + I::one()).unique_saturated_into();
let mut current_index: usize = index.unique_saturated_into();
@ -114,7 +101,7 @@ where
current_index >>= 1;
}
Ok(proof)
proof
}
pub fn verify_tree_proof<H, I>(
@ -133,11 +120,14 @@ where
let mut current_hash = leaf_prefixed::<H>(preimage);
for sibling in merkle_proof.iter() {
current_hash = if current_index % 2 == 0 {
H::combine_hashes_prefixed(NODE_PREFIX, current_hash, *sibling)
let sibling_bytes = sibling.as_ref();
let hash_bytes = current_hash.as_ref();
if current_index % 2 == 0 {
current_hash = node_prefixed::<H>(hash_bytes, sibling_bytes);
} else {
H::combine_hashes_prefixed(NODE_PREFIX, *sibling, current_hash)
};
current_hash = node_prefixed::<H>(sibling_bytes, hash_bytes);
}
current_index >>= 1;
}
@ -148,64 +138,66 @@ where
#[cfg(test)]
mod tests {
use super::*;
use sp_core::H256;
use sp_io::hashing::blake2_256;
use crate::{
SubstrateBlake2Hasher, SubstrateKeccakHasher, UtxoSha2Hasher,
};
pub struct TestBlake2Hasher;
impl GhostHasher for TestBlake2Hasher {
type Hash = H256;
type HashBytes = [u8; 32];
macro_rules! run_merkle_tree_tests {
($hasher_type:ty, $mod_name:ident) => {
mod $mod_name {
use super::*;
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]
fn test_generate_tree_perfect_power_of_two() {
let max_index = 3u32;
let size_hint = 69;
let raw_data = sp_std::vec![
(0, sp_std::vec![1; 69]),
(1, sp_std::vec![2; 69]),
(2, sp_std::vec![3; 69]),
(3, sp_std::vec![4; 69]),
(0, sp_std::vec![1]),
(1, sp_std::vec![2]),
(2, sp_std::vec![3]),
(3, sp_std::vec![4]),
];
let tree = generate_tree::<$hasher_type, u32, _, _, ()>(
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>(
max_index,
size_hint,
raw_data,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
|(index, bytes)| Ok((index, bytes)),
)
.ok()
.unwrap();
assert_eq!(tree.len(), 7);
let h0 = <$hasher_type>::hash(&[ &[0u8], [1; 69].as_slice() ].concat());
let h1 = <$hasher_type>::hash(&[ &[0u8], [2; 69].as_slice() ].concat());
let h2 = <$hasher_type>::hash(&[ &[0u8], [3; 69].as_slice() ].concat());
let h3 = <$hasher_type>::hash(&[ &[0u8], [4; 69].as_slice() ].concat());
let h0 = TestBlake2Hasher::hash(&[ &[0u8], [1].as_slice() ].concat());
let h1 = TestBlake2Hasher::hash(&[ &[0u8], [2].as_slice() ].concat());
let h2 = TestBlake2Hasher::hash(&[ &[0u8], [3].as_slice() ].concat());
let h3 = TestBlake2Hasher::hash(&[ &[0u8], [4].as_slice() ].concat());
let mut c1 = [0u8; 65];
c1[0] = NODE_PREFIX;
c1[1..33].copy_from_slice(h0.as_ref());
c1[33..].copy_from_slice(h1.as_ref());
let parent_left = <$hasher_type>::hash(&c1);
let parent_left = TestBlake2Hasher::hash(&c1);
let mut c2 = [0u8; 65];
c2[0] = NODE_PREFIX;
c2[1..33].copy_from_slice(h2.as_ref());
c2[33..].copy_from_slice(h3.as_ref());
let parent_right = <$hasher_type>::hash(&c2);
let parent_right = TestBlake2Hasher::hash(&c2);
let mut c_root = [0u8; 65];
c_root[0] = NODE_PREFIX;
c_root[1..33].copy_from_slice(parent_left.as_ref());
c_root[33..].copy_from_slice(parent_right.as_ref());
let expected_root = <$hasher_type>::hash(&c_root);
let expected_root = TestBlake2Hasher::hash(&c_root);
assert_eq!(tree.last().unwrap(), &expected_root);
}
@ -213,44 +205,36 @@ mod tests {
#[test]
fn test_generate_tree_with_padding_hashing() {
let max_index = 2u32;
let size_hint = 420;
let raw_data = sp_std::vec![
(0, sp_std::vec![1; size_hint]),
(1, sp_std::vec![2; size_hint]),
(2, sp_std::vec![3; size_hint]),
(0, sp_std::vec![1]),
(1, sp_std::vec![2]),
(2, sp_std::vec![3]),
];
let tree = generate_tree::<$hasher_type, u32, _, _, ()>(
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>(
max_index,
size_hint,
raw_data,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
|(index, bytes)| Ok((index, bytes)),
)
.ok()
.unwrap();
let mut empty_data = sp_std::vec![LEAF_PREFIX];
empty_data.extend_from_slice(&<$hasher_type>::empty().to_fixed_bytes());
let empty_hash = <$hasher_type>::hash(&empty_data);
empty_data.extend_from_slice(&H256::zero().to_fixed_bytes());
let empty_hash = TestBlake2Hasher::hash(&empty_data);
assert_eq!(tree.len(), 7);
assert_eq!(tree[3], empty_hash);
let mut leaf2_data = sp_std::vec![LEAF_PREFIX];
leaf2_data.extend_from_slice(&sp_std::vec![3; size_hint]);
let h2 = <$hasher_type>::hash(&leaf2_data);
leaf2_data.extend_from_slice(&[3]);
let h2 = TestBlake2Hasher::hash(&leaf2_data);
let mut combined_right = [0u8; 65];
combined_right[0] = NODE_PREFIX;
combined_right[1..33].copy_from_slice(h2.as_ref());
combined_right[33..].copy_from_slice(empty_hash.as_ref());
let expected_parent_right = <$hasher_type>::hash(&combined_right);
let expected_parent_right = TestBlake2Hasher::hash(&combined_right);
assert_eq!(tree[5], expected_parent_right);
}
@ -262,43 +246,20 @@ mod tests {
let data_2 = sp_std::vec![(0, sp_std::vec![100]), (1, sp_std::vec![200])];
let data_3 = sp_std::vec![(0, sp_std::vec![101]), (1, sp_std::vec![200])];
let tree_1 = generate_tree::<$hasher_type, u32, _, _, ()>(
max_index,
1,
data_1,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
)
.ok()
let tree_1 =
generate_tree::<TestBlake2Hasher, u32, _, _, ()>(max_index, data_1, |(i, b)| {
Ok((i, b))
})
.unwrap();
let tree_2 = generate_tree::<$hasher_type, u32, _, _, ()>(
max_index,
1,
data_2,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
)
.ok()
let tree_2 =
generate_tree::<TestBlake2Hasher, u32, _, _, ()>(max_index, data_2, |(i, b)| {
Ok((i, b))
})
.unwrap();
let tree_3 = generate_tree::<$hasher_type, u32, _, _, ()>(
max_index,
1,
data_3,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
)
.ok()
let tree_3 =
generate_tree::<TestBlake2Hasher, u32, _, _, ()>(max_index, data_3, |(i, b)| {
Ok((i, b))
})
.unwrap();
assert_eq!(tree_1.last().unwrap(), tree_2.last().unwrap());
@ -308,132 +269,96 @@ mod tests {
#[test]
fn test_generate_tree_single_element() {
let max_index = 0u32;
let size_hint = 1337;
let raw_data = sp_std::vec![(0, sp_std::vec![42; size_hint])];
let raw_data = sp_std::vec![(0, sp_std::vec![42])];
let tree = generate_tree::<$hasher_type, u32, _, _, ()>(
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>(
max_index,
size_hint,
raw_data,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
|(index, bytes)| Ok((index, bytes)),
)
.ok()
.unwrap();
let expected_leaf_data = [
&[LEAF_PREFIX][..],
sp_std::vec![42; size_hint].as_slice()
].concat();
let expected_hash = <$hasher_type>::hash(&expected_leaf_data);
assert_eq!(tree.len(), 1);
assert_eq!(tree[0], expected_hash);
assert_eq!(tree[0], TestBlake2Hasher::hash(&vec![LEAF_PREFIX, 42]));
}
#[test]
fn test_proof_and_verification_end_to_end() {
let max_index = 3u32;
let size_hint = 420;
let raw_data = sp_std::vec![
(0, sp_std::vec![1; size_hint]),
(1, sp_std::vec![2; size_hint]),
(2, sp_std::vec![3; size_hint]),
(3, sp_std::vec![4; size_hint]),
(0, sp_std::vec![1]),
(1, sp_std::vec![2]),
(2, sp_std::vec![3]),
(3, sp_std::vec![4]),
];
let tree = generate_tree::<$hasher_type, u32, _, _, ()>(
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>(
max_index,
size_hint,
raw_data,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
|(index, bytes)| Ok((index, bytes)),
)
.ok()
.unwrap();
let root = *tree.last().unwrap();
let target_index = 2u32;
let proof = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, target_index)
.ok()
.unwrap();
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, target_index);
assert_eq!(proof.len(), 2);
let preimage = sp_std::vec![3; size_hint];
assert!(verify_tree_proof::<$hasher_type, u32>(&preimage, &proof, root, target_index));
let preimage = sp_std::vec![3];
let is_valid =
verify_tree_proof::<TestBlake2Hasher, u32>(&preimage, &proof, root, target_index);
assert!(is_valid);
}
#[test]
fn test_proof_index_out_of_bounds() {
let max_index = 3u32;
let size_hint = 420;
let raw_data = sp_std::vec![
(0, sp_std::vec![1; size_hint]),
(1, sp_std::vec![2; size_hint]),
(2, sp_std::vec![3; size_hint]),
(3, sp_std::vec![4; size_hint]),
(0, sp_std::vec![1]),
(1, sp_std::vec![2]),
(2, sp_std::vec![3]),
(3, sp_std::vec![4]),
];
let tree = generate_tree::<$hasher_type, u32, _, _, ()>(
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>(
max_index,
size_hint,
raw_data,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
|(index, bytes)| Ok((index, bytes)),
)
.ok()
.unwrap();
let root = *tree.last().unwrap();
let target_index = 2u32;
let proof = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, target_index)
.ok()
.unwrap();
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, target_index);
assert_eq!(proof.len(), 2);
let preimage = sp_std::vec![3; size_hint];
assert!(verify_tree_proof::<$hasher_type, u32>(&preimage, &proof, root, target_index));
assert!(!verify_tree_proof::<$hasher_type, u32>(&preimage, &proof, root, 4));
let preimage = sp_std::vec![3];
let is_valid =
verify_tree_proof::<TestBlake2Hasher, u32>(&preimage, &proof, root, target_index + 1);
assert!(!is_valid);
}
#[test]
fn test_proof_contains_correct_siblings() {
let max_index = 3u32;
let size_hint = 1337;
let raw_data = sp_std::vec![
(0, sp_std::vec![10; size_hint]),
(1, sp_std::vec![20; size_hint]),
(2, sp_std::vec![30; size_hint]),
(3, sp_std::vec![40; size_hint]),
(0, sp_std::vec![10]),
(1, sp_std::vec![20]),
(2, sp_std::vec![30]),
(3, sp_std::vec![40]),
];
let tree = generate_tree::<$hasher_type, u32, _, _, ()>(
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>(
max_index,
size_hint,
raw_data,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
|(index, bytes)| Ok((index, bytes)),
)
.ok()
.unwrap();
let h0 = tree[0];
@ -444,31 +369,19 @@ mod tests {
let parent_left = tree[4]; // hash(h0 + h1)
let parent_right = tree[5]; // hash(h2 + h3)
let proof_for_0 = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, 0)
.ok()
.unwrap();
let proof_for_0 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 0);
assert_eq!(proof_for_0[0], h1);
assert_eq!(proof_for_0[1], parent_right);
let proof_for_1 = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, 1)
.ok()
.unwrap();
let proof_for_1 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 1);
assert_eq!(proof_for_1[0], h0);
assert_eq!(proof_for_1[1], parent_right);
let proof_for_2 = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, 2)
.ok()
.unwrap();
let proof_for_2 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 2);
assert_eq!(proof_for_2[0], h3);
assert_eq!(proof_for_2[1], parent_left);
let proof_for_3 = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, 3)
.ok()
.unwrap();
let proof_for_3 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 3);
assert_eq!(proof_for_3[0], h2);
assert_eq!(proof_for_3[1], parent_left);
}
@ -476,38 +389,30 @@ mod tests {
#[test]
fn test_proof_for_padded_tree_leaf() {
let max_index = 2u32;
let size_hint = 69;
let raw_data = sp_std::vec![
(0, sp_std::vec![1; size_hint]),
(1, sp_std::vec![2; size_hint]),
(2, sp_std::vec![3; size_hint]),
(0, sp_std::vec![1]),
(1, sp_std::vec![2]),
(2, sp_std::vec![3]),
];
let tree = generate_tree::<$hasher_type, u32, _, _, ()>(
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>(
max_index,
size_hint,
raw_data,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
|(index, bytes)| Ok((index, bytes)),
)
.ok()
.unwrap();
let proof = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, 2)
.ok()
.unwrap();
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 2);
let mut empty_data = sp_std::vec![LEAF_PREFIX];
empty_data.extend_from_slice(&<$hasher_type>::empty().to_fixed_bytes());
let empty_hash = <$hasher_type>::hash(&empty_data);
empty_data.extend_from_slice(&H256::zero().to_fixed_bytes());
let empty_hash = TestBlake2Hasher::hash(&empty_data);
assert_eq!(proof[0], empty_hash);
let root = *tree.last().unwrap();
assert!(verify_tree_proof::<$hasher_type, u32>(&sp_std::vec![3; size_hint], &proof, root, 2));
let is_valid =
verify_tree_proof::<TestBlake2Hasher, u32>(&sp_std::vec![3], &proof, root, 2);
assert!(is_valid);
}
#[test]
@ -515,39 +420,24 @@ mod tests {
let max_index = 0u32;
let raw_data = sp_std::vec![(0, sp_std::vec![99])];
let tree = generate_tree::<$hasher_type, u32, _, _, ()>(
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>(
max_index,
1,
raw_data,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
|(index, bytes)| Ok((index, bytes)),
)
.ok()
.unwrap();
let proof = generate_proof::<$hasher_type, u32, ()>(
&tree,
max_index,
0
)
.ok()
.unwrap();
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 0);
assert!(proof.is_empty());
}
#[test]
fn test_verify_tree_proof_with_h0_h3_and_random_values() {
let max_index = 3u32;
let size_hint = 69;
let leaf_0 = sp_std::vec![10u8; 69];
let leaf_1 = sp_std::vec![20u8; 69];
let leaf_2 = sp_std::vec![30u8; 69];
let leaf_3 = sp_std::vec![40u8; 69];
let leaf_0 = sp_std::vec![10u8];
let leaf_1 = sp_std::vec![20u8];
let leaf_2 = sp_std::vec![30u8];
let leaf_3 = sp_std::vec![40u8];
let raw_data = sp_std::vec![
(0, leaf_0.clone()),
@ -556,17 +446,11 @@ mod tests {
(3, leaf_3.clone())
];
let tree = generate_tree::<$hasher_type, u32, _, _, ()>(
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>(
max_index,
size_hint,
raw_data,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
|(index, bytes)| Ok((index, bytes)),
)
.ok()
.unwrap();
let root = *tree.last().unwrap();
@ -576,35 +460,45 @@ mod tests {
let h2 = tree[2];
let h3 = tree[3];
let proof_for_1 = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, 1).ok().unwrap();
let proof_for_1 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 1);
assert_eq!(proof_for_1[0], h0);
let is_valid_1 = verify_tree_proof::<$hasher_type, u32>(&leaf_1, &proof_for_1, root, 1);
let is_valid_1 = verify_tree_proof::<TestBlake2Hasher, u32>(&leaf_1, &proof_for_1, root, 1);
assert!(is_valid_1);
let proof_for_2 = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, 2).ok().unwrap();
let proof_for_2 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 2);
assert_eq!(proof_for_2[0], h3);
let is_valid_2 = verify_tree_proof::<$hasher_type, u32>(&leaf_2, &proof_for_2, root, 2);
let is_valid_2 = verify_tree_proof::<TestBlake2Hasher, u32>(&leaf_2, &proof_for_2, root, 2);
assert!(is_valid_2);
let proof_for_0 = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, 0).ok().unwrap();
let proof_for_0 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 0);
assert_eq!(proof_for_0[0], h1);
assert!(verify_tree_proof::<$hasher_type, u32>(&leaf_0, &proof_for_0, root, 0));
assert!(verify_tree_proof::<TestBlake2Hasher, u32>(
&leaf_0,
&proof_for_0,
root,
0
));
let proof_for_3 = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, 3).ok().unwrap();
let proof_for_3 = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 3);
assert_eq!(proof_for_3[0], h2);
assert!(verify_tree_proof::<$hasher_type, u32>(&leaf_3, &proof_for_3, root, 3));
assert!(verify_tree_proof::<TestBlake2Hasher, u32>(
&leaf_3,
&proof_for_3,
root,
3
));
let mut bad_proof = proof_for_1.clone();
bad_proof[0] = <$hasher_type>::empty();
bad_proof[0] = H256::random();
let is_valid_bad_proof =
verify_tree_proof::<$hasher_type, u32>(&leaf_1, &bad_proof, root, 1);
verify_tree_proof::<TestBlake2Hasher, u32>(&leaf_1, &bad_proof, root, 1);
assert!(!is_valid_bad_proof);
let bad_preimage = vec![99u8];
let is_valid_bad_preimage =
verify_tree_proof::<$hasher_type, u32>(&bad_preimage, &proof_for_1, root, 1);
verify_tree_proof::<TestBlake2Hasher, u32>(&bad_preimage, &proof_for_1, root, 1);
assert!(!is_valid_bad_preimage);
}
@ -617,17 +511,11 @@ mod tests {
raw_data.push((i, sp_std::vec![i as u8]));
}
let tree = generate_tree::<$hasher_type, u32, _, _, ()>(
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>(
max_index,
1,
raw_data,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
|(index, bytes)| Ok((index, bytes)),
)
.ok()
.unwrap();
let root = *tree.last().unwrap();
@ -637,55 +525,50 @@ mod tests {
let target_index = 11u32;
let preimage = vec![target_index as u8];
let proof = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, target_index)
.ok()
.unwrap();
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, target_index);
assert_eq!(proof.len(), 4);
let h10 = tree[10];
assert_eq!(proof[0], h10);
assert!(verify_tree_proof::<$hasher_type, u32>(&preimage, &proof, root, target_index));
assert!(!verify_tree_proof::<$hasher_type, u32>(&preimage, &proof, root, 4));
let is_valid =
verify_tree_proof::<TestBlake2Hasher, u32>(&preimage, &proof, root, target_index);
assert!(is_valid);
let is_valid_wrong_index =
verify_tree_proof::<TestBlake2Hasher, u32>(&preimage, &proof, root, 4);
assert!(!is_valid_wrong_index);
}
#[test]
fn test_verification_index_at_upper_bound() {
let max_index = 3u32;
let size_hint = 420;
let raw_data = sp_std::vec![
(0, sp_std::vec![1; size_hint]),
(1, sp_std::vec![2; size_hint]),
(2, sp_std::vec![3; size_hint]),
(3, sp_std::vec![4; size_hint]),
(0, sp_std::vec![1]),
(1, sp_std::vec![2]),
(2, sp_std::vec![3]),
(3, sp_std::vec![4]),
];
let tree = generate_tree::<$hasher_type, u32, _, _, ()>(
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>(
max_index,
size_hint,
raw_data,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
|(index, bytes)| Ok((index, bytes)),
)
.ok()
.unwrap();
let root = *tree.last().unwrap();
let target_index = 3u32;
let proof = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, target_index)
.ok()
.unwrap();
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, target_index);
assert_eq!(proof.len(), 2);
let preimage = sp_std::vec![4; size_hint];
assert!(verify_tree_proof::<$hasher_type, u32>(&preimage, &proof, root, target_index));
let preimage = sp_std::vec![4];
let is_valid =
verify_tree_proof::<TestBlake2Hasher, u32>(&preimage, &proof, root, target_index);
assert!(is_valid);
}
#[test]
@ -698,32 +581,23 @@ mod tests {
(3, sp_std::vec![4]),
];
let tree = generate_tree::<$hasher_type, u32, _, _, ()>(
let tree = generate_tree::<TestBlake2Hasher, u32, _, _, ()>(
max_index,
1,
raw_data,
|(index, bytes), buffer| {
buffer.extend_from_slice(&bytes);
Ok(index as usize)
}
|(index, bytes)| Ok((index, bytes)),
)
.ok()
.unwrap();
let root = *tree.last().unwrap();
let proof = generate_proof::<$hasher_type, u32, ()>(&tree, max_index, 3u32).ok().unwrap();
let proof = generate_proof::<TestBlake2Hasher, u32>(&tree, max_index, 3u32);
let target_index = 4u32;
let preimage = sp_std::vec![4];
assert!(!verify_tree_proof::<$hasher_type, u32>(&preimage, &proof, root, target_index));
}
}
}
}
let is_valid =
verify_tree_proof::<TestBlake2Hasher, u32>(&preimage, &proof, root, target_index);
run_merkle_tree_tests!(SubstrateBlake2Hasher, blake2_merkle_tree_tests);
run_merkle_tree_tests!(SubstrateKeccakHasher, keccak_merkle_tree_tests);
run_merkle_tree_tests!(UtxoSha2Hasher, sha2_merkle_tree_tests);
assert!(!is_valid);
}
}

2
pallets/traits/Cargo.toml
View File

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

17
pallets/traits/src/exodus.rs
View File

@ -6,14 +6,7 @@ use sp_std::{
vec::Vec,
};
pub trait CiphersuiteSizes<A, E> {
fn header_bytes_len(&self) -> usize;
fn element_bytes_len(&self) -> usize;
fn signature_bytes_len(&self) -> usize;
fn scalar_bytes_len(&self) -> usize;
}
pub trait IdentifierConverter<A, E>: CiphersuiteSizes<A, E> {
pub trait IdentifierConverter<A, E> {
fn non_zero_index(index: A) -> Result<A, E>;
fn convert_identifier_to_index(bytes: &[u8]) -> Result<A, E>;
}
@ -22,6 +15,11 @@ pub trait FlexibleRoundOptimizedSchnorrThresholdSignature<A, E>: MerkleTreeBuild
type Packages<'a>;
type NoncePackages<'a>;
fn header_bytes_len(&self) -> usize;
fn element_bytes_len(&self) -> usize;
fn signature_bytes_len(&self) -> usize;
fn scalar_bytes_len(&self) -> usize;
fn verify_signature_share(
&self,
i: A,
@ -93,14 +91,13 @@ pub trait MerkleTreeBuilder<A, E>: IdentifierConverter<A, E> {
type Hash;
fn build_merkle_tree<C, V, F>(
size_hint: usize,
verifying_shares: &BTreeMap<Identifier<C>, V>,
serialize_fn: F,
) -> Result<Vec<Self::Hash>, E>
where
C: frost_core::Ciphersuite,
<<C as Ciphersuite>::Group as Group>::Field: frost_core::Field,
F: Fn(&V, &mut Vec<u8>) -> Result<(), E>;
F: Fn(&V) -> Result<Vec<u8>, E>;
fn generate_merkle_proof_from_tree<C, V, F>(
verifying_shares: &BTreeMap<Identifier<C>, V>,

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

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