Sokol v0: can process 1-st block (#2310)

Author: AskAlexSharov

.gitignore

@@ -68,3 +68,5 @@ docker-compose.dev.yml
 
 /ethdb/*.fail
 
+libmdbx/build/*
+tests/testdata/*

consensus/aura/aura.go

@@ -196,16 +196,13 @@ func (e *EpochManager) zoomToAfter(chain consensus.ChainHeaderReader, validators
 		return e.finalityChecker, e.epochTransitionNumber, false
 	}
 	// extract other epoch set if it's not the same as the last.
-	fmt.Printf("aa3: %x,%x\n", lastTransition.BlockHash, e.epochTransitionHash)
 	if lastTransition.BlockHash != e.epochTransitionHash {
-		fmt.Printf("aa2: %T\n", validators)
 		proof, err := destructure_proofs(lastTransition.ProofRlp)
 		if err != nil {
 			panic(err)
 		}
 		first := proof.SignalNumber == 0
 		// use signal number so multi-set first calculation is correct.
-		fmt.Printf("aa1: %T\n", validators)
 		list, _, err := validators.epochSet(first, proof.SignalNumber, proof.SetProof)
 		if err != nil {
 			panic(fmt.Errorf("proof produced by this engine; therefore it is valid; qed. %w", err))
@@ -512,15 +509,20 @@ func nextStepTimeDuration(info StepDurationInfo, time uint64) (uint64, uint64, b
 // Author implements consensus.Engine, returning the Ethereum address recovered
 // from the signature in the header's extra-data section.
 func (c *AuRa) Author(header *types.Header) (common.Address, error) {
+	/*
+	 let message = keccak(empty_step_rlp(self.step, &self.parent_hash));
+	        let public = publickey::recover(&self.signature.into(), &message)?;
+	        Ok(publickey::public_to_address(&public))
+	*/
 	return common.Address{}, nil
-	//return ecrecover(header, c.signatures)
 }
 
 // VerifyHeader checks whether a header conforms to the consensus rules.
 func (c *AuRa) VerifyHeader(chain consensus.ChainHeaderReader, header *types.Header, _ bool) error {
 	return nil
 }
 
+//nolint
 func (c *AuRa) hasReceivedStepHashes(step uint64, author common.Address, newHash common.Hash) bool {
 	/*
 		self
@@ -531,6 +533,8 @@ func (c *AuRa) hasReceivedStepHashes(step uint64, author common.Address, newHash
 	*/
 	return false
 }
