-
Notifications
You must be signed in to change notification settings - Fork 198
/
shardBlock.go
125 lines (107 loc) · 3.35 KB
/
shardBlock.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
package process
import (
"math/big"
"github.com/ElrondNetwork/elrond-go/core"
"github.com/ElrondNetwork/elrond-go/data"
"github.com/ElrondNetwork/elrond-go/data/block"
"github.com/ElrondNetwork/elrond-go/dataRetriever"
"github.com/ElrondNetwork/elrond-go/hashing"
"github.com/ElrondNetwork/elrond-go/marshal"
"github.com/ElrondNetwork/elrond-go/process"
"github.com/ElrondNetwork/elrond-go/sharding"
"github.com/ElrondNetwork/elrond-go/update"
)
// ArgsNewShardBlockCreatorAfterHardFork defines the arguments structure to create a new shard block creator
type ArgsNewShardBlockCreatorAfterHardFork struct {
Hasher hashing.Hasher
ImportHandler update.ImportHandler
Marshalizer marshal.Marshalizer
PendingTxProcessor update.PendingTransactionProcessor
ShardCoordinator sharding.Coordinator
Storage dataRetriever.StorageService
TxCoordinator process.TransactionCoordinator
SelfShardID uint32
}
type shardBlockCreator struct {
*baseProcessor
}
// NewShardBlockCreatorAfterHardFork creates a shard block processor for the first block after hardfork
func NewShardBlockCreatorAfterHardFork(args ArgsNewShardBlockCreatorAfterHardFork) (*shardBlockCreator, error) {
err := checkBlockCreatorAfterHardForkNilParameters(
args.Hasher,
args.ImportHandler,
args.Marshalizer,
args.PendingTxProcessor,
args.ShardCoordinator,
args.Storage,
args.TxCoordinator,
)
if err != nil {
return nil, err
}
base := &baseProcessor{
hasher: args.Hasher,
importHandler: args.ImportHandler,
marshalizer: args.Marshalizer,
pendingTxProcessor: args.PendingTxProcessor,
shardCoordinator: args.ShardCoordinator,
storage: args.Storage,
txCoordinator: args.TxCoordinator,
selfShardID: args.SelfShardID,
}
return &shardBlockCreator{
baseProcessor: base,
}, nil
}
// CreateBlock will create a block after hardfork import
func (s *shardBlockCreator) CreateBlock(
body *block.Body,
chainID string,
round uint64,
nonce uint64,
epoch uint32,
) (data.HeaderHandler, error) {
if len(chainID) == 0 {
return nil, update.ErrEmptyChainID
}
rootHash, err := s.pendingTxProcessor.RootHash()
if err != nil {
return nil, err
}
shardHeader := &block.Header{
Nonce: nonce,
ShardID: s.shardCoordinator.SelfId(),
Round: round,
Epoch: epoch,
ChainID: []byte(chainID),
SoftwareVersion: []byte(""),
RootHash: rootHash,
RandSeed: rootHash,
PrevHash: rootHash,
PrevRandSeed: rootHash,
AccumulatedFees: big.NewInt(0),
DeveloperFees: big.NewInt(0),
PubKeysBitmap: []byte{1},
}
shardHeader.ReceiptsHash, err = s.txCoordinator.CreateReceiptsHash()
if err != nil {
return nil, err
}
totalTxCount, miniBlockHeaders, err := s.createMiniBlockHeaders(body)
if err != nil {
return nil, err
}
shardHeader.MiniBlockHeaders = miniBlockHeaders
shardHeader.TxCount = uint32(totalTxCount)
metaBlockHash, err := core.CalculateHash(s.marshalizer, s.hasher, s.importHandler.GetHardForkMetaBlock())
if err != nil {
return nil, err
}
shardHeader.MetaBlockHashes = [][]byte{metaBlockHash}
s.saveAllBlockDataToStorageForSelfShard(shardHeader, body)
return shardHeader, nil
}
// IsInterfaceNil returns true if underlying object is nil
func (s *shardBlockCreator) IsInterfaceNil() bool {
return s == nil
}