diff --git a/go.sum b/go.sum index 016423154..ce3742d0a 100644 --- a/go.sum +++ b/go.sum @@ -107,8 +107,6 @@ github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfc github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= github.com/cosmos/go-bip39 v0.0.0-20180819234021-555e2067c45d h1:49RLWk1j44Xu4fjHb6JFYmeUnDORVwHNkDxaQ0ctCVU= github.com/cosmos/go-bip39 v0.0.0-20180819234021-555e2067c45d/go.mod h1:tSxLoYXyBmiFeKpvmq4dzayMdCjCnu8uqmCysIGBT2Y= -github.com/cosmos/iavl v0.15.0-rc1 h1:cYMPAxu5xpGPhGYvGlpeCmgmgH7oY+kebZm2oHfh2nE= -github.com/cosmos/iavl v0.15.0-rc1/go.mod h1:qFTkoCC00sBKWCG3Ws8GAUaYR1jIOtwNZ9p8uFOu4Jo= github.com/cosmos/iavl v0.15.0-rc2 h1:4HI/LYLjWUnou8dehPD+NqEsDc8uamJOU2yHcqdTKv8= github.com/cosmos/iavl v0.15.0-rc2/go.mod h1:bXLXbwmww0kYtAYRCYNXR/k44lWaK8rIZJlCmqSK8lQ= github.com/cosmos/ledger-cosmos-go v0.11.1 h1:9JIYsGnXP613pb2vPjFeMMjBI5lEDsEaF6oYorTy6J4= @@ -444,8 +442,6 @@ github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt2 github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4= github.com/prometheus/common v0.10.0 h1:RyRA7RzGXQZiW+tGMr7sxa85G1z0yOpM1qq5c8lNawc= github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo= -github.com/prometheus/common v0.12.0 h1:mj4ewtVukAfkS37JU7IXPJPr7zwLEjwgWO6nZo8ROvk= -github.com/prometheus/common v0.12.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s= github.com/prometheus/common v0.13.0 h1:vJlpe9wPgDRM1Z+7Wj3zUUjY1nr6/1jNKyl7llliccg= github.com/prometheus/common v0.13.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s= github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= @@ -510,7 +506,6 @@ github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s= github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE= -github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= github.com/spf13/viper v1.7.1 h1:pM5oEahlgWv/WnHXpgbKz7iLIxRf65tye2Ci+XFK5sk= github.com/spf13/viper v1.7.1/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg= github.com/streadway/amqp v0.0.0-20190404075320-75d898a42a94/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= @@ -537,11 +532,8 @@ github.com/tendermint/crypto v0.0.0-20191022145703-50d29ede1e15 h1:hqAk8riJvK4RM github.com/tendermint/crypto v0.0.0-20191022145703-50d29ede1e15/go.mod h1:z4YtwM70uOnk8h0pjJYlj3zdYwi9l03By6iAIF5j/Pk= github.com/tendermint/go-amino v0.15.1 h1:D2uk35eT4iTsvJd9jWIetzthE5C0/k2QmMFkCN+4JgQ= github.com/tendermint/go-amino v0.15.1/go.mod h1:TQU0M1i/ImAo+tYpZi73AU3V/dKeCoMC9Sphe2ZwGME= -github.com/tendermint/tendermint v0.34.0-rc2/go.mod h1:+AG8ftE2PD4uMVzGSB7c0oH9xbTlIyMeoX0M9r89x3Y= github.com/tendermint/tendermint v0.34.0-rc3 h1:d7Fsd5rdbxq4GmJ0kRfx7l7LesQM7e70f0ytWLTQ/Go= github.com/tendermint/tendermint v0.34.0-rc3/go.mod h1:BoHcEpjfpBHc1Be7RQz3AHaXFNObcDG7SNHCev6Or4g= -github.com/tendermint/tm-db v0.6.0 h1:Us30k7H1UDcdqoSPhmP8ztAW/SWV6c6OfsfeCiboTC4= -github.com/tendermint/tm-db v0.6.0/go.mod h1:xj3AWJ08kBDlCHKijnhJ7mTcDMOikT1r8Poxy2pJn7Q= github.com/tendermint/tm-db v0.6.1 h1:w3X87itMPXopcRPlFiqspEKhw4FXihPk2rnFFkP0zGk= github.com/tendermint/tm-db v0.6.1/go.mod h1:m3x9kRP4UFd7JODJL0yBAZqE7wTw+S37uAE90cTx7OA= github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= @@ -753,7 +745,6 @@ google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQ google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk= google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60= -google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/grpc v1.31.0 h1:T7P4R73V3SSDPhH7WW7ATbfViLtmamH0DKrP3f9AuDI= google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak= google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8= @@ -799,7 +790,6 @@ honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWh honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= -honnef.co/go/tools v0.0.1-2019.2.3 h1:3JgtbtFHMiCmsznwGVTUWbgGov+pVqnlf1dEJTNAXeM= honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= diff --git a/proto/ibc/client/client.proto b/proto/ibc/client/client.proto index 9385f53b5..15be107ea 100644 --- a/proto/ibc/client/client.proto +++ b/proto/ibc/client/client.proto @@ -8,8 +8,16 @@ import "google/protobuf/any.proto"; // IdentifiedClientState defines a client state with additional client identifier field. message IdentifiedClientState { - option (gogoproto.goproto_getters) = false; // client identifier - string id = 1 [(gogoproto.moretags) = "yaml:\"id\""]; - google.protobuf.Any client_state = 2; + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + // client state + google.protobuf.Any client_state = 2 [(gogoproto.moretags) = "yaml:\"client_state\""]; +} + +// ClientConsensusStates defines all the stored consensus states for a given client. +message ClientConsensusStates { + // client identifier + string client_id = 1 [(gogoproto.moretags) = "yaml:\"client_id\""]; + // consensus states associated with the client + repeated google.protobuf.Any consensus_states = 2 [(gogoproto.moretags) = "yaml:\"consensus_states\""]; } diff --git a/proto/ibc/client/genesis.proto b/proto/ibc/client/genesis.proto index 6a45043f6..ee399c49f 100644 --- a/proto/ibc/client/genesis.proto +++ b/proto/ibc/client/genesis.proto @@ -3,36 +3,19 @@ package ibc.client; option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types"; +import "ibc/client/client.proto"; import "gogoproto/gogo.proto"; -import "google/protobuf/any.proto"; - -// GenesisClientState defines an identified ClientState as protobuf Any format. -message GenesisClientState { - string client_id = 1 [ - (gogoproto.moretags) = "yaml:\"client_id\"" - ]; - google.protobuf.Any client_state = 2 [(gogoproto.moretags) = "yaml:\"client_state\""]; -} - -// ClientConsensusStates defines all the stored consensus states for a given client. -message ClientConsensusStates { - string client_id = 1; - repeated google.protobuf.Any consensus_states = 2 [ - (gogoproto.moretags) = "yaml:\"consensus_states\"" - ]; -} // GenesisState defines the ibc client submodule's genesis state. message GenesisState { - repeated GenesisClientState clients = 1 [ - (gogoproto.nullable) = false - ]; + // client states with their corresponding identifiers + repeated IdentifiedClientState clients = 1 [(gogoproto.nullable) = false]; + // consensus states from each client repeated ClientConsensusStates clients_consensus = 2 [ - (gogoproto.nullable) = false, + (gogoproto.nullable) = false, (gogoproto.castrepeated) = "ClientsConsensusStates", - (gogoproto.moretags) = "yaml:\"clients_consensus\"" - ]; - bool create_localhost = 3 [ - (gogoproto.moretags) = "yaml:\"create_localhost\"" + (gogoproto.moretags) = "yaml:\"clients_consensus\"" ]; + // create localhost on initialization + bool create_localhost = 3 [(gogoproto.moretags) = "yaml:\"create_localhost\""]; } diff --git a/proto/ibc/client/query.proto b/proto/ibc/client/query.proto new file mode 100644 index 000000000..0571f2441 --- /dev/null +++ b/proto/ibc/client/query.proto @@ -0,0 +1,108 @@ +syntax = "proto3"; +package ibc.client; + +import "cosmos/base/query/v1beta1/pagination.proto"; +import "ibc/client/client.proto"; +import "google/protobuf/any.proto"; +import "google/api/annotations.proto"; + +option go_package = "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types"; + +// Query provides defines the gRPC querier service +service Query { + // ClientState queries an IBC light client. + rpc ClientState(QueryClientStateRequest) returns (QueryClientStateResponse) { + option (google.api.http).get = "/ibc/client/v1beta1/client_states/{client_id}"; + } + + // ClientStates queries all the IBC light clients of a chain. + rpc ClientStates(QueryClientStatesRequest) returns (QueryClientStatesResponse) { + option (google.api.http).get = "/ibc/client/v1beta1/client_states"; + } + + // ConsensusState queries a consensus state associated with a client state at a given height. + rpc ConsensusState(QueryConsensusStateRequest) returns (QueryConsensusStateResponse) { + option (google.api.http).get = "/ibc/client/v1beta1/consensus_states/{client_id}/{height}"; + } + + // ConsensusStates queries all the consensus state associated with a given client. + rpc ConsensusStates(QueryConsensusStatesRequest) returns (QueryConsensusStatesResponse) { + option (google.api.http).get = "/ibc/client/v1beta1/consensus_states/{client_id}"; + } +} + +// QueryClientStateRequest is the request type for the Query/ClientState RPC +// method +message QueryClientStateRequest { + // client state unique identifier + string client_id = 1; +} + +// QueryClientStateResponse is the response type for the Query/ClientState RPC +// method. Besides the client state, it includes a proof and the height from +// which the proof was retrieved. +message QueryClientStateResponse { + // client state associated with the request identifier + google.protobuf.Any client_state = 1; + // merkle proof of existence + bytes proof = 2; + // merkle proof path + string proof_path = 3; + // height at which the proof was retrieved + uint64 proof_height = 4; +} + +// QueryClientStatesRequest is the request type for the Query/ClientStates RPC +// method +message QueryClientStatesRequest { + // pagination request + cosmos.base.query.v1beta1.PageRequest pagination = 1; +} + +// QueryClientStatesResponse is the response type for the Query/ClientStates RPC +// method. +message QueryClientStatesResponse { + // list of stored ClientStates of the chain. + repeated IdentifiedClientState client_states = 1; + // pagination response + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} + +// QueryConsensusStateRequest is the request type for the Query/ConsensusState RPC method. Besides +// the consensus state, it includes a proof and the height from which the proof was retrieved. +message QueryConsensusStateRequest { + // client identifier + string client_id = 1; + // consensus state height + uint64 height = 2; + // latest_height overrrides the height field and queries the latest stored ConsensusState + bool latest_height = 3; +} + +// QueryConsensusStateResponse is the response type for the Query/ConsensusState RPC method +message QueryConsensusStateResponse { + // consensus state associated with the client identifier at the given height + google.protobuf.Any consensus_state = 1; + // merkle proof of existence + bytes proof = 2; + // merkle proof path + string proof_path = 3; + // height at which the proof was retrieved + uint64 proof_height = 4; +} + +// QueryConsensusStatesRequest is the request type for the Query/ConsensusStates RPC method. +message QueryConsensusStatesRequest { + // client identifier + string client_id = 1; + // pagination request + cosmos.base.query.v1beta1.PageRequest pagination = 2; +} + +// QueryConsensusStatesResponse is the response type for the Query/ConsensusStates RPC method +message QueryConsensusStatesResponse { + // consensus states associated with the identifier + repeated google.protobuf.Any consensus_states = 1; + // pagination response + cosmos.base.query.v1beta1.PageResponse pagination = 2; +} diff --git a/x/ibc/02-client/client/cli/cli.go b/x/ibc/02-client/client/cli/cli.go index 605996119..517a170c6 100644 --- a/x/ibc/02-client/client/cli/cli.go +++ b/x/ibc/02-client/client/cli/cli.go @@ -20,6 +20,7 @@ func GetQueryCmd() *cobra.Command { queryCmd.AddCommand( GetCmdQueryClientStates(), GetCmdQueryClientState(), + GetCmdQueryConsensusStates(), GetCmdQueryConsensusState(), GetCmdQueryHeader(), GetCmdNodeConsensusState(), diff --git a/x/ibc/02-client/client/cli/query.go b/x/ibc/02-client/client/cli/query.go index d59e43a55..95d6953a4 100644 --- a/x/ibc/02-client/client/cli/query.go +++ b/x/ibc/02-client/client/cli/query.go @@ -1,10 +1,10 @@ package cli import ( + "context" "errors" "fmt" "strconv" - "strings" "github.com/spf13/cobra" @@ -16,6 +16,8 @@ import ( host "github.com/cosmos/cosmos-sdk/x/ibc/24-host" ) +const flagLatestHeight = "latest-height" + // GetCmdQueryClientStates defines the command to query all the light clients // that this chain mantains. func GetCmdQueryClientStates() *cobra.Command { @@ -32,23 +34,27 @@ func GetCmdQueryClientStates() *cobra.Command { return err } - page, _ := cmd.Flags().GetInt(flags.FlagPage) - limit, _ := cmd.Flags().GetInt(flags.FlagLimit) + queryClient := types.NewQueryClient(clientCtx) - clientStates, height, err := utils.QueryAllClientStates(clientCtx, page, limit) + pageReq, err := client.ReadPageRequest(cmd.Flags()) if err != nil { return err } - clientCtx = clientCtx.WithHeight(height) + req := &types.QueryClientStatesRequest{ + Pagination: pageReq, + } - return clientCtx.PrintOutputLegacy(clientStates) + res, err := queryClient.ClientStates(context.Background(), req) + if err != nil { + return err + } + + return clientCtx.PrintOutput(res) }, } - - cmd.Flags().Int(flags.FlagPage, 1, "pagination page of light clients to query for") - cmd.Flags().Int(flags.FlagLimit, 100, "pagination limit of light clients to query for") flags.AddQueryFlagsToCmd(cmd) + flags.AddPaginationFlagsToCmd(cmd, "client states") return cmd } @@ -70,10 +76,6 @@ func GetCmdQueryClientState() *cobra.Command { } clientID := args[0] - if strings.TrimSpace(clientID) == "" { - return errors.New("client ID can't be blank") - } - prove, _ := cmd.Flags().GetBool(flags.FlagProve) clientStateRes, err := utils.QueryClientState(clientCtx, clientID, prove) @@ -81,8 +83,7 @@ func GetCmdQueryClientState() *cobra.Command { return err } - clientCtx = clientCtx.WithHeight(int64(clientStateRes.ProofHeight)) - return clientCtx.PrintOutputLegacy(clientStateRes) + return clientCtx.PrintOutput(clientStateRes) }, } @@ -92,15 +93,15 @@ func GetCmdQueryClientState() *cobra.Command { return cmd } -// GetCmdQueryConsensusState defines the command to query the consensus state of -// the chain as defined in https://github.com/cosmos/ics/tree/master/spec/ics-002-client-semantics#query -func GetCmdQueryConsensusState() *cobra.Command { +// GetCmdQueryConsensusStates defines the command to query all the consensus states from a given +// client state. +func GetCmdQueryConsensusStates() *cobra.Command { cmd := &cobra.Command{ - Use: "consensus-state [client-id] [height]", - Short: "Query the consensus state of a client at a given height", - Long: "Query the consensus state for a particular light client at a given height", - Example: fmt.Sprintf("%s query %s %s consensus-state [client-id] [height]", version.AppName, host.ModuleName, types.SubModuleName), - Args: cobra.ExactArgs(2), + Use: "consensus-states [client-id]", + Short: "Query all the consensus states of a client.", + Long: "Query all the consensus states from a given client state.", + Example: fmt.Sprintf("%s query %s %s consensus-states [client-id]", version.AppName, host.ModuleName, types.SubModuleName), + Args: cobra.ExactArgs(1), RunE: func(cmd *cobra.Command, args []string) error { clientCtx := client.GetClientContextFromCmd(cmd) clientCtx, err := client.ReadQueryCommandFlags(clientCtx, cmd.Flags()) @@ -109,28 +110,80 @@ func GetCmdQueryConsensusState() *cobra.Command { } clientID := args[0] - if strings.TrimSpace(clientID) == "" { - return errors.New("client ID can't be blank") - } - height, err := strconv.ParseUint(args[1], 10, 64) - if err != nil { - return fmt.Errorf("expected integer height, got: %s", args[1]) - } + queryClient := types.NewQueryClient(clientCtx) - prove, _ := cmd.Flags().GetBool(flags.FlagProve) - - csRes, err := utils.QueryConsensusState(clientCtx, clientID, height, prove) + pageReq, err := client.ReadPageRequest(cmd.Flags()) if err != nil { return err } - clientCtx = clientCtx.WithHeight(int64(csRes.ProofHeight)) - return clientCtx.PrintOutputLegacy(csRes) + req := &types.QueryConsensusStatesRequest{ + ClientId: clientID, + Pagination: pageReq, + } + + res, err := queryClient.ConsensusStates(context.Background(), req) + if err != nil { + return err + } + + return clientCtx.PrintOutput(res) + }, + } + flags.AddQueryFlagsToCmd(cmd) + flags.AddPaginationFlagsToCmd(cmd, "consensus states") + + return cmd +} + +// GetCmdQueryConsensusState defines the command to query the consensus state of +// the chain as defined in https://github.com/cosmos/ics/tree/master/spec/ics-002-client-semantics#query +func GetCmdQueryConsensusState() *cobra.Command { + cmd := &cobra.Command{ + Use: "consensus-state [client-id] [height]", + Short: "Query the consensus state of a client at a given height", + Long: `Query the consensus state for a particular light client at a given height. +If the '--latest' flag is included, the query returns the latest consensus state, overriding the height argument.`, + Example: fmt.Sprintf("%s query %s %s consensus-state [client-id] [height]", version.AppName, host.ModuleName, types.SubModuleName), + Args: cobra.RangeArgs(1, 2), + RunE: func(cmd *cobra.Command, args []string) error { + clientCtx := client.GetClientContextFromCmd(cmd) + clientCtx, err := client.ReadQueryCommandFlags(clientCtx, cmd.Flags()) + if err != nil { + return err + } + + clientID := args[0] + + queryLatestHeight, _ := cmd.Flags().GetBool(flagLatestHeight) + + var height uint64 + + if !queryLatestHeight { + if len(args) != 2 { + return errors.New("must include a second 'height' argument when '--latest-height' flag is not provided") + } + + height, err = strconv.ParseUint(args[1], 10, 64) + if err != nil { + return fmt.Errorf("expected integer height, got: %s", args[1]) + } + } + + prove, _ := cmd.Flags().GetBool(flags.FlagProve) + + csRes, err := utils.QueryConsensusState(clientCtx, clientID, height, prove, queryLatestHeight) + if err != nil { + return err + } + + return clientCtx.PrintOutput(csRes) }, } cmd.Flags().Bool(flags.FlagProve, true, "show proofs for the query results") + cmd.Flags().Bool(flagLatestHeight, false, "return latest stored consensus state") flags.AddQueryFlagsToCmd(cmd) return cmd @@ -143,6 +196,7 @@ func GetCmdQueryHeader() *cobra.Command { Short: "Query the latest header of the running chain", Long: "Query the latest Tendermint header of the running chain", Example: fmt.Sprintf("%s query %s %s header", version.AppName, host.ModuleName, types.SubModuleName), + Args: cobra.NoArgs, RunE: func(cmd *cobra.Command, _ []string) error { clientCtx := client.GetClientContextFromCmd(cmd) clientCtx, err := client.ReadQueryCommandFlags(clientCtx, cmd.Flags()) @@ -173,7 +227,7 @@ func GetCmdNodeConsensusState() *cobra.Command { Short: "Query a node consensus state", Long: "Query a node consensus state. This result is feed to the client creation transaction.", Example: fmt.Sprintf("%s query %s %s node-state", version.AppName, host.ModuleName, types.SubModuleName), - Args: cobra.ExactArgs(0), + Args: cobra.NoArgs, RunE: func(cmd *cobra.Command, _ []string) error { clientCtx := client.GetClientContextFromCmd(cmd) clientCtx, err := client.ReadQueryCommandFlags(clientCtx, cmd.Flags()) diff --git a/x/ibc/02-client/client/utils/utils.go b/x/ibc/02-client/client/utils/utils.go index 72538e4f7..49aade196 100644 --- a/x/ibc/02-client/client/utils/utils.go +++ b/x/ibc/02-client/client/utils/utils.go @@ -1,7 +1,7 @@ package utils import ( - "fmt" + "context" abci "github.com/tendermint/tendermint/abci/types" tmtypes "github.com/tendermint/tendermint/types" @@ -14,120 +14,83 @@ import ( host "github.com/cosmos/cosmos-sdk/x/ibc/24-host" ) -// QueryAllClientStates returns all the light client states. It _does not_ return -// any merkle proof. -func QueryAllClientStates(clientCtx client.Context, page, limit int) ([]exported.ClientState, int64, error) { - params := types.NewQueryAllClientsParams(page, limit) - bz, err := clientCtx.JSONMarshaler.MarshalJSON(params) - if err != nil { - return nil, 0, fmt.Errorf("failed to marshal query params: %w", err) - } - - route := fmt.Sprintf("custom/%s/%s/%s", "ibc", types.QuerierRoute, types.QueryAllClients) - res, height, err := clientCtx.QueryWithData(route, bz) - if err != nil { - return nil, 0, err - } - - var clients []exported.ClientState - err = clientCtx.JSONMarshaler.UnmarshalJSON(res, &clients) - if err != nil { - return nil, 0, fmt.Errorf("failed to unmarshal light clients: %w", err) - } - return clients, height, nil -} - -// QueryClientState queries the store to get the light client state and a merkle -// proof. -// TODO: delete +// QueryClientState returns a client state. +// If prove is true, it performs an ABCI store query in order to retrieve the merkle proof. Otherwise, +// it uses the gRPC query client. func QueryClientState( clientCtx client.Context, clientID string, prove bool, -) (types.StateResponse, error) { +) (*types.QueryClientStateResponse, error) { + if prove { + return QueryClientStateABCI(clientCtx, clientID) + } + + queryClient := types.NewQueryClient(clientCtx) + req := &types.QueryClientStateRequest{ + ClientId: clientID, + } + + return queryClient.ClientState(context.Background(), req) +} + +// QueryClientStateABCI queries the store to get the light client state and a merkle proof. +func QueryClientStateABCI( + clientCtx client.Context, clientID string, +) (*types.QueryClientStateResponse, error) { req := abci.RequestQuery{ Path: "store/ibc/key", Data: host.FullKeyClientPath(clientID, host.KeyClientState()), - Prove: prove, + Prove: true, } res, err := clientCtx.QueryABCI(req) if err != nil { - return types.StateResponse{}, err + return nil, err } var clientState exported.ClientState if err := clientCtx.LegacyAmino.UnmarshalBinaryBare(res.Value, &clientState); err != nil { - return types.StateResponse{}, err + return nil, err } - clientStateRes := types.NewClientStateResponse(clientID, clientState, res.ProofOps, res.Height) + anyClientState, err := types.PackClientState(clientState) + if err != nil { + return nil, err + } + proofBz, err := clientCtx.LegacyAmino.MarshalBinaryBare(res.ProofOps) + if err != nil { + return nil, err + } + + clientStateRes := types.NewQueryClientStateResponse(clientID, anyClientState, proofBz, res.Height) return clientStateRes, nil } -// QueryClientState queries the store to get the light client state and a merkle -// proof. -func QueryClientStateABCI( - clientCtx client.Context, clientID string, -) (exported.ClientState, []byte, uint64, error) { - req := abci.RequestQuery{ - Path: "store/ibc/key", - Data: host.FullKeyClientPath(clientID, host.KeyClientState()), - Prove: true, - } - - res, err := clientCtx.QueryABCI(req) - if err != nil { - return nil, nil, 0, err - } - - proofBz, err := clientCtx.LegacyAmino.MarshalBinaryBare(res.ProofOps) - if err != nil { - return nil, nil, 0, err - } - - var clientState exported.ClientState - if err := clientCtx.LegacyAmino.UnmarshalBinaryBare(res.Value, &clientState); err != nil { - return nil, nil, 0, err - } - - // FIXME: height + 1 is returned as the proof height - // Issue: https://github.com/cosmos/cosmos-sdk/issues/6567 - return clientState, proofBz, uint64(res.Height + 1), nil -} - -// QueryConsensusState queries the store to get the consensus state and a merkle -// proof. -// TODO: delete +// QueryConsensusState returns a consensus state. +// If prove is true, it performs an ABCI store query in order to retrieve the merkle proof. Otherwise, +// it uses the gRPC query client. func QueryConsensusState( - clientCtx client.Context, clientID string, height uint64, prove bool, -) (types.ConsensusStateResponse, error) { - var conStateRes types.ConsensusStateResponse - - req := abci.RequestQuery{ - Path: "store/ibc/key", - Data: host.FullKeyClientPath(clientID, host.KeyConsensusState(height)), - Prove: prove, + clientCtx client.Context, clientID string, height uint64, prove, latestHeight bool, +) (*types.QueryConsensusStateResponse, error) { + if prove { + return QueryConsensusStateABCI(clientCtx, clientID, height) } - res, err := clientCtx.QueryABCI(req) - if err != nil { - return conStateRes, err + queryClient := types.NewQueryClient(clientCtx) + req := &types.QueryConsensusStateRequest{ + ClientId: clientID, + Height: height, + LatestHeight: latestHeight, } - var cs exported.ConsensusState - if err := clientCtx.LegacyAmino.UnmarshalBinaryBare(res.Value, &cs); err != nil { - return conStateRes, err - } - - return types.NewConsensusStateResponse(clientID, cs, res.ProofOps, res.Height), nil + return queryClient.ConsensusState(context.Background(), req) } -// QueryConsensusState queries the store to get the consensus state of a light -// client and a merkle proof of its existence or non-existence. +// QueryConsensusStateABCI queries the store to get the consensus state of a light client and a +// merkle proof of its existence or non-existence. func QueryConsensusStateABCI( clientCtx client.Context, clientID string, height uint64, -) (exported.ConsensusState, []byte, uint64, error) { - +) (*types.QueryConsensusStateResponse, error) { req := abci.RequestQuery{ Path: "store/ibc/key", Data: host.FullKeyClientPath(clientID, host.KeyConsensusState(height)), @@ -136,22 +99,25 @@ func QueryConsensusStateABCI( res, err := clientCtx.QueryABCI(req) if err != nil { - return nil, nil, 0, err - } - - proofBz, err := clientCtx.LegacyAmino.MarshalBinaryBare(res.ProofOps) - if err != nil { - return nil, nil, 0, err + return nil, err } var cs exported.ConsensusState if err := clientCtx.LegacyAmino.UnmarshalBinaryBare(res.Value, &cs); err != nil { - return nil, nil, 0, err + return nil, err } - // FIXME: height + 1 is returned as the proof height - // Issue: https://github.com/cosmos/cosmos-sdk/issues/6567 - return cs, proofBz, uint64(res.Height + 1), nil + anyConsensusState, err := types.PackConsensusState(cs) + if err != nil { + return nil, err + } + + proofBz, err := clientCtx.LegacyAmino.MarshalBinaryBare(res.ProofOps) + if err != nil { + return nil, err + } + + return types.NewQueryConsensusStateResponse(clientID, anyConsensusState, proofBz, res.Height), nil } // QueryTendermintHeader takes a client context and returns the appropriate diff --git a/x/ibc/02-client/keeper/encoding.go b/x/ibc/02-client/keeper/encoding.go index 1ed18c470..06242a2dc 100644 --- a/x/ibc/02-client/keeper/encoding.go +++ b/x/ibc/02-client/keeper/encoding.go @@ -5,12 +5,24 @@ import ( "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types" ) +// UnmarshalClientState attempts to decode and return an ClientState object from +// raw encoded bytes. +func (k Keeper) UnmarshalClientState(bz []byte) (exported.ClientState, error) { + return types.UnmarshalClientState(k.cdc, bz) +} + // MustUnmarshalClientState attempts to decode and return an ClientState object from // raw encoded bytes. It panics on error. func (k Keeper) MustUnmarshalClientState(bz []byte) exported.ClientState { return types.MustUnmarshalClientState(k.cdc, bz) } +// UnmarshalConsensusState attempts to decode and return an ConsensusState object from +// raw encoded bytes. +func (k Keeper) UnmarshalConsensusState(bz []byte) (exported.ConsensusState, error) { + return types.UnmarshalConsensusState(k.cdc, bz) +} + // MustUnmarshalConsensusState attempts to decode and return an ConsensusState object from // raw encoded bytes. It panics on error. func (k Keeper) MustUnmarshalConsensusState(bz []byte) exported.ConsensusState { diff --git a/x/ibc/02-client/keeper/grpc_query.go b/x/ibc/02-client/keeper/grpc_query.go new file mode 100644 index 000000000..3c716c2ef --- /dev/null +++ b/x/ibc/02-client/keeper/grpc_query.go @@ -0,0 +1,177 @@ +package keeper + +import ( + "context" + "strings" + + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + "github.com/cosmos/cosmos-sdk/store/prefix" + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/cosmos/cosmos-sdk/types/query" + "github.com/cosmos/cosmos-sdk/x/ibc/02-client/exported" + "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types" + host "github.com/cosmos/cosmos-sdk/x/ibc/24-host" +) + +var _ types.QueryServer = Keeper{} + +// ClientState implements the Query/ClientState gRPC method +func (q Keeper) ClientState(c context.Context, req *types.QueryClientStateRequest) (*types.QueryClientStateResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + if err := host.ClientIdentifierValidator(req.ClientId); err != nil { + return nil, status.Error(codes.InvalidArgument, err.Error()) + } + + ctx := sdk.UnwrapSDKContext(c) + clientState, found := q.GetClientState(ctx, req.ClientId) + if !found { + return nil, status.Error( + codes.NotFound, + sdkerrors.Wrap(types.ErrClientNotFound, req.ClientId).Error(), + ) + } + + any, err := types.PackClientState(clientState) + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryClientStateResponse{ + ClientState: any, + ProofHeight: uint64(ctx.BlockHeight()), + }, nil +} + +// ClientStates implements the Query/ClientStates gRPC method +func (q Keeper) ClientStates(c context.Context, req *types.QueryClientStatesRequest) (*types.QueryClientStatesResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + ctx := sdk.UnwrapSDKContext(c) + + clientStates := []*types.IdentifiedClientState{} + store := prefix.NewStore(ctx.KVStore(q.storeKey), host.KeyClientStorePrefix) + + pageRes, err := query.Paginate(store, req.Pagination, func(key, value []byte) error { + keySplit := strings.Split(string(key), "/") + if keySplit[len(keySplit)-1] != "clientState" { + return nil + } + + clientState, err := q.UnmarshalClientState(value) + if err != nil { + return err + } + + clientID := keySplit[1] + if err := host.ClientIdentifierValidator(clientID); err != nil { + return err + } + + identifiedClient := types.NewIdentifiedClientState(clientID, clientState) + clientStates = append(clientStates, &identifiedClient) + return nil + }) + + if err != nil { + return nil, err + } + + return &types.QueryClientStatesResponse{ + ClientStates: clientStates, + Pagination: pageRes, + }, nil +} + +// ConsensusState implements the Query/ConsensusState gRPC method +func (q Keeper) ConsensusState(c context.Context, req *types.QueryConsensusStateRequest) (*types.QueryConsensusStateResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + if err := host.ClientIdentifierValidator(req.ClientId); err != nil { + return nil, status.Error(codes.InvalidArgument, err.Error()) + } + + ctx := sdk.UnwrapSDKContext(c) + + var ( + consensusState exported.ConsensusState + found bool + ) + + if req.LatestHeight { + consensusState, found = q.GetLatestClientConsensusState(ctx, req.ClientId) + } else { + if req.Height == 0 { + return nil, status.Error(codes.InvalidArgument, "consensus state height cannot be 0") + } + + consensusState, found = q.GetClientConsensusState(ctx, req.ClientId, req.Height) + } + + if !found { + return nil, status.Error( + codes.NotFound, + sdkerrors.Wrapf(types.ErrConsensusStateNotFound, "client-id: %s, height: %d", req.ClientId, req.Height).Error(), + ) + } + + any, err := types.PackConsensusState(consensusState) + if err != nil { + return nil, status.Error(codes.Internal, err.Error()) + } + + return &types.QueryConsensusStateResponse{ + ConsensusState: any, + ProofHeight: uint64(ctx.BlockHeight()), + }, nil +} + +// ConsensusStates implements the Query/ConsensusStates gRPC method +func (q Keeper) ConsensusStates(c context.Context, req *types.QueryConsensusStatesRequest) (*types.QueryConsensusStatesResponse, error) { + if req == nil { + return nil, status.Error(codes.InvalidArgument, "empty request") + } + + if err := host.ClientIdentifierValidator(req.ClientId); err != nil { + return nil, status.Error(codes.InvalidArgument, err.Error()) + } + + ctx := sdk.UnwrapSDKContext(c) + + consensusStates := []*codectypes.Any{} + store := prefix.NewStore(ctx.KVStore(q.storeKey), host.FullKeyClientPath(req.ClientId, []byte("consensusState/"))) + + pageRes, err := query.Paginate(store, req.Pagination, func(key, value []byte) error { + consensusState, err := q.UnmarshalConsensusState(value) + if err != nil { + return err + } + + any, err := types.PackConsensusState(consensusState) + if err != nil { + return err + } + + consensusStates = append(consensusStates, any) + return nil + }) + + if err != nil { + return nil, err + } + + return &types.QueryConsensusStatesResponse{ + ConsensusStates: consensusStates, + Pagination: pageRes, + }, nil +} diff --git a/x/ibc/02-client/keeper/grpc_query_test.go b/x/ibc/02-client/keeper/grpc_query_test.go new file mode 100644 index 000000000..24a7bb188 --- /dev/null +++ b/x/ibc/02-client/keeper/grpc_query_test.go @@ -0,0 +1,357 @@ +package keeper_test + +import ( + "fmt" + "time" + + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + sdk "github.com/cosmos/cosmos-sdk/types" + + "github.com/cosmos/cosmos-sdk/types/query" + "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types" + ibctmtypes "github.com/cosmos/cosmos-sdk/x/ibc/07-tendermint/types" + commitmenttypes "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/types" +) + +func (suite *KeeperTestSuite) TestQueryClientState() { + var ( + req *types.QueryClientStateRequest + expClientState *codectypes.Any + ) + + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + {"invalid clientID", + func() { + req = &types.QueryClientStateRequest{} + }, + false, + }, + {"client not found", + func() { + req = &types.QueryClientStateRequest{ + ClientId: testClientID, + } + }, + false, + }, + { + "success", + func() { + clientState := ibctmtypes.NewClientState(testChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, 0, commitmenttypes.GetSDKSpecs()) + suite.keeper.SetClientState(suite.ctx, testClientID, clientState) + + var err error + expClientState, err = types.PackClientState(clientState) + suite.Require().NoError(err) + + req = &types.QueryClientStateRequest{ + ClientId: testClientID, + } + }, + true, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + suite.SetupTest() // reset + + tc.malleate() + ctx := sdk.WrapSDKContext(suite.ctx) + res, err := suite.queryClient.ClientState(ctx, req) + + if tc.expPass { + suite.Require().NoError(err) + suite.Require().NotNil(res) + + expClientState.ClearCachedValue() + suite.Require().Equal(expClientState, res.ClientState) + } else { + suite.Require().Error(err) + } + }) + } +} + +func (suite *KeeperTestSuite) TestQueryClientStates() { + var ( + req *types.QueryClientStatesRequest + expClientStates = []*types.IdentifiedClientState(nil) + ) + + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + { + "empty pagination", + func() { + req = &types.QueryClientStatesRequest{} + }, + true, + }, + { + "success, no results", + func() { + req = &types.QueryClientStatesRequest{ + Pagination: &query.PageRequest{ + Limit: 3, + CountTotal: true, + }, + } + }, + true, + }, + { + "success", + func() { + clientState := ibctmtypes.NewClientState(testChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, 0, commitmenttypes.GetSDKSpecs()) + clientState2 := ibctmtypes.NewClientState(testChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, 0, commitmenttypes.GetSDKSpecs()) + suite.keeper.SetClientState(suite.ctx, testClientID, clientState) + suite.keeper.SetClientState(suite.ctx, testClientID2, clientState2) + + idcs := types.NewIdentifiedClientState(testClientID, clientState) + idcs2 := types.NewIdentifiedClientState(testClientID2, clientState2) + + // order is swapped because the res is sorted by client id + expClientStates = []*types.IdentifiedClientState{&idcs2, &idcs} + req = &types.QueryClientStatesRequest{ + Pagination: &query.PageRequest{ + Limit: 3, + CountTotal: true, + }, + } + }, + true, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + suite.SetupTest() // reset + + tc.malleate() + ctx := sdk.WrapSDKContext(suite.ctx) + + res, err := suite.queryClient.ClientStates(ctx, req) + + if tc.expPass { + suite.Require().NoError(err) + suite.Require().NotNil(res) + suite.Require().Equal(len(expClientStates), len(res.ClientStates)) + for i := range expClientStates { + suite.Require().Equal(expClientStates[i].ClientId, res.ClientStates[i].ClientId) + suite.Require().NotNil(res.ClientStates[i].ClientState) + expClientStates[i].ClientState.ClearCachedValue() + suite.Require().Equal(expClientStates[i].ClientState, res.ClientStates[i].ClientState) + } + } else { + suite.Require().Error(err) + } + }) + } +} + +func (suite *KeeperTestSuite) TestQueryConsensusState() { + var ( + req *types.QueryConsensusStateRequest + expConsensusState *codectypes.Any + ) + + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + { + "invalid clientID", + func() { + req = &types.QueryConsensusStateRequest{} + }, + false, + }, + { + "invalid height", + func() { + req = &types.QueryConsensusStateRequest{ + ClientId: testClientID, + Height: 0, + LatestHeight: false, + } + }, + false, + }, + { + "consensus state not found", + func() { + req = &types.QueryConsensusStateRequest{ + ClientId: testClientID, + LatestHeight: true, + } + }, + false, + }, + { + "success latest height", + func() { + clientState := ibctmtypes.NewClientState(testChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, testClientHeight, commitmenttypes.GetSDKSpecs()) + cs := ibctmtypes.NewConsensusState( + suite.consensusState.Timestamp, commitmenttypes.NewMerkleRoot([]byte("hash1")), suite.consensusState.GetHeight(), nil, + ) + suite.keeper.SetClientState(suite.ctx, testClientID, clientState) + suite.keeper.SetClientConsensusState(suite.ctx, testClientID, suite.consensusState.GetHeight(), cs) + + var err error + expConsensusState, err = types.PackConsensusState(cs) + suite.Require().NoError(err) + + req = &types.QueryConsensusStateRequest{ + ClientId: testClientID, + LatestHeight: true, + } + }, + true, + }, + { + "success with height", + func() { + cs := ibctmtypes.NewConsensusState( + suite.consensusState.Timestamp, commitmenttypes.NewMerkleRoot([]byte("hash1")), suite.consensusState.GetHeight(), nil, + ) + suite.keeper.SetClientConsensusState(suite.ctx, testClientID, testClientHeight, cs) + + var err error + expConsensusState, err = types.PackConsensusState(cs) + suite.Require().NoError(err) + + req = &types.QueryConsensusStateRequest{ + ClientId: testClientID, + Height: testClientHeight, + } + }, + true, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + suite.SetupTest() // reset + + tc.malleate() + ctx := sdk.WrapSDKContext(suite.ctx) + res, err := suite.queryClient.ConsensusState(ctx, req) + + if tc.expPass { + suite.Require().NoError(err) + suite.Require().NotNil(res) + + expConsensusState.ClearCachedValue() + suite.Require().Equal(expConsensusState, res.ConsensusState) + } else { + suite.Require().Error(err) + } + }) + } +} + +func (suite *KeeperTestSuite) TestQueryConsensusStates() { + var ( + req *types.QueryConsensusStatesRequest + expConsensusStates = []*codectypes.Any(nil) + ) + + testCases := []struct { + msg string + malleate func() + expPass bool + }{ + { + "invalid client identifier", + func() { + req = &types.QueryConsensusStatesRequest{} + }, + false, + }, + { + "empty pagination", + func() { + req = &types.QueryConsensusStatesRequest{ + ClientId: testClientID, + } + }, + true, + }, + { + "success, no results", + func() { + req = &types.QueryConsensusStatesRequest{ + ClientId: testClientID, + Pagination: &query.PageRequest{ + Limit: 3, + CountTotal: true, + }, + } + }, + true, + }, + { + "success", + func() { + cs := ibctmtypes.NewConsensusState( + suite.consensusState.Timestamp, commitmenttypes.NewMerkleRoot([]byte("hash1")), suite.consensusState.GetHeight(), nil, + ) + cs2 := ibctmtypes.NewConsensusState( + suite.consensusState.Timestamp.Add(time.Second), commitmenttypes.NewMerkleRoot([]byte("hash2")), suite.consensusState.GetHeight(), nil, + ) + + suite.keeper.SetClientConsensusState(suite.ctx, testClientID, testClientHeight, cs) + suite.keeper.SetClientConsensusState(suite.ctx, testClientID, testClientHeight+1, cs2) + + any, err := types.PackConsensusState(cs) + suite.Require().NoError(err) + any2, err := types.PackConsensusState(cs2) + suite.Require().NoError(err) + + // order is swapped because the res is sorted by client id + expConsensusStates = []*codectypes.Any{any, any2} + req = &types.QueryConsensusStatesRequest{ + ClientId: testClientID, + Pagination: &query.PageRequest{ + Limit: 3, + CountTotal: true, + }, + } + }, + true, + }, + } + + for _, tc := range testCases { + suite.Run(fmt.Sprintf("Case %s", tc.msg), func() { + suite.SetupTest() // reset + + tc.malleate() + ctx := sdk.WrapSDKContext(suite.ctx) + + res, err := suite.queryClient.ConsensusStates(ctx, req) + + if tc.expPass { + suite.Require().NoError(err) + suite.Require().NotNil(res) + suite.Require().Equal(len(expConsensusStates), len(res.ConsensusStates)) + for i := range expConsensusStates { + suite.Require().NotNil(res.ConsensusStates[i]) + expConsensusStates[i].ClearCachedValue() + suite.Require().Equal(expConsensusStates[i], res.ConsensusStates[i]) + } + } else { + suite.Require().Error(err) + } + }) + } +} diff --git a/x/ibc/02-client/keeper/keeper.go b/x/ibc/02-client/keeper/keeper.go index 4909a12a1..6c5d8a4e0 100644 --- a/x/ibc/02-client/keeper/keeper.go +++ b/x/ibc/02-client/keeper/keeper.go @@ -116,10 +116,10 @@ func (k Keeper) IterateConsensusStates(ctx sdk.Context, cb func(clientID string, } } -// GetAllGenesisClients returns all the clients in state with their client ids returned as GenesisClientState -func (k Keeper) GetAllGenesisClients(ctx sdk.Context) (genClients []types.GenesisClientState) { +// GetAllGenesisClients returns all the clients in state with their client ids returned as IdentifiedClientState +func (k Keeper) GetAllGenesisClients(ctx sdk.Context) (genClients []types.IdentifiedClientState) { k.IterateClients(ctx, func(clientID string, cs exported.ClientState) bool { - genClients = append(genClients, types.NewGenesisClientState(clientID, cs)) + genClients = append(genClients, types.NewIdentifiedClientState(clientID, cs)) return false }) return diff --git a/x/ibc/02-client/keeper/keeper_test.go b/x/ibc/02-client/keeper/keeper_test.go index 33c20a8f6..410f24860 100644 --- a/x/ibc/02-client/keeper/keeper_test.go +++ b/x/ibc/02-client/keeper/keeper_test.go @@ -10,6 +10,7 @@ import ( tmproto "github.com/tendermint/tendermint/proto/tendermint/types" tmtypes "github.com/tendermint/tendermint/types" + "github.com/cosmos/cosmos-sdk/baseapp" "github.com/cosmos/cosmos-sdk/codec" "github.com/cosmos/cosmos-sdk/simapp" sdk "github.com/cosmos/cosmos-sdk/types" @@ -48,6 +49,8 @@ type KeeperTestSuite struct { privVal tmtypes.PrivValidator now time.Time past time.Time + + queryClient types.QueryClient } func (suite *KeeperTestSuite) SetupTest() { @@ -83,6 +86,10 @@ func (suite *KeeperTestSuite) SetupTest() { app.StakingKeeper.SetHistoricalInfo(suite.ctx, int64(i), stakingtypes.NewHistoricalInfo(suite.ctx.BlockHeader(), validators)) } + + queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, app.InterfaceRegistry()) + types.RegisterQueryServer(queryHelper, app.IBCKeeper.ClientKeeper) + suite.queryClient = types.NewQueryClient(queryHelper) } func TestKeeperTestSuite(t *testing.T) { @@ -152,18 +159,18 @@ func (suite KeeperTestSuite) TestGetAllGenesisClients() { ibctmtypes.NewClientState(testChainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, 0, commitmenttypes.GetSDKSpecs()), } - expGenClients := make([]types.GenesisClientState, len(expClients)) + expGenClients := make([]types.IdentifiedClientState, len(expClients)) for i := range expClients { suite.keeper.SetClientState(suite.ctx, clientIDs[i], expClients[i]) - expGenClients[i] = types.NewGenesisClientState(clientIDs[i], expClients[i]) + expGenClients[i] = types.NewIdentifiedClientState(clientIDs[i], expClients[i]) } // add localhost client // TODO: uncomment after simapp is migrated to proto // localHostClient, found := suite.keeper.GetClientState(suite.ctx, exported.ClientTypeLocalHost) // suite.Require().True(found) - // expGenClients = append(expGenClients, types.NewGenesisClientState(exported.ClientTypeLocalHost, localHostClient)) + // expGenClients = append(expGenClients, types.NewIdentifiedClientState(exported.ClientTypeLocalHost, localHostClient)) genClients := suite.keeper.GetAllGenesisClients(suite.ctx) diff --git a/x/ibc/02-client/keeper/querier.go b/x/ibc/02-client/keeper/querier.go deleted file mode 100644 index 416c7e3ae..000000000 --- a/x/ibc/02-client/keeper/querier.go +++ /dev/null @@ -1,37 +0,0 @@ -package keeper - -import ( - abci "github.com/tendermint/tendermint/abci/types" - - "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" - "github.com/cosmos/cosmos-sdk/x/ibc/02-client/exported" - "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types" -) - -// QuerierClients defines the sdk.Querier to query all the light client states. -func QuerierClients(ctx sdk.Context, req abci.RequestQuery, k Keeper, legacyQuerierCdc codec.JSONMarshaler) ([]byte, error) { - var params types.QueryAllClientsParams - - if err := legacyQuerierCdc.UnmarshalJSON(req.Data, ¶ms); err != nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrJSONUnmarshal, err.Error()) - } - - clients := k.GetAllClients(ctx) - - start, end := client.Paginate(len(clients), params.Page, params.Limit, 100) - if start < 0 || end < 0 { - clients = []exported.ClientState{} - } else { - clients = clients[start:end] - } - - res, err := codec.MarshalJSONIndent(legacyQuerierCdc, clients) - if err != nil { - return nil, sdkerrors.Wrap(sdkerrors.ErrJSONMarshal, err.Error()) - } - - return res, nil -} diff --git a/x/ibc/02-client/module.go b/x/ibc/02-client/module.go index 40240ac4a..b3bb44edd 100644 --- a/x/ibc/02-client/module.go +++ b/x/ibc/02-client/module.go @@ -1,6 +1,7 @@ package client import ( + "github.com/gogo/protobuf/grpc" "github.com/spf13/cobra" "github.com/cosmos/cosmos-sdk/x/ibc/02-client/client/cli" @@ -16,3 +17,8 @@ func Name() string { func GetQueryCmd() *cobra.Command { return cli.GetQueryCmd() } + +// RegisterQueryService registers the gRPC query service for IBC client. +func RegisterQueryService(server grpc.Server, queryServer types.QueryServer) { + types.RegisterQueryServer(server, queryServer) +} diff --git a/x/ibc/02-client/types/client.go b/x/ibc/02-client/types/client.go index 5b9e1c5dd..318581b33 100644 --- a/x/ibc/02-client/types/client.go +++ b/x/ibc/02-client/types/client.go @@ -24,7 +24,7 @@ func NewIdentifiedClientState(clientID string, clientState exported.ClientState) } return IdentifiedClientState{ - Id: clientID, + ClientId: clientID, ClientState: anyClientState, } } diff --git a/x/ibc/02-client/types/client.pb.go b/x/ibc/02-client/types/client.pb.go index ce01a82a2..a380e095e 100644 --- a/x/ibc/02-client/types/client.pb.go +++ b/x/ibc/02-client/types/client.pb.go @@ -27,8 +27,9 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // IdentifiedClientState defines a client state with additional client identifier field. type IdentifiedClientState struct { // client identifier - Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" yaml:"id"` - ClientState *types.Any `protobuf:"bytes,2,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty"` + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty" yaml:"client_id"` + // client state + ClientState *types.Any `protobuf:"bytes,2,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty" yaml:"client_state"` } func (m *IdentifiedClientState) Reset() { *m = IdentifiedClientState{} } @@ -64,30 +65,104 @@ func (m *IdentifiedClientState) XXX_DiscardUnknown() { var xxx_messageInfo_IdentifiedClientState proto.InternalMessageInfo +func (m *IdentifiedClientState) GetClientId() string { + if m != nil { + return m.ClientId + } + return "" +} + +func (m *IdentifiedClientState) GetClientState() *types.Any { + if m != nil { + return m.ClientState + } + return nil +} + +// ClientConsensusStates defines all the stored consensus states for a given client. +type ClientConsensusStates struct { + // client identifier + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty" yaml:"client_id"` + // consensus states associated with the client + ConsensusStates []*types.Any `protobuf:"bytes,2,rep,name=consensus_states,json=consensusStates,proto3" json:"consensus_states,omitempty" yaml:"consensus_states"` +} + +func (m *ClientConsensusStates) Reset() { *m = ClientConsensusStates{} } +func (m *ClientConsensusStates) String() string { return proto.CompactTextString(m) } +func (*ClientConsensusStates) ProtoMessage() {} +func (*ClientConsensusStates) Descriptor() ([]byte, []int) { + return fileDescriptor_226f80e576f20abd, []int{1} +} +func (m *ClientConsensusStates) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ClientConsensusStates) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ClientConsensusStates.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 *ClientConsensusStates) XXX_Merge(src proto.Message) { + xxx_messageInfo_ClientConsensusStates.Merge(m, src) +} +func (m *ClientConsensusStates) XXX_Size() int { + return m.Size() +} +func (m *ClientConsensusStates) XXX_DiscardUnknown() { + xxx_messageInfo_ClientConsensusStates.DiscardUnknown(m) +} + +var xxx_messageInfo_ClientConsensusStates proto.InternalMessageInfo + +func (m *ClientConsensusStates) GetClientId() string { + if m != nil { + return m.ClientId + } + return "" +} + +func (m *ClientConsensusStates) GetConsensusStates() []*types.Any { + if m != nil { + return m.ConsensusStates + } + return nil +} + func init() { proto.RegisterType((*IdentifiedClientState)(nil), "ibc.client.IdentifiedClientState") + proto.RegisterType((*ClientConsensusStates)(nil), "ibc.client.ClientConsensusStates") } func init() { proto.RegisterFile("ibc/client/client.proto", fileDescriptor_226f80e576f20abd) } var fileDescriptor_226f80e576f20abd = []byte{ - // 250 bytes of a gzipped FileDescriptorProto + // 314 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0x4c, 0x4a, 0xd6, 0x4f, 0xce, 0xc9, 0x4c, 0xcd, 0x2b, 0x81, 0x52, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0x5c, 0x99, 0x49, 0xc9, 0x7a, 0x10, 0x11, 0x29, 0x91, 0xf4, 0xfc, 0xf4, 0x7c, 0xb0, 0xb0, 0x3e, 0x88, 0x05, 0x51, 0x21, 0x25, 0x99, 0x9e, 0x9f, 0x9f, 0x9e, 0x93, 0xaa, 0x0f, 0xe6, 0x25, 0x95, 0xa6, - 0xe9, 0x27, 0xe6, 0x55, 0x42, 0xa4, 0x94, 0x4a, 0xb9, 0x44, 0x3d, 0x53, 0x52, 0xf3, 0x4a, 0x32, - 0xd3, 0x32, 0x53, 0x53, 0x9c, 0xc1, 0x86, 0x04, 0x97, 0x24, 0x96, 0xa4, 0x0a, 0xc9, 0x72, 0x31, - 0x65, 0xa6, 0x48, 0x30, 0x2a, 0x30, 0x6a, 0x70, 0x3a, 0xf1, 0x7e, 0xba, 0x27, 0xcf, 0x59, 0x99, - 0x98, 0x9b, 0x63, 0xa5, 0x94, 0x99, 0xa2, 0x14, 0xc4, 0x94, 0x99, 0x22, 0x64, 0xce, 0xc5, 0x03, - 0xb1, 0x32, 0xbe, 0x18, 0xa4, 0x5c, 0x82, 0x49, 0x81, 0x51, 0x83, 0xdb, 0x48, 0x44, 0x0f, 0x62, - 0x93, 0x1e, 0xcc, 0x26, 0x3d, 0xc7, 0xbc, 0xca, 0x20, 0xee, 0x64, 0x84, 0xb9, 0x56, 0x2c, 0x1d, - 0x0b, 0xe4, 0x19, 0x9c, 0x7c, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, - 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1, 0x58, 0x8e, 0x21, 0xca, - 0x28, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x3f, 0x39, 0xbf, 0x38, 0x37, - 0xbf, 0x18, 0x4a, 0xe9, 0x16, 0xa7, 0x64, 0xeb, 0x57, 0xe8, 0x83, 0x42, 0xc1, 0xc0, 0x48, 0x17, - 0x1a, 0x10, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c, 0x60, 0xeb, 0x8c, 0x01, 0x01, 0x00, 0x00, - 0xff, 0xff, 0x40, 0x46, 0x80, 0x22, 0x23, 0x01, 0x00, 0x00, + 0xe9, 0x27, 0xe6, 0x55, 0x42, 0xa4, 0x94, 0xe6, 0x30, 0x72, 0x89, 0x7a, 0xa6, 0xa4, 0xe6, 0x95, + 0x64, 0xa6, 0x65, 0xa6, 0xa6, 0x38, 0x83, 0x4d, 0x09, 0x2e, 0x49, 0x2c, 0x49, 0x15, 0x32, 0xe4, + 0xe2, 0x84, 0x18, 0x1a, 0x9f, 0x99, 0x22, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0xe9, 0x24, 0xf2, 0xe9, + 0x9e, 0xbc, 0x40, 0x65, 0x62, 0x6e, 0x8e, 0x95, 0x12, 0x5c, 0x4a, 0x29, 0x88, 0x03, 0xc2, 0xf6, + 0x4c, 0x11, 0x0a, 0xe0, 0xe2, 0x81, 0x8a, 0x17, 0x83, 0x8c, 0x90, 0x60, 0x52, 0x60, 0xd4, 0xe0, + 0x36, 0x12, 0xd1, 0x83, 0x58, 0xaf, 0x07, 0xb3, 0x5e, 0xcf, 0x31, 0xaf, 0xd2, 0x49, 0xfc, 0xd3, + 0x3d, 0x79, 0x61, 0x14, 0xb3, 0xc0, 0x7a, 0x94, 0x82, 0xb8, 0x93, 0x11, 0x8e, 0x50, 0x5a, 0xc1, + 0xc8, 0x25, 0x0a, 0x71, 0x94, 0x73, 0x7e, 0x5e, 0x71, 0x6a, 0x5e, 0x71, 0x69, 0x31, 0x58, 0xa2, + 0x98, 0x1c, 0xe7, 0xc5, 0x70, 0x09, 0x24, 0xc3, 0x4c, 0x81, 0xd8, 0x56, 0x2c, 0xc1, 0xa4, 0xc0, + 0x8c, 0xd3, 0x89, 0xd2, 0x9f, 0xee, 0xc9, 0x8b, 0x43, 0xcd, 0x43, 0xd3, 0xa7, 0x14, 0xc4, 0x9f, + 0x8c, 0xea, 0x20, 0x27, 0x9f, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, + 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18, 0x6e, 0x3c, 0x96, 0x63, 0x88, 0x32, + 0x4a, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0x2f, 0xce, 0xcd, + 0x2f, 0x86, 0x52, 0xba, 0xc5, 0x29, 0xd9, 0xfa, 0x15, 0xfa, 0xa0, 0x88, 0x35, 0x30, 0xd2, 0x85, + 0xc6, 0x6d, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0xd8, 0x25, 0xc6, 0x80, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x38, 0x45, 0x52, 0x5c, 0xf6, 0x01, 0x00, 0x00, } func (m *IdentifiedClientState) Marshal() (dAtA []byte, err error) { @@ -122,10 +197,54 @@ func (m *IdentifiedClientState) MarshalToSizedBuffer(dAtA []byte) (int, error) { i-- dAtA[i] = 0x12 } - if len(m.Id) > 0 { - i -= len(m.Id) - copy(dAtA[i:], m.Id) - i = encodeVarintClient(dAtA, i, uint64(len(m.Id))) + if len(m.ClientId) > 0 { + i -= len(m.ClientId) + copy(dAtA[i:], m.ClientId) + i = encodeVarintClient(dAtA, i, uint64(len(m.ClientId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *ClientConsensusStates) 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 *ClientConsensusStates) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ClientConsensusStates) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ConsensusStates) > 0 { + for iNdEx := len(m.ConsensusStates) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ConsensusStates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintClient(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } + if len(m.ClientId) > 0 { + i -= len(m.ClientId) + copy(dAtA[i:], m.ClientId) + i = encodeVarintClient(dAtA, i, uint64(len(m.ClientId))) i-- dAtA[i] = 0xa } @@ -149,7 +268,7 @@ func (m *IdentifiedClientState) Size() (n int) { } var l int _ = l - l = len(m.Id) + l = len(m.ClientId) if l > 0 { n += 1 + l + sovClient(uint64(l)) } @@ -160,6 +279,25 @@ func (m *IdentifiedClientState) Size() (n int) { return n } +func (m *ClientConsensusStates) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ClientId) + if l > 0 { + n += 1 + l + sovClient(uint64(l)) + } + if len(m.ConsensusStates) > 0 { + for _, e := range m.ConsensusStates { + l = e.Size() + n += 1 + l + sovClient(uint64(l)) + } + } + return n +} + func sovClient(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -197,7 +335,7 @@ func (m *IdentifiedClientState) Unmarshal(dAtA []byte) error { switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -225,7 +363,7 @@ func (m *IdentifiedClientState) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Id = string(dAtA[iNdEx:postIndex]) + m.ClientId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { @@ -287,6 +425,125 @@ func (m *IdentifiedClientState) Unmarshal(dAtA []byte) error { } return nil } +func (m *ClientConsensusStates) 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 ErrIntOverflowClient + } + 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: ClientConsensusStates: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ClientConsensusStates: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowClient + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthClient + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthClient + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusStates", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowClient + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthClient + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthClient + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ConsensusStates = append(m.ConsensusStates, &types.Any{}) + if err := m.ConsensusStates[len(m.ConsensusStates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipClient(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthClient + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthClient + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipClient(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/x/ibc/02-client/types/codec.go b/x/ibc/02-client/types/codec.go index 9d3daca34..9b7a79326 100644 --- a/x/ibc/02-client/types/codec.go +++ b/x/ibc/02-client/types/codec.go @@ -53,6 +53,34 @@ func init() { amino.Seal() } +// PackClientState constructs a new Any packed with the given client state value. It returns +// an error if the client state can't be casted to a protobuf message or if the concrete +// implemention is not registered to the protobuf codec. +func PackClientState(clientState exported.ClientState) (*codectypes.Any, error) { + msg, ok := clientState.(proto.Message) + if !ok { + return nil, fmt.Errorf("cannot proto marshal %T", clientState) + } + + anyClientState, err := codectypes.NewAnyWithValue(msg) + if err != nil { + return nil, err + } + + return anyClientState, nil +} + +// UnpackClientState unpacks an Any into a ClientState. It returns an error if the +// client state can't be unpacked into a ClientState. +func UnpackClientState(any *codectypes.Any) (exported.ClientState, error) { + clientState, ok := any.GetCachedValue().(exported.ClientState) + if !ok { + return nil, fmt.Errorf("cannot unpack Any into ClientState %T", any) + } + + return clientState, nil +} + // PackConsensusState constructs a new Any packed with the given consensus state value. It returns // an error if the consensus state can't be casted to a protobuf message or if the concrete // implemention is not registered to the protobuf codec. diff --git a/x/ibc/02-client/types/genesis.go b/x/ibc/02-client/types/genesis.go index 0a16a1330..f5b29c5d0 100644 --- a/x/ibc/02-client/types/genesis.go +++ b/x/ibc/02-client/types/genesis.go @@ -4,48 +4,18 @@ import ( "fmt" "sort" - proto "github.com/gogo/protobuf/proto" - codectypes "github.com/cosmos/cosmos-sdk/codec/types" "github.com/cosmos/cosmos-sdk/x/ibc/02-client/exported" host "github.com/cosmos/cosmos-sdk/x/ibc/24-host" ) var ( - _ codectypes.UnpackInterfacesMessage = GenesisClientState{} + _ codectypes.UnpackInterfacesMessage = IdentifiedClientState{} _ codectypes.UnpackInterfacesMessage = ClientsConsensusStates{} _ codectypes.UnpackInterfacesMessage = ClientConsensusStates{} _ codectypes.UnpackInterfacesMessage = GenesisState{} ) -// NewGenesisClientState creates a new GenesisClientState instance. -func NewGenesisClientState(clientID string, clientState exported.ClientState) GenesisClientState { - msg, ok := clientState.(proto.Message) - if !ok { - panic(fmt.Errorf("cannot proto marshal %T", clientState)) - } - - anyClientState, err := codectypes.NewAnyWithValue(msg) - if err != nil { - panic(err) - } - - return GenesisClientState{ - ClientId: clientID, - ClientState: anyClientState, - } -} - -// UnpackInterfaces implements UnpackInterfacesMessage.UnpackInterfaces -func (gs GenesisClientState) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error { - var clientState exported.ClientState - err := unpacker.UnpackAny(gs.ClientState, &clientState) - if err != nil { - return err - } - return nil -} - var _ sort.Interface = ClientsConsensusStates{} // ClientsConsensusStates defines a slice of ClientConsensusStates that supports the sort interface @@ -104,7 +74,7 @@ func (ccs ClientConsensusStates) UnpackInterfaces(unpacker codectypes.AnyUnpacke // NewGenesisState creates a GenesisState instance. func NewGenesisState( - clients []GenesisClientState, clientsConsensus ClientsConsensusStates, createLocalhost bool, + clients []IdentifiedClientState, clientsConsensus ClientsConsensusStates, createLocalhost bool, ) GenesisState { return GenesisState{ Clients: clients, @@ -116,7 +86,7 @@ func NewGenesisState( // DefaultGenesisState returns the ibc client submodule's default genesis state. func DefaultGenesisState() GenesisState { return GenesisState{ - Clients: []GenesisClientState{}, + Clients: []IdentifiedClientState{}, ClientsConsensus: ClientsConsensusStates{}, CreateLocalhost: false, } diff --git a/x/ibc/02-client/types/genesis.pb.go b/x/ibc/02-client/types/genesis.pb.go index 800aac420..865942263 100644 --- a/x/ibc/02-client/types/genesis.pb.go +++ b/x/ibc/02-client/types/genesis.pb.go @@ -5,7 +5,6 @@ package types import ( fmt "fmt" - types "github.com/cosmos/cosmos-sdk/codec/types" _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" io "io" @@ -24,124 +23,21 @@ var _ = math.Inf // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package -// GenesisClientState defines an identified ClientState as protobuf Any format. -type GenesisClientState struct { - ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty" yaml:"client_id"` - ClientState *types.Any `protobuf:"bytes,2,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty" yaml:"client_state"` -} - -func (m *GenesisClientState) Reset() { *m = GenesisClientState{} } -func (m *GenesisClientState) String() string { return proto.CompactTextString(m) } -func (*GenesisClientState) ProtoMessage() {} -func (*GenesisClientState) Descriptor() ([]byte, []int) { - return fileDescriptor_2eb5d7ff040be5c2, []int{0} -} -func (m *GenesisClientState) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *GenesisClientState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_GenesisClientState.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 *GenesisClientState) XXX_Merge(src proto.Message) { - xxx_messageInfo_GenesisClientState.Merge(m, src) -} -func (m *GenesisClientState) XXX_Size() int { - return m.Size() -} -func (m *GenesisClientState) XXX_DiscardUnknown() { - xxx_messageInfo_GenesisClientState.DiscardUnknown(m) -} - -var xxx_messageInfo_GenesisClientState proto.InternalMessageInfo - -func (m *GenesisClientState) GetClientId() string { - if m != nil { - return m.ClientId - } - return "" -} - -func (m *GenesisClientState) GetClientState() *types.Any { - if m != nil { - return m.ClientState - } - return nil -} - -// ClientConsensusStates defines all the stored consensus states for a given client. -type ClientConsensusStates struct { - ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` - ConsensusStates []*types.Any `protobuf:"bytes,2,rep,name=consensus_states,json=consensusStates,proto3" json:"consensus_states,omitempty" yaml:"consensus_states"` -} - -func (m *ClientConsensusStates) Reset() { *m = ClientConsensusStates{} } -func (m *ClientConsensusStates) String() string { return proto.CompactTextString(m) } -func (*ClientConsensusStates) ProtoMessage() {} -func (*ClientConsensusStates) Descriptor() ([]byte, []int) { - return fileDescriptor_2eb5d7ff040be5c2, []int{1} -} -func (m *ClientConsensusStates) XXX_Unmarshal(b []byte) error { - return m.Unmarshal(b) -} -func (m *ClientConsensusStates) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { - if deterministic { - return xxx_messageInfo_ClientConsensusStates.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 *ClientConsensusStates) XXX_Merge(src proto.Message) { - xxx_messageInfo_ClientConsensusStates.Merge(m, src) -} -func (m *ClientConsensusStates) XXX_Size() int { - return m.Size() -} -func (m *ClientConsensusStates) XXX_DiscardUnknown() { - xxx_messageInfo_ClientConsensusStates.DiscardUnknown(m) -} - -var xxx_messageInfo_ClientConsensusStates proto.InternalMessageInfo - -func (m *ClientConsensusStates) GetClientId() string { - if m != nil { - return m.ClientId - } - return "" -} - -func (m *ClientConsensusStates) GetConsensusStates() []*types.Any { - if m != nil { - return m.ConsensusStates - } - return nil -} - // GenesisState defines the ibc client submodule's genesis state. type GenesisState struct { - Clients []GenesisClientState `protobuf:"bytes,1,rep,name=clients,proto3" json:"clients"` + // client states with their corresponding identifiers + Clients []IdentifiedClientState `protobuf:"bytes,1,rep,name=clients,proto3" json:"clients"` + // consensus states from each client ClientsConsensus ClientsConsensusStates `protobuf:"bytes,2,rep,name=clients_consensus,json=clientsConsensus,proto3,castrepeated=ClientsConsensusStates" json:"clients_consensus" yaml:"clients_consensus"` - CreateLocalhost bool `protobuf:"varint,3,opt,name=create_localhost,json=createLocalhost,proto3" json:"create_localhost,omitempty" yaml:"create_localhost"` + // create localhost on initialization + CreateLocalhost bool `protobuf:"varint,3,opt,name=create_localhost,json=createLocalhost,proto3" json:"create_localhost,omitempty" yaml:"create_localhost"` } func (m *GenesisState) Reset() { *m = GenesisState{} } func (m *GenesisState) String() string { return proto.CompactTextString(m) } func (*GenesisState) ProtoMessage() {} func (*GenesisState) Descriptor() ([]byte, []int) { - return fileDescriptor_2eb5d7ff040be5c2, []int{2} + return fileDescriptor_2eb5d7ff040be5c2, []int{0} } func (m *GenesisState) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -170,7 +66,7 @@ func (m *GenesisState) XXX_DiscardUnknown() { var xxx_messageInfo_GenesisState proto.InternalMessageInfo -func (m *GenesisState) GetClients() []GenesisClientState { +func (m *GenesisState) GetClients() []IdentifiedClientState { if m != nil { return m.Clients } @@ -192,128 +88,33 @@ func (m *GenesisState) GetCreateLocalhost() bool { } func init() { - proto.RegisterType((*GenesisClientState)(nil), "ibc.client.GenesisClientState") - proto.RegisterType((*ClientConsensusStates)(nil), "ibc.client.ClientConsensusStates") proto.RegisterType((*GenesisState)(nil), "ibc.client.GenesisState") } func init() { proto.RegisterFile("ibc/client/genesis.proto", fileDescriptor_2eb5d7ff040be5c2) } var fileDescriptor_2eb5d7ff040be5c2 = []byte{ - // 432 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x52, 0xbf, 0x8e, 0xd3, 0x30, - 0x1c, 0x8e, 0x7b, 0x08, 0xee, 0x7c, 0x27, 0x11, 0x42, 0xe1, 0xc2, 0x9d, 0x94, 0x04, 0x4f, 0x5d, - 0xce, 0x86, 0xb2, 0xdd, 0x80, 0x44, 0x4e, 0x02, 0x21, 0xdd, 0x80, 0xc2, 0x86, 0x90, 0xaa, 0xc4, - 0x35, 0xb9, 0x88, 0x34, 0xae, 0x6a, 0x57, 0x22, 0xaf, 0xc0, 0x84, 0xd8, 0x98, 0xd9, 0x78, 0x92, - 0x8e, 0x1d, 0x99, 0x02, 0x6a, 0xdf, 0x20, 0x4f, 0x80, 0x62, 0x27, 0x6d, 0x9a, 0x72, 0x53, 0x9c, - 0xef, 0xf7, 0xfb, 0xfe, 0xe8, 0xb3, 0xa1, 0x9d, 0x44, 0x94, 0xd0, 0x34, 0x61, 0x99, 0x24, 0x31, - 0xcb, 0x98, 0x48, 0x04, 0x9e, 0xce, 0xb8, 0xe4, 0x16, 0x4c, 0x22, 0x8a, 0xf5, 0xe4, 0xac, 0x1f, - 0xf3, 0x98, 0x2b, 0x98, 0x54, 0x27, 0xbd, 0x71, 0xf6, 0x24, 0xe6, 0x3c, 0x4e, 0x19, 0x51, 0x7f, - 0xd1, 0xfc, 0x13, 0x09, 0xb3, 0x5c, 0x8f, 0xd0, 0x0f, 0x00, 0xad, 0x37, 0x5a, 0xee, 0x4a, 0x49, - 0xbc, 0x97, 0xa1, 0x64, 0xd6, 0x73, 0x78, 0xa4, 0x15, 0x47, 0xc9, 0xd8, 0x06, 0x1e, 0x18, 0x1c, - 0xf9, 0xfd, 0xb2, 0x70, 0xcd, 0x3c, 0x9c, 0xa4, 0x97, 0x68, 0x33, 0x42, 0xc1, 0xa1, 0x3e, 0xbf, - 0x1d, 0x5b, 0xef, 0xe0, 0x49, 0x8d, 0x8b, 0x4a, 0xc2, 0xee, 0x79, 0x60, 0x70, 0x3c, 0xec, 0x63, - 0xed, 0x8d, 0x1b, 0x6f, 0xfc, 0x2a, 0xcb, 0xfd, 0xd3, 0xb2, 0x70, 0x1f, 0xee, 0x68, 0x29, 0x0e, - 0x0a, 0x8e, 0xe9, 0x36, 0x04, 0xfa, 0x0e, 0xe0, 0x23, 0x1d, 0xea, 0x8a, 0x67, 0x82, 0x65, 0x62, - 0x2e, 0xd4, 0x40, 0x58, 0xe7, 0x7b, 0xf1, 0x5a, 0x41, 0x3e, 0x42, 0x93, 0x36, 0xfb, 0x5a, 0x57, - 0xd8, 0x3d, 0xef, 0xe0, 0xd6, 0x30, 0xe7, 0x65, 0xe1, 0x9e, 0xd6, 0x61, 0x3a, 0x3c, 0x14, 0xdc, - 0xa7, 0xbb, 0xd6, 0xe8, 0x67, 0x0f, 0x9e, 0xd4, 0x85, 0xe9, 0xaa, 0x5e, 0xc2, 0x7b, 0xda, 0x5a, - 0xd8, 0x40, 0xb9, 0x38, 0x78, 0x7b, 0x21, 0x78, 0xbf, 0x5b, 0xff, 0xce, 0xa2, 0x70, 0x8d, 0xa0, - 0x21, 0x59, 0x5f, 0x01, 0x7c, 0x50, 0x9f, 0x47, 0x1b, 0xb3, 0x3a, 0xf0, 0xd3, 0xb6, 0xd4, 0x7f, - 0xab, 0xf0, 0x2f, 0x2b, 0xb5, 0xb2, 0x70, 0xed, 0x76, 0x9d, 0x2d, 0x25, 0xf4, 0xeb, 0x8f, 0xfb, - 0x58, 0x53, 0x45, 0x87, 0x1b, 0x98, 0xb4, 0x83, 0x5b, 0xaf, 0xa1, 0x49, 0x67, 0x2c, 0x94, 0x6c, - 0x94, 0x72, 0x1a, 0xa6, 0x37, 0x5c, 0x48, 0xfb, 0xc0, 0x03, 0x83, 0xc3, 0x9d, 0x96, 0x3a, 0x1b, - 0x55, 0x4b, 0x0a, 0xba, 0x6e, 0x10, 0xff, 0x7a, 0xb1, 0x72, 0xc0, 0x72, 0xe5, 0x80, 0xbf, 0x2b, - 0x07, 0x7c, 0x5b, 0x3b, 0xc6, 0x72, 0xed, 0x18, 0xbf, 0xd7, 0x8e, 0xf1, 0x61, 0x18, 0x27, 0xf2, - 0x66, 0x1e, 0x61, 0xca, 0x27, 0x84, 0x72, 0x31, 0xe1, 0xa2, 0xfe, 0x5c, 0x88, 0xf1, 0x67, 0xf2, - 0x85, 0x54, 0xcf, 0xfc, 0xd9, 0xf0, 0xa2, 0x7e, 0xe9, 0x32, 0x9f, 0x32, 0x11, 0xdd, 0x55, 0xf7, - 0xf5, 0xe2, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x63, 0xf9, 0x67, 0x68, 0x04, 0x03, 0x00, 0x00, -} - -func (m *GenesisClientState) 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 *GenesisClientState) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *GenesisClientState) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if m.ClientState != nil { - { - size, err := m.ClientState.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGenesis(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - if len(m.ClientId) > 0 { - i -= len(m.ClientId) - copy(dAtA[i:], m.ClientId) - i = encodeVarintGenesis(dAtA, i, uint64(len(m.ClientId))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - -func (m *ClientConsensusStates) 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 *ClientConsensusStates) MarshalTo(dAtA []byte) (int, error) { - size := m.Size() - return m.MarshalToSizedBuffer(dAtA[:size]) -} - -func (m *ClientConsensusStates) MarshalToSizedBuffer(dAtA []byte) (int, error) { - i := len(dAtA) - _ = i - var l int - _ = l - if len(m.ConsensusStates) > 0 { - for iNdEx := len(m.ConsensusStates) - 1; iNdEx >= 0; iNdEx-- { - { - size, err := m.ConsensusStates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = encodeVarintGenesis(dAtA, i, uint64(size)) - } - i-- - dAtA[i] = 0x12 - } - } - if len(m.ClientId) > 0 { - i -= len(m.ClientId) - copy(dAtA[i:], m.ClientId) - i = encodeVarintGenesis(dAtA, i, uint64(len(m.ClientId))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil + // 313 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xc8, 0x4c, 0x4a, 0xd6, + 0x4f, 0xce, 0xc9, 0x4c, 0xcd, 0x2b, 0xd1, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c, 0xd6, 0x2b, + 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0xca, 0x4c, 0x4a, 0xd6, 0x83, 0xc8, 0x48, 0x89, 0x23, 0xa9, + 0x82, 0x50, 0x10, 0x45, 0x52, 0x22, 0xe9, 0xf9, 0xe9, 0xf9, 0x60, 0xa6, 0x3e, 0x88, 0x05, 0x11, + 0x55, 0x5a, 0xc6, 0xc4, 0xc5, 0xe3, 0x0e, 0x31, 0x2c, 0xb8, 0x24, 0xb1, 0x24, 0x55, 0xc8, 0x91, + 0x8b, 0x1d, 0xa2, 0xad, 0x58, 0x82, 0x51, 0x81, 0x59, 0x83, 0xdb, 0x48, 0x51, 0x0f, 0x61, 0xba, + 0x9e, 0x67, 0x4a, 0x6a, 0x5e, 0x49, 0x66, 0x5a, 0x66, 0x6a, 0x8a, 0x33, 0x58, 0x00, 0xac, 0xc7, + 0x89, 0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0x98, 0x3e, 0xa1, 0x2e, 0x46, 0x2e, 0x41, 0x28, 0x3b, + 0x3e, 0x39, 0x3f, 0xaf, 0x38, 0x35, 0xaf, 0xb8, 0xb4, 0x58, 0x82, 0x09, 0xd3, 0x34, 0x88, 0x19, + 0xce, 0x30, 0x25, 0x60, 0xc3, 0x8a, 0x9d, 0xac, 0x40, 0xa6, 0x7d, 0xba, 0x27, 0x2f, 0x51, 0x99, + 0x98, 0x9b, 0x63, 0xa5, 0x84, 0x61, 0x92, 0xd2, 0xaa, 0xfb, 0xf2, 0x62, 0x10, 0xad, 0xc5, 0x68, + 0x7a, 0x83, 0x04, 0x92, 0xd1, 0xc4, 0x85, 0xdc, 0xb8, 0x04, 0x92, 0x8b, 0x52, 0x13, 0x4b, 0x52, + 0xe3, 0x73, 0xf2, 0x93, 0x13, 0x73, 0x32, 0xf2, 0x8b, 0x4b, 0x24, 0x98, 0x15, 0x18, 0x35, 0x38, + 0x9c, 0xa4, 0x3f, 0xdd, 0x93, 0x17, 0x87, 0xda, 0x81, 0xa6, 0x42, 0x29, 0x88, 0x1f, 0x22, 0xe4, + 0x03, 0x13, 0x71, 0xf2, 0x39, 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, 0xa3, + 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4, 0xfc, 0x5c, 0xfd, 0xe4, 0xfc, 0xe2, 0xdc, 0xfc, + 0x62, 0x28, 0xa5, 0x5b, 0x9c, 0x92, 0xad, 0x5f, 0xa1, 0x0f, 0x8a, 0x10, 0x03, 0x23, 0x5d, 0x68, + 0x9c, 0x94, 0x54, 0x16, 0xa4, 0x16, 0x27, 0xb1, 0x81, 0x43, 0xdf, 0x18, 0x10, 0x00, 0x00, 0xff, + 0xff, 0xe0, 0x1c, 0x5d, 0xa3, 0xd4, 0x01, 0x00, 0x00, } func (m *GenesisState) Marshal() (dAtA []byte, err error) { @@ -388,42 +189,6 @@ func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int { dAtA[offset] = uint8(v) return base } -func (m *GenesisClientState) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.ClientId) - if l > 0 { - n += 1 + l + sovGenesis(uint64(l)) - } - if m.ClientState != nil { - l = m.ClientState.Size() - n += 1 + l + sovGenesis(uint64(l)) - } - return n -} - -func (m *ClientConsensusStates) Size() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.ClientId) - if l > 0 { - n += 1 + l + sovGenesis(uint64(l)) - } - if len(m.ConsensusStates) > 0 { - for _, e := range m.ConsensusStates { - l = e.Size() - n += 1 + l + sovGenesis(uint64(l)) - } - } - return n -} - func (m *GenesisState) Size() (n int) { if m == nil { return 0 @@ -454,246 +219,6 @@ func sovGenesis(x uint64) (n int) { func sozGenesis(x uint64) (n int) { return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } -func (m *GenesisClientState) 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 ErrIntOverflowGenesis - } - 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: GenesisClientState: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: GenesisClientState: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenesis - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthGenesis - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGenesis - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ClientId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClientState", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenesis - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGenesis - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGenesis - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.ClientState == nil { - m.ClientState = &types.Any{} - } - if err := m.ClientState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGenesis(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthGenesis - } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthGenesis - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *ClientConsensusStates) 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 ErrIntOverflowGenesis - } - 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: ClientConsensusStates: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: ClientConsensusStates: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenesis - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthGenesis - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthGenesis - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ClientId = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ConsensusStates", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowGenesis - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthGenesis - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthGenesis - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.ConsensusStates = append(m.ConsensusStates, &types.Any{}) - if err := m.ConsensusStates[len(m.ConsensusStates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipGenesis(dAtA[iNdEx:]) - if err != nil { - return err - } - if skippy < 0 { - return ErrInvalidLengthGenesis - } - if (iNdEx + skippy) < 0 { - return ErrInvalidLengthGenesis - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func (m *GenesisState) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -752,7 +277,7 @@ func (m *GenesisState) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Clients = append(m.Clients, GenesisClientState{}) + m.Clients = append(m.Clients, IdentifiedClientState{}) if err := m.Clients[len(m.Clients)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } diff --git a/x/ibc/02-client/types/genesis_test.go b/x/ibc/02-client/types/genesis_test.go index 9411ed2af..a87040cff 100644 --- a/x/ibc/02-client/types/genesis_test.go +++ b/x/ibc/02-client/types/genesis_test.go @@ -47,11 +47,11 @@ func TestValidateGenesis(t *testing.T) { { name: "valid genesis", genState: types.NewGenesisState( - []types.GenesisClientState{ - types.NewGenesisClientState( + []types.IdentifiedClientState{ + types.NewIdentifiedClientState( clientID, ibctmtypes.NewClientState(chainID, ibctesting.DefaultTrustLevel, ibctesting.TrustingPeriod, ibctesting.UnbondingPeriod, ibctesting.MaxClockDrift, height, commitmenttypes.GetSDKSpecs()), ), - types.NewGenesisClientState( + types.NewIdentifiedClientState( exported.ClientTypeLocalHost, localhosttypes.NewClientState("chainID", 10), ), }, @@ -72,11 +72,11 @@ func TestValidateGenesis(t *testing.T) { { name: "invalid clientid", genState: types.NewGenesisState( - []types.GenesisClientState{ - types.NewGenesisClientState( + []types.IdentifiedClientState{ + types.NewIdentifiedClientState( "/~@$*", ibctmtypes.NewClientState(chainID, ibctmtypes.DefaultTrustLevel, ibctesting.TrustingPeriod, ibctesting.UnbondingPeriod, ibctesting.MaxClockDrift, height, commitmenttypes.GetSDKSpecs()), ), - types.NewGenesisClientState( + types.NewIdentifiedClientState( exported.ClientTypeLocalHost, localhosttypes.NewClientState("chainID", 10), ), }, @@ -97,11 +97,11 @@ func TestValidateGenesis(t *testing.T) { { name: "invalid client", genState: types.NewGenesisState( - []types.GenesisClientState{ - types.NewGenesisClientState( + []types.IdentifiedClientState{ + types.NewIdentifiedClientState( clientID, ibctmtypes.NewClientState(chainID, ibctmtypes.DefaultTrustLevel, ibctesting.TrustingPeriod, ibctesting.UnbondingPeriod, ibctesting.MaxClockDrift, height, commitmenttypes.GetSDKSpecs()), ), - types.NewGenesisClientState(exported.ClientTypeLocalHost, localhosttypes.NewClientState("chaindID", 0)), + types.NewIdentifiedClientState(exported.ClientTypeLocalHost, localhosttypes.NewClientState("chaindID", 0)), }, nil, true, @@ -111,11 +111,11 @@ func TestValidateGenesis(t *testing.T) { { name: "invalid consensus state", genState: types.NewGenesisState( - []types.GenesisClientState{ - types.NewGenesisClientState( + []types.IdentifiedClientState{ + types.NewIdentifiedClientState( clientID, ibctmtypes.NewClientState(chainID, ibctmtypes.DefaultTrustLevel, ibctesting.TrustingPeriod, ibctesting.UnbondingPeriod, ibctesting.MaxClockDrift, height, commitmenttypes.GetSDKSpecs()), ), - types.NewGenesisClientState( + types.NewIdentifiedClientState( exported.ClientTypeLocalHost, localhosttypes.NewClientState("chaindID", 10), ), }, @@ -136,11 +136,11 @@ func TestValidateGenesis(t *testing.T) { { name: "invalid consensus state", genState: types.NewGenesisState( - []types.GenesisClientState{ - types.NewGenesisClientState( + []types.IdentifiedClientState{ + types.NewIdentifiedClientState( clientID, ibctmtypes.NewClientState(chainID, ibctmtypes.DefaultTrustLevel, ibctesting.TrustingPeriod, ibctesting.UnbondingPeriod, ibctesting.MaxClockDrift, height, commitmenttypes.GetSDKSpecs()), ), - types.NewGenesisClientState( + types.NewIdentifiedClientState( exported.ClientTypeLocalHost, localhosttypes.NewClientState("chaindID", 10), ), }, diff --git a/x/ibc/02-client/types/querier.go b/x/ibc/02-client/types/querier.go deleted file mode 100644 index 37f7b4bec..000000000 --- a/x/ibc/02-client/types/querier.go +++ /dev/null @@ -1,73 +0,0 @@ -package types - -import ( - "strings" - - tmcrypto "github.com/tendermint/tendermint/proto/tendermint/crypto" - - "github.com/cosmos/cosmos-sdk/x/ibc/02-client/exported" - commitmenttypes "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/types" - host "github.com/cosmos/cosmos-sdk/x/ibc/24-host" -) - -// query routes supported by the IBC client Querier -const ( - QueryAllClients = "client_states" -) - -// QueryAllClientsParams defines the parameters necessary for querying for all -// light client states. -type QueryAllClientsParams struct { - Page int `json:"page" yaml:"page"` - Limit int `json:"limit" yaml:"limit"` -} - -// NewQueryAllClientsParams creates a new QueryAllClientsParams instance. -func NewQueryAllClientsParams(page, limit int) QueryAllClientsParams { - return QueryAllClientsParams{ - Page: page, - Limit: limit, - } -} - -// StateResponse defines the client response for a client state query. -// It includes the commitment proof and the height of the proof. -type StateResponse struct { - ClientState exported.ClientState `json:"client_state" yaml:"client_state"` - Proof commitmenttypes.MerkleProof `json:"proof,omitempty" yaml:"proof,omitempty"` - ProofPath commitmenttypes.MerklePath `json:"proof_path,omitempty" yaml:"proof_path,omitempty"` - ProofHeight uint64 `json:"proof_height,omitempty" yaml:"proof_height,omitempty"` -} - -// NewClientStateResponse creates a new StateResponse instance. -func NewClientStateResponse( - clientID string, clientState exported.ClientState, proof *tmcrypto.ProofOps, height int64, -) StateResponse { - return StateResponse{ - ClientState: clientState, - Proof: commitmenttypes.MerkleProof{Proof: proof}, - ProofPath: commitmenttypes.NewMerklePath(append([]string{clientID}, strings.Split(host.ClientStatePath(), "/")...)), - ProofHeight: uint64(height), - } -} - -// ConsensusStateResponse defines the client response for a Consensus state query. -// It includes the commitment proof and the height of the proof. -type ConsensusStateResponse struct { - ConsensusState exported.ConsensusState `json:"consensus_state" yaml:"consensus_state"` - Proof commitmenttypes.MerkleProof `json:"proof,omitempty" yaml:"proof,omitempty"` - ProofPath commitmenttypes.MerklePath `json:"proof_path,omitempty" yaml:"proof_path,omitempty"` - ProofHeight uint64 `json:"proof_height,omitempty" yaml:"proof_height,omitempty"` -} - -// NewConsensusStateResponse creates a new ConsensusStateResponse instance. -func NewConsensusStateResponse( - clientID string, cs exported.ConsensusState, proof *tmcrypto.ProofOps, height int64, -) ConsensusStateResponse { - return ConsensusStateResponse{ - ConsensusState: cs, - Proof: commitmenttypes.MerkleProof{Proof: proof}, - ProofPath: commitmenttypes.NewMerklePath(append([]string{clientID}, strings.Split(host.ClientStatePath(), "/")...)), - ProofHeight: uint64(height), - } -} diff --git a/x/ibc/02-client/types/query.go b/x/ibc/02-client/types/query.go new file mode 100644 index 000000000..cce305f95 --- /dev/null +++ b/x/ibc/02-client/types/query.go @@ -0,0 +1,35 @@ +package types + +import ( + "strings" + + codectypes "github.com/cosmos/cosmos-sdk/codec/types" + commitmenttypes "github.com/cosmos/cosmos-sdk/x/ibc/23-commitment/types" + host "github.com/cosmos/cosmos-sdk/x/ibc/24-host" +) + +// NewQueryClientStateResponse creates a new QueryClientStateResponse instance. +func NewQueryClientStateResponse( + clientID string, clientStateAny *codectypes.Any, proof []byte, height int64, +) *QueryClientStateResponse { + path := commitmenttypes.NewMerklePath(append([]string{clientID}, strings.Split(host.ClientStatePath(), "/")...)) + return &QueryClientStateResponse{ + ClientState: clientStateAny, + Proof: proof, + ProofPath: path.Pretty(), + ProofHeight: uint64(height), + } +} + +// NewQueryConsensusStateResponse creates a new QueryConsensusStateResponse instance. +func NewQueryConsensusStateResponse( + clientID string, consensusStateAny *codectypes.Any, proof []byte, height int64, +) *QueryConsensusStateResponse { + path := commitmenttypes.NewMerklePath(strings.Split(host.FullClientPath(clientID, host.ConsensusStatePath(uint64(height))), "/")) + return &QueryConsensusStateResponse{ + ConsensusState: consensusStateAny, + Proof: proof, + ProofPath: path.Pretty(), + ProofHeight: uint64(height), + } +} diff --git a/x/ibc/02-client/types/query.pb.go b/x/ibc/02-client/types/query.pb.go new file mode 100644 index 000000000..9153c4b16 --- /dev/null +++ b/x/ibc/02-client/types/query.pb.go @@ -0,0 +1,2381 @@ +// Code generated by protoc-gen-gogo. DO NOT EDIT. +// source: ibc/client/query.proto + +package types + +import ( + context "context" + fmt "fmt" + types "github.com/cosmos/cosmos-sdk/codec/types" + query "github.com/cosmos/cosmos-sdk/types/query" + grpc1 "github.com/gogo/protobuf/grpc" + proto "github.com/gogo/protobuf/proto" + _ "google.golang.org/genproto/googleapis/api/annotations" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" + io "io" + math "math" + math_bits "math/bits" +) + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package + +// QueryClientStateRequest is the request type for the Query/ClientState RPC +// method +type QueryClientStateRequest struct { + // client state unique identifier + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` +} + +func (m *QueryClientStateRequest) Reset() { *m = QueryClientStateRequest{} } +func (m *QueryClientStateRequest) String() string { return proto.CompactTextString(m) } +func (*QueryClientStateRequest) ProtoMessage() {} +func (*QueryClientStateRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_320a7d3a97b17345, []int{0} +} +func (m *QueryClientStateRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryClientStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryClientStateRequest.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 *QueryClientStateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryClientStateRequest.Merge(m, src) +} +func (m *QueryClientStateRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryClientStateRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryClientStateRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryClientStateRequest proto.InternalMessageInfo + +func (m *QueryClientStateRequest) GetClientId() string { + if m != nil { + return m.ClientId + } + return "" +} + +// QueryClientStateResponse is the response type for the Query/ClientState RPC +// method. Besides the client state, it includes a proof and the height from +// which the proof was retrieved. +type QueryClientStateResponse struct { + // client state associated with the request identifier + ClientState *types.Any `protobuf:"bytes,1,opt,name=client_state,json=clientState,proto3" json:"client_state,omitempty"` + // merkle proof of existence + Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"` + // merkle proof path + ProofPath string `protobuf:"bytes,3,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"` + // height at which the proof was retrieved + ProofHeight uint64 `protobuf:"varint,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty"` +} + +func (m *QueryClientStateResponse) Reset() { *m = QueryClientStateResponse{} } +func (m *QueryClientStateResponse) String() string { return proto.CompactTextString(m) } +func (*QueryClientStateResponse) ProtoMessage() {} +func (*QueryClientStateResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_320a7d3a97b17345, []int{1} +} +func (m *QueryClientStateResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryClientStateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryClientStateResponse.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 *QueryClientStateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryClientStateResponse.Merge(m, src) +} +func (m *QueryClientStateResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryClientStateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryClientStateResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryClientStateResponse proto.InternalMessageInfo + +func (m *QueryClientStateResponse) GetClientState() *types.Any { + if m != nil { + return m.ClientState + } + return nil +} + +func (m *QueryClientStateResponse) GetProof() []byte { + if m != nil { + return m.Proof + } + return nil +} + +func (m *QueryClientStateResponse) GetProofPath() string { + if m != nil { + return m.ProofPath + } + return "" +} + +func (m *QueryClientStateResponse) GetProofHeight() uint64 { + if m != nil { + return m.ProofHeight + } + return 0 +} + +// QueryClientStatesRequest is the request type for the Query/ClientStates RPC +// method +type QueryClientStatesRequest struct { + // pagination request + Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryClientStatesRequest) Reset() { *m = QueryClientStatesRequest{} } +func (m *QueryClientStatesRequest) String() string { return proto.CompactTextString(m) } +func (*QueryClientStatesRequest) ProtoMessage() {} +func (*QueryClientStatesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_320a7d3a97b17345, []int{2} +} +func (m *QueryClientStatesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryClientStatesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryClientStatesRequest.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 *QueryClientStatesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryClientStatesRequest.Merge(m, src) +} +func (m *QueryClientStatesRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryClientStatesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryClientStatesRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryClientStatesRequest proto.InternalMessageInfo + +func (m *QueryClientStatesRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryClientStatesResponse is the response type for the Query/ClientStates RPC +// method. +type QueryClientStatesResponse struct { + // list of stored ClientStates of the chain. + ClientStates []*IdentifiedClientState `protobuf:"bytes,1,rep,name=client_states,json=clientStates,proto3" json:"client_states,omitempty"` + // pagination response + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryClientStatesResponse) Reset() { *m = QueryClientStatesResponse{} } +func (m *QueryClientStatesResponse) String() string { return proto.CompactTextString(m) } +func (*QueryClientStatesResponse) ProtoMessage() {} +func (*QueryClientStatesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_320a7d3a97b17345, []int{3} +} +func (m *QueryClientStatesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryClientStatesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryClientStatesResponse.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 *QueryClientStatesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryClientStatesResponse.Merge(m, src) +} +func (m *QueryClientStatesResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryClientStatesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryClientStatesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryClientStatesResponse proto.InternalMessageInfo + +func (m *QueryClientStatesResponse) GetClientStates() []*IdentifiedClientState { + if m != nil { + return m.ClientStates + } + return nil +} + +func (m *QueryClientStatesResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryConsensusStateRequest is the request type for the Query/ConsensusState RPC method. Besides +// the consensus state, it includes a proof and the height from which the proof was retrieved. +type QueryConsensusStateRequest struct { + // client identifier + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + // consensus state height + Height uint64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"` + // latest_height overrrides the height field and queries the latest stored ConsensusState + LatestHeight bool `protobuf:"varint,3,opt,name=latest_height,json=latestHeight,proto3" json:"latest_height,omitempty"` +} + +func (m *QueryConsensusStateRequest) Reset() { *m = QueryConsensusStateRequest{} } +func (m *QueryConsensusStateRequest) String() string { return proto.CompactTextString(m) } +func (*QueryConsensusStateRequest) ProtoMessage() {} +func (*QueryConsensusStateRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_320a7d3a97b17345, []int{4} +} +func (m *QueryConsensusStateRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryConsensusStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryConsensusStateRequest.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 *QueryConsensusStateRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryConsensusStateRequest.Merge(m, src) +} +func (m *QueryConsensusStateRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryConsensusStateRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryConsensusStateRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryConsensusStateRequest proto.InternalMessageInfo + +func (m *QueryConsensusStateRequest) GetClientId() string { + if m != nil { + return m.ClientId + } + return "" +} + +func (m *QueryConsensusStateRequest) GetHeight() uint64 { + if m != nil { + return m.Height + } + return 0 +} + +func (m *QueryConsensusStateRequest) GetLatestHeight() bool { + if m != nil { + return m.LatestHeight + } + return false +} + +// QueryConsensusStateResponse is the response type for the Query/ConsensusState RPC method +type QueryConsensusStateResponse struct { + // consensus state associated with the client identifier at the given height + ConsensusState *types.Any `protobuf:"bytes,1,opt,name=consensus_state,json=consensusState,proto3" json:"consensus_state,omitempty"` + // merkle proof of existence + Proof []byte `protobuf:"bytes,2,opt,name=proof,proto3" json:"proof,omitempty"` + // merkle proof path + ProofPath string `protobuf:"bytes,3,opt,name=proof_path,json=proofPath,proto3" json:"proof_path,omitempty"` + // height at which the proof was retrieved + ProofHeight uint64 `protobuf:"varint,4,opt,name=proof_height,json=proofHeight,proto3" json:"proof_height,omitempty"` +} + +func (m *QueryConsensusStateResponse) Reset() { *m = QueryConsensusStateResponse{} } +func (m *QueryConsensusStateResponse) String() string { return proto.CompactTextString(m) } +func (*QueryConsensusStateResponse) ProtoMessage() {} +func (*QueryConsensusStateResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_320a7d3a97b17345, []int{5} +} +func (m *QueryConsensusStateResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryConsensusStateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryConsensusStateResponse.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 *QueryConsensusStateResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryConsensusStateResponse.Merge(m, src) +} +func (m *QueryConsensusStateResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryConsensusStateResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryConsensusStateResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryConsensusStateResponse proto.InternalMessageInfo + +func (m *QueryConsensusStateResponse) GetConsensusState() *types.Any { + if m != nil { + return m.ConsensusState + } + return nil +} + +func (m *QueryConsensusStateResponse) GetProof() []byte { + if m != nil { + return m.Proof + } + return nil +} + +func (m *QueryConsensusStateResponse) GetProofPath() string { + if m != nil { + return m.ProofPath + } + return "" +} + +func (m *QueryConsensusStateResponse) GetProofHeight() uint64 { + if m != nil { + return m.ProofHeight + } + return 0 +} + +// QueryConsensusStatesRequest is the request type for the Query/ConsensusStates RPC method. +type QueryConsensusStatesRequest struct { + // client identifier + ClientId string `protobuf:"bytes,1,opt,name=client_id,json=clientId,proto3" json:"client_id,omitempty"` + // pagination request + Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryConsensusStatesRequest) Reset() { *m = QueryConsensusStatesRequest{} } +func (m *QueryConsensusStatesRequest) String() string { return proto.CompactTextString(m) } +func (*QueryConsensusStatesRequest) ProtoMessage() {} +func (*QueryConsensusStatesRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_320a7d3a97b17345, []int{6} +} +func (m *QueryConsensusStatesRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryConsensusStatesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryConsensusStatesRequest.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 *QueryConsensusStatesRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryConsensusStatesRequest.Merge(m, src) +} +func (m *QueryConsensusStatesRequest) XXX_Size() int { + return m.Size() +} +func (m *QueryConsensusStatesRequest) XXX_DiscardUnknown() { + xxx_messageInfo_QueryConsensusStatesRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryConsensusStatesRequest proto.InternalMessageInfo + +func (m *QueryConsensusStatesRequest) GetClientId() string { + if m != nil { + return m.ClientId + } + return "" +} + +func (m *QueryConsensusStatesRequest) GetPagination() *query.PageRequest { + if m != nil { + return m.Pagination + } + return nil +} + +// QueryConsensusStatesResponse is the response type for the Query/ConsensusStates RPC method +type QueryConsensusStatesResponse struct { + // consensus states associated with the identifier + ConsensusStates []*types.Any `protobuf:"bytes,1,rep,name=consensus_states,json=consensusStates,proto3" json:"consensus_states,omitempty"` + // pagination response + Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"` +} + +func (m *QueryConsensusStatesResponse) Reset() { *m = QueryConsensusStatesResponse{} } +func (m *QueryConsensusStatesResponse) String() string { return proto.CompactTextString(m) } +func (*QueryConsensusStatesResponse) ProtoMessage() {} +func (*QueryConsensusStatesResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_320a7d3a97b17345, []int{7} +} +func (m *QueryConsensusStatesResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *QueryConsensusStatesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_QueryConsensusStatesResponse.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 *QueryConsensusStatesResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_QueryConsensusStatesResponse.Merge(m, src) +} +func (m *QueryConsensusStatesResponse) XXX_Size() int { + return m.Size() +} +func (m *QueryConsensusStatesResponse) XXX_DiscardUnknown() { + xxx_messageInfo_QueryConsensusStatesResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_QueryConsensusStatesResponse proto.InternalMessageInfo + +func (m *QueryConsensusStatesResponse) GetConsensusStates() []*types.Any { + if m != nil { + return m.ConsensusStates + } + return nil +} + +func (m *QueryConsensusStatesResponse) GetPagination() *query.PageResponse { + if m != nil { + return m.Pagination + } + return nil +} + +func init() { + proto.RegisterType((*QueryClientStateRequest)(nil), "ibc.client.QueryClientStateRequest") + proto.RegisterType((*QueryClientStateResponse)(nil), "ibc.client.QueryClientStateResponse") + proto.RegisterType((*QueryClientStatesRequest)(nil), "ibc.client.QueryClientStatesRequest") + proto.RegisterType((*QueryClientStatesResponse)(nil), "ibc.client.QueryClientStatesResponse") + proto.RegisterType((*QueryConsensusStateRequest)(nil), "ibc.client.QueryConsensusStateRequest") + proto.RegisterType((*QueryConsensusStateResponse)(nil), "ibc.client.QueryConsensusStateResponse") + proto.RegisterType((*QueryConsensusStatesRequest)(nil), "ibc.client.QueryConsensusStatesRequest") + proto.RegisterType((*QueryConsensusStatesResponse)(nil), "ibc.client.QueryConsensusStatesResponse") +} + +func init() { proto.RegisterFile("ibc/client/query.proto", fileDescriptor_320a7d3a97b17345) } + +var fileDescriptor_320a7d3a97b17345 = []byte{ + // 688 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x95, 0xcf, 0x4f, 0xd4, 0x4e, + 0x18, 0xc6, 0x99, 0xe5, 0x47, 0xe0, 0xdd, 0x05, 0xbe, 0x99, 0x10, 0x58, 0x0a, 0xdf, 0xcd, 0xb2, + 0x28, 0xac, 0x26, 0xcc, 0xc0, 0x1a, 0x7f, 0xc5, 0x18, 0x83, 0x26, 0x28, 0x89, 0x07, 0xac, 0x37, + 0x2f, 0xa4, 0xed, 0x0e, 0xbb, 0x8d, 0xd0, 0x29, 0xcc, 0x2c, 0x91, 0x10, 0x2e, 0x1c, 0xbc, 0x6a, + 0xe2, 0xdd, 0x93, 0x07, 0x13, 0x3d, 0xfa, 0x47, 0x78, 0x24, 0xf1, 0xe2, 0xd1, 0x80, 0x27, 0xff, + 0x0a, 0xd3, 0x99, 0x29, 0xb4, 0x50, 0x29, 0x1a, 0x3d, 0x95, 0xbe, 0xef, 0xcc, 0x3c, 0x1f, 0x9e, + 0xe7, 0x9d, 0x2e, 0x8c, 0xfa, 0xae, 0x47, 0xbd, 0x75, 0x9f, 0x05, 0x92, 0x6e, 0x76, 0xd8, 0xd6, + 0x0e, 0x09, 0xb7, 0xb8, 0xe4, 0x18, 0x7c, 0xd7, 0x23, 0xba, 0x6e, 0x5d, 0xf5, 0xb8, 0xd8, 0xe0, + 0x82, 0xba, 0x8e, 0x60, 0x7a, 0x11, 0xdd, 0x5e, 0x70, 0x99, 0x74, 0x16, 0x68, 0xe8, 0xb4, 0xfc, + 0xc0, 0x91, 0x3e, 0x0f, 0xf4, 0x3e, 0x6b, 0x2c, 0x71, 0x9e, 0x7e, 0x98, 0xc6, 0x78, 0x8b, 0xf3, + 0xd6, 0x3a, 0xa3, 0xea, 0xcd, 0xed, 0xac, 0x51, 0x27, 0x30, 0x5a, 0xd6, 0xa4, 0x69, 0x39, 0xa1, + 0x4f, 0x9d, 0x20, 0xe0, 0x52, 0x1d, 0x28, 0x74, 0xb7, 0x76, 0x03, 0xc6, 0x9e, 0x44, 0x9a, 0x0f, + 0xd4, 0x69, 0x4f, 0xa5, 0x23, 0x99, 0xcd, 0x36, 0x3b, 0x4c, 0x48, 0x3c, 0x01, 0x03, 0x5a, 0x63, + 0xd5, 0x6f, 0x96, 0x51, 0x15, 0xd5, 0x07, 0xec, 0x7e, 0x5d, 0x58, 0x6e, 0xd6, 0x3e, 0x20, 0x28, + 0x9f, 0xdd, 0x28, 0x42, 0x1e, 0x08, 0x86, 0x6f, 0x42, 0xc9, 0xec, 0x14, 0x51, 0x5d, 0x6d, 0x2e, + 0x36, 0x46, 0x88, 0x26, 0x21, 0x31, 0x24, 0x59, 0x0c, 0x76, 0xec, 0xa2, 0x77, 0x72, 0x00, 0x1e, + 0x81, 0xde, 0x70, 0x8b, 0xf3, 0xb5, 0x72, 0xa1, 0x8a, 0xea, 0x25, 0x5b, 0xbf, 0xe0, 0xff, 0x01, + 0xd4, 0x1f, 0xab, 0xa1, 0x23, 0xdb, 0xe5, 0x6e, 0x45, 0x32, 0xa0, 0x2a, 0x2b, 0x8e, 0x6c, 0xe3, + 0x29, 0x28, 0xe9, 0x76, 0x9b, 0xf9, 0xad, 0xb6, 0x2c, 0xf7, 0x54, 0x51, 0xbd, 0xc7, 0x2e, 0xaa, + 0xda, 0x23, 0x55, 0xaa, 0xb9, 0x67, 0x61, 0x45, 0xfc, 0x6f, 0x2e, 0x01, 0x9c, 0xf8, 0x6c, 0x50, + 0x67, 0x88, 0x0e, 0x85, 0x44, 0xa1, 0x10, 0x9d, 0x9c, 0x09, 0x85, 0xac, 0x38, 0xad, 0xd8, 0x22, + 0x3b, 0xb1, 0xb3, 0xf6, 0x11, 0xc1, 0x78, 0x86, 0x88, 0xb1, 0x64, 0x09, 0x06, 0x93, 0x96, 0x88, + 0x32, 0xaa, 0x76, 0xd7, 0x8b, 0x8d, 0x29, 0x72, 0x32, 0x09, 0x64, 0xb9, 0xc9, 0x02, 0xe9, 0xaf, + 0xf9, 0xac, 0x99, 0x34, 0xb5, 0x94, 0x30, 0x48, 0xe0, 0x87, 0x29, 0xda, 0x82, 0xa2, 0x9d, 0xcd, + 0xa5, 0xd5, 0x10, 0x29, 0xdc, 0x6d, 0xb0, 0x34, 0x6d, 0xd4, 0x09, 0x44, 0x47, 0x5c, 0x38, 0x7b, + 0x3c, 0x0a, 0x7d, 0xc6, 0xea, 0x82, 0xb2, 0xda, 0xbc, 0xe1, 0x69, 0x18, 0x5c, 0x8f, 0x20, 0x65, + 0x9c, 0x44, 0x14, 0x55, 0xbf, 0x5d, 0xd2, 0x45, 0x13, 0xc5, 0x27, 0x04, 0x13, 0x99, 0xc2, 0xc6, + 0xa8, 0xbb, 0x30, 0xec, 0xc5, 0x9d, 0x0b, 0x8c, 0xcf, 0x90, 0x97, 0x3a, 0xe6, 0x9f, 0x4d, 0xd0, + 0x7e, 0x36, 0xb6, 0xb8, 0x90, 0x61, 0x4b, 0x19, 0xa1, 0xfd, 0xc9, 0x88, 0xbd, 0x47, 0x30, 0x99, + 0x0d, 0x61, 0xcc, 0xbb, 0x07, 0xff, 0x9d, 0x32, 0x2f, 0x1e, 0xb4, 0x6c, 0xf7, 0x86, 0xd3, 0xee, + 0xfd, 0xbd, 0xf1, 0x6a, 0xfc, 0xe8, 0x81, 0x5e, 0x85, 0x8a, 0x5f, 0x21, 0x28, 0x26, 0xe6, 0x19, + 0x4f, 0x27, 0x47, 0xfe, 0x17, 0xdf, 0x1e, 0xeb, 0xd2, 0xf9, 0x8b, 0xb4, 0x60, 0xed, 0xfa, 0xfe, + 0x97, 0xef, 0x6f, 0x0a, 0x14, 0xcf, 0xd1, 0xc4, 0x77, 0x31, 0xfe, 0x78, 0xa6, 0xae, 0x1b, 0xdd, + 0x3d, 0x4e, 0x67, 0x0f, 0xbf, 0x44, 0x50, 0x4a, 0x5e, 0x52, 0x7c, 0xae, 0x5a, 0x1c, 0xb1, 0x75, + 0x39, 0x67, 0x95, 0x81, 0xba, 0xa2, 0xa0, 0xa6, 0xf1, 0x54, 0x2e, 0x14, 0x7e, 0x87, 0x60, 0x28, + 0x1d, 0x25, 0x9e, 0x39, 0x2b, 0x92, 0x75, 0x41, 0xad, 0xd9, 0xdc, 0x75, 0x06, 0x67, 0x51, 0xe1, + 0xdc, 0xc1, 0xb7, 0x33, 0x71, 0x4e, 0x0d, 0x4b, 0xd2, 0x26, 0xba, 0xab, 0x6f, 0xc3, 0x1e, 0x7e, + 0x8b, 0x60, 0xf8, 0xd4, 0xc4, 0xe1, 0x3c, 0xfd, 0x63, 0xd7, 0xea, 0xf9, 0x0b, 0x0d, 0xe9, 0x2d, + 0x45, 0xda, 0xc0, 0xf3, 0xbf, 0x4b, 0x7a, 0xff, 0xf1, 0xe7, 0xc3, 0x0a, 0x3a, 0x38, 0xac, 0xa0, + 0x6f, 0x87, 0x15, 0xf4, 0xfa, 0xa8, 0xd2, 0x75, 0x70, 0x54, 0xe9, 0xfa, 0x7a, 0x54, 0xe9, 0x7a, + 0xd6, 0x68, 0xf9, 0xb2, 0xdd, 0x71, 0x89, 0xc7, 0x37, 0xa8, 0xf9, 0x9d, 0xd5, 0x8f, 0x39, 0xd1, + 0x7c, 0x4e, 0x5f, 0x28, 0xa5, 0xf9, 0xc6, 0x9c, 0x11, 0x93, 0x3b, 0x21, 0x13, 0x6e, 0x9f, 0xba, + 0x22, 0xd7, 0x7e, 0x06, 0x00, 0x00, 0xff, 0xff, 0x03, 0xb5, 0x39, 0xdd, 0xbd, 0x07, 0x00, 0x00, +} + +// Reference imports to suppress errors if they are not otherwise used. +var _ context.Context +var _ grpc.ClientConn + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the grpc package it is being compiled against. +const _ = grpc.SupportPackageIsVersion4 + +// QueryClient is the client API for Query service. +// +// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. +type QueryClient interface { + // ClientState queries an IBC light client. + ClientState(ctx context.Context, in *QueryClientStateRequest, opts ...grpc.CallOption) (*QueryClientStateResponse, error) + // ClientStates queries all the IBC light clients of a chain. + ClientStates(ctx context.Context, in *QueryClientStatesRequest, opts ...grpc.CallOption) (*QueryClientStatesResponse, error) + // ConsensusState queries a consensus state associated with a client state at a given height. + ConsensusState(ctx context.Context, in *QueryConsensusStateRequest, opts ...grpc.CallOption) (*QueryConsensusStateResponse, error) + // ConsensusStates queries all the consensus state associated with a given client. + ConsensusStates(ctx context.Context, in *QueryConsensusStatesRequest, opts ...grpc.CallOption) (*QueryConsensusStatesResponse, error) +} + +type queryClient struct { + cc grpc1.ClientConn +} + +func NewQueryClient(cc grpc1.ClientConn) QueryClient { + return &queryClient{cc} +} + +func (c *queryClient) ClientState(ctx context.Context, in *QueryClientStateRequest, opts ...grpc.CallOption) (*QueryClientStateResponse, error) { + out := new(QueryClientStateResponse) + err := c.cc.Invoke(ctx, "/ibc.client.Query/ClientState", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ClientStates(ctx context.Context, in *QueryClientStatesRequest, opts ...grpc.CallOption) (*QueryClientStatesResponse, error) { + out := new(QueryClientStatesResponse) + err := c.cc.Invoke(ctx, "/ibc.client.Query/ClientStates", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ConsensusState(ctx context.Context, in *QueryConsensusStateRequest, opts ...grpc.CallOption) (*QueryConsensusStateResponse, error) { + out := new(QueryConsensusStateResponse) + err := c.cc.Invoke(ctx, "/ibc.client.Query/ConsensusState", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *queryClient) ConsensusStates(ctx context.Context, in *QueryConsensusStatesRequest, opts ...grpc.CallOption) (*QueryConsensusStatesResponse, error) { + out := new(QueryConsensusStatesResponse) + err := c.cc.Invoke(ctx, "/ibc.client.Query/ConsensusStates", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +// QueryServer is the server API for Query service. +type QueryServer interface { + // ClientState queries an IBC light client. + ClientState(context.Context, *QueryClientStateRequest) (*QueryClientStateResponse, error) + // ClientStates queries all the IBC light clients of a chain. + ClientStates(context.Context, *QueryClientStatesRequest) (*QueryClientStatesResponse, error) + // ConsensusState queries a consensus state associated with a client state at a given height. + ConsensusState(context.Context, *QueryConsensusStateRequest) (*QueryConsensusStateResponse, error) + // ConsensusStates queries all the consensus state associated with a given client. + ConsensusStates(context.Context, *QueryConsensusStatesRequest) (*QueryConsensusStatesResponse, error) +} + +// UnimplementedQueryServer can be embedded to have forward compatible implementations. +type UnimplementedQueryServer struct { +} + +func (*UnimplementedQueryServer) ClientState(ctx context.Context, req *QueryClientStateRequest) (*QueryClientStateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ClientState not implemented") +} +func (*UnimplementedQueryServer) ClientStates(ctx context.Context, req *QueryClientStatesRequest) (*QueryClientStatesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ClientStates not implemented") +} +func (*UnimplementedQueryServer) ConsensusState(ctx context.Context, req *QueryConsensusStateRequest) (*QueryConsensusStateResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ConsensusState not implemented") +} +func (*UnimplementedQueryServer) ConsensusStates(ctx context.Context, req *QueryConsensusStatesRequest) (*QueryConsensusStatesResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ConsensusStates not implemented") +} + +func RegisterQueryServer(s grpc1.Server, srv QueryServer) { + s.RegisterService(&_Query_serviceDesc, srv) +} + +func _Query_ClientState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryClientStateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ClientState(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ibc.client.Query/ClientState", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ClientState(ctx, req.(*QueryClientStateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ClientStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryClientStatesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ClientStates(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ibc.client.Query/ClientStates", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ClientStates(ctx, req.(*QueryClientStatesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ConsensusState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryConsensusStateRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ConsensusState(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ibc.client.Query/ConsensusState", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ConsensusState(ctx, req.(*QueryConsensusStateRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Query_ConsensusStates_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(QueryConsensusStatesRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(QueryServer).ConsensusStates(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/ibc.client.Query/ConsensusStates", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(QueryServer).ConsensusStates(ctx, req.(*QueryConsensusStatesRequest)) + } + return interceptor(ctx, in, info, handler) +} + +var _Query_serviceDesc = grpc.ServiceDesc{ + ServiceName: "ibc.client.Query", + HandlerType: (*QueryServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ClientState", + Handler: _Query_ClientState_Handler, + }, + { + MethodName: "ClientStates", + Handler: _Query_ClientStates_Handler, + }, + { + MethodName: "ConsensusState", + Handler: _Query_ConsensusState_Handler, + }, + { + MethodName: "ConsensusStates", + Handler: _Query_ConsensusStates_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "ibc/client/query.proto", +} + +func (m *QueryClientStateRequest) 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 *QueryClientStateRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryClientStateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.ClientId) > 0 { + i -= len(m.ClientId) + copy(dAtA[i:], m.ClientId) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ClientId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryClientStateResponse) 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 *QueryClientStateResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryClientStateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ProofHeight != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.ProofHeight)) + i-- + dAtA[i] = 0x20 + } + if len(m.ProofPath) > 0 { + i -= len(m.ProofPath) + copy(dAtA[i:], m.ProofPath) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath))) + i-- + dAtA[i] = 0x1a + } + if len(m.Proof) > 0 { + i -= len(m.Proof) + copy(dAtA[i:], m.Proof) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Proof))) + i-- + dAtA[i] = 0x12 + } + if m.ClientState != nil { + { + size, err := m.ClientState.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 (m *QueryClientStatesRequest) 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 *QueryClientStatesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryClientStatesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.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 (m *QueryClientStatesResponse) 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 *QueryClientStatesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryClientStatesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ClientStates) > 0 { + for iNdEx := len(m.ClientStates) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ClientStates[iNdEx].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 (m *QueryConsensusStateRequest) 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 *QueryConsensusStateRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryConsensusStateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.LatestHeight { + i-- + if m.LatestHeight { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x18 + } + if m.Height != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.Height)) + i-- + dAtA[i] = 0x10 + } + if len(m.ClientId) > 0 { + i -= len(m.ClientId) + copy(dAtA[i:], m.ClientId) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ClientId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryConsensusStateResponse) 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 *QueryConsensusStateResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryConsensusStateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.ProofHeight != 0 { + i = encodeVarintQuery(dAtA, i, uint64(m.ProofHeight)) + i-- + dAtA[i] = 0x20 + } + if len(m.ProofPath) > 0 { + i -= len(m.ProofPath) + copy(dAtA[i:], m.ProofPath) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ProofPath))) + i-- + dAtA[i] = 0x1a + } + if len(m.Proof) > 0 { + i -= len(m.Proof) + copy(dAtA[i:], m.Proof) + i = encodeVarintQuery(dAtA, i, uint64(len(m.Proof))) + i-- + dAtA[i] = 0x12 + } + if m.ConsensusState != nil { + { + size, err := m.ConsensusState.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 (m *QueryConsensusStatesRequest) 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 *QueryConsensusStatesRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryConsensusStatesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ClientId) > 0 { + i -= len(m.ClientId) + copy(dAtA[i:], m.ClientId) + i = encodeVarintQuery(dAtA, i, uint64(len(m.ClientId))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *QueryConsensusStatesResponse) 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 *QueryConsensusStatesResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *QueryConsensusStatesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Pagination != nil { + { + size, err := m.Pagination.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintQuery(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.ConsensusStates) > 0 { + for iNdEx := len(m.ConsensusStates) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ConsensusStates[iNdEx].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 + for v >= 1<<7 { + dAtA[offset] = uint8(v&0x7f | 0x80) + v >>= 7 + offset++ + } + dAtA[offset] = uint8(v) + return base +} +func (m *QueryClientStateRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ClientId) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryClientStateResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ClientState != nil { + l = m.ClientState.Size() + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.Proof) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.ProofPath) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.ProofHeight != 0 { + n += 1 + sovQuery(uint64(m.ProofHeight)) + } + return n +} + +func (m *QueryClientStatesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryClientStatesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ClientStates) > 0 { + for _, e := range m.ClientStates { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryConsensusStateRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ClientId) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Height != 0 { + n += 1 + sovQuery(uint64(m.Height)) + } + if m.LatestHeight { + n += 2 + } + return n +} + +func (m *QueryConsensusStateResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.ConsensusState != nil { + l = m.ConsensusState.Size() + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.Proof) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + l = len(m.ProofPath) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.ProofHeight != 0 { + n += 1 + sovQuery(uint64(m.ProofHeight)) + } + return n +} + +func (m *QueryConsensusStatesRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.ClientId) + if l > 0 { + n += 1 + l + sovQuery(uint64(l)) + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func (m *QueryConsensusStatesResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if len(m.ConsensusStates) > 0 { + for _, e := range m.ConsensusStates { + l = e.Size() + n += 1 + l + sovQuery(uint64(l)) + } + } + if m.Pagination != nil { + l = m.Pagination.Size() + n += 1 + l + sovQuery(uint64(l)) + } + return n +} + +func sovQuery(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozQuery(x uint64) (n int) { + return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *QueryClientStateRequest) 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: QueryClientStateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryClientStateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryClientStateResponse) 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: QueryClientStateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryClientStateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientState", 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 m.ClientState == nil { + m.ClientState = &types.Any{} + } + if err := m.ClientState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...) + if m.Proof == nil { + m.Proof = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType) + } + m.ProofHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProofHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryClientStatesRequest) 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: QueryClientStatesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryClientStatesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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 m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.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 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryClientStatesResponse) 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: QueryClientStatesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryClientStatesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientStates", 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 + } + m.ClientStates = append(m.ClientStates, &IdentifiedClientState{}) + if err := m.ClientStates[len(m.ClientStates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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 m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.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 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryConsensusStateRequest) 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: QueryConsensusStateRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryConsensusStateRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) + } + m.Height = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Height |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field LatestHeight", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.LatestHeight = bool(v != 0) + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryConsensusStateResponse) 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: QueryConsensusStateResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryConsensusStateResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusState", 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 m.ConsensusState == nil { + m.ConsensusState = &types.Any{} + } + if err := m.ConsensusState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) + } + var byteLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + byteLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if byteLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + byteLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Proof = append(m.Proof[:0], dAtA[iNdEx:postIndex]...) + if m.Proof == nil { + m.Proof = []byte{} + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofPath", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ProofPath = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ProofHeight", wireType) + } + m.ProofHeight = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.ProofHeight |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipQuery(dAtA[iNdEx:]) + if err != nil { + return err + } + if skippy < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryConsensusStatesRequest) 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: QueryConsensusStatesRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryConsensusStatesRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ClientId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowQuery + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthQuery + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthQuery + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ClientId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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 m.Pagination == nil { + m.Pagination = &query.PageRequest{} + } + if err := m.Pagination.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 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) < 0 { + return ErrInvalidLengthQuery + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *QueryConsensusStatesResponse) 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: QueryConsensusStatesResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: QueryConsensusStatesResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ConsensusStates", 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 + } + m.ConsensusStates = append(m.ConsensusStates, &types.Any{}) + if err := m.ConsensusStates[len(m.ConsensusStates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Pagination", 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 m.Pagination == nil { + m.Pagination = &query.PageResponse{} + } + if err := m.Pagination.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 { + return ErrInvalidLengthQuery + } + if (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 + depth := 0 + for iNdEx < l { + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= (uint64(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + wireType := int(wire & 0x7) + switch wireType { + case 0: + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + iNdEx++ + if dAtA[iNdEx-1] < 0x80 { + break + } + } + case 1: + iNdEx += 8 + case 2: + var length int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return 0, ErrIntOverflowQuery + } + if iNdEx >= l { + return 0, io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + length |= (int(b) & 0x7F) << shift + if b < 0x80 { + break + } + } + if length < 0 { + return 0, ErrInvalidLengthQuery + } + iNdEx += length + case 3: + depth++ + case 4: + if depth == 0 { + return 0, ErrUnexpectedEndOfGroupQuery + } + depth-- + case 5: + iNdEx += 4 + default: + return 0, fmt.Errorf("proto: illegal wireType %d", wireType) + } + if iNdEx < 0 { + return 0, ErrInvalidLengthQuery + } + if depth == 0 { + return iNdEx, nil + } + } + return 0, io.ErrUnexpectedEOF +} + +var ( + ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling") + ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow") + ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group") +) diff --git a/x/ibc/02-client/types/query.pb.gw.go b/x/ibc/02-client/types/query.pb.gw.go new file mode 100644 index 000000000..8e39fc807 --- /dev/null +++ b/x/ibc/02-client/types/query.pb.gw.go @@ -0,0 +1,518 @@ +// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. +// source: ibc/client/query.proto + +/* +Package types is a reverse proxy. + +It translates gRPC into RESTful JSON APIs. +*/ +package types + +import ( + "context" + "io" + "net/http" + + "github.com/golang/protobuf/descriptor" + "github.com/golang/protobuf/proto" + "github.com/grpc-ecosystem/grpc-gateway/runtime" + "github.com/grpc-ecosystem/grpc-gateway/utilities" + "google.golang.org/grpc" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/grpclog" + "google.golang.org/grpc/status" +) + +// Suppress "imported and not used" errors +var _ codes.Code +var _ io.Reader +var _ status.Status +var _ = runtime.String +var _ = utilities.NewDoubleArray +var _ = descriptor.ForMessage + +func request_Query_ClientState_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryClientStateRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["client_id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "client_id") + } + + protoReq.ClientId, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "client_id", err) + } + + msg, err := client.ClientState(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_ClientState_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryClientStateRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["client_id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "client_id") + } + + protoReq.ClientId, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "client_id", err) + } + + msg, err := server.ClientState(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_Query_ClientStates_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} +) + +func request_Query_ClientStates_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryClientStatesRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ClientStates_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.ClientStates(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_ClientStates_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryClientStatesRequest + var metadata runtime.ServerMetadata + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ClientStates_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.ClientStates(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_Query_ConsensusState_0 = &utilities.DoubleArray{Encoding: map[string]int{"client_id": 0, "height": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}} +) + +func request_Query_ConsensusState_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryConsensusStateRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["client_id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "client_id") + } + + protoReq.ClientId, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "client_id", err) + } + + val, ok = pathParams["height"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "height") + } + + protoReq.Height, err = runtime.Uint64(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "height", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ConsensusState_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.ConsensusState(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_ConsensusState_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryConsensusStateRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["client_id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "client_id") + } + + protoReq.ClientId, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "client_id", err) + } + + val, ok = pathParams["height"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "height") + } + + protoReq.Height, err = runtime.Uint64(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "height", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ConsensusState_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.ConsensusState(ctx, &protoReq) + return msg, metadata, err + +} + +var ( + filter_Query_ConsensusStates_0 = &utilities.DoubleArray{Encoding: map[string]int{"client_id": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}} +) + +func request_Query_ConsensusStates_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryConsensusStatesRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["client_id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "client_id") + } + + protoReq.ClientId, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "client_id", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ConsensusStates_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := client.ConsensusStates(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD)) + return msg, metadata, err + +} + +func local_request_Query_ConsensusStates_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) { + var protoReq QueryConsensusStatesRequest + var metadata runtime.ServerMetadata + + var ( + val string + ok bool + err error + _ = err + ) + + val, ok = pathParams["client_id"] + if !ok { + return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "client_id") + } + + protoReq.ClientId, err = runtime.String(val) + + if err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "client_id", err) + } + + if err := req.ParseForm(); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_ConsensusStates_0); err != nil { + return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) + } + + msg, err := server.ConsensusStates(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. +// Note that using this registration option will cause many gRPC library features (such as grpc.SendHeader, etc) to stop working. Consider using RegisterQueryHandlerFromEndpoint instead. +func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error { + + mux.Handle("GET", pattern_Query_ClientState_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.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_ClientState_0(rctx, inboundMarshaler, server, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_ClientState_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_ClientStates_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.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_ClientStates_0(rctx, inboundMarshaler, server, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_ClientStates_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_ConsensusState_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.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_ConsensusState_0(rctx, inboundMarshaler, server, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_ConsensusState_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_ConsensusStates_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.AnnotateIncomingContext(ctx, mux, req) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + resp, md, err := local_request_Query_ConsensusStates_0(rctx, inboundMarshaler, server, req, pathParams) + ctx = runtime.NewServerMetadataContext(ctx, md) + if err != nil { + runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) + return + } + + forward_Query_ConsensusStates_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but +// automatically dials to "endpoint" and closes the connection when "ctx" gets done. +func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { + conn, err := grpc.Dial(endpoint, opts...) + if err != nil { + return err + } + defer func() { + if err != nil { + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + return + } + go func() { + <-ctx.Done() + if cerr := conn.Close(); cerr != nil { + grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) + } + }() + }() + + return RegisterQueryHandler(ctx, mux, conn) +} + +// RegisterQueryHandler registers the http handlers for service Query to "mux". +// The handlers forward requests to the grpc endpoint over "conn". +func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { + return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn)) +} + +// RegisterQueryHandlerClient registers the http handlers for service Query +// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". +// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" +// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in +// "QueryClient" to call the correct interceptors. +func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error { + + mux.Handle("GET", pattern_Query_ClientState_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_ClientState_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_ClientState_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_ClientStates_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_ClientStates_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_ClientStates_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_ConsensusState_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_ConsensusState_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_ConsensusState_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + mux.Handle("GET", pattern_Query_ConsensusStates_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_ConsensusStates_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_ConsensusStates_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...) + + }) + + return nil +} + +var ( + pattern_Query_ClientState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"ibc", "client", "v1beta1", "client_states", "client_id"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_ClientStates_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"ibc", "client", "v1beta1", "client_states"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_ConsensusState_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"ibc", "client", "v1beta1", "consensus_states", "client_id", "height"}, "", runtime.AssumeColonVerbOpt(true))) + + pattern_Query_ConsensusStates_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"ibc", "client", "v1beta1", "consensus_states", "client_id"}, "", runtime.AssumeColonVerbOpt(true))) +) + +var ( + forward_Query_ClientState_0 = runtime.ForwardResponseMessage + + forward_Query_ClientStates_0 = runtime.ForwardResponseMessage + + forward_Query_ConsensusState_0 = runtime.ForwardResponseMessage + + forward_Query_ConsensusStates_0 = runtime.ForwardResponseMessage +) diff --git a/x/ibc/03-connection/client/utils/utils.go b/x/ibc/03-connection/client/utils/utils.go index acef9933f..9ae378840 100644 --- a/x/ibc/03-connection/client/utils/utils.go +++ b/x/ibc/03-connection/client/utils/utils.go @@ -122,14 +122,18 @@ func QueryConnectionClientState( } if prove { - clientState, proof, proofHeight, err := clientutils.QueryClientStateABCI(clientCtx, res.IdentifiedClientState.Id) + clientStateRes, err := clientutils.QueryClientStateABCI(clientCtx, res.IdentifiedClientState.ClientId) if err != nil { return nil, err } // use client state returned from ABCI query in case query height differs - identifiedClientState := clienttypes.NewIdentifiedClientState(res.IdentifiedClientState.Id, clientState) - res = types.NewQueryConnectionClientStateResponse(identifiedClientState, proof, int64(proofHeight)) + identifiedClientState := clienttypes.IdentifiedClientState{ + ClientId: res.IdentifiedClientState.ClientId, + ClientState: clientStateRes.ClientState, + } + + res = types.NewQueryConnectionClientStateResponse(identifiedClientState, clientStateRes.Proof, int64(clientStateRes.ProofHeight)) } return res, nil @@ -159,18 +163,12 @@ func QueryConnectionConsensusState( } if prove { - consensusState, proof, proofHeight, err := clientutils.QueryConsensusStateABCI(clientCtx, res.ClientId, consensusState.GetHeight()) + consensusStateRes, err := clientutils.QueryConsensusStateABCI(clientCtx, res.ClientId, consensusState.GetHeight()) if err != nil { return nil, err } - // use consensus state returned from ABCI query in case query height differs - anyConsensusState, err := clienttypes.PackConsensusState(consensusState) - if err != nil { - return nil, err - } - - res = types.NewQueryConnectionConsensusStateResponse(res.ClientId, anyConsensusState, consensusState.GetHeight(), proof, int64(proofHeight)) + res = types.NewQueryConnectionConsensusStateResponse(res.ClientId, consensusStateRes.ConsensusState, consensusState.GetHeight(), consensusStateRes.Proof, int64(consensusStateRes.ProofHeight)) } return res, nil diff --git a/x/ibc/03-connection/types/query.go b/x/ibc/03-connection/types/query.go index ce58eee6b..27e7e122a 100644 --- a/x/ibc/03-connection/types/query.go +++ b/x/ibc/03-connection/types/query.go @@ -44,7 +44,7 @@ func NewQueryClientConnectionsRequest(clientID string) *QueryClientConnectionsRe // NewQueryConnectionClientStateResponse creates a newQueryConnectionClientStateResponse instance func NewQueryConnectionClientStateResponse(identifiedClientState clienttypes.IdentifiedClientState, proof []byte, height int64) *QueryConnectionClientStateResponse { - path := commitmenttypes.NewMerklePath(strings.Split(host.FullClientPath(identifiedClientState.Id, host.ClientStatePath()), "/")) + path := commitmenttypes.NewMerklePath(strings.Split(host.FullClientPath(identifiedClientState.ClientId, host.ClientStatePath()), "/")) return &QueryConnectionClientStateResponse{ IdentifiedClientState: &identifiedClientState, Proof: proof, diff --git a/x/ibc/04-channel/client/utils/utils.go b/x/ibc/04-channel/client/utils/utils.go index cee76083e..17a1f74b9 100644 --- a/x/ibc/04-channel/client/utils/utils.go +++ b/x/ibc/04-channel/client/utils/utils.go @@ -122,14 +122,17 @@ func QueryChannelClientState( } if prove { - clientState, proof, proofHeight, err := clientutils.QueryClientStateABCI(clientCtx, res.IdentifiedClientState.Id) + clientStateRes, err := clientutils.QueryClientStateABCI(clientCtx, res.IdentifiedClientState.ClientId) if err != nil { return nil, err } // use client state returned from ABCI query in case query height differs - identifiedClientState := clienttypes.NewIdentifiedClientState(res.IdentifiedClientState.Id, clientState) - res = types.NewQueryChannelClientStateResponse(identifiedClientState, proof, int64(proofHeight)) + identifiedClientState := clienttypes.IdentifiedClientState{ + ClientId: res.IdentifiedClientState.ClientId, + ClientState: clientStateRes.ClientState, + } + res = types.NewQueryChannelClientStateResponse(identifiedClientState, clientStateRes.Proof, int64(clientStateRes.ProofHeight)) } return res, nil @@ -160,18 +163,12 @@ func QueryChannelConsensusState( } if prove { - consensusState, proof, proofHeight, err := clientutils.QueryConsensusStateABCI(clientCtx, res.ClientId, consensusState.GetHeight()) + consensusStateRes, err := clientutils.QueryConsensusStateABCI(clientCtx, res.ClientId, consensusState.GetHeight()) if err != nil { return nil, err } - // use consensus state returned from ABCI query in case query height differs - anyConsensusState, err := clienttypes.PackConsensusState(consensusState) - if err != nil { - return nil, err - } - - res = types.NewQueryChannelConsensusStateResponse(res.ClientId, anyConsensusState, consensusState.GetHeight(), proof, int64(proofHeight)) + res = types.NewQueryChannelConsensusStateResponse(res.ClientId, consensusStateRes.ConsensusState, consensusState.GetHeight(), consensusStateRes.Proof, int64(consensusStateRes.ProofHeight)) } return res, nil diff --git a/x/ibc/04-channel/types/query.go b/x/ibc/04-channel/types/query.go index 11c7f67e0..a4979dd2e 100644 --- a/x/ibc/04-channel/types/query.go +++ b/x/ibc/04-channel/types/query.go @@ -22,7 +22,7 @@ func NewQueryChannelResponse(portID, channelID string, channel Channel, proof [] // NewQueryChannelClientStateResponse creates a newQueryChannelClientStateResponse instance func NewQueryChannelClientStateResponse(identifiedClientState clienttypes.IdentifiedClientState, proof []byte, height int64) *QueryChannelClientStateResponse { - path := commitmenttypes.NewMerklePath(strings.Split(host.FullClientPath(identifiedClientState.Id, host.ClientStatePath()), "/")) + path := commitmenttypes.NewMerklePath(strings.Split(host.FullClientPath(identifiedClientState.ClientId, host.ClientStatePath()), "/")) return &QueryChannelClientStateResponse{ IdentifiedClientState: &identifiedClientState, Proof: proof, diff --git a/x/ibc/24-host/parse.go b/x/ibc/24-host/parse.go index ef1c0707f..31500c346 100644 --- a/x/ibc/24-host/parse.go +++ b/x/ibc/24-host/parse.go @@ -17,7 +17,7 @@ func RemovePath(paths []string, path string) ([]string, bool) { } // ParseConnectionPath returns the connection ID from a full path. It returns -// an error if the provided path is invalid, +// an error if the provided path is invalid. func ParseConnectionPath(path string) (string, error) { split := strings.Split(path, "/") if len(split) != 2 { @@ -28,7 +28,7 @@ func ParseConnectionPath(path string) (string, error) { } // ParseChannelPath returns the port and channel ID from a full path. It returns -// an error if the provided path is invalid, +// an error if the provided path is invalid. func ParseChannelPath(path string) (string, string, error) { split := strings.Split(path, "/") if len(split) < 5 { @@ -43,7 +43,7 @@ func ParseChannelPath(path string) (string, string, error) { } // MustParseConnectionPath returns the connection ID from a full path. Panics -// if the provided path is invalid +// if the provided path is invalid. func MustParseConnectionPath(path string) string { connectionID, err := ParseConnectionPath(path) if err != nil { @@ -53,7 +53,7 @@ func MustParseConnectionPath(path string) string { } // MustParseChannelPath returns the port and channel ID from a full path. Panics -// if the provided path is invalid +// if the provided path is invalid. func MustParseChannelPath(path string) (string, string) { portID, channelID, err := ParseChannelPath(path) if err != nil { diff --git a/x/ibc/genesis_test.go b/x/ibc/genesis_test.go index 9fcf26e03..0ce923237 100644 --- a/x/ibc/genesis_test.go +++ b/x/ibc/genesis_test.go @@ -35,11 +35,11 @@ func (suite *IBCTestSuite) TestValidateGenesis() { name: "valid genesis", genState: &types.GenesisState{ ClientGenesis: clienttypes.NewGenesisState( - []clienttypes.GenesisClientState{ - clienttypes.NewGenesisClientState( + []clienttypes.IdentifiedClientState{ + clienttypes.NewIdentifiedClientState( clientID, ibctmtypes.NewClientState(chainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, height, commitmenttypes.GetSDKSpecs()), ), - clienttypes.NewGenesisClientState( + clienttypes.NewIdentifiedClientState( clientexported.ClientTypeLocalHost, localhosttypes.NewClientState("chaindID", 10), ), }, @@ -95,11 +95,11 @@ func (suite *IBCTestSuite) TestValidateGenesis() { name: "invalid client genesis", genState: &types.GenesisState{ ClientGenesis: clienttypes.NewGenesisState( - []clienttypes.GenesisClientState{ - clienttypes.NewGenesisClientState( + []clienttypes.IdentifiedClientState{ + clienttypes.NewIdentifiedClientState( clientID, ibctmtypes.NewClientState(chainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, height, commitmenttypes.GetSDKSpecs()), ), - clienttypes.NewGenesisClientState( + clienttypes.NewIdentifiedClientState( clientexported.ClientTypeLocalHost, localhosttypes.NewClientState("(chaindID)", 0), ), }, @@ -164,11 +164,11 @@ func (suite *IBCTestSuite) TestInitGenesis() { name: "valid genesis", genState: &types.GenesisState{ ClientGenesis: clienttypes.NewGenesisState( - []clienttypes.GenesisClientState{ - clienttypes.NewGenesisClientState( + []clienttypes.IdentifiedClientState{ + clienttypes.NewIdentifiedClientState( clientID, ibctmtypes.NewClientState(chainID, ibctmtypes.DefaultTrustLevel, trustingPeriod, ubdPeriod, maxClockDrift, height, commitmenttypes.GetSDKSpecs()), ), - clienttypes.NewGenesisClientState( + clienttypes.NewIdentifiedClientState( clientexported.ClientTypeLocalHost, localhosttypes.NewClientState("chaindID", 10), ), }, diff --git a/x/ibc/keeper/grpc_query.go b/x/ibc/keeper/grpc_query.go index 8241091de..870e58994 100644 --- a/x/ibc/keeper/grpc_query.go +++ b/x/ibc/keeper/grpc_query.go @@ -3,10 +3,31 @@ package keeper import ( "context" + clienttypes "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types" connectiontypes "github.com/cosmos/cosmos-sdk/x/ibc/03-connection/types" channeltypes "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types" ) +// ClientState implements the IBC QueryServer interface +func (q Keeper) ClientState(c context.Context, req *clienttypes.QueryClientStateRequest) (*clienttypes.QueryClientStateResponse, error) { + return q.ClientKeeper.ClientState(c, req) +} + +// ClientStates implements the IBC QueryServer interface +func (q Keeper) ClientStates(c context.Context, req *clienttypes.QueryClientStatesRequest) (*clienttypes.QueryClientStatesResponse, error) { + return q.ClientKeeper.ClientStates(c, req) +} + +// ConsensusState implements the IBC QueryServer interface +func (q Keeper) ConsensusState(c context.Context, req *clienttypes.QueryConsensusStateRequest) (*clienttypes.QueryConsensusStateResponse, error) { + return q.ClientKeeper.ConsensusState(c, req) +} + +// ConsensusStates implements the IBC QueryServer interface +func (q Keeper) ConsensusStates(c context.Context, req *clienttypes.QueryConsensusStatesRequest) (*clienttypes.QueryConsensusStatesResponse, error) { + return q.ClientKeeper.ConsensusStates(c, req) +} + // Connection implements the IBC QueryServer interface func (q Keeper) Connection(c context.Context, req *connectiontypes.QueryConnectionRequest) (*connectiontypes.QueryConnectionResponse, error) { return q.ConnectionKeeper.Connection(c, req) diff --git a/x/ibc/keeper/keeper_test.go b/x/ibc/keeper/keeper_test.go index e993ee1be..c35a1e3dc 100644 --- a/x/ibc/keeper/keeper_test.go +++ b/x/ibc/keeper/keeper_test.go @@ -15,21 +15,18 @@ import ( type KeeperTestSuite struct { suite.Suite - cdc *codec.LegacyAmino - ctx sdk.Context - keeper *keeper.Keeper - querier sdk.Querier + cdc *codec.LegacyAmino + ctx sdk.Context + keeper *keeper.Keeper } func (suite *KeeperTestSuite) SetupTest() { isCheckTx := false app := simapp.Setup(isCheckTx) - legacyQuerierCdc := codec.NewAminoCodec(app.LegacyAmino()) suite.cdc = app.LegacyAmino() suite.ctx = app.BaseApp.NewContext(isCheckTx, tmproto.Header{}) suite.keeper = app.IBCKeeper - suite.querier = keeper.NewQuerier(*app.IBCKeeper, legacyQuerierCdc) } func TestKeeperTestSuite(t *testing.T) { diff --git a/x/ibc/keeper/querier.go b/x/ibc/keeper/querier.go deleted file mode 100644 index 0c0965cbc..000000000 --- a/x/ibc/keeper/querier.go +++ /dev/null @@ -1,42 +0,0 @@ -package keeper - -import ( - abci "github.com/tendermint/tendermint/abci/types" - - "github.com/cosmos/cosmos-sdk/codec" - - sdk "github.com/cosmos/cosmos-sdk/types" - sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" - clientkeeper "github.com/cosmos/cosmos-sdk/x/ibc/02-client/keeper" - clienttypes "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types" - connectiontypes "github.com/cosmos/cosmos-sdk/x/ibc/03-connection/types" - channeltypes "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types" -) - -// NewQuerier creates a querier for the IBC module -func NewQuerier(k Keeper, legacyQuerierCdc codec.JSONMarshaler) sdk.Querier { - return func(ctx sdk.Context, path []string, req abci.RequestQuery) ([]byte, error) { - var ( - res []byte - err error - ) - - switch path[0] { - case clienttypes.SubModuleName: - switch path[1] { - case clienttypes.QueryAllClients: - res, err = clientkeeper.QuerierClients(ctx, req, k.ClientKeeper, legacyQuerierCdc) - default: - err = sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unknown IBC %s query endpoint", clienttypes.SubModuleName) - } - case connectiontypes.SubModuleName: - err = sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unknown IBC %s query endpoint", connectiontypes.SubModuleName) - case channeltypes.SubModuleName: - err = sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unknown IBC %s query endpoint", channeltypes.SubModuleName) - default: - err = sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "unknown IBC query endpoint") - } - - return res, err - } -} diff --git a/x/ibc/keeper/querier_test.go b/x/ibc/keeper/querier_test.go deleted file mode 100644 index c0050f58b..000000000 --- a/x/ibc/keeper/querier_test.go +++ /dev/null @@ -1,71 +0,0 @@ -package keeper_test - -import ( - "fmt" - - "github.com/stretchr/testify/require" - - clienttypes "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types" - connectiontypes "github.com/cosmos/cosmos-sdk/x/ibc/03-connection/types" - channeltypes "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types" - - abci "github.com/tendermint/tendermint/abci/types" -) - -// TestNewQuerier tests that the querier paths are correct. -// NOTE: the actuall testing functionality are located on each ICS querier test. -func (suite *KeeperTestSuite) TestNewQuerier() { - query := abci.RequestQuery{ - Path: "", - Data: []byte{}, - } - - cases := []struct { - name string - path []string - expectsDefaultErr bool - errMsg string - }{ - {"client - QuerierClients", - []string{clienttypes.SubModuleName, clienttypes.QueryAllClients}, - false, - "", - }, - { - "client - invalid query", - []string{clienttypes.SubModuleName, "foo"}, - true, - fmt.Sprintf("unknown IBC %s query endpoint", clienttypes.SubModuleName), - }, - { - "connection - invalid query", - []string{connectiontypes.SubModuleName, "foo"}, - true, - fmt.Sprintf("unknown IBC %s query endpoint", connectiontypes.SubModuleName), - }, - { - "channel - invalid query", - []string{channeltypes.SubModuleName, "foo"}, - true, - fmt.Sprintf("unknown IBC %s query endpoint", channeltypes.SubModuleName), - }, - { - "invalid query", - []string{"foo"}, - true, - "unknown IBC query endpoint", - }, - } - - for i, tc := range cases { - i, tc := i, tc - suite.Run(tc.name, func() { - _, err := suite.querier(suite.ctx, tc.path, query) - if tc.expectsDefaultErr { - require.Contains(suite.T(), err.Error(), tc.errMsg, "test case #%d", i) - } else { - suite.Error(err, "test case #%d", i) - } - }) - } -} diff --git a/x/ibc/module.go b/x/ibc/module.go index ef9cf507d..8c68a0b0d 100644 --- a/x/ibc/module.go +++ b/x/ibc/module.go @@ -117,9 +117,9 @@ func (AppModule) QuerierRoute() string { return host.QuerierRoute } -// LegacyQuerierHandler returns the ibc module sdk.Querier. +// LegacyQuerierHandler returns nil. IBC does not support the legacy querier. func (am AppModule) LegacyQuerierHandler(legacyQuerierCdc codec.JSONMarshaler) sdk.Querier { - return keeper.NewQuerier(*am.keeper, legacyQuerierCdc) + return nil } // RegisterQueryService registers the gRPC query service for the ibc module. diff --git a/x/ibc/types/query.go b/x/ibc/types/query.go index 07db85b70..d02d36500 100644 --- a/x/ibc/types/query.go +++ b/x/ibc/types/query.go @@ -3,6 +3,8 @@ package types import ( "github.com/gogo/protobuf/grpc" + client "github.com/cosmos/cosmos-sdk/x/ibc/02-client" + clienttypes "github.com/cosmos/cosmos-sdk/x/ibc/02-client/types" connection "github.com/cosmos/cosmos-sdk/x/ibc/03-connection" connectiontypes "github.com/cosmos/cosmos-sdk/x/ibc/03-connection/types" channel "github.com/cosmos/cosmos-sdk/x/ibc/04-channel" @@ -11,12 +13,14 @@ import ( // QueryServer defines the IBC interfaces that the gRPC query server must implement type QueryServer interface { + clienttypes.QueryServer connectiontypes.QueryServer channeltypes.QueryServer } // RegisterQueryService registers each individual IBC submodule query service func RegisterQueryService(server grpc.Server, queryService QueryServer) { + client.RegisterQueryService(server, queryService) connection.RegisterQueryService(server, queryService) channel.RegisterQueryService(server, queryService) }