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

foundry.lock

@@ -1,17 +1,17 @@
 {
   "lib/forge-std": {
-    "rev": "b8f065fda83b8cd94a6b2fec8fcd911dc3b444fd"
+    "rev": "1801b0541f4fda118a10798fd3486bb7051c5dd6"
   },
   "lib/rain.datacontract": {
     "rev": "061bf7cd63496ccbe4f74bcd0c48715883c1c3cb"
   },
   "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.

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();

src/lib/LibDecimalFloat.sol

@@ -44,6 +44,9 @@ type Float is bytes32;
 library LibDecimalFloat {
     using LibDecimalFloat for Float;
 
+    /// Address of the log tables data contract. Only valid if deployed using
+    /// the standard Rain deployment scripts that use Zoltu deterministic
+    /// deployment.
     address constant LOG_TABLES_ADDRESS = 0x6421E8a23cdEe2E6E579b2cDebc8C2A514843593;
 
     /// A zero valued float.
@@ -347,6 +350,11 @@ library LibDecimalFloat {
         }
     }
 
+    /// Lossless version of `packLossy`. This will revert if the conversion is
+    /// lossy.
+    /// @param signedCoefficient As per `packLossy`.
+    /// @param exponent As per `packLossy`.
+    /// @return float As per `packLossy`.
     function packLossless(int256 signedCoefficient, int256 exponent) internal pure returns (Float) {
         (Float c, bool lossless) = packLossy(signedCoefficient, exponent);
         if (!lossless) {
@@ -573,28 +581,31 @@ library LibDecimalFloat {
     /// @param float The float to frac.
     function frac(Float float) internal pure returns (Float) {
         (int256 signedCoefficient, int256 exponent) = float.unpack();
-        (int256 characteristic, int256 mantissa) =
-            LibDecimalFloatImplementation.characteristicMantissa(signedCoefficient, exponent);
-        (characteristic);
-        (Float result, bool lossless) = packLossy(mantissa, exponent);
+        (int256 integer, int256 fraction) = LibDecimalFloatImplementation.intFrac(signedCoefficient, exponent);
+        (integer);
+        (Float result, bool lossless) = packLossy(fraction, exponent);
         // Frac is lossy by definition.
         (lossless);
         return result;
     }
 
-    /// Integer component of a float.
+    /// Smallest integer value less than or equal to the float.
     /// @param float The float to floor.
     function floor(Float float) internal pure returns (Float) {
         (int256 signedCoefficient, int256 exponent) = float.unpack();
         // If the exponent is 0 or greater then the float is already an integer.
         if (exponent >= 0) {
             return float;
         }
-        (int256 characteristic, int256 mantissa) =
-            LibDecimalFloatImplementation.characteristicMantissa(signedCoefficient, exponent);
-        (Float result, bool lossless) = packLossy(characteristic, exponent);
+        (int256 integer, int256 fraction) = LibDecimalFloatImplementation.intFrac(signedCoefficient, exponent);
+        if (signedCoefficient < 0 && fraction != 0) {
+            // If the float is negative and has a fractional part, we need to
+            // subtract 1 from the characteristic to floor it.
+            (integer, exponent) = LibDecimalFloatImplementation.sub(integer, exponent, 1e76, -76);
+        }
+        (Float result, bool lossless) = packLossy(integer, exponent);
         // Flooring is lossy by definition.
-        (lossless, mantissa);
+        (lossless, fraction);
         return result;
     }
 
@@ -606,22 +617,21 @@ library LibDecimalFloat {
         if (exponent >= 0) {
             return float;
         }
-        (int256 characteristic, int256 mantissa) =
-            LibDecimalFloatImplementation.characteristicMantissa(signedCoefficient, exponent);
+        (int256 integer, int256 fraction) = LibDecimalFloatImplementation.intFrac(signedCoefficient, exponent);
 
-        // If the mantissa is 0, then the float is already an integer.
-        if (mantissa == 0) {
+        // If the fraction is 0, then the float is already an integer.
+        if (fraction == 0) {
             return float;
         }
         // Truncate the fractional part when exponent < 0:
-        //   mantissa < 0 (input < 0) → truncation towards zero increases the value (correct ceil).
-        //   mantissa == 0 → value is already an integer.
-        //   mantissa > 0 (input > 0) → truncation decreases the value, so add 1 to round up.
-        else if (mantissa > 0) {
-            (characteristic, exponent) = LibDecimalFloatImplementation.add(characteristic, exponent, 1e76, -76);
+        //   fraction < 0 (input < 0) → truncation towards zero increases the value (correct ceil).
+        //   fraction == 0 → value is already an integer.
+        //   fraction > 0 (input > 0) → truncation decreases the value, so add 1 to round up.
+        else if (fraction > 0) {
+            (integer, exponent) = LibDecimalFloatImplementation.add(integer, exponent, 1e76, -76);
         }
 
-        (Float result, bool lossless) = packLossy(characteristic, exponent);
+        (Float result, bool lossless) = packLossy(integer, exponent);
         (lossless);
         return result;
     }
@@ -700,11 +710,9 @@ library LibDecimalFloat {
         }
 
         (int256 signedCoefficientB, int256 exponentB) = b.unpack();
-        (int256 characteristicB, int256 mantissaB) =
-            LibDecimalFloatImplementation.characteristicMantissa(signedCoefficientB, exponentB);
+        (int256 integerB, int256 fractionB) = LibDecimalFloatImplementation.intFrac(signedCoefficientB, exponentB);
 
-        uint256 exponentBInteger =
-            uint256(LibDecimalFloatImplementation.withTargetExponent(characteristicB, exponentB, 0));
+        uint256 exponentBInteger = uint256(LibDecimalFloatImplementation.withTargetExponent(integerB, exponentB, 0));
 
         // Exponentiation by squaring.
         (int256 signedCoefficientResult, int256 exponentResult) = (1, 0);
@@ -725,7 +733,7 @@ library LibDecimalFloat {
             LibDecimalFloatImplementation.log10(tablesDataContract, signedCoefficientA, exponentA);
 
         (signedCoefficientC, exponentC) =
-            LibDecimalFloatImplementation.mul(signedCoefficientC, exponentC, mantissaB, exponentB);
+            LibDecimalFloatImplementation.mul(signedCoefficientC, exponentC, fractionB, exponentB);
 
         (signedCoefficientC, exponentC) =
             LibDecimalFloatImplementation.pow10(tablesDataContract, signedCoefficientC, exponentC);
@@ -772,6 +780,9 @@ library LibDecimalFloat {
         return gt(a, b) ? a : b;
     }
 
+    /// Returns true if the float is zero. Handles the case where the signed
+    /// coefficient is zero and exponent is potentially non zero.
+    /// @param a The float to check.
     function isZero(Float a) internal pure returns (bool result) {
         uint256 mask = type(uint224).max;
         assembly ("memory-safe") {