Skip to content

Commit e9bed70

Browse files
moglu2017moglu2017
authored
Optimize pause code (#1222)
1 parent 49c5904 commit e9bed70

2 files changed

Lines changed: 38 additions & 59 deletions

File tree

‎builtin/staker_native.go‎

Lines changed: 30 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@
66
package builtin
77

88
import (
9+
"errors"
910
"fmt"
1011
"math"
1112
"math/big"
@@ -19,30 +20,36 @@ import (
1920
"github.com/vechain/thor/v2/xenv"
2021
)
2122

22-
// The stargate pause switch at binary position 0. (binary: 1 0 [1])
23-
func IsStargatePaused(state *state.State, charger *gascharger.Charger) (bool, error) {
23+
func isContractPaused(state *state.State, charger *gascharger.Charger, pauseBit int) (bool, error) {
2424
charger.Charge(thor.SloadGas)
2525
switches, err := Params.Native(state).Get(thor.KeyStargateSwitches)
2626
if err != nil {
2727
return false, err
2828
}
29-
if switches == nil {
30-
return false, nil
29+
return switches.Bit(pauseBit) == 1, nil
30+
}
31+
32+
func IsStargatePaused(state *state.State, charger *gascharger.Charger) error {
33+
isPaused, err := isContractPaused(state, charger, 0)
34+
if err != nil {
35+
return err
36+
}
37+
if isPaused {
38+
return errors.New("stargate is paused")
3139
}
32-
return switches.Bit(0) == 1, nil
40+
return nil
3341
}
3442

3543
// The staker pause switch at binary position 1. (binary: 1 [1] 0)
36-
func IsStakerPaused(state *state.State, charger *gascharger.Charger) (bool, error) {
37-
charger.Charge(thor.SloadGas)
38-
switches, err := Params.Native(state).Get(thor.KeyStargateSwitches)
44+
func IsStakerPaused(state *state.State, charger *gascharger.Charger) error {
45+
isPaused, err := isContractPaused(state, charger, 1)
3946
if err != nil {
40-
return false, err
47+
return err
4148
}
42-
if switches == nil {
43-
return false, nil
49+
if isPaused {
50+
return errors.New("staker is paused")
4451
}
45-
return switches.Bit(1) == 1, nil
52+
return nil
4653
}
4754

4855
func init() {
@@ -160,11 +167,9 @@ func init() {
160167
env.ParseArgs(&args)
161168
charger := gascharger.New(env)
162169

163-
isPaused, err := IsStakerPaused(env.State(), charger)
170+
err := IsStakerPaused(env.State(), charger)
164171
if err != nil {
165172
return []any{new(big.Int), fmt.Sprintf("revert: %v", err)}
166-
} else if isPaused {
167-
return []any{new(big.Int), "revert: staker is paused"}
168173
}
169174

170175
stake, err := Staker.NativeMetered(env.State(), charger).WithdrawStake(
@@ -188,11 +193,9 @@ func init() {
188193
env.ParseArgs(&args)
189194
charger := gascharger.New(env)
190195

191-
isPaused, err := IsStakerPaused(env.State(), charger)
196+
err := IsStakerPaused(env.State(), charger)
192197
if err != nil {
193198
return []any{fmt.Sprintf("revert: %v", err)}
194-
} else if isPaused {
195-
return []any{"revert: staker is paused"}
196199
}
197200

198201
isPoSActive, err := Staker.NativeMetered(env.State(), charger).IsPoSActive()
@@ -236,11 +239,9 @@ func init() {
236239
env.ParseArgs(&args)
237240
charger := gascharger.New(env)
238241

239-
isPaused, err := IsStakerPaused(env.State(), charger)
242+
err := IsStakerPaused(env.State(), charger)
240243
if err != nil {
241244
return []any{fmt.Sprintf("revert: %v", err)}
242-
} else if isPaused {
243-
return []any{"revert: staker is paused"}
244245
}
245246

246247
err = Staker.NativeMetered(env.State(), charger).
@@ -262,11 +263,9 @@ func init() {
262263
env.ParseArgs(&args)
263264
charger := gascharger.New(env)
264265

265-
isPaused, err := IsStakerPaused(env.State(), charger)
266+
err := IsStakerPaused(env.State(), charger)
266267
if err != nil {
267268
return []any{fmt.Sprintf("revert: %v", err)}
268-
} else if isPaused {
269-
return []any{"revert: staker is paused"}
270269
}
271270

272271
err = Staker.NativeMetered(env.State(), charger).
@@ -290,11 +289,9 @@ func init() {
290289
env.ParseArgs(&args)
291290
charger := gascharger.New(env)
292291

293-
isPaused, err := IsStakerPaused(env.State(), charger)
292+
err := IsStakerPaused(env.State(), charger)
294293
if err != nil {
295294
return []any{fmt.Sprintf("revert: %v", err)}
296-
} else if isPaused {
297-
return []any{"revert: staker is paused"}
298295
}
299296

300297
err = Staker.NativeMetered(env.State(), charger).
@@ -317,18 +314,14 @@ func init() {
317314
env.ParseArgs(&args)
318315
charger := gascharger.New(env)
319316

320-
isPaused, err := IsStargatePaused(env.State(), charger)
317+
err := IsStargatePaused(env.State(), charger)
321318
if err != nil {
322319
return []any{new(big.Int), fmt.Sprintf("revert: %v", err)}
323-
} else if isPaused {
324-
return []any{new(big.Int), "revert: stargate is paused"}
325320
}
326321

327-
isPaused, err = IsStakerPaused(env.State(), charger)
322+
err = IsStakerPaused(env.State(), charger)
328323
if err != nil {
329324
return []any{new(big.Int), fmt.Sprintf("revert: %v", err)}
330-
} else if isPaused {
331-
return []any{new(big.Int), "revert: staker is paused"}
332325
}
333326

334327
delegationID, err := Staker.NativeMetered(env.State(), charger).
@@ -349,18 +342,14 @@ func init() {
349342
env.ParseArgs(&args)
350343
charger := gascharger.New(env)
351344

352-
isPaused, err := IsStargatePaused(env.State(), charger)
345+
err := IsStargatePaused(env.State(), charger)
353346
if err != nil {
354347
return []any{new(big.Int), fmt.Sprintf("revert: %v", err)}
355-
} else if isPaused {
356-
return []any{new(big.Int), "revert: stargate is paused"}
357348
}
358349

359-
isPaused, err = IsStakerPaused(env.State(), charger)
350+
err = IsStakerPaused(env.State(), charger)
360351
if err != nil {
361352
return []any{new(big.Int), fmt.Sprintf("revert: %v", err)}
362-
} else if isPaused {
363-
return []any{new(big.Int), "revert: staker is paused"}
364353
}
365354

366355
stake, err := Staker.NativeMetered(env.State(), charger).WithdrawDelegation(args.DelegationID)
@@ -377,18 +366,14 @@ func init() {
377366
env.ParseArgs(&args)
378367
charger := gascharger.New(env)
379368

380-
isPaused, err := IsStargatePaused(env.State(), charger)
369+
err := IsStargatePaused(env.State(), charger)
381370
if err != nil {
382371
return []any{fmt.Sprintf("revert: %v", err)}
383-
} else if isPaused {
384-
return []any{"revert: stargate is paused"}
385372
}
386373

387-
isPaused, err = IsStakerPaused(env.State(), charger)
374+
err = IsStakerPaused(env.State(), charger)
388375
if err != nil {
389376
return []any{fmt.Sprintf("revert: %v", err)}
390-
} else if isPaused {
391-
return []any{"revert: staker is paused"}
392377
}
393378

394379
err = Staker.NativeMetered(env.State(), charger).SignalDelegationExit(args.DelegationID)

‎builtin/staker_native_pause_test.go‎

Lines changed: 8 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -193,55 +193,49 @@ func TestIsStargatePaused(t *testing.T) {
193193
charger := gascharger.New(setup.Xenv(setup.params, nil))
194194

195195
// The KeyStargateSwitches not initialized, so the stargate is not paused
196-
isPaused, err := builtin.IsStargatePaused(setup.state, charger)
196+
err := builtin.IsStargatePaused(setup.state, charger)
197197
require.NoError(t, err, "Function IsStargatePaused should not return error %s", err)
198-
require.False(t, isPaused, "Stargate should not be paused")
199198

200199
// Set Stargate pause active
201200
result := executeParamesNativeMethod(t, setup, "native_set", []any{thor.KeyStargateSwitches, big.NewInt(3)}) // Set the first bit to 1
202201
_, err = unpackResult(result)
203202
require.NoError(t, err, "Function native_set should not return error %s", err)
204203

205-
isPaused, err = builtin.IsStargatePaused(setup.state, charger)
206-
require.NoError(t, err, "Function IsStargatePaused should not return error %s", err)
207-
require.True(t, isPaused, "Stargate should be paused")
204+
err = builtin.IsStargatePaused(setup.state, charger)
205+
require.ErrorContains(t, err, "stargate is paused", "Function IsStargatePaused should return error")
208206

209207
// Set Stargate pause inactive
210208
result = executeParamesNativeMethod(t, setup, "native_set", []any{thor.KeyStargateSwitches, big.NewInt(0)}) // Set the first bit to 0
211209
_, err = unpackResult(result)
212210
require.NoError(t, err, "Function native_set should not return error %s", err)
213211

214-
isPaused, err = builtin.IsStargatePaused(setup.state, charger)
212+
err = builtin.IsStargatePaused(setup.state, charger)
215213
require.NoError(t, err, "Function IsStargatePaused should not return error %s", err)
216-
require.False(t, isPaused, "Stargate should not be paused")
217214
}
218215

219216
func TestIsStakerPaused(t *testing.T) {
220217
setup := createPauseTestSetup(t)
221218
charger := gascharger.New(setup.Xenv(setup.params, nil))
222219

223220
// The KeyStargateSwitches not initialized, so the Staker is not paused
224-
isPaused, err := builtin.IsStakerPaused(setup.state, charger)
221+
err := builtin.IsStakerPaused(setup.state, charger)
225222
require.NoError(t, err, "Function IsStakerPaused should not return error %s", err)
226-
require.False(t, isPaused, "Staker should not be paused")
227223

228224
// Set Staker pause active
229225
result := executeParamesNativeMethod(t, setup, "native_set", []any{thor.KeyStargateSwitches, big.NewInt(2)}) // Set the second bit to 1
230226
_, err = unpackResult(result)
231227
require.NoError(t, err, "Function native_set should not return error %s", err)
232228

233-
isPaused, err = builtin.IsStakerPaused(setup.state, charger)
234-
require.NoError(t, err, "Function IsStakerPaused should not return error %s", err)
235-
require.True(t, isPaused, "Staker should be paused")
229+
err = builtin.IsStakerPaused(setup.state, charger)
230+
require.ErrorContains(t, err, "staker is paused", "Function IsStakerPaused should return error")
236231

237232
// Set Staker pause inactive
238233
result = executeParamesNativeMethod(t, setup, "native_set", []any{thor.KeyStargateSwitches, big.NewInt(4)}) // Set the second bit to 0
239234
_, err = unpackResult(result)
240235
require.NoError(t, err, "Function native_set should not return error %s", err)
241236

242-
isPaused, err = builtin.IsStakerPaused(setup.state, charger)
237+
err = builtin.IsStakerPaused(setup.state, charger)
243238
require.NoError(t, err, "Function IsStakerPaused should not return error %s", err)
244-
require.False(t, isPaused, "Staker should not be paused")
245239
}
246240

247241
func TestAddAndExitValidatorForPause(t *testing.T) {

0 commit comments

Comments
 (0)