ics23 0.9.0

Merkle proof verification library - implements Cosmos ICS23 Spec
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

/// If this is to be executed in a blockchain context, then we need to delegate these hashing
/// functions to a native implementation through host function calls.
/// This trait provides that interface.
pub trait HostFunctionsProvider {
    /// The SHA-256 hash algorithm
    fn sha2_256(message: &[u8]) -> [u8; 32];

    /// The SHA-512 hash algorithm
    fn sha2_512(message: &[u8]) -> [u8; 64];

    /// The SHA-512 hash algorithm with its output truncated to 256 bits.
    fn sha2_512_truncated(message: &[u8]) -> [u8; 32];

    /// SHA-3-512 hash function.
    fn sha3_512(message: &[u8]) -> [u8; 64];

    /// Ripemd160 hash function.
    fn ripemd160(message: &[u8]) -> [u8; 20];
}

#[cfg(any(feature = "host-functions", test))]
pub mod host_functions_impl {
    use crate::host_functions::HostFunctionsProvider;
    use ripemd::Ripemd160;
    use sha2::{Digest, Sha256, Sha512, Sha512_256};
    use sha3::Sha3_512;

    pub struct HostFunctionsManager;
    impl HostFunctionsProvider for HostFunctionsManager {
        fn sha2_256(message: &[u8]) -> [u8; 32] {
            let digest = Sha256::digest(message);
            let mut buf = [0u8; 32];
            buf.copy_from_slice(&digest);
            buf
        }

        fn sha2_512(message: &[u8]) -> [u8; 64] {
            let digest = Sha512::digest(message);
            let mut buf = [0u8; 64];
            buf.copy_from_slice(&digest);
            buf
        }

        fn sha2_512_truncated(message: &[u8]) -> [u8; 32] {
            let digest = Sha512_256::digest(message);
            let mut buf = [0u8; 32];
            buf.copy_from_slice(&digest);
            buf
        }

        fn sha3_512(message: &[u8]) -> [u8; 64] {
            let digest = Sha3_512::digest(message);
            let mut buf = [0u8; 64];
            buf.copy_from_slice(&digest);
            buf
        }

        fn ripemd160(message: &[u8]) -> [u8; 20] {
            let digest = Ripemd160::digest(message);
            let mut buf = [0u8; 20];
            buf.copy_from_slice(&digest);
            buf
        }
    }
}