-
Notifications
You must be signed in to change notification settings - Fork 198
/
afterHardFork.go
136 lines (117 loc) · 3.87 KB
/
afterHardFork.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
126
127
128
129
130
131
132
133
134
135
136
package process
import (
"github.com/ElrondNetwork/elrond-go-core/core"
"github.com/ElrondNetwork/elrond-go-core/core/check"
"github.com/ElrondNetwork/elrond-go-core/data"
"github.com/ElrondNetwork/elrond-go-core/data/block"
"github.com/ElrondNetwork/elrond-go-core/hashing"
"github.com/ElrondNetwork/elrond-go-core/marshal"
"github.com/ElrondNetwork/elrond-go/sharding"
"github.com/ElrondNetwork/elrond-go/update"
)
// TODO: save blocks and transactions to storage
// TODO: marshalize if there are cross shard results (smart contract results in special)
// TODO: use new genesis block process, integrate with it
// ArgsAfterHardFork defines the arguments for the new after hard fork process handler
type ArgsAfterHardFork struct {
MapBlockProcessors map[uint32]update.HardForkBlockProcessor
ImportHandler update.ImportHandler
ShardCoordinator sharding.Coordinator
Hasher hashing.Hasher
Marshalizer marshal.Marshalizer
}
type afterHardFork struct {
mapBlockProcessors map[uint32]update.HardForkBlockProcessor
importHandler update.ImportHandler
shardCoordinator sharding.Coordinator
hasher hashing.Hasher
marshalizer marshal.Marshalizer
}
// NewAfterHardForkBlockCreation creates the after hard fork block creator process handler
func NewAfterHardForkBlockCreation(args ArgsAfterHardFork) (*afterHardFork, error) {
if args.MapBlockProcessors == nil {
return nil, update.ErrNilHardForkBlockProcessor
}
if check.IfNil(args.ImportHandler) {
return nil, update.ErrNilImportHandler
}
if check.IfNil(args.Hasher) {
return nil, update.ErrNilHasher
}
if check.IfNil(args.Marshalizer) {
return nil, update.ErrNilMarshalizer
}
if check.IfNil(args.ShardCoordinator) {
return nil, update.ErrNilShardCoordinator
}
return &afterHardFork{
mapBlockProcessors: args.MapBlockProcessors,
importHandler: args.ImportHandler,
shardCoordinator: args.ShardCoordinator,
hasher: args.Hasher,
marshalizer: args.Marshalizer,
}, nil
}
// CreateAllBlocksAfterHardfork creates all the blocks after hardfork
func (a *afterHardFork) CreateAllBlocksAfterHardfork(
chainID string,
round uint64,
nonce uint64,
epoch uint32,
) (map[uint32]data.HeaderHandler, map[uint32]*block.Body, error) {
mapHeaders := make(map[uint32]data.HeaderHandler)
mapBodies := make(map[uint32]*block.Body)
shardIDs := make([]uint32, a.shardCoordinator.NumberOfShards()+1)
for i := uint32(0); i < a.shardCoordinator.NumberOfShards(); i++ {
shardIDs[i] = i
}
shardIDs[a.shardCoordinator.NumberOfShards()] = core.MetachainShardId
args := update.ArgsHardForkProcessor{
Hasher: a.hasher,
Marshalizer: a.marshalizer,
ShardIDs: shardIDs,
MapBodies: mapBodies,
MapHardForkBlockProcessor: a.mapBlockProcessors,
}
lastPostMbs, err := update.CreateBody(args)
if err != nil {
return nil, nil, err
}
args.PostMbs = lastPostMbs
err = update.CreatePostMiniBlocks(args)
if err != nil {
return nil, nil, err
}
err = a.createHeaders(shardIDs, mapBodies, mapHeaders, chainID, round, nonce, epoch)
if err != nil {
return nil, nil, err
}
return mapHeaders, mapBodies, nil
}
func (a *afterHardFork) createHeaders(
shardIDs []uint32,
mapBodies map[uint32]*block.Body,
mapHeaders map[uint32]data.HeaderHandler,
chainID string,
round uint64,
nonce uint64,
epoch uint32,
) error {
for _, shardID := range shardIDs {
log.Debug("afterHardFork.createHeader", "shard", shardID)
blockProcessor, ok := a.mapBlockProcessors[shardID]
if !ok {
return update.ErrNilHardForkBlockProcessor
}
hdr, err := blockProcessor.CreateBlock(mapBodies[shardID], chainID, round, nonce, epoch)
if err != nil {
return err
}
mapHeaders[shardID] = hdr
}
return nil
}
// IsInterfaceNil returns true if underlying object is nil
func (a *afterHardFork) IsInterfaceNil() bool {
return a == nil
}