/
grpc_query.go
130 lines (106 loc) · 3.35 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
package keeper
import (
"context"
"strconv"
"github.com/cosmos/cosmos-sdk/store/prefix"
"github.com/cosmos/cosmos-sdk/types/query"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmosquad-labs/squad/v3/x/marketmaker/types"
)
// Querier is used as Keeper will have duplicate methods if used directly, and gRPC names take precedence over keeper.
type Querier struct {
Keeper
}
var _ types.QueryServer = Querier{}
// Params queries the parameters of the marketmaker module.
func (k Querier) Params(c context.Context, _ *types.QueryParamsRequest) (*types.QueryParamsResponse, error) {
ctx := sdk.UnwrapSDKContext(c)
var params types.Params
k.Keeper.paramSpace.GetParamSet(ctx, ¶ms)
return &types.QueryParamsResponse{Params: params}, nil
}
// MarketMakers queries all market makers.
func (k Querier) MarketMakers(c context.Context, req *types.QueryMarketMakersRequest) (*types.QueryMarketMakersResponse, error) {
if req == nil {
return nil, status.Error(codes.InvalidArgument, "empty request")
}
ctx := sdk.UnwrapSDKContext(c)
var mmAddr sdk.AccAddress
var eligible bool
var err error
if req.Address != "" {
mmAddr, err = sdk.AccAddressFromBech32(req.Address)
if err != nil {
return nil, err
}
}
if req.Eligible != "" {
eligible, err = strconv.ParseBool(req.Eligible)
if err != nil {
return nil, err
}
}
// query specific market maker case
if !mmAddr.Empty() && req.PairId != 0 {
mm, found := k.GetMarketMaker(ctx, mmAddr, req.PairId)
if !found {
return &types.QueryMarketMakersResponse{}, nil
}
return &types.QueryMarketMakersResponse{
Marketmakers: []types.MarketMaker{
mm,
},
}, nil
}
store := ctx.KVStore(k.storeKey)
var keyPrefix = types.MarketMakerKeyPrefix
switch {
case req.PairId != 0:
keyPrefix = types.GetMarketMakerByPairIdPrefix(req.PairId)
case !mmAddr.Empty():
keyPrefix = types.GetMarketMakerByAddrPrefix(mmAddr)
}
mmStore := prefix.NewStore(store, keyPrefix)
var mmsRes []types.MarketMaker
pageRes, err := query.FilteredPaginate(mmStore, req.Pagination, func(key, value []byte, accumulate bool) (bool, error) {
var mm types.MarketMaker
switch {
case req.PairId != 0:
pairId, mmAddr := types.ParseMarketMakerIndexByPairIdKey(append(keyPrefix, key...))
mm, _ = k.GetMarketMaker(ctx, mmAddr, pairId)
default:
mm, err = types.UnmarshalMarketMaker(k.cdc, value)
if err != nil {
return false, err
}
}
if req.Eligible != "" && mm.Eligible != eligible {
return false, nil
}
if accumulate {
mmsRes = append(mmsRes, mm)
}
return true, nil
})
return &types.QueryMarketMakersResponse{Marketmakers: mmsRes, Pagination: pageRes}, nil
}
// Incentive queries all queued stakings of the farmer.
func (k Querier) Incentive(c context.Context, req *types.QueryIncentiveRequest) (*types.QueryIncentiveResponse, error) {
if req == nil || req.Address == "" {
return nil, status.Error(codes.InvalidArgument, "empty request")
}
ctx := sdk.UnwrapSDKContext(c)
var mmAddr sdk.AccAddress
var err error
mmAddr, err = sdk.AccAddressFromBech32(req.Address)
if err != nil {
return nil, err
}
incentive, found := k.GetIncentive(ctx, mmAddr)
if !found {
return nil, status.Errorf(codes.NotFound, "incentive for %s doesn't exist", req.Address)
}
return &types.QueryIncentiveResponse{Incentive: incentive}, nil
}