linter recom fixes for scripts and ewm packages

Signed-off-by: Pranay Valson <[email protected]>

internal/config/config.go

@@ -49,6 +49,7 @@ type ChainConfig struct {
 	WebsocketURLs string
 }
 
+// CovenetConfig contains the gRPC url and private key for EWM node
 type CovenetConfig struct {
 	PrivateKey string
 	GRPCURL    string

internal/config/env_config.go

@@ -11,7 +11,7 @@ type RedisEnvConfig struct {
 	Password string `envconfig:"REDIS_PWD" default:""`
 }
 
-// EWM node config
+// CovenetEnvConfig (ewm) node config
 type CovenetEnvConfig struct {
 	PrivateKey string `envconfig:"COVENET_PRIVATE_KEY"`
 	GRPCURL    string `envconfig:"COVENET_GRPC_URL"`

internal/ewm/tx.go

@@ -59,8 +59,9 @@ type CovenetInteractor struct {
 func (interactor *CovenetInteractor) getPrivateKey() (cryptotypes.PrivKey, error) {
 	privKeyBytes, err := hex.DecodeString(interactor.config.CovenetConfig.PrivateKey)
 	if err != nil {
-		return nil, fmt.Errorf("error decoding private key: %v", err)
+		return nil, fmt.Errorf("error decoding private key: %w", err)
 	}
+
 	return &secp256k1.PrivKey{Key: privKeyBytes}, nil
 }
 
@@ -84,13 +85,13 @@ func NewCovenetInteractor(config *config.AgentConfig) (*CovenetInteractor, error
 	// Process the key and set up the interactor account
 	err = interactor.ProcessKey()
 	if err != nil {
-		return nil, fmt.Errorf("failed to process key: %v", err)
+		return nil, fmt.Errorf("failed to process key: %w", err)
 	}
 
 	// Cache initial account info
 	sequenceNum, accountNum, err := interactor.GetAccountInfo()
 	if err != nil {
-		return nil, fmt.Errorf("failed to get initial account info: %v", err)
+		return nil, fmt.Errorf("failed to get initial account info: %w", err)
 	}
 	interactor.sequenceNumber = sequenceNum
 	interactor.accountNumber = accountNum
@@ -106,26 +107,29 @@ func (interactor *CovenetInteractor) GetSystemInfo() (*ewmtypes.SystemInfo, erro
 
 	res, err := covenetClient.SystemInfo(context.Background(), params)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to get system info: %w", err)
 	}
-	log.Info("System Info: ", res)
+	log.Info("system info: ", res)
 
 	return &res.SystemInfo, nil
 }
 
 // GetGRPCConnection establishes a gRPC connection to the Covenet node.
 func GetGRPCConnection(config *config.AgentConfig) (*grpc.ClientConn, error) {
 	// Create a connection to the gRPC server.
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	_, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
-	grpcConn, err := grpc.DialContext(
-		ctx,
-		config.CovenetConfig.GRPCURL,
+	options := []grpc.DialOption{
 		grpc.WithTransportCredentials(insecure.NewCredentials()),
+	}
+
+	grpcConn, err := grpc.NewClient(
+		config.CovenetConfig.GRPCURL,
+		options...,
 	)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to init grpc client: %w", err)
 	}
 
 	log.Info("GRPC connection status: ", grpcConn.GetState())
@@ -147,7 +151,7 @@ func (interactor *CovenetInteractor) ProcessKey() error {
 	// Decode the hex string to bytes
 	privKeyBytes, err := hex.DecodeString(interactor.config.CovenetConfig.PrivateKey)
 	if err != nil {
-		return fmt.Errorf("error decoding private key: %v", err)
+		return fmt.Errorf("error decoding private key: %w", err)
 	}
 
 	// Create a new PrivKey object
@@ -162,13 +166,13 @@ func (interactor *CovenetInteractor) ProcessKey() error {
 	// Encode with the correct prefix
 	bech32Addr, err := bech32.ConvertAndEncode(Bech32PrefixAccAddr, addrBytes)
 	if err != nil {
-		return fmt.Errorf("error encoding bech32 address: %v", err)
+		return fmt.Errorf("error encoding bech32 address: %w", err)
 	}
 
 	// If you specifically need a Covenet address type
 	covenetAddr, err := ewmtypes.CovenetAccAddressFromBech32(bech32Addr)
 	if err != nil {
-		return fmt.Errorf("error converting to Covenet address: %v", err)
+		return fmt.Errorf("error converting to Covenet address: %w", err)
 	}
 
 	// Set interactor key address values
@@ -182,6 +186,7 @@ func (interactor *CovenetInteractor) ProcessKey() error {
 func (interactor *CovenetInteractor) GetLatestSequence() uint64 {
 	interactor.sequenceMutex.Lock()
 	defer interactor.sequenceMutex.Unlock()
+
 	return interactor.sequenceNumber
 }
 
@@ -204,7 +209,7 @@ func (interactor *CovenetInteractor) GetAccountInfo() (uint64, uint64, error) {
 	)
 	if err != nil {
 		// If the account is not found return 0 values with error
-		return 0, 0, fmt.Errorf("failed to query account %s: %v", interactor.address.String(), err)
+		return 0, 0, fmt.Errorf("failed to query account %s: %w", interactor.address.String(), err)
 	}
 
 	// Create a new AccountI interface
@@ -213,7 +218,7 @@ func (interactor *CovenetInteractor) GetAccountInfo() (uint64, uint64, error) {
 	// Unmarshal the account data
 	err = encCfg.InterfaceRegistry.UnpackAny(res.Account, &account)
 	if err != nil {
-		return 0, 0, fmt.Errorf("failed to unpack account %s: %v", interactor.address.String(), err)
+		return 0, 0, fmt.Errorf("failed to unpack account %s: %w", interactor.address.String(), err)
 	}
 
 	// Get the sequence number
@@ -248,11 +253,10 @@ func (interactor *CovenetInteractor) SendCovenetBlockReplicaProofTx(ctx context.
 
 // CreateProofTx creates and broadcasts a proof transaction on the Covenet blockchain.
 func (interactor *CovenetInteractor) CreateProofTx(ctx context.Context, blockReplica *bsptypes.BlockReplica, txHash chan string, chainHeight uint64, replicaURL string, sha256Result [sha256.Size]byte) error {
-
 	// Get account from private key
 	privK, err := interactor.getPrivateKey()
 	if err != nil {
-		return fmt.Errorf("failed to get private key for address %s: %v", interactor.address.String(), err)
+		return fmt.Errorf("failed to get private key for address %s: %w", interactor.address.String(), err)
 	}
 
 	sequence := interactor.GetLatestSequence()
@@ -265,7 +269,7 @@ func (interactor *CovenetInteractor) CreateProofTx(ctx context.Context, blockRep
 
 	err = txBuilder.SetMsgs(proofMsg)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to set messages: %w", err)
 	}
 
 	txBuilder.SetGasLimit(200000)
@@ -287,7 +291,7 @@ func (interactor *CovenetInteractor) CreateProofTx(ctx context.Context, blockRep
 
 	err = txBuilder.SetSignatures(sigV2)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to set signatures: %w", err)
 	}
 
 	// Second round: actual signing
@@ -300,37 +304,40 @@ func (interactor *CovenetInteractor) CreateProofTx(ctx context.Context, blockRep
 		encCfg.TxConfig.SignModeHandler().DefaultMode(), signerData,
 		txBuilder, privK, encCfg.TxConfig, sequence)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to sign with private key: %w", err)
 	}
 
 	err = txBuilder.SetSignatures(sigV2)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to set signatures: %w", err)
 	}
 
 	// Generated Protobuf-encoded bytes.
 	txBytes, err := encCfg.TxConfig.TxEncoder()(txBuilder.GetTx())
-
+	if err != nil {
+		return fmt.Errorf("failed to encode transaction: %w", err)
+	}
 	// Broadcast the tx via gRPC.
 	// We create a new client for the Protobuf Tx service.
 	txClient := tx.NewServiceClient(interactor.grpcClient)
 	// We then call the BroadcastTx method on this client.
 	grpcRes, err := txClient.BroadcastTx(
-		context.Background(),
+		ctx,
 		&tx.BroadcastTxRequest{
 			Mode:    tx.BroadcastMode_BROADCAST_MODE_SYNC,
 			TxBytes: txBytes, // Proto-binary of the signed transaction, see previous step.
 		},
 	)
 	if err != nil {
-		return err
+		return fmt.Errorf("failed to broadcast transaction: %w", err)
 	}
 
 	log.Info("response code\n", grpcRes.TxResponse.String()) // Should be `0` if the tx is successful
 
 	if grpcRes.TxResponse.Code == 0 {
 		interactor.IncrementSequence()
 		txHash <- grpcRes.TxResponse.TxHash
+
 		return nil
 	}
 
@@ -346,7 +353,7 @@ func (interactor *CovenetInteractor) CreateProofTxWithRetry(ctx context.Context,
 			log.Warn("skipping: covenet creator is already a session member")
 			txHash <- "presubmitted hash"
 		case strings.Contains(errStr, "proof session submitted out of acceptable live bounds"):
-			log.Warn("skipping: covenet Proof session out of acceptable live bounds")
+			log.Warn("skipping: covenet proof session out of acceptable live bounds")
 			txHash <- "out-of-bounds block"
 		// Add additional cases that need skipping based on response from covenet
 		// case strings.Contains(errStr, "the client connection is closing"):
@@ -356,20 +363,21 @@ func (interactor *CovenetInteractor) CreateProofTxWithRetry(ctx context.Context,
 			log.Error("too many errors in creating proof on covenet: ", errStr)
 			txHash <- ""
 		}
-		return fmt.Errorf("exceeded retry limit of %d attempts, with response %s", retryCountLimit, lastError)
+
+		return fmt.Errorf("exceeded retry limit of attempts: %d, with response: %w", retryCountLimit, lastError)
 	}
 
 	err := interactor.CreateProofTx(ctx, blockReplica, txHash, chainHeight, replicaURL, sha256Result)
 	if err != nil {
 		lastError = err
-		log.Error(err)
+		log.Errorf("retry count %d, error: %v", retryCount, err)
 	} else {
 		return nil
 	}
 
 	// Exponential backoff
 	backoffDuration := time.Duration(1<<uint(retryCount)) * time.Second
-	log.Info("Retrying Create Proof tx in: ", backoffDuration)
+	log.Info("retrying create proof tx in: ", backoffDuration)
 	time.Sleep(backoffDuration)
 
 	// Recursive call with now incremented retry count