params: update testnet config (#177)

* vendor:sync to latest core
* params: Update config for testnet

3 files changed, 140 insertions, 72 deletions

diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/agreement-mgr.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/agreement-mgr.go
index a8fab7c69..bcf10139c 100644
--- a/vendor/github.com/dexon-foundation/dexon-consensus/core/agreement-mgr.go
+++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/agreement-mgr.go
@@ -35,6 +35,8 @@ var (
 	ErrPreviousRoundIsNotFinished = errors.New("previous round is not finished")
 )
 
+const maxResultCache = 100
+
 // genValidLeader generate a validLeader function for agreement modules.
 func genValidLeader(
 	mgr *agreementMgr) func(*types.Block) (bool, error) {
@@ -80,25 +82,26 @@ type baRoundSetting struct {
 
 type agreementMgr struct {
 	// TODO(mission): unbound Consensus instance from this module.
-	con           *Consensus
-	ID            types.NodeID
-	app           Application
-	gov           Governance
-	network       Network
-	logger        common.Logger
-	cache         *utils.NodeSetCache
-	signer        *utils.Signer
-	lattice       *Lattice
-	ctx           context.Context
-	lastEndTime   time.Time
-	initRound     uint64
-	configs       []*agreementMgrConfig
-	baModules     []*agreement
-	voteFilters   []*utils.VoteFilter
-	waitGroup     sync.WaitGroup
-	pendingVotes  map[uint64][]*types.Vote
-	pendingBlocks map[uint64][]*types.Block
-	isRunning     bool
+	con               *Consensus
+	ID                types.NodeID
+	app               Application
+	gov               Governance
+	network           Network
+	logger            common.Logger
+	cache             *utils.NodeSetCache
+	signer            *utils.Signer
+	lattice           *Lattice
+	ctx               context.Context
+	lastEndTime       time.Time
+	initRound         uint64
+	configs           []*agreementMgrConfig
+	baModules         []*agreement
+	processedBAResult map[types.Position]struct{}
+	voteFilters       []*utils.VoteFilter
+	waitGroup         sync.WaitGroup
+	pendingVotes      map[uint64][]*types.Vote
+	pendingBlocks     map[uint64][]*types.Block
+	isRunning         bool
 
 	// This lock should be used when attempting to:
 	//  - add a new baModule.
@@ -114,18 +117,19 @@ type agreementMgr struct {
 func newAgreementMgr(con *Consensus, initRound uint64,
 	initRoundBeginTime time.Time) *agreementMgr {
 	return &agreementMgr{
-		con:         con,
-		ID:          con.ID,
-		app:         con.app,
-		gov:         con.gov,
-		network:     con.network,
-		logger:      con.logger,
-		cache:       con.nodeSetCache,
-		signer:      con.signer,
-		lattice:     con.lattice,
-		ctx:         con.ctx,
-		initRound:   initRound,
-		lastEndTime: initRoundBeginTime,
+		con:               con,
+		ID:                con.ID,
+		app:               con.app,
+		gov:               con.gov,
+		network:           con.network,
+		logger:            con.logger,
+		cache:             con.nodeSetCache,
+		signer:            con.signer,
+		lattice:           con.lattice,
+		ctx:               con.ctx,
+		initRound:         initRound,
+		lastEndTime:       initRoundBeginTime,
+		processedBAResult: make(map[types.Position]struct{}, maxResultCache),
 	}
 }
 
@@ -251,6 +255,29 @@ func (mgr *agreementMgr) processBlock(b *types.Block) error {
 	return mgr.baModules[b.Position.ChainID].processBlock(b)
 }
 
+func (mgr *agreementMgr) touchAgreementResult(
+	result *types.AgreementResult) (first bool) {
+	// DO NOT LOCK THIS FUNCTION!!!!!!!! YOU WILL REGRET IT!!!!!
+	if _, exist := mgr.processedBAResult[result.Position]; !exist {
+		first = true
+		if len(mgr.processedBAResult) > maxResultCache {
+			for k := range mgr.processedBAResult {
+				// Randomly drop one element.
+				delete(mgr.processedBAResult, k)
+				break
+			}
+		}
+		mgr.processedBAResult[result.Position] = struct{}{}
+	}
+	return
+}
+
+func (mgr *agreementMgr) untouchAgreementResult(
+	result *types.AgreementResult) {
+	// DO NOT LOCK THIS FUNCTION!!!!!!!! YOU WILL REGRET IT!!!!!
+	delete(mgr.processedBAResult, result.Position)
+}
+
 func (mgr *agreementMgr) processAgreementResult(
 	result *types.AgreementResult) error {
 	mgr.lock.RLock()
diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/compaction-chain.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/compaction-chain.go
index 8e044293f..d7c2f8556 100644
--- a/vendor/github.com/dexon-foundation/dexon-consensus/core/compaction-chain.go
+++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/compaction-chain.go
@@ -41,6 +41,7 @@ var (
 )
 
 const maxPendingPeriod = 3 * time.Second
+const maxRandomnessCache = 100
 
 type pendingRandomnessResult struct {
 	receivedTime time.Time
@@ -50,24 +51,26 @@ type pendingRandomnessResult struct {
 type finalizedBlockHeap = types.ByFinalizationHeight
 
 type compactionChain struct {
-	gov               Governance
-	chainUnsynced     uint32
-	tsigVerifier      *TSigVerifierCache
-	blocks            map[common.Hash]*types.Block
-	blockRandomness   map[common.Hash][]byte
-	pendingRandomness map[common.Hash]pendingRandomnessResult
-	pendingBlocks     []*types.Block
-	lock              sync.RWMutex
-	prevBlock         *types.Block
+	gov                       Governance
+	chainUnsynced             uint32
+	tsigVerifier              *TSigVerifierCache
+	blocks                    map[common.Hash]*types.Block
+	blockRandomness           map[common.Hash][]byte
+	pendingRandomness         map[common.Hash]pendingRandomnessResult
+	processedRandomnessResult map[types.Position]struct{}
+	pendingBlocks             []*types.Block
+	lock                      sync.RWMutex
+	prevBlock                 *types.Block
 }
 
 func newCompactionChain(gov Governance) *compactionChain {
 	return &compactionChain{
-		gov:               gov,
-		tsigVerifier:      NewTSigVerifierCache(gov, 7),
-		blocks:            make(map[common.Hash]*types.Block),
-		blockRandomness:   make(map[common.Hash][]byte),
-		pendingRandomness: make(map[common.Hash]pendingRandomnessResult),
+		gov:                       gov,
+		tsigVerifier:              NewTSigVerifierCache(gov, 7),
+		blocks:                    make(map[common.Hash]*types.Block),
+		blockRandomness:           make(map[common.Hash][]byte),
+		pendingRandomness:         make(map[common.Hash]pendingRandomnessResult),
+		processedRandomnessResult: make(map[types.Position]struct{}, maxRandomnessCache),
 	}
 }
 
@@ -207,6 +210,23 @@ func (cc *compactionChain) processFinalizedBlock(block *types.Block) error {
 	return nil
 }
 
+func (cc *compactionChain) touchBlockRandomnessResult(
+	rand *types.BlockRandomnessResult) (first bool) {
+	// DO NOT LOCK THIS FUNCTION!!!!!!!! YOU WILL REGRET IT!!!!!
+	if _, exist := cc.processedRandomnessResult[rand.Position]; !exist {
+		first = true
+		if len(cc.processedRandomnessResult) > maxRandomnessCache {
+			for k := range cc.processedRandomnessResult {
+				// Randomly drop one element.
+				delete(cc.processedRandomnessResult, k)
+				break
+			}
+		}
+		cc.processedRandomnessResult[rand.Position] = struct{}{}
+	}
+	return
+}
+
 func (cc *compactionChain) processBlockRandomnessResult(
 	rand *types.BlockRandomnessResult) error {
 	ok, err := cc.verifyRandomness(
diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/consensus.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/consensus.go
index 3a27b5fc1..f46501038 100644
--- a/vendor/github.com/dexon-foundation/dexon-consensus/core/consensus.go
+++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/consensus.go
@@ -1021,11 +1021,17 @@ func (con *Consensus) ProcessVote(vote *types.Vote) (err error) {
 // ProcessAgreementResult processes the randomness request.
 func (con *Consensus) ProcessAgreementResult(
 	rand *types.AgreementResult) error {
+	if !con.baMgr.touchAgreementResult(rand) {
+		return nil
+	}
+
 	// Sanity Check.
 	if err := VerifyAgreementResult(rand, con.nodeSetCache); err != nil {
+		con.baMgr.untouchAgreementResult(rand)
 		return err
 	}
 	con.lattice.AddShallowBlock(rand.BlockHash, rand.Position)
+
 	// Syncing BA Module.
 	if err := con.baMgr.processAgreementResult(rand); err != nil {
 		return err
@@ -1039,32 +1045,46 @@ func (con *Consensus) ProcessAgreementResult(
 	if !con.cfgModule.touchTSigHash(rand.BlockHash) {
 		return nil
 	}
+
 	con.logger.Debug("Rebroadcast AgreementResult",
 		"result", rand)
 	con.network.BroadcastAgreementResult(rand)
-	dkgSet, err := con.nodeSetCache.GetDKGSet(rand.Position.Round)
-	if err != nil {
-		return err
-	}
-	if _, exist := dkgSet[con.ID]; !exist {
-		return nil
-	}
-	psig, err := con.cfgModule.preparePartialSignature(rand.Position.Round, rand.BlockHash)
-	if err != nil {
-		return err
-	}
-	if err = con.signer.SignDKGPartialSignature(psig); err != nil {
-		return err
-	}
-	if err = con.cfgModule.processPartialSignature(psig); err != nil {
-		return err
-	}
-	con.logger.Debug("Calling Network.BroadcastDKGPartialSignature",
-		"proposer", psig.ProposerID,
-		"round", psig.Round,
-		"hash", psig.Hash.String()[:6])
-	con.network.BroadcastDKGPartialSignature(psig)
+
 	go func() {
+		dkgSet, err := con.nodeSetCache.GetDKGSet(rand.Position.Round)
+		if err != nil {
+			con.logger.Error("Failed to get dkg set",
+				"round", rand.Position.Round, "error", err)
+			return
+		}
+		if _, exist := dkgSet[con.ID]; !exist {
+			return
+		}
+		psig, err := con.cfgModule.preparePartialSignature(rand.Position.Round, rand.BlockHash)
+		if err != nil {
+			con.logger.Error("Failed to prepare psig",
+				"round", rand.Position.Round,
+				"hash", rand.BlockHash.String()[:6],
+				"error", err)
+			return
+		}
+		if err = con.signer.SignDKGPartialSignature(psig); err != nil {
+			con.logger.Error("Failed to sign psig",
+				"hash", rand.BlockHash.String()[:6],
+				"error", err)
+			return
+		}
+		if err = con.cfgModule.processPartialSignature(psig); err != nil {
+			con.logger.Error("Failed process psig",
+				"hash", rand.BlockHash.String()[:6],
+				"error", err)
+			return
+		}
+		con.logger.Debug("Calling Network.BroadcastDKGPartialSignature",
+			"proposer", psig.ProposerID,
+			"round", psig.Round,
+			"hash", psig.Hash.String()[:6])
+		con.network.BroadcastDKGPartialSignature(psig)
 		tsig, err := con.cfgModule.runTSig(rand.Position.Round, rand.BlockHash)
 		if err != nil {
 			if err != ErrTSigAlreadyRunning {
@@ -1080,11 +1100,9 @@ func (con *Consensus) ProcessAgreementResult(
 			Position:   rand.Position,
 			Randomness: tsig.Signature,
 		}
-		if err := con.ProcessBlockRandomnessResult(result, true); err != nil {
-			con.logger.Error("Failed to process randomness result",
-				"error", err)
-			return
-		}
+		// ProcessBlockRandomnessResult is not thread-safe so we put the result in
+		// the message channnel to be processed in the main thread.
+		con.msgChan <- result
 	}()
 	return nil
 }
@@ -1095,6 +1113,9 @@ func (con *Consensus) ProcessBlockRandomnessResult(
 	if rand.Position.Round == 0 {
 		return nil
 	}
+	if !con.ccModule.touchBlockRandomnessResult(rand) {
+		return nil
+	}
 	if err := con.ccModule.processBlockRandomnessResult(rand); err != nil {
 		if err == ErrBlockNotRegistered {
 			err = nil