rust-bitcoin-unsafe-fast/src/network/serialize.rs

// Rust Bitcoin Library
// Written in 2014 by
//   Andrew Poelstra <apoelstra@wpsoftware.net>
//
// To the extent possible under law, the author(s) have dedicated all
// copyright and related and neighboring rights to this software to
// the public domain worldwide. This software is distributed without
// any warranty.
//
// You should have received a copy of the CC0 Public Domain Dedication
// along with this software.
// If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
//

//! # Network Serialization
//!
//! This module defines the `Serializable` trait which is used for
//! (de)serializing Bitcoin objects for transmission on the network.
//! It also defines (de)serialization routines for many primitives.
//!

use collections::Vec;
use std::io::{self, Cursor, Read, Write};
use serialize::hex::ToHex;

use network::encodable::{ConsensusDecodable, ConsensusEncodable};
use util::hash::Sha256dHash;

/// Objects which are referred to by hash
pub trait BitcoinHash {
  /// Produces a Sha256dHash which can be used to refer to the object
  fn bitcoin_hash(&self) -> Sha256dHash;
}

impl BitcoinHash for Vec<u8> {
  fn bitcoin_hash(&self) -> Sha256dHash {
    Sha256dHash::from_data(self.as_slice())
  }
}

/// Encode an object into a vector
pub fn serialize<T: ConsensusEncodable<RawEncoder<Cursor<Vec<u8>>>>>(obj: &T) -> io::Result<Vec<u8>> {
  let mut encoder = RawEncoder::new(Cursor::new(vec![]));
  try!(obj.consensus_encode(&mut encoder));
  Ok(encoder.unwrap().unwrap())
}

/// Encode an object into a hex-encoded string
pub fn serialize_hex<T: ConsensusEncodable<RawEncoder<Cursor<Vec<u8>>>>>(obj: &T) -> io::Result<String> {
  let serial = try!(serialize(obj));
  Ok(serial.as_slice().to_hex())
}

/// Deserialize an object from a vector
pub fn deserialize<T: ConsensusDecodable<RawDecoder<Cursor<Vec<u8>>>>>(data: Vec<u8>) -> io::Result<T> {
  let mut decoder = RawDecoder::new(Cursor::new(data));
  ConsensusDecodable::consensus_decode(&mut decoder)
}

/// An encoder for raw binary data
pub struct RawEncoder<W> {
  writer: W
}

/// An decoder for raw binary data
pub struct RawDecoder<R> {
  reader: R
}

impl<W:Write> RawEncoder<W> {
  /// Constructor
  pub fn new(writer: W) -> RawEncoder<W> {
    RawEncoder { writer: writer }
  }

  /// Returns the underlying Writer
  pub fn unwrap(self) -> W {
    self.writer
  }
}

impl<R:Read> RawDecoder<R> {
  /// Constructor
  pub fn new(reader: R) -> RawDecoder<R> {
    RawDecoder { reader: reader }
  }

  /// Returns the underlying Reader
  pub fn unwrap(self) -> R {
    self.reader
  }
}

/// A simple Encoder trait
pub trait SimpleEncoder {
  type Error;

  /// Output a 64-bit uint
  fn emit_u64(&mut self, v: u64) -> Result<(), Self::Error>;
  /// Output a 32-bit uint
  fn emit_u32(&mut self, v: u32) -> Result<(), Self::Error>;
  /// Output a 16-bit uint
  fn emit_u16(&mut self, v: u16) -> Result<(), Self::Error>;
  /// Output a 8-bit uint
  fn emit_u8(&mut self, v: u8) -> Result<(), Self::Error>;

  /// Output a 64-bit int
  fn emit_i64(&mut self, v: i64) -> Result<(), Self::Error>;
  /// Output a 32-bit int
  fn emit_i32(&mut self, v: i32) -> Result<(), Self::Error>;
  /// Output a 16-bit int
  fn emit_i16(&mut self, v: i16) -> Result<(), Self::Error>;
  /// Output a 8-bit int
  fn emit_i8(&mut self, v: i8) -> Result<(), Self::Error>;

