BigInt wrapper and local types

Cargo.toml

@@ -14,5 +14,6 @@ members = [
     "node",
     "node/clock",
     "crypto",
-    "encoding"
+    "encoding",
+    "math/bigint",
 ]

Makefile

@@ -17,6 +17,7 @@ clean:
 	@cargo clean -p interpreter
 	@cargo clean -p crypto
 	@cargo clean -p encoding
+	@cargo clean -p bigint
 	@echo "Done cleaning."
 
 lint: clean

math/bigint/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "ferret_bigint"
+version = "0.1.0"
+authors = ["ChainSafe Systems <info@chainsafe.io>"]
+edition = "2018"
+
+[dependencies]
+num-bigint = "0.2.3"

math/bigint/src/big.rs

@@ -0,0 +1,65 @@
+pub use num_bigint::BigInt as BaseBigInt;
+use std::fmt;
+use std::ops::{Deref, DerefMut};
+
+/// Signed Big integer variable
+#[derive(PartialEq, Eq, Clone, Debug, Hash, Default, Ord, PartialOrd)]
+pub struct BigInt {
+    num: BaseBigInt,
+}
+
+impl From<i64> for BigInt {
+    #[inline]
+    fn from(n: i64) -> Self {
+        BigInt::from(BaseBigInt::from(n))
+    }
+}
+
+impl From<BaseBigInt> for BigInt {
+    fn from(num: BaseBigInt) -> Self {
+        Self { num }
+    }
+}
+
+impl Deref for BigInt {
+    type Target = BaseBigInt;
+    fn deref(&self) -> &Self::Target {
+        &self.num
+    }
+}
+
+impl DerefMut for BigInt {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.num
+    }
+}
+
+impl fmt::Display for BigInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.deref().fmt(f)
+    }
+}
+
+impl fmt::Binary for BigInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.deref().fmt(f)
+    }
+}
+
+impl fmt::Octal for BigInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.deref().fmt(f)
+    }
+}
+
+impl fmt::LowerHex for BigInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.deref().fmt(f)
+    }
+}
+
+impl fmt::UpperHex for BigInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.deref().fmt(f)
+    }
+}

math/bigint/src/lib.rs

@@ -0,0 +1,6 @@
+mod big;
+mod ubig;
+
+pub use self::big::{BaseBigInt, BigInt};
+pub use self::ubig::{BaseUBigInt, UBigInt};
+pub use num_bigint as base_big;

math/bigint/src/ubig.rs

@@ -0,0 +1,64 @@
+pub use num_bigint::BigUint as BaseUBigInt;
+use std::fmt;
+use std::ops::{Deref, DerefMut};
+
+#[derive(PartialEq, Eq, Clone, Debug, Hash, Default)]
+pub struct UBigInt {
+    num: BaseUBigInt,
+}
+
+impl From<u64> for UBigInt {
+    #[inline]
+    fn from(n: u64) -> Self {
+        UBigInt::from(BaseUBigInt::from(n))
+    }
+}
+
+impl From<BaseUBigInt> for UBigInt {
+    fn from(num: BaseUBigInt) -> Self {
+        Self { num }
+    }
+}
+
+impl Deref for UBigInt {
+    type Target = BaseUBigInt;
+    fn deref(&self) -> &Self::Target {
+        &self.num
+    }
+}
+
+impl DerefMut for UBigInt {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.num
+    }
+}
+
+impl fmt::Display for UBigInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.deref().fmt(f)
+    }
+}
+
+impl fmt::Binary for UBigInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.deref().fmt(f)
+    }
+}
+
+impl fmt::Octal for UBigInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.deref().fmt(f)
+    }
+}
+
+impl fmt::LowerHex for UBigInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.deref().fmt(f)
+    }
+}
+
+impl fmt::UpperHex for UBigInt {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.deref().fmt(f)
+    }
+}

math/bigint/tests/big_test.rs

