feat: add MarkDelegationAsTransitioned method

docs/docs.go

@@ -960,6 +960,9 @@ const docTemplate = `{
                 "is_slashed": {
                     "type": "boolean"
                 },
+                "is_transitioned": {
+                    "type": "boolean"
+                },
                 "staker_pk_hex": {
                     "type": "string"
                 },

docs/swagger.json

@@ -952,6 +952,9 @@
                 "is_slashed": {
                     "type": "boolean"
                 },
+                "is_transitioned": {
+                    "type": "boolean"
+                },
                 "staker_pk_hex": {
                     "type": "string"
                 },

docs/swagger.yaml

@@ -214,6 +214,8 @@ definitions:
         type: boolean
       is_slashed:
         type: boolean
+      is_transitioned:
+        type: boolean
       staker_pk_hex:
         type: string
       staking_tx:

internal/v1/db/client/delegation.go

@@ -156,6 +156,23 @@ func (v1dbclient *V1Database) ScanDelegationsPaginated(
 	)
 }
 
+// MarkDelegationAsTransitioned marks an existing delegation as transitioned
+func (v1dbclient *V1Database) MarkDelegationAsTransitioned(ctx context.Context, stakingTxHashHex string) error {
+	client := v1dbclient.Client.Database(v1dbclient.DbName).Collection(dbmodel.V1DelegationCollection)
+	update := bson.M{"$set": bson.M{"is_transitioned": true}}
+	result, err := client.UpdateOne(ctx, bson.M{"_id": stakingTxHashHex}, update)
+	if err != nil {
+		return err
+	}
+	if result.MatchedCount == 0 {
+		return &db.NotFoundError{
+			Key:     stakingTxHashHex,
+			Message: "Delegation not found",
+		}
+	}
+	return nil
+}
+
 // TransitionState updates the state of a staking transaction to a new state
 // It returns an NotFoundError if the staking transaction is not found or not in the eligible state to transition
 func (v1dbclient *V1Database) transitionState(

internal/v1/db/client/interface.go

@@ -30,6 +30,7 @@ type V1DBClient interface {
 		ctx context.Context, stakingTxHashHex, unbondingTxHashHex, txHex, signatureHex string,
 	) error
 	FindDelegationByTxHashHex(ctx context.Context, txHashHex string) (*v1dbmodel.DelegationDocument, error)
+	MarkDelegationAsTransitioned(ctx context.Context, stakingTxHashHex string) error
 	SaveTimeLockExpireCheck(ctx context.Context, stakingTxHashHex string, expireHeight uint64, txType string) error
 	TransitionToUnbondedState(
 		ctx context.Context, stakingTxHashHex string, eligiblePreviousState []types.DelegationState,

internal/v1/db/model/delegation.go

@@ -22,6 +22,7 @@ type DelegationDocument struct {
 	StakingTx             *TimelockTransaction  `bson:"staking_tx"` // Always exist
 	UnbondingTx           *TimelockTransaction  `bson:"unbonding_tx,omitempty"`
 	IsOverflow            bool                  `bson:"is_overflow"`
+	IsTransitioned        bool                  `bson:"is_transitioned"`
 }
 
 type DelegationByStakerPagination struct {

internal/v1/service/delegation.go

@@ -32,6 +32,7 @@ type DelegationPublic struct {
 	IsOverflow              bool               `json:"is_overflow"`
 	IsEligibleForTransition bool               `json:"is_eligible_for_transition"`
 	IsSlashed               bool               `json:"is_slashed"`
+	IsTransitioned          bool               `json:"is_transitioned"`
 }
 
 func (s *V1Service) DelegationsByStakerPk(
@@ -212,6 +213,7 @@ func (s *V1Service) FromDelegationDocument(
 		IsOverflow:              d.IsOverflow,
 		IsEligibleForTransition: isFpTransitioned && !isSlashed && s.isEligibleForTransition(d, bbnHeight),
 		IsSlashed:               isSlashed,
+		IsTransitioned:            d.IsTransitioned,
 	}
 
 	// Add unbonding transaction if it exists

internal/v2/db/client/deelgation.go

@@ -0,0 +1,55 @@
+package v2dbclient
+
+import (
+	"context"
+	"errors"
+
+	"github.com/babylonlabs-io/staking-api-service/internal/shared/db"
+	dbmodel "github.com/babylonlabs-io/staking-api-service/internal/shared/db/model"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/mongo"
+)
+
+func (v2dbclient *V2Database) MarkV1DelegationAsTransitioned(ctx context.Context, stakingTxHashHex string) error {
+	session, err := v2dbclient.Client.StartSession()
+	if err != nil {
+		return err
+	}
+	defer session.EndSession(ctx)
+
+	transactionWork := func(sessCtx mongo.SessionContext) (interface{}, error) {
+		client := v2dbclient.Client.Database(v2dbclient.DbName).Collection(dbmodel.V1DelegationCollection)
+		filter := bson.M{"_id": stakingTxHashHex}
+
+		var delegation interface{}
+		err := client.FindOne(sessCtx, filter).Decode(&delegation)
+		if err != nil {
+			if errors.Is(err, mongo.ErrNoDocuments) {
+				return nil, &db.NotFoundError{
+					Key:     stakingTxHashHex,
+					Message: "Delegation not found",
+				}
+			}
+			return nil, err
+		}
+
+		update := bson.M{"$set": bson.M{"is_transitioned": true}}
+		result, err := client.UpdateOne(sessCtx, filter, update)
+		if err != nil {
+			return nil, err
+		}
+
+		if result.MatchedCount == 0 {
+			return nil, &db.NotFoundError{
+				Key:     stakingTxHashHex,
+				Message: "Delegation not found",
+			}
+		}
+
+		return nil, nil
+	}
+
+	_, err = session.WithTransaction(ctx, transactionWork)
+	return err
+}
+

internal/v2/db/client/interface.go

@@ -26,4 +26,5 @@ type V2DBClient interface {
 	SubtractStakerStats(
 		ctx context.Context, stakingTxHashHex, stakerPkHex string, amount uint64,
 	) error
+	MarkV1DelegationAsTransitioned(ctx context.Context, stakingTxHashHex string) error
 }

internal/v2/queue/handler/staking.go

@@ -20,6 +20,12 @@ func (h *V2QueueHandler) ActiveStakingHandler(ctx context.Context, messageBody s
 		return types.NewError(http.StatusBadRequest, types.BadRequest, err)
 	}
 
+	// Mark as v1 delegation as transitioned if it exists
+	if err := h.Service.MarkV1DelegationAsTransitioned(ctx, activeStakingEvent.StakingTxHashHex); err != nil {
+		log.Ctx(ctx).Error().Err(err).Msg("Failed to mark v1 delegation as transitioned")
+		return err
+	}
+
 	// Perform the address lookup conversion
 	addressLookupErr := h.performAddressLookupConversion(ctx, activeStakingEvent.StakerBtcPkHex, types.Active)
 	if addressLookupErr != nil {

internal/v2/service/delegation.go

@@ -170,3 +170,14 @@ func (s *V2Service) SaveUnprocessableMessages(ctx context.Context, messageBody,
 	}
 	return nil
 }
+
+func (s *V2Service) MarkV1DelegationAsTransitioned(ctx context.Context, stakingTxHashHex string) *types.Error {
+	err := s.DbClients.V2DBClient.MarkV1DelegationAsTransitioned(ctx, stakingTxHashHex)
+	if err != nil {
+		if db.IsNotFoundError(err) {
+			return nil
+		}
+		return types.NewInternalServiceError(err)
+	}
+	return nil
+}

internal/v2/service/interface.go

@@ -14,6 +14,7 @@ type V2ServiceProvider interface {
 	IsDelegationPresent(ctx context.Context, txHashHex string) (bool, *types.Error)
 	GetDelegation(ctx context.Context, stakingTxHashHex string) (*StakerDelegationPublic, *types.Error)
 	GetDelegations(ctx context.Context, stakerPKHex string, paginationKey string) ([]*StakerDelegationPublic, string, *types.Error)
+	MarkV1DelegationAsTransitioned(ctx context.Context, stakingTxHashHex string) *types.Error
 	GetOverallStats(ctx context.Context) (*OverallStatsPublic, *types.Error)
 	GetStakerStats(ctx context.Context, stakerPKHex string) (*StakerStatsPublic, *types.Error)
 	ProcessAndSaveBtcAddresses(ctx context.Context, stakerPkHex string) *types.Error