Expose fromFixedDecimalLosslessPacked

Cargo.toml

@@ -17,3 +17,4 @@ revm = { version = "25.0.0", default-features = false, features = [
 ] }
 thiserror = "2.0.12"
 proptest = "1.7.0"
+serde = "1.0.219"

crates/float/Cargo.toml

@@ -8,6 +8,7 @@ homepage.workspace = true
 [dependencies]
 alloy.workspace = true
 thiserror.workspace = true
+serde.workspace = true
 
 [target.'cfg(not(target_family = "wasm"))'.dependencies]
 revm = { workspace = true, default-features = false, features = [
@@ -29,3 +30,4 @@ getrandom = { version = "0.2.11", features = ["js", "js-sys"] }
 [dev-dependencies]
 alloy = { workspace = true, features = ["sol-types", "json-rpc", "arbitrary"] }
 proptest.workspace = true
+serde_json = "1.0.140"

crates/float/src/lib.rs

@@ -1,6 +1,5 @@
-#[cfg(test)]
 use alloy::primitives::aliases::I224;
-use alloy::primitives::{Address, Bytes, FixedBytes};
+use alloy::primitives::{Address, B256, Bytes, FixedBytes};
 use alloy::sol_types::{SolError, SolInterface};
 use alloy::{sol, sol_types::SolCall};
 use revm::context::result::{EVMError, ExecutionResult, HaltReason, Output, SuccessReason};
@@ -9,8 +8,9 @@ use revm::database::InMemoryDB;
 use revm::handler::EthPrecompiles;
 use revm::handler::instructions::EthInstructions;
 use revm::interpreter::interpreter::EthInterpreter;
-use revm::primitives::{address, fixed_bytes};
+use revm::primitives::{U256, address, fixed_bytes};
 use revm::{Context, MainBuilder, MainContext, SystemCallEvm};
+use serde::{Deserialize, Serialize};
 use std::cell::RefCell;
 use std::ops::{Add, Div, Mul, Neg, Sub};
 use std::thread::AccessError;
@@ -131,12 +131,23 @@ where
     }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub struct Float(FixedBytes<32>);
+#[derive(Debug, Copy, Clone, Default, Serialize, Deserialize)]
+pub struct Float(pub B256);
 
 impl Float {
-    #[cfg(test)]
-    fn pack_lossless(coefficient: I224, exponent: i32) -> Result<Self, FloatError> {
+    pub fn from_fixed_decimal(value: U256, decimals: u8) -> Result<Self, FloatError> {
+        let calldata =
+            DecimalFloat::fromFixedDecimalLosslessPackedCall { value, decimals }.abi_encode();
+
+        execute_call(Bytes::from(calldata), |output| {
+            let decoded = DecimalFloat::fromFixedDecimalLosslessPackedCall::abi_decode_returns(
+                output.as_ref(),
+            )?;
+            Ok(Float(decoded))
+        })
+    }
+
+    pub fn pack_lossless(coefficient: I224, exponent: i32) -> Result<Self, FloatError> {
         let calldata = DecimalFloat::packLosslessCall {
             coefficient,
             exponent,
@@ -386,6 +397,13 @@ mod tests {
     use super::*;
     use core::str::FromStr;
     use proptest::prelude::*;
+    use serde_json::json;
+
+    #[test]
+    fn test_default() {
+        let zero = Float::parse("0".to_string()).unwrap();
+        assert!(zero.eq(Float::default()).unwrap());
+    }
 
     prop_compose! {
         fn arb_float()(
@@ -411,6 +429,29 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_serde() {
+        let float = Float::parse("1.1341234234625468391".to_string()).unwrap();
+        let serialized = serde_json::to_string(&float).unwrap();
+        assert_eq!(
+            serialized,
+            json!("0xffffffed00000000000000000000000000000000000000009d642872ad59a7e7").to_string()
+        );
+        let deserialized: Float = serde_json::from_str(&serialized).unwrap();
+        assert!(float.eq(deserialized).unwrap());
+    }
+
+    proptest! {
+        #[test]
+        fn proptest_serde(float in arb_float()) {
+            let serialized = serde_json::to_string(&float).unwrap();
+            let deserialized: Float = serde_json::from_str(&serialized).unwrap();
+            prop_assert!(float.eq(deserialized).unwrap());
+            let re_serialized = serde_json::to_string(&deserialized).unwrap();
+            prop_assert_eq!(serialized, re_serialized);
+        }
+    }
+
     #[test]
     fn test_parse_and_format() {
         let float = Float::parse("1.1341234234625468391".to_string()).unwrap();
@@ -773,6 +814,33 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn test_from_fixed_decimal() {
+        let cases = vec![
+            (U256::from(0u128), 0u8, "0"),
+            (U256::from(0u128), 18u8, "0"),
+            (U256::from(1u128), 18u8, "1e-18"),
+            (U256::from(123456789u128), 0u8, "123456789"),
+            (U256::from(123456789u128), 2u8, "123456789e-2"),
+            (U256::from(1000000000000000000u128), 18u8, "1"),
+        ];
+
+        for (amount, decimals, expected) in cases {
+            let float = Float::from_fixed_decimal(amount, decimals).expect("should convert");
+            let expected = Float::parse(expected.to_string()).unwrap();
+            assert!(float.eq(expected).unwrap());
+        }
+    }
+
+    #[test]
+    fn test_from_fixed_decimal_err() {
+        let err = Float::from_fixed_decimal(U256::MAX, 1).unwrap_err();
+        assert!(matches!(
+            err,
+            FloatError::DecimalFloat(DecimalFloatErrors::LossyConversionToFloat(_))
+        ));
+    }
+
     #[test]
     fn test_frac_and_floor_integers() {
         let int_float = Float::parse("12345".to_string()).unwrap();
@@ -808,6 +876,20 @@ mod tests {
         assert!(frac.eq(expected_frac).unwrap());
     }
 
+    proptest! {
+        #[test]
+        fn test_from_fixed_decimal_valid_range(coeff in any::<I224>(), decimals in 0u8..=66u8) {
+            prop_assume!(coeff >= I224::ZERO);
+
+            let exponent = -(decimals as i32);
+            let value = U256::from(coeff);
+
+            let float = Float::from_fixed_decimal(value, decimals).unwrap();
+            let expected = Float::pack_lossless(coeff, exponent).unwrap();
+            prop_assert!(float.eq(expected).unwrap());
+        }
+    }
+
     proptest! {
         #[test]
         fn test_frac_floor_properties(float in arb_float()) {

src/concrete/DecimalFloat.sol

@@ -180,4 +180,15 @@ contract DecimalFloat {
         (int256 coefficient, int256 exponent) = LibDecimalFloat.unpack(float);
         return (int224(coefficient), int32(exponent));
     }
+
+    /// Exposes `LibDecimalFloat.fromFixedDecimalLosslessPacked` for offchain
+    /// use.
+    /// @param value The fixed point decimal value to convert.
+    /// @param decimals The number of decimals in the fixed point
+    /// representation. e.g. If 1e18 represents 1 this would be 18 decimals.
+    /// @return float The Float struct containing the signed coefficient and
+    /// exponent.
+    function fromFixedDecimalLosslessPacked(uint256 value, uint8 decimals) external pure returns (Float) {
+        return LibDecimalFloat.fromFixedDecimalLosslessPacked(value, decimals);
+    }
 }