You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
611 lines
24 KiB
611 lines
24 KiB
package core
|
|
|
|
import (
|
|
"math/big"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/ethdb"
|
|
"github.com/harmony-one/bls/ffi/go/bls"
|
|
"github.com/harmony-one/harmony/core/state"
|
|
"github.com/harmony-one/harmony/crypto/hash"
|
|
common2 "github.com/harmony-one/harmony/internal/common"
|
|
"github.com/harmony-one/harmony/internal/ctxerror"
|
|
"github.com/harmony-one/harmony/numeric"
|
|
"github.com/harmony-one/harmony/shard"
|
|
staking "github.com/harmony-one/harmony/staking/types"
|
|
)
|
|
|
|
var (
|
|
validatorAddress = common.Address(common2.MustBech32ToAddress("one1pdv9lrdwl0rg5vglh4xtyrv3wjk3wsqket7zxy"))
|
|
postStakingEpoch = big.NewInt(200)
|
|
)
|
|
|
|
func generateBlsKeySigPair() (shard.BlsPublicKey, shard.BLSSignature) {
|
|
p := &bls.PublicKey{}
|
|
p.DeserializeHexStr(testBLSPubKey)
|
|
pub := shard.BlsPublicKey{}
|
|
pub.FromLibBLSPublicKey(p)
|
|
messageBytes := []byte(staking.BlsVerificationStr)
|
|
privateKey := &bls.SecretKey{}
|
|
privateKey.DeserializeHexStr(testBLSPrvKey)
|
|
msgHash := hash.Keccak256(messageBytes)
|
|
signature := privateKey.SignHash(msgHash[:])
|
|
var sig shard.BLSSignature
|
|
copy(sig[:], signature.Serialize())
|
|
return pub, sig
|
|
}
|
|
|
|
func createValidator() *staking.CreateValidator {
|
|
desc := staking.Description{
|
|
Name: "SuperHero",
|
|
Identity: "YouWouldNotKnow",
|
|
Website: "Secret Website",
|
|
SecurityContact: "LicenseToKill",
|
|
Details: "blah blah blah",
|
|
}
|
|
rate, _ := numeric.NewDecFromStr("0.1")
|
|
maxRate, _ := numeric.NewDecFromStr("0.5")
|
|
maxChangeRate, _ := numeric.NewDecFromStr("0.05")
|
|
commission := staking.CommissionRates{
|
|
Rate: rate,
|
|
MaxRate: maxRate,
|
|
MaxChangeRate: maxChangeRate,
|
|
}
|
|
minSelfDel := big.NewInt(1e18)
|
|
maxTotalDel := big.NewInt(9e18)
|
|
pubKey, pubSig := generateBlsKeySigPair()
|
|
slotPubKeys := []shard.BlsPublicKey{pubKey}
|
|
slotKeySigs := []shard.BLSSignature{pubSig}
|
|
amount := big.NewInt(5e18)
|
|
v := staking.CreateValidator{
|
|
ValidatorAddress: validatorAddress,
|
|
Description: desc,
|
|
CommissionRates: commission,
|
|
MinSelfDelegation: minSelfDel,
|
|
MaxTotalDelegation: maxTotalDel,
|
|
SlotPubKeys: slotPubKeys,
|
|
SlotKeySigs: slotKeySigs,
|
|
Amount: amount,
|
|
}
|
|
return &v
|
|
}
|
|
|
|
// Test CV1: create validator
|
|
func TestCV1(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV3: validator already exists
|
|
func TestCV3(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
statedb.SetValidatorFlag(msg.ValidatorAddress)
|
|
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); !strings.Contains(err.Error(), errValidatorExist.Error()) {
|
|
t.Error("expected", errValidatorExist, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV5: identity longer than 140 characters
|
|
func TestCV5(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// identity length: 200 characters
|
|
msg.Identity = "adsfwryuiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwiewwerfhuwefiuewfhuewhfiuewhfefhshfrhfhifhwbfvberhbvihfwuoefhusioehfeuwiafhaiobcfwfhceirui"
|
|
identitylengthCtxError := ctxerror.New("[EnsureLength] Exceed Maximum Length", "have", len(msg.Identity), "maxIdentityLen", staking.MaxIdentityLength)
|
|
var err error
|
|
if _, err = VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Errorf("expected non null error")
|
|
}
|
|
ctxerr, ok := err.(ctxerror.CtxError)
|
|
if !ok {
|
|
t.Errorf("expected context aware error")
|
|
}
|
|
if ctxerr.Message() != identitylengthCtxError.Message() {
|
|
t.Error("expected", identitylengthCtxError, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV6: website longer than 140 characters
|
|
func TestCV6(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// Website length: 200 characters
|
|
msg.Website = "https://www.iwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwiewwerfhuwefiuewfwwwwwfiuewhfefhshfrheterhbvihfwuoefhusioehfeuwiafhaiobcfwfhceirui.com"
|
|
websiteLengthCtxError := ctxerror.New("[EnsureLength] Exceed Maximum Length", "have", len(msg.Website), "maxWebsiteLen", staking.MaxWebsiteLength)
|
|
_, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
)
|
|
if err == nil {
|
|
t.Errorf("expected non null error")
|
|
}
|
|
ctxerr, ok := err.(ctxerror.CtxError)
|
|
if !ok {
|
|
t.Errorf("expected context aware error")
|
|
}
|
|
if ctxerr.Message() != websiteLengthCtxError.Message() {
|
|
t.Error("expected", websiteLengthCtxError, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV7: security contact longer than 140 characters
|
|
func TestCV7(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// Security Contact length: 200 characters
|
|
msg.SecurityContact = "HelloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwiewwerfhuwefiuewfwwwwwfiuewhfefhshfrheterhbvihfwuoefhusioehfeuwiafhaiobcfwfhceiruiHellodfdfdf"
|
|
securityContactLengthError := ctxerror.New("[EnsureLength] Exceed Maximum Length", "have", len(msg.SecurityContact), "maxSecurityContactLen", staking.MaxSecurityContactLength)
|
|
_, err := VerifyAndCreateValidatorFromMsg(statedb, postStakingEpoch, big.NewInt(0), msg)
|
|
if err == nil {
|
|
t.Errorf("expected non null error")
|
|
}
|
|
ctxerr, ok := err.(ctxerror.CtxError)
|
|
if !ok {
|
|
t.Errorf("expected context aware error")
|
|
}
|
|
if ctxerr.Message() != securityContactLengthError.Message() {
|
|
t.Error("expected", securityContactLengthError, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV8: details longer than 280 characters
|
|
func TestCV8(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// Details length: 300 characters
|
|
msg.Details = "HelloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwiewwerfhuwefiuewfwwwwwfiuewhfefhshfrheterhbvihfwuoefhusioehfeuwiafhaiobcfwfhceiruiHellodfdfdfjiusngognoherugbounviesrbgufhuoshcofwevusguahferhgvuervurehniwjvseivusehvsghjvorsugjvsiovjpsevsvvvvv"
|
|
detailsLenCtxError := ctxerror.New("[EnsureLength] Exceed Maximum Length", "have", len(msg.Details), "maxDetailsLen", staking.MaxDetailsLength)
|
|
_, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
)
|
|
if err == nil {
|
|
t.Errorf("Expected non null error")
|
|
}
|
|
ctxerr, ok := err.(ctxerror.CtxError)
|
|
if !ok {
|
|
t.Errorf("expected context aware error")
|
|
}
|
|
if ctxerr.Message() != detailsLenCtxError.Message() {
|
|
t.Error("expected", detailsLenCtxError, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV9: name == 140 characters
|
|
func TestCV9(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
// name length: 140 characters
|
|
msg.Name = "Helloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwidsffevjnononwondqmeofniowfndjowe"
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV10: identity == 140 characters
|
|
func TestCV10(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
// identity length: 140 characters
|
|
msg.Identity = "Helloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwidsffevjnononwondqmeofniowfndjowe"
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV11: website == 140 characters
|
|
func TestCV11(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
// website length: 140 characters
|
|
msg.Website = "Helloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwidsffevjnononwondqmeofniowfndjowe"
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV12: security == 140 characters
|
|
func TestCV12(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
// security contact length: 140 characters
|
|
msg.SecurityContact = "Helloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwidsffevjnononwondqmeofniowfndjowe"
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV13: details == 280 characters
|
|
func TestCV13(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
// details length: 280 characters
|
|
msg.Details = "HelloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwidsffevjnononwondqmeofniowfndjoweHlloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuedbfcuyiewfhwieufwiweifhcwefhwefhwidsffevjnononwondqmeofniowfndjowe"
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV14: commission rate <= max rate & max change rate <= max rate
|
|
func TestCV14(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// commission rate == max rate && max change rate == max rate
|
|
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("0.5")
|
|
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("0.5")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV15: commission rate > max rate
|
|
func TestCV15(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// commission rate: 0.6 > max rate: 0.5
|
|
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("0.6")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "commission rate and change rate can not be larger than max commission rate", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV16: max change rate > max rate
|
|
func TestCV16(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// max change rate: 0.6 > max rate: 0.5
|
|
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("0.6")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "commission rate and change rate can not be larger than max commission rate", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV17: max rate == 1
|
|
func TestCV17(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// max rate == 1
|
|
msg.CommissionRates.MaxRate, _ = numeric.NewDecFromStr("1")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV18: max rate == 1 && max change rate == 1 && commission rate == 0
|
|
func TestCV18(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// max rate == 1 && max change rate == 1 && commission rate == 0
|
|
msg.CommissionRates.MaxRate, _ = numeric.NewDecFromStr("1")
|
|
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("1")
|
|
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("1")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV19: commission rate == 0
|
|
func TestCV19(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// commission rate == 0
|
|
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("0")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV20: max change rate == 0
|
|
func TestCV20(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// commission rate == 0
|
|
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("0")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV21: max change rate == 0 & max rate == 0 & commission rate == 0
|
|
func TestCV21(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// max change rate == 0 & max rate == 0 & commission rate == 0
|
|
msg.CommissionRates.MaxRate, _ = numeric.NewDecFromStr("0")
|
|
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("0")
|
|
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("0")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV22: max change rate == 1 & max rate == 1
|
|
func TestCV22(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// max change rate == 1 & max rate == 1
|
|
msg.CommissionRates.MaxRate, _ = numeric.NewDecFromStr("1")
|
|
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("1")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV23: commission rate < 0
|
|
func TestCV23(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// commission rate < 0
|
|
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("-0.1")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "rate:-0.100000000000000000: commission rate, change rate and max rate should be within 0-100 percent", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV24: max rate < 0
|
|
func TestCV24(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// max rate < 0
|
|
msg.CommissionRates.MaxRate, _ = numeric.NewDecFromStr("-0.001")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "rate:-0.001000000000000000: commission rate, change rate and max rate should be within 0-100 percent", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV25: max change rate < 0
|
|
func TestCV25(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// max rate < 0
|
|
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("-0.001")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "rate:-0.001000000000000000: commission rate, change rate and max rate should be within 0-100 percent", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV26: commission rate > 1
|
|
func TestCV26(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// commission rate > 1
|
|
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("1.01")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "rate:1.01000000000000000: commission rate, change rate and max rate should be within 0-100 percent", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV27: max rate > 1
|
|
func TestCV27(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// max rate > 1
|
|
msg.CommissionRates.MaxRate, _ = numeric.NewDecFromStr("1.01")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "rate:1.01000000000000000: commission rate, change rate and max rate should be within 0-100 percent", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV28: max change rate > 1
|
|
func TestCV28(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// max change rate > 1
|
|
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("1.01")
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "rate:1.01000000000000000: commission rate, change rate and max rate should be within 0-100 percent", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV29: amount > MinSelfDelegation
|
|
func TestCV29(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// amount > MinSelfDelegation
|
|
msg.Amount = big.NewInt(4e18)
|
|
msg.MinSelfDelegation = big.NewInt(1e18)
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV30: amount == MinSelfDelegation
|
|
func TestCV30(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// amount > MinSelfDelegation
|
|
msg.Amount = big.NewInt(4e18)
|
|
msg.MinSelfDelegation = big.NewInt(4e18)
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err != nil {
|
|
t.Error("expected", nil, "got", err)
|
|
}
|
|
}
|
|
|
|
// Test CV31: amount < MinSelfDelegation
|
|
func TestCV31(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// amount > MinSelfDelegation
|
|
msg.Amount = big.NewInt(4e18)
|
|
msg.MinSelfDelegation = big.NewInt(5e18)
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "have 4000000000000000000 want 5000000000000000000: self delegation can not be less than min_self_delegation", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV32: MaxTotalDelegation < MinSelfDelegation
|
|
func TestCV32(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// MaxTotalDelegation < MinSelfDelegation
|
|
msg.MaxTotalDelegation = big.NewInt(2e18)
|
|
msg.MinSelfDelegation = big.NewInt(3e18)
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "max_total_delegation can not be less than min_self_delegation", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV33: MinSelfDelegation < 1 ONE
|
|
func TestCV33(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// MinSelfDelegation < 1 ONE
|
|
msg.MinSelfDelegation = big.NewInt(1e18 - 1)
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "delegation-given 999999999999999999: min_self_delegation has to be greater than 1 ONE", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV34: MinSelfDelegation not specified
|
|
func TestCV34(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// MinSelfDelegation not specified
|
|
msg.MinSelfDelegation = nil
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "MinSelfDelegation can not be nil", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV35: MinSelfDelegation < 0
|
|
func TestCV35(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// MinSelfDelegation < 0
|
|
msg.MinSelfDelegation = big.NewInt(-1)
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "delegation-given -1: min_self_delegation has to be greater than 1 ONE", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV36: amount > MaxTotalDelegation
|
|
func TestCV36(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// amount > MaxTotalDelegation
|
|
msg.Amount = big.NewInt(4e18)
|
|
msg.MaxTotalDelegation = big.NewInt(3e18)
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "total delegation can not be bigger than max_total_delegation", "got", nil)
|
|
}
|
|
}
|
|
|
|
// Test CV39: MaxTotalDelegation < 0
|
|
func TestCV39(t *testing.T) {
|
|
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
|
|
msg := createValidator()
|
|
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
|
|
// MaxTotalDelegation < 0
|
|
msg.MaxTotalDelegation = big.NewInt(-1)
|
|
if _, err := VerifyAndCreateValidatorFromMsg(
|
|
statedb, postStakingEpoch, big.NewInt(0), msg,
|
|
); err == nil {
|
|
t.Error("expected", "max_total_delegation can not be less than min_self_delegation", "got", nil)
|
|
}
|
|
}
|
|
|