@layerzerolabs/utils-upgradeable-evm-contracts 1.2.9 → 1.2.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (17) hide show
  1. package/.turbo/turbo-lint.log +232 -228
  2. package/.turbo/turbo-test.log +765 -734
  3. package/package.json +4 -4
  4. package/test/AccessControl2StepUpgradeable.t.sol +115 -111
  5. package/test/AllowlistBaseUpgradeable.t.sol +10 -15
  6. package/test/AllowlistRBACUpgradeable.t.sol +20 -16
  7. package/test/FeeConfigBaseUpgradeable.t.sol +68 -70
  8. package/test/FeeConfigRBACUpgradeable.t.sol +13 -10
  9. package/test/FeeHandlerBaseUpgradeable.t.sol +22 -28
  10. package/test/FeeHandlerRBACUpgradeable.t.sol +12 -9
  11. package/test/PauseBaseUpgradeable.t.sol +72 -85
  12. package/test/PauseByIDBaseUpgradeable.t.sol +84 -94
  13. package/test/PauseByIDRBACUpgradeable.t.sol +101 -115
  14. package/test/PauseRBACUpgradeable.t.sol +74 -106
  15. package/test/RateLimiterBaseUpgradeable.t.sol +28 -24
  16. package/test/RateLimiterRBACUpgradeable.t.sol +22 -12
  17. package/test/RateLimiterRBACUpgradeableInvariant.t.sol +10 -10
package/test/PauseBaseUpgradeable.t.sol CHANGED
@@ -7,12 +7,7 @@ import { TransparentUpgradeableProxy } from "@openzeppelin/contracts/proxy/trans
7
7
  import { Test } from "forge-std/Test.sol";
8
8
  import { PauseBaseUpgradeable } from "./../contracts/pause/PauseBaseUpgradeable.sol";
9
9
 
