Set height, timestamp, and public key in block builder (iotexproject#1675)

Author: CoderZhi

action/protocol/poll/protocol.go

@@ -81,12 +81,14 @@ func MustGetProtocol(registry *protocol.Registry) Protocol {
 	}
 	p, ok := registry.Find(ProtocolID)
 	if !ok {
-		log.S().Panic("rolldpos protocol is not registered")
+		log.S().Panic("poll protocol is not registered")
 	}
+
 	pp, ok := p.(Protocol)
 	if !ok {
-		log.S().Panic("fail to cast to poll protocol")
+		log.S().Panic("fail to cast poll protocol")
 	}
+
 	return pp
 }
 

api/api_test.go

@@ -1485,8 +1485,11 @@ func TestServer_GetEpochMeta(t *testing.T) {
 				if height > 0 && height <= 4 {
 					pk := identityset.PrivateKey(int(height))
 					blk, err := block.NewBuilder(
-						block.NewRunnableActionsBuilder().SetHeight(height).Build(pk.PublicKey()),
-					).SignAndBuild(pk)
+						block.NewRunnableActionsBuilder().Build(),
+					).
+						SetHeight(height).
+						SetTimestamp(time.Time{}).
+						SignAndBuild(pk)
 					if err != nil {
 						return &block.Header{}, err
 					}

blockchain/block/block.go

@@ -111,13 +111,7 @@ func (b *Block) VerifyReceiptRoot(root hash.Hash256) error {
 
 // RunnableActions abstructs RunnableActions from a Block.
 func (b *Block) RunnableActions() RunnableActions {
-	return RunnableActions{
-		blockHeight:         b.Header.height,
-		blockTimeStamp:      b.Header.timestamp,
-		blockProducerPubKey: b.Header.pubkey,
-		actions:             b.Actions,
-		txHash:              b.txRoot,
-	}
+	return RunnableActions{actions: b.Actions, txHash: b.txRoot}
 }
 
 // Finalize creates a footer for the block

blockchain/block/block_test.go

@@ -199,12 +199,11 @@ func makeBlock(tb testing.TB, n int) *Block {
 		sevlps = append(sevlps, sevlp)
 	}
 	rap := RunnableActionsBuilder{}
-	ra := rap.
-		SetHeight(1).
-		SetTimeStamp(time.Now()).
-		AddActions(sevlps...).
-		Build(identityset.PrivateKey(0).PublicKey())
+	ra := rap.AddActions(sevlps...).
+		Build()
 	blk, err := NewBuilder(ra).
+		SetHeight(1).
+		SetTimestamp(time.Now()).
 		SetVersion(1).
 		SetReceiptRoot(hash.Hash256b([]byte("hello, world!"))).
 		SetDeltaStateDigest(hash.Hash256b([]byte("world, hello!"))).

blockchain/block/builder.go

@@ -7,7 +7,7 @@
 package block
 
 import (
-	"bytes"
+	"time"
 
 	"github.com/iotexproject/go-pkgs/bloom"
 	"github.com/iotexproject/go-pkgs/crypto"
@@ -26,11 +26,8 @@ func NewBuilder(ra RunnableActions) *Builder {
 	return &Builder{
 		blk: Block{
 			Header: Header{
-				version:   version.ProtocolVersion,
-				height:    ra.blockHeight,
-				timestamp: ra.blockTimeStamp,
-				txRoot:    ra.txHash,
-				pubkey:    ra.blockProducerPubKey,
+				version: version.ProtocolVersion,
+				txRoot:  ra.txHash,
 			},
 			Body: Body{
 				Actions: ra.actions,
@@ -39,6 +36,18 @@ func NewBuilder(ra RunnableActions) *Builder {
 	}
 }
 
+// SetTimestamp sets the block timestamp
+func (b *Builder) SetTimestamp(ts time.Time) *Builder {
+	b.blk.Header.timestamp = ts
+	return b
+}
+
+// SetHeight sets the block height
+func (b *Builder) SetHeight(h uint64) *Builder {
+	b.blk.Header.height = h
+	return b
+}
+
 // SetVersion sets the protocol version for block which is building.
 func (b *Builder) SetVersion(v uint32) *Builder {
 	b.blk.Header.version = v
@@ -77,10 +86,7 @@ func (b *Builder) SetLogsBloom(f bloom.BloomFilter) *Builder {
 
 // SignAndBuild signs and then builds a block.
 func (b *Builder) SignAndBuild(signerPrvKey crypto.PrivateKey) (Block, error) {
-	if !bytes.Equal(b.blk.Header.pubkey.Bytes(), signerPrvKey.PublicKey().Bytes()) {
-		return Block{}, errors.New("public key from the signer doesn't match that from runnable actions")
-	}
-
+	b.blk.Header.pubkey = signerPrvKey.PublicKey()
 	h := b.blk.Header.HashHeaderCore()
 	sig, err := signerPrvKey.Sign(h[:])
 	if err != nil {

blockchain/block/builder_test.go

@@ -17,12 +17,11 @@ import (
 )
 
 func TestBuilder(t *testing.T) {
-	ra := NewRunnableActionsBuilder().
-		SetHeight(1).
-		SetTimeStamp(testutil.TimestampNow()).
-		Build(identityset.PrivateKey(29).PublicKey())
+	ra := NewRunnableActionsBuilder().Build()
 
 	nblk, err := NewBuilder(ra).
+		SetHeight(1).
+		SetTimestamp(testutil.TimestampNow()).
 		SetPrevBlockHash(hash.ZeroHash256).
 		SignAndBuild(identityset.PrivateKey(29))
 	require.NoError(t, err)

blockchain/block/runnable.go

@@ -7,36 +7,15 @@
 package block
 
 import (
-	"time"
-
-	"github.com/iotexproject/go-pkgs/crypto"
 	"github.com/iotexproject/go-pkgs/hash"
 
 	"github.com/iotexproject/iotex-core/action"
 )
 
 // RunnableActions is abstructed from block which contains information to execute all actions in a block.
 type RunnableActions struct {
-	blockHeight         uint64
-	blockTimeStamp      time.Time
-	blockProducerPubKey crypto.PublicKey
-	txHash              hash.Hash256
-	actions             []action.SealedEnvelope
-}
-
-// BlockHeight returns block height.
-func (ra RunnableActions) BlockHeight() uint64 {
-	return ra.blockHeight
-}
-
-// BlockTimeStamp returns blockTimeStamp.
-func (ra RunnableActions) BlockTimeStamp() time.Time {
-	return ra.blockTimeStamp
-}
-
-// BlockProducerPubKey return BlockProducerPubKey.
-func (ra RunnableActions) BlockProducerPubKey() crypto.PublicKey {
-	return ra.blockProducerPubKey
+	txHash  hash.Hash256
+	actions []action.SealedEnvelope
 }
 
 // TxHash returns TxHash.
@@ -53,18 +32,6 @@ type RunnableActionsBuilder struct{ ra RunnableActions }
 // NewRunnableActionsBuilder creates a RunnableActionsBuilder.
 func NewRunnableActionsBuilder() *RunnableActionsBuilder { return &RunnableActionsBuilder{} }
 
-// SetHeight sets the block height for block which is building.
-func (b *RunnableActionsBuilder) SetHeight(h uint64) *RunnableActionsBuilder {
-	b.ra.blockHeight = h
-	return b
-}
-
-// SetTimeStamp sets the time stamp for block which is building.
-func (b *RunnableActionsBuilder) SetTimeStamp(ts time.Time) *RunnableActionsBuilder {
-	b.ra.blockTimeStamp = ts
-	return b
-}
-
 // AddActions adds actions for block which is building.
 func (b *RunnableActionsBuilder) AddActions(acts ...action.SealedEnvelope) *RunnableActionsBuilder {
 	if b.ra.actions == nil {
@@ -75,8 +42,7 @@ func (b *RunnableActionsBuilder) AddActions(acts ...action.SealedEnvelope) *Runn
 }
 
 // Build signs and then builds a block.
-func (b *RunnableActionsBuilder) Build(producerPubKey crypto.PublicKey) RunnableActions {
-	b.ra.blockProducerPubKey = producerPubKey
+func (b *RunnableActionsBuilder) Build() RunnableActions {
 	b.ra.txHash = calculateTxRoot(b.ra.actions)
 	return b.ra
 }

blockchain/blockchain.go

@@ -508,10 +508,8 @@ func (bc *blockchain) MintNewBlock(
 
 	sk := bc.config.ProducerPrivateKey()
 	ra := block.NewRunnableActionsBuilder().
-		SetHeight(newblockHeight).
-		SetTimeStamp(timestamp).
 		AddActions(actions...).
-		Build(sk.PublicKey())
+		Build()
 
 	prevBlkHash := bc.tipHash
 	// The first block's previous block hash is pointing to the digest of genesis config. This is to guarantee all nodes
@@ -520,6 +518,8 @@ func (bc *blockchain) MintNewBlock(
 		prevBlkHash = bc.config.Genesis.Hash()
 	}
 	blk, err := block.NewBuilder(ra).
+		SetHeight(newblockHeight).
+		SetTimestamp(timestamp).
 		SetPrevBlockHash(prevBlkHash).
 		SetDeltaStateDigest(ws.Digest()).
 		SetReceipts(rc).
@@ -652,7 +652,7 @@ func (bc *blockchain) startExistingBlockchain() error {
 		if err != nil {
 			return errors.Wrap(err, "failed to obtain working set from state factory")
 		}
-		if _, err := bc.runActions(blk.RunnableActions(), ws); err != nil {
+		if _, err := bc.runActions(blk, ws); err != nil {
 			return err
 		}
 
@@ -718,7 +718,7 @@ func (bc *blockchain) validateBlock(blk *block.Block) error {
 		return errors.Wrap(err, "Failed to obtain working set from state factory")
 	}
 	runTimer := bc.timerFactory.NewTimer("runActions")
-	receipts, err := bc.runActions(blk.RunnableActions(), ws)
+	receipts, err := bc.runActions(blk, ws)
 	runTimer.End()
 	if err != nil {
 		log.L().Panic("Failed to update state.", zap.Uint64("tipHeight", bc.tipHeight), zap.Error(err))
@@ -782,27 +782,27 @@ func (bc *blockchain) commitBlock(blk *block.Block) error {
 }
 
 func (bc *blockchain) runActions(
-	acts block.RunnableActions,
+	blk *block.Block,
 	ws factory.WorkingSet,
 ) ([]*action.Receipt, error) {
 	if bc.sf == nil {
 		return nil, errors.New("statefactory cannot be nil")
 	}
 
-	producer, err := address.FromBytes(acts.BlockProducerPubKey().Hash())
+	producer, err := address.FromBytes(blk.PublicKey().Hash())
 	if err != nil {
 		return nil, err
 	}
 
-	ctx, err := bc.context(context.Background(), producer, acts.BlockHeight(), acts.BlockTimeStamp())
+	ctx, err := bc.context(context.Background(), producer, blk.Height(), blk.Timestamp())
 	if err != nil {
 		return nil, err
 	}
 
 	raCtx := protocol.MustGetRunActionsCtx(ctx)
 	raCtx.History = ws.History()
+	registry := raCtx.Registry
 	ctx = protocol.WithRunActionsCtx(ctx, raCtx)
-	registry := protocol.MustGetRunActionsCtx(ctx).Registry
 	for _, p := range registry.All() {
 		if pp, ok := p.(protocol.PreStatesCreator); ok {
 			if err := pp.CreatePreStates(ctx, ws); err != nil {
@@ -812,7 +812,7 @@ func (bc *blockchain) runActions(
 	}
 	// TODO: verify whether the post system actions are appended tail
 
-	return ws.RunActions(ctx, acts.BlockHeight(), acts.Actions())
+	return ws.RunActions(ctx, blk.Height(), blk.RunnableActions().Actions())
 }
 
 func (bc *blockchain) pickAndRunActions(ctx context.Context, actionMap map[string][]action.SealedEnvelope,

blocksync/blocksync_test.go

@@ -257,7 +257,7 @@ func TestBlockSyncerProcessBlockOutOfOrder(t *testing.T) {
 	cs1.EXPECT().Calibrate(gomock.Any()).Times(3)
 
 	bs1, err := NewBlockSyncer(cfg, chain1, ap1, cs1, opts...)
-	require.Nil(err)
+	require.NoError(err)
 	registry2 := protocol.NewRegistry()
 	require.NoError(registry2.Register(account.ProtocolID, acc))
 	require.NoError(registry2.Register(rolldpos.ProtocolID, rp))
@@ -325,7 +325,7 @@ func TestBlockSyncerProcessBlockSync(t *testing.T) {
 
 	ctx := context.Background()
 	cfg, err := newTestConfig()
-	require.Nil(err)
+	require.NoError(err)
 	registry := protocol.NewRegistry()
 	acc := account.NewProtocol()
 	require.NoError(registry.Register(account.ProtocolID, acc))
@@ -352,7 +352,7 @@ func TestBlockSyncerProcessBlockSync(t *testing.T) {
 	cs1.EXPECT().ValidateBlockFooter(gomock.Any()).Return(nil).Times(3)
 	cs1.EXPECT().Calibrate(gomock.Any()).Times(3)
 	bs1, err := NewBlockSyncer(cfg, chain1, ap1, cs1, opts...)
-	require.Nil(err)
+	require.NoError(err)
 	registry2 := protocol.NewRegistry()
 	require.NoError(registry2.Register(account.ProtocolID, acc))
 	require.NoError(registry2.Register(rolldpos.ProtocolID, rolldposProtocol))

consensus/scheme/rolldpos/rolldpos_test.go

@@ -147,11 +147,10 @@ func makeBlock(t *testing.T, accountIndex, numOfEndosements int, makeInvalidEndo
 	}
 	timeT := time.Unix(blkTime, 0)
 	rap := block.RunnableActionsBuilder{}
-	ra := rap.
-		SetHeight(uint64(height)).
-		SetTimeStamp(timeT).
-		Build(identityset.PrivateKey(accountIndex).PublicKey())
+	ra := rap.Build()
 	blk, err := block.NewBuilder(ra).
+		SetHeight(uint64(height)).
+		SetTimestamp(timeT).
 		SetVersion(1).
 		SetReceiptRoot(hash.Hash256b([]byte("hello, world!"))).
 		SetDeltaStateDigest(hash.Hash256b([]byte("world, hello!"))).