Examples / MerkleForge

01 / Tree

Build and verify

Insert leaves, generate a proof for one position, and verify it against the trusted root.

binary_tree.rsSHA-256

use merkle_core::{traits::MerkleTree, types::LeafIndex};
use merkle_variants::BinaryMerkleTree;
use merkleforge_hash::Sha256;

let mut tree = BinaryMerkleTree::<Sha256>::new();
tree.insert(b"alice")?;
tree.insert(b"bob")?;

let proof = tree.generate_proof(LeafIndex(0))?;
let root = tree.root().unwrap();
assert!(BinaryMerkleTree::<Sha256>::verify(
    root, b"alice", &proof
));

02 / Hashing

Swap algorithms

The tree API remains unchanged. Select a different adapter through the generic parameter.

hash_adapters.rsZero runtime dispatch

use merkle_variants::BinaryMerkleTree;
use merkleforge_hash::{Blake3, Keccak256, Sha256};

let sha_tree = BinaryMerkleTree::<Sha256>::new();
let eth_tree = BinaryMerkleTree::<Keccak256>::new();
let fast_tree = BinaryMerkleTree::<Blake3>::new();

03 / Hash API

Hash directly

Use the adapters independently when implementing another authenticated structure.

direct_hash.rsDomain separated

use merkle_core::traits::HashFunction;
use merkleforge_hash::Blake3;

let left = Blake3::hash(b"left leaf");
let right = Blake3::hash(b"right leaf");
let parent = Blake3::hash_nodes(&left, &right);

assert_eq!(Blake3::digest_size(), 32);
assert_eq!(Blake3::algorithm_name(), "BLAKE3");

04 / Metadata

Inspect tree state

Generic tooling can report tree size and implementation details without knowing the concrete hash type.

metadata.rsDiagnostics

use merkle_core::traits::MerkleTree;

let metadata = tree.metadata();
println!("variant: {}", metadata.variant);
println!("algorithm: {}", metadata.hash_algorithm);
println!("leaves: {}", metadata.leaf_count);
println!("height: {}", metadata.height);
println!("allocated nodes: {}", metadata.node_count);

05 / Serialization

Transport a proof

Serialize proof data for storage or transport using the shared Serializable trait.

proof_transport.rsbincode

use merkle_core::{
    traits::Serializable,
    types::MerkleProof,
};

let bytes = proof.to_bytes()?;
let recovered =
    MerkleProof::<[u8; 32]>::from_bytes(&bytes)?;

assert_eq!(proof, recovered);