merkleproof 0.1.0

A robust implementation of Merkle trees for data verification in distributed systems
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use merkleproof::MerkleTree;

fn main() {
    println!("=== Merkle Tree Demonstration ===\n");

    // Create a tree with transactions
    println!("Blockchain Transaction Merkle Tree Example");
    let transactions = vec![
        b"Alice sends 5 BTC to Bob".to_vec(),
        b"Bob sends 3 BTC to Charlie".to_vec(),
        b"David sends 2 BTC to Eve".to_vec(),
        b"Charlie sends 1 BTC to Alice".to_vec(),
        b"Eve sends 0.5 BTC to David".to_vec(),
    ];

    // Print the transactions
    println!("Transactions:");
    for (i, tx) in transactions.iter().enumerate() {
        println!("  {}. {}", i + 1, String::from_utf8_lossy(tx));
    }

    // Create the Merkle tree
    let tree = MerkleTree::new(transactions.clone());
    println!("\nMerkle Root: {}", tree.root_hash_hex());

    // Print the tree structure
    println!("\nTree Structure:");
    tree.print_tree();

    // Generate and verify a proof
    let tx_to_verify = b"Bob sends 3 BTC to Charlie".to_vec();
    println!(
        "\nVerifying transaction: '{}'",
        String::from_utf8_lossy(&tx_to_verify)
    );

    if let Some(proof) = tree.generate_proof(&tx_to_verify) {
        println!("Proof generated with {} elements", proof.len());

        // Show the proof details
        println!("Proof details:");
        for (i, (hash, is_left)) in proof.iter().enumerate() {
            println!(
                "  Step {}: Combine with {} ({})",
                i + 1,
                hex::encode(&hash[0..4]),
                if *is_left { "left" } else { "right" }
            );
        }

        // Verify the proof
        let root_hash = tree.root_hash().unwrap();
        let is_valid = MerkleTree::verify_proof(&tx_to_verify, &proof, &root_hash);
        println!(
            "\nProof verification result: {}",
            if is_valid { "VALID ✓" } else { "INVALID ✗" }
        );

        // Try an invalid transaction
        let invalid_tx = b"Eve sends 100 BTC to Alice".to_vec();
        println!(
            "\nAttempting to verify invalid transaction: '{}'",
            String::from_utf8_lossy(&invalid_tx)
        );
        let is_valid = MerkleTree::verify_proof(&invalid_tx, &proof, &root_hash);
        println!(
            "Invalid transaction verification result: {}",
            if is_valid {
                "VALID (PROBLEM!)"
            } else {
                "INVALID ✗ (Expected)"
            }
        );
    } else {
        println!("Failed to generate proof - transaction not found in tree");
    }
}