avoid processing already finalized snapshot

kernel/cosi.go

@@ -1022,16 +1022,21 @@ func (node *Node) VerifyAndQueueAppendSnapshotFinalization(peerId crypto.Hash, s
 		return nil
 	}
 
-	tx, err := node.checkTxInStorage(s.SoleTransaction())
+	tx, finalized, err := node.checkTxInStorage(s.SoleTransaction())
 	if err != nil {
 		logger.Verbosef("VerifyAndQueueAppendSnapshotFinalization(%s, %s) check tx error %s\n", peerId, s.Hash, err)
 	} else if tx == nil {
 		logger.Verbosef("VerifyAndQueueAppendSnapshotFinalization(%s, %s) SendTransactionRequestMessage %s\n",
 			peerId, s.Hash, s.SoleTransaction())
 		node.Peer.SendTransactionRequestMessage(peerId, s.SoleTransaction())
+	} else if finalized == s.Hash.String() {
+		return nil
 	}
 
 	chain := node.getOrCreateChain(s.NodeId)
+	if cs := chain.State; cs != nil && cs.CacheRound.index[s.Hash] {
+		return nil
+	}
 	if _, finalized := chain.verifyFinalization(s); !finalized {
 		logger.Verbosef("ERROR VerifyAndQueueAppendSnapshotFinalization %s %v %d %t %v %v\n",
 			peerId, s, node.ConsensusThreshold(s.Timestamp, true), chain.IsPledging(), chain.State, chain.ConsensusInfo)

kernel/election.go

@@ -422,6 +422,7 @@ func (node *Node) finalizeNodeAcceptSnapshot(s *common.Snapshot, signers []crypt
 			Self:     final.Hash,
 			External: external.Hash,
 		},
+		index: make(map[crypto.Hash]bool),
 	}
 	err = node.persistStore.StartNewRound(cache.NodeId, cache.Number, cache.References, final.Start)
 	if err != nil {

kernel/final.go

@@ -5,11 +5,12 @@ import (
 	"github.com/MixinNetwork/mixin/crypto"
 )
 
-func (node *Node) checkTxInStorage(id crypto.Hash) (*common.VersionedTransaction, error) {
-	tx, _, err := node.persistStore.ReadTransaction(id)
+func (node *Node) checkTxInStorage(id crypto.Hash) (*common.VersionedTransaction, string, error) {
+	tx, snap, err := node.persistStore.ReadTransaction(id)
 	if err != nil || tx != nil {
-		return tx, err
+		return tx, snap, err
 	}
 
-	return node.persistStore.CacheGetTransaction(id)
+	tx, err = node.persistStore.CacheGetTransaction(id)
+	return tx, "", err
 }

kernel/graph.go

@@ -25,6 +25,7 @@ func (chain *Chain) startNewRoundAndPersist(cache *CacheRound, references *commo
 		Number:     final.Number + 1,
 		Timestamp:  timestamp,
 		References: references.Copy(),
+		index:      make(map[crypto.Hash]bool),
 	}
 	if dummy {
 		cache.References.External = dummyExternal

kernel/node.go

@@ -435,7 +435,7 @@ func (node *Node) Authenticate(msg []byte) (crypto.Hash, string, error) {
 }
 
 func (node *Node) SendTransactionToPeer(peerId, hash crypto.Hash) error {
-	tx, err := node.checkTxInStorage(hash)
+	tx, _, err := node.checkTxInStorage(hash)
 	if err != nil || tx == nil {
 		return err
 	}

kernel/round.go

@@ -19,6 +19,7 @@ type CacheRound struct {
 	Timestamp  uint64
 	References *common.RoundLink
 	Snapshots  []*common.Snapshot
+	index      map[crypto.Hash]bool
 }
 
 type FinalRound struct {
@@ -96,6 +97,7 @@ func loadHeadRoundForNode(store storage.Store, nodeIdWithNetwork crypto.Hash) (*
 		Number:     meta.Number,
 		Timestamp:  meta.Timestamp,
 		References: meta.References,
+		index:      make(map[crypto.Hash]bool),
 	}
 	topos, err := store.ReadSnapshotsForNodeRound(round.NodeId, round.Number)
 	if err != nil {
@@ -105,6 +107,7 @@ func loadHeadRoundForNode(store storage.Store, nodeIdWithNetwork crypto.Hash) (*
 		s := t.Snapshot
 		s.Hash = s.PayloadHash()
 		round.Snapshots = append(round.Snapshots, s)
+		round.index[s.Hash] = true
 	}
 	return round, nil
 }
@@ -142,6 +145,7 @@ func (c *CacheRound) Copy() *CacheRound {
 			External: c.References.External,
 		},
 		Snapshots: append([]*common.Snapshot{}, c.Snapshots...),
+		index:     c.index,
 	}
 }
 
@@ -184,10 +188,12 @@ func (c *CacheRound) Gap() (uint64, uint64) {
 
 func (chain *Chain) AddSnapshot(final *FinalRound, cache *CacheRound, s *common.Snapshot, signers []crypto.Hash) error {
 	chain.node.TopoWrite(s, signers)
-	if err := cache.validateSnapshot(s, true); err != nil {
-		panic("should never be here")
+	err := cache.validateSnapshot(s, true)
+	if err != nil {
+		panic(err)
 	}
 	chain.assignNewGraphRound(final, cache)
+	chain.State.CacheRound.index[s.Hash] = true
 	return nil
 }