Add LightDAG and Patch interface

Author: sorpaas

src/dag.rs

@@ -0,0 +1,45 @@
+use bigint::{H256, H64, U256};
+use std::marker::PhantomData;
+
+pub trait Patch {
+    fn epoch_length() -> U256;
+}
+
+pub struct EthereumPatch;
+impl Patch for EthereumPatch {
+    fn epoch_length() -> U256 { U256::from(30000) }
+}
+
+pub struct LightDAG<P: Patch> {
+    epoch: usize,
+    cache: Vec<u8>,
+    cache_size: usize,
+    full_size: usize,
+    _marker: PhantomData<P>
+}
+
+impl<P: Patch> LightDAG<P> {
+    pub fn new(number: U256) -> Self {
+        let epoch = (number / P::epoch_length()).as_usize();
+        let cache_size = ::get_cache_size(epoch);
+        let full_size = ::get_full_size(epoch);
+        let seed = ::get_seedhash(epoch);
+
+        let mut cache: Vec<u8> = Vec::with_capacity(cache_size);
+        cache.resize(cache_size, 0);
+        ::make_cache(&mut cache, seed);
+
+        Self {
+            cache, cache_size, full_size, epoch,
+            _marker: PhantomData
+        }
+    }
+
+    pub fn hashimoto(&self, hash: H256, nonce: H64) -> (H256, H256) {
+        ::hashimoto_light(hash, nonce, self.full_size, &self.cache)
+    }
+
+    pub fn is_valid_for(&self, number: U256) -> bool {
+        (number / P::epoch_length()).as_usize() == self.epoch
+    }
+}

src/lib.rs

@@ -8,6 +8,9 @@ extern crate bigint;
 extern crate byteorder;
 
 mod miller_rabin;
+mod dag;
+
+pub use dag::{LightDAG, Patch, EthereumPatch};
 
 use miller_rabin::is_prime;
 use sha3::{Digest, Keccak256, Keccak512};

tests/headers.rs

@@ -19,17 +19,19 @@ use std::str::FromStr;
 fn header1() {
     let header: Header = rlp::decode(&read_hex("f901f3a00000000000000000000000000000000000000000000000000000000000000000a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347940000000000000000000000000000000000000000a09178d0f23c965d81f0834a4c72c6253ce6830f4022b1359aaebfc1ecba442d4ea056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302000080830f4240808080a058f759ede17a706c93f13030328bcea40c1d1341fb26f2facd21ceb0dae57017884242424242424242").unwrap());
 
-    assert_eq!(get_cache_size(header.number), 16776896);
-    assert_eq!(get_full_size(header.number), 1073739904);
+    let epoch = (header.number / U256::from(30000)).as_usize();
+
+    assert_eq!(get_cache_size(epoch), 16776896);
+    assert_eq!(get_full_size(epoch), 1073739904);
     assert_eq!(header.partial_hash(), H256::from_str("2a8de2adf89af77358250bf908bf04ba94a6e8c3ba87775564a41d269a05e4ce").unwrap());
 
-    let cache_size = get_cache_size(header.number);
-    let full_size = get_full_size(header.number);
+    let cache_size = get_cache_size(epoch);
+    let full_size = get_full_size(epoch);
 
     let mut cache: Vec<u8> = Vec::with_capacity(cache_size);
     cache.resize(cache_size, 0);
 
-    let seed = get_seedhash(header.number);
+    let seed = get_seedhash(epoch);
     assert_eq!(seed, H256::from_str("0000000000000000000000000000000000000000000000000000000000000000").unwrap());
 
     make_cache(&mut cache, seed);
@@ -48,17 +50,19 @@ fn header1() {
 fn header2() {
     let header: Header = rlp::decode(&read_hex("f901f7a01bef91439a3e070a6586851c11e6fd79bbbea074b2b836727b8e75c7d4a6b698a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d4934794ea3cb5f94fa2ddd52ec6dd6eb75cf824f4058ca1a00c6e51346be0670ce63ac5f05324e27d20b180146269c5aab844d09a2b108c64a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421b90100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008302004002832fefd880845511ed2a80a0e55d02c555a7969361cf74a9ec6211d8c14e4517930a00442f171bdb1698d17588307692cf71b12f6d").unwrap());
 
-    assert_eq!(get_cache_size(header.number), 16776896);
-    assert_eq!(get_full_size(header.number), 1073739904);
+    let epoch = (header.number / U256::from(30000)).as_usize();
+
+    assert_eq!(get_cache_size(epoch), 16776896);
+    assert_eq!(get_full_size(epoch), 1073739904);
     assert_eq!(header.partial_hash(), H256::from_str("100cbec5e5ef82991290d0d93d758f19082e71f234cf479192a8b94df6da6bfe").unwrap());
 
-    let cache_size = get_cache_size(header.number);
-    let full_size = get_full_size(header.number);
+    let cache_size = get_cache_size(epoch);
+    let full_size = get_full_size(epoch);
 
     let mut cache: Vec<u8> = Vec::with_capacity(cache_size);
     cache.resize(cache_size, 0);
 
-    let seed = get_seedhash(header.number);
+    let seed = get_seedhash(epoch);
     assert_eq!(seed, H256::from_str("0000000000000000000000000000000000000000000000000000000000000000").unwrap());
 
     make_cache(&mut cache, seed);