From 11cf89a3ce4757eb593321b32864511c8a61c3cb Mon Sep 17 00:00:00 2001 From: aljo242 Date: Wed, 29 Nov 2023 14:18:12 -0500 Subject: [PATCH] state query --- proto/feemarket/feemarket/v1/query.proto | 14 + x/feemarket/client/cli/query.go | 28 ++ x/feemarket/keeper/query_server.go | 12 + x/feemarket/types/query.pb.go | 362 ++++++++++++++++++++++- x/feemarket/types/query.pb.gw.go | 65 ++++ 5 files changed, 468 insertions(+), 13 deletions(-) diff --git a/proto/feemarket/feemarket/v1/query.proto b/proto/feemarket/feemarket/v1/query.proto index 1349271..e505627 100644 --- a/proto/feemarket/feemarket/v1/query.proto +++ b/proto/feemarket/feemarket/v1/query.proto @@ -6,6 +6,7 @@ option go_package = "github.com/skip-mev/feemarket/x/feemarket/types"; import "gogoproto/gogo.proto"; import "google/api/annotations.proto"; import "feemarket/feemarket/v1/params.proto"; +import "feemarket/feemarket/v1/genesis.proto"; // Query Service for the feemarket module. service Query { @@ -15,6 +16,13 @@ service Query { get : "/feemarket/v1/params" }; }; + + // State returns the current feemarket module state. + rpc State(StateRequest) returns (StateResponse) { + option (google.api.http) = { + get : "/feemarket/v1/state" + }; + }; } // ParamsRequest is the request type for the Query/Params RPC method. @@ -22,3 +30,9 @@ message ParamsRequest {} // ParamsResponse is the response type for the Query/Params RPC method. message ParamsResponse { Params params = 1 [ (gogoproto.nullable) = false ]; } + +// StateRequest is the request type for the Query/State RPC method. +message StateRequest {} + +// StateResponse is the response type for the Query/State RPC method. +message StateResponse { State state = 1 [ (gogoproto.nullable) = false ]; } diff --git a/x/feemarket/client/cli/query.go b/x/feemarket/client/cli/query.go index d36139b..851c674 100644 --- a/x/feemarket/client/cli/query.go +++ b/x/feemarket/client/cli/query.go @@ -24,6 +24,7 @@ func GetQueryCmd() *cobra.Command { // add sub-commands cmd.AddCommand( GetParamsCmd(), + GetStateCmd(), ) return cmd @@ -55,3 +56,30 @@ func GetParamsCmd() *cobra.Command { return cmd } + +// GetStateCmd returns the cli-command that queries the current feemarket state. +func GetStateCmd() *cobra.Command { + cmd := &cobra.Command{ + Use: "state", + Short: "Query for the current feemarket state", + Args: cobra.NoArgs, + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx, err := client.GetClientQueryContext(cmd) + if err != nil { + return err + } + + queryClient := types.NewQueryClient(clientCtx) + resp, err := queryClient.State(cmd.Context(), &types.StateRequest{}) + if err != nil { + return err + } + + return clientCtx.PrintProto(&resp.State) + }, + } + + flags.AddQueryFlagsToCmd(cmd) + + return cmd +} diff --git a/x/feemarket/keeper/query_server.go b/x/feemarket/keeper/query_server.go index 1907402..af0dc58 100644 --- a/x/feemarket/keeper/query_server.go +++ b/x/feemarket/keeper/query_server.go @@ -31,3 +31,15 @@ func (q QueryServer) Params(goCtx context.Context, _ *types.ParamsRequest) (*typ return &types.ParamsResponse{Params: params}, nil } + +// State defines a method that returns the current feemarket state. +func (q QueryServer) State(goCtx context.Context, _ *types.StateRequest) (*types.StateResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + state, err := q.k.GetState(ctx) + if err != nil { + return nil, err + } + + return &types.StateResponse{State: state}, nil +} diff --git a/x/feemarket/types/query.pb.go b/x/feemarket/types/query.pb.go index 60b7b52..2cb5cd9 100644 --- a/x/feemarket/types/query.pb.go +++ b/x/feemarket/types/query.pb.go @@ -111,9 +111,93 @@ func (m *ParamsResponse) GetParams() Params { return Params{} } +// StateRequest is the request type for the Query/State RPC method. +type StateRequest struct { +} + +func (m *StateRequest) Reset() { *m = StateRequest{} } +func (m *StateRequest) String() string { return proto.CompactTextString(m) } +func (*StateRequest) ProtoMessage() {} +func (*StateRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_d683b3b0d8494138, []int{2} +} +func (m *StateRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StateRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_StateRequest.Merge(m, src) +} +func (m *StateRequest) XXX_Size() int { + return m.Size() +} +func (m *StateRequest) XXX_DiscardUnknown() { + xxx_messageInfo_StateRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_StateRequest proto.InternalMessageInfo + +// StateResponse is the response type for the Query/State RPC method. +type StateResponse struct { + State State `protobuf:"bytes,1,opt,name=state,proto3" json:"state"` +} + +func (m *StateResponse) Reset() { *m = StateResponse{} } +func (m *StateResponse) String() string { return proto.CompactTextString(m) } +func (*StateResponse) ProtoMessage() {} +func (*StateResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_d683b3b0d8494138, []int{3} +} +func (m *StateResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *StateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_StateResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *StateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_StateResponse.Merge(m, src) +} +func (m *StateResponse) XXX_Size() int { + return m.Size() +} +func (m *StateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_StateResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_StateResponse proto.InternalMessageInfo + +func (m *StateResponse) GetState() State { + if m != nil { + return m.State + } + return State{} +} + func init() { proto.RegisterType((*ParamsRequest)(nil), "feemarket.feemarket.v1.ParamsRequest") proto.RegisterType((*ParamsResponse)(nil), "feemarket.feemarket.v1.ParamsResponse") + proto.RegisterType((*StateRequest)(nil), "feemarket.feemarket.v1.StateRequest") + proto.RegisterType((*StateResponse)(nil), "feemarket.feemarket.v1.StateResponse") } func init() { @@ -121,24 +205,29 @@ func init() { } var fileDescriptor_d683b3b0d8494138 = []byte{ - // 268 bytes of a gzipped FileDescriptorProto + // 346 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x52, 0x4a, 0x4b, 0x4d, 0xcd, 0x4d, 0x2c, 0xca, 0x4e, 0x2d, 0xd1, 0x47, 0xb0, 0xca, 0x0c, 0xf5, 0x0b, 0x4b, 0x53, 0x8b, 0x2a, 0xf5, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0xc4, 0xe0, 0x32, 0x7a, 0x08, 0x56, 0x99, 0xa1, 0x94, 0x48, 0x7a, 0x7e, 0x7a, 0x3e, 0x58, 0x89, 0x3e, 0x88, 0x05, 0x51, 0x2d, 0x25, 0x93, 0x9e, 0x9f, 0x9f, 0x9e, 0x93, 0xaa, 0x9f, 0x58, 0x90, 0xa9, 0x9f, 0x98, 0x97, 0x97, 0x5f, 0x92, 0x58, 0x92, - 0x99, 0x9f, 0x57, 0x0c, 0x95, 0x55, 0xc6, 0x61, 0x5f, 0x41, 0x62, 0x51, 0x62, 0x2e, 0x54, 0x91, - 0x12, 0x3f, 0x17, 0x6f, 0x00, 0x98, 0x1f, 0x94, 0x5a, 0x58, 0x9a, 0x5a, 0x5c, 0xa2, 0xe4, 0xc7, - 0xc5, 0x07, 0x13, 0x28, 0x2e, 0xc8, 0xcf, 0x2b, 0x4e, 0x15, 0xb2, 0xe1, 0x62, 0x83, 0x68, 0x91, - 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x36, 0x92, 0xd3, 0xc3, 0xee, 0x48, 0x3d, 0x88, 0x3e, 0x27, 0x96, - 0x13, 0xf7, 0xe4, 0x19, 0x82, 0xa0, 0x7a, 0x8c, 0xea, 0xb8, 0x58, 0x03, 0x41, 0x1e, 0x14, 0x2a, - 0xe5, 0x62, 0x83, 0x28, 0x10, 0x52, 0xc5, 0x6f, 0x00, 0xd4, 0x25, 0x52, 0x6a, 0x84, 0x94, 0x41, - 0xdc, 0xa7, 0x24, 0xd3, 0x74, 0xf9, 0xc9, 0x64, 0x26, 0x31, 0x21, 0x11, 0x6c, 0xde, 0x74, 0xf2, - 0x3c, 0xf1, 0x48, 0x8e, 0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, - 0x63, 0xb8, 0xf0, 0x58, 0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0xfd, 0xf4, 0xcc, 0x92, 0x8c, - 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0xfd, 0xe2, 0xec, 0xcc, 0x02, 0xdd, 0xdc, 0xd4, 0x32, 0x24, - 0x23, 0x2a, 0x90, 0xd8, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0xe0, 0x20, 0x33, 0x06, 0x04, - 0x00, 0x00, 0xff, 0xff, 0x5d, 0xe7, 0x26, 0x76, 0xc9, 0x01, 0x00, 0x00, + 0x99, 0x9f, 0x57, 0x0c, 0x95, 0x55, 0xc6, 0x61, 0x5f, 0x41, 0x62, 0x51, 0x62, 0x2e, 0x4c, 0x91, + 0x0a, 0x0e, 0x45, 0xe9, 0xa9, 0x79, 0xa9, 0xc5, 0x99, 0x50, 0x55, 0x4a, 0xfc, 0x5c, 0xbc, 0x01, + 0x60, 0x5d, 0x41, 0xa9, 0x85, 0xa5, 0xa9, 0xc5, 0x25, 0x4a, 0x7e, 0x5c, 0x7c, 0x30, 0x81, 0xe2, + 0x82, 0xfc, 0xbc, 0xe2, 0x54, 0x21, 0x1b, 0x2e, 0x36, 0x88, 0xc1, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, + 0xdc, 0x46, 0x72, 0x7a, 0xd8, 0xbd, 0xa2, 0x07, 0xd1, 0xe7, 0xc4, 0x72, 0xe2, 0x9e, 0x3c, 0x43, + 0x10, 0x54, 0x8f, 0x12, 0x1f, 0x17, 0x4f, 0x70, 0x49, 0x62, 0x49, 0x2a, 0xcc, 0x7c, 0x2f, 0x2e, + 0x5e, 0x28, 0x1f, 0x6a, 0xbc, 0x25, 0x17, 0x6b, 0x31, 0x48, 0x00, 0x6a, 0xba, 0x2c, 0x2e, 0xd3, + 0xc1, 0xba, 0xa0, 0x86, 0x43, 0x74, 0x18, 0x7d, 0x64, 0xe4, 0x62, 0x0d, 0x04, 0x85, 0xb1, 0x50, + 0x29, 0x17, 0x1b, 0xc4, 0x76, 0x21, 0x55, 0xfc, 0xae, 0x83, 0x3a, 0x43, 0x4a, 0x8d, 0x90, 0x32, + 0x88, 0xeb, 0x94, 0x64, 0x9a, 0x2e, 0x3f, 0x99, 0xcc, 0x24, 0x26, 0x24, 0x82, 0x2d, 0xa4, 0x85, + 0x0a, 0xb9, 0x58, 0xc1, 0xce, 0x12, 0x52, 0xc1, 0xeb, 0x6a, 0x98, 0xa5, 0xaa, 0x04, 0x54, 0x41, + 0xed, 0x94, 0x06, 0xdb, 0x29, 0x2a, 0x24, 0x8c, 0x6a, 0x27, 0xd8, 0xcf, 0x4e, 0x9e, 0x27, 0x1e, + 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17, + 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0xa5, 0x9f, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, + 0x97, 0x9c, 0x9f, 0xab, 0x5f, 0x9c, 0x9d, 0x59, 0xa0, 0x9b, 0x9b, 0x5a, 0x86, 0x64, 0x42, 0x05, + 0x12, 0xbb, 0xa4, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, 0x9c, 0x04, 0x8c, 0x01, 0x01, 0x00, 0x00, + 0xff, 0xff, 0x49, 0x79, 0x9e, 0x42, 0xbf, 0x02, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -155,6 +244,8 @@ const _ = grpc.SupportPackageIsVersion4 type QueryClient interface { // Params returns the current feemarket module parameters. Params(ctx context.Context, in *ParamsRequest, opts ...grpc.CallOption) (*ParamsResponse, error) + // State returns the current feemarket module state. + State(ctx context.Context, in *StateRequest, opts ...grpc.CallOption) (*StateResponse, error) } type queryClient struct { @@ -174,10 +265,21 @@ func (c *queryClient) Params(ctx context.Context, in *ParamsRequest, opts ...grp return out, nil } +func (c *queryClient) State(ctx context.Context, in *StateRequest, opts ...grpc.CallOption) (*StateResponse, error) { + out := new(StateResponse) + err := c.cc.Invoke(ctx, "/feemarket.feemarket.v1.Query/State", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // QueryServer is the server API for Query service. type QueryServer interface { // Params returns the current feemarket module parameters. Params(context.Context, *ParamsRequest) (*ParamsResponse, error) + // State returns the current feemarket module state. + State(context.Context, *StateRequest) (*StateResponse, error) } // UnimplementedQueryServer can be embedded to have forward compatible implementations. @@ -187,6 +289,9 @@ type UnimplementedQueryServer struct { func (*UnimplementedQueryServer) Params(ctx context.Context, req *ParamsRequest) (*ParamsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Params not implemented") } +func (*UnimplementedQueryServer) State(ctx context.Context, req *StateRequest) (*StateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method State not implemented") +} func RegisterQueryServer(s grpc1.Server, srv QueryServer) { s.RegisterService(&_Query_serviceDesc, srv) @@ -210,6 +315,24 @@ func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interf return interceptor(ctx, in, info, handler) } +func _Query_State_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(StateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).State(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/feemarket.feemarket.v1.Query/State", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).State(ctx, req.(*StateRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _Query_serviceDesc = grpc.ServiceDesc{ ServiceName: "feemarket.feemarket.v1.Query", HandlerType: (*QueryServer)(nil), @@ -218,6 +341,10 @@ var _Query_serviceDesc = grpc.ServiceDesc{ MethodName: "Params", Handler: _Query_Params_Handler, }, + { + MethodName: "State", + Handler: _Query_State_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "feemarket/feemarket/v1/query.proto", @@ -279,6 +406,62 @@ func (m *ParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *StateRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StateRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *StateResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *StateResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *StateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.State.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + return len(dAtA) - i, nil +} + func encodeVarintQuery(dAtA []byte, offset int, v uint64) int { offset -= sovQuery(v) base := offset @@ -310,6 +493,26 @@ func (m *ParamsResponse) Size() (n int) { return n } +func (m *StateRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *StateResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = m.State.Size() + n += 1 + l + sovQuery(uint64(l)) + return n +} + func sovQuery(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -449,6 +652,139 @@ func (m *ParamsResponse) Unmarshal(dAtA []byte) error { } return nil } +func (m *StateRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *StateResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: StateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: StateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipQuery(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/feemarket/types/query.pb.gw.go b/x/feemarket/types/query.pb.gw.go index 3cc3407..ed8c553 100644 --- a/x/feemarket/types/query.pb.gw.go +++ b/x/feemarket/types/query.pb.gw.go @@ -51,6 +51,24 @@ func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshal } +func request_Query_State_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq StateRequest + var metadata runtime.ServerMetadata + + msg, err := client.State(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_State_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq StateRequest + var metadata runtime.ServerMetadata + + msg, err := server.State(ctx, &protoReq) + return msg, metadata, err + +} + // RegisterQueryHandlerServer registers the http handlers for service Query to "mux". // UnaryRPC :call QueryServer directly. // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. @@ -80,6 +98,29 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv }) + mux.Handle("GET", pattern_Query_State_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + var stream runtime.ServerTransportStream + ctx = grpc.NewContextWithServerTransportStream(ctx, &stream) + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_State_0(rctx, inboundMarshaler, server, req, pathParams) + md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer()) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_State_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } @@ -141,13 +182,37 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie }) + mux.Handle("GET", pattern_Query_State_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { + ctx, cancel := context.WithCancel(req.Context()) + defer cancel() + inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) + rctx, err := runtime.AnnotateContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := request_Query_State_0(rctx, inboundMarshaler, client, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_State_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + return nil } var ( pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"feemarket", "v1", "params"}, "", runtime.AssumeColonVerbOpt(false))) + + pattern_Query_State_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"feemarket", "v1", "state"}, "", runtime.AssumeColonVerbOpt(false))) ) var ( forward_Query_Params_0 = runtime.ForwardResponseMessage + + forward_Query_State_0 = runtime.ForwardResponseMessage )