@@ -32,11 +32,20 @@ library Lib4337 {
3232 }
3333
3434 function checkValidation (uint256 validationData ) internal view returns (bool ) {
35+ if (validationData == 0 ) {
36+ return true ;
37+ }
3538 (uint48 vAfter , uint48 vUntil , address res ) = Lib4337.parseValidationData (validationData);
36- if (vAfter > block .timestamp || vUntil < block .timestamp ) {
37- return false ;
39+ uint256 current;
40+ if (_usesBlockNumberFormat (vAfter, vUntil)) {
41+ vAfter &= MODE_BIT - 1 ;
42+ vUntil &= MODE_BIT - 1 ;
43+ current = block .number ;
44+ } else {
45+ current = block .timestamp ;
3846 }
39- return res == address (0 );
47+ // Canonical EntryPoint v0.9 interval: (validAfter, validUntil].
48+ return res == address (0 ) && current > vAfter && current <= vUntil;
4049 }
4150
4251 /// @dev Variant of `_hashTypedData` that excludes the chain ID.
@@ -78,25 +87,8 @@ library Lib4337 {
7887 return preValidationData | validationRes;
7988 }
8089
81- // Extract raw time bounds
82- uint48 validUntil1 = uint48 (preValidationData >> 160 );
83- uint48 validUntil2 = uint48 (validationRes >> 160 );
84- uint48 validAfter1 = uint48 (preValidationData >> 208 );
85- uint48 validAfter2 = uint48 (validationRes >> 208 );
86-
87- // Check for validity format mismatch (EP v0.9: block number vs timestamp)
88- // Block number format: both validAfter and validUntil have highest bit set
89- bool preUsesBlock = _usesBlockNumberFormat (validAfter1, validUntil1);
90- bool resUsesBlock = _usesBlockNumberFormat (validAfter2, validUntil2);
91- require (preUsesBlock == resUsesBlock, ValidityFormatMismatch ());
92-
93- // Convert validUntil=0 to max (no expiry)
94- if (validUntil1 == 0 ) validUntil1 = type (uint48 ).max;
95- if (validUntil2 == 0 ) validUntil2 = type (uint48 ).max;
96-
97- resValidationData = uint256 (validUntil1 > validUntil2 ? validUntil2 : validUntil1) << 160 ;
98- resValidationData |= uint256 (validAfter1 < validAfter2 ? validAfter2 : validAfter1) << 208 ;
99-
90+ // Aggregator FIRST: resolve success / failure / conflict before touching the ranges.
91+ //
10092 // Aggregator values: 0 = success, 1 = failure, >1 = aggregator address
10193 //
10294 // Rules (in precedence order):
@@ -109,20 +101,51 @@ library Lib4337 {
109101 uint160 preAgg = uint160 (preValidationData);
110102 uint160 resAgg = uint160 (validationRes);
111103
112- uint160 finalAgg;
113-
114- finalAgg = (preAgg == 1 || resAgg == 1 )
104+ uint160 finalAgg = (preAgg == 1 || resAgg == 1 )
115105 ? 1 // Any failure
116106 : (preAgg == 0 && resAgg == 0 )
117107 ? 0 // Both success
118108 : (preAgg > 1 && resAgg == 0 )
119- ? preAgg // Preserve aggregator (FIX)
109+ ? preAgg // Preserve aggregator
120110 : (preAgg == 0 && resAgg > 1 )
121111 ? resAgg // Use new aggregator
122112 : (preAgg == resAgg)
123113 ? preAgg // Same aggregator
124114 : 1 ; // Conflict or unknown
125115
116+ // Extract raw time bounds
117+ uint48 validUntil1 = uint48 (preValidationData >> 160 );
118+ uint48 validUntil2 = uint48 (validationRes >> 160 );
119+ uint48 validAfter1 = uint48 (preValidationData >> 208 );
120+ uint48 validAfter2 = uint48 (validationRes >> 208 );
121+
122+ // Normalize validUntil=0 to max (no expiry) BEFORE classifying the format. Doing this
123+ // after the format check misclassifies an unbounded block range (validUntil=0) as a
124+ // timestamp range, letting a mixed intersection drop a future timestamp start.
125+ if (validUntil1 == 0 ) validUntil1 = type (uint48 ).max;
126+ if (validUntil2 == 0 ) validUntil2 = type (uint48 ).max;
127+
128+ // Only enforce format compatibility for a usable (non-failure) result. When either side
129+ // reports signature failure (finalAgg == 1) the op is rejected regardless of its time
130+ // bounds, and a failed operand carries zeroed bounds that must not trigger a spurious
131+ // ValidityFormatMismatch revert — so the check is skipped. A neutral [0, max] range
132+ // carries no restriction and no format and is likewise exempt (its normalized validUntil
133+ // has MODE_BIT set, which would otherwise misclassify it as a block range).
134+ if (finalAgg != 1 ) {
135+ bool preNeutral = validAfter1 == 0 && validUntil1 == type (uint48 ).max;
136+ bool resNeutral = validAfter2 == 0 && validUntil2 == type (uint48 ).max;
137+ // Block number format: both validAfter and validUntil have the highest bit set.
138+ if (! preNeutral && ! resNeutral) {
139+ require (
140+ _usesBlockNumberFormat (validAfter1, validUntil1)
141+ == _usesBlockNumberFormat (validAfter2, validUntil2),
142+ ValidityFormatMismatch ()
143+ );
144+ }
145+ }
146+
147+ resValidationData = uint256 (validUntil1 > validUntil2 ? validUntil2 : validUntil1) << 160 ;
148+ resValidationData |= uint256 (validAfter1 < validAfter2 ? validAfter2 : validAfter1) << 208 ;
126149 resValidationData |= finalAgg;
127150 }
128151}
0 commit comments