10
- interface IPauseTestHelper is IPause {
11
- function pause() external;
12
- function unpause() external;
13
- }
14
-
15
- contract PauseBaseUpgradeableMock is PauseBaseUpgradeable {
10
+ contract PauseBaseUpgradeableHarness is PauseBaseUpgradeable {
16
11
  uint256 public callCount;
17
12
 
18
13
  constructor() {
@@ -43,16 +38,20 @@ contract PauseBaseUpgradeableMock is PauseBaseUpgradeable {
43
38
  }
44
39
 
45
40
  contract PauseBaseUpgradeableTest is Test {
46
- IPauseTestHelper pauseHelper;
41
+ PauseBaseUpgradeableHarness pause;
47
42
 
48
- function setUp() public virtual {
49
- PauseBaseUpgradeableMock impl = new PauseBaseUpgradeableMock();
43
+ function _deployPause() internal virtual returns (PauseBaseUpgradeableHarness) {
44
+ PauseBaseUpgradeableHarness impl = new PauseBaseUpgradeableHarness();
50
45
  TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(
51
46
  address(impl),
52
47
  address(this),
53
- abi.encodeWithSelector(PauseBaseUpgradeableMock.initialize.selector)
48
+ abi.encodeWithSelector(PauseBaseUpgradeableHarness.initialize.selector)
54
49
  );
55
- pauseHelper = IPauseTestHelper(address(proxy));
50
+ return PauseBaseUpgradeableHarness(address(proxy));
51
+ }
52
+
53
+ function setUp() public virtual {
54
+ pause = _deployPause();
56
55
  }
57
56
 
58
57
  function test_storageHash() public pure {
@@ -62,183 +61,171 @@ contract PauseBaseUpgradeableTest is Test {
62
61
  }
63
62
 
64
63
  function test_isPaused_InitialState() public view {
65
- assertFalse(pauseHelper.isPaused());
64
+ assertFalse(pause.isPaused());
66
65
  }
67
66
 
68
67
  function test_pause() public {
69
68
  vm.expectEmit(false, false, false, true);
70
69
  emit IPause.PauseSet(true);
71
- pauseHelper.pause();
70
+ pause.pause();
72
71
 
73
- assertTrue(pauseHelper.isPaused());
72
+ assertTrue(pause.isPaused());
74
73
  }
75
74
 
76
75
  function test_unpause() public {
77
- pauseHelper.pause();
78
- assertTrue(pauseHelper.isPaused());
76
+ pause.pause();
77
+ assertTrue(pause.isPaused());
79
78
 
80
79
  vm.expectEmit(false, false, false, true);
81
80
  emit IPause.PauseSet(false);
82
- pauseHelper.unpause();
81
+ pause.unpause();
83
82
 
84
- assertFalse(pauseHelper.isPaused());
83
+ assertFalse(pause.isPaused());
85
84
  }
86
85
 
87
86
  function test_setPaused_Fuzz(bool _paused) public {
88
87
  if (!_paused) {
89
88
  vm.expectRevert(abi.encodeWithSelector(IPause.PauseStateIdempotent.selector, false));
90
- pauseHelper.unpause();
89
+ pause.unpause();
91
90
  return;
92
91
  }
93
92
 
94
93
  vm.expectEmit(false, false, false, true);
95
94
  emit IPause.PauseSet(_paused);
96
- pauseHelper.pause();
97
- assertEq(pauseHelper.isPaused(), _paused);
95
+ pause.pause();
96
+ assertEq(pause.isPaused(), _paused);
98
97
  }
99
98
 
100
99
  function test_setPaused_Success_ToggleMultipleTimes() public {
101
- assertFalse(pauseHelper.isPaused());
100
+ assertFalse(pause.isPaused());
102
101
 
103
- pauseHelper.pause();
104
- assertTrue(pauseHelper.isPaused());
102
+ pause.pause();
103
+ assertTrue(pause.isPaused());
105
104
 
106
- pauseHelper.unpause();
107
- assertFalse(pauseHelper.isPaused());
105
+ pause.unpause();
106
+ assertFalse(pause.isPaused());
108
107
 
109
- pauseHelper.pause();
110
- assertTrue(pauseHelper.isPaused());
108
+ pause.pause();
109
+ assertTrue(pause.isPaused());
111
110
 
112
- pauseHelper.unpause();
113
- assertFalse(pauseHelper.isPaused());
111
+ pause.unpause();
112
+ assertFalse(pause.isPaused());
114
113
 
115
- pauseHelper.pause();
116
- assertTrue(pauseHelper.isPaused());
114
+ pause.pause();
115
+ assertTrue(pause.isPaused());
117
116
  }
118
117
 
119
118
  function test_assertNotPaused_Success() public view {
120
- PauseBaseUpgradeableMock(address(pauseHelper)).assertNotPaused();
119
+ pause.assertNotPaused();
121
120
  }
122
121
 
123
122
  function test_assertNotPaused_Revert_Paused() public {
124
- pauseHelper.pause();
123
+ pause.pause();
125
124
  vm.expectRevert(abi.encodeWithSelector(IPause.Paused.selector));
126
- PauseBaseUpgradeableMock(address(pauseHelper)).assertNotPaused();
125
+ pause.assertNotPaused();
127
126
  }
128
127
 
129
128
  function test_assertNotPaused_Fuzz(bool _paused) public {
130
129
  if (_paused) {
131
- pauseHelper.pause();
130
+ pause.pause();
132
131
  }
133
132
 
134
133
  if (_paused) {
135
134
  vm.expectRevert(abi.encodeWithSelector(IPause.Paused.selector));
136
- PauseBaseUpgradeableMock(address(pauseHelper)).assertNotPaused();
135
+ pause.assertNotPaused();
137
136
  } else {
138
- PauseBaseUpgradeableMock(address(pauseHelper)).assertNotPaused();
137
+ pause.assertNotPaused();
139
138
  }
140
139
  }
141
140
 
142
141
  function test_initialize_Revert_AlreadyInitialized() public virtual {
143
142
  vm.expectRevert(Initializable.InvalidInitialization.selector);
144
- PauseBaseUpgradeableMock(address(pauseHelper)).initialize();
143
+ pause.initialize();
145
144
  }
146
145
 
147
146
  function test_setPaused_Idempotent_Reverts() public {
148
- pauseHelper.pause();
147
+ pause.pause();
149
148
 
150
149
  vm.expectRevert(abi.encodeWithSelector(IPause.PauseStateIdempotent.selector, true));
151
- pauseHelper.pause();
150
+ pause.pause();
152
151
  }
153
152
 
154
153
  function test_setPaused_Idempotent_InitialState_Reverts() public {
155
- assertFalse(pauseHelper.isPaused());
154
+ assertFalse(pause.isPaused());
156
155
 
157
156
  vm.expectRevert(abi.encodeWithSelector(IPause.PauseStateIdempotent.selector, false));
158
- pauseHelper.unpause();
157
+ pause.unpause();
159
158
  }
160
159
 
161
160
  function test_whenNotPaused_Success() public {
162
- PauseBaseUpgradeableMock mock = PauseBaseUpgradeableMock(address(pauseHelper));
163
- mock.functionWithModifier();
164
- assertEq(mock.callCount(), 1);
161
+ pause.functionWithModifier();
162
+ assertEq(pause.callCount(), 1);
165
163
  }
166
164
 
167
165
  function test_whenNotPaused_Revert_Paused() public {
168
- pauseHelper.pause();
169
-
170
- PauseBaseUpgradeableMock mock = PauseBaseUpgradeableMock(address(pauseHelper));
166
+ pause.pause();
171
167
  vm.expectRevert(abi.encodeWithSelector(IPause.Paused.selector));
172
- mock.functionWithModifier();
168
+ pause.functionWithModifier();
173
169
 
174
- assertEq(mock.callCount(), 0);
170
+ assertEq(pause.callCount(), 0);
175
171
  }
176
172
 
177
173
  function test_whenNotPaused_Success_AfterUnpause() public {
178
- PauseBaseUpgradeableMock mock = PauseBaseUpgradeableMock(address(pauseHelper));
179
-
180
- pauseHelper.pause();
174
+ pause.pause();
181
175
 
182
176
  vm.expectRevert(abi.encodeWithSelector(IPause.Paused.selector));
183
- mock.functionWithModifier();
177
+ pause.functionWithModifier();
184
178
 
185
- pauseHelper.unpause();
179
+ pause.unpause();
186
180
 
187
- mock.functionWithModifier();
188
- assertEq(mock.callCount(), 1);
181
+ pause.functionWithModifier();
182
+ assertEq(pause.callCount(), 1);
189
183
  }
190
184
 
191
185
  function test_whenNotPaused_WithReturnValue() public view {
192
- PauseBaseUpgradeableMock mock = PauseBaseUpgradeableMock(address(pauseHelper));
193
- uint256 result = mock.functionWithModifierReturns();
186
+ uint256 result = pause.functionWithModifierReturns();
194
187
  assertEq(result, 42);
195
188
  }
196
189
 
197
190
  function test_whenNotPaused_Revert_WithReturnValue() public {
198
- pauseHelper.pause();
199
-
200
- PauseBaseUpgradeableMock mock = PauseBaseUpgradeableMock(address(pauseHelper));
191
+ pause.pause();
201
192
  vm.expectRevert(abi.encodeWithSelector(IPause.Paused.selector));
202
- mock.functionWithModifierReturns();
193
+ pause.functionWithModifierReturns();
203
194
  }
204
195
 
205
196
  function test_whenNotPaused_Fuzz(bool _paused) public {
206
197
  if (_paused) {
207
- pauseHelper.pause();
198
+ pause.pause();
208
199
  }
209
200
 
210
- PauseBaseUpgradeableMock mock = PauseBaseUpgradeableMock(address(pauseHelper));
211
-
212
201
  if (_paused) {
213
202
  vm.expectRevert(abi.encodeWithSelector(IPause.Paused.selector));
214
- mock.functionWithModifier();
215
- assertEq(mock.callCount(), 0);
203
+ pause.functionWithModifier();
204
+ assertEq(pause.callCount(), 0);
216
205
  } else {
217
- mock.functionWithModifier();
218
- assertEq(mock.callCount(), 1);
206
+ pause.functionWithModifier();
207
+ assertEq(pause.callCount(), 1);
219
208
  }
220
209
  }
221
210
 
222
211
  function test_whenNotPaused_Success_MultipleCalls() public {
223
- PauseBaseUpgradeableMock mock = PauseBaseUpgradeableMock(address(pauseHelper));
224
-
225
- mock.functionWithModifier();
226
- mock.functionWithModifier();
227
- mock.functionWithModifier();
228
- assertEq(mock.callCount(), 3);
212
+ pause.functionWithModifier();
213
+ pause.functionWithModifier();
214
+ pause.functionWithModifier();
215
+ assertEq(pause.callCount(), 3);
229
216
 
230
- pauseHelper.pause();
217
+ pause.pause();
231
218
 
232
219
  vm.expectRevert(abi.encodeWithSelector(IPause.Paused.selector));
233
- mock.functionWithModifier();
220
+ pause.functionWithModifier();
234
221
  vm.expectRevert(abi.encodeWithSelector(IPause.Paused.selector));
235
- mock.functionWithModifier();
236
- assertEq(mock.callCount(), 3);
222
+ pause.functionWithModifier();
223
+ assertEq(pause.callCount(), 3);
237
224
 
238
- pauseHelper.unpause();
225
+ pause.unpause();
239
226
 
240
- mock.functionWithModifier();
241
- mock.functionWithModifier();
242
- assertEq(mock.callCount(), 5);
227
+ pause.functionWithModifier();
228
+ pause.functionWithModifier();
229
+ assertEq(pause.callCount(), 5);
243
230
  }
244
231
  }
package/test/PauseByIDBaseUpgradeable.t.sol CHANGED
@@ -7,17 +7,7 @@ import { TransparentUpgradeableProxy } from "@openzeppelin/contracts/proxy/trans
7
7
  import { Test } from "forge-std/Test.sol";
8
8
  import { PauseByIDBaseUpgradeable } from "./../contracts/pause-by-id/PauseByIDBaseUpgradeable.sol";
9
9
 
10
- /// @dev Interface for pause mock with management and test helper functions.
11
- interface IPauseByIDBaseMock is IPauseByID {
12
- function setDefaultPaused(bool _paused) external;
13
- function setPaused(SetPausedParam[] calldata _params) external;
14
- function assertNotPaused(uint256 _id) external view;
15
- function functionWithModifier(uint256 _id) external;
16
- function functionWithModifierReturns(uint256 _id) external view returns (uint256);
17
- function callCount() external view returns (uint256);
18
- }
19
-
20
- contract PauseByIDBaseUpgradeableMock is PauseByIDBaseUpgradeable {
10
+ contract PauseByIDBaseUpgradeableHarness is PauseByIDBaseUpgradeable {
21
11
  uint256 public callCount;
22
12
 
23
13
  constructor() {
@@ -48,23 +38,23 @@ contract PauseByIDBaseUpgradeableMock is PauseByIDBaseUpgradeable {
48
38
  }
49
39
 
50
40
  contract PauseByIDBaseUpgradeableTest is Test {
51
- IPauseByIDBaseMock pauseHelper;
41
+ PauseByIDBaseUpgradeableHarness pause;
52
42
 
53
43
  uint32 constant ID_1 = 1;
54
44
  uint32 constant ID_2 = 2;
55
45
 
56
- function _createPause() internal virtual returns (IPauseByIDBaseMock) {
57
- PauseByIDBaseUpgradeableMock impl = new PauseByIDBaseUpgradeableMock();
46
+ function _deployPause() internal virtual returns (PauseByIDBaseUpgradeableHarness) {
47
+ PauseByIDBaseUpgradeableHarness impl = new PauseByIDBaseUpgradeableHarness();
58
48
  TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(
59
49
  address(impl),
60
50
  address(this),
61
- abi.encodeWithSelector(PauseByIDBaseUpgradeableMock.initialize.selector)
51
+ abi.encodeWithSelector(PauseByIDBaseUpgradeableHarness.initialize.selector)
62
52
  );
63
- return IPauseByIDBaseMock(address(proxy));
53
+ return PauseByIDBaseUpgradeableHarness(address(proxy));
64
54
  }
65
55
 
66
56
  function setUp() public virtual {
67
- pauseHelper = _createPause();
57
+ pause = _deployPause();
68
58
  }
69
59
 
70
60
  function test_storageHash() public pure {
@@ -74,33 +64,33 @@ contract PauseByIDBaseUpgradeableTest is Test {
74
64
  }
75
65
 
76
66
  function test_defaultPaused_InitialState() public view {
77
- assertFalse(pauseHelper.defaultPaused());
67
+ assertFalse(pause.defaultPaused());
78
68
  }
79
69
 
80
70
  function test_isPaused_InitialState() public view {
81
- assertFalse(pauseHelper.isPaused(ID_1));
82
- assertFalse(pauseHelper.isPaused(ID_2));
71
+ assertFalse(pause.isPaused(ID_1));
72
+ assertFalse(pause.isPaused(ID_2));
83
73
  }
84
74
 
85
75
  function test_setDefaultPaused() public {
86
76
  vm.expectEmit(false, false, false, true);
87
77
  emit IPauseByID.DefaultPauseSet(true);
88
- pauseHelper.setDefaultPaused(true);
78
+ pause.setDefaultPaused(true);
89
79
 
90
- assertTrue(pauseHelper.defaultPaused());
80
+ assertTrue(pause.defaultPaused());
91
81
  }
92
82
 
93
83
  function test_setDefaultPaused_Fuzz(bool _paused) public {
94
84
  if (!_paused) {
95
85
  vm.expectRevert(abi.encodeWithSelector(IPauseByID.PauseStateIdempotent.selector, false));
96
- pauseHelper.setDefaultPaused(_paused);
86
+ pause.setDefaultPaused(_paused);
97
87
  return;
98
88
  }
99
89
 
100
90
  vm.expectEmit(false, false, false, true);
101
91
  emit IPauseByID.DefaultPauseSet(_paused);
102
- pauseHelper.setDefaultPaused(_paused);
103
- assertEq(pauseHelper.defaultPaused(), _paused);
92
+ pause.setDefaultPaused(_paused);
93
+ assertEq(pause.defaultPaused(), _paused);
104
94
  }
105
95
 
106
96
  function test_setPaused() public {
@@ -109,9 +99,9 @@ contract PauseByIDBaseUpgradeableTest is Test {
109
99
 
110
100
  vm.expectEmit(false, false, false, true);
111
101
  emit IPauseByID.PauseSet(ID_1, true, true);
112
- pauseHelper.setPaused(params);
102
+ pause.setPaused(params);
113
103
 
114
- IPauseByID.PauseConfig memory config = pauseHelper.pauseConfig(ID_1);
104
+ IPauseByID.PauseConfig memory config = pause.pauseConfig(ID_1);
115
105
  assertTrue(config.paused);
116
106
  assertTrue(config.enabled);
117
107
  }
@@ -122,85 +112,85 @@ contract PauseByIDBaseUpgradeableTest is Test {
122
112
 
123
113
  vm.expectEmit(false, false, false, true);
124
114
  emit IPauseByID.PauseSet(_id, _paused, _enabled);
125
- pauseHelper.setPaused(params);
115
+ pause.setPaused(params);
126
116
 
127
- IPauseByID.PauseConfig memory config = pauseHelper.pauseConfig(_id);
117
+ IPauseByID.PauseConfig memory config = pause.pauseConfig(_id);
128
118
  assertEq(config.paused, _paused);
129
119
  assertEq(config.enabled, _enabled);
130
120
  }
131
121
 
132
122
  function test_setPaused_EmptyArray() public {
133
123
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](0);
134
- pauseHelper.setPaused(params);
124
+ pause.setPaused(params);
135
125
  }
136
126
 
137
127
  function test_isPaused_Default() public {
138
- pauseHelper.setDefaultPaused(true);
139
- assertTrue(pauseHelper.isPaused(ID_1));
140
- assertTrue(pauseHelper.isPaused(ID_2));
128
+ pause.setDefaultPaused(true);
129
+ assertTrue(pause.isPaused(ID_1));
130
+ assertTrue(pause.isPaused(ID_2));
141
131
  }
142
132
 
143
133
  function test_isPaused_Specific() public {
144
134
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](1);
145
135
  params[0] = IPauseByID.SetPausedParam(ID_1, true, true);
146
- pauseHelper.setPaused(params);
136
+ pause.setPaused(params);
147
137
 
148
- assertTrue(pauseHelper.isPaused(ID_1));
149
- assertFalse(pauseHelper.isPaused(ID_2));
138
+ assertTrue(pause.isPaused(ID_1));
139
+ assertFalse(pause.isPaused(ID_2));
150
140
  }
151
141
 
152
142
  function test_isPaused_SpecificDisabled() public {
153
- pauseHelper.setDefaultPaused(true);
143
+ pause.setDefaultPaused(true);
154
144
 
155
145
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](1);
156
146
  params[0] = IPauseByID.SetPausedParam(ID_1, true, true);
157
- pauseHelper.setPaused(params);
147
+ pause.setPaused(params);
158
148
 
159
149
  params[0] = IPauseByID.SetPausedParam(ID_1, false, false);
160
- pauseHelper.setPaused(params);
150
+ pause.setPaused(params);
161
151
 
162
152
  // When disabled, falls back to default.
163
- assertTrue(pauseHelper.isPaused(ID_1));
153
+ assertTrue(pause.isPaused(ID_1));
164
154
  }
165
155
 
166
156
  function test_isPaused_Override() public {
167
- pauseHelper.setDefaultPaused(true);
157
+ pause.setDefaultPaused(true);
168
158
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](1);
169
159
  params[0] = IPauseByID.SetPausedParam(ID_1, false, true);
170
- pauseHelper.setPaused(params);
160
+ pause.setPaused(params);
171
161
 
172
- assertFalse(pauseHelper.isPaused(ID_1));
173
- assertTrue(pauseHelper.isPaused(ID_2));
162
+ assertFalse(pause.isPaused(ID_1));
163
+ assertTrue(pause.isPaused(ID_2));
174
164
  }
175
165
 
176
166
  function test_assertNotPaused_Success() public view {
177
- pauseHelper.assertNotPaused(ID_1);
167
+ pause.assertNotPaused(ID_1);
178
168
  }
179
169
 
180
170
  function test_assertNotPaused_Revert_DefaultPaused() public {
181
- pauseHelper.setDefaultPaused(true);
171
+ pause.setDefaultPaused(true);
182
172
  vm.expectRevert(abi.encodeWithSelector(IPauseByID.Paused.selector, ID_1));
183
- pauseHelper.assertNotPaused(ID_1);
173
+ pause.assertNotPaused(ID_1);
184
174
  }
185
175
 
186
176
  function test_assertNotPaused_Revert_SpecificPaused() public {
187
177
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](1);
188
178
  params[0] = IPauseByID.SetPausedParam(ID_1, true, true);
189
- pauseHelper.setPaused(params);
179
+ pause.setPaused(params);
190
180
  vm.expectRevert(abi.encodeWithSelector(IPauseByID.Paused.selector, ID_1));
191
- pauseHelper.assertNotPaused(ID_1);
181
+ pause.assertNotPaused(ID_1);
192
182
  }
193
183
 
194
184
  function test_pauseConfig() public {
195
185
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](1);
196
186
  params[0] = IPauseByID.SetPausedParam(ID_1, true, true);
197
- pauseHelper.setPaused(params);
187
+ pause.setPaused(params);
198
188
 
199
- IPauseByID.PauseConfig memory config = pauseHelper.pauseConfig(ID_1);
189
+ IPauseByID.PauseConfig memory config = pause.pauseConfig(ID_1);
200
190
  assertTrue(config.paused);
201
191
  assertTrue(config.enabled);
202
192
 
203
- config = pauseHelper.pauseConfig(ID_2);
193
+ config = pause.pauseConfig(ID_2);
204
194
  assertFalse(config.paused);
205
195
  assertFalse(config.enabled);
206
196
  }
@@ -209,129 +199,129 @@ contract PauseByIDBaseUpgradeableTest is Test {
209
199
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](2);
210
200
  params[0] = IPauseByID.SetPausedParam(ID_1, true, true);
211
201
  params[1] = IPauseByID.SetPausedParam(ID_2, false, true);
212
- pauseHelper.setPaused(params);
202
+ pause.setPaused(params);
213
203
 
214
- assertTrue(pauseHelper.isPaused(ID_1));
215
- assertFalse(pauseHelper.isPaused(ID_2));
216
- assertFalse(pauseHelper.isPaused(3));
204
+ assertTrue(pause.isPaused(ID_1));
205
+ assertFalse(pause.isPaused(ID_2));
206
+ assertFalse(pause.isPaused(3));
217
207
  }
218
208
 
219
209
  function test_setPaused_Success_Toggle() public {
220
- assertFalse(pauseHelper.isPaused(ID_1));
210
+ assertFalse(pause.isPaused(ID_1));
221
211
 
222
212
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](1);
223
213
  params[0] = IPauseByID.SetPausedParam(ID_1, true, true);
224
- pauseHelper.setPaused(params);
225
- assertTrue(pauseHelper.isPaused(ID_1));
214
+ pause.setPaused(params);
215
+ assertTrue(pause.isPaused(ID_1));
226
216
 
227
217
  params[0] = IPauseByID.SetPausedParam(ID_1, false, true);
228
- pauseHelper.setPaused(params);
229
- assertFalse(pauseHelper.isPaused(ID_1));
218
+ pause.setPaused(params);
219
+ assertFalse(pause.isPaused(ID_1));
230
220
  }
231
221
 
232
222
  function test_defaultPause_AffectsMultipleIDs() public {
233
- pauseHelper.setDefaultPaused(true);
234
- assertTrue(pauseHelper.isPaused(1));
235
- assertTrue(pauseHelper.isPaused(2));
236
- assertTrue(pauseHelper.isPaused(100));
237
- assertTrue(pauseHelper.isPaused(type(uint256).max));
223
+ pause.setDefaultPaused(true);
224
+ assertTrue(pause.isPaused(1));
225
+ assertTrue(pause.isPaused(2));
226
+ assertTrue(pause.isPaused(100));
227
+ assertTrue(pause.isPaused(type(uint256).max));
238
228
  }
239
229
 
240
230
  function test_specificOverridesDefault_Fuzz(bool _defaultPaused, bool _specificPaused) public {
241
231
  if (_defaultPaused) {
242
- pauseHelper.setDefaultPaused(_defaultPaused);
232
+ pause.setDefaultPaused(_defaultPaused);
243
233
  }
244
234
 
245
235
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](1);
246
236
  params[0] = IPauseByID.SetPausedParam(ID_1, _specificPaused, true);
247
- pauseHelper.setPaused(params);
237
+ pause.setPaused(params);
248
238
 
249
- assertEq(pauseHelper.isPaused(ID_1), _specificPaused);
250
- assertEq(pauseHelper.isPaused(ID_2), _defaultPaused);
239
+ assertEq(pause.isPaused(ID_1), _specificPaused);
240
+ assertEq(pause.isPaused(ID_2), _defaultPaused);
251
241
  }
252
242
 
253
243
  function test_initialize_Revert_AlreadyInitialized() public virtual {
254
244
  vm.expectRevert(Initializable.InvalidInitialization.selector);
255
- PauseByIDBaseUpgradeableMock(address(pauseHelper)).initialize();
245
+ pause.initialize();
256
246
  }
257
247
 
258
248
  function test_setPaused_Success_EdgeCase_IDZero() public {
259
249
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](1);
260
250
  params[0] = IPauseByID.SetPausedParam(0, true, true);
261
- pauseHelper.setPaused(params);
262
- assertTrue(pauseHelper.isPaused(0));
251
+ pause.setPaused(params);
252
+ assertTrue(pause.isPaused(0));
263
253
  }
264
254
 
265
255
  function test_setPaused_Success_EdgeCase_IDMaxUint256() public {
266
256
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](1);
267
257
  params[0] = IPauseByID.SetPausedParam(type(uint256).max, true, true);
268
- pauseHelper.setPaused(params);
269
- assertTrue(pauseHelper.isPaused(type(uint256).max));
258
+ pause.setPaused(params);
259
+ assertTrue(pause.isPaused(type(uint256).max));
270
260
  }
271
261
 
272
262
  function test_setDefaultPaused_Idempotent_Reverts() public {
273
- pauseHelper.setDefaultPaused(true);
263
+ pause.setDefaultPaused(true);
274
264
 
275
265
  vm.expectRevert(abi.encodeWithSelector(IPauseByID.PauseStateIdempotent.selector, true));
276
- pauseHelper.setDefaultPaused(true);
266
+ pause.setDefaultPaused(true);
277
267
  }
278
268
 
279
269
  function test_setDefaultPaused_Idempotent_InitialState_Reverts() public {
280
- assertFalse(pauseHelper.defaultPaused());
270
+ assertFalse(pause.defaultPaused());
281
271
 
282
272
  vm.expectRevert(abi.encodeWithSelector(IPauseByID.PauseStateIdempotent.selector, false));
283
- pauseHelper.setDefaultPaused(false);
273
+ pause.setDefaultPaused(false);
284
274
  }
285
275
 
286
276
  // ============ Modifier Tests ============
287
277
 
288
278
  function test_whenNotPaused_Success() public {
289
- pauseHelper.functionWithModifier(ID_1);
290
- assertEq(pauseHelper.callCount(), 1);
279
+ pause.functionWithModifier(ID_1);
280
+ assertEq(pause.callCount(), 1);
291
281
  }
292
282
 
293
283
  function test_whenNotPaused_Revert_DefaultPaused() public {
294
- pauseHelper.setDefaultPaused(true);
284
+ pause.setDefaultPaused(true);
295
285
 
296
286
  vm.expectRevert(abi.encodeWithSelector(IPauseByID.Paused.selector, ID_1));
297
- pauseHelper.functionWithModifier(ID_1);
287
+ pause.functionWithModifier(ID_1);
298
288
 
299
- assertEq(pauseHelper.callCount(), 0);
289
+ assertEq(pause.callCount(), 0);
300
290
  }
301
291
 
302
292
  function test_whenNotPaused_Revert_SpecificPaused() public {
303
293
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](1);
304
294
  params[0] = IPauseByID.SetPausedParam(ID_1, true, true);
305
- pauseHelper.setPaused(params);
295
+ pause.setPaused(params);
306
296
 
307
297
  vm.expectRevert(abi.encodeWithSelector(IPauseByID.Paused.selector, ID_1));
308
- pauseHelper.functionWithModifier(ID_1);
298
+ pause.functionWithModifier(ID_1);
309
299
 
310
- assertEq(pauseHelper.callCount(), 0);
300
+ assertEq(pause.callCount(), 0);
311
301
  }
