Replace types.error with error (#126)

internal/db/model/delegation.go

@@ -2,7 +2,6 @@ package model
 
 import (
 	"fmt"
-	"net/http"
 	"strconv"
 
 	"github.com/babylonlabs-io/babylon-staking-indexer/internal/types"
@@ -59,50 +58,30 @@ func FromEventBTCDelegationCreated(
 	event *bbntypes.EventBTCDelegationCreated,
 	bbnBlockHeight,
 	bbnBlockTime int64,
-) (*BTCDelegationDetails, *types.Error) {
+) (*BTCDelegationDetails, error) {
 	stakingOutputIdx, err := strconv.ParseUint(event.StakingOutputIndex, 10, 32)
 	if err != nil {
-		return nil, types.NewError(
-			http.StatusInternalServerError,
-			types.InternalServiceError,
-			fmt.Errorf("failed to parse staking output index: %w", err),
-		)
+		return nil, fmt.Errorf("failed to parse staking output index: %w", err)
 	}
 
 	paramsVersion, err := strconv.ParseUint(event.ParamsVersion, 10, 32)
 	if err != nil {
-		return nil, types.NewError(
-			http.StatusInternalServerError,
-			types.InternalServiceError,
-			fmt.Errorf("failed to parse params version: %w", err),
-		)
+		return nil, fmt.Errorf("failed to parse params version: %w", err)
 	}
 
 	stakingTime, err := strconv.ParseUint(event.StakingTime, 10, 32)
 	if err != nil {
-		return nil, types.NewError(
-			http.StatusInternalServerError,
-			types.InternalServiceError,
-			fmt.Errorf("failed to parse staking time: %w", err),
-		)
+		return nil, fmt.Errorf("failed to parse staking time: %w", err)
 	}
 
 	unbondingTime, err := strconv.ParseUint(event.UnbondingTime, 10, 32)
 	if err != nil {
-		return nil, types.NewError(
-			http.StatusInternalServerError,
-			types.InternalServiceError,
-			fmt.Errorf("failed to parse unbonding time: %w", err),
-		)
+		return nil, fmt.Errorf("failed to parse unbonding time: %w", err)
 	}
 
 	stakingTx, err := utils.DeserializeBtcTransactionFromHex(event.StakingTxHex)
 	if err != nil {
-		return nil, types.NewError(
-			http.StatusInternalServerError,
-			types.InternalServiceError,
-			fmt.Errorf("failed to deserialize staking tx: %w", err),
-		)
+		return nil, fmt.Errorf("failed to deserialize staking tx: %w", err)
 	}
 
 	stakingValue := btcutil.Amount(stakingTx.TxOut[stakingOutputIdx].Value)

internal/services/bootstrap.go

@@ -3,9 +3,6 @@ package services
 import (
 	"context"
 	"fmt"
-	"net/http"
-
-	"github.com/babylonlabs-io/babylon-staking-indexer/internal/types"
 	"github.com/rs/zerolog/log"
 )
 
@@ -86,15 +83,11 @@ func (s *Service) processBlocksSequentially(ctx context.Context) error {
 // /block_result endpoint of the BBN blockchain.
 func (s *Service) getEventsFromBlock(
 	ctx context.Context, blockHeight int64,
-) ([]BbnEvent, *types.Error) {
+) ([]BbnEvent, error) {
 	events := make([]BbnEvent, 0)
 	blockResult, err := s.bbn.GetBlockResults(ctx, &blockHeight)
 	if err != nil {
-		return nil, types.NewError(
-			http.StatusInternalServerError,
-			types.ClientRequestError,
-			fmt.Errorf("failed to get block results: %w", err),
-		)
+		return nil, fmt.Errorf("failed to get block results: %w", err)
 	}
 	// Append transaction-level events
 	for _, txResult := range blockResult.TxsResults {

internal/services/consumer_events.go

@@ -5,14 +5,13 @@ import (
 	"fmt"
 
 	"github.com/babylonlabs-io/babylon-staking-indexer/internal/db/model"
-	"github.com/babylonlabs-io/babylon-staking-indexer/internal/types"
 	queuecli "github.com/babylonlabs-io/staking-queue-client/client"
 )
 
 func (s *Service) emitActiveDelegationEvent(
 	ctx context.Context,
 	delegation *model.BTCDelegationDetails,
-) *types.Error {
+) error {
 	stateHistoryStrs := model.ToStateStrings(delegation.StateHistory)
 	stakingEvent := queuecli.NewActiveStakingEvent(
 		delegation.StakingTxHashHex,
@@ -23,15 +22,15 @@ func (s *Service) emitActiveDelegationEvent(
 	)
 
 	if err := s.queueManager.PushActiveStakingEvent(ctx, &stakingEvent); err != nil {
-		return types.NewInternalServiceError(fmt.Errorf("failed to push the staking event to the queue: %w", err))
+		return fmt.Errorf("failed to push the staking event to the queue: %w", err)
 	}
 	return nil
 }
 
 func (s *Service) emitUnbondingDelegationEvent(
 	ctx context.Context,
 	delegation *model.BTCDelegationDetails,
-) *types.Error {
+) error {
 	stateHistoryStrs := model.ToStateStrings(delegation.StateHistory)
 	ev := queuecli.NewUnbondingStakingEvent(
 		delegation.StakingTxHashHex,
@@ -41,15 +40,15 @@ func (s *Service) emitUnbondingDelegationEvent(
 		stateHistoryStrs,
 	)
 	if err := s.queueManager.PushUnbondingStakingEvent(ctx, &ev); err != nil {
-		return types.NewInternalServiceError(fmt.Errorf("failed to push the unbonding event to the queue: %w", err))
+		return fmt.Errorf("failed to push the unbonding event to the queue: %w", err)
 	}
 	return nil
 }
 
 func (s *Service) emitWithdrawableDelegationEvent(
 	ctx context.Context,
 	delegation *model.BTCDelegationDetails,
-) *types.Error {
+) error {
 	stateHistoryStrs := model.ToStateStrings(delegation.StateHistory)
 	ev := queuecli.NewWithdrawableStakingEvent(
 		delegation.StakingTxHashHex,
@@ -59,15 +58,15 @@ func (s *Service) emitWithdrawableDelegationEvent(
 		stateHistoryStrs,
 	)
 	if err := s.queueManager.PushWithdrawableStakingEvent(ctx, &ev); err != nil {
-		return types.NewInternalServiceError(fmt.Errorf("failed to push the withdrawable event to the queue: %w", err))
+		return fmt.Errorf("failed to push the withdrawable event to the queue: %w", err)
 	}
 	return nil
 }
 
 func (s *Service) emitWithdrawnDelegationEvent(
 	ctx context.Context,
 	delegation *model.BTCDelegationDetails,
-) *types.Error {
+) error {
 	stateHistoryStrs := model.ToStateStrings(delegation.StateHistory)
 	ev := queuecli.NewWithdrawnStakingEvent(
 		delegation.StakingTxHashHex,
@@ -77,7 +76,7 @@ func (s *Service) emitWithdrawnDelegationEvent(
 		stateHistoryStrs,
 	)
 	if err := s.queueManager.PushWithdrawnStakingEvent(ctx, &ev); err != nil {
-		return types.NewInternalServiceError(fmt.Errorf("failed to push the withdrawn event to the queue: %w", err))
+		return fmt.Errorf("failed to push the withdrawn event to the queue: %w", err)
 	}
 	return nil
 }