Fix overflow issue, add tests (#1456)

Author: vanja-vechain

builtin/gen/compiled/Staker.bin-runtime

@@ -295,6 +295,7 @@ contract Staker {
     modifier checkStake(uint256 amount) {
         require(amount > 0, "staker: stake is empty");
         require(amount % 1e18 == 0, "staker: stake is not multiple of 1VET");
+        require(amount <= 100_000_000_000*1e18, "staker: stake is above max supply");
         _;
     }
 

builtin/gen/staker.sol

@@ -1690,6 +1690,19 @@ func TestStakerContract_Native_Revert(t *testing.T) {
 	assert.NoError(t, err)
 	assert.True(t, receipt.Reverted)
 
+	decreaseStakeArgs = []any{genesis.DevAccounts()[2].Address, big.NewInt(0).Mul(big.NewInt(0).SetUint64(math.MaxUint64), big.NewInt(1e18))}
+	desc = TestTxDescription{
+		t:          t,
+		abi:        abi,
+		methodName: "decreaseStake",
+		address:    toAddr,
+		acc:        genesis.DevAccounts()[2],
+		args:       decreaseStakeArgs,
+	}
+	receipt, _, err = executeTxAndGetReceipt(desc)
+	assert.NoError(t, err)
+	assert.True(t, receipt.Reverted)
+
 	// update delegator auto renew
 	updateDelegatorAutoRenewArgs := []any{big.NewInt(0)}
 	desc = TestTxDescription{

builtin/native_calls_test.go

@@ -310,7 +310,10 @@ func (s *Staker) ContractBalanceCheck(pendingWithdraw uint64) error {
 	if err != nil {
 		return err
 	}
-	balanceVET := ToVET(balance)
+	balanceVET, err := ToVET(balance)
+	if err != nil {
+		return err
+	}
 
 	// Get the Effective VET tracked
 	effectiveVET, err := s.GetEffectiveVET()

builtin/staker/housekeep.go

@@ -60,8 +60,22 @@ func (s *Staker) SyncPOS(forkConfig *thor.ForkConfig, current uint32) (Status, e
 	return status, nil
 }
 
-func ToVET(wei *big.Int) uint64 {
-	return new(big.Int).Div(wei, bigE18).Uint64()
+func ToVET(wei *big.Int) (uint64, error) {
+	if wei == nil {
+		return 0, fmt.Errorf("wei amount cannot be nil")
+	}
+
+	if wei.Sign() < 0 {
+		return 0, fmt.Errorf("wei amount cannot be negative")
+	}
+
+	result := new(big.Int).Div(wei, bigE18)
+
+	if !result.IsUint64() {
+		return 0, fmt.Errorf("wei amount too large")
+	}
+
+	return result.Uint64(), nil
 }
 
 func ToWei(vet uint64) *big.Int {

builtin/staker/protocol.go

@@ -7,6 +7,7 @@
 package staker
 
 import (
+	"math"
 	"math/big"
 	"testing"
 
@@ -401,3 +402,27 @@ func TestSyncPOS_NegativeCases(t *testing.T) {
 	_, err = staker.SyncPOS(forkConfig, current)
 	require.Error(t, err)
 }
+
+func TestToVET(t *testing.T) {
+	weiValue := big.NewInt(-1)
+	_, err := ToVET(weiValue)
+	assert.ErrorContains(t, err, "wei amount cannot be negative")
+
+	_, err = ToVET(nil)
+	assert.ErrorContains(t, err, "wei amount cannot be nil")
+
+	weiValue = big.NewInt(0).SetUint64(math.MaxUint64)
+	vetValue, err := ToVET(weiValue)
+	assert.NoError(t, err)
+	assert.Equal(t, uint64(math.MaxUint64)/1e18, vetValue)
+
+	weiValue = big.NewInt(0).SetUint64(math.MaxUint64)
+	weiValue = big.NewInt(0).Mul(weiValue, big.NewInt(1e18))
+	vetValue, err = ToVET(weiValue)
+	assert.NoError(t, err)
+	assert.Equal(t, uint64(math.MaxUint64), vetValue)
+
+	weiValue = big.NewInt(0).Add(weiValue, big.NewInt(1e18))
+	_, err = ToVET(weiValue)
+	assert.ErrorContains(t, err, "wei amount too large")
+}

builtin/staker/protocol_test.go

@@ -777,5 +777,5 @@ func (s *Staker) GetEffectiveVET() (uint64, error) {
 		return 0, err
 	}
 
-	return ToVET(new(big.Int).SetBytes(val.Bytes())), nil
+	return ToVET(new(big.Int).SetBytes(val.Bytes()))
 }

builtin/staker/staker.go

@@ -198,12 +198,17 @@ func init() {
 				}
 			}
 
+			stake, err := staker.ToVET(args.Stake) // convert from wei to VET
+			if err != nil {
+				return nil, staker.NewReverts(err.Error())
+			}
+
 			err = Staker.NativeMetered(env.State(), charger).
 				AddValidation(
 					val,
 					end,
 					args.Period,
-					staker.ToVET(args.Stake), // convert from wei to VET
+					stake,
 				)
 			if err != nil {
 				return nil, err
@@ -239,11 +244,16 @@ func init() {
 			env.ParseArgs(&args)
 			charger := gascharger.New(env)
 
-			err := Staker.NativeMetered(env.State(), charger).
+			stake, err := staker.ToVET(args.Amount) // convert from wei to VET
+			if err != nil {
+				return nil, staker.NewReverts(err.Error())
+			}
+
+			err = Staker.NativeMetered(env.State(), charger).
 				IncreaseStake(
 					thor.Address(args.Validator),
 					thor.Address(args.Endorser),
-					staker.ToVET(args.Amount), // convert from wei to VET
+					stake,
 				)
 			if err != nil {
 				return nil, err
@@ -280,11 +290,16 @@ func init() {
 			env.ParseArgs(&args)
 			charger := gascharger.New(env)
 
-			err := Staker.NativeMetered(env.State(), charger).
+			stake, err := staker.ToVET(args.Amount) // convert from wei to VET
+			if err != nil {
+				return nil, staker.NewReverts(err.Error())
+			}
+
+			err = Staker.NativeMetered(env.State(), charger).
 				DecreaseStake(
 					thor.Address(args.Validator),
 					thor.Address(args.Endorser),
-					staker.ToVET(args.Amount), // convert from wei to VET,
+					stake,
 				)
 			if err != nil {
 				return nil, err
@@ -300,10 +315,15 @@ func init() {
 			env.ParseArgs(&args)
 			charger := gascharger.New(env)
 
+			stake, err := staker.ToVET(args.Stake) // convert from wei to VET,
+			if err != nil {
+				return nil, staker.NewReverts(err.Error())
+			}
+
 			delegationID, err := Staker.NativeMetered(env.State(), charger).
 				AddDelegation(
 					thor.Address(args.Validator),
-					staker.ToVET(args.Stake), // convert from wei to VET,
+					stake,
 					args.Multiplier,
 					env.BlockContext().Number,
 				)

builtin/staker_native.go

@@ -483,20 +483,20 @@ func TestStakerContract_PauseSwitches(t *testing.T) {
 	test.Case("addValidation", master, thor.LowStakingPeriod()).
 		Value(minStake).
 		Caller(endorser).
-		ShouldUseGas(1860).
+		ShouldUseGas(1886).
 		ShouldRevert("staker: staker is paused").
 		Assert(t)
 
 	test.Case("increaseStake", validator1).
 		Value(minStake).
 		Caller(endorser).
-		ShouldUseGas(1749).
+		ShouldUseGas(1775).
 		ShouldRevert("staker: staker is paused").
 		Assert(t)
 
 	test.Case("decreaseStake", validator1, minStake).
 		Caller(endorser).
-		ShouldUseGas(1796).
+		ShouldUseGas(1822).
 		ShouldRevert("staker: staker is paused").
 		Assert(t)
 
@@ -516,7 +516,7 @@ func TestStakerContract_PauseSwitches(t *testing.T) {
 	test.Case("addDelegation", validator1, uint8(100)).
 		Value(minStake).
 		Caller(delegator).
-		ShouldUseGas(3132).
+		ShouldUseGas(3158).
 		ShouldRevert("staker: staker is paused").
 		Assert(t)
 
@@ -560,18 +560,18 @@ func TestStakerContract_PauseSwitches(t *testing.T) {
 	test.Case("addValidation", master, thor.LowStakingPeriod()).
 		Value(minStake).
 		Caller(endorser).
-		ShouldUseGas(132571).
+		ShouldUseGas(132597).
 		Assert(t)
 
 	test.Case("increaseStake", validator1).
 		Value(minStake).
 		Caller(endorser).
-		ShouldUseGas(67189).
+		ShouldUseGas(67215).
 		Assert(t)
 
 	test.Case("decreaseStake", validator1, minStake).
 		Caller(endorser).
-		ShouldUseGas(16344).
+		ShouldUseGas(16370).
 		Assert(t)
 
 	test.Case("withdrawStake", validator1).
@@ -587,7 +587,7 @@ func TestStakerContract_PauseSwitches(t *testing.T) {
 	test.Case("addDelegation", validator1, uint8(100)).
 		Value(minStake).
 		Caller(delegator).
-		ShouldUseGas(48922).
+		ShouldUseGas(48948).
 		Assert(t)
 
 	// cannot add delegation after the signal validation exit

builtin/staker_native_test.go

@@ -45,7 +45,14 @@ func TestAuthority_Hayabusa_TransitionPeriod(t *testing.T) {
 	// check the endorsor balance has reduced
 	newEndorsorBal, err := getEndorsorBalance(best.Header, setup.chain)
 	assert.NoError(t, err)
-	assert.Equal(t, staker.ToVET(newEndorsorBal)+minStake, staker.ToVET(endorsorBal))
+
+	expectedEndorserVetBalance, err := staker.ToVET(newEndorsorBal)
+	assert.NoError(t, err)
+	expectedEndorserVetBalance = expectedEndorserVetBalance + minStake
+
+	endorserVetBalance, err := staker.ToVET(endorsorBal)
+	assert.NoError(t, err)
+	assert.Equal(t, expectedEndorserVetBalance, endorserVetBalance)
 
 	// check the staker contract has the correct stake
 	masterStake, err := getMasterStake(setup.chain, blk.Header)