[*] bring more compatibility with origin erigon and some code cleanup

consensus/aura/aura.go

@@ -1342,7 +1342,7 @@ func callBlockRewardAbi(contractAddr common.Address, syscall consensus.SystemCal
 	if err != nil {
 		panic(err)
 	}
-	_, out, err := syscall(contractAddr, packed)
+	out, err := syscall(contractAddr, packed)
 	if err != nil {
 		panic(err)
 	}

consensus/aura/validators.go

@@ -633,7 +633,7 @@ func (s *ValidatorSafeContract) getListSyscall(caller consensus.SystemCall) (*Si
 	if err != nil {
 		panic(err)
 	}
-	_, out, err := caller(s.contractAddress, packed)
+	out, err := caller(s.contractAddress, packed)
 	if err != nil {
 		panic(err)
 	}
@@ -651,7 +651,7 @@ func (s *ValidatorSafeContract) genesisEpochData(header *types.Header, call cons
 
 func (s *ValidatorSafeContract) onEpochBegin(firstInEpoch bool, header *types.Header, caller consensus.SystemCall) error {
 	data := common.FromHex("75286211")
-	_, _, err := caller(s.contractAddress, data)
+	_, err := caller(s.contractAddress, data)
 	if err != nil {
 		return err
 	}

consensus/consensus.go

@@ -67,7 +67,7 @@ type EpochReader interface {
 	FindBeforeOrEqualNumber(number uint64) (blockNum uint64, blockHash common.Hash, transitionProof []byte, err error)
 }
 
-type SystemCall func(contract common.Address, data []byte) (gasUsed uint64, returnData []byte, err error)
+type SystemCall func(contract common.Address, data []byte) ([]byte, error)
 type Call func(contract common.Address, data []byte) ([]byte, error)
 
 // Engine is an algorithm agnostic consensus engine.

consensus/parlia/parlia.go

@@ -21,6 +21,7 @@ import (
 	"github.com/ledgerwatch/erigon/core/systemcontracts"
 	"github.com/ledgerwatch/erigon/core/types"
 	"github.com/ledgerwatch/erigon/core/types/accounts"
+	"github.com/ledgerwatch/erigon/core/vm"
 	"github.com/ledgerwatch/erigon/crypto"
 	"github.com/ledgerwatch/erigon/params"
 	"github.com/ledgerwatch/erigon/rlp"
@@ -823,7 +824,7 @@ func (p *Parlia) getCurrentValidators(header *types.Header, state *state.IntraBl
 	// call
 	msgData := (hexutil.Bytes)(data)
 	toAddress := common.HexToAddress(systemcontracts.ValidatorContract)
-	_, returnData, err := core.SysCallContract(header.Coinbase, toAddress, msgData[:], *p.chainConfig, state, header, p, u256.Num0)
+	_, returnData, err := systemCall(header.Coinbase, toAddress, msgData[:], *p.chainConfig, state, header, p, u256.Num0)
 	if err != nil {
 		return nil, err
 	}
@@ -1000,7 +1001,7 @@ func (p *Parlia) applyTransaction(
 		*receivedTxs = (*receivedTxs)[1:]
 	}
 	ibs.Prepare(expectedTx.Hash(), common.Hash{}, len(*txs))
-	gasUsed, _, err := core.SysCallContract(from, to, data, *p.chainConfig, ibs, header, p, value)
+	gasUsed, _, err := systemCall(from, to, data, *p.chainConfig, ibs, header, p, value)
 	*txs = append(*txs, expectedTx)
 	*usedGas += gasUsed
 	receipt := types.NewReceipt(false, *usedGas)
@@ -1020,16 +1021,32 @@ func (p *Parlia) applyTransaction(
 	return nil
 }
 
-// chain context
-type chainContext struct {
-	Chain  consensus.ChainHeaderReader
-	parlia consensus.Engine
-}
-
-func (c chainContext) Engine() consensus.Engine {
-	return c.parlia
-}
-
-func (c chainContext) GetHeader(hash common.Hash, number uint64) *types.Header {
-	return c.Chain.GetHeader(hash, number)
+func systemCall(from, contract common.Address, data []byte, chainConfig params.ChainConfig, ibs *state.IntraBlockState, header *types.Header, engine consensus.Engine, value *uint256.Int) (gasUsed uint64, returnData []byte, err error) {
+	if chainConfig.DAOForkSupport && chainConfig.DAOForkBlock != nil && chainConfig.DAOForkBlock.Cmp(header.Number) == 0 {
+		misc.ApplyDAOHardFork(ibs)
+	}
+	msg := types.NewMessage(
+		from,
+		&contract,
+		0, value,
+		math.MaxUint64/2, u256.Num0,
+		nil, nil,
+		data, nil, false,
+	)
+	vmConfig := vm.Config{NoReceipts: true}
+	// Create a new context to be used in the EVM environment
+	blockContext := core.NewEVMBlockContext(header, nil, engine, &from, nil)
+	evm := vm.NewEVM(blockContext, core.NewEVMTxContext(msg), ibs, &chainConfig, vmConfig)
+	ret, leftOverGas, err := evm.Call(
+		vm.AccountRef(msg.From()),
+		*msg.To(),
+		msg.Data(),
+		msg.Gas(),
+		msg.Value(),
+		false,
+	)
+	if err != nil {
+		return 0, nil, err
+	}
+	return msg.Gas() - leftOverGas, ret, nil
 }

core/blockchain.go

@@ -20,8 +20,6 @@ package core
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/holiman/uint256"
-	"github.com/ledgerwatch/erigon/common/math"
 	"github.com/ledgerwatch/erigon/core/systemcontracts"
 	"os"
 	"time"
@@ -187,36 +185,30 @@ func ExecuteBlockEphemerally(
 	return receipts, nil
 }
 
-func SysCallContract(from, contract common.Address, data []byte, chainConfig params.ChainConfig, ibs *state.IntraBlockState, header *types.Header, engine consensus.Engine, value *uint256.Int) (gasUsed uint64, returnData []byte, err error) {
+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(
-		from,
+		state.SystemAddress,
 		&contract,
-		0, value,
-		math.MaxUint64/2, u256.Num0,
+		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, &from, nil)
+	blockContext := NewEVMBlockContext(header, nil, engine, &state.SystemAddress, nil)
 	evm := vm.NewEVM(blockContext, NewEVMTxContext(msg), ibs, &chainConfig, vmConfig)
-	ret, leftOverGas, err := evm.Call(
-		vm.AccountRef(msg.From()),
-		*msg.To(),
-		msg.Data(),
-		msg.Gas(),
-		msg.Value(),
-		false,
-	)
-
-	//res, err := ApplyMessage(evm, msg, gp, true /* refunds */, false /* gasBailout */)
+	res, err := ApplyMessage(evm, msg, gp, true /* refunds */, false /* gasBailout */)
 	if err != nil {
-		return 0, nil, err
+		return nil, err
 	}
-	return msg.Gas() - leftOverGas, ret, nil
+	return res.ReturnData, nil
 }
 
 // from the null sender, with 50M gas.
@@ -256,21 +248,21 @@ func CallContractTx(contract common.Address, data []byte, ibs *state.IntraBlockS
 }
 
 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, gasUsed *uint64) (*types.Block, error) {
-	//ibs.Print(cc.Rules(header.Number.Uint64()))
-	//fmt.Printf("====tx processing end====\n")
-	//if posa := engine.(consensus.PoSA); posa != nil {
-	//	posa.FinalizeAndAssemble()
-	//}
-
+
+	// We're doing this hack for BSC to avoid changing consensus interfaces. 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 = *gasUsed
-	block, err := engine.FinalizeAndAssemble(cc, header, ibs, txs, uncles, *receipts, e, headerReader, nil, nil)
+	block, err := engine.FinalizeAndAssemble(cc, header, ibs, txs, uncles, *receipts, e, headerReader, func(contract common.Address, data []byte) ([]byte, error) {
+		return SysCallContract(contract, data, *cc, ibs, header, engine)
+	}, nil)
 	if err != nil {
 		return nil, err
 	}
 	*gasUsed = header.GasUsed
-	//fmt.Printf("====finalize start %d====\n", header.Number.Uint64())
-	//ibs.Print(cc.Rules(header.Number.Uint64()))
-	//fmt.Printf("====finalize end====\n")
 
 	var originalSystemAcc *accounts.Account
 
@@ -305,12 +297,8 @@ func FinalizeBlockExecution(engine consensus.Engine, stateReader state.StateRead
 
 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) (gasUsed uint64, returnData []byte, err error) {
-		panic("not implemented")
+	engine.Initialize(cc, chain, epochReader, header, txs, uncles, func(contract common.Address, data []byte) ([]byte, error) {
+		return SysCallContract(contract, data, *cc, ibs, header, engine)
 	})
-	//fmt.Printf("====InitializeBlockExecution start %d====\n", header.Number.Uint64())
-	//ibs.Print(cc.Rules(header.Number.Uint64()))
-	//fmt.Printf("====InitializeBlockExecution end====\n")
-
 	return nil
 }

core/state/intra_block_state.go

@@ -776,10 +776,6 @@ func (sdb *IntraBlockState) CommitBlock(chainRules params.Rules, stateWriter Sta
 	return nil
 }
 
-func (sdb *IntraBlockState) GetStateWriter() StateWriter {
-	return sdb.stateReader.(StateWriter)
-}
-
 func (sdb *IntraBlockState) Print(chainRules params.Rules) {
 	for addr, stateObject := range sdb.stateObjects {
 		_, isDirty := sdb.stateObjectsDirty[addr]

core/state/state_object.go

@@ -367,6 +367,7 @@ func (so *stateObject) CodeHash() []byte {
 }
 
 func (so *stateObject) Balance() *uint256.Int {
+	// It's better to return copy of balance, otherwise it might cause shadow changes
 	return so.data.Balance.Clone()
 }
 

core/state_processor.go

@@ -98,7 +98,11 @@ func applyTransaction(config *params.ChainConfig, gp *GasPool, statedb *state.In
 	// Update the evm with the new transaction context.
 	evm.Reset(txContext, statedb)
 
-	result, err := ApplyMessage(evm, msg, gp, true /* refunds */, true /* gasBailout */)
+	gasBailout := false
+	if config.Parlia != nil {
+		gasBailout = true
+	}
+	result, err := ApplyMessage(evm, msg, gp, true /* refunds */, gasBailout /* gasBailout */)
 	if err != nil {
 		return nil, nil, err
 	}

core/types/transaction_signing.go

@@ -68,8 +68,6 @@ func MakeSigner(config *params.ChainConfig, blockNumber uint64) *Signer {
 	return &signer
 }
 
-
-
 func MakeFrontierSigner() *Signer {
 	var signer Signer
 	signer.maleable = true

core/vm/contracts.go

@@ -69,6 +69,18 @@ var PrecompiledContractsByzantium = map[common.Address]PrecompiledContract{
 // PrecompiledContractsIstanbul contains the default set of pre-compiled Ethereum
 // contracts used in the Istanbul release.
 var PrecompiledContractsIstanbul = map[common.Address]PrecompiledContract{
+	common.BytesToAddress([]byte{1}): &ecrecover{},
+	common.BytesToAddress([]byte{2}): &sha256hash{},
+	common.BytesToAddress([]byte{3}): &ripemd160hash{},
+	common.BytesToAddress([]byte{4}): &dataCopy{},
+	common.BytesToAddress([]byte{5}): &bigModExp{eip2565: false},
+	common.BytesToAddress([]byte{6}): &bn256AddIstanbul{},
+	common.BytesToAddress([]byte{7}): &bn256ScalarMulIstanbul{},
+	common.BytesToAddress([]byte{8}): &bn256PairingIstanbul{},
+	common.BytesToAddress([]byte{9}): &blake2F{},
+}
+
+var PrecompiledContractsIstanbulForBSC = map[common.Address]PrecompiledContract{
 	common.BytesToAddress([]byte{1}): &ecrecover{},
 	common.BytesToAddress([]byte{2}): &sha256hash{},
 	common.BytesToAddress([]byte{3}): &ripemd160hash{},

core/vm/evm.go

@@ -49,7 +49,11 @@ func (evm *EVM) precompile(addr common.Address) (PrecompiledContract, bool) {
 	case evm.chainRules.IsBerlin:
 		precompiles = PrecompiledContractsBerlin
 	case evm.chainRules.IsIstanbul:
-		precompiles = PrecompiledContractsIstanbul
+		if evm.chainRules.IsParlia {
+			precompiles = PrecompiledContractsIstanbulForBSC
+		} else {
+			precompiles = PrecompiledContractsIstanbul
+		}
 	case evm.chainRules.IsByzantium:
 		precompiles = PrecompiledContractsByzantium
 	default:

params/config.go

@@ -897,7 +897,7 @@ type Rules struct {
 	ChainID                                                 *big.Int
 	IsHomestead, IsEIP150, IsEIP155, IsEIP158               bool
 	IsByzantium, IsConstantinople, IsPetersburg, IsIstanbul bool
-	IsBerlin, IsLondon                                      bool
+	IsBerlin, IsLondon, IsParlia                            bool
 }
 
 // Rules ensures c's ChainID is not nil.
@@ -918,5 +918,6 @@ func (c *ChainConfig) Rules(num uint64) Rules {
 		IsIstanbul:       c.IsIstanbul(num),
 		IsBerlin:         c.IsBerlin(num),
 		IsLondon:         c.IsLondon(num),
+		IsParlia:         c.Parlia != nil,
 	}
 }