Merge pull request #7748 from onflow/feature/malleability

Feature: Malleability

Author: tim-barry

.golangci.yml

@@ -46,6 +46,12 @@ issues:
     - path: 'utils/unittest/*' # disable some linters on test files
       linters:
         - structwrite
+    - path: 'consensus/hotstuff/helper/*' # disable some linters on test files
+      linters:
+        - structwrite
+    - path: 'engine/execution/testutil/*' # disable some linters on test files
+      linters:
+        - structwrite
     # typecheck currently not handling the way we do function inheritance well
     # disabling for now
     - path: 'cmd/access/node_build/*'

Makefile

@@ -155,7 +155,6 @@ generate-fvm-env-wrappers:
 .PHONY: generate-mocks
 generate-mocks: install-mock-generators
 	mockery --name '(Connector|PingInfoProvider)' --dir=network/p2p --case=underscore --output="./network/mocknetwork" --outpkg="mocknetwork"
-	CGO_CFLAGS=$(CRYPTO_FLAG) mockgen -destination=storage/mocks/storage.go -package=mocks github.com/onflow/flow-go/storage Blocks,Headers,Payloads,Collections,Commits,Events,ServiceEvents,TransactionResults
 	CGO_CFLAGS=$(CRYPTO_FLAG) mockgen -destination=network/mocknetwork/mock_network.go -package=mocknetwork github.com/onflow/flow-go/network EngineRegistry
 	mockery --name=ExecutionDataStore --dir=module/executiondatasync/execution_data --case=underscore --output="./module/executiondatasync/execution_data/mock" --outpkg="mock"
 	mockery --name=Downloader --dir=module/executiondatasync/execution_data --case=underscore --output="./module/executiondatasync/execution_data/mock" --outpkg="mock"

access/legacy/convert/convert.go

