2016-08-16 09:00:26 -07:00
|
|
|
use std::fmt;
|
2016-09-18 09:12:45 -07:00
|
|
|
use ser::{
|
|
|
|
Deserializable, Reader, Error as ReaderError,
|
|
|
|
Serializable, Stream
|
|
|
|
};
|
2016-09-19 05:37:53 -07:00
|
|
|
use hash::H256;
|
2016-08-15 05:50:20 -07:00
|
|
|
|
2016-09-19 05:37:53 -07:00
|
|
|
#[derive(PartialEq)]
|
2016-08-15 05:50:20 -07:00
|
|
|
pub struct BlockHeader {
|
2016-10-21 06:08:46 -07:00
|
|
|
pub version: u32,
|
|
|
|
pub previous_header_hash: H256,
|
|
|
|
pub merkle_root_hash: H256,
|
|
|
|
pub time: u32,
|
|
|
|
pub nbits: u32,
|
|
|
|
pub nonce: u32,
|
2016-08-15 05:50:20 -07:00
|
|
|
}
|
|
|
|
|
2016-09-19 05:37:53 -07:00
|
|
|
impl fmt::Debug for BlockHeader {
|
2016-08-16 09:00:26 -07:00
|
|
|
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
2016-09-19 05:37:53 -07:00
|
|
|
f.debug_struct("BlockHeader")
|
|
|
|
.field("version", &self.version)
|
|
|
|
.field("previous_header_hash", &self.previous_header_hash.reversed())
|
|
|
|
.field("merkle_root_hash", &self.merkle_root_hash.reversed())
|
|
|
|
.field("time", &self.time)
|
|
|
|
.field("nbits", &self.nbits)
|
|
|
|
.field("nonce", &self.nonce)
|
|
|
|
.finish()
|
2016-08-16 09:00:26 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-15 05:50:20 -07:00
|
|
|
impl Serializable for BlockHeader {
|
|
|
|
fn serialize(&self, stream: &mut Stream) {
|
|
|
|
stream
|
|
|
|
.append(&self.version)
|
2016-09-19 02:58:53 -07:00
|
|
|
.append(&self.previous_header_hash)
|
|
|
|
.append(&self.merkle_root_hash)
|
2016-08-15 05:50:20 -07:00
|
|
|
.append(&self.time)
|
|
|
|
.append(&self.nbits)
|
|
|
|
.append(&self.nonce);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-15 07:13:52 -07:00
|
|
|
impl Deserializable for BlockHeader {
|
|
|
|
fn deserialize(reader: &mut Reader) -> Result<Self, ReaderError> where Self: Sized {
|
|
|
|
let block_header = BlockHeader {
|
2016-09-19 05:37:53 -07:00
|
|
|
version: try!(reader.read()),
|
|
|
|
previous_header_hash: try!(reader.read()),
|
|
|
|
merkle_root_hash: try!(reader.read()),
|
|
|
|
time: try!(reader.read()),
|
|
|
|
nbits: try!(reader.read()),
|
|
|
|
nonce: try!(reader.read()),
|
2016-08-15 07:13:52 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
Ok(block_header)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-15 05:50:20 -07:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2016-09-18 09:12:45 -07:00
|
|
|
use ser::{Reader, Error as ReaderError, Stream};
|
2016-08-15 05:50:20 -07:00
|
|
|
use super::BlockHeader;
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_block_header_stream() {
|
|
|
|
let block_header = BlockHeader {
|
|
|
|
version: 1,
|
2016-09-19 02:58:53 -07:00
|
|
|
previous_header_hash: [2; 32].into(),
|
|
|
|
merkle_root_hash: [3; 32].into(),
|
2016-08-15 05:50:20 -07:00
|
|
|
time: 4,
|
|
|
|
nbits: 5,
|
|
|
|
nonce: 6,
|
|
|
|
};
|
|
|
|
|
|
|
|
let mut stream = Stream::default();
|
|
|
|
stream.append(&block_header);
|
|
|
|
|
|
|
|
let expected = vec![
|
|
|
|
1, 0, 0, 0,
|
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
|
|
4, 0, 0, 0,
|
|
|
|
5, 0, 0, 0,
|
|
|
|
6, 0, 0, 0,
|
2016-09-19 09:06:43 -07:00
|
|
|
].into();
|
2016-08-15 05:50:20 -07:00
|
|
|
|
|
|
|
assert_eq!(stream.out(), expected);
|
|
|
|
}
|
2016-08-15 07:13:52 -07:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_block_header_reader() {
|
|
|
|
let buffer = vec![
|
|
|
|
1, 0, 0, 0,
|
|
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
|
|
|
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
|
|
4, 0, 0, 0,
|
|
|
|
5, 0, 0, 0,
|
|
|
|
6, 0, 0, 0,
|
|
|
|
];
|
|
|
|
|
|
|
|
let mut reader = Reader::new(&buffer);
|
|
|
|
|
|
|
|
let expected = BlockHeader {
|
|
|
|
version: 1,
|
2016-09-19 02:58:53 -07:00
|
|
|
previous_header_hash: [2; 32].into(),
|
|
|
|
merkle_root_hash: [3; 32].into(),
|
2016-08-15 07:13:52 -07:00
|
|
|
time: 4,
|
|
|
|
nbits: 5,
|
|
|
|
nonce: 6,
|
|
|
|
};
|
|
|
|
|
|
|
|
assert_eq!(expected, reader.read().unwrap());
|
|
|
|
assert_eq!(ReaderError::UnexpectedEnd, reader.read::<BlockHeader>().unwrap_err());
|
|
|
|
}
|
2016-08-15 05:50:20 -07:00
|
|
|
}
|