small fixes

consensus/polybft/bridge.go

@@ -3,7 +3,6 @@ package polybft
 import (
 	"fmt"
 
-	"github.com/0xPolygon/polygon-edge/consensus/polybft/wallet"
 	"github.com/hashicorp/go-hclog"
 	bolt "go.etcd.io/bbolt"
 )
@@ -12,10 +11,10 @@ var _ Bridge = (*bridge)(nil)
 
 // bridge is a struct that manages different bridges
 type bridge struct {
-	bridgeManagers     map[uint64]BridgeManager
-	state              *State
-	internalChainID    uint64
-	bridgeEventRelayer BridgeEventRelayer
+	bridgeManagers  map[uint64]BridgeManager
+	state           *State
+	internalChainID uint64
+	relayer         BridgeEventRelayer
 }
 
 // Bridge is an interface that defines functions that a bridge must implement
@@ -62,38 +61,14 @@ func newBridge(runtime Runtime,
 		bridge.bridgeManagers[externalChainID] = bridgeManager
 	}
 
-	if err := bridge.initBridgeEventRelayer(eventProvider, runtimeConfig, logger); err != nil {
+	relayer, err := newBridgeEventRelayer(runtimeConfig, eventProvider, logger)
+	if err != nil {
 		return nil, err
 	}
 
-	return bridge, nil
-}
+	bridge.relayer = relayer
 
-// initBridgeEventRelayer initializes bridge event relayer
-// if not enabled, then a dummy bridge event relayer will be used
-func (b *bridge) initBridgeEventRelayer(
-	eventProvider *EventProvider,
-	runtimeConfig *runtimeConfig,
-	logger hclog.Logger) error {
-	if runtimeConfig.consensusConfig.IsRelayer {
-
-		bridgeEventRelayer, err := newBridgeEventRelayer(
-			runtimeConfig,
-			wallet.NewEcdsaSigner(runtimeConfig.Key),
-			logger.Named("bridge_event_relayer"),
-		)
-		if err != nil {
-			return err
-		}
-
-		b.bridgeEventRelayer = bridgeEventRelayer
-	} else {
-		b.bridgeEventRelayer = &dummyBridgeEventRelayer{}
-	}
-
-	eventProvider.Subscribe(b.bridgeEventRelayer)
-
-	return nil
+	return bridge, nil
 }
 
 // Close calls Close on each bridge manager, which stops ongoing go routines in manager
@@ -102,7 +77,7 @@ func (b *bridge) Close() {
 		bridgeManager.Close()
 	}
 
-	b.bridgeEventRelayer.Close()
+	b.relayer.Close()
 }
 
 // PostBlock is a function executed on every block finalization (either by consensus or syncer)
@@ -114,7 +89,7 @@ func (b bridge) PostBlock(req *PostBlockRequest) error {
 		}
 	}
 
