dbft: optimize the API for obtaining the list of validators

Author: qianhh

consensus/dbft/dbft.go

@@ -426,16 +426,16 @@ func (c *DBFT) getValidatorsCb(txs ...dbft.Transaction[common.Hash]) []dbft.Publ
 		err   error
 	)
 	if txs == nil {
-		// GetValidatorsSorted with empty args is used by dbft to fill the list of
+		// GetValidatorsSortedByBlockNumber is used by dbft to fill the list of
 		// block's validators, thus should return validators from the current
 		// epoch without recalculation.
 		if c.backend != nil {
-			pKeys, err = c.backend.GetValidatorsSorted(&c.lastIndex, nil, nil)
+			pKeys, err = c.backend.GetValidatorsSortedByBlockNumber(c.lastIndex)
 		} else {
 			err = errNotInitializedBackend
 		}
 	}
-	// GetValidatorsSorted with non-empty args is used by dbft to fill block's
+	// GetValidatorsSortedByState is used by dbft to fill block's
 	// NextConsensus field, but DBFT doesn't provide WithGetConsensusAddress
 	// callback and fills NextConsensus by itself via WithNewBlockFromContext
 	// callback. Thus, leave pKeys empty if txes != nil.
@@ -2405,7 +2405,7 @@ func (c *DBFT) validatePayload(p *Payload) error {
 	if c.backend == nil {
 		return errNotInitializedBackend
 	}
-	validators, err := c.backend.GetValidatorsSorted(&h, nil, nil)
+	validators, err := c.backend.GetValidatorsSortedByBlockNumber(h)
 	if err != nil {
 		return fmt.Errorf("failed to get next block validators: %w", err)
 	}
@@ -2491,7 +2491,7 @@ func (c *DBFT) calcDifficulty(signer common.Address, parent *types.Header) *big.
 	if c.backend == nil {
 		return nil
 	}
-	vals, err := c.backend.GetValidatorsSorted(&h, nil, nil)
+	vals, err := c.backend.GetValidatorsSortedByBlockNumber(h)
 	if err != nil {
 		return nil
 	}
@@ -2712,7 +2712,7 @@ func (c *DBFT) getNextConsensus(h *types.Header, s *state.StateDB) (common.Hash,
 	if c.backend == nil {
 		log.Crit("Can't calculate next consensus", "err", errNotInitializedBackend)
 	}
-	nextVals, err := c.backend.GetValidatorsSorted(nil, s.Copy(), h)
+	nextVals, err := c.backend.GetValidatorsSortedByState(s.Copy(), h)
 	if err != nil {
 		log.Crit("Failed to compute next block validators",
 			"err", err)

eth/api_backend.go

@@ -470,8 +470,12 @@ func (b *EthAPIBackend) IsExtensibleAllowed(blockNum uint64, addr common.Address
 	return b.eth.extensibleVerifier.IsExtensibleAllowed(blockNum, addr)
 }
 
-func (b *EthAPIBackend) GetValidatorsSorted(blockNum *uint64, state *state.StateDB, header *types.Header) ([]common.Address, error) {
-	return b.eth.extensibleVerifier.GetValidatorsSorted(blockNum, state, header)
+func (b *EthAPIBackend) GetValidatorsSortedByBlockNumber(blockNum uint64) ([]common.Address, error) {
+	return b.eth.extensibleVerifier.GetValidatorsSortedByBlockNumber(blockNum)
+}
+
+func (b *EthAPIBackend) GetValidatorsSortedByState(state *state.StateDB, header *types.Header) ([]common.Address, error) {
+	return b.eth.extensibleVerifier.GetValidatorsSortedByState(state, header)
 }
 
 func (b *EthAPIBackend) GetDKGIndex(blockNum uint64, validatorIndex int) (int, error) {

eth/verifier/extensible_verifier.go

@@ -115,48 +115,47 @@ func (v *ExtensibleVerifier) Close() {
 
 // IsExtensibleAllowed determines if address is allowed to send extensible payloads
 // (only consensus payloads for now) at the specified height.
-func (v *ExtensibleVerifier) IsExtensibleAllowed(h uint64, u common.Address) error {
+func (v *ExtensibleVerifier) IsExtensibleAllowed(blockNum uint64, addr common.Address) error {
 	// Can't verify extensible sender if the node has an outdated state.
 	if v.syncing.Load() {
 		return dbftproto.ErrSyncing
 	}
 	// Only validators are included into extensible whitelist for now.
-	validators, err := v.GetValidatorsSorted(&h, nil, nil)
+	validators, err := v.GetValidatorsSortedByBlockNumber(blockNum)
 	if err != nil {
 		return fmt.Errorf("failed to get validators: %w", err)
 	}
-	_, found := slices.BinarySearchFunc(validators, u, common.Address.Cmp)
+	_, found := slices.BinarySearchFunc(validators, addr, common.Address.Cmp)
 	if !found {
 		return fmt.Errorf("address is not a validator")
 	}
 	return nil
 }
 
-// GetValidatorsSorted returns validators chosen in the result of the latest
-// finalized voting epoch. It calls Governance contract under the hood. The call
-// is based on the provided state or (if not provided) on the state of the block
-// with the specified height. Validators returned from this method are always
-// sorted by bytes order (even if the list returned from governance contract is
-// sorted in another way). This method uses cached values in case of validators
-// requested by block height.
-func (v *ExtensibleVerifier) GetValidatorsSorted(blockNum *uint64, state *state.StateDB, header *types.Header) ([]common.Address, error) {
-	res, err := v.getValidators(blockNum, state, header)
-	if err != nil {
-		return nil, err
-	}
+// GetValidatorsSortedByBlockNumber returns validators chosen in the result of the
+// latest finalized voting epoch. It calls Governance contract under the hood. The
+// call is based on the state of the block with the specified height. Validators
+// returned from this method are sorted in the original order used by Governance
+// contract. This method will use the cached values.
+func (v *ExtensibleVerifier) GetValidatorsSortedByBlockNumber(blockNum uint64) ([]common.Address, error) {
+	return v.getValidatorsSorted(&blockNum, nil, nil)
+}
 
-	sortedList := slices.Clone(res)
-	slices.SortFunc(sortedList, common.Address.Cmp)
-	return sortedList, err
+// GetValidatorsSortedByState returns validators chosen in the result of the latest
+// finalized voting epoch. It calls Governance contract under the hood. The call is
+// based on the provided state. Validators returned from this method are sorted in
+// the original order used by Governance contract.
+func (v *ExtensibleVerifier) GetValidatorsSortedByState(state *state.StateDB, header *types.Header) ([]common.Address, error) {
+	return v.getValidatorsSorted(nil, state, header)
 }
 
-// getValidators returns validators chosen in the result of the latest finalized
+// getValidatorsSorted returns validators chosen in the result of the latest finalized
 // voting epoch. It calls Governance contract under the hood. The call is based
 // on the provided state or (if not provided) on the state of the block with the
 // specified height. Validators returned from this method are sorted in the original
 // order used by Governance contract. This method uses cached values in case of
 // validators requested by block height.
-func (v *ExtensibleVerifier) getValidators(blockNum *uint64, state *state.StateDB, header *types.Header) ([]common.Address, error) {
+func (v *ExtensibleVerifier) getValidatorsSorted(blockNum *uint64, state *state.StateDB, header *types.Header) ([]common.Address, error) {
 	if state == nil && blockNum != nil {
 		vals, ok := v.validatorsCache.Get(*blockNum)
 		if ok {
@@ -193,18 +192,20 @@ func (v *ExtensibleVerifier) getValidators(blockNum *uint64, state *state.StateD
 	if err != nil {
 		return nil, fmt.Errorf("failed to perform '%s' call: %w", method, err)
 	}
-	var res []common.Address
-	err = unpackContractExecutionResult(&res, result, systemcontracts.GovernanceABI, method)
+	var validators []common.Address
+	err = unpackContractExecutionResult(&validators, result, systemcontracts.GovernanceABI, method)
 	if err != nil {
 		return nil, err
 	}
 
+	slices.SortFunc(validators, common.Address.Cmp)
+
 	// Update cache in case if existing state was used for validators retrieval.
 	if state == nil && blockNum != nil {
-		_ = v.validatorsCache.Add(*blockNum, res)
+		_ = v.validatorsCache.Add(*blockNum, validators)
 	}
 
-	return res, err
+	return validators, err
 }
 
 func unpackContractExecutionResult(res interface{}, result *core.ExecutionResult, contractAbi abi.ABI, method string) error {
@@ -223,7 +224,7 @@ func unpackContractExecutionResult(res interface{}, result *core.ExecutionResult
 func (v *ExtensibleVerifier) GetDKGIndex(blockNum uint64, validatorIndex int) (int, error) {
 	indices, ok := v.dkgIndexCache.Get(blockNum)
 	if !ok {
-		originValidators, err := v.getValidators(&blockNum, nil, nil)
+		originValidators, err := v.getValidatorsSorted(&blockNum, nil, nil)
 		if err != nil {
 			return -1, err
 		}

internal/ethapi/backend.go

@@ -106,7 +106,8 @@ type Backend interface {
 	IsExtensibleAllowed(blockNum uint64, addr common.Address) error
 
 	// Validators API
-	GetValidatorsSorted(blockNum *uint64, state *state.StateDB, header *types.Header) ([]common.Address, error)
+	GetValidatorsSortedByBlockNumber(blockNum uint64) ([]common.Address, error)
+	GetValidatorsSortedByState(state *state.StateDB, header *types.Header) ([]common.Address, error)
 	GetDKGIndex(blockNum uint64, validatorIndex int) (int, error)
 }