Make Uint128 inner field private

Author: uint

CHANGELOG.md

@@ -6,6 +6,11 @@ and this project adheres to
 
 ## [Unreleased]
 
+### Removed
+- cosmwasm-std: Make `Uint128` inner field private ([#905])
+
+[#905]: https://github.com/CosmWasm/cosmwasm/issues/905
+
 ## [0.14.1] - 2021-06-14
 
 ### Added
@@ -19,8 +24,8 @@ and this project adheres to
 
 ### Fixed
 
-- cosmwasm-std: Fix `Uint64::multiply_ratio` and `Uint128::multiply_ratio` so
-  that internal multiplication cannot cause an unnecessary overflow. ([#920])
+- cosmwasm-std: Fix `Uint64::multiply_ratio` and `Uint128::multiply_ratio`
+  so that internal multiplication cannot cause an unnecessary overflow. ([#920])
 
 [#920]: https://github.com/CosmWasm/cosmwasm/issues/920
 

packages/std/src/coins.rs

@@ -13,7 +13,7 @@ pub struct Coin {
 impl Coin {
     pub fn new<S: Into<String>>(amount: u128, denom: S) -> Self {
         Coin {
-            amount: Uint128(amount),
+            amount: Uint128::new(amount),
             denom: denom.into(),
         }
     }
@@ -90,7 +90,7 @@ mod tests {
     #[test]
     fn coin_implements_display() {
         let a = Coin {
-            amount: Uint128(123),
+            amount: Uint128::new(123),
             denom: "ucosm".to_string(),
         };
 
@@ -105,7 +105,7 @@ mod tests {
         assert_eq!(
             a,
             Coin {
-                amount: Uint128(123),
+                amount: Uint128::new(123),
                 denom: "ucosm".to_string()
             }
         );
@@ -114,7 +114,7 @@ mod tests {
         assert_eq!(
             zero,
             Coin {
-                amount: Uint128(0),
+                amount: Uint128::new(0),
                 denom: "ucosm".to_string()
             }
         );
@@ -123,7 +123,7 @@ mod tests {
         assert_eq!(
             string_denom,
             Coin {
-                amount: Uint128(42),
+                amount: Uint128::new(42),
                 denom: "ucosm".to_string()
             }
         );
@@ -135,7 +135,7 @@ mod tests {
         assert_eq!(
             a,
             vec![Coin {
-                amount: Uint128(123),
+                amount: Uint128::new(123),
                 denom: "ucosm".to_string()
             }]
         );
@@ -144,7 +144,7 @@ mod tests {
         assert_eq!(
             zero,
             vec![Coin {
-                amount: Uint128(0),
+                amount: Uint128::new(0),
                 denom: "ucosm".to_string()
             }]
         );
@@ -153,7 +153,7 @@ mod tests {
         assert_eq!(
             string_denom,
             vec![Coin {
-                amount: Uint128(42),
+                amount: Uint128::new(42),
                 denom: "ucosm".to_string()
             }]
         );

packages/std/src/math/decimal.rs

@@ -560,71 +560,71 @@ mod tests {
     // in this test the Decimal is on the right
     fn uint128_decimal_multiply() {
         // a*b
-        let left = Uint128(300);
+        let left = Uint128::new(300);
         let right = Decimal::one() + Decimal::percent(50); // 1.5
-        assert_eq!(left * right, Uint128(450));
+        assert_eq!(left * right, Uint128::new(450));
 
         // a*0
-        let left = Uint128(300);
+        let left = Uint128::new(300);
         let right = Decimal::zero();
-        assert_eq!(left * right, Uint128(0));
+        assert_eq!(left * right, Uint128::new(0));
 
         // 0*a
-        let left = Uint128(0);
+        let left = Uint128::new(0);
         let right = Decimal::one() + Decimal::percent(50); // 1.5
-        assert_eq!(left * right, Uint128(0));
+        assert_eq!(left * right, Uint128::new(0));
     }
 
     #[test]
     // in this test the Decimal is on the left
     fn decimal_uint128_multiply() {
         // a*b
         let left = Decimal::one() + Decimal::percent(50); // 1.5
-        let right = Uint128(300);
-        assert_eq!(left * right, Uint128(450));
+        let right = Uint128::new(300);
+        assert_eq!(left * right, Uint128::new(450));
 
         // 0*a
         let left = Decimal::zero();
-        let right = Uint128(300);
-        assert_eq!(left * right, Uint128(0));
+        let right = Uint128::new(300);
+        assert_eq!(left * right, Uint128::new(0));
 
         // a*0
         let left = Decimal::one() + Decimal::percent(50); // 1.5
-        let right = Uint128(0);
-        assert_eq!(left * right, Uint128(0));
+        let right = Uint128::new(0);
+        assert_eq!(left * right, Uint128::new(0));
     }
 
     #[test]
     fn decimal_uint128_division() {
         // a/b
         let left = Decimal::percent(150); // 1.5
-        let right = Uint128(3);
+        let right = Uint128::new(3);
         assert_eq!(left / right, Decimal::percent(50));
 
         // 0/a
         let left = Decimal::zero();
-        let right = Uint128(300);
+        let right = Uint128::new(300);
         assert_eq!(left / right, Decimal::zero());
     }
 
     #[test]
     #[should_panic(expected = "attempt to divide by zero")]
     fn decimal_uint128_divide_by_zero() {
         let left = Decimal::percent(150); // 1.5
-        let right = Uint128(0);
+        let right = Uint128::new(0);
         let _result = left / right;
     }
 
     #[test]
     fn decimal_uint128_div_assign() {
         // a/b
         let mut dec = Decimal::percent(150); // 1.5
-        dec /= Uint128(3);
+        dec /= Uint128::new(3);
         assert_eq!(dec, Decimal::percent(50));
 
         // 0/a
         let mut dec = Decimal::zero();
-        dec /= Uint128(300);
+        dec /= Uint128::new(300);
         assert_eq!(dec, Decimal::zero());
     }
 
@@ -633,7 +633,7 @@ mod tests {
     fn decimal_uint128_div_assign_by_zero() {
         // a/0
         let mut dec = Decimal::percent(50);
-        dec /= Uint128(0);
+        dec /= Uint128::new(0);
     }
 
     #[test]

packages/std/src/math/uint128.rs

@@ -27,9 +27,7 @@ use crate::errors::{DivideByZeroError, OverflowError, OverflowOperation, StdErro
 /// assert_eq!(c.u128(), 70);
 /// ```
 #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, JsonSchema)]
-pub struct Uint128(
-    #[schemars(with = "String")] pub u128, // Simon thinks this should be private, but does not want to worry about breaking code right now
-);
+pub struct Uint128(#[schemars(with = "String")] u128);
 
 impl Uint128 {
     /// Creates a Uint128(value).

packages/std/src/results/attribute.rs

@@ -31,7 +31,7 @@ mod tests {
         assert_eq!(attr("foo", "42"), expeceted);
         assert_eq!(attr("foo".to_string(), "42"), expeceted);
         assert_eq!(attr("foo", "42".to_string()), expeceted);
-        assert_eq!(attr("foo", Uint128(42)), expeceted);
+        assert_eq!(attr("foo", Uint128::new(42)), expeceted);
         assert_eq!(attr("foo", 42), expeceted);
     }
 }

packages/std/src/traits.rs

@@ -354,6 +354,6 @@ mod tests {
             .unwrap()
             .unwrap();
         let balance: BalanceResponse = from_slice(&raw).unwrap();
-        assert_eq!(balance.amount.amount, Uint128(5));
+        assert_eq!(balance.amount.amount, Uint128::new(5));
     }
 }