fix: added error logs

executor/executor.go

@@ -42,6 +42,7 @@ func NewExecutor(cfg *config.Config) *Executor {
 
 	km, err := sdkkeys.NewPrivateKeyManager(privKey)
 	if err != nil {
+		logging.Logger.Errorf("executor failed to initiate with a key manager, err=%s", err.Error())
 		panic(err)
 	}
 
@@ -66,6 +67,7 @@ func getGreenfieldPrivateKey(cfg *config.GreenfieldConfig) string {
 	if cfg.KeyType == config.KeyTypeAWSPrivateKey {
 		result, err := config.GetSecret(cfg.AWSSecretName, cfg.AWSRegion)
 		if err != nil {
+			logging.Logger.Errorf("failed to get aws secret from config file, err=%s", err.Error())
 			panic(err)
 		}
 		type AwsPrivateKey struct {
@@ -74,6 +76,7 @@ func getGreenfieldPrivateKey(cfg *config.GreenfieldConfig) string {
 		var awsPrivateKey AwsPrivateKey
 		err = json.Unmarshal([]byte(result), &awsPrivateKey)
 		if err != nil {
+			logging.Logger.Errorf("failed to unmarshal aws private key, err=%s", err.Error())
 			panic(err)
 		}
 		privateKey = awsPrivateKey.PrivateKey
@@ -86,6 +89,7 @@ func getGreenfieldPrivateKey(cfg *config.GreenfieldConfig) string {
 func (e *Executor) getRpcClient() (client.Client, error) {
 	client, err := e.gnfdClients.GetClient()
 	if err != nil {
+		logging.Logger.Errorf("executor failed to get rpc client, err=%s", err.Error())
 		return nil, err
 	}
 	return client.TendermintClient.RpcClient.TmClient, nil
@@ -94,6 +98,7 @@ func (e *Executor) getRpcClient() (client.Client, error) {
 func (e *Executor) GetGnfdClient() (*sdkclient.GreenfieldClient, error) {
 	client, err := e.gnfdClients.GetClient()
 	if err != nil {
+		logging.Logger.Errorf("executor failed to get greenfield client, err=%s", err.Error())
 		return nil, err
 	}
 	return client.GreenfieldClient, nil
@@ -111,10 +116,12 @@ func (e *Executor) GetBlockAndBlockResultAtHeight(height int64) (*tmtypes.Block,
 	}
 	block, err := client.Block(context.Background(), &height)
 	if err != nil {
+		logging.Logger.Errorf("executor failed to get block at height %d, err=%s", height, err.Error())
 		return nil, nil, err
 	}
 	blockResults, err := client.BlockResults(context.Background(), &height)
 	if err != nil {
+		logging.Logger.Errorf("executor failed to get block results at height %d, err=%s", height, err.Error())
 		return nil, nil, err
 	}
 	return block.Block, blockResults, nil
@@ -123,6 +130,7 @@ func (e *Executor) GetBlockAndBlockResultAtHeight(height int64) (*tmtypes.Block,
 func (e *Executor) GetLatestBlockHeight() (latestHeight uint64, err error) {
 	client, err := e.gnfdClients.GetClient()
 	if err != nil {
+		logging.Logger.Errorf("executor failed to get greenfield clients, err=%s", err.Error())
 		return 0, err
 	}
 	return uint64(client.Height), nil
@@ -135,6 +143,7 @@ func (e *Executor) queryLatestValidators() ([]*tmtypes.Validator, error) {
 	}
 	validators, err := client.Validators(context.Background(), nil, nil, nil)
 	if err != nil {
+		logging.Logger.Errorf("executor failed to query the latest validators, err=%s", err.Error())
 		return nil, err
 	}
 	return validators.Validators, nil
@@ -185,6 +194,7 @@ func (e *Executor) SendAttestTx(challengeId uint64, objectId, spOperatorAddress
 
 	acc, err := sdk.AccAddressFromHexUnsafe(e.address)
 	if err != nil {
+		logging.Logger.Errorf("error converting addr from hex unsafe when sending attest tx, err=%s", err.Error())
 		return "", err
 	}
 
@@ -204,6 +214,7 @@ func (e *Executor) SendAttestTx(challengeId uint64, objectId, spOperatorAddress
 		nil,
 	)
 	if err != nil {
+		logging.Logger.Errorf("error broadcasting msg attest, err=%s", err.Error())
 		return "", err
 	}
 	if txRes.TxResponse.Code != 0 {
@@ -220,6 +231,7 @@ func (e *Executor) QueryLatestAttestedChallenge() (uint64, error) {
 
 	res, err := client.ChallengeQueryClient.LatestAttestedChallenge(context.Background(), &challangetypes.QueryLatestAttestedChallengeRequest{})
 	if err != nil {
+		logging.Logger.Errorf("executor failed to get latest attested challenge, err=%s", err.Error())
 		return 0, err
 	}
 
@@ -234,6 +246,7 @@ func (e *Executor) GetStorageProviderEndpoint(address string) (string, error) {
 
 	res, err := client.SpQueryClient.StorageProvider(context.Background(), &sptypes.QueryStorageProviderRequest{SpAddress: address})
 	if err != nil {
+		logging.Logger.Errorf("executor failed to query storage provider %s, err=%s", address, err.Error())
 		return "", err
 	}
 
@@ -249,6 +262,7 @@ func (e *Executor) GetObjectInfoChecksums(objectId string) ([][]byte, error) {
 	headObjQueryReq := storagetypes.QueryHeadObjectByIdRequest{ObjectId: objectId}
 	res, err := client.StorageQueryClient.HeadObjectById(context.Background(), &headObjQueryReq)
 	if err != nil {
+		logging.Logger.Errorf("executor failed to query storage client for objectId %s, err=%s", objectId, err.Error())
 		return nil, err
 	}
 	return res.ObjectInfo.Checksums, nil
@@ -257,6 +271,7 @@ func (e *Executor) GetObjectInfoChecksums(objectId string) ([][]byte, error) {
 func (e *Executor) GetChallengeResultFromSp(endpoint string, objectId string, segmentIndex, redundancyIndex int) (*sp.ChallengeResult, error) {
 	spUrl, err := url.Parse(endpoint)
 	if err != nil {
+		logging.Logger.Errorf("executor failed to parse sp url %s, err=%s", endpoint, err.Error())
 		return nil, err
 	}
 	e.spClient.SetUrl(spUrl)
@@ -269,6 +284,7 @@ func (e *Executor) GetChallengeResultFromSp(endpoint string, objectId string, se
 	authInfo := sp.NewAuthInfo(false, "") // TODO: fill auth info when sp api is ready
 	challengeRes, err := e.spClient.ChallengeSP(context.Background(), challengeInfo, authInfo)
 	if err != nil {
+		logging.Logger.Errorf("executor failed to query challenge result info from sp client for objectId %s, err=%s", objectId, err.Error())
 		return nil, err
 	}
 	return &challengeRes, nil
@@ -286,6 +302,7 @@ func (e *Executor) QueryVotes(eventHash []byte, eventType votepool.EventType) ([
 	var queryVote coretypes.ResultQueryVote
 	_, err = client.JsonRpcClient.Call(context.Background(), VotePoolQueryMethodName, queryMap, &queryVote)
 	if err != nil {
+		logging.Logger.Errorf("executor failed to query votes for event hash %s event type %s, err=%s", string(eventHash), string(eventType), err.Error())
 		return nil, err
 	}
 	return queryVote.Votes, nil
@@ -300,6 +317,7 @@ func (e *Executor) BroadcastVote(v *votepool.Vote) error {
 	broadcastMap[VotePoolBroadcastParameterKey] = *v
 	_, err = client.JsonRpcClient.Call(context.Background(), VotePoolBroadcastMethodName, broadcastMap, &ctypes.ResultBroadcastVote{})
 	if err != nil {
+		logging.Logger.Errorf("executor failed to broadcast vote to votepool for event hash %s event type %s, err=%s", string(v.EventHash), string(v.EventType), err.Error())
 		return err
 	}
 	return nil

submitter/tx_submitter.go

@@ -41,6 +41,7 @@ func (s *TxSubmitter) SubmitTransactionLoop() {
 func (s *TxSubmitter) process() error {
 	events, err := s.FetchEventsForSubmit()
 	if err != nil {
+		logging.Logger.Errorf("tx submitter failed to fetch events for submitting, err=%s", err.Error())
 		return err
 	}
 	if len(events) == 0 {
@@ -62,7 +63,7 @@ func (s *TxSubmitter) submitForSingleEvent(event *model.Event) error {
 	// Get votes result for s tx, which are already validated and qualified to aggregate sig
 	votes, err := s.FetchVotesForAggregation(event.ChallengeId)
 	if err != nil {
-		logging.Logger.Errorf("failed to get votes for event with challenge id %d", event.ChallengeId)
+		logging.Logger.Errorf("failed to get votes for event with challenge id %d, err=%s", event.ChallengeId, err.Error())
 		return err
 	}
 	validators, err := s.executor.QueryCachedLatestValidators()

verifier/hash_verifier.go

@@ -3,6 +3,7 @@ package verifier
 import (
 	"bytes"
 	"encoding/hex"
+	"github.com/bnb-chain/greenfield-challenger/logging"
 	"io"
 	"time"
 
@@ -46,6 +47,7 @@ func (v *Verifier) verifyHash() error {
 	// Read unprocessed event from db with lowest challengeId
 	events, err := v.daoManager.EventDao.GetEarliestEventByStatus(model.Unprocessed, 10)
 	if err != nil {
+		logging.Logger.Errorf("verifier failed to retrieve the earliest events from db to begin verification, err=%s", err.Error())
 		return err
 	}
 	if len(events) == 0 {
@@ -72,6 +74,7 @@ func (v *Verifier) verifyForSingleEvent(event *model.Event) error {
 		found, err := v.daoManager.EventDao.IsEventExistsBetween(event.ObjectId, event.SpOperatorAddress,
 			event.ChallengeId-v.deduplicationInterval, event.ChallengeId-1)
 		if err != nil {
+			logging.Logger.Errorf("verifier failed to retrieve information for event %d, err=%s", event.ChallengeId, err.Error())
 			return err
 		}
 		if found {
@@ -89,39 +92,38 @@ func (v *Verifier) verifyForSingleEvent(event *model.Event) error {
 	// Call StorageProvider API to get piece hashes of the event
 	spEndpoint, err := v.executor.GetStorageProviderEndpoint(event.SpOperatorAddress)
 	if err != nil {
+		logging.Logger.Errorf("verifier failed to get piece hashes from StorageProvider for event %d, err=%s", event.ChallengeId, err.Error())
 		return err
 	}
 	challengeRes, err := v.executor.GetChallengeResultFromSp(spEndpoint, event.ObjectId,
 		int(event.SegmentIndex), int(event.RedundancyIndex))
 
 	pieceData, err := io.ReadAll(challengeRes.PieceData)
 	if err != nil {
+		logging.Logger.Errorf("verifier failed to read piece data for event %d, err=%s", event.ChallengeId, err.Error())
 		return err
 	}
 	spChecksums := make([][]byte, 0)
 	for _, h := range challengeRes.PiecesHash {
 		checksum, err := hex.DecodeString(h)
 		if err != nil {
+			logging.Logger.Errorf("verifier failed to decode piece hash for event %d, err=%s", event.ChallengeId, err.Error())
 			return err
 		}
 		spChecksums = append(checksums, checksum)
 	}
-	spRootHash, err := v.computeRootHash(event.SegmentIndex, pieceData, spChecksums)
-	if err != nil {
-		return err
-	}
-
+	spRootHash := v.computeRootHash(event.SegmentIndex, pieceData, spChecksums)
 	// Update database after comparing
 	return v.compareHashAndUpdate(event.ChallengeId, chainRootHash, spRootHash)
 }
 
-func (v *Verifier) computeRootHash(segmentIndex uint32, pieceData []byte, checksums [][]byte) ([]byte, error) {
+func (v *Verifier) computeRootHash(segmentIndex uint32, pieceData []byte, checksums [][]byte) []byte {
 	// Hash the piece that is challenged, replace original checksum, recompute new root hash
 	dataHash := hash.CalcSHA256(pieceData)
 	checksums[segmentIndex] = dataHash
 	total := bytes.Join(checksums, []byte(""))
 	rootHash := []byte(hash.CalcSHA256Hex(total))
-	return rootHash, nil
+	return rootHash
 }
 
 func (v *Verifier) compareHashAndUpdate(challengeId uint64, newHash []byte, originalHash []byte) error {

vote/data_provider.go

@@ -2,6 +2,7 @@ package vote
 
 import (
 	"encoding/binary"
+	"github.com/bnb-chain/greenfield-challenger/logging"
 
 	sdkmath "cosmossdk.io/math"
 	"github.com/bnb-chain/greenfield-challenger/db/dao"
@@ -60,6 +61,7 @@ func (h *DataHandler) CalculateEventHash(event *model.Event) [32]byte {
 func (h *DataHandler) FetchEventsForSelfVote() ([]*model.Event, error) {
 	events, err := h.daoManager.GetEarliestEventsByStatusAndAfter(model.Verified, batchSize, h.lastIdForSelfVote)
 	if err != nil {
+		logging.Logger.Errorf("failed to fetch events for self vote, err=%s", err.Error())
 		return nil, err
 	}
 

vote/util.go

@@ -2,6 +2,7 @@ package vote
 
 import (
 	"encoding/hex"
+	"github.com/bnb-chain/greenfield-challenger/logging"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
@@ -57,6 +58,7 @@ func AggregateSignatureAndValidatorBitSet(votes []*model.Vote, validators []*tmt
 
 	sigs, err := bls.MultipleSignaturesFromBytes(signatures)
 	if err != nil {
+		logging.Logger.Errorf("signature aggregator failed to generate multiple signatures from bytes, err=%s", err.Error())
 		return nil, valBitSet, err
 	}
 	return bls.AggregateSignatures(sigs).Marshal(), valBitSet, nil

vote/vote_processor.go

@@ -118,6 +118,7 @@ func (p *VoteProcessor) CollectVotesLoop() {
 func (p *VoteProcessor) collectVotes() error {
 	events, err := p.FetchEventsForCollectVotes()
 	if err != nil {
+		logging.Logger.Errorf("vote processor failed to fetch events to collect votes, err=%s", err.Error())
 		return err
 	}
 	if len(events) == 0 {
@@ -165,6 +166,7 @@ func (p *VoteProcessor) queryMoreThanTwoThirdVotesForEvent(event *model.Event, v
 	validVotesTotalCount := 1 // assume local vote is valid
 	localVote, err := p.constructVoteAndSign(event)
 	if err != nil {
+		logging.Logger.Errorf("vote processor failed to construct vote and sign for event %d, err=%s", event.ChallengeId, err.Error())
 		return err
 	}
 	for {
@@ -210,6 +212,7 @@ func (p *VoteProcessor) queryMoreThanTwoThirdVotesForEvent(event *model.Event, v
 			// check duplicate, the vote might have been saved in previous request.
 			exist, err := p.IsVoteExists(event.ChallengeId, hex.EncodeToString(v.PubKey[:]))
 			if err != nil {
+				logging.Logger.Errorf("vote processor failed to check if vote exists for event %d, err=%s", event.ChallengeId, err.Error())
 				return err
 			}
 			if exist {

vote/vote_signer.go

@@ -1,6 +1,7 @@
 package vote
 
 import (
+	"github.com/bnb-chain/greenfield-challenger/logging"
 	"github.com/prysmaticlabs/prysm/crypto/bls/blst"
 	blscmn "github.com/prysmaticlabs/prysm/crypto/bls/common"
 	"github.com/tendermint/tendermint/votepool"
@@ -14,6 +15,7 @@ type VoteSigner struct {
 func NewVoteSigner(pk []byte) *VoteSigner {
 	privKey, err := blst.SecretKeyFromBytes(pk)
 	if err != nil {
+		logging.Logger.Errorf("vote signer failed to generate key from bytes, err=%s", err.Error())
 		panic(err)
 	}
 	pubKey := privKey.PublicKey()