Merge branch 'master' into next

Cargo.lock

@@ -178,7 +178,6 @@ name = "blockstack-core"
 version = "0.0.1"
 dependencies = [
  "assert-json-diff",
- "byteorder",
  "criterion",
  "curve25519-dalek",
  "ed25519-dalek",

Cargo.toml

@@ -38,7 +38,6 @@ name = "block_limits"
 harness = false
 
 [dependencies]
-byteorder = "1.1"
 tini = "0.2"
 rand = "=0.7.2"
 serde = "1"

src/address/b58.rs

@@ -16,7 +16,6 @@
 
 use std::{error, fmt, str};
 
-use byteorder::{ByteOrder, LittleEndian};
 use util::hash::DoubleSha256;
 use address::Error;
 
@@ -80,7 +79,11 @@ pub fn from_check(data: &str) -> Result<Vec<u8>, Error> {
     }
     let ck_start = ret.len() - 4;
     let expected = DoubleSha256::from_data(&ret[..ck_start]).into_le().low_u32();
-    let actual = LittleEndian::read_u32(&ret[ck_start..(ck_start + 4)]);
+
+    let mut actual_buff = [0; 4];
+    actual_buff.copy_from_slice(&ret[ck_start..(ck_start + 4)]);
+    let actual = u32::from_le_bytes(actual_buff);
+
     if expected != actual {
         return Err(Error::BadChecksum(expected, actual));
     }

src/deps/bitcoin/blockdata/transaction.rs

@@ -23,9 +23,9 @@
 //! This module provides the structures and functions needed to support transactions.
 //!
 
-use byteorder::{LittleEndian, WriteBytesExt};
 use std::default::Default;
 use std::fmt;
+use std::io::Write;
 
 use deps::bitcoin::util::hash::Sha256dHash;
 use deps::bitcoin::blockdata::script::Script;
@@ -237,7 +237,7 @@ impl Transaction {
         };
         // hash the result
         let mut raw_vec = serialize(&tx).unwrap();
-        raw_vec.write_u32::<LittleEndian>(sighash_u32).unwrap();
+        raw_vec.write_all(&sighash_u32.to_le_bytes()).unwrap();
         Sha256dHash::from_data(&raw_vec)
     }
 

src/deps/bitcoin/network/serialize.rs

@@ -23,7 +23,6 @@ use std::error;
 use std::fmt;
 use std::io;
 use std::io::{Cursor, Read, Write};
-use byteorder::{LittleEndian, WriteBytesExt, ReadBytesExt};
 use util::hash::to_hex as hex_encode;
 
 use address;
