More Integer conversions

CHANGELOG.md

@@ -10,8 +10,13 @@ and this project adheres to
 
 - cosmwasm-std: Add `abs` and `unsigned_abs` for `Int{64,128,256,512}`
  ([#1854]).
+- cosmwasm-std: Add `From<Int{64,128,256}>` for `Int512`,
+ `TryFrom<Int{128,256,512}>` for `Int64`, `TryFrom<Int{256,512}>` for `Int128`,
+ `TryFrom<Int512>` for `Int256` and `Int256::from_i128` for const contexts
+ ([#1861]).
 
 [#1854]: https://github.com/CosmWasm/cosmwasm/pull/1854
+[#1861]: https://github.com/CosmWasm/cosmwasm/pull/1861
 
 ## [1.4.0] - 2023-09-04
 

packages/std/src/math/conversion.rs

@@ -0,0 +1,104 @@
+/// Grows a big endian signed integer to a bigger size.
+/// See <https://en.wikipedia.org/wiki/Sign_extension>
+pub const fn grow_be_int<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize>(
+ input: [u8; INPUT_SIZE],
+) -> [u8; OUTPUT_SIZE] {
+ debug_assert!(INPUT_SIZE <= OUTPUT_SIZE);
+ // check if sign bit is set
+ let mut output = if input[0] & 0b10000000 != 0 {
+ // negative number is filled up with 1s
+ [0b11111111u8; OUTPUT_SIZE]
+ } else {
+ [0u8; OUTPUT_SIZE]
+ };
+ let mut i = 0;
+
+ // copy input to the end of output
+ // copy_from_slice is not const, so we have to do this manually
+ while i < INPUT_SIZE {
+ output[OUTPUT_SIZE - INPUT_SIZE + i] = input[i];
+ i += 1;
+ }
+ output
+}
+
+/// Shrinks a big endian signed integer to a smaller size.
+/// This is the opposite operation of sign extension.
+pub fn shrink_be_int<const INPUT_SIZE: usize, const OUTPUT_SIZE: usize>(
+ input: [u8; INPUT_SIZE],
+) -> Option<[u8; OUTPUT_SIZE]> {
+ debug_assert!(INPUT_SIZE >= OUTPUT_SIZE);
+
+ // check bounds
+ if input[0] & 0b10000000 != 0 {
+ // a negative number should start with only 1s, otherwise it's too small
+ for i in &input[0..(INPUT_SIZE - OUTPUT_SIZE)] {
+ if *i != 0b11111111u8 {
+ return None;
+ }
+ }
+ } else {
+ // a positive number should start with only 0s, otherwise it's too large
+ for i in &input[0..(INPUT_SIZE - OUTPUT_SIZE)] {
+ if *i != 0u8 {
+ return None;
+ }
+ }
+ }
+
+ // Now, we can just copy the last bytes
+ let mut output = [0u8; OUTPUT_SIZE];
+ output.copy_from_slice(&input[(INPUT_SIZE - OUTPUT_SIZE)..]);
+ Some(output)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn grow_be_int_works() {
+ // test against rust std's integers
+ let i32s = [i32::MIN, -1, 0, 1, 42, i32::MAX];
+ for i in i32s {
+ assert_eq!(grow_be_int(i.to_be_bytes()), (i as i64).to_be_bytes());
+ assert_eq!(grow_be_int(i.to_be_bytes()), (i as i128).to_be_bytes());
+ }
+ let i8s = [i8::MIN, -1, 0, 1, 42, i8::MAX];
+ for i in i8s {
+ assert_eq!(grow_be_int(i.to_be_bytes()), (i as i16).to_be_bytes());
+ assert_eq!(grow_be_int(i.to_be_bytes()), (i as i32).to_be_bytes());
+ assert_eq!(grow_be_int(i.to_be_bytes()), (i as i64).to_be_bytes());
+ assert_eq!(grow_be_int(i.to_be_bytes()), (i as i128).to_be_bytes());
+ }
+ }
+
+ #[test]
+ fn shrink_be_int_works() {
+ // test against rust std's integers
+ let i32s = [-42, -1, 0i32, 1, 42];
+ for i in i32s {
+ assert_eq!(
+ shrink_be_int(i.to_be_bytes()),
+ Some((i as i16).to_be_bytes())
+ );
+ assert_eq!(
+ shrink_be_int(i.to_be_bytes()),
+ Some((i as i8).to_be_bytes())
+ );
+ }
+ // these should be too big to fit into an i16 or i8
+ let oob = [
+ i32::MIN,
+ i32::MIN + 10,
+ i32::MIN + 1234,
+ i32::MAX - 1234,
+ i32::MAX - 10,
+ i32::MAX,
+ ];
+ for i in oob {
+ assert_eq!(shrink_be_int::<4, 2>(i.to_be_bytes()), None);
+ assert_eq!(shrink_be_int::<4, 1>(i.to_be_bytes()), None);
+ }
+ }
+}

packages/std/src/math/int128.rs

@@ -9,7 +9,11 @@ use schemars::JsonSchema;
 use serde::{de, ser, Deserialize, Deserializer, Serialize};
 
 use crate::errors::{DivideByZeroError, DivisionError, OverflowError, OverflowOperation, StdError};
-use crate::{forward_ref_partial_eq, Int64, Uint128, Uint64};
+use crate::{
+ forward_ref_partial_eq, ConversionOverflowError, Int256, Int512, Int64, Uint128, Uint64,
+};
+
+use super::conversion::shrink_be_int;
 
 /// An implementation of i128 that is using strings for JSON encoding/decoding,
 /// such that the full i128 range can be used for clients that convert JSON numbers to floats,
@@ -287,6 +291,26 @@ impl From<i8> for Int128 {
  }
 }
 
+impl TryFrom<Int256> for Int128 {
+ type Error = ConversionOverflowError;
+
+ fn try_from(value: Int256) -> Result<Self, Self::Error> {
+ shrink_be_int(value.to_be_bytes())
+ .ok_or_else(|| ConversionOverflowError::new("Int256", "Int128", value))
+ .map(Self::from_be_bytes)
+ }
+}
+
+impl TryFrom<Int512> for Int128 {
+ type Error = ConversionOverflowError;
+
+ fn try_from(value: Int512) -> Result<Self, Self::Error> {
+ shrink_be_int(value.to_be_bytes())
+ .ok_or_else(|| ConversionOverflowError::new("Int512", "Int128", value))
+ .map(Self::from_be_bytes)
+ }
+}
+
 impl TryFrom<&str> for Int128 {
  type Error = StdError;
 

packages/std/src/math/int256.rs

@@ -9,12 +9,17 @@ use schemars::JsonSchema;
 use serde::{de, ser, Deserialize, Deserializer, Serialize};
 
 use crate::errors::{DivideByZeroError, DivisionError, OverflowError, OverflowOperation, StdError};
-use crate::{forward_ref_partial_eq, Int128, Int64, Uint128, Uint256, Uint64};
+use crate::{
+ forward_ref_partial_eq, ConversionOverflowError, Int128, Int512, Int64, Uint128, Uint256,
+ Uint64,
+};
 
 /// Used internally - we don't want to leak this type since we might change
 /// the implementation in the future.
 use bnum::types::{I256, U256};
 
+use super::conversion::{grow_be_int, shrink_be_int};
+
 /// An implementation of i256 that is using strings for JSON encoding/decoding,
 /// such that the full i256 range can be used for clients that convert JSON numbers to floats,
 /// like JavaScript and jq.
@@ -63,6 +68,12 @@ impl Int256 {
  Self(I256::ONE)
  }
 
+ /// A conversion from `i128` that, unlike the one provided by the `From` trait,
+ /// can be used in a `const` context.
+ pub const fn from_i128(v: i128) -> Self {
+ Self::from_be_bytes(grow_be_int(v.to_be_bytes()))
+ }
+
  #[must_use]
  pub const fn from_be_bytes(data: [u8; 32]) -> Self {
  let words: [u64; 4] = [
@@ -354,6 +365,16 @@ impl From<i8> for Int256 {
  }
 }
 
+impl TryFrom<Int512> for Int256 {
+ type Error = ConversionOverflowError;
+
+ fn try_from(value: Int512) -> Result<Self, Self::Error> {
+ shrink_be_int(value.to_be_bytes())
+ .ok_or_else(|| ConversionOverflowError::new("Int512", "Int256", value))
+ .map(Self::from_be_bytes)
+ }
+}
+
 impl TryFrom<&str> for Int256 {
  type Error = StdError;
 
@@ -681,6 +702,25 @@ mod tests {
  assert!(result.is_err());
  }
 
+ #[test]
+ fn int256_from_i128() {
+ assert_eq!(Int256::from_i128(123i128), Int256::from_str("123").unwrap());
+
+ assert_eq!(
+ Int256::from_i128(9785746283745i128),
+ Int256::from_str("9785746283745").unwrap()
+ );
+
+ assert_eq!(
+ Int256::from_i128(i128::MAX).to_string(),
+ i128::MAX.to_string()
+ );
+ assert_eq!(
+ Int256::from_i128(i128::MIN).to_string(),
+ i128::MIN.to_string()
+ );
+ }
+
  #[test]
  fn int256_implements_display() {
  let a = Int256::from(12345u32);

packages/std/src/math/int512.rs

@@ -9,12 +9,14 @@ use schemars::JsonSchema;
 use serde::{de, ser, Deserialize, Deserializer, Serialize};
 
 use crate::errors::{DivideByZeroError, DivisionError, OverflowError, OverflowOperation, StdError};
-use crate::{forward_ref_partial_eq, Uint128, Uint256, Uint512, Uint64};
+use crate::{forward_ref_partial_eq, Int128, Int256, Int64, Uint128, Uint256, Uint512, Uint64};
 
 /// Used internally - we don't want to leak this type since we might change
 /// the implementation in the future.
 use bnum::types::{I512, U512};
 
+use super::conversion::grow_be_int;
+
 /// An implementation of i512 that is using strings for JSON encoding/decoding,
 /// such that the full i512 range can be used for clients that convert JSON numbers to floats,
 /// like JavaScript and jq.
@@ -387,6 +389,24 @@ impl From<i8> for Int512 {
  }
 }
 
+impl From<Int64> for Int512 {
+ fn from(val: Int64) -> Self {
+ Int512(val.i64().into())
+ }
+}
+
+impl From<Int128> for Int512 {
+ fn from(val: Int128) -> Self {
+ Int512(val.i128().into())
+ }
+}
+
+impl From<Int256> for Int512 {
+ fn from(val: Int256) -> Self {
+ Self::from_be_bytes(grow_be_int(val.to_be_bytes()))
+ }
+}
+
 impl TryFrom<&str> for Int512 {
  type Error = StdError;
 
@@ -710,6 +730,40 @@ mod tests {
  let a = Int512::from(-5i8);
  assert_eq!(a.0, I512::from(-5i32));
 
+ // other big signed integers
+ let values = [
+ Int64::MAX,
+ Int64::MIN,
+ Int64::one(),
+ -Int64::one(),
+ Int64::zero(),
+ ];
+ for v in values {
+ assert_eq!(Int512::from(v).to_string(), v.to_string());
+ }
+
+ let values = [
+ Int128::MAX,
+ Int128::MIN,
+ Int128::one(),
+ -Int128::one(),
+ Int128::zero(),
+ ];
+ for v in values {
+ assert_eq!(Int512::from(v).to_string(), v.to_string());
+ }
+
+ let values = [
+ Int256::MAX,
+ Int256::MIN,
+ Int256::one(),
+ -Int256::one(),
+ Int256::zero(),
+ ];
+ for v in values {
+ assert_eq!(Int512::from(v).to_string(), v.to_string());
+ }
+
  let result = Int512::try_from("34567");
  assert_eq!(
  result.unwrap().0,

packages/std/src/math/int64.rs

@@ -9,7 +9,9 @@ use schemars::JsonSchema;
 use serde::{de, ser, Deserialize, Deserializer, Serialize};
 
 use crate::errors::{DivideByZeroError, DivisionError, OverflowError, OverflowOperation, StdError};
-use crate::{forward_ref_partial_eq, Uint64};
+use crate::{forward_ref_partial_eq, ConversionOverflowError, Int128, Int256, Int512, Uint64};
+
+use super::conversion::shrink_be_int;
 
 /// An implementation of i64 that is using strings for JSON encoding/decoding,
 /// such that the full i64 range can be used for clients that convert JSON numbers to floats,
@@ -263,6 +265,36 @@ impl From<i8> for Int64 {
  }
 }
 
+impl TryFrom<Int128> for Int64 {
+ type Error = ConversionOverflowError;
+
+ fn try_from(value: Int128) -> Result<Self, Self::Error> {
+ shrink_be_int(value.to_be_bytes())
+ .ok_or_else(|| ConversionOverflowError::new("Int128", "Int64", value))
+ .map(Self::from_be_bytes)
+ }
+}
+
+impl TryFrom<Int256> for Int64 {
+ type Error = ConversionOverflowError;
+
+ fn try_from(value: Int256) -> Result<Self, Self::Error> {
+ shrink_be_int(value.to_be_bytes())
+ .ok_or_else(|| ConversionOverflowError::new("Int256", "Int64", value))
+ .map(Self::from_be_bytes)
+ }
+}
+
+impl TryFrom<Int512> for Int64 {
+ type Error = ConversionOverflowError;
+
+ fn try_from(value: Int512) -> Result<Self, Self::Error> {
+ shrink_be_int(value.to_be_bytes())
+ .ok_or_else(|| ConversionOverflowError::new("Int512", "Int64", value))
+ .map(Self::from_be_bytes)
+ }
+}
+
 impl TryFrom<&str> for Int64 {
  type Error = StdError;
 

packages/std/src/math/mod.rs

@@ -1,3 +1,4 @@
+mod conversion;
 mod decimal;
 mod decimal256;
 mod fraction;