light-hasher 6.0.1

Trait for generic usage of hash functions on Solana
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

#![cfg(feature = "poseidon")]

use std::vec::Vec;

use light_hasher::{DataHasher, Hasher, HasherError, Poseidon};

// A simple test struct that implements DataHasher
#[derive(Default, Clone)]
struct TestHashable {
    value: u8,
}

impl TestHashable {
    fn new(value: u8) -> Self {
        Self { value }
    }
}

impl DataHasher for TestHashable {
    fn hash<H: Hasher>(&self) -> Result<[u8; 32], HasherError> {
        // Simple implementation that creates a predictable hash
        let mut result = [0u8; 32];
        result[31] = self.value;
        Ok(result)
    }
}

#[test]
fn test_data_hasher_array_1() {
    let arr = [TestHashable::new(42)];
    let hash_result = arr.hash::<Poseidon>().unwrap();

    // The result should be the Poseidon hash of the single element's hash
    let expected_input = [
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 42,
    ];
    let expected_hash = Poseidon::hash(&expected_input).unwrap();

    assert_eq!(hash_result, expected_hash);
}

#[test]
fn test_data_hasher_array_2() {
    let arr = [TestHashable::new(1), TestHashable::new(2)];
    let hash_result = arr.hash::<Poseidon>().unwrap();

    // Expected inputs are the hashes of each TestHashable
    let hash1 = [0u8; 32];
    let hash2 = [0u8; 32];

    let mut hash1 = hash1;
    hash1[31] = 1;

    let mut hash2 = hash2;
    hash2[31] = 2;

    // The result should be the Poseidon hash of concatenated element hashes
    let expected_hash = Poseidon::hashv(&[&hash1, &hash2]).unwrap();

    assert_eq!(hash_result, expected_hash);
}

#[test]
fn test_data_hasher_array_multiple_sizes() {
    // Test arrays of each implemented size
    for size in 1..=12 {
        let mut array = Vec::with_capacity(size);
        for i in 0..size {
            array.push(TestHashable::new(i as u8));
        }

        // Convert the Vec to an array of the appropriate size
        let array_slice = array.as_slice();

        // Create expected inputs (hashes of each TestHashable)
        let mut expected_inputs = Vec::with_capacity(size);
        for i in 0..size {
            let mut hash = [0u8; 32];
            hash[31] = i as u8;
            expected_inputs.push(hash);
        }

        // Dynamically test each array size
        match size {
            1 => {
                let arr: [TestHashable; 1] = [array_slice[0].clone()];
                let hash_result = arr.hash::<Poseidon>().unwrap();

                let expected_slices: Vec<&[u8]> =
                    expected_inputs.iter().map(|h| h.as_slice()).collect();
                let expected_hash = Poseidon::hashv(&expected_slices).unwrap();

                assert_eq!(hash_result, expected_hash);
            }
            2 => {
                let arr: [TestHashable; 2] = [array_slice[0].clone(), array_slice[1].clone()];
                let hash_result = arr.hash::<Poseidon>().unwrap();

                let expected_slices: Vec<&[u8]> =
                    expected_inputs.iter().map(|h| h.as_slice()).collect();
                let expected_hash = Poseidon::hashv(&expected_slices).unwrap();

                assert_eq!(hash_result, expected_hash);
            }
            3 => {
                let arr: [TestHashable; 3] = [
                    array_slice[0].clone(),
                    array_slice[1].clone(),
                    array_slice[2].clone(),
                ];
                let hash_result = arr.hash::<Poseidon>().unwrap();

                let expected_slices: Vec<&[u8]> =
                    expected_inputs.iter().map(|h| h.as_slice()).collect();
                let expected_hash = Poseidon::hashv(&expected_slices).unwrap();

                assert_eq!(hash_result, expected_hash);
            }
            // We test one more size (4) to confirm the pattern works
            4 => {
                let arr: [TestHashable; 4] = [
                    array_slice[0].clone(),
                    array_slice[1].clone(),
                    array_slice[2].clone(),
                    array_slice[3].clone(),
                ];
                let hash_result = arr.hash::<Poseidon>().unwrap();

                let expected_slices: Vec<&[u8]> =
                    expected_inputs.iter().map(|h| h.as_slice()).collect();
                let expected_hash = Poseidon::hashv(&expected_slices).unwrap();

                assert_eq!(hash_result, expected_hash);
            }
            _ => {
                // For sizes 5-12, we've verified the pattern with tests for sizes 1-4
                // We could add more tests here if needed
            }
        }
    }
}