mirror of
https://gitlab.com/pulsechaincom/erigon-pulse.git
synced 2024-12-25 13:07:17 +00:00
17b2a9ba93
* Integration to work with bor * Turn off validator set check * disable verifySeal, add skeleton of postExec stage * Pass around syscall * Print * Print more * Default heimdall values for integration * restore contract * Print * Print * Print * Print * Print * Print * Print * Print * Fix nonce of system contract * Remove prints * Revert some more printing * More fixes * Print log * Fix transfer log * More printing * More printing * Print * Print * Print * Print * Print * Print * Print * Fix validaor reward * Remove printing * Remove more prints * Less printing * Fetch validators from heimdall * Remove syscall from Seal and CalcDifficulty * Remove syscall from Prepare * Print * Remove DNS discovery * Print apply snapshot * Print * Chunk up snapshot generation * Chunk up snapshot generation * Better logs when snapshotting * Handle parents * Prevent shadowing of snap * Fix heimdall fetch * Logging fixes * Save generated snapshots * Add header * Less logging Co-authored-by: Alexey Sharp <alexeysharp@Alexeys-iMac.local> Co-authored-by: Alex Sharp <alexsharp@Alexs-MacBook-Pro.local>
464 lines
17 KiB
Go
464 lines
17 KiB
Go
// Copyright 2014 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
// Package core implements the Ethereum consensus protocol.
|
|
package core
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"sort"
|
|
"time"
|
|
|
|
"github.com/ledgerwatch/erigon/core/systemcontracts"
|
|
|
|
metrics2 "github.com/VictoriaMetrics/metrics"
|
|
"github.com/ledgerwatch/log/v3"
|
|
|
|
"github.com/ledgerwatch/erigon/common"
|
|
"github.com/ledgerwatch/erigon/common/mclock"
|
|
"github.com/ledgerwatch/erigon/common/u256"
|
|
"github.com/ledgerwatch/erigon/consensus"
|
|
"github.com/ledgerwatch/erigon/consensus/misc"
|
|
"github.com/ledgerwatch/erigon/core/state"
|
|
"github.com/ledgerwatch/erigon/core/types"
|
|
"github.com/ledgerwatch/erigon/core/types/accounts"
|
|
"github.com/ledgerwatch/erigon/core/vm"
|
|
"github.com/ledgerwatch/erigon/params"
|
|
)
|
|
|
|
var (
|
|
blockExecutionTimer = metrics2.GetOrCreateSummary("chain_execution_seconds")
|
|
)
|
|
|
|
const (
|
|
TriesInMemory = 128
|
|
)
|
|
|
|
// statsReportLimit is the time limit during import and export after which we
|
|
// always print out progress. This avoids the user wondering what's going on.
|
|
const statsReportLimit = 8 * time.Second
|
|
|
|
// report prints statistics if some number of blocks have been processed
|
|
// or more than a few seconds have passed since the last message.
|
|
func (st *InsertStats) Report(logPrefix string, chain []*types.Block, index int, toCommit bool) {
|
|
// Fetch the timings for the batch
|
|
var (
|
|
now = mclock.Now()
|
|
elapsed = time.Duration(now) - time.Duration(st.StartTime)
|
|
)
|
|
// If we're at the last block of the batch or report period reached, log
|
|
if index == len(chain)-1 || elapsed >= statsReportLimit || toCommit {
|
|
// Count the number of transactions in this segment
|
|
var txs int
|
|
for _, block := range chain[st.lastIndex : index+1] {
|
|
txs += len(block.Transactions())
|
|
}
|
|
end := chain[index]
|
|
context := []interface{}{
|
|
"blocks", st.Processed, "txs", txs,
|
|
"elapsed", common.PrettyDuration(elapsed),
|
|
"number", end.Number(), "hash", end.Hash(),
|
|
}
|
|
if timestamp := time.Unix(int64(end.Time()), 0); time.Since(timestamp) > time.Minute {
|
|
context = append(context, []interface{}{"age", common.PrettyAge(timestamp)}...)
|
|
}
|
|
if st.queued > 0 {
|
|
context = append(context, []interface{}{"queued", st.queued}...)
|
|
}
|
|
if st.ignored > 0 {
|
|
context = append(context, []interface{}{"ignored", st.ignored}...)
|
|
}
|
|
log.Info(fmt.Sprintf("[%s] Imported new chain segment", logPrefix), context...)
|
|
*st = InsertStats{StartTime: now, lastIndex: index + 1}
|
|
}
|
|
}
|
|
|
|
// ExecuteBlockEphemerally runs a block from provided stateReader and
|
|
// writes the result to the provided stateWriter
|
|
func ExecuteBlockEphemerallyForBSC(
|
|
chainConfig *params.ChainConfig,
|
|
vmConfig *vm.Config,
|
|
getHeader func(hash common.Hash, number uint64) *types.Header,
|
|
engine consensus.Engine,
|
|
block *types.Block,
|
|
stateReader state.StateReader,
|
|
stateWriter state.WriterWithChangeSets,
|
|
epochReader consensus.EpochReader,
|
|
chainReader consensus.ChainHeaderReader,
|
|
contractHasTEVM func(codeHash common.Hash) (bool, error),
|
|
) (types.Receipts, error) {
|
|
defer blockExecutionTimer.UpdateDuration(time.Now())
|
|
block.Uncles()
|
|
ibs := state.New(stateReader)
|
|
header := block.Header()
|
|
var receipts types.Receipts
|
|
usedGas := new(uint64)
|
|
gp := new(GasPool)
|
|
gp.AddGas(block.GasLimit())
|
|
|
|
if !vmConfig.ReadOnly {
|
|
if err := InitializeBlockExecution(engine, chainReader, epochReader, block.Header(), block.Transactions(), block.Uncles(), chainConfig, ibs); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if chainConfig.DAOForkSupport && chainConfig.DAOForkBlock != nil && chainConfig.DAOForkBlock.Cmp(block.Number()) == 0 {
|
|
misc.ApplyDAOHardFork(ibs)
|
|
}
|
|
systemcontracts.UpgradeBuildInSystemContract(chainConfig, header.Number, ibs)
|
|
noop := state.NewNoopWriter()
|
|
posa, isPoSA := engine.(consensus.PoSA)
|
|
//fmt.Printf("====txs processing start: %d====\n", block.NumberU64())
|
|
for i, tx := range block.Transactions() {
|
|
if isPoSA {
|
|
if isSystemTx, err := posa.IsSystemTransaction(tx, block.Header()); err != nil {
|
|
return nil, err
|
|
} else if isSystemTx {
|
|
continue
|
|
}
|
|
}
|
|
ibs.Prepare(tx.Hash(), block.Hash(), i)
|
|
writeTrace := false
|
|
if vmConfig.Debug && vmConfig.Tracer == nil {
|
|
vmConfig.Tracer = vm.NewStructLogger(&vm.LogConfig{})
|
|
writeTrace = true
|
|
}
|
|
|
|
receipt, _, err := ApplyTransaction(chainConfig, getHeader, engine, nil, gp, ibs, noop, header, tx, usedGas, *vmConfig, contractHasTEVM)
|
|
if writeTrace {
|
|
w, err1 := os.Create(fmt.Sprintf("txtrace_%x.txt", tx.Hash()))
|
|
if err1 != nil {
|
|
panic(err1)
|
|
}
|
|
encoder := json.NewEncoder(w)
|
|
logs := FormatLogs(vmConfig.Tracer.(*vm.StructLogger).StructLogs())
|
|
if err2 := encoder.Encode(logs); err2 != nil {
|
|
panic(err2)
|
|
}
|
|
if err2 := w.Close(); err2 != nil {
|
|
panic(err2)
|
|
}
|
|
vmConfig.Tracer = nil
|
|
}
|
|
if err != nil {
|
|
return nil, fmt.Errorf("could not apply tx %d from block %d [%v]: %w", i, block.NumberU64(), tx.Hash().Hex(), err)
|
|
}
|
|
if !vmConfig.NoReceipts {
|
|
receipts = append(receipts, receipt)
|
|
}
|
|
}
|
|
|
|
var newBlock *types.Block
|
|
if !vmConfig.ReadOnly {
|
|
// We're doing this hack for BSC to avoid changing consensus interfaces a lot. BSC modifies txs and receipts by appending
|
|
// system transactions, and they increase used gas and write cumulative gas to system receipts, that's why we need
|
|
// to deduct system gas before. This line is equal to "blockGas-systemGas", but since we don't know how much gas is
|
|
// used by system transactions we just override. Of course, we write used by block gas back. It also always true
|
|
// that used gas by block is always equal to original's block header gas, and it's checked by receipts root verification
|
|
// otherwise it causes block verification error.
|
|
header.GasUsed = *usedGas
|
|
syscall := func(contract common.Address, data []byte) ([]byte, error) {
|
|
return SysCallContract(contract, data, *chainConfig, ibs, header, engine)
|
|
}
|
|
outTxs, outReceipts, err := engine.Finalize(chainConfig, header, ibs, block.Transactions(), block.Uncles(), receipts, epochReader, chainReader, syscall)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
*usedGas = header.GasUsed
|
|
|
|
// We need repack this block because transactions and receipts might be changed by consensus, and
|
|
// it won't pass receipts hash or bloom verification
|
|
newBlock = types.NewBlock(block.Header(), outTxs, block.Uncles(), outReceipts)
|
|
// Update receipts
|
|
if !vmConfig.NoReceipts {
|
|
receipts = outReceipts
|
|
}
|
|
} else {
|
|
newBlock = block
|
|
}
|
|
|
|
if chainConfig.IsByzantium(header.Number.Uint64()) && !vmConfig.NoReceipts {
|
|
if newBlock.ReceiptHash() != block.ReceiptHash() {
|
|
return nil, fmt.Errorf("mismatched receipt headers for block %d (%s != %s)", block.NumberU64(), newBlock.ReceiptHash().Hex(), block.Header().ReceiptHash.Hex())
|
|
}
|
|
}
|
|
if newBlock.GasUsed() != header.GasUsed {
|
|
return nil, fmt.Errorf("gas used by execution: %d, in header: %d", *usedGas, header.GasUsed)
|
|
}
|
|
if !vmConfig.NoReceipts {
|
|
if newBlock.Bloom() != header.Bloom {
|
|
return nil, fmt.Errorf("bloom computed by execution: %x, in header: %x", newBlock.Bloom(), header.Bloom)
|
|
}
|
|
}
|
|
|
|
if err := ibs.CommitBlock(chainConfig.Rules(header.Number.Uint64()), stateWriter); err != nil {
|
|
return nil, fmt.Errorf("committing block %d failed: %w", header.Number.Uint64(), err)
|
|
} else if err := stateWriter.WriteChangeSets(); err != nil {
|
|
return nil, fmt.Errorf("writing changesets for block %d failed: %w", header.Number.Uint64(), err)
|
|
}
|
|
|
|
return receipts, nil
|
|
}
|
|
|
|
// ExecuteBlockEphemerally runs a block from provided stateReader and
|
|
// writes the result to the provided stateWriter
|
|
func ExecuteBlockEphemerally(
|
|
chainConfig *params.ChainConfig,
|
|
vmConfig *vm.Config,
|
|
getHeader func(hash common.Hash, number uint64) *types.Header,
|
|
engine consensus.Engine,
|
|
block *types.Block,
|
|
stateReader state.StateReader,
|
|
stateWriter state.WriterWithChangeSets,
|
|
epochReader consensus.EpochReader,
|
|
chainReader consensus.ChainHeaderReader,
|
|
contractHasTEVM func(codeHash common.Hash) (bool, error),
|
|
) (types.Receipts, *types.ReceiptForStorage, error) {
|
|
defer blockExecutionTimer.UpdateDuration(time.Now())
|
|
block.Uncles()
|
|
ibs := state.New(stateReader)
|
|
header := block.Header()
|
|
var receipts types.Receipts
|
|
usedGas := new(uint64)
|
|
gp := new(GasPool)
|
|
gp.AddGas(block.GasLimit())
|
|
|
|
if !vmConfig.ReadOnly {
|
|
if err := InitializeBlockExecution(engine, chainReader, epochReader, block.Header(), block.Transactions(), block.Uncles(), chainConfig, ibs); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
}
|
|
|
|
if chainConfig.DAOForkSupport && chainConfig.DAOForkBlock != nil && chainConfig.DAOForkBlock.Cmp(block.Number()) == 0 {
|
|
misc.ApplyDAOHardFork(ibs)
|
|
}
|
|
noop := state.NewNoopWriter()
|
|
//fmt.Printf("====txs processing start: %d====\n", block.NumberU64())
|
|
for i, tx := range block.Transactions() {
|
|
ibs.Prepare(tx.Hash(), block.Hash(), i)
|
|
writeTrace := false
|
|
if vmConfig.Debug && vmConfig.Tracer == nil {
|
|
vmConfig.Tracer = vm.NewStructLogger(&vm.LogConfig{})
|
|
writeTrace = true
|
|
}
|
|
|
|
receipt, _, err := ApplyTransaction(chainConfig, getHeader, engine, nil, gp, ibs, noop, header, tx, usedGas, *vmConfig, contractHasTEVM)
|
|
if writeTrace {
|
|
w, err1 := os.Create(fmt.Sprintf("txtrace_%x.txt", tx.Hash()))
|
|
if err1 != nil {
|
|
panic(err1)
|
|
}
|
|
encoder := json.NewEncoder(w)
|
|
logs := FormatLogs(vmConfig.Tracer.(*vm.StructLogger).StructLogs())
|
|
if err2 := encoder.Encode(logs); err2 != nil {
|
|
panic(err2)
|
|
}
|
|
if err2 := w.Close(); err2 != nil {
|
|
panic(err2)
|
|
}
|
|
vmConfig.Tracer = nil
|
|
}
|
|
if err != nil {
|
|
return nil, nil, fmt.Errorf("could not apply tx %d from block %d [%v]: %w", i, block.NumberU64(), tx.Hash().Hex(), err)
|
|
}
|
|
if !vmConfig.NoReceipts {
|
|
receipts = append(receipts, receipt)
|
|
}
|
|
}
|
|
|
|
if chainConfig.IsByzantium(header.Number.Uint64()) && !vmConfig.NoReceipts {
|
|
receiptSha := types.DeriveSha(receipts)
|
|
if receiptSha != block.ReceiptHash() {
|
|
return nil, nil, fmt.Errorf("mismatched receipt headers for block %d", block.NumberU64())
|
|
}
|
|
}
|
|
|
|
if *usedGas != header.GasUsed {
|
|
return nil, nil, fmt.Errorf("gas used by execution: %d, in header: %d", *usedGas, header.GasUsed)
|
|
}
|
|
if !vmConfig.NoReceipts {
|
|
bloom := types.CreateBloom(receipts)
|
|
if bloom != header.Bloom {
|
|
return nil, nil, fmt.Errorf("bloom computed by execution: %x, in header: %x", bloom, header.Bloom)
|
|
}
|
|
}
|
|
if !vmConfig.ReadOnly {
|
|
txs := block.Transactions()
|
|
if _, err := FinalizeBlockExecution(engine, stateReader, block.Header(), txs, block.Uncles(), stateWriter, chainConfig, ibs, receipts, epochReader, chainReader, false); err != nil {
|
|
return nil, nil, err
|
|
}
|
|
}
|
|
|
|
var logs []*types.Log
|
|
for _, receipt := range receipts {
|
|
logs = append(logs, receipt.Logs...)
|
|
}
|
|
|
|
blockLogs := ibs.Logs()
|
|
var stateSyncReceipt *types.ReceiptForStorage
|
|
if chainConfig.Consensus == params.BorConsensus && len(blockLogs) > 0 {
|
|
var stateSyncLogs []*types.Log
|
|
sort.SliceStable(blockLogs, func(i, j int) bool {
|
|
return blockLogs[i].Index < blockLogs[j].Index
|
|
})
|
|
|
|
if len(blockLogs) > len(logs) {
|
|
stateSyncLogs = blockLogs[len(logs):] // get state-sync logs from `state.Logs()`
|
|
|
|
types.DeriveFieldsForBorLogs(stateSyncLogs, block.Hash(), block.NumberU64(), uint(len(receipts)), uint(len(logs)))
|
|
|
|
stateSyncReceipt = &types.ReceiptForStorage{
|
|
Status: types.ReceiptStatusSuccessful, // make receipt status successful
|
|
Logs: stateSyncLogs,
|
|
}
|
|
}
|
|
}
|
|
|
|
return receipts, stateSyncReceipt, nil
|
|
}
|
|
|
|
func SysCallContract(contract common.Address, data []byte, chainConfig params.ChainConfig, ibs *state.IntraBlockState, header *types.Header, engine consensus.Engine) (result []byte, err error) {
|
|
gp := new(GasPool).AddGas(50_000_000)
|
|
|
|
if chainConfig.DAOForkSupport && chainConfig.DAOForkBlock != nil && chainConfig.DAOForkBlock.Cmp(header.Number) == 0 {
|
|
misc.ApplyDAOHardFork(ibs)
|
|
}
|
|
|
|
msg := types.NewMessage(
|
|
state.SystemAddress,
|
|
&contract,
|
|
0, u256.Num0,
|
|
50_000_000, u256.Num0,
|
|
nil, nil,
|
|
data, nil, false,
|
|
)
|
|
vmConfig := vm.Config{NoReceipts: true}
|
|
// Create a new context to be used in the EVM environment
|
|
blockContext := NewEVMBlockContext(header, nil, engine, &state.SystemAddress, nil)
|
|
evm := vm.NewEVM(blockContext, NewEVMTxContext(msg), ibs, &chainConfig, vmConfig)
|
|
if chainConfig.Bor != nil {
|
|
ret, _, err := evm.Call(
|
|
vm.AccountRef(msg.From()),
|
|
*msg.To(),
|
|
msg.Data(),
|
|
msg.Gas(),
|
|
msg.Value(),
|
|
false,
|
|
)
|
|
if err != nil {
|
|
return nil, nil
|
|
}
|
|
return ret, nil
|
|
}
|
|
res, err := ApplyMessage(evm, msg, gp, true /* refunds */, false /* gasBailout */)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return res.ReturnData, nil
|
|
}
|
|
|
|
// from the null sender, with 50M gas.
|
|
func SysCallContractTx(contract common.Address, data []byte) (tx types.Transaction, err error) {
|
|
//nonce := ibs.GetNonce(SystemAddress)
|
|
tx = types.NewTransaction(0, contract, u256.Num0, 50_000_000, u256.Num0, data)
|
|
return tx.FakeSign(state.SystemAddress)
|
|
}
|
|
|
|
func CallContract(contract common.Address, data []byte, chainConfig params.ChainConfig, ibs *state.IntraBlockState, header *types.Header, engine consensus.Engine) (result []byte, err error) {
|
|
gp := new(GasPool)
|
|
gp.AddGas(50_000_000)
|
|
var gasUsed uint64
|
|
|
|
if chainConfig.DAOForkSupport && chainConfig.DAOForkBlock != nil && chainConfig.DAOForkBlock.Cmp(header.Number) == 0 {
|
|
misc.ApplyDAOHardFork(ibs)
|
|
}
|
|
noop := state.NewNoopWriter()
|
|
tx, err := CallContractTx(contract, data, ibs)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("SysCallContract: %w ", err)
|
|
}
|
|
vmConfig := vm.Config{NoReceipts: true}
|
|
_, result, err = ApplyTransaction(&chainConfig, nil, engine, &state.SystemAddress, gp, ibs, noop, header, tx, &gasUsed, vmConfig, nil)
|
|
if err != nil {
|
|
return result, fmt.Errorf("SysCallContract: %w ", err)
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
// from the null sender, with 50M gas.
|
|
func CallContractTx(contract common.Address, data []byte, ibs *state.IntraBlockState) (tx types.Transaction, err error) {
|
|
from := common.Address{}
|
|
nonce := ibs.GetNonce(from)
|
|
tx = types.NewTransaction(nonce, contract, u256.Num0, 50_000_000, u256.Num0, data)
|
|
return tx.FakeSign(from)
|
|
}
|
|
|
|
func FinalizeBlockExecution(engine consensus.Engine, stateReader state.StateReader, header *types.Header,
|
|
txs types.Transactions, uncles []*types.Header, stateWriter state.WriterWithChangeSets, cc *params.ChainConfig, ibs *state.IntraBlockState,
|
|
receipts types.Receipts, e consensus.EpochReader, headerReader consensus.ChainHeaderReader, isMining bool,
|
|
) (newBlock *types.Block, err error) {
|
|
syscall := func(contract common.Address, data []byte) ([]byte, error) {
|
|
return SysCallContract(contract, data, *cc, ibs, header, engine)
|
|
}
|
|
if isMining {
|
|
newBlock, _, _, err = engine.FinalizeAndAssemble(cc, header, ibs, txs, uncles, receipts, e, headerReader, syscall, nil)
|
|
} else {
|
|
_, _, err = engine.Finalize(cc, header, ibs, txs, uncles, receipts, e, headerReader, syscall)
|
|
}
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
var originalSystemAcc *accounts.Account
|
|
if cc.ChainID.Uint64() == 77 { // hack for Sokol - don't understand why eip158 is enabled, but OE still save SystemAddress with nonce=0
|
|
n := ibs.GetNonce(state.SystemAddress) //hack - because syscall must use ApplyMessage instead of ApplyTx (and don't create tx at all). But CallContract must create tx.
|
|
if n > 0 {
|
|
var err error
|
|
originalSystemAcc, err = stateReader.ReadAccountData(state.SystemAddress)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
|
|
if err := ibs.CommitBlock(cc.Rules(header.Number.Uint64()), stateWriter); err != nil {
|
|
return nil, fmt.Errorf("committing block %d failed: %w", header.Number.Uint64(), err)
|
|
}
|
|
|
|
if originalSystemAcc != nil { // hack for Sokol - don't understand why eip158 is enabled, but OE still save SystemAddress with nonce=0
|
|
acc := accounts.NewAccount()
|
|
acc.Nonce = 0
|
|
if err := stateWriter.UpdateAccountData(state.SystemAddress, originalSystemAcc, &acc); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
if err := stateWriter.WriteChangeSets(); err != nil {
|
|
return nil, fmt.Errorf("writing changesets for block %d failed: %w", header.Number.Uint64(), err)
|
|
}
|
|
return newBlock, nil
|
|
}
|
|
|
|
func InitializeBlockExecution(engine consensus.Engine, chain consensus.ChainHeaderReader, epochReader consensus.EpochReader, header *types.Header, txs types.Transactions, uncles []*types.Header, cc *params.ChainConfig, ibs *state.IntraBlockState) error {
|
|
// Finalize the block, applying any consensus engine specific extras (e.g. block rewards)
|
|
engine.Initialize(cc, chain, epochReader, header, txs, uncles, func(contract common.Address, data []byte) ([]byte, error) {
|
|
return SysCallContract(contract, data, *cc, ibs, header, engine)
|
|
})
|
|
return nil
|
|
}
|