spacejam 0.1.2

Take your protein pills and put your helmet on.
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

// pow
use std::cmp::Ordering;
use std::ops::Shl;
use num_bigint::{BigInt, Sign};
use super::utils::hmac;

/// How to control the mining time?
#[derive(Debug, Clone)]
pub struct ProofOfWork {
    pub barrel: Vec<u8>,
    pub target: BigInt
}

impl ProofOfWork {
    /// TODO - !optimize
    pub fn new(barrel: Vec<u8>, bits: i32) -> Self {
        let target = BigInt::from(1).shl(256 as usize - bits as usize);
        ProofOfWork { barrel: barrel, target: target }
    }
    
    fn prepare_data(&mut self, nonce: usize) -> Vec<u8> {
        let mut data = Vec::new();

        data.append(&mut self.barrel);
        data.append(&mut nonce.to_string().into_bytes());
        data
    }

    pub fn run(&mut self) -> (usize, [u8; 32]) {
        let mut nonce: usize = 0;
        let mut hash_int: BigInt;
        let mut barrel_hash: [u8; 32] = hmac(self.clone().prepare_data(nonce));
        
        while (nonce as i32) < i32::max_value() {
            barrel_hash = hmac(self.clone().prepare_data(nonce));
            hash_int = BigInt::from_bytes_be(Sign::Plus, &barrel_hash);
            if hash_int.cmp(&self.target) == Ordering::Less {
                break;
            } else {
                nonce += 1;
            }
        }
        (nonce, barrel_hash)
    }
}

#[cfg(test)]
mod tests {
    use super::ProofOfWork;
    #[test]
    fn pow() {
        let mut pow = ProofOfWork::new([0_u8; 8].to_vec(), 10);
        let (nonce, hash) = pow.run();
        assert_ne!(nonce, 0);
        assert_eq!(hash.len(), 32);
    }
}