use common block prev hash (#258)

* use common block prev hash

Signed-off-by: Hagar Meir <[email protected]>

* sign over common block headers

Signed-off-by: Hagar Meir <[email protected]>

* address review comments

Signed-off-by: Hagar Meir <[email protected]>

---------

Signed-off-by: Hagar Meir <[email protected]>

Author: HagarMeir

node/assembler/oba_utils_test.go

@@ -29,6 +29,7 @@ func NewOrderedBatchAttestationCreator() (*OrderedBatchAttestationCreator, *stat
 	ba := &state.AvailableBatchOrdered{
 		AvailableBatch: state.NewAvailableBatch(0, math.MaxUint16, 0, genesisDigest),
 		OrderingInformation: &state.OrderingInformation{
+			CommonBlock: &common.Block{Header: &common.BlockHeader{Number: 0, PreviousHash: nil, DataHash: genesisDigest}},
 			BlockHeader: &state.BlockHeader{
 				Number:   0,
 				PrevHash: nil,
@@ -41,7 +42,7 @@ func NewOrderedBatchAttestationCreator() (*OrderedBatchAttestationCreator, *stat
 	}
 	orderedBatchAttestationCreator := &OrderedBatchAttestationCreator{
 		prevBa:     ba,
-		headerHash: calculateHeaderHash(ba.OrderingInformation.BlockHeader),
+		headerHash: protoutil.BlockHeaderHash(ba.OrderingInformation.CommonBlock.Header),
 	}
 	return orderedBatchAttestationCreator, ba
 }
@@ -58,22 +59,13 @@ func (obac *OrderedBatchAttestationCreator) Append(batchId types.BatchID, decisi
 				PrevHash: obac.headerHash,
 				Digest:   batchId.Digest(),
 			},
-			CommonBlock: &common.Block{Header: &common.BlockHeader{Number: uint64(decisionNum), DataHash: batchId.Digest()}},
+			CommonBlock: &common.Block{Header: &common.BlockHeader{Number: uint64(decisionNum), PreviousHash: obac.headerHash, DataHash: batchId.Digest()}},
 			DecisionNum: decisionNum,
 			BatchIndex:  batchIndex,
 			BatchCount:  batchCount,
 		},
 	}
-	obac.headerHash = calculateHeaderHash(ba.OrderingInformation.BlockHeader)
+	obac.headerHash = protoutil.BlockHeaderHash(ba.OrderingInformation.CommonBlock.Header)
 	obac.prevBa = ba
 	return ba
 }
-
-func calculateHeaderHash(bh *state.BlockHeader) []byte {
-	header := &common.BlockHeader{
-		Number:       bh.Number,
-		PreviousHash: bh.PrevHash,
-		DataHash:     bh.Digest,
-	}
-	return protoutil.BlockHeaderHash(header)
-}

node/assembler/stub_consenter_test.go

@@ -135,7 +135,7 @@ func (sc *stubConsenter) SetNextDecision(ba *state.AvailableBatchOrdered) {
 				Batch:  ba.AvailableBatch,
 				Header: ba.OrderingInformation.BlockHeader,
 			}},
-			AvailableCommonBlocks: []*common.Block{{Header: &common.BlockHeader{Number: ba.OrderingInformation.BlockHeader.Number, DataHash: ba.OrderingInformation.BlockHeader.Digest}}},
+			AvailableCommonBlocks: []*common.Block{ba.OrderingInformation.CommonBlock},
 		}).Serialize(),
 	}
 
@@ -149,10 +149,7 @@ func (sc *stubConsenter) SetNextDecision(ba *state.AvailableBatchOrdered) {
 	bytes := state.DecisionToBytes(proposal, signatures)
 
 	sc.decisions <- &common.Block{
-		Header: &common.BlockHeader{
-			Number:       uint64(ba.OrderingInformation.DecisionNum),
-			PreviousHash: ba.OrderingInformation.PrevHash,
-		},
-		Data: &common.BlockData{Data: [][]byte{bytes}},
+		Header: ba.OrderingInformation.CommonBlock.Header,
+		Data:   &common.BlockData{Data: [][]byte{bytes}},
 	}
 }

node/consensus/consensus.go