-	if err := b.bridgeEventRelayer.PostBlock(req); err != nil {
+	if err := b.relayer.PostBlock(req); err != nil {
 		return err
 	}
 

consensus/polybft/bridge_event_relayer.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 
 	"github.com/0xPolygon/polygon-edge/consensus/polybft/contractsapi"
+	"github.com/0xPolygon/polygon-edge/consensus/polybft/wallet"
 	"github.com/0xPolygon/polygon-edge/contracts"
 	"github.com/0xPolygon/polygon-edge/crypto"
 	"github.com/0xPolygon/polygon-edge/txrelayer"
@@ -66,74 +67,88 @@ type bridgeEventRelayerImpl struct {
 	eventTrackers []*tracker.EventTracker
 }
 
+// newBridgeEventRelayer creates a new instance of bridge event relayer
+// if the node is not a relayer, it will return a dummy bridge event relayer
 func newBridgeEventRelayer(
 	runtimeConfig *runtimeConfig,
-	key crypto.Key,
+	eventProvider *EventProvider,
 	logger hclog.Logger,
 ) (BridgeEventRelayer, error) {
-	var relayer BridgeEventRelayer
-	txRelayerMap := make(map[uint64]txrelayer.TxRelayer)
+	if !runtimeConfig.consensusConfig.IsRelayer {
+		return &dummyBridgeEventRelayer{}, nil
+	}
+
+	relayer := &bridgeEventRelayerImpl{
+		key:           wallet.NewEcdsaSigner(runtimeConfig.Key),
+		logger:        logger,
+		runtimeConfig: runtimeConfig,
+	}
+
+	txRelayers := make(map[uint64]txrelayer.TxRelayer, len(runtimeConfig.GenesisConfig.Bridge))
+	trackers := make([]*tracker.EventTracker, 0, len(runtimeConfig.GenesisConfig.Bridge))
+
 	for chainID, config := range runtimeConfig.GenesisConfig.Bridge {
-		txRelayer, err := getBridgeTxRelayer(config.JSONRPCEndpoint, logger)
+		txRelayer, err := createBridgeTxRelayer(config.JSONRPCEndpoint, logger)
 		if err != nil {
 			return nil, err
 		}
 
-		txRelayerMap[chainID] = txRelayer
-	}
+		txRelayers[chainID] = txRelayer
 
-	relayerImpl := &bridgeEventRelayerImpl{
-		key:           key,
-		logger:        logger,
-		txRelayers:    txRelayerMap,
-		runtimeConfig: runtimeConfig,
-	}
+		tracker, err := relayer.startTrackerForChain(chainID, config, runtimeConfig)
+		if err != nil {
+			return nil, err
+		}
 
-	if err := relayerImpl.initTrackers(runtimeConfig); err != nil {
-		return nil, err
+		trackers = append(trackers, tracker)
 	}
 
+	relayer.txRelayers = txRelayers
+	relayer.eventTrackers = trackers
+
+	eventProvider.Subscribe(relayer)
+
 	return relayer, nil
 }
-func (ber *bridgeEventRelayerImpl) initTrackers(runtimeConfig *runtimeConfig) error {
+
+// startTrackerForChain starts a new instance of tracker.EventTracker
+// for listening to the events from an external chain
+func (ber *bridgeEventRelayerImpl) startTrackerForChain(chainID uint64,
+	bridgeCfg *BridgeConfig, runtimeCfg *runtimeConfig) (*tracker.EventTracker, error) {
 	var (
 		bridgeMessageResultEventSig    = new(contractsapi.BridgeMessageResultEvent).Sig()
 		gatewayNewValidatorSetEventSig = new(contractsapi.NewValidatorSetEvent).Sig()
 	)
 
-	for chainID, bridgeConfig := range runtimeConfig.GenesisConfig.Bridge {
-		store, err := store.NewBoltDBEventTrackerStore(
-			path.Join(runtimeConfig.DataDir, fmt.Sprintf("/bridge-event-relayer%d.db", chainID)))
-		if err != nil {
-			return err
-		}
+	store, err := store.NewBoltDBEventTrackerStore(
+		path.Join(runtimeCfg.DataDir, fmt.Sprintf("/bridge-event-relayer%d.db", chainID)))
+	if err != nil {
+		return nil, err
+	}
 
-		eventTracker, err := tracker.NewEventTracker(
-			&tracker.EventTrackerConfig{
-				EventSubscriber:        ber,
-				Logger:                 ber.logger,
-				RPCEndpoint:            bridgeConfig.JSONRPCEndpoint,
-				SyncBatchSize:          runtimeConfig.eventTracker.SyncBatchSize,
-				NumBlockConfirmations:  runtimeConfig.eventTracker.NumBlockConfirmations,
-				NumOfBlocksToReconcile: runtimeConfig.eventTracker.NumOfBlocksToReconcile,
-				PollInterval:           runtimeConfig.GenesisConfig.BlockTrackerPollInterval.Duration,
-				LogFilter: map[ethgo.Address][]ethgo.Hash{
-					ethgo.Address(bridgeConfig.ExternalGatewayAddr): {
-						bridgeMessageResultEventSig,
-						gatewayNewValidatorSetEventSig},
-				},
+	eventTracker, err := tracker.NewEventTracker(
+		&tracker.EventTrackerConfig{
+			EventSubscriber:        ber,
+			Logger:                 ber.logger,
+			RPCEndpoint:            bridgeCfg.JSONRPCEndpoint,
+			SyncBatchSize:          runtimeCfg.eventTracker.SyncBatchSize,
+			NumBlockConfirmations:  runtimeCfg.eventTracker.NumBlockConfirmations,
+			NumOfBlocksToReconcile: runtimeCfg.eventTracker.NumOfBlocksToReconcile,
+			PollInterval:           runtimeCfg.GenesisConfig.BlockTrackerPollInterval.Duration,
+			LogFilter: map[ethgo.Address][]ethgo.Hash{
+				ethgo.Address(bridgeCfg.ExternalGatewayAddr): {
+					bridgeMessageResultEventSig,
+					gatewayNewValidatorSetEventSig},
 			},
-			store,
-			bridgeConfig.EventTrackerStartBlocks[bridgeConfig.ExternalGatewayAddr],
-		)
-		if err != nil {
-			return err
-		}
-
-		ber.eventTrackers = append(ber.eventTrackers, eventTracker)
+		},
+		store,
+		bridgeCfg.EventTrackerStartBlocks[bridgeCfg.ExternalGatewayAddr],
+	)
+	if err != nil {
+		return nil, err
 	}
 
-	return nil
+	return eventTracker, eventTracker.Start()
 }
 
 func (ber *bridgeEventRelayerImpl) PostBlock(req *PostBlockRequest) error {
@@ -311,7 +326,9 @@ func (ber *bridgeEventRelayerImpl) Close() {
 	}
 }
 
-func getBridgeTxRelayer(rpcEndpoint string, logger hclog.Logger) (txrelayer.TxRelayer, error) {
+// createBridgeTxRelayer creates a new instance of txrelayer.TxRelayer
+// used for sending transactions to the external chain
+func createBridgeTxRelayer(rpcEndpoint string, logger hclog.Logger) (txrelayer.TxRelayer, error) {
 	if rpcEndpoint == "" || strings.Contains(rpcEndpoint, "0.0.0.0") {
 		_, port, err := net.SplitHostPort(rpcEndpoint)
 		if err == nil {

consensus/polybft/bridge_manager.go

@@ -16,16 +16,6 @@ import (
 	bolt "go.etcd.io/bbolt"
 )
 
-const (
-	// defaultMaxBlocksToWaitForResend specifies how many blocks should be wait
-	// in order to try again to send transaction
-	defaultMaxBlocksToWaitForResend = uint64(30)
-	// defaultMaxAttemptsToSend specifies how many sending retries for one transaction
-	defaultMaxAttemptsToSend = uint64(15)
-	// defaultMaxEventsPerBatch specifies maximum events per one batchExecute tx
-	defaultMaxEventsPerBatch = uint64(10)
-)
-
 var bridgeMessageEventSig = new(contractsapi.BridgeMsgEvent).Sig()
 
 // eventTrackerConfig is a struct that holds the event tracker configuration

consensus/polybft/consensus_runtime_test.go

@@ -1151,8 +1151,8 @@ func createTestBridge(t *testing.T, state *State) Bridge {
 	manager := &mockBridgeManager{state: state, chainID: 1}
 
 	return &bridge{
-		bridgeManagers:     map[uint64]BridgeManager{1: manager},
-		state:              state,
-		bridgeEventRelayer: &dummyBridgeEventRelayer{},
+		bridgeManagers: map[uint64]BridgeManager{1: manager},
+		state:          state,
+		relayer:        &dummyBridgeEventRelayer{},
 	}
 }

consensus/polybft/extra_test.go

@@ -588,11 +588,6 @@ func Test_GetIbftExtraClean_Fail(t *testing.T) {
 }
 
 func TestBlockMetaData_Hash(t *testing.T) {
-	const (
-		chainID     = uint64(1)
-		blockNumber = uint64(27)
-	)
-
 	blockHash := types.BytesToHash(generateRandomBytes(t))
 	origBlockMeta := &BlockMetaData{
 		BlockRound:  0,

consensus/polybft/fsm.go

@@ -283,18 +283,6 @@ func (f *fsm) applyValidatorSetCommitTx(nextValidators validator.AccountSet, ext
 	return f.blockBuilder.WriteTx(tx)
 }
 
-// getValidatorsTransition applies delta to the current validators,
-func (f *fsm) getValidatorsTransition(delta *validator.ValidatorSetDelta) (validator.AccountSet, error) {
-	nextValidators, err := f.validators.Accounts().ApplyDelta(delta)
-	if err != nil {
-		return nil, err
-	}
-
-	f.logger.Debug("getValidatorsTransition", "Next validators", nextValidators)
-
-	return nextValidators, nil
-}
-
 // createCommitEpochTx create a StateTransaction, which invokes ValidatorSet smart contract
 // and sends all the necessary metadata to it.
 func (f *fsm) createCommitEpochTx() (*types.Transaction, error) {