forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-06-19 21:31:37 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #1493 from XinFinOrg/fix-rewardhash

Browse source 
fix: XDPoS_v2 save reward file during Seal for block miner for v2 engine
This commit is contained in:
Wanwiset Peerapatanapokin 2025-09-23 12:49:12 +04:00 committed by GitHub
commit 53e5601825
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
1 changed files with 104 additions and 8 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

112
consensus/XDPoS/engines/engine_v2/engine.go
View file

@ -7,6 +7,7 @@ import (
"math/big"
"os"
"path/filepath"
"strconv"
"sync"
"time"
@ -66,6 +67,9 @@ type XDPoS_v2 struct {
highestTimeoutCert *types.TimeoutCert
highestCommitBlock *types.BlockInfo
latestReward map[string]interface{}
latestRewardBlocknum uint64
HookReward func(chain consensus.ChainReader, state *state.StateDB, parentState *state.StateDB, header *types.Header) (map[string]interface{}, error)
HookPenalty func(chain consensus.ChainReader, number *big.Int, parentHash common.Hash, candidates []common.Address) ([]common.Address, error)
@ -402,14 +406,34 @@ func (x *XDPoS_v2) Finalize(chain consensus.ChainReader, header *types.Header, s
if err != nil {
return nil, err
}
if len(common.StoreRewardFolder) > 0 {
data, err := json.Marshal(rewards)
if err == nil {
err = os.WriteFile(filepath.Join(common.StoreRewardFolder, header.Number.String()+"."+header.Hash().Hex()), data, 0644)
}
if err != nil {
log.Error("Error when save reward info ", "number", header.Number, "hash", header.Hash().Hex(), "err", err)
}
x.signLock.RLock()
signer := x.signer
x.signLock.RUnlock()
x.lock.Lock()
x.latestRewardBlocknum = header.Number.Uint64()
x.latestReward, err = deepCloneJSON(rewards)
x.lock.Unlock()
if err != nil {
log.Error("[Finalize] Error deep cloning latest reward", "err", err, "rewards", rewards)
return nil, err
}
var decodedExtraField types.ExtraFields_v2
err = utils.DecodeBytesExtraFields(header.Extra, &decodedExtraField)
if err != nil {
log.Error("[Finalize] Error when decode extra field to get the round number", "Hash", header.Hash().Hex(), "Number", header.Number.Uint64(), "Error", err)
}
parentHeader := chain.GetHeaderByHash(header.ParentHash)
isMyTurn, err := x.yourturn(chain, decodedExtraField.Round, parentHeader, signer)
if err != nil {
log.Error("[Finalize] Error checking myturn", "err", err, "round", decodedExtraField.Round, "signer", signer, "parentHeader", parentHeader)
return nil, err
}
if !isMyTurn { // if myturn use Seal to save file
x.saveRewardToFile(header.Hash(), header.Number.Uint64())
}
}
@ -470,6 +494,24 @@ func (x *XDPoS_v2) Seal(chain consensus.ChainReader, block *types.Block, stop <-
log.Error("[Seal] Error when decode extra field to get the round number from v2 block during sealing", "Hash", header.Hash().Hex(), "Number", header.Number.Uint64(), "Error", err)
return nil, err
}
isEpochSwitch, _, err := x.IsEpochSwitch(header)
if err != nil {
log.Error("[Seal] IsEpochSwitch bug!", "err", err)
return nil, err
}
if isEpochSwitch {
parentHeader := chain.GetHeaderByHash(header.ParentHash)
isMyTurn, err := x.yourturn(chain, decodedExtraField.Round, parentHeader, signer)
if err != nil {
log.Error("[Seal] Error checking myturn", "err", err, "round", decodedExtraField.Round, "signer", signer, "parentHeader", parentHeader)
return nil, err
}
if isMyTurn { // if not myturn use Finalize to save file
x.saveRewardToFile(header.Hash(), header.Number.Uint64())
}
}
x.highestSelfMinedRound = decodedExtraField.Round
return block.WithSeal(header), nil
@ -1017,3 +1059,57 @@ func (x *XDPoS_v2) periodicJob() {
func (x *XDPoS_v2) GetLatestCommittedBlockInfo() *types.BlockInfo {
return x.highestCommitBlock
}
func (x *XDPoS_v2) saveRewardToFile(blockHash common.Hash, blockNumber uint64) {
if len(common.StoreRewardFolder) == 0 {
log.Info("[saveRewardToFile] Skip saving reward to file", "len(common.StoreRewardFolder)", len(common.StoreRewardFolder))
return
}
x.lock.RLock()
rewardsBlocknum := x.latestRewardBlocknum
rewards, err := deepCloneJSON(x.latestReward)
x.lock.RUnlock()
if err != nil {
log.Error("[saveRewardToFile] Error deep cloning latest reward", "err", err)
return
}
if rewardsBlocknum != blockNumber {
log.Error("[saveRewardToFile] Error blocknumber mismatch with latest reward state, this should not happen!!", "rewardsBlocknum", rewardsBlocknum, "blockNumber", blockNumber)
return
}
data, err := json.Marshal(rewards)
if err != nil {
log.Error("[saveRewardToFile] Error Marshalling rewards", "err", err, "rewards", rewards)
return
}
filename := strconv.FormatUint(blockNumber, 10) + "." + blockHash.Hex()
err = os.WriteFile(filepath.Join(common.StoreRewardFolder, filename), data, 0644)
if err != nil {
log.Error("[saveRewardToFile] Error when writing reward info", "filename", filename, "rewards", string(data), "err", err)
return
}
log.Debug("[saveRewardToFile] Saved rewards", "filename", filename)
log.Debug("[saveRewardToFile] Saved rewards", "rewards", string(data))
return
}
func deepCloneJSON(original map[string]interface{}) (map[string]interface{}, error) {
data, err := json.Marshal(original)
if err != nil {
return nil, fmt.Errorf("failed to marshal: %w", err)
}
var cloned map[string]interface{}
err = json.Unmarshal(data, &cloned)
if err != nil {
return nil, fmt.Errorf("failed to unmarshal: %w", err)
}
return cloned, nil
}