milksad
/
rust-bitcoin-unsafe-fast
14
0
Fork 0
Code Issues Pull Requests Activity

Merge pull request #47 from apoelstra/no-num 

Remove some dependencies; bump major version number
This commit is contained in:
Andrew Poelstra 2018-02-21 16:34:49 +00:00 committed by GitHub
parent e034ae6065 740d9e6fde
commit 279e6dec28
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 388 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Cargo.toml
View File

@ -1,7 +1,7 @@
[package]
name = "bitcoin"
version = "0.10.9"
version = "0.11.0"
authors = ["Andrew Poelstra <apoelstra@wpsoftware.net>"]
license = "CC0-1.0"
homepage = "https://github.com/apoelstra/rust-bitcoin/"
@ -23,15 +23,13 @@ broken_consensus_code = []
[dependencies]
byteorder = "1.1"
num = "0.1"
rand = "0.3"
rust-crypto = "0.2"
rustc-serialize = "0.3"
secp256k1 = "0.6"
serde = "0.6"
strason = "0.3"
[dependencies.jsonrpc]
version = "0.8" # for serde macros
default-features = false
[dependencies.secp256k1]
version = "0.8"
features = [ "rand", "serde" ]

9
README.md
View File

@ -71,4 +71,13 @@ cross-chain atomic swaps) are more likely to be accepted than things which
support only a single blockchain.
## Release Notes
I will try to document all breaking changes here so that people upgrading will know
what they need to change.
### 0.11
Remove `num` dependency at Matt's request; agree this is obnoxious to require all
downstream users to also have a `num` dependency just so they can use `Uint256::from_u64`.

6
src/blockdata/block.rs
View File

@ -20,8 +20,6 @@
//! these blocks and the blockchain.
//!
use num::{FromPrimitive, Zero};
use util;
use util::Error::{SpvBadTarget, SpvBadProofOfWork};
use util::hash::Sha256dHash;
@ -90,9 +88,9 @@ impl BlockHeader {
// The mantissa is signed but may not be negative
if mant > 0x7FFFFF {
Zero::zero()
Default::default()
} else {
<Uint256 as FromPrimitive>::from_u64(mant as u64).unwrap() << (expt as usize)
Uint256::from_u64(mant as u64).unwrap() << (expt as usize)
}
}

5
src/blockdata/blockchain.rs
View File

