yevm-core 0.1.0

/// blake2f (precompile 0x09) - BLAKE2b F compression function (EIP-152)
/// Input: rounds (4 bytes) || h (64 bytes) || m (128 bytes) || t (16 bytes) || f (1 byte)
/// = 213 bytes total
/// Gas: rounds (the 4-byte big-endian uint)
#[allow(clippy::needless_range_loop)]
pub fn blake2f(input: &[u8], gas_limit: i64) -> (bool, Vec<u8>, i64) {
    if input.len() != 213 {
        return (false, vec![], gas_limit);
    }

    let f = input[212];
    if f != 0 && f != 1 {
        return (false, vec![], gas_limit);
    }

    let rounds = u32::from_be_bytes([input[0], input[1], input[2], input[3]]) as i64;
    if rounds > gas_limit {
        return (false, vec![], gas_limit);
    }

    // Parse h: 8 x u64 (little-endian)
    let mut h = [0u64; 8];
    for i in 0..8 {
        let offset = 4 + i * 8;
        h[i] = u64::from_le_bytes(input[offset..offset + 8].try_into().unwrap());
    }

    // Parse m: 16 x u64 (little-endian)
    let mut m = [0u64; 16];
    for i in 0..16 {
        let offset = 68 + i * 8;
        m[i] = u64::from_le_bytes(input[offset..offset + 8].try_into().unwrap());
    }

    // Parse t: 2 x u64 (little-endian)
    let t = [
        u64::from_le_bytes(input[196..204].try_into().unwrap()),
        u64::from_le_bytes(input[204..212].try_into().unwrap()),
    ];

    compress(&mut h, &m, &t, f != 0, rounds as u32);

    // Output: h as 64 bytes (little-endian)
    let mut out = vec![0u8; 64];
    for i in 0..8 {
        out[i * 8..(i + 1) * 8].copy_from_slice(&h[i].to_le_bytes());
    }
    (true, out, rounds)
}

// BLAKE2b IV
const IV: [u64; 8] = [
    0x6a09e667f3bcc908,
    0xbb67ae8584caa73b,
    0x3c6ef372fe94f82b,
    0xa54ff53a5f1d36f1,
    0x510e527fade682d1,
    0x9b05688c2b3e6c1f,
    0x1f83d9abfb41bd6b,
    0x5be0cd19137e2179,
];

// BLAKE2b sigma schedule
const SIGMA: [[usize; 16]; 10] = [
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
    [14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3],
    [11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4],
    [7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8],
    [9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13],
    [2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9],
    [12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11],
    [13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10],
    [6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5],
    [10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0],
];

fn compress(h: &mut [u64; 8], m: &[u64; 16], t: &[u64; 2], f: bool, rounds: u32) {
    let mut v = [0u64; 16];
    v[..8].copy_from_slice(h);
    v[8..].copy_from_slice(&IV);
    v[12] ^= t[0];
    v[13] ^= t[1];
    if f {
        v[14] = !v[14];
    }

    for i in 0..rounds as usize {
        let s = &SIGMA[i % 10];
        g(&mut v, 0, 4, 8, 12, m[s[0]], m[s[1]]);
        g(&mut v, 1, 5, 9, 13, m[s[2]], m[s[3]]);
        g(&mut v, 2, 6, 10, 14, m[s[4]], m[s[5]]);
        g(&mut v, 3, 7, 11, 15, m[s[6]], m[s[7]]);
        g(&mut v, 0, 5, 10, 15, m[s[8]], m[s[9]]);
        g(&mut v, 1, 6, 11, 12, m[s[10]], m[s[11]]);
        g(&mut v, 2, 7, 8, 13, m[s[12]], m[s[13]]);
        g(&mut v, 3, 4, 9, 14, m[s[14]], m[s[15]]);
    }

    for i in 0..8 {
        h[i] ^= v[i] ^ v[i + 8];
    }
}

#[inline(always)]
fn g(v: &mut [u64; 16], a: usize, b: usize, c: usize, d: usize, x: u64, y: u64) {
    v[a] = v[a].wrapping_add(v[b]).wrapping_add(x);
    v[d] = (v[d] ^ v[a]).rotate_right(32);
    v[c] = v[c].wrapping_add(v[d]);
    v[b] = (v[b] ^ v[c]).rotate_right(24);
    v[a] = v[a].wrapping_add(v[b]).wrapping_add(y);
    v[d] = (v[d] ^ v[a]).rotate_right(16);
    v[c] = v[c].wrapping_add(v[d]);
    v[b] = (v[b] ^ v[c]).rotate_right(63);
}