Uint256 implementation

CHANGELOG.md

@@ -8,7 +8,11 @@ and this project adheres to
 
 ### Added
 
-- Added `From<Addr>` and `From<&Addr>` conversions for `Cow<Addr>`.
+- cosmwasm-std: Added `From<Addr>` and `From<&Addr>` conversions for
+  `Cow<Addr>`.
+- cosmwasm-std: Added a new `Uint256` type.
+- cosmwasm-std: Added implementations of `Isqrt` (integer square root) for
+  `Uint64`, `Uint128`, and `Uint256`.
 
 ## [0.16.0] - 2021-08-05
 

packages/std/src/errors/mod.rs

@@ -4,6 +4,9 @@ mod system_error;
 mod verification_error;
 
 pub use recover_pubkey_error::RecoverPubkeyError;
-pub use std_error::{DivideByZeroError, OverflowError, OverflowOperation, StdError, StdResult};
+pub use std_error::{
+    ConversionOverflowError, DivideByZeroError, OverflowError, OverflowOperation, StdError,
+    StdResult,
+};
 pub use system_error::SystemError;
 pub use verification_error::VerificationError;

packages/std/src/errors/std_error.rs

@@ -95,6 +95,13 @@ pub enum StdError {
         #[cfg(feature = "backtraces")]
         backtrace: Backtrace,
     },
+    #[error("Conversion error: ")]
+    ConversionOverflow {
+        #[from]
+        source: ConversionOverflowError,
+        #[cfg(feature = "backtraces")]
+        backtrace: Backtrace,
+    },
 }
 
 impl StdError {
@@ -376,6 +383,22 @@ impl PartialEq<StdError> for StdError {
                     false
                 }
             }
+            StdError::ConversionOverflow {
+                source,
+                #[cfg(feature = "backtraces")]
+                    backtrace: _,
+            } => {
+                if let StdError::ConversionOverflow {
+                    source: rhs_source,
+                    #[cfg(feature = "backtraces")]
+                        backtrace: _,
+                } = rhs
+                {
+                    source == rhs_source
+                } else {
+                    false
+                }
+            }
         }
     }
 }
@@ -455,6 +478,28 @@ impl OverflowError {
     }
 }
 
