0g-chain/x/incentive/keeper/grpc_query.go

package keeper

import (
	"context"
	"strings"

	sdk "github.com/cosmos/cosmos-sdk/types"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"

	"github.com/0glabs/0g-chain/x/incentive/types"
	liquidtypes "github.com/0glabs/0g-chain/x/liquid/types"
)

const (
	RewardTypeHard        = "hard"
	RewardTypeUSDXMinting = "usdx_minting"
	RewardTypeDelegator   = "delegator"
	RewardTypeSwap        = "swap"
	RewardTypeSavings     = "savings"
	RewardTypeEarn        = "earn"
)

type queryServer struct {
	keeper Keeper
}

var _ types.QueryServer = queryServer{}

// NewQueryServerImpl creates a new server for handling gRPC queries.
func NewQueryServerImpl(keeper Keeper) types.QueryServer {
	return &queryServer{
		keeper: keeper,
	}
}

func (s queryServer) Params(
	ctx context.Context,
	req *types.QueryParamsRequest,
) (*types.QueryParamsResponse, error) {
	if req == nil {
		return nil, status.Errorf(codes.InvalidArgument, "empty request")
	}

	sdkCtx := sdk.UnwrapSDKContext(ctx)

	return &types.QueryParamsResponse{
		Params: s.keeper.GetParams(sdkCtx),
	}, nil
}

func (s queryServer) Rewards(
	ctx context.Context,
	req *types.QueryRewardsRequest,
) (*types.QueryRewardsResponse, error) {
	if req == nil {
		return nil, status.Errorf(codes.InvalidArgument, "empty request")
	}

	sdkCtx := sdk.UnwrapSDKContext(ctx)

	res := types.QueryRewardsResponse{}

	hasOwner := req.Owner != ""

	var owner sdk.AccAddress
	if hasOwner {
		addr, err := sdk.AccAddressFromBech32(req.Owner)
		if err != nil {
			return nil, status.Errorf(codes.InvalidArgument, "invalid address: %s", err)
		}

		owner = addr
	}

	if err := s.queryRewards(sdkCtx, &res, owner, hasOwner, req.RewardType); err != nil {
		return nil, err
	}

	if !req.Unsynchronized {
		if err := s.synchronizeRewards(sdkCtx, &res); err != nil {
			return nil, err
		}
	}

	return &res, nil
}

func (s queryServer) RewardFactors(
	ctx context.Context,
	req *types.QueryRewardFactorsRequest,
) (*types.QueryRewardFactorsResponse, error) {
	if req == nil {
		return nil, status.Errorf(codes.InvalidArgument, "empty request")
	}

	sdkCtx := sdk.UnwrapSDKContext(ctx)

	var usdxFactors types.RewardIndexes
	s.keeper.IterateUSDXMintingRewardFactors(sdkCtx, func(collateralType string, factor sdk.Dec) (stop bool) {
		usdxFactors = usdxFactors.With(collateralType, factor)
		return false
	})

	var supplyFactors types.MultiRewardIndexes
	s.keeper.IterateHardSupplyRewardIndexes(sdkCtx, func(denom string, indexes types.RewardIndexes) (stop bool) {
		supplyFactors = supplyFactors.With(denom, indexes)
		return false
	})

	var borrowFactors types.MultiRewardIndexes
	s.keeper.IterateHardBorrowRewardIndexes(sdkCtx, func(denom string, indexes types.RewardIndexes) (stop bool) {
		borrowFactors = borrowFactors.With(denom, indexes)
		return false
	})

	var delegatorFactors types.MultiRewardIndexes
	s.keeper.IterateDelegatorRewardIndexes(sdkCtx, func(denom string, indexes types.RewardIndexes) (stop bool) {
		delegatorFactors = delegatorFactors.With(denom, indexes)
		return false
	})

	var swapFactors types.MultiRewardIndexes
	s.keeper.IterateSwapRewardIndexes(sdkCtx, func(poolID string, indexes types.RewardIndexes) (stop bool) {
		swapFactors = swapFactors.With(poolID, indexes)
		return false
	})

	var savingsFactors types.MultiRewardIndexes
	s.keeper.IterateSavingsRewardIndexes(sdkCtx, func(denom string, indexes types.RewardIndexes) (stop bool) {
		savingsFactors = savingsFactors.With(denom, indexes)
		return false
	})

	var earnFactors types.MultiRewardIndexes
	s.keeper.IterateEarnRewardIndexes(sdkCtx, func(denom string, indexes types.RewardIndexes) (stop bool) {
		earnFactors = earnFactors.With(denom, indexes)
		return false
	})

	return &types.QueryRewardFactorsResponse{
		UsdxMintingRewardFactors: usdxFactors,
		HardSupplyRewardFactors:  supplyFactors,
		HardBorrowRewardFactors:  borrowFactors,
		DelegatorRewardFactors:   delegatorFactors,
		SwapRewardFactors:        swapFactors,
		SavingsRewardFactors:     savingsFactors,
		EarnRewardFactors:        earnFactors,
	}, nil
}

