-
Notifications
You must be signed in to change notification settings - Fork 0
/
grpc_query.go
149 lines (120 loc) · 4.15 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
142
143
144
145
146
147
148
149
package keeper
import (
"bytes"
"context"
"strings"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/ethereum/go-ethereum/common"
"github.com/fury-labs/fury-bridge/x/bridge/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 queries module params
func (s queryServer) Params(stdCtx context.Context, req *types.QueryParamsRequest) (*types.QueryParamsResponse, error) {
if req == nil {
return nil, status.Errorf(codes.InvalidArgument, "empty request")
}
ctx := sdk.UnwrapSDKContext(stdCtx)
params := s.keeper.GetParams(ctx)
return &types.QueryParamsResponse{Params: params}, nil
}
// ERC20BridgePairs queries ERC20 bridge pair addresses.
func (s queryServer) ERC20BridgePairs(
stdCtx context.Context,
req *types.QueryERC20BridgePairsRequest,
) (*types.QueryERC20BridgePairsResponse, error) {
if req == nil {
return nil, status.Errorf(codes.InvalidArgument, "empty request")
}
ctx := sdk.UnwrapSDKContext(stdCtx)
var bridgePairs types.ERC20BridgePairs
s.keeper.IterateBridgePairs(ctx, func(pair types.ERC20BridgePair) bool {
bridgePairs = append(bridgePairs, pair)
return false
})
return &types.QueryERC20BridgePairsResponse{
ERC20BridgePairs: bridgePairs,
}, nil
}
// ERC20BridgePair queries for a ERC20 bridge pair's addresses.
func (s queryServer) ERC20BridgePair(
stdCtx context.Context,
req *types.QueryERC20BridgePairRequest,
) (*types.QueryERC20BridgePairResponse, error) {
if req == nil {
return nil, status.Errorf(codes.InvalidArgument, "empty request")
}
ctx := sdk.UnwrapSDKContext(stdCtx)
if !common.IsHexAddress(req.Address) {
return nil, status.Error(codes.InvalidArgument, "invalid hex address")
}
addrBytes := common.HexToAddress(req.Address)
var bridgePair types.ERC20BridgePair
found := false
s.keeper.IterateBridgePairs(ctx, func(pair types.ERC20BridgePair) bool {
// Match either internal or external
if bytes.Equal(pair.ExternalERC20Address, addrBytes.Bytes()) || bytes.Equal(pair.InternalERC20Address, addrBytes.Bytes()) {
bridgePair = pair
found = true
return true
}
return false
})
if !found {
return nil, status.Error(codes.NotFound, "could not find an ERC20 bridge pair with the provided address")
}
return &types.QueryERC20BridgePairResponse{
ERC20BridgePair: bridgePair,
}, nil
}
// ConversionPairs queries for all conversion pairs.
func (s queryServer) ConversionPairs(
stdCtx context.Context,
req *types.QueryConversionPairsRequest,
) (*types.QueryConversionPairsResponse, error) {
if req == nil {
return nil, status.Errorf(codes.InvalidArgument, "empty request")
}
ctx := sdk.UnwrapSDKContext(stdCtx)
params := s.keeper.GetParams(ctx)
return &types.QueryConversionPairsResponse{
ConversionPairs: params.EnabledConversionPairs,
}, nil
}
// ConversionPair queries for a conversion pair with an ERC20 address or sdk.Coin denom.
func (s queryServer) ConversionPair(
stdCtx context.Context,
req *types.QueryConversionPairRequest,
) (*types.QueryConversionPairResponse, error) {
if req == nil {
return nil, status.Errorf(codes.InvalidArgument, "empty request")
}
ctx := sdk.UnwrapSDKContext(stdCtx)
if !common.IsHexAddress(req.AddressOrDenom) {
// If not hex addr, try as denom
// If both addr and denom are invalid then return err
if err := sdk.ValidateDenom(req.AddressOrDenom); err != nil {
return nil, status.Error(codes.InvalidArgument, "invalid hex address or denom")
}
}
// Not valid if request is a denom
addrBytes := common.HexToAddress(req.AddressOrDenom)
params := s.keeper.GetParams(ctx)
for _, pair := range params.EnabledConversionPairs {
// Match either address bytes or denom string
if bytes.Equal(pair.FuryERC20Address, addrBytes.Bytes()) || pair.Denom == strings.TrimSpace(req.AddressOrDenom) {
return &types.QueryConversionPairResponse{
ConversionPair: pair,
}, nil
}
}
return nil, status.Error(codes.NotFound, "could not find bridge pair with provided address or denom")
}