@@ -8,7 +8,6 @@ import (
 	"github.com/onflow/crypto/hash"
 	accessproto "github.com/onflow/flow/protobuf/go/flow/legacy/access"
 	entitiesproto "github.com/onflow/flow/protobuf/go/flow/legacy/entities"
-	"google.golang.org/protobuf/types/known/timestamppb"
 
 	"github.com/onflow/flow-go/engine/common/rpc/convert"
 	accessmodel "github.com/onflow/flow-go/model/access"
@@ -18,60 +17,64 @@ import (
 var ErrEmptyMessage = errors.New("protobuf message is empty")
 
 func MessageToTransaction(m *entitiesproto.Transaction, chain flow.Chain) (flow.TransactionBody, error) {
+	var t flow.TransactionBody
 	if m == nil {
-		return flow.TransactionBody{}, ErrEmptyMessage
+		return t, ErrEmptyMessage
 	}
 
-	t := flow.NewTransactionBody()
-
+	tb := flow.NewTransactionBodyBuilder()
 	proposalKey := m.GetProposalKey()
 	if proposalKey != nil {
 		proposalAddress, err := convert.Address(proposalKey.GetAddress(), chain)
 		if err != nil {
-			return *t, err
+			return t, err
 		}
-		t.SetProposalKey(proposalAddress, proposalKey.GetKeyId(), proposalKey.GetSequenceNumber())
+		tb.SetProposalKey(proposalAddress, proposalKey.GetKeyId(), proposalKey.GetSequenceNumber())
 	}
 
 	payer := m.GetPayer()
 	if payer != nil {
 		payerAddress, err := convert.Address(payer, chain)
 		if err != nil {
-			return *t, err
+			return t, err
 		}
-		t.SetPayer(payerAddress)
+		tb.SetPayer(payerAddress)
 	}
 
 	for _, authorizer := range m.GetAuthorizers() {
 		authorizerAddress, err := convert.Address(authorizer, chain)
 		if err != nil {
-			return *t, err
+			return t, err
 		}
-		t.AddAuthorizer(authorizerAddress)
+		tb.AddAuthorizer(authorizerAddress)
 	}
 
 	for _, sig := range m.GetPayloadSignatures() {
 		addr, err := convert.Address(sig.GetAddress(), chain)
 		if err != nil {
-			return *t, err
+			return t, err
 		}
-		t.AddPayloadSignature(addr, sig.GetKeyId(), sig.GetSignature())
+		tb.AddPayloadSignature(addr, sig.GetKeyId(), sig.GetSignature())
 	}
 
 	for _, sig := range m.GetEnvelopeSignatures() {
 		addr, err := convert.Address(sig.GetAddress(), chain)
 		if err != nil {
-			return *t, err
+			return t, err
 		}
-		t.AddEnvelopeSignature(addr, sig.GetKeyId(), sig.GetSignature())
+		tb.AddEnvelopeSignature(addr, sig.GetKeyId(), sig.GetSignature())
 	}
 
-	t.SetScript(m.GetScript())
-	t.SetArguments(m.GetArguments())
-	t.SetReferenceBlockID(flow.HashToID(m.GetReferenceBlockId()))
-	t.SetComputeLimit(m.GetGasLimit())
+	transactionBody, err := tb.SetScript(m.GetScript()).
+		SetArguments(m.GetArguments()).
+		SetReferenceBlockID(flow.HashToID(m.GetReferenceBlockId())).
+		SetComputeLimit(m.GetGasLimit()).
+		Build()
+	if err != nil {
+		return t, fmt.Errorf("could not build transaction body: %w", err)
+	}
 
-	return *t, nil
+	return *transactionBody, nil
 }
 
 func TransactionToMessage(tb flow.TransactionBody) *entitiesproto.Transaction {
@@ -131,22 +134,17 @@ func TransactionResultToMessage(result accessmodel.TransactionResult) *accesspro
 func BlockHeaderToMessage(h *flow.Header) (*entitiesproto.BlockHeader, error) {
 	id := h.ID()
 
-	t := timestamppb.New(h.Timestamp)
-
 	return &entitiesproto.BlockHeader{
 		Id:        id[:],
 		ParentId:  h.ParentID[:],
 		Height:    h.Height,
-		Timestamp: t,
+		Timestamp: convert.BlockTimestamp2ProtobufTime(h.Timestamp),
 	}, nil
 }
 
 func BlockToMessage(h *flow.Block) (*entitiesproto.Block, error) {
 	id := h.ID()
 
-	parentID := h.Header.ParentID
-	t := timestamppb.New(h.Header.Timestamp)
-
 	cg := make([]*entitiesproto.CollectionGuarantee, len(h.Payload.Guarantees))
 	for i, g := range h.Payload.Guarantees {
 		cg[i] = collectionGuaranteeToMessage(g)
@@ -159,22 +157,20 @@ func BlockToMessage(h *flow.Block) (*entitiesproto.Block, error) {
 
 	bh := entitiesproto.Block{
 		Id:                   id[:],
-		Height:               h.Header.Height,
-		ParentId:             parentID[:],
-		Timestamp:            t,
+		Height:               h.Height,
+		ParentId:             h.ParentID[:],
+		Timestamp:            convert.BlockTimestamp2ProtobufTime(h.Timestamp),
 		CollectionGuarantees: cg,
 		BlockSeals:           seals,
-		Signatures:           [][]byte{h.Header.ParentVoterSigData},
+		Signatures:           [][]byte{h.ParentVoterSigData},
 	}
 
 	return &bh, nil
 }
 
 func collectionGuaranteeToMessage(g *flow.CollectionGuarantee) *entitiesproto.CollectionGuarantee {
-	id := g.ID()
-
 	return &entitiesproto.CollectionGuarantee{
-		CollectionId: id[:],
+		CollectionId: IdentifierToMessage(g.CollectionID),
 		Signatures:   [][]byte{g.Signature},
 	}
 }

access/mock/api.go

@@ -122,7 +122,7 @@ func (r *ReadProtocolStateBlocksCommand) Handler(_ context.Context, req *admin.C
 	}
 
 	result = append(result, block)
-	firstHeight := int64(block.Header.Height)
+	firstHeight := int64(block.Height)
 
 	for height := firstHeight - 1; height >= 0 && height > firstHeight-int64(data.numBlocksToQuery); height-- {
 		block, err = r.getBlockByHeight(uint64(height))

admin/commands/common/read_protocol_state_blocks.go

@@ -55,28 +55,28 @@ func (suite *ReadProtocolStateBlocksSuite) SetupTest() {
 
 	var blocks []*flow.Block
 
-	genesis := unittest.GenesisFixture()
+	genesis := unittest.Block.Genesis(flow.Emulator)
 	blocks = append(blocks, genesis)
-	sealed := unittest.BlockWithParentFixture(genesis.Header)
+	sealed := unittest.BlockWithParentFixture(genesis.ToHeader())
 	blocks = append(blocks, sealed)
-	final := unittest.BlockWithParentFixture(sealed.Header)
+	final := unittest.BlockWithParentFixture(sealed.ToHeader())
 	blocks = append(blocks, final)
-	final = unittest.BlockWithParentFixture(final.Header)
+	final = unittest.BlockWithParentFixture(final.ToHeader())
 	blocks = append(blocks, final)
-	final = unittest.BlockWithParentFixture(final.Header)
+	final = unittest.BlockWithParentFixture(final.ToHeader())
 	blocks = append(blocks, final)
 
 	suite.allBlocks = blocks
 	suite.sealed = sealed
 	suite.final = final
 
-	suite.state.On("Final").Return(createSnapshot(final.Header))
-	suite.state.On("Sealed").Return(createSnapshot(sealed.Header))
+	suite.state.On("Final").Return(createSnapshot(final.ToHeader()))
+	suite.state.On("Sealed").Return(createSnapshot(sealed.ToHeader()))
 	suite.state.On("AtBlockID", mock.Anything).Return(
 		func(blockID flow.Identifier) protocol.Snapshot {
 			for _, block := range blocks {
 				if block.ID() == blockID {
-					return createSnapshot(block.Header)
+					return createSnapshot(block.ToHeader())
 				}
 			}
 			return invalid.NewSnapshot(fmt.Errorf("invalid block ID: %v", blockID))
@@ -86,7 +86,7 @@ func (suite *ReadProtocolStateBlocksSuite) SetupTest() {
 		func(height uint64) protocol.Snapshot {
 			if int(height) < len(blocks) {
 				block := blocks[height]
-				return createSnapshot(block.Header)
+				return createSnapshot(block.ToHeader())
 			}
 			return invalid.NewSnapshot(fmt.Errorf("invalid height: %v", height))
 		},

admin/commands/common/read_protocol_state_blocks_test.go

@@ -99,7 +99,7 @@ func TestCommandsSetsValues(t *testing.T) {
 		nil,
 		nil,
 		nil,
-		&flow.Header{Height: 1},
+		&flow.Header{HeaderBody: flow.HeaderBody{Height: 1}},
 		false,
 		false,
 	)