@@ -10,9 +10,9 @@ import (
 	"bytes"
 	"encoding/asn1"
 	"encoding/base64"
+	"encoding/hex"
 	"fmt"
 	"io"
-	"math"
 	"math/rand"
 	"sync"
 
@@ -28,6 +28,7 @@ import (
 	"github.com/hyperledger/fabric-x-orderer/node/consensus/state"
 	"github.com/hyperledger/fabric-x-orderer/node/delivery"
 	protos "github.com/hyperledger/fabric-x-orderer/node/protos/comm"
+	"github.com/hyperledger/fabric/protoutil"
 	"github.com/pkg/errors"
 	"google.golang.org/protobuf/proto"
 )
@@ -176,10 +177,12 @@ func (c *Consensus) VerifyProposal(proposal smartbft_types.Proposal) ([]smartbft
 	c.stateLock.Unlock()
 
 	availableBlocks := make([]state.AvailableBlock, len(attestations))
+	availableCommonBlocks := make([]*common.Block, len(attestations))
+
 	for i, ba := range attestations {
 		availableBlocks[i].Batch = state.NewAvailableBatch(ba[0].Primary(), ba[0].Shard(), ba[0].Seq(), ba[0].Digest())
 		if !bytes.Equal(hdr.AvailableCommonBlocks[i].Header.DataHash, ba[0].Digest()) {
-			return nil, fmt.Errorf("proposed available common block data hash in index %d isn't equal to computed digest", i)
+			return nil, fmt.Errorf("proposed available common block %s data hash in index %d isn't equal to computed digest %s", arma_types.CommonBlockToString(hdr.AvailableCommonBlocks[i]), i, arma_types.BatchIDToString(ba[0]))
 		}
 	}
 
@@ -189,24 +192,28 @@ func (c *Consensus) VerifyProposal(proposal smartbft_types.Proposal) ([]smartbft
 		}
 	}
 
-	var lastBlockHeader state.BlockHeader
-	if err := lastBlockHeader.FromBytes(computedState.AppContext); err != nil {
-		c.Logger.Panicf("Failed deserializing app context to BlockHeader from state: %v", err)
+	lastCommonBlockHeader := &common.BlockHeader{}
+	if err := proto.Unmarshal(computedState.AppContext, lastCommonBlockHeader); err != nil {
+		c.Logger.Panicf("Failed unmarshaling app context to block header from state: %v", err)
 	}
 
-	lastBlockNumber := lastBlockHeader.Number
-	prevHash := lastBlockHeader.Hash()
-	if lastBlockNumber == math.MaxUint64 { // This is a signal that we bootstrap
-		prevHash = nil
-	}
+	lastBlockNumber := lastCommonBlockHeader.Number
+	prevHash := protoutil.BlockHeaderHash(lastCommonBlockHeader)
 
 	for i, ba := range attestations {
 		var bh state.BlockHeader
 		bh.Digest = ba[0].Digest()
 		lastBlockNumber++
+
+		if hex.EncodeToString(hdr.AvailableCommonBlocks[i].Header.PreviousHash) != hex.EncodeToString(prevHash) {
+			return nil, fmt.Errorf("proposed common block header prev hash %s in index %d isn't equal to computed prev hash %s, last block number is %d", hex.EncodeToString(hdr.AvailableCommonBlocks[i].Header.PreviousHash), i, hex.EncodeToString(prevHash), lastBlockNumber)
+		}
+
+		availableCommonBlocks[i] = protoutil.NewBlock(lastBlockNumber, prevHash)
+		availableCommonBlocks[i].Header.DataHash = ba[0].Digest()
 		bh.Number = lastBlockNumber
 		bh.PrevHash = prevHash
-		prevHash = bh.Hash()
+		prevHash = protoutil.BlockHeaderHash(availableCommonBlocks[i].Header)
 		availableBlocks[i].Header = &bh
 
 		if hdr.AvailableCommonBlocks[i].Header.Number != lastBlockNumber {
@@ -223,7 +230,7 @@ func (c *Consensus) VerifyProposal(proposal smartbft_types.Proposal) ([]smartbft
 	}
 
 	if len(attestations) > 0 {
-		computedState.AppContext = availableBlocks[len(attestations)-1].Header.Bytes()
+		computedState.AppContext = protoutil.MarshalOrPanic(availableCommonBlocks[len(attestations)-1].Header)
 	}
 
 	if !bytes.Equal(hdr.State.Serialize(), computedState.Serialize()) {
@@ -285,10 +292,10 @@ func (c *Consensus) VerifyConsenterSig(signature smartbft_types.Signature, prop
 		return nil, errors.Wrap(err, "failed deserializing proposal header")
 	}
 
-	for i, bh := range hdr.AvailableBlocks {
+	for i, bh := range hdr.AvailableCommonBlocks {
 		if err := c.VerifySignature(smartbft_types.Signature{
 			Value: values[i+1],
-			Msg:   bh.Header.Bytes(),
+			Msg:   protoutil.BlockHeaderBytes(bh.Header),
 			ID:    signature.ID,
 		}); err != nil {
 			return nil, errors.Wrap(err, "failed verifying signature over block header")
@@ -393,9 +400,9 @@ func (c *Consensus) SignProposal(proposal smartbft_types.Proposal, _ []byte) *sm
 
 	sigs = append(sigs, proposalSig)
 
-	for _, bh := range hdr.AvailableBlocks {
-		msg := bh.Header.Bytes()
-		sig, err := c.Signer.Sign(msg)
+	for _, bh := range hdr.AvailableCommonBlocks {
+		msg := protoutil.BlockHeaderBytes(bh.Header)
+		sig, err := c.Signer.Sign(msg) // TODO sign like we do in Fabric
 		if err != nil {
 			c.Logger.Panicf("Failed signing block header: %v", err)
 		}
@@ -422,13 +429,13 @@ func (c *Consensus) AssembleProposal(metadata []byte, requests [][]byte) smartbf
 	newState, attestations := c.Arma.SimulateStateTransition(c.State, requests)
 	c.stateLock.Unlock()
 
-	var lastBlockHeader state.BlockHeader
-	if err := lastBlockHeader.FromBytes(newState.AppContext); err != nil {
-		c.Logger.Panicf("Failed deserializing app context to BlockHeader from state: %v", err)
+	lastCommonBlockHeader := &common.BlockHeader{}
+	if err := proto.Unmarshal(newState.AppContext, lastCommonBlockHeader); err != nil {
+		c.Logger.Panicf("Failed unmarshaling app context to block header from state: %v", err)
 	}
 
-	lastBlockNumber := lastBlockHeader.Number
-	prevHash := lastBlockHeader.Hash()
+	lastBlockNumber := lastCommonBlockHeader.Number
+	prevHash := protoutil.BlockHeaderHash(lastCommonBlockHeader)
 
 	c.Logger.Infof("Creating proposal with %d attestations", len(attestations))
 
@@ -437,22 +444,22 @@ func (c *Consensus) AssembleProposal(metadata []byte, requests [][]byte) smartbf
 
 	for i, ba := range attestations {
 		availableBlocks[i].Batch = state.NewAvailableBatch(ba[0].Primary(), ba[0].Shard(), ba[0].Seq(), ba[0].Digest())
-		availableCommonBlocks[i] = &common.Block{Header: &common.BlockHeader{DataHash: ba[0].Digest()}}
 	}
 
 	for i, ba := range attestations {
 		var hdr state.BlockHeader
 		hdr.Digest = ba[0].Digest()
 		lastBlockNumber++
+		availableCommonBlocks[i] = protoutil.NewBlock(lastBlockNumber, prevHash)
+		availableCommonBlocks[i].Header.DataHash = ba[0].Digest()
 		hdr.Number = lastBlockNumber
 		hdr.PrevHash = prevHash
-		prevHash = hdr.Hash()
+		prevHash = protoutil.BlockHeaderHash(availableCommonBlocks[i].Header)
 		availableBlocks[i].Header = &hdr
-		availableCommonBlocks[i].Header.Number = lastBlockNumber
 	}
 
 	if len(attestations) > 0 {
-		newState.AppContext = availableBlocks[len(attestations)-1].Header.Bytes()
+		newState.AppContext = protoutil.MarshalOrPanic(availableCommonBlocks[len(attestations)-1].Header)
 	}
 
 	md := &smartbftprotos.ViewMetadata{}

node/consensus/consensus_builder.go

@@ -250,13 +250,12 @@ func initialStateFromConfig(config *config.ConsenterNodeConfig) *state.State {
 		return int(initState.Shards[i].Shard) < int(initState.Shards[j].Shard)
 	})
 
-	// TODO set right initial app context
-	initialAppContext := &state.BlockHeader{
-		Number:   0, // We want the first block to start with 0, this is how we signal bootstrap
-		PrevHash: nil,
-		Digest:   nil,
+	initialAppContext := &common.BlockHeader{
+		Number:       0, // We want the first block to start with 0, this is how we signal bootstrap
+		PreviousHash: nil,
+		DataHash:     nil,
 	}
-	initState.AppContext = initialAppContext.Bytes()
+	initState.AppContext = protoutil.MarshalOrPanic(initialAppContext)
 
 	return &initState
 }
@@ -274,21 +273,24 @@ func appendGenesisBlock(genesisBlock *common.Block, initState *state.State, ledg
 		Batch: state.NewAvailableBatch(0, arma_types.ShardIDConsensus, 0, genesisDigest),
 	}
 
-	var lastBlockHeader state.BlockHeader
-	if err := lastBlockHeader.FromBytes(initState.AppContext); err != nil {
-		panic(fmt.Sprintf("Failed deserializing app context to BlockHeader from initial state: %v", err))
+	lastCommonBlockHeader := &common.BlockHeader{}
+	if err := proto.Unmarshal(initState.AppContext, lastCommonBlockHeader); err != nil {
+		panic(fmt.Sprintf("Failed unmarshaling app context to BlockHeader from initial state: %v", err))
 	}
-	lastBlockHeader.Digest = genesisDigest
-	initState.AppContext = lastBlockHeader.Bytes()
+
+	lastCommonBlockHeader.DataHash = genesisDigest
+
+	initState.AppContext = protoutil.MarshalOrPanic(lastCommonBlockHeader)
 
 	genesisProposal := smartbft_types.Proposal{
-		Payload: protoutil.MarshalOrPanic(genesisBlock), // TODO create a correct payload
+		Payload: protoutil.MarshalOrPanic(genesisBlock),
 		Header: (&state.Header{
-			AvailableBlocks: genesisBlocks,
-			State:           initState,
-			Num:             0,
+			AvailableCommonBlocks: []*common.Block{genesisBlock},
+			AvailableBlocks:       genesisBlocks,
+			State:                 initState,
+			Num:                   0,
 		}).Serialize(),
-		Metadata: nil, // TODO maybe use this metadata
+		Metadata: nil,
 	}
 
 	ledger.Append(state.DecisionToBytes(genesisProposal, nil))