mirror of
https://github.com/mimblewimble/grin.git
synced 2025-04-25 11:51:14 +03:00
PoW only ever needs the block header, full block unnecessary.
This commit is contained in:
Ignotus Peverell
parent
dde54beb3f
commit
45b134ab30
2 changed files with 20 additions and 464 deletions
core/src/pow
|
|
@ -1,444 +0,0 @@
|
|||
//! Implementation of Cuckoo Cycle designed by John Tromp. Ported to Rust from
|
||||
//! the C and Java code at https://github.com/tromp/cuckoo. Note that only the
|
||||
//! simple miner is included, mostly for testing purposes. John Tromp's Tomato
|
||||
//! miner will be much faster in almost every environment.
|
||||
|
||||
use std::collections::HashSet;
|
||||
use std::cmp;
|
||||
use std::fmt;
|
||||
|
||||
use crypto::digest::Digest;
|
||||
use crypto::sha2::Sha256;
|
||||
|
||||
use pow::siphash::siphash24;
|
||||
|
||||
const PROOFSIZE: usize = 42;
|
||||
const MAXPATHLEN: usize = 8192;
|
||||
|
||||
/// A Cuckoo proof representing the nonces for a cycle of the right size.
|
||||
pub struct Proof([u32; PROOFSIZE]);
|
||||
|
||||
impl fmt::Debug for Proof {
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
try!(write!(f, "Cuckoo("));
|
||||
for (i, val) in self.0[..].iter().enumerate() {
|
||||
try!(write!(f, "{:x}", val));
|
||||
if i < PROOFSIZE - 1 {
|
||||
write!(f, " ");
|
||||
}
|
||||
}
|
||||
write!(f, ")")
|
||||
}
|
||||
}
|
||||
impl PartialEq for Proof {
|
||||
fn eq(&self, other: &Proof) -> bool {
|
||||
self.0[..] == other.0[..]
|
||||
}
|
||||
}
|
||||
impl Eq for Proof {}
|
||||
impl Clone for Proof {
|
||||
#[inline]
|
||||
fn clone(&self) -> Proof {
|
||||
let mut cp = [0; PROOFSIZE];
|
||||
for (i, n) in self.0.iter().enumerate() {
|
||||
cp[i] = *n;
|
||||
}
|
||||
Proof(cp)
|
||||
}
|
||||
}
|
||||
|
||||
impl Proof {
|
||||
fn to_u64s(&self) -> Vec<u64> {
|
||||
let mut nonces = Vec::with_capacity(PROOFSIZE);
|
||||
for n in self.0.iter() {
|
||||
nonces.push(*n as u64);
|
||||
}
|
||||
nonces
|
||||
}
|
||||
}
|
||||
|
||||
/// An edge in the Cuckoo graph, simply references two u64 nodes.
|
||||
#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
|
||||
struct Edge {
|
||||
u: u64,
|
||||
v: u64,
|
||||
}
|
||||
|
||||
pub struct Cuckoo {
|
||||
mask: u64,
|
||||
size: u64,
|
||||
v: [u64; 4],
|
||||
}
|
||||
|
||||
impl Cuckoo {
|
||||
/// Initializes a new Cuckoo Cycle setup, using the provided byte array to
|
||||
/// generate a seed. In practice for PoW applications the byte array is a
|
||||
/// serialized block header.
|
||||
pub fn new(header: &[u8], sizeshift: u32) -> Cuckoo {
|
||||
let size = 1 << sizeshift;
|
||||
let mut hasher = Sha256::new();
|
||||
let mut hashed = [0; 32];
|
||||
hasher.input(header);
|
||||
hasher.result(&mut hashed);
|
||||
|
||||
let k0 = u8_to_u64(hashed, 0);
|
||||
let k1 = u8_to_u64(hashed, 8);
|
||||
let mut v = [0; 4];
|
||||
v[0] = k0 ^ 0x736f6d6570736575;
|
||||
v[1] = k1 ^ 0x646f72616e646f6d;
|
||||
v[2] = k0 ^ 0x6c7967656e657261;
|
||||
v[3] = k1 ^ 0x7465646279746573;
|
||||
// println!("{:?} {:?} {:?} {:?}", v[0], v[1], v[2], v[3]);
|
||||
Cuckoo {
|
||||
v: v,
|
||||
size: size,
|
||||
mask: (1 << sizeshift) / 2 - 1,
|
||||
}
|
||||
}
|
||||
|
||||
/// Generates a node in the cuckoo graph generated from our seed. A node is
|
||||
/// simply materialized as a u64 from a nonce and an offset (generally 0 or
|
||||
/// 1).
|
||||
pub fn new_node(&self, nonce: u64, uorv: u64) -> u64 {
|
||||
return ((siphash24(self.v, 2 * nonce + uorv) & self.mask) << 1) | uorv;
|
||||
}
|
||||
|
||||
/// Creates a new edge in the cuckoo graph generated by our seed from a
|
||||
/// nonce. Generates two node coordinates from the nonce and links them
|
||||
/// together.
|
||||
pub fn new_edge(&self, nonce: u64) -> Edge {
|
||||
Edge {
|
||||
u: self.new_node(nonce, 0),
|
||||
v: self.new_node(nonce, 1),
|
||||
}
|
||||
}
|
||||
|
||||
/// Assuming increasing nonces all smaller than easiness, verifies the
|
||||
/// nonces form a cycle in a Cuckoo graph. Each nonce generates an edge, we
|
||||
/// build the nodes on both side of that edge and count the connections.
|
||||
pub fn verify(&self, proof: Proof, ease: u64) -> bool {
|
||||
let easiness = ease * (self.size as u64) / 100;
|
||||
let nonces = proof.to_u64s();
|
||||
let mut us = [0; PROOFSIZE];
|
||||
let mut vs = [0; PROOFSIZE];
|
||||
for n in 0..PROOFSIZE {
|
||||
if nonces[n] >= easiness || (n != 0 && nonces[n] <= nonces[n - 1]) {
|
||||
return false;
|
||||
}
|
||||
us[n] = self.new_node(nonces[n], 0);
|
||||
vs[n] = self.new_node(nonces[n], 1);
|
||||
}
|
||||
let mut i = 0;
|
||||
let mut count = PROOFSIZE;
|
||||
loop {
|
||||
let mut j = i;
|
||||
for k in 0..PROOFSIZE {
|
||||
// find unique other j with same vs[j]
|
||||
if k != i && vs[k] == vs[i] {
|
||||
if j != i {
|
||||
return false;
|
||||
}
|
||||
j = k;
|
||||
}
|
||||
}
|
||||
if j == i {
|
||||
return false;
|
||||
}
|
||||
i = j;
|
||||
for k in 0..PROOFSIZE {
|
||||
// find unique other i with same us[i]
|
||||
if k != j && us[k] == us[j] {
|
||||
if i != j {
|
||||
return false;
|
||||
}
|
||||
i = k;
|
||||
}
|
||||
}
|
||||
if i == j {
|
||||
return false;
|
||||
}
|
||||
count -= 2;
|
||||
if i == 0 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
count == 0
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum Error {
|
||||
PathError,
|
||||
NoSolutionError,
|
||||
}
|
||||
|
||||
/// Miner for the Cuckoo Cycle algorithm. While the verifier will work for
|
||||
/// graph sizes up to a u64, the miner is limited to u32 to be more memory
|
||||
/// compact (so shift <= 32). Non-optimized for now and and so mostly used for
|
||||
/// tests, being impractical with sizes greater than 2^22.
|
||||
pub struct Miner {
|
||||
easiness: u64,
|
||||
size: usize,
|
||||
cuckoo: Cuckoo,
|
||||
graph: Vec<u32>,
|
||||
}
|
||||
|
||||
/// What type of cycle we have found?
|
||||
enum CycleSol {
|
||||
/// A cycle of the right length is a valid proof.
|
||||
ValidProof([u32; PROOFSIZE]),
|
||||
/// A cycle of the wrong length is great, but not a proof.
|
||||
InvalidCycle(usize),
|
||||
/// No cycles have been found.
|
||||
NoCycle,
|
||||
}
|
||||
|
||||
impl Miner {
|
||||
pub fn new(header: &[u8], ease: u64, sizeshift: u32) -> Miner {
|
||||
let cuckoo = Cuckoo::new(header, sizeshift);
|
||||
let size = 1 << sizeshift;
|
||||
let graph = vec![0; size + 1];
|
||||
let easiness = ease * (size as u64) / 100;
|
||||
Miner {
|
||||
easiness: easiness,
|
||||
size: size,
|
||||
cuckoo: cuckoo,
|
||||
graph: graph,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn mine(&mut self) -> Result<Proof, Error> {
|
||||
let mut us = [0; MAXPATHLEN];
|
||||
let mut vs = [0; MAXPATHLEN];
|
||||
// println!("{}", self.easiness);
|
||||
let mut m = 0;
|
||||
for nonce in 0..self.easiness {
|
||||
m += 1;
|
||||
// println!("- {}", nonce);
|
||||
us[0] = self.cuckoo.new_node(nonce, 0) as u32;
|
||||
vs[0] = self.cuckoo.new_node(nonce, 1) as u32;
|
||||
let u = self.graph[us[0] as usize];
|
||||
let v = self.graph[vs[0] as usize];
|
||||
if us[0] == 0 {
|
||||
continue; // ignore duplicate edges
|
||||
}
|
||||
// println!("{}, {}, {}, {}", us[0], vs[0], u, v);
|
||||
// println!(" ^{}, {}", us[0], vs[0]);
|
||||
// println!(" _{}, {}", u, v);
|
||||
let nu = try!(if nonce == 481921 {
|
||||
self.path_p(u, &mut us)
|
||||
} else {
|
||||
self.path(u, &mut us)
|
||||
}) as usize;
|
||||
let nv = try!(if nonce == 481921 {
|
||||
self.path_p(v, &mut vs)
|
||||
} else {
|
||||
self.path(v, &mut vs)
|
||||
}) as usize;
|
||||
// println!(" &{}, {}", nu, nv);
|
||||
|
||||
let sol = self.find_sol(nu, &us, nv, &vs);
|
||||
match sol {
|
||||
CycleSol::ValidProof(res) => return Ok(Proof(res)),
|
||||
CycleSol::InvalidCycle(_) => continue,
|
||||
CycleSol::NoCycle => {
|
||||
self.update_graph(nu, &us, nv, &vs);
|
||||
}
|
||||
}
|
||||
}
|
||||
// println!("== {}", m);
|
||||
Err(Error::NoSolutionError)
|
||||
}
|
||||
|
||||
fn path(&self, mut u: u32, us: &mut [u32]) -> Result<u32, Error> {
|
||||
let mut nu = 0;
|
||||
while u != 0 {
|
||||
nu += 1;
|
||||
if nu >= MAXPATHLEN {
|
||||
while nu != 0 && us[(nu - 1) as usize] != u {
|
||||
nu -= 1;
|
||||
}
|
||||
return Err(Error::PathError);
|
||||
}
|
||||
us[nu as usize] = u;
|
||||
u = self.graph[u as usize];
|
||||
}
|
||||
Ok(nu as u32)
|
||||
}
|
||||
|
||||
fn path_p(&self, mut u: u32, us: &mut [u32]) -> Result<u32, Error> {
|
||||
let mut nu = 0;
|
||||
while u != 0 {
|
||||
// println!("{}", u);
|
||||
nu += 1;
|
||||
if nu >= MAXPATHLEN {
|
||||
while nu != 0 && us[(nu - 1) as usize] != u {
|
||||
nu -= 1;
|
||||
}
|
||||
return Err(Error::PathError);
|
||||
}
|
||||
us[nu as usize] = u;
|
||||
u = self.graph[u as usize];
|
||||
}
|
||||
Ok(nu as u32)
|
||||
}
|
||||
|
||||
fn update_graph(&mut self, mut nu: usize, us: &[u32], mut nv: usize, vs: &[u32]) {
|
||||
if nu < nv {
|
||||
while nu != 0 {
|
||||
nu -= 1;
|
||||
// self.graph[us[nu + 1] as usize] = us[nu];
|
||||
self.set_graph(us[nu + 1] as usize, us[nu]);
|
||||
}
|
||||
// self.graph[us[0] as usize] = vs[0];
|
||||
self.set_graph(us[0] as usize, vs[0]);
|
||||
} else {
|
||||
while nv != 0 {
|
||||
nv -= 1;
|
||||
// self.graph[vs[nv + 1] as usize] = vs[nv];
|
||||
self.set_graph(vs[nv + 1] as usize, vs[nv]);
|
||||
}
|
||||
// self.graph[vs[0] as usize] = us[0];
|
||||
self.set_graph(vs[0] as usize, us[0]);
|
||||
}
|
||||
}
|
||||
|
||||
fn set_graph(&mut self, idx: usize, val: u32) {
|
||||
// println!("set {} = {}", idx, val);
|
||||
self.graph[idx] = val;
|
||||
}
|
||||
|
||||
fn find_sol(&self, mut nu: usize, us: &[u32], mut nv: usize, vs: &[u32]) -> CycleSol {
|
||||
if us[nu] == vs[nv] {
|
||||
let min = cmp::min(nu, nv);
|
||||
nu -= min;
|
||||
nv -= min;
|
||||
while us[nu] != vs[nv] {
|
||||
nu += 1;
|
||||
nv += 1;
|
||||
}
|
||||
if nu + nv + 1 == PROOFSIZE {
|
||||
self.solution(&us, nu as u32, &vs, nv as u32)
|
||||
} else {
|
||||
CycleSol::InvalidCycle(nu + nv + 1)
|
||||
}
|
||||
} else {
|
||||
CycleSol::NoCycle
|
||||
}
|
||||
}
|
||||
|
||||
fn solution(&self, us: &[u32], mut nu: u32, vs: &[u32], mut nv: u32) -> CycleSol {
|
||||
let mut cycle = HashSet::new();
|
||||
cycle.insert(Edge {
|
||||
u: us[0] as u64,
|
||||
v: vs[0] as u64,
|
||||
});
|
||||
while nu != 0 {
|
||||
// u's in even position; v's in odd
|
||||
nu -= 1;
|
||||
cycle.insert(Edge {
|
||||
u: us[((nu + 1) & !1) as usize] as u64,
|
||||
v: us[(nu | 1) as usize] as u64,
|
||||
});
|
||||
}
|
||||
while nv != 0 {
|
||||
// u's in odd position; v's in even
|
||||
nv -= 1;
|
||||
cycle.insert(Edge {
|
||||
u: vs[(nv | 1) as usize] as u64,
|
||||
v: vs[((nv + 1) & !1) as usize] as u64,
|
||||
});
|
||||
}
|
||||
let mut n = 0;
|
||||
let mut sol = [0; PROOFSIZE];
|
||||
for nonce in 0..self.easiness {
|
||||
let edge = self.cuckoo.new_edge(nonce);
|
||||
if cycle.contains(&edge) {
|
||||
sol[n] = nonce as u32;
|
||||
n += 1;
|
||||
cycle.remove(&edge);
|
||||
}
|
||||
}
|
||||
return if n == PROOFSIZE {
|
||||
CycleSol::ValidProof(sol)
|
||||
} else {
|
||||
CycleSol::NoCycle
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// Utility to transform a 8 bytes of a byte array into a u64.
|
||||
fn u8_to_u64(p: [u8; 32], i: usize) -> u64 {
|
||||
(p[i] as u64) | (p[i + 1] as u64) << 8 | (p[i + 2] as u64) << 16 | (p[i + 3] as u64) << 24 |
|
||||
(p[i + 4] as u64) << 32 | (p[i + 5] as u64) << 40 |
|
||||
(p[i + 6] as u64) << 48 | (p[i + 7] as u64) << 56
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod test {
|
||||
use super::*;
|
||||
|
||||
static V1: Proof = Proof([0xe13, 0x410c, 0x7974, 0x8317, 0xb016, 0xb992, 0xe3c8, 0x1038a,
|
||||
0x116f0, 0x15ed2, 0x165a2, 0x17793, 0x17dd1, 0x1f885, 0x20932,
|
||||
0x20936, 0x2171b, 0x28968, 0x2b184, 0x30b8e, 0x31d28, 0x35782,
|
||||
0x381ea, 0x38321, 0x3b414, 0x3e14b, 0x43615, 0x49a51, 0x4a319,
|
||||
0x58271, 0x5dbb9, 0x5dbcf, 0x62db4, 0x653d2, 0x655f6, 0x66382,
|
||||
0x7057d, 0x765b0, 0x79c7c, 0x83167, 0x86e7b, 0x8a5f4]);
|
||||
static V2: Proof = Proof([0x33b8, 0x3fd9, 0x8f2b, 0xba0d, 0x11e2d, 0x1d51d, 0x2786e, 0x29625,
|
||||
0x2a862, 0x2a972, 0x2e6d7, 0x319df, 0x37ce7, 0x3f771, 0x4373b,
|
||||
0x439b7, 0x48626, 0x49c7d, 0x4a6f1, 0x4a808, 0x4e518, 0x519e3,
|
||||
0x526bb, 0x54988, 0x564e9, 0x58a6c, 0x5a4dd, 0x63fa2, 0x68ad1,
|
||||
0x69e52, 0x6bf53, 0x70841, 0x76343, 0x763a4, 0x79681, 0x7d006,
|
||||
0x7d633, 0x7eebe, 0x7fe7c, 0x811fa, 0x863c1, 0x8b149]);
|
||||
static V3: Proof = Proof([0x24ae, 0x5180, 0x9f3d, 0xd379, 0x102c9, 0x15787, 0x16df4, 0x19509,
|
||||
0x19a78, 0x235a0, 0x24210, 0x24410, 0x2567f, 0x282c3, 0x2d986,
|
||||
0x2efde, 0x319d7, 0x334d7, 0x336dd, 0x34296, 0x35809, 0x3ad40,
|
||||
0x46d81, 0x48c92, 0x4b374, 0x4c353, 0x4fe4c, 0x50e4f, 0x53202,
|
||||
0x5d167, 0x6527c, 0x6a8b5, 0x6c70d, 0x76d90, 0x794f4, 0x7c411,
|
||||
0x7c5d4, 0x7f59f, 0x7fead, 0x872d8, 0x875b4, 0x95c6b]);
|
||||
|
||||
/// Find a 42-cycle on Cuckoo20 at 75% easiness and verifiy against a few
|
||||
/// known cycle proofs
|
||||
/// generated by other implementations.
|
||||
#[test]
|
||||
fn mine20_vectors() {
|
||||
let nonces1 = Miner::new(&[49], 75, 20).mine().unwrap();
|
||||
assert_eq!(V1, nonces1);
|
||||
|
||||
let nonces2 = Miner::new(&[50], 70, 20).mine().unwrap();
|
||||
assert_eq!(V2, nonces2);
|
||||
|
||||
let nonces3 = Miner::new(&[51], 70, 20).mine().unwrap();
|
||||
assert_eq!(V3, nonces3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn validate20_vectors() {
|
||||
assert!(Cuckoo::new(&[49], 20).verify(V1.clone(), 75));
|
||||
assert!(Cuckoo::new(&[50], 20).verify(V2.clone(), 70));
|
||||
assert!(Cuckoo::new(&[51], 20).verify(V3.clone(), 70));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn validate_fail() {
|
||||
assert!(!Cuckoo::new(&[49], 20).verify(Proof([0; 42]), 75));
|
||||
assert!(!Cuckoo::new(&[50], 20).verify(V1.clone(), 75));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mine20_validate() {
|
||||
// cuckoo20
|
||||
for n in 1..5 {
|
||||
let h = [n; 32];
|
||||
let nonces = Miner::new(&h, 75, 20).mine().unwrap();
|
||||
assert!(Cuckoo::new(&h, 20).verify(nonces, 75));
|
||||
}
|
||||
// cuckoo18
|
||||
for n in 1..5 {
|
||||
let h = [n; 32];
|
||||
let nonces = Miner::new(&h, 75, 18).mine().unwrap();
|
||||
assert!(Cuckoo::new(&h, 18).verify(nonces, 75));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -28,7 +28,7 @@ pub mod cuckoo;
|
|||
use time;
|
||||
|
||||
use consensus::EASINESS;
|
||||
use core::{Block, Proof};
|
||||
use core::{BlockHeader, Proof};
|
||||
use core::hash::{Hash, Hashed};
|
||||
use core::target::Difficulty;
|
||||
use pow::cuckoo::{Cuckoo, Miner, Error};
|
||||
|
|
@ -37,58 +37,58 @@ use ser;
|
|||
use ser::{Writeable, Writer};
|
||||
|
||||
/// Validates the proof of work of a given header.
|
||||
pub fn verify(b: &Block) -> bool {
|
||||
verify_size(b, b.header.cuckoo_len as u32)
|
||||
pub fn verify(bh: &BlockHeader) -> bool {
|
||||
verify_size(bh, bh.cuckoo_len as u32)
|
||||
}
|
||||
|
||||
pub fn verify_size(b: &Block, cuckoo_sz: u32) -> bool {
|
||||
pub fn verify_size(bh: &BlockHeader, cuckoo_sz: u32) -> bool {
|
||||
// make sure the pow hash shows a difficulty at least as large as the target
|
||||
// difficulty
|
||||
if b.header.difficulty > b.header.pow.to_difficulty() {
|
||||
if bh.difficulty > bh.pow.to_difficulty() {
|
||||
return false;
|
||||
}
|
||||
Cuckoo::new(b.hash().to_slice(), cuckoo_sz).verify(b.header.pow, EASINESS as u64)
|
||||
Cuckoo::new(bh.hash().to_slice(), cuckoo_sz).verify(bh.pow, EASINESS as u64)
|
||||
}
|
||||
|
||||
/// Runs a naive single-threaded proof of work computation over the provided
|
||||
/// block, until the required difficulty target is reached. May take a
|
||||
/// while for a low target...
|
||||
pub fn pow(b: &mut Block, diff: Difficulty) -> Result<(), Error> {
|
||||
let cuckoo_len = b.header.cuckoo_len as u32;
|
||||
pow_size(b, diff, cuckoo_len)
|
||||
pub fn pow(bh: &mut BlockHeader, diff: Difficulty) -> Result<(), Error> {
|
||||
let cuckoo_len = bh.cuckoo_len as u32;
|
||||
pow_size(bh, diff, cuckoo_len)
|
||||
}
|
||||
|
||||
/// Same as default pow function but uses the much easier Cuckoo20 (mostly for
|
||||
/// tests).
|
||||
pub fn pow20(b: &mut Block, diff: Difficulty) -> Result<(), Error> {
|
||||
pow_size(b, diff, 20)
|
||||
pub fn pow20(bh: &mut BlockHeader, diff: Difficulty) -> Result<(), Error> {
|
||||
pow_size(bh, diff, 20)
|
||||
}
|
||||
|
||||
pub fn pow_size(b: &mut Block, diff: Difficulty, sizeshift: u32) -> Result<(), Error> {
|
||||
let start_nonce = b.header.nonce;
|
||||
pub fn pow_size(bh: &mut BlockHeader, diff: Difficulty, sizeshift: u32) -> Result<(), Error> {
|
||||
let start_nonce = bh.nonce;
|
||||
|
||||
// try to find a cuckoo cycle on that header hash
|
||||
loop {
|
||||
// can be trivially optimized by avoiding re-serialization every time but this
|
||||
// is not meant as a fast miner implementation
|
||||
let pow_hash = b.hash();
|
||||
let pow_hash = bh.hash();
|
||||
|
||||
// if we found a cycle (not guaranteed) and the proof hash is higher that the
|
||||
// diff, we're all good
|
||||
if let Ok(proof) = Miner::new(pow_hash.to_slice(), EASINESS, sizeshift).mine() {
|
||||
if proof.to_difficulty() >= diff {
|
||||
b.header.pow = proof;
|
||||
bh.pow = proof;
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
|
||||
// otherwise increment the nonce
|
||||
b.header.nonce += 1;
|
||||
bh.nonce += 1;
|
||||
|
||||
// and if we're back where we started, update the time (changes the hash as
|
||||
// well)
|
||||
if b.header.nonce == start_nonce {
|
||||
b.header.timestamp = time::at_utc(time::Timespec { sec: 0, nsec: 0 });
|
||||
if bh.nonce == start_nonce {
|
||||
bh.timestamp = time::at_utc(time::Timespec { sec: 0, nsec: 0 });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -104,9 +104,9 @@ mod test {
|
|||
fn genesis_pow() {
|
||||
let mut b = genesis::genesis();
|
||||
b.header.nonce = 310;
|
||||
pow20(&mut b, Difficulty::one()).unwrap();
|
||||
pow20(&mut b.header, Difficulty::one()).unwrap();
|
||||
assert!(b.header.nonce != 310);
|
||||
assert!(b.header.pow.to_difficulty() >= Difficulty::one());
|
||||
assert!(verify_size(&b, 20));
|
||||
assert!(verify_size(&b.header, 20));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue