Let Int256::new take an i128 argument

Author: webmaster128

CHANGELOG.md

@@ -41,6 +41,8 @@ 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` now takes an `i128` argument instead of bytes. Use
+  `Int256::from_be_bytes` if you need the old behaviour.
 
 ## Fixed
 

packages/std/src/math/int256.rs

@@ -29,19 +29,21 @@ use super::num_consts::NumConsts;
 ///
 /// # Examples
 ///
-/// Use `from` to create instances out of primitive uint types or `new` to provide big
-/// endian bytes:
+/// Use `new` to create instances out of i128, `from` for other primitive uint/int types
+/// or `from_be_bytes` to provide big endian bytes:
 ///
 /// ```
 /// # use cosmwasm_std::Int256;
-/// let a = Int256::from(258u128);
-/// let b = Int256::new([
+/// let a = Int256::new(258i128);
+/// let b = Int256::from(258u16);
+/// let c = Int256::from_be_bytes([
 ///     0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
 ///     0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
 ///     0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
 ///     0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8, 2u8,
 /// ]);
 /// assert_eq!(a, b);
+/// assert_eq!(a, c);
 /// ```
 #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, schemars::JsonSchema)]
 pub struct Int256(#[schemars(with = "String")] pub(crate) I256);
@@ -53,11 +55,30 @@ impl Int256 {
     pub const MAX: Int256 = Int256(I256::MAX);
     pub const MIN: Int256 = Int256(I256::MIN);
 
-    /// Creates a Int256(value) from a big endian representation. It's just an alias for
-    /// `from_be_bytes`.
+    /// Creates a Int256(value).
+    ///
+    /// This method is less flexible than `from` but can be called in a const context.
+    ///
+    /// Before CosmWasm 3 this took a byte array as an argument. You can get this behaviour
+    /// with [`from_be_bytes`].
+    ///
+    /// [`from_be_bytes`]: Self::from_be_bytes
     #[inline]
-    pub const fn new(value: [u8; 32]) -> Self {
-        Self::from_be_bytes(value)
+    pub const fn new(value: i128) -> Self {
+        // See https://en.wikipedia.org/wiki/Sign_extension
+        let b = value.to_be_bytes();
+        if value.is_negative() {
+            Self::from_be_bytes([
+                0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+                0xFF, 0xFF, b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8], b[9], b[10],
+                b[11], b[12], b[13], b[14], b[15],
+            ])
+        } else {
+            Self::from_be_bytes([
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, b[0], b[1], b[2], b[3], b[4], b[5],
+                b[6], b[7], b[8], b[9], b[10], b[11], b[12], b[13], b[14], b[15],
+            ])
+        }
     }
 
     /// Creates a Int256(0)
@@ -588,22 +609,49 @@ mod tests {
 
     #[test]
     fn int256_new_works() {
-        let num = Int256::new([1; 32]);
+        let num = Int256::new(1);
+        assert_eq!(
+            num.to_be_bytes(),
+            [
+                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                0, 0, 0, 1
+            ]
+        );
+
+        let num = Int256::new(-1);
+        assert_eq!(
+            num.to_be_bytes(),
+            [
+                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+                255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+            ]
+        );
+
+        for v in [0, 1, -4, 18, 875786576, -11763498739, i128::MAX, i128::MIN] {
+            // From is implemented by bnum, so we test two independent implementations against each other
+            let uut = Int256::new(v);
+            assert_eq!(uut, Int256::from(v));
+        }
+    }
+
+    #[test]
+    fn int256_from_be_bytes_works() {
+        let num = Int256::from_be_bytes([1; 32]);
         let a: [u8; 32] = num.to_be_bytes();
         assert_eq!(a, [1; 32]);
 
         let be_bytes = [
             0u8, 222u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
             0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 1u8, 2u8, 3u8,
         ];
-        let num = Int256::new(be_bytes);
+        let num = Int256::from_be_bytes(be_bytes);
         let resulting_bytes: [u8; 32] = num.to_be_bytes();
         assert_eq!(be_bytes, resulting_bytes);
     }
 
     #[test]
     fn int256_not_works() {
-        let num = Int256::new([1; 32]);
+        let num = Int256::from_be_bytes([1; 32]);
         let a = (!num).to_be_bytes();
         assert_eq!(a, [254; 32]);
 
@@ -640,12 +688,10 @@ mod tests {
         ];
 
         // These should all be the same.
-        let num1 = Int256::new(be_bytes);
-        let num2 = Int256::from_be_bytes(be_bytes);
-        let num3 = Int256::from_le_bytes(le_bytes);
-        assert_eq!(num1, Int256::from(65536u32 + 512 + 3));
-        assert_eq!(num1, num2);
-        assert_eq!(num1, num3);
+        let a = Int256::from_be_bytes(be_bytes);
+        let b = Int256::from_le_bytes(le_bytes);
+        assert_eq!(a, Int256::from(65536u32 + 512 + 3));
+        assert_eq!(a, b);
     }
 
     #[test]
@@ -1059,12 +1105,12 @@ mod tests {
 
     #[test]
     fn int256_shr_works() {
-        let original = Int256::new([
+        let original = Int256::from_be_bytes([
             0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
             0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 2u8, 0u8, 4u8, 2u8,
         ]);
 
-        let shifted = Int256::new([
+        let shifted = Int256::from_be_bytes([
             0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
             0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 128u8, 1u8, 0u8,
         ]);