Merge pull request ethereum#83 from XinFinOrg/develop

Fix Bad_Block issue

Author: AnilChinchawale

.github/CONTRIBUTING.md

@@ -2,11 +2,15 @@
 
 Before you do a feature request please check and make sure that it isn't possible
 through some other means. The JavaScript enabled console is a powerful feature
-in the right hands.
+in the right hands. Please check our [Wiki page](https://github.com/ethereum/go-ethereum/wiki) for more info
+and help.
 
 ## Contributing
 
 If you'd like to contribute to go-ethereum please fork, fix, commit and
 send a pull request. Commits which do not comply with the coding standards
 are ignored (use gofmt!).
 
+See [Developers' Guide](https://github.com/ethereum/go-ethereum/wiki/Developers'-Guide)
+for more details on configuring your environment, testing, and
+dependency management.

Dockerfile.node

@@ -2,17 +2,17 @@ FROM golang:1.10-alpine as builder
 
 RUN apk add --no-cache make gcc musl-dev linux-headers
 
-ADD . /XDChain
+ADD . /XDCchain
 
-RUN cd /XDChain \
-    && make XDC\
+RUN cd /XDCchain \
+    && make XDC \
     && chmod +x /XDCchain/build/bin/XDC
 
 FROM alpine:latest
 
 LABEL maintainer="anil@xinfin.org"
 
-WORKDIR /XDChain
+WORKDIR /XDCchain
 
 COPY --from=builder /XDCchain/build/bin/XDC /usr/local/bin/XDC
 
@@ -31,7 +31,7 @@ ENV ANNOUNCE_TXS ''
 
 RUN apk add --no-cache ca-certificates
 
-COPY docker/XDChain ./
+COPY docker/XDCchain ./
 COPY genesis/ ./
 
 EXPOSE 8545 8546 30303 30303/udp

Makefile

@@ -15,6 +15,11 @@ XDC:
 	@echo "Done building."
 	@echo "Run \"$(GOBIN)/XDC\" to launch XDC."
 
+gc:
+	build/env.sh go run build/ci.go install ./cmd/gc
+	@echo "Done building."
+	@echo "Run \"$(GOBIN)/gc\" to launch gc."
+
 bootnode:
 	build/env.sh go run build/ci.go install ./cmd/bootnode
 	@echo "Done building."

cmd/XDCclean/main.go renamed to cmd/gc/main.go

@@ -3,6 +3,13 @@ package main
 import (
 	"flag"
 	"fmt"
+	"os"
+	"os/signal"
+	"runtime"
+	"sync"
+	"sync/atomic"
+	"time"
+
 	"github.com/ethereum/go-ethereum/cmd/utils"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core"
@@ -14,17 +21,18 @@ import (
 	"github.com/hashicorp/golang-lru"
 	"github.com/syndtr/goleveldb/leveldb"
 	"github.com/syndtr/goleveldb/leveldb/util"
-	"os"
-	"os/signal"
-	"runtime"
-	"sync"
-	"sync/atomic"
-	"time"
 )
 
 var (
-	dir       = flag.String("dir", "", "dir to mainet chain data")
-	cacheSize = flag.Int("size", 1000000, "dir to mainet chain data")
+	dir          = flag.String("dir", "", "directory to XDCChain chaindata")
+	cacheSize    = flag.Int("size", 1000000, "LRU cache size")
+	sercureKey   = []byte("secure-key-")
+	nWorker      = runtime.NumCPU() / 2
+	cleanAddress = []common.Address{common.HexToAddress(common.BlockSigners)}
+	cache        *lru.Cache
+	finish       = int32(0)
+	running      = true
+	stateRoots   = make(chan TrieRoot)
 )
 
 type TrieRoot struct {
@@ -42,14 +50,6 @@ type ResultProcessNode struct {
 	keys     [17]*[]byte
 }
 
-var sercureKey = []byte("secure-key-")
-var nWorker = runtime.NumCPU() / 2
-var cleanAddress = []common.Address{common.HexToAddress(common.BlockSigners)}
-var cache *lru.Cache
-var finish = int32(0)
-var running = true
-var stateRoots = make(chan TrieRoot)
-
 func main() {
 	flag.Parse()
 	lddb, _ := ethdb.NewLDBDatabase(*dir, eth.DefaultConfig.DatabaseCache, utils.MakeDatabaseHandles())

cmd/puppeth/wizard_genesis.go

@@ -122,8 +122,8 @@ func (w *wizard) makeGenesis() {
 		genesis.Config.XDPoS.Period = uint64(w.readDefaultInt(2))
 
 		fmt.Println()
-		fmt.Println("How many XDC should be rewarded to masternode? (default = 100)")
-		genesis.Config.XDPoS.Reward = uint64(w.readDefaultInt(100))
+		fmt.Println("How many XDC should be rewarded to masternode? (default = 350)")
+		genesis.Config.XDPoS.Reward = uint64(w.readDefaultInt(350))
 
 		fmt.Println()
 		fmt.Println("Who own the first masternodes? (mandatory)")
@@ -231,8 +231,8 @@ func (w *wizard) makeGenesis() {
 		code, _ = contractBackend.CodeAt(ctx, multiSignWalletAddr, nil)
 		storage = make(map[common.Hash]common.Hash)
 		contractBackend.ForEachStorageAt(ctx, multiSignWalletAddr, nil, f)
-		fBalance := big.NewInt(0) // 16m
-		fBalance.Add(fBalance, big.NewInt(16*1000*1000))
+		fBalance := big.NewInt(0) // 3 billion
+		fBalance.Add(fBalance, big.NewInt(3*1000*1000*1000))
 		fBalance.Mul(fBalance, big.NewInt(1000000000000000000))
 		genesis.Alloc[common.HexToAddress(common.FoudationAddr)] = core.GenesisAccount{
 			Balance: fBalance,
@@ -298,24 +298,24 @@ func (w *wizard) makeGenesis() {
 		storage = make(map[common.Hash]common.Hash)
 		contractBackend.ForEachStorageAt(ctx, multiSignWalletTeamAddr, nil, f)
 		// Team balance.
-		balance := big.NewInt(0) // 12m
-		balance.Add(balance, big.NewInt(12*1000*1000))
-		balance.Mul(balance, big.NewInt(1000000000000000000))
-		subBalance := big.NewInt(0) // i * 50k
-		subBalance.Add(subBalance, big.NewInt(int64(len(signers))*50*1000))
-		subBalance.Mul(subBalance, big.NewInt(1000000000000000000))
-		balance.Sub(balance, subBalance) // 12m - i * 50k
-		genesis.Alloc[common.HexToAddress(common.TeamAddr)] = core.GenesisAccount{
+		balance := big.NewInt(0) // 20 billion
+        balance.Add(balance, big.NewInt(20*1000*1000*1000))
+        balance.Mul(balance, big.NewInt(1000000000000000000))
+        subBalance := big.NewInt(0) // i * 50k
+        subBalance.Add(subBalance, big.NewInt(int64(len(signers))*50*1000))
+        subBalance.Mul(subBalance, big.NewInt(1000000000000000000))
+        balance.Sub(balance, subBalance) // 12m - i * 50k
+        genesis.Alloc[common.HexToAddress(common.TeamAddr)] = core.GenesisAccount{
 			Balance: balance,
 			Code:    code,
 			Storage: storage,
 		}
 
 		fmt.Println()
-		fmt.Println("What is swap wallet address for fund 55m XDC?")
+		fmt.Println("What is swap wallet address for fund 14.5Billion XDC?")
 		swapAddr := *w.readAddress()
-		baseBalance := big.NewInt(0) // 55m
-		baseBalance.Add(baseBalance, big.NewInt(55*1000*1000))
+		baseBalance := big.NewInt(0) // 14.5Billion 
+		baseBalance.Add(baseBalance, big.NewInt(145*1000*1000*100))
 		baseBalance.Mul(baseBalance, big.NewInt(1000000000000000000))
 		genesis.Alloc[swapAddr] = core.GenesisAccount{
 			Balance: baseBalance,

common/constants.go

@@ -22,8 +22,9 @@ const (
 	MinimunMinerBlockPerEpoch  = 1
 )
 
-var TIP2019Block = big.NewInt(1050000)
+var TIP2019Block = big.NewInt(1)
 var TIPSigning = big.NewInt(3000000)
+var TIPRandomize = big.NewInt(3464000)
 var IsTestnet bool = false
 var StoreRewardFolder string
 var RollbackHash Hash

consensus/XDPoS/XDPoS.go

@@ -13,7 +13,7 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 
-// Package XDPoS implements the delegated-proof-of-stake consensus engine.
+// Package XDPoS implements the proof-of-stake-voting consensus engine.
 package XDPoS
 
 import (
@@ -25,6 +25,8 @@ import (
 	"math/big"
 	"math/rand"
 	"path/filepath"
+	"reflect"
+	"sort"
 	"strconv"
 	"sync"
 	"time"
@@ -58,7 +60,7 @@ type Masternode struct {
 	Stake   *big.Int
 }
 
-// XDPoS delegated-proof-of-stake protocol constants.
+// XDPoS proof-of-stake-voting protocol constants.
 var (
 	epochLength = uint64(900) // Default number of blocks after which to checkpoint and reset the pending votes
 
@@ -149,7 +151,7 @@ var (
 // backing account.
 //type SignerFn func(accounts.Account, []byte) ([]byte, error)
 
-// sigHash returns the hash which is used as input for the delegated-proof-of-stake
+// sigHash returns the hash which is used as input for the proof-of-stake-voting
 // signing. It is the hash of the entire header apart from the 65 byte signature
 // contained at the end of the extra data.
 //
@@ -209,7 +211,7 @@ func ecrecover(header *types.Header, sigcache *lru.ARCCache) (common.Address, er
 	return signer, nil
 }
 
-// XDPoS is the delegated-proof-of-stake consensus engine proposed to support the
+// XDPoS is the proof-of-stake-voting consensus engine proposed to support the
 // Ethereum testnet following the Ropsten attacks.
 type XDPoS struct {
 	config *params.XDPoSConfig // Consensus engine configuration parameters
@@ -225,15 +227,15 @@ type XDPoS struct {
 	signFn clique.SignerFn // Signer function to authorize hashes with
 	lock   sync.RWMutex    // Protects the signer fields
 
-	BlockSigners *lru.Cache
-	HookReward   func(chain consensus.ChainReader, state *state.StateDB, header *types.Header) (error, map[string]interface{})
+	BlockSigners          *lru.Cache
+	HookReward            func(chain consensus.ChainReader, state *state.StateDB, header *types.Header) (error, map[string]interface{})
 	HookPenalty           func(chain consensus.ChainReader, blockNumberEpoc uint64) ([]common.Address, error)
 	HookPenaltyTIPSigning func(chain consensus.ChainReader, header *types.Header, candidate []common.Address) ([]common.Address, error)
 	HookValidator         func(header *types.Header, signers []common.Address) ([]byte, error)
 	HookVerifyMNs         func(header *types.Header, signers []common.Address) error
 }
 
-// New creates a XDPoS delegated-proof-of-stake consensus engine with the initial
+// New creates a XDPoS proof-of-stake-voting consensus engine with the initial
 // signers set to the ones provided by the user.
 func New(config *params.XDPoSConfig, db ethdb.Database) *XDPoS {
 	// Set any missing consensus parameters to their defaults
@@ -424,9 +426,11 @@ func (c *XDPoS) verifyCascadingFields(chain consensus.ChainReader, header *types
 				signers = RemovePenaltiesFromBlock(chain, signers, number-uint64(i)*c.config.Epoch)
 			}
 		}
-		byteMasterNodes := common.ExtractAddressToBytes(signers)
 		extraSuffix := len(header.Extra) - extraSeal
-		if !bytes.Equal(header.Extra[extraVanity:extraSuffix], byteMasterNodes) {
+		masternodesFromCheckpointHeader := common.ExtractAddressFromBytes(header.Extra[extraVanity:extraSuffix])
+		validSigners := compareSignersLists(masternodesFromCheckpointHeader, signers)
+		if !validSigners {
+			log.Error("Masternodes lists are different in checkpoint header and snapshot", "number", number, "masternodes_from_checkpoint_header", masternodesFromCheckpointHeader, "masternodes_in_snapshot", signers, "penList", penPenalties)
 			return errInvalidCheckpointSigners
 		}
 		if c.HookVerifyMNs != nil {
@@ -440,6 +444,21 @@ func (c *XDPoS) verifyCascadingFields(chain consensus.ChainReader, header *types
 	return c.verifySeal(chain, header, parents, fullVerify)
 }
 
+// compare 2 signers lists
+// return true if they are same elements, otherwise return false
+func compareSignersLists(list1 []common.Address, list2 []common.Address) bool {
+	if len(list1) == 0 && len(list2) == 0 {
+		return true
+	}
+	sort.Slice(list1, func(i, j int) bool {
+		return list1[i].String() <= list1[j].String()
+	})
+	sort.Slice(list2, func(i, j int) bool {
+		return list2[i].String() <= list2[j].String()
+	})
+	return reflect.DeepEqual(list1, list2)
+}
+
 func (c *XDPoS) GetSnapshot(chain consensus.ChainReader, header *types.Header) (*Snapshot, error) {
 	number := header.Number.Uint64()
 	log.Trace("take snapshot", "number", number, "hash", header.Hash())
@@ -739,7 +758,7 @@ func (c *XDPoS) GetValidator(creator common.Address, chain consensus.ChainReader
 			return common.Address{}, fmt.Errorf("couldn't find checkpoint header")
 		}
 	}
-	m, err := GetM1M2FromCheckpointHeader(cpHeader)
+	m, err := GetM1M2FromCheckpointHeader(cpHeader, header, chain.Config())
 	if err != nil {
 		return common.Address{}, err
 	}
@@ -977,7 +996,13 @@ func (c *XDPoS) Seal(chain consensus.ChainReader, block *types.Block, stop <-cha
 		return nil, err
 	}
 	copy(header.Extra[len(header.Extra)-extraSeal:], sighash)
-
+	m2, err := c.GetValidator(signer, chain, header)
+	if err != nil {
+		return nil, fmt.Errorf("can't get block validator: %v", err)
+	}
+	if m2 == signer {
+		header.Validator = sighash
+	}
 	return block.WithSeal(header), nil
 }
 
@@ -1119,24 +1144,39 @@ func GetMasternodesFromCheckpointHeader(checkpointHeader *types.Header) []common
 }
 
 // Get m2 list from checkpoint block.
-func GetM1M2FromCheckpointHeader(checkpointHeader *types.Header) (map[common.Address]common.Address, error) {
+func GetM1M2FromCheckpointHeader(checkpointHeader *types.Header, currentHeader *types.Header, config *params.ChainConfig) (map[common.Address]common.Address, error) {
 	if checkpointHeader.Number.Uint64()%common.EpocBlockRandomize != 0 {
 		return nil, errors.New("This block is not checkpoint block epoc.")
 	}
-	m1m2 := map[common.Address]common.Address{}
 	// Get signers from this block.
 	masternodes := GetMasternodesFromCheckpointHeader(checkpointHeader)
 	validators := ExtractValidatorsFromBytes(checkpointHeader.Validators)
-
-	if len(validators) < len(masternodes) {
-		return nil, errors.New("len(m2) is less than len(m1)")
+	m1m2, _, err := getM1M2(masternodes, validators, currentHeader, config)
+	if err != nil {
+		return map[common.Address]common.Address{}, err
 	}
-	if len(masternodes) > 0 {
+	return m1m2, nil
+}
+
+func getM1M2(masternodes []common.Address, validators []int64, currentHeader *types.Header, config *params.ChainConfig) (map[common.Address]common.Address, uint64, error) {
+	m1m2 := map[common.Address]common.Address{}
+	maxMNs := len(masternodes)
+	moveM2 := uint64(0)
+	if len(validators) < maxMNs {
+		return nil, moveM2, errors.New("len(m2) is less than len(m1)")
+	}
+	if maxMNs > 0 {
+		isForked := config.IsTIPRandomize(currentHeader.Number)
+		if isForked {
+			moveM2 = ((currentHeader.Number.Uint64() % config.XDPoS.Epoch) / uint64(maxMNs)) % uint64(maxMNs)
+		}
 		for i, m1 := range masternodes {
-			m1m2[m1] = masternodes[validators[i]%int64(len(masternodes))]
+			m2Index := uint64(validators[i] % int64(maxMNs))
+			m2Index = (m2Index + moveM2) % uint64(maxMNs)
+			m1m2[m1] = masternodes[m2Index]
 		}
 	}
-	return m1m2, nil
+	return m1m2, moveM2, nil
 }
 
 // Extract validators from byte array.