casper-executor-wasm-common 0.1.3

Casper executor common package
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

use blake2::{digest::consts::U32, Blake2b, Digest};

/// Compute a predictable address for a contract.
///
/// The address is computed as the hash of the chain name, initiator account, and the hash of the
/// Wasm code.
pub fn compute_predictable_address<T: AsRef<[u8]>>(
    chain_name: T,
    initiator_address: [u8; 32],
    bytecode_hash: [u8; 32],
    seed: Option<[u8; 32]>,
) -> [u8; 32] {
    let mut hasher = Blake2b::<U32>::new();

    hasher.update(chain_name);
    hasher.update(initiator_address);
    hasher.update(bytecode_hash);

    if let Some(seed) = seed {
        hasher.update(seed);
    }

    hasher.finalize().into()
}

pub fn compute_wasm_bytecode_hash<T: AsRef<[u8]>>(wasm_bytes: T) -> [u8; 32] {
    let mut hasher = Blake2b::<U32>::new();
    hasher.update(wasm_bytes);
    let hash = hasher.finalize();
    hash.into()
}

#[cfg(test)]
mod tests {
    const SEED: [u8; 32] = [1u8; 32];

    #[test]
    fn test_compute_predictable_address() {
        let initiator = [1u8; 32];
        let bytecode_hash = [2u8; 32];

        let predictable_address_1 =
            super::compute_predictable_address("testnet", initiator, bytecode_hash, Some(SEED));
        let predictable_address_2 =
            super::compute_predictable_address("mainnet", initiator, bytecode_hash, Some(SEED));
        assert_ne!(predictable_address_1, predictable_address_2);
    }
}