// Copyright 2018 The dexon-consensus Authors
// This file is part of the dexon-consensus library.
//
// The dexon-consensus library is free software: you can redistribute it
// and/or modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the License,
// or (at your option) any later version.
//
// The dexon-consensus library is distributed in the hope that it will be
// useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
// General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with the dexon-consensus library. If not, see
// <http://www.gnu.org/licenses/>.
package vm
import (
"bytes"
"crypto/ecdsa"
"math/big"
"math/rand"
"testing"
"time"
"github.com/dexon-foundation/dexon/common"
"github.com/dexon-foundation/dexon/core/state"
"github.com/dexon-foundation/dexon/crypto"
"github.com/dexon-foundation/dexon/ethdb"
"github.com/dexon-foundation/dexon/params"
"github.com/stretchr/testify/suite"
)
func init() {
rand.Seed(time.Now().UnixNano())
}
func randomBytes(minLength, maxLength int32) []byte {
length := rand.Int31()%(maxLength-minLength) + minLength
b := make([]byte, length)
for i := range b {
b[i] = byte(65 + rand.Int31()%60)
}
return b
}
type GovernanceStateHelperTestSuite struct {
suite.Suite
s *GovernanceStateHelper
}
func (g *GovernanceStateHelperTestSuite) SetupTest() {
db := state.NewDatabase(ethdb.NewMemDatabase())
statedb, err := state.New(common.Hash{}, db)
if err != nil {
panic(err)
}
g.s = &GovernanceStateHelper{statedb}
}
func (g *GovernanceStateHelperTestSuite) TestReadWriteBytes() {
for i := 0; i < 100; i++ {
// Short bytes.
loc := big.NewInt(rand.Int63())
data := randomBytes(3, 32)
g.s.writeBytes(loc, data)
read := g.s.readBytes(loc)
g.Require().Equal(0, bytes.Compare(data, read))
// long bytes.
loc = big.NewInt(rand.Int63())
data = randomBytes(33, 2560)
g.s.writeBytes(loc, data)
read = g.s.readBytes(loc)
g.Require().Equal(0, bytes.Compare(data, read))
}
}
func TestGovernanceStateHelper(t *testing.T) {
suite.Run(t, new(GovernanceStateHelperTestSuite))
}
type GovernanceContractTestSuite struct {
suite.Suite
config *params.DexconConfig
memDB *ethdb.MemDatabase
stateDB *state.StateDB
s *GovernanceStateHelper
}
func (g *GovernanceContractTestSuite) SetupTest() {
memDB := ethdb.NewMemDatabase()
stateDB, err := state.New(common.Hash{}, state.NewDatabase(memDB))
if err != nil {
panic(err)
}
g.memDB = memDB
g.stateDB = stateDB
g.s = &GovernanceStateHelper{stateDB}
config := params.TestnetChainConfig.Dexcon
config.LockupPeriod = 1000
g.config = config
// Give governance contract balance so it will not be deleted because of being an empty state object.
stateDB.AddBalance(GovernanceContractAddress, big.NewInt(1))
// Genesis CRS.
crs := crypto.Keccak256Hash([]byte(config.GenesisCRSText))
g.s.PushCRS(crs)
// Round 0 height.
g.s.PushRoundHeight(big.NewInt(0))
// Owner.
g.s.SetOwner(g.config.Owner)
// Governance configuration.
g.s.UpdateConfiguration(config)
g.stateDB.Commit(true)
}
func (g *GovernanceContractTestSuite) newPrefundAccount() (*ecdsa.PrivateKey, common.Address) {
privKey, err := crypto.GenerateKey()
if err != nil {
panic(err)
}
address := crypto.PubkeyToAddress(privKey.PublicKey)
g.stateDB.AddBalance(address, new(big.Int).Mul(big.NewInt(1e18), big.NewInt(2e5)))
return privKey, address
}
func (g *GovernanceContractTestSuite) call(caller common.Address, input []byte, value *big.Int) ([]byte, error) {
context := Context{
CanTransfer: func(db StateDB, addr common.Address, amount *big.Int) bool {
return db.GetBalance(addr).Cmp(amount) >= 0
},
Transfer: func(db StateDB, sender common.Address, recipient common.Address, amount *big.Int) {
db.SubBalance(sender, amount)
db.AddBalance(recipient, amount)
},
GetRoundHeight: func(round uint64) (uint64, bool) {
switch round {
case 0:
return 0, true
case 1:
return 1000, true
case 2:
return 2000, true
}
return 0, false
},
Time: big.NewInt(time.Now().UnixNano() / 1000000),
BlockNumber: big.NewInt(0),
}
evm := NewEVM(context, g.stateDB, params.TestChainConfig, Config{IsBlockProposer: true})
ret, _, err := evm.Call(AccountRef(caller), GovernanceContractAddress, input, 10000000, value)
return ret, err
}
func (g *GovernanceContractTestSuite) TestTransferOwnership() {
_, addr := g.newPrefundAccount()
input, err := abiObject.Pack("transferOwnership", addr)
g.Require().Nil(err)
// Call with non-owner.
_, err = g.call(addr, input, big.NewInt(0))
g.Require().NotNil(err)
// Call with owner.
_, err = g.call(g.config.Owner, input, big.NewInt(0))
g.Require().Nil(err)
g.Require().Equal(addr, g.s.Owner())
}
func (g *GovernanceContractTestSuite) TestStakeUnstakeWithoutExtraDelegators() {
privKey, addr := g.newPrefundAccount()
pk := crypto.FromECDSAPub(&privKey.PublicKey)
// Stake.
amount := new(big.Int).Mul(big.NewInt(1e18), big.NewInt(5e4))
balanceBeforeStake := g.stateDB.GetBalance(addr)
input, err := abiObject.Pack("stake", pk, "Test1", "test1@dexon.org", "Taipei, Taiwan", "https://dexon.org")
g.Require().Nil(err)
_, err = g.call(addr, input, amount)
g.Require().Nil(err)
// Node staked but staked fund < MinStake so is still unqualified.
g.Require().Equal(1, int(g.s.LenNodes().Uint64()))
g.Require().Equal(0, len(g.s.QualifiedNodes()))
g.Require().Equal("Test1", g.s.Node(big.NewInt(0)).Name)
// Check balance.
g.Require().Equal(new(big.Int).Sub(balanceBeforeStake, amount), g.stateDB.GetBalance(addr))
g.Require().Equal(new(big.Int).Add(big.NewInt(1), amount), g.stateDB.GetBalance(GovernanceContractAddress))
// Staking again should fail.
_, err = g.call(addr, input, amount)
g.Require().NotNil(err)
// Unstake.
input, err = abiObject.Pack("unstake")
g.Require().Nil(err)
_, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
g.Require().Equal(1, int(g.s.LenDelegators(addr).Uint64()))
g.Require().Equal(1, int(g.s.LenNodes().Uint64()))
// Wait for lockup time than withdraw.
time.Sleep(time.Second * 2)
input, err = abiObject.Pack("withdraw", addr)
g.Require().Nil(err)
_, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
g.Require().Equal(0, int(g.s.LenDelegators(addr).Uint64()))
g.Require().Equal(0, int(g.s.LenNodes().Uint64()))
// Stake 2 nodes, and unstake the first then the second.
// 2nd node Stake.
privKey2, addr2 := g.newPrefundAccount()
pk2 := crypto.FromECDSAPub(&privKey2.PublicKey)
input, err = abiObject.Pack("stake", pk2, "Test2", "test2@dexon.org", "Taipei, Taiwan", "https://dexon.org")
g.Require().Nil(err)
_, err = g.call(addr2, input, amount)
g.Require().Nil(err)
g.Require().Equal("Test2", g.s.Node(big.NewInt(0)).Name)
g.Require().Equal(0, int(g.s.NodesOffset(addr2).Int64()))
// 1st node Stake.
input, err = abiObject.Pack("stake", pk, "Test1", "test1@dexon.org", "Taipei, Taiwan", "https://dexon.org")
g.Require().Nil(err)
_, err = g.call(addr, input, amount)
g.Require().Nil(err)
// 2nd node Unstake.
input, err = abiObject.Pack("unstake")
g.Require().Nil(err)
_, err = g.call(addr2, input, big.NewInt(0))
g.Require().Nil(err)
time.Sleep(time.Second * 2)
input, err = abiObject.Pack("withdraw", addr2)
g.Require().Nil(err)
_, err = g.call(addr2, input, big.NewInt(0))
g.Require().Nil(err)
g.Require().Equal(1, int(g.s.LenNodes().Uint64()))
g.Require().Equal("Test1", g.s.Node(big.NewInt(0)).Name)
g.Require().Equal(-1, int(g.s.NodesOffset(addr2).Int64()))
// 1st node Unstake.
input, err = abiObject.Pack("unstake")
g.Require().Nil(err)
_, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
time.Sleep(time.Second * 2)
input, err = abiObject.Pack("withdraw", addr)
g.Require().Nil(err)
_, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
g.Require().Equal(0, int(g.s.LenNodes().Uint64()))
g.Require().Equal(-1, int(g.s.NodesOffset(addr).Int64()))
g.Require().Equal(-1, int(g.s.DelegatorsOffset(addr, addr).Int64()))
// Check balance.
g.Require().Equal(balanceBeforeStake, g.stateDB.GetBalance(addr))
g.Require().Equal(balanceBeforeStake, g.stateDB.GetBalance(addr2))
g.Require().Equal(big.NewInt(1), g.stateDB.GetBalance(GovernanceContractAddress))
}
func (g *GovernanceContractTestSuite) TestDelegateUndelegate() {
privKey, addr := g.newPrefundAccount()
pk := crypto.FromECDSAPub(&privKey.PublicKey)
// Stake.
input, err := abiObject.Pack("stake", pk, "Test1", "test1@dexon.org", "Taipei, Taiwan", "https://dexon.org")
g.Require().Nil(err)
ownerStaked := new(big.Int).Mul(big.NewInt(1e18), big.NewInt(5e4))
_, err = g.call(addr, input, ownerStaked)
g.Require().Nil(err)
g.Require().Equal(0, len(g.s.QualifiedNodes()))
g.Require().Equal(addr, g.s.Delegator(addr, big.NewInt(0)).Owner)
g.Require().Equal(ownerStaked, g.s.Node(big.NewInt(0)).Staked)
// 1st delegator delegate to 1st node.
_, addrDelegator := g.newPrefundAccount()
balanceBeforeDelegate := g.stateDB.GetBalance(addrDelegator)
amount := new(big.Int).Mul(big.NewInt(1e18), big.NewInt(3e4))
input, err = abiObject.Pack("delegate", addr)
g.Require().Nil(err)
_, err = g.call(addrDelegator, input, amount)
g.Require().Nil(err)
g.Require().Equal(new(big.Int).Sub(balanceBeforeDelegate, amount), g.stateDB.GetBalance(addrDelegator))
g.Require().Equal(addrDelegator, g.s.Delegator(addr, big.NewInt(1)).Owner)
g.Require().Equal(new(big.Int).Add(amount, ownerStaked), g.s.Node(big.NewInt(0)).Staked)
g.Require().Equal(1, int(g.s.DelegatorsOffset(addr, addrDelegator).Int64()))
// Same person delegate the 2nd time should fail.
_, err = g.call(addrDelegator, input, big.NewInt(1e18))
g.Require().NotNil(err)
// Not yet qualified.
g.Require().Equal(0, len(g.s.QualifiedNodes()))
// 2nd delegator delegate to 1st node.
_, addrDelegator2 := g.newPrefundAccount()
_, err = g.call(addrDelegator2, input, amount)
g.Require().Nil(err)
g.Require().Equal(new(big.Int).Sub(balanceBeforeDelegate, amount), g.stateDB.GetBalance(addrDelegator2))
g.Require().Equal(addrDelegator2, g.s.Delegator(addr, big.NewInt(2)).Owner)
g.Require().Equal(new(big.Int).Add(ownerStaked, new(big.Int).Mul(amount, big.NewInt(2))),
g.s.Node(big.NewInt(0)).Staked)
g.Require().Equal(2, int(g.s.DelegatorsOffset(addr, addrDelegator2).Int64()))
// Qualified.
g.Require().Equal(1, len(g.s.QualifiedNodes()))
// Undelegate addrDelegator.
balanceBeforeUnDelegate := g.stateDB.GetBalance(addrDelegator)
input, err = abiObject.Pack("undelegate", addr)
g.Require().Nil(err)
_, err = g.call(addrDelegator, input, big.NewInt(0))
g.Require().Nil(err)
// Withdraw within lockup time should fail.
input, err = abiObject.Pack("withdraw", addr)
g.Require().Nil(err)
_, err = g.call(addrDelegator, input, big.NewInt(0))
g.Require().NotNil(err)
g.Require().Equal(3, int(g.s.LenDelegators(addr).Uint64()))
g.Require().Equal(balanceBeforeUnDelegate, g.stateDB.GetBalance(addrDelegator))
g.Require().NotEqual(-1, int(g.s.DelegatorsOffset(addr, addrDelegator).Int64()))
// Wait for lockup time than withdraw.
time.Sleep(time.Second * 2)
input, err = abiObject.Pack("withdraw", addr)
g.Require().Nil(err)
_, err = g.call(addrDelegator, input, big.NewInt(0))
g.Require().Nil(err)
g.Require().Equal(2, int(g.s.LenDelegators(addr).Uint64()))
g.Require().Equal(new(big.Int).Add(balanceBeforeUnDelegate, amount), g.stateDB.GetBalance(addrDelegator))
g.Require().Equal(-1, int(g.s.DelegatorsOffset(addr, addrDelegator).Int64()))
// Withdraw when their is no delegation should fail.
time.Sleep(time.Second)
input, err = abiObject.Pack("withdraw", addr)
g.Require().Nil(err)
_, err = g.call(addrDelegator, input, big.NewInt(0))
g.Require().NotNil(err)
// Undelegate addrDelegator2.
balanceBeforeUnDelegate = g.stateDB.GetBalance(addrDelegator2)
input, err = abiObject.Pack("undelegate", addr)
g.Require().Nil(err)
_, err = g.call(addrDelegator2, input, big.NewInt(0))
g.Require().Nil(err)
// Wait for lockup time than withdraw.
time.Sleep(time.Second * 2)
input, err = abiObject.Pack("withdraw", addr)
g.Require().Nil(err)
_, err = g.call(addrDelegator2, input, big.NewInt(0))
g.Require().Nil(err)
g.Require().Equal(1, int(g.s.LenDelegators(addr).Uint64()))
g.Require().Equal(new(big.Int).Add(balanceBeforeUnDelegate, amount), g.stateDB.GetBalance(addrDelegator2))
g.Require().Equal(-1, int(g.s.DelegatorsOffset(addr, addrDelegator2).Int64()))
// Unqualified
g.Require().Equal(0, len(g.s.QualifiedNodes()))
}
func (g *GovernanceContractTestSuite) TestUnstakeWithExtraDelegators() {
privKey, addr := g.newPrefundAccount()
pk := crypto.FromECDSAPub(&privKey.PublicKey)
// Stake.
amount := new(big.Int).Mul(big.NewInt(1e18), big.NewInt(5e4))
input, err := abiObject.Pack("stake", pk, "Test1", "test1@dexon.org", "Taipei, Taiwan", "https://dexon.org")
g.Require().Nil(err)
_, err = g.call(addr, input, amount)
g.Require().Nil(err)
// 1st delegator delegate to 1st node.
_, addrDelegator := g.newPrefundAccount()
balanceBeforeDelegate := g.stateDB.GetBalance(addrDelegator)
amount = new(big.Int).Mul(big.NewInt(1e18), big.NewInt(3e4))
input, err = abiObject.Pack("delegate", addr)
g.Require().Nil(err)
_, err = g.call(addrDelegator, input, amount)
g.Require().Nil(err)
g.Require().Equal(new(big.Int).Sub(balanceBeforeDelegate, amount), g.stateDB.GetBalance(addrDelegator))
g.Require().Equal(addrDelegator, g.s.Delegator(addr, big.NewInt(1)).Owner)
g.Require().Equal(0, len(g.s.QualifiedNodes()))
// 2st delegator delegate to 1st node.
_, addrDelegator2 := g.newPrefundAccount()
balanceBeforeDelegate = g.stateDB.GetBalance(addrDelegator2)
input, err = abiObject.Pack("delegate", addr)
g.Require().Nil(err)
_, err = g.call(addrDelegator2, input, amount)
g.Require().Nil(err)
g.Require().Equal(new(big.Int).Sub(balanceBeforeDelegate, amount), g.stateDB.GetBalance(addrDelegator2))
g.Require().Equal(addrDelegator2, g.s.Delegator(addr, big.NewInt(2)).Owner)
// Node is now qualified.
g.Require().Equal(1, len(g.s.QualifiedNodes()))
// Unstake.
input, err = abiObject.Pack("unstake")
g.Require().Nil(err)
_, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
time.Sleep(time.Second * 2)
input, err = abiObject.Pack("withdraw", addr)
g.Require().Nil(err)
_, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
_, err = g.call(addrDelegator, input, big.NewInt(0))
g.Require().Nil(err)
_, err = g.call(addrDelegator2, input, big.NewInt(0))
g.Require().Nil(err)
g.Require().Equal(0, int(g.s.LenDelegators(addr).Uint64()))
g.Require().Equal(0, int(g.s.LenNodes().Uint64()))
// Check balance.
g.Require().Equal(balanceBeforeDelegate, g.stateDB.GetBalance(addr))
g.Require().Equal(balanceBeforeDelegate, g.stateDB.GetBalance(addrDelegator))
g.Require().Equal(balanceBeforeDelegate, g.stateDB.GetBalance(addrDelegator2))
g.Require().Equal(big.NewInt(1), g.stateDB.GetBalance(GovernanceContractAddress))
}
func (g *GovernanceContractTestSuite) TestUpdateConfiguration() {
_, addr := g.newPrefundAccount()
input, err := abiObject.Pack("updateConfiguration",
new(big.Int).Mul(big.NewInt(1e18), big.NewInt(1e5)), big.NewInt(1000),
big.NewInt(1e18), big.NewInt(8000000), big.NewInt(6), big.NewInt(250), big.NewInt(2500),
big.NewInt(0), big.NewInt(667000), big.NewInt(4), big.NewInt(4), big.NewInt(600000), big.NewInt(900))
g.Require().Nil(err)
// Call with non-owner.
_, err = g.call(addr, input, big.NewInt(0))
g.Require().NotNil(err)
// Call with owner.
_, err = g.call(g.config.Owner, input, big.NewInt(0))
g.Require().Nil(err)
}
func (g *GovernanceContractTestSuite) TestSnapshotRound() {
_, addr := g.newPrefundAccount()
// Wrong height.
input, err := abiObject.Pack("snapshotRound", big.NewInt(1), big.NewInt(666))
g.Require().Nil(err)
_, err = g.call(addr, input, big.NewInt(0))
g.Require().NotNil(err)
// Invalid round.
input, err = abiObject.Pack("snapshotRound", big.NewInt(2), big.NewInt(2000))
g.Require().Nil(err)
_, err = g.call(addr, input, big.NewInt(0))
g.Require().NotNil(err)
// Correct.
input, err = abiObject.Pack("snapshotRound", big.NewInt(1), big.NewInt(1000))
g.Require().Nil(err)
_, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
// Duplicate round.
input, err = abiObject.Pack("snapshotRound", big.NewInt(1), big.NewInt(1000))
g.Require().Nil(err)
_, err = g.call(addr, input, big.NewInt(0))
g.Require().NotNil(err)
// Invalid round.
input, err = abiObject.Pack("snapshotRound", big.NewInt(3), big.NewInt(3000))
g.Require().Nil(err)
_, err = g.call(addr, input, big.NewInt(0))
g.Require().NotNil(err)
// Correct.
input, err = abiObject.Pack("snapshotRound", big.NewInt(2), big.NewInt(2000))
g.Require().Nil(err)
_, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
}
func (g *GovernanceContractTestSuite) TestConfigurationReading() {
_, addr := g.newPrefundAccount()
// CRS.
input, err := abiObject.Pack("crs", big.NewInt(0))
g.Require().Nil(err)
res, err := g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
var crs0 [32]byte
err = abiObject.Unpack(&crs0, "crs", res)
g.Require().Nil(err)
g.Require().Equal(crypto.Keccak256Hash([]byte(g.config.GenesisCRSText)), common.BytesToHash(crs0[:]))
// Owner.
input, err = abiObject.Pack("owner")
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
var owner common.Address
err = abiObject.Unpack(&owner, "owner", res)
g.Require().Nil(err)
g.Require().Equal(g.config.Owner, owner)
// MinStake.
input, err = abiObject.Pack("minStake")
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
var value *big.Int
err = abiObject.Unpack(&value, "minStake", res)
g.Require().Nil(err)
g.Require().Equal(g.config.MinStake.String(), value.String())
// BlockReward.
input, err = abiObject.Pack("blockReward")
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "blockReward", res)
g.Require().Nil(err)
g.Require().Equal(g.config.BlockReward.String(), value.String())
// BlockGasLimit.
input, err = abiObject.Pack("blockGasLimit")
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "blockGasLimit", res)
g.Require().Nil(err)
g.Require().Equal(g.config.BlockGasLimit, value.Uint64())
// NumChains.
input, err = abiObject.Pack("numChains")
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "numChains", res)
g.Require().Nil(err)
g.Require().Equal(g.config.NumChains, uint32(value.Uint64()))
// LambdaBA.
input, err = abiObject.Pack("lambdaBA")
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "lambdaBA", res)
g.Require().Nil(err)
g.Require().Equal(g.config.LambdaBA, value.Uint64())
// LambdaDKG.
input, err = abiObject.Pack("lambdaDKG")
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "lambdaDKG", res)
g.Require().Nil(err)
g.Require().Equal(g.config.LambdaDKG, value.Uint64())
// K.
input, err = abiObject.Pack("k")
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "k", res)
g.Require().Nil(err)
g.Require().Equal(g.config.K, uint32(value.Uint64()))
// PhiRatio.
input, err = abiObject.Pack("phiRatio")
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "phiRatio", res)
g.Require().Nil(err)
g.Require().Equal(g.config.PhiRatio, float32(value.Uint64())/phiRatioMultiplier)
// NotarySetSize.
input, err = abiObject.Pack("notarySetSize")
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "notarySetSize", res)
g.Require().Nil(err)
g.Require().Equal(g.config.NotarySetSize, uint32(value.Uint64()))
// DKGSetSize.
input, err = abiObject.Pack("dkgSetSize")
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "dkgSetSize", res)
g.Require().Nil(err)
g.Require().Equal(g.config.DKGSetSize, uint32(value.Uint64()))
// RoundInterval.
input, err = abiObject.Pack("roundInterval")
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "roundInterval", res)
g.Require().Nil(err)
g.Require().Equal(g.config.RoundInterval, value.Uint64())
// MinBlockInterval.
input, err = abiObject.Pack("minBlockInterval")
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "minBlockInterval", res)
g.Require().Nil(err)
g.Require().Equal(g.config.MinBlockInterval, value.Uint64())
}
func (g *GovernanceContractTestSuite) TestMiscVariableReading() {
privKey, addr := g.newPrefundAccount()
pk := crypto.FromECDSAPub(&privKey.PublicKey)
// Stake.
amount := new(big.Int).Mul(big.NewInt(1e18), big.NewInt(5e4))
input, err := abiObject.Pack("stake", pk, "Test1", "test1@dexon.org", "Taipei, Taiwan", "https://dexon.org")
g.Require().Nil(err)
_, err = g.call(addr, input, amount)
g.Require().Nil(err)
// 1st delegator delegate to 1st node.
_, addrDelegator := g.newPrefundAccount()
amount = new(big.Int).Mul(big.NewInt(1e18), big.NewInt(3e4))
input, err = abiObject.Pack("delegate", addr)
g.Require().Nil(err)
_, err = g.call(addrDelegator, input, amount)
g.Require().Nil(err)
// 2st delegator delegate to 1st node.
_, addrDelegator2 := g.newPrefundAccount()
input, err = abiObject.Pack("delegate", addr)
g.Require().Nil(err)
_, err = g.call(addrDelegator2, input, amount)
g.Require().Nil(err)
input, err = abiObject.Pack("nodesLength")
g.Require().Nil(err)
res, err := g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
var value *big.Int
err = abiObject.Unpack(&value, "nodesLength", res)
g.Require().Nil(err)
g.Require().Equal(1, int(value.Uint64()))
input, err = abiObject.Pack("nodesOffset", addr)
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "nodesOffset", res)
g.Require().Nil(err)
g.Require().Equal(0, int(value.Uint64()))
input, err = abiObject.Pack("delegatorsLength", addr)
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "delegatorsLength", res)
g.Require().Nil(err)
g.Require().Equal(3, int(value.Uint64()))
input, err = abiObject.Pack("delegatorsOffset", addr, addrDelegator2)
g.Require().Nil(err)
res, err = g.call(addr, input, big.NewInt(0))
g.Require().Nil(err)
err = abiObject.Unpack(&value, "delegatorsOffset", res)
g.Require().Nil(err)
g.Require().Equal(2, int(value.Uint64()))
}
func TestGovernanceContract(t *testing.T) {
suite.Run(t, new(GovernanceContractTestSuite))
}