@@ -0,0 +1,62 @@
+use ferret_bigint::{BaseBigInt, BigInt};
+
+#[test]
+fn test_lower_hex() {
+    let a = BigInt::from(BaseBigInt::parse_bytes(b"A", 16).unwrap());
+    let hello = BigInt::from(
+        BaseBigInt::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap(),
+    );
+
+    assert_eq!(format!("{:x}", a), "a");
+    assert_eq!(format!("{:x}", hello), "48656c6c6f20776f726c6421");
+    assert_eq!(format!("{:♥>+#8x}", a), "♥♥♥♥+0xa");
+}
+
+#[test]
+fn test_upper_hex() {
+    let a = BigInt::from(BaseBigInt::parse_bytes(b"A", 16).unwrap());
+    let hello = BigInt::from(
+        BaseBigInt::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap(),
+    );
+
+    assert_eq!(format!("{:X}", a), "A");
+    assert_eq!(format!("{:X}", hello), "48656C6C6F20776F726C6421");
+    assert_eq!(format!("{:♥>+#8X}", a), "♥♥♥♥+0xA");
+}
+
+#[test]
+fn test_binary() {
+    let a = BigInt::from(BaseBigInt::parse_bytes(b"A", 16).unwrap());
+    let hello = BigInt::from(BaseBigInt::parse_bytes("224055342307539".as_bytes(), 10).unwrap());
+
+    assert_eq!(format!("{:b}", a), "1010");
+    assert_eq!(
+        format!("{:b}", hello),
+        "110010111100011011110011000101101001100011010011"
+    );
+    assert_eq!(format!("{:♥>+#8b}", a), "♥+0b1010");
+}
+
+#[test]
+fn test_octal() {
+    let a = BigInt::from(BaseBigInt::parse_bytes(b"A", 16).unwrap());
+    let hello = BigInt::from(
+        BaseBigInt::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap(),
+    );
+
+    assert_eq!(format!("{:o}", a), "12");
+    assert_eq!(format!("{:o}", hello), "22062554330674403566756233062041");
+    assert_eq!(format!("{:♥>+#8o}", a), "♥♥♥+0o12");
+}
+
+#[test]
+fn test_display() {
+    let a = BigInt::from(BaseBigInt::parse_bytes(b"A", 16).unwrap());
+    let hello = BigInt::from(
+        BaseBigInt::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap(),
+    );
+
+    assert_eq!(format!("{}", a), "10");
+    assert_eq!(format!("{}", hello), "22405534230753963835153736737");
+    assert_eq!(format!("{:♥>+#8}", a), "♥♥♥♥♥+10");
+}

math/bigint/tests/ubig_test.rs

@@ -0,0 +1,62 @@
+use ferret_bigint::{BaseUBigInt, UBigInt};
+
+#[test]
+fn test_lower_hex() {
+    let a = UBigInt::from(BaseUBigInt::parse_bytes(b"A", 16).unwrap());
+    let hello = UBigInt::from(
+        BaseUBigInt::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap(),
+    );
+
+    assert_eq!(format!("{:x}", a), "a");
+    assert_eq!(format!("{:x}", hello), "48656c6c6f20776f726c6421");
+    assert_eq!(format!("{:♥>+#8x}", a), "♥♥♥♥+0xa");
+}
+
+#[test]
+fn test_upper_hex() {
+    let a = UBigInt::from(BaseUBigInt::parse_bytes(b"A", 16).unwrap());
+    let hello = UBigInt::from(
+        BaseUBigInt::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap(),
+    );
+
+    assert_eq!(format!("{:X}", a), "A");
+    assert_eq!(format!("{:X}", hello), "48656C6C6F20776F726C6421");
+    assert_eq!(format!("{:♥>+#8X}", a), "♥♥♥♥+0xA");
+}
+
+#[test]
+fn test_binary() {
+    let a = UBigInt::from(BaseUBigInt::parse_bytes(b"A", 16).unwrap());
+    let hello = UBigInt::from(BaseUBigInt::parse_bytes("224055342307539".as_bytes(), 10).unwrap());
+
+    assert_eq!(format!("{:b}", a), "1010");
+    assert_eq!(
+        format!("{:b}", hello),
+        "110010111100011011110011000101101001100011010011"
+    );
+    assert_eq!(format!("{:♥>+#8b}", a), "♥+0b1010");
+}
+
+#[test]
+fn test_octal() {
+    let a = UBigInt::from(BaseUBigInt::parse_bytes(b"A", 16).unwrap());
+    let hello = UBigInt::from(
+        BaseUBigInt::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap(),
+    );
+
+    assert_eq!(format!("{:o}", a), "12");
+    assert_eq!(format!("{:o}", hello), "22062554330674403566756233062041");
+    assert_eq!(format!("{:♥>+#8o}", a), "♥♥♥+0o12");
+}
+
+#[test]
+fn test_display() {
+    let a = UBigInt::from(BaseUBigInt::parse_bytes(b"A", 16).unwrap());
+    let hello = UBigInt::from(
+        BaseUBigInt::parse_bytes("22405534230753963835153736737".as_bytes(), 10).unwrap(),
+    );
+
+    assert_eq!(format!("{}", a), "10");
+    assert_eq!(format!("{}", hello), "22405534230753963835153736737");
+    assert_eq!(format!("{:♥>+#8}", a), "♥♥♥♥♥+10");
+}

