update forge

.github/workflows/manual-sol-artifacts.yaml

@@ -72,6 +72,8 @@ jobs:
           DEPLOY_BROADCAST: '1'
           DEPLOYMENT_KEY: ${{ github.ref == 'refs/heads/main' && secrets.PRIVATE_KEY || secrets.PRIVATE_KEY_DEV }}
           ETH_RPC_URL: ${{ secrets[env.rpc_secret_name] || vars[env.rpc_secret_name] || '' }}
+          CI_FORK_ETH_RPC_URL: ${{ secrets.RPC_URL_ETHEREUM_FORK || vars.RPC_URL_ETHEREUM_FORK || '' }}
+          CI_FORK_FLARE_RPC_URL: ${{ secrets.RPC_URL_FLARE_FORK || vars.RPC_URL_FLARE_FORK || '' }}
           ETHERSCAN_API_KEY: ${{ secrets[env.etherscan_api_key_secret_name] || vars[env.etherscan_api_key_secret_name] || ''}}
           DEPLOY_VERIFY: ${{ secrets[env.verify_secret_name] || vars[env.verify_secret_name] || '' }}
           DEPLOY_VERIFIER: ${{ secrets[env.verifier_secret_name] || vars[env.verifier_secret_name] || '' }}

.github/workflows/rainix.yaml

@@ -54,6 +54,10 @@ jobs:
       - name: Run ${{ matrix.task }}
         env:
           ETH_RPC_URL: ${{ secrets.CI_DEPLOY_SEPOLIA_RPC_URL || vars.CI_DEPLOY_SEPOLIA_RPC_URL }}
+          CI_FORK_ARB_RPC_URL: ${{ secrets.RPC_URL_ARBITRUM_FORK || vars.RPC_URL_ARBITRUM_FORK || '' }}
+          CI_FORK_ETH_RPC_URL: ${{ secrets.RPC_URL_ETHEREUM_FORK || vars.RPC_URL_ETHEREUM_FORK || '' }}
+          CI_FORK_BASE_RPC_URL: ${{ secrets.RPC_URL_BASE_FORK || vars.RPC_URL_BASE_FORK || '' }}
+          CI_FORK_FLARE_RPC_URL: ${{ secrets.RPC_URL_FLARE_FORK || vars.RPC_URL_FLARE_FORK || '' }}
           ETHERSCAN_API_KEY: ${{ secrets.EXPLORER_VERIFICATION_KEY }}
           DEPLOY_BROADCAST: ""
           DEPLOY_VERIFIER: ""

.gitignore

@@ -5,3 +5,4 @@ target
 temp
 dist
 node_modules
+.env

crates/float/src/lib.rs

