Skip to content

Commit 19b29b6

Browse files
rappierappie
authored
Merge pull request #2 from ljz3/main
Added disable logging option for clamping
2 parents d9d0e7d + 729be03 commit 19b29b6

3 files changed

Lines changed: 189 additions & 102 deletions

File tree

‎src/ClampHelper.sol‎

Lines changed: 122 additions & 100 deletions
Original file line numberDiff line numberDiff line change
@@ -12,19 +12,22 @@ abstract contract ClampHelper is AssertHelper {
1212
function clampBetween(
1313
uint256 value,
1414
uint256 low,
15-
uint256 high
15+
uint256 high,
16+
bool enableLogs
1617
) internal returns (uint256) {
1718
if (value < low || value > high) {
1819
uint256 ans = low + (value % (high - low + 1));
19-
string memory valueStr = FuzzLibString.toString(value);
20-
string memory ansStr = FuzzLibString.toString(ans);
21-
bytes memory message = abi.encodePacked(
22-
"Clamping value ",
23-
valueStr,
24-
" to ",
25-
ansStr
26-
);
27-
emit Clamped(string(message));
20+
if (enableLogs) {
21+
string memory valueStr = FuzzLibString.toString(value);
22+
string memory ansStr = FuzzLibString.toString(ans);
23+
bytes memory message = abi.encodePacked(
24+
"Clamping value ",
25+
valueStr,
26+
" to ",
27+
ansStr
28+
);
29+
emit Clamped(string(message));
30+
}
2831
return ans;
2932
}
3033
return value;
@@ -34,178 +37,197 @@ abstract contract ClampHelper is AssertHelper {
3437
function clampBetween(
3538
int256 value,
3639
int256 low,
37-
int256 high
40+
int256 high,
41+
bool enableLogs
3842
) internal returns (int256) {
3943
if (value < low || value > high) {
4044
int256 range = high - low + 1;
4145
int256 clamped = (value - low) % (range);
4246
if (clamped < 0) clamped += range;
4347
int256 ans = low + clamped;
44-
string memory valueStr = FuzzLibString.toString(value);
45-
string memory ansStr = FuzzLibString.toString(ans);
46-
bytes memory message = abi.encodePacked(
47-
"Clamping value ",
48-
valueStr,
49-
" to ",
50-
ansStr
51-
);
52-
emit Clamped(string(message));
48+
if (enableLogs) {
49+
string memory valueStr = FuzzLibString.toString(value);
50+
string memory ansStr = FuzzLibString.toString(ans);
51+
bytes memory message = abi.encodePacked(
52+
"Clamping value ",
53+
valueStr,
54+
" to ",
55+
ansStr
56+
);
57+
emit Clamped(string(message));
58+
}
5359
return ans;
5460
}
5561
return value;
5662
}
5763

5864
/// @notice clamps a to be less than b
59-
function clampLt(uint256 a, uint256 b) internal returns (uint256) {
65+
function clampLt(uint256 a, uint256 b, bool enableLogs) internal returns (uint256) {
6066
if (!(a < b)) {
6167
assertNeq(
6268
b,
6369
0,
6470
"clampLt cannot clamp value a to be less than zero. Check your inputs/assumptions."
6571
);
6672
uint256 value = a % b;
67-
string memory aStr = FuzzLibString.toString(a);
68-
string memory valueStr = FuzzLibString.toString(value);
69-
bytes memory message = abi.encodePacked(
70-
"Clamping value ",
71-
aStr,
72-
" to ",
73-
valueStr
74-
);
75-
emit Clamped(string(message));
73+
if (enableLogs) {
74+
string memory aStr = FuzzLibString.toString(a);
75+
string memory valueStr = FuzzLibString.toString(value);
76+
bytes memory message = abi.encodePacked(
77+
"Clamping value ",
78+
aStr,
79+
" to ",
80+
valueStr
81+
);
82+
emit Clamped(string(message));
83+
}
7684
return value;
7785
}
7886
return a;
7987
}
8088

8189
/// @notice int256 version of clampLt
82-
function clampLt(int256 a, int256 b) internal returns (int256) {
90+
function clampLt(int256 a, int256 b, bool enableLogs) internal returns (int256) {
8391
if (!(a < b)) {
8492
int256 value = b - 1;
85-
string memory aStr = FuzzLibString.toString(a);
86-
string memory valueStr = FuzzLibString.toString(value);
87-
bytes memory message = abi.encodePacked(
88-
"Clamping value ",
89-
aStr,
90-
" to ",
91-
valueStr
92-
);
93-
emit Clamped(string(message));
93+
if (enableLogs) {
94+
string memory aStr = FuzzLibString.toString(a);
95+
string memory valueStr = FuzzLibString.toString(value);
96+
bytes memory message = abi.encodePacked(
97+
"Clamping value ",
98+
aStr,
99+
" to ",
100+
valueStr
101+
);
102+
emit Clamped(string(message));
103+
}
94104
return value;
95105
}
96106
return a;
97107
}
98108

99109
/// @notice clamps a to be less than or equal to b
100-
function clampLte(uint256 a, uint256 b) internal returns (uint256) {
110+
function clampLte(uint256 a, uint256 b, bool enableLogs) internal returns (uint256) {
101111
if (!(a <= b)) {
102112
uint256 value = a % (b + 1);
103-
string memory aStr = FuzzLibString.toString(a);
104-
string memory valueStr = FuzzLibString.toString(value);
105-
bytes memory message = abi.encodePacked(
106-
"Clamping value ",
107-
aStr,
108-
" to ",
109-
valueStr
110-
);
111-
emit Clamped(string(message));
113+
if (enableLogs) {
114+
string memory aStr = FuzzLibString.toString(a);
115+
string memory valueStr = FuzzLibString.toString(value);
116+
bytes memory message = abi.encodePacked(
117+
"Clamping value ",
118+
aStr,
119+
" to ",
120+
valueStr
121+
);
122+
emit Clamped(string(message));
123+
}
112124
return value;
113125
}
114126
return a;
115127
}
116128

117129
/// @notice int256 version of clampLte
118-
function clampLte(int256 a, int256 b) internal returns (int256) {
130+
function clampLte(int256 a, int256 b, bool enableLogs) internal returns (int256) {
119131
if (!(a <= b)) {
120132
int256 value = b;
121-
string memory aStr = FuzzLibString.toString(a);
122-
string memory valueStr = FuzzLibString.toString(value);
123-
bytes memory message = abi.encodePacked(
124-
"Clamping value ",
125-
aStr,
126-
" to ",
127-
valueStr
128-
);
129-
emit Clamped(string(message));
133+
if (enableLogs) {
134+
string memory aStr = FuzzLibString.toString(a);
135+
string memory valueStr = FuzzLibString.toString(value);
136+
bytes memory message = abi.encodePacked(
137+
"Clamping value ",
138+
aStr,
139+
" to ",
140+
valueStr
141+
);
142+
emit Clamped(string(message));
143+
}
130144
return value;
131145
}
132146
return a;
133147
}
134148

135149
/// @notice clamps a to be greater than b
136-
function clampGt(uint256 a, uint256 b) internal returns (uint256) {
150+
function clampGt(uint256 a, uint256 b, bool enableLogs) internal returns (uint256) {
137151
if (!(a > b)) {
138152
assertNeq(
139153
b,
140154
type(uint256).max,
141155
"clampGt cannot clamp value a to be larger than uint256.max. Check your inputs/assumptions."
142156
);
143157
uint256 value = b + 1;
144-
string memory aStr = FuzzLibString.toString(a);
145-
string memory valueStr = FuzzLibString.toString(value);
146-
bytes memory message = abi.encodePacked(
147-
"Clamping value ",
148-
aStr,
149-
" to ",
150-
valueStr
151-
);
152-
emit Clamped(string(message));
158+
if (enableLogs) {
159+
string memory aStr = FuzzLibString.toString(a);
160+
string memory valueStr = FuzzLibString.toString(value);
161+
bytes memory message = abi.encodePacked(
162+
"Clamping value ",
163+
aStr,
164+
" to ",
165+
valueStr
166+
);
167+
emit Clamped(string(message));
168+
}
153169
return value;
154170
} else {
155171
return a;
156172
}
157173
}
158174

159175
/// @notice int256 version of clampGt
160-
function clampGt(int256 a, int256 b) internal returns (int256) {
176+
function clampGt(int256 a, int256 b, bool enableLogs) internal returns (int256) {
161177
if (!(a > b)) {
162178
int256 value = b + 1;
163-
string memory aStr = FuzzLibString.toString(a);
164-
string memory valueStr = FuzzLibString.toString(value);
165-
bytes memory message = abi.encodePacked(
166-
"Clamping value ",
167-
aStr,
168-
" to ",
169-
valueStr
170-
);
171-
emit Clamped(string(message));
179+
if (enableLogs) {
180+
string memory aStr = FuzzLibString.toString(a);
181+
string memory valueStr = FuzzLibString.toString(value);
182+
bytes memory message = abi.encodePacked(
183+
"Clamping value ",
184+
aStr,
185+
" to ",
186+
valueStr
187+
);
188+
emit Clamped(string(message));
189+
}
172190
return value;
173191
} else {
174192
return a;
175193
}
176194
}
177195

178196
/// @notice clamps a to be greater than or equal to b
179-
function clampGte(uint256 a, uint256 b) internal returns (uint256) {
197+
function clampGte(uint256 a, uint256 b, bool enableLogs) internal returns (uint256) {
180198
if (!(a > b)) {
181199
uint256 value = b;
182-
string memory aStr = FuzzLibString.toString(a);
183-
string memory valueStr = FuzzLibString.toString(value);
184-
bytes memory message = abi.encodePacked(
185-
"Clamping value ",
186-
aStr,
187-
" to ",
188-
valueStr
189-
);
190-
emit Clamped(string(message));
200+
if (enableLogs) {
201+
string memory aStr = FuzzLibString.toString(a);
202+
string memory valueStr = FuzzLibString.toString(value);
203+
bytes memory message = abi.encodePacked(
204+
"Clamping value ",
205+
aStr,
206+
" to ",
207+
valueStr
208+
);
209+
emit Clamped(string(message));
210+
}
191211
return value;
192212
}
193213
return a;
194214
}
195215

196216
/// @notice int256 version of clampGte
197-
function clampGte(int256 a, int256 b) internal returns (int256) {
217+
function clampGte(int256 a, int256 b, bool enableLogs) internal returns (int256) {
198218
if (!(a > b)) {
199219
int256 value = b;
200-
string memory aStr = FuzzLibString.toString(a);
201-
string memory valueStr = FuzzLibString.toString(value);
202-
bytes memory message = abi.encodePacked(
203-
"Clamping value ",
204-
aStr,
205-
" to ",
206-
valueStr
207-
);
208-
emit Clamped(string(message));
220+
if (enableLogs) {
221+
string memory aStr = FuzzLibString.toString(a);
222+
string memory valueStr = FuzzLibString.toString(value);
223+
bytes memory message = abi.encodePacked(
224+
"Clamping value ",
225+
aStr,
226+
" to ",
227+
valueStr
228+
);
229+
emit Clamped(string(message));
230+
}
209231
return value;
210232
}
211233
return a;

‎src/ClampWrapper.sol‎

Lines changed: 65 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,65 @@
1+
// SPDX-License-Identifier: MIT
2+
pragma solidity ^0.8.0;
3+
4+
import "./ClampHelper.sol";
5+
6+
abstract contract ClampWrapper is ClampHelper {
7+
8+
/// @notice Clamps value to be between low and high, both inclusive
9+
function clampBetween(
10+
uint256 value,
11+
uint256 low,
12+
uint256 high
13+
) internal returns (uint256) {
14+
return clampBetween(value, low, high, true);
15+
}
16+
17+
/// @notice int256 version of clampBetween
18+
function clampBetween(
19+
int256 value,
20+
int256 low,
21+
int256 high
22+
) internal returns (int256) {
23+
return clampBetween(value, low, high, true);
24+
}
25+
26+
/// @notice clamps a to be less than b
27+
function clampLt(uint256 a, uint256 b) internal returns (uint256) {
28+
return clampLt(a, b);
29+
}
30+
31+
/// @notice int256 version of clampLt
32+
function clampLt(int256 a, int256 b) internal returns (int256) {
33+
return clampLt(a, b, true);
34+
}
35+
36+
/// @notice clamps a to be less than or equal to b
37+
function clampLte(uint256 a, uint256 b) internal returns (uint256) {
38+
return clampLte(a, b, true);
39+
}
40+
41+
/// @notice int256 version of clampLte
42+
function clampLte(int256 a, int256 b) internal returns (int256) {
43+
return clampLte(a, b, true);
44+
}
45+
46+
/// @notice clamps a to be greater than b
47+
function clampGt(uint256 a, uint256 b) internal returns (uint256) {
48+
return clampGt(a, b, true);
49+
}
50+
51+
/// @notice int256 version of clampGt
52+
function clampGt(int256 a, int256 b) internal returns (int256) {
53+
return clampGt(a, b, true);
54+
}
55+
56+
/// @notice clamps a to be greater than or equal to b
57+
function clampGte(uint256 a, uint256 b) internal returns (uint256) {
58+
return clampGte(a, b, true);
59+
}
60+
61+
/// @notice int256 version of clampGte
62+
function clampGte(int256 a, int256 b) internal returns (int256) {
63+
return clampGte(a, b, true);
64+
}
65+
}

‎src/FuzzBase.sol‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,6 @@ pragma solidity ^0.8.0;
44
import "./Logging.sol";
55
import "./Constants.sol";
66
import "./AssertHelper.sol";
7-
import "./ClampHelper.sol";
7+
import "./ClampWrapper.sol";
88

9-
abstract contract FuzzBase is AssertHelper, ClampHelper, Logging, Constants {}
9+
abstract contract FuzzBase is AssertHelper, ClampWrapper, Logging, Constants {}

0 commit comments

Comments
 (0)