Newer
Older
use ser::{Serializable, Stream, Reader};
use network::Magic;
use common::Command;
pub command: Command,
pub len: u32,
impl MessageHeader {
pub fn for_data(magic: Magic, command: Command, data: &[u8]) -> Self {
MessageHeader {
magic: magic,
command: command,
len: data.len() as u32,
checksum: checksum(data),
}
}
}
pub fn deserialize(data: &[u8], flags: u32, expected: Magic) -> Result<Self, Error> {
if data.len() != 24 {
return Err(Error::Deserialize);
}
let magic: u32 = try!(reader.read());
let magic = Magic::from(magic);
return Err(Error::InvalidMagic);
command: try!(reader.read()),
len: try!(reader.read()),
};
Ok(header)
}
}
impl Serializable for MessageHeader {
fn serialize(&self, stream: &mut Stream) {
stream
.append(&self.magic)
.append(&self.command)
.append(&self.len)
#[cfg(test)]
mod tests {
use bytes::Bytes;
use network::{Network, ConsensusFork};
use super::MessageHeader;
#[test]
fn test_message_header_serialization() {
let expected = "f9beb4d96164647200000000000000001f000000ed52399b".into();
let header = MessageHeader {
magic: Network::Mainnet.magic(&ConsensusFork::BitcoinCore),
};
assert_eq!(serialize(&header), expected);
}
#[test]
fn test_message_header_deserialization() {
let raw: Bytes = "f9beb4d96164647200000000000000001f000000ed52399b".into();
let expected = MessageHeader {
magic: Network::Mainnet.magic(&ConsensusFork::BitcoinCore),
assert_eq!(expected, MessageHeader::deserialize(&raw, 0, Network::Mainnet.magic(&ConsensusFork::BitcoinCore)).unwrap());