@@ -1052,6 +1052,38 @@ impl Div for Float {
 }
 
 impl Float {
+    /// Returns the integer part of the float (truncation toward zero).
+    ///
+    /// # Returns
+    ///
+    /// * `Ok(Float)` - The integer part.
+    /// * `Err(FloatError)` - If the operation fails.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use rain_math_float::Float;
+    ///
+    /// let x = Float::parse("3.75".to_string())?;
+    /// let int = x.integer()?;
+    /// assert_eq!(int.format()?, "3");
+    ///
+    /// let y = Float::parse("-3.75".to_string())?;
+    /// let int_y = y.integer()?;
+    /// assert_eq!(int_y.format()?, "-3");
+    ///
+    /// anyhow::Ok(())
+    /// ```
+    pub fn integer(self) -> Result<Float, FloatError> {
+        let Float(a) = self;
+        let calldata = DecimalFloat::integerCall { a }.abi_encode();
+
+        execute_call(Bytes::from(calldata), |output| {
+            let decoded = DecimalFloat::integerCall::abi_decode_returns(output.as_ref())?;
+            Ok(Float(decoded))
+        })
+    }
+
     /// Returns the fractional part of the float.
     ///
     /// # Returns
@@ -1804,6 +1836,48 @@ mod tests {
         assert!(frac.eq(expected_frac).unwrap());
     }
 
+    #[test]
+    fn test_integer_positive() {
+        let float = Float::parse("12345.6789".to_string()).unwrap();
+        let int = float.integer().unwrap();
+        let expected = Float::parse("12345".to_string()).unwrap();
+        assert!(int.eq(expected).unwrap());
+
+        let frac = float.frac().unwrap();
+        let recombined = (int + frac).unwrap();
+        assert!(float.eq(recombined).unwrap());
+    }
+
+    #[test]
+    fn test_integer_negative() {
+        let float = Float::parse("-12345.6789".to_string()).unwrap();
+        let int = float.integer().unwrap();
+        let frac = float.frac().unwrap();
+
+        // integer truncates toward zero, so -12345.6789 -> -12345
+        let expected_int = Float::parse("-12345".to_string()).unwrap();
+        let expected_frac = Float::parse("-0.6789".to_string()).unwrap();
+
+        assert!(int.eq(expected_int).unwrap());
+        assert!(frac.eq(expected_frac).unwrap());
+
+        // integer + frac == original
+        let recombined = (int + frac).unwrap();
+        assert!(float.eq(recombined).unwrap());
+    }
+
+    #[test]
+    fn test_integer_whole_numbers() {
+        let pos = Float::parse("42".to_string()).unwrap();
+        assert!(pos.integer().unwrap().eq(pos).unwrap());
+        let zero = Float::parse("0".to_string()).unwrap();
+        assert!(pos.frac().unwrap().eq(zero).unwrap());
+
+        let neg = Float::parse("-42".to_string()).unwrap();
+        assert!(neg.integer().unwrap().eq(neg).unwrap());
+        assert!(neg.frac().unwrap().eq(zero).unwrap());
+    }
+
     proptest! {
         #[test]
         fn test_from_to_fixed_decimal_valid_range(coeff in any::<I224>(), decimals in 0u8..=66u8) {
@@ -1823,30 +1897,30 @@ mod tests {
 
     proptest! {
         #[test]
-        fn test_frac_floor_properties(float in arb_float()) {
-            let floor = float.floor().unwrap();
+        fn test_int_frac_properties(float in arb_float()) {
+            let int = float.integer().unwrap();
             let frac = float.frac().unwrap();
 
             let zero = Float::parse("0".to_string()).unwrap();
 
             prop_assert!(
-                floor.frac().unwrap().eq(zero).unwrap(),
-                "floor.frac() is not zero: {}",
-                floor.show_unpacked().unwrap()
+                int.frac().unwrap().eq(zero).unwrap(),
+                "int.frac() is not zero: {}",
+                int.show_unpacked().unwrap()
             );
 
             prop_assert!(
-                frac.floor().unwrap().eq(zero).unwrap(),
-                "frac.floor() is not zero: {}",
+                frac.integer().unwrap().eq(zero).unwrap(),
+                "frac.integer() is not zero: {}",
                 frac.show_unpacked().unwrap()
             );
 
-            let recombined = (floor + frac).unwrap();
+            let recombined = (int + frac).unwrap();
             prop_assert!(
                 float.eq(recombined).unwrap(),
-                "original: {}, floor: {}, frac: {}, recombined: {}",
+                "original: {}, int: {}, frac: {}, recombined: {}",
                 float.show_unpacked().unwrap(),
-                floor.show_unpacked().unwrap(),
+                int.show_unpacked().unwrap(),
                 frac.show_unpacked().unwrap(),
                 recombined.show_unpacked().unwrap()
             );

foundry.lock

@@ -1,17 +1,17 @@
 {
   "lib/forge-std": {
-    "rev": "b8f065fda83b8cd94a6b2fec8fcd911dc3b444fd"
+    "rev": "1801b0541f4fda118a10798fd3486bb7051c5dd6"
   },
   "lib/rain.datacontract": {
-    "rev": "061bf7cd63496ccbe4f74bcd0c48715883c1c3cb"
+    "rev": "82590300cf768b6c5efc8b92c64b7f402bd34bee"
   },
   "lib/rain.math.fixedpoint": {
-    "rev": "1752e9fbd635901ac7eb177699681ed97290e12e"
+    "rev": "8308cbb6da0e231c6f3437f1861e66eff7ea2b00"
   },
   "lib/rain.sol.codegen": {
     "rev": "bd7993b3f6b301e5a667ff687f25b80fdda878cd"
   },
   "lib/rain.string": {
-    "rev": "0b1ca08aed6d9c06b83fe127a7d20ee7002ead28"
+    "rev": "488f237cd59874e4eb91b5a4f747bd57578fec7f"
   }
 }

src/concrete/DecimalFloat.sol

@@ -67,15 +67,18 @@ contract DecimalFloat {
     }
 
     /// Exposes `LibFormatDecimalFloat.toDecimalString` for offchain use.
-    /// @param a The float to format.
+    /// @param a The float to format. The absolute value of `a` is used to
+    /// determine if scientific notation is used, this allows negative numbers to
+    /// be formatted consistently with their positive counterparts.
     /// @param scientificMin The smallest number that won't be formatted in
     /// scientific notation.
     /// @param scientificMax The largest number that won't be formatted in
     /// scientific notation.
     /// @return The string representation of the float.
     function format(Float a, Float scientificMin, Float scientificMax) public pure returns (string memory) {
         require(scientificMin.lt(scientificMax), "scientificMin must be less than scientificMax");
-        return LibFormatDecimalFloat.toDecimalString(a, a.lt(scientificMin) || a.gt(scientificMax));
+        Float absA = a.abs();
+        return LibFormatDecimalFloat.toDecimalString(a, absA.lt(scientificMin) || absA.gt(scientificMax));
     }
 
     /// Exposes `LibFormatDecimalFloat.toDecimalString` for offchain use.
@@ -191,6 +194,13 @@ contract DecimalFloat {
         return a.gte(b);
     }
 
+    /// Exposes `LibDecimalFloat.integer` for offchain use.
+    /// @param a The float to get the integer part of.
+    /// @return The integer part of the float.
+    function integer(Float a) external pure returns (Float) {
+        return a.integer();
+    }
+
     /// Exposes `LibDecimalFloat.frac` for offchain use.
     /// @param a The float to get the fractional part of.
     /// @return The fractional part of the float.

src/error/ErrDecimalFloat.sol

@@ -44,3 +44,6 @@ error DivisionByZero(int256 signedCoefficient, int256 exponent);
 
 /// @dev Thrown when attempting to exponentiate a negative base.
 error PowNegativeBase(int256 signedCoefficient, int256 exponent);
+
+/// @dev Thrown if writing the data by creating the contract fails somehow.
+error WriteError();