func (s queryServer) Apy(
	ctx context.Context,
	req *types.QueryApyRequest,
) (*types.QueryApyResponse, error) {
	if req == nil {
		return nil, status.Errorf(codes.InvalidArgument, "empty request")
	}

	sdkCtx := sdk.UnwrapSDKContext(ctx)

	params := s.keeper.GetParams(sdkCtx)
	var apys types.APYs

	// bkava APY (staking + incentive rewards)
	stakingAPR, err := GetStakingAPR(sdkCtx, s.keeper, params)
	if err != nil {
		return nil, err
	}

	apys = append(apys, types.NewAPY(liquidtypes.DefaultDerivativeDenom, stakingAPR))

	// Incentive only APYs
	for _, param := range params.EarnRewardPeriods {
		// Skip bkava as it's calculated earlier with staking rewards
		if param.CollateralType == liquidtypes.DefaultDerivativeDenom {
			continue
		}

		// Value in the vault in the same denom as CollateralType
		vaultTotalValue, err := s.keeper.earnKeeper.GetVaultTotalValue(sdkCtx, param.CollateralType)
		if err != nil {
			return nil, err
		}
		apy, err := GetAPYFromMultiRewardPeriod(sdkCtx, s.keeper, param.CollateralType, param, vaultTotalValue.Amount)
		if err != nil {
			return nil, err
		}

		apys = append(apys, types.NewAPY(param.CollateralType, apy))
	}

	return &types.QueryApyResponse{
		Earn: apys,
	}, nil
}

