forked from Kava-Labs/kava
/
grpc_query.go
141 lines (119 loc) · 3.58 KB
/
grpc_query.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
package keeper
import (
"context"
"strings"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"github.com/cosmos/cosmos-sdk/client"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/cosmos/cosmos-sdk/types/query"
"github.com/mokitanetwork/aether/x/savings/types"
)
type queryServer struct {
keeper Keeper
}
// NewQueryServerImpl creates a new server for handling gRPC queries.
func NewQueryServerImpl(k Keeper) types.QueryServer {
return &queryServer{keeper: k}
}
var _ types.QueryServer = queryServer{}
// Params implements the gRPC service handler for querying x/savings parameters.
func (s queryServer) Params(c context.Context, req *types.QueryParamsRequest) (*types.QueryParamsResponse, error) {
if req == nil {
return nil, status.Errorf(codes.InvalidArgument, "empty request")
}
sdkCtx := sdk.UnwrapSDKContext(c)
params := s.keeper.GetParams(sdkCtx)
return &types.QueryParamsResponse{Params: params}, nil
}
func (s queryServer) Deposits(ctx context.Context, req *types.QueryDepositsRequest) (*types.QueryDepositsResponse, error) {
if req == nil {
return nil, status.Errorf(codes.InvalidArgument, "empty request")
}
sdkCtx := sdk.UnwrapSDKContext(ctx)
hasDenom := len(req.Denom) > 0
hasOwner := len(req.Owner) > 0
var owner sdk.AccAddress
var err error
if hasOwner {
owner, err = sdk.AccAddressFromBech32(req.Owner)
if err != nil {
return nil, sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, err.Error())
}
}
var deposits types.Deposits
switch {
case hasOwner && hasDenom:
deposit, found := s.keeper.GetDeposit(sdkCtx, owner)
if found {
for _, coin := range deposit.Amount {
if coin.Denom == req.Denom {
deposits = append(deposits, deposit)
}
}
}
case hasOwner:
deposit, found := s.keeper.GetDeposit(sdkCtx, owner)
if found {
deposits = append(deposits, deposit)
}
case hasDenom:
s.keeper.IterateDeposits(sdkCtx, func(deposit types.Deposit) (stop bool) {
if deposit.Amount.AmountOf(req.Denom).IsPositive() {
deposits = append(deposits, deposit)
}
return false
})
default:
s.keeper.IterateDeposits(sdkCtx, func(deposit types.Deposit) (stop bool) {
deposits = append(deposits, deposit)
return false
})
}
page, limit, err := query.ParsePagination(req.Pagination)
if err != nil {
return nil, err
}
start, end := client.Paginate(len(deposits), page, limit, 100)
if start < 0 || end < 0 {
deposits = types.Deposits{}
} else {
deposits = deposits[start:end]
}
return &types.QueryDepositsResponse{
Deposits: deposits,
Pagination: nil,
}, nil
}
func (s queryServer) TotalSupply(ctx context.Context, req *types.QueryTotalSupplyRequest) (*types.QueryTotalSupplyResponse, error) {
sdkCtx := sdk.UnwrapSDKContext(ctx)
totalSupply := sdk.NewCoins()
liquidStakedDerivatives := sdk.NewCoins()
s.keeper.IterateDeposits(sdkCtx, func(deposit types.Deposit) (stop bool) {
for _, c := range deposit.Amount {
// separate out baeth denoms
if strings.HasPrefix(c.Denom, baethPrefix) {
liquidStakedDerivatives = liquidStakedDerivatives.Add(c)
} else {
totalSupply = totalSupply.Add(c)
}
}
return false
})
// determine underlying value of baeth denoms
if len(liquidStakedDerivatives) > 0 {
underlyingValue, err := s.keeper.liquidKeeper.GetStakedTokensForDerivatives(
sdkCtx,
liquidStakedDerivatives,
)
if err != nil {
return nil, err
}
totalSupply = totalSupply.Add(sdk.NewCoin(baethDenom, underlyingValue.Amount))
}
return &types.QueryTotalSupplyResponse{
Height: sdkCtx.BlockHeight(),
Result: totalSupply,
}, nil
}