mirror of
https://github.com/0glabs/0g-chain.git
synced 2024-12-27 00:35:18 +00:00
339 lines
9.8 KiB
Go
339 lines
9.8 KiB
Go
package keeper
|
|
|
|
import (
|
|
"github.com/cosmos/cosmos-sdk/client"
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
|
|
supplyexported "github.com/cosmos/cosmos-sdk/x/supply/exported"
|
|
|
|
abci "github.com/tendermint/tendermint/abci/types"
|
|
|
|
"github.com/kava-labs/kava/x/hard/types"
|
|
)
|
|
|
|
// NewQuerier is the module level router for state queries
|
|
func NewQuerier(k Keeper) sdk.Querier {
|
|
return func(ctx sdk.Context, path []string, req abci.RequestQuery) (res []byte, err error) {
|
|
switch path[0] {
|
|
case types.QueryGetParams:
|
|
return queryGetParams(ctx, req, k)
|
|
case types.QueryGetModuleAccounts:
|
|
return queryGetModAccounts(ctx, req, k)
|
|
case types.QueryGetDeposits:
|
|
return queryGetDeposits(ctx, req, k)
|
|
case types.QueryGetDeposit:
|
|
return queryGetDeposit(ctx, req, k)
|
|
case types.QueryGetClaims:
|
|
return queryGetClaims(ctx, req, k)
|
|
case types.QueryGetBorrows:
|
|
return queryGetBorrows(ctx, req, k)
|
|
case types.QueryGetBorrow:
|
|
return queryGetBorrow(ctx, req, k)
|
|
case types.QueryGetBorrowed:
|
|
return queryGetBorrowed(ctx, req, k)
|
|
default:
|
|
return nil, sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unknown %s query endpoint", types.ModuleName)
|
|
}
|
|
}
|
|
}
|
|
|
|
func queryGetParams(ctx sdk.Context, _ abci.RequestQuery, k Keeper) ([]byte, error) {
|
|
// Get params
|
|
params := k.GetParams(ctx)
|
|
|
|
// Encode results
|
|
bz, err := codec.MarshalJSONIndent(k.cdc, params)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, err.Error())
|
|
}
|
|
return bz, nil
|
|
}
|
|
|
|
func queryGetModAccounts(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, error) {
|
|
|
|
var params types.QueryAccountParams
|
|
err := types.ModuleCdc.UnmarshalJSON(req.Data, ¶ms)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONUnmarshal, err.Error())
|
|
}
|
|
var accs []supplyexported.ModuleAccountI
|
|
if len(params.Name) > 0 {
|
|
acc := k.supplyKeeper.GetModuleAccount(ctx, params.Name)
|
|
accs = append(accs, acc)
|
|
} else {
|
|
acc := k.supplyKeeper.GetModuleAccount(ctx, types.ModuleAccountName)
|
|
accs = append(accs, acc)
|
|
acc = k.supplyKeeper.GetModuleAccount(ctx, types.LPAccount)
|
|
accs = append(accs, acc)
|
|
acc = k.supplyKeeper.GetModuleAccount(ctx, types.DelegatorAccount)
|
|
accs = append(accs, acc)
|
|
}
|
|
|
|
bz, err := codec.MarshalJSONIndent(k.cdc, accs)
|
|
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, err.Error())
|
|
}
|
|
|
|
return bz, nil
|
|
}
|
|
|
|
func queryGetDeposits(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, error) {
|
|
|
|
var params types.QueryDepositsParams
|
|
err := types.ModuleCdc.UnmarshalJSON(req.Data, ¶ms)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONUnmarshal, err.Error())
|
|
}
|
|
depositDenom := len(params.DepositDenom) > 0
|
|
owner := len(params.Owner) > 0
|
|
|
|
var deposits []types.Deposit
|
|
switch {
|
|
case depositDenom && owner:
|
|
deposit, found := k.GetDeposit(ctx, params.Owner)
|
|
if found {
|
|
for _, depCoin := range deposit.Amount {
|
|
if depCoin.Denom == params.DepositDenom {
|
|
deposits = append(deposits, deposit)
|
|
}
|
|
}
|
|
|
|
}
|
|
case depositDenom:
|
|
k.IterateDeposits(ctx, func(deposit types.Deposit) (stop bool) {
|
|
if deposit.Amount.AmountOf(params.DepositDenom).IsPositive() {
|
|
deposits = append(deposits, deposit)
|
|
}
|
|
return false
|
|
})
|
|
case owner:
|
|
deposit, found := k.GetDeposit(ctx, params.Owner)
|
|
if found {
|
|
deposits = append(deposits, deposit)
|
|
}
|
|
default:
|
|
k.IterateDeposits(ctx, func(deposit types.Deposit) (stop bool) {
|
|
deposits = append(deposits, deposit)
|
|
return false
|
|
})
|
|
}
|
|
|
|
start, end := client.Paginate(len(deposits), params.Page, params.Limit, 100)
|
|
if start < 0 || end < 0 {
|
|
deposits = []types.Deposit{}
|
|
} else {
|
|
deposits = deposits[start:end]
|
|
}
|
|
|
|
bz, err := codec.MarshalJSONIndent(types.ModuleCdc, deposits)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, err.Error())
|
|
}
|
|
|
|
return bz, nil
|
|
}
|
|
|
|
func queryGetClaims(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, error) {
|
|
|
|
var params types.QueryClaimParams
|
|
err := types.ModuleCdc.UnmarshalJSON(req.Data, ¶ms)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONUnmarshal, err.Error())
|
|
}
|
|
depositDenom := len(params.DepositDenom) > 0
|
|
owner := len(params.Owner) > 0
|
|
claimType := len(params.ClaimType) > 0
|
|
|
|
var claims []types.Claim
|
|
switch {
|
|
case depositDenom && owner && claimType:
|
|
claim, found := k.GetClaim(ctx, params.Owner, params.DepositDenom, params.ClaimType)
|
|
if found {
|
|
claims = append(claims, claim)
|
|
}
|
|
case depositDenom && owner:
|
|
for _, dt := range types.ClaimTypesClaimQuery {
|
|
claim, found := k.GetClaim(ctx, params.Owner, params.DepositDenom, dt)
|
|
if found {
|
|
claims = append(claims, claim)
|
|
}
|
|
}
|
|
case depositDenom && claimType:
|
|
k.IterateClaimsByTypeAndDenom(ctx, params.ClaimType, params.DepositDenom, func(claim types.Claim) (stop bool) {
|
|
claims = append(claims, claim)
|
|
return false
|
|
})
|
|
case owner && claimType:
|
|
hardParams := k.GetParams(ctx)
|
|
switch {
|
|
case params.ClaimType == types.LP:
|
|
for _, lps := range hardParams.LiquidityProviderSchedules {
|
|
claim, found := k.GetClaim(ctx, params.Owner, lps.DepositDenom, params.ClaimType)
|
|
if found {
|
|
claims = append(claims, claim)
|
|
}
|
|
}
|
|
case params.ClaimType == types.Stake:
|
|
for _, dss := range hardParams.DelegatorDistributionSchedules {
|
|
claim, found := k.GetClaim(ctx, params.Owner, dss.DistributionSchedule.DepositDenom, params.ClaimType)
|
|
if found {
|
|
claims = append(claims, claim)
|
|
}
|
|
}
|
|
}
|
|
case depositDenom:
|
|
for _, dt := range types.ClaimTypesClaimQuery {
|
|
k.IterateClaimsByTypeAndDenom(ctx, dt, params.DepositDenom, func(claim types.Claim) (stop bool) {
|
|
claims = append(claims, claim)
|
|
return false
|
|
})
|
|
}
|
|
case owner:
|
|
hardParams := k.GetParams(ctx)
|
|
for _, lps := range hardParams.LiquidityProviderSchedules {
|
|
claim, found := k.GetClaim(ctx, params.Owner, lps.DepositDenom, types.LP)
|
|
if found {
|
|
claims = append(claims, claim)
|
|
}
|
|
}
|
|
for _, dds := range hardParams.DelegatorDistributionSchedules {
|
|
claim, found := k.GetClaim(ctx, params.Owner, dds.DistributionSchedule.DepositDenom, types.Stake)
|
|
if found {
|
|
claims = append(claims, claim)
|
|
}
|
|
}
|
|
case claimType:
|
|
hardParams := k.GetParams(ctx)
|
|
for _, lps := range hardParams.LiquidityProviderSchedules {
|
|
k.IterateClaimsByTypeAndDenom(ctx, params.ClaimType, lps.DepositDenom, func(claim types.Claim) (stop bool) {
|
|
claims = append(claims, claim)
|
|
return false
|
|
})
|
|
}
|
|
for _, dds := range hardParams.DelegatorDistributionSchedules {
|
|
k.IterateClaimsByTypeAndDenom(ctx, params.ClaimType, dds.DistributionSchedule.DepositDenom, func(claim types.Claim) (stop bool) {
|
|
claims = append(claims, claim)
|
|
return false
|
|
})
|
|
}
|
|
default:
|
|
k.IterateClaims(ctx, func(claim types.Claim) (stop bool) {
|
|
claims = append(claims, claim)
|
|
return false
|
|
})
|
|
}
|
|
|
|
start, end := client.Paginate(len(claims), params.Page, params.Limit, 100)
|
|
if start < 0 || end < 0 {
|
|
claims = []types.Claim{}
|
|
} else {
|
|
claims = claims[start:end]
|
|
}
|
|
|
|
bz, err := codec.MarshalJSONIndent(types.ModuleCdc, claims)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, err.Error())
|
|
}
|
|
|
|
return bz, nil
|
|
}
|
|
|
|
func queryGetBorrows(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, error) {
|
|
var params types.QueryBorrowsParams
|
|
err := types.ModuleCdc.UnmarshalJSON(req.Data, ¶ms)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONUnmarshal, err.Error())
|
|
}
|
|
|
|
// TODO: filter query results
|
|
// depositDenom := len(params.BorrowDenom) > 0
|
|
// owner := len(params.Owner) > 0
|
|
|
|
var borrows []types.Borrow
|
|
k.IterateBorrows(ctx, func(borrow types.Borrow) (stop bool) {
|
|
borrows = append(borrows, borrow)
|
|
return false
|
|
})
|
|
|
|
start, end := client.Paginate(len(borrows), params.Page, params.Limit, 100)
|
|
if start < 0 || end < 0 {
|
|
borrows = []types.Borrow{}
|
|
} else {
|
|
borrows = borrows[start:end]
|
|
}
|
|
|
|
bz, err := codec.MarshalJSONIndent(types.ModuleCdc, borrows)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, err.Error())
|
|
}
|
|
|
|
return bz, nil
|
|
}
|
|
|
|
func queryGetBorrowed(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, error) {
|
|
var params types.QueryBorrowedParams
|
|
err := types.ModuleCdc.UnmarshalJSON(req.Data, ¶ms)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONUnmarshal, err.Error())
|
|
}
|
|
|
|
borrowedCoins, found := k.GetBorrowedCoins(ctx)
|
|
if !found {
|
|
return nil, types.ErrBorrowedCoinsNotFound
|
|
}
|
|
|
|
// If user specified a denom only return coins of that denom type
|
|
if len(params.Denom) > 0 {
|
|
borrowedCoins = sdk.NewCoins(sdk.NewCoin(params.Denom, borrowedCoins.AmountOf(params.Denom)))
|
|
}
|
|
|
|
bz, err := codec.MarshalJSONIndent(types.ModuleCdc, borrowedCoins)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, err.Error())
|
|
}
|
|
|
|
return bz, nil
|
|
}
|
|
|
|
func queryGetBorrow(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, error) {
|
|
var params types.QueryBorrowsParams
|
|
err := types.ModuleCdc.UnmarshalJSON(req.Data, ¶ms)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONUnmarshal, err.Error())
|
|
}
|
|
|
|
var borrowBalance sdk.Coins
|
|
if len(params.Owner) > 0 {
|
|
borrowBalance = k.GetBorrowBalance(ctx, params.Owner)
|
|
}
|
|
|
|
bz, err := codec.MarshalJSONIndent(types.ModuleCdc, borrowBalance)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, err.Error())
|
|
}
|
|
|
|
return bz, nil
|
|
}
|
|
|
|
func queryGetDeposit(ctx sdk.Context, req abci.RequestQuery, k Keeper) ([]byte, error) {
|
|
var params types.QueryDepositParams
|
|
err := types.ModuleCdc.UnmarshalJSON(req.Data, ¶ms)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONUnmarshal, err.Error())
|
|
}
|
|
|
|
var supplyBalance sdk.Coins
|
|
if len(params.Owner) > 0 {
|
|
supplyBalance = k.GetSupplyBalance(ctx, params.Owner)
|
|
}
|
|
|
|
bz, err := codec.MarshalJSONIndent(types.ModuleCdc, supplyBalance)
|
|
if err != nil {
|
|
return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, err.Error())
|
|
}
|
|
|
|
return bz, nil
|
|
}
|