// queryRewards queries the rewards for a given owner and reward type, updating
// the response with the results in place.
func (s queryServer) queryRewards(
	ctx sdk.Context,
	res *types.QueryRewardsResponse,
	owner sdk.AccAddress,
	hasOwner bool,
	rewardType string,
) error {
	rewardType = strings.ToLower(rewardType)
	isAllRewards := rewardType == ""

	if !rewardTypeIsValid(rewardType) {
		return status.Errorf(codes.InvalidArgument, "invalid reward type for owner %s: %s", owner, rewardType)
	}

	if isAllRewards || rewardType == RewardTypeUSDXMinting {
		if hasOwner {
			usdxMintingClaim, foundUsdxMintingClaim := s.keeper.GetUSDXMintingClaim(ctx, owner)
			if foundUsdxMintingClaim {
				res.USDXMintingClaims = append(res.USDXMintingClaims, usdxMintingClaim)
			}
		} else {
			usdxMintingClaims := s.keeper.GetAllUSDXMintingClaims(ctx)
			res.USDXMintingClaims = append(res.USDXMintingClaims, usdxMintingClaims...)
		}
	}

	if isAllRewards || rewardType == RewardTypeHard {
		if hasOwner {
			hardClaim, foundHardClaim := s.keeper.GetHardLiquidityProviderClaim(ctx, owner)
			if foundHardClaim {
				res.HardLiquidityProviderClaims = append(res.HardLiquidityProviderClaims, hardClaim)
			}
		} else {
			hardClaims := s.keeper.GetAllHardLiquidityProviderClaims(ctx)
			res.HardLiquidityProviderClaims = append(res.HardLiquidityProviderClaims, hardClaims...)
		}
	}

	if isAllRewards || rewardType == RewardTypeDelegator {
		if hasOwner {
			delegatorClaim, foundDelegatorClaim := s.keeper.GetDelegatorClaim(ctx, owner)
			if foundDelegatorClaim {
				res.DelegatorClaims = append(res.DelegatorClaims, delegatorClaim)
			}
		} else {
			delegatorClaims := s.keeper.GetAllDelegatorClaims(ctx)
			res.DelegatorClaims = append(res.DelegatorClaims, delegatorClaims...)
		}
	}

	if isAllRewards || rewardType == RewardTypeSwap {
		if hasOwner {
			swapClaim, foundSwapClaim := s.keeper.GetSwapClaim(ctx, owner)
			if foundSwapClaim {
				res.SwapClaims = append(res.SwapClaims, swapClaim)
			}
		} else {
			swapClaims := s.keeper.GetAllSwapClaims(ctx)
			res.SwapClaims = append(res.SwapClaims, swapClaims...)
		}
	}

	if isAllRewards || rewardType == RewardTypeSavings {
		if hasOwner {
			savingsClaim, foundSavingsClaim := s.keeper.GetSavingsClaim(ctx, owner)
			if foundSavingsClaim {
				res.SavingsClaims = append(res.SavingsClaims, savingsClaim)
			}
		} else {
			savingsClaims := s.keeper.GetAllSavingsClaims(ctx)
			res.SavingsClaims = append(res.SavingsClaims, savingsClaims...)
		}
	}

	if isAllRewards || rewardType == RewardTypeEarn {
		if hasOwner {
			earnClaim, foundEarnClaim := s.keeper.GetEarnClaim(ctx, owner)
			if foundEarnClaim {
				res.EarnClaims = append(res.EarnClaims, earnClaim)
			}
		} else {
			earnClaims := s.keeper.GetAllEarnClaims(ctx)
			res.EarnClaims = append(res.EarnClaims, earnClaims...)
		}
	}

	return nil
}

// synchronizeRewards synchronizes all non-empty rewards in place.
func (s queryServer) synchronizeRewards(
	ctx sdk.Context,
	res *types.QueryRewardsResponse,
) error {
	// Synchronize all non-empty rewards
	for i, claim := range res.USDXMintingClaims {
		res.USDXMintingClaims[i] = s.keeper.SimulateUSDXMintingSynchronization(ctx, claim)
	}

	for i, claim := range res.HardLiquidityProviderClaims {
		res.HardLiquidityProviderClaims[i] = s.keeper.SimulateHardSynchronization(ctx, claim)
	}

	for i, claim := range res.DelegatorClaims {
		res.DelegatorClaims[i] = s.keeper.SimulateDelegatorSynchronization(ctx, claim)
	}

	for i, claim := range res.SwapClaims {
		syncedClaim, found := s.keeper.GetSynchronizedSwapClaim(ctx, claim.Owner)
		if !found {
			return status.Errorf(codes.Internal, "previously found swap claim for owner %s should still be found", claim.Owner)
		}
		res.SwapClaims[i] = syncedClaim
	}

	for i, claim := range res.SavingsClaims {
		syncedClaim, found := s.keeper.GetSynchronizedSavingsClaim(ctx, claim.Owner)
		if !found {
			return status.Errorf(codes.Internal, "previously found savings claim for owner %s should still be found", claim.Owner)
		}
		res.SavingsClaims[i] = syncedClaim
	}

	for i, claim := range res.EarnClaims {
		syncedClaim, found := s.keeper.GetSynchronizedEarnClaim(ctx, claim.Owner)
		if !found {
			return status.Errorf(codes.Internal, "previously found earn claim for owner %s should still be found", claim.Owner)
		}
		res.EarnClaims[i] = syncedClaim
	}

	return nil
}

func rewardTypeIsValid(rewardType string) bool {
	return rewardType == "" ||
		rewardType == RewardTypeHard ||
		rewardType == RewardTypeUSDXMinting ||
		rewardType == RewardTypeDelegator ||
		rewardType == RewardTypeSwap ||
		rewardType == RewardTypeSavings ||
		rewardType == RewardTypeEarn
}