1 files changed, 40 insertions, 39 deletions

diff --git a/vendor/github.com/dexon-foundation/dexon-consensus/core/lattice.go b/vendor/github.com/dexon-foundation/dexon-consensus/core/lattice.go
index 7b66bd557..f76813d82 100644
--- a/vendor/github.com/dexon-foundation/dexon-consensus/core/lattice.go
+++ b/vendor/github.com/dexon-foundation/dexon-consensus/core/lattice.go
@@ -41,7 +41,6 @@ type Lattice struct {
 	pool       blockPool
 	retryAdd   bool
 	data       *latticeData
-	toSyncer   *totalOrderingSyncer
 	toModule   *totalOrdering
 	ctModule   *consensusTimestamp
 	logger     common.Logger
@@ -65,7 +64,6 @@ func NewLattice(
 		debug:      debug,
 		pool:       newBlockPool(cfg.NumChains),
 		data:       newLatticeData(db, dMoment, round, cfg),
-		toSyncer:   newTotalOrderingSyncer(cfg.NumChains),
 		toModule:   newTotalOrdering(dMoment, cfg),
 		ctModule:   newConsensusTimestamp(dMoment, round, cfg.NumChains),
 		logger:     logger,
@@ -102,7 +100,9 @@ func (l *Lattice) PrepareBlock(
 func (l *Lattice) PrepareEmptyBlock(b *types.Block) (err error) {
 	l.lock.RLock()
 	defer l.lock.RUnlock()
-	l.data.prepareEmptyBlock(b)
+	if err = l.data.prepareEmptyBlock(b); err != nil {
+		return
+	}
 	if b.Hash, err = hashBlock(b); err != nil {
 		return
 	}
@@ -155,6 +155,16 @@ func (l *Lattice) SanityCheck(b *types.Block) (err error) {
 	return
 }
 
+// Exist checks if the block is known to lattice.
+func (l *Lattice) Exist(hash common.Hash) bool {
+	l.lock.RLock()
+	defer l.lock.RUnlock()
+	if _, err := l.data.findBlock(hash); err != nil {
+		return false
+	}
+	return true
+}
+
 // addBlockToLattice adds a block into lattice, and delivers blocks with the
 // acks already delivered.
 //
@@ -164,6 +174,8 @@ func (l *Lattice) addBlockToLattice(
 
 	if tip := l.data.chains[input.Position.ChainID].tip; tip != nil {
 		if !input.Position.Newer(&tip.Position) {
+			l.logger.Warn("Dropping block: older than tip",
+				"block", input, "tip", tip)
 			return
 		}
 	}
@@ -203,7 +215,7 @@ func (l *Lattice) addBlockToLattice(
 		if l.debug != nil {
 			l.debug.StronglyAcked(b.Hash)
 		}
-		l.logger.Debug("Calling Application.BlockConfirmed", "block", input)
+		l.logger.Debug("Calling Application.BlockConfirmed", "block", b)
 		l.app.BlockConfirmed(*b.Clone())
 		// Purge blocks in pool with the same chainID and lower height.
 		l.pool.purgeBlocks(b.Position.ChainID, b.Position.Height)
@@ -237,40 +249,37 @@ func (l *Lattice) ProcessBlock(
 		return
 	}
 
-	for _, blockToSyncer := range inLattice {
-		toTotalOrdering := l.toSyncer.processBlock(blockToSyncer)
-		// Perform total ordering for each block added to lattice.
-		for _, b = range toTotalOrdering {
-			toDelivered, deliveredMode, err = l.toModule.processBlock(b)
-			if err != nil {
-				// All errors from total ordering is serious, should panic.
-				panic(err)
-			}
-			if len(toDelivered) == 0 {
-				continue
-			}
-			hashes := make(common.Hashes, len(toDelivered))
-			for idx := range toDelivered {
-				hashes[idx] = toDelivered[idx].Hash
-			}
-			if l.debug != nil {
-				l.debug.TotalOrderingDelivered(hashes, deliveredMode)
-			}
-			// Perform consensus timestamp module.
-			if err = l.ctModule.processBlocks(toDelivered); err != nil {
-				return
-			}
-			delivered = append(delivered, toDelivered...)
+	for _, b = range inLattice {
+		toDelivered, deliveredMode, err = l.toModule.processBlock(b)
+		if err != nil {
+			// All errors from total ordering is serious, should panic.
+			panic(err)
+		}
+		if len(toDelivered) == 0 {
+			continue
+		}
+		hashes := make(common.Hashes, len(toDelivered))
+		for idx := range toDelivered {
+			hashes[idx] = toDelivered[idx].Hash
+		}
+		if l.debug != nil {
+			l.debug.TotalOrderingDelivered(hashes, deliveredMode)
 		}
+		// Perform consensus timestamp module.
+		if err = l.ctModule.processBlocks(toDelivered); err != nil {
+			return
+		}
+		delivered = append(delivered, toDelivered...)
 	}
 	return
 }
 
-// NextPosition returns expected position of incoming block for specified chain.
-func (l *Lattice) NextPosition(chainID uint32) types.Position {
+// NextHeight returns expected height of incoming block for specified chain and
+// given round.
+func (l *Lattice) NextHeight(round uint64, chainID uint32) (uint64, error) {
 	l.lock.RLock()
 	defer l.lock.RUnlock()
-	return l.data.nextPosition(chainID)
+	return l.data.nextHeight(round, chainID)
 }
 
 // PurgeBlocks purges blocks' cache in memory, this is called when the caller
@@ -301,12 +310,4 @@ func (l *Lattice) AppendConfig(round uint64, config *types.Config) (err error) {
 
 // ProcessFinalizedBlock is used for syncing lattice data.
 func (l *Lattice) ProcessFinalizedBlock(b *types.Block) {
-	defer func() { l.retryAdd = true }()
-	l.lock.Lock()
-	defer l.lock.Unlock()
-	if err := l.data.addFinalizedBlock(b); err != nil {
-		panic(err)
-	}
-	l.pool.purgeBlocks(b.Position.ChainID, b.Position.Height)
-	l.toSyncer.processFinalizedBlock(b)
 }