Merge pull request #852 from ava-labs/pre-migration

Pre migration

snow/engine/avalanche/state/unique_vertex.go

@@ -51,18 +51,26 @@ func newUniqueVertex(s *Serializer, b []byte) (*uniqueVertex, error) {
 	if err := innerVertex.Verify(); err != nil {
 		return nil, err
 	}
+
+	unparsedTxs := innerVertex.Txs()
+	txs := make([]snowstorm.Tx, len(unparsedTxs))
+	for i, txBytes := range unparsedTxs {
+		tx, err := vtx.serializer.vm.ParseTx(txBytes)
+		if err != nil {
+			return nil, err
+		}
+		txs[i] = tx
+	}
+
 	vtx.v.vtx = innerVertex
+	vtx.v.txs = txs
 
 	// If the vertex has already been fetched,
 	// skip persisting the vertex.
 	if vtx.v.status.Fetched() {
 		return vtx, nil
 	}
 
-	if _, err := vtx.Txs(); err != nil {
-		return nil, err
-	}
-
 	// The vertex is newly parsed, so set the status
 	// and persist it.
 	vtx.v.status = choices.Processing

snow/engine/avalanche/state/unique_vertex_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/ava-labs/avalanchego/snow/choices"
 	"github.com/ava-labs/avalanchego/snow/consensus/snowstorm"
 	"github.com/ava-labs/avalanchego/snow/engine/avalanche/vertex"
+	"github.com/ava-labs/avalanchego/utils/hashing"
 )
 
 func newSerializer(t *testing.T, parse func([]byte) (snowstorm.Tx, error)) *Serializer {
@@ -281,12 +282,58 @@ func TestParseVertexWithInvalidTxs(t *testing.T) {
 	}
 	vtxBytes := statelessVertex.Bytes()
 
-	s := newSerializer(t, func([]byte) (snowstorm.Tx, error) {
-		return nil, errors.New("invalid tx")
+	s := newSerializer(t, func(b []byte) (snowstorm.Tx, error) {
+		switch {
+		case bytes.Equal(b, []byte{1}):
+			return nil, errors.New("invalid tx")
+		case bytes.Equal(b, []byte{2}):
+			return &snowstorm.TestTx{}, nil
+		default:
+			return nil, errors.New("invalid tx")
+		}
 	})
 
-	_, err = s.ParseVtx(vtxBytes)
-	if err == nil {
+	if _, err := s.ParseVtx(vtxBytes); err == nil {
 		t.Fatal("should have failed to parse the vertex due to invalid transactions")
 	}
+
+	if _, err := s.ParseVtx(vtxBytes); err == nil {
+		t.Fatal("should have failed to parse the vertex after previously error on parsing invalid transactions")
+	}
+
+	vtxID := hashing.ComputeHash256Array(vtxBytes)
+	if _, err := s.GetVtx(vtxID); err == nil {
+		t.Fatal("should have failed to lookup invalid vertex after previously error on parsing invalid transactions")
+	}
+
+	childStatelessVertex, err := vertex.Build(
+		ctx.ChainID,
+		1,
+		0,
+		[]ids.ID{vtxID},
+		[][]byte{{2}},
+		nil,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	childVtxBytes := childStatelessVertex.Bytes()
+
+	childVtx, err := s.ParseVtx(childVtxBytes)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	parents, err := childVtx.Parents()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(parents) != 1 {
+		t.Fatal("wrong number of parents")
+	}
+	parent := parents[0]
+
+	if parent.Status().Fetched() {
+		t.Fatal("the parent is invalid, so it shouldn't be marked as fetched")
+	}
 }