aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorJhih-Ming Huang <jm.huang@cobinhood.com>2019-02-19 11:26:49 +0800
committerJhih-Ming Huang <jm.huang@cobinhood.com>2019-04-11 10:39:58 +0800
commit85111874b93c3a1038c783d9b5964690a88d7cf8 (patch)
treef45d8dec85de0830ad55efbcfcd412a8985f7416
parent247edfc7fe5ab84c55cd666fa98632d9a3b35924 (diff)
downloaddexon-85111874b93c3a1038c783d9b5964690a88d7cf8.tar
dexon-85111874b93c3a1038c783d9b5964690a88d7cf8.tar.gz
dexon-85111874b93c3a1038c783d9b5964690a88d7cf8.tar.bz2
dexon-85111874b93c3a1038c783d9b5964690a88d7cf8.tar.lz
dexon-85111874b93c3a1038c783d9b5964690a88d7cf8.tar.xz
dexon-85111874b93c3a1038c783d9b5964690a88d7cf8.tar.zst
dexon-85111874b93c3a1038c783d9b5964690a88d7cf8.zip
core: rebase dev and fix lint
-rw-r--r--consensus/dexcon/fake_dexcon.go4
-rw-r--r--core/chain_makers.go4
-rw-r--r--core/dexon_chain_makers.go4
-rw-r--r--core/vm/evm/governance.go2198
-rw-r--r--core/vm/evm/governance_abi.go1133
-rw-r--r--core/vm/evm/governance_test.go1061
-rw-r--r--core/vm/evm/oracle.go (renamed from core/vm/oracle.go)7
-rw-r--r--core/vm/evm/oracle_contract_abi.go (renamed from core/vm/oracle_contract_abi.go)2
-rw-r--r--core/vm/evm/oracle_contracts.go (renamed from core/vm/oracle_contracts.go)17
-rw-r--r--core/vm/evm/oracle_contracts_test.go (renamed from core/vm/oracle_contracts_test.go)13
10 files changed, 27 insertions, 4416 deletions
diff --git a/consensus/dexcon/fake_dexcon.go b/consensus/dexcon/fake_dexcon.go
index 430d9bc6b..befda7514 100644
--- a/consensus/dexcon/fake_dexcon.go
+++ b/consensus/dexcon/fake_dexcon.go
@@ -16,7 +16,7 @@ import (
"github.com/dexon-foundation/dexon/common"
"github.com/dexon-foundation/dexon/consensus"
"github.com/dexon-foundation/dexon/core/types"
- "github.com/dexon-foundation/dexon/core/vm"
+ "github.com/dexon-foundation/dexon/core/vm/evm"
"github.com/dexon-foundation/dexon/crypto"
"github.com/dexon-foundation/dexon/rlp"
)
@@ -140,7 +140,7 @@ func (n *Node) DKGFinalize(round uint64) *coreTypesDKG.Finalize {
func (n *Node) CreateGovTx(nonce uint64, data []byte) *types.Transaction {
tx, err := types.SignTx(types.NewTransaction(
nonce,
- vm.GovernanceContractAddress,
+ evm.GovernanceContractAddress,
big.NewInt(0),
uint64(2000000),
big.NewInt(1e10),
diff --git a/core/chain_makers.go b/core/chain_makers.go
index f57eb37ff..50a537964 100644
--- a/core/chain_makers.go
+++ b/core/chain_makers.go
@@ -27,7 +27,7 @@ import (
"github.com/dexon-foundation/dexon/consensus/misc"
"github.com/dexon-foundation/dexon/core/state"
"github.com/dexon-foundation/dexon/core/types"
- "github.com/dexon-foundation/dexon/core/vm"
+ "github.com/dexon-foundation/dexon/core/vm/evm"
"github.com/dexon-foundation/dexon/ethdb"
"github.com/dexon-foundation/dexon/params"
)
@@ -103,7 +103,7 @@ func (b *BlockGen) AddTxWithChain(bc *BlockChain, tx *types.Transaction) {
b.SetCoinbase(common.Address{})
}
b.statedb.Prepare(tx.Hash(), common.Hash{}, len(b.txs))
- receipt, _, err := ApplyTransaction(b.config, bc, &b.header.Coinbase, b.gasPool, b.statedb, b.header, tx, &b.header.GasUsed, vm.Config{})
+ receipt, _, err := ApplyTransaction(b.config, bc, &b.header.Coinbase, b.gasPool, b.statedb, b.header, tx, &b.header.GasUsed, evm.Config{})
if err != nil {
panic(err)
}
diff --git a/core/dexon_chain_makers.go b/core/dexon_chain_makers.go
index 010b30c84..6901a8bc2 100644
--- a/core/dexon_chain_makers.go
+++ b/core/dexon_chain_makers.go
@@ -28,7 +28,7 @@ import (
"github.com/dexon-foundation/dexon/consensus"
"github.com/dexon-foundation/dexon/core/state"
"github.com/dexon-foundation/dexon/core/types"
- "github.com/dexon-foundation/dexon/core/vm"
+ "github.com/dexon-foundation/dexon/core/vm/evm"
"github.com/dexon-foundation/dexon/ethdb"
"github.com/dexon-foundation/dexon/params"
"github.com/dexon-foundation/dexon/rlp"
@@ -110,7 +110,7 @@ func (b *DexonBlockGen) ProcessTransactions(c ChainContext) {
for _, tx := range b.txs {
b.statedb.Prepare(tx.Hash(), common.Hash{}, len(b.txs))
// TODO: fix the chain context parameter
- receipt, _, err := ApplyTransaction(b.config, c, &b.header.Coinbase, b.gasPool, b.statedb, b.header, tx, &b.header.GasUsed, vm.Config{})
+ receipt, _, err := ApplyTransaction(b.config, c, &b.header.Coinbase, b.gasPool, b.statedb, b.header, tx, &b.header.GasUsed, evm.Config{})
if err != nil {
panic(err)
}
diff --git a/core/vm/evm/governance.go b/core/vm/evm/governance.go
deleted file mode 100644
index 18e733342..000000000
--- a/core/vm/evm/governance.go
+++ /dev/null
@@ -1,2198 +0,0 @@
-// 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 evm
-
-import (
- "bytes"
- "errors"
- "math/big"
- "sort"
- "strings"
-
- "github.com/dexon-foundation/dexon/accounts/abi"
- "github.com/dexon-foundation/dexon/common"
- "github.com/dexon-foundation/dexon/core/types"
- "github.com/dexon-foundation/dexon/crypto"
- "github.com/dexon-foundation/dexon/params"
- "github.com/dexon-foundation/dexon/rlp"
-
- coreCommon "github.com/dexon-foundation/dexon-consensus/common"
- "github.com/dexon-foundation/dexon-consensus/core"
- coreCrypto "github.com/dexon-foundation/dexon-consensus/core/crypto"
- coreUtils "github.com/dexon-foundation/dexon-consensus/core/utils"
- "github.com/dexon-foundation/dexon/core/vm"
-
- "github.com/dexon-foundation/dexon-consensus/core/crypto/ecdsa"
- coreTypes "github.com/dexon-foundation/dexon-consensus/core/types"
- dkgTypes "github.com/dexon-foundation/dexon-consensus/core/types/dkg"
-)
-
-var GovernanceContractAddress = common.HexToAddress("63751838d6485578b23e8b051d40861ecc416794")
-
-var abiObject abi.ABI
-var GovernanceContractName2Method map[string]abi.Method
-var sig2Method map[string]abi.Method
-var events map[string]abi.Event
-
-type Bytes32 [32]byte
-
-type ReportType uint64
-
-const (
- ReportTypeInvalidDKG = iota
- ReportTypeForkVote
- ReportTypeForkBlock
-)
-
-func init() {
- var err error
-
- // Parse governance contract ABI.
- abiObject, err = abi.JSON(strings.NewReader(GovernanceABIJSON))
- if err != nil {
- panic(err)
- }
-
- sig2Method = make(map[string]abi.Method)
- GovernanceContractName2Method = make(map[string]abi.Method)
-
- // Construct dispatch table.
- for _, method := range abiObject.Methods {
- sig2Method[string(method.Id())] = method
- GovernanceContractName2Method[method.Name] = method
- }
-
- events = make(map[string]abi.Event)
-
- // Event cache.
- for _, event := range abiObject.Events {
- events[event.Name] = event
- }
-}
-
-// RunGovernanceContract executes governance contract.
-func RunGovernanceContract(evm *EVM, input []byte, contract *vm.Contract) (ret []byte, err error) {
- if len(input) < 4 {
- return nil, nil
- }
-
- // Parse input.
- method, exists := sig2Method[string(input[:4])]
- if !exists {
- return nil, errExecutionReverted
- }
-
- // Dispatch method call.
- g := newGovernanceContract(evm, contract)
- arguments := input[4:]
-
- switch method.Name {
- case "addDKGComplaint":
- args := struct {
- Round *big.Int
- Complaint []byte
- }{}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.addDKGComplaint(args.Round, args.Complaint)
- case "addDKGMasterPublicKey":
- args := struct {
- Round *big.Int
- PublicKey []byte
- }{}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.addDKGMasterPublicKey(args.Round, args.PublicKey)
- case "addDKGMPKReady":
- args := struct {
- Round *big.Int
- MPKReady []byte
- }{}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.addDKGMPKReady(args.Round, args.MPKReady)
- case "addDKGFinalize":
- args := struct {
- Round *big.Int
- Finalize []byte
- }{}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.addDKGFinalize(args.Round, args.Finalize)
- case "delegate":
- address := common.Address{}
- if err := method.Inputs.Unpack(&address, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.delegate(address)
- case "delegatorsLength":
- address := common.Address{}
- if err := method.Inputs.Unpack(&address, arguments); err != nil {
- return nil, errExecutionReverted
- }
- res, err := method.Outputs.Pack(g.state.LenDelegators(address))
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "nodesLength":
- res, err := method.Outputs.Pack(g.state.LenNodes())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "payFine":
- address := common.Address{}
- if err := method.Inputs.Unpack(&address, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.payFine(address)
- case "proposeCRS":
- args := struct {
- Round *big.Int
- SignedCRS []byte
- }{}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.proposeCRS(args.Round, args.SignedCRS)
- case "report":
- args := struct {
- Type *big.Int
- Arg1 []byte
- Arg2 []byte
- }{}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.report(args.Type, args.Arg1, args.Arg2)
- case "stake":
- args := struct {
- PublicKey []byte
- Name string
- Email string
- Location string
- Url string
- }{}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.stake(args.PublicKey, args.Name, args.Email, args.Location, args.Url)
- case "snapshotRound":
- args := struct {
- Round *big.Int
- Height *big.Int
- }{}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.snapshotRound(args.Round, args.Height)
- case "transferOwnership":
- var newOwner common.Address
- if err := method.Inputs.Unpack(&newOwner, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.transferOwnership(newOwner)
- case "undelegate":
- address := common.Address{}
- if err := method.Inputs.Unpack(&address, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.undelegate(address)
- case "unstake":
- return g.unstake()
- case "updateConfiguration":
- var cfg rawConfigStruct
- if err := method.Inputs.Unpack(&cfg, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.updateConfiguration(&cfg)
- case "withdraw":
- address := common.Address{}
- if err := method.Inputs.Unpack(&address, arguments); err != nil {
- return nil, errExecutionReverted
- }
- return g.withdraw(address)
-
- // --------------------------------
- // Solidity auto generated methods.
- // --------------------------------
-
- case "blockGasLimit":
- res, err := method.Outputs.Pack(g.state.BlockGasLimit())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "crs":
- round := new(big.Int)
- if err := method.Inputs.Unpack(&round, arguments); err != nil {
- return nil, errExecutionReverted
- }
- res, err := method.Outputs.Pack(g.state.CRS(round))
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "delegators":
- nodeAddr, index := common.Address{}, new(big.Int)
- args := []interface{}{&nodeAddr, &index}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- delegator := g.state.Delegator(nodeAddr, index)
- res, err := method.Outputs.Pack(delegator.Owner, delegator.Value, delegator.UndelegatedAt)
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "delegatorsOffset":
- nodeAddr, delegatorAddr := common.Address{}, common.Address{}
- args := []interface{}{&nodeAddr, &delegatorAddr}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- res, err := method.Outputs.Pack(g.state.DelegatorsOffset(nodeAddr, delegatorAddr))
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "dkgComplaints":
- round, index := new(big.Int), new(big.Int)
- args := []interface{}{&round, &index}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- complaints := g.state.DKGComplaints(round)
- if int(index.Uint64()) >= len(complaints) {
- return nil, errExecutionReverted
- }
- complaint := complaints[index.Uint64()]
- res, err := method.Outputs.Pack(complaint)
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "dkgReadys":
- round, addr := new(big.Int), common.Address{}
- args := []interface{}{&round, &addr}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- ready := g.state.DKGMPKReady(round, addr)
- res, err := method.Outputs.Pack(ready)
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "dkgReadysCount":
- round := new(big.Int)
- if err := method.Inputs.Unpack(&round, arguments); err != nil {
- return nil, errExecutionReverted
- }
- count := g.state.DKGMPKReadysCount(round)
- res, err := method.Outputs.Pack(count)
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
-
- case "dkgFinalizeds":
- round, addr := new(big.Int), common.Address{}
- args := []interface{}{&round, &addr}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- finalized := g.state.DKGFinalized(round, addr)
- res, err := method.Outputs.Pack(finalized)
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "dkgFinalizedsCount":
- round := new(big.Int)
- if err := method.Inputs.Unpack(&round, arguments); err != nil {
- return nil, errExecutionReverted
- }
- count := g.state.DKGFinalizedsCount(round)
- res, err := method.Outputs.Pack(count)
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "dkgMasterPublicKeys":
- round, index := new(big.Int), new(big.Int)
- args := []interface{}{&round, &index}
- if err := method.Inputs.Unpack(&args, arguments); err != nil {
- return nil, errExecutionReverted
- }
- mpks := g.state.DKGMasterPublicKeys(round)
- if int(index.Uint64()) >= len(mpks) {
- return nil, errExecutionReverted
- }
- mpk := mpks[index.Uint64()]
- res, err := method.Outputs.Pack(mpk)
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "dkgSetSize":
- res, err := method.Outputs.Pack(g.state.DKGSetSize())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "finedRecords":
- record := Bytes32{}
- if err := method.Inputs.Unpack(&record, arguments); err != nil {
- return nil, errExecutionReverted
- }
- value := g.state.FineRecords(record)
- res, err := method.Outputs.Pack(value)
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "fineValues":
- index := new(big.Int)
- if err := method.Inputs.Unpack(&index, arguments); err != nil {
- return nil, errExecutionReverted
- }
- value := g.state.FineValue(index)
- res, err := method.Outputs.Pack(value)
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "k":
- res, err := method.Outputs.Pack(g.state.K())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "lambdaBA":
- res, err := method.Outputs.Pack(g.state.LambdaBA())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "lambdaDKG":
- res, err := method.Outputs.Pack(g.state.LambdaDKG())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "lastHalvedAmount":
- res, err := method.Outputs.Pack(g.state.LastHalvedAmount())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "lockupPeriod":
- res, err := method.Outputs.Pack(g.state.LockupPeriod())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "minBlockInterval":
- res, err := method.Outputs.Pack(g.state.MinBlockInterval())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "miningVelocity":
- res, err := method.Outputs.Pack(g.state.MiningVelocity())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "minStake":
- res, err := method.Outputs.Pack(g.state.MinStake())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "nextHalvingSupply":
- res, err := method.Outputs.Pack(g.state.NextHalvingSupply())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "numChains":
- res, err := method.Outputs.Pack(g.state.NumChains())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "nodes":
- index := new(big.Int)
- if err := method.Inputs.Unpack(&index, arguments); err != nil {
- return nil, errExecutionReverted
- }
- info := g.state.Node(index)
- res, err := method.Outputs.Pack(
- info.Owner, info.PublicKey, info.Staked, info.Fined,
- info.Name, info.Email, info.Location, info.Url)
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "nodesOffsetByAddress":
- address := common.Address{}
- if err := method.Inputs.Unpack(&address, arguments); err != nil {
- return nil, errExecutionReverted
- }
- res, err := method.Outputs.Pack(g.state.NodesOffsetByAddress(address))
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "nodesOffsetByID":
- var id Bytes32
- if err := method.Inputs.Unpack(&id, arguments); err != nil {
- return nil, errExecutionReverted
- }
- res, err := method.Outputs.Pack(g.state.NodesOffsetByID(id))
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "notarySetSize":
- res, err := method.Outputs.Pack(g.state.NotarySetSize())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "owner":
- res, err := method.Outputs.Pack(g.state.Owner())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "phiRatio":
- res, err := method.Outputs.Pack(g.state.PhiRatio())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "roundHeight":
- round := new(big.Int)
- if err := method.Inputs.Unpack(&round, arguments); err != nil {
- return nil, errExecutionReverted
- }
- res, err := method.Outputs.Pack(g.state.RoundHeight(round))
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "roundInterval":
- res, err := method.Outputs.Pack(g.state.RoundInterval())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "totalStaked":
- res, err := method.Outputs.Pack(g.state.TotalStaked())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- case "totalSupply":
- res, err := method.Outputs.Pack(g.state.TotalSupply())
- if err != nil {
- return nil, errExecutionReverted
- }
- return res, nil
- }
- return nil, errExecutionReverted
-}
-
-// Storage position enums.
-const (
- roundHeightLoc = iota
- totalSupplyLoc
- totalStakedLoc
- nodesLoc
- nodesOffsetByAddressLoc
- nodesOffsetByIDLoc
- delegatorsLoc
- delegatorsOffsetLoc
- crsLoc
- dkgMasterPublicKeysLoc
- dkgComplaintsLoc
- dkgReadyLoc
- dkgReadysCountLoc
- dkgFinalizedLoc
- dkgFinalizedsCountLoc
- ownerLoc
- minStakeLoc
- lockupPeriodLoc
- miningVelocityLoc
- nextHalvingSupplyLoc
- lastHalvedAmountLoc
- blockGasLimitLoc
- numChainsLoc
- lambdaBALoc
- lambdaDKGLoc
- kLoc
- phiRatioLoc
- notarySetSizeLoc
- dkgSetSizeLoc
- roundIntervalLoc
- minBlockIntervalLoc
- fineValuesLoc
- finedRecordsLoc
-)
-
-func publicKeyToNodeID(pkBytes []byte) (Bytes32, error) {
- pk, err := crypto.UnmarshalPubkey(pkBytes)
- if err != nil {
- return Bytes32{}, err
- }
- id := Bytes32(coreTypes.NewNodeID(ecdsa.NewPublicKeyFromECDSA(pk)).Hash)
- return id, nil
-}
-
-// State manipulation helper fro the governance contract.
-type GovernanceStateHelper struct {
- StateDB vm.StateDB
-}
-
-func (s *GovernanceStateHelper) getState(loc common.Hash) common.Hash {
- return s.StateDB.GetState(GovernanceContractAddress, loc)
-}
-
-func (s *GovernanceStateHelper) setState(loc common.Hash, val common.Hash) {
- s.StateDB.SetState(GovernanceContractAddress, loc, val)
-}
-
-func (s *GovernanceStateHelper) getStateBigInt(loc *big.Int) *big.Int {
- res := s.StateDB.GetState(GovernanceContractAddress, common.BigToHash(loc))
- return new(big.Int).SetBytes(res.Bytes())
-}
-
-func (s *GovernanceStateHelper) setStateBigInt(loc *big.Int, val *big.Int) {
- s.setState(common.BigToHash(loc), common.BigToHash(val))
-}
-
-func (s *GovernanceStateHelper) getSlotLoc(loc *big.Int) *big.Int {
- return new(big.Int).SetBytes(crypto.Keccak256(common.BigToHash(loc).Bytes()))
-}
-
-func (s *GovernanceStateHelper) getMapLoc(pos *big.Int, key []byte) *big.Int {
- return new(big.Int).SetBytes(crypto.Keccak256(key, common.BigToHash(pos).Bytes()))
-}
-
-func (s *GovernanceStateHelper) readBytes(loc *big.Int) []byte {
- // Length of the dynamic array (bytes).
- rawLength := s.getStateBigInt(loc)
- lengthByte := new(big.Int).Mod(rawLength, big.NewInt(256))
-
- // Bytes length <= 31, lengthByte % 2 == 0
- // return the high 31 bytes.
- if new(big.Int).Mod(lengthByte, big.NewInt(2)).Cmp(big.NewInt(0)) == 0 {
- length := new(big.Int).Div(lengthByte, big.NewInt(2)).Uint64()
- return rawLength.Bytes()[:length]
- }
-
- // Actual length = (rawLength - 1) / 2
- length := new(big.Int).Div(new(big.Int).Sub(rawLength, big.NewInt(1)), big.NewInt(2)).Uint64()
-
- // Data address.
- dataLoc := s.getSlotLoc(loc)
-
- // Read continuously for length bytes.
- carry := int64(0)
- if length%32 > 0 {
- carry = 1
- }
- chunks := int64(length/32) + carry
- var data []byte
- for i := int64(0); i < chunks; i++ {
- loc = new(big.Int).Add(dataLoc, big.NewInt(i))
- data = append(data, s.getState(common.BigToHash(loc)).Bytes()...)
- }
- data = data[:length]
- return data
-}
-
-func (s *GovernanceStateHelper) writeBytes(loc *big.Int, data []byte) {
- length := int64(len(data))
-
- if length == 0 {
- s.setState(common.BigToHash(loc), common.Hash{})
- return
- }
-
- // Short bytes (length <= 31).
- if length < 32 {
- data2 := append([]byte(nil), data...)
- // Right pad with zeros
- for len(data2) < 31 {
- data2 = append(data2, byte(0))
- }
- data2 = append(data2, byte(length*2))
- s.setState(common.BigToHash(loc), common.BytesToHash(data2))
- return
- }
-
- // Write 2 * length + 1.
- storedLength := new(big.Int).Add(new(big.Int).Mul(
- big.NewInt(length), big.NewInt(2)), big.NewInt(1))
- s.setStateBigInt(loc, storedLength)
- // Write data chunck.
- dataLoc := s.getSlotLoc(loc)
- carry := int64(0)
- if length%32 > 0 {
- carry = 1
- }
- chunks := length/32 + carry
- for i := int64(0); i < chunks; i++ {
- loc = new(big.Int).Add(dataLoc, big.NewInt(i))
- maxLoc := (i + 1) * 32
- if maxLoc > length {
- maxLoc = length
- }
- data2 := data[i*32 : maxLoc]
- // Right pad with zeros.
- for len(data2) < 32 {
- data2 = append(data2, byte(0))
- }
- s.setState(common.BigToHash(loc), common.BytesToHash(data2))
- }
-}
-
-func (s *GovernanceStateHelper) read2DByteArray(pos, index *big.Int) [][]byte {
- baseLoc := s.getSlotLoc(pos)
- loc := new(big.Int).Add(baseLoc, index)
-
- arrayLength := s.getStateBigInt(loc)
- dataLoc := s.getSlotLoc(loc)
-
- data := [][]byte{}
- for i := int64(0); i < int64(arrayLength.Uint64()); i++ {
- elementLoc := new(big.Int).Add(dataLoc, big.NewInt(i))
- data = append(data, s.readBytes(elementLoc))
- }
-
- return data
-}
-func (s *GovernanceStateHelper) appendTo2DByteArray(pos, index *big.Int, data []byte) {
- // Find the loc of the last element.
- baseLoc := s.getSlotLoc(pos)
- loc := new(big.Int).Add(baseLoc, index)
-
- // Increase length by 1.
- arrayLength := s.getStateBigInt(loc)
- s.setStateBigInt(loc, new(big.Int).Add(arrayLength, big.NewInt(1)))
-
- // Write element.
- dataLoc := s.getSlotLoc(loc)
- elementLoc := new(big.Int).Add(dataLoc, arrayLength)
- s.writeBytes(elementLoc, data)
-}
-
-// uint256[] public roundHeight;
-func (s *GovernanceStateHelper) LenRoundHeight() *big.Int {
- return s.getStateBigInt(big.NewInt(roundHeightLoc))
-}
-func (s *GovernanceStateHelper) RoundHeight(round *big.Int) *big.Int {
- baseLoc := s.getSlotLoc(big.NewInt(roundHeightLoc))
- loc := new(big.Int).Add(baseLoc, round)
- return s.getStateBigInt(loc)
-}
-func (s *GovernanceStateHelper) PushRoundHeight(height *big.Int) {
- // Increase length by 1.
- length := s.getStateBigInt(big.NewInt(roundHeightLoc))
- s.setStateBigInt(big.NewInt(roundHeightLoc), new(big.Int).Add(length, big.NewInt(1)))
-
- baseLoc := s.getSlotLoc(big.NewInt(roundHeightLoc))
- loc := new(big.Int).Add(baseLoc, length)
-
- s.setStateBigInt(loc, height)
-}
-
-// uint256 public totalSupply;
-func (s *GovernanceStateHelper) TotalSupply() *big.Int {
- return s.getStateBigInt(big.NewInt(totalSupplyLoc))
-}
-func (s *GovernanceStateHelper) IncTotalSupply(amount *big.Int) {
- s.setStateBigInt(big.NewInt(totalSupplyLoc), new(big.Int).Add(s.TotalSupply(), amount))
-}
-func (s *GovernanceStateHelper) DecTotalSupply(amount *big.Int) {
- s.setStateBigInt(big.NewInt(totalSupplyLoc), new(big.Int).Sub(s.TotalSupply(), amount))
-}
-
-// uint256 public totalStaked;
-func (s *GovernanceStateHelper) TotalStaked() *big.Int {
- return s.getStateBigInt(big.NewInt(totalStakedLoc))
-}
-func (s *GovernanceStateHelper) IncTotalStaked(amount *big.Int) {
- s.setStateBigInt(big.NewInt(totalStakedLoc), new(big.Int).Add(s.TotalStaked(), amount))
-}
-func (s *GovernanceStateHelper) DecTotalStaked(amount *big.Int) {
- s.setStateBigInt(big.NewInt(totalStakedLoc), new(big.Int).Sub(s.TotalStaked(), amount))
-}
-
-// struct Node {
-// address owner;
-// bytes publicKey;
-// uint256 staked;
-// uint256 fined;
-// string name;
-// string email;
-// string location;
-// string url;
-// }
-//
-// Node[] nodes;
-
-type nodeInfo struct {
- Owner common.Address
- PublicKey []byte
- Staked *big.Int
- Fined *big.Int
- Name string
- Email string
- Location string
- Url string
-}
-
-const nodeStructSize = 8
-
-func (s *GovernanceStateHelper) LenNodes() *big.Int {
- return s.getStateBigInt(big.NewInt(nodesLoc))
-}
-func (s *GovernanceStateHelper) Node(index *big.Int) *nodeInfo {
- node := new(nodeInfo)
-
- arrayBaseLoc := s.getSlotLoc(big.NewInt(nodesLoc))
- elementBaseLoc := new(big.Int).Add(arrayBaseLoc,
- new(big.Int).Mul(index, big.NewInt(nodeStructSize)))
-
- // Owner.
- loc := elementBaseLoc
- node.Owner = common.BytesToAddress(s.getState(common.BigToHash(elementBaseLoc)).Bytes())
-
- // PublicKey.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(1))
- node.PublicKey = s.readBytes(loc)
-
- // Staked.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(2))
- node.Staked = s.getStateBigInt(loc)
-
- // Fined.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(3))
- node.Fined = s.getStateBigInt(loc)
-
- // Name.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(4))
- node.Name = string(s.readBytes(loc))
-
- // Email.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(5))
- node.Email = string(s.readBytes(loc))
-
- // Location.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(6))
- node.Location = string(s.readBytes(loc))
-
- // Url.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(7))
- node.Url = string(s.readBytes(loc))
-
- return node
-}
-func (s *GovernanceStateHelper) PushNode(n *nodeInfo) {
- // Increase length by 1.
- arrayLength := s.LenNodes()
- s.setStateBigInt(big.NewInt(nodesLoc), new(big.Int).Add(arrayLength, big.NewInt(1)))
-
- s.UpdateNode(arrayLength, n)
-}
-func (s *GovernanceStateHelper) UpdateNode(index *big.Int, n *nodeInfo) {
- arrayBaseLoc := s.getSlotLoc(big.NewInt(nodesLoc))
- elementBaseLoc := new(big.Int).Add(arrayBaseLoc,
- new(big.Int).Mul(index, big.NewInt(nodeStructSize)))
-
- // Owner.
- loc := elementBaseLoc
- s.setState(common.BigToHash(loc), n.Owner.Hash())
-
- // PublicKey.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(1))
- s.writeBytes(loc, n.PublicKey)
-
- // Staked.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(2))
- s.setStateBigInt(loc, n.Staked)
-
- // Fined.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(3))
- s.setStateBigInt(loc, n.Fined)
-
- // Name.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(4))
- s.writeBytes(loc, []byte(n.Name))
-
- // Email.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(5))
- s.writeBytes(loc, []byte(n.Email))
-
- // Location.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(6))
- s.writeBytes(loc, []byte(n.Location))
-
- // Url.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(7))
- s.writeBytes(loc, []byte(n.Url))
-}
-func (s *GovernanceStateHelper) PopLastNode() {
- // Decrease length by 1.
- arrayLength := s.LenNodes()
- newArrayLength := new(big.Int).Sub(arrayLength, big.NewInt(1))
- s.setStateBigInt(big.NewInt(nodesLoc), newArrayLength)
-
- s.UpdateNode(newArrayLength, &nodeInfo{
- Staked: big.NewInt(0),
- Fined: big.NewInt(0),
- })
-}
-func (s *GovernanceStateHelper) Nodes() []*nodeInfo {
- var nodes []*nodeInfo
- for i := int64(0); i < int64(s.LenNodes().Uint64()); i++ {
- nodes = append(nodes, s.Node(big.NewInt(i)))
- }
- return nodes
-}
-func (s *GovernanceStateHelper) QualifiedNodes() []*nodeInfo {
- var nodes []*nodeInfo
- for i := int64(0); i < int64(s.LenNodes().Uint64()); i++ {
- node := s.Node(big.NewInt(i))
- if new(big.Int).Sub(node.Staked, node.Fined).Cmp(s.MinStake()) >= 0 {
- nodes = append(nodes, node)
- }
- }
- return nodes
-}
-
-// mapping(address => uint256) public nodeOffsetByAddress;
-func (s *GovernanceStateHelper) NodesOffsetByAddress(addr common.Address) *big.Int {
- loc := s.getMapLoc(big.NewInt(nodesOffsetByAddressLoc), addr.Bytes())
- return new(big.Int).Sub(s.getStateBigInt(loc), big.NewInt(1))
-}
-func (s *GovernanceStateHelper) PutNodesOffsetByAddress(addr common.Address, offset *big.Int) {
- loc := s.getMapLoc(big.NewInt(nodesOffsetByAddressLoc), addr.Bytes())
- s.setStateBigInt(loc, new(big.Int).Add(offset, big.NewInt(1)))
-}
-func (s *GovernanceStateHelper) DeleteNodesOffsetByAddress(addr common.Address) {
- loc := s.getMapLoc(big.NewInt(nodesOffsetByAddressLoc), addr.Bytes())
- s.setStateBigInt(loc, big.NewInt(0))
-}
-
-// mapping(address => uint256) public nodeOffsetByID;
-func (s *GovernanceStateHelper) NodesOffsetByID(id Bytes32) *big.Int {
- loc := s.getMapLoc(big.NewInt(nodesOffsetByIDLoc), id[:])
- return new(big.Int).Sub(s.getStateBigInt(loc), big.NewInt(1))
-}
-func (s *GovernanceStateHelper) PutNodesOffsetByID(id Bytes32, offset *big.Int) {
- loc := s.getMapLoc(big.NewInt(nodesOffsetByIDLoc), id[:])
- s.setStateBigInt(loc, new(big.Int).Add(offset, big.NewInt(1)))
-}
-func (s *GovernanceStateHelper) DeleteNodesOffsetByID(id Bytes32) {
- loc := s.getMapLoc(big.NewInt(nodesOffsetByIDLoc), id[:])
- s.setStateBigInt(loc, big.NewInt(0))
-}
-
-func (s *GovernanceStateHelper) PutNodeOffsets(n *nodeInfo, offset *big.Int) error {
- id, err := publicKeyToNodeID(n.PublicKey)
- if err != nil {
- return err
- }
- s.PutNodesOffsetByID(id, offset)
- s.PutNodesOffsetByAddress(n.Owner, offset)
- return nil
-}
-
-// struct Delegator {
-// address node;
-// address owner;
-// uint256 value;
-// uint256 undelegated_at;
-// }
-
-type delegatorInfo struct {
- Owner common.Address
- Value *big.Int
- UndelegatedAt *big.Int
-}
-
-const delegatorStructSize = 3
-
-// mapping(address => Delegator[]) public delegators;
-func (s *GovernanceStateHelper) LenDelegators(nodeAddr common.Address) *big.Int {
- loc := s.getMapLoc(big.NewInt(delegatorsLoc), nodeAddr.Bytes())
- return s.getStateBigInt(loc)
-}
-func (s *GovernanceStateHelper) Delegator(nodeAddr common.Address, offset *big.Int) *delegatorInfo {
- delegator := new(delegatorInfo)
-
- loc := s.getMapLoc(big.NewInt(delegatorsLoc), nodeAddr.Bytes())
- arrayBaseLoc := s.getSlotLoc(loc)
- elementBaseLoc := new(big.Int).Add(arrayBaseLoc, new(big.Int).Mul(big.NewInt(delegatorStructSize), offset))
-
- // Owner.
- loc = elementBaseLoc
- delegator.Owner = common.BytesToAddress(s.getState(common.BigToHash(elementBaseLoc)).Bytes())
-
- // Value.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(1))
- delegator.Value = s.getStateBigInt(loc)
-
- // UndelegatedAt.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(2))
- delegator.UndelegatedAt = s.getStateBigInt(loc)
-
- return delegator
-}
-func (s *GovernanceStateHelper) PushDelegator(nodeAddr common.Address, delegator *delegatorInfo) {
- // Increase length by 1.
- arrayLength := s.LenDelegators(nodeAddr)
- loc := s.getMapLoc(big.NewInt(delegatorsLoc), nodeAddr.Bytes())
- s.setStateBigInt(loc, new(big.Int).Add(arrayLength, big.NewInt(1)))
-
- s.UpdateDelegator(nodeAddr, arrayLength, delegator)
-}
-func (s *GovernanceStateHelper) UpdateDelegator(nodeAddr common.Address, offset *big.Int, delegator *delegatorInfo) {
- loc := s.getMapLoc(big.NewInt(delegatorsLoc), nodeAddr.Bytes())
- arrayBaseLoc := s.getSlotLoc(loc)
- elementBaseLoc := new(big.Int).Add(arrayBaseLoc, new(big.Int).Mul(big.NewInt(delegatorStructSize), offset))
-
- // Owner.
- loc = elementBaseLoc
- s.setState(common.BigToHash(loc), delegator.Owner.Hash())
-
- // Value.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(1))
- s.setStateBigInt(loc, delegator.Value)
-
- // UndelegatedAt.
- loc = new(big.Int).Add(elementBaseLoc, big.NewInt(2))
- s.setStateBigInt(loc, delegator.UndelegatedAt)
-}
-func (s *GovernanceStateHelper) PopLastDelegator(nodeAddr common.Address) {
- // Decrease length by 1.
- arrayLength := s.LenDelegators(nodeAddr)
- newArrayLength := new(big.Int).Sub(arrayLength, big.NewInt(1))
- loc := s.getMapLoc(big.NewInt(delegatorsLoc), nodeAddr.Bytes())
- s.setStateBigInt(loc, newArrayLength)
-
- s.UpdateDelegator(nodeAddr, newArrayLength, &delegatorInfo{
- Value: big.NewInt(0),
- UndelegatedAt: big.NewInt(0),
- })
-}
-
-// mapping(address => mapping(address => uint256)) delegatorsOffset;
-func (s *GovernanceStateHelper) DelegatorsOffset(nodeAddr, delegatorAddr common.Address) *big.Int {
- loc := s.getMapLoc(s.getMapLoc(big.NewInt(delegatorsOffsetLoc), nodeAddr.Bytes()), delegatorAddr.Bytes())
- return new(big.Int).Sub(s.getStateBigInt(loc), big.NewInt(1))
-}
-func (s *GovernanceStateHelper) PutDelegatorOffset(nodeAddr, delegatorAddr common.Address, offset *big.Int) {
- loc := s.getMapLoc(s.getMapLoc(big.NewInt(delegatorsOffsetLoc), nodeAddr.Bytes()), delegatorAddr.Bytes())
- s.setStateBigInt(loc, new(big.Int).Add(offset, big.NewInt(1)))
-}
-func (s *GovernanceStateHelper) DeleteDelegatorsOffset(nodeAddr, delegatorAddr common.Address) {
- loc := s.getMapLoc(s.getMapLoc(big.NewInt(delegatorsOffsetLoc), nodeAddr.Bytes()), delegatorAddr.Bytes())
- s.setStateBigInt(loc, big.NewInt(0))
-}
-
-// bytes32[] public crs;
-func (s *GovernanceStateHelper) LenCRS() *big.Int {
- return s.getStateBigInt(big.NewInt(crsLoc))
-}
-func (s *GovernanceStateHelper) CRS(index *big.Int) common.Hash {
- baseLoc := s.getSlotLoc(big.NewInt(crsLoc))
- loc := new(big.Int).Add(baseLoc, index)
- return s.getState(common.BigToHash(loc))
-}
-func (s *GovernanceStateHelper) CurrentCRS() common.Hash {
- return s.CRS(new(big.Int).Sub(s.LenCRS(), big.NewInt(1)))
-}
-func (s *GovernanceStateHelper) PushCRS(crs common.Hash) {
- // increase length by 1.
- length := s.getStateBigInt(big.NewInt(crsLoc))
- s.setStateBigInt(big.NewInt(crsLoc), new(big.Int).Add(length, big.NewInt(1)))
-
- baseLoc := s.getSlotLoc(big.NewInt(crsLoc))
- loc := new(big.Int).Add(baseLoc, length)
-
- s.setState(common.BigToHash(loc), crs)
-}
-func (s *GovernanceStateHelper) Round() *big.Int {
- return new(big.Int).Sub(s.getStateBigInt(big.NewInt(crsLoc)), big.NewInt(1))
-}
-
-// bytes[][] public dkgMasterPublicKeys;
-func (s *GovernanceStateHelper) DKGMasterPublicKeys(round *big.Int) [][]byte {
- return s.read2DByteArray(big.NewInt(dkgMasterPublicKeysLoc), round)
-}
-func (s *GovernanceStateHelper) PushDKGMasterPublicKey(round *big.Int, mpk []byte) {
- s.appendTo2DByteArray(big.NewInt(dkgMasterPublicKeysLoc), round, mpk)
-}
-func (s *GovernanceStateHelper) UniqueDKGMasterPublicKeys(round *big.Int) []*dkgTypes.MasterPublicKey {
- // Prepare DKGMasterPublicKeys.
- var dkgMasterPKs []*dkgTypes.MasterPublicKey
- existence := make(map[coreTypes.NodeID]struct{})
- for _, mpk := range s.DKGMasterPublicKeys(round) {
- x := new(dkgTypes.MasterPublicKey)
- if err := rlp.DecodeBytes(mpk, x); err != nil {
- panic(err)
- }
-
- // Only the first DKG MPK submission is valid.
- if _, exists := existence[x.ProposerID]; exists {
- continue
- }
- existence[x.ProposerID] = struct{}{}
- dkgMasterPKs = append(dkgMasterPKs, x)
- }
- return dkgMasterPKs
-}
-func (s *GovernanceStateHelper) GetDKGMasterPublicKeyByProposerID(
- round *big.Int, proposerID coreTypes.NodeID) (*dkgTypes.MasterPublicKey, error) {
-
- for _, mpk := range s.DKGMasterPublicKeys(round) {
- x := new(dkgTypes.MasterPublicKey)
- if err := rlp.DecodeBytes(mpk, x); err != nil {
- panic(err)
- }
- if x.ProposerID.Equal(proposerID) {
- return x, nil
- }
- }
- return nil, errors.New("not found")
-}
-
-// bytes[][] public dkgComplaints;
-func (s *GovernanceStateHelper) DKGComplaints(round *big.Int) [][]byte {
- return s.read2DByteArray(big.NewInt(dkgComplaintsLoc), round)
-}
-func (s *GovernanceStateHelper) PushDKGComplaint(round *big.Int, complaint []byte) {
- s.appendTo2DByteArray(big.NewInt(dkgComplaintsLoc), round, complaint)
-}
-
-// mapping(address => bool)[] public dkgReady;
-func (s *GovernanceStateHelper) DKGMPKReady(round *big.Int, addr common.Address) bool {
- baseLoc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgReadyLoc)), round)
- mapLoc := s.getMapLoc(baseLoc, addr.Bytes())
- return s.getStateBigInt(mapLoc).Cmp(big.NewInt(0)) != 0
-}
-func (s *GovernanceStateHelper) PutDKGMPKReady(round *big.Int, addr common.Address, ready bool) {
- baseLoc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgReadyLoc)), round)
- mapLoc := s.getMapLoc(baseLoc, addr.Bytes())
- res := big.NewInt(0)
- if ready {
- res = big.NewInt(1)
- }
- s.setStateBigInt(mapLoc, res)
-}
-
-// uint256[] public dkgReadysCount;
-func (s *GovernanceStateHelper) DKGMPKReadysCount(round *big.Int) *big.Int {
- loc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgReadysCountLoc)), round)
- return s.getStateBigInt(loc)
-}
-func (s *GovernanceStateHelper) IncDKGMPKReadysCount(round *big.Int) {
- loc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgReadysCountLoc)), round)
- count := s.getStateBigInt(loc)
- s.setStateBigInt(loc, new(big.Int).Add(count, big.NewInt(1)))
-}
-
-// mapping(address => bool)[] public dkgFinalized;
-func (s *GovernanceStateHelper) DKGFinalized(round *big.Int, addr common.Address) bool {
- baseLoc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgFinalizedLoc)), round)
- mapLoc := s.getMapLoc(baseLoc, addr.Bytes())
- return s.getStateBigInt(mapLoc).Cmp(big.NewInt(0)) != 0
-}
-func (s *GovernanceStateHelper) PutDKGFinalized(round *big.Int, addr common.Address, finalized bool) {
- baseLoc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgFinalizedLoc)), round)
- mapLoc := s.getMapLoc(baseLoc, addr.Bytes())
- res := big.NewInt(0)
- if finalized {
- res = big.NewInt(1)
- }
- s.setStateBigInt(mapLoc, res)
-}
-
-// uint256[] public dkgFinalizedsCount;
-func (s *GovernanceStateHelper) DKGFinalizedsCount(round *big.Int) *big.Int {
- loc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgFinalizedsCountLoc)), round)
- return s.getStateBigInt(loc)
-}
-func (s *GovernanceStateHelper) IncDKGFinalizedsCount(round *big.Int) {
- loc := new(big.Int).Add(s.getSlotLoc(big.NewInt(dkgFinalizedsCountLoc)), round)
- count := s.getStateBigInt(loc)
- s.setStateBigInt(loc, new(big.Int).Add(count, big.NewInt(1)))
-}
-
-// address public owner;
-func (s *GovernanceStateHelper) Owner() common.Address {
- val := s.getState(common.BigToHash(big.NewInt(ownerLoc)))
- return common.BytesToAddress(val.Bytes())
-}
-func (s *GovernanceStateHelper) SetOwner(newOwner common.Address) {
- s.setState(common.BigToHash(big.NewInt(ownerLoc)), newOwner.Hash())
-}
-
-// uint256 public minStake;
-func (s *GovernanceStateHelper) MinStake() *big.Int {
- return s.getStateBigInt(big.NewInt(minStakeLoc))
-}
-
-// uint256 public lockupPeriod;
-func (s *GovernanceStateHelper) LockupPeriod() *big.Int {
- return s.getStateBigInt(big.NewInt(lockupPeriodLoc))
-}
-
-// uint256 public miningVelocity;
-func (s *GovernanceStateHelper) MiningVelocity() *big.Int {
- return s.getStateBigInt(big.NewInt(miningVelocityLoc))
-}
-func (s *GovernanceStateHelper) HalfMiningVelocity() {
- s.setStateBigInt(big.NewInt(miningVelocityLoc),
- new(big.Int).Div(s.MiningVelocity(), big.NewInt(2)))
-}
-
-// uint256 public nextHalvingSupply;
-func (s *GovernanceStateHelper) NextHalvingSupply() *big.Int {
- return s.getStateBigInt(big.NewInt(nextHalvingSupplyLoc))
-}
-func (s *GovernanceStateHelper) IncNextHalvingSupply(amount *big.Int) {
- s.setStateBigInt(big.NewInt(nextHalvingSupplyLoc),
- new(big.Int).Add(s.NextHalvingSupply(), amount))
-}
-
-// uint256 public lastHalvedAmount;
-func (s *GovernanceStateHelper) LastHalvedAmount() *big.Int {
- return s.getStateBigInt(big.NewInt(lastHalvedAmountLoc))
-}
-func (s *GovernanceStateHelper) HalfLastHalvedAmount() {
- s.setStateBigInt(big.NewInt(lastHalvedAmountLoc),
- new(big.Int).Div(s.LastHalvedAmount(), big.NewInt(2)))
-}
-
-func (s *GovernanceStateHelper) MiningHalved() {
- s.HalfMiningVelocity()
- s.HalfLastHalvedAmount()
- s.IncNextHalvingSupply(s.LastHalvedAmount())
-}
-
-// uint256 public blockGasLimit;
-func (s *GovernanceStateHelper) BlockGasLimit() *big.Int {
- return s.getStateBigInt(big.NewInt(blockGasLimitLoc))
-}
-func (s *GovernanceStateHelper) SetBlockGasLimit(reward *big.Int) {
- s.setStateBigInt(big.NewInt(blockGasLimitLoc), reward)
-}
-
-// uint256 public numChains;
-func (s *GovernanceStateHelper) NumChains() *big.Int {
- return s.getStateBigInt(big.NewInt(numChainsLoc))
-}
-
-// uint256 public lambdaBA;
-func (s *GovernanceStateHelper) LambdaBA() *big.Int {
- return s.getStateBigInt(big.NewInt(lambdaBALoc))
-}
-
-// uint256 public lambdaDKG;
-func (s *GovernanceStateHelper) LambdaDKG() *big.Int {
- return s.getStateBigInt(big.NewInt(lambdaDKGLoc))
-}
-
-// uint256 public k;
-func (s *GovernanceStateHelper) K() *big.Int {
- return s.getStateBigInt(big.NewInt(kLoc))
-}
-
-// uint256 public phiRatio; // stored as PhiRatio * 10^6
-func (s *GovernanceStateHelper) PhiRatio() *big.Int {
- return s.getStateBigInt(big.NewInt(phiRatioLoc))
-}
-
-// uint256 public notarySetSize;
-func (s *GovernanceStateHelper) NotarySetSize() *big.Int {
- return s.getStateBigInt(big.NewInt(notarySetSizeLoc))
-}
-
-// uint256 public dkgSetSize;
-func (s *GovernanceStateHelper) DKGSetSize() *big.Int {
- return s.getStateBigInt(big.NewInt(dkgSetSizeLoc))
-}
-
-// uint256 public roundInterval;
-func (s *GovernanceStateHelper) RoundInterval() *big.Int {
- return s.getStateBigInt(big.NewInt(roundIntervalLoc))
-}
-
-// uint256 public minBlockInterval;
-func (s *GovernanceStateHelper) MinBlockInterval() *big.Int {
- return s.getStateBigInt(big.NewInt(minBlockIntervalLoc))
-}
-
-// uint256[] public fineValues;
-func (s *GovernanceStateHelper) FineValue(index *big.Int) *big.Int {
- arrayBaseLoc := s.getSlotLoc(big.NewInt(fineValuesLoc))
- return s.getStateBigInt(new(big.Int).Add(arrayBaseLoc, index))
-}
-func (s *GovernanceStateHelper) FineValues() []*big.Int {
- len := s.getStateBigInt(big.NewInt(fineValuesLoc))
- result := make([]*big.Int, len.Uint64())
- for i := 0; i < int(len.Uint64()); i++ {
- result[i] = s.FineValue(big.NewInt(int64(i)))
- }
- return result
-}
-func (s *GovernanceStateHelper) SetFineValues(values []*big.Int) {
- s.setStateBigInt(big.NewInt(fineValuesLoc), big.NewInt(int64(len(values))))
-
- arrayBaseLoc := s.getSlotLoc(big.NewInt(fineValuesLoc))
- for i, v := range values {
- s.setStateBigInt(new(big.Int).Add(arrayBaseLoc, big.NewInt(int64(i))), v)
- }
-}
-
-// uint256[] public fineRdecords;
-func (s *GovernanceStateHelper) FineRecords(recordHash Bytes32) bool {
- loc := s.getMapLoc(big.NewInt(finedRecordsLoc), recordHash[:])
- return s.getStateBigInt(loc).Cmp(big.NewInt(0)) > 0
-}
-func (s *GovernanceStateHelper) SetFineRecords(recordHash Bytes32, status bool) {
- loc := s.getMapLoc(big.NewInt(finedRecordsLoc), recordHash[:])
- value := int64(0)
- if status {
- value = int64(1)
- }
- s.setStateBigInt(loc, big.NewInt(value))
-}
-
-// Stake is a helper function for creating genesis state.
-func (s *GovernanceStateHelper) Stake(
- addr common.Address, publicKey []byte, staked *big.Int,
- name, email, location, url string) {
- offset := s.LenNodes()
- node := &nodeInfo{
- Owner: addr,
- PublicKey: publicKey,
- Staked: staked,
- Fined: big.NewInt(0),
- Name: name,
- Email: email,
- Location: location,
- Url: url,
- }
- s.PushNode(node)
- if err := s.PutNodeOffsets(node, offset); err != nil {
- panic(err)
- }
-
- if staked.Cmp(big.NewInt(0)) == 0 {
- return
- }
-
- offset = s.LenDelegators(addr)
- s.PushDelegator(addr, &delegatorInfo{
- Owner: addr,
- Value: staked,
- UndelegatedAt: big.NewInt(0),
- })
- s.PutDelegatorOffset(addr, addr, offset)
-
- // Add to network total staked.
- s.IncTotalStaked(staked)
-}
-
-const decimalMultiplier = 100000000.0
-
-// Configuration returns the current configuration.
-func (s *GovernanceStateHelper) Configuration() *params.DexconConfig {
- return &params.DexconConfig{
- MinStake: s.getStateBigInt(big.NewInt(minStakeLoc)),
- LockupPeriod: s.getStateBigInt(big.NewInt(lockupPeriodLoc)).Uint64(),
- MiningVelocity: float32(s.getStateBigInt(big.NewInt(miningVelocityLoc)).Uint64()) / decimalMultiplier,
- NextHalvingSupply: s.getStateBigInt(big.NewInt(nextHalvingSupplyLoc)),
- LastHalvedAmount: s.getStateBigInt(big.NewInt(lastHalvedAmountLoc)),
- BlockGasLimit: s.getStateBigInt(big.NewInt(blockGasLimitLoc)).Uint64(),
- NumChains: uint32(s.getStateBigInt(big.NewInt(numChainsLoc)).Uint64()),
- LambdaBA: s.getStateBigInt(big.NewInt(lambdaBALoc)).Uint64(),
- LambdaDKG: s.getStateBigInt(big.NewInt(lambdaDKGLoc)).Uint64(),
- K: uint32(s.getStateBigInt(big.NewInt(kLoc)).Uint64()),
- PhiRatio: float32(s.getStateBigInt(big.NewInt(phiRatioLoc)).Uint64()) / decimalMultiplier,
- NotarySetSize: uint32(s.getStateBigInt(big.NewInt(notarySetSizeLoc)).Uint64()),
- DKGSetSize: uint32(s.getStateBigInt(big.NewInt(dkgSetSizeLoc)).Uint64()),
- RoundInterval: s.getStateBigInt(big.NewInt(roundIntervalLoc)).Uint64(),
- MinBlockInterval: s.getStateBigInt(big.NewInt(minBlockIntervalLoc)).Uint64(),
- FineValues: s.FineValues(),
- }
-}
-
-// UpdateConfiguration updates system configuration.
-func (s *GovernanceStateHelper) UpdateConfiguration(cfg *params.DexconConfig) {
- s.setStateBigInt(big.NewInt(minStakeLoc), cfg.MinStake)
- s.setStateBigInt(big.NewInt(lockupPeriodLoc), big.NewInt(int64(cfg.LockupPeriod)))
- s.setStateBigInt(big.NewInt(miningVelocityLoc), big.NewInt(int64(cfg.MiningVelocity*decimalMultiplier)))
- s.setStateBigInt(big.NewInt(nextHalvingSupplyLoc), cfg.NextHalvingSupply)
- s.setStateBigInt(big.NewInt(lastHalvedAmountLoc), cfg.LastHalvedAmount)
- s.setStateBigInt(big.NewInt(blockGasLimitLoc), big.NewInt(int64(cfg.BlockGasLimit)))
- s.setStateBigInt(big.NewInt(numChainsLoc), big.NewInt(int64(cfg.NumChains)))
- s.setStateBigInt(big.NewInt(lambdaBALoc), big.NewInt(int64(cfg.LambdaBA)))
- s.setStateBigInt(big.NewInt(lambdaDKGLoc), big.NewInt(int64(cfg.LambdaDKG)))
- s.setStateBigInt(big.NewInt(kLoc), big.NewInt(int64(cfg.K)))
- s.setStateBigInt(big.NewInt(phiRatioLoc), big.NewInt(int64(cfg.PhiRatio*decimalMultiplier)))
- s.setStateBigInt(big.NewInt(notarySetSizeLoc), big.NewInt(int64(cfg.NotarySetSize)))
- s.setStateBigInt(big.NewInt(dkgSetSizeLoc), big.NewInt(int64(cfg.DKGSetSize)))
- s.setStateBigInt(big.NewInt(roundIntervalLoc), big.NewInt(int64(cfg.RoundInterval)))
- s.setStateBigInt(big.NewInt(minBlockIntervalLoc), big.NewInt(int64(cfg.MinBlockInterval)))
- s.SetFineValues(cfg.FineValues)
-}
-
-type rawConfigStruct struct {
- MinStake *big.Int
- LockupPeriod *big.Int
- MiningVelocity *big.Int
- BlockGasLimit *big.Int
- NumChains *big.Int
- LambdaBA *big.Int
- LambdaDKG *big.Int
- K *big.Int
- PhiRatio *big.Int
- NotarySetSize *big.Int
- DKGSetSize *big.Int
- RoundInterval *big.Int
- MinBlockInterval *big.Int
- FineValues []*big.Int
-}
-
-// UpdateConfigurationRaw updates system configuration.
-func (s *GovernanceStateHelper) UpdateConfigurationRaw(cfg *rawConfigStruct) {
- s.setStateBigInt(big.NewInt(minStakeLoc), cfg.MinStake)
- s.setStateBigInt(big.NewInt(lockupPeriodLoc), cfg.LockupPeriod)
- s.setStateBigInt(big.NewInt(miningVelocityLoc), cfg.MiningVelocity)
- s.setStateBigInt(big.NewInt(blockGasLimitLoc), cfg.BlockGasLimit)
- s.setStateBigInt(big.NewInt(numChainsLoc), cfg.NumChains)
- s.setStateBigInt(big.NewInt(lambdaBALoc), cfg.LambdaBA)
- s.setStateBigInt(big.NewInt(lambdaDKGLoc), cfg.LambdaDKG)
- s.setStateBigInt(big.NewInt(kLoc), cfg.K)
- s.setStateBigInt(big.NewInt(phiRatioLoc), cfg.PhiRatio)
- s.setStateBigInt(big.NewInt(notarySetSizeLoc), cfg.NotarySetSize)
- s.setStateBigInt(big.NewInt(dkgSetSizeLoc), cfg.DKGSetSize)
- s.setStateBigInt(big.NewInt(roundIntervalLoc), cfg.RoundInterval)
- s.setStateBigInt(big.NewInt(minBlockIntervalLoc), cfg.MinBlockInterval)
- s.SetFineValues(cfg.FineValues)
-}
-
-// event ConfigurationChanged();
-func (s *GovernanceStateHelper) emitConfigurationChangedEvent() {
- s.StateDB.AddLog(&types.Log{
- Address: GovernanceContractAddress,
- Topics: []common.Hash{events["ConfigurationChanged"].Id()},
- Data: []byte{},
- })
-}
-
-// event CRSProposed(uint256 round, bytes32 crs);
-func (s *GovernanceStateHelper) emitCRSProposed(round *big.Int, crs common.Hash) {
- s.StateDB.AddLog(&types.Log{
- Address: GovernanceContractAddress,
- Topics: []common.Hash{events["CRSProposed"].Id(), common.BigToHash(round)},
- Data: crs.Bytes(),
- })
-}
-
-// event Staked(address indexed NodeAddress, uint256 Amount);
-func (s *GovernanceStateHelper) emitStaked(nodeAddr common.Address) {
- s.StateDB.AddLog(&types.Log{
- Address: GovernanceContractAddress,
- Topics: []common.Hash{events["Staked"].Id(), nodeAddr.Hash()},
- Data: []byte{},
- })
-}
-
-// event Unstaked(address indexed NodeAddress);
-func (s *GovernanceStateHelper) emitUnstaked(nodeAddr common.Address) {
- s.StateDB.AddLog(&types.Log{
- Address: GovernanceContractAddress,
- Topics: []common.Hash{events["Unstaked"].Id(), nodeAddr.Hash()},
- Data: []byte{},
- })
-}
-
-// event Delegated(address indexed NodeAddress, address indexed DelegatorAddress, uint256 Amount);
-func (s *GovernanceStateHelper) emitDelegated(nodeAddr, delegatorAddr common.Address, amount *big.Int) {
- s.StateDB.AddLog(&types.Log{
- Address: GovernanceContractAddress,
- Topics: []common.Hash{events["Delegated"].Id(), nodeAddr.Hash(), delegatorAddr.Hash()},
- Data: common.BigToHash(amount).Bytes(),
- })
-}
-
-// event Undelegated(address indexed NodeAddress, address indexed DelegatorAddress);
-func (s *GovernanceStateHelper) emitUndelegated(nodeAddr, delegatorAddr common.Address) {
- s.StateDB.AddLog(&types.Log{
- Address: GovernanceContractAddress,
- Topics: []common.Hash{events["Undelegated"].Id(), nodeAddr.Hash(), delegatorAddr.Hash()},
- Data: []byte{},
- })
-}
-
-// event Withdrawn(address indexed NodeAddress, uint256 Amount);
-func (s *GovernanceStateHelper) emitWithdrawn(nodeAddr common.Address, amount *big.Int) {
- s.StateDB.AddLog(&types.Log{
- Address: GovernanceContractAddress,
- Topics: []common.Hash{events["Withdrawn"].Id(), nodeAddr.Hash()},
- Data: common.BigToHash(amount).Bytes(),
- })
-}
-
-// event ForkReported(address indexed NodeAddress, address indexed Type, bytes Arg1, bytes Arg2);
-func (s *GovernanceStateHelper) emitForkReported(nodeAddr common.Address, reportType *big.Int, arg1, arg2 []byte) {
-
- t, err := abi.NewType("bytes")
- if err != nil {
- panic(err)
- }
-
- arg := abi.Arguments{
- abi.Argument{
- Name: "Arg1",
- Type: t,
- Indexed: false,
- },
- abi.Argument{
- Name: "Arg2",
- Type: t,
- Indexed: false,
- },
- }
-
- data, err := arg.Pack(arg1, arg2)
- if err != nil {
- panic(err)
- }
- s.StateDB.AddLog(&types.Log{
- Address: GovernanceContractAddress,
- Topics: []common.Hash{events["ForkReported"].Id(), nodeAddr.Hash()},
- Data: data,
- })
-}
-
-// event Fined(address indexed NodeAddress, uint256 Amount);
-func (s *GovernanceStateHelper) emitFined(nodeAddr common.Address, amount *big.Int) {
- s.StateDB.AddLog(&types.Log{
- Address: GovernanceContractAddress,
- Topics: []common.Hash{events["Fined"].Id(), nodeAddr.Hash()},
- Data: common.BigToHash(amount).Bytes(),
- })
-}
-
-// event FinePaid(address indexed NodeAddress, uint256 Amount);
-func (s *GovernanceStateHelper) emitFinePaid(nodeAddr common.Address, amount *big.Int) {
- s.StateDB.AddLog(&types.Log{
- Address: GovernanceContractAddress,
- Topics: []common.Hash{events["FinePaid"].Id(), nodeAddr.Hash()},
- Data: common.BigToHash(amount).Bytes(),
- })
-}
-
-// GovernanceContract represents the governance contract of DEXCON.
-type GovernanceContract struct {
- evm *EVM
- state GovernanceStateHelper
- contract *vm.Contract
-}
-
-func newGovernanceContract(evm *EVM, contract *vm.Contract) *GovernanceContract {
- return &GovernanceContract{
- evm: evm,
- state: GovernanceStateHelper{evm.StateDB},
- contract: contract,
- }
-}
-
-func (g *GovernanceContract) Address() common.Address {
- return GovernanceContractAddress
-}
-
-func (g *GovernanceContract) transfer(from, to common.Address, amount *big.Int) bool {
- // TODO(w): add this to debug trace so it shows up as internal transaction.
- if g.evm.CanTransfer(g.evm.StateDB, from, amount) {
- g.evm.Transfer(g.evm.StateDB, from, to, amount)
- return true
- }
- return false
-}
-
-func (g *GovernanceContract) useGas(gas uint64) ([]byte, error) {
- if !g.contract.UseGas(gas) {
- return nil, vm.ErrOutOfGas
- }
- return nil, nil
-}
-
-func (g *GovernanceContract) penalize() ([]byte, error) {
- g.useGas(g.contract.Gas)
- return nil, errExecutionReverted
-}
-
-func (g *GovernanceContract) inDKGSet(round *big.Int, nodeID coreTypes.NodeID) bool {
- target := coreTypes.NewDKGSetTarget(coreCommon.Hash(g.state.CurrentCRS()))
- ns := coreTypes.NewNodeSet()
-
- configRound := big.NewInt(0) // If round < core.ConfigRoundShift, use 0.
- if round.Uint64() >= core.ConfigRoundShift {
- configRound = new(big.Int).Sub(round, big.NewInt(int64(core.ConfigRoundShift)))
- }
-
- statedb, err := g.evm.StateAtNumber(g.state.RoundHeight(configRound).Uint64())
- if err != nil {
- panic(err)
- }
-
- state := GovernanceStateHelper{statedb}
- for _, x := range state.QualifiedNodes() {
- mpk, err := ecdsa.NewPublicKeyFromByteSlice(x.PublicKey)
- if err != nil {
- panic(err)
- }
- ns.Add(coreTypes.NewNodeID(mpk))
- }
-
- dkgSet := ns.GetSubSet(int(g.state.DKGSetSize().Uint64()), target)
- _, ok := dkgSet[nodeID]
- return ok
-}
-
-func (g *GovernanceContract) addDKGComplaint(round *big.Int, comp []byte) ([]byte, error) {
- if round.Cmp(g.state.Round()) != 0 {
- return g.penalize()
- }
-
- caller := g.contract.Caller()
-
- // Finalized caller is not allowed to propose complaint.
- if g.state.DKGFinalized(round, caller) {
- return g.penalize()
- }
-
- // Calculate 2f
- threshold := new(big.Int).Mul(
- big.NewInt(2),
- new(big.Int).Div(g.state.DKGSetSize(), big.NewInt(3)))
-
- // If 2f + 1 of DKG set is finalized, one can not propose complaint anymore.
- if g.state.DKGFinalizedsCount(round).Cmp(threshold) > 0 {
- return nil, errExecutionReverted
- }
-
- var dkgComplaint dkgTypes.Complaint
- if err := rlp.DecodeBytes(comp, &dkgComplaint); err != nil {
- return g.penalize()
- }
-
- // DKGComplaint must belongs to someone in DKG set.
- if !g.inDKGSet(round, dkgComplaint.ProposerID) {
- return g.penalize()
- }
-
- verified, _ := coreUtils.VerifyDKGComplaintSignature(&dkgComplaint)
- if !verified {
- return g.penalize()
- }
-
- mpk, err := g.state.GetDKGMasterPublicKeyByProposerID(
- round, dkgComplaint.PrivateShare.ProposerID)
- if err != nil {
- return g.penalize()
- }
-
- // Verify DKG complaint is correct.
- ok, err := coreUtils.VerifyDKGComplaint(&dkgComplaint, mpk)
- if !ok || err != nil {
- return g.penalize()
- }
-
- // Fine the attacker.
- need, err := coreUtils.NeedPenaltyDKGPrivateShare(&dkgComplaint, mpk)
- if err != nil {
- return g.penalize()
- }
- if need {
- fineValue := g.state.FineValue(big.NewInt(ReportTypeInvalidDKG))
- offset := g.state.NodesOffsetByID(Bytes32(dkgComplaint.PrivateShare.ProposerID.Hash))
- node := g.state.Node(offset)
- if err := g.fine(node.Owner, fineValue, comp, nil); err != nil {
- return g.penalize()
- }
- }
-
- g.state.PushDKGComplaint(round, comp)
-
- // Set this to relatively high to prevent spamming
- return g.useGas(5000000)
-}
-
-func (g *GovernanceContract) addDKGMasterPublicKey(round *big.Int, mpk []byte) ([]byte, error) {
- // Can only add DKG master public key of current and next round.
- if round.Cmp(new(big.Int).Add(g.state.Round(), big.NewInt(1))) > 0 {
- return g.penalize()
- }
-
- caller := g.contract.Caller()
- offset := g.state.NodesOffsetByAddress(caller)
-
- // Can not add dkg mpk if not staked.
- if offset.Cmp(big.NewInt(0)) < 0 {
- return nil, errExecutionReverted
- }
-
- // MPKReady caller is not allowed to propose mpk.
- if g.state.DKGMPKReady(round, caller) {
- return g.penalize()
- }
-
- // Calculate 2f
- threshold := new(big.Int).Mul(
- big.NewInt(2),
- new(big.Int).Div(g.state.DKGSetSize(), big.NewInt(3)))
-
- // If 2f + 1 of DKG set is mpk ready, one can not propose mpk anymore.
- if g.state.DKGMPKReadysCount(round).Cmp(threshold) > 0 {
- return nil, errExecutionReverted
- }
-
- var dkgMasterPK dkgTypes.MasterPublicKey
- if err := rlp.DecodeBytes(mpk, &dkgMasterPK); err != nil {
- return g.penalize()
- }
-
- // DKGMasterPublicKey must belongs to someone in DKG set.
- if !g.inDKGSet(round, dkgMasterPK.ProposerID) {
- return g.penalize()
- }
-
- verified, _ := coreUtils.VerifyDKGMasterPublicKeySignature(&dkgMasterPK)
- if !verified {
- return g.penalize()
- }
-
- g.state.PushDKGMasterPublicKey(round, mpk)
-
- return g.useGas(100000)
-}
-
-func (g *GovernanceContract) addDKGMPKReady(round *big.Int, ready []byte) ([]byte, error) {
- if round.Cmp(g.state.Round()) != 0 {
- return g.penalize()
- }
-
- caller := g.contract.Caller()
-
- var dkgReady dkgTypes.MPKReady
- if err := rlp.DecodeBytes(ready, &dkgReady); err != nil {
- return g.penalize()
- }
-
- // DKGFInalize must belongs to someone in DKG set.
- if !g.inDKGSet(round, dkgReady.ProposerID) {
- return g.penalize()
- }
-
- verified, _ := coreUtils.VerifyDKGMPKReadySignature(&dkgReady)
- if !verified {
- return g.penalize()
- }
-
- if !g.state.DKGMPKReady(round, caller) {
- g.state.PutDKGMPKReady(round, caller, true)
- g.state.IncDKGMPKReadysCount(round)
- }
-
- return g.useGas(100000)
-}
-func (g *GovernanceContract) addDKGFinalize(round *big.Int, finalize []byte) ([]byte, error) {
- if round.Cmp(g.state.Round()) != 0 {
- return g.penalize()
- }
-
- caller := g.contract.Caller()
-
- var dkgFinalize dkgTypes.Finalize
- if err := rlp.DecodeBytes(finalize, &dkgFinalize); err != nil {
- return g.penalize()
- }
-
- // DKGFInalize must belongs to someone in DKG set.
- if !g.inDKGSet(round, dkgFinalize.ProposerID) {
- return g.penalize()
- }
-
- verified, _ := coreUtils.VerifyDKGFinalizeSignature(&dkgFinalize)
- if !verified {
- return g.penalize()
- }
-
- if !g.state.DKGFinalized(round, caller) {
- g.state.PutDKGFinalized(round, caller, true)
- g.state.IncDKGFinalizedsCount(round)
- }
-
- return g.useGas(100000)
-}
-
-func (g *GovernanceContract) delegate(nodeAddr common.Address) ([]byte, error) {
- offset := g.state.NodesOffsetByAddress(nodeAddr)
- if offset.Cmp(big.NewInt(0)) < 0 {
- return nil, errExecutionReverted
- }
-
- caller := g.contract.Caller()
- value := g.contract.Value
-
- // Can not delegate if no fund was sent.
- if value.Cmp(big.NewInt(0)) == 0 {
- return nil, errExecutionReverted
- }
-
- // Can not delegate if already delegated.
- delegatorOffset := g.state.DelegatorsOffset(nodeAddr, caller)
- if delegatorOffset.Cmp(big.NewInt(0)) >= 0 {
- return nil, errExecutionReverted
- }
-
- // Add to the total staked of node.
- node := g.state.Node(offset)
- node.Staked = new(big.Int).Add(node.Staked, g.contract.Value)
- g.state.UpdateNode(offset, node)
-
- // Add to network total staked.
- g.state.IncTotalStaked(g.contract.Value)
-
- // Push delegator record.
- offset = g.state.LenDelegators(nodeAddr)
- g.state.PushDelegator(nodeAddr, &delegatorInfo{
- Owner: caller,
- Value: value,
- UndelegatedAt: big.NewInt(0),
- })
- g.state.PutDelegatorOffset(nodeAddr, caller, offset)
- g.state.emitDelegated(nodeAddr, caller, value)
-
- return g.useGas(200000)
-}
-
-func (g *GovernanceContract) updateConfiguration(cfg *rawConfigStruct) ([]byte, error) {
- // Only owner can update configuration.
- if g.contract.Caller() != g.state.Owner() {
- return nil, errExecutionReverted
- }
-
- g.state.UpdateConfigurationRaw(cfg)
- g.state.emitConfigurationChangedEvent()
- return nil, nil
-}
-
-func (g *GovernanceContract) stake(
- publicKey []byte, name, email, location, url string) ([]byte, error) {
-
- // Reject invalid inputs.
- if len(name) >= 32 || len(email) >= 32 || len(location) >= 32 || len(url) >= 128 {
- return g.penalize()
- }
-
- caller := g.contract.Caller()
- offset := g.state.NodesOffsetByAddress(caller)
-
- // Can not stake if already staked.
- if offset.Cmp(big.NewInt(0)) >= 0 {
- return nil, errExecutionReverted
- }
-
- offset = g.state.LenNodes()
- node := &nodeInfo{
- Owner: caller,
- PublicKey: publicKey,
- Staked: big.NewInt(0),
- Fined: big.NewInt(0),
- Name: name,
- Email: email,
- Location: location,
- Url: url,
- }
- g.state.PushNode(node)
- if err := g.state.PutNodeOffsets(node, offset); err != nil {
- return g.penalize()
- }
-
- // Delegate fund to itself.
- if g.contract.Value.Cmp(big.NewInt(0)) > 0 {
- if ret, err := g.delegate(caller); err != nil {
- return ret, err
- }
- }
-
- g.state.emitStaked(caller)
- return g.useGas(100000)
-}
-
-func (g *GovernanceContract) undelegateHelper(nodeAddr, caller common.Address) ([]byte, error) {
- nodeOffset := g.state.NodesOffsetByAddress(nodeAddr)
- if nodeOffset.Cmp(big.NewInt(0)) < 0 {
- return nil, errExecutionReverted
- }
-
- offset := g.state.DelegatorsOffset(nodeAddr, caller)
- if offset.Cmp(big.NewInt(0)) < 0 {
- return nil, errExecutionReverted
- }
-
- node := g.state.Node(nodeOffset)
- if node.Fined.Cmp(big.NewInt(0)) > 0 {
- return nil, errExecutionReverted
- }
-
- delegator := g.state.Delegator(nodeAddr, offset)
-
- if delegator.UndelegatedAt.Cmp(big.NewInt(0)) != 0 {
- return nil, errExecutionReverted
- }
-
- // Set undelegate time.
- delegator.UndelegatedAt = g.evm.Time
- g.state.UpdateDelegator(nodeAddr, offset, delegator)
-
- // Subtract from the total staked of node.
- node.Staked = new(big.Int).Sub(node.Staked, delegator.Value)
- g.state.UpdateNode(nodeOffset, node)
-
- // Subtract to network total staked.
- g.state.DecTotalStaked(delegator.Value)
-
- g.state.emitUndelegated(nodeAddr, caller)
-
- return g.useGas(100000)
-}
-
-func (g *GovernanceContract) undelegate(nodeAddr common.Address) ([]byte, error) {
- return g.undelegateHelper(nodeAddr, g.contract.Caller())
-}
-
-func (g *GovernanceContract) withdraw(nodeAddr common.Address) ([]byte, error) {
- caller := g.contract.Caller()
-
- nodeOffset := g.state.NodesOffsetByAddress(nodeAddr)
- if nodeOffset.Cmp(big.NewInt(0)) < 0 {
- return nil, errExecutionReverted
- }
-
- offset := g.state.DelegatorsOffset(nodeAddr, caller)
- if offset.Cmp(big.NewInt(0)) < 0 {
- return nil, errExecutionReverted
- }
-
- delegator := g.state.Delegator(nodeAddr, offset)
-
- // Not yet undelegated.
- if delegator.UndelegatedAt.Cmp(big.NewInt(0)) == 0 {
- return g.penalize()
- }
-
- unlockTime := new(big.Int).Add(delegator.UndelegatedAt, g.state.LockupPeriod())
- if g.evm.Time.Cmp(unlockTime) <= 0 {
- return g.penalize()
- }
-
- length := g.state.LenDelegators(nodeAddr)
- lastIndex := new(big.Int).Sub(length, big.NewInt(1))
-
- // Delete the delegator.
- if offset.Cmp(lastIndex) != 0 {
- lastNode := g.state.Delegator(nodeAddr, lastIndex)
- g.state.UpdateDelegator(nodeAddr, offset, lastNode)
- g.state.PutDelegatorOffset(nodeAddr, lastNode.Owner, offset)
- }
- g.state.DeleteDelegatorsOffset(nodeAddr, caller)
- g.state.PopLastDelegator(nodeAddr)
-
- // Return the staked fund.
- if !g.transfer(GovernanceContractAddress, delegator.Owner, delegator.Value) {
- return nil, errExecutionReverted
- }
-
- g.state.emitWithdrawn(nodeAddr, delegator.Value)
-
- // We are the last delegator to withdraw the fund, remove the node info.
- if g.state.LenDelegators(nodeAddr).Cmp(big.NewInt(0)) == 0 {
- length := g.state.LenNodes()
- lastIndex := new(big.Int).Sub(length, big.NewInt(1))
-
- // Delete the node.
- if offset.Cmp(lastIndex) != 0 {
- lastNode := g.state.Node(lastIndex)
- g.state.UpdateNode(offset, lastNode)
- if err := g.state.PutNodeOffsets(lastNode, offset); err != nil {
- panic(err)
- }
- }
- g.state.DeleteNodesOffsetByAddress(nodeAddr)
- g.state.PopLastNode()
- }
-
- return g.useGas(100000)
-}
-
-func (g *GovernanceContract) unstake() ([]byte, error) {
- caller := g.contract.Caller()
- offset := g.state.NodesOffsetByAddress(caller)
- if offset.Cmp(big.NewInt(0)) < 0 {
- return nil, errExecutionReverted
- }
-
- node := g.state.Node(offset)
- if node.Fined.Cmp(big.NewInt(0)) > 0 {
- return nil, errExecutionReverted
- }
-
- // Undelegate all delegators.
- lenDelegators := g.state.LenDelegators(caller)
- i := new(big.Int).Sub(lenDelegators, big.NewInt(1))
- for i.Cmp(big.NewInt(0)) >= 0 {
- delegator := g.state.Delegator(caller, i)
- if ret, err := g.undelegateHelper(caller, delegator.Owner); err != nil {
- return ret, err
- }
- i = i.Sub(i, big.NewInt(1))
- }
-
- g.state.emitUnstaked(caller)
-
- return g.useGas(100000)
-}
-
-func (g *GovernanceContract) payFine(nodeAddr common.Address) ([]byte, error) {
- caller := g.contract.Caller()
-
- nodeOffset := g.state.NodesOffsetByAddress(nodeAddr)
- if nodeOffset.Cmp(big.NewInt(0)) < 0 {
- return nil, errExecutionReverted
- }
-
- offset := g.state.DelegatorsOffset(nodeAddr, caller)
- if offset.Cmp(big.NewInt(0)) < 0 {
- return nil, errExecutionReverted
- }
-
- node := g.state.Node(nodeOffset)
- if node.Fined.Cmp(big.NewInt(0)) <= 0 || node.Fined.Cmp(g.contract.Value) < 0 {
- return nil, errExecutionReverted
- }
-
- node.Fined = new(big.Int).Sub(node.Fined, g.contract.Value)
- g.state.UpdateNode(nodeOffset, node)
-
- // TODO: paid fine should be added to award pool.
-
- g.state.emitFinePaid(nodeAddr, g.contract.Value)
-
- return g.useGas(100000)
-}
-
-func (g *GovernanceContract) proposeCRS(nextRound *big.Int, signedCRS []byte) ([]byte, error) {
- round := g.state.Round()
-
- if nextRound.Cmp(round) <= 0 {
- return nil, errExecutionReverted
- }
-
- prevCRS := g.state.CRS(round)
-
- // Prepare DKGMasterPublicKeys.
- dkgMasterPKs := g.state.UniqueDKGMasterPublicKeys(round)
-
- // Prepare DKGComplaints.
- var dkgComplaints []*dkgTypes.Complaint
- for _, comp := range g.state.DKGComplaints(round) {
- x := new(dkgTypes.Complaint)
- if err := rlp.DecodeBytes(comp, x); err != nil {
- panic(err)
- }
- dkgComplaints = append(dkgComplaints, x)
- }
-
- threshold := int(g.state.DKGSetSize().Uint64()/3 + 1)
-
- dkgGPK, err := core.NewDKGGroupPublicKey(
- round.Uint64(), dkgMasterPKs, dkgComplaints, threshold)
- if err != nil {
- return nil, errExecutionReverted
- }
- signature := coreCrypto.Signature{
- Type: "bls",
- Signature: signedCRS,
- }
- if !dkgGPK.VerifySignature(coreCommon.Hash(prevCRS), signature) {
- return g.penalize()
- }
-
- // Save new CRS into state and increase round.
- newCRS := crypto.Keccak256(signedCRS)
- crs := common.BytesToHash(newCRS)
-
- g.state.PushCRS(crs)
- g.state.emitCRSProposed(nextRound, crs)
-
- // To encourage DKG set to propose the correct value, correctly submitting
- // this should cause nothing.
- return g.useGas(0)
-}
-
-type sortBytes [][]byte
-
-func (s sortBytes) Less(i, j int) bool {
- return bytes.Compare(s[i], s[j]) < 0
-}
-
-func (s sortBytes) Swap(i, j int) {
- s[i], s[j] = s[j], s[i]
-}
-
-func (s sortBytes) Len() int {
- return len(s)
-}
-
-func (g *GovernanceContract) fine(nodeAddr common.Address, amount *big.Int, payloads ...[]byte) error {
- sort.Sort(sortBytes(payloads))
-
- hash := Bytes32(crypto.Keccak256Hash(payloads...))
- if g.state.FineRecords(hash) {
- return errors.New("already fined")
- }
- g.state.SetFineRecords(hash, true)
-
- nodeOffset := g.state.NodesOffsetByAddress(nodeAddr)
- if nodeOffset.Cmp(big.NewInt(0)) < 0 {
- return errExecutionReverted
- }
-
- // Set fined value.
- node := g.state.Node(nodeOffset)
- node.Fined = new(big.Int).Add(node.Fined, amount)
- g.state.UpdateNode(nodeOffset, node)
-
- g.state.emitFined(nodeAddr, amount)
-
- return nil
-}
-
-func (g *GovernanceContract) report(reportType *big.Int, arg1, arg2 []byte) ([]byte, error) {
- typeEnum := ReportType(reportType.Uint64())
- var reportedNodeID coreTypes.NodeID
-
- switch typeEnum {
- case ReportTypeForkVote:
- vote1 := new(coreTypes.Vote)
- if err := rlp.DecodeBytes(arg1, vote1); err != nil {
- return g.penalize()
- }
- vote2 := new(coreTypes.Vote)
- if err := rlp.DecodeBytes(arg2, vote2); err != nil {
- return g.penalize()
- }
- need, err := coreUtils.NeedPenaltyForkVote(vote1, vote2)
- if !need || err != nil {
- return g.penalize()
- }
- reportedNodeID = vote1.ProposerID
- case ReportTypeForkBlock:
- block1 := new(coreTypes.Block)
- if err := rlp.DecodeBytes(arg1, block1); err != nil {
- return g.penalize()
- }
- block2 := new(coreTypes.Block)
- if err := rlp.DecodeBytes(arg2, block2); err != nil {
- return g.penalize()
- }
- need, err := coreUtils.NeedPenaltyForkBlock(block1, block2)
- if !need || err != nil {
- return g.penalize()
- }
- reportedNodeID = block1.ProposerID
- default:
- return g.penalize()
- }
-
- offset := g.state.NodesOffsetByID(Bytes32(reportedNodeID.Hash))
- node := g.state.Node(offset)
-
- g.state.emitForkReported(node.Owner, reportType, arg1, arg2)
-
- fineValue := g.state.FineValue(reportType)
- if err := g.fine(node.Owner, fineValue, arg1, arg2); err != nil {
- return nil, errExecutionReverted
- }
- return nil, nil
-}
-
-func (g *GovernanceContract) transferOwnership(newOwner common.Address) ([]byte, error) {
- // Only owner can update configuration.
- if g.contract.Caller() != g.state.Owner() {
- return nil, errExecutionReverted
- }
- g.state.SetOwner(newOwner)
- return nil, nil
-}
-
-func (g *GovernanceContract) snapshotRound(round, height *big.Int) ([]byte, error) {
- // Validate if this mapping is correct. Only block proposer need to verify this.
- if g.evm.IsBlockProposer() {
- realHeight, ok := g.evm.GetRoundHeight(round.Uint64())
- if !ok {
- return g.penalize()
- }
-
- if height.Cmp(new(big.Int).SetUint64(realHeight)) != 0 {
- return g.penalize()
- }
- }
-
- // Only allow updating the next round.
- nextRound := g.state.LenRoundHeight()
- if round.Cmp(nextRound) != 0 {
- // No need to penalize, since the only possibility at this point is the
- // round height is already snapshoted.
- return nil, errExecutionReverted
- }
-
- g.state.PushRoundHeight(height)
- return nil, nil
-}
diff --git a/core/vm/evm/governance_abi.go b/core/vm/evm/governance_abi.go
deleted file mode 100644
index 966c4c4f3..000000000
--- a/core/vm/evm/governance_abi.go
+++ /dev/null
@@ -1,1133 +0,0 @@
-// Copyright 2019 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 evm
-
-// The governance ABI is generated from:
-// https://github.com/dexon-foundation/governance-abi
-
-const GovernanceABIJSON = `
-[
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "address"
- },
- {
- "name": "",
- "type": "address"
- }
- ],
- "name": "delegatorsOffset",
- "outputs": [
- {
- "name": "",
- "type": "int256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "uint256"
- },
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "name": "dkgComplaints",
- "outputs": [
- {
- "name": "",
- "type": "bytes"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "notarySetSize",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "dkgSetSize",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "totalSupply",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "name": "nodes",
- "outputs": [
- {
- "name": "owner",
- "type": "address"
- },
- {
- "name": "publicKey",
- "type": "bytes"
- },
- {
- "name": "staked",
- "type": "uint256"
- },
- {
- "name": "fined",
- "type": "uint256"
- },
- {
- "name": "name",
- "type": "string"
- },
- {
- "name": "email",
- "type": "string"
- },
- {
- "name": "location",
- "type": "string"
- },
- {
- "name": "url",
- "type": "string"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "miningVelocity",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "lambdaBA",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "minStake",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "name": "crs",
- "outputs": [
- {
- "name": "",
- "type": "bytes32"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "phiRatio",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "name": "dkgMPKReadysCount",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "uint256"
- },
- {
- "name": "",
- "type": "address"
- }
- ],
- "name": "dkgMPKReadys",
- "outputs": [
- {
- "name": "",
- "type": "bool"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "address"
- },
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "name": "delegators",
- "outputs": [
- {
- "name": "owner",
- "type": "address"
- },
- {
- "name": "value",
- "type": "uint256"
- },
- {
- "name": "undelegated_at",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "blockGasLimit",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "bytes32"
- }
- ],
- "name": "nodesOffsetByID",
- "outputs": [
- {
- "name": "",
- "type": "int256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "totalStaked",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "roundInterval",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "address"
- }
- ],
- "name": "nodesOffsetByAddress",
- "outputs": [
- {
- "name": "",
- "type": "int256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "nextHalvingSupply",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "owner",
- "outputs": [
- {
- "name": "",
- "type": "address"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "lastHalvedAmount",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "bytes32"
- }
- ],
- "name": "finedRecords",
- "outputs": [
- {
- "name": "",
- "type": "bool"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "lambdaDKG",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "name": "fineValues",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "name": "roundHeight",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "minBlockInterval",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "k",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "uint256"
- },
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "name": "dkgMasterPublicKeys",
- "outputs": [
- {
- "name": "",
- "type": "bytes"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "uint256"
- },
- {
- "name": "",
- "type": "address"
- }
- ],
- "name": "dkgFinalizeds",
- "outputs": [
- {
- "name": "",
- "type": "bool"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "numChains",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "lockupPeriod",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "name": "dkgFinalizedsCount",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "anonymous": false,
- "inputs": [],
- "name": "ConfigurationChanged",
- "type": "event"
- },
- {
- "anonymous": false,
- "inputs": [
- {
- "indexed": true,
- "name": "Round",
- "type": "uint256"
- },
- {
- "indexed": false,
- "name": "CRS",
- "type": "bytes32"
- }
- ],
- "name": "CRSProposed",
- "type": "event"
- },
- {
- "anonymous": false,
- "inputs": [
- {
- "indexed": true,
- "name": "NodeAddress",
- "type": "address"
- }
- ],
- "name": "Staked",
- "type": "event"
- },
- {
- "anonymous": false,
- "inputs": [
- {
- "indexed": true,
- "name": "NodeAddress",
- "type": "address"
- }
- ],
- "name": "Unstaked",
- "type": "event"
- },
- {
- "anonymous": false,
- "inputs": [
- {
- "indexed": true,
- "name": "NodeAddress",
- "type": "address"
- },
- {
- "indexed": true,
- "name": "DelegatorAddress",
- "type": "address"
- },
- {
- "indexed": false,
- "name": "Amount",
- "type": "uint256"
- }
- ],
- "name": "Delegated",
- "type": "event"
- },
- {
- "anonymous": false,
- "inputs": [
- {
- "indexed": true,
- "name": "NodeAddress",
- "type": "address"
- },
- {
- "indexed": true,
- "name": "DelegatorAddress",
- "type": "address"
- }
- ],
- "name": "Undelegated",
- "type": "event"
- },
- {
- "anonymous": false,
- "inputs": [
- {
- "indexed": true,
- "name": "NodeAddress",
- "type": "address"
- },
- {
- "indexed": false,
- "name": "Amount",
- "type": "uint256"
- }
- ],
- "name": "Withdrawn",
- "type": "event"
- },
- {
- "anonymous": false,
- "inputs": [
- {
- "indexed": true,
- "name": "NodeAddress",
- "type": "address"
- },
- {
- "indexed": false,
- "name": "Type",
- "type": "uint256"
- },
- {
- "indexed": false,
- "name": "Arg1",
- "type": "bytes"
- },
- {
- "indexed": false,
- "name": "Arg2",
- "type": "bytes"
- }
- ],
- "name": "ForkReported",
- "type": "event"
- },
- {
- "anonymous": false,
- "inputs": [
- {
- "indexed": true,
- "name": "NodeAddress",
- "type": "address"
- },
- {
- "indexed": false,
- "name": "Amount",
- "type": "uint256"
- }
- ],
- "name": "Fined",
- "type": "event"
- },
- {
- "anonymous": false,
- "inputs": [
- {
- "indexed": true,
- "name": "NodeAddress",
- "type": "address"
- },
- {
- "indexed": false,
- "name": "Amount",
- "type": "uint256"
- }
- ],
- "name": "FinePaid",
- "type": "event"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "newOwner",
- "type": "address"
- }
- ],
- "name": "transferOwnership",
- "outputs": [],
- "payable": false,
- "stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "MinStake",
- "type": "uint256"
- },
- {
- "name": "LockupPeriod",
- "type": "uint256"
- },
- {
- "name": "MiningVelocity",
- "type": "uint256"
- },
- {
- "name": "NextHalvingSupply",
- "type": "uint256"
- },
- {
- "name": "LastHalvingAmount",
- "type": "uint256"
- },
- {
- "name": "BlockGasLimit",
- "type": "uint256"
- },
- {
- "name": "NumChains",
- "type": "uint256"
- },
- {
- "name": "LambdaBA",
- "type": "uint256"
- },
- {
- "name": "LambdaDKG",
- "type": "uint256"
- },
- {
- "name": "K",
- "type": "uint256"
- },
- {
- "name": "PhiRatio",
- "type": "uint256"
- },
- {
- "name": "NotarySetSize",
- "type": "uint256"
- },
- {
- "name": "DKGSetSize",
- "type": "uint256"
- },
- {
- "name": "RoundInterval",
- "type": "uint256"
- },
- {
- "name": "MinBlockInterval",
- "type": "uint256"
- },
- {
- "name": "FineValues",
- "type": "uint256[]"
- }
- ],
- "name": "updateConfiguration",
- "outputs": [],
- "payable": false,
- "stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [],
- "name": "nodesLength",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": true,
- "inputs": [
- {
- "name": "NodeAddress",
- "type": "address"
- }
- ],
- "name": "delegatorsLength",
- "outputs": [
- {
- "name": "",
- "type": "uint256"
- }
- ],
- "payable": false,
- "stateMutability": "view",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "Round",
- "type": "uint256"
- },
- {
- "name": "Height",
- "type": "uint256"
- }
- ],
- "name": "snapshotRound",
- "outputs": [],
- "payable": false,
- "stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "Round",
- "type": "uint256"
- },
- {
- "name": "SignedCRS",
- "type": "bytes"
- }
- ],
- "name": "proposeCRS",
- "outputs": [],
- "payable": false,
- "stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "Round",
- "type": "uint256"
- },
- {
- "name": "Complaint",
- "type": "bytes"
- }
- ],
- "name": "addDKGComplaint",
- "outputs": [],
- "payable": false,
- "stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "Round",
- "type": "uint256"
- },
- {
- "name": "PublicKey",
- "type": "bytes"
- }
- ],
- "name": "addDKGMasterPublicKey",
- "outputs": [],
- "payable": false,
- "stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "Round",
- "type": "uint256"
- },
- {
- "name": "MPKReady",
- "type": "bytes"
- }
- ],
- "name": "addDKGMPKReady",
- "outputs": [],
- "payable": false,
- "stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "Round",
- "type": "uint256"
- },
- {
- "name": "Finalize",
- "type": "bytes"
- }
- ],
- "name": "addDKGFinalize",
- "outputs": [],
- "payable": false,
- "stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "PublicKey",
- "type": "bytes"
- },
- {
- "name": "Name",
- "type": "string"
- },
- {
- "name": "Email",
- "type": "string"
- },
- {
- "name": "Location",
- "type": "string"
- },
- {
- "name": "Url",
- "type": "string"
- }
- ],
- "name": "stake",
- "outputs": [],
- "payable": true,
- "stateMutability": "payable",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [],
- "name": "unstake",
- "outputs": [],
- "payable": false,
- "stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "NodeAddress",
- "type": "address"
- }
- ],
- "name": "delegate",
- "outputs": [],
- "payable": true,
- "stateMutability": "payable",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "NodeAddress",
- "type": "address"
- }
- ],
- "name": "undelegate",
- "outputs": [],
- "payable": false,
- "stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "NodeAddress",
- "type": "address"
- }
- ],
- "name": "withdraw",
- "outputs": [],
- "payable": false,
- "stateMutability": "nonpayable",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "NodeAddress",
- "type": "address"
- }
- ],
- "name": "payFine",
- "outputs": [],
- "payable": true,
- "stateMutability": "payable",
- "type": "function"
- },
- {
- "constant": false,
- "inputs": [
- {
- "name": "Type",
- "type": "uint256"
- },
- {
- "name": "Arg1",
- "type": "bytes"
- },
- {
- "name": "Arg2",
- "type": "bytes"
- }
- ],
- "name": "report",
- "outputs": [],
- "payable": false,
- "stateMutability": "nonpayable",
- "type": "function"
- }
-]
-`
diff --git a/core/vm/evm/governance_test.go b/core/vm/evm/governance_test.go
deleted file mode 100644
index 5a82c7f1a..000000000
--- a/core/vm/evm/governance_test.go
+++ /dev/null
@@ -1,1061 +0,0 @@
-// 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 evm
-
-import (
- "bytes"
- "crypto/ecdsa"
- "math/big"
- "math/rand"
- "sort"
- "testing"
- "time"
-
- coreCommon "github.com/dexon-foundation/dexon-consensus/common"
- coreCrypto "github.com/dexon-foundation/dexon-consensus/core/crypto"
- coreEcdsa "github.com/dexon-foundation/dexon-consensus/core/crypto/ecdsa"
- coreTypes "github.com/dexon-foundation/dexon-consensus/core/types"
- coreUtils "github.com/dexon-foundation/dexon-consensus/core/utils"
-
- "github.com/dexon-foundation/dexon/common"
- "github.com/dexon-foundation/dexon/core/state"
- "github.com/dexon-foundation/dexon/core/vm"
- "github.com/dexon-foundation/dexon/crypto"
- "github.com/dexon-foundation/dexon/ethdb"
- "github.com/dexon-foundation/dexon/params"
- "github.com/dexon-foundation/dexon/rlp"
- "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
- config.NextHalvingSupply = new(big.Int).Mul(big.NewInt(1e18), big.NewInt(2.5e9))
- config.LastHalvedAmount = new(big.Int).Mul(big.NewInt(1e18), big.NewInt(1.5e9))
- config.MiningVelocity = 0.1875
-
- 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(2e6)))
- return privKey, address
-}
-
-func (g *GovernanceContractTestSuite) call(caller common.Address, input []byte, value *big.Int) ([]byte, error) {
- context := vm.Context{
- CanTransfer: func(db vm.StateDB, addr common.Address, amount *big.Int) bool {
- return db.GetBalance(addr).Cmp(amount) >= 0
- },
- Transfer: func(db vm.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(vm.AccountRef(caller), GovernanceContractAddress, input, 10000000, value)
- return ret, err
-}
-
-func (g *GovernanceContractTestSuite) TestTransferOwnership() {
- _, addr := g.newPrefundAccount()
-
- input, err := abiObject.Pack("transferOwnership", addr)
- g.Require().NoError(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().NoError(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(1e6))
- balanceBeforeStake := g.stateDB.GetBalance(addr)
- input, err := abiObject.Pack("stake", pk, "Test1", "test1@dexon.org", "Taipei, Taiwan", "https://dexon.org")
- g.Require().NoError(err)
- _, err = g.call(addr, input, amount)
- g.Require().NoError(err)
-
- g.Require().Equal(1, int(g.s.LenNodes().Uint64()))
- g.Require().Equal(1, len(g.s.QualifiedNodes()))
- g.Require().Equal("Test1", g.s.Node(big.NewInt(0)).Name)
- g.Require().Equal(amount.String(), g.s.TotalStaked().String())
-
- // 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().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- g.Require().Equal(0, len(g.s.QualifiedNodes()))
- g.Require().Equal(1, int(g.s.LenDelegators(addr).Uint64()))
- g.Require().Equal(1, int(g.s.LenNodes().Uint64()))
-
- node := g.s.Node(big.NewInt(0))
- g.Require().Equal(big.NewInt(0).String(), node.Staked.String())
- g.Require().Equal(big.NewInt(0).String(), g.s.TotalStaked().String())
-
- // Wait for lockup time than withdraw.
- time.Sleep(time.Second * 2)
- input, err = abiObject.Pack("withdraw", addr)
- g.Require().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-
- g.Require().Equal(0, len(g.s.QualifiedNodes()))
- 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().NoError(err)
- _, err = g.call(addr2, input, amount)
- g.Require().NoError(err)
- g.Require().Equal("Test2", g.s.Node(big.NewInt(0)).Name)
- g.Require().Equal(0, int(g.s.NodesOffsetByAddress(addr2).Int64()))
-
- // 1st node Stake.
- input, err = abiObject.Pack("stake", pk, "Test1", "test1@dexon.org", "Taipei, Taiwan", "https://dexon.org")
- g.Require().NoError(err)
- _, err = g.call(addr, input, amount)
- g.Require().NoError(err)
-
- g.Require().Equal(2, len(g.s.QualifiedNodes()))
- g.Require().Equal(new(big.Int).Mul(amount, big.NewInt(2)).String(), g.s.TotalStaked().String())
-
- // 2nd node Unstake.
- input, err = abiObject.Pack("unstake")
- g.Require().NoError(err)
- _, err = g.call(addr2, input, big.NewInt(0))
- g.Require().NoError(err)
- node = g.s.Node(big.NewInt(0))
- g.Require().Equal("Test2", node.Name)
- g.Require().Equal(big.NewInt(0).String(), node.Staked.String())
- g.Require().Equal(1, len(g.s.QualifiedNodes()))
- g.Require().Equal(amount.String(), g.s.TotalStaked().String())
-
- time.Sleep(time.Second * 2)
- input, err = abiObject.Pack("withdraw", addr2)
- g.Require().NoError(err)
- _, err = g.call(addr2, input, big.NewInt(0))
- g.Require().NoError(err)
- g.Require().Equal(1, len(g.s.QualifiedNodes()))
-
- 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.NodesOffsetByAddress(addr2).Int64()))
-
- // 1st node Unstake.
- input, err = abiObject.Pack("unstake")
- g.Require().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- g.Require().Equal(0, len(g.s.QualifiedNodes()))
- g.Require().Equal(big.NewInt(0).String(), g.s.TotalStaked().String())
-
- time.Sleep(time.Second * 2)
- input, err = abiObject.Pack("withdraw", addr)
- g.Require().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-
- g.Require().Equal(0, int(g.s.LenNodes().Uint64()))
- g.Require().Equal(-1, int(g.s.NodesOffsetByAddress(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().NoError(err)
- ownerStaked := new(big.Int).Mul(big.NewInt(1e18), big.NewInt(5e5))
- _, err = g.call(addr, input, ownerStaked)
- g.Require().NoError(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(3e5))
- input, err = abiObject.Pack("delegate", addr)
- g.Require().NoError(err)
-
- _, err = g.call(addrDelegator, input, amount)
- g.Require().NoError(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(g.s.Node(big.NewInt(0)).Staked.String(), g.s.TotalStaked().String())
- 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().NoError(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(g.s.Node(big.NewInt(0)).Staked.String(), g.s.TotalStaked().String())
- 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().NoError(err)
- _, err = g.call(addrDelegator, input, big.NewInt(0))
- g.Require().Equal(new(big.Int).Add(amount, ownerStaked), g.s.Node(big.NewInt(0)).Staked)
- g.Require().Equal(g.s.Node(big.NewInt(0)).Staked.String(), g.s.TotalStaked().String())
- g.Require().NoError(err)
-
- // Undelegate the second time should fail.
- _, err = g.call(addrDelegator, input, big.NewInt(0))
- g.Require().Error(err)
-
- // Withdraw within lockup time should fail.
- input, err = abiObject.Pack("withdraw", addr)
- g.Require().NoError(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().NoError(err)
- _, err = g.call(addrDelegator, input, big.NewInt(0))
- g.Require().NoError(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().NoError(err)
- _, err = g.call(addrDelegator, input, big.NewInt(0))
- g.Require().Error(err)
-
- // Undelegate addrDelegator2.
- balanceBeforeUnDelegate = g.stateDB.GetBalance(addrDelegator2)
- input, err = abiObject.Pack("undelegate", addr)
- g.Require().NoError(err)
- _, err = g.call(addrDelegator2, input, big.NewInt(0))
- g.Require().NoError(err)
-
- g.Require().Equal(ownerStaked, g.s.Node(big.NewInt(0)).Staked)
- g.Require().Equal(g.s.Node(big.NewInt(0)).Staked.String(), g.s.TotalStaked().String())
-
- // Wait for lockup time than withdraw.
- time.Sleep(time.Second * 2)
- input, err = abiObject.Pack("withdraw", addr)
- g.Require().NoError(err)
- _, err = g.call(addrDelegator2, input, big.NewInt(0))
- g.Require().NoError(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()))
-
- // Owner undelegate itself.
- g.Require().Equal(1, int(g.s.LenNodes().Uint64()))
- g.Require().Equal(1, int(g.s.LenDelegators(addr).Uint64()))
-
- input, err = abiObject.Pack("undelegate", addr)
- g.Require().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- g.Require().Equal(big.NewInt(0).String(), g.s.Node(big.NewInt(0)).Staked.String())
- g.Require().Equal(big.NewInt(0).String(), g.s.TotalStaked().String())
-
- time.Sleep(time.Second * 2)
- input, err = abiObject.Pack("withdraw", addr)
- g.Require().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
-
- g.Require().Equal(0, int(g.s.LenNodes().Uint64()))
- g.Require().Equal(0, int(g.s.LenDelegators(addr).Uint64()))
-}
-
-func (g *GovernanceContractTestSuite) TestFine() {
- 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().NoError(err)
- ownerStaked := new(big.Int).Mul(big.NewInt(1e18), big.NewInt(5e5))
- _, err = g.call(addr, input, ownerStaked)
- g.Require().NoError(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(5e5))
- input, err = abiObject.Pack("delegate", addr)
- g.Require().NoError(err)
-
- _, err = g.call(addrDelegator, input, amount)
- g.Require().NoError(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()))
-
- // Qualified.
- g.Require().Equal(1, len(g.s.QualifiedNodes()))
-
- // Paying to node without fine should fail.
- input, err = abiObject.Pack("payFine", addr)
- g.Require().NoError(err)
- _, err = g.call(addrDelegator, input, amount)
- g.Require().NotNil(err)
-
- // Fined.
- offset := g.s.NodesOffsetByAddress(addr)
- g.Require().True(offset.Cmp(big.NewInt(0)) >= 0)
- node := g.s.Node(offset)
- node.Fined = new(big.Int).Set(amount)
- g.s.UpdateNode(offset, node)
- node = g.s.Node(offset)
- g.Require().Equal(0, node.Fined.Cmp(amount))
-
- // Not qualified after fined.
- g.Require().Equal(0, len(g.s.QualifiedNodes()))
-
- // Cannot undelegate before fines are paied.
- input, err = abiObject.Pack("undelegate", addr)
- g.Require().NoError(err)
- _, err = g.call(addrDelegator, input, big.NewInt(0))
- g.Require().NotNil(err)
-
- // Only delegators can pay fine.
- _, addrDelegator2 := g.newPrefundAccount()
- input, err = abiObject.Pack("payFine", addr)
- g.Require().NoError(err)
- _, err = g.call(addrDelegator2, input, big.NewInt(5e5))
- g.Require().NotNil(err)
-
- // Paying more than fine should fail.
- payAmount := new(big.Int).Add(amount, amount)
- input, err = abiObject.Pack("payFine", addr)
- g.Require().NoError(err)
- _, err = g.call(addrDelegator, input, payAmount)
- g.Require().NotNil(err)
-
- // Pay the fine.
- input, err = abiObject.Pack("payFine", addr)
- g.Require().NoError(err)
- _, err = g.call(addrDelegator, input, amount)
- g.Require().NoError(err)
-
- // Qualified.
- g.Require().Equal(1, len(g.s.QualifiedNodes()))
-
- // Can undelegate after all fines are paied.
- input, err = abiObject.Pack("undelegate", addr)
- g.Require().NoError(err)
- _, err = g.call(addrDelegator, input, big.NewInt(0))
- g.Require().NoError(err)
-}
-
-func (g *GovernanceContractTestSuite) TestUnstakeWithExtraDelegators() {
- privKey, addr := g.newPrefundAccount()
- pk := crypto.FromECDSAPub(&privKey.PublicKey)
-
- // Stake.
- amount := new(big.Int).Mul(big.NewInt(1e18), big.NewInt(5e5))
- input, err := abiObject.Pack("stake", pk, "Test1", "test1@dexon.org", "Taipei, Taiwan", "https://dexon.org")
- g.Require().NoError(err)
- _, err = g.call(addr, input, amount)
- g.Require().NoError(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(3e5))
- input, err = abiObject.Pack("delegate", addr)
- g.Require().NoError(err)
-
- _, err = g.call(addrDelegator, input, amount)
- g.Require().NoError(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().NoError(err)
-
- _, err = g.call(addrDelegator2, input, amount)
- g.Require().NoError(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().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-
- time.Sleep(time.Second * 2)
- input, err = abiObject.Pack("withdraw", addr)
- g.Require().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- _, err = g.call(addrDelegator, input, big.NewInt(0))
- g.Require().NoError(err)
- _, err = g.call(addrDelegator2, input, big.NewInt(0))
- g.Require().NoError(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(1e6)),
- big.NewInt(1000),
- big.NewInt(0.1875*decimalMultiplier),
- big.NewInt(1e18),
- 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),
- []*big.Int{big.NewInt(1), big.NewInt(1), big.NewInt(1)})
- g.Require().NoError(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().NoError(err)
-}
-
-func (g *GovernanceContractTestSuite) TestSnapshotRound() {
- _, addr := g.newPrefundAccount()
-
- // Wrong height.
- input, err := abiObject.Pack("snapshotRound", big.NewInt(1), big.NewInt(666))
- g.Require().NoError(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().NoError(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().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-
- // Duplicate round.
- input, err = abiObject.Pack("snapshotRound", big.NewInt(1), big.NewInt(1000))
- g.Require().NoError(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().NoError(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().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-}
-
-func (g *GovernanceContractTestSuite) TestConfigurationReading() {
- _, addr := g.newPrefundAccount()
-
- // CRS.
- input, err := abiObject.Pack("crs", big.NewInt(0))
- g.Require().NoError(err)
- res, err := g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- var crs0 [32]byte
- err = abiObject.Unpack(&crs0, "crs", res)
- g.Require().NoError(err)
- g.Require().Equal(crypto.Keccak256Hash([]byte(g.config.GenesisCRSText)), common.BytesToHash(crs0[:]))
-
- // Owner.
- input, err = abiObject.Pack("owner")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- var owner common.Address
- err = abiObject.Unpack(&owner, "owner", res)
- g.Require().NoError(err)
- g.Require().Equal(g.config.Owner, owner)
-
- // MinStake.
- input, err = abiObject.Pack("minStake")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- var value *big.Int
- err = abiObject.Unpack(&value, "minStake", res)
- g.Require().NoError(err)
- g.Require().Equal(g.config.MinStake.String(), value.String())
-
- // BlockReward.
- input, err = abiObject.Pack("miningVelocity")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "miningVelocity", res)
- g.Require().NoError(err)
- g.Require().Equal(g.config.MiningVelocity, float32(value.Uint64())/decimalMultiplier)
-
- // BlockGasLimit.
- input, err = abiObject.Pack("blockGasLimit")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "blockGasLimit", res)
- g.Require().NoError(err)
- g.Require().Equal(g.config.BlockGasLimit, value.Uint64())
-
- // NumChains.
- input, err = abiObject.Pack("numChains")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "numChains", res)
- g.Require().NoError(err)
- g.Require().Equal(g.config.NumChains, uint32(value.Uint64()))
-
- // LambdaBA.
- input, err = abiObject.Pack("lambdaBA")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "lambdaBA", res)
- g.Require().NoError(err)
- g.Require().Equal(g.config.LambdaBA, value.Uint64())
-
- // LambdaDKG.
- input, err = abiObject.Pack("lambdaDKG")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "lambdaDKG", res)
- g.Require().NoError(err)
- g.Require().Equal(g.config.LambdaDKG, value.Uint64())
-
- // K.
- input, err = abiObject.Pack("k")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "k", res)
- g.Require().NoError(err)
- g.Require().Equal(g.config.K, uint32(value.Uint64()))
-
- // PhiRatio.
- input, err = abiObject.Pack("phiRatio")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "phiRatio", res)
- g.Require().NoError(err)
- g.Require().Equal(g.config.PhiRatio, float32(value.Uint64())/decimalMultiplier)
-
- // NotarySetSize.
- input, err = abiObject.Pack("notarySetSize")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "notarySetSize", res)
- g.Require().NoError(err)
- g.Require().Equal(g.config.NotarySetSize, uint32(value.Uint64()))
-
- // DKGSetSize.
- input, err = abiObject.Pack("dkgSetSize")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "dkgSetSize", res)
- g.Require().NoError(err)
- g.Require().Equal(g.config.DKGSetSize, uint32(value.Uint64()))
-
- // RoundInterval.
- input, err = abiObject.Pack("roundInterval")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "roundInterval", res)
- g.Require().NoError(err)
- g.Require().Equal(g.config.RoundInterval, value.Uint64())
-
- // MinBlockInterval.
- input, err = abiObject.Pack("minBlockInterval")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "minBlockInterval", res)
- g.Require().NoError(err)
- g.Require().Equal(g.config.MinBlockInterval, value.Uint64())
-}
-
-func (g *GovernanceContractTestSuite) TestReportForkVote() {
- key, addr := g.newPrefundAccount()
- pkBytes := crypto.FromECDSAPub(&key.PublicKey)
-
- // Stake.
- amount := new(big.Int).Mul(big.NewInt(1e18), big.NewInt(5e5))
- input, err := abiObject.Pack("stake", pkBytes, "Test1", "test1@dexon.org", "Taipei, Taiwan", "https://dexon.org")
- g.Require().NoError(err)
- _, err = g.call(addr, input, amount)
- g.Require().NoError(err)
-
- pubKey := coreEcdsa.NewPublicKeyFromECDSA(&key.PublicKey)
- privKey := coreEcdsa.NewPrivateKeyFromECDSA(key)
- vote1 := coreTypes.NewVote(coreTypes.VoteCom, coreCommon.NewRandomHash(), uint64(0))
- vote1.ProposerID = coreTypes.NewNodeID(pubKey)
-
- vote2 := vote1.Clone()
- for vote2.BlockHash == vote1.BlockHash {
- vote2.BlockHash = coreCommon.NewRandomHash()
- }
- vote1.Signature, err = privKey.Sign(coreUtils.HashVote(vote1))
- g.Require().NoError(err)
- vote2.Signature, err = privKey.Sign(coreUtils.HashVote(vote2))
- g.Require().NoError(err)
-
- vote1Bytes, err := rlp.EncodeToBytes(vote1)
- g.Require().NoError(err)
- vote2Bytes, err := rlp.EncodeToBytes(vote2)
- g.Require().NoError(err)
-
- // Report wrong type (fork block)
- input, err = abiObject.Pack("report", big.NewInt(2), vote1Bytes, vote2Bytes)
- g.Require().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().Error(err)
-
- input, err = abiObject.Pack("report", big.NewInt(1), vote1Bytes, vote2Bytes)
- g.Require().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-
- node := g.s.Node(big.NewInt(0))
- g.Require().Equal(node.Fined, g.s.FineValue(big.NewInt(1)))
-
- // Duplicate report should fail.
- input, err = abiObject.Pack("report", big.NewInt(1), vote1Bytes, vote2Bytes)
- g.Require().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().Error(err)
-
- // Check if finedRecords is set.
- payloads := [][]byte{vote1Bytes, vote2Bytes}
- sort.Sort(sortBytes(payloads))
-
- hash := Bytes32(crypto.Keccak256Hash(payloads...))
- input, err = abiObject.Pack("finedRecords", hash)
- g.Require().NoError(err)
- res, err := g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-
- var value bool
- err = abiObject.Unpack(&value, "finedRecords", res)
- g.Require().NoError(err)
- g.Require().True(value)
-}
-
-func (g *GovernanceContractTestSuite) TestReportForkBlock() {
- key, addr := g.newPrefundAccount()
- pkBytes := crypto.FromECDSAPub(&key.PublicKey)
-
- // Stake.
- amount := new(big.Int).Mul(big.NewInt(1e18), big.NewInt(5e5))
- input, err := abiObject.Pack("stake", pkBytes, "Test1", "test1@dexon.org", "Taipei, Taiwan", "https://dexon.org")
- g.Require().NoError(err)
- _, err = g.call(addr, input, amount)
- g.Require().NoError(err)
-
- privKey := coreEcdsa.NewPrivateKeyFromECDSA(key)
- block1 := &coreTypes.Block{
- ProposerID: coreTypes.NewNodeID(privKey.PublicKey()),
- ParentHash: coreCommon.NewRandomHash(),
- Timestamp: time.Now(),
- }
-
- block2 := block1.Clone()
- for block2.ParentHash == block1.ParentHash {
- block2.ParentHash = coreCommon.NewRandomHash()
- }
-
- hashBlock := func(block *coreTypes.Block) coreCommon.Hash {
- block.PayloadHash = coreCrypto.Keccak256Hash(block.Payload)
- var err error
- block.Hash, err = coreUtils.HashBlock(block)
- g.Require().NoError(err)
- return block.Hash
- }
-
- block1.Signature, err = privKey.Sign(hashBlock(block1))
- g.Require().NoError(err)
- block2.Signature, err = privKey.Sign(hashBlock(block2))
- g.Require().NoError(err)
-
- block1Bytes, err := rlp.EncodeToBytes(block1)
- g.Require().NoError(err)
- block2Bytes, err := rlp.EncodeToBytes(block2)
- g.Require().NoError(err)
-
- // Report wrong type (fork vote)
- input, err = abiObject.Pack("report", big.NewInt(1), block1Bytes, block2Bytes)
- g.Require().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().Error(err)
-
- input, err = abiObject.Pack("report", big.NewInt(2), block1Bytes, block2Bytes)
- g.Require().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-
- node := g.s.Node(big.NewInt(0))
- g.Require().Equal(node.Fined, g.s.FineValue(big.NewInt(2)))
-
- // Duplicate report should fail.
- input, err = abiObject.Pack("report", big.NewInt(2), block1Bytes, block2Bytes)
- g.Require().NoError(err)
- _, err = g.call(addr, input, big.NewInt(0))
- g.Require().Error(err)
-
- // Check if finedRecords is set.
- payloads := [][]byte{block1Bytes, block2Bytes}
- sort.Sort(sortBytes(payloads))
-
- hash := Bytes32(crypto.Keccak256Hash(payloads...))
- input, err = abiObject.Pack("finedRecords", hash)
- g.Require().NoError(err)
- res, err := g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-
- var value bool
- err = abiObject.Unpack(&value, "finedRecords", res)
- g.Require().NoError(err)
- g.Require().True(value)
-}
-
-func (g *GovernanceContractTestSuite) TestMiscVariableReading() {
- privKey, addr := g.newPrefundAccount()
- pk := crypto.FromECDSAPub(&privKey.PublicKey)
-
- input, err := abiObject.Pack("totalSupply")
- g.Require().NoError(err)
- res, err := g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-
- input, err = abiObject.Pack("totalStaked")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-
- // Stake.
- amount := new(big.Int).Mul(big.NewInt(1e18), big.NewInt(5e5))
- input, err = abiObject.Pack("stake", pk, "Test1", "test1@dexon.org", "Taipei, Taiwan", "https://dexon.org")
- g.Require().NoError(err)
- _, err = g.call(addr, input, amount)
- g.Require().NoError(err)
-
- // 1st delegator delegate to 1st node.
- _, addrDelegator := g.newPrefundAccount()
- amount = new(big.Int).Mul(big.NewInt(1e18), big.NewInt(3e5))
- input, err = abiObject.Pack("delegate", addr)
- g.Require().NoError(err)
- _, err = g.call(addrDelegator, input, amount)
- g.Require().NoError(err)
-
- // 2st delegator delegate to 1st node.
- _, addrDelegator2 := g.newPrefundAccount()
- input, err = abiObject.Pack("delegate", addr)
- g.Require().NoError(err)
- _, err = g.call(addrDelegator2, input, amount)
- g.Require().NoError(err)
-
- input, err = abiObject.Pack("nodes", big.NewInt(0))
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-
- input, err = abiObject.Pack("nodesLength")
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- var value *big.Int
- err = abiObject.Unpack(&value, "nodesLength", res)
- g.Require().NoError(err)
- g.Require().Equal(1, int(value.Uint64()))
-
- input, err = abiObject.Pack("nodesOffsetByAddress", addr)
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "nodesOffsetByAddress", res)
- g.Require().NoError(err)
- g.Require().Equal(0, int(value.Uint64()))
-
- id, err := publicKeyToNodeID(pk)
- g.Require().NoError(err)
- input, err = abiObject.Pack("nodesOffsetByID", id)
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "nodesOffsetByID", res)
- g.Require().NoError(err)
- g.Require().Equal(0, int(value.Uint64()))
-
- input, err = abiObject.Pack("delegators", addr, big.NewInt(0))
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-
- input, err = abiObject.Pack("delegatorsLength", addr)
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "delegatorsLength", res)
- g.Require().NoError(err)
- g.Require().Equal(3, int(value.Uint64()))
-
- input, err = abiObject.Pack("delegatorsOffset", addr, addrDelegator2)
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
- err = abiObject.Unpack(&value, "delegatorsOffset", res)
- g.Require().NoError(err)
- g.Require().Equal(2, int(value.Uint64()))
-
- input, err = abiObject.Pack("fineValues", big.NewInt(0))
- g.Require().NoError(err)
- res, err = g.call(addr, input, big.NewInt(0))
- g.Require().NoError(err)
-}
-
-func (g *GovernanceContractTestSuite) TestHalvingCondition() {
- // TotalSupply 2.5B reached
- g.s.MiningHalved()
- g.Require().Equal(new(big.Int).Mul(big.NewInt(1e18), big.NewInt(3.25e9)).String(),
- g.s.NextHalvingSupply().String())
- g.Require().Equal(new(big.Int).Mul(big.NewInt(1e18), big.NewInt(0.75e9)).String(),
- g.s.LastHalvedAmount().String())
-
- // TotalSupply 3.25B reached
- g.s.MiningHalved()
- g.Require().Equal(new(big.Int).Mul(big.NewInt(1e18), big.NewInt(3.625e9)).String(),
- g.s.NextHalvingSupply().String())
- g.Require().Equal(new(big.Int).Mul(big.NewInt(1e18), big.NewInt(0.375e9)).String(),
- g.s.LastHalvedAmount().String())
-}
-
-func TestGovernanceContract(t *testing.T) {
- suite.Run(t, new(GovernanceContractTestSuite))
-}
diff --git a/core/vm/oracle.go b/core/vm/evm/oracle.go
index 0d4c10d9e..1daba822e 100644
--- a/core/vm/oracle.go
+++ b/core/vm/evm/oracle.go
@@ -15,13 +15,14 @@
// along with the dexon-consensus library. If not, see
// <http://www.gnu.org/licenses/>.
-package vm
+package evm
import (
"strings"
"github.com/dexon-foundation/dexon/accounts/abi"
"github.com/dexon-foundation/dexon/common"
+ "github.com/dexon-foundation/dexon/core/vm"
)
var GovernanceContractAddress = common.HexToAddress("63751838d6485578b23e8b051d40861ecc416794")
@@ -34,7 +35,7 @@ func init() {
// OracleContract represent special system contracts written in Go.
type OracleContract interface {
- Run(evm *EVM, input []byte, contract *Contract) (ret []byte, err error)
+ Run(evm *EVM, input []byte, contract *vm.Contract) (ret []byte, err error)
}
// A map representing available system oracle contracts.
@@ -47,7 +48,7 @@ var OracleContracts = map[common.Address]func() OracleContract{
}
// Run oracle contract.
-func RunOracleContract(oracle OracleContract, evm *EVM, input []byte, contract *Contract) (ret []byte, err error) {
+func RunOracleContract(oracle OracleContract, evm *EVM, input []byte, contract *vm.Contract) (ret []byte, err error) {
return oracle.Run(evm, input, contract)
}
diff --git a/core/vm/oracle_contract_abi.go b/core/vm/evm/oracle_contract_abi.go
index bd99c0cc7..5e16ea842 100644
--- a/core/vm/oracle_contract_abi.go
+++ b/core/vm/evm/oracle_contract_abi.go
@@ -15,7 +15,7 @@
// along with the dexon-consensus library. If not, see
// <http://www.gnu.org/licenses/>.
-package vm
+package evm
// The governance ABI is generated from:
// https://github.com/dexon-foundation/governance-abi
diff --git a/core/vm/oracle_contracts.go b/core/vm/evm/oracle_contracts.go
index 2d1025492..4f0a21ff3 100644
--- a/core/vm/oracle_contracts.go
+++ b/core/vm/evm/oracle_contracts.go
@@ -15,7 +15,7 @@
// along with the dexon-consensus library. If not, see
// <http://www.gnu.org/licenses/>.
-package vm
+package evm
import (
"bytes"
@@ -29,6 +29,7 @@ import (
"github.com/dexon-foundation/dexon/accounts/abi"
"github.com/dexon-foundation/dexon/common"
"github.com/dexon-foundation/dexon/core/types"
+ "github.com/dexon-foundation/dexon/core/vm"
"github.com/dexon-foundation/dexon/crypto"
"github.com/dexon-foundation/dexon/params"
"github.com/dexon-foundation/dexon/rlp"
@@ -122,7 +123,7 @@ func IdToAddress(id coreTypes.NodeID) common.Address {
// State manipulation helper fro the governance contract.
type GovernanceState struct {
- StateDB StateDB
+ StateDB vm.StateDB
}
func (s *GovernanceState) getState(loc common.Hash) common.Hash {
@@ -1239,7 +1240,7 @@ type tsigVerifierIntf interface {
type GovernanceContract struct {
evm *EVM
state GovernanceState
- contract *Contract
+ contract *vm.Contract
coreDKGUtils coreDKGUtils
}
@@ -1286,7 +1287,7 @@ func (g *GovernanceContract) transfer(from, to common.Address, amount *big.Int)
func (g *GovernanceContract) useGas(gas uint64) ([]byte, error) {
if !g.contract.UseGas(gas) {
- return nil, ErrOutOfGas
+ return nil, vm.ErrOutOfGas
}
return nil, nil
}
@@ -1819,17 +1820,17 @@ func (g *GovernanceContract) payFine(nodeAddr common.Address) ([]byte, error) {
}
node := g.state.Node(nodeOffset)
- if node.Fined.Cmp(big.NewInt(0)) <= 0 || node.Fined.Cmp(g.contract.Value()) < 0 {
+ if node.Fined.Cmp(big.NewInt(0)) <= 0 || node.Fined.Cmp(g.contract.Value) < 0 {
return nil, errExecutionReverted
}
- node.Fined = new(big.Int).Sub(node.Fined, g.contract.Value())
+ node.Fined = new(big.Int).Sub(node.Fined, g.contract.Value)
g.state.UpdateNode(nodeOffset, node)
// Pay the fine to governance owner.
g.evm.StateDB.AddBalance(g.state.Owner(), g.contract.Value)
- g.state.emitFinePaid(nodeAddr, g.contract.Value())
+ g.state.emitFinePaid(nodeAddr, g.contract.Value)
return g.useGas(GovernanceActionGasCost)
}
@@ -2080,7 +2081,7 @@ func (g *GovernanceContract) resetDKG(newSignedCRS []byte) ([]byte, error) {
}
// Run executes governance contract.
-func (g *GovernanceContract) Run(evm *EVM, input []byte, contract *Contract) (ret []byte, err error) {
+func (g *GovernanceContract) Run(evm *EVM, input []byte, contract *vm.Contract) (ret []byte, err error) {
if len(input) < 4 {
return nil, errExecutionReverted
}
diff --git a/core/vm/oracle_contracts_test.go b/core/vm/evm/oracle_contracts_test.go
index 269421717..34427af15 100644
--- a/core/vm/oracle_contracts_test.go
+++ b/core/vm/evm/oracle_contracts_test.go
@@ -15,7 +15,7 @@
// along with the dexon-consensus library. If not, see
// <http://www.gnu.org/licenses/>.
-package vm
+package evm
import (
"bytes"
@@ -36,6 +36,7 @@ import (
"github.com/dexon-foundation/dexon/common"
"github.com/dexon-foundation/dexon/core/state"
+ "github.com/dexon-foundation/dexon/core/vm"
"github.com/dexon-foundation/dexon/crypto"
"github.com/dexon-foundation/dexon/ethdb"
"github.com/dexon-foundation/dexon/params"
@@ -164,7 +165,7 @@ func TestGovernanceState(t *testing.T) {
type OracleContractsTestSuite struct {
suite.Suite
- context Context
+ context vm.Context
config *params.DexconConfig
memDB *ethdb.MemDatabase
stateDB *state.StateDB
@@ -208,11 +209,11 @@ func (g *OracleContractsTestSuite) SetupTest() {
g.stateDB.Commit(true)
- g.context = Context{
- CanTransfer: func(db StateDB, addr common.Address, amount *big.Int) bool {
+ g.context = vm.Context{
+ CanTransfer: func(db vm.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) {
+ Transfer: func(db vm.StateDB, sender common.Address, recipient common.Address, amount *big.Int) {
db.SubBalance(sender, amount)
db.AddBalance(recipient, amount)
},
@@ -249,7 +250,7 @@ func (g *OracleContractsTestSuite) call(
g.context.Time = big.NewInt(time.Now().UnixNano() / 1000000)
evm := NewEVM(g.context, g.stateDB, params.TestChainConfig, Config{IsBlockProposer: true})
- ret, _, err := evm.Call(AccountRef(caller), contractAddr, input, 10000000, value)
+ ret, _, err := evm.Call(vm.AccountRef(caller), contractAddr, input, 10000000, value)
return ret, err
}