312
302
 
313
303
  function test_whenNotPaused_Success_SpecificUnpaused() public {
314
- pauseHelper.setDefaultPaused(true);
304
+ pause.setDefaultPaused(true);
315
305
 
316
306
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](1);
317
307
  params[0] = IPauseByID.SetPausedParam(ID_1, false, true);
318
- pauseHelper.setPaused(params);
308
+ pause.setPaused(params);
319
309
 
320
- pauseHelper.functionWithModifier(ID_1);
321
- assertEq(pauseHelper.callCount(), 1);
310
+ pause.functionWithModifier(ID_1);
311
+ assertEq(pause.callCount(), 1);
322
312
  }
323
313
 
324
314
  function test_whenNotPaused_WithReturnValue() public view {
325
- uint256 result = pauseHelper.functionWithModifierReturns(ID_1);
315
+ uint256 result = pause.functionWithModifierReturns(ID_1);
326
316
  assertEq(result, 42);
327
317
  }
328
318
 
329
319
  function test_whenNotPaused_WithReturnValue_Reverts() public {
330
320
  IPauseByID.SetPausedParam[] memory params = new IPauseByID.SetPausedParam[](1);
331
321
  params[0] = IPauseByID.SetPausedParam(ID_1, true, true);
332
- pauseHelper.setPaused(params);
322
+ pause.setPaused(params);
333
323
 
334
324
  vm.expectRevert(abi.encodeWithSelector(IPauseByID.Paused.selector, ID_1));
335
- pauseHelper.functionWithModifierReturns(ID_1);
325
+ pause.functionWithModifierReturns(ID_1);
336
326
  }
337
327
  }