polygon/bor: simplify state receiver contract code (#11618)

Tidying up bor contracts code:
- Rename `GenesisContractsClient` to `StateReceiver` for clarity
- Remove unused `LastStateId` func in `StateReceiver`
- Move `StateReceiver` into its own file `state_receiver.go`
- Create a gomock for it in `state_receiver_mock.go` and use in test
- Remove unused function input for `ChainSpanner`

eth/ethconsensusconfig/config.go

@@ -98,19 +98,17 @@ func CreateConsensusEngine(ctx context.Context, nodeConfig *nodecfg.Config, chai
 		// In order to pass the ethereum transaction tests, we need to set the burn contract which is in the bor config
 		// Then, bor != nil will also be enabled for ethash and clique. Only enable Bor for real if there is a validator contract present.
 		if chainConfig.Bor != nil && consensusCfg.ValidatorContract != "" {
-			genesisContractsClient := bor.NewGenesisContractsClient(chainConfig, consensusCfg.ValidatorContract, consensusCfg.StateReceiverContract, logger)
-
+			stateReceiver := bor.NewStateReceiver(consensusCfg.StateReceiverContract)
 			spanner := bor.NewChainSpanner(bor.GenesisContractValidatorSetABI(), chainConfig, withoutHeimdall, logger)
 
 			var err error
 			var db kv.RwDB
-
 			db, err = node.OpenDatabase(ctx, nodeConfig, kv.ConsensusDB, "bor", readonly, logger)
 			if err != nil {
 				panic(err)
 			}
 
-			eng = bor.New(chainConfig, db, blockReader, spanner, heimdallClient, genesisContractsClient, logger, polygonBridge, heimdallService)
+			eng = bor.New(chainConfig, db, blockReader, spanner, heimdallClient, stateReceiver, logger, polygonBridge, heimdallService)
 		}
 	}
 

eth/stagedsync/stage_bor_heimdall_test.go

@@ -252,7 +252,6 @@ func TestBorHeimdallForwardErrHeaderValidatorsBytesMismatch(t *testing.T) {
 
 func TestBorHeimdallForwardDetectsUnauthorizedSignerError(t *testing.T) {
 	t.Parallel()
-	t.Skip("fixme(?) in ci plz")
 
 	ctx := context.Background()
 	numBlocks := 312

eth/stagedsync/stagedsynctest/harness.go

@@ -491,20 +491,14 @@ func (h *Harness) seal(t *testing.T, chr consensus.ChainHeaderReader, eng consen
 
 func (h *Harness) consensusEngine(t *testing.T, cfg HarnessCfg) consensus.Engine {
 	if h.chainConfig.Bor != nil {
-		genesisContracts := bor.NewGenesisContractsClient(
-			h.chainConfig,
-			h.borConfig.ValidatorContract,
-			h.borConfig.StateReceiverContract,
-			h.logger,
-		)
-
+		stateReceiver := bor.NewStateReceiver(h.borConfig.StateReceiverContract)
 		borConsensusEng := bor.New(
 			h.chainConfig,
 			h.borConsensusDB,
 			nil,
 			h.borSpanner,
 			h.heimdallClient,
-			genesisContracts,
+			stateReceiver,
 			h.logger,
 			nil,
 			nil,
@@ -593,14 +587,14 @@ func (h *Harness) setHeimdallNextMockSpan() {
 func (h *Harness) mockBorSpanner() {
 	h.borSpanner.
 		EXPECT().
-		GetCurrentValidators(gomock.Any(), gomock.Any(), gomock.Any()).
+		GetCurrentValidators(gomock.Any(), gomock.Any()).
 		Return(h.heimdallNextMockSpan.ValidatorSet.Validators, nil).
 		AnyTimes()
 
 	h.borSpanner.
 		EXPECT().
-		GetCurrentProducers(gomock.Any(), gomock.Any(), gomock.Any()).
-		DoAndReturn(func(_ uint64, _ libcommon.Address, _ consensus.ChainHeaderReader) ([]*valset.Validator, error) {
+		GetCurrentProducers(gomock.Any(), gomock.Any()).
+		DoAndReturn(func(_ uint64, _ consensus.ChainHeaderReader) ([]*valset.Validator, error) {
 			res := make([]*valset.Validator, len(h.heimdallNextMockSpan.SelectedProducers))
 			for i := range h.heimdallNextMockSpan.SelectedProducers {
 				res[i] = &h.heimdallNextMockSpan.SelectedProducers[i]

polygon/bor/bor.go

@@ -322,11 +322,11 @@ type Bor struct {
 
 	execCtx context.Context // context of caller execution stage
 
-	spanner                Spanner
-	GenesisContractsClient GenesisContracts
-	HeimdallClient         heimdall.HeimdallClient
-	spanReader             spanReader
-	bridgeReader           bridgeReader
+	spanner        Spanner
+	stateReceiver  StateReceiver
+	HeimdallClient heimdall.HeimdallClient
+	spanReader     spanReader
+	bridgeReader   bridgeReader
 
 	// scope event.SubscriptionScope
 	// The fields below are for testing only
@@ -352,7 +352,7 @@ func New(
 	blockReader services.FullBlockReader,
 	spanner Spanner,
 	heimdallClient heimdall.HeimdallClient,
-	genesisContracts GenesisContracts,
+	genesisContracts StateReceiver,
 	logger log.Logger,
 	bridgeReader bridgeReader,
 	spanReader spanReader,
@@ -370,20 +370,20 @@ func New(
 	signatures, _ := lru.NewARC[libcommon.Hash, libcommon.Address](inmemorySignatures)
 
 	c := &Bor{
-		chainConfig:            chainConfig,
-		config:                 borConfig,
-		DB:                     db,
-		blockReader:            blockReader,
-		Recents:                recents,
-		Signatures:             signatures,
-		spanner:                spanner,
-		GenesisContractsClient: genesisContracts,
-		HeimdallClient:         heimdallClient,
-		execCtx:                context.Background(),
-		logger:                 logger,
-		closeCh:                make(chan struct{}),
-		bridgeReader:           bridgeReader,
-		spanReader:             spanReader,
+		chainConfig:    chainConfig,
+		config:         borConfig,
+		DB:             db,
+		blockReader:    blockReader,
+		Recents:        recents,
+		Signatures:     signatures,
+		spanner:        spanner,
+		stateReceiver:  genesisContracts,
+		HeimdallClient: heimdallClient,
+		execCtx:        context.Background(),
+		logger:         logger,
+		closeCh:        make(chan struct{}),
+		bridgeReader:   bridgeReader,
+		spanReader:     spanReader,
 	}
 
 	c.authorizedSigner.Store(&signer{
@@ -670,7 +670,7 @@ func (c *Bor) initFrozenSnapshot(chain consensus.ChainHeaderReader, number uint6
 		// get validators and current span
 		var validators []*valset.Validator
 
-		validators, err = c.spanner.GetCurrentValidators(0, c.authorizedSigner.Load().signer, chain)
+		validators, err = c.spanner.GetCurrentValidators(0, chain)
 
 		if err != nil {
 			return nil, err
@@ -922,7 +922,7 @@ func (c *Bor) Prepare(chain consensus.ChainHeaderReader, header *types.Header, s
 	// in Erigon, use directly the `GetCurrentProducers` function.
 	if isSprintStart(number+1, c.config.CalculateSprintLength(number)) {
 		spanID := uint64(heimdall.SpanIdAt(number + 1))
-		newValidators, err := c.spanner.GetCurrentProducers(spanID, c.authorizedSigner.Load().signer, chain)
+		newValidators, err := c.spanner.GetCurrentProducers(spanID, chain)
 		if err != nil {
 			return errUnknownValidators
 		}
@@ -1556,7 +1556,7 @@ func (c *Bor) CommitStates(
 	}
 
 	for _, event := range events {
-		if err := c.GenesisContractsClient.CommitState(event, syscall); err != nil {
+		if err := c.stateReceiver.CommitState(event, syscall); err != nil {
 			return err
 		}
 	}

polygon/bor/bor_test.go

@@ -25,6 +25,9 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/require"
+	"go.uber.org/mock/gomock"
+
 	"github.com/erigontech/erigon/polygon/bor/borcfg"
 	"github.com/erigontech/erigon/polygon/heimdall"
 
@@ -166,17 +169,6 @@ func (h test_heimdall) FetchLatestSpan(ctx context.Context) (*heimdall.Span, err
 
 func (h test_heimdall) Close() {}
 
-type test_genesisContract struct {
-}
-
-func (g test_genesisContract) CommitState(event rlp.RawValue, syscall consensus.SystemCall) error {
-	return nil
-}
-
-func (g test_genesisContract) LastStateId(syscall consensus.SystemCall) (*big.Int, error) {
-	return big.NewInt(0), nil
-}
-
 type headerReader struct {
 	validator validator
 }
@@ -240,7 +232,7 @@ func (c *spanner) CommitSpan(heimdallSpan heimdall.Span, syscall consensus.Syste
 	return nil
 }
 
-func (c *spanner) GetCurrentValidators(spanId uint64, signer libcommon.Address, chain consensus.ChainHeaderReader) ([]*valset.Validator, error) {
+func (c *spanner) GetCurrentValidators(spanId uint64, chain consensus.ChainHeaderReader) ([]*valset.Validator, error) {
 	return []*valset.Validator{
 		{
 			ID:               1,
@@ -311,8 +303,11 @@ func (v validator) verifyBlocks(blocks []*types.Block) error {
 
 func newValidator(t *testing.T, heimdall *test_heimdall, blocks map[uint64]*types.Block) validator {
 	logger := log.Root()
-
-	validatorKey, _ := crypto.GenerateKey()
+	ctrl := gomock.NewController(t)
+	stateReceiver := bor.NewMockStateReceiver(ctrl)
+	stateReceiver.EXPECT().CommitState(gomock.Any(), gomock.Any()).AnyTimes()
+	validatorKey, err := crypto.GenerateKey()
+	require.NoError(t, err)
 	validatorAddress := crypto.PubkeyToAddress(validatorKey.PublicKey)
 	bor := bor.New(
 		heimdall.chainConfig,
@@ -323,7 +318,7 @@ func newValidator(t *testing.T, heimdall *test_heimdall, blocks map[uint64]*type
 			validatorAddress: validatorAddress,
 		},
 		heimdall,
-		test_genesisContract{},
+		stateReceiver,
 		logger,
 		nil,
 		nil,

polygon/bor/genesis_contracts.go

@@ -17,16 +17,9 @@
 package bor
 
 import (
-	"math/big"
 	"strings"
 
-	"github.com/erigontech/erigon-lib/log/v3"
-
-	"github.com/erigontech/erigon-lib/chain"
-	libcommon "github.com/erigontech/erigon-lib/common"
 	"github.com/erigontech/erigon/accounts/abi"
-	"github.com/erigontech/erigon/consensus"
-	"github.com/erigontech/erigon/rlp"
 )
 
 const (
@@ -42,62 +35,7 @@ var (
 func GenesisContractValidatorSetABI() abi.ABI {
 	return validatorSetABI
 }
+
 func GenesisContractStateReceiverABI() abi.ABI {
 	return stateReceiverABI
 }
-
-type GenesisContracts interface {
-	CommitState(event rlp.RawValue, syscall consensus.SystemCall) error
-	LastStateId(syscall consensus.SystemCall) (*big.Int, error)
-}
-
-type GenesisContractsClient struct {
-	validatorSetABI       abi.ABI
-	stateReceiverABI      abi.ABI
-	ValidatorContract     libcommon.Address
-	StateReceiverContract libcommon.Address
-	chainConfig           *chain.Config
-	logger                log.Logger
-}
-
-func NewGenesisContractsClient(
-	chainConfig *chain.Config,
-	validatorContract,
-	stateReceiverContract string,
-	logger log.Logger,
-) *GenesisContractsClient {
-	return &GenesisContractsClient{
-		validatorSetABI:       GenesisContractValidatorSetABI(),
-		stateReceiverABI:      GenesisContractStateReceiverABI(),
-		ValidatorContract:     libcommon.HexToAddress(validatorContract),
-		StateReceiverContract: libcommon.HexToAddress(stateReceiverContract),
-		chainConfig:           chainConfig,
-		logger:                logger,
-	}
-}
-
-func (gc *GenesisContractsClient) CommitState(event rlp.RawValue, syscall consensus.SystemCall) error {
-	_, err := syscall(gc.StateReceiverContract, event)
-	return err
-}
-
-func (gc *GenesisContractsClient) LastStateId(syscall consensus.SystemCall) (*big.Int, error) {
-	const method = "lastStateId"
-
-	data, err := gc.stateReceiverABI.Pack(method)
-	if err != nil {
-		gc.logger.Error("[bor] Unable to pack txn for LastStateId", "err", err)
-		return nil, err
-	}
-
-	result, err := syscall(gc.StateReceiverContract, data)
-	if err != nil {
-		return nil, err
-	}
-
-	var ret = new(*big.Int)
-	if err := gc.stateReceiverABI.UnpackIntoInterface(ret, method, result); err != nil {
-		return nil, err
-	}
-	return *ret, nil
-}

polygon/bor/spanner.go

@@ -35,8 +35,8 @@ import (
 //go:generate mockgen -typed=true -destination=./spanner_mock.go -package=bor . Spanner
 type Spanner interface {
 	GetCurrentSpan(syscall consensus.SystemCall) (*heimdall.Span, error)
-	GetCurrentValidators(spanId uint64, signer libcommon.Address, chain consensus.ChainHeaderReader) ([]*valset.Validator, error)
-	GetCurrentProducers(spanId uint64, signer libcommon.Address, chain consensus.ChainHeaderReader) ([]*valset.Validator, error)
+	GetCurrentValidators(spanId uint64, chain consensus.ChainHeaderReader) ([]*valset.Validator, error)
+	GetCurrentProducers(spanId uint64, chain consensus.ChainHeaderReader) ([]*valset.Validator, error)
 	CommitSpan(heimdallSpan heimdall.Span, syscall consensus.SystemCall) error
 }
 
@@ -66,7 +66,6 @@ func NewChainSpanner(validatorSet ABI, chainConfig *chain.Config, withoutHeimdal
 
 // GetCurrentSpan get current span from contract
 func (c *ChainSpanner) GetCurrentSpan(syscall consensus.SystemCall) (*heimdall.Span, error) {
-
 	// method
 	const method = "getCurrentSpan"
 
@@ -102,7 +101,7 @@ func (c *ChainSpanner) GetCurrentSpan(syscall consensus.SystemCall) (*heimdall.S
 	return &span, nil
 }
 
-func (c *ChainSpanner) GetCurrentValidators(spanId uint64, signer libcommon.Address, chain consensus.ChainHeaderReader) ([]*valset.Validator, error) {
+func (c *ChainSpanner) GetCurrentValidators(spanId uint64, chain consensus.ChainHeaderReader) ([]*valset.Validator, error) {
 	// Use hardcoded bor devnet valset if chain-name = bor-devnet
 	if NetworkNameVals[c.chainConfig.ChainName] != nil && c.withoutHeimdall {
 		return NetworkNameVals[c.chainConfig.ChainName], nil
@@ -117,7 +116,7 @@ func (c *ChainSpanner) GetCurrentValidators(spanId uint64, signer libcommon.Addr
 	return span.ValidatorSet.Validators, nil
 }
 
-func (c *ChainSpanner) GetCurrentProducers(spanId uint64, signer libcommon.Address, chain consensus.ChainHeaderReader) ([]*valset.Validator, error) {
+func (c *ChainSpanner) GetCurrentProducers(spanId uint64, chain consensus.ChainHeaderReader) ([]*valset.Validator, error) {
 	// Use hardcoded bor devnet valset if chain-name = bor-devnet
 	if NetworkNameVals[c.chainConfig.ChainName] != nil && c.withoutHeimdall {
 		return NetworkNameVals[c.chainConfig.ChainName], nil
@@ -138,7 +137,6 @@ func (c *ChainSpanner) GetCurrentProducers(spanId uint64, signer libcommon.Addre
 }
 
 func (c *ChainSpanner) CommitSpan(heimdallSpan heimdall.Span, syscall consensus.SystemCall) error {
-
 	// method
 	const method = "commitSpan"