feat: add signed integer constraints and OR predicate composition

fichiokaku · fichiokaku · commit 92bade9cd990 · 2026-04-22T23:22:02.000+02:00
Community feedback on ERC-8211 identified two gaps in the constraint system:
- Unsigned-only GTE/LTE constraints are incorrect for int256 values (two's complement
  makes negative numbers appear greater than positives in raw bytes32 comparison).
- No way to express OR logic without deploying helper contracts.
diff --git a/contracts/ComposableExecutionLib.sol b/contracts/ComposableExecutionLib.sol
@@ -62,11 +62,7 @@ library ComposableExecutionLib {
         // we don't restrict it since some calls may want to call address(0)
         // if a param with VALUE type was not provided, it will be 0
         // this is even more often case, as many calls happen with 0 value
-        return Execution({
-            target: composedTarget, 
-            value: composedValue,
-            callData: composedCalldata
-        });
+        return Execution({ target: composedTarget, value: composedValue, callData: composedCalldata });
     }
 
     // Process a single input parameter and return the composed calldata
@@ -99,8 +95,7 @@ library ComposableExecutionLib {
 
             // expect paramData to be abi.encodePacked(address token, address account)
             // Validate exact length requirement
-            require(paramData.length == 40, 
-                     InvalidParameterEncoding("Invalid paramData length"));
+            require(paramData.length == 40, InvalidParameterEncoding("Invalid paramData length"));
             assembly {
                 tokenAddr := shr(96, calldataload(paramData.offset))
                 account := shr(96, calldataload(add(paramData.offset, 0x14)))
@@ -170,31 +165,54 @@ library ComposableExecutionLib {
         }
     }
 
-    /// @dev Validate the constraints => compare the value with the reference data
+    /// @dev Validate the constraints => compare the value with the reference data.
+    /// Each constraints[i] is checked against the i-th 32-byte word of rawValue (AND semantics).
+    /// Use ConstraintType.OR to express OR semantics within a single word position.
     function _validateConstraints(bytes memory rawValue, Constraint[] calldata constraints) private pure {
-        if (constraints.length > 0) {
-            for (uint256 i; i < constraints.length; i++) {
-                Constraint memory constraint = constraints[i];
-                bytes32 returnValue;
-                assembly {
-                    returnValue := mload(add(rawValue, add(0x20, mul(i, 0x20))))
-                }
-                if (constraint.constraintType == ConstraintType.EQ) {
-                    require(returnValue == bytes32(constraint.referenceData), ConstraintNotMet(ConstraintType.EQ));
-                } else if (constraint.constraintType == ConstraintType.GTE) {
-                    require(returnValue >= bytes32(constraint.referenceData), ConstraintNotMet(ConstraintType.GTE));
-                } else if (constraint.constraintType == ConstraintType.LTE) {
-                    require(returnValue <= bytes32(constraint.referenceData), ConstraintNotMet(ConstraintType.LTE));
-                } else if (constraint.constraintType == ConstraintType.IN) {
-                    (bytes32 lowerBound, bytes32 upperBound) = abi.decode(constraint.referenceData, (bytes32, bytes32));
-                    require(returnValue >= lowerBound && returnValue <= upperBound, ConstraintNotMet(ConstraintType.IN));
-                } else {
-                    revert InvalidConstraintType();
+        uint256 len = constraints.length;
+        for (uint256 i; i < len; i++) {
+            Constraint memory c = constraints[i];
+            bytes32 value;
+            assembly {
+                value := mload(add(rawValue, add(0x20, mul(i, 0x20))))
+            }
+            if (c.constraintType == ConstraintType.OR) {
+                Constraint[] memory subs = abi.decode(c.referenceData, (Constraint[]));
+                bool anyMet;
+                for (uint256 j; j < subs.length; j++) {
+                    if (_checkConstraint(value, subs[j])) {
+                        anyMet = true;
+                        break;
+                    }
                 }
+                if (!anyMet) revert ConstraintNotMet(ConstraintType.OR);
+            } else {
+                if (!_checkConstraint(value, c)) revert ConstraintNotMet(c.constraintType);
             }
         }
     }
 
+    /// @dev Returns true if value satisfies constraint c. OR nesting is not supported.
+    function _checkConstraint(bytes32 value, Constraint memory c) private pure returns (bool) {
+        ConstraintType ct = c.constraintType;
+        if (ct == ConstraintType.EQ) {
+            return value == bytes32(c.referenceData);
+        } else if (ct == ConstraintType.GTE) {
+            return value >= bytes32(c.referenceData);
+        } else if (ct == ConstraintType.LTE) {
+            return value <= bytes32(c.referenceData);
+        } else if (ct == ConstraintType.IN) {
+            (bytes32 lower, bytes32 upper) = abi.decode(c.referenceData, (bytes32, bytes32));
+            return value >= lower && value <= upper;
+        } else if (ct == ConstraintType.GTE_SIGNED) {
+            return int256(uint256(value)) >= int256(uint256(bytes32(c.referenceData)));
+        } else if (ct == ConstraintType.LTE_SIGNED) {
+            return int256(uint256(value)) <= int256(uint256(bytes32(c.referenceData)));
+        } else {
+            revert InvalidConstraintType();
+        }
+    }
+
     /// @dev Parse the return data and write to the appropriate storage contract
     function _parseReturnDataAndWriteToStorage(
         uint256 returnValues,
diff --git a/contracts/ComposableExecutionModule.sol b/contracts/ComposableExecutionModule.sol
@@ -84,7 +84,7 @@ contract ComposableExecutionModule is IComposableExecutionModule, IExecutor, ERC
     function _executeComposable(
         ComposableExecution[] calldata cExecutions,
         address account,
-        function(Execution memory execution) internal returns(bytes[] memory) executeExecutionFunction
+        function(Execution memory execution) internal returns (bytes[] memory) executeExecutionFunction
     )
         internal
     {
@@ -107,10 +107,10 @@ contract ComposableExecutionModule is IComposableExecutionModule, IExecutor, ERC
 
     /// @dev function to be used as an argument for _executeComposable in case of regular call
     function _executeExecutionCall(Execution memory execution) internal returns (bytes[] memory) {
-        return IERC7579Account(msg.sender).executeFromExecutor({
-            mode: ModeLib.encodeSimpleSingle(),
-            executionCalldata: ExecutionLib.encodeSingle(execution.target, execution.value, execution.callData)
-        });
+        return IERC7579Account(msg.sender)
+            .executeFromExecutor({
+                mode: ModeLib.encodeSimpleSingle(), executionCalldata: ExecutionLib.encodeSingle(execution.target, execution.value, execution.callData)
+            });
     }
 
     /// @dev function to be used as an argument for _executeComposable in case of delegatecall
diff --git a/contracts/types/ComposabilityDataTypes.sol b/contracts/types/ComposabilityDataTypes.sol
@@ -6,30 +6,29 @@ enum InputParamType {
     TARGET, // The target address
     VALUE, // The value
     CALL_DATA // The call data
-
 }
 
 // Parameter type for composition
 enum InputParamFetcherType {
     RAW_BYTES, // Already encoded bytes
     STATIC_CALL, // Perform a static call
     BALANCE // Get the balance of an address
-
 }
 
 enum OutputParamFetcherType {
     EXEC_RESULT, // The return of the execution call
     STATIC_CALL // Call to some other function
-
 }
 
 // Constraint type for parameter validation
 enum ConstraintType {
-    EQ, // Equal to
-    GTE, // Greater than or equal to
-    LTE, // Less than or equal to
-    IN // In range
-
+    EQ, // Equal to (unsigned / bitwise)
+    GTE, // Greater than or equal to (unsigned)
+    LTE, // Less than or equal to (unsigned)
+    IN, // In range (unsigned)
+    GTE_SIGNED, // Greater than or equal to (signed int256)
+    LTE_SIGNED, // Less than or equal to (signed int256)
+    OR // At least one sub-constraint must pass; referenceData = abi.encode(Constraint[])
 }
 
 // Constraint for parameter validation
diff --git a/test/ComposabilityBase.t.sol b/test/ComposabilityBase.t.sol
@@ -63,19 +63,13 @@ contract ComposabilityTestBase is Test {
 
     function _createRawTargetInputParam(address target) internal returns (InputParam memory) {
         return InputParam({
-            paramType: InputParamType.TARGET,
-            fetcherType: InputParamFetcherType.RAW_BYTES,
-            paramData: abi.encode(target),
-            constraints: emptyConstraints
+            paramType: InputParamType.TARGET, fetcherType: InputParamFetcherType.RAW_BYTES, paramData: abi.encode(target), constraints: emptyConstraints
         });
     }
 
     function _createRawValueInputParam(uint256 value) internal returns (InputParam memory) {
         return InputParam({
-            paramType: InputParamType.VALUE,
-            fetcherType: InputParamFetcherType.RAW_BYTES,
-            paramData: abi.encode(value),
-            constraints: emptyConstraints
+            paramType: InputParamType.VALUE, fetcherType: InputParamFetcherType.RAW_BYTES, paramData: abi.encode(value), constraints: emptyConstraints
         });
     }
 }
diff --git a/test/mock/DummyContract.sol b/test/mock/DummyContract.sol
@@ -110,4 +110,8 @@ contract DummyContract {
     function payableEmit() external payable {
         emit Received(msg.value);
     }
+
+    function getSignedValue() external pure returns (int256) {
+        return -42;
+    }
 }
diff --git a/test/unit/ComposableExecution_Complex.sol b/test/unit/ComposableExecution_Complex.sol
@@ -94,7 +94,9 @@ contract ComposableExecutionTestComplexCases is ComposabilityTestBase {
         OutputParam[] memory outputParams = new OutputParam[](1);
         outputParams[0] = OutputParam({
             fetcherType: OutputParamFetcherType.STATIC_CALL,
-            paramData: abi.encode(4, address(dummyContract), abi.encodeWithSelector(DummyContract.returnMultipleValues.selector), address(storageContract), SLOT_A)
+            paramData: abi.encode(
+                4, address(dummyContract), abi.encodeWithSelector(DummyContract.returnMultipleValues.selector), address(storageContract), SLOT_A
+            )
         });
 
         ComposableExecution[] memory executions = new ComposableExecution[](1);
@@ -258,18 +260,12 @@ contract ComposableExecutionTestComplexCases is ComposabilityTestBase {
 
         // tokenIn
         inputParams[3] = InputParam({
-            paramType: InputParamType.CALL_DATA,
-            fetcherType: InputParamFetcherType.RAW_BYTES,
-            paramData: abi.encode(tokenIn),
-            constraints: emptyConstraints
+            paramType: InputParamType.CALL_DATA, fetcherType: InputParamFetcherType.RAW_BYTES, paramData: abi.encode(tokenIn), constraints: emptyConstraints
         });
 
         // tokenOut
         inputParams[4] = InputParam({
-            paramType: InputParamType.CALL_DATA,
-            fetcherType: InputParamFetcherType.RAW_BYTES,
-            paramData: abi.encode(tokenOut),
-            constraints: emptyConstraints
+            paramType: InputParamType.CALL_DATA, fetcherType: InputParamFetcherType.RAW_BYTES, paramData: abi.encode(tokenOut), constraints: emptyConstraints
         });
 
         // amountIn
@@ -290,18 +286,12 @@ contract ComposableExecutionTestComplexCases is ComposabilityTestBase {
 
         // deadline
         inputParams[7] = InputParam({
-            paramType: InputParamType.CALL_DATA,
-            fetcherType: InputParamFetcherType.RAW_BYTES,
-            paramData: abi.encode(deadline),
-            constraints: emptyConstraints
+            paramType: InputParamType.CALL_DATA, fetcherType: InputParamFetcherType.RAW_BYTES, paramData: abi.encode(deadline), constraints: emptyConstraints
         });
 
         // fee
         inputParams[8] = InputParam({
-            paramType: InputParamType.CALL_DATA,
-            fetcherType: InputParamFetcherType.RAW_BYTES,
-            paramData: abi.encode(fee),
-            constraints: emptyConstraints
+            paramType: InputParamType.CALL_DATA, fetcherType: InputParamFetcherType.RAW_BYTES, paramData: abi.encode(fee), constraints: emptyConstraints
         });
 
         // === end struct ==
diff --git a/test/unit/ComposableExecution_ConstraintsReverts.sol b/test/unit/ComposableExecution_ConstraintsReverts.sol
diff --git a/test/unit/ComposableExecution_Simple.t.sol b/test/unit/ComposableExecution_Simple.t.sol

Original file line number	Diff line number	Diff line change
`@@ -110,4 +110,8 @@ contract DummyContract {`
`110`	`110`	`function payableEmit() external payable {`
`111`	`111`	`emit Received(msg.value);`
`112`	`112`	`}`
	`113`	`+`
	`114`	`+ function getSignedValue() external pure returns (int256) {`
	`115`	`+ return -42;`
	`116`	`+ }`
`113`	`117`	`}`