Merge pull request #2399 from CosmWasm/new-argument

Change {Int256,Int512,Uint256,Uint512}::new argument from bytes to i128/u128

Author: chipshort

CHANGELOG.md

@@ -41,6 +41,16 @@ and this project adheres to
   makes the use of `schemars` optional for contracts. ([#2201])
 - cosmwasm-std: Remove `schemars::JsonSchema` requirement from `CustomMsg`.
   ([#2201])
+- cosmwasm-std: `Int256::new`/`Int512::new` now take an `i128` argument instead
+  of bytes. Use `::from_be_bytes` if you need the old behaviour. ([#2367])
+- cosmwasm-std: `Uint256::new`/`Uint512::new` now take an `u128` argument
+  instead of bytes. Use `::from_be_bytes` if you need the old behaviour.
+  ([#2367])
+- cosmwasm-std: Deprecate `{Decimal,Decimal256}::raw` and
+  `{SignedDecimal,SignedDecimal256}::raw` in favour of e.g.
+  `Decimal::new(Uint128::new(value))`. ([#2399])
+- cosmwasm-std: Deprecate `Uint256::from_u128` and `Int256::from_i128` in favour
+  of `::new`. ([#2399])
 
 ## Fixed
 
@@ -58,10 +68,12 @@ and this project adheres to
 [#2337]: https://github.com/CosmWasm/cosmwasm/issues/2337
 [#2340]: https://github.com/CosmWasm/cosmwasm/pull/2340
 [#2344]: https://github.com/CosmWasm/cosmwasm/pull/2344
+[#2367]: https://github.com/CosmWasm/cosmwasm/issues/2367
 [#2374]: https://github.com/CosmWasm/cosmwasm/issues/2374
 [#2378]: https://github.com/CosmWasm/cosmwasm/issues/2378
 [#2383]: https://github.com/CosmWasm/cosmwasm/issues/2383
 [#2390]: https://github.com/CosmWasm/cosmwasm/issues/2390
+[#2399]: https://github.com/CosmWasm/cosmwasm/pull/2399
 
 ## [2.2.0] - 2024-12-17
 

packages/std/src/math/decimal.rs

@@ -43,12 +43,27 @@ impl Decimal {
 
     /// Creates a Decimal(value)
     /// This is equivalent to `Decimal::from_atomics(value, 18)` but usable in a const context.
+    ///
+    /// ## Examples
+    ///
+    /// ```
+    /// # use cosmwasm_std::{Uint128, Decimal};
+    /// let atoms = Uint128::new(141_183_460_469_231_731_687_303_715_884_105_727_125);
+    /// let value = Decimal::new(atoms);
+    /// assert_eq!(value.to_string(), "141183460469231731687.303715884105727125");
+    /// ```
+    #[inline]
+    #[must_use]
     pub const fn new(value: Uint128) -> Self {
         Self(value)
     }
 
     /// Creates a Decimal(Uint128(value))
     /// This is equivalent to `Decimal::from_atomics(value, 18)` but usable in a const context.
+    #[deprecated(
+        since = "3.0.0",
+        note = "Use Decimal::new(Uint128::new(value)) instead"
+    )]
     pub const fn raw(value: u128) -> Self {
         Self(Uint128::new(value))
     }
@@ -795,6 +810,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn decimal_raw() {
         let value = 300u128;
         assert_eq!(Decimal::raw(value).0.u128(), value);
@@ -857,7 +873,7 @@ mod tests {
     fn decimal_try_from_signed_works() {
         assert_eq!(
             Decimal::try_from(SignedDecimal::MAX).unwrap(),
-            Decimal::raw(SignedDecimal::MAX.atomics().i128() as u128)
+            Decimal::new(Uint128::new(SignedDecimal::MAX.atomics().i128() as u128))
         );
         assert_eq!(
             Decimal::try_from(SignedDecimal::zero()).unwrap(),

packages/std/src/math/decimal256.rs

@@ -34,9 +34,9 @@ pub struct Decimal256RangeExceeded;
 
 impl Decimal256 {
     const DECIMAL_FRACTIONAL: Uint256 = // 1*10**18
-        Uint256::from_u128(1_000_000_000_000_000_000);
+        Uint256::new(1_000_000_000_000_000_000);
     const DECIMAL_FRACTIONAL_SQUARED: Uint256 = // 1*10**36
-        Uint256::from_u128(1_000_000_000_000_000_000_000_000_000_000_000_000);
+        Uint256::new(1_000_000_000_000_000_000_000_000_000_000_000_000);
 
     /// The number of decimal places. Since decimal types are fixed-point rather than
     /// floating-point, this is a constant.
@@ -48,14 +48,29 @@ impl Decimal256 {
 
     /// Creates a Decimal256 from Uint256
     /// This is equivalent to `Decimal256::from_atomics(value, 18)` but usable in a const context.
+    ///
+    /// ## Examples
+    ///
+    /// ```
+    /// # use cosmwasm_std::{Uint256, Decimal256};
+    /// let atoms = Uint256::new(141_183_460_469_231_731_687_303_715_884_105_727_125);
+    /// let value = Decimal256::new(atoms);
+    /// assert_eq!(value.to_string(), "141183460469231731687.303715884105727125");
+    /// ```
+    #[inline]
+    #[must_use]
     pub const fn new(value: Uint256) -> Self {
         Self(value)
     }
 
     /// Creates a Decimal256 from u128
     /// This is equivalent to `Decimal256::from_atomics(value, 18)` but usable in a const context.
+    #[deprecated(
+        since = "3.0.0",
+        note = "Use Decimal256::new(Uint256::new(value)) instead"
+    )]
     pub const fn raw(value: u128) -> Self {
-        Self(Uint256::from_u128(value))
+        Self(Uint256::new(value))
     }
 
     /// Create a 1.0 Decimal256
@@ -84,7 +99,7 @@ impl Decimal256 {
     pub const fn percent(x: u64) -> Self {
         // multiplication does not overflow since `u64::MAX` * 10**16 is well in u128 range
         let atomics = (x as u128) * 10_000_000_000_000_000;
-        Self(Uint256::from_u128(atomics))
+        Self(Uint256::new(atomics))
     }
 
     /// Convert permille (x/1000) into Decimal256
@@ -101,7 +116,7 @@ impl Decimal256 {
     pub const fn permille(x: u64) -> Self {
         // multiplication does not overflow since `u64::MAX` * 10**15 is well in u128 range
         let atomics = (x as u128) * 1_000_000_000_000_000;
-        Self(Uint256::from_u128(atomics))
+        Self(Uint256::new(atomics))
     }
 
     /// Convert basis points (x/10000) into Decimal256
@@ -120,7 +135,7 @@ impl Decimal256 {
     pub const fn bps(x: u64) -> Self {
         // multiplication does not overflow since `u64::MAX` * 10**14 is well in u128 range
         let atomics = (x as u128) * 100_000_000_000_000;
-        Self(Uint256::from_u128(atomics))
+        Self(Uint256::new(atomics))
     }
 
     /// Creates a decimal from a number of atomic units and the number
@@ -798,6 +813,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn decimal256_raw() {
         let value = 300u128;
         let expected = Uint256::from(value);
@@ -2218,18 +2234,18 @@ mod tests {
     #[test]
     fn decimal256_to_uint_floor_works() {
         let d = Decimal256::from_str("12.000000000000000001").unwrap();
-        assert_eq!(d.to_uint_floor(), Uint256::from_u128(12));
+        assert_eq!(d.to_uint_floor(), Uint256::new(12));
         let d = Decimal256::from_str("12.345").unwrap();
-        assert_eq!(d.to_uint_floor(), Uint256::from_u128(12));
+        assert_eq!(d.to_uint_floor(), Uint256::new(12));
         let d = Decimal256::from_str("12.999").unwrap();
-        assert_eq!(d.to_uint_floor(), Uint256::from_u128(12));
+        assert_eq!(d.to_uint_floor(), Uint256::new(12));
         let d = Decimal256::from_str("0.98451384").unwrap();
-        assert_eq!(d.to_uint_floor(), Uint256::from_u128(0));
+        assert_eq!(d.to_uint_floor(), Uint256::new(0));
 
         let d = Decimal256::from_str("75.0").unwrap();
-        assert_eq!(d.to_uint_floor(), Uint256::from_u128(75));
+        assert_eq!(d.to_uint_floor(), Uint256::new(75));
         let d = Decimal256::from_str("0.0").unwrap();
-        assert_eq!(d.to_uint_floor(), Uint256::from_u128(0));
+        assert_eq!(d.to_uint_floor(), Uint256::new(0));
 
         let d = Decimal256::MAX;
         assert_eq!(
@@ -2267,16 +2283,16 @@ mod tests {
     #[test]
     fn decimal256_to_uint_ceil_works() {
         let d = Decimal256::from_str("12.000000000000000001").unwrap();
-        assert_eq!(d.to_uint_ceil(), Uint256::from_u128(13));
+        assert_eq!(d.to_uint_ceil(), Uint256::new(13));
         let d = Decimal256::from_str("12.345").unwrap();
-        assert_eq!(d.to_uint_ceil(), Uint256::from_u128(13));
+        assert_eq!(d.to_uint_ceil(), Uint256::new(13));
         let d = Decimal256::from_str("12.999").unwrap();
-        assert_eq!(d.to_uint_ceil(), Uint256::from_u128(13));
+        assert_eq!(d.to_uint_ceil(), Uint256::new(13));
 
         let d = Decimal256::from_str("75.0").unwrap();
-        assert_eq!(d.to_uint_ceil(), Uint256::from_u128(75));
+        assert_eq!(d.to_uint_ceil(), Uint256::new(75));
         let d = Decimal256::from_str("0.0").unwrap();
-        assert_eq!(d.to_uint_ceil(), Uint256::from_u128(0));
+        assert_eq!(d.to_uint_ceil(), Uint256::new(0));
 
         let d = Decimal256::MAX;
         assert_eq!(

packages/std/src/math/int128.rs

@@ -47,6 +47,7 @@ impl Int128 {
     ///
     /// This method is less flexible than `from` but can be called in a const context.
     #[inline]
+    #[must_use]
     pub const fn new(value: i128) -> Self {
         Self(value)
     }