Deprecate {Decimal,Decimal256,SignedDecimal,SignedDecimal256}::raw

Author: webmaster128

CHANGELOG.md

@@ -46,6 +46,9 @@ and this project adheres to
 - 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])
 
 ## Fixed
 
@@ -68,6 +71,7 @@ and this project adheres to
 [#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

@@ -59,6 +59,10 @@ impl Decimal {
 
     /// 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))
     }
@@ -805,6 +809,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn decimal_raw() {
         let value = 300u128;
         assert_eq!(Decimal::raw(value).0.u128(), value);
@@ -867,7 +872,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

@@ -64,6 +64,10 @@ impl Decimal256 {
 
     /// 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))
     }
@@ -808,6 +812,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn decimal256_raw() {
         let value = 300u128;
         let expected = Uint256::from(value);

packages/std/src/math/signed_decimal.rs

@@ -86,6 +86,10 @@ impl SignedDecimal {
     /// # use cosmwasm_std::SignedDecimal;
     /// assert_eq!(SignedDecimal::raw(1234i128).to_string(), "0.000000000000001234");
     /// ```
+    #[deprecated(
+        since = "3.0.0",
+        note = "Use SignedDecimal::new(Int128::new(value)) instead"
+    )]
     pub const fn raw(value: i128) -> Self {
         Self(Int128::new(value))
     }
@@ -910,6 +914,8 @@ impl de::Visitor<'_> for SignedDecimalVisitor {
 
 #[cfg(test)]
 mod tests {
+    use crate::Uint128;
+
     use super::*;
 
     use alloc::vec::Vec;
@@ -928,6 +934,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn signed_decimal_raw() {
         let value = 300i128;
         assert_eq!(SignedDecimal::raw(value).0.i128(), value);
@@ -1461,8 +1468,8 @@ mod tests {
             SignedDecimal::try_from(Decimal::MAX).unwrap_err(),
             SignedDecimalRangeExceeded
         );
-        let max = Decimal::raw(SignedDecimal::MAX.atomics().i128() as u128);
-        let too_big = max + Decimal::raw(1);
+        let max = Decimal::new(Uint128::new(SignedDecimal::MAX.atomics().i128() as u128));
+        let too_big = max + Decimal::new(Uint128::one());
         assert_eq!(
             SignedDecimal::try_from(too_big).unwrap_err(),
             SignedDecimalRangeExceeded

packages/std/src/math/signed_decimal_256.rs

@@ -98,6 +98,10 @@ impl SignedDecimal256 {
     /// # use cosmwasm_std::SignedDecimal256;
     /// assert_eq!(SignedDecimal256::raw(1234i128).to_string(), "0.000000000000001234");
     /// ```
+    #[deprecated(
+        since = "3.0.0",
+        note = "Use SignedDecimal256::new(Int256::new(value)) instead"
+    )]
     pub const fn raw(value: i128) -> Self {
         Self(Int256::from_i128(value))
     }
@@ -936,6 +940,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn signed_decimal_256_raw() {
         let value = 300i128;
         assert_eq!(SignedDecimal256::raw(value).0, Int256::from(value));