+#[derive(Error, Debug, PartialEq, Eq)]
+#[error("Error converting {source_type} to {target_type} for {value}")]
+pub struct ConversionOverflowError {
+    pub source_type: &'static str,
+    pub target_type: &'static str,
+    pub value: String,
+}
+
+impl ConversionOverflowError {
+    pub fn new(
+        source_type: &'static str,
+        target_type: &'static str,
+        value: impl Into<String>,
+    ) -> Self {
+        Self {
+            source_type,
+            target_type,
+            value: value.into(),
+        }
+    }
+}
+
 #[derive(Error, Debug, PartialEq, Eq)]
 #[error("Cannot devide {operand} by zero")]
 pub struct DivideByZeroError {

packages/std/src/lib.rs

@@ -41,7 +41,7 @@ pub use crate::ibc::{
 #[cfg(feature = "iterator")]
 #[allow(deprecated)]
 pub use crate::iterator::{Order, Pair, KV};
-pub use crate::math::{Decimal, Fraction, Uint128, Uint64};
+pub use crate::math::{Decimal, Fraction, Uint128, Uint256, Uint64};
 pub use crate::query::{
     AllBalanceResponse, BalanceResponse, BankQuery, CustomQuery, QueryRequest, WasmQuery,
 };

packages/std/src/math/isqrt.rs

@@ -1,5 +1,7 @@
 use std::{cmp, ops};
 
+use crate::{Uint128, Uint256, Uint64};
+
 /// A trait for calculating the
 /// [integer square root](https://en.wikipedia.org/wiki/Integer_square_root).
 pub trait Isqrt {
@@ -12,7 +14,7 @@ where
     I: Unsigned
         + ops::Add<I, Output = I>
         + ops::Div<I, Output = I>
-        + ops::Shr<u8, Output = I>
+        + ops::Shr<u32, Output = I>
         + cmp::PartialOrd
         + Copy
         + From<u8>,
@@ -43,14 +45,19 @@ impl Unsigned for u16 {}
 impl Unsigned for u32 {}
 impl Unsigned for u64 {}
 impl Unsigned for u128 {}
+impl Unsigned for Uint64 {}
+impl Unsigned for Uint128 {}
+impl Unsigned for Uint256 {}
 impl Unsigned for usize {}
 
 #[cfg(test)]
 mod tests {
+    use std::convert::TryFrom;
+
     use super::*;
 
     #[test]
-    fn isqrts() {
+    fn isqrt_primitives() {
         // Let's check correctness.
         assert_eq!(0u8.isqrt(), 0);
         assert_eq!(1u8.isqrt(), 1);
@@ -66,4 +73,23 @@ mod tests {
         assert_eq!(26u64.isqrt(), 5);
         assert_eq!(26u128.isqrt(), 5);
     }
+
+    #[test]
+    fn isqrt_uint64() {
+        assert_eq!(Uint64::new(24).isqrt(), Uint64::new(4));
+    }
+
+    #[test]
+    fn isqrt_uint128() {
+        assert_eq!(Uint128::new(24).isqrt(), Uint128::new(4));
+    }
+
+    #[test]
+    fn isqrt_uint256() {
+        assert_eq!(Uint256::from(24u32).isqrt(), Uint256::from(4u32));
+        assert_eq!(
+            (Uint256::from(u128::MAX) * Uint256::from(u128::MAX)).isqrt(),
+            Uint256::try_from("340282366920938463463374607431768211455").unwrap()
+        );
+    }
 }

packages/std/src/math/mod.rs

@@ -2,10 +2,12 @@ mod decimal;
 mod fraction;
 mod isqrt;
 mod uint128;
+mod uint256;
 mod uint64;
 
 pub use decimal::Decimal;
 pub use fraction::Fraction;
 pub use isqrt::Isqrt;
 pub use uint128::Uint128;
+pub use uint256::Uint256;
 pub use uint64::Uint64;

packages/std/src/math/uint128.rs

@@ -6,6 +6,7 @@ use std::iter::Sum;
 use std::ops;
 
 use crate::errors::{DivideByZeroError, OverflowError, OverflowOperation, StdError};
+use crate::Uint256;
 
 /// A thin wrapper around u128 that is using strings for JSON encoding/decoding,
 /// such that the full u128 range can be used for clients that convert JSON numbers to floats,
@@ -222,6 +223,38 @@ impl<'a> ops::Sub<&'a Uint128> for Uint128 {
     }
 }
 
+impl ops::Div<Uint128> for Uint128 {
+    type Output = Self;
+
+    fn div(self, rhs: Self) -> Self::Output {
+        Self(self.u128().checked_div(rhs.u128()).unwrap())
+    }
+}
+
+impl<'a> ops::Div<&'a Uint128> for Uint128 {
+    type Output = Self;
+
+    fn div(self, rhs: &'a Uint128) -> Self::Output {
+        Self(self.u128().checked_div(rhs.u128()).unwrap())
+    }
+}
+
+impl ops::Shr<u32> for Uint128 {
+    type Output = Self;
+
+    fn shr(self, rhs: u32) -> Self::Output {
+        Self(self.u128().checked_shr(rhs).unwrap())
+    }
+}
+
+impl<'a> ops::Shr<&'a u32> for Uint128 {
+    type Output = Self;
+
+    fn shr(self, rhs: &'a u32) -> Self::Output {
+        Self(self.u128().checked_shr(*rhs).unwrap())
+    }
+}
+
 impl ops::AddAssign<Uint128> for Uint128 {
     fn add_assign(&mut self, rhs: Uint128) {
         self.0 = self.0.checked_add(rhs.u128()).unwrap();
@@ -246,6 +279,30 @@ impl<'a> ops::SubAssign<&'a Uint128> for Uint128 {
     }
 }
 
+impl ops::DivAssign<Uint128> for Uint128 {
+    fn div_assign(&mut self, rhs: Self) {
+        self.0 = self.0.checked_div(rhs.u128()).unwrap();
+    }
+}
+
+impl<'a> ops::DivAssign<&'a Uint128> for Uint128 {
+    fn div_assign(&mut self, rhs: &'a Uint128) {
+        self.0 = self.0.checked_div(rhs.u128()).unwrap();
+    }
+}
+
+impl ops::ShrAssign<u32> for Uint128 {
+    fn shr_assign(&mut self, rhs: u32) {
+        self.0 = self.0.checked_shr(rhs).unwrap();
+    }
+}
+
+impl<'a> ops::ShrAssign<&'a u32> for Uint128 {
+    fn shr_assign(&mut self, rhs: &'a u32) {
+        self.0 = self.0.checked_shr(*rhs).unwrap();
+    }
+}
+
 impl Uint128 {
     /// Returns `self * numerator / denominator`
     pub fn multiply_ratio<A: Into<u128>, B: Into<u128>>(
@@ -258,15 +315,16 @@ impl Uint128 {
         if denominator == 0 {
             panic!("Denominator must not be zero");
         }
-        let val: u128 = (self.full_mul(numerator) / denominator)
+        (self.full_mul(numerator) / Uint256::from(denominator))
             .try_into()
-            .expect("multiplication overflow");
-        Uint128::from(val)
+            .expect("multiplication overflow")
     }
 
     /// Multiplies two u128 values without overflow.
-    fn full_mul(self, rhs: impl Into<u128>) -> U256 {
-        U256::from(self.u128()) * U256::from(rhs.into())
+    pub fn full_mul(self, rhs: impl Into<u128>) -> Uint256 {
+        Uint256::from(self.u128())
+            .checked_mul(Uint256::from(rhs.into()))
+            .unwrap()
     }
 }
 
@@ -322,19 +380,6 @@ impl<'a> Sum<&'a Uint128> for Uint128 {
     }
 }
 
-/// This module is purely a workaround that lets us ignore lints for all the code
-/// the `construct_uint!` macro generates.
-#[allow(clippy::all)]
-mod uints {
-    uint::construct_uint! {
-        pub struct U256(4);
-    }
-}
-
-/// Only used internally - namely to store the intermediate result of
-/// multiplying two 128-bit uints.
-use uints::U256;
-
 #[cfg(test)]
 mod tests {
     use super::*;