@@ -38,8 +37,6 @@ pub enum Error {
     Io(io::Error),
     /// Base58 encoding error
     Base58(address::Error),
-    /// Error from the `byteorder` crate
-    ByteOrder(io::Error),
     /// Network magic was not expected
     UnexpectedNetworkMagic {
         /// The expected network magic
@@ -80,7 +77,6 @@ impl fmt::Display for Error {
         match *self {
             Error::Io(ref e) => fmt::Display::fmt(e, f),
             Error::Base58(ref e) => fmt::Display::fmt(e, f),
-            Error::ByteOrder(ref e) => fmt::Display::fmt(e, f),
             Error::UnexpectedNetworkMagic { expected: ref e, actual: ref a } => write!(f, "unexpected network magic: expected {}, actual {}", e, a),
             Error::OversizedVectorAllocation { requested: ref r, max: ref m } => write!(f, "allocation of oversized vector requested: requested {}, maximum {}", r, m),
             Error::InvalidChecksum { expected: ref e, actual: ref a } => write!(f, "invalid checksum: expected {}, actual {}", hex_encode(e), hex_encode(a)),
@@ -99,7 +95,6 @@ impl error::Error for Error {
         match *self {
             Error::Io(ref e) => Some(e),
             Error::Base58(ref e) => Some(e),
-            Error::ByteOrder(ref e) => Some(e),
             Error::UnexpectedNetworkMagic { .. }
             | Error::OversizedVectorAllocation { .. }
             | Error::InvalidChecksum { .. }
@@ -246,67 +241,56 @@ pub trait SimpleDecoder {
 }
 
 macro_rules! encoder_fn {
-    ($name:ident, $val_type:ty, $writefn:ident) => {
+    ($name:ident, $val_type:ty) => {
         #[inline]
         fn $name(&mut self, v: $val_type) -> Result<(), Error> {
-            self.writer.$writefn::<LittleEndian>(v).map_err(Error::Io)
+            self.writer.write_all(&v.to_le_bytes()).map_err(Error::Io)
         }
     }
 }
 
 macro_rules! decoder_fn {
-    ($name:ident, $val_type:ty, $readfn:ident) => {
+    ($name:ident, $val_type:ty, $type_size:literal) => {
         #[inline]
         fn $name(&mut self) -> Result<$val_type, Error> {
-            self.reader.$readfn::<LittleEndian>().map_err(Error::Io)
+            let mut buff = [0; $type_size];
+            self.reader.read_exact(&mut buff)
+                .map_err(Error::Io)?;
+            Ok(<$val_type>::from_le_bytes(buff))
         }
     }
 }
 
 impl<W: Write> SimpleEncoder for RawEncoder<W> {
-    encoder_fn!(emit_u64, u64, write_u64);
-    encoder_fn!(emit_u32, u32, write_u32);
-    encoder_fn!(emit_u16, u16, write_u16);
-    encoder_fn!(emit_i64, i64, write_i64);
-    encoder_fn!(emit_i32, i32, write_i32);
-    encoder_fn!(emit_i16, i16, write_i16);
+    encoder_fn!(emit_u64, u64);
+    encoder_fn!(emit_u32, u32);
+    encoder_fn!(emit_u16, u16);
+    encoder_fn!(emit_i64, i64);
+    encoder_fn!(emit_i32, i32);
+    encoder_fn!(emit_i16, i16);
+    encoder_fn!(emit_i8, i8);
+    encoder_fn!(emit_u8, u8);
 
-    #[inline]
-    fn emit_i8(&mut self, v: i8) -> Result<(), Error> {
-        self.writer.write_i8(v).map_err(Error::Io)
-    }
-    #[inline]
-    fn emit_u8(&mut self, v: u8) -> Result<(), Error> {
-        self.writer.write_u8(v).map_err(Error::Io)
-    }
     #[inline]
     fn emit_bool(&mut self, v: bool) -> Result<(), Error> {
-        self.writer.write_i8(if v {1} else {0}).map_err(Error::Io)
+        self.emit_i8(if v {1} else {0})
     }
 }
 
 impl<R: Read> SimpleDecoder for RawDecoder<R> {
-    decoder_fn!(read_u64, u64, read_u64);
-    decoder_fn!(read_u32, u32, read_u32);
-    decoder_fn!(read_u16, u16, read_u16);
-    decoder_fn!(read_i64, i64, read_i64);
-    decoder_fn!(read_i32, i32, read_i32);
-    decoder_fn!(read_i16, i16, read_i16);
+    decoder_fn!(read_u64, u64, 8);
+    decoder_fn!(read_u32, u32, 4);
+    decoder_fn!(read_u16, u16, 2);
+    decoder_fn!(read_i64, i64, 8);
+    decoder_fn!(read_i32, i32, 4);
+    decoder_fn!(read_i16, i16, 2);
+    decoder_fn!(read_u8, u8, 1);
+    decoder_fn!(read_i8, i8, 1);
 
-    #[inline]
-    fn read_u8(&mut self) -> Result<u8, Error> {
-        self.reader.read_u8().map_err(Error::Io)
-    }
-    #[inline]
-    fn read_i8(&mut self) -> Result<i8, Error> {
-        self.reader.read_i8().map_err(Error::Io)
-    }
     #[inline]
     fn read_bool(&mut self) -> Result<bool, Error> {
-        match self.reader.read_i8() {
-            Ok(bit) => Ok(bit != 0),
-            Err(e) => Err(Error::Io(e))
-        }
+        self.read_i8()
+            .map(|bit| bit != 0)
     }
 }
 

src/deps/bitcoin/util/hash.rs

@@ -20,12 +20,12 @@ use std::cmp::min;
 use std::default::Default;
 use std::error;
 use std::fmt;
-use std::io::Cursor;
+use std::io::{
+    Cursor, Write
+};
 use std::mem;
 #[cfg(feature = "serde")] use serde;
 
-use byteorder::{LittleEndian, WriteBytesExt};
-
 use ripemd160::Ripemd160;
 use sha2::Sha256;
 use sha2::Digest;
@@ -70,42 +70,42 @@ impl Sha256dEncoder {
 impl SimpleEncoder for Sha256dEncoder {
     fn emit_u64(&mut self, v: u64) -> Result<(), serialize::Error> {
         let mut data = [0; 8];
-        (&mut data[..]).write_u64::<LittleEndian>(v).unwrap();
+        (&mut data[..]).write_all(&v.to_le_bytes()).unwrap();
         self.0.input(&data);
         Ok(())
     }
 
     fn emit_u32(&mut self, v: u32) -> Result<(), serialize::Error> {
         let mut data = [0; 4];
-        (&mut data[..]).write_u32::<LittleEndian>(v).unwrap();
+        (&mut data[..]).write_all(&v.to_le_bytes()).unwrap();
         self.0.input(&data);
         Ok(())
     }
 
     fn emit_u16(&mut self, v: u16) -> Result<(), serialize::Error> {
         let mut data = [0; 2];
-        (&mut data[..]).write_u16::<LittleEndian>(v).unwrap();
+        (&mut data[..]).write_all(&v.to_le_bytes()).unwrap();
         self.0.input(&data);
         Ok(())
     }
 
     fn emit_i64(&mut self, v: i64) -> Result<(), serialize::Error> {
         let mut data = [0; 8];
-        (&mut data[..]).write_i64::<LittleEndian>(v).unwrap();
+        (&mut data[..]).write_all(&v.to_le_bytes()).unwrap();
         self.0.input(&data);
         Ok(())
     }
 
     fn emit_i32(&mut self, v: i32) -> Result<(), serialize::Error> {
         let mut data = [0; 4];
-        (&mut data[..]).write_i32::<LittleEndian>(v).unwrap();
+        (&mut data[..]).write_all(&v.to_le_bytes()).unwrap();
         self.0.input(&data);
         Ok(())
     }
 
     fn emit_i16(&mut self, v: i16) -> Result<(), serialize::Error> {
         let mut data = [0; 2];
-        (&mut data[..]).write_i16::<LittleEndian>(v).unwrap();
+        (&mut data[..]).write_all(&v.to_le_bytes()).unwrap();
         self.0.input(&data);
         Ok(())
     }

src/lib.rs

@@ -37,7 +37,6 @@ extern crate sha3;
 extern crate ripemd160;
 extern crate regex;
 extern crate time;
-extern crate byteorder;
 extern crate mio;
 extern crate url;
 extern crate percent_encoding;