vm/Cargo.toml

@@ -5,6 +5,6 @@ authors = ["ChainSafe Systems <info@chainsafe.io>"]
 edition = "2018"
 
 [dependencies]
-num-bigint = "0.2.3"
+ferret_bigint = {path = "../math/bigint"}
 address = {path = "./address"}
 encoding = {path = "../encoding"}

vm/actor/Cargo.toml

@@ -9,7 +9,7 @@ vm = {path = "../../vm"}
 address = {path = "../address"}
 runtime = {path = "../runtime"}
 cid = "0.3.1"
-num-bigint = "0.2.3"
+ferret_bigint = {path = "../../math/bigint"}
 encoding = {path = "../../encoding"}
 num-traits = "0.2"
 num-derive = "0.2"

vm/actor/src/lib.rs

@@ -6,7 +6,7 @@ pub use self::code::*;
 
 use cid::Cid;
 use encoding::{Cbor, CodecProtocol, Error as EncodingError};
-use num_bigint::BigUint;
+use ferret_bigint::UBigInt;
 
 #[derive(PartialEq, Eq, Copy, Clone, Debug, Default)]
 pub struct ActorID(u64);
@@ -33,13 +33,13 @@ impl Cbor for ActorID {
 pub struct ActorState {
     code_id: CodeID,
     state: Cid,
-    balance: BigUint,
+    balance: UBigInt,
     sequence: u64,
 }
 
 impl ActorState {
     /// Constructor for actor state
-    pub fn new(code_id: CodeID, state: Cid, balance: BigUint, sequence: u64) -> Self {
+    pub fn new(code_id: CodeID, state: Cid, balance: UBigInt, sequence: u64) -> Self {
         Self {
             code_id,
             state,

vm/message/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2018"
 [dependencies]
 vm = {path = "../../vm"}
 address = {path = "../address"}
-num-bigint = "0.2.3"
+ferret_bigint = {path = "../../math/bigint"}
 encoding = {path = "../../encoding"}
 crypto = {path = "../../crypto"}
 derive_builder = "0.9"

vm/message/src/lib.rs

@@ -7,7 +7,7 @@ pub use signed_message::*;
 pub use unsigned_message::*;
 
 use address::Address;
-use num_bigint::BigUint;
+use ferret_bigint::UBigInt;
 use vm::{MethodNum, MethodParams, TokenAmount};
 
 pub trait Message {
@@ -24,7 +24,7 @@ pub trait Message {
     /// params returns the encoded parameters for the method call
     fn params(&self) -> MethodParams;
     /// gas_price returns gas price for the message
-    fn gas_price(&self) -> BigUint;
+    fn gas_price(&self) -> UBigInt;
     /// gas_limit returns the gas limit for the message
-    fn gas_limit(&self) -> BigUint;
+    fn gas_limit(&self) -> UBigInt;
 }

vm/message/src/message_receipt.rs

@@ -1,4 +1,4 @@
-use num_bigint::BigUint;
+use ferret_bigint::UBigInt;
 use vm::ExitCode;
 
 /// MessageReceipt is the result of a state transition from a message
@@ -7,5 +7,5 @@ pub struct MessageReceipt {
     // TODO: determine if this is necessary, code returned from cbor
     pub exit_code: ExitCode,
     pub return_data: Vec<u8>,
-    pub gas_used: BigUint,
+    pub gas_used: UBigInt,
 }

vm/message/src/signed_message.rs

@@ -4,7 +4,7 @@ use vm::{MethodNum, MethodParams, TokenAmount};
 use address::Address;
 use crypto::{Error as CryptoError, Signature, Signer};
 use encoding::{Cbor, CodecProtocol, Error as EncodingError};
-use num_bigint::BigUint;
+use ferret_bigint::UBigInt;
 
 /// SignedMessage represents a wrapped message with signature bytes
 #[derive(PartialEq, Clone, Debug)]
@@ -58,11 +58,11 @@ impl Message for SignedMessage {
         self.message.params()
     }
     /// gas_price returns gas price for the message
-    fn gas_price(&self) -> BigUint {
+    fn gas_price(&self) -> UBigInt {
         self.message.gas_price()
     }
     /// gas_limit returns the gas limit for the message
-    fn gas_limit(&self) -> BigUint {
+    fn gas_limit(&self) -> UBigInt {
         self.message.gas_limit()
     }
 }