+
+//nolint
 func (c *AuRa) insertReceivedStepHashes(step uint64, author common.Address, newHash common.Hash) {
 	/*
 	   	    self.received_step_hashes
@@ -540,7 +544,9 @@ func (c *AuRa) insertReceivedStepHashes(step uint64, author common.Address, newH
 }
 
 /// Phase 3 verification. Check block information against parent. Returns either a null `Ok` or a general error detailing the problem with import.
+//nolint
 func (c *AuRa) VerifyFamily(chain consensus.ChainHeaderReader, header *types.Header) error {
+	return nil
 	step, err := headerStep(header)
 	if err != nil {
 		return err
@@ -788,8 +794,17 @@ func (c *AuRa) Prepare(chain consensus.ChainHeaderReader, header *types.Header)
 	//return nil
 }
 
-// Finalize implements consensus.Engine, ensuring no uncles are set, nor block
-// rewards given.
+func (c *AuRa) Initialize(cc *params.ChainConfig, header *types.Header, state *state.IntraBlockState, txs []types.Transaction, uncles []*types.Header, syscall consensus.SystemCall) {
+	isEpochBegin := header.Number.Uint64() == 1
+	if !isEpochBegin {
+		return
+	}
+	err := c.cfg.Validators.onEpochBegin(isEpochBegin, header, syscall)
+	if err != nil {
+		log.Warn("aura initialize block: on epoch begin", "err", err)
+	}
+}
+
 func (c *AuRa) Finalize(cc *params.ChainConfig, header *types.Header, state *state.IntraBlockState, txs []types.Transaction, uncles []*types.Header, syscall consensus.SystemCall) {
 	// accumulateRewards retreives rewards for a block and applies them to the coinbase accounts for miner and uncle miners
 	beneficiaries, _, rewards, err := AccumulateRewards(cc, c, header, uncles, syscall)
@@ -1185,7 +1200,6 @@ func callBlockRewardAbi(contractAddr common.Address, syscall consensus.SystemCal
 	}
 	_ = res[0]
 	_ = res[1]
-	fmt.Printf("aaaaa: %#v, %#v\n", res[0], res[1])
 	return nil, nil
 }
 

consensus/aura/config.go

@@ -52,10 +52,14 @@ func newValidatorSetFromJson(j *ValidatorSetJson, posdaoTransition *uint64) Vali
 		return &SimpleList{validators: j.List}
 	}
 	if j.SafeContract != nil {
-		return &ValidatorSafeContract{contractAddress: *j.SafeContract}
+		return &ValidatorSafeContract{contractAddress: *j.SafeContract, posdaoTransition: posdaoTransition}
 	}
 	if j.Contract != nil {
-		return &ValidatorContract{contractAddress: *j.SafeContract, posdaoTransition: posdaoTransition}
+		return &ValidatorContract{
+			contractAddress:  *j.SafeContract,
+			validators:       ValidatorSafeContract{contractAddress: *j.SafeContract, posdaoTransition: posdaoTransition},
+			posdaoTransition: posdaoTransition,
+		}
 	}
 	if j.Multi != nil {
 		l := map[uint64]ValidatorSet{}

consensus/aura/validators.go

@@ -9,21 +9,14 @@ import (
 
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/ledgerwatch/erigon/common"
+	"github.com/ledgerwatch/erigon/consensus"
 	"github.com/ledgerwatch/erigon/consensus/aura/aurainterfaces"
 	"github.com/ledgerwatch/erigon/core/types"
 	"github.com/ledgerwatch/erigon/log"
 	"github.com/ledgerwatch/erigon/rlp"
 	"go.uber.org/atomic"
 )
 
-/// Kind of SystemOrCodeCall, this is either an on-chain address, or code.
-type SystemOrCodeCallKind uint8
-
-const (
-	SystemCallOnChain SystemOrCodeCallKind = 0
-	CallHardCodedCode SystemOrCodeCallKind = 1
-)
-
 //nolint
 type CallResults struct {
 	data      []byte
@@ -58,6 +51,15 @@ type ValidatorSet interface {
 	// Returns a list of contract calls to be pushed onto the new block.
 	//func generateEngineTransactions(_first bool, _header *types.Header, _call SystemCall) -> Result<Vec<(Address, Bytes)>, EthcoreError>
 
+	// Signalling that a new epoch has begun.
+	//
+	// All calls here will be from the `SYSTEM_ADDRESS`: 2^160 - 2
+	// and will have an effect on the block's state.
+	// The caller provided here may not generate proofs.
+	//
+	// `first` is true if this is the first block in the set.
+	onEpochBegin(first bool, header *types.Header, caller consensus.SystemCall) error
+
 	// Called on the close of every block.
 	onCloseBlock(_header *types.Header, _address common.Address) error
 
@@ -279,10 +281,10 @@ func (s *Multi) genesisEpochData(header *types.Header, call Call) ([]byte, error
 	return set.genesisEpochData(header, call)
 }
 
-//func (s *Multi) onEpochBegin(first bool, header *types.Header, call SysCall) error {
-//	first, set := s.get(header.Number.Uint64())
-//	return set.onEpochBegin(first,header, address)
-//}
+func (s *Multi) onEpochBegin(_ bool, header *types.Header, caller consensus.SystemCall) error {
+	setTransition, set := s.correctSetByNumber(header.Number.Uint64())
+	return set.onEpochBegin(setTransition == header.Number.Uint64(), header, caller)
+}
 
 type SimpleList struct {
 	validators []common.Address
@@ -291,6 +293,9 @@ type SimpleList struct {
 func (s *SimpleList) epochSet(first bool, num uint64, proof []byte) (SimpleList, common.Hash, error) {
 	return *s, common.Hash{}, nil
 }
+func (s *SimpleList) onEpochBegin(first bool, header *types.Header, caller consensus.SystemCall) error {
+	return nil
+}
 func (s *SimpleList) onCloseBlock(_header *types.Header, _address common.Address) error { return nil }
 func (s *SimpleList) defaultCaller(blockHash common.Hash) (Call, error) {
 	return nil, nil //simple list doesn't require calls
@@ -620,6 +625,22 @@ func (s *ValidatorSafeContract) genesisEpochData(header *types.Header, call Call
 	return proveInitial(s.contractAddress, header, call)
 }
 
+func (s *ValidatorSafeContract) onEpochBegin(first bool, header *types.Header, caller consensus.SystemCall) error {
+	data := common.FromHex("75286211")
+	_, err := caller(s.contractAddress, data)
+	if err != nil {
+		return err
+	}
+	/*
+	 let data = validator_set::functions::finalize_change::encode_input();
+	        caller(self.contract_address, data)
+	            .map(|_| ())
+	            .map_err(::engines::EngineError::FailedSystemCall)
+	            .map_err(Into::into)
+	*/
+	return nil
+}
+
 func (s *ValidatorSafeContract) onCloseBlock(header *types.Header, ourAddress common.Address) error {
 	// Skip the rest of the function unless there has been a transition to POSDAO AuRa.
 	if s.posdaoTransition != nil && header.Number.Uint64() < *s.posdaoTransition {
@@ -676,18 +697,18 @@ type ValidatorContract struct {
 func (s *ValidatorContract) epochSet(first bool, num uint64, proof []byte) (SimpleList, common.Hash, error) {
 	return s.validators.epochSet(first, num, proof)
 }
-
 func (s *ValidatorContract) defaultCaller(blockHash common.Hash) (Call, error) {
 	return s.validators.defaultCaller(blockHash)
 }
-
 func (s *ValidatorContract) getWithCaller(parentHash common.Hash, nonce uint, caller Call) (common.Address, error) {
 	return s.validators.getWithCaller(parentHash, nonce, caller)
 }
-
 func (s *ValidatorContract) countWithCaller(parentHash common.Hash, caller Call) (uint64, error) {
 	return s.validators.countWithCaller(parentHash, caller)
 }
+func (s *ValidatorContract) onEpochBegin(first bool, header *types.Header, caller consensus.SystemCall) error {
+	return s.validators.onEpochBegin(first, header, caller)
+}
 func (s *ValidatorContract) onCloseBlock(header *types.Header, address common.Address) error {
 	return s.validators.onCloseBlock(header, address)
 }

consensus/clique/clique.go

@@ -363,6 +363,9 @@ func (c *Clique) Prepare(chain consensus.ChainHeaderReader, header *types.Header
 	return nil
 }
 
+func (c *Clique) Initialize(_ *params.ChainConfig, header *types.Header, state *state.IntraBlockState, txs []types.Transaction, uncles []*types.Header, syscall consensus.SystemCall) {
+}
+
 // Finalize implements consensus.Engine, ensuring no uncles are set, nor block
 // rewards given.
 func (c *Clique) Finalize(_ *params.ChainConfig, header *types.Header, state *state.IntraBlockState, txs []types.Transaction, uncles []*types.Header, syscall consensus.SystemCall) {

consensus/consensus.go

@@ -59,7 +59,8 @@ type ChainReader interface {
 	HasBlock(hash common.Hash, number uint64) bool
 }
 
-type SystemCall func(address common.Address, in []byte) ([]byte, 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.
 type Engine interface {
@@ -87,6 +88,9 @@ type Engine interface {
 	// rules of a particular engine. The changes are executed inline.
 	Prepare(chain ChainHeaderReader, header *types.Header) error
 
+	// Initialize runs any pre-transaction state modifications (e.g. epoch start)
+	Initialize(config *params.ChainConfig, header *types.Header, state *state.IntraBlockState, txs []types.Transaction, uncles []*types.Header, syscall SystemCall)
+
 	// Finalize runs any post-transaction state modifications (e.g. block rewards)
 	// but does not assemble the block.
 	//

consensus/ethash/consensus.go

@@ -596,6 +596,9 @@ func (ethash *Ethash) Prepare(chain consensus.ChainHeaderReader, header *types.H
 	return nil
 }
 
+func (ethash *Ethash) Initialize(config *params.ChainConfig, header *types.Header, state *state.IntraBlockState, txs []types.Transaction, uncles []*types.Header, _ consensus.SystemCall) {
+}
+
 // Finalize implements consensus.Engine, accumulating the block and uncle rewards,
 // setting the final state on the header
 func (ethash *Ethash) Finalize(config *params.ChainConfig, header *types.Header, state *state.IntraBlockState, txs []types.Transaction, uncles []*types.Header, _ consensus.SystemCall) {

core/blockchain.go

@@ -23,7 +23,6 @@ import (
 	"os"
 	"time"
 
-	"github.com/holiman/uint256"
 	"github.com/ledgerwatch/erigon/common"
 	"github.com/ledgerwatch/erigon/common/mclock"
 	"github.com/ledgerwatch/erigon/common/u256"
@@ -106,6 +105,12 @@ func ExecuteBlockEphemerally(
 	gp := new(GasPool)
 	gp.AddGas(block.GasLimit())
 
+	if !vmConfig.ReadOnly {
+		if err := InitializeBlockExecution(engine, block.Header(), block.Transactions(), block.Uncles(), stateWriter, chainConfig, ibs); err != nil {
+			return nil, err
+		}
+	}
+
 	if chainConfig.DAOForkSupport && chainConfig.DAOForkBlock != nil && chainConfig.DAOForkBlock.Cmp(block.Number()) == 0 {
 		misc.ApplyDAOHardFork(ibs)
 	}
@@ -167,6 +172,52 @@ func ExecuteBlockEphemerally(
 	return receipts, nil
 }
 
+// SystemAddress - sender address for internal state updates.
+var SystemAddress = common.HexToAddress("0xfffffffffffffffffffffffffffffffffffffffe")
+
+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)
+	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 := SysCallContractTx(contract, data, ibs)
+	if err != nil {
+		return nil, fmt.Errorf("SysCallContract: %w ", err)
+	}
+	// Set infinite balance to the fake caller account.
+	fmt.Printf("call contract: %d,%x,%x\n", header.Number.Uint64(), contract, data)
+
+	vmConfig := vm.Config{NoReceipts: true, Debug: true, Tracer: vm.NewStructLogger(&vm.LogConfig{})}
+	_, result, err = ApplyTransaction(&chainConfig, nil, engine, &SystemAddress, gp, ibs, noop, header, tx, &gasUsed, vmConfig, nil)
+	if err != nil {
+		return result, fmt.Errorf("SysCallContract: %w ", err)
+	}
+	ibs.SetNonce(SystemAddress, 0)
+
+	//w, err1 := os.Create(fmt.Sprintf("txtrace_before.json"))
+	//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)
+	//}
+	return result, nil
+}
+
+// from the null sender, with 50M gas.
+func SysCallContractTx(contract common.Address, data []byte, ibs *state.IntraBlockState) (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(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)
@@ -178,24 +229,33 @@ func CallContract(contract common.Address, data []byte, chainConfig params.Chain
 	noop := state.NewNoopWriter()
 	tx, err := CallContractTx(contract, data, ibs)
 	if err != nil {
-		return nil, fmt.Errorf("CallContract: %w ", err)
+		return nil, fmt.Errorf("SysCallContract: %w ", err)
 	}
 	// Set infinite balance to the fake caller account.
-	from := ibs.GetOrNewStateObject(common.Address{})
-	from.SetBalance(uint256.NewInt(0).SetAllOne())
+	fmt.Printf("call contract: %d,%x,%x\n", header.Number.Uint64(), contract, data)
 
-	_, result, err = ApplyTransaction(&chainConfig, nil, engine, nil, gp, ibs, noop, header, tx, &gasUsed, vm.Config{}, nil)
+	vmConfig := vm.Config{NoReceipts: true, Debug: true, Tracer: vm.NewStructLogger(&vm.LogConfig{})}
+	_, result, err = ApplyTransaction(&chainConfig, nil, engine, &SystemAddress, gp, ibs, noop, header, tx, &gasUsed, vmConfig, nil)
 	if err != nil {
-		return result, fmt.Errorf("CallContract: %w ", err)
+		return result, fmt.Errorf("SysCallContract: %w ", err)
 	}
+	//w, err1 := os.Create(fmt.Sprintf("txtrace_before.json"))
+	//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)
+	//}
 	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) {
-	var from common.Address
+	from := common.Address{}
 	nonce := ibs.GetNonce(from)
-	tx = types.NewTransaction(nonce, contract, u256.Num0, 50_000_000, u256.Num1, data)
+	tx = types.NewTransaction(nonce, contract, u256.Num0, 50_000_000, u256.Num0, data)
 	return tx.FakeSign(from)
 }
 
@@ -213,3 +273,12 @@ func FinalizeBlockExecution(engine consensus.Engine, header *types.Header, txs t
 	}
 	return nil
 }
+
+func InitializeBlockExecution(engine consensus.Engine, header *types.Header, txs types.Transactions, uncles []*types.Header, stateWriter state.WriterWithChangeSets, cc *params.ChainConfig, ibs *state.IntraBlockState) error {
+	// Finalize the block, applying any consensus engine specific extras (e.g. block rewards)
+	engine.Initialize(cc, header, ibs, txs, uncles, func(contract common.Address, data []byte) ([]byte, error) {
+		return SysCallContract(contract, data, *cc, ibs, header, engine)
+	})
+
+	return nil
+}