  /// Output a boolean
  fn emit_bool(&mut self, v: bool) -> Result<(), Self::Error>;
}

/// A simple Decoder trait
pub trait SimpleDecoder {
  type Error;

  /// Read a 64-bit uint
  fn read_u64(&mut self) -> Result<u64, Self::Error>;
  /// Read a 32-bit uint
  fn read_u32(&mut self) -> Result<u32, Self::Error>;
  /// Read a 16-bit uint
  fn read_u16(&mut self) -> Result<u16, Self::Error>;
  /// Read a 8-bit uint
  fn read_u8(&mut self) -> Result<u8, Self::Error>;

  /// Read a 64-bit int
  fn read_i64(&mut self) -> Result<i64, Self::Error>;
  /// Read a 32-bit int
  fn read_i32(&mut self) -> Result<i32, Self::Error>;
  /// Read a 16-bit int
  fn read_i16(&mut self) -> Result<i16, Self::Error>;
  /// Read a 8-bit int
  fn read_i8(&mut self) -> Result<i8, Self::Error>;

  /// Read a boolean
  fn read_bool(&mut self) -> Result<bool, Self::Error>;

  /// Signal a decoding error
  fn error(&mut self, err: &str) -> Self::Error;
}

// TODO: trait reform: impl SimpleEncoder for every Encoder, ditto for Decoder

impl<W: Write> SimpleEncoder for RawEncoder<W> {
  type Error = io::Error;

  #[inline]
  fn emit_u64(&mut self, v: u64) -> io::Result<()> { self.writer.write_le_u64(v) }
  #[inline]
  fn emit_u32(&mut self, v: u32) -> io::Result<()> { self.writer.write_le_u32(v) }
  #[inline]
  fn emit_u16(&mut self, v: u16) -> io::Result<()> { self.writer.write_le_u16(v) }
  #[inline]
  fn emit_u8(&mut self, v: u8) -> io::Result<()> { self.writer.write_u8(v) }

  #[inline]
  fn emit_i64(&mut self, v: i64) -> io::Result<()> { self.writer.write_le_i64(v) }
  #[inline]
  fn emit_i32(&mut self, v: i32) -> io::Result<()> { self.writer.write_le_i32(v) }
  #[inline]
  fn emit_i16(&mut self, v: i16) -> io::Result<()> { self.writer.write_le_i16(v) }
  #[inline]
  fn emit_i8(&mut self, v: i8) -> io::Result<()> { self.writer.write_i8(v) }

  #[inline]
  fn emit_bool(&mut self, v: bool) -> io::Result<()> { self.writer.write_i8(if v {1} else {0}) }
}

impl<R: Read> SimpleDecoder for RawDecoder<R> {
  type Error = io::Error;

  #[inline]
  fn read_u64(&mut self) -> io::Result<u64> { self.reader.read_le_u64() }
  #[inline]
  fn read_u32(&mut self) -> io::Result<u32> { self.reader.read_le_u32() }
  #[inline]
  fn read_u16(&mut self) -> io::Result<u16> { self.reader.read_le_u16() }
  #[inline]
  fn read_u8(&mut self) -> io::Result<u8> { self.reader.read_u8() }

  #[inline]
  fn read_i64(&mut self) -> io::Result<i64> { self.reader.read_le_i64() }
  #[inline]
  fn read_i32(&mut self) -> io::Result<i32> { self.reader.read_le_i32() }
  #[inline]
  fn read_i16(&mut self) -> io::Result<i16> { self.reader.read_le_i16() }
  #[inline]
  fn read_i8(&mut self) -> io::Result<i8> { self.reader.read_i8() }

  #[inline]
  fn read_bool(&mut self) -> io::Result<bool> { self.reader.read_u8().map(|res| res != 0) }

  #[inline]
  fn error(&mut self, err: &str) -> io::Error {
    io::Error {
      kind: io::ErrorKind::OtherError,
      desc: "parse error",
      detail: Some(err.to_string())
    }
  }
}

// Aren't really any tests here.. the main functions are serialize and
// deserialize, which get the crap tested out of them it every other
// module.