fix: clear3 refuses a side on its raw calculation, before dividing by its ratio

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: thedavidmeister

crates/test_fixtures/abis/RaindexV6.json

@@ -628,19 +628,20 @@ contract RaindexV6 is IRaindexV6, IMetaV1_2, ReentrancyGuard, Multicall, Raindex
             new bytes32[](0)
         );
 
-        ClearStateChangeV2 memory clearStateChange =
-            calculateClearStateChange(aliceOrderIOCalculation, bobOrderIOCalculation);
-
-        // Each side must be one `takeOrders4` would take.
+        // Each side must be one `takeOrders4` would take. Given this, each
+        // computed output is positive or the Float math reverts.
         if (
-            !clearStateChange.aliceOutput.gt(LibDecimalFloat.FLOAT_ZERO)
-                || !clearStateChange.bobOutput.gt(LibDecimalFloat.FLOAT_ZERO)
+            !aliceOrderIOCalculation.outputMax.gt(LibDecimalFloat.FLOAT_ZERO)
+                || !bobOrderIOCalculation.outputMax.gt(LibDecimalFloat.FLOAT_ZERO)
                 || aliceOrderIOCalculation.IORatio.lt(LibDecimalFloat.FLOAT_ZERO)
                 || bobOrderIOCalculation.IORatio.lt(LibDecimalFloat.FLOAT_ZERO)
         ) {
             revert ClearZeroAmount();
         }
 
+        ClearStateChangeV2 memory clearStateChange =
+            calculateClearStateChange(aliceOrderIOCalculation, bobOrderIOCalculation);
+
         Float aliceBounty = clearStateChange.aliceOutput.sub(clearStateChange.bobInput);
         Float bobBounty = clearStateChange.bobOutput.sub(clearStateChange.aliceInput);
 

src/concrete/raindex/RaindexV6.sol

@@ -4,6 +4,7 @@ pragma solidity =0.8.25;
 
 import {Test, Vm} from "forge-std-1.17.0/src/Test.sol";
 import {NegativeBounty, ClearZeroAmount} from "src/error/ErrRaindexV6.sol";
+import {ExponentUnderflow} from "rain-math-float-0.3.10/src/error/ErrDecimalFloat.sol";
 import {
     OrderV4,
     OrderConfigV4,
@@ -393,6 +394,37 @@ contract RaindexV6ClearFreshDriverTest is Test {
         assertTrue(raindex.vaultBalance2(bountyBot, address(token0), ALICE_BOUNTY_VAULT).eq(f(1, 0)), "alice bounty 1");
     }
 
+    /// A zero ratio caps against a negative counterparty max, which would
+    /// divide by that zero ratio if the sides were not refused first.
+    function testFreshClearAliceZeroRatioBobNegativeOutputReverts() external {
+        expectClearZeroAmount(f(0, 0), f(1, 0), f(1, 0), f(-1, 0));
+    }
+
+    function testFreshClearBobZeroRatioAliceNegativeOutputReverts() external {
+        expectClearZeroAmount(f(1, 0), f(-1, 0), f(0, 0), f(1, 0));
+    }
+
+    /// Both sides pass the refusal but the capped output, the smallest max
+    /// over the largest ratio, is below every non-zero Float: the division
+    /// reverts rather than yielding a zero output.
+    function testFreshClearAliceCappedOutputUnderflowReverts() external {
+        (OrderV4 memory aliceOrder, OrderV4 memory bobOrder) =
+            wireOrders(f(1, type(int32).max), f(1, 0), f(1, 0), f(1, type(int32).min), f(10, 0));
+
+        vm.prank(bountyBot);
+        vm.expectPartialRevert(ExponentUnderflow.selector);
+        raindex.clear3(aliceOrder, bobOrder, clearConfig(), new SignedContextV1[](0), new SignedContextV1[](0));
+    }
+
+    function testFreshClearBobCappedOutputUnderflowReverts() external {
+        (OrderV4 memory aliceOrder, OrderV4 memory bobOrder) =
+            wireOrders(f(1, 0), f(1, type(int32).min), f(1, type(int32).max), f(1, 0), f(10, 0));
+
+        vm.prank(bountyBot);
+        vm.expectPartialRevert(ExponentUnderflow.selector);
+        raindex.clear3(aliceOrder, bobOrder, clearConfig(), new SignedContextV1[](0), new SignedContextV1[](0));
+    }
+
     // ---------------------------------------------------------------------
     // Vault-0 (token-plumbing) clear: record ordering / pushVaultZeroInput (B11)
     // ---------------------------------------------------------------------