@ -18,7 +18,6 @@
//! blockchain.
//!
use num::{FromPrimitive, Zero};
use std::{marker, ptr};
use blockdata::block::{Block, BlockHeader};
@ -348,7 +347,7 @@ impl Blockchain {
let genesis = genesis_block(network);
let genhash = genesis.header.bitcoin_hash();
let new_node = Box::new(BlockchainNode {
total_work: Zero::zero(),
total_work: Default::default(),
required_difficulty: genesis.header.target(),
block: genesis,
height: 0,
@ -444,7 +443,7 @@ impl Blockchain {
// Compute new target
let mut target = unsafe { (*prev).block.header.target() };
target = target.mul_u32(timespan);
target = target / FromPrimitive::from_u64(DIFFCHANGE_TIMESPAN as u64).unwrap();
target = target / Uint256::from_u64(DIFFCHANGE_TIMESPAN as u64).unwrap();
// Clamp below MAX_TARGET (difficulty 1)
let max = max_target(self.network);
if target > max { target = max };

3
src/blockdata/constants.rs
View File

@ -20,7 +20,6 @@
//!
use std::default::Default;
use num::FromPrimitive;
use blockdata::opcodes;
use blockdata::script;
@ -44,7 +43,7 @@ pub static DIFFCHANGE_TIMESPAN: u32 = 14 * 24 * 3600;
/// In Bitcoind this is insanely described as ~((u256)0 >> 32)
pub fn max_target(_: Network) -> Uint256 {
<Uint256 as FromPrimitive>::from_u64(0xFFFF).unwrap() << 208
Uint256::from_u64(0xFFFF).unwrap() << 208
}
/// The maximum value allowed in an output (useful for sanity checking,

300
src/internal_macros.rs
View File

@ -282,3 +282,303 @@ macro_rules! hex_script (($s:expr) => (Script::from($s.from_hex().unwrap())));
#[cfg(test)]
macro_rules! hex_hash (($s:expr) => (Sha256dHash::from(&$s.from_hex().unwrap()[..])));
// Macros to replace serde's codegen while that is not stable
// Taken from rust-jsonrpc 8a50735712cb7870990314cc150ab9c2955dbfd5
#[macro_export]
macro_rules! __rust_jsonrpc_internal__define_anything_type {
() => (
struct Anything;
struct AnythingVisitor;
impl ::serde::de::Visitor for AnythingVisitor {
type Value = Anything;
fn visit_bool<E>(&mut self, _: bool) -> Result<Anything, E> { Ok(Anything) }
fn visit_i64<E>(&mut self, _: i64) -> Result<Anything, E> { Ok(Anything) }
fn visit_u64<E>(&mut self, _: u64) -> Result<Anything, E> { Ok(Anything) }
fn visit_f64<E>(&mut self, _: f64) -> Result<Anything, E> { Ok(Anything) }
fn visit_str<E>(&mut self, _: &str) -> Result<Anything, E> { Ok(Anything) }
fn visit_string<E>(&mut self, _: String) -> Result<Anything, E> { Ok(Anything) }
fn visit_unit<E>(&mut self) -> Result<Anything, E> { Ok(Anything) }
fn visit_none<E>(&mut self) -> Result<Anything, E> { Ok(Anything) }
fn visit_some<D: ::serde::de::Deserializer>(&mut self, d: &mut D) -> Result<Anything, D::Error> {
serde::de::Deserialize::deserialize(d)
}
fn visit_seq<V: ::serde::de::SeqVisitor>(&mut self, v: V) -> Result<Anything, V::Error> {
let _: Vec<Anything> = try!(::serde::de::impls::VecVisitor::new().visit_seq(v));
Ok(Anything)
}
fn visit_map<V: ::serde::de::MapVisitor>(&mut self, mut v: V) -> Result<Anything, V::Error> {
while let Some((Anything, Anything)) = try!(v.visit()) { }
try!(v.end());
Ok(Anything)
}
}
impl ::serde::Deserialize for Anything {
fn deserialize<D>(deserializer: &mut D) -> Result<Anything, D::Error>
where D: ::serde::de::Deserializer
{
deserializer.visit(AnythingVisitor)
}
}
)
}
#[macro_export]
macro_rules! serde_struct_impl {
($name:ident, $($fe:ident $(<- $alt:expr)*),*) => (
impl ::serde::Deserialize for $name {
fn deserialize<D>(deserializer: &mut D) -> Result<$name, D::Error>
where D: serde::de::Deserializer
{
// begin type defs
__rust_jsonrpc_internal__define_anything_type!();
#[allow(non_camel_case_types)]
enum Enum { Unknown__Field, $($fe),* }
struct EnumVisitor;
impl ::serde::de::Visitor for EnumVisitor {
type Value = Enum;
fn visit_str<E>(&mut self, value: &str) -> Result<Enum, E>
where E: ::serde::de::Error
{
match value {
$(
stringify!($fe) => Ok(Enum::$fe)
$(, $alt => Ok(Enum::$fe))*
),*,
_ => Ok(Enum::Unknown__Field)
}
}
}
impl ::serde::Deserialize for Enum {
fn deserialize<D>(deserializer: &mut D) -> Result<Enum, D::Error>
where D: ::serde::de::Deserializer
{
deserializer.visit_str(EnumVisitor)
}
}
struct Visitor;
impl ::serde::de::Visitor for Visitor {
type Value = $name;
fn visit_map<V>(&mut self, mut v: V) -> Result<$name, V::Error>
where V: ::serde::de::MapVisitor
{
$(let mut $fe = None;)*
loop {
match try!(v.visit_key()) {
Some(Enum::Unknown__Field) => { let _: Anything = try!(v.visit_value()); }
$(Some(Enum::$fe) => { $fe = Some(try!(v.visit_value())); })*
None => { break; }
}
}
$(let $fe = match $fe {
Some(x) => x,
None => try!(v.missing_field(stringify!($fe))),
};)*
try!(v.end());
Ok($name{ $($fe: $fe),* })
}
}
// end type defs
static FIELDS: &'static [&'static str] = &[$(stringify!($fe)),*];
deserializer.visit_struct(stringify!($name), FIELDS, Visitor)
}
}
impl ::serde::Serialize for $name {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: ::serde::Serializer
{
// begin type defs
#[repr(u16)]
#[derive(Copy, Clone)]
#[allow(non_camel_case_types)]
#[allow(dead_code)]
enum State { $($fe),* , Finished }
struct MapVisitor<'a> {
value: &'a $name,
state: State,
}
impl<'a> ::serde::ser::MapVisitor for MapVisitor<'a> {
fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
where S: ::serde::Serializer
{
match self.state {
$(State::$fe => {
self.state = unsafe { ::std::mem::transmute(self.state as u16 + 1) };
// Use the last alternate name for serialization; in the common case
// with zero or one alternates this does the RIght Thing
let names = [stringify!($fe), $($alt),*];
Ok(Some(try!(serializer.visit_struct_elt(names[names.len() - 1], &self.value.$fe))))
})*
State::Finished => {
Ok(None)
}
}
}
}
// end type defs
serializer.visit_struct(stringify!($name), MapVisitor {
value: self,
state: unsafe { ::std::mem::transmute(0u16) },
})
}
}
)
}
#[macro_export]
macro_rules! serde_struct_enum_impl {
($name:ident,
$($varname:ident, $structname:ident, $($fe:ident $(<- $alt:expr)*),*);*
) => (
impl ::serde::Deserialize for $name {
fn deserialize<D>(deserializer: &mut D) -> Result<$name, D::Error>
where D: serde::de::Deserializer
{
// start type defs
__rust_jsonrpc_internal__define_anything_type!();
$(#[allow(non_camel_case_types)] enum $varname { $($fe),* })*
#[allow(non_camel_case_types)]
enum Enum { Unknown__Field, $($varname($varname)),* }
struct EnumVisitor;
impl ::serde::de::Visitor for EnumVisitor {
type Value = Enum;
fn visit_str<E>(&mut self, value: &str) -> Result<Enum, E>
where E: ::serde::de::Error
{
$($(
if value == stringify!($fe) $(|| value == $alt)* {
Ok(Enum::$varname($varname::$fe))
} else)*)* {
Ok(Enum::Unknown__Field)
}
}
}
impl ::serde::Deserialize for Enum {
fn deserialize<D>(deserializer: &mut D) -> Result<Enum, D::Error>
where D: ::serde::de::Deserializer
{
deserializer.visit_str(EnumVisitor)
}
}
struct Visitor;
impl ::serde::de::Visitor for Visitor {
type Value = $name;
#[allow(non_snake_case)] //for $structname
#[allow(unused_assignments)] // for `$fe = None` hack
fn visit_map<V>(&mut self, mut v: V) -> Result<$name, V::Error>
where V: ::serde::de::MapVisitor
{
$(
$(let mut $fe = None;)*
// In case of multiple variants having the same field, some of
// the above lets will get shadowed. We therefore need to tell
// rustc its type, since it otherwise cannot infer it, causing
// a compilation error. Hence this hack, which the denizens of
// #rust and I had a good laugh over:
if false { let _ = $structname { $($fe: $fe.unwrap()),* }; }
// The above expression moved $fe so we have to reassign it :)
$($fe = None;)*
)*
loop {
match try!(v.visit_key()) {
Some(Enum::Unknown__Field) => { let _: Anything = try!(v.visit_value()); }
$($(Some(Enum::$varname($varname::$fe)) => {
$fe = Some(try!(v.visit_value())); })*)*
None => { break; }
}
}
// try to find a variant for which we have all fields
$(
let mut $structname = true;
$(if $fe.is_none() { $structname = false })*
// if we found one, success. extra fields is not an error,
// it'd be too much of a PITA to manage overlapping field
// sets otherwise.
if $structname {
$(let $fe = $fe.unwrap();)*
try!(v.end());
return Ok($name::$varname($structname { $($fe: $fe),* }))
}
)*
// If we get here we failed
Err(::serde::de::Error::syntax("did not get all fields"))
}
}
// end type defs
static FIELDS: &'static [&'static str] = &[$($(stringify!($fe)),*),*];
deserializer.visit_struct(stringify!($name), FIELDS, Visitor)
}
}
// impl Serialize (and Deserialize, tho we don't need it) for the underlying structs
$( serde_struct_impl!($structname, $($fe $(<- $alt)*),*); )*
// call serialize on the right one
impl ::serde::Serialize for $name {
fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
where S: ::serde::Serializer
{
match *self {
$($name::$varname(ref x) => x.serialize(serializer)),*
}
}
}
)
}
#[cfg(test)]
mod tests {
use serde;
pub struct Variant1 {
success: bool,
success_message: String
}
pub struct Variant2 {
success: bool,
errors: Vec<String>
}
pub enum Reply {
Good(Variant1),
Bad(Variant2),
}
serde_struct_enum_impl!(Reply,
Good, Variant1, success, success_message;
Bad, Variant2, success, errors
);
}

2
src/lib.rs
View File

@ -43,8 +43,6 @@
extern crate byteorder;
extern crate crypto;
#[macro_use] extern crate jsonrpc;
extern crate num;
extern crate rand;
extern crate rustc_serialize as serialize;
extern crate secp256k1;

7
src/util/address.rs
View File

@ -55,11 +55,14 @@ impl Address {
/// Creates an address from a public key
#[inline]
pub fn from_key(network: Network, pk: &PublicKey, compressed: bool) -> Address {
let secp = Secp256k1::without_caps();
Address {
ty: Type::PubkeyHash,
network: network,
hash: Hash160::from_data(&pk.serialize_vec(&secp, compressed)[..])
hash: if compressed {
Hash160::from_data(&pk.serialize()[..])
} else {
Hash160::from_data(&pk.serialize_uncompressed()[..])
}
}
}

12
src/util/bip32.rs
View File

@ -209,7 +209,7 @@ impl ExtendedPrivKey {
ChildNumber::Normal(n) => {
if n >= (1 << 31) { return Err(Error::InvalidChildNumber(i)) }
// Non-hardened key: compute public data and use that
hmac.input(&PublicKey::from_secret_key(secp, &self.secret_key).unwrap().serialize_vec(secp, true)[..]);
hmac.input(&PublicKey::from_secret_key(secp, &self.secret_key).unwrap().serialize()[..]);
BigEndian::write_u32(&mut be_n, n);
}
ChildNumber::Hardened(n) => {
@ -243,7 +243,7 @@ impl ExtendedPrivKey {
let pk = ExtendedPubKey::from_private(secp, self);
// Do SHA256 of just the ECDSA pubkey
let mut sha2 = Sha256::new();
sha2.input(&pk.public_key.serialize_vec(secp, true)[..]);
sha2.input(&pk.public_key.serialize()[..]);
sha2.result(&mut sha2_res);
// do RIPEMD160
let mut ripemd = Ripemd160::new();
@ -284,7 +284,7 @@ impl ExtendedPubKey {
}
ChildNumber::Normal(n) => {
let mut hmac = Hmac::new(Sha512::new(), &self.chain_code[..]);
hmac.input(&self.public_key.serialize_vec(secp, true)[..]);
hmac.input(&self.public_key.serialize()[..]);
let mut be_n = [0; 4];
BigEndian::write_u32(&mut be_n, n);
hmac.input(&be_n);
@ -317,12 +317,11 @@ impl ExtendedPubKey {
/// Returns the HASH160 of the chaincode
pub fn identifier(&self) -> [u8; 20] {
let s = Secp256k1::with_caps(secp256k1::ContextFlag::None);
let mut sha2_res = [0; 32];
let mut ripemd_res = [0; 20];
// Do SHA256 of just the ECDSA pubkey
let mut sha2 = Sha256::new();
sha2.input(&self.public_key.serialize_vec(&s, true)[..]);
sha2.input(&self.public_key.serialize()[..]);
sha2.result(&mut sha2_res);
// do RIPEMD160
let mut ripemd = Ripemd160::new();
@ -395,7 +394,6 @@ impl FromBase58 for ExtendedPrivKey {
impl ToBase58 for ExtendedPubKey {
fn base58_layout(&self) -> Vec<u8> {
let s = Secp256k1::with_caps(secp256k1::ContextFlag::None);
let mut ret = Vec::with_capacity(78);
ret.extend(match self.network {
Network::Bitcoin => [0x04u8, 0x88, 0xB2, 0x1E],
@ -414,7 +412,7 @@ impl ToBase58 for ExtendedPubKey {
}
ret.extend(be_n.iter().cloned());
ret.extend(self.chain_code[..].iter().cloned());
ret.extend(self.public_key.serialize_vec(&s, true)[..].iter().cloned());
ret.extend(self.public_key.serialize()[..].iter().cloned());
ret
}
}

9
src/util/contracthash.rs
View File

@ -17,7 +17,7 @@
//! at http://blockstream.com/sidechains.pdf for details of
//! what this does.
use secp256k1::{self, ContextFlag, Secp256k1};
use secp256k1::{self, Secp256k1};
use secp256k1::key::{PublicKey, SecretKey};
use blockdata::{opcodes, script};
use crypto::{hmac, sha2};
@ -109,7 +109,6 @@ pub struct Template(Vec<TemplateElement>);
impl Template {
/// Instantiate a template
pub fn to_script(&self, keys: &[PublicKey]) -> Result<script::Script, Error> {
let secp = Secp256k1::with_caps(ContextFlag::None);
let mut key_index = 0;
let mut ret = script::Builder::new();
for elem in &self.0 {
@ -120,7 +119,7 @@ impl Template {
return Err(Error::TooFewKeys(key_index));
}
key_index += 1;
ret.push_slice(&keys[key_index - 1].serialize_vec(&secp, true)[..])
ret.push_slice(&keys[key_index - 1].serialize()[..])
}
}
}
@ -171,7 +170,7 @@ pub fn tweak_keys(secp: &Secp256k1, keys: &[PublicKey], contract: &[u8]) -> Resu
let mut ret = Vec::with_capacity(keys.len());
for mut key in keys.iter().cloned() {
let mut hmac_raw = [0; 32];
let mut hmac = hmac::Hmac::new(sha2::Sha256::new(), &key.serialize_vec(secp, true));
let mut hmac = hmac::Hmac::new(sha2::Sha256::new(), &key.serialize());
hmac.input(contract);
hmac.raw_result(&mut hmac_raw);
let hmac_sk = try!(SecretKey::from_slice(secp, &hmac_raw).map_err(Error::BadTweak));
@ -184,7 +183,7 @@ pub fn tweak_keys(secp: &Secp256k1, keys: &[PublicKey], contract: &[u8]) -> Resu
/// Compute a tweak from some given data for the given public key
pub fn compute_tweak(secp: &Secp256k1, pk: &PublicKey, contract: &[u8]) -> Result<SecretKey, Error> {
let mut hmac_raw = [0; 32];
let mut hmac = hmac::Hmac::new(sha2::Sha256::new(), &pk.serialize_vec(secp, true));
let mut hmac = hmac::Hmac::new(sha2::Sha256::new(), &pk.serialize());
hmac.input(contract);
hmac.raw_result(&mut hmac_raw);
SecretKey::from_slice(secp, &hmac_raw).map_err(Error::BadTweak)

6
src/util/hash.rs
View File

@ -429,11 +429,11 @@ impl <T: BitcoinHash> MerkleRoot for Vec<T> {
#[cfg(test)]
mod tests {
use num::FromPrimitive;
use strason;
use network::encodable::VarInt;
use network::serialize::{serialize, deserialize};
use util::uint::{Uint128, Uint256};
use super::*;
#[test]
@ -515,8 +515,8 @@ mod tests {
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0]);
assert_eq!(Some(one.into_le()), FromPrimitive::from_u64(1));
assert_eq!(Some(one.into_le().low_128()), FromPrimitive::from_u64(1));
assert_eq!(Some(one.into_le()), Uint256::from_u64(1));
assert_eq!(Some(one.into_le().low_128()), Uint128::from_u64(1));
}
}

6
src/util/mod.rs
View File

@ -43,6 +43,12 @@ pub trait BitArray {
/// Trailing zeros
fn trailing_zeros(&self) -> usize;
/// Create all-zeros value
fn zero() -> Self;
/// Create value represeting one
fn one() -> Self;
}
/// A general error code

27
src/util/patricia_tree.rs
View File

@ -23,7 +23,6 @@
use std::fmt::Debug;
use std::marker;
use std::{cmp, fmt, ops, ptr};
use num::{Zero, One};
use network::encodable::{ConsensusDecodable, ConsensusEncodable};
use network::serialize::{SimpleDecoder, SimpleEncoder};
@ -39,7 +38,7 @@ pub struct PatriciaTree<K: Copy, V> {
}
impl<K, V> PatriciaTree<K, V>
where K: Copy + BitArray + cmp::Eq + Zero + One +
where K: Copy + BitArray + cmp::Eq +
ops::BitXor<K, Output=K> +
ops::Add<K, Output=K> +
ops::Shr<usize, Output=K> +
@ -51,7 +50,7 @@ impl<K, V> PatriciaTree<K, V>
data: None,
child_l: None,
child_r: None,
skip_prefix: Zero::zero(),
skip_prefix: BitArray::zero(),
skip_len: 0
}
}
@ -221,7 +220,7 @@ impl<K, V> PatriciaTree<K, V>
/// Return value is (deletable, actual return value), where `deletable` is true
/// is true when the entire node can be deleted (i.e. it has no children)
fn recurse<K, V>(tree: &mut PatriciaTree<K, V>, key: &K, key_len: usize) -> (bool, Option<V>)
where K: Copy + BitArray + cmp::Eq + Zero + One +
where K: Copy + BitArray + cmp::Eq +
ops::Add<K, Output=K> +
ops::Shr<usize, Output=K> +
ops::Shl<usize, Output=K>
@ -255,9 +254,9 @@ impl<K, V> PatriciaTree<K, V>
tree.data = data;
tree.child_l = child_l;
tree.child_r = child_r;
let new_bit = if bit { let ret: K = One::one();
let new_bit = if bit { let ret: K = BitArray::one();
ret << (tree.skip_len as usize) }
else { Zero::zero() };
else { BitArray::zero() };
tree.skip_prefix = tree.skip_prefix +
new_bit +
(skip_prefix << (1 + tree.skip_len as usize));
@ -314,9 +313,9 @@ impl<K, V> PatriciaTree<K, V>
tree.data = data;
tree.child_l = child_l;
tree.child_r = child_r;
let new_bit = if bit { let ret: K = One::one();
let new_bit = if bit { let ret: K = BitArray::one();
ret << (tree.skip_len as usize) }
else { Zero::zero() };
else { BitArray::zero() };
tree.skip_prefix = tree.skip_prefix +
new_bit +
(skip_prefix << (1 + tree.skip_len as usize));
@ -545,18 +544,16 @@ impl<'a, K: Copy, V> Iterator for MutItems<'a, K, V> {
#[cfg(test)]
mod tests {
use num::Zero;
use num::FromPrimitive;
use network::serialize::{deserialize, serialize};
use util::hash::Sha256dHash;
use util::uint::Uint128;
use util::uint::Uint256;
use util::patricia_tree::PatriciaTree;
use util::BitArray;
#[test]
fn patricia_single_insert_lookup_delete_test() {
let mut key: Uint256 = FromPrimitive::from_u64(0xDEADBEEFDEADBEEF).unwrap();
let mut key = Uint256::from_u64(0xDEADBEEFDEADBEEF).unwrap();
key = key + (key << 64);
let mut tree = PatriciaTree::new();
@ -622,14 +619,14 @@ mod tests {
// Do the actual test -- note that we also test insertion and deletion
// at the root here.
for i in 0u32..10 {
tree.insert(&Zero::zero(), i as usize, i);
tree.insert(&BitArray::zero(), i as usize, i);
}
for i in 0u32..10 {
let m = tree.lookup(&Zero::zero(), i as usize);
let m = tree.lookup(&BitArray::zero(), i as usize);
assert_eq!(m, Some(&i));
}
for i in 0u32..10 {
let m = tree.delete(&Zero::zero(), i as usize);
let m = tree.delete(&BitArray::zero(), i as usize);
assert_eq!(m, Some(i));
}
// Check that the chunder was unharmed

75
src/util/uint.rs
View File

@ -19,7 +19,6 @@
//!
use std::fmt;
use num::{FromPrimitive, Zero, One};
use util::BitArray;
@ -71,31 +70,18 @@ macro_rules! construct_uint {
}
$name(ret) + $name(carry)
}
}
impl FromPrimitive for $name {
#[inline]
fn from_u64(init: u64) -> Option<$name> {
/// Create an object from a given unsigned 64-bit integer
pub fn from_u64(init: u64) -> Option<$name> {
let mut ret = [0; $n_words];
ret[0] = init;
Some($name(ret))
}
#[inline]
fn from_i64(init: i64) -> Option<$name> {
/// Create an object from a given signed 64-bit integer
pub fn from_i64(init: i64) -> Option<$name> {
assert!(init >= 0);
FromPrimitive::from_u64(init as u64)
}
}
impl Zero for $name {
fn zero() -> $name { $name([0; $n_words]) }
fn is_zero(&self) -> bool { self.0.iter().all(|&n| n == 0) }
}
impl One for $name {
fn one() -> $name {
$name({ let mut ret = [0; $n_words]; ret[0] = 1; ret })
$name::from_u64(init as u64)
}
}
@ -124,7 +110,7 @@ macro_rules! construct_uint {
#[inline]
fn sub(self, other: $name) -> $name {
self + !other + One::one()
self + !other + BitArray::one()
}
}
@ -212,6 +198,17 @@ macro_rules! construct_uint {
}
(0x40 * ($n_words - 1)) + arr[$n_words - 1].trailing_zeros() as usize
}
fn zero() -> $name { $name([0; $n_words]) }
fn one() -> $name {
$name({ let mut ret = [0; $n_words]; ret[0] = 1; ret })
}
}
impl ::std::default::Default for $name {
fn default() -> $name {
BitArray::zero()
}
}
impl ::std::ops::BitAnd<$name> for $name {
@ -375,22 +372,20 @@ impl Uint256 {
#[cfg(test)]
mod tests {
use num::FromPrimitive;
use network::serialize::{deserialize, serialize};
use util::uint::Uint256;
use util::BitArray;
#[test]
pub fn uint256_bits_test() {
assert_eq!(<Uint256 as FromPrimitive>::from_u64(255).unwrap().bits(), 8);
assert_eq!(<Uint256 as FromPrimitive>::from_u64(256).unwrap().bits(), 9);
assert_eq!(<Uint256 as FromPrimitive>::from_u64(300).unwrap().bits(), 9);
assert_eq!(<Uint256 as FromPrimitive>::from_u64(60000).unwrap().bits(), 16);
assert_eq!(<Uint256 as FromPrimitive>::from_u64(70000).unwrap().bits(), 17);
assert_eq!(Uint256::from_u64(255).unwrap().bits(), 8);
assert_eq!(Uint256::from_u64(256).unwrap().bits(), 9);
assert_eq!(Uint256::from_u64(300).unwrap().bits(), 9);
assert_eq!(Uint256::from_u64(60000).unwrap().bits(), 16);
assert_eq!(Uint256::from_u64(70000).unwrap().bits(), 17);
// Try to read the following lines out loud quickly
let mut shl = <Uint256 as FromPrimitive>::from_u64(70000).unwrap();
let mut shl = Uint256::from_u64(70000).unwrap();
shl = shl << 100;
assert_eq!(shl.bits(), 117);
shl = shl << 100;
@ -399,11 +394,11 @@ mod tests {
assert_eq!(shl.bits(), 0);
// Bit set check
assert!(!<Uint256 as FromPrimitive>::from_u64(10).unwrap().bit(0));
assert!(<Uint256 as FromPrimitive>::from_u64(10).unwrap().bit(1));
assert!(!<Uint256 as FromPrimitive>::from_u64(10).unwrap().bit(2));
assert!(<Uint256 as FromPrimitive>::from_u64(10).unwrap().bit(3));
assert!(!<Uint256 as FromPrimitive>::from_u64(10).unwrap().bit(4));
assert!(!Uint256::from_u64(10).unwrap().bit(0));
assert!(Uint256::from_u64(10).unwrap().bit(1));
assert!(!Uint256::from_u64(10).unwrap().bit(2));
assert!(Uint256::from_u64(10).unwrap().bit(3));
assert!(!Uint256::from_u64(10).unwrap().bit(4));
}
#[test]
@ -425,7 +420,7 @@ mod tests {
#[test]
pub fn uint256_arithmetic_test() {
let init = <Uint256 as FromPrimitive>::from_u64(0xDEADBEEFDEADBEEF).unwrap();
let init = Uint256::from_u64(0xDEADBEEFDEADBEEF).unwrap();
let copy = init;
let add = init + copy;
@ -446,17 +441,17 @@ mod tests {
let mult = sub.mul_u32(300);
assert_eq!(mult, Uint256([0x8C8C3EE70C644118u64, 0x0209E7378231E632, 0, 0]));
// Division
assert_eq!(<Uint256 as FromPrimitive>::from_u64(105).unwrap() /
<Uint256 as FromPrimitive>::from_u64(5).unwrap(),
<Uint256 as FromPrimitive>::from_u64(21).unwrap());
let div = mult / <Uint256 as FromPrimitive>::from_u64(300).unwrap();
assert_eq!(Uint256::from_u64(105).unwrap() /
Uint256::from_u64(5).unwrap(),
Uint256::from_u64(21).unwrap());
let div = mult / Uint256::from_u64(300).unwrap();
assert_eq!(div, Uint256([0x9F30411021524112u64, 0x0001BD5B7DDFBD5A, 0, 0]));
// TODO: bit inversion
}
#[test]
pub fn uint256_bitslice_test() {
let init = <Uint256 as FromPrimitive>::from_u64(0xDEADBEEFDEADBEEF).unwrap();
let init = Uint256::from_u64(0xDEADBEEFDEADBEEF).unwrap();
let add = init + (init << 64);
assert_eq!(add.bit_slice(64, 128), init);
assert_eq!(add.mask(64), init);
@ -466,7 +461,7 @@ mod tests {
pub fn uint256_extreme_bitshift_test() {
// Shifting a u64 by 64 bits gives an undefined value, so make sure that
// we're doing the Right Thing here
let init = <Uint256 as FromPrimitive>::from_u64(0xDEADBEEFDEADBEEF).unwrap();
let init = Uint256::from_u64(0xDEADBEEFDEADBEEF).unwrap();
assert_eq!(init << 64, Uint256([0, 0xDEADBEEFDEADBEEF, 0, 0]));
let add = (init << 64) + init;